stdcxx-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From se...@apache.org
Subject svn commit: r387099 - /incubator/stdcxx/trunk/tests/iostream/27.istream.unformatted.get.cpp
Date Mon, 20 Mar 2006 01:29:03 GMT
Author: sebor
Date: Sun Mar 19 17:29:02 2006
New Revision: 387099

URL: http://svn.apache.org/viewcvs?rev=387099&view=rev
Log:
2006-03-19  Martin Sebor  <sebor@roguewave.com>

	STDCXX-4
	* 27.istream.unformatted.get.cpp: New test exercising the overloads
	of the get() member functions specified in lib.istream.unformatted.

Added:
    incubator/stdcxx/trunk/tests/iostream/27.istream.unformatted.get.cpp   (with props)

Added: incubator/stdcxx/trunk/tests/iostream/27.istream.unformatted.get.cpp
URL: http://svn.apache.org/viewcvs/incubator/stdcxx/trunk/tests/iostream/27.istream.unformatted.get.cpp?rev=387099&view=auto
==============================================================================
--- incubator/stdcxx/trunk/tests/iostream/27.istream.unformatted.get.cpp (added)
+++ incubator/stdcxx/trunk/tests/iostream/27.istream.unformatted.get.cpp Sun Mar 19 17:29:02
2006
@@ -0,0 +1,802 @@
+/************************************************************************
+ *
+ * 27.istream.unformatted.get.cpp - test exercising overloads of
+ *                                  basic_istream::get()
+ *
+ * $Id$
+ *
+ ***************************************************************************
+ *
+ * Copyright 2006 The Apache Software Foundation or its licensors,
+ * as applicable.
+ *
+ * Copyright 2003-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 <fstream>
+#include <istream>
+#include <sstream>
+#include <cstddef>          // for size_t
+
+#include <driver.h>         // for rw_test(), ...
+#include <rw_char.h>        // for UserTraits
+#include <rw_streambuf.h>   // for MyStreambuf
+
+/***********************************************************************/
+
+#define Bad   std::ios_base::badbit
+#define Eof   std::ios_base::eofbit
+#define Fail  std::ios_base::failbit
+#define Good  std::ios_base::goodbit
+
+
+template <class charT, class Traits>
+void
+check_failure (const MyStreambuf<charT, Traits>&  sb,
+               const char*                        cname,
+               int                                lineno,
+               const char*                        fun,
+               std::basic_istream<charT, Traits>& strm,
+               int                                gcount,
+               int                                nexpect,
+               int                                rdstate,
+               int                                exceptions,
+               MemFun                             caught)
+{
+    static const char* const exnames[] = {
+        "none", "std::ios_base::failure", "unknown exception"
+    };
+
+    const char* const caught_what =
+        caught < int (sizeof exnames / sizeof *exnames) ?
+        exnames [caught] : "streambuf_exception";
+
+    // verify that stream is in the expected state
+    rw_assert (strm.rdstate () == rdstate, 0, lineno,
+               "line %d: basic_istream<%s>::%s; "
+               "rdstate () == %{Is}, got %{Is}",
+               __LINE__, cname, fun, rdstate, strm.rdstate ());
+
+
+    if (sb.throw_set_ && sb.ncalls (sb.threw_) == sb.fail_when_ + 1) {
+
+        // verify that the same exception (and not ios_base::failure)
+        // as the one thrown from basic_filebuf has been propagated
+        // and caught when badbit is set in exceptions, and that no
+        // exception has been thrown if exceptions is clear
+        if (exceptions & Bad && caught != sb.threw_) {
+
+            rw_assert (false, 0, lineno,
+                       "line %d: basic_istream<%s>::%s failed "
+                       "to propagate an exception thrown "
+                       "by basic_filebuf; caught %s instead",
+                       __LINE__, cname, fun,
+                       caught_what);
+        }
+        else if (!(exceptions & Bad) && caught) {
+
+            rw_assert (false, 0, lineno,
+                       "line %d: basic_istream<%s>::%s propagated "
+                       "an exception thrown by basic_filebuf when "
+                       "ios_base::badbit is clear in exceptions",
+                       __LINE__, cname, fun);
+        }
+
+        // verify that the original gcount of 0 was unaffected
+        // (for non-array forms of unformatted input functions)
+        // or that it increased exactly `fail_when_'
+        const int actual = strm.gcount () - gcount;
+
+        rw_assert (!actual || actual ==  sb.fail_when_, 0, lineno,
+                   "line %d: basic_istream<%s>::%s changed "
+                   "gcount () from %d to %d after a failure; "
+                   "either no change from 0 expected, or "
+                   "an increase to %d from 0 expected",
+                   __LINE__, cname, fun,
+                   gcount, strm.gcount (), sb.fail_when_ - 1);
+    }
+    else {
+
+        // verify that ios_base::failure has been thrown (and caught)
+        // if badbit is set in exceptions
+        rw_assert (!(exceptions & strm.rdstate ()) || caught == Failure,
+                   0, lineno,
+                   "line %d: basic_istream<%s>::%s set %{Is} "
+                   "but failed to throw ios_base::failure "
+                   "when the same bit is set in exceptions",
+                   __LINE__, cname, fun, rdstate);
+
+        // verify that gcount has the expected value
+
+        const int actual = strm.gcount () - gcount;
+
+        rw_assert (nexpect == actual, 0, lineno,
+                   "line %d: basic_istream<%s>::%s changed "
+                   "gcount () from %d to %d after a successful "
+                   "extraction; a change from 0 to %d expected",
+                   __LINE__, cname, fun,
+                   gcount, strm.gcount (), nexpect);
+    }
+}
+
+/***********************************************************************/
+
+#define TRY_GET(expr)                         \
+    try {                                     \
+        expr;                                 \
+    }                                         \
+    catch (MemFun e) {                        \
+        caught = e;                           \
+    }                                         \
+    catch (const std::ios_base::failure&) {   \
+        caught = Failure;                     \
+    }                                         \
+    catch (...) {                             \
+        caught = Unknown;                     \
+    } (void)0
+
+
+/***********************************************************************/
+
+
+// 27.6.1.3   Unformatted input functions   [lib.istream.unformatted]
+//
+// -1-  Each unformatted input function begins execution by constructing
+//      an object of class sentry with the default argument noskipws
+//      (second) argument true. If the sentry object returns true, when
+//      converted to a value of type bool, the function endeavors to
+//      obtain the requested input. If an exception is thrown during
+//      input then ios::badbit is turned on284) in *this?s error state.
+//      If (exception() & badbit) != 0 then the exception is rethrown.
+//      It also counts the number of characters extracted. If no exception
+//      has been thrown it ends by storing the count in a member object
+//      and returning the value specified. In any event the sentry object
+//      is destroyed before leaving the unformatted input function.
+
+template <class charT, class Traits>
+void
+test_get_void (charT, const char *cname,
+               const Traits*, int lineno,
+               const char  *str,
+               std::size_t  strsize,
+               int          ival,
+               int          rdstate,
+               int          exceptions,
+               int          failure,
+               int          fail_when)
+{
+    // int_type get();
+    // -3-  Effects: Extracts a character c, if one is available.
+    //          Otherwise, the function calls setstate(failbit),
+    //          which may throw ios_base::failure (27.4.4.3),
+    // -4-  Returns: c if available, otherwise traits::eof().
+
+    typedef MyStreambuf<charT, Traits>        Streambuf;
+    typedef std::basic_istream<charT, Traits> Istream;
+    typedef typename Istream::int_type        int_type;
+
+    const int_type val = int_type (ival);
+
+    // create a test streambuf object initialized with `str'
+    Streambuf sb (str, strsize, failure, fail_when);
+
+    Istream strm (&sb);
+
+    strm.exceptions (std::ios_base::iostate (exceptions));
+
+    const std::streamsize gcount = strm.gcount ();
+
+    int_type got = Traits::eof ();
+
+    MemFun caught = None;
+
+    TRY_GET (got = strm.get ());
+
+    check_failure (sb, cname, lineno, "get()", strm, gcount, !rdstate,
+                   rdstate, exceptions, caught);
+
+    // verify that the extracted value is the one expected
+
+    if (!sb.throw_set_ && !caught && val != got) {
+
+        const charT cval = Traits::to_char_type (val);
+        const charT cgot = Traits::to_char_type (got);
+
+        rw_assert (false, __FILE__, lineno,
+                   "line %d: basic_istream<%s>::get () == %{#lc}, got %{#lc}",
+                   __LINE__, cname, cval, cgot);
+    }
+
+    rw_assert (val == Traits::eof () || !(gcount || 1 != strm.gcount ()),
+               0, lineno,
+               "line %d: basic_istream<%s>::get () changed "
+               "gcount () from %d to %d after a successful "
+               "extraction; 0 to 1 expected",
+               __LINE__, cname,
+               gcount, strm.gcount ());
+}
+
+/***********************************************************************/
+
+template <class charT>
+void test_get_void (charT, const char *cname)
+{
+#define T      charT (), cname, (UserTraits<charT>*)0, __LINE__
+#define TEST   test_get_void
+
+    rw_info (0, 0, 0, "27.6.1.3, p3 - std::basic_istream<%s>::get ()",
+             cname);
+
+    typename UserTraits<charT>::int_type &eof =
+        UserTraits<charT>::eof_;
+
+    eof = ~0;
+
+    TEST (T, "",      0, eof,  Eof | Fail, Good, 0, -1);
+    TEST (T, "",      1, '\0', Good,       Good, 0, -1);
+    TEST (T, "a",     1, 'a',  Good,       Good, 0, -1);
+    TEST (T, " b",    2, ' ',  Good,       Good, 0, -1);
+    TEST (T, "\x80",  1, 0x80, Good,       Good, 0, -1);
+    TEST (T, "\xff ", 2, 0xff, Good,       Good, 0, -1);
+
+    TEST (T, "c",     1, eof,  Eof | Fail, Good, Underflow, 0);
+    TEST (T, "d",     1, eof,  Bad,        Good, Underflow | Throw, 0);
+
+    eof = 256;
+
+    TEST (T, "",  0, eof, Eof | Fail, Good, 0, 0);
+    TEST (T, "f", 1, 'f', Good,       Good, 0, 0);
+    TEST (T, "g", 1, eof, Eof | Fail, Good, Underflow, 0);
+    TEST (T, "h", 1, eof, Bad,        Good, Underflow | Throw, 0);
+    
+    eof = '\0';
+
+    TEST (T, "\0", 1, eof, Eof | Fail, Good, 0, -1);
+    TEST (T, "\1", 1, eof, Eof | Fail, Good, Underflow, 0);
+    TEST (T, "\2", 1, eof, Bad,        Good, Underflow | Throw, 0);
+}
+
+/***********************************************************************/
+
+template <class charT, class Traits>
+void test_get_char (charT, const char* cname,
+                    const Traits*, int lineno,
+                    const char  *str,
+                    std::size_t  strsize,
+                    char         initval,
+                    char         expectval,
+                    int          rdstate,
+                    int          exceptions,
+                    int          failure,
+                    int          fail_when)
+{
+    // basic_istream<charT, Traits>& get (char_type&);
+    // -5-  Effects: Extracts a character, if one is available,
+    //          and assigns it to c.(285) Otherwise, the function calls
+    //          setstate(failbit) (which may throw ios_base::failure
+    //          (27.4.4.3)).
+    // -6-  Returns: *this.
+    // ---
+    // 285) Note that this function is not overloaded on types signed
+    //      charand unsigned char.
+
+    typedef MyStreambuf<charT, Traits>        Streambuf;
+    typedef std::basic_istream<charT, Traits> Istream;
+    typedef typename Istream::int_type        int_type;
+
+    // create a test streambuf object initialized with `str'
+    Streambuf sb (str, strsize, failure, fail_when);
+
+    Istream strm (&sb);
+
+    strm.exceptions (std::ios_base::iostate (exceptions));
+
+    const std::streamsize gcount = strm.gcount ();
+
+    typedef unsigned char UChar;
+
+          charT got = charT (UChar (initval));
+    const charT val = charT (UChar (expectval));
+
+    MemFun caught = None;
+
+    TRY_GET (strm.get (got));
+
+    check_failure (sb, cname, lineno, "get(char_type&)", strm,
+                   gcount, !rdstate, rdstate, exceptions, caught);
+
+    // verify that the extracted value is the one expected
+
+    rw_assert (sb.throw_set_ || caught || Traits::eq (val, got), 0, lineno,
+               "line %d: basic_istream<%s>::get (char_type& = %{#lc}),"
+               " expected %{#lc}", __LINE__, cname, got, val);
+
+    rw_assert (rdstate || !(gcount || 1 != strm.gcount ()), 0, lineno,
+               "line %d: basic_istream<%s>::get (char_type&) "
+               "changed gcount () from %d to %d after a successful "
+               "extraction; 0 to 1 expected",
+               __LINE__, cname,
+               gcount, strm.gcount ());
+}
+
+/***********************************************************************/
+
+template <class charT>
+void test_get_char (charT, const char *cname)
+{
+#undef T
+#undef TEST
+
+#define T      charT (), cname, (UserTraits<charT>*)0, __LINE__
+#define TEST   test_get_char
+
+    rw_info (0, 0, 0,
+             "27.6.1.3, p5 - std::basic_istream<%s>::get (char_type&)",
+             cname);
+
+    typename UserTraits<charT>::int_type &eof =
+        UserTraits<charT>::eof_;
+
+    eof = ~0;
+
+    //       +- initial stream buffer contents (will be widened)
+    //       |     +- the length of the buffer contents in chars
+    //       |     |  +- initial value of get(char_type&) argument
+    //       |     |  |     +- expected value of argument on return
+    //       |     |  |     |     +- expected stream state on return
+    //       |     |  |     |     |           +- stream exceptions
+    //       |     |  |     |     |           |     +- force failure
+    //       |     |  |     |     |           |     |  +- when to fail
+    //       |     |  |     |     |           |     |  |
+    //       v     v  v     v     v           v     v  v
+    TEST (T, "",   0, '\0', '\0', Eof | Fail, Good, 0, -1);
+    TEST (T, "",   1, '\1', '\0', Good,       Good, 0, -1);
+    TEST (T, "1",  1, '\2', '1',  Good,       Good, 0, -1);
+    TEST (T, "2 ", 2, '\3', '2',  Good,       Good, 0, -1);
+    TEST (T, " 3", 2, '\4', ' ',  Good,       Good, 0, -1);
+
+    TEST (T, "4",  1, '\5', '\5', Eof | Fail, Good, Underflow, 0);
+    TEST (T, "5",  1, '\6', '\6', Bad,        Good, Underflow | Throw, 0);
+    TEST (T, "6",  1, '\7', '\6', Eof | Fail, Eof,  Underflow, 0);
+    TEST (T, "7",  1, 'x',   'x', Eof | Fail, Fail, Underflow, 0);
+    TEST (T, "8",  1, 'y',   'y', Eof | Fail, Eof | Fail, Underflow, 0);
+    TEST (T, "9",  1, 'z',   'z', Eof | Fail, Eof | Fail | Bad, Underflow, 0);
+
+    TEST (T, "A",  1, 'a',   'a', Bad,        Bad, Underflow | Throw, 0);
+}
+
+/***********************************************************************/
+
+#define MAXCHARS   (4096U * 4U)
+
+
+template <class charT, class Traits>
+void test_get_char_array (charT, const char* cname,
+                          const Traits*,
+                          int          lineno,
+                          const char  *str,
+                          std::size_t  strsize,
+                          int          nread,
+                          int          idelim,
+                          int          nexpect,
+                          int          rdstate,
+                          int          exceptions,
+                          int          failure,
+                          int          fail_when)
+{
+    // basic_istream<charT, traits>&
+    // get(char_type* s, streamsize n, char_type delim);
+    //
+    // -7-  Effects: Extracts characters and stores them into successive
+    //      locations of an array whose first element is designated by s.
+    //      286) Characters are extracted and stored until any of the
+    //      following occurs:
+    //      -  (n - 1) characters are stored;
+    //      -  end-of-file occurs on the input sequence (in which case
+    //         the function calls setstate(eofbit));
+    //      -  (c == delim) for the next available input character c
+    //         (in which case cis not extracted).
+    //
+    // -8-  If the function stores no characters, it calls setstate(failbit)
+    //      (which may throw ios_base::failure (27.4.4.3)). In any case, it
+    //      then stores a null character into the next successive location
+    //      of the array.
+    //
+    // -9-  Returns: *this.
+
+    // basic_istream<charT,traits>&
+    // get(char_type* s, streamsize n);
+    //
+    // -10-  Effects: Calls get(s, n, widen('\n')).
+    // -11-  Returns: Value returned by the call.
+
+    typedef MyStreambuf<charT, Traits>        Streambuf;
+    typedef std::basic_istream<charT, Traits> Istream;
+    typedef typename Istream::int_type        int_type;
+
+    const int_type delim = int_type (idelim);
+
+    // create a test streambuf object initialized with `str'
+    Streambuf sb (str, strsize, failure, fail_when);
+
+    Istream strm (&sb);
+
+    strm.exceptions (std::ios_base::iostate (exceptions));
+
+    const std::streamsize gcount = strm.gcount ();
+
+    typedef unsigned char UChar;
+
+    MemFun caught = None;
+
+    charT got [MAXCHARS + 1];
+    Traits::assign (got, sizeof got / sizeof *got, charT ('\xfe'));
+
+    const char *fun;
+
+    if (delim != Traits::eof ()) {
+        fun = "get(char_type*, streamsize, char_type)";
+        TRY_GET (strm.get (got, std::streamsize (nread), delim));
+    }
+    else {
+        fun = "get(char_type*, streamsize)";
+        TRY_GET (strm.get (got, std::streamsize (nread)));
+    }
+
+    check_failure (sb, cname, lineno, fun, strm, gcount, nexpect,
+                   rdstate, exceptions, caught);
+
+    // verify that number and values of the extracted characters
+    // matches the expected number and values
+
+    rw_assert (strm.gcount () == nexpect, 0, lineno,
+               "line %d: basic_istream<%s>::get (char_type*, "
+               "streamsize = %d).gcount () == %d, got %d",
+               __LINE__, cname, nread, nexpect, strm.gcount ());
+
+    rw_assert (1 < nread || Traits::eq (got [0], charT ()), 0, lineno,
+               "line %d: basic_istream<%s>::get (char_type *s "
+               "= %{*Ac}, streamsize = %d); s[0] == '\\0', got %{#lc}",
+               __LINE__, cname, int (sizeof *got), got, nread, *got);
+
+    rw_assert (!Traits::compare (sb.buf_, got, std::size_t (nexpect)),
+               0, lineno,
+               "line %d: basic_istream<%s>::get (char_type* "
+               "= %{*Ac}, streamsize = %d) data mismatch",
+               __LINE__, cname, int (sizeof *got), got, nread);
+}
+
+/***********************************************************************/
+
+template <class charT>
+void test_get_char_array (charT, const char *cname)
+{
+#undef T
+#undef TEST
+
+#define T      charT (), cname, (UserTraits<charT>*)0, __LINE__
+#define TEST   test_get_char_array
+
+    rw_info (0, 0, 0, "27.6.1.3, p5 - std::basic_istream<%s>"
+             "::get (char_type*, streamsize)", cname);
+
+    typename UserTraits<charT>::int_type &eof =
+        UserTraits<charT>::eof_;
+
+    eof = ~0;
+
+    //       +- initial stream buffer contents (will be widened)
+    //       |        +- the length of the buffer contents in chars
+    //       |        |  +- number of characters (2nd argument to get())
+    //                |  |  +- delimiter (3rd argument to get() or eof)
+    //       |        |  |  |    +- expected number of extracted characters
+    //       |        |  |  |    |  +- expected stream state on return
+    //       |        |  |  |    |  |           +- stream exceptions
+    //       |        |  |  |    |  |           |     +- force failure
+    //       |        |  |  |    |  |           |     |  +- when to fail
+    //       |        |  |  |    |  |           |     |  |
+    //       v        v  v  v    v  v           v     v  v
+    TEST (T, "",      0, 0, eof, 0, Fail,       Good, 0, -1);
+    TEST (T, "\0",    1, 1, eof, 0, Fail,       Good, 0, -1);
+    TEST (T, "1",     1, 2, eof, 1, Good,       Good, 0, -1);
+    TEST (T, "2",     1, 3, eof, 1, Eof,        Good, 0, -1);
+    TEST (T, "23",    2, 3, eof, 2, Good,       Good, 0, -1);
+    TEST (T, "34",    2, 4, eof, 2, Eof,        Good, 0, -1);
+    TEST (T, "4\n",   2, 3, eof, 1, Good,       Good, 0, -1);
+    TEST (T, "56\n",  3, 3, eof, 2, Good,       Good, 0, -1);
+    TEST (T, "67\n",  3, 4, eof, 2, Good,       Good, 0, -1);
+
+    // exercise the behavior on underflow() failure indicated
+    // by returning traits_type::eof()
+    TEST (T, "78\n9", 4, 4, eof, 0, Eof | Fail, Good,        Underflow, 0);
+    TEST (T, "78901", 5, 5, eof, 0, Eof | Fail, Eof,         Underflow, 0);
+    TEST (T, "78902", 5, 5, eof, 0, Eof | Fail, Fail,        Underflow, 0);
+    TEST (T, "78803", 5, 5, eof, 0, Eof | Fail, Eof | Fail,  Underflow, 0);
+    TEST (T, "89\na", 4, 4, eof, 1, Eof,        Good,        Underflow, 1);
+    TEST (T, "9a\nb", 4, 4, eof, 2, Eof,        Good,        Underflow, 2);
+    TEST (T, "ab\nc", 4, 4, eof, 2, Good,       Good,        Underflow, 3);
+
+    // exercise the behavior on underflow() failure caused
+    // by throwing an exception
+    TEST (T, "bc\nd", 4, 4, eof, 0, Bad,        Good, Underflow | Throw, 0);
+    TEST (T, "cd\ne", 4, 4, eof, 1, Bad,        Good, Underflow | Throw, 1);
+    TEST (T, "def\n", 4, 4, eof, 2, Bad,        Good, Underflow | Throw, 2);
+    TEST (T, "efg\n", 4, 4, eof, 2, Bad,        Bad,  Underflow | Throw, 2);
+    TEST (T, "fgh\n", 4, 4, eof, 3, Good,       Bad,  Underflow | Throw, 3);
+    TEST (T, "ghij",  4, 4, eof, 3, Good,       Bad,  Underflow | Throw, 3);
+    TEST (T, "hijk",  4, 5, eof, 3, Bad,        Bad,  Underflow | Throw, 3);
+
+    const std::streamsize N = std::streamsize (MAXCHARS);
+    char *buf = new char [N];
+
+    for (std::streamsize i = 0; i != N; ++i) {
+        buf [i] = char (i);
+    }
+
+    // set the maximum number of characters in the pending input
+    // sequence to be greater than the default 1 to allow get()
+    // not to have to call underflow() on every iteration and
+    // to exercise any/all branches in the function
+    MyStreambuf<charT, UserTraits<charT> >::in_pending_ = N / 33;
+
+    TEST (T, "12345", 5, 4, eof, 3, Good, Good, 0, -1);
+    TEST (T, "12346", 5, 5, eof, 4, Good, Good, 0, -1);
+    TEST (T, "12347", 5, 6, eof, 5, Good, Good, 0, -1);
+    TEST (T, "12348", 5, 7, eof, 5, Eof,  Good, 0, -1);
+    
+    for (std::streamsize i = 0; i < N; i += 256) {
+        TEST (T, buf, N, N, eof, '\n' + i, Good, Good, 0, -1);
+
+        buf ['\n' + i] = '\0';
+    }
+
+    rw_info (0, 0, 0, "27.6.1.3, p5 - std::basic_istream<%s>"
+             "::get (char_type*, streamsize, char_type)", cname);
+
+    TEST (T, "",   0, 0, '\0', 0, Fail,       Good, 0, -1);
+    TEST (T, "",   1, 1, '\0', 0, Fail,       Good, 0, -1);
+    TEST (T, "a",  1, 2, '\0', 1, Good,       Good, 0, -1);
+    TEST (T, "bc", 2, 2, 'c',  1, Good,       Good, 0, -1);
+    TEST (T, "cd", 2, 3, 'd',  1, Good,       Good, 0, -1);
+    TEST (T, "de", 2, 3, 'd',  0, Fail,       Good, 0, -1);
+}
+
+/***********************************************************************/
+
+template <class charT, class Traits>
+void test_get_streambuf (charT, const char* cname,
+                         const Traits*,
+                         int          lineno,
+                         const char  *str,
+                         std::size_t  strsize,
+                         int          idelim,
+                         int          nexpect,
+                         int          rdstate,
+                         int          exceptions,
+                         int          failure,
+                         int          fail_when)
+{
+    typedef MyStreambuf<charT, Traits>        Streambuf;
+    typedef std::basic_istream<charT, Traits> Istream;
+    typedef typename Istream::int_type        int_type;
+
+    const int_type delim = int_type (idelim);
+
+    int in_failure, in_fail_when;
+    int out_failure, out_fail_when;
+
+    switch (failure & ~Throw) {
+    case Xsgetn: case Underflow: case Uflow:
+        in_failure = failure;
+        in_fail_when = fail_when;
+        out_failure = 0;
+        out_fail_when = 0;
+        break;
+
+    case Overflow: case Xsputn:
+        in_failure = 0;
+        in_fail_when = 0;
+        out_failure = failure;
+        out_fail_when = fail_when;
+        break;
+
+    default:
+        in_failure = failure;
+        in_fail_when = fail_when;
+        out_failure = failure;
+        out_fail_when = fail_when;
+    }
+
+    // create a test streambuf object initialized with `str'
+    Streambuf inbuf (str, strsize, in_failure, in_fail_when);
+
+    Istream strm (&inbuf);
+
+    strm.exceptions (std::ios_base::iostate (exceptions));
+
+    const std::streamsize gcount = strm.gcount ();
+
+    typedef unsigned char UChar;
+
+    MemFun caught = None;
+
+    Streambuf outbuf (strsize, out_failure, out_fail_when);
+
+    const char *fun;
+
+    if (delim != Traits::eof ()) {
+        fun = "get(basic_streambuf<char_type, traits_type>&, char_type)";
+        TRY_GET (strm.get (outbuf, delim));
+    }
+    else {
+        fun = "get(basic_streambuf<char_type, traits_type>&)";
+        TRY_GET (strm.get (outbuf));
+    }
+
+    check_failure (inbuf, cname, lineno, fun, strm, gcount, nexpect,
+                   rdstate, exceptions, caught);
+
+    // verify that number and values of the extracted characters
+    // matches the expected number and values
+
+    rw_assert (strm.gcount () == nexpect, 0, lineno,
+               "line %d: basic_istream<%s>::get (basic_streambuf"
+               "<char_type, traits_type>*).gcount () == %d, got %d",
+               __LINE__, cname, nexpect, strm.gcount ());
+
+    rw_assert (!Traits::compare (inbuf.buf_, outbuf.buf_,
+                                 std::size_t (nexpect)), 0, lineno,
+               "line %d: basic_istream<%s>::get (basic_streambuf"
+               "<char_type, traits_type>*) data mismatch",
+               __LINE__, cname);
+}
+
+/***********************************************************************/
+
+template <class charT>
+void test_get_streambuf (charT, const char *cname)
+{
+#undef T
+#undef TEST
+
+#define T      charT (), cname, (UserTraits<charT>*)0, __LINE__
+#define TEST   test_get_streambuf
+
+    rw_info (0, 0, 0, "27.6.1.3, p12 - std::basic_istream<%s>"
+             "::get (basic_streambuf<char_type, traits_type>*, char_type)",
+             cname);
+
+    typename UserTraits<charT>::int_type &eof =
+        UserTraits<charT>::eof_;
+
+    eof = ~0;
+
+    // set the maximum number of characters in the pending input
+    // sequence to 1 to force a call to underflow() for each
+    // character
+    MyStreambuf<charT, UserTraits<charT> >::in_pending_ = 1;
+
+    // basic_istream<charT, traits>&
+    // get (basic_streambuf<charT, traits> &sb, char_type delim);
+    //
+    // -12-  Effects: Extracts characters and inserts them in the output
+    //       sequence controlled by sb. Characters are extracted and
+    //       inserted until any of the following occurs:
+    //       -  end-of-file occurs on the input sequence;
+    //       -  inserting in the output sequence fails (in which case the
+    //          character to be inserted is not extracted);
+    //       -  (c == delim) for the next available input character c
+    //          (in which case cis not extracted);
+    //       -  an exception occurs (in which case, the exception is caught
+    //          but not rethrown).
+    // -13-  If the function inserts no characters, it calls
+    //       setstate(failbit), which may throw ios_base::failure (27.4.4.3).
+    // -14-  Returns: *this.
+
+    TEST (T, "",      0, 'x',  0, Eof | Fail, Good, 0, 0);
+    TEST (T, "\0",    1, 'y',  1, Eof,        Good, 0, 0);
+    TEST (T, "ab",    2, 'z',  2, Eof,        Good, 0, 0);
+    TEST (T, "abc",   3, '\0', 3, Eof,        Good, 0, 0);
+    TEST (T, "b\0c",  3, '\0', 1, Good,       Good, 0, 0);
+    TEST (T, "cd\0e", 4, '\0', 2, Good,       Good, 0, 0);
+    TEST (T, "def\0", 4, '\0', 3, Good,       Good, 0, 0);
+
+    TEST (T, "efgh",  4, 'f',  0, Eof | Fail, Good,       Underflow, 0);
+    TEST (T, "fghi",  4, 'g',  0, Eof | Fail, Eof,        Underflow, 0);
+    TEST (T, "ghij",  4, 'h',  0, Eof | Fail, Fail,       Underflow, 0);
+    TEST (T, "hijk",  4, 'i',  0, Eof | Fail, Eof | Fail, Underflow, 0);
+
+    TEST (T, "ijkl",  4, 'k',  1, Eof,        Good, Underflow, 1);
+    TEST (T, "jklm",  4, 'm',  2, Eof,        Good, Underflow, 2);
+
+    TEST (T, "klmn",  4, 'n',  2, Bad,        Good, Underflow | Throw, 2);
+    TEST (T, "lmno",  4, 'o',  2, Bad,        Bad,  Underflow | Throw, 2);
+
+    TEST (T, "EFGH",  4, 'F',  0, Fail,       Good,       Overflow, 0);
+    TEST (T, "FGHI",  4, 'G',  0, Fail,       Eof,        Overflow, 0);
+    TEST (T, "GHIJ",  4, 'H',  0, Fail,       Fail,       Overflow, 0);
+    TEST (T, "HIJK",  4, 'I',  0, Fail,       Eof | Fail, Overflow, 0);
+
+    TEST (T, "IJKL",  4, 'K',  1, Fail,       Good, Overflow, 1);
+    TEST (T, "JKLM",  4, 'M',  2, Fail,       Good, Overflow, 2);
+
+    TEST (T, "KLMN",  4, 'N',  2, Fail,       Good, Overflow | Throw, 2);
+    TEST (T, "LMNO",  4, 'O',  2, Fail,       Bad,  Overflow | Throw, 2);
+
+    rw_info (0, 0, 0, "27.6.1.3, p15 - std::basic_istream<%s>"
+             "::get (basic_streambuf<char_type, traits_type>&)", cname);
+
+    TEST (T, "",      0, eof, 0, Eof | Fail, Good, 0, 0);
+    TEST (T, "\n",    1, eof, 0, Fail,       Good, 0, 0);
+    TEST (T, "a\n",   2, eof, 1, Good,       Good, 0, 0);
+    TEST (T, "ab\n",  3, eof, 2, Good,       Good, 0, 0);
+}
+
+/***********************************************************************/
+
+static int rw_opt_no_get_void;
+static int rw_opt_no_get_char;
+static int rw_opt_no_get_char_array;
+static int rw_opt_no_get_streambuf;
+
+
+static int
+run_test (int, char**)
+{
+#undef TEST
+#define TEST(T, arg)                                            \
+    if (rw_opt_no_get_ ## arg)                                  \
+        rw_note (0, 0, 0,                                       \
+                 "basic_istream::get(%s) test disabled", #arg); \
+    else                                                        \
+        test_get_ ## arg (T (), #T)
+
+
+    TEST (char, void);
+    TEST (char, char);
+    TEST (char, char_array);
+    TEST (char, streambuf);
+
+#ifndef _RWSTD_NO_WCHAR_T
+
+    TEST (wchar_t, void);
+    TEST (wchar_t, char);
+    TEST (wchar_t, char_array);
+    TEST (wchar_t, streambuf);
+
+#endif   // _RWSTD_NO_WCHAR_T
+
+    return 0;
+}
+
+/***********************************************************************/
+
+int main (int argc, char *argv[])
+{
+    return rw_test (argc, argv, __FILE__,
+                    "lib.istream.unformatted",
+                    "overloads of get() member function",
+                    run_test,
+                    "|-no-get-void#"
+                    "|-no-get-char#"
+                    "|-no-get-char_array#"
+                    "|-no-get-streambuf#",
+                    &rw_opt_no_get_void,
+                    &rw_opt_no_get_char,
+                    &rw_opt_no_get_char_array,
+                    &rw_opt_no_get_streambuf,
+                    0);
+}

Propchange: incubator/stdcxx/trunk/tests/iostream/27.istream.unformatted.get.cpp
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: incubator/stdcxx/trunk/tests/iostream/27.istream.unformatted.get.cpp
------------------------------------------------------------------------------
    svn:keywords = Id



Mime
View raw message