generic-library/cxx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

libcxx initial import

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@103490 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Howard Hinnant
2010-05-11 19:42:16 +00:00
commit bc8d3f97eb
3893 changed files with 1209942 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
test/input.output/file.streams/fstreams/filebuf.assign/member_swap.pass.cpp Normal file
View File

@@ -0,0 +1,52 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_filebuf
// void swap(basic_filebuf& rhs);
#include <fstream>
#include <cassert>
int main()
{
{
std::filebuf f;
assert(f.open("test.dat", std::ios_base::out | std::ios_base::in
| std::ios_base::trunc) != 0);
assert(f.is_open());
assert(f.sputn("123", 3) == 3);
f.pubseekoff(1, std::ios_base::beg);
assert(f.sgetc() == '2');
std::filebuf f2;
f2.swap(f);
assert(!f.is_open());
assert(f2.is_open());
assert(f2.sgetc() == '2');
}
remove("test.dat");
{
std::wfilebuf f;
assert(f.open("test.dat", std::ios_base::out | std::ios_base::in
| std::ios_base::trunc) != 0);
assert(f.is_open());
assert(f.sputn(L"123", 3) == 3);
f.pubseekoff(1, std::ios_base::beg);
assert(f.sgetc() == L'2');
std::wfilebuf f2;
f2.swap(f);
assert(!f.is_open());
assert(f2.is_open());
assert(f2.sgetc() == L'2');
}
remove("test.dat");
}

54
test/input.output/file.streams/fstreams/filebuf.assign/move_assign.pass.cpp Normal file
View File

@@ -0,0 +1,54 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_filebuf
// basic_filebuf& operator=(basic_filebuf&& rhs);
#include <fstream>
#include <cassert>
int main()
{
#ifdef _LIBCPP_MOVE
{
std::filebuf f;
assert(f.open("test.dat", std::ios_base::out | std::ios_base::in
| std::ios_base::trunc) != 0);
assert(f.is_open());
assert(f.sputn("123", 3) == 3);
f.pubseekoff(1, std::ios_base::beg);
assert(f.sgetc() == '2');
std::filebuf f2;
f2 = move(f);
assert(!f.is_open());
assert(f2.is_open());
assert(f2.sgetc() == '2');
}
remove("test.dat");
{
std::wfilebuf f;
assert(f.open("test.dat", std::ios_base::out | std::ios_base::in
| std::ios_base::trunc) != 0);
assert(f.is_open());
assert(f.sputn(L"123", 3) == 3);
f.pubseekoff(1, std::ios_base::beg);
assert(f.sgetc() == L'2');
std::wfilebuf f2;
f2 = move(f);
assert(!f.is_open());
assert(f2.is_open());
assert(f2.sgetc() == L'2');
}
remove("test.dat");
#endif
}

54
test/input.output/file.streams/fstreams/filebuf.assign/nonmember_swap.pass.cpp Normal file
View File

@@ -0,0 +1,54 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_filebuf
// template <class charT, class traits>
// void
// swap(basic_filebuf<charT, traits>& x, basic_filebuf<charT, traits>& y);
#include <fstream>
#include <cassert>
int main()
{
{
std::filebuf f;
assert(f.open("test.dat", std::ios_base::out | std::ios_base::in
| std::ios_base::trunc) != 0);
assert(f.is_open());
assert(f.sputn("123", 3) == 3);
f.pubseekoff(1, std::ios_base::beg);
assert(f.sgetc() == '2');
std::filebuf f2;
swap(f2, f);
assert(!f.is_open());
assert(f2.is_open());
assert(f2.sgetc() == '2');
}
remove("test.dat");
{
std::wfilebuf f;
assert(f.open("test.dat", std::ios_base::out | std::ios_base::in
| std::ios_base::trunc) != 0);
assert(f.is_open());
assert(f.sputn(L"123", 3) == 3);
f.pubseekoff(1, std::ios_base::beg);
assert(f.sgetc() == L'2');
std::wfilebuf f2;
swap(f2, f);
assert(!f.is_open());
assert(f2.is_open());
assert(f2.sgetc() == L'2');
}
remove("test.dat");
}

30
test/input.output/file.streams/fstreams/filebuf.cons/default.pass.cpp Normal file
View File

@@ -0,0 +1,30 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_filebuf
// basic_filebuf();
#include <fstream>
#include <cassert>
int main()
{
{
std::filebuf f;
assert(!f.is_open());
}
{
std::wfilebuf f;
assert(!f.is_open());
}
}

52
test/input.output/file.streams/fstreams/filebuf.cons/move.pass.cpp Normal file
View File

@@ -0,0 +1,52 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_filebuf
// basic_filebuf(basic_filebuf&& rhs);
#include <fstream>
#include <cassert>
int main()
{
#ifdef _LIBCPP_MOVE
{
std::filebuf f;
assert(f.open("test.dat", std::ios_base::out | std::ios_base::in
| std::ios_base::trunc) != 0);
assert(f.is_open());
assert(f.sputn("123", 3) == 3);
f.pubseekoff(1, std::ios_base::beg);
assert(f.sgetc() == '2');
std::filebuf f2(move(f));
assert(!f.is_open());
assert(f2.is_open());
assert(f2.sgetc() == '2');
}
remove("test.dat");
{
std::wfilebuf f;
assert(f.open("test.dat", std::ios_base::out | std::ios_base::in
| std::ios_base::trunc) != 0);
assert(f.is_open());
assert(f.sputn(L"123", 3) == 3);
f.pubseekoff(1, std::ios_base::beg);
assert(f.sgetc() == L'2');
std::wfilebuf f2(move(f));
assert(!f.is_open());
assert(f2.is_open());
assert(f2.sgetc() == L'2');
}
remove("test.dat");
#endif
}

49
test/input.output/file.streams/fstreams/filebuf.members/open_pointer.pass.cpp Normal file
View File

@@ -0,0 +1,49 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// basic_filebuf<charT,traits>* open(const char* s, ios_base::openmode mode);
#include <fstream>
#include <cassert>
int main()
{
{
std::filebuf f;
assert(f.open("test.dat", std::ios_base::out) != 0);
assert(f.is_open());
assert(f.sputn("123", 3) == 3);
}
{
std::filebuf f;
assert(f.open("test.dat", std::ios_base::in) != 0);
assert(f.is_open());
assert(f.sbumpc() == '1');
assert(f.sbumpc() == '2');
assert(f.sbumpc() == '3');
}
remove("test.dat");
{
std::wfilebuf f;
assert(f.open("test.dat", std::ios_base::out) != 0);
assert(f.is_open());
assert(f.sputn(L"123", 3) == 3);
}
{
std::wfilebuf f;
assert(f.open("test.dat", std::ios_base::in) != 0);
assert(f.is_open());
assert(f.sbumpc() == L'1');
assert(f.sbumpc() == L'2');
assert(f.sbumpc() == L'3');
}
remove("test.dat");
}

140
test/input.output/file.streams/fstreams/filebuf.virtuals/overflow.pass.cpp Normal file
View File

@@ -0,0 +1,140 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// int_type overflow(int_type c = traits::eof());
// This test is not entirely portable
#include <fstream>
#include <cassert>
template <class CharT>
struct test_buf
: public std::basic_filebuf<CharT>
{
typedef std::basic_filebuf<CharT> base;
typedef typename base::char_type char_type;
typedef typename base::int_type int_type;
typedef typename base::traits_type traits_type;
char_type* pbase() const {return base::pbase();}
char_type* pptr() const {return base::pptr();}
char_type* epptr() const {return base::epptr();}
void gbump(int n) {base::gbump(n);}
virtual int_type overflow(int_type c = traits_type::eof()) {return base::overflow(c);}
};
int main()
{
{
test_buf<char> f;
assert(f.open("overflow.dat", std::ios_base::out) != 0);
assert(f.is_open());
assert(f.pbase() == 0);
assert(f.pptr() == 0);
assert(f.epptr() == 0);
assert(f.overflow('a') == 'a');
assert(f.pbase() != 0);
assert(f.pptr() == f.pbase());
assert(f.epptr() - f.pbase() == 4095);
}
{
test_buf<char> f;
assert(f.open("overflow.dat", std::ios_base::in) != 0);
assert(f.is_open());
assert(f.sgetc() == 'a');
}
std::remove("overflow.dat");
{
test_buf<char> f;
f.pubsetbuf(0, 0);
assert(f.open("overflow.dat", std::ios_base::out) != 0);
assert(f.is_open());
assert(f.pbase() == 0);
assert(f.pptr() == 0);
assert(f.epptr() == 0);
assert(f.overflow('a') == 'a');
assert(f.pbase() == 0);
assert(f.pptr() == 0);
assert(f.epptr() == 0);
}
{
test_buf<char> f;
assert(f.open("overflow.dat", std::ios_base::in) != 0);
assert(f.is_open());
assert(f.sgetc() == 'a');
}
std::remove("overflow.dat");
{
test_buf<wchar_t> f;
assert(f.open("overflow.dat", std::ios_base::out) != 0);
assert(f.is_open());
assert(f.pbase() == 0);
assert(f.pptr() == 0);
assert(f.epptr() == 0);
assert(f.overflow(L'a') == L'a');
assert(f.pbase() != 0);
assert(f.pptr() == f.pbase());
assert(f.epptr() - f.pbase() == 4095);
}
{
test_buf<wchar_t> f;
assert(f.open("overflow.dat", std::ios_base::in) != 0);
assert(f.is_open());
assert(f.sgetc() == L'a');
}
std::remove("overflow.dat");
{
test_buf<wchar_t> f;
f.pubsetbuf(0, 0);
assert(f.open("overflow.dat", std::ios_base::out) != 0);
assert(f.is_open());
assert(f.pbase() == 0);
assert(f.pptr() == 0);
assert(f.epptr() == 0);
assert(f.overflow(L'a') == L'a');
assert(f.pbase() == 0);
assert(f.pptr() == 0);
assert(f.epptr() == 0);
}
{
test_buf<wchar_t> f;
assert(f.open("overflow.dat", std::ios_base::in) != 0);
assert(f.is_open());
assert(f.sgetc() == L'a');
}
std::remove("overflow.dat");
{
test_buf<wchar_t> f;
f.pubimbue(std::locale("en_US.UTF-8"));
assert(f.open("overflow.dat", std::ios_base::out) != 0);
assert(f.sputc(0x4E51) == 0x4E51);
assert(f.sputc(0x4E52) == 0x4E52);
assert(f.sputc(0x4E53) == 0x4E53);
}
{
test_buf<char> f;
assert(f.open("overflow.dat", std::ios_base::in) != 0);
assert(f.is_open());
assert(f.sbumpc() == 0xE4);
assert(f.sbumpc() == 0xB9);
assert(f.sbumpc() == 0x91);
assert(f.sbumpc() == 0xE4);
assert(f.sbumpc() == 0xB9);
assert(f.sbumpc() == 0x92);
assert(f.sbumpc() == 0xE4);
assert(f.sbumpc() == 0xB9);
assert(f.sbumpc() == 0x93);
assert(f.sbumpc() == -1);
}
std::remove("overflow.dat");
}

56
test/input.output/file.streams/fstreams/filebuf.virtuals/pbackfail.pass.cpp Normal file
View File

@@ -0,0 +1,56 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// int_type pbackfail(int_type c = traits::eof());
// This test is not entirely portable
#include <fstream>
#include <cassert>
template <class CharT>
struct test_buf
: public std::basic_filebuf<CharT>
{
typedef std::basic_filebuf<CharT> base;
typedef typename base::char_type char_type;
typedef typename base::int_type int_type;
typedef typename base::traits_type traits_type;
char_type* eback() const {return base::eback();}
char_type* gptr() const {return base::gptr();}
char_type* egptr() const {return base::egptr();}
void gbump(int n) {base::gbump(n);}
virtual int_type pbackfail(int_type c = traits_type::eof()) {return base::pbackfail(c);}
};
int main()
{
{
test_buf<char> f;
assert(f.open("underflow.dat", std::ios_base::in) != 0);
assert(f.is_open());
assert(f.sbumpc() == '1');
assert(f.sgetc() == '2');
assert(f.pbackfail('a') == -1);
}
{
test_buf<char> f;
assert(f.open("underflow.dat", std::ios_base::in | std::ios_base::out) != 0);
assert(f.is_open());
assert(f.sbumpc() == '1');
assert(f.sgetc() == '2');
assert(f.pbackfail('a') == 'a');
assert(f.sbumpc() == 'a');
assert(f.sgetc() == '2');
}
}

83
test/input.output/file.streams/fstreams/filebuf.virtuals/seekoff.pass.cpp Normal file
View File

@@ -0,0 +1,83 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// pos_type seekoff(off_type off, ios_base::seekdir way,
// ios_base::openmode which = ios_base::in | ios_base::out);
// pos_type seekpos(pos_type sp,
// ios_base::openmode which = ios_base::in | ios_base::out);
// This test is not entirely portable
#include <fstream>
#include <cassert>
template <class CharT>
struct test_buf
: public std::basic_filebuf<CharT>
{
typedef std::basic_filebuf<CharT> base;
typedef typename base::char_type char_type;
typedef typename base::int_type int_type;
typedef typename base::pos_type pos_type;
char_type* eback() const {return base::eback();}
char_type* gptr() const {return base::gptr();}
char_type* egptr() const {return base::egptr();}
void gbump(int n) {base::gbump(n);}
virtual int_type underflow() {return base::underflow();}
};
int main()
{
{
char buf[10];
typedef std::filebuf::pos_type pos_type;
std::filebuf f;
f.pubsetbuf(buf, sizeof(buf));
assert(f.open("seekoff.dat", std::ios_base::in | std::ios_base::out
| std::ios_base::trunc) != 0);
assert(f.is_open());
f.sputn("abcdefghijklmnopqrstuvwxyz", 26);
assert(buf[0] == 'v');
pos_type p = f.pubseekoff(-15, std::ios_base::cur);
assert(p == 11);
assert(f.sgetc() == 'l');
f.pubseekoff(0, std::ios_base::beg);
assert(f.sgetc() == 'a');
f.pubseekoff(-1, std::ios_base::end);
assert(f.sgetc() == 'z');
assert(f.pubseekpos(p) == p);
assert(f.sgetc() == 'l');
}
std::remove("seekoff.dat");
{
wchar_t buf[10];
typedef std::filebuf::pos_type pos_type;
std::wfilebuf f;
f.pubsetbuf(buf, sizeof(buf)/sizeof(buf[0]));
assert(f.open("seekoff.dat", std::ios_base::in | std::ios_base::out
| std::ios_base::trunc) != 0);
assert(f.is_open());
f.sputn(L"abcdefghijklmnopqrstuvwxyz", 26);
assert(buf[0] == L'v');
pos_type p = f.pubseekoff(-15, std::ios_base::cur);
assert(p == 11);
assert(f.sgetc() == L'l');
f.pubseekoff(0, std::ios_base::beg);
assert(f.sgetc() == L'a');
f.pubseekoff(-1, std::ios_base::end);
assert(f.sgetc() == L'z');
assert(f.pubseekpos(p) == p);
assert(f.sgetc() == L'l');
}
std::remove("seekoff.dat");
}

1
test/input.output/file.streams/fstreams/filebuf.virtuals/underflow.dat Normal file
View File

@@ -0,0 +1 @@
123456789

119
test/input.output/file.streams/fstreams/filebuf.virtuals/underflow.pass.cpp Normal file
View File

@@ -0,0 +1,119 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// int_type underflow();
// This test is not entirely portable
#include <fstream>
#include <cassert>
template <class CharT>
struct test_buf
: public std::basic_filebuf<CharT>
{
typedef std::basic_filebuf<CharT> base;
typedef typename base::char_type char_type;
typedef typename base::int_type int_type;
char_type* eback() const {return base::eback();}
char_type* gptr() const {return base::gptr();}
char_type* egptr() const {return base::egptr();}
void gbump(int n) {base::gbump(n);}
virtual int_type underflow() {return base::underflow();}
};
int main()
{
{
test_buf<char> f;
assert(f.open("underflow.dat", std::ios_base::in) != 0);
assert(f.is_open());
assert(f.eback() == 0);
assert(f.gptr() == 0);
assert(f.egptr() == 0);
assert(f.underflow() == '1');
assert(f.eback() != 0);
assert(f.eback() == f.gptr());
assert(*f.gptr() == '1');
assert(f.egptr() - f.eback() == 9);
}
{
test_buf<char> f;
assert(f.open("underflow.dat", std::ios_base::in) != 0);
assert(f.pubsetbuf(0, 0));
assert(f.is_open());
assert(f.eback() == 0);
assert(f.gptr() == 0);
assert(f.egptr() == 0);
assert(f.underflow() == '1');
assert(f.eback() != 0);
assert(f.eback() == f.gptr());
assert(*f.gptr() == '1');
assert(f.egptr() - f.eback() == 8);
f.gbump(8);
assert(f.sgetc() == '9');
assert(f.eback()[0] == '5');
assert(f.eback()[1] == '6');
assert(f.eback()[2] == '7');
assert(f.eback()[3] == '8');
assert(f.gptr() - f.eback() == 4);
assert(*f.gptr() == '9');
assert(f.egptr() - f.gptr() == 1);
}
{
test_buf<wchar_t> f;
assert(f.open("underflow.dat", std::ios_base::in) != 0);
assert(f.is_open());
assert(f.eback() == 0);
assert(f.gptr() == 0);
assert(f.egptr() == 0);
assert(f.underflow() == L'1');
assert(f.eback() != 0);
assert(f.eback() == f.gptr());
assert(*f.gptr() == L'1');
assert(f.egptr() - f.eback() == 9);
}
{
test_buf<wchar_t> f;
assert(f.pubsetbuf(0, 0));
assert(f.open("underflow.dat", std::ios_base::in) != 0);
assert(f.is_open());
assert(f.eback() == 0);
assert(f.gptr() == 0);
assert(f.egptr() == 0);
assert(f.underflow() == L'1');
assert(f.eback() != 0);
assert(f.eback() == f.gptr());
assert(*f.gptr() == L'1');
assert(f.egptr() - f.eback() == 8);
f.gbump(8);
assert(f.sgetc() == L'9');
assert(f.eback()[0] == L'5');
assert(f.eback()[1] == L'6');
assert(f.eback()[2] == L'7');
assert(f.eback()[3] == L'8');
assert(f.gptr() - f.eback() == 4);
assert(*f.gptr() == L'9');
assert(f.egptr() - f.gptr() == 1);
}
{
test_buf<wchar_t> f;
f.pubimbue(std::locale("en_US.UTF-8"));
assert(f.open("underflow_utf8.dat", std::ios_base::in) != 0);
assert(f.is_open());
assert(f.sbumpc() == 0x4E51);
assert(f.sbumpc() == 0x4E52);
assert(f.sbumpc() == 0x4E53);
assert(f.sbumpc() == -1);
}
}

1
test/input.output/file.streams/fstreams/filebuf.virtuals/underflow_utf8.dat Normal file
View File

@@ -0,0 +1 @@
乑乒乓

34
test/input.output/file.streams/fstreams/filebuf/types.pass.cpp Normal file
View File

@@ -0,0 +1,34 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_filebuf
// : public basic_streambuf<charT, traits>
// {
// public:
// typedef charT char_type;
// typedef traits traits_type;
// typedef typename traits_type::int_type int_type;
// typedef typename traits_type::pos_type pos_type;
// typedef typename traits_type::off_type off_type;
#include <fstream>
#include <type_traits>
int main()
{
static_assert((std::is_base_of<std::basic_streambuf<char>, std::basic_filebuf<char> >::value), "");
static_assert((std::is_same<std::basic_filebuf<char>::char_type, char>::value), "");
static_assert((std::is_same<std::basic_filebuf<char>::traits_type, std::char_traits<char> >::value), "");
static_assert((std::is_same<std::basic_filebuf<char>::int_type, std::char_traits<char>::int_type>::value), "");
static_assert((std::is_same<std::basic_filebuf<char>::pos_type, std::char_traits<char>::pos_type>::value), "");
static_assert((std::is_same<std::basic_filebuf<char>::off_type, std::char_traits<char>::off_type>::value), "");
}

68
test/input.output/file.streams/fstreams/fstream.assign/member_swap.pass.cpp Normal file
View File

@@ -0,0 +1,68 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_fstream
// void swap(basic_fstream& rhs);
#include <fstream>
#include <cassert>
int main()
{
{
std::fstream fs1("test1.dat", std::ios_base::in | std::ios_base::out
| std::ios_base::trunc);
std::fstream fs2("test2.dat", std::ios_base::in | std::ios_base::out
| std::ios_base::trunc);
fs1 << 1 << ' ' << 2;
fs2 << 2 << ' ' << 1;
fs1.seekg(0);
fs1.swap(fs2);
fs1.seekg(0);
int i;
fs1 >> i;
assert(i == 2);
fs1 >> i;
assert(i == 1);
i = 0;
fs2 >> i;
assert(i == 1);
fs2 >> i;
assert(i == 2);
}
std::remove("test1.dat");
std::remove("test2.dat");
{
std::wfstream fs1("test1.dat", std::ios_base::in | std::ios_base::out
| std::ios_base::trunc);
std::wfstream fs2("test2.dat", std::ios_base::in | std::ios_base::out
| std::ios_base::trunc);
fs1 << 1 << ' ' << 2;
fs2 << 2 << ' ' << 1;
fs1.seekg(0);
fs1.swap(fs2);
fs1.seekg(0);
int i;
fs1 >> i;
assert(i == 2);
fs1 >> i;
assert(i == 1);
i = 0;
fs2 >> i;
assert(i == 1);
fs2 >> i;
assert(i == 2);
}
std::remove("test1.dat");
std::remove("test2.dat");
}

48
test/input.output/file.streams/fstreams/fstream.assign/move_assign.pass.cpp Normal file
View File

@@ -0,0 +1,48 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_fstream
// basic_fstream& operator=(basic_fstream&& rhs);
#include <fstream>
#include <cassert>
int main()
{
#ifdef _LIBCPP_MOVE
{
std::fstream fso("test.dat", std::ios_base::in | std::ios_base::out
| std::ios_base::trunc);
std::fstream fs;
fs = move(fso);
double x = 0;
fs << 3.25;
fs.seekg(0);
fs >> x;
assert(x == 3.25);
}
std::remove("test.dat");
{
std::wfstream fso("test.dat", std::ios_base::in | std::ios_base::out
| std::ios_base::trunc);
std::wfstream fs;
fs = move(fso);
double x = 0;
fs << 3.25;
fs.seekg(0);
fs >> x;
assert(x == 3.25);
}
std::remove("test.dat");
#endif
}

69
test/input.output/file.streams/fstreams/fstream.assign/nonmember_swap.pass.cpp Normal file
View File

@@ -0,0 +1,69 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_fstream
// template <class charT, class traits>
// void swap(basic_fstream<charT, traits>& x, basic_fstream<charT, traits>& y);
#include <fstream>
#include <cassert>
int main()
{
{
std::fstream fs1("test1.dat", std::ios_base::in | std::ios_base::out
| std::ios_base::trunc);
std::fstream fs2("test2.dat", std::ios_base::in | std::ios_base::out
| std::ios_base::trunc);
fs1 << 1 << ' ' << 2;
fs2 << 2 << ' ' << 1;
fs1.seekg(0);
swap(fs1, fs2);
fs1.seekg(0);
int i;
fs1 >> i;
assert(i == 2);
fs1 >> i;
assert(i == 1);
i = 0;
fs2 >> i;
assert(i == 1);
fs2 >> i;
assert(i == 2);
}
std::remove("test1.dat");
std::remove("test2.dat");
{
std::wfstream fs1("test1.dat", std::ios_base::in | std::ios_base::out
| std::ios_base::trunc);
std::wfstream fs2("test2.dat", std::ios_base::in | std::ios_base::out
| std::ios_base::trunc);
fs1 << 1 << ' ' << 2;
fs2 << 2 << ' ' << 1;
fs1.seekg(0);
swap(fs1, fs2);
fs1.seekg(0);
int i;
fs1 >> i;
assert(i == 2);
fs1 >> i;
assert(i == 1);
i = 0;
fs2 >> i;
assert(i == 1);
fs2 >> i;
assert(i == 2);
}
std::remove("test1.dat");
std::remove("test2.dat");
}

28
test/input.output/file.streams/fstreams/fstream.cons/default.pass.cpp Normal file
View File

@@ -0,0 +1,28 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_fstream
// basic_fstream();
#include <fstream>
#include <type_traits>
int main()
{
{
std::fstream fs;
}
{
std::wfstream fs;
}
}

46
test/input.output/file.streams/fstreams/fstream.cons/move.pass.cpp Normal file
View File

@@ -0,0 +1,46 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_fstream
// basic_fstream(basic_fstream&& rhs);
#include <fstream>
#include <cassert>
int main()
{
#ifdef _LIBCPP_MOVE
{
std::fstream fso("test.dat", std::ios_base::in | std::ios_base::out
| std::ios_base::trunc);
std::fstream fs = move(fso);
double x = 0;
fs << 3.25;
fs.seekg(0);
fs >> x;
assert(x == 3.25);
}
std::remove("test.dat");
{
std::wfstream fso("test.dat", std::ios_base::in | std::ios_base::out
| std::ios_base::trunc);
std::wfstream fs = move(fso);
double x = 0;
fs << 3.25;
fs.seekg(0);
fs >> x;
assert(x == 3.25);
}
std::remove("test.dat");
#endif
}

42
test/input.output/file.streams/fstreams/fstream.cons/pointer.pass.cpp Normal file
View File

@@ -0,0 +1,42 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_fstream
// explicit basic_fstream(const char* s, ios_base::openmode mode = ios_base::in | ios_base::out);
#include <fstream>
#include <cassert>
int main()
{
{
std::fstream fs("test.dat", std::ios_base::in | std::ios_base::out
| std::ios_base::trunc);
double x = 0;
fs << 3.25;
fs.seekg(0);
fs >> x;
assert(x == 3.25);
}
std::remove("test.dat");
{
std::wfstream fs("test.dat", std::ios_base::in | std::ios_base::out
| std::ios_base::trunc);
double x = 0;
fs << 3.25;
fs.seekg(0);
fs >> x;
assert(x == 3.25);
}
std::remove("test.dat");
}

44
test/input.output/file.streams/fstreams/fstream.cons/string.pass.cpp Normal file
View File

@@ -0,0 +1,44 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_fstream
// explicit basic_fstream(const string& s, ios_base::openmode mode = ios_base::in|ios_base::out);
#include <fstream>
#include <cassert>
int main()
{
{
std::fstream fs(std::string("test.dat"),
std::ios_base::in | std::ios_base::out
| std::ios_base::trunc);
double x = 0;
fs << 3.25;
fs.seekg(0);
fs >> x;
assert(x == 3.25);
}
std::remove("test.dat");
{
std::wfstream fs(std::string("test.dat"),
std::ios_base::in | std::ios_base::out
| std::ios_base::trunc);
double x = 0;
fs << 3.25;
fs.seekg(0);
fs >> x;
assert(x == 3.25);
}
std::remove("test.dat");
}

40
test/input.output/file.streams/fstreams/fstream.members/close.pass.cpp Normal file
View File

@@ -0,0 +1,40 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_fstream
// void close();
#include <fstream>
#include <cassert>
int main()
{
{
std::fstream fs;
assert(!fs.is_open());
fs.open("test.dat", std::ios_base::out);
assert(fs.is_open());
fs.close();
assert(!fs.is_open());
}
remove("test.dat");
{
std::wfstream fs;
assert(!fs.is_open());
fs.open("test.dat", std::ios_base::out);
assert(fs.is_open());
fs.close();
assert(!fs.is_open());
}
remove("test.dat");
}

48
test/input.output/file.streams/fstreams/fstream.members/open_pointer.pass.cpp Normal file
View File

@@ -0,0 +1,48 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_fstream
// void open(const char* s, ios_base::openmode mode = ios_base::in|ios_base::out);
#include <fstream>
#include <cassert>
int main()
{
{
std::fstream fs;
assert(!fs.is_open());
fs.open("test.dat", std::ios_base::in | std::ios_base::out
| std::ios_base::trunc);
assert(fs.is_open());
double x = 0;
fs << 3.25;
fs.seekg(0);
fs >> x;
assert(x == 3.25);
}
std::remove("test.dat");
{
std::wfstream fs;
assert(!fs.is_open());
fs.open("test.dat", std::ios_base::in | std::ios_base::out
| std::ios_base::trunc);
assert(fs.is_open());
double x = 0;
fs << 3.25;
fs.seekg(0);
fs >> x;
assert(x == 3.25);
}
std::remove("test.dat");
}

48
test/input.output/file.streams/fstreams/fstream.members/open_string.pass.cpp Normal file
View File

@@ -0,0 +1,48 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_fstream
// void open(const string& s, ios_base::openmode mode = ios_base::in|ios_base::out);
#include <fstream>
#include <cassert>
int main()
{
{
std::fstream fs;
assert(!fs.is_open());
fs.open(std::string("test.dat"), std::ios_base::in | std::ios_base::out
| std::ios_base::trunc);
assert(fs.is_open());
double x = 0;
fs << 3.25;
fs.seekg(0);
fs >> x;
assert(x == 3.25);
}
std::remove("test.dat");
{
std::wfstream fs;
assert(!fs.is_open());
fs.open(std::string("test.dat"), std::ios_base::in | std::ios_base::out
| std::ios_base::trunc);
assert(fs.is_open());
double x = 0;
fs << 3.25;
fs.seekg(0);
fs >> x;
assert(x == 3.25);
}
std::remove("test.dat");
}

30
test/input.output/file.streams/fstreams/fstream.members/rdbuf.pass.cpp Normal file
View File

@@ -0,0 +1,30 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_fstream
// basic_filebuf<charT,traits>* rdbuf() const;
#include <fstream>
#include <cassert>
int main()
{
{
std::fstream fs;
assert(fs.rdbuf());
}
{
std::wfstream fs;
assert(fs.rdbuf());
}
}

34
test/input.output/file.streams/fstreams/fstream/types.pass.cpp Normal file
View File

@@ -0,0 +1,34 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_fstream
// : public basic_iostream<charT,traits>
// {
// public:
// typedef charT char_type;
// typedef traits traits_type;
// typedef typename traits_type::int_type int_type;
// typedef typename traits_type::pos_type pos_type;
// typedef typename traits_type::off_type off_type;
#include <fstream>
#include <type_traits>
int main()
{
static_assert((std::is_base_of<std::basic_iostream<char>, std::basic_fstream<char> >::value), "");
static_assert((std::is_same<std::basic_fstream<char>::char_type, char>::value), "");
static_assert((std::is_same<std::basic_fstream<char>::traits_type, std::char_traits<char> >::value), "");
static_assert((std::is_same<std::basic_fstream<char>::int_type, std::char_traits<char>::int_type>::value), "");
static_assert((std::is_same<std::basic_fstream<char>::pos_type, std::char_traits<char>::pos_type>::value), "");
static_assert((std::is_same<std::basic_fstream<char>::off_type, std::char_traits<char>::off_type>::value), "");
}

42
test/input.output/file.streams/fstreams/ifstream.assign/member_swap.pass.cpp Normal file
View File

@@ -0,0 +1,42 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_ifstream
// void swap(basic_ifstream& rhs);
#include <fstream>
#include <cassert>
int main()
{
{
std::ifstream fs1("test.dat");
std::ifstream fs2("test2.dat");
fs1.swap(fs2);
double x = 0;
fs1 >> x;
assert(x == 4.5);
fs2 >> x;
assert(x == 3.25);
}
{
std::wifstream fs1("test.dat");
std::wifstream fs2("test2.dat");
fs1.swap(fs2);
double x = 0;
fs1 >> x;
assert(x == 4.5);
fs2 >> x;
assert(x == 3.25);
}
}

40
test/input.output/file.streams/fstreams/ifstream.assign/move_assign.pass.cpp Normal file
View File

@@ -0,0 +1,40 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_ifstream
// basic_ifstream& operator=(basic_ifstream&& rhs);
#include <fstream>
#include <cassert>
int main()
{
#ifdef _LIBCPP_MOVE
{
std::ifstream fso("test.dat");
std::ifstream fs;
fs = move(fso);
double x = 0;
fs >> x;
assert(x == 3.25);
}
{
std::wifstream fso("test.dat");
std::wifstream fs;
fs = move(fso);
double x = 0;
fs >> x;
assert(x == 3.25);
}
#endif
}

43
test/input.output/file.streams/fstreams/ifstream.assign/nonmember_swap.pass.cpp Normal file
View File

@@ -0,0 +1,43 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_ifstream
// template <class charT, class traits>
// void swap(basic_ifstream<charT, traits>& x, basic_ifstream<charT, traits>& y);
#include <fstream>
#include <cassert>
int main()
{
{
std::ifstream fs1("test.dat");
std::ifstream fs2("test2.dat");
swap(fs1, fs2);
double x = 0;
fs1 >> x;
assert(x == 4.5);
fs2 >> x;
assert(x == 3.25);
}
{
std::wifstream fs1("test.dat");
std::wifstream fs2("test2.dat");
swap(fs1, fs2);
double x = 0;
fs1 >> x;
assert(x == 4.5);
fs2 >> x;
assert(x == 3.25);
}
}

1
test/input.output/file.streams/fstreams/ifstream.assign/test.dat Normal file
View File

@@ -0,0 +1 @@
3.25

1
test/input.output/file.streams/fstreams/ifstream.assign/test2.dat Normal file
View File

@@ -0,0 +1 @@
4.5

28
test/input.output/file.streams/fstreams/ifstream.cons/default.pass.cpp Normal file
View File

@@ -0,0 +1,28 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_ifstream
// basic_ifstream();
#include <fstream>
#include <type_traits>
int main()
{
{
std::ifstream fs;
}
{
std::wifstream fs;
}
}

38
test/input.output/file.streams/fstreams/ifstream.cons/move.pass.cpp Normal file
View File

@@ -0,0 +1,38 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_ifstream
// basic_ifstream(basic_ifstream&& rhs);
#include <fstream>
#include <cassert>
int main()
{
#ifdef _LIBCPP_MOVE
{
std::ifstream fso("test.dat");
std::ifstream fs = move(fso);
double x = 0;
fs >> x;
assert(x == 3.25);
}
{
std::wifstream fso("test.dat");
std::wifstream fs = move(fso);
double x = 0;
fs >> x;
assert(x == 3.25);
}
#endif
}

46
test/input.output/file.streams/fstreams/ifstream.cons/pointer.pass.cpp Normal file
View File

@@ -0,0 +1,46 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_ifstream
// explicit basic_ifstream(const char* s, ios_base::openmode mode = ios_base::in);
#include <fstream>
#include <cassert>
int main()
{
{
std::ifstream fs("test.dat");
double x = 0;
fs >> x;
assert(x == 3.25);
}
{
std::ifstream fs("test.dat", std::ios_base::out);
double x = 0;
fs >> x;
assert(x == 3.25);
}
{
std::wifstream fs("test.dat");
double x = 0;
fs >> x;
assert(x == 3.25);
}
{
std::wifstream fs("test.dat", std::ios_base::out);
double x = 0;
fs >> x;
assert(x == 3.25);
}
}

46
test/input.output/file.streams/fstreams/ifstream.cons/string.pass.cpp Normal file
View File

@@ -0,0 +1,46 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_ifstream
// explicit basic_ifstream(const string& s, ios_base::openmode mode = ios_base::in);
#include <fstream>
#include <cassert>
int main()
{
{
std::ifstream fs(std::string("test.dat"));
double x = 0;
fs >> x;
assert(x == 3.25);
}
{
std::ifstream fs(std::string("test.dat"), std::ios_base::out);
double x = 0;
fs >> x;
assert(x == 3.25);
}
{
std::wifstream fs(std::string("test.dat"));
double x = 0;
fs >> x;
assert(x == 3.25);
}
{
std::wifstream fs(std::string("test.dat"), std::ios_base::out);
double x = 0;
fs >> x;
assert(x == 3.25);
}
}

1
test/input.output/file.streams/fstreams/ifstream.cons/test.dat Normal file
View File

@@ -0,0 +1 @@
3.25

38
test/input.output/file.streams/fstreams/ifstream.members/close.pass.cpp Normal file
View File

@@ -0,0 +1,38 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_ifstream
// void close();
#include <fstream>
#include <cassert>
int main()
{
{
std::ifstream fs;
assert(!fs.is_open());
fs.open("test.dat");
assert(fs.is_open());
fs.close();
assert(!fs.is_open());
}
{
std::wifstream fs;
assert(!fs.is_open());
fs.open("test.dat");
assert(fs.is_open());
fs.close();
assert(!fs.is_open());
}
}

46
test/input.output/file.streams/fstreams/ifstream.members/open_pointer.pass.cpp Normal file
View File

@@ -0,0 +1,46 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_ifstream
// void open(const char* s, ios_base::openmode mode = ios_base::in);
#include <fstream>
#include <cassert>
int main()
{
{
std::ifstream fs;
assert(!fs.is_open());
char c = 'a';
fs >> c;
assert(fs.fail());
assert(c == 'a');
fs.open("test.dat");
assert(fs.is_open());
fs >> c;
assert(c == 'r');
}
{
std::wifstream fs;
assert(!fs.is_open());
wchar_t c = L'a';
fs >> c;
assert(fs.fail());
assert(c == L'a');
fs.open("test.dat");
assert(fs.is_open());
fs >> c;
assert(c == L'r');
}
}

46
test/input.output/file.streams/fstreams/ifstream.members/open_string.pass.cpp Normal file
View File

@@ -0,0 +1,46 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_ifstream
// void open(const string& s, ios_base::openmode mode = ios_base::in);
#include <fstream>
#include <cassert>
int main()
{
{
std::ifstream fs;
assert(!fs.is_open());
char c = 'a';
fs >> c;
assert(fs.fail());
assert(c == 'a');
fs.open(std::string("test.dat"));
assert(fs.is_open());
fs >> c;
assert(c == 'r');
}
{
std::wifstream fs;
assert(!fs.is_open());
wchar_t c = L'a';
fs >> c;
assert(fs.fail());
assert(c == L'a');
fs.open(std::string("test.dat"));
assert(fs.is_open());
fs >> c;
assert(c == L'r');
}
}

32
test/input.output/file.streams/fstreams/ifstream.members/rdbuf.pass.cpp Normal file
View File

@@ -0,0 +1,32 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_ifstream
// basic_filebuf<charT,traits>* rdbuf() const;
#include <fstream>
#include <cassert>
int main()
{
{
std::ifstream fs("test.dat");
std::filebuf* fb = fs.rdbuf();
assert(fb->sgetc() == 'r');
}
{
std::wifstream fs("test.dat");
std::wfilebuf* fb = fs.rdbuf();
assert(fb->sgetc() == L'r');
}
}

1
test/input.output/file.streams/fstreams/ifstream.members/test.dat Normal file
View File

@@ -0,0 +1 @@
r

34
test/input.output/file.streams/fstreams/ifstream/types.pass.cpp Normal file
View File

@@ -0,0 +1,34 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_ifstream
// : public basic_istream<charT,traits>
// {
// public:
// typedef charT char_type;
// typedef traits traits_type;
// typedef typename traits_type::int_type int_type;
// typedef typename traits_type::pos_type pos_type;
// typedef typename traits_type::off_type off_type;
#include <fstream>
#include <type_traits>
int main()
{
static_assert((std::is_base_of<std::basic_istream<char>, std::basic_ifstream<char> >::value), "");
static_assert((std::is_same<std::basic_ifstream<char>::char_type, char>::value), "");
static_assert((std::is_same<std::basic_ifstream<char>::traits_type, std::char_traits<char> >::value), "");
static_assert((std::is_same<std::basic_ifstream<char>::int_type, std::char_traits<char>::int_type>::value), "");
static_assert((std::is_same<std::basic_ifstream<char>::pos_type, std::char_traits<char>::pos_type>::value), "");
static_assert((std::is_same<std::basic_ifstream<char>::off_type, std::char_traits<char>::off_type>::value), "");
}

76
test/input.output/file.streams/fstreams/ofstream.assign/member_swap.pass.cpp Normal file
View File

@@ -0,0 +1,76 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_ofstream
// void swap(basic_ofstream& rhs);
#include <fstream>
#include <cassert>
int main()
{
{
std::ofstream fs1("test1.dat");
std::ofstream fs2("test2.dat");
fs1 << 3.25;
fs2 << 4.5;
fs1.swap(fs2);
fs1 << ' ' << 3.25;
fs2 << ' ' << 4.5;
}
{
std::ifstream fs("test1.dat");
double x = 0;
fs >> x;
assert(x == 3.25);
fs >> x;
assert(x == 4.5);
}
remove("test1.dat");
{
std::ifstream fs("test2.dat");
double x = 0;
fs >> x;
assert(x == 4.5);
fs >> x;
assert(x == 3.25);
}
remove("test2.dat");
{
std::wofstream fs1("test1.dat");
std::wofstream fs2("test2.dat");
fs1 << 3.25;
fs2 << 4.5;
fs1.swap(fs2);
fs1 << ' ' << 3.25;
fs2 << ' ' << 4.5;
}
{
std::wifstream fs("test1.dat");
double x = 0;
fs >> x;
assert(x == 3.25);
fs >> x;
assert(x == 4.5);
}
remove("test1.dat");
{
std::wifstream fs("test2.dat");
double x = 0;
fs >> x;
assert(x == 4.5);
fs >> x;
assert(x == 3.25);
}
remove("test2.dat");
}

50
test/input.output/file.streams/fstreams/ofstream.assign/move_assign.pass.cpp Normal file
View File

@@ -0,0 +1,50 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_ofstream
// basic_ofstream& operator=(basic_ofstream&& rhs);
#include <fstream>
#include <cassert>
int main()
{
#ifdef _LIBCPP_MOVE
{
std::ofstream fso("test.dat");
std::ofstream fs;
fs = move(fso);
fs << 3.25;
}
{
std::ifstream fs("test.dat");
double x = 0;
fs >> x;
assert(x == 3.25);
}
remove("test.dat");
{
std::wofstream fso("test.dat");
std::wofstream fs;
fs = move(fso);
fs << 3.25;
}
{
std::wifstream fs("test.dat");
double x = 0;
fs >> x;
assert(x == 3.25);
}
remove("test.dat");
#endif
}

77
test/input.output/file.streams/fstreams/ofstream.assign/nonmember_swap.pass.cpp Normal file
View File

@@ -0,0 +1,77 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_ofstream
// template <class charT, class traits>
// void swap(basic_ofstream<charT, traits>& x, basic_ofstream<charT, traits>& y);
#include <fstream>
#include <cassert>
int main()
{
{
std::ofstream fs1("test1.dat");
std::ofstream fs2("test2.dat");
fs1 << 3.25;
fs2 << 4.5;
swap(fs1, fs2);
fs1 << ' ' << 3.25;
fs2 << ' ' << 4.5;
}
{
std::ifstream fs("test1.dat");
double x = 0;
fs >> x;
assert(x == 3.25);
fs >> x;
assert(x == 4.5);
}
remove("test1.dat");
{
std::ifstream fs("test2.dat");
double x = 0;
fs >> x;
assert(x == 4.5);
fs >> x;
assert(x == 3.25);
}
remove("test2.dat");
{
std::wofstream fs1("test1.dat");
std::wofstream fs2("test2.dat");
fs1 << 3.25;
fs2 << 4.5;
swap(fs1, fs2);
fs1 << ' ' << 3.25;
fs2 << ' ' << 4.5;
}
{
std::wifstream fs("test1.dat");
double x = 0;
fs >> x;
assert(x == 3.25);
fs >> x;
assert(x == 4.5);
}
remove("test1.dat");
{
std::wifstream fs("test2.dat");
double x = 0;
fs >> x;
assert(x == 4.5);
fs >> x;
assert(x == 3.25);
}
remove("test2.dat");
}

28
test/input.output/file.streams/fstreams/ofstream.cons/default.pass.cpp Normal file
View File

@@ -0,0 +1,28 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_ofstream
// basic_ofstream();
#include <fstream>
#include <type_traits>
int main()
{
{
std::ofstream fs;
}
{
std::wofstream fs;
}
}

48
test/input.output/file.streams/fstreams/ofstream.cons/move.pass.cpp Normal file
View File

@@ -0,0 +1,48 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_ofstream
// basic_ofstream(basic_ofstream&& rhs);
#include <fstream>
#include <cassert>
int main()
{
#ifdef _LIBCPP_MOVE
{
std::ofstream fso("test.dat");
std::ofstream fs = move(fso);
fs << 3.25;
}
{
std::ifstream fs("test.dat");
double x = 0;
fs >> x;
assert(x == 3.25);
}
remove("test.dat");
{
std::wofstream fso("test.dat");
std::wofstream fs = move(fso);
fs << 3.25;
}
{
std::wifstream fs("test.dat");
double x = 0;
fs >> x;
assert(x == 3.25);
}
remove("test.dat");
#endif
}

44
test/input.output/file.streams/fstreams/ofstream.cons/pointer.pass.cpp Normal file
View File

@@ -0,0 +1,44 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_ofstream
// explicit basic_ofstream(const char* s, ios_base::openmode mode = ios_base::out);
#include <fstream>
#include <cassert>
int main()
{
{
std::ofstream fs("test.dat");
fs << 3.25;
}
{
std::ifstream fs("test.dat");
double x = 0;
fs >> x;
assert(x == 3.25);
}
remove("test.dat");
{
std::wofstream fs("test.dat");
fs << 3.25;
}
{
std::wifstream fs("test.dat");
double x = 0;
fs >> x;
assert(x == 3.25);
}
remove("test.dat");
}

44
test/input.output/file.streams/fstreams/ofstream.cons/string.pass.cpp Normal file
View File

@@ -0,0 +1,44 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_ofstream
// explicit basic_ofstream(const string& s, ios_base::openmode mode = ios_base::out);
#include <fstream>
#include <cassert>
int main()
{
{
std::ofstream fs(std::string("test.dat"));
fs << 3.25;
}
{
std::ifstream fs(std::string("test.dat"));
double x = 0;
fs >> x;
assert(x == 3.25);
}
remove("test.dat");
{
std::wofstream fs(std::string("test.dat"));
fs << 3.25;
}
{
std::wifstream fs(std::string("test.dat"));
double x = 0;
fs >> x;
assert(x == 3.25);
}
remove("test.dat");
}

40
test/input.output/file.streams/fstreams/ofstream.members/close.pass.cpp Normal file
View File

@@ -0,0 +1,40 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_ofstream
// void close();
#include <fstream>
#include <cassert>
int main()
{
{
std::ofstream fs;
assert(!fs.is_open());
fs.open("test.dat");
assert(fs.is_open());
fs.close();
assert(!fs.is_open());
}
remove("test.dat");
{
std::wofstream fs;
assert(!fs.is_open());
fs.open("test.dat");
assert(fs.is_open());
fs.close();
assert(!fs.is_open());
}
remove("test.dat");
}

56
test/input.output/file.streams/fstreams/ofstream.members/open_pointer.pass.cpp Normal file
View File

@@ -0,0 +1,56 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_ofstream
// void open(const char* s, ios_base::openmode mode = ios_base::out);
#include <fstream>
#include <cassert>
int main()
{
{
std::ofstream fs;
assert(!fs.is_open());
char c = 'a';
fs << c;
assert(fs.fail());
fs.open("test.dat");
assert(fs.is_open());
fs << c;
}
{
std::ifstream fs("test.dat");
char c = 0;
fs >> c;
assert(c == 'a');
}
remove("test.dat");
{
std::wofstream fs;
assert(!fs.is_open());
wchar_t c = L'a';
fs << c;
assert(fs.fail());
fs.open("test.dat");
assert(fs.is_open());
fs << c;
}
{
std::wifstream fs("test.dat");
wchar_t c = 0;
fs >> c;
assert(c == L'a');
}
remove("test.dat");
}

56
test/input.output/file.streams/fstreams/ofstream.members/open_string.pass.cpp Normal file
View File

@@ -0,0 +1,56 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_ofstream
// void open(const string& s, ios_base::openmode mode = ios_base::out);
#include <fstream>
#include <cassert>
int main()
{
{
std::ofstream fs;
assert(!fs.is_open());
char c = 'a';
fs << c;
assert(fs.fail());
fs.open(std::string("test.dat"));
assert(fs.is_open());
fs << c;
}
{
std::ifstream fs("test.dat");
char c = 0;
fs >> c;
assert(c == 'a');
}
remove("test.dat");
{
std::wofstream fs;
assert(!fs.is_open());
wchar_t c = L'a';
fs << c;
assert(fs.fail());
fs.open(std::string("test.dat"));
assert(fs.is_open());
fs << c;
}
{
std::wifstream fs("test.dat");
wchar_t c = 0;
fs >> c;
assert(c == L'a');
}
remove("test.dat");
}

34
test/input.output/file.streams/fstreams/ofstream.members/rdbuf.pass.cpp Normal file
View File

@@ -0,0 +1,34 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_ofstream
// basic_filebuf<charT,traits>* rdbuf() const;
#include <fstream>
#include <cassert>
int main()
{
{
std::ofstream fs("test.dat");
std::filebuf* fb = fs.rdbuf();
assert(fb->sputc('r') == 'r');
}
remove("test.dat");
{
std::wofstream fs("test.dat");
std::wfilebuf* fb = fs.rdbuf();
assert(fb->sputc(L'r') == L'r');
}
remove("test.dat");
}

34
test/input.output/file.streams/fstreams/ofstream/types.pass.cpp Normal file
View File

@@ -0,0 +1,34 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
// template <class charT, class traits = char_traits<charT> >
// class basic_ofstream
// : public basic_ostream<charT,traits>
// {
// public:
// typedef charT char_type;
// typedef traits traits_type;
// typedef typename traits_type::int_type int_type;
// typedef typename traits_type::pos_type pos_type;
// typedef typename traits_type::off_type off_type;
#include <fstream>
#include <type_traits>
int main()
{
static_assert((std::is_base_of<std::basic_ostream<char>, std::basic_ofstream<char> >::value), "");
static_assert((std::is_same<std::basic_ofstream<char>::char_type, char>::value), "");
static_assert((std::is_same<std::basic_ofstream<char>::traits_type, std::char_traits<char> >::value), "");
static_assert((std::is_same<std::basic_ofstream<char>::int_type, std::char_traits<char>::int_type>::value), "");
static_assert((std::is_same<std::basic_ofstream<char>::pos_type, std::char_traits<char>::pos_type>::value), "");
static_assert((std::is_same<std::basic_ofstream<char>::off_type, std::char_traits<char>::off_type>::value), "");
}

20
test/input.output/file.streams/fstreams/version.pass.cpp Normal file
View File

@@ -0,0 +1,20 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <fstream>
#include <fstream>
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
int main()
{
}