stdcxx-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From elemi...@apache.org
Subject svn commit: r653943 - /stdcxx/branches/4.2.x/tests/iostream/27.std.manip.cpp
Date Tue, 06 May 2008 22:41:25 GMT
Author: elemings
Date: Tue May  6 15:41:23 2008
New Revision: 653943

URL: http://svn.apache.org/viewvc?rev=653943&view=rev
Log:
2008-05-06  Eric Lemings <eric.lemings@roguewave.com>

        STDCXX-885
        * branches/4.2.x/tests/iostream/27.std.manip.cpp: Migrated older
	test from Perforce repository to new test driver in Subversion
	repository.


Added:
    stdcxx/branches/4.2.x/tests/iostream/27.std.manip.cpp

Added: stdcxx/branches/4.2.x/tests/iostream/27.std.manip.cpp
URL: http://svn.apache.org/viewvc/stdcxx/branches/4.2.x/tests/iostream/27.std.manip.cpp?rev=653943&view=auto
==============================================================================
--- stdcxx/branches/4.2.x/tests/iostream/27.std.manip.cpp (added)
+++ stdcxx/branches/4.2.x/tests/iostream/27.std.manip.cpp Tue May  6 15:41:23 2008
@@ -0,0 +1,710 @@
+/***********************************************************************
+ *
+ * 27.std.manip.cpp - test exercising 27.6.3 - Standard manipulators
+ *
+ * $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 1994-2008 Rogue Wave Software.
+ * 
+ **************************************************************************/
+
+#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 <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);
+}
+



Mime
View raw message