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