Last active
December 14, 2015 13:59
-
-
Save waywardmonkeys/5097296 to your computer and use it in GitHub Desktop.
Causes the emscripten relooper to crash (previously caused stack range errors).
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
//===----------------------------------------------------------------------===// | |
// | |
// The LLVM Compiler Infrastructure | |
// | |
// This file is dual licensed under the MIT and the University of Illinois Open | |
// Source Licenses. See LICENSE.TXT for details. | |
// | |
//===----------------------------------------------------------------------===// | |
// <regex> | |
// template <class BidirectionalIterator, class Allocator, class charT, | |
// class traits> | |
// bool regex_match(BidirectionalIterator first, BidirectionalIterator last, | |
// match_results<BidirectionalIterator, Allocator>& m, | |
// const basic_regex<charT, traits>& e, | |
// regex_constants::match_flag_type flags | |
// = regex_constants::match_default); | |
#include <regex> | |
#include <cassert> | |
#include "test_iterators.h" | |
int main() | |
{ | |
{ | |
std::cmatch m; | |
const char s[] = "a"; | |
assert(std::regex_match(s, m, std::regex("a", std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.empty()); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == s+1); | |
assert(m.length(0) == 1); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == "a"); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "ab"; | |
assert(std::regex_match(s, m, std::regex("ab", std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == s+2); | |
assert(m.length(0) == 2); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == "ab"); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "ab"; | |
assert(!std::regex_match(s, m, std::regex("ba", std::regex_constants::awk))); | |
assert(m.size() == 0); | |
assert(m.empty()); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "aab"; | |
assert(!std::regex_match(s, m, std::regex("ab", std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "aab"; | |
assert(!std::regex_match(s, m, std::regex("ab", std::regex_constants::awk), | |
std::regex_constants::match_continuous)); | |
assert(m.size() == 0); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "abcd"; | |
assert(!std::regex_match(s, m, std::regex("bc", std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "abbc"; | |
assert(std::regex_match(s, m, std::regex("ab*c", std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == s+4); | |
assert(m.length(0) == 4); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "ababc"; | |
assert(std::regex_match(s, m, std::regex("(ab)*c", std::regex_constants::awk))); | |
assert(m.size() == 2); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == s+5); | |
assert(m.length(0) == 5); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
assert(m.length(1) == 2); | |
assert(m.position(1) == 2); | |
assert(m.str(1) == "ab"); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "abcdefghijk"; | |
assert(!std::regex_match(s, m, std::regex("cd((e)fg)hi", | |
std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "abc"; | |
assert(std::regex_match(s, m, std::regex("^abc", std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == s+3); | |
assert(m.length(0) == 3); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "abcd"; | |
assert(!std::regex_match(s, m, std::regex("^abc", std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "aabc"; | |
assert(!std::regex_match(s, m, std::regex("^abc", std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "abc"; | |
assert(std::regex_match(s, m, std::regex("abc$", std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == s+3); | |
assert(m.length(0) == 3); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "efabc"; | |
assert(!std::regex_match(s, m, std::regex("abc$", std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "efabcg"; | |
assert(!std::regex_match(s, m, std::regex("abc$", std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "abc"; | |
assert(std::regex_match(s, m, std::regex("a.c", std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == s+3); | |
assert(m.length(0) == 3); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "acc"; | |
assert(std::regex_match(s, m, std::regex("a.c", std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == s+3); | |
assert(m.length(0) == 3); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "acc"; | |
assert(std::regex_match(s, m, std::regex("a.c", std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == s+3); | |
assert(m.length(0) == 3); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "abcdef"; | |
assert(std::regex_match(s, m, std::regex("(.*).*", std::regex_constants::awk))); | |
assert(m.size() == 2); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == s+6); | |
assert(m.length(0) == 6); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
assert(m.length(1) == 6); | |
assert(m.position(1) == 0); | |
assert(m.str(1) == s); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "bc"; | |
assert(!std::regex_match(s, m, std::regex("(a*)*", std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "abbc"; | |
assert(!std::regex_match(s, m, std::regex("ab{3,5}c", std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "abbbc"; | |
assert(std::regex_match(s, m, std::regex("ab{3,5}c", std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<char>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "abbbbc"; | |
assert(std::regex_match(s, m, std::regex("ab{3,5}c", std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<char>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "abbbbbc"; | |
assert(std::regex_match(s, m, std::regex("ab{3,5}c", std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<char>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "adefc"; | |
assert(!std::regex_match(s, m, std::regex("ab{3,5}c", std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "abbbbbbc"; | |
assert(!std::regex_match(s, m, std::regex("ab{3,5}c", std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "adec"; | |
assert(!std::regex_match(s, m, std::regex("a.{3,5}c", std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "adefc"; | |
assert(std::regex_match(s, m, std::regex("a.{3,5}c", std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<char>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "adefgc"; | |
assert(std::regex_match(s, m, std::regex("a.{3,5}c", std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<char>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "adefghc"; | |
assert(std::regex_match(s, m, std::regex("a.{3,5}c", std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<char>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "adefghic"; | |
assert(!std::regex_match(s, m, std::regex("a.{3,5}c", std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "tournament"; | |
assert(std::regex_match(s, m, std::regex("tour|to|tournament", | |
std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<char>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "tournamenttotour"; | |
assert(std::regex_match(s, m, std::regex("(tour|to|tournament)+", | |
std::regex_constants::awk | std::regex_constants::nosubs))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<char>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "ttotour"; | |
assert(std::regex_match(s, m, std::regex("(tour|to|t)+", | |
std::regex_constants::awk))); | |
assert(m.size() == 2); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<char>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
assert(m.length(1) == 4); | |
assert(m.position(1) == 3); | |
assert(m.str(1) == "tour"); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "-ab,ab-"; | |
assert(!std::regex_match(s, m, std::regex("-(.*),\1-", std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "-ab,ab-"; | |
assert(std::regex_match(s, m, std::regex("-.*,.*-", std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<char>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "a"; | |
assert(std::regex_match(s, m, std::regex("^[a]$", | |
std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == 1); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == "a"); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "a"; | |
assert(std::regex_match(s, m, std::regex("^[ab]$", | |
std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == 1); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == "a"); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "c"; | |
assert(std::regex_match(s, m, std::regex("^[a-f]$", | |
std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == 1); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "g"; | |
assert(!std::regex_match(s, m, std::regex("^[a-f]$", | |
std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "Iraqi"; | |
assert(!std::regex_match(s, m, std::regex("q[^u]", | |
std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "Iraq"; | |
assert(!std::regex_match(s, m, std::regex("q[^u]", | |
std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "AmB"; | |
assert(std::regex_match(s, m, std::regex("A[[:lower:]]B", | |
std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<char>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "AMB"; | |
assert(!std::regex_match(s, m, std::regex("A[[:lower:]]B", | |
std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "AMB"; | |
assert(std::regex_match(s, m, std::regex("A[^[:lower:]]B", | |
std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<char>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "AmB"; | |
assert(!std::regex_match(s, m, std::regex("A[^[:lower:]]B", | |
std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "A5B"; | |
assert(!std::regex_match(s, m, std::regex("A[^[:lower:]0-9]B", | |
std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "A?B"; | |
assert(std::regex_match(s, m, std::regex("A[^[:lower:]0-9]B", | |
std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<char>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "-"; | |
assert(std::regex_match(s, m, std::regex("[a[.hyphen.]z]", | |
std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<char>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "z"; | |
assert(std::regex_match(s, m, std::regex("[a[.hyphen.]z]", | |
std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<char>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "m"; | |
assert(!std::regex_match(s, m, std::regex("[a[.hyphen.]z]", | |
std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
std::locale::global(std::locale("cs_CZ.ISO8859-2")); | |
{ | |
std::cmatch m; | |
const char s[] = "m"; | |
assert(std::regex_match(s, m, std::regex("[a[=M=]z]", | |
std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<char>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "Ch"; | |
assert(std::regex_match(s, m, std::regex("[a[.ch.]z]", | |
std::regex_constants::awk | std::regex_constants::icase))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<char>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
std::locale::global(std::locale("C")); | |
{ | |
std::cmatch m; | |
const char s[] = "m"; | |
assert(!std::regex_match(s, m, std::regex("[a[=M=]z]", | |
std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "01a45cef9"; | |
assert(!std::regex_match(s, m, std::regex("[ace1-9]*", | |
std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "01a45cef9"; | |
assert(!std::regex_match(s, m, std::regex("[ace1-9]+", | |
std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
const char r[] = "^[-+]?[0-9]+[CF]$"; | |
std::ptrdiff_t sr = std::char_traits<char>::length(r); | |
typedef forward_iterator<const char*> FI; | |
typedef bidirectional_iterator<const char*> BI; | |
std::regex regex(FI(r), FI(r+sr), std::regex_constants::awk); | |
std::match_results<BI> m; | |
const char s[] = "-40C"; | |
std::ptrdiff_t ss = std::char_traits<char>::length(s); | |
assert(std::regex_match(BI(s), BI(s+ss), m, regex)); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == BI(s)); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == 4); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::cmatch m; | |
const char s[] = "\n\n\n"; | |
assert(std::regex_match(s, m, std::regex("[\\n]+", | |
std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == s + std::char_traits<char>::length(s)); | |
assert(m.length(0) == std::char_traits<char>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"a"; | |
assert(std::regex_match(s, m, std::wregex(L"a", std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.empty()); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == s+1); | |
assert(m.length(0) == 1); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == L"a"); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"ab"; | |
assert(std::regex_match(s, m, std::wregex(L"ab", std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == s+2); | |
assert(m.length(0) == 2); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == L"ab"); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"ab"; | |
assert(!std::regex_match(s, m, std::wregex(L"ba", std::regex_constants::awk))); | |
assert(m.size() == 0); | |
assert(m.empty()); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"aab"; | |
assert(!std::regex_match(s, m, std::wregex(L"ab", std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"aab"; | |
assert(!std::regex_match(s, m, std::wregex(L"ab", std::regex_constants::awk), | |
std::regex_constants::match_continuous)); | |
assert(m.size() == 0); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"abcd"; | |
assert(!std::regex_match(s, m, std::wregex(L"bc", std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"abbc"; | |
assert(std::regex_match(s, m, std::wregex(L"ab*c", std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == s+4); | |
assert(m.length(0) == 4); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"ababc"; | |
assert(std::regex_match(s, m, std::wregex(L"(ab)*c", std::regex_constants::awk))); | |
assert(m.size() == 2); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == s+5); | |
assert(m.length(0) == 5); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
assert(m.length(1) == 2); | |
assert(m.position(1) == 2); | |
assert(m.str(1) == L"ab"); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"abcdefghijk"; | |
assert(!std::regex_match(s, m, std::wregex(L"cd((e)fg)hi", | |
std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"abc"; | |
assert(std::regex_match(s, m, std::wregex(L"^abc", std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == s+3); | |
assert(m.length(0) == 3); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"abcd"; | |
assert(!std::regex_match(s, m, std::wregex(L"^abc", std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"aabc"; | |
assert(!std::regex_match(s, m, std::wregex(L"^abc", std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"abc"; | |
assert(std::regex_match(s, m, std::wregex(L"abc$", std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == s+3); | |
assert(m.length(0) == 3); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"efabc"; | |
assert(!std::regex_match(s, m, std::wregex(L"abc$", std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"efabcg"; | |
assert(!std::regex_match(s, m, std::wregex(L"abc$", std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"abc"; | |
assert(std::regex_match(s, m, std::wregex(L"a.c", std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == s+3); | |
assert(m.length(0) == 3); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"acc"; | |
assert(std::regex_match(s, m, std::wregex(L"a.c", std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == s+3); | |
assert(m.length(0) == 3); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"acc"; | |
assert(std::regex_match(s, m, std::wregex(L"a.c", std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == s+3); | |
assert(m.length(0) == 3); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"abcdef"; | |
assert(std::regex_match(s, m, std::wregex(L"(.*).*", std::regex_constants::awk))); | |
assert(m.size() == 2); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == s+6); | |
assert(m.length(0) == 6); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
assert(m.length(1) == 6); | |
assert(m.position(1) == 0); | |
assert(m.str(1) == s); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"bc"; | |
assert(!std::regex_match(s, m, std::wregex(L"(a*)*", std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"abbc"; | |
assert(!std::regex_match(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"abbbc"; | |
assert(std::regex_match(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<wchar_t>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"abbbbc"; | |
assert(std::regex_match(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<wchar_t>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"abbbbbc"; | |
assert(std::regex_match(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<wchar_t>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"adefc"; | |
assert(!std::regex_match(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"abbbbbbc"; | |
assert(!std::regex_match(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"adec"; | |
assert(!std::regex_match(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"adefc"; | |
assert(std::regex_match(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<wchar_t>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"adefgc"; | |
assert(std::regex_match(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<wchar_t>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"adefghc"; | |
assert(std::regex_match(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<wchar_t>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"adefghic"; | |
assert(!std::regex_match(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"tournament"; | |
assert(std::regex_match(s, m, std::wregex(L"tour|to|tournament", | |
std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<wchar_t>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"tournamenttotour"; | |
assert(std::regex_match(s, m, std::wregex(L"(tour|to|tournament)+", | |
std::regex_constants::awk | std::regex_constants::nosubs))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<wchar_t>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"ttotour"; | |
assert(std::regex_match(s, m, std::wregex(L"(tour|to|t)+", | |
std::regex_constants::awk))); | |
assert(m.size() == 2); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<wchar_t>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
assert(m.length(1) == 4); | |
assert(m.position(1) == 3); | |
assert(m.str(1) == L"tour"); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"-ab,ab-"; | |
assert(!std::regex_match(s, m, std::wregex(L"-(.*),\1-", std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"-ab,ab-"; | |
assert(std::regex_match(s, m, std::wregex(L"-.*,.*-", std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<wchar_t>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"a"; | |
assert(std::regex_match(s, m, std::wregex(L"^[a]$", | |
std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == 1); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == L"a"); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"a"; | |
assert(std::regex_match(s, m, std::wregex(L"^[ab]$", | |
std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == 1); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == L"a"); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"c"; | |
assert(std::regex_match(s, m, std::wregex(L"^[a-f]$", | |
std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == 1); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"g"; | |
assert(!std::regex_match(s, m, std::wregex(L"^[a-f]$", | |
std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"Iraqi"; | |
assert(!std::regex_match(s, m, std::wregex(L"q[^u]", | |
std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"Iraq"; | |
assert(!std::regex_match(s, m, std::wregex(L"q[^u]", | |
std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"AmB"; | |
assert(std::regex_match(s, m, std::wregex(L"A[[:lower:]]B", | |
std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<wchar_t>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"AMB"; | |
assert(!std::regex_match(s, m, std::wregex(L"A[[:lower:]]B", | |
std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"AMB"; | |
assert(std::regex_match(s, m, std::wregex(L"A[^[:lower:]]B", | |
std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<wchar_t>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"AmB"; | |
assert(!std::regex_match(s, m, std::wregex(L"A[^[:lower:]]B", | |
std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"A5B"; | |
assert(!std::regex_match(s, m, std::wregex(L"A[^[:lower:]0-9]B", | |
std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"A?B"; | |
assert(std::regex_match(s, m, std::wregex(L"A[^[:lower:]0-9]B", | |
std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<wchar_t>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"-"; | |
assert(std::regex_match(s, m, std::wregex(L"[a[.hyphen.]z]", | |
std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<wchar_t>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"z"; | |
assert(std::regex_match(s, m, std::wregex(L"[a[.hyphen.]z]", | |
std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<wchar_t>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"m"; | |
assert(!std::regex_match(s, m, std::wregex(L"[a[.hyphen.]z]", | |
std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
std::locale::global(std::locale("cs_CZ.ISO8859-2")); | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"m"; | |
assert(std::regex_match(s, m, std::wregex(L"[a[=M=]z]", | |
std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<wchar_t>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"Ch"; | |
assert(std::regex_match(s, m, std::wregex(L"[a[.ch.]z]", | |
std::regex_constants::awk | std::regex_constants::icase))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == std::char_traits<wchar_t>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
std::locale::global(std::locale("C")); | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"m"; | |
assert(!std::regex_match(s, m, std::wregex(L"[a[=M=]z]", | |
std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"01a45cef9"; | |
assert(!std::regex_match(s, m, std::wregex(L"[ace1-9]*", | |
std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"01a45cef9"; | |
assert(!std::regex_match(s, m, std::wregex(L"[ace1-9]+", | |
std::regex_constants::awk))); | |
assert(m.size() == 0); | |
} | |
{ | |
const wchar_t r[] = L"^[-+]?[0-9]+[CF]$"; | |
std::ptrdiff_t sr = std::char_traits<wchar_t>::length(r); | |
typedef forward_iterator<const wchar_t*> FI; | |
typedef bidirectional_iterator<const wchar_t*> BI; | |
std::wregex regex(FI(r), FI(r+sr), std::regex_constants::awk); | |
std::match_results<BI> m; | |
const wchar_t s[] = L"-40C"; | |
std::ptrdiff_t ss = std::char_traits<wchar_t>::length(s); | |
assert(std::regex_match(BI(s), BI(s+ss), m, regex)); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == BI(s)); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == m[0].second); | |
assert(m.length(0) == 4); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
{ | |
std::wcmatch m; | |
const wchar_t s[] = L"\n\n\n"; | |
assert(std::regex_match(s, m, std::wregex(L"[\\n]+", | |
std::regex_constants::awk))); | |
assert(m.size() == 1); | |
assert(!m.prefix().matched); | |
assert(m.prefix().first == s); | |
assert(m.prefix().second == m[0].first); | |
assert(!m.suffix().matched); | |
assert(m.suffix().first == m[0].second); | |
assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s)); | |
assert(m.length(0) == std::char_traits<wchar_t>::length(s)); | |
assert(m.position(0) == 0); | |
assert(m.str(0) == s); | |
} | |
} |
This file has been truncated, but you can view the full file.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
//===----------------------------------------------------------------------===// | |
// | |
// The LLVM Compiler Infrastructure | |
// | |
// This file is dual licensed under the MIT and the University of Illinois Open | |
// Source Licenses. See LICENSE.TXT for details. | |
// | |
//===----------------------------------------------------------------------===// | |
// <locale> | |
// class num_put<charT, OutputIterator> | |
// iter_type put(iter_type s, ios_base& iob, char_type fill, double v) const; | |
#include <locale> | |
#include <ios> | |
#include <cassert> | |
#include <streambuf> | |
#include <cmath> | |
#include "test_iterators.h" | |
typedef std::num_put<char, output_iterator<char*> > F; | |
class my_facet | |
: public F | |
{ | |
public: | |
explicit my_facet(std::size_t refs = 0) | |
: F(refs) {} | |
}; | |
class my_numpunct | |
: public std::numpunct<char> | |
{ | |
public: | |
my_numpunct() : std::numpunct<char>() {} | |
protected: | |
virtual char_type do_decimal_point() const {return ';';} | |
virtual char_type do_thousands_sep() const {return '_';} | |
virtual std::string do_grouping() const {return std::string("\1\2\3");} | |
}; | |
void test1() | |
{ | |
char str[200]; | |
output_iterator<char*> iter; | |
std::locale lc = std::locale::classic(); | |
std::locale lg(lc, new my_numpunct); | |
const my_facet f(1); | |
{ | |
double v = +0.; | |
std::ios ios(0); | |
// %g | |
{ | |
ios.precision(0); | |
{ | |
nouppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0************************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0************************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0."); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************0."); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************0."); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************0;"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************0;"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+***********************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+***********************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0."); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.**********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********************+0."); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+**********************0."); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;**********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********************+0;"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+**********************0;"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
uppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0************************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0************************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0."); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************0."); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************0."); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************0;"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************0;"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+***********************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+***********************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0."); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.**********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********************+0."); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+**********************0."); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;**********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********************+0;"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+**********************0;"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
} | |
ios.precision(1); | |
{ | |
nouppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0************************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0************************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0."); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************0."); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************0."); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************0;"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************0;"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+***********************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+***********************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0."); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.**********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********************+0."); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+**********************0."); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;**********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********************+0;"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+**********************0;"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
uppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0************************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0************************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0."); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************0."); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************0."); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************0;"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************0;"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+***********************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+***********************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0."); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.**********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********************+0."); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+**********************0."); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;**********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********************+0;"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+**********************0;"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
} | |
ios.precision(6); | |
{ | |
nouppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0************************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0************************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.00000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.00000******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************0.00000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************0.00000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;00000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;00000******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************0;00000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************0;00000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+***********************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+***********************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.00000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.00000*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************+0.00000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*****************0.00000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;00000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;00000*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************+0;00000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*****************0;00000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
uppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0************************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0************************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.00000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.00000******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************0.00000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************0.00000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;00000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;00000******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************0;00000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************0;00000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+***********************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+***********************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.00000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.00000*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************+0.00000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*****************0.00000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;00000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;00000*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************+0;00000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*****************0;00000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
} | |
ios.precision(16); | |
{ | |
nouppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0************************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0************************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.000000000000000********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********0.000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********0.000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;000000000000000********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********0;000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********0;000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+***********************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+***********************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.000000000000000*******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******+0.000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*******0.000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;000000000000000*******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******+0;000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*******0;000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
uppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0************************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0************************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.000000000000000********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********0.000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********0.000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;000000000000000********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********0;000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********0;000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+***********************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+***********************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.000000000000000*******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******+0.000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*******0.000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;000000000000000*******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******+0;000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*******0;000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
} | |
ios.precision(60); | |
{ | |
nouppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0************************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0************************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.00000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.00000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.00000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.00000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;00000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;00000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;00000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;00000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+***********************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+***********************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
uppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0************************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0************************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.00000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.00000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.00000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.00000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;00000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;00000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;00000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;00000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+***********************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+***********************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
void test2() | |
{ | |
char str[200]; | |
output_iterator<char*> iter; | |
std::locale lc = std::locale::classic(); | |
std::locale lg(lc, new my_numpunct); | |
const my_facet f(1); | |
{ | |
double v = 1234567890.125; | |
std::ios ios(0); | |
// %g | |
{ | |
ios.precision(0); | |
{ | |
nouppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1e+09********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********************1e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********************1e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1e+09********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********************1e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********************1e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.e+09*******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************1.e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************1.e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;e+09*******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************1;e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************1;e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1e+09*******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************+1e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*******************1e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1e+09*******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************+1e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*******************1e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.e+09******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************+1.e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+******************1.e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;e+09******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************+1;e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+******************1;e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
uppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1E+09********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********************1E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********************1E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1E+09********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********************1E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********************1E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.E+09*******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************1.E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************1.E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;E+09*******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************1;E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************1;E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1E+09*******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************+1E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*******************1E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1E+09*******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************+1E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*******************1E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.E+09******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************+1.E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+******************1.E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;E+09******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************+1;E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+******************1;E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
} | |
ios.precision(1); | |
{ | |
nouppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1e+09********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********************1e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********************1e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1e+09********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********************1e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********************1e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.e+09*******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************1.e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************1.e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;e+09*******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************1;e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************1;e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1e+09*******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************+1e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*******************1e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1e+09*******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************+1e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*******************1e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.e+09******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************+1.e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+******************1.e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;e+09******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************+1;e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+******************1;e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
uppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1E+09********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********************1E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********************1E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1E+09********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********************1E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********************1E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.E+09*******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************1.E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************1.E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;E+09*******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************1;E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************1;E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1E+09*******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************+1E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*******************1E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1E+09*******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************+1E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*******************1E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.E+09******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************+1.E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+******************1.E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;E+09******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************+1;E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+******************1;E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
} | |
ios.precision(6); | |
{ | |
nouppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.23457e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.23457e+09**************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**************1.23457e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**************1.23457e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;23457e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;23457e+09**************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**************1;23457e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**************1;23457e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.23457e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.23457e+09**************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**************1.23457e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**************1.23457e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;23457e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;23457e+09**************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**************1;23457e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**************1;23457e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.23457e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.23457e+09*************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*************+1.23457e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*************1.23457e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;23457e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;23457e+09*************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*************+1;23457e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*************1;23457e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.23457e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.23457e+09*************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*************+1.23457e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*************1.23457e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;23457e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;23457e+09*************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*************+1;23457e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*************1;23457e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
uppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.23457E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.23457E+09**************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**************1.23457E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**************1.23457E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;23457E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;23457E+09**************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**************1;23457E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**************1;23457E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.23457E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.23457E+09**************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**************1.23457E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**************1.23457E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;23457E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;23457E+09**************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**************1;23457E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**************1;23457E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.23457E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.23457E+09*************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*************+1.23457E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*************1.23457E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;23457E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;23457E+09*************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*************+1;23457E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*************1;23457E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.23457E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.23457E+09*************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*************+1.23457E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*************1.23457E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;23457E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;23457E+09*************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*************+1;23457E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*************1;23457E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
} | |
ios.precision(16); | |
{ | |
nouppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.125"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.125***********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********1234567890.125"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********1234567890.125"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;125"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;125*******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******1_234_567_89_0;125"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******1_234_567_89_0;125"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.125000********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;125000****"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "****1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "****1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.125"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.125**********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********+1234567890.125"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+**********1234567890.125"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;125"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;125******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******+1_234_567_89_0;125"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+******1_234_567_89_0;125"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.125000*******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******+1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*******1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;125000***"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***+1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+***1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
uppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.125"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.125***********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********1234567890.125"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********1234567890.125"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;125"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;125*******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******1_234_567_89_0;125"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******1_234_567_89_0;125"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.125000********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;125000****"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "****1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "****1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.125"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.125**********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********+1234567890.125"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+**********1234567890.125"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;125"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;125******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******+1_234_567_89_0;125"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+******1_234_567_89_0;125"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.125000*******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******+1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*******1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;125000***"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***+1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+***1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
} | |
ios.precision(60); | |
{ | |
nouppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.125"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.125***********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********1234567890.125"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********1234567890.125"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;125"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;125*******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******1_234_567_89_0;125"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******1_234_567_89_0;125"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.12500000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.12500000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.12500000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.12500000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.125"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.125**********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********+1234567890.125"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+**********1234567890.125"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;125"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;125******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******+1_234_567_89_0;125"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+******1_234_567_89_0;125"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
uppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.125"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.125***********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********1234567890.125"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********1234567890.125"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;125"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;125*******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******1_234_567_89_0;125"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******1_234_567_89_0;125"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.12500000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.12500000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.12500000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.12500000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.125"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.125**********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********+1234567890.125"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+**********1234567890.125"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;125"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;125******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******+1_234_567_89_0;125"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+******1_234_567_89_0;125"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
void test3() | |
{ | |
char str[200]; | |
output_iterator<char*> iter; | |
std::locale lc = std::locale::classic(); | |
std::locale lg(lc, new my_numpunct); | |
const my_facet f(1); | |
{ | |
double v = +0.; | |
std::ios ios(0); | |
fixed(ios); | |
// %f | |
{ | |
ios.precision(0); | |
{ | |
nouppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0************************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0************************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0."); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************0."); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************0."); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************0;"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************0;"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+***********************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+***********************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0."); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.**********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********************+0."); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+**********************0."); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;**********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********************+0;"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+**********************0;"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
uppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0************************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0************************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0."); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************0."); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************0."); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************0;"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************0;"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+***********************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0***********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********************+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+***********************0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0."); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.**********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********************+0."); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+**********************0."); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;**********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********************+0;"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+**********************0;"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
} | |
ios.precision(1); | |
{ | |
nouppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.0**********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********************0.0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********************0.0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;0**********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********************0;0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********************0;0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.0**********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********************0.0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********************0.0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;0**********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********************0;0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********************0;0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.0*********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*********************+0.0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*********************0.0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;0*********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*********************+0;0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*********************0;0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.0*********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*********************+0.0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*********************0.0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;0*********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*********************+0;0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*********************0;0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
uppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.0**********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********************0.0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********************0.0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;0**********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********************0;0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********************0;0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.0**********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********************0.0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********************0.0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;0**********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********************0;0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********************0;0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.0*********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*********************+0.0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*********************0.0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;0*********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*********************+0;0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*********************0;0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.0*********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*********************+0.0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*********************0.0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;0*********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*********************+0;0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*********************0;0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
} | |
ios.precision(6); | |
{ | |
nouppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.000000*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************0.000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************0.000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;000000*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************0;000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************0;000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.000000*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************0.000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************0.000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;000000*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************0;000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************0;000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.000000****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "****************+0.000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+****************0.000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;000000****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "****************+0;000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+****************0;000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.000000****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "****************+0.000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+****************0.000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;000000****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "****************+0;000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+****************0;000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
uppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.000000*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************0.000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************0.000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;000000*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************0;000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************0;000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.000000*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************0.000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************0.000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;000000*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************0;000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************0;000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.000000****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "****************+0.000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+****************0.000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;000000****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "****************+0;000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+****************0;000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.000000****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "****************+0.000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+****************0.000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;000000****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "****************+0;000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+****************0;000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
} | |
ios.precision(16); | |
{ | |
nouppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.0000000000000000*******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******0.0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******0.0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;0000000000000000*******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******0;0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******0;0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.0000000000000000*******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******0.0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******0.0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;0000000000000000*******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******0;0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******0;0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.0000000000000000******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******+0.0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+******0.0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;0000000000000000******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******+0;0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+******0;0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.0000000000000000******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******+0.0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+******0.0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;0000000000000000******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******+0;0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+******0;0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
uppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.0000000000000000*******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******0.0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******0.0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;0000000000000000*******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******0;0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******0;0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.0000000000000000*******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******0.0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******0.0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;0000000000000000*******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******0;0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******0;0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.0000000000000000******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******+0.0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+******0.0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;0000000000000000******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******+0;0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+******0;0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.0000000000000000******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******+0.0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+******0.0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;0000000000000000******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******+0;0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+******0;0000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
} | |
ios.precision(60); | |
{ | |
nouppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
uppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
void test4() | |
{ | |
char str[200]; | |
output_iterator<char*> iter; | |
std::locale lc = std::locale::classic(); | |
std::locale lg(lc, new my_numpunct); | |
const my_facet f(1); | |
{ | |
double v = 1234567890.125; | |
std::ios ios(0); | |
fixed(ios); | |
// %f | |
{ | |
ios.precision(0); | |
{ | |
nouppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890***************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***************1234567890"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***************1234567890"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0***********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********1_234_567_89_0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********1_234_567_89_0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890."); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.**************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**************1234567890."); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**************1234567890."); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;**********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********1_234_567_89_0;"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********1_234_567_89_0;"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890**************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**************+1234567890"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+**************1234567890"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0**********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********+1_234_567_89_0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+**********1_234_567_89_0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890."); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.*************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*************+1234567890."); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*************1234567890."); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;*********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*********+1_234_567_89_0;"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*********1_234_567_89_0;"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
uppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890***************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***************1234567890"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***************1234567890"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0***********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********1_234_567_89_0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***********1_234_567_89_0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890."); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.**************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**************1234567890."); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**************1234567890."); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;**********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********1_234_567_89_0;"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********1_234_567_89_0;"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890**************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**************+1234567890"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+**************1234567890"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0**********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "**********+1_234_567_89_0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+**********1_234_567_89_0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890."); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.*************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*************+1234567890."); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*************1234567890."); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;*********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*********+1_234_567_89_0;"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*********1_234_567_89_0;"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
} | |
ios.precision(1); | |
{ | |
nouppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.1"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.1*************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*************1234567890.1"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*************1234567890.1"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;1"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;1*********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*********1_234_567_89_0;1"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*********1_234_567_89_0;1"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.1"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.1*************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*************1234567890.1"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*************1234567890.1"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;1"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;1*********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*********1_234_567_89_0;1"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*********1_234_567_89_0;1"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.1"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.1************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************+1234567890.1"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+************1234567890.1"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;1"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;1********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********+1_234_567_89_0;1"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+********1_234_567_89_0;1"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.1"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.1************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************+1234567890.1"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+************1234567890.1"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;1"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;1********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********+1_234_567_89_0;1"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+********1_234_567_89_0;1"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
uppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.1"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.1*************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*************1234567890.1"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*************1234567890.1"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;1"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;1*********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*********1_234_567_89_0;1"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*********1_234_567_89_0;1"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.1"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.1*************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*************1234567890.1"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*************1234567890.1"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;1"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;1*********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*********1_234_567_89_0;1"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*********1_234_567_89_0;1"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.1"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.1************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************+1234567890.1"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+************1234567890.1"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;1"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;1********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********+1_234_567_89_0;1"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+********1_234_567_89_0;1"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.1"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.1************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************+1234567890.1"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+************1234567890.1"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;1"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;1********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********+1_234_567_89_0;1"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+********1_234_567_89_0;1"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
} | |
ios.precision(6); | |
{ | |
nouppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.125000********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;125000****"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "****1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "****1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.125000********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;125000****"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "****1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "****1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.125000*******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******+1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*******1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;125000***"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***+1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+***1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.125000*******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******+1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*******1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;125000***"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***+1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+***1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
uppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.125000********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;125000****"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "****1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "****1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1234567890.125000********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1_234_567_89_0;125000****"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "****1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "****1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.125000*******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******+1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*******1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;125000***"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***+1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+***1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1234567890.125000*******"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******+1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*******1234567890.125000"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1_234_567_89_0;125000***"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "***+1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+***1_234_567_89_0;125000"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
} | |
ios.precision(16); | |
{} | |
ios.precision(60); | |
{} | |
} | |
} | |
} | |
void test5() | |
{ | |
char str[200]; | |
output_iterator<char*> iter; | |
std::locale lc = std::locale::classic(); | |
std::locale lg(lc, new my_numpunct); | |
const my_facet f(1); | |
{ | |
double v = -0.; | |
std::ios ios(0); | |
scientific(ios); | |
// %e | |
{ | |
ios.precision(0); | |
{ | |
nouppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0e+00*******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************-0e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*******************0e+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0e+00*******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************-0e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*******************0e+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.e+00******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************-0.e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-******************0.e+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;e+00******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************-0;e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-******************0;e+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0e+00*******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************-0e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*******************0e+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0e+00*******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************-0e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*******************0e+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.e+00******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************-0.e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-******************0.e+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;e+00******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************-0;e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-******************0;e+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
uppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0E+00*******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************-0E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*******************0E+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0E+00*******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************-0E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*******************0E+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.E+00******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************-0.E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-******************0.E+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;E+00******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************-0;E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-******************0;E+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0E+00*******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************-0E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*******************0E+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0E+00*******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************-0E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*******************0E+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.E+00******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************-0.E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-******************0.E+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;E+00******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************-0;E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-******************0;E+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
} | |
ios.precision(1); | |
{ | |
nouppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.0e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.0e+00*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0.0e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0.0e+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;0e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;0e+00*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0;0e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0;0e+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.0e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.0e+00*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0.0e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0.0e+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;0e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;0e+00*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0;0e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0;0e+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.0e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.0e+00*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0.0e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0.0e+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;0e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;0e+00*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0;0e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0;0e+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.0e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.0e+00*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0.0e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0.0e+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;0e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;0e+00*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0;0e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0;0e+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
uppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.0E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.0E+00*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0.0E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0.0E+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;0E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;0E+00*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0;0E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0;0E+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.0E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.0E+00*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0.0E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0.0E+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;0E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;0E+00*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0;0E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0;0E+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.0E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.0E+00*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0.0E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0.0E+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;0E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;0E+00*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0;0E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0;0E+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.0E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.0E+00*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0.0E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0.0E+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;0E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;0E+00*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0;0E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0;0E+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
} | |
ios.precision(6); | |
{ | |
nouppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.000000e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.000000e+00************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************-0.000000e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-************0.000000e+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;000000e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;000000e+00************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************-0;000000e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-************0;000000e+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.000000e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.000000e+00************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************-0.000000e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-************0.000000e+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;000000e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;000000e+00************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************-0;000000e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-************0;000000e+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.000000e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.000000e+00************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************-0.000000e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-************0.000000e+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;000000e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;000000e+00************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************-0;000000e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-************0;000000e+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.000000e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.000000e+00************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************-0.000000e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-************0.000000e+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;000000e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;000000e+00************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************-0;000000e+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-************0;000000e+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
uppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.000000E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.000000E+00************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************-0.000000E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-************0.000000E+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;000000E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;000000E+00************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************-0;000000E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-************0;000000E+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.000000E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.000000E+00************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************-0.000000E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-************0.000000E+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;000000E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;000000E+00************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************-0;000000E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-************0;000000E+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.000000E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.000000E+00************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************-0.000000E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-************0.000000E+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;000000E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;000000E+00************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************-0;000000E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-************0;000000E+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.000000E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0.000000E+00************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************-0.000000E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-************0.000000E+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;000000E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0;000000E+00************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "************-0;000000E+00"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-************0;000000E+00"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
} | |
ios.precision(16); | |
{ | |
} | |
ios.precision(60); | |
{ | |
} | |
} | |
} | |
} | |
void test6() | |
{ | |
char str[200]; | |
output_iterator<char*> iter; | |
std::locale lc = std::locale::classic(); | |
std::locale lg(lc, new my_numpunct); | |
const my_facet f(1); | |
{ | |
double v = 1234567890.125; | |
std::ios ios(0); | |
scientific(ios); | |
// %e | |
{ | |
ios.precision(0); | |
{ | |
nouppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1e+09********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********************1e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********************1e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1e+09********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********************1e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********************1e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.e+09*******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************1.e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************1.e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;e+09*******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************1;e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************1;e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1e+09*******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************+1e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*******************1e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1e+09*******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************+1e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*******************1e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.e+09******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************+1.e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+******************1.e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;e+09******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************+1;e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+******************1;e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
uppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1E+09********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********************1E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********************1E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1E+09********************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********************1E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********************1E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.E+09*******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************1.E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************1.E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;E+09*******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************1;E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************1;E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1E+09*******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************+1E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*******************1E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1E+09*******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*******************+1E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*******************1E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.E+09******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************+1.E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+******************1.E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;E+09******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************+1;E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+******************1;E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
} | |
ios.precision(1); | |
{ | |
nouppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.2e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.2e+09******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************1.2e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************1.2e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;2e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;2e+09******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************1;2e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************1;2e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.2e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.2e+09******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************1.2e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************1.2e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;2e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;2e+09******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************1;2e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************1;2e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.2e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.2e+09*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************+1.2e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*****************1.2e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;2e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;2e+09*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************+1;2e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*****************1;2e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.2e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.2e+09*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************+1.2e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*****************1.2e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;2e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;2e+09*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************+1;2e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*****************1;2e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
uppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.2E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.2E+09******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************1.2E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************1.2E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;2E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;2E+09******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************1;2E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************1;2E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.2E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.2E+09******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************1.2E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************1.2E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;2E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;2E+09******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************1;2E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************1;2E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.2E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.2E+09*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************+1.2E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*****************1.2E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;2E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;2E+09*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************+1;2E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*****************1;2E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.2E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.2E+09*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************+1.2E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*****************1.2E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;2E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;2E+09*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************+1;2E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+*****************1;2E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
} | |
ios.precision(6); | |
{ | |
} | |
ios.precision(16); | |
{ | |
} | |
ios.precision(60); | |
{ | |
nouppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
uppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
void test7() | |
{ | |
char str[200]; | |
output_iterator<char*> iter; | |
std::locale lc = std::locale::classic(); | |
std::locale lg(lc, new my_numpunct); | |
const my_facet f(1); | |
{ | |
double v = -0.; | |
std::ios ios(0); | |
hexfloat(ios); | |
// %a | |
{ | |
ios.precision(0); | |
{ | |
nouppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0p+0******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************-0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-******************0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0p+0******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************-0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-******************0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0.p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0.p+0*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0x0.p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0x0.p+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0;p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0;p+0*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0x0;p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0x0;p+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0p+0******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************-0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-******************0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0p+0******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************-0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-******************0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0.p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0.p+0*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0x0.p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0x0.p+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0;p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0;p+0*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0x0;p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0x0;p+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
uppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0P+0******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************-0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-******************0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0P+0******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************-0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-******************0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0.P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0.P+0*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0X0.P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0X0.P+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0;P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0;P+0*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0X0;P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0X0;P+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0P+0******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************-0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-******************0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0P+0******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************-0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-******************0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0.P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0.P+0*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0X0.P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0X0.P+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0;P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0;P+0*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0X0;P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0X0;P+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
} | |
ios.precision(1); | |
{ | |
nouppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0p+0******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************-0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-******************0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0p+0******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************-0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-******************0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0.p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0.p+0*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0x0.p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0x0.p+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0;p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0;p+0*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0x0;p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0x0;p+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0p+0******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************-0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-******************0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0p+0******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************-0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-******************0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0.p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0.p+0*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0x0.p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0x0.p+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0;p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0;p+0*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0x0;p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0x0;p+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
uppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0P+0******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************-0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-******************0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0P+0******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************-0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-******************0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0.P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0.P+0*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0X0.P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0X0.P+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0;P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0;P+0*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0X0;P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0X0;P+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0P+0******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************-0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-******************0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0P+0******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************-0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-******************0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0.P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0.P+0*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0X0.P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0X0.P+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0;P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0;P+0*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0X0;P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0X0;P+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
} | |
ios.precision(6); | |
{ | |
nouppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0p+0******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************-0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-******************0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0p+0******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************-0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-******************0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0.p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0.p+0*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0x0.p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0x0.p+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0;p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0;p+0*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0x0;p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0x0;p+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0p+0******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************-0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-******************0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0p+0******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************-0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-******************0x0p+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0.p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0.p+0*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0x0.p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0x0.p+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0;p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0x0;p+0*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0x0;p+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0x0;p+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
uppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0P+0******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************-0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-******************0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0P+0******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************-0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-******************0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0.P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0.P+0*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0X0.P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0X0.P+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0;P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0;P+0*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0X0;P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0X0;P+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
showpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0P+0******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************-0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-******************0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0P+0******************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "******************-0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-******************0X0P+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0.P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0.P+0*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0X0.P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0X0.P+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0;P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-0X0;P+0*****************"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "*****************-0X0;P+0"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "-*****************0X0;P+0"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
} | |
} | |
} | |
ios.precision(16); | |
{ | |
} | |
ios.precision(60); | |
{ | |
} | |
} | |
} | |
} | |
void test8() | |
{ | |
char str[200]; | |
output_iterator<char*> iter; | |
std::locale lc = std::locale::classic(); | |
std::locale lg(lc, new my_numpunct); | |
const my_facet f(1); | |
{ | |
double v = 1234567890.125; | |
std::ios ios(0); | |
hexfloat(ios); | |
// %a | |
{ | |
ios.precision(0); | |
{ | |
nouppercase(ios); | |
{ | |
noshowpos(ios); | |
{ | |
noshowpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0x1.26580b488p+30"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0x1.26580b488p+30********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********0x1.26580b488p+30"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0x********1.26580b488p+30"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0x1;26580b488p+30"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0x1;26580b488p+30********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********0x1;26580b488p+30"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0x********1;26580b488p+30"); | |
assert(ios.width() == 0); | |
} | |
} | |
} | |
showpoint(ios); | |
{ | |
ios.imbue(lc); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0x1.26580b488p+30"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
left(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0x1.26580b488p+30********"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
right(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "********0x1.26580b488p+30"); | |
assert(ios.width() == 0); | |
} | |
ios.width(25); | |
internal(ios); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert(ex == "0x********1.26580b488p+30"); | |
assert(ios.width() == 0); | |
} | |
} | |
ios.imbue(lg); | |
{ | |
ios.width(0); | |
{ | |
iter = f.put(output_iterator<char*>(str), ios, '*', v); | |
std::string ex(str, iter.base()); | |
assert( |
View raw
(Sorry about that, but we can’t show files that are this big right now.)
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment