You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@stdcxx.apache.org by se...@apache.org on 2006/03/20 02:29:03 UTC
svn commit: r387099 -
/incubator/stdcxx/trunk/tests/iostream/27.istream.unformatted.get.cpp
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 <se...@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