get_long_double_en_US.pass.cpp revision c0d0cbad9ed434267a7af9531bdeeae52eb6d706
1bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant//===----------------------------------------------------------------------===// 2bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// 3f5256e16dfc425c1d466f6308d4026d529ce9e0bHoward Hinnant// The LLVM Compiler Infrastructure 4bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// 5b64f8b07c104c6cc986570ac8ee0ed16a9f23976Howard Hinnant// This file is dual licensed under the MIT and the University of Illinois Open 6b64f8b07c104c6cc986570ac8ee0ed16a9f23976Howard Hinnant// Source Licenses. See LICENSE.TXT for details. 7bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// 8bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant//===----------------------------------------------------------------------===// 9bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 10bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// <locale> 11bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 12bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// class money_get<charT, InputIterator> 13bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 14bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// iter_type get(iter_type b, iter_type e, bool intl, ios_base& iob, 15bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// ios_base::iostate& err, long double& v) const; 16bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 17bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant#include <locale> 18bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant#include <ios> 19bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant#include <streambuf> 20bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant#include <cassert> 21bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant#include "iterators.h" 22bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 23c0d0cbad9ed434267a7af9531bdeeae52eb6d706Howard Hinnant#include "../../../../../platform_support.h" // locale name macros 24c0d0cbad9ed434267a7af9531bdeeae52eb6d706Howard Hinnant 25bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnanttypedef std::money_get<char, input_iterator<const char*> > Fn; 26bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 27bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnantclass my_facet 28bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant : public Fn 29bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant{ 30bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnantpublic: 31bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant explicit my_facet(std::size_t refs = 0) 32bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant : Fn(refs) {} 33bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant}; 34bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 35bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnanttypedef std::money_get<wchar_t, input_iterator<const wchar_t*> > Fw; 36bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 37bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnantclass my_facetw 38bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant : public Fw 39bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant{ 40bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnantpublic: 41bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant explicit my_facetw(std::size_t refs = 0) 42bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant : Fw(refs) {} 43bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant}; 44bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 45bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnantint main() 46bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant{ 47bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios ios(0); 48c0d0cbad9ed434267a7af9531bdeeae52eb6d706Howard Hinnant std::string loc_name(LOCALE_en_US_UTF_8); 49bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ios.imbue(std::locale(ios.getloc(), 50bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant new std::moneypunct_byname<char, false>(loc_name))); 51bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ios.imbue(std::locale(ios.getloc(), 52bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant new std::moneypunct_byname<char, true>(loc_name))); 53bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ios.imbue(std::locale(ios.getloc(), 54bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant new std::moneypunct_byname<wchar_t, false>(loc_name))); 55bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ios.imbue(std::locale(ios.getloc(), 56bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant new std::moneypunct_byname<wchar_t, true>(loc_name))); 57bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 58bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant const my_facet f(1); 59bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant // char, national 60bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // zero 61bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::string v = "0.00"; 62bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const char*> I; 63bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 64bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 65bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 66bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant false, ios, err, ex); 67bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 68bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 69bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == 0); 70bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 71bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // negative one 72bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::string v = "-0.01"; 73bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const char*> I; 74bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 75bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 76bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 77bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant false, ios, err, ex); 78bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 79bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 80bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == -1); 81bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 82bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // positive 83bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::string v = "1,234,567.89"; 84bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const char*> I; 85bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 86bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 87bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 88bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant false, ios, err, ex); 89bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 90bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 91bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == 123456789); 92bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 93bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // negative 94bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::string v = "-1,234,567.89"; 95bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const char*> I; 96bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 97bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 98bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 99bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant false, ios, err, ex); 100bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 101bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 102bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == -123456789); 103bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 104bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // negative 105bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::string v = "-1234567.89"; 106bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const char*> I; 107bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 108bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 109bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 110bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant false, ios, err, ex); 111bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 112bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 113bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == -123456789); 114bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 115bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // zero, showbase 116bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::string v = "$0.00"; 117bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const char*> I; 118bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 119bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 120bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 121bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant false, ios, err, ex); 122bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 123bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 124bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == 0); 125bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 126bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // zero, showbase 127bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::string v = "$0.00"; 128bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant showbase(ios); 129bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const char*> I; 130bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 131bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 132bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 133bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant false, ios, err, ex); 134bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 135bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 136bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == 0); 137bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant noshowbase(ios); 138bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 139bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // negative one, showbase 140bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::string v = "-$0.01"; 141bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const char*> I; 142bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 143bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 144bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 145bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant false, ios, err, ex); 146bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 147bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 148bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == -1); 149bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 150bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // negative one, showbase 151bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::string v = "-$0.01"; 152bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant showbase(ios); 153bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const char*> I; 154bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 155bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 156bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 157bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant false, ios, err, ex); 158bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 159bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 160bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == -1); 161bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant noshowbase(ios); 162bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 163bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // positive, showbase 164bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::string v = "$1,234,567.89"; 165bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const char*> I; 166bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 167bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 168bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 169bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant false, ios, err, ex); 170bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 171bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 172bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == 123456789); 173bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 174bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // positive, showbase 175bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::string v = "$1,234,567.89"; 176bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant showbase(ios); 177bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const char*> I; 178bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 179bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 180bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 181bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant false, ios, err, ex); 182bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 183bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 184bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == 123456789); 185bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant noshowbase(ios); 186bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 187bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // negative, showbase 188bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::string v = "-$1,234,567.89"; 189bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant showbase(ios); 190bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const char*> I; 191bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 192bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 193bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 194bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant false, ios, err, ex); 195bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 196bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 197bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == -123456789); 198bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant noshowbase(ios); 199bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 200bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // negative, showbase 201bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::string v = "-USD 1,234,567.89"; 202bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant showbase(ios); 203bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const char*> I; 204bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 205bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 206bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 207bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant false, ios, err, ex); 208bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + 1); 209bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::failbit); 210bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant noshowbase(ios); 211bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 212bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // negative, showbase 213bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::string v = "-USD 1,234,567.89"; 214bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const char*> I; 215bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 216bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 217bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 218bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant false, ios, err, ex); 219bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + 1); 220bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::failbit); 221bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 222bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 223bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 224bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant const my_facet f(1); 225bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant // char, international 226bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // zero 227bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::string v = "0.00"; 228bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const char*> I; 229bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 230bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 231bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 232bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant true, ios, err, ex); 233bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 234bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 235bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == 0); 236bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 237bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // negative one 238bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::string v = "-0.01"; 239bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const char*> I; 240bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 241bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 242bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 243bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant true, ios, err, ex); 244bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 245bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 246bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == -1); 247bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 248bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // positive 249bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::string v = "1,234,567.89"; 250bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const char*> I; 251bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 252bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 253bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 254bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant true, ios, err, ex); 255bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 256bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 257bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == 123456789); 258bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 259bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // negative 260bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::string v = "-1,234,567.89"; 261bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const char*> I; 262bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 263bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 264bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 265bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant true, ios, err, ex); 266bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 267bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 268bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == -123456789); 269bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 270bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // negative 271bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::string v = "-1234567.89"; 272bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const char*> I; 273bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 274bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 275bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 276bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant true, ios, err, ex); 277bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 278bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 279bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == -123456789); 280bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 281bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // zero, showbase 282bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::string v = "USD 0.00"; 283bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const char*> I; 284bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 285bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 286bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 287bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant true, ios, err, ex); 288bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 289bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 290bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == 0); 291bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 292bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // zero, showbase 293bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::string v = "USD 0.00"; 294bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant showbase(ios); 295bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const char*> I; 296bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 297bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 298bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 299bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant true, ios, err, ex); 300bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 301bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 302bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == 0); 303bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant noshowbase(ios); 304bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 305bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // negative one, showbase 306bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::string v = "-USD 0.01"; 307bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const char*> I; 308bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 309bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 310bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 311bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant true, ios, err, ex); 312bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 313bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 314bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == -1); 315bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 316bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // negative one, showbase 317bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::string v = "-USD 0.01"; 318bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant showbase(ios); 319bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const char*> I; 320bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 321bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 322bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 323bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant true, ios, err, ex); 324bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 325bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 326bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == -1); 327bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant noshowbase(ios); 328bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 329bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // positive, showbase 330bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::string v = "USD 1,234,567.89"; 331bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const char*> I; 332bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 333bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 334bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 335bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant true, ios, err, ex); 336bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 337bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 338bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == 123456789); 339bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 340bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // positive, showbase 341bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::string v = "USD 1,234,567.89"; 342bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant showbase(ios); 343bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const char*> I; 344bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 345bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 346bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 347bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant true, ios, err, ex); 348bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 349bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 350bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == 123456789); 351bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant noshowbase(ios); 352bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 353bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // negative, showbase 354bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::string v = "-USD 1,234,567.89"; 355bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant showbase(ios); 356bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const char*> I; 357bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 358bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 359bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 360bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant true, ios, err, ex); 361bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 362bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 363bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == -123456789); 364bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant noshowbase(ios); 365bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 366bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // negative, showbase 367bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::string v = "-$1,234,567.89"; 368bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant showbase(ios); 369bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const char*> I; 370bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 371bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 372bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 373bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant true, ios, err, ex); 374bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + 1); 375bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::failbit); 376bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant noshowbase(ios); 377bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 378bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // negative, showbase 379bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::string v = "-$1,234,567.89"; 380bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const char*> I; 381bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 382bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 383bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 384bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant true, ios, err, ex); 385bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + 1); 386bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::failbit); 387bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 388bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 389bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 390bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant const my_facetw f(1); 391bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant // wchar_t, national 392bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // zero 393bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::wstring v = L"0.00"; 394bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const wchar_t*> I; 395bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 396bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 397bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 398bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant false, ios, err, ex); 399bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 400bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 401bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == 0); 402bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 403bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // negative one 404bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::wstring v = L"-0.01"; 405bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const wchar_t*> I; 406bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 407bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 408bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 409bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant false, ios, err, ex); 410bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 411bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 412bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == -1); 413bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 414bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // positive 415bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::wstring v = L"1,234,567.89"; 416bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const wchar_t*> I; 417bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 418bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 419bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 420bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant false, ios, err, ex); 421bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 422bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 423bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == 123456789); 424bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 425bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // negative 426bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::wstring v = L"-1,234,567.89"; 427bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const wchar_t*> I; 428bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 429bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 430bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 431bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant false, ios, err, ex); 432bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 433bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 434bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == -123456789); 435bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 436bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // negative 437bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::wstring v = L"-1234567.89"; 438bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const wchar_t*> I; 439bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 440bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 441bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 442bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant false, ios, err, ex); 443bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 444bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 445bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == -123456789); 446bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 447bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // zero, showbase 448bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::wstring v = L"$0.00"; 449bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const wchar_t*> I; 450bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 451bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 452bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 453bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant false, ios, err, ex); 454bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 455bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 456bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == 0); 457bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 458bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // zero, showbase 459bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::wstring v = L"$0.00"; 460bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant showbase(ios); 461bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const wchar_t*> I; 462bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 463bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 464bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 465bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant false, ios, err, ex); 466bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 467bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 468bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == 0); 469bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant noshowbase(ios); 470bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 471bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // negative one, showbase 472bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::wstring v = L"-$0.01"; 473bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const wchar_t*> I; 474bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 475bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 476bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 477bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant false, ios, err, ex); 478bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 479bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 480bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == -1); 481bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 482bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // negative one, showbase 483bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::wstring v = L"-$0.01"; 484bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant showbase(ios); 485bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const wchar_t*> I; 486bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 487bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 488bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 489bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant false, ios, err, ex); 490bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 491bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 492bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == -1); 493bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant noshowbase(ios); 494bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 495bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // positive, showbase 496bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::wstring v = L"$1,234,567.89"; 497bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const wchar_t*> I; 498bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 499bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 500bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 501bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant false, ios, err, ex); 502bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 503bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 504bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == 123456789); 505bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 506bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // positive, showbase 507bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::wstring v = L"$1,234,567.89"; 508bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant showbase(ios); 509bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const wchar_t*> I; 510bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 511bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 512bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 513bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant false, ios, err, ex); 514bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 515bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 516bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == 123456789); 517bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant noshowbase(ios); 518bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 519bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // negative, showbase 520bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::wstring v = L"-$1,234,567.89"; 521bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant showbase(ios); 522bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const wchar_t*> I; 523bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 524bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 525bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 526bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant false, ios, err, ex); 527bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 528bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 529bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == -123456789); 530bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant noshowbase(ios); 531bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 532bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // negative, showbase 533bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::wstring v = L"-USD 1,234,567.89"; 534bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant showbase(ios); 535bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const wchar_t*> I; 536bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 537bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 538bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 539bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant false, ios, err, ex); 540bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + 1); 541bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::failbit); 542bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant noshowbase(ios); 543bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 544bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // negative, showbase 545bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::wstring v = L"-USD 1,234,567.89"; 546bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const wchar_t*> I; 547bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 548bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 549bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 550bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant false, ios, err, ex); 551bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + 1); 552bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::failbit); 553bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 554bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 555bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { 556bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant const my_facetw f(1); 557bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant // wchar_t, international 558bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // zero 559bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::wstring v = L"0.00"; 560bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const wchar_t*> I; 561bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 562bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 563bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 564bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant true, ios, err, ex); 565bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 566bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 567bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == 0); 568bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 569bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // negative one 570bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::wstring v = L"-0.01"; 571bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const wchar_t*> I; 572bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 573bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 574bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 575bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant true, ios, err, ex); 576bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 577bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 578bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == -1); 579bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 580bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // positive 581bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::wstring v = L"1,234,567.89"; 582bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const wchar_t*> I; 583bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 584bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 585bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 586bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant true, ios, err, ex); 587bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 588bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 589bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == 123456789); 590bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 591bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // negative 592bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::wstring v = L"-1,234,567.89"; 593bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const wchar_t*> I; 594bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 595bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 596bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 597bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant true, ios, err, ex); 598bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 599bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 600bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == -123456789); 601bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 602bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // negative 603bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::wstring v = L"-1234567.89"; 604bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const wchar_t*> I; 605bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 606bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 607bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 608bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant true, ios, err, ex); 609bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 610bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 611bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == -123456789); 612bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 613bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // zero, showbase 614bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::wstring v = L"USD 0.00"; 615bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const wchar_t*> I; 616bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 617bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 618bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 619bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant true, ios, err, ex); 620bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 621bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 622bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == 0); 623bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 624bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // zero, showbase 625bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::wstring v = L"USD 0.00"; 626bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant showbase(ios); 627bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const wchar_t*> I; 628bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 629bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 630bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 631bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant true, ios, err, ex); 632bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 633bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 634bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == 0); 635bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant noshowbase(ios); 636bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 637bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // negative one, showbase 638bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::wstring v = L"-USD 0.01"; 639bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const wchar_t*> I; 640bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 641bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 642bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 643bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant true, ios, err, ex); 644bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 645bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 646bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == -1); 647bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 648bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // negative one, showbase 649bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::wstring v = L"-USD 0.01"; 650bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant showbase(ios); 651bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const wchar_t*> I; 652bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 653bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 654bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 655bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant true, ios, err, ex); 656bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 657bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 658bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == -1); 659bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant noshowbase(ios); 660bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 661bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // positive, showbase 662bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::wstring v = L"USD 1,234,567.89"; 663bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const wchar_t*> I; 664bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 665bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 666bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 667bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant true, ios, err, ex); 668bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 669bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 670bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == 123456789); 671bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 672bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // positive, showbase 673bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::wstring v = L"USD 1,234,567.89"; 674bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant showbase(ios); 675bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const wchar_t*> I; 676bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 677bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 678bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 679bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant true, ios, err, ex); 680bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 681bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 682bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == 123456789); 683bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant noshowbase(ios); 684bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 685bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // negative, showbase 686bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::wstring v = L"-USD 1,234,567.89"; 687bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant showbase(ios); 688bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const wchar_t*> I; 689bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 690bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 691bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 692bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant true, ios, err, ex); 693bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + v.size()); 694bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::eofbit); 695bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ex == -123456789); 696bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant noshowbase(ios); 697bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 698bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // negative, showbase 699bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::wstring v = L"-$1,234,567.89"; 700bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant showbase(ios); 701bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const wchar_t*> I; 702bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 703bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 704bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 705bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant true, ios, err, ex); 706bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + 1); 707bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::failbit); 708bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant noshowbase(ios); 709bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 710bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant { // negative, showbase 711bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::wstring v = L"-$1,234,567.89"; 712bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant typedef input_iterator<const wchar_t*> I; 713bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant long double ex; 714bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::ios_base::iostate err = std::ios_base::goodbit; 715bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant I iter = f.get(I(v.data()), I(v.data() + v.size()), 716bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant true, ios, err, ex); 717bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(iter.base() == v.data() + 1); 718bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(err == std::ios_base::failbit); 719bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 720bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant } 721bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant} 722