stdcxx-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ant...@apache.org
Subject svn commit: r418319 - /incubator/stdcxx/trunk/tests/strings/21.string.io.cpp
Date Fri, 30 Jun 2006 16:22:33 GMT
Author: antonp
Date: Fri Jun 30 09:22:31 2006
New Revision: 418319

URL: http://svn.apache.org/viewvc?rev=418319&view=rev
Log:
2006-06-30  Anton Pevtsov  <antonp@moscow.vdiweb.com>

	STDCXX-4
	* 21.string.io.cpp: New test exercising lib.string.io.

Added:
    incubator/stdcxx/trunk/tests/strings/21.string.io.cpp   (with props)

Added: incubator/stdcxx/trunk/tests/strings/21.string.io.cpp
URL: http://svn.apache.org/viewvc/incubator/stdcxx/trunk/tests/strings/21.string.io.cpp?rev=418319&view=auto
==============================================================================
--- incubator/stdcxx/trunk/tests/strings/21.string.io.cpp (added)
+++ incubator/stdcxx/trunk/tests/strings/21.string.io.cpp Fri Jun 30 09:22:31 2006
@@ -0,0 +1,1264 @@
+/***************************************************************************
+*
+* 21.string.io.cpp - string test exercising lib.string.io
+*
+* $Id$
+*
+***************************************************************************
+*
+* Copyright 2006 The Apache Software Foundation or its licensors,
+* as applicable.
+*
+* Copyright 2006 Rogue Wave Software.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*
+**************************************************************************/
+
+#include <string>         // for string
+#include <cstddef>        // for size_t
+#include <istream>        // for istream
+#include <ostream>        // for ostream
+#include <locale>         // for locale
+
+#include <21.strings.h>   // for StringMembers
+#include <driver.h>       // for rw_test()
+#include <rw_allocator.h> // for UserAlloc
+#include <rw_char.h>      // for rw_expand()
+#include <rw_new.h>       // for bad_alloc, replacement operator new
+#include <rw_streambuf.h> // for MyStreambuf
+
+/**************************************************************************/
+
+static const char* const exceptions[] = {
+    "unknown exception", "ios_base::failure", "bad_alloc", "exception"
+};
+
+/**************************************************************************/
+
+// for convenience
+#define Good    std::ios_base::goodbit
+#define Eof     std::ios_base::eofbit
+#define Fail    std::ios_base::failbit
+#define Bad     std::ios_base::badbit
+
+#define NotGood Eof | Fail | Bad
+
+#define Skipws   std::ios_base::skipws
+#define Left     std::ios_base::left
+#define Right    std::ios_base::right
+
+#define WHITESPACE " \f\n\r\t\v"
+
+// off   - width
+// size  - fmtflags
+// off2  - iostate or exceptions mask
+// size2 - expected iostate or -1 if not verifyed
+// val   - expected width
+// str   - controlled sequence
+// arg   - sequence in stream
+// res   - expected result
+
+// bthrow == 0 - off2 is initial stream state
+//        == 1 - off2 is exceptions mask
+
+// used to exercise
+// operator>> (istream&, string&)
+static const StringTestCase 
+extractor_test_cases [] = {
+
+#undef TEST
+#define TEST(str, arg, width, flags, state, res, res_width, res_st, bthrow) { \
+    __LINE__, width, flags, state, res_st, res_width,                         \
+    str, sizeof (str) - 1, arg, sizeof (arg) - 1,                             \
+    res, sizeof (res) - 1, bthrow                                             \
+}
+
+    // 1.
+    // string and width should be unchanged when initial iostate is not good
+    // or initial iostate is good and flag skipws is set
+    // and stream contains only spaces or empty
+
+    //    +----------------------------------------------- controlled sequence
+    //    |    +------------------------------------------ sequence in stream 
+    //    |    |           +------------------------------ stream width       
+    //    |    |           |   +-------------------------- stream flags       
+    //    |    |           |   |       +------------------ stream state       
+    //    |    |           |   |       |                     or exceptions
+    //    |    |           |   |       |        +--------- expected result    
+    //    |    |           |   |       |        | +------- expected width     
+    //    |    |           |   |       |        | |   +--- expected state
+    //    |    |           |   |       |        | |   | +- exception info:
+    //    |    |           |   |       |        | |   | |  0 - no exception
+    //    |    |           |   |       |        | |   | |  1 - ios_base::failure
+    //    |    |           |   |       |        | |   | |  -1 - exc. safety
+    //    |    |           |   |       |        | |   | |
+    //    |    |           |   |       |        | |   | +------+
+    //    |    |           |   |       |        | |   +--+     |
+    //    |    |           |   |       |        | +--+   |     |
+    //    |    |           |   |       |        |    |   |     |
+    //    V    V           V   V       V        V    V   V     V
+
+#undef TEST1                                
+#define TEST1(str)                                                 \
+    TEST (str, "",         0,  0,      Eof,     str, 0,  Eof,  0), \
+    TEST (str, "",         1,  0,      Fail,    str, 1,  Fail, 0), \
+    TEST (str, "",         2,  0,      Bad,     str, 2,  Bad,  0), \
+    TEST (str, "",         3,  Skipws, Eof,     str, 3,  Eof,  0), \
+    TEST (str, "",         4,  Skipws, Fail,    str, 4,  Fail, 0), \
+    TEST (str, "",         5,  Skipws, Bad,     str, 5,  Bad,  0), \
+    TEST (str, "",         6,  Skipws, Good,    str, 6,  -1,   0), \
+    TEST (str, WHITESPACE, 7,  0,      Eof,     str, 7,  Eof,  0), \
+    TEST (str, WHITESPACE, 8,  0,      Fail,    str, 8,  Fail, 0), \
+    TEST (str, WHITESPACE, 9,  0,      Bad,     str, 9,  Bad,  0), \
+    TEST (str, WHITESPACE, 10, Skipws, Eof,     str, 10, Eof,  0), \
+    TEST (str, WHITESPACE, 11, Skipws, Fail,    str, 11, Fail, 0), \
+    TEST (str, WHITESPACE, 12, Skipws, Bad,     str, 12, Bad,  0), \
+    TEST (str, WHITESPACE, 13, Skipws, Good,    str, 13, -1,   0), \
+    TEST (str, "",         14, Skipws, NotGood, str, 14, -1,   1), \
+    TEST (str, WHITESPACE, 15, Skipws, NotGood, str, 15, -1,   1)
+
+    //     +----------------------------------------- controlled sequence
+    //     |
+    //     |
+    //     V
+    TEST1 (""             ),
+    TEST1 ("ab"           ),
+    TEST1 ("abc"          ),
+    TEST1 ("<U0>"         ),
+    TEST1 ("<U0>@2ab"     ),
+    TEST1 ("a<U0>@2b"     ),
+    TEST1 ("ab<U0>@2"     ),
+    TEST1 ("a<U0>b<U0>@2c"),
+    TEST1 ("<U0>ab<U0>@2c"),
+    TEST1 ("x@4096"       ),
+
+
+    // 2.
+    // string should be erased when initial iostate is good and
+    // flag skipws is not set and stream empty or contains string
+    // which begins from spaces
+    // width should be 0, iostate should have Fail bit setted
+
+    //    +----------------------------------------------- controlled sequence
+    //    |    +------------------------------------------ sequence in stream 
+    //    |    |                      +------------------- stream width       
+    //    |    |                      |   +--------------- stream flags       
+    //    |    |                      |   |  +------------ stream state       
+    //    |    |                      |   |  |               or exceptions
+    //    |    |                      |   |  |   +-------- expected result    
+    //    |    |                      |   |  |   |  +----- expected width     
+    //    |    |                      |   |  |   |  | +--- expected state
+    //    |    |                      |   |  |   |  | | +- exception info:
+    //    |    |                      |   |  |   |  | | |  0 - no exception
+    //    |    |                      |   |  |   |  | | |  1 - ios_base::failure
+    //    |    |                      |   |  |   |  | | |  -1 - exc. safety
+    //    |    |                      |   |  |   |  | | |
+    //    |    |                      |   |  |   |  | | +-----------------+
+    //    |    |                      |   |  |   |  | +-------+           |
+    //    |    |                      |   |  |   |  +-----+   |           |     
+    //    |    |                      |   |  |   +----+   |   |           |     
+    //    |    |                      |   |  |        |   |   |           |     
+    //    V    V                      V   V  V        V   V   V           V     
+                                                   
+#undef TEST2                                       
+#define TEST2(str)                                                            \
+    TEST (str, "",                    0,  0, Good,    "", 0 , Eof | Fail, 0), \
+    TEST (str, "",                    10, 0, Good,    "", 0 , Eof | Fail, 0), \
+    TEST (str, WHITESPACE,            0,  0, Good,    "", 0 , Fail,       0), \
+    TEST (str, WHITESPACE,            2,  0, Good,    "", 0 , Fail,       0), \
+    TEST (str, WHITESPACE,            20, 0, Good,    "", 0 , Fail,       0), \
+    TEST (str, WHITESPACE "abc",      0,  0, Good,    "", 0 , Fail,       0), \
+    TEST (str, WHITESPACE "abc",      2,  0, Good,    "", 0 , Fail,       0), \
+    TEST (str, WHITESPACE "abc",      10, 0, Good,    "", 0 , Fail,       0), \
+    TEST (str, WHITESPACE "abc\ndef", 0,  0, Good,    "", 0 , Fail,       0), \
+    TEST (str, WHITESPACE "abc\ndef", 3,  0, Good,    "", 0 , Fail,       0), \
+    TEST (str, WHITESPACE "abc\ndef", 30, 0, Good,    "", 0 , Fail,       0), \
+    TEST (str, WHITESPACE "<U0>@3",   0,  0, Good,    "", 0 , Fail,       0), \
+    TEST (str, WHITESPACE "<U0>@3",   2,  0, Good,    "", 0 , Fail,       0), \
+    TEST (str, WHITESPACE "<U0>@3",   10, 0, Good,    "", 0 , Fail,       0), \
+    TEST (str, "",                    0,  0, NotGood, "", 0 , Eof | Fail, 1), \
+    TEST (str, "",                    10, 0, NotGood, "", 0 , Eof | Fail, 1), \
+    TEST (str, WHITESPACE,            0,  0, NotGood, "", 0 , Fail,       1), \
+    TEST (str, WHITESPACE,            2,  0, NotGood, "", 0 , Fail,       1), \
+    TEST (str, WHITESPACE,            20, 0, NotGood, "", 0 , Fail,       1), \
+    TEST (str, WHITESPACE "abc",      0,  0, NotGood, "", 0 , Fail,       1), \
+    TEST (str, WHITESPACE "abc",      2,  0, NotGood, "", 0 , Fail,       1), \
+    TEST (str, WHITESPACE "abc",      10, 0, NotGood, "", 0 , Fail,       1), \
+    TEST (str, WHITESPACE "abc\ndef", 0,  0, NotGood, "", 0 , Fail,       1), \
+    TEST (str, WHITESPACE "abc\ndef", 3,  0, NotGood, "", 0 , Fail,       1), \
+    TEST (str, WHITESPACE "abc\ndef", 30, 0, NotGood, "", 0 , Fail,       1), \
+    TEST (str, WHITESPACE "<U0>@3",   0,  0, NotGood, "", 0 , Fail,       1), \
+    TEST (str, WHITESPACE "<U0>@3",   2,  0, NotGood, "", 0 , Fail,       1), \
+    TEST (str, WHITESPACE "<U0>@3",   10, 0, NotGood, "", 0 , Fail,       1)
+
+    //     +----------------------------------------- controlled sequence
+    //     |
+    //     |
+    //     V
+    TEST2 (""             ),
+    TEST2 ("ab"           ),
+    TEST2 ("abc"          ),
+    TEST2 ("<U0>"         ),
+    TEST2 ("<U0>@2ab"     ),
+    TEST2 ("a<U0>@2b"     ),
+    TEST2 ("ab<U0>@2"     ),
+    TEST2 ("a<U0>b<U0>@2c"),
+    TEST2 ("<U0>ab<U0>@2c"),
+    TEST2 ("x@4096"       ),
+
+
+    // 3.
+    // string should be compared with result when
+    // initial iostate is good
+    // and
+    //     flag skipws is not set and stream string begins from not space
+    //   or
+    //     flag skipws is set and stream string contains not only spaces
+    // width should be 0
+
+    //    +----------------------------------------------- controlled sequence
+    //    |                +------------------------------ sequence in stream 
+    //    |                |    +------------------------- stream width       
+    //    |                |    |      +------------------ stream flags       
+    //    |                |    |      |      +----------- stream state       
+    //    |                |    |      |      |              or exceptions
+    //    |                |    |      |      |  +-------- expected result    
+    //    |                |    |      |      |  |  +----- expected width     
+    //    |                |    |      |      |  |  | +--- expected state
+    //    |                |    |      |      |  |  | | +- exception info:
+    //    |                |    |      |      |  |  | | |  0 - no exception
+    //    |                |    |      |      |  |  | | |  1 - ios_base::failure
+    //    |                |    |      |      |  |  | | |  -1 - exc. safety
+    //    |                |    |      |      |  |  | | |
+    //    |                |    |      |      |  |  | | +----------+
+    //    |                |    |      |      |  |  | +--------+   |
+    //    |                |    |      |      |  |  +------+   |   |
+    //    |                |    |      |      |  +-----+   |   |   |
+    //    |                |    |      |      |        |   |   |   |
+    //    V                V    V      V      V        V   V   V   V
+                                                
+#undef TEST3                                    
+#define TEST3(arg, width, flags, res)                                  \
+    TEST ("",              arg, width, flags, Good,    res, 0, -1, 0), \
+    TEST ("ab",            arg, width, flags, Good,    res, 0, -1, 0), \
+    TEST ("abc",           arg, width, flags, Good,    res, 0, -1, 0), \
+    TEST ("<U0>",          arg, width, flags, Good,    res, 0, -1, 0), \
+    TEST ("<U0>@2ab",      arg, width, flags, Good,    res, 0, -1, 0), \
+    TEST ("a<U0>@2b",      arg, width, flags, Good,    res, 0, -1, 0), \
+    TEST ("ab<U0>@2",      arg, width, flags, Good,    res, 0, -1, 0), \
+    TEST ("a<U0>b<U0>@2c", arg, width, flags, Good,    res, 0, -1, 0), \
+    TEST ("<U0>ab<U0>@2c", arg, width, flags, Good,    res, 0, -1, 0), \
+    TEST ("x@4096",        arg, width, flags, Good,    res, 0, -1, 0), \
+    TEST ("",              arg, width, flags, NotGood, res, 0, -1, 1), \
+    TEST ("ab",            arg, width, flags, NotGood, res, 0, -1, 1), \
+    TEST ("abc",           arg, width, flags, NotGood, res, 0, -1, 1), \
+    TEST ("<U0>",          arg, width, flags, NotGood, res, 0, -1, 1), \
+    TEST ("<U0>@2ab",      arg, width, flags, NotGood, res, 0, -1, 1), \
+    TEST ("a<U0>@2b",      arg, width, flags, NotGood, res, 0, -1, 1), \
+    TEST ("ab<U0>@2",      arg, width, flags, NotGood, res, 0, -1, 1), \
+    TEST ("a<U0>b<U0>@2c", arg, width, flags, NotGood, res, 0, -1, 1), \
+    TEST ("<U0>ab<U0>@2c", arg, width, flags, NotGood, res, 0, -1, 1), \
+    TEST ("x@4096",        arg, width, flags, NotGood, res, 0, -1, 1)
+
+    //     +------------------------------------------------- sequence in stream
+    //     |                            +-------------------- stream width
+    //     |                            |   +---------------- stream flags
+    //     |                            |   |       +-------- expected result 
+    //     |                            |   |       |
+    //     |                            |   |       |
+    //     V                            V   V       V
+    TEST3 ("abc",                       0,  0,      "abc"),
+    TEST3 ("abc",                       2,  0,      "ab" ),
+    TEST3 ("abc",                       10, 0,      "abc"),
+
+    TEST3 ("abc" WHITESPACE,            0,  0,      "abc"),
+    TEST3 ("abc" WHITESPACE,            2,  0,      "ab" ),
+    TEST3 ("abc" WHITESPACE,            10, 0,      "abc"),
+
+    TEST3 ("abc",                       0,  Skipws, "abc"),
+    TEST3 ("abc",                       2,  Skipws, "ab" ),
+    TEST3 ("abc",                       10, Skipws, "abc"),
+
+    TEST3 ("abc" WHITESPACE,            0,  Skipws, "abc"),
+    TEST3 ("abc" WHITESPACE,            2,  Skipws, "ab" ),
+    TEST3 ("abc" WHITESPACE,            10, Skipws, "abc"),
+
+    TEST3 (WHITESPACE "abc",            0,  Skipws, "abc"),
+    TEST3 (WHITESPACE "abc",            2,  Skipws, "ab" ),
+    TEST3 (WHITESPACE "abc",            30, Skipws, "abc"),
+
+    TEST3 (WHITESPACE "abc" WHITESPACE, 0,  Skipws, "abc"),
+    TEST3 (WHITESPACE "abc" WHITESPACE, 2,  Skipws, "ab" ),
+    TEST3 (WHITESPACE "abc" WHITESPACE, 30, Skipws, "abc")
+};
+
+/**************************************************************************/
+
+// off   - width
+// size  - fmtflags
+// off2  - iostate or exceptions mask
+// size2 - expected iostate or -1 if not verifyed
+// val   - unused
+// str   - controlled sequence
+// arg   - sequence in stream
+// res   - expected result
+
+// bthrow == 0 - off2 is initial stream state
+//        == 1 - off2 is exceptions mask
+
+// used to exercise
+// getline (istream&, string&)
+static const StringTestCase 
+getline_test_cases [] = {
+
+#undef TEST
+#define TEST(str, arg, width, flags, state, res, res_width, res_st, bthrow) { \
+    __LINE__, width, flags, state, res_st, res_width,                         \
+    str, sizeof (str) - 1, arg, sizeof (arg) - 1,                             \
+    res, sizeof (res) - 1, bthrow                                             \
+}
+
+    // 1.
+    // string and width should be unchanged when initial iostate is not good
+
+    //    +---------------------------------------------- controlled sequence
+    //    |    +----------------------------------------- sequence in stream 
+    //    |    |              +-------------------------- stream width       
+    //    |    |              |   +---------------------- stream flags       
+    //    |    |              |   |       +-------------- stream state       
+    //    |    |              |   |       |                 or exceptions
+    //    |    |              |   |       |     +-------- expected result    
+    //    |    |              |   |       |     |  +----- unused
+    //    |    |              |   |       |     |  | +--- expected state
+    //    |    |              |   |       |     |  | | +- exception info:
+    //    |    |              |   |       |     |  | | |  0 - no exception
+    //    |    |              |   |       |     |  | | |  1 - ios_base::failure
+    //    |    |              |   |       |     |  | | |  -1 - exc. safety
+    //    |    |              |   |       |     |  | | |
+    //    |    |              |   |       |     |  | | +---------+
+    //    |    |              |   |       |     |  | +-----+     |
+    //    |    |              |   |       |     |  +---+   |     |
+    //    |    |              |   |       |     +--+   |   |     |
+    //    |    |              |   |       |        |   |   |     |
+    //    V    V              V   V       V        V   V   V     V
+
+#undef TEST1                                
+#define TEST1(str)                                                   \
+    TEST (str, "",            0,  0,      Eof,     str, 0, Eof,  0), \
+    TEST (str, "",            1,  0,      Fail,    str, 0, Fail, 0), \
+    TEST (str, "",            2,  0,      Bad,     str, 0, Bad,  0), \
+    TEST (str, "",            3,  Skipws, Eof,     str, 0, Eof,  0), \
+    TEST (str, "",            4,  Skipws, Fail,    str, 0, Fail, 0), \
+    TEST (str, "",            5,  Skipws, Bad,     str, 0, Bad,  0), \
+    TEST (str, WHITESPACE,    7,  0,      Eof,     str, 0, Eof,  0), \
+    TEST (str, WHITESPACE,    8,  0,      Fail,    str, 0, Fail, 0), \
+    TEST (str, WHITESPACE,    9,  0,      Bad,     str, 0, Bad,  0), \
+    TEST (str, WHITESPACE,    10, Skipws, Eof,     str, 0, Eof,  0), \
+    TEST (str, WHITESPACE,    11, Skipws, Fail,    str, 0, Fail, 0), \
+    TEST (str, WHITESPACE,    12, Skipws, Bad,     str, 0, Bad,  0), \
+    TEST (str, "abc",         13, 0,      Eof,     str, 0, Eof,  0), \
+    TEST (str, "x@4096",      14, 0,      Fail,    str, 0, Fail, 0), \
+    TEST (str, "<U0>abc<U0>", 15, 0,      Bad,     str, 0, Bad,  0), \
+    TEST (str, "abc\ndef",    16, Skipws, Eof,     str, 0, Eof,  0), \
+    TEST (str, " \tabc",      17, Skipws, Fail,    str, 0, Fail, 0), \
+    TEST (str, "\n\n<U0>\n",  18, Skipws, Bad,     str, 0, Bad,  0)
+
+    //     +----------------------------------------- controlled sequence
+    //     |
+    //     |
+    //     V
+    TEST1 (""             ),
+    TEST1 ("ab"           ),
+    TEST1 ("abc"          ),
+    TEST1 ("<U0>"         ),
+    TEST1 ("<U0>@2ab"     ),
+    TEST1 ("a<U0>@2b"     ),
+    TEST1 ("ab<U0>@2"     ),
+    TEST1 ("a<U0>b<U0>@2c"),
+    TEST1 ("<U0>ab<U0>@2c"),
+    TEST1 ("x@4096"       ),
+
+
+    // 2.
+    // string should be erased when initial iostate is good and
+    // stream empty or contains string which begins from '\n'
+    // width should be unchanged, iostate should have Fail bit setted
+
+    //    +--------------------------------------------- controlled sequence
+    //    |    +---------------------------------------- sequence in stream 
+    //    |    |             +-------------------------- stream width       
+    //    |    |             |   +---------------------- stream flags       
+    //    |    |             |   |       +-------------- stream state       
+    //    |    |             |   |       |                 or exceptions
+    //    |    |             |   |       |     +-------- expected result    
+    //    |    |             |   |       |     |  +----- unused
+    //    |    |             |   |       |     |  | +--- expected state
+    //    |    |             |   |       |     |  | | +- exception info:
+    //    |    |             |   |       |     |  | | |  0 - no exception
+    //    |    |             |   |       |     |  | | |  1 - ios_base::failure
+    //    |    |             |   |       |     |  | | |  -1 - exc. safety
+    //    |    |             |   |       |     |  | | |
+    //    |    |             |   |       |     |  | | +--------------+
+    //    |    |             |   |       |     |  | +----+           |
+    //    |    |             |   |       |     |  +---+  |           |
+    //    |    |             |   |       |     +--+   |  |           |
+    //    |    |             |   |       |        |   |  |           |
+    //    V    V             V   V       V        V   V  V           V
+
+#undef TEST2                                       
+#define TEST2(str)                                                       \
+    TEST (str, "",           0,  Skipws, Good,    "", 0, Eof | Fail, 0), \
+    TEST (str, "",           10, 0,      Good,    "", 0, Eof | Fail, 0), \
+    TEST (str, "\n",         0,  Skipws, Good,    "", 0, Good,       0), \
+    TEST (str, "\n",         2,  0,      Good,    "", 0, Good,       0), \
+    TEST (str, "\nabc",      0,  Skipws, Good,    "", 0, Good,       0), \
+    TEST (str, "\nabc",      2,  0,      Good,    "", 0, Good,       0), \
+    TEST (str, "\nabc\ndef", 0,  Skipws, Good,    "", 0, Good,       0), \
+    TEST (str, "\nabc\ndef", 3,  0,      Good,    "", 0, Good,       0), \
+    TEST (str, "\n<U0>@3",   0,  Skipws, Good,    "", 0, Good,       0), \
+    TEST (str, "\n<U0>@3",   2,  0,      Good,    "", 0, Good,       0), \
+    TEST (str, "",           0,  Skipws, NotGood, "", 0, Eof | Fail, 1), \
+    TEST (str, "",           10, 0,      NotGood, "", 0, Eof | Fail, 1), \
+    TEST (str, "\n",         0,  Skipws, NotGood, "", 0, Good,       1), \
+    TEST (str, "\n",         2,  0,      NotGood, "", 0, Good,       1), \
+    TEST (str, "\nabc",      0,  Skipws, NotGood, "", 0, Good,       1), \
+    TEST (str, "\nabc",      2,  0,      NotGood, "", 0, Good,       1), \
+    TEST (str, "\nabc\ndef", 0,  Skipws, NotGood, "", 0, Good,       1), \
+    TEST (str, "\nabc\ndef", 3,  0,      NotGood, "", 0, Good,       1), \
+    TEST (str, "\n<U0>@3",   0,  Skipws, NotGood, "", 0, Good,       1), \
+    TEST (str, "\n<U0>@3",   2,  0,      NotGood, "", 0, Good,       1)
+
+    //     +----------------------------------------- controlled sequence
+    //     |
+    //     |
+    //     V
+    TEST2 (""             ),
+    TEST2 ("ab"           ),
+    TEST2 ("abc"          ),
+    TEST2 ("<U0>"         ),
+    TEST2 ("<U0>@2ab"     ),
+    TEST2 ("a<U0>@2b"     ),
+    TEST2 ("ab<U0>@2"     ),
+    TEST2 ("a<U0>b<U0>@2c"),
+    TEST2 ("<U0>ab<U0>@2c"),
+    TEST2 ("x@4096"       ),
+
+
+    // 3.
+    // string should be compared with result when initial iostate is good
+    // and stream string begins from not '\n'
+    // width should be unchanged
+
+    //    +----------------------------------------------- controlled sequence
+    //    |                +------------------------------ sequence in stream 
+    //    |                |    +------------------------- stream width       
+    //    |                |    |   +--------------------- stream flags       
+    //    |                |    |   |       +------------- stream state       
+    //    |                |    |   |       |                or exceptions
+    //    |                |    |   |       |    +-------- expected result    
+    //    |                |    |   |       |    |  +----- unused
+    //    |                |    |   |       |    |  | +--- expected state
+    //    |                |    |   |       |    |  | | +- exception info:
+    //    |                |    |   |       |    |  | | |  0 - no exception
+    //    |                |    |   |       |    |  | | |  1 - ios_base::failure
+    //    |                |    |   |       |    |  | | |  -1 - exc. safety
+    //    |                |    |   |       |    |  | | |
+    //    |                |    |   |       |    |  | | +--------+
+    //    |                |    |   |       |    |  | +------+   |
+    //    |                |    |   |       |    |  +-----+  |   |
+    //    |                |    |   |       |    +---+    |  |   |
+    //    |                |    |   |       |        |    |  |   |
+    //    V                V    V   V       V        V    V  V   V
+
+#undef TEST3
+#define TEST3(arg, res)                                              \
+    TEST ("",              arg, 0,  Skipws, Good,    res, 0, -1, 0), \
+    TEST ("ab",            arg, 1,  0,      Good,    res, 0, -1, 0), \
+    TEST ("abc",           arg, 2,  Skipws, Good,    res, 0, -1, 0), \
+    TEST ("<U0>",          arg, 3,  0,      Good,    res, 0, -1, 0), \
+    TEST ("<U0>@2ab",      arg, 4,  Skipws, Good,    res, 0, -1, 0), \
+    TEST ("a<U0>@2b",      arg, 5,  0,      Good,    res, 0, -1, 0), \
+    TEST ("ab<U0>@2",      arg, 6,  Skipws, Good,    res, 0, -1, 0), \
+    TEST ("a<U0>b<U0>@2c", arg, 7,  0,      Good,    res, 0, -1, 0), \
+    TEST ("<U0>ab<U0>@2c", arg, 8,  Skipws, Good,    res, 0, -1, 0), \
+    TEST ("x@4096",        arg, 9,  0,      Good,    res, 0, -1, 0), \
+    TEST ("",              arg, 10, Skipws, NotGood, res, 0, -1, 1), \
+    TEST ("ab",            arg, 11, 0,      NotGood, res, 0, -1, 1), \
+    TEST ("abc",           arg, 12, Skipws, NotGood, res, 0, -1, 1), \
+    TEST ("<U0>",          arg, 13, 0,      NotGood, res, 0, -1, 1), \
+    TEST ("<U0>@2ab",      arg, 14, Skipws, NotGood, res, 0, -1, 1), \
+    TEST ("a<U0>@2b",      arg, 15, 0,      NotGood, res, 0, -1, 1), \
+    TEST ("ab<U0>@2",      arg, 16, Skipws, NotGood, res, 0, -1, 1), \
+    TEST ("a<U0>b<U0>@2c", arg, 17, 0,      NotGood, res, 0, -1, 1), \
+    TEST ("<U0>ab<U0>@2c", arg, 18, Skipws, NotGood, res, 0, -1, 1), \
+    TEST ("x@4096",        arg, 19, 0,      NotGood, res, 0, -1, 1)
+
+    //     +------------------------------------------------- sequence in stream
+    //     |                         +----------------------- expected result 
+    //     |                         |
+    //     |                         |
+    //     V                         V
+    TEST3 ("abc",                    "abc"           ),
+    TEST3 ("ab\nc",                  "ab"            ),
+    TEST3 ("a\nbc",                  "a"             ),
+    TEST3 (" \t\n",                  " \t"           ),
+    TEST3 (" \f\r\t\v\n",            " \f\r\t\v"     ),
+    TEST3 (" \f\r\n\t\v\n",          " \f\r"         ),
+    TEST3 ("<U0>a<U0>b<U0>\n<U0>@2", "<U0>a<U0>b<U0>"),
+    TEST3 ("<U0>@7",                 "<U0>@7"        ),
+    TEST3 ("x@4096",                 "x@4096"        ),
+    TEST3 ("x@4096\nx@4096",         "x@4096"        )
+};
+
+/**************************************************************************/
+
+// off   - width
+// size  - fmtflags
+// off2  - iostate or exceptions mask
+// size2 - expected iostate or -1 if not verifyed
+// val   - char delim
+// str   - controlled sequence
+// arg   - sequence in stream
+// res   - expected result
+
+// bthrow == 0 - off2 is initial stream state
+//        == 1 - off2 is exceptions mask
+
+// used to exercise
+// getline (istream&, string&, char)
+static const StringTestCase 
+getline_val_test_cases [] = {
+
+#undef TEST
+#define TEST(str, arg, width, flags, state, res, res_width, res_st, bthrow) { \
+    __LINE__, width, flags, state, res_st, res_width,                         \
+    str, sizeof (str) - 1, arg, sizeof (arg) - 1,                             \
+    res, sizeof (res) - 1, bthrow                                             \
+}
+
+    // 1.
+    // string and width should be unchanged when initial iostate is not good
+
+    //    +---------------------------------------------- controlled sequence
+    //    |    +----------------------------------------- sequence in stream 
+    //    |    |              +-------------------------- stream width       
+    //    |    |              |   +---------------------- stream flags       
+    //    |    |              |   |       +-------------- stream state       
+    //    |    |              |   |       |                 or exceptions
+    //    |    |              |   |       |     +-------- expected result    
+    //    |    |              |   |       |     |  +----- delim
+    //    |    |              |   |       |     |  | +--- expected state
+    //    |    |              |   |       |     |  | | +- exception info:
+    //    |    |              |   |       |     |  | | |  0 - no exception
+    //    |    |              |   |       |     |  | | |  1 - ios_base::failure
+    //    |    |              |   |       |     |  | | |  -1 - exc. safety
+    //    |    |              |   |       |     |  | | |
+    //    |    |              |   |       |     |  | | +------------+
+    //    |    |              |   |       |     |  | +--------+     |
+    //    |    |              |   |       |     |  +----+     |     |
+    //    |    |              |   |       |     +--+    |     |     |
+    //    |    |              |   |       |        |    |     |     |
+    //    V    V              V   V       V        V    V     V     V
+                        
+#undef TEST1                                   
+#define TEST1(str)                                                      \
+    TEST (str, "",            0,  0,      Eof,     str, '\n', Eof,  0), \
+    TEST (str, "",            1,  0,      Fail,    str, '\0', Fail, 0), \
+    TEST (str, "",            2,  0,      Bad,     str, '\r', Bad,  0), \
+    TEST (str, "",            3,  Skipws, Eof,     str, '\a', Eof,  0), \
+    TEST (str, "",            4,  Skipws, Fail,    str, '\b', Fail, 0), \
+    TEST (str, "",            5,  Skipws, Bad,     str, '\t', Bad,  0), \
+    TEST (str, WHITESPACE,    7,  0,      Eof,     str, '\v', Eof,  0), \
+    TEST (str, WHITESPACE,    8,  0,      Fail,    str, 'a',  Fail, 0), \
+    TEST (str, WHITESPACE,    9,  0,      Bad,     str, ' ',  Bad,  0), \
+    TEST (str, WHITESPACE,    10, Skipws, Eof,     str, '1',  Eof,  0), \
+    TEST (str, WHITESPACE,    11, Skipws, Fail,    str, '5',  Fail, 0), \
+    TEST (str, WHITESPACE,    12, Skipws, Bad,     str, 'w',  Bad,  0), \
+    TEST (str, "abc",         13, 0,      Eof,     str, 'b',  Eof,  0), \
+    TEST (str, "x@4096",      14, 0,      Fail,    str, 'x',  Fail, 0), \
+    TEST (str, "<U0>abc<U0>", 15, 0,      Bad,     str, 'c',  Bad,  0), \
+    TEST (str, "abc\ndef",    16, Skipws, Eof,     str, 'e',  Eof,  0), \
+    TEST (str, " \tabc",      17, Skipws, Fail,    str, '\t', Fail, 0), \
+    TEST (str, "\n\n<U0>\n",  18, Skipws, Bad,     str, '\0', Bad,  0)
+
+    //     +----------------------------------------- controlled sequence
+    //     |
+    //     |
+    //     V
+    TEST1 (""             ),
+    TEST1 ("ab"           ),
+    TEST1 ("abc"          ),
+    TEST1 ("<U0>"         ),
+    TEST1 ("<U0>@2ab"     ),
+    TEST1 ("a<U0>@2b"     ),
+    TEST1 ("ab<U0>@2"     ),
+    TEST1 ("a<U0>b<U0>@2c"),
+    TEST1 ("<U0>ab<U0>@2c"),
+    TEST1 ("x@4096"       ),
+
+
+    // 2.
+    // string should be erased when initial iostate is good and
+    // stream empty or contains string which begins from delim
+    // width should be unchanged, iostate should have Fail bit setted
+
+    //    +--------------------------------------------- controlled sequence
+    //    |    +---------------------------------------- sequence in stream 
+    //    |    |             +-------------------------- stream width       
+    //    |    |             |   +---------------------- stream flags       
+    //    |    |             |   |       +-------------- stream state       
+    //    |    |             |   |       |                 or exceptions
+    //    |    |             |   |       |     +-------- expected result    
+    //    |    |             |   |       |     |  +----- delim
+    //    |    |             |   |       |     |  | +--- expected state
+    //    |    |             |   |       |     |  | | +- exception info:
+    //    |    |             |   |       |     |  | | |  0 - no exception
+    //    |    |             |   |       |     |  | | |  1 - ios_base::failure
+    //    |    |             |   |       |     |  | | |  -1 - exc. safety
+    //    |    |             |   |       |     |  | | |
+    //    |    |             |   |       |     |  | | +-----------------+
+    //    |    |             |   |       |     |  | +-------+           |
+    //    |    |             |   |       |     |  +---+     |           |
+    //    |    |             |   |       |     +--+   |     |           |
+    //    |    |             |   |       |        |   |     |           |
+    //    V    V             V   V       V        V   V     V           V
+
+#undef TEST2                                       
+#define TEST2(str)                                                          \
+    TEST (str, "",           0,  Skipws, Good,    "", '\a', Eof | Fail, 0), \
+    TEST (str, "",           10, 0,      Good,    "", '\0', Eof | Fail, 0), \
+    TEST (str, "<U0>",       0,  Skipws, Good,    "", '\0', Good,       0), \
+    TEST (str, "\n",         2,  0,      Good,    "", '\n', Good,       0), \
+    TEST (str, "\rabc",      0,  Skipws, Good,    "", '\r', Good,       0), \
+    TEST (str, "abc",        2,  0,      Good,    "", 'a',  Good,       0), \
+    TEST (str, "\babc\ndef", 0,  Skipws, Good,    "", '\b', Good,       0), \
+    TEST (str, "\tabc\ndef", 3,  0,      Good,    "", '\t', Good,       0), \
+    TEST (str, "\v<U0>@3",   0,  Skipws, Good,    "", '\v', Good,       0), \
+    TEST (str, " <U0>@3",    2,  0,      Good,    "", ' ',  Good,       0), \
+    TEST (str, "",           0,  Skipws, NotGood, "", '\a', Eof | Fail, 1), \
+    TEST (str, "",           10, 0,      NotGood, "", '\0', Eof | Fail, 1), \
+    TEST (str, "<U0>",       0,  Skipws, NotGood, "", '\0', Good,       1), \
+    TEST (str, "\n",         2,  0,      NotGood, "", '\n', Good,       1), \
+    TEST (str, "\rabc",      0,  Skipws, NotGood, "", '\r', Good,       1), \
+    TEST (str, "abc",        2,  0,      NotGood, "", 'a',  Good,       1), \
+    TEST (str, "\babc\ndef", 0,  Skipws, NotGood, "", '\b', Good,       1), \
+    TEST (str, "\tabc\ndef", 3,  0,      NotGood, "", '\t', Good,       1), \
+    TEST (str, "\v<U0>@3",   0,  Skipws, NotGood, "", '\v', Good,       1), \
+    TEST (str, " <U0>@3",    2,  0,      NotGood, "", ' ',  Good,       1)
+
+    //     +----------------------------------------- controlled sequence
+    //     |
+    //     |
+    //     V
+    TEST2 (""             ),
+    TEST2 ("ab"           ),
+    TEST2 ("abc"          ),
+    TEST2 ("<U0>"         ),
+    TEST2 ("<U0>@2ab"     ),
+    TEST2 ("a<U0>@2b"     ),
+    TEST2 ("ab<U0>@2"     ),
+    TEST2 ("a<U0>b<U0>@2c"),
+    TEST2 ("<U0>ab<U0>@2c"),
+    TEST2 ("x@4096"       ),
+
+
+    // 3.
+    // string should be compared with result when initial iostate is good
+    // and stream string begins from not delim
+    // width should be unchanged
+
+    //    +----------------------------------------------- controlled sequence
+    //    |                +------------------------------ sequence in stream 
+    //    |                |    +------------------------- stream width       
+    //    |                |    |   +--------------------- stream flags       
+    //    |                |    |   |       +------------- stream state       
+    //    |                |    |   |       |                or exceptions
+    //    |                |    |   |       |    +-------- expected result    
+    //    |                |    |   |       |    |  +----- delim
+    //    |                |    |   |       |    |  | +--- expected state
+    //    |                |    |   |       |    |  | | +- exception info:
+    //    |                |    |   |       |    |  | | |  0 - no exception
+    //    |                |    |   |       |    |  | | |  1 - ios_base::failure
+    //    |                |    |   |       |    |  | | |  -1 - exc. safety
+    //    |                |    |   |       |    |  | | |
+    //    |                |    |   |       |    |  | | +------------+
+    //    |                |    |   |       |    |  | +----------+   |
+    //    |                |    |   |       |    |  +-----+      |   |
+    //    |                |    |   |       |    +---+    |      |   |
+    //    |                |    |   |       |        |    |      |   |
+    //    V                V    V   V       V        V    V      V   V
+
+#undef TEST3
+#define TEST3(arg, delim, res)                                           \
+    TEST ("",              arg, 0,  Skipws, Good,    res, delim, -1, 0), \
+    TEST ("ab",            arg, 1,  0,      Good,    res, delim, -1, 0), \
+    TEST ("abc",           arg, 2,  Skipws, Good,    res, delim, -1, 0), \
+    TEST ("<U0>",          arg, 3,  0,      Good,    res, delim, -1, 0), \
+    TEST ("<U0>@2ab",      arg, 4,  Skipws, Good,    res, delim, -1, 0), \
+    TEST ("a<U0>@2b",      arg, 5,  0,      Good,    res, delim, -1, 0), \
+    TEST ("ab<U0>@2",      arg, 6,  Skipws, Good,    res, delim, -1, 0), \
+    TEST ("a<U0>b<U0>@2c", arg, 7,  0,      Good,    res, delim, -1, 0), \
+    TEST ("<U0>ab<U0>@2c", arg, 8,  Skipws, Good,    res, delim, -1, 0), \
+    TEST ("x@4096",        arg, 9,  0,      Good,    res, delim, -1, 0), \
+    TEST ("",              arg, 10, Skipws, NotGood, res, delim, -1, 1), \
+    TEST ("ab",            arg, 11, 0,      NotGood, res, delim, -1, 1), \
+    TEST ("abc",           arg, 12, Skipws, NotGood, res, delim, -1, 1), \
+    TEST ("<U0>",          arg, 13, 0,      NotGood, res, delim, -1, 1), \
+    TEST ("<U0>@2ab",      arg, 14, Skipws, NotGood, res, delim, -1, 1), \
+    TEST ("a<U0>@2b",      arg, 15, 0,      NotGood, res, delim, -1, 1), \
+    TEST ("ab<U0>@2",      arg, 16, Skipws, NotGood, res, delim, -1, 1), \
+    TEST ("a<U0>b<U0>@2c", arg, 17, 0,      NotGood, res, delim, -1, 1), \
+    TEST ("<U0>ab<U0>@2c", arg, 18, Skipws, NotGood, res, delim, -1, 1), \
+    TEST ("x@4096",        arg, 19, 0,      NotGood, res, delim, -1, 1)
+
+    //     +------------------------------------------------- sequence in stream
+    //     |                         +----------------------- delim
+    //     |                         |     +----------------- expected result 
+    //     |                         |     |
+    //     |                         |     |
+    //     V                         V     V
+    TEST3 ("abc",                    '\t', "abc"      ),
+    TEST3 ("ab<U0>c",                '\0', "ab"       ),
+    TEST3 ("a\nbc",                  'b',  "a\n"      ),
+    TEST3 (" \t\n",                  '\n', " \t"      ),
+    TEST3 (" \f\r\t\v\n",            '\v', " \f\r\t"  ),
+    TEST3 (" \f\r\n\t\v\n",          '\r', " \f"      ),
+    TEST3 ("<U0>a<U0>b<U0>\n<U0>@2", 'b',  "<U0>a<U0>"),
+    TEST3 ("<U0>@7",                 '1',  "<U0>@7"   ),
+    TEST3 ("x@4096",                 ' ',  "x@4096"   ),
+    TEST3 ("x@4096yx@4096",          'y',  "x@4096"   )
+};
+
+/**************************************************************************/
+
+// off     - width
+// size    - fmtflags
+// off2    - iostate or exceptions mask
+// size2   - expected iostate or -1 if not verifyed
+// val     - expected width
+// str     - controlled sequence
+// arg_len - size of streambuf
+// res     - expected result
+
+// bthrow == 0 - off2 is initial stream state
+//        == 1 - off2 is exceptions mask
+
+// used to exercise
+// operator<< (ostream&, const string&)
+static const StringTestCase 
+inserter_test_cases [] = {
+
+#undef TEST
+#define TEST(str, arg, width, flags, state, res, res_width, res_st, bthrow) { \
+    __LINE__, width, flags, state, res_st, res_width,                         \
+    str, sizeof (str) - 1, 0, arg, res, sizeof (res) - 1, bthrow              \
+}
+
+    // 1. if initial state is not good then width should be
+    // unchanged and no data in output stream
+
+    //    +----------------------------------------- controlled sequence
+    //    |    +------------------------------------ size of streambuf
+    //    |    |          +------------------------- stream width       
+    //    |    |          |   +--------------------- stream flags       
+    //    |    |          |   |       +------------- stream state       
+    //    |    |          |   |       |                 or exceptions
+    //    |    |          |   |       |     +------- expected result    
+    //    |    |          |   |       |     | +----- expected width
+    //    |    |          |   |       |     | | +--- expected state
+    //    |    |          |   |       |     | | | +- exception info:
+    //    |    |          |   |       |     | | | |  0 - no exception
+    //    |    |          |   |       |     | | | |  1 - ios_base::failure
+    //    |    |          |   |       |     | | | |  -1 - exc. safety
+    //    |    |          |   |       |     | | | |
+    //    |    |          |   |       |     | | | +-------+
+    //    |    |          |   |       |     | | +---+     |
+    //    |    |          |   |       |     | +-+   |     |
+    //    |    |          |   |       |     |   |   |     |
+    //    |    |          |   |       |     |   |   |     |
+    //    V    V          V   V       V     V   V   V     V
+
+#undef TEST1
+#define TEST1(str)                                            \
+    TEST (str, 0,         0,  0,      Eof,  "", 0,  Eof,  0), \
+    TEST (str, 0,         1,  0,      Fail, "", 1,  Fail, 0), \
+    TEST (str, 0,         2,  0,      Bad,  "", 2,  Bad,  0)
+
+    //     +----------------------------------------- controlled sequence
+    //     |
+    //     |
+    //     V
+    TEST1 (""             ),
+    TEST1 ("ab"           ),
+    TEST1 ("abc"          ),
+    TEST1 ("<U0>"         ),
+    TEST1 ("<U0>@2ab"     ),
+    TEST1 ("a<U0>@2b"     ),
+    TEST1 ("ab<U0>@2"     ),
+    TEST1 ("a<U0>b<U0>@2c"),
+    TEST1 ("<U0>ab<U0>@2c"),
+    TEST1 ("x@4096"       ),
+
+
+    // 2. if initial state is good then:
+    // if stream has not enough size to get string then failbit should be set
+    //   and width should be unchanged
+    // else width should be 0
+
+    //    +---------------------------------------- controlled sequence
+    //    |    +----------------------------------- size of streambuf
+    //    |    |    +------------------------------ stream width
+    //    |    |    |      +----------------------- stream flags
+    //    |    |    |      |      +---------------- stream state
+    //    |    |    |      |      |                   or exceptions
+    //    |    |    |      |      |        +------- expected result    
+    //    |    |    |      |      |        | +----- expected width
+    //    |    |    |      |      |        | | +--- expected state
+    //    |    |    |      |      |        | | | +- exception info:
+    //    |    |    |      |      |        | | | |  0 - no exception
+    //    |    |    |      |      |        | | | |  1 - ios_base::failure
+    //    |    |    |      |      |        | | | |  -1 - exc. safety
+    //    |    |    |      |      |        | | | |
+    //    |    |    |      |      |        | | | +-----------------+
+    //    |    |    |      |      |        | | +-----------+       |
+    //    |    |    |      |      |        | +--+          |       |
+    //    |    |    |      |      |        |    |          |       |
+    //    |    |    |      |      |        |    |          |       |
+    //    V    V    V      V      V        V    V          V       V
+
+#undef TEST2
+#define TEST2(str, arg, width, flags, res, res_width, res_st)          \
+    TEST (str, arg, width, flags, Good,    res, res_width, res_st, 0), \
+    TEST (str, arg, width, flags, NotGood, res, res_width, res_st, 1)
+
+    //     +------------------------------------------------ controlled sequence
+    //     |                +------------------------------- size of streambuf
+    //     |                |     +------------------------- stream width
+    //     |                |     |     +------------------- stream flags
+    //     |                |     |     |      +------------ expected result
+    //     |                |     |     |      |      +----- expected width
+    //     |                |     |     |      |      |  +-- expected state
+    //     |                |     |     |      |      |  |
+    //     |                |     |     |      |      |  +---------------+
+    //     |                |     |     |      |      +------------+     |
+    //     |                |     |     |      |                   |     |
+    //     V                V     V     V      V                   V     V
+    TEST2 ("",              0,    0,    0,     "",                 0,    Good),
+    TEST2 ("",              0,    0,    Right, "",                 0,    Good),
+    TEST2 ("",              0,    0,    Left,  "",                 0,    Good),
+                                                                  
+    TEST2 ("",              20,   10,   0,     " @10",             0,    Good),
+    TEST2 ("",              20,   10,   Right, " @10",             0,    Good),
+    TEST2 ("",              20,   10,   Left,  " @10",             0,    Good),
+                                                             
+    TEST2 ("",              5,    10,   0,     " @5",              10,   Fail),
+    TEST2 ("",              5,    10,   Right, " @5",              10,   Fail),
+    TEST2 ("",              5,    10,   Left,  " @5",              10,   Fail),
+                                                             
+    TEST2 (" @10",          20,   10,   0,     " @10",             0,    Good),
+    TEST2 (" @10",          20,   10,   Right, " @10",             0,    Good),
+    TEST2 (" @10",          20,   10,   Left,  " @10",             0,    Good),
+                                                                     
+    TEST2 ("abc def",       20,   0,    0,     "abc def",          0,    Good),
+    TEST2 ("abc def",       20,   0,    Right, "abc def",          0,    Good),
+    TEST2 ("abc def",       20,   0,    Left,  "abc def",          0,    Good),
+                                                             
+    TEST2 ("abc def",       5,    0,    0,     "abc d",            0,    Fail),
+    TEST2 ("abc def",       5,    0,    Right, "abc d",            0,    Fail),
+    TEST2 ("abc def",       5,    0,    Left,  "abc d",            0,    Fail),
+                                                             
+    TEST2 ("abc def",       20,   5,    0,     "abc def",          0,    Good),
+    TEST2 ("abc def",       20,   5,    Right, "abc def",          0,    Good),
+    TEST2 ("abc def",       20,   5,    Left,  "abc def",          0,    Good),
+                                                            
+    TEST2 ("abc def",       20,   10,   0,     "   abc def",       0,    Good),
+    TEST2 ("abc def",       20,   10,   Right, "   abc def",       0,    Good),
+    TEST2 ("abc def",       20,   10,   Left,  "abc def   ",       0,    Good),
+                                                                
+    TEST2 ("<U0>",          20,   10,   0,     " @9<U0>",          0,    Good),
+    TEST2 ("<U0>",          20,   10,   Right, " @9<U0>",          0,    Good),
+    TEST2 ("<U0>",          20,   10,   Left,  "<U0> @9",          0,    Good),
+                                                                
+    TEST2 ("<U0>ab<U0>@2c", 20,   10,   0,     " @4<U0>ab<U0>@2c", 0,    Good),
+    TEST2 ("<U0>ab<U0>@2c", 20,   10,   Right, " @4<U0>ab<U0>@2c", 0,    Good),
+    TEST2 ("<U0>ab<U0>@2c", 20,   10,   Left,  "<U0>ab<U0>@2c @4", 0,    Good),
+                                                            
+    TEST2 ("x@4096",        4096, 10,   0,     "x@4096",           0,    Good),
+    TEST2 ("x@4096",        4096, 10,   Right, "x@4096",           0,    Good),
+    TEST2 ("x@4096",        4096, 10,   Left,  "x@4096",           0,    Good),
+
+    TEST2 ("x@4096",        4097, 4097, 0,     " x@4096",          0,    Good),
+    TEST2 ("x@4096",        4097, 4097, Right, " x@4096",          0,    Good),
+    TEST2 ("x@4096",        4097, 4097, Left,  "x@4096 ",          0,    Good)
+};
+
+/**************************************************************************/
+
+class Ctype : public std::ctype<UserChar>
+{
+    typedef std::ctype<UserChar> Base;
+
+public:
+
+    explicit Ctype(size_t refs = 0) : Base(refs)
+    {
+    }
+
+protected:
+
+    virtual bool do_is (mask mask_val, UserChar ch) const
+    {
+        return std::use_facet<std::ctype<char> >(std::locale ()).is (
+            mask_val, do_narrow (ch, char ()));
+    }
+
+    virtual const UserChar* do_is (const UserChar* low,
+                                   const UserChar* high, mask* vec) const
+    {
+        const size_t size = high - low;
+
+        char * buf = new char[size];
+
+        do_narrow (low, high, char (), buf);
+
+        std::use_facet<std::ctype<char> >(std::locale ()).is (
+            buf, buf + size, vec);
+
+        delete[] buf;
+
+        return high;
+    }
+
+    virtual const UserChar* do_scan_is (mask mask_val,
+                                        const UserChar* low,
+                                        const UserChar* high) const
+    {
+        for (; low != high && !do_is (mask_val, *low); ++low) ;
+        return low;
+    }
+
+    virtual const UserChar* do_scan_not (mask mask_val,
+                                         const UserChar* low,
+                                         const UserChar* high) const
+    {
+        for (; low != high && do_is (mask_val, *low); ++low) ;
+        return low;
+    }
+
+    virtual UserChar do_widen (char ch) const
+    {
+        return make_char (ch, _RWSTD_STATIC_CAST (UserChar *, 0));
+    }
+
+    virtual const char* do_widen (const char* low,
+                                  const char* high, UserChar* dest) const
+    {
+        for (; low != high; ++low, ++dest)
+            *dest = do_widen (*low);
+        return low;
+    }
+
+    virtual char do_narrow (UserChar ch, char /*dfault*/) const
+    {
+        char c[2];
+        rw_narrow (c, &ch, 1);
+        return c[0];
+    }
+
+    virtual const UserChar* do_narrow (const UserChar* low,
+                                       const UserChar* high,
+                                       char dfault, char* dest) const
+    {
+        for (; low != high; ++low, ++dest)
+            *dest = do_narrow (*low, dfault);
+        return low;
+    }
+};
+
+/**************************************************************************/
+
+template <class charT, class Traits, class Allocator>
+void test_io (charT*, Traits*, Allocator*,
+              const StringTestCaseData<charT> &tdata)
+{
+    typedef std::basic_string <charT, Traits, Allocator> String;
+    typedef MyStreambuf<charT, Traits>                   Streambuf;
+    typedef std::basic_istream<charT, Traits>            Istream;
+    typedef std::basic_ostream<charT, Traits>            Ostream;
+
+    typedef std::ios_base::fmtflags                      Fmtflags;
+    typedef std::ios_base::iostate                       Iostate;
+
+    const StringFunc     &func  = tdata.func_;
+    const StringTestCase &tcase = tdata.tcase_;
+
+    // construct the string object 
+    String str (tdata.str_, tdata.strlen_);
+    // construct the constant string object
+    const String cstr (tdata.str_, tdata.strlen_);
+
+    static const size_t BUFSIZE = 256;
+
+    static char arg_buf [BUFSIZE];
+
+    size_t arg_len = 0;
+    const char * arg = rw_expand (arg_buf,
+        tcase.arg, tcase.arg_len, &arg_len);
+
+    std::streamsize os_size = tcase.arg_len;
+
+    Ctype ctyp(1);
+
+    Streambuf inbuf (arg, arg_len, 0, -1);
+    Streambuf outbuf (os_size, 0, -1);
+
+    if (arg != arg_buf)
+        delete[] arg;
+
+    arg = 0;
+
+    Istream is (&inbuf);
+    Ostream os (&outbuf);
+
+    // add facet std::ctype<UserChar>
+    is.imbue (std::locale (is.getloc (), &ctyp));
+    os.imbue (is.getloc ());
+
+    is.width(tcase.off);
+    os.width(tcase.off);
+
+    Fmtflags flags = _RWSTD_STATIC_CAST (Fmtflags, tcase.size);
+
+    is.flags(flags);
+    os.flags(flags);
+
+    // save the state of the const string object before the call
+    // to any (changes to the state of the object after a call)
+    const StringState cstr_state (rw_get_string_state (cstr));
+
+#ifndef _RWSTD_NO_EXCEPTIONS
+
+    // (name of) expected and caught exception
+    const char* expected = 0;
+    const char* caught   = 0;
+
+    if (1 == tcase.bthrow) {
+        expected = exceptions [1];   // ios_base::failure
+    } else {
+        // exceptions disabled for this test case
+    }
+
+#else   // if defined (_RWSTD_NO_EXCEPTIONS)
+
+    if (tcase.bthrow)
+        return;
+
+#endif   // _RWSTD_NO_EXCEPTIONS
+
+    Iostate state = _RWSTD_STATIC_CAST (Iostate, tcase.off2);
+
+    if (0 == tcase.bthrow) {
+        // set the state
+        is.clear (state);
+        os.clear (state);
+    } else {
+        // set the exceptions
+        is.exceptions (state);
+        os.exceptions (state);
+    }
+
+    // start checking for memory leaks
+    rw_check_leaks (str.get_allocator ());
+
+    try {
+
+        std::ptrdiff_t ret_off = 0;
+
+        try
+        {
+            switch (func.which_) {
+
+            case StringIds::extractor_istream_str:
+                ret_off = &is - &(is >> str);
+                break;
+
+            case StringIds::getline_istream_str:
+                ret_off = &is - &std::getline (is, str);
+                break;
+
+            case StringIds::getline_istream_str_val:
+                ret_off = &is - &std::getline (is, str,
+                    is.widen (_RWSTD_STATIC_CAST (char, tcase.val)));
+                break;
+
+            case StringIds::inserter_ostream_cstr:
+                ret_off = &os - &(os << cstr);
+                break;
+
+            default:
+                RW_ASSERT ("test logic error: unknown io overload");
+                return;
+            }
+        }
+#ifndef _RWSTD_NO_EXCEPTIONS
+        catch (std::ios_base::failure& ex)
+        {
+            caught = exceptions [1];
+            rw_assert (caught == expected, 0, tcase.line,
+                "line %d. %{$FUNCALL} %{?}expected %s,%{:}"
+                "unexpectedly%{;} caught std::%s(%#s)",
+                __LINE__, 0 != expected, expected, caught, ex.what ());
+
+        }
+#endif   // _RWSTD_NO_EXCEPTIONS
+
+
+        std::streamsize ret_width;
+        Iostate ret_state;
+        const charT * ret_str;
+        size_t ret_sz;
+
+        if (func.which_ != StringIds::inserter_ostream_cstr) {
+            ret_width = is.width ();
+            ret_state = is.rdstate ();
+            ret_str = str.c_str ();
+            ret_sz = str.size ();
+        } else {
+            ret_width = os.width ();
+            ret_state = os.rdstate ();
+            ret_str = outbuf.pubpbase ();
+            ret_sz = outbuf.pubepptr () - ret_str;
+        }
+
+        // for convenience
+        static const int cwidth = sizeof (charT);
+
+        // verify that the reference returned from the function
+        // refers to the passed stream object
+        bool success = 0 == ret_off;
+        rw_assert (success, 0, tcase.line,
+            "line %d. %{$FUNCALL} returned invalid reference, "
+            "offset is %td", __LINE__, ret_off);
+
+        // verify the width
+        std::streamsize width =
+            (func.which_ == StringIds::getline_istream_str ||
+            func.which_ == StringIds::getline_istream_str_val) ?
+            tcase.off : tcase.val;
+
+        success = width == ret_width;
+        rw_assert (success, 0, tcase.line,
+            "line %d. After %{$FUNCALL} strm.width () expected %td, "
+            "actual is %td", __LINE__, width, ret_width);
+
+        // tcase.size2 is expected iostate
+        if (0 <= tcase.size2)
+        {
+            // verify the iostate
+            Iostate res_state = _RWSTD_STATIC_CAST (Iostate, tcase.size2);
+            success = res_state ?
+                (res_state == (ret_state & res_state)) : (0 == ret_state);
+            rw_assert (success, 0, tcase.line,
+                "line %d. After %{$FUNCALL} strm.rdstate () expected %d"
+                ", actual is %d", __LINE__,
+                int (res_state), int (ret_state));
+        }
+
+        // verify that strings length are equal
+        success = tdata.reslen_ == ret_sz;
+        rw_assert (success, 0, tcase.line,
+            "line %d. %{$FUNCALL}: expected %{/*.*Gs} with length "
+            "%zu, got %{/*.*Gs} with length %zu", __LINE__, 
+            cwidth, int (tdata.reslen_), tdata.res_, tdata.reslen_,
+            cwidth, int (ret_sz), ret_str, ret_sz);
+
+        if (tdata.reslen_ == ret_sz) {
+            // if the result length matches the expected length
+            // (and only then), also verify that the modified
+            // string matches the expected result
+            const std::size_t match =
+                rw_match (tcase.res, ret_str, ret_sz);
+
+            success = match == tdata.reslen_;
+            rw_assert (success, 0, tcase.line,
+                "line %d. %{$FUNCALL}: expected %{/*.*Gs}, "
+                "got %{/*.*Gs}, difference at off %zu",
+                __LINE__, cwidth, int (tdata.reslen_), tdata.res_,
+                cwidth, int (ret_sz), ret_str, match);
+        }
+    }
+
+#ifndef _RWSTD_NO_EXCEPTIONS
+
+    catch (const std::bad_alloc &ex) {
+        caught = exceptions [2];
+        rw_assert (0, 0, tcase.line,
+            "line %d. %{$FUNCALL} %{?}expected %s,%{:}"
+            "unexpectedly%{;} caught std::%s(%#s)",
+            __LINE__, 0 != expected, expected, caught, ex.what ());
+    }
+    catch (const std::exception &ex) {
+        caught = exceptions [3];
+        rw_assert (0, 0, tcase.line,
+            "line %d. %{$FUNCALL} %{?}expected %s,%{:}"
+            "unexpectedly%{;} caught std::%s(%#s)",
+            __LINE__, 0 != expected, expected, caught, ex.what ());
+    }
+    catch (...) {
+        caught = exceptions [0];
+        rw_assert (0, 0, tcase.line,
+            "line %d. %{$FUNCALL} %{?}expected %s,%{:}"
+            "unexpectedly%{;} caught %s",
+            __LINE__, 0 != expected, expected, caught);
+    }
+
+#endif   // _RWSTD_NO_EXCEPTIONS
+
+    // verify that const string object was not modified during call
+    cstr_state.assert_equal (rw_get_string_state (cstr),
+        __LINE__, tcase.line, "call");
+
+    // FIXME: verify the number of blocks the function call
+    // is expected to allocate and detect any memory leaks
+    rw_check_leaks (str.get_allocator (), tcase.line,
+        std::size_t (-1), std::size_t (-1));
+}
+
+/**************************************************************************/
+
+DEFINE_STRING_TEST_FUNCTIONS (test_io);
+
+int main (int argc, char** argv)
+{
+    static const StringTest
+    tests [] = {
+
+#undef TEST
+#define TEST(gsig, sig) {                                       \
+    gsig, sig ## _test_cases,                                   \
+    sizeof sig ## _test_cases / sizeof *sig ## _test_cases      \
+}
+
+        TEST (StringIds::extractor_istream_str, extractor),
+        TEST (StringIds::inserter_ostream_cstr, inserter),
+        TEST (StringIds::getline_istream_str, getline),
+        TEST (StringIds::getline_istream_str_val, getline_val)
+    };
+
+    const std::size_t test_count = sizeof tests / sizeof *tests;
+
+    return rw_run_string_test (argc, argv, __FILE__,
+                               "lib.string.io",
+                               test_io_func_array, tests, test_count);
+}

Propchange: incubator/stdcxx/trunk/tests/strings/21.string.io.cpp
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: incubator/stdcxx/trunk/tests/strings/21.string.io.cpp
------------------------------------------------------------------------------
    svn:keywords = Id



Mime
View raw message