void test_neg_one() {
const my_facet f(1);
std::ios ios(0);
T v = static_cast<T>(42);
{
const char str[] = "-1";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == T(-1));
}
v = 42;
{
const char str[] = "-";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
assert(v == 0);
}
}
int main()
{
char str[200];
output_iterator<char*> iter;
tm t;
t.tm_sec = 6;
t.tm_min = 3;
t.tm_hour = 13;
t.tm_mday = 2;
t.tm_mon = 4;
t.tm_year = 109;
t.tm_wday = 6;
t.tm_yday = -1;
t.tm_isdst = 1;
std::ios ios(0);
{
const my_facet f(LOCALE_en_US_UTF_8, 1);
std::string pat("Today is %A which is abreviated %a.");
iter = f.put(output_iterator<char*>(str), ios, '*', &t,
pat.data(), pat.data() + pat.size());
std::string ex(str, iter.base());
assert(ex == "Today is Saturday which is abreviated Sat.");
}
{
const my_facet f(LOCALE_fr_FR_UTF_8, 1);
std::string pat("Today is %A which is abreviated %a.");
iter = f.put(output_iterator<char*>(str), ios, '*', &t,
pat.data(), pat.data() + pat.size());
std::string ex(str, iter.base());
assert((ex == "Today is Samedi which is abreviated Sam.")||
(ex == "Today is samedi which is abreviated sam." ));
}
}
int main()
{
const my_facet f(1);
std::ios ios(0);
{
const char str[] = "0x0";
std::ios_base::iostate err = ios.goodbit;
void* p;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, p);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(p == 0);
}
{
const char str[] = "0x73";
std::ios_base::iostate err = ios.goodbit;
void* p;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, p);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(p == (void*)0x73);
}
}
int main()
{
const my_facet f(1);
{
std::ios ios(0);
void* v = 0;
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "0x0");
}
}
int main()
{
std::ios ios(0);
std::ios_base::iostate err;
std::tm t;
{
const my_facet f(LOCALE_en_US_UTF_8, 1);
const char in[] = "06/10/2009";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_date(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_mon == 5);
assert(t.tm_mday == 10);
assert(t.tm_year == 109);
assert(err == std::ios_base::eofbit);
}
{
const my_facet f(LOCALE_fr_FR_UTF_8, 1);
const char in[] = "10.06.2009";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_date(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_mon == 5);
assert(t.tm_mday == 10);
assert(t.tm_year == 109);
assert(err == std::ios_base::eofbit);
}
{
const my_facet f(LOCALE_ru_RU_UTF_8, 1);
const char in[] = "10.06.2009";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_date(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_mon == 5);
assert(t.tm_mday == 10);
assert(t.tm_year == 109);
assert(err == std::ios_base::eofbit);
}
{
const my_facet f(LOCALE_zh_CN_UTF_8, 1);
const char in[] = "2009/06/10";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_date(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_mon == 5);
assert(t.tm_mday == 10);
assert(t.tm_year == 109);
assert(err == std::ios_base::eofbit);
}
}
int main()
{
std::ios ios(0);
std::ios_base::iostate err;
std::tm t;
{
const my_facet f(LOCALE_en_US_UTF_8, 1);
const wchar_t in[] = L"13:14:15";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_time(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_hour == 13);
assert(t.tm_min == 14);
assert(t.tm_sec == 15);
assert(err == std::ios_base::eofbit);
}
{
const my_facet f(LOCALE_fr_FR_UTF_8, 1);
const wchar_t in[] = L"13:14:15";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_time(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_hour == 13);
assert(t.tm_min == 14);
assert(t.tm_sec == 15);
assert(err == std::ios_base::eofbit);
}
{
const my_facet f(LOCALE_ru_RU_UTF_8, 1);
const wchar_t in[] = L"13:14:15";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_time(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_hour == 13);
assert(t.tm_min == 14);
assert(t.tm_sec == 15);
assert(err == std::ios_base::eofbit);
}
{
const my_facet f(LOCALE_zh_CN_UTF_8, 1);
const wchar_t in[] = L"13:14:15";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_time(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_hour == 13);
assert(t.tm_min == 14);
assert(t.tm_sec == 15);
assert(err == std::ios_base::eofbit);
}
}
int main()
{
std::ios ios(0);
std::ios_base::iostate err;
std::tm t;
{
const my_facet f("en_US", 1);
const wchar_t in[] = L"06/10/2009";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_date(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_mon == 5);
assert(t.tm_mday == 10);
assert(t.tm_year == 109);
assert(err == std::ios_base::eofbit);
}
{
const my_facet f("fr_FR", 1);
const wchar_t in[] = L"10.06.2009";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_date(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_mon == 5);
assert(t.tm_mday == 10);
assert(t.tm_year == 109);
assert(err == std::ios_base::eofbit);
}
{
const my_facet f("ru_RU", 1);
const wchar_t in[] = L"10.06.2009";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_date(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_mon == 5);
assert(t.tm_mday == 10);
assert(t.tm_year == 109);
assert(err == std::ios_base::eofbit);
}
{
const my_facet f("zh_CN", 1);
const wchar_t in[] = L"2009/06/10";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_date(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_mon == 5);
assert(t.tm_mday == 10);
assert(t.tm_year == 109);
assert(err == std::ios_base::eofbit);
}
}
int main()
{
const my_facet f(1);
{
std::ios ios(0);
{
bool v = false;
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "0");
}
{
bool v = true;
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "1");
}
}
{
std::ios ios(0);
boolalpha(ios);
{
bool v = false;
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "false");
}
{
bool v = true;
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "true");
}
}
{
std::ios ios(0);
boolalpha(ios);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
{
bool v = false;
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "no");
}
{
bool v = true;
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "yes");
}
}
}
int main(int, char**)
{
const my_facet f(1);
std::ios ios(0);
unsigned long v = static_cast<unsigned long>(-1);
{
const char str[] = "0";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == 0);
}
{
const char str[] = "1";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == 1);
}
hex(ios);
{
const char str[] = "0xFFFFFFFF";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == 0xFFFFFFFF);
}
return 0;
}
int main()
{
const my_facet f(1);
std::ios ios(0);
unsigned short v = -1;
{
const char str[] = "0";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == 0);
}
{
const char str[] = "1";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == 1);
}
hex(ios);
{
const char str[] = "0xFFFF";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == 0xFFFF);
}
}
int main()
{
std::ios ios(0);
std::ios_base::iostate err;
std::tm t;
{
const my_facet f(LOCALE_en_US_UTF_8, 1);
const char in[] = "Monday";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_wday == 1);
assert(err == std::ios_base::eofbit);
}
{
const my_facet f(LOCALE_fr_FR_UTF_8, 1);
const char in[] = "Lundi";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_wday == 1);
assert(err == std::ios_base::eofbit);
}
{
const my_facet f(LOCALE_ru_RU_UTF_8, 1);
const char in[] = "\xD0\xBF\xD0\xBE\xD0\xBD\xD0\xB5"
"\xD0\xB4\xD0\xB5\xD0\xBB\xD1\x8C"
"\xD0\xBD\xD0\xB8\xD0\xBA";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_wday == 1);
assert(err == std::ios_base::eofbit);
}
{
const my_facet f(LOCALE_zh_CN_UTF_8, 1);
const char in[] = "\xE6\x98\x9F\xE6\x9C\x9F\xE4\xB8\x80";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_wday == 1);
assert(err == std::ios_base::eofbit);
}
}
int main(int, char**)
{
const my_facet f(1);
std::ios ios(0);
std::ios_base::iostate err;
std::tm t;
{
const char in[] = "2009 May 9, 10:27pm";
const char fmt[] = "%Y %b %d, %I:%M%p";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, fmt, fmt+sizeof(fmt)-1);
assert(i.base() == in+sizeof(in)-1);
assert(t.tm_year == 109);
assert(t.tm_mon == 4);
assert(t.tm_mday == 9);
assert(t.tm_hour == 22);
assert(t.tm_min == 27);
assert(err == std::ios_base::eofbit);
}
{
const char in[] = "10:27PM May 9, 2009";
const char fmt[] = "%I:%M%p %b %d, %Y";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, fmt, fmt+sizeof(fmt)-1);
assert(i.base() == in+sizeof(in)-1);
assert(t.tm_year == 109);
assert(t.tm_mon == 4);
assert(t.tm_mday == 9);
assert(t.tm_hour == 22);
assert(t.tm_min == 27);
assert(err == std::ios_base::eofbit);
}
return 0;
}
int main()
{
std::ios ios(0);
std::ios_base::iostate err;
std::tm t;
{
const my_facet f(LOCALE_en_US_UTF_8, 1);
const wchar_t in[] = L"June";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_mon == 5);
assert(err == std::ios_base::eofbit);
}
{
const my_facet f(LOCALE_fr_FR_UTF_8, 1);
const wchar_t in[] = L"juin";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_mon == 5);
assert(err == std::ios_base::eofbit);
}
{
const my_facet f(LOCALE_ru_RU_UTF_8, 1);
const wchar_t in[] = L"\x438\x44E\x43D\x44F";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_mon == 5);
assert(err == std::ios_base::eofbit);
}
{
const my_facet f(LOCALE_zh_CN_UTF_8, 1);
const wchar_t in[] = L"\x516D\x6708";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_mon == 5);
assert(err == std::ios_base::eofbit);
}
}
int main()
{
std::ios ios(0);
std::ios_base::iostate err;
std::tm t;
{
const my_facet f(LOCALE_en_US_UTF_8, 1);
const wchar_t in[] = L"Monday";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_wday == 1);
assert(err == std::ios_base::eofbit);
}
{
const my_facet f(LOCALE_fr_FR_UTF_8, 1);
const wchar_t in[] = L"Lundi";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_wday == 1);
assert(err == std::ios_base::eofbit);
}
{
const my_facet f(LOCALE_ru_RU_UTF_8, 1);
const wchar_t in[] = L"\x43F\x43E\x43D\x435\x434\x435\x43B\x44C\x43D\x438\x43A";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_wday == 1);
assert(err == std::ios_base::eofbit);
}
{
const my_facet f(LOCALE_zh_CN_UTF_8, 1);
const wchar_t in[] = L"\x661F\x671F\x4E00";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_wday == 1);
assert(err == std::ios_base::eofbit);
}
}
int main(int, char**)
{
{
const my_facet f(LOCALE_en_US_UTF_8, 1);
assert(f.date_order() == std::time_base::mdy);
}
{
const my_facet f(LOCALE_fr_FR_UTF_8, 1);
assert(f.date_order() == std::time_base::dmy);
}
{
const my_facet f(LOCALE_ru_RU_UTF_8, 1);
assert(f.date_order() == std::time_base::dmy);
}
{
const my_facet f(LOCALE_zh_CN_UTF_8, 1);
assert(f.date_order() == std::time_base::ymd);
}
return 0;
}
int main()
{
const my_facet f(1);
std::ios ios(0);
std::ios_base::iostate err;
std::tm t;
{
const char in[] = "mon";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'a');
assert(i.base() == in+sizeof(in)-1);
assert(t.tm_wday == 1);
assert(err == std::ios_base::eofbit);
}
{
const char in[] = "wednesdaY";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'A');
assert(i.base() == in+sizeof(in)-1);
assert(t.tm_wday == 3);
assert(err == std::ios_base::eofbit);
}
{
const char in[] = "June";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'b');
assert(i.base() == in+sizeof(in)-1);
assert(t.tm_mon == 5);
assert(err == std::ios_base::eofbit);
}
{
const char in[] = "Jul";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'B');
assert(i.base() == in+sizeof(in)-1);
assert(t.tm_mon == 6);
assert(err == std::ios_base::eofbit);
}
{
const char in[] = "Thu Jun 6 09:49:10 2009";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'c');
assert(i.base() == in+sizeof(in)-1);
assert(t.tm_wday == 4);
assert(t.tm_mon == 5);
assert(t.tm_mday == 6);
assert(t.tm_hour == 9);
assert(t.tm_min == 49);
assert(t.tm_sec == 10);
assert(t.tm_year == 109);
assert(err == std::ios_base::eofbit);
}
{
const char in[] = "11";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'd');
assert(i.base() == in+sizeof(in)-1);
assert(t.tm_mday == 11);
assert(err == std::ios_base::eofbit);
}
{
const char in[] = "2/1/1";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'D');
assert(i.base() == in+sizeof(in)-1);
assert(t.tm_mon == 1);
assert(t.tm_mday == 1);
assert(t.tm_year == 101);
assert(err == std::ios_base::eofbit);
}
{
const char in[] = "11";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'e');
assert(i.base() == in+sizeof(in)-1);
assert(t.tm_mday == 11);
assert(err == std::ios_base::eofbit);
}
{
const char in[] = "June";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'h');
assert(i.base() == in+sizeof(in)-1);
assert(t.tm_mon == 5);
assert(err == std::ios_base::eofbit);
}
{
const char in[] = "19";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'H');
assert(i.base() == in+sizeof(in)-1);
assert(t.tm_hour == 19);
assert(err == std::ios_base::eofbit);
}
{
const char in[] = "12";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'm');
assert(i.base() == in+sizeof(in)-1);
assert(t.tm_mon == 11);
assert(err == std::ios_base::eofbit);
}
{
const char in[] = "59";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'M');
assert(i.base() == in+sizeof(in)-1);
assert(t.tm_min == 59);
assert(err == std::ios_base::eofbit);
}
{
const char in[] = "\t\n ";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'n');
assert(i.base() == in+sizeof(in)-1);
assert(err == std::ios_base::eofbit);
}
{
const char in[] = "09:49:10 PM";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'r');
assert(i.base() == in+sizeof(in)-1);
assert(t.tm_hour == 21);
assert(t.tm_min == 49);
assert(t.tm_sec == 10);
assert(err == std::ios_base::eofbit);
}
{
const char in[] = "09:49:10 AM";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'r');
assert(i.base() == in+sizeof(in)-1);
assert(t.tm_hour == 9);
assert(t.tm_min == 49);
assert(t.tm_sec == 10);
assert(err == std::ios_base::eofbit);
}
{
const char in[] = "12:49:10 AM";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'r');
assert(i.base() == in+sizeof(in)-1);
assert(t.tm_hour == 0);
assert(t.tm_min == 49);
assert(t.tm_sec == 10);
assert(err == std::ios_base::eofbit);
}
{
const char in[] = "12:49:10 PM";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'r');
assert(i.base() == in+sizeof(in)-1);
assert(t.tm_hour == 12);
assert(t.tm_min == 49);
assert(t.tm_sec == 10);
assert(err == std::ios_base::eofbit);
}
{
const char in[] = "09:49";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'R');
assert(i.base() == in+sizeof(in)-1);
assert(t.tm_hour == 9);
assert(t.tm_min == 49);
assert(t.tm_sec == 0);
assert(err == std::ios_base::eofbit);
}
{
const char in[] = "60";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'S');
assert(i.base() == in+sizeof(in)-1);
assert(t.tm_hour == 0);
assert(t.tm_min == 0);
assert(t.tm_sec == 60);
assert(err == std::ios_base::eofbit);
}
{
const char in[] = "\t\n ";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 't');
assert(i.base() == in+sizeof(in)-1);
assert(err == std::ios_base::eofbit);
}
{
const char in[] = "21:49:10";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'T');
assert(i.base() == in+sizeof(in)-1);
assert(t.tm_hour == 21);
assert(t.tm_min == 49);
assert(t.tm_sec == 10);
assert(err == std::ios_base::eofbit);
}
{
const char in[] = "3";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'w');
assert(i.base() == in+sizeof(in)-1);
assert(t.tm_wday == 3);
assert(err == std::ios_base::eofbit);
}
{
const char in[] = "06/06/09";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'x');
assert(i.base() == in+sizeof(in)-1);
assert(t.tm_mon == 5);
assert(t.tm_mday == 6);
assert(t.tm_year == 109);
assert(err == std::ios_base::eofbit);
}
{
const char in[] = "21:49:10";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'X');
assert(i.base() == in+sizeof(in)-1);
assert(t.tm_hour == 21);
assert(t.tm_min == 49);
assert(t.tm_sec == 10);
assert(err == std::ios_base::eofbit);
}
{
const char in[] = "68";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'y');
assert(i.base() == in+sizeof(in)-1);
assert(t.tm_year == 168);
assert(err == std::ios_base::eofbit);
}
{
const char in[] = "68";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'Y');
assert(i.base() == in+sizeof(in)-1);
assert(t.tm_year == -1832);
assert(err == std::ios_base::eofbit);
}
{
const char in[] = "%";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, '%');
assert(i.base() == in+sizeof(in)-1);
assert(err == std::ios_base::eofbit);
}
}
int main()
{
const my_facet f(1);
std::ios ios(0);
{
const char str[] = "1";
std::ios_base::iostate err = ios.goodbit;
bool b;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, b);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(b == true);
}
{
const char str[] = "0";
std::ios_base::iostate err = ios.goodbit;
bool b;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, b);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(b == false);
}
{
const char str[] = "12";
std::ios_base::iostate err = ios.goodbit;
bool b;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, b);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
assert(b == true);
}
{
const char str[] = "*12";
std::ios_base::iostate err = ios.goodbit;
bool b;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, b);
assert(iter.base() == str+0);
assert(err == ios.failbit);
assert(b == false);
}
boolalpha(ios);
{
const char str[] = "1";
std::ios_base::iostate err = ios.goodbit;
bool b;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, b);
assert(iter.base() == str+0);
assert(err == ios.failbit);
assert(b == false);
}
{
const char str[] = "true";
std::ios_base::iostate err = ios.goodbit;
bool b;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, b);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(b == true);
}
{
const char str[] = "false";
std::ios_base::iostate err = ios.goodbit;
bool b;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, b);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(b == false);
}
ios.imbue(std::locale(ios.getloc(), new p1));
{
const char str[] = "a";
std::ios_base::iostate err = ios.goodbit;
bool b;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+1),
ios, err, b);
assert(iter.base() == str+1);
assert(err == ios.eofbit);
assert(b == true);
}
{
const char str[] = "abc";
std::ios_base::iostate err = ios.goodbit;
bool b;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+3),
ios, err, b);
assert(iter.base() == str+2);
assert(err == ios.failbit);
assert(b == false);
}
{
const char str[] = "acc";
std::ios_base::iostate err = ios.goodbit;
bool b;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+3),
ios, err, b);
assert(iter.base() == str+1);
assert(err == ios.goodbit);
assert(b == true);
}
ios.imbue(std::locale(ios.getloc(), new p2));
{
const char str[] = "a";
std::ios_base::iostate err = ios.goodbit;
bool b;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+1),
ios, err, b);
assert(iter.base() == str+1);
assert(err == ios.eofbit);
assert(b == true);
}
{
const char str[] = "ab";
std::ios_base::iostate err = ios.goodbit;
bool b;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+2),
ios, err, b);
assert(iter.base() == str+2);
assert(err == ios.eofbit);
assert(b == false);
}
{
const char str[] = "abc";
std::ios_base::iostate err = ios.goodbit;
bool b;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+3),
ios, err, b);
assert(iter.base() == str+2);
assert(err == ios.goodbit);
assert(b == false);
}
{
const char str[] = "ac";
std::ios_base::iostate err = ios.goodbit;
bool b;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+2),
ios, err, b);
assert(iter.base() == str+1);
assert(err == ios.goodbit);
assert(b == true);
}
}
int main()
{
std::ios ios(0);
std::ios_base::iostate err;
std::tm t;
{
const my_facet f("en_US", 1);
const char in[] = "Sat Dec 31 23:55:59 2061";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t, 'c');
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_sec == 59);
assert(t.tm_min == 55);
assert(t.tm_hour == 23);
assert(t.tm_mday == 31);
assert(t.tm_mon == 11);
assert(t.tm_year == 161);
assert(t.tm_wday == 6);
assert(err == std::ios_base::eofbit);
}
{
const my_facet f("en_US", 1);
const char in[] = "23:55:59";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t, 'X');
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_sec == 59);
assert(t.tm_min == 55);
assert(t.tm_hour == 23);
assert(err == std::ios_base::eofbit);
}
{
const my_facet f("fr_FR", 1);
const char in[] = "Sam 31 d""\xC3\xA9""c 23:55:59 2061";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t, 'c');
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_sec == 59);
assert(t.tm_min == 55);
assert(t.tm_hour == 23);
assert(t.tm_mday == 31);
assert(t.tm_mon == 11);
assert(t.tm_year == 161);
assert(t.tm_wday == 6);
assert(err == std::ios_base::eofbit);
}
{
const my_facet f("fr_FR", 1);
const char in[] = "23:55:59";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t, 'X');
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_sec == 59);
assert(t.tm_min == 55);
assert(t.tm_hour == 23);
assert(err == std::ios_base::eofbit);
}
{
const my_facet f("ru_RU", 1);
const char in[] = "\xD1\x81\xD1\x83\xD0\xB1\xD0\xB1"
"\xD0\xBE\xD1\x82\xD0\xB0"
", 31 "
"\xD0\xB4\xD0\xB5\xD0\xBA\xD0\xB0"
"\xD0\xB1\xD1\x80\xD1\x8F"
" 2061 "
"\xD0\xB3"
". 23:55:59";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t, 'c');
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_sec == 59);
assert(t.tm_min == 55);
assert(t.tm_hour == 23);
assert(t.tm_mday == 31);
assert(t.tm_mon == 11);
assert(t.tm_year == 161);
assert(t.tm_wday == 6);
assert(err == std::ios_base::eofbit);
}
{
const my_facet f("ru_RU", 1);
const char in[] = "23:55:59";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t, 'X');
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_sec == 59);
assert(t.tm_min == 55);
assert(t.tm_hour == 23);
assert(err == std::ios_base::eofbit);
}
{
const my_facet f("zh_CN", 1);
const char in[] = "\xE5\x85\xAD"
" 12/31 23:55:59 2061";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t, 'c');
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_sec == 59);
assert(t.tm_min == 55);
assert(t.tm_hour == 23);
assert(t.tm_mday == 31);
assert(t.tm_mon == 11);
assert(t.tm_year == 161);
assert(t.tm_wday == 6);
assert(err == std::ios_base::eofbit);
}
{
const my_facet f("zh_CN", 1);
const char in[] = "23""\xE6\x97\xB6""55""\xE5\x88\x86""59""\xE7\xA7\x92";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t, 'X');
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_sec == 59);
assert(t.tm_min == 55);
assert(t.tm_hour == 23);
assert(err == std::ios_base::eofbit);
}
}
int main()
{
const my_facet f(1);
std::ios ios(0);
float v = -1;
{
const char str[] = "123";
assert((ios.flags() & ios.basefield) == ios.dec);
assert(ios.getloc().name() == "C");
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == 123);
}
{
const char str[] = "-123";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == -123);
}
{
const char str[] = "123.5";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == 123.5);
}
{
const char str[] = "125e-1";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == 125e-1);
}
{
const char str[] = "0x125p-1";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == hexfloat<float>(0x125, 0, -1));
}
{
const char str[] = "inf";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == INFINITY);
}
{
const char str[] = "INF";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == INFINITY);
}
{
const char str[] = "-inf";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == -INFINITY);
}
{
const char str[] = "-INF";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == -INFINITY);
}
{
const char str[] = "nan";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(std::isnan(v));
}
{
const char str[] = "NAN";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(std::isnan(v));
}
{
v = -1;
const char str[] = "3.40283e+39"; // unrepresentable
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
assert(v == HUGE_VALF);
}
{
v = -1;
const char str[] = "-3.40283e+38"; // unrepresentable
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
assert(v == -HUGE_VALF);
}
{
v = -1;
const char str[] = "2-";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+1);
assert(err == ios.goodbit);
assert(v == 2);
}
}
int main()
{
const my_facet f(1);
std::ios ios(0);
std::ios_base::iostate err;
std::tm t;
{
const wchar_t in[] = L"Sun";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+3);
assert(t.tm_wday == 0);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"Suny";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+3);
assert(t.tm_wday == 0);
assert(err == std::ios_base::goodbit);
}
{
const wchar_t in[] = L"Sund";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+4);
assert(t.tm_wday == 0);
assert(err == (std::ios_base::failbit | std::ios_base::eofbit));
}
{
const wchar_t in[] = L"sun";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+3);
assert(t.tm_wday == 0);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"sunday";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+6);
assert(t.tm_wday == 0);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"Mon";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+3);
assert(t.tm_wday == 1);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"Mony";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+3);
assert(t.tm_wday == 1);
assert(err == std::ios_base::goodbit);
}
{
const wchar_t in[] = L"Mond";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+4);
assert(t.tm_wday == 0);
assert(err == (std::ios_base::failbit | std::ios_base::eofbit));
}
{
const wchar_t in[] = L"mon";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+3);
assert(t.tm_wday == 1);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"monday";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+6);
assert(t.tm_wday == 1);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"Tue";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+3);
assert(t.tm_wday == 2);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"Tuesday";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+7);
assert(t.tm_wday == 2);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"Wed";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+3);
assert(t.tm_wday == 3);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"Wednesday";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+9);
assert(t.tm_wday == 3);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"Thu";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+3);
assert(t.tm_wday == 4);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"Thursday";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+8);
assert(t.tm_wday == 4);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"Fri";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+3);
assert(t.tm_wday == 5);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"Friday";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+6);
assert(t.tm_wday == 5);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"Sat";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+3);
assert(t.tm_wday == 6);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"Saturday";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+8);
assert(t.tm_wday == 6);
assert(err == std::ios_base::eofbit);
}
}
int main()
{
std::ios ios(0);
std::ios_base::iostate err;
std::tm t;
{
const my_facet f(LOCALE_en_US_UTF_8, 1);
const wchar_t in[] = L"Sat Dec 31 23:55:59 2061";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t, 'c');
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_sec == 59);
assert(t.tm_min == 55);
assert(t.tm_hour == 23);
assert(t.tm_mday == 31);
assert(t.tm_mon == 11);
assert(t.tm_year == 161);
assert(t.tm_wday == 6);
assert(err == std::ios_base::eofbit);
}
{
const my_facet f(LOCALE_en_US_UTF_8, 1);
const wchar_t in[] = L"23:55:59";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t, 'X');
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_sec == 59);
assert(t.tm_min == 55);
assert(t.tm_hour == 23);
assert(err == std::ios_base::eofbit);
}
{
const my_facet f(LOCALE_fr_FR_UTF_8, 1);
const wchar_t in[] = L"Sam 31 d" L"\xE9" L"c 23:55:59 2061";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t, 'c');
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_sec == 59);
assert(t.tm_min == 55);
assert(t.tm_hour == 23);
assert(t.tm_mday == 31);
assert(t.tm_mon == 11);
assert(t.tm_year == 161);
assert(t.tm_wday == 6);
assert(err == std::ios_base::eofbit);
}
{
const my_facet f(LOCALE_fr_FR_UTF_8, 1);
const wchar_t in[] = L"23:55:59";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t, 'X');
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_sec == 59);
assert(t.tm_min == 55);
assert(t.tm_hour == 23);
assert(err == std::ios_base::eofbit);
}
#ifdef __APPLE__
{
const my_facet f("ru_RU", 1);
const wchar_t in[] = L"\x441\x443\x431\x431\x43E\x442\x430"
L", 31 "
L"\x434\x435\x43A\x430\x431\x440\x44F"
L" 2061 "
L"\x433"
L". 23:55:59";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t, 'c');
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_sec == 59);
assert(t.tm_min == 55);
assert(t.tm_hour == 23);
assert(t.tm_mday == 31);
assert(t.tm_mon == 11);
assert(t.tm_year == 161);
assert(t.tm_wday == 6);
assert(err == std::ios_base::eofbit);
}
#endif
{
const my_facet f(LOCALE_ru_RU_UTF_8, 1);
const wchar_t in[] = L"23:55:59";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t, 'X');
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_sec == 59);
assert(t.tm_min == 55);
assert(t.tm_hour == 23);
assert(err == std::ios_base::eofbit);
}
#ifdef __APPLE__
{
const my_facet f("zh_CN", 1);
const wchar_t in[] = L"\x516D"
L" 12/31 23:55:59 2061";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t, 'c');
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_sec == 59);
assert(t.tm_min == 55);
assert(t.tm_hour == 23);
assert(t.tm_mday == 31);
assert(t.tm_mon == 11);
assert(t.tm_year == 161);
assert(t.tm_wday == 6);
assert(err == std::ios_base::eofbit);
}
#endif
{
const my_facet f(LOCALE_zh_CN_UTF_8, 1);
const wchar_t in[] = L"23" L"\x65F6" L"55" L"\x5206" L"59" L"\x79D2";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t, 'X');
assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_sec == 59);
assert(t.tm_min == 55);
assert(t.tm_hour == 23);
assert(err == std::ios_base::eofbit);
}
}
int main()
{
const my_facet f(1);
{
std::ios ios(0);
unsigned long long v = 0;
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "0");
}
{
std::ios ios(0);
unsigned long long v = 1;
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "1");
}
{
std::ios ios(0);
unsigned long long v = -1;
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == (sizeof(unsigned long long) == 4 ? "4294967295" : "18446744073709551615"));
}
{
std::ios ios(0);
unsigned long long v = -1000;
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "18446744073709550616");
}
{
std::ios ios(0);
unsigned long long v = 1000;
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "1000");
}
{
std::ios ios(0);
showpos(ios);
unsigned long long v = 1000;
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "1000");
}
{
std::ios ios(0);
oct(ios);
unsigned long long v = 1000;
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "1750");
}
{
std::ios ios(0);
oct(ios);
showbase(ios);
unsigned long long v = 1000;
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "01750");
}
{
std::ios ios(0);
hex(ios);
unsigned long long v = 1000;
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "3e8");
}
{
std::ios ios(0);
hex(ios);
showbase(ios);
unsigned long long v = 1000;
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "0x3e8");
}
{
std::ios ios(0);
hex(ios);
showbase(ios);
uppercase(ios);
unsigned long long v = 1000;
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "0X3E8");
}
{
std::ios ios(0);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
hex(ios);
showbase(ios);
uppercase(ios);
unsigned long long v = 1000;
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "0X3E_8");
}
{
std::ios ios(0);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
hex(ios);
showbase(ios);
unsigned long long v = 2147483647;
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "0x7f_fff_ff_f");
}
{
std::ios ios(0);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
oct(ios);
unsigned long long v = 0123467;
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "123_46_7");
}
{
std::ios ios(0);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
oct(ios);
showbase(ios);
unsigned long long v = 0123467;
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "0_123_46_7");
}
{
std::ios ios(0);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
oct(ios);
showbase(ios);
right(ios);
ios.width(15);
unsigned long long v = 0123467;
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "*****0_123_46_7");
}
{
std::ios ios(0);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
oct(ios);
showbase(ios);
left(ios);
ios.width(15);
unsigned long long v = 0123467;
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "0_123_46_7*****");
}
{
std::ios ios(0);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
oct(ios);
showbase(ios);
internal(ios);
ios.width(15);
unsigned long long v = 0123467;
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "*****0_123_46_7");
assert(ios.width() == 0);
}
{
std::ios ios(0);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
hex(ios);
showbase(ios);
right(ios);
ios.width(15);
unsigned long long v = 2147483647;
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "**0x7f_fff_ff_f");
}
{
std::ios ios(0);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
hex(ios);
showbase(ios);
left(ios);
ios.width(15);
unsigned long long v = 2147483647;
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "0x7f_fff_ff_f**");
}
{
std::ios ios(0);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
hex(ios);
showbase(ios);
internal(ios);
ios.width(15);
unsigned long long v = 2147483647;
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "0x**7f_fff_ff_f");
assert(ios.width() == 0);
}
{
std::ios ios(0);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
showpos(ios);
unsigned long long v = 1000;
right(ios);
ios.width(10);
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "****1_00_0");
assert(ios.width() == 0);
}
{
std::ios ios(0);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
showpos(ios);
unsigned long long v = 1000;
left(ios);
ios.width(10);
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "1_00_0****");
assert(ios.width() == 0);
}
{
std::ios ios(0);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
showpos(ios);
unsigned long long v = 1000;
internal(ios);
ios.width(10);
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "****1_00_0");
assert(ios.width() == 0);
}
{
std::ios ios(0);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
unsigned long long v = -1000;
right(ios);
showpos(ios);
ios.width(10);
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "18_446_744_073_709_550_61_6");
assert(ios.width() == 0);
}
{
std::ios ios(0);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
unsigned long long v = -1000;
left(ios);
ios.width(10);
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "18_446_744_073_709_550_61_6");
assert(ios.width() == 0);
}
{
std::ios ios(0);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
unsigned long long v = -1000;
internal(ios);
ios.width(10);
char str[50];
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "18_446_744_073_709_550_61_6");
assert(ios.width() == 0);
}
}
int main()
{
const my_facet f(1);
std::ios ios(0);
long v = -1;
{
const char str[] = "123";
assert((ios.flags() & ios.basefield) == ios.dec);
assert(ios.getloc().name() == "C");
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+3);
assert(err == ios.goodbit);
assert(v == 123);
}
{
const char str[] = "-123";
assert((ios.flags() & ios.basefield) == ios.dec);
assert(ios.getloc().name() == "C");
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+4);
assert(err == ios.goodbit);
assert(v == -123);
}
{
const char str[] = "123";
oct(ios);
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+3);
assert(err == ios.goodbit);
assert(v == 83);
}
{
const char str[] = "123";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+3);
assert(err == ios.goodbit);
assert(v == 291);
}
{
const char str[] = "0x123";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == 291);
}
{
const char str[] = "123";
ios.setf(0, ios.basefield);
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == 123);
}
{
const char str[] = "0x123";
ios.setf(0, ios.basefield);
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == 291);
}
{
const char str[] = "0123";
ios.setf(0, ios.basefield);
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == 83);
}
{
const char str[] = "2-";
ios.setf(0, ios.basefield);
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+1);
assert(err == ios.goodbit);
assert(v == 2);
}
dec(ios);
ios.imbue(std::locale(std::locale(), new my_numpunct));
{
v = -1;
const char str[] = "123";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
assert(v == 123);
}
{
v = -1;
const char str[] = "+1";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == 1);
}
{
v = -1;
const char str[] = "+1_";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
assert(v == 1);
}
{
v = -1;
const char str[] = "+_1";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
assert(v == 1);
}
{
v = -1;
const char str[] = "_+1";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
assert(v == 1);
}
{
v = -1;
const char str[] = "+1__";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
assert(v == 1);
}
{
v = -1;
const char str[] = "+_1_";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
assert(v == 1);
}
{
v = -1;
const char str[] = "_+1_";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
assert(v == 1);
}
{
v = -1;
const char str[] = "+__1";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
assert(v == 1);
}
{
v = -1;
const char str[] = "_+_1";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
assert(v == 1);
}
{
v = -1;
const char str[] = "__+1";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
assert(v == 1);
}
{
v = -1;
const char str[] = "+1_2";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == 12);
}
{
v = -1;
const char str[] = "+12_";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
assert(v == 12);
}
{
v = -1;
const char str[] = "+_12";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
assert(v == 12);
}
{
v = -1;
const char str[] = "+1__2";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
assert(v == 12);
}
{
v = -1;
const char str[] = "+12_3";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == 123);
}
{
v = -1;
const char str[] = "+1_23";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
assert(v == 123);
}
{
v = -1;
const char str[] = "+1_23_4";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == 1234);
}
{
v = -1;
const char str[] = "+123_4";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
assert(v == 1234);
}
{
v = -1;
const char str[] = "+12_34";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
assert(v == 1234);
}
{
v = -1;
const char str[] = "+12_34_5";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == 12345);
}
{
v = -1;
const char str[] = "+123_45_6";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == 123456);
}
{
v = -1;
const char str[] = "+1_23_45_6";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
assert(v == 123456);
}
{
v = -1;
const char str[] = "+1_234_56_7";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == 1234567);
}
{
v = -1;
const char str[] = "+1_234_567_89_0";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == 1234567890);
}
{
v = -1;
const char str[] = "-1_234_567_89_0";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == -1234567890);
}
{
v = -1;
const char str[] = "1_234_567_89_0";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == 1234567890);
}
{
v = -1;
const char str[] = "1234_567_89_0";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
assert(v == 1234567890);
}
{
v = -1;
const char str[] = "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
assert(v == std::numeric_limits<long>::max());
}
}
int main()
{
const my_facet f(1);
std::ios ios(0);
std::ios_base::iostate err;
std::tm t;
{
const char in[] = "0:0:0";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_time(I(in), I(in+sizeof(in)-1), ios, err, &t);
assert(i.base() == in+sizeof(in)-1);
assert(t.tm_hour == 0);
assert(t.tm_min == 0);
assert(t.tm_sec == 0);
assert(err == std::ios_base::eofbit);
}
{
const char in[] = "23:59:60";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_time(I(in), I(in+sizeof(in)-1), ios, err, &t);
assert(i.base() == in+sizeof(in)-1);
assert(t.tm_hour == 23);
assert(t.tm_min == 59);
assert(t.tm_sec == 60);
assert(err == std::ios_base::eofbit);
}
{
const char in[] = "24:59:60";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_time(I(in), I(in+sizeof(in)-1), ios, err, &t);
assert(i.base() == in+2);
assert(t.tm_hour == 0);
assert(t.tm_min == 0);
assert(t.tm_sec == 0);
assert(err == std::ios_base::failbit);
}
{
const char in[] = "23:60:60";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_time(I(in), I(in+sizeof(in)-1), ios, err, &t);
assert(i.base() == in+5);
// assert(t.tm_hour == 0);
// assert(t.tm_min == 0);
// assert(t.tm_sec == 0);
assert(err == std::ios_base::failbit);
}
{
const char in[] = "23:59:61";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_time(I(in), I(in+sizeof(in)-1), ios, err, &t);
assert(i.base() == in+8);
// assert(t.tm_hour == 0);
// assert(t.tm_min == 0);
// assert(t.tm_sec == 0);
assert(err == (std::ios_base::failbit | std::ios_base::eofbit));
}
{
const char in[] = "2:43:221";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_time(I(in), I(in+sizeof(in)-1), ios, err, &t);
assert(i.base() == in+7);
assert(t.tm_hour == 2);
assert(t.tm_min == 43);
assert(t.tm_sec == 22);
assert(err == std::ios_base::goodbit);
}
{
const char in[] = "2.43:221";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_time(I(in), I(in+sizeof(in)-1), ios, err, &t);
assert(i.base() == in+1);
// assert(t.tm_hour == 0);
// assert(t.tm_min == 0);
// assert(t.tm_sec == 0);
assert(err == std::ios_base::failbit);
}
}
int main()
{
std::ios ios(0);
std::string loc_name("en_US");
ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<char, false>(loc_name)));
ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<char, true>(loc_name)));
ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<wchar_t, false>(loc_name)));
ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<wchar_t, true>(loc_name)));
{
const my_facet f(1);
// char, national
{ // zero
long double v = 0;
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
false, ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "0.00");
}
{ // negative one
long double v = -1;
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
false, ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "-0.01");
}
{ // positive
long double v = 123456789;
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
false, ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "1,234,567.89");
}
{ // negative
long double v = -123456789;
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
false, ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "-1,234,567.89");
}
{ // zero, showbase
long double v = 0;
showbase(ios);
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
false, ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "$0.00");
}
{ // negative one, showbase
long double v = -1;
showbase(ios);
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
false, ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "-$0.01");
}
{ // positive, showbase
long double v = 123456789;
showbase(ios);
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
false, ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "$1,234,567.89");
}
{ // negative, showbase
long double v = -123456789;
showbase(ios);
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
false, ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "-$1,234,567.89");
}
{ // negative, showbase, left
long double v = -123456789;
showbase(ios);
ios.width(20);
left(ios);
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
false, ios, ' ', v);
std::string ex(str, iter.base());
assert(ex == "-$1,234,567.89 ");
assert(ios.width() == 0);
}
{ // negative, showbase, internal
long double v = -123456789;
showbase(ios);
ios.width(20);
internal(ios);
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
false, ios, ' ', v);
std::string ex(str, iter.base());
assert(ex == "-$ 1,234,567.89");
assert(ios.width() == 0);
}
{ // negative, showbase, right
long double v = -123456789;
showbase(ios);
ios.width(20);
right(ios);
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
false, ios, ' ', v);
std::string ex(str, iter.base());
assert(ex == " -$1,234,567.89");
assert(ios.width() == 0);
}
// char, international
noshowbase(ios);
ios.unsetf(std::ios_base::adjustfield);
{ // zero
long double v = 0;
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
true, ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "0.00");
}
{ // negative one
long double v = -1;
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
true, ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "-0.01");
}
{ // positive
long double v = 123456789;
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
true, ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "1,234,567.89");
}
{ // negative
long double v = -123456789;
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
true, ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "-1,234,567.89");
}
{ // zero, showbase
long double v = 0;
showbase(ios);
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
true, ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "USD 0.00");
}
{ // negative one, showbase
long double v = -1;
showbase(ios);
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
true, ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "-USD 0.01");
}
{ // positive, showbase
long double v = 123456789;
showbase(ios);
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
true, ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "USD 1,234,567.89");
}
{ // negative, showbase
long double v = -123456789;
showbase(ios);
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
true, ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "-USD 1,234,567.89");
}
{ // negative, showbase, left
long double v = -123456789;
showbase(ios);
ios.width(20);
left(ios);
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
true, ios, ' ', v);
std::string ex(str, iter.base());
assert(ex == "-USD 1,234,567.89 ");
assert(ios.width() == 0);
}
{ // negative, showbase, internal
long double v = -123456789;
showbase(ios);
ios.width(20);
internal(ios);
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
true, ios, ' ', v);
std::string ex(str, iter.base());
assert(ex == "-USD 1,234,567.89");
assert(ios.width() == 0);
}
{ // negative, showbase, right
long double v = -123456789;
showbase(ios);
ios.width(20);
right(ios);
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
true, ios, ' ', v);
std::string ex(str, iter.base());
assert(ex == " -USD 1,234,567.89");
assert(ios.width() == 0);
}
}
{
const my_facetw f(1);
// wchar_t, national
noshowbase(ios);
ios.unsetf(std::ios_base::adjustfield);
{ // zero
long double v = 0;
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
false, ios, '*', v);
std::wstring ex(str, iter.base());
assert(ex == L"0.00");
}
{ // negative one
long double v = -1;
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
false, ios, '*', v);
std::wstring ex(str, iter.base());
assert(ex == L"-0.01");
}
{ // positive
long double v = 123456789;
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
false, ios, '*', v);
std::wstring ex(str, iter.base());
assert(ex == L"1,234,567.89");
}
{ // negative
long double v = -123456789;
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
false, ios, '*', v);
std::wstring ex(str, iter.base());
assert(ex == L"-1,234,567.89");
}
{ // zero, showbase
long double v = 0;
showbase(ios);
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
false, ios, '*', v);
std::wstring ex(str, iter.base());
assert(ex == L"$0.00");
}
{ // negative one, showbase
long double v = -1;
showbase(ios);
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
false, ios, '*', v);
std::wstring ex(str, iter.base());
assert(ex == L"-$0.01");
}
{ // positive, showbase
long double v = 123456789;
showbase(ios);
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
false, ios, '*', v);
std::wstring ex(str, iter.base());
assert(ex == L"$1,234,567.89");
}
{ // negative, showbase
long double v = -123456789;
showbase(ios);
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
false, ios, '*', v);
std::wstring ex(str, iter.base());
assert(ex == L"-$1,234,567.89");
}
{ // negative, showbase, left
long double v = -123456789;
showbase(ios);
ios.width(20);
left(ios);
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
false, ios, ' ', v);
std::wstring ex(str, iter.base());
assert(ex == L"-$1,234,567.89 ");
assert(ios.width() == 0);
}
{ // negative, showbase, internal
long double v = -123456789;
showbase(ios);
ios.width(20);
internal(ios);
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
false, ios, ' ', v);
std::wstring ex(str, iter.base());
assert(ex == L"-$ 1,234,567.89");
assert(ios.width() == 0);
}
{ // negative, showbase, right
long double v = -123456789;
showbase(ios);
ios.width(20);
right(ios);
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
false, ios, ' ', v);
std::wstring ex(str, iter.base());
assert(ex == L" -$1,234,567.89");
assert(ios.width() == 0);
}
// wchar_t, international
noshowbase(ios);
ios.unsetf(std::ios_base::adjustfield);
{ // zero
long double v = 0;
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
true, ios, '*', v);
std::wstring ex(str, iter.base());
assert(ex == L"0.00");
}
{ // negative one
long double v = -1;
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
true, ios, '*', v);
std::wstring ex(str, iter.base());
assert(ex == L"-0.01");
}
{ // positive
long double v = 123456789;
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
true, ios, '*', v);
std::wstring ex(str, iter.base());
assert(ex == L"1,234,567.89");
}
{ // negative
long double v = -123456789;
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
true, ios, '*', v);
std::wstring ex(str, iter.base());
assert(ex == L"-1,234,567.89");
}
{ // zero, showbase
long double v = 0;
showbase(ios);
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
true, ios, '*', v);
std::wstring ex(str, iter.base());
assert(ex == L"USD 0.00");
}
{ // negative one, showbase
long double v = -1;
showbase(ios);
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
true, ios, '*', v);
std::wstring ex(str, iter.base());
assert(ex == L"-USD 0.01");
}
{ // positive, showbase
long double v = 123456789;
showbase(ios);
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
true, ios, '*', v);
std::wstring ex(str, iter.base());
assert(ex == L"USD 1,234,567.89");
}
{ // negative, showbase
long double v = -123456789;
showbase(ios);
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
true, ios, '*', v);
std::wstring ex(str, iter.base());
assert(ex == L"-USD 1,234,567.89");
}
{ // negative, showbase, left
long double v = -123456789;
showbase(ios);
ios.width(20);
left(ios);
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
true, ios, ' ', v);
std::wstring ex(str, iter.base());
assert(ex == L"-USD 1,234,567.89 ");
assert(ios.width() == 0);
}
{ // negative, showbase, internal
long double v = -123456789;
showbase(ios);
ios.width(20);
internal(ios);
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
true, ios, ' ', v);
std::wstring ex(str, iter.base());
assert(ex == L"-USD 1,234,567.89");
assert(ios.width() == 0);
}
{ // negative, showbase, right
long double v = -123456789;
showbase(ios);
ios.width(20);
right(ios);
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
true, ios, ' ', v);
std::wstring ex(str, iter.base());
assert(ex == L" -USD 1,234,567.89");
assert(ios.width() == 0);
}
}
}
int main()
{
std::ios ios(0);
std::string loc_name(LOCALE_zh_CN_UTF_8);
ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<char, false>(loc_name)));
ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<char, true>(loc_name)));
ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<wchar_t, false>(loc_name)));
ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<wchar_t, true>(loc_name)));
{
const my_facet f(1);
// char, national
{ // zero
std::string v = "0.00";
typedef input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == 0);
}
{ // negative one
std::string v = "-0.01";
typedef input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == -1);
}
{ // positive
std::string v = "1,234,567.89";
typedef input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == 123456789);
}
{ // negative
std::string v = "-1,234,567.89";
typedef input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == -123456789);
}
{ // negative
std::string v = "-1234567.89";
typedef input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == -123456789);
}
{ // zero, showbase
std::string v = "\xEF\xBF\xA5""0.00";
typedef input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == 0);
}
{ // zero, showbase
std::string v = "\xEF\xBF\xA5""0.00";
showbase(ios);
typedef input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == 0);
noshowbase(ios);
}
{ // negative one, showbase
std::string v = "\xEF\xBF\xA5""-0.01";
typedef input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == -1);
}
{ // negative one, showbase
std::string v = "\xEF\xBF\xA5""-0.01";
showbase(ios);
typedef input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == -1);
noshowbase(ios);
}
{ // positive, showbase
std::string v = "\xEF\xBF\xA5""1,234,567.89";
typedef input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == 123456789);
}
{ // positive, showbase
std::string v = "\xEF\xBF\xA5""1,234,567.89";
showbase(ios);
typedef input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == 123456789);
noshowbase(ios);
}
{ // negative, showbase
std::string v = "\xEF\xBF\xA5""-1,234,567.89";
showbase(ios);
typedef input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == -123456789);
noshowbase(ios);
}
{ // negative, showbase
std::string v = "CNY -1,234,567.89";
showbase(ios);
typedef input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex);
assert(iter.base() == v.data() + 0);
assert(err == std::ios_base::failbit);
noshowbase(ios);
}
{ // negative, showbase
std::string v = "CNY -1,234,567.89";
typedef input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex);
assert(iter.base() == v.data() + 0);
assert(err == std::ios_base::failbit);
}
}
{
const my_facet f(1);
// char, international
{ // zero
std::string v = "0.00";
typedef input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == 0);
}
{ // negative one
std::string v = "-0.01";
typedef input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == -1);
}
{ // positive
std::string v = "1,234,567.89";
typedef input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == 123456789);
}
{ // negative
std::string v = "-1,234,567.89";
typedef input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == -123456789);
}
{ // negative
std::string v = "-1234567.89";
typedef input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == -123456789);
}
{ // zero, showbase
std::string v = "CNY 0.00";
typedef input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == 0);
}
{ // zero, showbase
std::string v = "CNY 0.00";
showbase(ios);
typedef input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == 0);
noshowbase(ios);
}
{ // negative one, showbase
std::string v = "CNY -0.01";
typedef input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == -1);
}
{ // negative one, showbase
std::string v = "CNY -0.01";
showbase(ios);
typedef input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == -1);
noshowbase(ios);
}
{ // positive, showbase
std::string v = "CNY 1,234,567.89";
typedef input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == 123456789);
}
{ // positive, showbase
std::string v = "CNY 1,234,567.89";
showbase(ios);
typedef input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == 123456789);
noshowbase(ios);
}
{ // negative, showbase
std::string v = "CNY -1,234,567.89";
showbase(ios);
typedef input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == -123456789);
noshowbase(ios);
}
{ // negative, showbase
std::string v = "\xEF\xBF\xA5""-1,234,567.89";
showbase(ios);
typedef input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex);
assert(iter.base() == v.data() + 0);
assert(err == std::ios_base::failbit);
noshowbase(ios);
}
{ // negative, showbase
std::string v = "\xEF\xBF\xA5""-1,234,567.89";
typedef input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex);
assert(iter.base() == v.data() + 0);
assert(err == std::ios_base::failbit);
}
}
{
const my_facetw f(1);
// wchar_t, national
{ // zero
std::wstring v = L"0.00";
typedef input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == 0);
}
{ // negative one
std::wstring v = L"-0.01";
typedef input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == -1);
}
{ // positive
std::wstring v = L"1,234,567.89";
typedef input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == 123456789);
}
{ // negative
std::wstring v = L"-1,234,567.89";
typedef input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == -123456789);
}
{ // negative
std::wstring v = L"-1234567.89";
typedef input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == -123456789);
}
{ // zero, showbase
std::wstring v = L"\xFFE5""0.00";
typedef input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == 0);
}
{ // zero, showbase
std::wstring v = L"\xFFE5""0.00";
showbase(ios);
typedef input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == 0);
noshowbase(ios);
}
{ // negative one, showbase
std::wstring v = L"\xFFE5""-0.01";
typedef input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == -1);
}
{ // negative one, showbase
std::wstring v = L"\xFFE5""-0.01";
showbase(ios);
typedef input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == -1);
noshowbase(ios);
}
{ // positive, showbase
std::wstring v = L"\xFFE5""1,234,567.89";
typedef input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == 123456789);
}
{ // positive, showbase
std::wstring v = L"\xFFE5""1,234,567.89";
showbase(ios);
typedef input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == 123456789);
noshowbase(ios);
}
{ // negative, showbase
std::wstring v = L"\xFFE5""-1,234,567.89";
showbase(ios);
typedef input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == -123456789);
noshowbase(ios);
}
{ // negative, showbase
std::wstring v = L"CNY -1,234,567.89";
showbase(ios);
typedef input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex);
assert(iter.base() == v.data() + 0);
assert(err == std::ios_base::failbit);
noshowbase(ios);
}
{ // negative, showbase
std::wstring v = L"CNY -1,234,567.89";
typedef input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex);
assert(iter.base() == v.data() + 0);
assert(err == std::ios_base::failbit);
}
}
{
const my_facetw f(1);
// wchar_t, international
{ // zero
std::wstring v = L"0.00";
typedef input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == 0);
}
{ // negative one
std::wstring v = L"-0.01";
typedef input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == -1);
}
{ // positive
std::wstring v = L"1,234,567.89";
typedef input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == 123456789);
}
{ // negative
std::wstring v = L"-1,234,567.89";
typedef input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == -123456789);
}
{ // negative
std::wstring v = L"-1234567.89";
typedef input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == -123456789);
}
{ // zero, showbase
std::wstring v = L"CNY 0.00";
typedef input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == 0);
}
{ // zero, showbase
std::wstring v = L"CNY 0.00";
showbase(ios);
typedef input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == 0);
noshowbase(ios);
}
{ // negative one, showbase
std::wstring v = L"CNY -0.01";
typedef input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == -1);
}
{ // negative one, showbase
std::wstring v = L"CNY -0.01";
showbase(ios);
typedef input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == -1);
noshowbase(ios);
}
{ // positive, showbase
std::wstring v = L"CNY 1,234,567.89";
typedef input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == 123456789);
}
{ // positive, showbase
std::wstring v = L"CNY 1,234,567.89";
showbase(ios);
typedef input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == 123456789);
noshowbase(ios);
}
{ // negative, showbase
std::wstring v = L"CNY -1,234,567.89";
showbase(ios);
typedef input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex);
assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit);
assert(ex == -123456789);
noshowbase(ios);
}
{ // negative, showbase
std::wstring v = L"\xFFE5""-1,234,567.89";
showbase(ios);
typedef input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex);
assert(iter.base() == v.data() + 0);
assert(err == std::ios_base::failbit);
noshowbase(ios);
}
{ // negative, showbase
std::wstring v = L"\xFFE5""-1,234,567.89";
typedef input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex);
assert(iter.base() == v.data() + 0);
assert(err == std::ios_base::failbit);
}
}
}
int main()
{
const my_facet f(1);
{
std::ios ios(0);
long v = 0;
char str[50];
std::ios_base::iostate err = ios.goodbit;
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "0");
}
{
std::ios ios(0);
long v = 1;
char str[50];
std::ios_base::iostate err = ios.goodbit;
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "1");
}
{
std::ios ios(0);
long v = -1;
char str[50];
std::ios_base::iostate err = ios.goodbit;
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "-1");
}
{
std::ios ios(0);
long v = -1000;
char str[50];
std::ios_base::iostate err = ios.goodbit;
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "-1000");
}
{
std::ios ios(0);
long v = 1000;
char str[50];
std::ios_base::iostate err = ios.goodbit;
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "1000");
}
{
std::ios ios(0);
showpos(ios);
long v = 1000;
char str[50];
std::ios_base::iostate err = ios.goodbit;
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "+1000");
}
{
std::ios ios(0);
oct(ios);
long v = 1000;
char str[50];
std::ios_base::iostate err = ios.goodbit;
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "1750");
}
{
std::ios ios(0);
oct(ios);
showbase(ios);
long v = 1000;
char str[50];
std::ios_base::iostate err = ios.goodbit;
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "01750");
}
{
std::ios ios(0);
hex(ios);
long v = 1000;
char str[50];
std::ios_base::iostate err = ios.goodbit;
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "3e8");
}
{
std::ios ios(0);
hex(ios);
showbase(ios);
long v = 1000;
char str[50];
std::ios_base::iostate err = ios.goodbit;
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "0x3e8");
}
{
std::ios ios(0);
hex(ios);
showbase(ios);
uppercase(ios);
long v = 1000;
char str[50];
std::ios_base::iostate err = ios.goodbit;
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "0X3E8");
}
{
std::ios ios(0);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
hex(ios);
showbase(ios);
uppercase(ios);
long v = 1000;
char str[50];
std::ios_base::iostate err = ios.goodbit;
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "0X3E_8");
}
{
std::ios ios(0);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
hex(ios);
showbase(ios);
long v = 2147483647;
char str[50];
std::ios_base::iostate err = ios.goodbit;
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "0x7f_fff_ff_f");
}
{
std::ios ios(0);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
oct(ios);
long v = 0123467;
char str[50];
std::ios_base::iostate err = ios.goodbit;
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "123_46_7");
}
{
std::ios ios(0);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
oct(ios);
showbase(ios);
long v = 0123467;
char str[50];
std::ios_base::iostate err = ios.goodbit;
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "0_123_46_7");
}
{
std::ios ios(0);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
oct(ios);
showbase(ios);
right(ios);
ios.width(15);
long v = 0123467;
char str[50];
std::ios_base::iostate err = ios.goodbit;
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "*****0_123_46_7");
}
{
std::ios ios(0);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
oct(ios);
showbase(ios);
left(ios);
ios.width(15);
long v = 0123467;
char str[50];
std::ios_base::iostate err = ios.goodbit;
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "0_123_46_7*****");
}
{
std::ios ios(0);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
oct(ios);
showbase(ios);
internal(ios);
ios.width(15);
long v = 0123467;
char str[50];
std::ios_base::iostate err = ios.goodbit;
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "*****0_123_46_7");
assert(ios.width() == 0);
}
{
std::ios ios(0);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
hex(ios);
showbase(ios);
right(ios);
ios.width(15);
long v = 2147483647;
char str[50];
std::ios_base::iostate err = ios.goodbit;
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "**0x7f_fff_ff_f");
}
{
std::ios ios(0);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
hex(ios);
showbase(ios);
left(ios);
ios.width(15);
long v = 2147483647;
char str[50];
std::ios_base::iostate err = ios.goodbit;
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "0x7f_fff_ff_f**");
}
{
std::ios ios(0);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
hex(ios);
showbase(ios);
internal(ios);
ios.width(15);
long v = 2147483647;
char str[50];
std::ios_base::iostate err = ios.goodbit;
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "0x**7f_fff_ff_f");
assert(ios.width() == 0);
}
{
std::ios ios(0);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
showpos(ios);
long v = 1000;
right(ios);
ios.width(10);
char str[50];
std::ios_base::iostate err = ios.goodbit;
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "***+1_00_0");
assert(ios.width() == 0);
}
{
std::ios ios(0);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
showpos(ios);
long v = 1000;
left(ios);
ios.width(10);
char str[50];
std::ios_base::iostate err = ios.goodbit;
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "+1_00_0***");
assert(ios.width() == 0);
}
{
std::ios ios(0);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
showpos(ios);
long v = 1000;
internal(ios);
ios.width(10);
char str[50];
std::ios_base::iostate err = ios.goodbit;
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "+***1_00_0");
assert(ios.width() == 0);
}
{
std::ios ios(0);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
long v = -1000;
right(ios);
showpos(ios);
ios.width(10);
char str[50];
std::ios_base::iostate err = ios.goodbit;
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "***-1_00_0");
assert(ios.width() == 0);
}
{
std::ios ios(0);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
long v = -1000;
left(ios);
ios.width(10);
char str[50];
std::ios_base::iostate err = ios.goodbit;
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "-1_00_0***");
assert(ios.width() == 0);
}
{
std::ios ios(0);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
long v = -1000;
internal(ios);
ios.width(10);
char str[50];
std::ios_base::iostate err = ios.goodbit;
output_iterator<char*> iter = f.put(output_iterator<char*>(str), ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "-***1_00_0");
assert(ios.width() == 0);
}
}
int main()
{
const my_facet f(1);
std::ios ios(0);
std::ios_base::iostate err;
std::tm t;
{
const wchar_t in[] = L"Jan";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+3);
assert(t.tm_mon == 0);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"Feb";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+3);
assert(t.tm_mon == 1);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"Mar";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+3);
assert(t.tm_mon == 2);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"Apr";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+3);
assert(t.tm_mon == 3);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"May";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+3);
assert(t.tm_mon == 4);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"Jun";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+3);
assert(t.tm_mon == 5);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"Jul";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+3);
assert(t.tm_mon == 6);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"Aug";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+3);
assert(t.tm_mon == 7);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"Sep";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+3);
assert(t.tm_mon == 8);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"Oct";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+3);
assert(t.tm_mon == 9);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"Nov";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+3);
assert(t.tm_mon == 10);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"Dec";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+3);
assert(t.tm_mon == 11);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"January";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+7);
assert(t.tm_mon == 0);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"February";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+8);
assert(t.tm_mon == 1);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"March";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+5);
assert(t.tm_mon == 2);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"April";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+5);
assert(t.tm_mon == 3);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"May";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+3);
assert(t.tm_mon == 4);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"June";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+4);
assert(t.tm_mon == 5);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"July";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+4);
assert(t.tm_mon == 6);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"August";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+6);
assert(t.tm_mon == 7);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"September";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+9);
assert(t.tm_mon == 8);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"October";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+7);
assert(t.tm_mon == 9);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"November";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+8);
assert(t.tm_mon == 10);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"December";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+8);
assert(t.tm_mon == 11);
assert(err == std::ios_base::eofbit);
}
{
const wchar_t in[] = L"Decemper";
err = std::ios_base::goodbit;
t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(i.base() == in+5);
assert(t.tm_mon == 0);
assert(err == std::ios_base::failbit);
}
}
int main()
{
const my_facet f(1);
std::ios ios(0);
double v = -1;
{
const char str[] = "123";
assert((ios.flags() & ios.basefield) == ios.dec);
assert(ios.getloc().name() == "C");
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == 123);
}
{
const char str[] = "-123";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == -123);
}
{
const char str[] = "123.5";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == 123.5);
}
{
const char str[] = "125e-1";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == 125e-1);
}
{
const char str[] = "0x125p-1";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == hexfloat<double>(0x125, 0, -1));
}
{
const char str[] = "inf";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == INFINITY);
}
{
const char str[] = "INF";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == INFINITY);
}
{
const char str[] = "-inf";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == -INFINITY);
}
{
const char str[] = "-INF";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == -INFINITY);
}
{
const char str[] = "nan";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(std::isnan(v));
}
{
const char str[] = "NAN";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(std::isnan(v));
}
{
v = -1;
const char str[] = "123_456_78_9;125";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+3);
assert(err == ios.goodbit);
assert(v == 123);
}
{
v = -1;
const char str[] = "2-";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+1);
assert(err == ios.goodbit);
assert(v == 2);
}
{
v = -1;
const char str[] = "1.79779e+309"; // unrepresentable
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
assert(v == HUGE_VAL);
}
{
v = -1;
const char str[] = "-1.79779e+308"; // unrepresentable
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
assert(v == -HUGE_VAL);
}
ios.imbue(std::locale(std::locale(), new my_numpunct));
{
v = -1;
const char str[] = "123_456_78_9;125";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(v == 123456789.125);
}
{
v = -1;
const char str[] = "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
}
{
v = -1;
const char str[] = "3;14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651e+10";
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
assert(std::abs(v - 3.14159265358979e+10)/3.14159265358979e+10 < 1.e-8);
}
}
int main(int, char**)
{
std::ios ios(0);
std::string loc_name(LOCALE_ru_RU_UTF_8);
ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<char, false>(loc_name)));
ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<char, true>(loc_name)));
ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<wchar_t, false>(loc_name)));
ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<wchar_t, true>(loc_name)));
{
const my_facet f(1);
// char, national
{ // zero
long double v = 0;
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
false, ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "0,00 ");
}
{ // negative one
long double v = -1;
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
false, ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "-0,01 ");
}
{ // positive
long double v = 123456789;
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
false, ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "1 234 567,89 ");
}
{ // negative
long double v = -123456789;
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
false, ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "-1 234 567,89 ");
}
{ // zero, showbase
long double v = 0;
showbase(ios);
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
false, ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "0,00 \xD1\x80\xD1\x83\xD0\xB1"".");
}
{ // negative one, showbase
long double v = -1;
showbase(ios);
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
false, ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "-0,01 \xD1\x80\xD1\x83\xD0\xB1"".");
}
{ // positive, showbase
long double v = 123456789;
showbase(ios);
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
false, ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "1 234 567,89 \xD1\x80\xD1\x83\xD0\xB1"".");
}
{ // negative, showbase
long double v = -123456789;
showbase(ios);
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
false, ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "-1 234 567,89 \xD1\x80\xD1\x83\xD0\xB1"".");
}
{ // negative, showbase, left
long double v = -123456789;
showbase(ios);
ios.width(20);
left(ios);
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
false, ios, ' ', v);
std::string ex(str, iter.base());
assert(ex == "-1 234 567,89 \xD1\x80\xD1\x83\xD0\xB1"".");
assert(ios.width() == 0);
}
{ // negative, showbase, internal
long double v = -123456789;
showbase(ios);
ios.width(20);
internal(ios);
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
false, ios, ' ', v);
std::string ex(str, iter.base());
assert(ex == "-1 234 567,89 \xD1\x80\xD1\x83\xD0\xB1"".");
assert(ios.width() == 0);
}
{ // negative, showbase, right
long double v = -123456789;
showbase(ios);
ios.width(20);
right(ios);
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
false, ios, ' ', v);
std::string ex(str, iter.base());
assert(ex == "-1 234 567,89 \xD1\x80\xD1\x83\xD0\xB1"".");
assert(ios.width() == 0);
}
// char, international
noshowbase(ios);
ios.unsetf(std::ios_base::adjustfield);
{ // zero
long double v = 0;
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
true, ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "0,00 ");
}
{ // negative one
long double v = -1;
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
true, ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "-0,01 ");
}
{ // positive
long double v = 123456789;
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
true, ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "1 234 567,89 ");
}
{ // negative
long double v = -123456789;
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
true, ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "-1 234 567,89 ");
}
{ // zero, showbase
long double v = 0;
showbase(ios);
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
true, ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "0,00 RUB ");
}
{ // negative one, showbase
long double v = -1;
showbase(ios);
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
true, ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "-0,01 RUB ");
}
{ // positive, showbase
long double v = 123456789;
showbase(ios);
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
true, ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "1 234 567,89 RUB ");
}
{ // negative, showbase
long double v = -123456789;
showbase(ios);
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
true, ios, '*', v);
std::string ex(str, iter.base());
assert(ex == "-1 234 567,89 RUB ");
}
{ // negative, showbase, left
long double v = -123456789;
showbase(ios);
ios.width(20);
left(ios);
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
true, ios, ' ', v);
std::string ex(str, iter.base());
assert(ex == "-1 234 567,89 RUB ");
assert(ios.width() == 0);
}
{ // negative, showbase, internal
long double v = -123456789;
showbase(ios);
ios.width(20);
internal(ios);
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
true, ios, ' ', v);
std::string ex(str, iter.base());
assert(ex == "-1 234 567,89 RUB ");
assert(ios.width() == 0);
}
{ // negative, showbase, right
long double v = -123456789;
showbase(ios);
ios.width(20);
right(ios);
char str[100];
output_iterator<char*> iter = f.put(output_iterator<char*>(str),
true, ios, ' ', v);
std::string ex(str, iter.base());
assert(ex == " -1 234 567,89 RUB ");
assert(ios.width() == 0);
}
}
{
const my_facetw f(1);
// wchar_t, national
noshowbase(ios);
ios.unsetf(std::ios_base::adjustfield);
{ // zero
long double v = 0;
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
false, ios, '*', v);
std::wstring ex(str, iter.base());
assert(ex == L"0,00 ");
}
{ // negative one
long double v = -1;
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
false, ios, '*', v);
std::wstring ex(str, iter.base());
assert(ex == L"-0,01 ");
}
{ // positive
long double v = 123456789;
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
false, ios, '*', v);
std::wstring ex(str, iter.base());
assert(ex == L"1 234 567,89 ");
}
{ // negative
long double v = -123456789;
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
false, ios, '*', v);
std::wstring ex(str, iter.base());
assert(ex == L"-1 234 567,89 ");
}
{ // zero, showbase
long double v = 0;
showbase(ios);
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
false, ios, '*', v);
std::wstring ex(str, iter.base());
assert(ex == L"0,00 \x440\x443\x431"".");
}
{ // negative one, showbase
long double v = -1;
showbase(ios);
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
false, ios, '*', v);
std::wstring ex(str, iter.base());
assert(ex == L"-0,01 \x440\x443\x431"".");
}
{ // positive, showbase
long double v = 123456789;
showbase(ios);
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
false, ios, '*', v);
std::wstring ex(str, iter.base());
assert(ex == L"1 234 567,89 \x440\x443\x431"".");
}
{ // negative, showbase
long double v = -123456789;
showbase(ios);
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
false, ios, '*', v);
std::wstring ex(str, iter.base());
assert(ex == L"-1 234 567,89 \x440\x443\x431"".");
}
{ // negative, showbase, left
long double v = -123456789;
showbase(ios);
ios.width(20);
left(ios);
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
false, ios, ' ', v);
std::wstring ex(str, iter.base());
assert(ex == L"-1 234 567,89 \x440\x443\x431"". ");
assert(ios.width() == 0);
}
{ // negative, showbase, internal
long double v = -123456789;
showbase(ios);
ios.width(20);
internal(ios);
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
false, ios, ' ', v);
std::wstring ex(str, iter.base());
assert(ex == L"-1 234 567,89 \x440\x443\x431"".");
assert(ios.width() == 0);
}
{ // negative, showbase, right
long double v = -123456789;
showbase(ios);
ios.width(20);
right(ios);
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
false, ios, ' ', v);
std::wstring ex(str, iter.base());
assert(ex == L" -1 234 567,89 \x440\x443\x431"".");
assert(ios.width() == 0);
}
// wchar_t, international
noshowbase(ios);
ios.unsetf(std::ios_base::adjustfield);
{ // zero
long double v = 0;
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
true, ios, '*', v);
std::wstring ex(str, iter.base());
assert(ex == L"0,00 ");
}
{ // negative one
long double v = -1;
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
true, ios, '*', v);
std::wstring ex(str, iter.base());
assert(ex == L"-0,01 ");
}
{ // positive
long double v = 123456789;
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
true, ios, '*', v);
std::wstring ex(str, iter.base());
assert(ex == L"1 234 567,89 ");
}
{ // negative
long double v = -123456789;
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
true, ios, '*', v);
std::wstring ex(str, iter.base());
assert(ex == L"-1 234 567,89 ");
}
{ // zero, showbase
long double v = 0;
showbase(ios);
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
true, ios, '*', v);
std::wstring ex(str, iter.base());
assert(ex == L"0,00 RUB ");
}
{ // negative one, showbase
long double v = -1;
showbase(ios);
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
true, ios, '*', v);
std::wstring ex(str, iter.base());
assert(ex == L"-0,01 RUB ");
}
{ // positive, showbase
long double v = 123456789;
showbase(ios);
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
true, ios, '*', v);
std::wstring ex(str, iter.base());
assert(ex == L"1 234 567,89 RUB ");
}
{ // negative, showbase
long double v = -123456789;
showbase(ios);
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
true, ios, '*', v);
std::wstring ex(str, iter.base());
assert(ex == L"-1 234 567,89 RUB ");
}
{ // negative, showbase, left
long double v = -123456789;
showbase(ios);
ios.width(20);
left(ios);
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
true, ios, ' ', v);
std::wstring ex(str, iter.base());
assert(ex == L"-1 234 567,89 RUB ");
assert(ios.width() == 0);
}
{ // negative, showbase, internal
long double v = -123456789;
showbase(ios);
ios.width(20);
internal(ios);
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
true, ios, ' ', v);
std::wstring ex(str, iter.base());
assert(ex == L"-1 234 567,89 RUB ");
assert(ios.width() == 0);
}
{ // negative, showbase, right
long double v = -123456789;
showbase(ios);
ios.width(20);
right(ios);
wchar_t str[100];
output_iterator<wchar_t*> iter = f.put(output_iterator<wchar_t*>(str),
true, ios, ' ', v);
std::wstring ex(str, iter.base());
assert(ex == L" -1 234 567,89 RUB ");
assert(ios.width() == 0);
}
}
return 0;
}
