27.istream.readsome.cpp

Go to the documentation of this file.

 
#include <istream>
#include <sstream>
 
#include <rw_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 ());
    }
};
 
 
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 */);
}