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()
{
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(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(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()
{
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()
{
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()
{
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);
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()
{
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);
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);
}
}
void test_negate() {
typedef typename std::make_signed<T>::type SignedT;
const my_facet f(1);
std::ios ios(0);
T v = 42;
{
T value = std::numeric_limits<SignedT>::max();
++value;
std::string std_str = make_neg_string(value);
const char* str = std_str.data();
size_t size = std_str.size();
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+size+1),
ios, err, v);
assert(iter.base() == str+size);
assert(err == ios.goodbit);
T expected = -value;
assert(v == expected);
}
v = 42;
{
T value = std::numeric_limits<SignedT>::max();
++value;
++value;
std::string std_str = make_neg_string(value);
const char* str = std_str.data();
size_t size = std_str.size();
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+size+1),
ios, err, v);
assert(iter.base() == str+size);
assert(err == ios.goodbit);
T expected = -value;
assert(v == expected);
}
v = 42;
{
T value = std::numeric_limits<T>::max();
std::string std_str = make_neg_string(value);
const char* str = std_str.data();
size_t size = std_str.size();
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+size+1),
ios, err, v);
assert(iter.base() == str+size);
assert(err == ios.goodbit);
T expected = -value;
assert(v == expected);
}
v = 42;
{
std::string std_str = make_neg_string(std::numeric_limits<T>::max());
std_str.back()++;
const char* str = std_str.data();
size_t size = std_str.size();
std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str),
input_iterator<const char*>(str+size+1),
ios, err, v);
assert(iter.base() == str+size);
assert(err == ios.failbit);
assert(v == T(-1));
}
}
