get_long_double_zh_CN.pass.cpp revision bc8d3f97eb5c958007f2713238472e0c1c8fe02c
195c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley//===----------------------------------------------------------------------===// 295c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley// 395c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley// ��������������������The LLVM Compiler Infrastructure 495c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley// 595c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley// This file is distributed under the University of Illinois Open Source 695c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley// License. See LICENSE.TXT for details. 795c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley// 895c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley//===----------------------------------------------------------------------===// 995c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley 1095c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley// <locale> 1195c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley 1295c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley// class money_get<charT, InputIterator> 1395c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley 1495c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley// iter_type get(iter_type b, iter_type e, bool intl, ios_base& iob, 1595c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley// ios_base::iostate& err, long double& v) const; 1695c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley 1795c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley#include <locale> 1895c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley#include <ios> 1995c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley#include <streambuf> 2095c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley#include <cassert> 2195c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley#include "iterators.h" 2295c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley 2395c29f3cd1f6c08c6c0927868683392eea727ccAdam Langleytypedef std::money_get<char, input_iterator<const char*> > Fn; 2495c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley 2595c29f3cd1f6c08c6c0927868683392eea727ccAdam Langleyclass my_facet 2695c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley : public Fn 2795c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley{ 2895c29f3cd1f6c08c6c0927868683392eea727ccAdam Langleypublic: 2995c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley explicit my_facet(std::size_t refs = 0) 3095c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley : Fn(refs) {} 3195c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley}; 3295c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley 3395c29f3cd1f6c08c6c0927868683392eea727ccAdam Langleytypedef std::money_get<wchar_t, input_iterator<const wchar_t*> > Fw; 3495c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley 3595c29f3cd1f6c08c6c0927868683392eea727ccAdam Langleyclass my_facetw 3695c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley : public Fw 3795c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley{ 3895c29f3cd1f6c08c6c0927868683392eea727ccAdam Langleypublic: 3995c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley explicit my_facetw(std::size_t refs = 0) 4095c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley : Fw(refs) {} 4195c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley}; 4295c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley 4395c29f3cd1f6c08c6c0927868683392eea727ccAdam Langleyint main() 4495c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley{ 4595c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::ios ios(0); 4695c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::string loc_name("zh_CN"); 4795c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley ios.imbue(std::locale(ios.getloc(), 4895c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley new std::moneypunct_byname<char, false>(loc_name))); 4995c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley ios.imbue(std::locale(ios.getloc(), 5095c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley new std::moneypunct_byname<char, true>(loc_name))); 5195c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley ios.imbue(std::locale(ios.getloc(), 5295c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley new std::moneypunct_byname<wchar_t, false>(loc_name))); 5395c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley ios.imbue(std::locale(ios.getloc(), 5495c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley new std::moneypunct_byname<wchar_t, true>(loc_name))); 5595c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley { 5695c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley const my_facet f(1); 5795c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley // char, national 5895c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley { // zero 5995c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::string v = "0.00"; 6095c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley typedef input_iterator<const char*> I; 6195c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley long double ex; 6295c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::ios_base::iostate err = std::ios_base::goodbit; 6395c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley I iter = f.get(I(v.data()), I(v.data() + v.size()), 6495c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley false, ios, err, ex); 6595c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(iter.base() == v.data() + v.size()); 6695c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(err == std::ios_base::eofbit); 6795c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(ex == 0); 6895c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley } 6995c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley { // negative one 7095c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::string v = "-0.01"; 7195c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley typedef input_iterator<const char*> I; 7295c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley long double ex; 7395c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::ios_base::iostate err = std::ios_base::goodbit; 74a09d2127eaeaab15d520c7e5dd964b72dba9597fAdam Langley I iter = f.get(I(v.data()), I(v.data() + v.size()), 7595c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley false, ios, err, ex); 7695c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(iter.base() == v.data() + v.size()); 7795c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(err == std::ios_base::eofbit); 7895c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(ex == -1); 7995c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley } 8095c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley { // positive 8195c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::string v = "1,234,567.89"; 8295c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley typedef input_iterator<const char*> I; 8395c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley long double ex; 8495c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::ios_base::iostate err = std::ios_base::goodbit; 8595c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley I iter = f.get(I(v.data()), I(v.data() + v.size()), 8695c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley false, ios, err, ex); 8795c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(iter.base() == v.data() + v.size()); 8895c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(err == std::ios_base::eofbit); 8995c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(ex == 123456789); 9095c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley } 9195c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley { // negative 9295c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::string v = "-1,234,567.89"; 9395c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley typedef input_iterator<const char*> I; 9495c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley long double ex; 9595c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::ios_base::iostate err = std::ios_base::goodbit; 9695c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley I iter = f.get(I(v.data()), I(v.data() + v.size()), 9795c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley false, ios, err, ex); 9895c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(iter.base() == v.data() + v.size()); 9995c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(err == std::ios_base::eofbit); 10095c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(ex == -123456789); 10195c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley } 10295c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley { // negative 10395c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::string v = "-1234567.89"; 10495c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley typedef input_iterator<const char*> I; 10595c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley long double ex; 10695c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::ios_base::iostate err = std::ios_base::goodbit; 10795c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley I iter = f.get(I(v.data()), I(v.data() + v.size()), 10895c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley false, ios, err, ex); 10995c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(iter.base() == v.data() + v.size()); 11095c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(err == std::ios_base::eofbit); 11195c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(ex == -123456789); 11295c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley } 11395c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley { // zero, showbase 11495c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::string v = "\xEF\xBF\xA5""0.00"; 11595c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley typedef input_iterator<const char*> I; 11695c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley long double ex; 11795c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::ios_base::iostate err = std::ios_base::goodbit; 11895c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley I iter = f.get(I(v.data()), I(v.data() + v.size()), 11995c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley false, ios, err, ex); 12095c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(iter.base() == v.data() + v.size()); 12195c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(err == std::ios_base::eofbit); 12295c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(ex == 0); 12395c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley } 12495c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley { // zero, showbase 12595c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::string v = "\xEF\xBF\xA5""0.00"; 12695c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley showbase(ios); 12795c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley typedef input_iterator<const char*> I; 12895c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley long double ex; 12995c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::ios_base::iostate err = std::ios_base::goodbit; 13095c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley I iter = f.get(I(v.data()), I(v.data() + v.size()), 13195c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley false, ios, err, ex); 13295c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(iter.base() == v.data() + v.size()); 13395c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(err == std::ios_base::eofbit); 13495c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(ex == 0); 13595c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley noshowbase(ios); 13695c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley } 13795c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley { // negative one, showbase 13895c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::string v = "\xEF\xBF\xA5""-0.01"; 13995c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley typedef input_iterator<const char*> I; 14095c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley long double ex; 14195c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::ios_base::iostate err = std::ios_base::goodbit; 14295c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley I iter = f.get(I(v.data()), I(v.data() + v.size()), 14395c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley false, ios, err, ex); 14495c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(iter.base() == v.data() + v.size()); 14595c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(err == std::ios_base::eofbit); 14695c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(ex == -1); 14795c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley } 14895c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley { // negative one, showbase 14995c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::string v = "\xEF\xBF\xA5""-0.01"; 15095c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley showbase(ios); 15195c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley typedef input_iterator<const char*> I; 15295c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley long double ex; 15395c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::ios_base::iostate err = std::ios_base::goodbit; 15495c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley I iter = f.get(I(v.data()), I(v.data() + v.size()), 15595c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley false, ios, err, ex); 15695c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(iter.base() == v.data() + v.size()); 15795c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(err == std::ios_base::eofbit); 15895c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(ex == -1); 15995c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley noshowbase(ios); 16095c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley } 16195c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley { // positive, showbase 16295c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::string v = "\xEF\xBF\xA5""1,234,567.89"; 16395c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley typedef input_iterator<const char*> I; 16495c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley long double ex; 16595c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::ios_base::iostate err = std::ios_base::goodbit; 16695c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley I iter = f.get(I(v.data()), I(v.data() + v.size()), 16795c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley false, ios, err, ex); 16895c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(iter.base() == v.data() + v.size()); 16995c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(err == std::ios_base::eofbit); 17095c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(ex == 123456789); 17195c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley } 17295c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley { // positive, showbase 17395c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::string v = "\xEF\xBF\xA5""1,234,567.89"; 17495c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley showbase(ios); 17595c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley typedef input_iterator<const char*> I; 17695c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley long double ex; 17795c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::ios_base::iostate err = std::ios_base::goodbit; 17895c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley I iter = f.get(I(v.data()), I(v.data() + v.size()), 17995c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley false, ios, err, ex); 18095c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(iter.base() == v.data() + v.size()); 18195c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(err == std::ios_base::eofbit); 18295c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(ex == 123456789); 18395c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley noshowbase(ios); 18495c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley } 18595c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley { // negative, showbase 18695c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::string v = "\xEF\xBF\xA5""-1,234,567.89"; 18795c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley showbase(ios); 18895c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley typedef input_iterator<const char*> I; 18995c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley long double ex; 19095c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::ios_base::iostate err = std::ios_base::goodbit; 19195c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley I iter = f.get(I(v.data()), I(v.data() + v.size()), 19295c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley false, ios, err, ex); 19395c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(iter.base() == v.data() + v.size()); 19495c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(err == std::ios_base::eofbit); 19595c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(ex == -123456789); 19695c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley noshowbase(ios); 19795c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley } 19895c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley { // negative, showbase 19995c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::string v = "CNY -1,234,567.89"; 20095c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley showbase(ios); 20195c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley typedef input_iterator<const char*> I; 20295c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley long double ex; 20395c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::ios_base::iostate err = std::ios_base::goodbit; 20495c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley I iter = f.get(I(v.data()), I(v.data() + v.size()), 20595c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley false, ios, err, ex); 20695c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(iter.base() == v.data() + 0); 20795c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(err == std::ios_base::failbit); 20895c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley noshowbase(ios); 20995c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley } 21095c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley { // negative, showbase 21195c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::string v = "CNY -1,234,567.89"; 21295c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley typedef input_iterator<const char*> I; 21395c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley long double ex; 21495c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::ios_base::iostate err = std::ios_base::goodbit; 21595c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley I iter = f.get(I(v.data()), I(v.data() + v.size()), 21695c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley false, ios, err, ex); 21795c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(iter.base() == v.data() + 0); 21895c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(err == std::ios_base::failbit); 21995c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley } 22095c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley } 22195c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley { 22295c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley const my_facet f(1); 22395c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley // char, international 22495c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley { // zero 22595c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::string v = "0.00"; 22695c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley typedef input_iterator<const char*> I; 22795c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley long double ex; 22895c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::ios_base::iostate err = std::ios_base::goodbit; 22995c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley I iter = f.get(I(v.data()), I(v.data() + v.size()), 23095c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley true, ios, err, ex); 23195c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(iter.base() == v.data() + v.size()); 23295c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(err == std::ios_base::eofbit); 23395c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(ex == 0); 23495c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley } 23595c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley { // negative one 23695c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::string v = "-0.01"; 23795c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley typedef input_iterator<const char*> I; 23895c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley long double ex; 23995c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::ios_base::iostate err = std::ios_base::goodbit; 24095c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley I iter = f.get(I(v.data()), I(v.data() + v.size()), 24195c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley true, ios, err, ex); 24295c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(iter.base() == v.data() + v.size()); 24395c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(err == std::ios_base::eofbit); 24495c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(ex == -1); 24595c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley } 24695c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley { // positive 24795c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::string v = "1,234,567.89"; 24895c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley typedef input_iterator<const char*> I; 24995c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley long double ex; 25095c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::ios_base::iostate err = std::ios_base::goodbit; 25195c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley I iter = f.get(I(v.data()), I(v.data() + v.size()), 25295c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley true, ios, err, ex); 25395c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(iter.base() == v.data() + v.size()); 254c44d2f4cb8a892a603edbbe710fa82bcd30f9cb5David Benjamin assert(err == std::ios_base::eofbit); 255c44d2f4cb8a892a603edbbe710fa82bcd30f9cb5David Benjamin assert(ex == 123456789); 25695c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley } 25795c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley { // negative 25895c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::string v = "-1,234,567.89"; 25995c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley typedef input_iterator<const char*> I; 26095c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley long double ex; 26195c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::ios_base::iostate err = std::ios_base::goodbit; 26295c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley I iter = f.get(I(v.data()), I(v.data() + v.size()), 26395c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley true, ios, err, ex); 26495c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(iter.base() == v.data() + v.size()); 26595c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(err == std::ios_base::eofbit); 26695c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(ex == -123456789); 26795c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley } 26895c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley { // negative 26995c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::string v = "-1234567.89"; 27095c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley typedef input_iterator<const char*> I; 27195c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley long double ex; 27295c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::ios_base::iostate err = std::ios_base::goodbit; 27395c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley I iter = f.get(I(v.data()), I(v.data() + v.size()), 27495c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley true, ios, err, ex); 27595c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(iter.base() == v.data() + v.size()); 27695c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(err == std::ios_base::eofbit); 27795c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley assert(ex == -123456789); 27895c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley } 27995c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley { // zero, showbase 28095c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::string v = "CNY 0.00"; 28195c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley typedef input_iterator<const char*> I; 282c44d2f4cb8a892a603edbbe710fa82bcd30f9cb5David Benjamin long double ex; 28395c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley std::ios_base::iostate err = std::ios_base::goodbit; 28495c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley I iter = f.get(I(v.data()), I(v.data() + v.size()), 28595c29f3cd1f6c08c6c0927868683392eea727ccAdam Langley true, ios, err, ex); 286 assert(iter.base() == v.data() + v.size()); 287 assert(err == std::ios_base::eofbit); 288 assert(ex == 0); 289 } 290 { // zero, showbase 291 std::string v = "CNY 0.00"; 292 showbase(ios); 293 typedef input_iterator<const char*> I; 294 long double ex; 295 std::ios_base::iostate err = std::ios_base::goodbit; 296 I iter = f.get(I(v.data()), I(v.data() + v.size()), 297 true, ios, err, ex); 298 assert(iter.base() == v.data() + v.size()); 299 assert(err == std::ios_base::eofbit); 300 assert(ex == 0); 301 noshowbase(ios); 302 } 303 { // negative one, showbase 304 std::string v = "CNY -0.01"; 305 typedef input_iterator<const char*> I; 306 long double ex; 307 std::ios_base::iostate err = std::ios_base::goodbit; 308 I iter = f.get(I(v.data()), I(v.data() + v.size()), 309 true, ios, err, ex); 310 assert(iter.base() == v.data() + v.size()); 311 assert(err == std::ios_base::eofbit); 312 assert(ex == -1); 313 } 314 { // negative one, showbase 315 std::string v = "CNY -0.01"; 316 showbase(ios); 317 typedef input_iterator<const char*> I; 318 long double ex; 319 std::ios_base::iostate err = std::ios_base::goodbit; 320 I iter = f.get(I(v.data()), I(v.data() + v.size()), 321 true, ios, err, ex); 322 assert(iter.base() == v.data() + v.size()); 323 assert(err == std::ios_base::eofbit); 324 assert(ex == -1); 325 noshowbase(ios); 326 } 327 { // positive, showbase 328 std::string v = "CNY 1,234,567.89"; 329 typedef input_iterator<const char*> I; 330 long double ex; 331 std::ios_base::iostate err = std::ios_base::goodbit; 332 I iter = f.get(I(v.data()), I(v.data() + v.size()), 333 true, ios, err, ex); 334 assert(iter.base() == v.data() + v.size()); 335 assert(err == std::ios_base::eofbit); 336 assert(ex == 123456789); 337 } 338 { // positive, showbase 339 std::string v = "CNY 1,234,567.89"; 340 showbase(ios); 341 typedef input_iterator<const char*> I; 342 long double ex; 343 std::ios_base::iostate err = std::ios_base::goodbit; 344 I iter = f.get(I(v.data()), I(v.data() + v.size()), 345 true, ios, err, ex); 346 assert(iter.base() == v.data() + v.size()); 347 assert(err == std::ios_base::eofbit); 348 assert(ex == 123456789); 349 noshowbase(ios); 350 } 351 { // negative, showbase 352 std::string v = "CNY -1,234,567.89"; 353 showbase(ios); 354 typedef input_iterator<const char*> I; 355 long double ex; 356 std::ios_base::iostate err = std::ios_base::goodbit; 357 I iter = f.get(I(v.data()), I(v.data() + v.size()), 358 true, ios, err, ex); 359 assert(iter.base() == v.data() + v.size()); 360 assert(err == std::ios_base::eofbit); 361 assert(ex == -123456789); 362 noshowbase(ios); 363 } 364 { // negative, showbase 365 std::string v = "\xEF\xBF\xA5""-1,234,567.89"; 366 showbase(ios); 367 typedef input_iterator<const char*> I; 368 long double ex; 369 std::ios_base::iostate err = std::ios_base::goodbit; 370 I iter = f.get(I(v.data()), I(v.data() + v.size()), 371 true, ios, err, ex); 372 assert(iter.base() == v.data() + 0); 373 assert(err == std::ios_base::failbit); 374 noshowbase(ios); 375 } 376 { // negative, showbase 377 std::string v = "\xEF\xBF\xA5""-1,234,567.89"; 378 typedef input_iterator<const char*> I; 379 long double ex; 380 std::ios_base::iostate err = std::ios_base::goodbit; 381 I iter = f.get(I(v.data()), I(v.data() + v.size()), 382 true, ios, err, ex); 383 assert(iter.base() == v.data() + 0); 384 assert(err == std::ios_base::failbit); 385 } 386 } 387 { 388 const my_facetw f(1); 389 // wchar_t, national 390 { // zero 391 std::wstring v = L"0.00"; 392 typedef input_iterator<const wchar_t*> I; 393 long double ex; 394 std::ios_base::iostate err = std::ios_base::goodbit; 395 I iter = f.get(I(v.data()), I(v.data() + v.size()), 396 false, ios, err, ex); 397 assert(iter.base() == v.data() + v.size()); 398 assert(err == std::ios_base::eofbit); 399 assert(ex == 0); 400 } 401 { // negative one 402 std::wstring v = L"-0.01"; 403 typedef input_iterator<const wchar_t*> I; 404 long double ex; 405 std::ios_base::iostate err = std::ios_base::goodbit; 406 I iter = f.get(I(v.data()), I(v.data() + v.size()), 407 false, ios, err, ex); 408 assert(iter.base() == v.data() + v.size()); 409 assert(err == std::ios_base::eofbit); 410 assert(ex == -1); 411 } 412 { // positive 413 std::wstring v = L"1,234,567.89"; 414 typedef input_iterator<const wchar_t*> I; 415 long double ex; 416 std::ios_base::iostate err = std::ios_base::goodbit; 417 I iter = f.get(I(v.data()), I(v.data() + v.size()), 418 false, ios, err, ex); 419 assert(iter.base() == v.data() + v.size()); 420 assert(err == std::ios_base::eofbit); 421 assert(ex == 123456789); 422 } 423 { // negative 424 std::wstring v = L"-1,234,567.89"; 425 typedef input_iterator<const wchar_t*> I; 426 long double ex; 427 std::ios_base::iostate err = std::ios_base::goodbit; 428 I iter = f.get(I(v.data()), I(v.data() + v.size()), 429 false, ios, err, ex); 430 assert(iter.base() == v.data() + v.size()); 431 assert(err == std::ios_base::eofbit); 432 assert(ex == -123456789); 433 } 434 { // negative 435 std::wstring v = L"-1234567.89"; 436 typedef input_iterator<const wchar_t*> I; 437 long double ex; 438 std::ios_base::iostate err = std::ios_base::goodbit; 439 I iter = f.get(I(v.data()), I(v.data() + v.size()), 440 false, ios, err, ex); 441 assert(iter.base() == v.data() + v.size()); 442 assert(err == std::ios_base::eofbit); 443 assert(ex == -123456789); 444 } 445 { // zero, showbase 446 std::wstring v = L"\xFFE5""0.00"; 447 typedef input_iterator<const wchar_t*> I; 448 long double ex; 449 std::ios_base::iostate err = std::ios_base::goodbit; 450 I iter = f.get(I(v.data()), I(v.data() + v.size()), 451 false, ios, err, ex); 452 assert(iter.base() == v.data() + v.size()); 453 assert(err == std::ios_base::eofbit); 454 assert(ex == 0); 455 } 456 { // zero, showbase 457 std::wstring v = L"\xFFE5""0.00"; 458 showbase(ios); 459 typedef input_iterator<const wchar_t*> I; 460 long double ex; 461 std::ios_base::iostate err = std::ios_base::goodbit; 462 I iter = f.get(I(v.data()), I(v.data() + v.size()), 463 false, ios, err, ex); 464 assert(iter.base() == v.data() + v.size()); 465 assert(err == std::ios_base::eofbit); 466 assert(ex == 0); 467 noshowbase(ios); 468 } 469 { // negative one, showbase 470 std::wstring v = L"\xFFE5""-0.01"; 471 typedef input_iterator<const wchar_t*> I; 472 long double ex; 473 std::ios_base::iostate err = std::ios_base::goodbit; 474 I iter = f.get(I(v.data()), I(v.data() + v.size()), 475 false, ios, err, ex); 476 assert(iter.base() == v.data() + v.size()); 477 assert(err == std::ios_base::eofbit); 478 assert(ex == -1); 479 } 480 { // negative one, showbase 481 std::wstring v = L"\xFFE5""-0.01"; 482 showbase(ios); 483 typedef input_iterator<const wchar_t*> I; 484 long double ex; 485 std::ios_base::iostate err = std::ios_base::goodbit; 486 I iter = f.get(I(v.data()), I(v.data() + v.size()), 487 false, ios, err, ex); 488 assert(iter.base() == v.data() + v.size()); 489 assert(err == std::ios_base::eofbit); 490 assert(ex == -1); 491 noshowbase(ios); 492 } 493 { // positive, showbase 494 std::wstring v = L"\xFFE5""1,234,567.89"; 495 typedef input_iterator<const wchar_t*> I; 496 long double ex; 497 std::ios_base::iostate err = std::ios_base::goodbit; 498 I iter = f.get(I(v.data()), I(v.data() + v.size()), 499 false, ios, err, ex); 500 assert(iter.base() == v.data() + v.size()); 501 assert(err == std::ios_base::eofbit); 502 assert(ex == 123456789); 503 } 504 { // positive, showbase 505 std::wstring v = L"\xFFE5""1,234,567.89"; 506 showbase(ios); 507 typedef input_iterator<const wchar_t*> I; 508 long double ex; 509 std::ios_base::iostate err = std::ios_base::goodbit; 510 I iter = f.get(I(v.data()), I(v.data() + v.size()), 511 false, ios, err, ex); 512 assert(iter.base() == v.data() + v.size()); 513 assert(err == std::ios_base::eofbit); 514 assert(ex == 123456789); 515 noshowbase(ios); 516 } 517 { // negative, showbase 518 std::wstring v = L"\xFFE5""-1,234,567.89"; 519 showbase(ios); 520 typedef input_iterator<const wchar_t*> I; 521 long double ex; 522 std::ios_base::iostate err = std::ios_base::goodbit; 523 I iter = f.get(I(v.data()), I(v.data() + v.size()), 524 false, ios, err, ex); 525 assert(iter.base() == v.data() + v.size()); 526 assert(err == std::ios_base::eofbit); 527 assert(ex == -123456789); 528 noshowbase(ios); 529 } 530 { // negative, showbase 531 std::wstring v = L"CNY -1,234,567.89"; 532 showbase(ios); 533 typedef input_iterator<const wchar_t*> I; 534 long double ex; 535 std::ios_base::iostate err = std::ios_base::goodbit; 536 I iter = f.get(I(v.data()), I(v.data() + v.size()), 537 false, ios, err, ex); 538 assert(iter.base() == v.data() + 0); 539 assert(err == std::ios_base::failbit); 540 noshowbase(ios); 541 } 542 { // negative, showbase 543 std::wstring v = L"CNY -1,234,567.89"; 544 typedef input_iterator<const wchar_t*> I; 545 long double ex; 546 std::ios_base::iostate err = std::ios_base::goodbit; 547 I iter = f.get(I(v.data()), I(v.data() + v.size()), 548 false, ios, err, ex); 549 assert(iter.base() == v.data() + 0); 550 assert(err == std::ios_base::failbit); 551 } 552 } 553 { 554 const my_facetw f(1); 555 // wchar_t, international 556 { // zero 557 std::wstring v = L"0.00"; 558 typedef input_iterator<const wchar_t*> I; 559 long double ex; 560 std::ios_base::iostate err = std::ios_base::goodbit; 561 I iter = f.get(I(v.data()), I(v.data() + v.size()), 562 true, ios, err, ex); 563 assert(iter.base() == v.data() + v.size()); 564 assert(err == std::ios_base::eofbit); 565 assert(ex == 0); 566 } 567 { // negative one 568 std::wstring v = L"-0.01"; 569 typedef input_iterator<const wchar_t*> I; 570 long double ex; 571 std::ios_base::iostate err = std::ios_base::goodbit; 572 I iter = f.get(I(v.data()), I(v.data() + v.size()), 573 true, ios, err, ex); 574 assert(iter.base() == v.data() + v.size()); 575 assert(err == std::ios_base::eofbit); 576 assert(ex == -1); 577 } 578 { // positive 579 std::wstring v = L"1,234,567.89"; 580 typedef input_iterator<const wchar_t*> I; 581 long double ex; 582 std::ios_base::iostate err = std::ios_base::goodbit; 583 I iter = f.get(I(v.data()), I(v.data() + v.size()), 584 true, ios, err, ex); 585 assert(iter.base() == v.data() + v.size()); 586 assert(err == std::ios_base::eofbit); 587 assert(ex == 123456789); 588 } 589 { // negative 590 std::wstring v = L"-1,234,567.89"; 591 typedef input_iterator<const wchar_t*> I; 592 long double ex; 593 std::ios_base::iostate err = std::ios_base::goodbit; 594 I iter = f.get(I(v.data()), I(v.data() + v.size()), 595 true, ios, err, ex); 596 assert(iter.base() == v.data() + v.size()); 597 assert(err == std::ios_base::eofbit); 598 assert(ex == -123456789); 599 } 600 { // negative 601 std::wstring v = L"-1234567.89"; 602 typedef input_iterator<const wchar_t*> I; 603 long double ex; 604 std::ios_base::iostate err = std::ios_base::goodbit; 605 I iter = f.get(I(v.data()), I(v.data() + v.size()), 606 true, ios, err, ex); 607 assert(iter.base() == v.data() + v.size()); 608 assert(err == std::ios_base::eofbit); 609 assert(ex == -123456789); 610 } 611 { // zero, showbase 612 std::wstring v = L"CNY 0.00"; 613 typedef input_iterator<const wchar_t*> I; 614 long double ex; 615 std::ios_base::iostate err = std::ios_base::goodbit; 616 I iter = f.get(I(v.data()), I(v.data() + v.size()), 617 true, ios, err, ex); 618 assert(iter.base() == v.data() + v.size()); 619 assert(err == std::ios_base::eofbit); 620 assert(ex == 0); 621 } 622 { // zero, showbase 623 std::wstring v = L"CNY 0.00"; 624 showbase(ios); 625 typedef input_iterator<const wchar_t*> I; 626 long double ex; 627 std::ios_base::iostate err = std::ios_base::goodbit; 628 I iter = f.get(I(v.data()), I(v.data() + v.size()), 629 true, ios, err, ex); 630 assert(iter.base() == v.data() + v.size()); 631 assert(err == std::ios_base::eofbit); 632 assert(ex == 0); 633 noshowbase(ios); 634 } 635 { // negative one, showbase 636 std::wstring v = L"CNY -0.01"; 637 typedef input_iterator<const wchar_t*> I; 638 long double ex; 639 std::ios_base::iostate err = std::ios_base::goodbit; 640 I iter = f.get(I(v.data()), I(v.data() + v.size()), 641 true, ios, err, ex); 642 assert(iter.base() == v.data() + v.size()); 643 assert(err == std::ios_base::eofbit); 644 assert(ex == -1); 645 } 646 { // negative one, showbase 647 std::wstring v = L"CNY -0.01"; 648 showbase(ios); 649 typedef input_iterator<const wchar_t*> I; 650 long double ex; 651 std::ios_base::iostate err = std::ios_base::goodbit; 652 I iter = f.get(I(v.data()), I(v.data() + v.size()), 653 true, ios, err, ex); 654 assert(iter.base() == v.data() + v.size()); 655 assert(err == std::ios_base::eofbit); 656 assert(ex == -1); 657 noshowbase(ios); 658 } 659 { // positive, showbase 660 std::wstring v = L"CNY 1,234,567.89"; 661 typedef input_iterator<const wchar_t*> I; 662 long double ex; 663 std::ios_base::iostate err = std::ios_base::goodbit; 664 I iter = f.get(I(v.data()), I(v.data() + v.size()), 665 true, ios, err, ex); 666 assert(iter.base() == v.data() + v.size()); 667 assert(err == std::ios_base::eofbit); 668 assert(ex == 123456789); 669 } 670 { // positive, showbase 671 std::wstring v = L"CNY 1,234,567.89"; 672 showbase(ios); 673 typedef input_iterator<const wchar_t*> I; 674 long double ex; 675 std::ios_base::iostate err = std::ios_base::goodbit; 676 I iter = f.get(I(v.data()), I(v.data() + v.size()), 677 true, ios, err, ex); 678 assert(iter.base() == v.data() + v.size()); 679 assert(err == std::ios_base::eofbit); 680 assert(ex == 123456789); 681 noshowbase(ios); 682 } 683 { // negative, showbase 684 std::wstring v = L"CNY -1,234,567.89"; 685 showbase(ios); 686 typedef input_iterator<const wchar_t*> I; 687 long double ex; 688 std::ios_base::iostate err = std::ios_base::goodbit; 689 I iter = f.get(I(v.data()), I(v.data() + v.size()), 690 true, ios, err, ex); 691 assert(iter.base() == v.data() + v.size()); 692 assert(err == std::ios_base::eofbit); 693 assert(ex == -123456789); 694 noshowbase(ios); 695 } 696 { // negative, showbase 697 std::wstring v = L"\xFFE5""-1,234,567.89"; 698 showbase(ios); 699 typedef input_iterator<const wchar_t*> I; 700 long double ex; 701 std::ios_base::iostate err = std::ios_base::goodbit; 702 I iter = f.get(I(v.data()), I(v.data() + v.size()), 703 true, ios, err, ex); 704 assert(iter.base() == v.data() + 0); 705 assert(err == std::ios_base::failbit); 706 noshowbase(ios); 707 } 708 { // negative, showbase 709 std::wstring v = L"\xFFE5""-1,234,567.89"; 710 typedef input_iterator<const wchar_t*> I; 711 long double ex; 712 std::ios_base::iostate err = std::ios_base::goodbit; 713 I iter = f.get(I(v.data()), I(v.data() + v.size()), 714 true, ios, err, ex); 715 assert(iter.base() == v.data() + 0); 716 assert(err == std::ios_base::failbit); 717 } 718 } 719} 720