27.istream.manip.cpp

Go to the documentation of this file.

 
#include <cstddef>
#include <istream>
 
#include <rw_driver.h>
 
 
template <class charT>
struct Ctype: std::ctype<charT>
{
    typedef std::ctype<charT> Base;
 
    const charT ws_;   // whitespace character
 
    std::ctype_base::mask table_ [256];
 
    Ctype (std::size_t ref, charT white)
        : Base (ref), ws_ (white) { }
 
    // used by ctype<wchar_t>
    /* virtual */ bool
    do_is (std::ctype_base::mask m, charT c) const {
        if (m & std::ctype_base::space)
            return ws_ == c;
        return Base::is (m, c);
    }
 
    // not used by the test, defined only to silence compiler warnings
    // about the overload above hiding the base function overloaded below
    /* virtual */ const charT*
    do_is (const charT *lo, const charT *hi, std::ctype_base::mask *m) const {
        return Base::do_is (lo, hi, m);
    }
};
 
 
// specialized for ctype<char>
_RWSTD_SPECIALIZED_CLASS
Ctype<char>::Ctype (std::size_t ref, char white)
    : Base (table_, false, ref), ws_ (white)
{
    for (std::size_t i = 0; i != sizeof table_ / sizeof *table_; ++i)
        table_ [i] = std::ctype_base::mask ();
 
    typedef unsigned char UChar;
 
    table_ [UChar (ws_)] = std::ctype_base::space;
}
 
 
// user-defined Traits type exercises the ability to instantiate
// std::ws and any supporting templates on types other than the
// default std::char_traits<charT>
template <class charT>
struct UserTraits: std::char_traits<charT> { };
 
 
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;
 
    int nsyncs_;       // number of calls to sync()
 
    // overflow() will return eof () after extracting this many chars
    int fail_after_;
 
    // overflow() 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 (),
          nsyncs_ (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 */ int sync () {
        ++nsyncs_;
        return Base::sync ();
    }
 
    /* virtual */ int_type underflow () {
        if (this->gptr () == end_)
            return traits_type::eof ();
 
        if (throw_after_ == this->gptr () - this->eback ()) {
 
#ifndef _RWSTD_NO_EXCEPTIONS
 
            throw throw_after_;
 
#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 ());
    }
};
 
 
template <class charT, class Traits>
void
test_ws (const Traits*           /* dummy */,
         const char             *cname,
         const char             *tname,
         std::size_t             iter,
         const charT            *cbuf,
         std::size_t             cbuf_size,
         std::ios_base::iostate  state,
         std::size_t             j,
         bool                    skipws,
         charT                   white)
{
    typedef std::basic_istream<charT, Traits>   Istream;
    typedef typename Istream::sentry            Sentry;
 
    // construct a ctype object that treats `wc' as the only
    // whitespace character
    const Ctype<charT> ctp (1, white);
 
    // construct a stream buffer object and initialize its read sequence
    // with the character buffer
    Streambuf<charT, Traits> sb (cbuf, cbuf + cbuf_size - 1);
 
    // set err_after to the number of successful extractions from
    // the stream; subsequent extraction will cause an error
    const std::size_t err_after = j % (cbuf_size - 1);
    const char *err_type;
 
    if (j < cbuf_size - 1) {
        // have the stream buffer object's underflow() fail (by throwing
        // an exception if possible) after j characters have been extracted
        // (this object calls underflow() for every char)
        sb.throw_after_ = int (err_after);
        err_type        = "threw";
    }
    else {
        // have the stream buffer object's underflow() fail by returning
        // eof after j characters have been extracted (this object calls
        // underflow() for every char)
        sb.fail_after_ = int (err_after);
        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 (state);
 
    // set or clear the skipws bit
    if (skipws)
        is.setf (std::ios_base::skipws);
    else
        is.unsetf (std::ios_base::skipws);
 
    // construct a locale object containing the user-defined ctype object
    const std::locale loc = is.imbue (std::locale (is.getloc (), &ctp));
 
    // imbue the previous locale into the stream buffer to verify that
    // the ws manipulator uses the locale imbued in the stream object
    // and not the one in the stream buffer
    sb.pubimbue (loc);
 
    // 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 () && white == cbuf [0] ? int (err_after) : 0;
 
#ifndef _RWSTD_NO_EXCEPTIONS
 
    bool caught = false;
 
    // on every other iteration set badbit in exceptions to check
    // that the thrown object is propagated by the function
    if (err_after % 2 && !is.bad ())
        is.exceptions (std::ios_base::badbit);
 
    try {
        std::ws (is);
    }
    catch (int) {
        caught = true;
    }
    catch (...) {
 
        caught = true;
 
        rw_assert (false, 0, __LINE__,
                   "%u. std::ws (basic_istream<%s, %s >&);"
                   " threw exception of unexpected type",
                   iter, cname, tname);
    }
 
    // 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 && !(err_after % 2)), 0, __LINE__,
               "%u. std::ws (basic_istream<%s, %s>&);"
               " unexpectedly propagated exception",
               iter, cname, tname);
 
#else   // if defined (_RWSTD_NO_EXCEPTIONS)
 
    std::ws (is);
 
#endif   // _RWSTD_NO_EXCEPTIONS
 
    // verify that the expected number of whitespace characters have
    // been extracted from the stream
 
    rw_assert (cbuf + extract == sb.pubgptr (), 0, __LINE__,
               "%u. std::ws (basic_istream<%s, %s>&);"
               " expected to extract %d "
               "whitespace chars ('%c') from %{*Ac}, "
               "extracted %u; initial rdstate() = %{Is}, "
               "is.flags() & ios::skipws = %d, "
               "underflow %s at extraction %u",
               iter, cname, tname, extract, (char)(white),
               int (sizeof *cbuf), cbuf,
               sb.pubgptr () - sb.pubeback (), state,
               skipws, err_type, err_after);
 
    // verify that gcount() value not affected (27.6.1.4 p1)
 
    rw_assert (0 == is.gcount (), 0, __LINE__,
               "%u. std::ws (basic_istream<%s, %s >&)."
               "gcount() == %d, got %d; whitespace is"
               " '%c', input is %{*Ac}, initial rdstate() = %{Is}, "
               "flags() & ios::skipws = %d,"
               " underflow %s at extraction %u",
               iter, cname, tname, extract, is.gcount (),
               (char)(white), int (sizeof *cbuf), cbuf, state,
               skipws, err_type, err_after);
 
    // 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 = state;
 
    if (state) {
        // lwg 419
        expect_state |= std::ios_base::failbit;
    }
    else if (white == cbuf [0] || !err_after) {
 
#ifndef _RWSTD_NO_EXCEPTIONS
 
        // ...when any whitespace characters are extracted, or the
        // first character on the stream is peeked at, even if it's
        // not a space, and an exception is thrown during input,
        // badbit should be set, otherwise eofbit (bot not failbit)
        // should be set
        if (j < cbuf_size - 1)
            expect_state = std::ios_base::badbit;
        else
            expect_state = std::ios_base::eofbit;
 
#else   // if defined (_RWSTD_NO_EXCEPTIONS)
 
        expect_state = std::ios_base::eofbit;
 
#endif   // _RWSTD_NO_EXCEPTIONS
    }
 
    rw_assert (is.rdstate () == expect_state, 0, __LINE__,
               "%u. std::ws (basic_istream<%s, %s >&)."
               "rdstate() == %{Is}, got %{Is}; "
               "extracting whitespace ('%c') from %{*Ac}, "
               "extracted %u; initial is.rdstate() = %{Is}, "
               "is.flags() & ios::skipws = %d, underflow %s "
               "at extraction %u",
               iter, cname, tname,
               expect_state, is.rdstate(),
               (char)(white), int (sizeof *cbuf), cbuf,
               sb.pubgptr () - sb.pubeback (), state,
               skipws, err_type, err_after);
}
 
 
template <class charT, class Traits>
void test_ws (charT*, Traits*, const char *cname, const char *tname)
{
    rw_info (0, 0, __LINE__, "std::basic_istream<%s, %s>& "
             "std::ws (std::basic_istream<%1$s, %2$s>&)",
             cname, tname);
 
    const charT cbuf[] = { 'a', 'a', 'a', '\0' };
    const std::size_t cbuf_size = sizeof cbuf / sizeof *cbuf;
 
    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
    };
 
    const std::size_t nstates = sizeof states / sizeof *states;
 
    {   
        // exercise 27.6.1.4, p1
 
        std::size_t iter = 0;     // iteration counter
 
        // iterate over all possible settings of the stream state
        for (std::size_t i = 0; i != nstates; ++i) {
 
            // iterate twice over all characters in the character buffer,
            // once to trigger an exception at each iteration (except
            // the last one), and then again to have underflow() fail
            // by returning EOF at each iteration (except the last one)
            for (std::size_t j = 0; j != 2 * cbuf_size - 1; ++j) {
 
                // iterate over the ios_base::skipws setting
                for (std::size_t k = 0; k != 2; ++k /* skipws */) {
 
                    // iterate over two whitespace characters
                    for (charT wc = charT ('a'); wc != charT ('c'); ++wc) {
 
                        test_ws ((Traits*)0, cname, tname, iter,
                                 cbuf, cbuf_size, states [i], j, !!k, wc);
 
                        ++iter;
                    }
                }
            }
        }
    }
}
 
 
static int opt_char;
static int opt_wchar;
static int opt_char_traits;
static int opt_user_traits;
 
 
static int
run_test (int, char**)
{
#define TEST(charT, Traits) \
    test_ws ((charT*)0, (Traits*)0, #charT, #Traits)
 
    if (rw_note (0 <= opt_char && 0 <= opt_char_traits, 0, __LINE__,
                 "ws (basic_istream<char, char_traits<char>>) disabled"))
        TEST (char, std::char_traits<char>);
 
    if (rw_note (0 <= opt_char && 0 <= opt_user_traits, 0, __LINE__,
                 "ws (basic_istream<char, UserTraits<char>>) disabled"))
        TEST (char, UserTraits<char>);
 
#ifndef _RWSTD_NO_WCHAR_T
 
    if (rw_note (0 <= opt_wchar && 0 <= opt_char_traits, 0, __LINE__,
                 "ws (basic_istream<wchar_t, char_traits<wchar_t>>) disabled"))
        TEST (wchar_t, std::char_traits<wchar_t>);
 
    if (rw_note (0 <= opt_wchar && 0 <= opt_user_traits, 0, __LINE__,
                 "ws (basic_istream<wchar_t, UserTraits<wchar_t>>) 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.manip",
                    0 /* no comment */,
                    run_test,
                    "|-char~ "
                    "|-wchar_t~ "
                    "|-char_traits~ "
                    "|-UserTraits~ ",
                    &opt_char,
                    &opt_wchar,
                    &opt_char_traits,
                    &opt_user_traits,
                    (void*)0   /* sentinel */);
}