LineageOS/android_external_libcxx
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Cleanup test issues reported by STL @ Microsoft.

Browse Source 
This patch cleans up a number of issues reported by STL, including:

1) Fix duplicate is_convertible test.
2) Move non-standard reference_wrapper tests under test/libcxx
3) Fix assumption that sizeof(wchar_t) == 32 in the codecvt and
   wstring_convert tests.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@302870 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Eric Fiselier
2017-05-12 03:38:28 +00:00
parent 050bf66723
commit e250cc68ce
10 changed files with 1230 additions and 1471 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
test/std/utilities/function.objects/refwrap/binary.pass.cpp → test/libcxx/utilities/function.objects/refwrap/binary.pass.cpp
View File

0
test/std/utilities/function.objects/refwrap/unary.pass.cpp → test/libcxx/utilities/function.objects/refwrap/unary.pass.cpp
View File

626
test/std/localization/locale.stdcvt/codecvt_utf16_out.pass.cpp
View File

@@ -25,307 +25,329 @@
#include <codecvt> #include <codecvt>
#include <cassert> #include <cassert>
int main() template <class CharT, size_t = sizeof(CharT)>
{ struct TestHelper;
{ template <class CharT>
typedef std::codecvt_utf16<wchar_t> C; struct TestHelper<CharT, 2> {
C c; static void test();
wchar_t w = 0x40003; };
char n[4] = {0}; template <class CharT>
const wchar_t* wp = nullptr; struct TestHelper<CharT, 4> {
std::mbstate_t m; static void test();
char* np = nullptr; };
std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+4, np);
assert(r == std::codecvt_base::ok);
assert(wp == &w+1);
assert(np == n+4);
assert(n[0] == char(0xD8));
assert(n[1] == char(0xC0));
assert(n[2] == char(0xDC));
assert(n[3] == char(0x03));
w = 0x1005; template <class CharT>
r = c.out(m, &w, &w+1, wp, n, n+4, np); void TestHelper<CharT, 2>::test() {
assert(r == std::codecvt_base::ok); // Nothing to do, the conversion in unsupported
assert(wp == &w+1); }
assert(np == n+2);
assert(n[0] == char(0x10)); template <class CharT>
assert(n[1] == char(0x05)); void TestHelper<CharT, 4>::test() {
assert(n[2] == char(0xDC)); {
assert(n[3] == char(0x03)); typedef std::codecvt_utf16<CharT> C;
C c;
w = 0x453; CharT w = 0x40003;
r = c.out(m, &w, &w+1, wp, n, n+4, np); char n[4] = {0};
assert(r == std::codecvt_base::ok); const CharT* wp = nullptr;
assert(wp == &w+1); std::mbstate_t m;
assert(np == n+2); char* np = nullptr;
assert(n[0] == char(0x04)); std::codecvt_base::result r = c.out(m, &w, &w + 1, wp, n, n + 4, np);
assert(n[1] == char(0x53)); assert(r == std::codecvt_base::ok);
assert(n[2] == char(0xDC)); assert(wp == &w + 1);
assert(n[3] == char(0x03)); assert(np == n + 4);
assert(n[0] == char(0xD8));
w = 0x56; assert(n[1] == char(0xC0));
r = c.out(m, &w, &w+1, wp, n, n+4, np); assert(n[2] == char(0xDC));
assert(r == std::codecvt_base::ok); assert(n[3] == char(0x03));
assert(wp == &w+1);
assert(np == n+2); w = 0x1005;
assert(n[0] == char(0x00)); r = c.out(m, &w, &w + 1, wp, n, n + 4, np);
assert(n[1] == char(0x56)); assert(r == std::codecvt_base::ok);
assert(n[2] == char(0xDC)); assert(wp == &w + 1);
assert(n[3] == char(0x03)); assert(np == n + 2);
} assert(n[0] == char(0x10));
{ assert(n[1] == char(0x05));
typedef std::codecvt_utf16<wchar_t, 0x1000> C; assert(n[2] == char(0xDC));
C c; assert(n[3] == char(0x03));
wchar_t w = 0x40003;
char n[4] = {0}; w = 0x453;
const wchar_t* wp = nullptr; r = c.out(m, &w, &w + 1, wp, n, n + 4, np);
std::mbstate_t m; assert(r == std::codecvt_base::ok);
char* np = nullptr; assert(wp == &w + 1);
std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+4, np); assert(np == n + 2);
assert(r == std::codecvt_base::error); assert(n[0] == char(0x04));
assert(wp == &w); assert(n[1] == char(0x53));
assert(np == n); assert(n[2] == char(0xDC));
assert(n[0] == char(0)); assert(n[3] == char(0x03));
assert(n[1] == char(0));
assert(n[2] == char(0)); w = 0x56;
assert(n[3] == char(0)); r = c.out(m, &w, &w + 1, wp, n, n + 4, np);
assert(r == std::codecvt_base::ok);
w = 0x1005; assert(wp == &w + 1);
r = c.out(m, &w, &w+1, wp, n, n+4, np); assert(np == n + 2);
assert(r == std::codecvt_base::error); assert(n[0] == char(0x00));
assert(wp == &w); assert(n[1] == char(0x56));
assert(np == n); assert(n[2] == char(0xDC));
assert(n[0] == char(0)); assert(n[3] == char(0x03));
assert(n[1] == char(0)); }
assert(n[2] == char(0)); {
assert(n[3] == char(0)); typedef std::codecvt_utf16<CharT, 0x1000> C;
C c;
w = 0x453; CharT w = 0x40003;
r = c.out(m, &w, &w+1, wp, n, n+4, np); char n[4] = {0};
assert(r == std::codecvt_base::ok); const CharT* wp = nullptr;
assert(wp == &w+1); std::mbstate_t m;
assert(np == n+2); char* np = nullptr;
assert(n[0] == char(0x04)); std::codecvt_base::result r = c.out(m, &w, &w + 1, wp, n, n + 4, np);
assert(n[1] == char(0x53)); assert(r == std::codecvt_base::error);
assert(n[2] == char(0)); assert(wp == &w);
assert(n[3] == char(0)); assert(np == n);
assert(n[0] == char(0));
w = 0x56; assert(n[1] == char(0));
r = c.out(m, &w, &w+1, wp, n, n+4, np); assert(n[2] == char(0));
assert(r == std::codecvt_base::ok); assert(n[3] == char(0));
assert(wp == &w+1);
assert(np == n+2); w = 0x1005;
assert(n[0] == char(0x00)); r = c.out(m, &w, &w + 1, wp, n, n + 4, np);
assert(n[1] == char(0x56)); assert(r == std::codecvt_base::error);
assert(n[2] == char(0)); assert(wp == &w);
assert(n[3] == char(0)); assert(np == n);
} assert(n[0] == char(0));
{ assert(n[1] == char(0));
typedef std::codecvt_utf16<wchar_t, 0x10ffff, std::generate_header> C; assert(n[2] == char(0));
C c; assert(n[3] == char(0));
wchar_t w = 0x40003;
char n[6] = {0}; w = 0x453;
const wchar_t* wp = nullptr; r = c.out(m, &w, &w + 1, wp, n, n + 4, np);
std::mbstate_t m; assert(r == std::codecvt_base::ok);
char* np = nullptr; assert(wp == &w + 1);
std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+6, np); assert(np == n + 2);
assert(r == std::codecvt_base::ok); assert(n[0] == char(0x04));
assert(wp == &w+1); assert(n[1] == char(0x53));
assert(np == n+6); assert(n[2] == char(0));
assert(n[0] == char(0xFE)); assert(n[3] == char(0));
assert(n[1] == char(0xFF));
assert(n[2] == char(0xD8)); w = 0x56;
assert(n[3] == char(0xC0)); r = c.out(m, &w, &w + 1, wp, n, n + 4, np);
assert(n[4] == char(0xDC)); assert(r == std::codecvt_base::ok);
assert(n[5] == char(0x03)); assert(wp == &w + 1);
assert(np == n + 2);
w = 0x1005; assert(n[0] == char(0x00));
r = c.out(m, &w, &w+1, wp, n, n+6, np); assert(n[1] == char(0x56));
assert(r == std::codecvt_base::ok); assert(n[2] == char(0));
assert(wp == &w+1); assert(n[3] == char(0));
assert(np == n+4); }
assert(n[0] == char(0xFE)); {
assert(n[1] == char(0xFF)); typedef std::codecvt_utf16<CharT, 0x10ffff, std::generate_header> C;
assert(n[2] == char(0x10)); C c;
assert(n[3] == char(0x05)); CharT w = 0x40003;
assert(n[4] == char(0xDC)); char n[6] = {0};
assert(n[5] == char(0x03)); const CharT* wp = nullptr;
std::mbstate_t m;
w = 0x453; char* np = nullptr;
r = c.out(m, &w, &w+1, wp, n, n+6, np); std::codecvt_base::result r = c.out(m, &w, &w + 1, wp, n, n + 6, np);
assert(r == std::codecvt_base::ok); assert(r == std::codecvt_base::ok);
assert(wp == &w+1); assert(wp == &w + 1);
assert(np == n+4); assert(np == n + 6);
assert(n[0] == char(0xFE)); assert(n[0] == char(0xFE));
assert(n[1] == char(0xFF)); assert(n[1] == char(0xFF));
assert(n[2] == char(0x04)); assert(n[2] == char(0xD8));
assert(n[3] == char(0x53)); assert(n[3] == char(0xC0));
assert(n[4] == char(0xDC)); assert(n[4] == char(0xDC));
assert(n[5] == char(0x03)); assert(n[5] == char(0x03));
w = 0x56; w = 0x1005;
r = c.out(m, &w, &w+1, wp, n, n+6, np); r = c.out(m, &w, &w + 1, wp, n, n + 6, np);
assert(r == std::codecvt_base::ok); assert(r == std::codecvt_base::ok);
assert(wp == &w+1); assert(wp == &w + 1);
assert(np == n+4); assert(np == n + 4);
assert(n[0] == char(0xFE)); assert(n[0] == char(0xFE));
assert(n[1] == char(0xFF)); assert(n[1] == char(0xFF));
assert(n[2] == char(0x00)); assert(n[2] == char(0x10));
assert(n[3] == char(0x56)); assert(n[3] == char(0x05));
assert(n[4] == char(0xDC)); assert(n[4] == char(0xDC));
assert(n[5] == char(0x03)); assert(n[5] == char(0x03));
}
w = 0x453;
{ r = c.out(m, &w, &w + 1, wp, n, n + 6, np);
typedef std::codecvt_utf16<wchar_t, 0x10FFFF, std::little_endian> C; assert(r == std::codecvt_base::ok);
C c; assert(wp == &w + 1);
wchar_t w = 0x40003; assert(np == n + 4);
char n[4] = {0}; assert(n[0] == char(0xFE));
const wchar_t* wp = nullptr; assert(n[1] == char(0xFF));
std::mbstate_t m; assert(n[2] == char(0x04));
char* np = nullptr; assert(n[3] == char(0x53));
std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+4, np); assert(n[4] == char(0xDC));
assert(r == std::codecvt_base::ok); assert(n[5] == char(0x03));
assert(wp == &w+1);
assert(np == n+4); w = 0x56;
assert(n[1] == char(0xD8)); r = c.out(m, &w, &w + 1, wp, n, n + 6, np);
assert(n[0] == char(0xC0)); assert(r == std::codecvt_base::ok);
assert(n[3] == char(0xDC)); assert(wp == &w + 1);
assert(n[2] == char(0x03)); assert(np == n + 4);
assert(n[0] == char(0xFE));
w = 0x1005; assert(n[1] == char(0xFF));
r = c.out(m, &w, &w+1, wp, n, n+4, np); assert(n[2] == char(0x00));
assert(r == std::codecvt_base::ok); assert(n[3] == char(0x56));
assert(wp == &w+1); assert(n[4] == char(0xDC));
assert(np == n+2); assert(n[5] == char(0x03));
assert(n[1] == char(0x10)); }
assert(n[0] == char(0x05));
assert(n[3] == char(0xDC)); {
assert(n[2] == char(0x03)); typedef std::codecvt_utf16<CharT, 0x10FFFF, std::little_endian> C;
C c;
w = 0x453; CharT w = 0x40003;
r = c.out(m, &w, &w+1, wp, n, n+4, np); char n[4] = {0};
assert(r == std::codecvt_base::ok); const CharT* wp = nullptr;
assert(wp == &w+1); std::mbstate_t m;
assert(np == n+2); char* np = nullptr;
assert(n[1] == char(0x04)); std::codecvt_base::result r = c.out(m, &w, &w + 1, wp, n, n + 4, np);
assert(n[0] == char(0x53)); assert(r == std::codecvt_base::ok);
assert(n[3] == char(0xDC)); assert(wp == &w + 1);
assert(n[2] == char(0x03)); assert(np == n + 4);
assert(n[1] == char(0xD8));
w = 0x56; assert(n[0] == char(0xC0));
r = c.out(m, &w, &w+1, wp, n, n+4, np); assert(n[3] == char(0xDC));
assert(r == std::codecvt_base::ok); assert(n[2] == char(0x03));
assert(wp == &w+1);
assert(np == n+2); w = 0x1005;
assert(n[1] == char(0x00)); r = c.out(m, &w, &w + 1, wp, n, n + 4, np);
assert(n[0] == char(0x56)); assert(r == std::codecvt_base::ok);
assert(n[3] == char(0xDC)); assert(wp == &w + 1);
assert(n[2] == char(0x03)); assert(np == n + 2);
} assert(n[1] == char(0x10));
{ assert(n[0] == char(0x05));
typedef std::codecvt_utf16<wchar_t, 0x1000, std::little_endian> C; assert(n[3] == char(0xDC));
C c; assert(n[2] == char(0x03));
wchar_t w = 0x40003;
char n[4] = {0}; w = 0x453;
const wchar_t* wp = nullptr; r = c.out(m, &w, &w + 1, wp, n, n + 4, np);
std::mbstate_t m; assert(r == std::codecvt_base::ok);
char* np = nullptr; assert(wp == &w + 1);
std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+4, np); assert(np == n + 2);
assert(r == std::codecvt_base::error); assert(n[1] == char(0x04));
assert(wp == &w); assert(n[0] == char(0x53));
assert(np == n); assert(n[3] == char(0xDC));
assert(n[1] == char(0)); assert(n[2] == char(0x03));
assert(n[0] == char(0));
assert(n[3] == char(0)); w = 0x56;
assert(n[2] == char(0)); r = c.out(m, &w, &w + 1, wp, n, n + 4, np);
assert(r == std::codecvt_base::ok);
w = 0x1005; assert(wp == &w + 1);
r = c.out(m, &w, &w+1, wp, n, n+4, np); assert(np == n + 2);
assert(r == std::codecvt_base::error); assert(n[1] == char(0x00));
assert(wp == &w); assert(n[0] == char(0x56));
assert(np == n); assert(n[3] == char(0xDC));
assert(n[1] == char(0)); assert(n[2] == char(0x03));
assert(n[0] == char(0)); }
assert(n[3] == char(0)); {
assert(n[2] == char(0)); typedef std::codecvt_utf16<CharT, 0x1000, std::little_endian> C;
C c;
w = 0x453; CharT w = 0x40003;
r = c.out(m, &w, &w+1, wp, n, n+4, np); char n[4] = {0};
assert(r == std::codecvt_base::ok); const CharT* wp = nullptr;
assert(wp == &w+1); std::mbstate_t m;
assert(np == n+2); char* np = nullptr;
assert(n[1] == char(0x04)); std::codecvt_base::result r = c.out(m, &w, &w + 1, wp, n, n + 4, np);
assert(n[0] == char(0x53)); assert(r == std::codecvt_base::error);
assert(n[3] == char(0)); assert(wp == &w);
assert(n[2] == char(0)); assert(np == n);
assert(n[1] == char(0));
w = 0x56; assert(n[0] == char(0));
r = c.out(m, &w, &w+1, wp, n, n+4, np); assert(n[3] == char(0));
assert(r == std::codecvt_base::ok); assert(n[2] == char(0));
assert(wp == &w+1);
assert(np == n+2); w = 0x1005;
assert(n[1] == char(0x00)); r = c.out(m, &w, &w + 1, wp, n, n + 4, np);
assert(n[0] == char(0x56)); assert(r == std::codecvt_base::error);
assert(n[3] == char(0)); assert(wp == &w);
assert(n[2] == char(0)); assert(np == n);
} assert(n[1] == char(0));
{ assert(n[0] == char(0));
typedef std::codecvt_utf16<wchar_t, 0x10ffff, std::codecvt_mode( assert(n[3] == char(0));
std::generate_header | assert(n[2] == char(0));
std::little_endian)> C;
C c; w = 0x453;
wchar_t w = 0x40003; r = c.out(m, &w, &w + 1, wp, n, n + 4, np);
char n[6] = {0}; assert(r == std::codecvt_base::ok);
const wchar_t* wp = nullptr; assert(wp == &w + 1);
std::mbstate_t m; assert(np == n + 2);
char* np = nullptr; assert(n[1] == char(0x04));
std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+6, np); assert(n[0] == char(0x53));
assert(r == std::codecvt_base::ok); assert(n[3] == char(0));
assert(wp == &w+1); assert(n[2] == char(0));
assert(np == n+6);
assert(n[1] == char(0xFE)); w = 0x56;
assert(n[0] == char(0xFF)); r = c.out(m, &w, &w + 1, wp, n, n + 4, np);
assert(n[3] == char(0xD8)); assert(r == std::codecvt_base::ok);
assert(n[2] == char(0xC0)); assert(wp == &w + 1);
assert(n[5] == char(0xDC)); assert(np == n + 2);
assert(n[4] == char(0x03)); assert(n[1] == char(0x00));
assert(n[0] == char(0x56));
w = 0x1005; assert(n[3] == char(0));
r = c.out(m, &w, &w+1, wp, n, n+6, np); assert(n[2] == char(0));
assert(r == std::codecvt_base::ok); }
assert(wp == &w+1); {
assert(np == n+4); typedef std::codecvt_utf16<CharT, 0x10ffff,
assert(n[1] == char(0xFE)); std::codecvt_mode(std::generate_header |
assert(n[0] == char(0xFF)); std::little_endian)>
assert(n[3] == char(0x10)); C;
assert(n[2] == char(0x05)); C c;
assert(n[5] == char(0xDC)); CharT w = 0x40003;
assert(n[4] == char(0x03)); char n[6] = {0};
const CharT* wp = nullptr;
w = 0x453; std::mbstate_t m;
r = c.out(m, &w, &w+1, wp, n, n+6, np); char* np = nullptr;
assert(r == std::codecvt_base::ok); std::codecvt_base::result r = c.out(m, &w, &w + 1, wp, n, n + 6, np);
assert(wp == &w+1); assert(r == std::codecvt_base::ok);
assert(np == n+4); assert(wp == &w + 1);
assert(n[1] == char(0xFE)); assert(np == n + 6);
assert(n[0] == char(0xFF)); assert(n[1] == char(0xFE));
assert(n[3] == char(0x04)); assert(n[0] == char(0xFF));
assert(n[2] == char(0x53)); assert(n[3] == char(0xD8));
assert(n[5] == char(0xDC)); assert(n[2] == char(0xC0));
assert(n[4] == char(0x03)); assert(n[5] == char(0xDC));
assert(n[4] == char(0x03));
w = 0x56;
r = c.out(m, &w, &w+1, wp, n, n+6, np); w = 0x1005;
assert(r == std::codecvt_base::ok); r = c.out(m, &w, &w + 1, wp, n, n + 6, np);
assert(wp == &w+1); assert(r == std::codecvt_base::ok);
assert(np == n+4); assert(wp == &w + 1);
assert(n[1] == char(0xFE)); assert(np == n + 4);
assert(n[0] == char(0xFF)); assert(n[1] == char(0xFE));
assert(n[3] == char(0x00)); assert(n[0] == char(0xFF));
assert(n[2] == char(0x56)); assert(n[3] == char(0x10));
assert(n[5] == char(0xDC)); assert(n[2] == char(0x05));
assert(n[4] == char(0x03)); assert(n[5] == char(0xDC));
} assert(n[4] == char(0x03));
w = 0x453;
r = c.out(m, &w, &w + 1, wp, n, n + 6, np);
assert(r == std::codecvt_base::ok);
assert(wp == &w + 1);
assert(np == n + 4);
assert(n[1] == char(0xFE));
assert(n[0] == char(0xFF));
assert(n[3] == char(0x04));
assert(n[2] == char(0x53));
assert(n[5] == char(0xDC));
assert(n[4] == char(0x03));
w = 0x56;
r = c.out(m, &w, &w + 1, wp, n, n + 6, np);
assert(r == std::codecvt_base::ok);
assert(wp == &w + 1);
assert(np == n + 4);
assert(n[1] == char(0xFE));
assert(n[0] == char(0xFF));
assert(n[3] == char(0x00));
assert(n[2] == char(0x56));
assert(n[5] == char(0xDC));
assert(n[4] == char(0x03));
}
}
int main() {
TestHelper<char32_t>::test();
TestHelper<wchar_t>::test();
} }

708
test/std/localization/locale.stdcvt/codecvt_utf8_out.pass.cpp
View File

@@ -25,432 +25,302 @@
#include <codecvt> #include <codecvt>
#include <cassert> #include <cassert>
int main() template <class CharT, size_t = sizeof(CharT)>
{ struct TestHelper;
{
typedef std::codecvt_utf8<wchar_t> C;
C c;
wchar_t w = 0x40003;
char n[4] = {0};
const wchar_t* wp = nullptr;
std::mbstate_t m;
char* np = nullptr;
std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+4, np);
assert(r == std::codecvt_base::ok);
assert(wp == &w+1);
assert(np == n+4);
assert(n[0] == char(0xF1));
assert(n[1] == char(0x80));
assert(n[2] == char(0x80));
assert(n[3] == char(0x83));
w = 0x1005; template <class CharT>
r = c.out(m, &w, &w+1, wp, n, n+4, np); struct TestHelper<CharT, 2> {
assert(r == std::codecvt_base::ok); static void test();
assert(wp == &w+1); };
assert(np == n+3);
assert(n[0] == char(0xE1));
assert(n[1] == char(0x80));
assert(n[2] == char(0x85));
assert(n[3] == char(0x83));
w = 0x453; template <class CharT>
r = c.out(m, &w, &w+1, wp, n, n+4, np); struct TestHelper<CharT, 4> {
assert(r == std::codecvt_base::ok); static void test();
assert(wp == &w+1); };
assert(np == n+2);
assert(n[0] == char(0xD1));
assert(n[1] == char(0x93));
assert(n[2] == char(0x85));
assert(n[3] == char(0x83));
w = 0x56; template <class CharT>
r = c.out(m, &w, &w+1, wp, n, n+4, np); void TestHelper<CharT, 2>::test() {
assert(r == std::codecvt_base::ok); {
assert(wp == &w+1); typedef std::codecvt_utf8<CharT> C;
assert(np == n+1); C c;
assert(n[0] == char(0x56)); CharT w = 0x1005;
assert(n[1] == char(0x93)); char n[4] = {0};
assert(n[2] == char(0x85)); const CharT* wp = nullptr;
assert(n[3] == char(0x83)); std::mbstate_t m;
} char* np = nullptr;
{ std::codecvt_base::result r = c.out(m, &w, &w + 1, wp, n, n + 4, np);
typedef std::codecvt_utf8<wchar_t, 0x1000> C; assert(r == std::codecvt_base::ok);
C c; assert(wp == &w + 1);
wchar_t w = 0x40003; assert(np == n + 3);
char n[4] = {0}; assert(n[0] == char(0xE1));
const wchar_t* wp = nullptr; assert(n[1] == char(0x80));
std::mbstate_t m; assert(n[2] == char(0x85));
char* np = nullptr; assert(n[3] == char(0));
std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+4, np);
assert(r == std::codecvt_base::error);
assert(wp == &w);
assert(np == n);
assert(n[0] == char(0));
assert(n[1] == char(0));
assert(n[2] == char(0));
assert(n[3] == char(0));
w = 0x1005; w = 0x453;
r = c.out(m, &w, &w+1, wp, n, n+4, np); r = c.out(m, &w, &w + 1, wp, n, n + 4, np);
assert(r == std::codecvt_base::error); assert(r == std::codecvt_base::ok);
assert(wp == &w); assert(wp == &w + 1);
assert(np == n); assert(np == n + 2);
assert(n[0] == char(0)); assert(n[0] == char(0xD1));
assert(n[1] == char(0)); assert(n[1] == char(0x93));
assert(n[2] == char(0)); assert(n[2] == char(0x85));
assert(n[3] == char(0)); assert(n[3] == char(0));
w = 0x453; w = 0x56;
r = c.out(m, &w, &w+1, wp, n, n+4, np); r = c.out(m, &w, &w + 1, wp, n, n + 4, np);
assert(r == std::codecvt_base::ok); assert(r == std::codecvt_base::ok);
assert(wp == &w+1); assert(wp == &w + 1);
assert(np == n+2); assert(np == n + 1);
assert(n[0] == char(0xD1)); assert(n[0] == char(0x56));
assert(n[1] == char(0x93)); assert(n[1] == char(0x93));
assert(n[2] == char(0)); assert(n[2] == char(0x85));
assert(n[3] == char(0)); assert(n[3] == char(0));
}
{
typedef std::codecvt_utf8<CharT, 0x1000> C;
C c;
CharT w = 0x1005;
char n[4] = {0};
const CharT* wp = nullptr;
std::mbstate_t m;
char* np = nullptr;
std::codecvt_base::result r = c.out(m, &w, &w + 1, wp, n, n + 4, np);
assert(r == std::codecvt_base::error);
assert(wp == &w);
assert(np == n);
assert(n[0] == char(0));
assert(n[1] == char(0));
assert(n[2] == char(0));
assert(n[3] == char(0));
w = 0x56; w = 0x453;
r = c.out(m, &w, &w+1, wp, n, n+4, np); r = c.out(m, &w, &w + 1, wp, n, n + 4, np);
assert(r == std::codecvt_base::ok); assert(r == std::codecvt_base::ok);
assert(wp == &w+1); assert(wp == &w + 1);
assert(np == n+1); assert(np == n + 2);
assert(n[0] == char(0x56)); assert(n[0] == char(0xD1));
assert(n[1] == char(0x93)); assert(n[1] == char(0x93));
assert(n[2] == char(0)); assert(n[2] == char(0));
assert(n[3] == char(0)); assert(n[3] == char(0));
}
{
typedef std::codecvt_utf8<wchar_t, 0xFFFFFFFF, std::generate_header> C;
C c;
wchar_t w = 0x40003;
char n[7] = {0};
const wchar_t* wp = nullptr;
std::mbstate_t m;
char* np = nullptr;
std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+7, np);
assert(r == std::codecvt_base::ok);
assert(wp == &w+1);
assert(np == n+7);
assert(n[0] == char(0xEF));
assert(n[1] == char(0xBB));
assert(n[2] == char(0xBF));
assert(n[3] == char(0xF1));
assert(n[4] == char(0x80));
assert(n[5] == char(0x80));
assert(n[6] == char(0x83));
w = 0x1005; w = 0x56;
r = c.out(m, &w, &w+1, wp, n, n+7, np); r = c.out(m, &w, &w + 1, wp, n, n + 4, np);
assert(r == std::codecvt_base::ok); assert(r == std::codecvt_base::ok);
assert(wp == &w+1); assert(wp == &w + 1);
assert(np == n+6); assert(np == n + 1);
assert(n[0] == char(0xEF)); assert(n[0] == char(0x56));
assert(n[1] == char(0xBB)); assert(n[1] == char(0x93));
assert(n[2] == char(0xBF)); assert(n[2] == char(0));
assert(n[3] == char(0xE1)); assert(n[3] == char(0));
assert(n[4] == char(0x80)); }
assert(n[5] == char(0x85)); {
assert(n[6] == char(0x83)); typedef std::codecvt_utf8<CharT, 0xFFFFFFFF, std::generate_header> C;
C c;
CharT w = 0x1005;
char n[7] = {0};
const CharT* wp = nullptr;
std::mbstate_t m;
char* np = nullptr;
std::codecvt_base::result r = c.out(m, &w, &w + 1, wp, n, n + 7, np);
assert(r == std::codecvt_base::ok);
assert(wp == &w + 1);
assert(np == n + 6);
assert(n[0] == char(0xEF));
assert(n[1] == char(0xBB));
assert(n[2] == char(0xBF));
assert(n[3] == char(0xE1));
assert(n[4] == char(0x80));
assert(n[5] == char(0x85));
assert(n[6] == char(0));
w = 0x453; w = 0x453;
r = c.out(m, &w, &w+1, wp, n, n+7, np); r = c.out(m, &w, &w + 1, wp, n, n + 7, np);
assert(r == std::codecvt_base::ok); assert(r == std::codecvt_base::ok);
assert(wp == &w+1); assert(wp == &w + 1);
assert(np == n+5); assert(np == n + 5);
assert(n[0] == char(0xEF)); assert(n[0] == char(0xEF));
assert(n[1] == char(0xBB)); assert(n[1] == char(0xBB));
assert(n[2] == char(0xBF)); assert(n[2] == char(0xBF));
assert(n[3] == char(0xD1)); assert(n[3] == char(0xD1));
assert(n[4] == char(0x93)); assert(n[4] == char(0x93));
assert(n[5] == char(0x85)); assert(n[5] == char(0x85));
assert(n[6] == char(0x83)); assert(n[6] == char(0));
w = 0x56; w = 0x56;
r = c.out(m, &w, &w+1, wp, n, n+7, np); r = c.out(m, &w, &w + 1, wp, n, n + 7, np);
assert(r == std::codecvt_base::ok); assert(r == std::codecvt_base::ok);
assert(wp == &w+1); assert(wp == &w + 1);
assert(np == n+4); assert(np == n + 4);
assert(n[0] == char(0xEF)); assert(n[0] == char(0xEF));
assert(n[1] == char(0xBB)); assert(n[1] == char(0xBB));
assert(n[2] == char(0xBF)); assert(n[2] == char(0xBF));
assert(n[3] == char(0x56)); assert(n[3] == char(0x56));
assert(n[4] == char(0x93)); assert(n[4] == char(0x93));
assert(n[5] == char(0x85)); assert(n[5] == char(0x85));
assert(n[6] == char(0x83)); assert(n[6] == char(0));
} }
{ }
typedef std::codecvt_utf8<char32_t> C;
C c; template <class CharT>
char32_t w = 0x40003; void TestHelper<CharT, 4>::test() {
char n[4] = {0}; {
const char32_t* wp = nullptr; typedef std::codecvt_utf8<CharT> C;
std::mbstate_t m; C c;
char* np = nullptr; CharT w = 0x40003;
std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+4, np); char n[4] = {0};
assert(r == std::codecvt_base::ok); const CharT* wp = nullptr;
assert(wp == &w+1); std::mbstate_t m;
assert(np == n+4); char* np = nullptr;
assert(n[0] == char(0xF1)); std::codecvt_base::result r = c.out(m, &w, &w + 1, wp, n, n + 4, np);
assert(n[1] == char(0x80)); assert(r == std::codecvt_base::ok);
assert(n[2] == char(0x80)); assert(wp == &w + 1);
assert(n[3] == char(0x83)); assert(np == n + 4);
assert(n[0] == char(0xF1));
w = 0x1005; assert(n[1] == char(0x80));
r = c.out(m, &w, &w+1, wp, n, n+4, np); assert(n[2] == char(0x80));
assert(r == std::codecvt_base::ok); assert(n[3] == char(0x83));
assert(wp == &w+1);
assert(np == n+3); w = 0x1005;
assert(n[0] == char(0xE1)); r = c.out(m, &w, &w + 1, wp, n, n + 4, np);
assert(n[1] == char(0x80)); assert(r == std::codecvt_base::ok);
assert(n[2] == char(0x85)); assert(wp == &w + 1);
assert(n[3] == char(0x83)); assert(np == n + 3);
assert(n[0] == char(0xE1));
w = 0x453; assert(n[1] == char(0x80));
r = c.out(m, &w, &w+1, wp, n, n+4, np); assert(n[2] == char(0x85));
assert(r == std::codecvt_base::ok); assert(n[3] == char(0x83));
assert(wp == &w+1);
assert(np == n+2); w = 0x453;
assert(n[0] == char(0xD1)); r = c.out(m, &w, &w + 1, wp, n, n + 4, np);
assert(n[1] == char(0x93)); assert(r == std::codecvt_base::ok);
assert(n[2] == char(0x85)); assert(wp == &w + 1);
assert(n[3] == char(0x83)); assert(np == n + 2);
assert(n[0] == char(0xD1));
w = 0x56; assert(n[1] == char(0x93));
r = c.out(m, &w, &w+1, wp, n, n+4, np); assert(n[2] == char(0x85));
assert(r == std::codecvt_base::ok); assert(n[3] == char(0x83));
assert(wp == &w+1);
assert(np == n+1); w = 0x56;
assert(n[0] == char(0x56)); r = c.out(m, &w, &w + 1, wp, n, n + 4, np);
assert(n[1] == char(0x93)); assert(r == std::codecvt_base::ok);
assert(n[2] == char(0x85)); assert(wp == &w + 1);
assert(n[3] == char(0x83)); assert(np == n + 1);
} assert(n[0] == char(0x56));
{ assert(n[1] == char(0x93));
typedef std::codecvt_utf8<char32_t, 0x1000> C; assert(n[2] == char(0x85));
C c; assert(n[3] == char(0x83));
char32_t w = 0x40003; }
char n[4] = {0}; {
const char32_t* wp = nullptr; typedef std::codecvt_utf8<CharT, 0x1000> C;
std::mbstate_t m; C c;
char* np = nullptr; CharT w = 0x40003;
std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+4, np); char n[4] = {0};
assert(r == std::codecvt_base::error); const CharT* wp = nullptr;
assert(wp == &w); std::mbstate_t m;
assert(np == n); char* np = nullptr;
assert(n[0] == char(0)); std::codecvt_base::result r = c.out(m, &w, &w + 1, wp, n, n + 4, np);
assert(n[1] == char(0)); assert(r == std::codecvt_base::error);
assert(n[2] == char(0)); assert(wp == &w);
assert(n[3] == char(0)); assert(np == n);
assert(n[0] == char(0));
w = 0x1005; assert(n[1] == char(0));
r = c.out(m, &w, &w+1, wp, n, n+4, np); assert(n[2] == char(0));
assert(r == std::codecvt_base::error); assert(n[3] == char(0));
assert(wp == &w);
assert(np == n); w = 0x1005;
assert(n[0] == char(0)); r = c.out(m, &w, &w + 1, wp, n, n + 4, np);
assert(n[1] == char(0)); assert(r == std::codecvt_base::error);
assert(n[2] == char(0)); assert(wp == &w);
assert(n[3] == char(0)); assert(np == n);
assert(n[0] == char(0));
w = 0x453; assert(n[1] == char(0));
r = c.out(m, &w, &w+1, wp, n, n+4, np); assert(n[2] == char(0));
assert(r == std::codecvt_base::ok); assert(n[3] == char(0));
assert(wp == &w+1);
assert(np == n+2); w = 0x453;
assert(n[0] == char(0xD1)); r = c.out(m, &w, &w + 1, wp, n, n + 4, np);
assert(n[1] == char(0x93)); assert(r == std::codecvt_base::ok);
assert(n[2] == char(0)); assert(wp == &w + 1);
assert(n[3] == char(0)); assert(np == n + 2);
assert(n[0] == char(0xD1));
w = 0x56; assert(n[1] == char(0x93));
r = c.out(m, &w, &w+1, wp, n, n+4, np); assert(n[2] == char(0));
assert(r == std::codecvt_base::ok); assert(n[3] == char(0));
assert(wp == &w+1);
assert(np == n+1); w = 0x56;
assert(n[0] == char(0x56)); r = c.out(m, &w, &w + 1, wp, n, n + 4, np);
assert(n[1] == char(0x93)); assert(r == std::codecvt_base::ok);
assert(n[2] == char(0)); assert(wp == &w + 1);
assert(n[3] == char(0)); assert(np == n + 1);
} assert(n[0] == char(0x56));
{ assert(n[1] == char(0x93));
typedef std::codecvt_utf8<char32_t, 0xFFFFFFFF, std::generate_header> C; assert(n[2] == char(0));
C c; assert(n[3] == char(0));
char32_t w = 0x40003; }
char n[7] = {0}; {
const char32_t* wp = nullptr; typedef std::codecvt_utf8<CharT, 0xFFFFFFFF, std::generate_header> C;
std::mbstate_t m; C c;
char* np = nullptr; CharT w = 0x40003;
std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+7, np); char n[7] = {0};
assert(r == std::codecvt_base::ok); const CharT* wp = nullptr;
assert(wp == &w+1); std::mbstate_t m;
assert(np == n+7); char* np = nullptr;
assert(n[0] == char(0xEF)); std::codecvt_base::result r = c.out(m, &w, &w + 1, wp, n, n + 7, np);
assert(n[1] == char(0xBB)); assert(r == std::codecvt_base::ok);
assert(n[2] == char(0xBF)); assert(wp == &w + 1);
assert(n[3] == char(0xF1)); assert(np == n + 7);
assert(n[4] == char(0x80)); assert(n[0] == char(0xEF));
assert(n[5] == char(0x80)); assert(n[1] == char(0xBB));
assert(n[6] == char(0x83)); assert(n[2] == char(0xBF));
assert(n[3] == char(0xF1));
w = 0x1005; assert(n[4] == char(0x80));
r = c.out(m, &w, &w+1, wp, n, n+7, np); assert(n[5] == char(0x80));
assert(r == std::codecvt_base::ok); assert(n[6] == char(0x83));
assert(wp == &w+1);
assert(np == n+6); w = 0x1005;
assert(n[0] == char(0xEF)); r = c.out(m, &w, &w + 1, wp, n, n + 7, np);
assert(n[1] == char(0xBB)); assert(r == std::codecvt_base::ok);
assert(n[2] == char(0xBF)); assert(wp == &w + 1);
assert(n[3] == char(0xE1)); assert(np == n + 6);
assert(n[4] == char(0x80)); assert(n[0] == char(0xEF));
assert(n[5] == char(0x85)); assert(n[1] == char(0xBB));
assert(n[6] == char(0x83)); assert(n[2] == char(0xBF));
assert(n[3] == char(0xE1));
w = 0x453; assert(n[4] == char(0x80));
r = c.out(m, &w, &w+1, wp, n, n+7, np); assert(n[5] == char(0x85));
assert(r == std::codecvt_base::ok); assert(n[6] == char(0x83));
assert(wp == &w+1);
assert(np == n+5); w = 0x453;
assert(n[0] == char(0xEF)); r = c.out(m, &w, &w + 1, wp, n, n + 7, np);
assert(n[1] == char(0xBB)); assert(r == std::codecvt_base::ok);
assert(n[2] == char(0xBF)); assert(wp == &w + 1);
assert(n[3] == char(0xD1)); assert(np == n + 5);
assert(n[4] == char(0x93)); assert(n[0] == char(0xEF));
assert(n[5] == char(0x85)); assert(n[1] == char(0xBB));
assert(n[6] == char(0x83)); assert(n[2] == char(0xBF));
assert(n[3] == char(0xD1));
w = 0x56; assert(n[4] == char(0x93));
r = c.out(m, &w, &w+1, wp, n, n+7, np); assert(n[5] == char(0x85));
assert(r == std::codecvt_base::ok); assert(n[6] == char(0x83));
assert(wp == &w+1);
assert(np == n+4); w = 0x56;
assert(n[0] == char(0xEF)); r = c.out(m, &w, &w + 1, wp, n, n + 7, np);
assert(n[1] == char(0xBB)); assert(r == std::codecvt_base::ok);
assert(n[2] == char(0xBF)); assert(wp == &w + 1);
assert(n[3] == char(0x56)); assert(np == n + 4);
assert(n[4] == char(0x93)); assert(n[0] == char(0xEF));
assert(n[5] == char(0x85)); assert(n[1] == char(0xBB));
assert(n[6] == char(0x83)); assert(n[2] == char(0xBF));
} assert(n[3] == char(0x56));
{ assert(n[4] == char(0x93));
typedef std::codecvt_utf8<char16_t> C; assert(n[5] == char(0x85));
C c; assert(n[6] == char(0x83));
char16_t w = 0x1005; }
char n[4] = {0}; }
const char16_t* wp = nullptr;
std::mbstate_t m; int main() {
char* np = nullptr; TestHelper<wchar_t>::test();
std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+4, np); TestHelper<char32_t>::test();
assert(r == std::codecvt_base::ok); TestHelper<char16_t>::test();
assert(wp == &w+1);
assert(np == n+3);
assert(n[0] == char(0xE1));
assert(n[1] == char(0x80));
assert(n[2] == char(0x85));
assert(n[3] == char(0));
w = 0x453;
r = c.out(m, &w, &w+1, wp, n, n+4, np);
assert(r == std::codecvt_base::ok);
assert(wp == &w+1);
assert(np == n+2);
assert(n[0] == char(0xD1));
assert(n[1] == char(0x93));
assert(n[2] == char(0x85));
assert(n[3] == char(0));
w = 0x56;
r = c.out(m, &w, &w+1, wp, n, n+4, np);
assert(r == std::codecvt_base::ok);
assert(wp == &w+1);
assert(np == n+1);
assert(n[0] == char(0x56));
assert(n[1] == char(0x93));
assert(n[2] == char(0x85));
assert(n[3] == char(0));
}
{
typedef std::codecvt_utf8<char16_t, 0x1000> C;
C c;
char16_t w = 0x1005;
char n[4] = {0};
const char16_t* wp = nullptr;
std::mbstate_t m;
char* np = nullptr;
std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+4, np);
assert(r == std::codecvt_base::error);
assert(wp == &w);
assert(np == n);
assert(n[0] == char(0));
assert(n[1] == char(0));
assert(n[2] == char(0));
assert(n[3] == char(0));
w = 0x453;
r = c.out(m, &w, &w+1, wp, n, n+4, np);
assert(r == std::codecvt_base::ok);
assert(wp == &w+1);
assert(np == n+2);
assert(n[0] == char(0xD1));
assert(n[1] == char(0x93));
assert(n[2] == char(0));
assert(n[3] == char(0));
w = 0x56;
r = c.out(m, &w, &w+1, wp, n, n+4, np);
assert(r == std::codecvt_base::ok);
assert(wp == &w+1);
assert(np == n+1);
assert(n[0] == char(0x56));
assert(n[1] == char(0x93));
assert(n[2] == char(0));
assert(n[3] == char(0));
}
{
typedef std::codecvt_utf8<char16_t, 0xFFFFFFFF, std::generate_header> C;
C c;
char16_t w = 0x1005;
char n[7] = {0};
const char16_t* wp = nullptr;
std::mbstate_t m;
char* np = nullptr;
std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+7, np);
assert(r == std::codecvt_base::ok);
assert(wp == &w+1);
assert(np == n+6);
assert(n[0] == char(0xEF));
assert(n[1] == char(0xBB));
assert(n[2] == char(0xBF));
assert(n[3] == char(0xE1));
assert(n[4] == char(0x80));
assert(n[5] == char(0x85));
assert(n[6] == char(0));
w = 0x453;
r = c.out(m, &w, &w+1, wp, n, n+7, np);
assert(r == std::codecvt_base::ok);
assert(wp == &w+1);
assert(np == n+5);
assert(n[0] == char(0xEF));
assert(n[1] == char(0xBB));
assert(n[2] == char(0xBF));
assert(n[3] == char(0xD1));
assert(n[4] == char(0x93));
assert(n[5] == char(0x85));
assert(n[6] == char(0));
w = 0x56;
r = c.out(m, &w, &w+1, wp, n, n+7, np);
assert(r == std::codecvt_base::ok);
assert(wp == &w+1);
assert(np == n+4);
assert(n[0] == char(0xEF));
assert(n[1] == char(0xBB));
assert(n[2] == char(0xBF));
assert(n[3] == char(0x56));
assert(n[4] == char(0x93));
assert(n[5] == char(0x85));
assert(n[6] == char(0));
}
} }

546
test/std/localization/locale.stdcvt/codecvt_utf8_utf16_in.pass.cpp
View File

@@ -25,348 +25,220 @@
#include <codecvt> #include <codecvt>
#include <cassert> #include <cassert>
int main() template <class CharT, size_t = sizeof(CharT)>
{ struct TestHelper;
{ template <class CharT>
typedef std::codecvt_utf8_utf16<wchar_t> C; struct TestHelper<CharT, 2> {
C c; static void test();
wchar_t w[2] = {0}; };
char n[4] = {char(0xF1), char(0x80), char(0x80), char(0x83)}; template <class CharT>
wchar_t* wp = nullptr; struct TestHelper<CharT, 4> {
std::mbstate_t m; static void test();
const char* np = nullptr; };
std::codecvt_base::result r = c.in(m, n, n+4, np, w, w+2, wp);
assert(r == std::codecvt_base::ok);
assert(wp == w+2);
assert(np == n+4);
assert(w[0] == 0xD8C0);
assert(w[1] == 0xDC03);
n[0] = char(0xE1); template <class CharT>
n[1] = char(0x80); void TestHelper<CharT, 2>::test() {
n[2] = char(0x85); {
r = c.in(m, n, n+3, np, w, w+2, wp); typedef std::codecvt_utf8_utf16<CharT, 0x1000> C;
assert(r == std::codecvt_base::ok); C c;
assert(wp == w+1); CharT w[2] = {0};
assert(np == n+3); char n[4] = {char(0xF1), char(0x80), char(0x80), char(0x83)};
assert(w[0] == 0x1005); CharT* wp = nullptr;
std::mbstate_t m;
const char* np = nullptr;
std::codecvt_base::result r = c.in(m, n, n + 4, np, w, w + 2, wp);
assert(r == std::codecvt_base::error);
assert(wp == w);
assert(np == n);
n[0] = char(0xD1); n[0] = char(0xE1);
n[1] = char(0x93); n[1] = char(0x80);
r = c.in(m, n, n+2, np, w, w+2, wp); n[2] = char(0x85);
assert(r == std::codecvt_base::ok); r = c.in(m, n, n + 3, np, w, w + 2, wp);
assert(wp == w+1); assert(r == std::codecvt_base::error);
assert(np == n+2); assert(wp == w);
assert(w[0] == 0x0453); assert(np == n);
n[0] = char(0x56); n[0] = char(0xD1);
r = c.in(m, n, n+1, np, w, w+2, wp); n[1] = char(0x93);
assert(r == std::codecvt_base::ok); r = c.in(m, n, n + 2, np, w, w + 2, wp);
assert(wp == w+1); assert(r == std::codecvt_base::ok);
assert(np == n+1); assert(wp == w + 1);
assert(w[0] == 0x0056); assert(np == n + 2);
} assert(w[0] == 0x0453);
{
typedef std::codecvt_utf8_utf16<wchar_t, 0x1000> C;
C c;
wchar_t w[2] = {0};
char n[4] = {char(0xF1), char(0x80), char(0x80), char(0x83)};
wchar_t* wp = nullptr;
std::mbstate_t m;
const char* np = nullptr;
std::codecvt_base::result r = c.in(m, n, n+4, np, w, w+2, wp);
assert(r == std::codecvt_base::error);
assert(wp == w);
assert(np == n);
n[0] = char(0xE1); n[0] = char(0x56);
n[1] = char(0x80); r = c.in(m, n, n + 1, np, w, w + 2, wp);
n[2] = char(0x85); assert(r == std::codecvt_base::ok);
r = c.in(m, n, n+3, np, w, w+2, wp); assert(wp == w + 1);
assert(r == std::codecvt_base::error); assert(np == n + 1);
assert(wp == w); assert(w[0] == 0x0056);
assert(np == n); }
{
typedef std::codecvt_utf8_utf16<CharT, 0x10ffff, std::consume_header> C;
C c;
CharT w[2] = {0};
char n[7] = {char(0xEF), char(0xBB), char(0xBF), char(0xF1),
char(0x80), char(0x80), char(0x83)};
CharT* wp = nullptr;
std::mbstate_t m;
const char* np = nullptr;
std::codecvt_base::result r = c.in(m, n, n + 7, np, w, w + 2, wp);
assert(r == std::codecvt_base::ok);
assert(wp == w + 2);
assert(np == n + 7);
assert(w[0] == 0xD8C0);
assert(w[1] == 0xDC03);
n[0] = char(0xD1); n[0] = char(0xE1);
n[1] = char(0x93); n[1] = char(0x80);
r = c.in(m, n, n+2, np, w, w+2, wp); n[2] = char(0x85);
assert(r == std::codecvt_base::ok); r = c.in(m, n, n + 3, np, w, w + 2, wp);
assert(wp == w+1); assert(r == std::codecvt_base::ok);
assert(np == n+2); assert(wp == w + 1);
assert(w[0] == 0x0453); assert(np == n + 3);
assert(w[0] == 0x1005);
n[0] = char(0x56); n[0] = char(0xD1);
r = c.in(m, n, n+1, np, w, w+2, wp); n[1] = char(0x93);
assert(r == std::codecvt_base::ok); r = c.in(m, n, n + 2, np, w, w + 2, wp);
assert(wp == w+1); assert(r == std::codecvt_base::ok);
assert(np == n+1); assert(wp == w + 1);
assert(w[0] == 0x0056); assert(np == n + 2);
} assert(w[0] == 0x0453);
{
typedef std::codecvt_utf8_utf16<wchar_t, 0x10ffff, std::consume_header> C;
C c;
wchar_t w[2] = {0};
char n[7] = {char(0xEF), char(0xBB), char(0xBF), char(0xF1), char(0x80), char(0x80), char(0x83)};
wchar_t* wp = nullptr;
std::mbstate_t m;
const char* np = nullptr;
std::codecvt_base::result r = c.in(m, n, n+7, np, w, w+2, wp);
assert(r == std::codecvt_base::ok);
assert(wp == w+2);
assert(np == n+7);
assert(w[0] == 0xD8C0);
assert(w[1] == 0xDC03);
n[0] = char(0xE1); n[0] = char(0x56);
n[1] = char(0x80); r = c.in(m, n, n + 1, np, w, w + 2, wp);
n[2] = char(0x85); assert(r == std::codecvt_base::ok);
r = c.in(m, n, n+3, np, w, w+2, wp); assert(wp == w + 1);
assert(r == std::codecvt_base::ok); assert(np == n + 1);
assert(wp == w+1); assert(w[0] == 0x0056);
assert(np == n+3); }
assert(w[0] == 0x1005); }
n[0] = char(0xD1); template <class CharT>
n[1] = char(0x93); void TestHelper<CharT, 4>::test() {
r = c.in(m, n, n+2, np, w, w+2, wp); {
assert(r == std::codecvt_base::ok); typedef std::codecvt_utf8_utf16<CharT> C;
assert(wp == w+1); C c;
assert(np == n+2); CharT w[2] = {0};
assert(w[0] == 0x0453); char n[4] = {char(0xF1), char(0x80), char(0x80), char(0x83)};
CharT* wp = nullptr;
n[0] = char(0x56); std::mbstate_t m;
r = c.in(m, n, n+1, np, w, w+2, wp); const char* np = nullptr;
assert(r == std::codecvt_base::ok); std::codecvt_base::result r = c.in(m, n, n + 4, np, w, w + 2, wp);
assert(wp == w+1); assert(r == std::codecvt_base::ok);
assert(np == n+1); assert(wp == w + 2);
assert(w[0] == 0x0056); assert(np == n + 4);
} assert(w[0] == 0xD8C0);
{ assert(w[1] == 0xDC03);
typedef std::codecvt_utf8_utf16<char32_t> C;
C c; n[0] = char(0xE1);
char32_t w[2] = {0}; n[1] = char(0x80);
char n[4] = {char(0xF1), char(0x80), char(0x80), char(0x83)}; n[2] = char(0x85);
char32_t* wp = nullptr; r = c.in(m, n, n + 3, np, w, w + 2, wp);
std::mbstate_t m; assert(r == std::codecvt_base::ok);
const char* np = nullptr; assert(wp == w + 1);
std::codecvt_base::result r = c.in(m, n, n+4, np, w, w+2, wp); assert(np == n + 3);
assert(r == std::codecvt_base::ok); assert(w[0] == 0x1005);
assert(wp == w+2);
assert(np == n+4); n[0] = char(0xD1);
assert(w[0] == 0xD8C0); n[1] = char(0x93);
assert(w[1] == 0xDC03); r = c.in(m, n, n + 2, np, w, w + 2, wp);
assert(r == std::codecvt_base::ok);
n[0] = char(0xE1); assert(wp == w + 1);
n[1] = char(0x80); assert(np == n + 2);
n[2] = char(0x85); assert(w[0] == 0x0453);
r = c.in(m, n, n+3, np, w, w+2, wp);
assert(r == std::codecvt_base::ok); n[0] = char(0x56);
assert(wp == w+1); r = c.in(m, n, n + 1, np, w, w + 2, wp);
assert(np == n+3); assert(r == std::codecvt_base::ok);
assert(w[0] == 0x1005); assert(wp == w + 1);
assert(np == n + 1);
n[0] = char(0xD1); assert(w[0] == 0x0056);
n[1] = char(0x93); }
r = c.in(m, n, n+2, np, w, w+2, wp); {
assert(r == std::codecvt_base::ok); typedef std::codecvt_utf8_utf16<CharT, 0x1000> C;
assert(wp == w+1); C c;
assert(np == n+2); CharT w[2] = {0};
assert(w[0] == 0x0453); char n[4] = {char(0xF1), char(0x80), char(0x80), char(0x83)};
CharT* wp = nullptr;
n[0] = char(0x56); std::mbstate_t m;
r = c.in(m, n, n+1, np, w, w+2, wp); const char* np = nullptr;
assert(r == std::codecvt_base::ok); std::codecvt_base::result r = c.in(m, n, n + 4, np, w, w + 2, wp);
assert(wp == w+1); assert(r == std::codecvt_base::error);
assert(np == n+1); assert(wp == w);
assert(w[0] == 0x0056); assert(np == n);
}
{ n[0] = char(0xE1);
typedef std::codecvt_utf8_utf16<char32_t, 0x1000> C; n[1] = char(0x80);
C c; n[2] = char(0x85);
char32_t w[2] = {0}; r = c.in(m, n, n + 3, np, w, w + 2, wp);
char n[4] = {char(0xF1), char(0x80), char(0x80), char(0x83)}; assert(r == std::codecvt_base::error);
char32_t* wp = nullptr; assert(wp == w);
std::mbstate_t m; assert(np == n);
const char* np = nullptr;
std::codecvt_base::result r = c.in(m, n, n+4, np, w, w+2, wp); n[0] = char(0xD1);
assert(r == std::codecvt_base::error); n[1] = char(0x93);
assert(wp == w); r = c.in(m, n, n + 2, np, w, w + 2, wp);
assert(np == n); assert(r == std::codecvt_base::ok);
assert(wp == w + 1);
n[0] = char(0xE1); assert(np == n + 2);
n[1] = char(0x80); assert(w[0] == 0x0453);
n[2] = char(0x85);
r = c.in(m, n, n+3, np, w, w+2, wp); n[0] = char(0x56);
assert(r == std::codecvt_base::error); r = c.in(m, n, n + 1, np, w, w + 2, wp);
assert(wp == w); assert(r == std::codecvt_base::ok);
assert(np == n); assert(wp == w + 1);
assert(np == n + 1);
n[0] = char(0xD1); assert(w[0] == 0x0056);
n[1] = char(0x93); }
r = c.in(m, n, n+2, np, w, w+2, wp); {
assert(r == std::codecvt_base::ok); typedef std::codecvt_utf8_utf16<CharT, 0x10ffff, std::consume_header> C;
assert(wp == w+1); C c;
assert(np == n+2); CharT w[2] = {0};
assert(w[0] == 0x0453); char n[7] = {char(0xEF), char(0xBB), char(0xBF), char(0xF1),
char(0x80), char(0x80), char(0x83)};
n[0] = char(0x56); CharT* wp = nullptr;
r = c.in(m, n, n+1, np, w, w+2, wp); std::mbstate_t m;
assert(r == std::codecvt_base::ok); const char* np = nullptr;
assert(wp == w+1); std::codecvt_base::result r = c.in(m, n, n + 7, np, w, w + 2, wp);
assert(np == n+1); assert(r == std::codecvt_base::ok);
assert(w[0] == 0x0056); assert(wp == w + 2);
} assert(np == n + 7);
{ assert(w[0] == 0xD8C0);
typedef std::codecvt_utf8_utf16<char32_t, 0x10ffff, std::consume_header> C; assert(w[1] == 0xDC03);
C c;
char32_t w[2] = {0}; n[0] = char(0xE1);
char n[7] = {char(0xEF), char(0xBB), char(0xBF), char(0xF1), char(0x80), char(0x80), char(0x83)}; n[1] = char(0x80);
char32_t* wp = nullptr; n[2] = char(0x85);
std::mbstate_t m; r = c.in(m, n, n + 3, np, w, w + 2, wp);
const char* np = nullptr; assert(r == std::codecvt_base::ok);
std::codecvt_base::result r = c.in(m, n, n+7, np, w, w+2, wp); assert(wp == w + 1);
assert(r == std::codecvt_base::ok); assert(np == n + 3);
assert(wp == w+2); assert(w[0] == 0x1005);
assert(np == n+7);
assert(w[0] == 0xD8C0); n[0] = char(0xD1);
assert(w[1] == 0xDC03); n[1] = char(0x93);
r = c.in(m, n, n + 2, np, w, w + 2, wp);
n[0] = char(0xE1); assert(r == std::codecvt_base::ok);
n[1] = char(0x80); assert(wp == w + 1);
n[2] = char(0x85); assert(np == n + 2);
r = c.in(m, n, n+3, np, w, w+2, wp); assert(w[0] == 0x0453);
assert(r == std::codecvt_base::ok);
assert(wp == w+1); n[0] = char(0x56);
assert(np == n+3); r = c.in(m, n, n + 1, np, w, w + 2, wp);
assert(w[0] == 0x1005); assert(r == std::codecvt_base::ok);
assert(wp == w + 1);
n[0] = char(0xD1); assert(np == n + 1);
n[1] = char(0x93); assert(w[0] == 0x0056);
r = c.in(m, n, n+2, np, w, w+2, wp); }
assert(r == std::codecvt_base::ok); }
assert(wp == w+1);
assert(np == n+2); int main() {
assert(w[0] == 0x0453); #ifndef _WIN32
TestHelper<wchar_t>::test();
n[0] = char(0x56); #endif
r = c.in(m, n, n+1, np, w, w+2, wp); TestHelper<char32_t>::test();
assert(r == std::codecvt_base::ok); TestHelper<char16_t>::test();
assert(wp == w+1);
assert(np == n+1);
assert(w[0] == 0x0056);
}
{
typedef std::codecvt_utf8_utf16<char16_t> C;
C c;
char16_t w[2] = {0};
char n[4] = {char(0xF1), char(0x80), char(0x80), char(0x83)};
char16_t* wp = nullptr;
std::mbstate_t m;
const char* np = nullptr;
std::codecvt_base::result r = c.in(m, n, n+4, np, w, w+2, wp);
assert(r == std::codecvt_base::ok);
assert(wp == w+2);
assert(np == n+4);
assert(w[0] == 0xD8C0);
assert(w[1] == 0xDC03);
n[0] = char(0xE1);
n[1] = char(0x80);
n[2] = char(0x85);
r = c.in(m, n, n+3, np, w, w+2, wp);
assert(r == std::codecvt_base::ok);
assert(wp == w+1);
assert(np == n+3);
assert(w[0] == 0x1005);
n[0] = char(0xD1);
n[1] = char(0x93);
r = c.in(m, n, n+2, np, w, w+2, wp);
assert(r == std::codecvt_base::ok);
assert(wp == w+1);
assert(np == n+2);
assert(w[0] == 0x0453);
n[0] = char(0x56);
r = c.in(m, n, n+1, np, w, w+2, wp);
assert(r == std::codecvt_base::ok);
assert(wp == w+1);
assert(np == n+1);
assert(w[0] == 0x0056);
}
{
typedef std::codecvt_utf8_utf16<char16_t, 0x1000> C;
C c;
char16_t w[2] = {0};
char n[4] = {char(0xF1), char(0x80), char(0x80), char(0x83)};
char16_t* wp = nullptr;
std::mbstate_t m;
const char* np = nullptr;
std::codecvt_base::result r = c.in(m, n, n+4, np, w, w+2, wp);
assert(r == std::codecvt_base::error);
assert(wp == w);
assert(np == n);
n[0] = char(0xE1);
n[1] = char(0x80);
n[2] = char(0x85);
r = c.in(m, n, n+3, np, w, w+2, wp);
assert(r == std::codecvt_base::error);
assert(wp == w);
assert(np == n);
n[0] = char(0xD1);
n[1] = char(0x93);
r = c.in(m, n, n+2, np, w, w+2, wp);
assert(r == std::codecvt_base::ok);
assert(wp == w+1);
assert(np == n+2);
assert(w[0] == 0x0453);
n[0] = char(0x56);
r = c.in(m, n, n+1, np, w, w+2, wp);
assert(r == std::codecvt_base::ok);
assert(wp == w+1);
assert(np == n+1);
assert(w[0] == 0x0056);
}
{
typedef std::codecvt_utf8_utf16<char16_t, 0x10ffff, std::consume_header> C;
C c;
char16_t w[2] = {0};
char n[7] = {char(0xEF), char(0xBB), char(0xBF), char(0xF1), char(0x80), char(0x80), char(0x83)};
char16_t* wp = nullptr;
std::mbstate_t m;
const char* np = nullptr;
std::codecvt_base::result r = c.in(m, n, n+7, np, w, w+2, wp);
assert(r == std::codecvt_base::ok);
assert(wp == w+2);
assert(np == n+7);
assert(w[0] == 0xD8C0);
assert(w[1] == 0xDC03);
n[0] = char(0xE1);
n[1] = char(0x80);
n[2] = char(0x85);
r = c.in(m, n, n+3, np, w, w+2, wp);
assert(r == std::codecvt_base::ok);
assert(wp == w+1);
assert(np == n+3);
assert(w[0] == 0x1005);
n[0] = char(0xD1);
n[1] = char(0x93);
r = c.in(m, n, n+2, np, w, w+2, wp);
assert(r == std::codecvt_base::ok);
assert(wp == w+1);
assert(np == n+2);
assert(w[0] == 0x0453);
n[0] = char(0x56);
r = c.in(m, n, n+1, np, w, w+2, wp);
assert(r == std::codecvt_base::ok);
assert(wp == w+1);
assert(np == n+1);
assert(w[0] == 0x0056);
}
} }

648
test/std/localization/locale.stdcvt/codecvt_utf8_utf16_out.pass.cpp
View File

@@ -25,391 +25,285 @@
#include <codecvt> #include <codecvt>
#include <cassert> #include <cassert>
int main() template <class CharT, size_t = sizeof(CharT)>
{ struct TestHelper;
{ template <class CharT>
typedef std::codecvt_utf8_utf16<wchar_t> C; struct TestHelper<CharT, 2> {
C c; static void test();
wchar_t w[2] = {0xD8C0, 0xDC03}; };
char n[4] = {0}; template <class CharT>
const wchar_t* wp = nullptr; struct TestHelper<CharT, 4> {
std::mbstate_t m; static void test();
char* np = nullptr; };
std::codecvt_base::result r = c.out(m, w, w+2, wp, n, n+4, np);
assert(r == std::codecvt_base::ok);
assert(wp == w+2);
assert(np == n+4);
assert(n[0] == char(0xF1));
assert(n[1] == char(0x80));
assert(n[2] == char(0x80));
assert(n[3] == char(0x83));
w[0] = 0x1005; template <class CharT>
r = c.out(m, w, w+1, wp, n, n+4, np); void TestHelper<CharT, 2>::test() {
assert(r == std::codecvt_base::ok); {
assert(wp == w+1); typedef std::codecvt_utf8_utf16<CharT> C;
assert(np == n+3); C c;
assert(n[0] == char(0xE1)); CharT w[2] = {0xD8C0, 0xDC03};
assert(n[1] == char(0x80)); char n[4] = {0};
assert(n[2] == char(0x85)); const CharT* wp = nullptr;
std::mbstate_t m;
char* np = nullptr;
std::codecvt_base::result r = c.out(m, w, w + 2, wp, n, n + 4, np);
assert(r == std::codecvt_base::ok);
assert(wp == w + 2);
assert(np == n + 4);
assert(n[0] == char(0xF1));
assert(n[1] == char(0x80));
assert(n[2] == char(0x80));
assert(n[3] == char(0x83));
w[0] = 0x453; w[0] = 0x1005;
r = c.out(m, w, w+1, wp, n, n+4, np); r = c.out(m, w, w + 1, wp, n, n + 4, np);
assert(r == std::codecvt_base::ok); assert(r == std::codecvt_base::ok);
assert(wp == w+1); assert(wp == w + 1);
assert(np == n+2); assert(np == n + 3);
assert(n[0] == char(0xD1)); assert(n[0] == char(0xE1));
assert(n[1] == char(0x93)); assert(n[1] == char(0x80));
assert(n[2] == char(0x85));
w[0] = 0x56; w[0] = 0x453;
r = c.out(m, w, w+1, wp, n, n+4, np); r = c.out(m, w, w + 1, wp, n, n + 4, np);
assert(r == std::codecvt_base::ok); assert(r == std::codecvt_base::ok);
assert(wp == w+1); assert(wp == w + 1);
assert(np == n+1); assert(np == n + 2);
assert(n[0] == char(0x56)); assert(n[0] == char(0xD1));
} assert(n[1] == char(0x93));
{
typedef std::codecvt_utf8_utf16<wchar_t, 0x1000> C;
C c;
wchar_t w[2] = {0xD8C0, 0xDC03};
char n[4] = {0};
const wchar_t* wp = nullptr;
std::mbstate_t m;
char* np = nullptr;
std::codecvt_base::result r = c.out(m, w, w+2, wp, n, n+4, np);
assert(r == std::codecvt_base::error);
assert(wp == w);
assert(np == n);
w[0] = 0x1005; w[0] = 0x56;
r = c.out(m, w, w+1, wp, n, n+4, np); r = c.out(m, w, w + 1, wp, n, n + 4, np);
assert(r == std::codecvt_base::error); assert(r == std::codecvt_base::ok);
assert(wp == w); assert(wp == w + 1);
assert(np == n); assert(np == n + 1);
assert(n[0] == char(0x56));
}
{
typedef std::codecvt_utf8_utf16<CharT, 0x1000> C;
C c;
CharT w[2] = {0xD8C0, 0xDC03};
char n[4] = {0};
const CharT* wp = nullptr;
std::mbstate_t m;
char* np = nullptr;
std::codecvt_base::result r = c.out(m, w, w + 2, wp, n, n + 4, np);
assert(r == std::codecvt_base::error);
assert(wp == w);
assert(np == n);
w[0] = 0x453; w[0] = 0x1005;
r = c.out(m, w, w+1, wp, n, n+4, np); r = c.out(m, w, w + 1, wp, n, n + 4, np);
assert(r == std::codecvt_base::ok); assert(r == std::codecvt_base::error);
assert(wp == w+1); assert(wp == w);
assert(np == n+2); assert(np == n);
assert(n[0] == char(0xD1));
assert(n[1] == char(0x93));
w[0] = 0x56; w[0] = 0x453;
r = c.out(m, w, w+1, wp, n, n+4, np); r = c.out(m, w, w + 1, wp, n, n + 4, np);
assert(r == std::codecvt_base::ok); assert(r == std::codecvt_base::ok);
assert(wp == w+1); assert(wp == w + 1);
assert(np == n+1); assert(np == n + 2);
assert(n[0] == char(0x56)); assert(n[0] == char(0xD1));
} assert(n[1] == char(0x93));
{
typedef std::codecvt_utf8_utf16<wchar_t, 0x10ffff, std::generate_header> C;
C c;
wchar_t w[2] = {0xD8C0, 0xDC03};
char n[7] = {0};
const wchar_t* wp = nullptr;
std::mbstate_t m;
char* np = nullptr;
std::codecvt_base::result r = c.out(m, w, w+2, wp, n, n+7, np);
assert(r == std::codecvt_base::ok);
assert(wp == w+2);
assert(np == n+7);
assert(n[0] == char(0xEF));
assert(n[1] == char(0xBB));
assert(n[2] == char(0xBF));
assert(n[3] == char(0xF1));
assert(n[4] == char(0x80));
assert(n[5] == char(0x80));
assert(n[6] == char(0x83));
w[0] = 0x1005; w[0] = 0x56;
r = c.out(m, w, w+1, wp, n, n+7, np); r = c.out(m, w, w + 1, wp, n, n + 4, np);
assert(r == std::codecvt_base::ok); assert(r == std::codecvt_base::ok);
assert(wp == w+1); assert(wp == w + 1);
assert(np == n+6); assert(np == n + 1);
assert(n[0] == char(0xEF)); assert(n[0] == char(0x56));
assert(n[1] == char(0xBB)); }
assert(n[2] == char(0xBF)); {
assert(n[3] == char(0xE1)); typedef std::codecvt_utf8_utf16<CharT, 0x10ffff, std::generate_header> C;
assert(n[4] == char(0x80)); C c;
assert(n[5] == char(0x85)); CharT w[2] = {0xD8C0, 0xDC03};
char n[7] = {0};
const CharT* wp = nullptr;
std::mbstate_t m;
char* np = nullptr;
std::codecvt_base::result r = c.out(m, w, w + 2, wp, n, n + 7, np);
assert(r == std::codecvt_base::ok);
assert(wp == w + 2);
assert(np == n + 7);
assert(n[0] == char(0xEF));
assert(n[1] == char(0xBB));
assert(n[2] == char(0xBF));
assert(n[3] == char(0xF1));
assert(n[4] == char(0x80));
assert(n[5] == char(0x80));
assert(n[6] == char(0x83));
w[0] = 0x453; w[0] = 0x1005;
r = c.out(m, w, w+1, wp, n, n+7, np); r = c.out(m, w, w + 1, wp, n, n + 7, np);
assert(r == std::codecvt_base::ok); assert(r == std::codecvt_base::ok);
assert(wp == w+1); assert(wp == w + 1);
assert(np == n+5); assert(np == n + 6);
assert(n[0] == char(0xEF)); assert(n[0] == char(0xEF));
assert(n[1] == char(0xBB)); assert(n[1] == char(0xBB));
assert(n[2] == char(0xBF)); assert(n[2] == char(0xBF));
assert(n[3] == char(0xD1)); assert(n[3] == char(0xE1));
assert(n[4] == char(0x93)); assert(n[4] == char(0x80));
assert(n[5] == char(0x85));
w[0] = 0x56; w[0] = 0x453;
r = c.out(m, w, w+1, wp, n, n+7, np); r = c.out(m, w, w + 1, wp, n, n + 7, np);
assert(r == std::codecvt_base::ok); assert(r == std::codecvt_base::ok);
assert(wp == w+1); assert(wp == w + 1);
assert(np == n+4); assert(np == n + 5);
assert(n[0] == char(0xEF)); assert(n[0] == char(0xEF));
assert(n[1] == char(0xBB)); assert(n[1] == char(0xBB));
assert(n[2] == char(0xBF)); assert(n[2] == char(0xBF));
assert(n[3] == char(0x56)); assert(n[3] == char(0xD1));
} assert(n[4] == char(0x93));
{
typedef std::codecvt_utf8_utf16<char32_t> C;
C c;
char32_t w[2] = {0xD8C0, 0xDC03};
char n[4] = {0};
const char32_t* wp = nullptr;
std::mbstate_t m;
char* np = nullptr;
std::codecvt_base::result r = c.out(m, w, w+2, wp, n, n+4, np);
assert(r == std::codecvt_base::ok);
assert(wp == w+2);
assert(np == n+4);
assert(n[0] == char(0xF1));
assert(n[1] == char(0x80));
assert(n[2] == char(0x80));
assert(n[3] == char(0x83));
w[0] = 0x1005; w[0] = 0x56;
r = c.out(m, w, w+1, wp, n, n+4, np); r = c.out(m, w, w + 1, wp, n, n + 7, np);
assert(r == std::codecvt_base::ok); assert(r == std::codecvt_base::ok);
assert(wp == w+1); assert(wp == w + 1);
assert(np == n+3); assert(np == n + 4);
assert(n[0] == char(0xE1)); assert(n[0] == char(0xEF));
assert(n[1] == char(0x80)); assert(n[1] == char(0xBB));
assert(n[2] == char(0x85)); assert(n[2] == char(0xBF));
assert(n[3] == char(0x56));
w[0] = 0x453; }
r = c.out(m, w, w+1, wp, n, n+4, np); }
assert(r == std::codecvt_base::ok);
assert(wp == w+1); template <class CharT>
assert(np == n+2); void TestHelper<CharT, 4>::test() {
assert(n[0] == char(0xD1)); {
assert(n[1] == char(0x93)); typedef std::codecvt_utf8_utf16<CharT> C;
C c;
w[0] = 0x56; CharT w[2] = {0xD8C0, 0xDC03};
r = c.out(m, w, w+1, wp, n, n+4, np); char n[4] = {0};
assert(r == std::codecvt_base::ok); const CharT* wp = nullptr;
assert(wp == w+1); std::mbstate_t m;
assert(np == n+1); char* np = nullptr;
assert(n[0] == char(0x56)); std::codecvt_base::result r = c.out(m, w, w + 2, wp, n, n + 4, np);
} assert(r == std::codecvt_base::ok);
{ assert(wp == w + 2);
typedef std::codecvt_utf8_utf16<char32_t, 0x1000> C; assert(np == n + 4);
C c; assert(n[0] == char(0xF1));
char32_t w[2] = {0xD8C0, 0xDC03}; assert(n[1] == char(0x80));
char n[4] = {0}; assert(n[2] == char(0x80));
const char32_t* wp = nullptr; assert(n[3] == char(0x83));
std::mbstate_t m;
char* np = nullptr; w[0] = 0x1005;
std::codecvt_base::result r = c.out(m, w, w+2, wp, n, n+4, np); r = c.out(m, w, w + 1, wp, n, n + 4, np);
assert(r == std::codecvt_base::error); assert(r == std::codecvt_base::ok);
assert(wp == w); assert(wp == w + 1);
assert(np == n); assert(np == n + 3);
assert(n[0] == char(0xE1));
w[0] = 0x1005; assert(n[1] == char(0x80));
r = c.out(m, w, w+1, wp, n, n+4, np); assert(n[2] == char(0x85));
assert(r == std::codecvt_base::error);
assert(wp == w); w[0] = 0x453;
assert(np == n); r = c.out(m, w, w + 1, wp, n, n + 4, np);
assert(r == std::codecvt_base::ok);
w[0] = 0x453; assert(wp == w + 1);
r = c.out(m, w, w+1, wp, n, n+4, np); assert(np == n + 2);
assert(r == std::codecvt_base::ok); assert(n[0] == char(0xD1));
assert(wp == w+1); assert(n[1] == char(0x93));
assert(np == n+2);
assert(n[0] == char(0xD1)); w[0] = 0x56;
assert(n[1] == char(0x93)); r = c.out(m, w, w + 1, wp, n, n + 4, np);
assert(r == std::codecvt_base::ok);
w[0] = 0x56; assert(wp == w + 1);
r = c.out(m, w, w+1, wp, n, n+4, np); assert(np == n + 1);
assert(r == std::codecvt_base::ok); assert(n[0] == char(0x56));
assert(wp == w+1); }
assert(np == n+1); {
assert(n[0] == char(0x56)); typedef std::codecvt_utf8_utf16<CharT, 0x1000> C;
} C c;
{ CharT w[2] = {0xD8C0, 0xDC03};
typedef std::codecvt_utf8_utf16<char32_t, 0x10ffff, std::generate_header> C; char n[4] = {0};
C c; const CharT* wp = nullptr;
char32_t w[2] = {0xD8C0, 0xDC03}; std::mbstate_t m;
char n[7] = {0}; char* np = nullptr;
const char32_t* wp = nullptr; std::codecvt_base::result r = c.out(m, w, w + 2, wp, n, n + 4, np);
std::mbstate_t m; assert(r == std::codecvt_base::error);
char* np = nullptr; assert(wp == w);
std::codecvt_base::result r = c.out(m, w, w+2, wp, n, n+7, np); assert(np == n);
assert(r == std::codecvt_base::ok);
assert(wp == w+2); w[0] = 0x1005;
assert(np == n+7); r = c.out(m, w, w + 1, wp, n, n + 4, np);
assert(n[0] == char(0xEF)); assert(r == std::codecvt_base::error);
assert(n[1] == char(0xBB)); assert(wp == w);
assert(n[2] == char(0xBF)); assert(np == n);
assert(n[3] == char(0xF1));
assert(n[4] == char(0x80)); w[0] = 0x453;
assert(n[5] == char(0x80)); r = c.out(m, w, w + 1, wp, n, n + 4, np);
assert(n[6] == char(0x83)); assert(r == std::codecvt_base::ok);
assert(wp == w + 1);
w[0] = 0x1005; assert(np == n + 2);
r = c.out(m, w, w+1, wp, n, n+7, np); assert(n[0] == char(0xD1));
assert(r == std::codecvt_base::ok); assert(n[1] == char(0x93));
assert(wp == w+1);
assert(np == n+6); w[0] = 0x56;
assert(n[0] == char(0xEF)); r = c.out(m, w, w + 1, wp, n, n + 4, np);
assert(n[1] == char(0xBB)); assert(r == std::codecvt_base::ok);
assert(n[2] == char(0xBF)); assert(wp == w + 1);
assert(n[3] == char(0xE1)); assert(np == n + 1);
assert(n[4] == char(0x80)); assert(n[0] == char(0x56));
assert(n[5] == char(0x85)); }
{
w[0] = 0x453; typedef std::codecvt_utf8_utf16<CharT, 0x10ffff, std::generate_header> C;
r = c.out(m, w, w+1, wp, n, n+7, np); C c;
assert(r == std::codecvt_base::ok); CharT w[2] = {0xD8C0, 0xDC03};
assert(wp == w+1); char n[7] = {0};
assert(np == n+5); const CharT* wp = nullptr;
assert(n[0] == char(0xEF)); std::mbstate_t m;
assert(n[1] == char(0xBB)); char* np = nullptr;
assert(n[2] == char(0xBF)); std::codecvt_base::result r = c.out(m, w, w + 2, wp, n, n + 7, np);
assert(n[3] == char(0xD1)); assert(r == std::codecvt_base::ok);
assert(n[4] == char(0x93)); assert(wp == w + 2);
assert(np == n + 7);
w[0] = 0x56; assert(n[0] == char(0xEF));
r = c.out(m, w, w+1, wp, n, n+7, np); assert(n[1] == char(0xBB));
assert(r == std::codecvt_base::ok); assert(n[2] == char(0xBF));
assert(wp == w+1); assert(n[3] == char(0xF1));
assert(np == n+4); assert(n[4] == char(0x80));
assert(n[0] == char(0xEF)); assert(n[5] == char(0x80));
assert(n[1] == char(0xBB)); assert(n[6] == char(0x83));
assert(n[2] == char(0xBF));
assert(n[3] == char(0x56)); w[0] = 0x1005;
} r = c.out(m, w, w + 1, wp, n, n + 7, np);
assert(r == std::codecvt_base::ok);
{ assert(wp == w + 1);
typedef std::codecvt_utf8_utf16<char16_t> C; assert(np == n + 6);
C c; assert(n[0] == char(0xEF));
char16_t w[2] = {0xD8C0, 0xDC03}; assert(n[1] == char(0xBB));
char n[4] = {0}; assert(n[2] == char(0xBF));
const char16_t* wp = nullptr; assert(n[3] == char(0xE1));
std::mbstate_t m; assert(n[4] == char(0x80));
char* np = nullptr; assert(n[5] == char(0x85));
std::codecvt_base::result r = c.out(m, w, w+2, wp, n, n+4, np);
assert(r == std::codecvt_base::ok); w[0] = 0x453;
assert(wp == w+2); r = c.out(m, w, w + 1, wp, n, n + 7, np);
assert(np == n+4); assert(r == std::codecvt_base::ok);
assert(n[0] == char(0xF1)); assert(wp == w + 1);
assert(n[1] == char(0x80)); assert(np == n + 5);
assert(n[2] == char(0x80)); assert(n[0] == char(0xEF));
assert(n[3] == char(0x83)); assert(n[1] == char(0xBB));
assert(n[2] == char(0xBF));
w[0] = 0x1005; assert(n[3] == char(0xD1));
r = c.out(m, w, w+1, wp, n, n+4, np); assert(n[4] == char(0x93));
assert(r == std::codecvt_base::ok);
assert(wp == w+1); w[0] = 0x56;
assert(np == n+3); r = c.out(m, w, w + 1, wp, n, n + 7, np);
assert(n[0] == char(0xE1)); assert(r == std::codecvt_base::ok);
assert(n[1] == char(0x80)); assert(wp == w + 1);
assert(n[2] == char(0x85)); assert(np == n + 4);
assert(n[0] == char(0xEF));
w[0] = 0x453; assert(n[1] == char(0xBB));
r = c.out(m, w, w+1, wp, n, n+4, np); assert(n[2] == char(0xBF));
assert(r == std::codecvt_base::ok); assert(n[3] == char(0x56));
assert(wp == w+1); }
assert(np == n+2); }
assert(n[0] == char(0xD1));
assert(n[1] == char(0x93)); int main() {
#ifndef _WIN32
w[0] = 0x56; TestHelper<wchar_t>::test();
r = c.out(m, w, w+1, wp, n, n+4, np); #endif
assert(r == std::codecvt_base::ok); TestHelper<char32_t>::test();
assert(wp == w+1); TestHelper<char16_t>::test();
assert(np == n+1);
assert(n[0] == char(0x56));
}
{
typedef std::codecvt_utf8_utf16<char16_t, 0x1000> C;
C c;
char16_t w[2] = {0xD8C0, 0xDC03};
char n[4] = {0};
const char16_t* wp = nullptr;
std::mbstate_t m;
char* np = nullptr;
std::codecvt_base::result r = c.out(m, w, w+2, wp, n, n+4, np);
assert(r == std::codecvt_base::error);
assert(wp == w);
assert(np == n);
w[0] = 0x1005;
r = c.out(m, w, w+1, wp, n, n+4, np);
assert(r == std::codecvt_base::error);
assert(wp == w);
assert(np == n);
w[0] = 0x453;
r = c.out(m, w, w+1, wp, n, n+4, np);
assert(r == std::codecvt_base::ok);
assert(wp == w+1);
assert(np == n+2);
assert(n[0] == char(0xD1));
assert(n[1] == char(0x93));
w[0] = 0x56;
r = c.out(m, w, w+1, wp, n, n+4, np);
assert(r == std::codecvt_base::ok);
assert(wp == w+1);
assert(np == n+1);
assert(n[0] == char(0x56));
}
{
typedef std::codecvt_utf8_utf16<char16_t, 0x10ffff, std::generate_header> C;
C c;
char16_t w[2] = {0xD8C0, 0xDC03};
char n[7] = {0};
const char16_t* wp = nullptr;
std::mbstate_t m;
char* np = nullptr;
std::codecvt_base::result r = c.out(m, w, w+2, wp, n, n+7, np);
assert(r == std::codecvt_base::ok);
assert(wp == w+2);
assert(np == n+7);
assert(n[0] == char(0xEF));
assert(n[1] == char(0xBB));
assert(n[2] == char(0xBF));
assert(n[3] == char(0xF1));
assert(n[4] == char(0x80));
assert(n[5] == char(0x80));
assert(n[6] == char(0x83));
w[0] = 0x1005;
r = c.out(m, w, w+1, wp, n, n+7, np);
assert(r == std::codecvt_base::ok);
assert(wp == w+1);
assert(np == n+6);
assert(n[0] == char(0xEF));
assert(n[1] == char(0xBB));
assert(n[2] == char(0xBF));
assert(n[3] == char(0xE1));
assert(n[4] == char(0x80));
assert(n[5] == char(0x85));
w[0] = 0x453;
r = c.out(m, w, w+1, wp, n, n+7, np);
assert(r == std::codecvt_base::ok);
assert(wp == w+1);
assert(np == n+5);
assert(n[0] == char(0xEF));
assert(n[1] == char(0xBB));
assert(n[2] == char(0xBF));
assert(n[3] == char(0xD1));
assert(n[4] == char(0x93));
w[0] = 0x56;
r = c.out(m, w, w+1, wp, n, n+7, np);
assert(r == std::codecvt_base::ok);
assert(wp == w+1);
assert(np == n+4);
assert(n[0] == char(0xEF));
assert(n[1] == char(0xBB));
assert(n[2] == char(0xBF));
assert(n[3] == char(0x56));
}
} }

39
test/std/localization/locales/locale.convenience/conversions/conversions.string/converted.pass.cpp
View File

@@ -17,9 +17,39 @@
#include <codecvt> #include <codecvt>
#include <cassert> #include <cassert>
int main() template <class CharT, size_t = sizeof(CharT)>
{ struct TestHelper;
typedef std::codecvt_utf8<wchar_t> Codecvt; template <class CharT>
struct TestHelper<CharT, 2> {
static void test();
};
template <class CharT>
struct TestHelper<CharT, 4> {
static void test();
};
template <class CharT>
void TestHelper<CharT, 2>::test() {
static_assert(std::is_same<CharT, wchar_t>::value, "");
{
typedef std::codecvt_utf8<CharT> Codecvt;
typedef std::wstring_convert<Codecvt> Myconv;
Myconv myconv;
assert(myconv.converted() == 0);
std::string bs = myconv.to_bytes(L"\x1005");
assert(myconv.converted() == 1);
bs = myconv.to_bytes(L"\x1005\x65");
assert(myconv.converted() == 2);
std::wstring ws = myconv.from_bytes("\xE1\x80\x85");
assert(myconv.converted() == 3);
}
}
template <class CharT>
void TestHelper<CharT, 4>::test() {
static_assert(std::is_same<CharT, wchar_t>::value, "");
{
typedef std::codecvt_utf8<CharT> Codecvt;
typedef std::wstring_convert<Codecvt> Myconv; typedef std::wstring_convert<Codecvt> Myconv;
Myconv myconv; Myconv myconv;
assert(myconv.converted() == 0); assert(myconv.converted() == 0);
@@ -29,4 +59,7 @@ int main()
assert(myconv.converted() == 2); assert(myconv.converted() == 2);
std::wstring ws = myconv.from_bytes("\xF1\x80\x80\x83"); std::wstring ws = myconv.from_bytes("\xF1\x80\x80\x83");
assert(myconv.converted() == 4); assert(myconv.converted() == 4);
}
} }
int main() { TestHelper<wchar_t>::test(); }

65
test/std/localization/locales/locale.convenience/conversions/conversions.string/from_bytes.pass.cpp
View File

@@ -20,20 +20,53 @@
#include <codecvt> #include <codecvt>
#include <cassert> #include <cassert>
int main() template <class CharT, size_t = sizeof(CharT)>
{ struct TestHelper;
{ template <class CharT>
std::wstring_convert<std::codecvt_utf8<wchar_t> > myconv; struct TestHelper<CharT, 2> {
std::string bs("\xF1\x80\x80\x83"); static void test();
std::wstring ws = myconv.from_bytes('a'); };
assert(ws == L"a"); template <class CharT>
ws = myconv.from_bytes(bs.c_str()); struct TestHelper<CharT, 4> {
assert(ws == L"\x40003"); static void test();
ws = myconv.from_bytes(bs); };
assert(ws == L"\x40003");
ws = myconv.from_bytes(bs.data(), bs.data() + bs.size()); template <class CharT>
assert(ws == L"\x40003"); void TestHelper<CharT, 2>::test() {
ws = myconv.from_bytes(""); static_assert(std::is_same<CharT, wchar_t>::value, "");
assert(ws.size() == 0); {
} std::wstring_convert<std::codecvt_utf8<CharT> > myconv;
std::string bs("\xE1\x80\x85\x00");
std::wstring ws = myconv.from_bytes('a');
assert(ws == L"a");
ws = myconv.from_bytes(bs.c_str());
assert(ws == L"\x1005");
ws = myconv.from_bytes(bs);
assert(ws == L"\x1005");
ws = myconv.from_bytes(bs.data(), bs.data() + bs.size());
assert(ws == L"\x1005");
ws = myconv.from_bytes("");
assert(ws.size() == 0);
}
} }
template <class CharT>
void TestHelper<CharT, 4>::test() {
static_assert(std::is_same<CharT, wchar_t>::value, "");
{
std::wstring_convert<std::codecvt_utf8<CharT> > myconv;
std::string bs("\xF1\x80\x80\x83");
std::wstring ws = myconv.from_bytes('a');
assert(ws == L"a");
ws = myconv.from_bytes(bs.c_str());
assert(ws == L"\x40003");
ws = myconv.from_bytes(bs);
assert(ws == L"\x40003");
ws = myconv.from_bytes(bs.data(), bs.data() + bs.size());
assert(ws == L"\x40003");
ws = myconv.from_bytes("");
assert(ws.size() == 0);
}
}
int main() { TestHelper<wchar_t>::test(); }

65
test/std/localization/locales/locale.convenience/conversions/conversions.string/to_bytes.pass.cpp
View File

@@ -20,20 +20,53 @@
#include <codecvt> #include <codecvt>
#include <cassert> #include <cassert>
int main() template <class CharT, size_t = sizeof(CharT)>
{ struct TestHelper;
{ template <class CharT>
std::wstring_convert<std::codecvt_utf8<wchar_t> > myconv; struct TestHelper<CharT, 2> {
std::wstring ws(1, L'\x40003'); static void test();
std::string bs = myconv.to_bytes(ws[0]); };
assert(bs == "\xF1\x80\x80\x83"); template <class CharT>
bs = myconv.to_bytes(ws.c_str()); struct TestHelper<CharT, 4> {
assert(bs == "\xF1\x80\x80\x83"); static void test();
bs = myconv.to_bytes(ws); };
assert(bs == "\xF1\x80\x80\x83");
bs = myconv.to_bytes(ws.data(), ws.data() + ws.size()); template <class CharT>
assert(bs == "\xF1\x80\x80\x83"); void TestHelper<CharT, 2>::test() {
bs = myconv.to_bytes(L""); static_assert(std::is_same<CharT, wchar_t>::value, "");
assert(bs.size() == 0); {
} std::wstring_convert<std::codecvt_utf8<CharT> > myconv;
std::wstring ws(1, CharT(0x1005));
std::string bs = myconv.to_bytes(ws[0]);
assert(bs == "\xE1\x80\x85\x00");
bs = myconv.to_bytes(ws.c_str());
assert(bs == "\xE1\x80\x85\x00");
bs = myconv.to_bytes(ws);
assert(bs == "\xE1\x80\x85\x00");
bs = myconv.to_bytes(ws.data(), ws.data() + ws.size());
assert(bs == "\xE1\x80\x85\x00");
bs = myconv.to_bytes(L"");
assert(bs.size() == 0);
}
} }
template <class CharT>
void TestHelper<CharT, 4>::test() {
static_assert(std::is_same<CharT, wchar_t>::value, "");
{
std::wstring_convert<std::codecvt_utf8<CharT> > myconv;
std::wstring ws(1, CharT(0x40003));
std::string bs = myconv.to_bytes(ws[0]);
assert(bs == "\xF1\x80\x80\x83");
bs = myconv.to_bytes(ws.c_str());
assert(bs == "\xF1\x80\x80\x83");
bs = myconv.to_bytes(ws);
assert(bs == "\xF1\x80\x80\x83");
bs = myconv.to_bytes(ws.data(), ws.data() + ws.size());
assert(bs == "\xF1\x80\x80\x83");
bs = myconv.to_bytes(L"");
assert(bs.size() == 0);
}
}
int main() { TestHelper<wchar_t>::test(); }

4
test/std/utilities/meta/meta.rel/is_convertible.pass.cpp
View File

@@ -120,7 +120,9 @@ int main()
static_assert((!std::is_convertible<ConstFunction, Function>::value), ""); static_assert((!std::is_convertible<ConstFunction, Function>::value), "");
static_assert((!std::is_convertible<ConstFunction, Function*>::value), ""); static_assert((!std::is_convertible<ConstFunction, Function*>::value), "");
static_assert((!std::is_convertible<ConstFunction, Function&>::value), ""); static_assert((!std::is_convertible<ConstFunction, Function&>::value), "");
static_assert((!std::is_convertible<ConstFunction, Function>::value), ""); #if TEST_STD_VER >= 11
static_assert((!std::is_convertible<ConstFunction, Function&&>::value), "");
#endif
static_assert((!std::is_convertible<Function*, ConstFunction>::value), ""); static_assert((!std::is_convertible<Function*, ConstFunction>::value), "");
static_assert((!std::is_convertible<Function&, ConstFunction>::value), ""); static_assert((!std::is_convertible<Function&, ConstFunction>::value), "");
static_assert((!std::is_convertible<ConstFunction, ConstFunction>::value), ""); static_assert((!std::is_convertible<ConstFunction, ConstFunction>::value), "");