27.istream.sentry.cpp

Go to the documentation of this file.

 
#include <istream>
#include <locale>        // for ctype
#include <streambuf>     // for streambuf
 
#include <rw_char.h>     // for UserChar, UserTraits
#include <rw_printf.h>   // for rw_printf()
#include <rw_driver.h>
 
 
void
memfun_info (int line, const char *cname, const char *tname, const char *fname)
{
    // format the ISTREAM and SENTRY environment variables 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_fprintf (0,
                "%{$SENTRY!:@}",
                "%{$ISTREAM}::sentry");
 
    // pass fname through the "%{@}" directive to expand any embedded
    // %{$XYZ} directives
    rw_info (0, 0, line, "std::%{$SENTRY}::%{@}", fname);
}
 
 
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 (unsigned ref, charT white)
        : Base (ref), ws_ (white) { }
 
    // virtuals overridden below used by ctype<wchar_t>
    // ctype<char> uses the table() member instead
 
    /* 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);
    }
 
    /* virtual */ const charT*
    do_is (const charT *from, const charT *to,
           std::ctype_base::mask *m) const {
        return Base::is (from, to, m);
    }
 
    /* virtual */ const charT*
    do_scan_is (std::ctype_base::mask m,
                 const charT *from, const charT *to) const {
        for (; from != to && !do_is (m, *from); ++from);
        return from;
    }
 
    /* virtual */ const charT*
    do_scan_not (std::ctype_base::mask m,
                 const charT *from, const charT *to) const {
        for (; from != to && do_is (m, *from); ++from);
        return from;
    }
};
 
 
// specialized for ctype<char>
_RWSTD_SPECIALIZED_CLASS
Ctype<char>::Ctype (unsigned ref, char white)
    : Base (table_, false, ref), ws_ (white)
{
    for (unsigned 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;
}
 
 
template <class charT, class Traits>
struct Streambuf: std::basic_streambuf<charT, Traits>
{
    typedef std::basic_streambuf<charT, Traits> Base;
 
    int nsyncs_;
 
    Streambuf (const charT *gbeg, const charT *gend)
        : Base (), nsyncs_ (0) {
        this->setg (_RWSTD_CONST_CAST (charT*, gbeg),
                    _RWSTD_CONST_CAST (charT*, gbeg),
                    _RWSTD_CONST_CAST (charT*, gend));
    }
 
    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 ();
    }
};
 
 
template <class charT, class Traits>
void test_ctor (const charT*, const Traits*,
                const char *cname, const char *tname)
{
    typedef std::basic_istream<charT, Traits>   Istream;
    typedef typename Istream::sentry            Sentry;
 
    memfun_info (__LINE__, cname, tname, "sentry (%{$ISTREAM}&, bool)");
 
    const charT cbuf[] = { 'a', 'b', 'c', 'd', 'e', ' ', 'f', '\0' };
 
    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
    };
 
    // exercise 27.6.1.1.2, p1:
    //     -  is.good() is true
    //     -  is.tie() is not null
    //     =  the function calls is.tie().flush()
 
    unsigned iter = 0;     // iteration counter
 
    for (unsigned i = 0; i != sizeof states / sizeof *states; ++i) {
        for (unsigned j = 0; j != 2; ++j /* noskipws */) {
            Streambuf<charT, Traits>
                sb (cbuf, cbuf + sizeof cbuf / sizeof *cbuf);
 
            Istream is (&sb);
 
            // flush() is called iff
            // all of the following conditions hold
            const bool flush_called = is.good () && 0 != is.tie ();
 
            const Sentry guard (is, 0 != j);
 
            _RWSTD_UNUSED (guard);
 
            rw_assert (flush_called == sb.nsyncs_, 0, __LINE__,
                       "%u. basic_istream<%s, %s>::sentry::sentry"
                       "(basic_istream &is, bool noskipws = %d); "
                       "expected to call is.flush () %d times, got %d"
                       "initial is.state () = %{Is}, is.flags() & "
                       "ios::skipws = %d",
                       iter, cname, tname, 0 != j, flush_called, sb.nsyncs_,
                       states [i], is.flags () & std::ios_base::skipws);
 
            ++iter;
        }
    }
 
    // exercise 27.6.1.1.2, p1:
    //     -  is.good() is true
    //     -  noskipws is zero
    //     -  is.flags() & ios_base::skipws
    //     =  the function extracts and discards each character as long
    //        as the next available input character c is a whitespace
    //        character.
 
    for (unsigned i = 0; i != sizeof states / sizeof *states; ++i) {
        for (unsigned j = 0; j != 2; ++j /* noskipws */) {
            for (unsigned k = 0; k != 2; ++k /* ios_base::skipws */) {
                for (charT wc = charT ('a'); wc != charT ('c'); ++wc) {
 
                    const Ctype<charT> ctp (1, wc);
 
                    Streambuf<charT, Traits>
                        sb (cbuf, cbuf + sizeof cbuf / sizeof *cbuf);
 
                    Istream is (&sb);
 
                    is.setstate (states [i]);
 
                    if (k)
                        is.setf (std::ios_base::skipws);
                    else
                        is.unsetf (std::ios_base::skipws);
 
                    const std::locale loc = 
                        is.imbue (std::locale (is.getloc (), &ctp));
 
                    // imbue the previous locale into the stream
                    // buffer to verify that the sentry ctor uses
                    // the locale imbued in the stream object and
                    // not the one in the stream buffer
                    sb.pubimbue (loc);
 
                    // a whitespace character is extracted iff
                    // all of the following conditions hold
                    const bool extract =
                           is.good ()
                        && 0 == j
                        && is.flags () & std::ios_base::skipws
                        && cbuf [0] == wc;
 
                    const Sentry guard (is, 0 != j);
 
                    _RWSTD_UNUSED (guard);
 
                    rw_assert (cbuf + extract == sb.pubgptr (), 0, __LINE__, 
                               "%u. %{$SENTRY}::sentry"
                               "(%{$ISTREAM} &is, bool noskipws "
                               "= %b); expected to extract %d "
                               "whitespace chars ('%c') from %{*Ac}, "
                               "extracted %u; initial is.state () = "
                               "%{Is}, is.flags() & ios::skipws = %d",
                               iter, j, extract + 0, char (wc),
                               int (sizeof (*cbuf)), cbuf,
                               sb.pubgptr () - sb.pubeback (),
                               states [i], k);
 
                    // verify that the ctor doesn't affect gcount()
                    rw_assert (0 == is.gcount (), 0, __LINE__, 
                               "%u. %{$SENTRY}::sentry"
                               "(%{$ISTREAM} &is = %{*Ac}, bool noskipws "
                               "= %b); changed is.gcount() from 0 to %i",
                               iter, int (sizeof (*cbuf)), cbuf, j,
                               is.gcount ());
 
                    ++iter;
                }
            }
        }
    }
}
 
 
template <class charT, class Traits>
void test_ok (const charT*, const Traits*,
              const char *cname, const char *tname)
{
    typedef std::basic_istream<charT, Traits>   Istream;
    typedef typename Istream::sentry            Sentry;
 
    memfun_info (__LINE__, cname, tname, "operator bool () const");
 
    const charT cbuf[] = { 'a', 'b', 'c', 'd', 'e', ' ', 'f', '\0' };
 
    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
    };
 
    // exercise 27.6.1.1.2, p5:
    //     -  is.good() is true
    //     -  noskipws is zero
    //     -  is.flags() & ios_base::skipws
    //     -  the function extracts and discards each character as long
    //        as the next available input character c is a whitespace
    //        character
    //     =  if, after any preparation is completed, is.good() is true,
    //        ok_ != false otherwise, ok_ == false.
 
    unsigned iter = 0;     // iteration counter
 
    for (unsigned i = 0; i != sizeof states / sizeof *states; ++i) {
        for (unsigned j = 0; j != 2; ++j /* noskipws */) {
            for (unsigned k = 0; k != 2; ++k /* ios_base::skipws */) {
                for (charT wc = charT ('a'); wc != charT ('c'); ++wc) {
 
                    const Ctype<charT> ctp (1, wc);
 
                    Streambuf<charT, Traits>
                        sb (cbuf, cbuf + sizeof cbuf / sizeof *cbuf);
 
                    Istream is (&sb);
 
                    is.setstate (states [i]);
 
                    if (k)
                        is.setf (std::ios_base::skipws);
                    else
                        is.unsetf (std::ios_base::skipws);
 
                    const std::locale loc = 
                        is.imbue (std::locale (is.getloc (), &ctp));
 
                    // imbue the previous locale into the stream
                    // buffer to verify that the sentry ctor uses
                    // the locale imbued in the stream object and
                    // not the one in the stream buffer
                    sb.pubimbue (loc);
 
                    const Sentry guard (is, 0 != j);
 
                    _RWSTD_UNUSED (guard);
 
                    // verify that both are either false or true
                    const bool success = !is.good () == !guard;
 
                    rw_assert (success, 0, __LINE__,
                               "%u. %{$SENTRY}"
                               "(%{$ISTREAM} &is, bool noskipws "
                               "= %d).operator bool() == %d; initial "
                               "is.state() = %{Is}, is.flags() & "
                               "ios::skipws = %d",
                               iter, j, is.good (),
                               states [i], k);
 
                    ++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(what, charT, Traits) \
    test_ ## what ((charT*)0, (Traits*)0, #charT, #Traits)
 
    using namespace std;
 
    if (rw_note (0 <= opt_char && 0 <= opt_char_traits, 0, __LINE__,
                 "istream::sentry tests disabled")) {
        TEST (ctor, char, char_traits<char>);
        TEST (ok, char, char_traits<char>);
    }
 
    if (rw_note (0 <= opt_char && 0 <= opt_user_traits, 0, __LINE__,
                 "basic_istream<char, UserTraits<char>::sentry "
                 "tests disabled")) {
        TEST (ctor, char, UserTraits<char>);
        TEST (ok, char, UserTraits<char>);
    }
 
#ifndef _RWSTD_NO_WCHAR_T
 
    if (rw_note (0 <= opt_wchar && 0 <= opt_char_traits, 0, __LINE__,
                 "wistream::sentry tests disabled")) {
        TEST (ctor, wchar_t, char_traits<wchar_t>);
        TEST (ok, 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>::sentry "
                 "tests disabled")) {
        TEST (ctor, wchar_t, UserTraits<wchar_t>);
        TEST (ok, 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.sentry",
                    0 /* no comment */,
                    run_test,
                    "|-char~ "
                    "|-wchar_t~ "
                    "|-char_traits~ "
                    "|-UserTraits~ ",
                    &opt_char,
                    &opt_wchar,
                    &opt_char_traits,
                    &opt_user_traits,
                    (void*)0   /* sentinel */);
}