27.std.manip.cpp

Go to the documentation of this file.

 
#include <rw/_defs.h>
 
#if !defined _MSC_VER || _MSC_VER > 1310
 
   // disabled for MSVC to work around its innumerable bugs
 
   // prevent the inclusion of non-essential public headers; only headers
   // necessary to compile each header #included here are #included
   // will produce errors if any templates defined in the header are
   // instantiated without the names they use having been completely defined
#  define _RWSTD_NO_REDUNDANT_DEFINITIONS
 
   // prevent out-of-line template definitions in .cc files from being
   // explicitly #included during the processing of library headers (faster
   // compilation) assumes that the test doesn't instantiate those templates
   // on types other than those they were explcitly instantiated on (will
   // have no effect if explicit instantiation is disabled or unsupported)
#  define _RWSTD_NO_TEMPLATE_DEFINITIONS
#endif   // !defined _MSC_VER || _MSC_VER > 1310
 
 
#include <climits>
#include <iomanip>
#include <istream>
#include <ostream>
#include <sstream>
 
#include <rw_driver.h>
 
 
// 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 CharTraits: std::char_traits<charT> { /* empty */ };
 
template < typename T >
/*static*/ const char* type_name ();
 
_RWSTD_SPECIALIZED_FUNCTION
/*static*/ const char*
type_name< char > ()
{
    return "char";
}
 
_RWSTD_SPECIALIZED_FUNCTION
/*static*/ const char*
type_name< std::char_traits<char> > ()
{
    return "std::char_traits<char>";
}
 
_RWSTD_SPECIALIZED_FUNCTION
/*static*/ const char*
type_name< CharTraits<char> > ()
{
    return "CharTraits<char>";
}
 
#ifndef _RWSTD_NO_WCHAR_T
 
_RWSTD_SPECIALIZED_FUNCTION
/*static*/ const char*
type_name< wchar_t > ()
{
    return "wchar_t";
}
 
_RWSTD_SPECIALIZED_FUNCTION
/*static*/ const char*
type_name< std::char_traits<wchar_t> > ()
{
    return "std::char_traits<wchar_t>";
}
 
_RWSTD_SPECIALIZED_FUNCTION
/*static*/ const char*
type_name< CharTraits<wchar_t> > ()
{
    return "CharTraits<wchar_t>";
}
 
#endif   // _RWSTD_NO_WCHAR_T
 
 
enum Manip {
    resetiosflags,
    setiosflags,
    setbase,
    setfill,
    setprecision,
    setw
};
 
 
template <class charT, class Traits>
struct StreamBuf: std::basic_streambuf<charT, Traits> { /* empty */ };
 
 
template <class charT, class Traits>
static int
test (int lineno, Manip m, int iarg, charT carg)
{
    static/*?*/ const char* const cname = type_name< charT > ();
    static/*?*/ const char* const tname = type_name< Traits > ();
 
    typedef std::ios_base::fmtflags            Fmtflags;
    typedef std::basic_istream<charT, Traits>  Istream;
    typedef std::basic_ostream<charT, Traits>  Ostream;
    typedef std::basic_iostream<charT, Traits> IOstream;
 
    StreamBuf<charT, Traits> sb;
 
    // stream objects used to apply manipulators to
    Istream  in1 (&sb);
    Ostream  out1 (&sb);
    IOstream inout1 (&sb);
 
    // stream objects used to call member functions on
    Istream  in2 (&sb);
    Ostream  out2 (&sb);
    IOstream inout2 (&sb);
 
    int nfailed = 0;
 
    switch (m) {
 
    case resetiosflags: {   // exercise 27.6.3, p3
 
        Istream &in3 = in1 >> std::resetiosflags (Fmtflags (iarg));
        in2.setf (Fmtflags (0), Fmtflags (iarg));
 
        if (in2.flags () != in3.flags ()) {
            ++nfailed;
            rw_assert (0, __FILE__, lineno,
                       "in >> std::resetiosflags(%{If}) with basic_istream "
                       "<%s, %s >", iarg, cname, tname);
        }
 
        Ostream &out3 = out1 << std::resetiosflags (Fmtflags (iarg));
        out2.setf (Fmtflags (0), Fmtflags (iarg));
 
        if (out2.flags () != out3.flags ()) {
            ++nfailed;
            rw_assert (0, __FILE__, lineno,
                       "out << std::resetiosflags(%{If}) with basic_ostream "
                       "<%s, %s >", iarg, cname, tname);
        }
 
        Ostream &inout3 = inout1 << std::resetiosflags (Fmtflags (iarg));
        inout2.setf (Fmtflags (0), Fmtflags (iarg));
 
        if (inout2.flags () != inout3.flags ()) {
            ++nfailed;
            rw_assert (0, __FILE__, lineno,
                       "io << std::resetiosflags(%{If}) with basic_iostream "
                       "<%s, %s >", iarg, cname, tname);
        }
 
        break;
    }
        
    case setiosflags: {   // exercise 27.6.3, p3
 
        Istream &in3 = in1 >> std::setiosflags (Fmtflags (iarg));
        in2.setf (Fmtflags (iarg));
 
        if (in2.flags () != in3.flags ()) {
            ++nfailed;
            rw_assert (0, __FILE__, lineno,
                       "std::setiosflags (%s) with basic_istream "
                       "<%s, %s >", iarg, cname, tname);
        }
 
        Ostream &out3 = out1 << std::setiosflags (Fmtflags (iarg));
        out2.setf (Fmtflags (iarg));
 
        if (out2.flags () != out3.flags ()) {
            ++nfailed;
            rw_assert (0, __FILE__, lineno,
                       "std::setiosflags (%s) with basic_ostream "
                       "<%s, %s >", iarg, cname, tname);
        }
 
        Ostream &inout3 = inout1 << std::setiosflags (Fmtflags (iarg));
        inout2.setf (Fmtflags (iarg));
 
        if (inout2.flags () != inout3.flags ()) {
            ++nfailed;
            rw_assert (0, __FILE__, lineno,
                       "std::setiosflags (%s) with basic_iostream "
                       "<%s, %s >", iarg, cname, tname);
        }
 
        break;
    }
 
    case setbase: {   // exercise 27.6.3, p5
 
        out1 << std::setbase (iarg);
 
        if (0 == iarg || 2 == iarg || 8 == iarg || 10 ==iarg || 16 == iarg) {
            out2.setf (   8 == iarg ? std::ios_base::oct
#ifndef _RWSTD_NO_EXT_BIN_IO
                          :  2 == iarg ? std::ios_base::bin
#endif   // _RWSTD_NO_EXT_BIN_IO
                          : 10 == iarg ? std::ios_base::dec
                          : 16 == iarg ? std::ios_base::hex
                          : Fmtflags (0),
                            std::ios_base::basefield);
 
            if (out1.flags () != out2.flags ()) {
                ++nfailed;
                rw_assert (0, __FILE__, lineno,
                           "std::setbase (%d)", iarg);
            }
        }
 
        std::basic_ostringstream<charT, std::char_traits<charT> > ostrm;
 
        static const struct {
            charT str[12];
        } num[] = {
            { { '1', '2', '3', '4', '\0' } },   // dec
            { { 'm', 'c', 'c', 'x', 'x', 'x', 'i', 'v', '\0' } },   // roman
            { { '1', '0', '0', '1', '1', '0', '1', '0', '0', '1', '0', '\0' } },
            { { '1', '2', '0', '0', '2', '0', '1', '\0' } },   // 3
            { { '1', '0', '3', '1', '0', '2', '\0' } },        // 4
            { { '1', '4', '4', '1', '4', '\0' } },             // 5
            { { '5', '4', '1', '4', '\0' } },   // 6
            { { '3', '4', '1', '2', '\0' } },   // 7
            { { '2', '3', '2', '2', '\0' } },   // oct
            { { '1', '6', '2', '1', '\0' } },   // 9
            { { '1', '2', '3', '4', '\0' } },   // dec
            { { 'a', '2', '2', '\0' } },        // 11
            { { '8', '6', 'a', '\0' } },        // 12
            { { '7', '3', 'c', '\0' } },        // 13
            { { '6', '4', '2', '\0' } },        // 14
            { { '5', '7', '4', '\0' } },        // 15
            { { '4', 'd', '2', '\0' } },        // hex
            { { '4', '4', 'a', '\0' } },        // 17
            { { '3', 'e', 'a', '\0' } },        // 18
            { { '3', '7', 'i', '\0' } },        // 19
            { { '3', '1', 'e', '\0' } },        // 20
            { { '2', 'g', 'g', '\0' } },        // 21
            { { '2', 'c', '2', '\0' } },        // 22
            { { '2', '7', 'f', '\0' } },        // 23
            { { '2', '3', 'a', '\0' } },        // 24
            { { '1', 'o', '9', '\0' } },        // 25
            { { '1', 'l', 'c', '\0' } },        // 26
            { { '1', 'i', 'j', '\0' } },        // 27
            { { '1', 'g', '2', '\0' } },        // 28
            { { '1', 'd', 'g', '\0' } },        // 29
            { { '1', 'b', '4', '\0' } },        // 30
            { { '1', '8', 'p', '\0' } },        // 31
            { { '1', '6', 'i', '\0' } },        // 32
            { { '1', '4', 'd', '\0' } },        // 33
            { { '1', '2', 'a', '\0' } },        // 34
            { { '1', '0', '9', '\0' } },        // 35
            { { 'y', 'a', '\0' } }              // 36
        };
 
        ostrm << std::setbase (iarg);
        ostrm << 1234;
 
        const int inx = iarg >= 0 && iarg <= 36 ? iarg : 0;
 
        if (ostrm.str () != num [inx].str) {
            ++nfailed;
            rw_assert (0, __FILE__, __LINE__,
                       "std::setbase (%d) inserted 1234 as \"%s\"; "
                       "expected \"%s\"", iarg,
                       ostrm.str ().data (), num [inx].str);
        }
 
        break;
    }
 
    case setfill: {   // exercise 27.6.3, p6
        Istream &in3 = in1 >> std::setfill (carg);
        in2.fill (carg);
 
        if (in2.fill () != in3.fill ()) {
            ++nfailed;
            rw_assert (0, __FILE__, lineno,
                       "in >> std::setfill('%c') with basic_istream"
                       "<%s, %s >", carg, cname, tname);
        }
 
        Ostream &out3 = out1 << std::setfill (carg);
        out2.fill (carg);
 
        if (out2.fill () != out3.fill ()) {
            ++nfailed;
            rw_assert (0, __FILE__, lineno,
                       "out << std::setfill('%c') with basic_ostream"
                       "<%s, %s >", carg, cname, tname);
        }
 
        Ostream &inout3 = inout1 << std::setfill (carg);
        inout2.fill (carg);
 
        if (inout2.fill () != inout3.fill ()) {
            ++nfailed;
            rw_assert (0, __FILE__, lineno,
                       "io << std::setfill('%c') with basic_iostream"
                       "<%s, %s >", carg, cname, tname);
        }
 
        break;
    }
 
    case setprecision: {   // exercise 27.6.3, p7
 
        Istream &in3 = in1 >> std::setprecision (iarg);
        in2.precision (std::streamsize (iarg));
 
        if (in2.precision () != in3.precision ()) {
            ++nfailed;
            rw_assert (0, __FILE__, lineno,
                       "std::setprecision (%d) with basic_istream "
                       "<%s, %s >", iarg, cname, tname);
        }
 
        Ostream &out3 = out1 << std::setprecision (iarg);
        out2.precision (std::streamsize (iarg));
 
        if (out2.precision () != out3.precision ()) {
            ++nfailed;
            rw_assert (0, __FILE__, lineno,
                       "std::setprecision (%d) with basic_ostream "
                       "<%s, %s >", iarg, cname, tname);
        }
 
        Ostream &inout3 = inout1 << std::setprecision (iarg);
        inout2.precision (std::streamsize (iarg));
 
        if (inout2.precision () != inout3.precision ()) {
            ++nfailed;
            rw_assert (0, __FILE__, lineno,
                       "std::setprecision (%d) with basic_iostream "
                       "<%s, %s >", iarg, cname, tname);
        }
 
        break;
    }
 
    case setw: {   // exercise 27.6.3, p8
 
        Istream &in3 = in1 >> std::setw (iarg);
        in2.width (std::streamsize (iarg));
 
        if (in2.width () != in3.width ()) {
            ++nfailed;
            rw_assert (0, __FILE__, lineno,
                       "std::setw (%d) with basic_istream<%s, %s >",
                       iarg, cname, tname);
        }
 
        Ostream &out3 = out1 << std::setw (iarg);
        out2.width (std::streamsize (iarg));
 
        if (out2.width () != out3.width ()) {
            ++nfailed;
            rw_assert (0, __FILE__, lineno,
                       "std::setw (%d) with basic_ostream<%s, %s >",
                       iarg, cname, tname);
        }
 
        Ostream &inout3 = inout1 << std::setw (iarg);
        inout2.width (std::streamsize (iarg));
 
        if (inout2.width () != inout3.width ()) {
            ++nfailed;
            rw_assert (0, __FILE__, lineno,
                       "std::setw (%d) with basic_iostream<%s, %s >",
                       iarg, cname, tname);
        }
 
        break;
    }
 
    }
 
    return nfailed;
}
 
 
// for convenience
#define Boolalpha   std::ios_base::boolalpha
#define Dec         std::ios_base::dec
#define Fixed       std::ios_base::fixed
#define Hex         std::ios_base::hex
#define Internal    std::ios_base::internal
#define Left        std::ios_base::left
#define Oct         std::ios_base::oct
#define Right       std::ios_base::right
#define Scientific  std::ios_base::scientific
#define Showbase    std::ios_base::showbase
#define Showpoint   std::ios_base::showpoint
#define Showpos     std::ios_base::showpos
#define Skipws      std::ios_base::skipws
#define Unitbuf     std::ios_base::unitbuf
#define Uppercase   std::ios_base::uppercase
#define Bin         std::ios_base::bin
#define Adjustfield std::ios_base::adjustfield
#define Basefield   std::ios_base::basefield
#define Floatfield  std::ios_base::floatfield
#define Nolock      std::ios_base::nolock
#define Nolockbuf   std::ios_base::nolockbuf
 
 
template <class charT, class Traits>
static void do_test ()
{
#define TEST(M, V, C) \
    ++ntried; nfailed += test< charT, Traits > (__LINE__, M, V, C)
 
    int ntried  = 0;
    int nfailed = 0;
 
    // exercise std::resetiosflags
 
    const char* const cname = type_name< charT > ();
    const char* const tname = type_name< Traits > ();
 
    rw_info (0, __FILE__, __LINE__,
             "27.6.3, p3 - std::resetiosflags(ios_base::"
             "fmtflags) with basic_{i,o,io}stream<%s, %s >",
             cname, tname);
 
    TEST (resetiosflags, Boolalpha, charT ());
    TEST (resetiosflags, Dec, charT ());
    TEST (resetiosflags, Fixed, charT ());
    TEST (resetiosflags, Hex, charT ());
    TEST (resetiosflags, Internal, charT ());
    TEST (resetiosflags, Left, charT ());
    TEST (resetiosflags, Oct, charT ());
    TEST (resetiosflags, Right, charT ());
    TEST (resetiosflags, Scientific, charT ());
    TEST (resetiosflags, Showbase, charT ());
    TEST (resetiosflags, Showpoint, charT ());
    TEST (resetiosflags, Showpos, charT ());
    TEST (resetiosflags, Skipws, charT ());
    TEST (resetiosflags, Unitbuf, charT ());
    TEST (resetiosflags, Uppercase, charT ());
 
#ifndef _RWSTD_NO_EXT_BIN_IO
 
    TEST (resetiosflags, Bin, charT ());
 
#endif   // _RWSTD_NO_EXT_BIN_IO
 
    TEST (resetiosflags, Adjustfield, charT ());
    TEST (resetiosflags, Basefield, charT ());
    TEST (resetiosflags, Floatfield, charT ());
 
#ifndef _RWSTD_NO_EXT_REENTRANT_IO
 
    TEST (resetiosflags, Nolock, charT ());
    TEST (resetiosflags, Nolockbuf, charT ());
 
#endif   // _RWSTD_NO_EXT_REENTRANT_IO
 
 
    TEST (resetiosflags, Oct | Dec,       charT ());
    TEST (resetiosflags, Oct | Hex,       charT ());
    TEST (resetiosflags, Dec | Hex,       charT ());
    TEST (resetiosflags, Oct | Dec | Hex, charT ());
    
    TEST (resetiosflags, Left | Internal,         charT ());
    TEST (resetiosflags, Left | Right,            charT ());
    TEST (resetiosflags, Right | Internal,        charT ());
    TEST (resetiosflags, Left | Right | Internal, charT ());
 
    TEST (resetiosflags, Showbase | Showpoint,           charT ());
    TEST (resetiosflags, Showbase | Showpos,             charT ());
    TEST (resetiosflags, Showbase | Showpoint | Showpos, charT ());
 
    if (!nfailed)
        rw_assert (true, __FILE__, __LINE__,
                   "std::resetiosflags failed %d out "
                   "of %d assertions", nfailed, ntried);
 
    // exercise std::setiosflags
 
    rw_info (0, __FILE__, __LINE__,
             "27.6.3, p4 - std::setiosflags(ios_base::"
             "fmtflags) with basic_{i,o,io}stream<%s, %s >",
             cname, tname);
 
    ntried = nfailed = 0;
 
    TEST (setiosflags, Boolalpha, charT ());
    TEST (setiosflags, Dec, charT ());
    TEST (setiosflags, Fixed, charT ());
    TEST (setiosflags, Hex, charT ());
    TEST (setiosflags, Internal, charT ());
    TEST (setiosflags, Left, charT ());
    TEST (setiosflags, Oct, charT ());
    TEST (setiosflags, Right, charT ());
    TEST (setiosflags, Scientific, charT ());
    TEST (setiosflags, Showbase, charT ());
    TEST (setiosflags, Showpoint, charT ());
    TEST (setiosflags, Showpos, charT ());
    TEST (setiosflags, Skipws, charT ());
    TEST (setiosflags, Unitbuf, charT ());
    TEST (setiosflags, Uppercase, charT ());
 
#ifndef _RWSTD_NO_EXT_BIN_IO
 
    TEST (setiosflags, Bin, charT ());
 
#endif   // _RWSTD_NO_EXT_BIN_IO
 
    TEST (setiosflags, Adjustfield, charT ());
    TEST (setiosflags, Basefield, charT ());
    TEST (setiosflags, Floatfield, charT ());
    TEST (setiosflags, Nolock, charT ());
    TEST (setiosflags, Nolockbuf, charT ());
 
    if (!nfailed)
        rw_assert (true, __FILE__, __LINE__,
                   "std::setiosflags failed %d out "
                   "of %d assertions", nfailed, ntried);
 
    // exercise std::setbase
 
    rw_info (0, __FILE__, __LINE__,
             "27.6.3, p5 - std::setbase(int) with "
             "basic_{i,o,io}stream<%s, %s >", cname, tname);
 
    ntried = nfailed = 0;
 
    TEST (setbase,  0, charT ());
    TEST (setbase,  8, charT ());
    TEST (setbase, 10, charT ());
    TEST (setbase, 16, charT ());
 
#ifndef _RWSTD_NO_EXT_BIN_IO
 
    TEST (setbase, 2, charT ());
 
#endif   // _RWSTD_NO_EXT_BIN_IO
 
#ifndef _RWSTD_NO_EXT_SETBASE
 
    TEST (setbase,  0, charT ());   // autodetect
    TEST (setbase,  1, charT ());   // roman
    TEST (setbase,  2, charT ());   // bin
    TEST (setbase,  3, charT ());
    TEST (setbase,  4, charT ());
    TEST (setbase,  5, charT ());
    TEST (setbase,  6, charT ());
    TEST (setbase,  7, charT ());
    TEST (setbase,  8, charT ());   // oct
    TEST (setbase,  9, charT ());
    TEST (setbase, 10, charT ());   // dec
    TEST (setbase, 11, charT ());
    TEST (setbase, 12, charT ());
    TEST (setbase, 16, charT ());   // hex
    TEST (setbase, 17, charT ());
    TEST (setbase, 36, charT ());   // 0-9, a-z
    TEST (setbase, -1, charT ());
    TEST (setbase, -2, charT ());
 
#endif   // _RWSTD_NO_EXT_SETBASE
 
    if (!nfailed)
        rw_assert (true, __FILE__, __LINE__,
                   "std::setbase failed %d out "
                   "of %d assertions", nfailed, ntried);
 
    // exercise std::setfill
 
    rw_info (0, __FILE__, __LINE__,
             "27.6.3, p6 - std::setfill(%s) with "
             "basic_{i,o,io}stream<%s, %s >", cname, cname, tname);
 
    ntried = nfailed = 0;
 
    TEST (setfill, 0, charT ('\0'));
    TEST (setfill, 0, charT ('\a'));
    TEST (setfill, 0, charT ('\n'));
    TEST (setfill, 0, charT ('\r'));
    TEST (setfill, 0, charT ('\t'));
    TEST (setfill, 0, charT ('\v'));
    TEST (setfill, 0, charT (' '));
    TEST (setfill, 0, charT ('*'));
    TEST (setfill, 0, charT ('#'));
 
    if (!nfailed)
        rw_assert (true, __FILE__, __LINE__,
                   "std::setfill failed %d out "
                   "of %d assertions", nfailed, ntried);
    
    // exercise std::setprecision
 
    rw_info (0, __FILE__, __LINE__,
             "27.6.3, p7 - std::setprecision(int) with "
             "basic_{i,o,io}stream<%s, %s >", cname, tname);
 
    ntried = nfailed = 0;
 
    TEST (setprecision, 0,         charT ());
    TEST (setprecision, 1,         charT ());
    TEST (setprecision, 2,         charT ());
    TEST (setprecision, SHRT_MAX,  charT ());
    TEST (setprecision, INT_MAX,   charT ());
    TEST (setprecision, -1,        charT ());
    TEST (setprecision, -2,        charT ());
    TEST (setprecision, SHRT_MIN,  charT ());
    TEST (setprecision, INT_MIN,   charT ());
 
    if (!nfailed)
        rw_assert (true, __FILE__, __LINE__,
                   "std::setprecision failed %d out "
                   "of %d assertions", nfailed, ntried);
 
    // exercise std::setw
 
    rw_info (0, __FILE__, __LINE__,
             "27.6.3, p8 - std::setw(int) with "
             "basic_{i,o,io}stream<%s, %s >", cname, tname);
 
    ntried = nfailed = 0;
 
    TEST (setw, 0,         charT ());
    TEST (setw, 1,         charT ());
    TEST (setw, 2,         charT ());
    TEST (setw, SHRT_MAX,  charT ());
    TEST (setw, INT_MAX,   charT ());
    TEST (setw, -1,        charT ());
    TEST (setw, -2,        charT ());
    TEST (setw, SHRT_MIN,  charT ());
    TEST (setw, INT_MIN,   charT ());
 
    if (!nfailed)
        rw_assert (true, __FILE__, __LINE__,
                   "std::setw failed %d out "
                   "of %d assertions", nfailed, ntried);
}
 
 
static int
run_test (int /*argc*/, char* /*argv*/ [])
{
    do_test<char, std::char_traits<char> > ();
    do_test<char, CharTraits<char> > ();
 
#ifndef _RWSTD_NO_WCHAR_T
 
    do_test<wchar_t, std::char_traits<wchar_t> > ();
    do_test<wchar_t, CharTraits<wchar_t> > ();
 
#endif   // _RWSTD_NO_WCHAR_T
 
    return 0;
}
 
 
/*extern*/ int
main (int argc, char* argv [])
{
    return rw_test (argc, argv, __FILE__,
                    "[lib.std.manip]",
                    "27.6.3 Standard manipulators",
                    run_test, "", 0);
}