stdcxx-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From se...@apache.org
Subject svn commit: r503954 - /incubator/stdcxx/trunk/tests/iostream/27.istream.readsome.cpp
Date Tue, 06 Feb 2007 01:59:06 GMT
Author: sebor
Date: Mon Feb  5 17:59:05 2007
New Revision: 503954

URL: http://svn.apache.org/viewvc?view=rev&rev=503954
Log:
2007-02-05  Martin Sebor  <sebor@roguewave.com>

	STDCXX-4
	* 27.istream.readsome.cpp: New test exercising the member function
	readsome() of basic_istream.

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

Added: incubator/stdcxx/trunk/tests/iostream/27.istream.readsome.cpp
URL: http://svn.apache.org/viewvc/incubator/stdcxx/trunk/tests/iostream/27.istream.readsome.cpp?view=auto&rev=503954
==============================================================================
--- incubator/stdcxx/trunk/tests/iostream/27.istream.readsome.cpp (added)
+++ incubator/stdcxx/trunk/tests/iostream/27.istream.readsome.cpp Mon Feb  5 17:59:05 2007
@@ -0,0 +1,476 @@
+/************************************************************************
+ *
+ * 27.readsome.cpp - test exercising istream::readsome()
+ *
+ * $Id$
+ *
+ ************************************************************************
+ *
+ * Licensed to the Apache Software  Foundation (ASF) under one or more
+ * contributor  license agreements.  See  the NOTICE  file distributed
+ * with  this  work  for  additional information  regarding  copyright
+ * ownership.   The ASF  licenses this  file to  you 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.
+ *
+ * Copyright 2003-2007 Rogue Wave Software.
+ * 
+ **************************************************************************/
+
+#include <istream>
+#include <sstream>
+
+#include <driver.h>
+#include <rw_char.h>     // for UserChar, UserTraits
+#include <rw_printf.h>   // for rw_printf()
+
+/***********************************************************************/
+
+template <class charT, class Traits>
+struct Streambuf: std::basic_streambuf<charT, Traits>
+{
+    typedef std::basic_streambuf<charT, Traits> Base;
+    typedef typename Base::traits_type          traits_type;
+    typedef typename Base::int_type             int_type;
+
+    // value returned from showmanyc()
+    int showmanyc_;
+
+    // underflow() will return eof () after extracting this many chars
+    int fail_after_;
+
+    // underflow() will throw am exception after extracting this many chars
+    int throw_after_;
+
+    const charT *end_;          // the end of the buffer (future eback())
+
+    Streambuf (const charT *gbeg, const charT *gend)
+        : Base (),
+          showmanyc_ (0),
+          fail_after_ (-1),    // never fail
+          throw_after_ (-1),   // never throw
+          end_ (gend) {
+        this->setg (_RWSTD_CONST_CAST (charT*, gbeg),
+                    _RWSTD_CONST_CAST (charT*, gbeg),
+                    _RWSTD_CONST_CAST (charT*, gbeg));
+    }
+
+    const charT* pubeback () const {
+        return this->eback ();
+    }
+
+    const charT* pubgptr () const {
+        return this->gptr ();
+    }
+
+    const charT* pubegptr () const {
+        return this->egptr ();
+    }
+
+    /* virtual */ std::streamsize showmanyc () {
+#ifndef _RWSTD_NO_EXCEPTIONS
+
+        if (-2 == showmanyc_)
+            throw (const char*)"showmanyc";
+
+#endif   // _RWSTD_NO_EXCEPTIONS
+
+        return showmanyc_;
+    }
+
+    /* virtual */ int_type underflow () {
+        if (this->gptr () == end_)
+            return traits_type::eof ();
+
+        if (throw_after_ == this->gptr () - this->eback ()) {
+
+#ifndef _RWSTD_NO_EXCEPTIONS
+
+            throw (const char*)"underflow";
+
+#else   // if defined (_RWSTD_NO_EXCEPTIONS)
+
+            return traits_type::eof ();
+
+#endif   // _RWSTD_NO_EXCEPTIONS
+
+        }
+
+        if (fail_after_ == this->gptr () - this->eback ())
+            return traits_type::eof ();
+
+        this->setg (this->eback (), this->gptr (), this->gptr () + 1);
+        return traits_type::to_int_type (*this->gptr ());
+    }
+};
+
+/***********************************************************************
+
+    27.6.1.3, p30 and 31
+
+    streamsize readsome (char_type* s, streamsize n);
+
+    -30- Effects: If !good() calls setstate(failbit) which may throw an
+         exception, and return. Otherwise extracts characters and stores
+         them into successive locations of an array whose first element
+         is designated by s.
+         --  If rdbuf()­>in_avail() == ­1, calls setstate(eofbit) (which
+             may throw ios_base::failure (27.4.4.3)), and extracts no
+             characters;
+         --  If rdbuf()­>in_avail() == 0, extracts no characters
+         --  If rdbuf()­>in_avail() > 0, extracts min(rdbuf()­>in_avail(),
+             n)).
+    -31- Returns: The number of characters extracted.
+
+************************************************************************/
+
+void
+memfun_info (int line, const char *cname, const char *tname)
+{
+    // format the ISTREAM environment variable w/o writing
+    // out any output
+    rw_fprintf (0,
+                "%{$ISTREAM!:@}",
+                "%{?}istream%{:}%{?}wistream"
+                "%{:}basic_istream<%s, %s>%{;}%{;}",
+                'c' == *cname && 'c' == *tname, 
+                'w' == *cname && 'c' == *tname,
+                cname, tname);
+
+    rw_info (0, 0, line,
+             "std::%{$ISTREAM}::readsome (char_type*, streamsize)");
+}
+
+/************************************************************************/
+
+extern const std::ios_base::iostate
+states[] = {
+    std::ios_base::badbit,
+    std::ios_base::eofbit,
+    std::ios_base::failbit,
+    std::ios_base::goodbit,
+    std::ios_base::badbit | std::ios_base::eofbit,
+    std::ios_base::badbit | std::ios_base::failbit,
+    std::ios_base::eofbit | std::ios_base::failbit,
+    std::ios_base::badbit | std::ios_base::eofbit | std::ios_base::failbit
+};
+
+extern const unsigned nstates = sizeof states / sizeof *states;
+
+
+template <class charT, class Traits>
+void test_readsome (const charT *cbuf, const Traits*,
+                    unsigned cbuf_size,
+                    unsigned i,   // index into states
+                    unsigned j,   // number of chars to read
+                    unsigned k,   // when underflow() will fail
+                    int      l,   // value returned from showmanyc()
+                    unsigned m)   // how underflow should fail()
+{
+    typedef std::basic_istream<charT, Traits> Istream;
+
+    static unsigned iter = 0;   // iteration counter
+
+    // construct a stream buffer object and initialize its read
+    // sequence with the character buffer
+    Streambuf<charT, Traits> sb (cbuf, cbuf + cbuf_size - 1);
+
+    sb.showmanyc_ = l;
+
+    const char* err_type = 0;
+
+    if (m < 1) {
+        // have the stream buffer object's underflow() fail (by
+        // throwing an exception if possible) after k characters
+        // have been extracted (this object calls underflow() for
+        // every char)
+        sb.throw_after_ = k;
+        err_type        = "threw";
+    }
+    else {
+        // have the stream buffer object's underflow() fail by
+        // returning eof after k characters have been extracted
+        // (this object calls underflow() for every char)
+        sb.fail_after_ = k;
+        err_type       = "returned EOF";
+    }
+
+    // construct an istream object and initialize it with the user
+    // defined streambuf object
+    Istream is (&sb);
+
+    // set the stream object's initial state
+    is.setstate (states [i]);
+
+    // the number of extracted whitespace characters expected to
+    // be reported by gcount() must equal the number of successful
+    // extractions computed by the the stream buffer overridden
+    // underflow member function
+    const int extract =
+        is.good () ? j < k ? int (j) < l ? j
+                                         : l < 0 ? 0 : l
+                           : int (k) < l ? k
+                                         : l < 0 ? 0 : l
+                   : 0;
+
+    charT buf [256] = { 0 };
+
+    std::streamsize nread = -1;
+
+    // format the FCALL environment variable so that it can be
+    // conveniently used in diagnostics below
+    rw_fprintf (0, "%u. %{$FCALL!:@}",
+                iter,
+                "%{$ISTREAM}(%{*Ac}).readsome(%p, %d)",
+                int (sizeof *cbuf), cbuf, buf, j);
+
+#ifndef _RWSTD_NO_EXCEPTIONS
+
+    const char *caught = 0;
+
+    // on every other iteration set badbit in exceptions to check
+    // that the thrown object is propagated by the function
+    if (k % 2 && !is.bad ())
+        is.exceptions (std::ios_base::badbit);
+
+    try {
+        nread = is.readsome (buf, j);
+    }
+    catch (const char *s) {
+        caught = s;
+    }
+    catch (...) {
+
+        caught = "...";
+
+        rw_assert (0, 0, __LINE__,
+                   "%{$FCALL} threw an exception of unexpected type");
+    }
+
+    //////////////////////////////////////////////////////////////////
+    // verify that the function propagates exceptions thrown from the
+    // streambuf object only when badbit is set in the stream object's
+    // exceptions()
+
+    rw_assert (!caught || (k % 2), 0, __LINE__,
+               "%{$FCALL} unexpectedly propagated an exception");
+
+#else   // if defined (_RWSTD_NO_EXCEPTIONS)
+
+    nread = is.readsome (buf, j);
+
+#endif   // _RWSTD_NO_EXCEPTIONS
+
+    //////////////////////////////////////////////////////////////////
+    // verify that the function returned the expected number of
+    // extracted characters
+
+    const std::streamsize extracted = sb.pubgptr () - sb.pubeback ();
+
+    rw_assert (extract == extracted, 0, __LINE__,
+               "%{$FCALL} expected to extract %d chars, got %u; "
+               "initial state = %{Is}, underflow %s at extraction %u",
+               extract, extracted, states [i],
+               err_type, k);
+
+    //////////////////////////////////////////////////////////////////
+    // verify that the expected number of characters have been
+    // extracted from the stream
+
+    rw_assert (cbuf + extract == sb.pubgptr (), 0, __LINE__,
+               "%{$FCALL} expected to extract %d chars, got %u; "
+               "initial state = %{Is}, underflow %s at extraction %u",
+               extract, extracted, states [i],
+               err_type, k);
+
+    //////////////////////////////////////////////////////////////////
+    // verify that the extracted characters match those in the buffer
+
+    rw_assert (0 == std::char_traits<charT>::compare (buf, cbuf, extract),
+               0, __LINE__,
+               "%{$FCALL} expected to extract the first %d chars, got %{*Ac}",
+               extract, int (sizeof *buf), buf);
+
+    //////////////////////////////////////////////////////////////////
+    // verify that gcount() correctly reflects the number of
+    // characters successfully extracted from the stream
+
+    rw_assert (extract == is.gcount (), 0, __LINE__,
+               "%{$FCALL}: gcount() == %d, got %d; initial state = %{Is}, "
+               "underflow %s at extraction %u",
+               extract, is.gcount (), states [i],
+               err_type, k);
+
+    //////////////////////////////////////////////////////////////////
+    // verify the state of the stream object after the function call
+
+    // expected stream state after the function call is unchanged
+    // (i.e., the initial stream state), except...
+    std::ios_base::iostate expect_state = states [i];
+
+    if (!states [i]) {
+
+#ifndef _RWSTD_NO_EXCEPTIONS
+
+        // ...if an extraction is attempted, or even if the first
+        // character on the stream is peeked at, and an exception
+        // is thrown during input, badbit should be set, otherwise
+        // if in_avail() returned -1, eofbit should be set, else
+        // the state should be good
+        if (-2 == l)
+            expect_state = std::ios_base::badbit;
+        else if (l < 0)
+            expect_state = std::ios_base::eofbit;
+        else
+            expect_state = std::ios_base::goodbit;
+
+#else   // if defined (_RWSTD_NO_EXCEPTIONS)
+
+        if (l < 0)
+            expect_state = std::ios_base::eofbit;
+        else
+            expect_state = std::ios_base::goodbit;
+
+#endif   // _RWSTD_NO_EXCEPTIONS
+
+    }
+    else {
+
+        // ...if the initial stream state is not good, failbit
+        // must be set
+        expect_state = states [i] | std::ios_base::failbit;
+    }
+
+    rw_assert (is.rdstate () == expect_state, 0, __LINE__,
+               "%{$FCALL}: rdstate() == %{Is}, got %{Is}; "
+               "extracted %u characters; "
+               "initial state = %{Is}, underflow %s at extraction %u",
+               expect_state, is.rdstate (), extracted,
+               states [i], err_type, k);
+
+    ++iter;
+}
+
+/***********************************************************************/
+
+
+template <class charT, class Traits>
+void test_readsome (const charT*, const Traits*,
+                    const char *cname, const char *tname)
+{
+    memfun_info (__LINE__, cname, tname);
+
+    //////////////////////////////////////////////////////////////
+    // exercise 27.6.1.3, p1
+
+    const charT cbuf[] = { ' ', 'a', ' ', 'b', 'c', '\0' };
+    const unsigned cbuf_size = sizeof cbuf / sizeof *cbuf;
+
+    unsigned iter   = 0;   // iteration counter
+
+    // iterate over all possible settings of the stream state
+    for (unsigned i = 0; i != nstates; ++i) {
+
+        // call readsome(..., j) to extract j characters 
+        for (unsigned j = 0; j != cbuf_size - 1; ++j) {
+
+            // have underflow() fail after the `k-th' extraction
+            for (unsigned k = 0; k != j + 1; ++k) {
+
+                // return `l' from showmanyc(); -2 will throw
+                for (int l = -4; l != int (k); ++l) {
+
+                    // if (0 == m), underflow() will throw an exception
+                    // at `k-th' extraction, otherwise the function will
+                    // return EOF
+                    for (unsigned m = 0; m != 2; ++m, ++iter) {
+
+                        // prevent causing underflow() to fail by
+                        // returning EOF when in_avail() promised
+                        // it wouldn't (by returning a value
+                        // greater than the number of extractions
+                        // underflow() will allow to succeed)
+                        if (1U == m && int (k) < l)
+                            continue;
+
+                        test_readsome (cbuf, (Traits*)0,
+                                       cbuf_size, i, j, k, l, m);
+                    }
+                }
+            }
+        }
+    }
+}
+
+/***********************************************************************/
+
+static int opt_char;
+static int opt_wchar;
+static int opt_char_traits;
+static int opt_user_traits;
+
+
+static int
+run_test (int, char**)
+{
+    // introduce char_traits into scope
+    using namespace std;
+
+#undef TEST
+#define TEST(CharT, Traits) \
+    test_readsome ((CharT*)0, (Traits*)0, #CharT, #Traits)
+
+    if (rw_note (0 <= opt_char && 0 <= opt_char_traits, 0, __LINE__,
+                 "basic_istream<char, char_traits<char>>::readsome() "
+                 "tests disabled"))
+        TEST (char, char_traits<char>);
+
+    if (rw_note (0 <= opt_char && 0 <= opt_user_traits, 0, __LINE__,
+                 "basic_istream<char, UserTraits<char>>::readsome() "
+                 "tests disabled"))
+        TEST (char, UserTraits<char>);
+
+#ifndef _RWSTD_NO_WCHAR_T
+
+    if (rw_note (0 <= opt_wchar && 0 <= opt_char_traits, 0, __LINE__,
+                 "basic_istream<wchar_t, char_traits<wchar_t>>::readsome() "
+                 "tests disabled"))
+        TEST (wchar_t, char_traits<wchar_t>);
+
+    if (rw_note (0 <= opt_wchar && 0 <= opt_user_traits, 0, __LINE__,
+                 "basic_istream<wchar_t, UserTraits<wchar_t>>::readsome() "
+                 "tests disabled"))
+        TEST (wchar_t, UserTraits<wchar_t>);
+
+#endif   // _RWSTD_NO_WCHAR_T
+
+    return 0;
+}
+
+/***********************************************************************/
+
+int main (int argc, char *argv[])
+{
+    return rw_test (argc, argv, __FILE__,
+                    "istream.unformatted",
+                    "readsome",
+                    run_test,
+                    "|-char~ "
+                    "|-wchar_t~ "
+                    "|-char_traits~ "
+                    "|-UserTraits~ ",
+                    &opt_char,
+                    &opt_wchar,
+                    &opt_char_traits,
+                    &opt_user_traits,
+                    (void*)0   /* sentinel */);
+}

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

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



Mime
View raw message