stdcxx-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From se...@apache.org
Subject svn commit: r413737 - /incubator/stdcxx/trunk/tests/iostream/27.ostream.cpp
Date Mon, 12 Jun 2006 20:16:50 GMT
Author: sebor
Date: Mon Jun 12 13:16:50 2006
New Revision: 413737

URL: http://svn.apache.org/viewvc?rev=413737&view=rev
Log:
2006-06-12  Martin Sebor  <sebor@roguewave.com>

	STDCXX-4
	* 27.ostream.cpp: New test exercising lib.ostream.

Added:
    incubator/stdcxx/trunk/tests/iostream/27.ostream.cpp   (with props)

Added: incubator/stdcxx/trunk/tests/iostream/27.ostream.cpp
URL: http://svn.apache.org/viewvc/incubator/stdcxx/trunk/tests/iostream/27.ostream.cpp?rev=413737&view=auto
==============================================================================
--- incubator/stdcxx/trunk/tests/iostream/27.ostream.cpp (added)
+++ incubator/stdcxx/trunk/tests/iostream/27.ostream.cpp Mon Jun 12 13:16:50 2006
@@ -0,0 +1,1493 @@
+/***************************************************************************
+ *
+ * ostream.cpp - test exercising class template basic_ostream
+ *
+ * $Id$
+ *
+ ***************************************************************************
+ *
+ * Copyright (c) 1994-2005 Quovadx,  Inc., acting through its  Rogue Wave
+ * Software division. Licensed 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.
+ * 
+ **************************************************************************/
+
+
+#include <exception>   // for uncaught_exception()
+#include <ostream>     // for basic_ostream
+#include <climits>     // for XXX_MAX and XXX_MIN
+#include <cstddef>     // for ptrdiff_t
+#include <cstring>     // for memset()
+
+#include <any.h>       // for rw_any_t()
+#include <driver.h>    // for rw_test()
+
+/***************************************************************************/
+
+int rw_opt_sentry;          // for --enable/disable-sentry
+int rw_opt_formatted;       // for --enable/disable-formatted
+int rw_opt_unformatted;     // for --enable/disable-unformatted
+int rw_opt_flush;           // for --enable/disable-flush
+int rw_opt_exceptions;      // for --enable/disable-exceptions
+
+/***************************************************************************/
+
+enum streambuf_failure {
+    Setbuf = 1, Seekoff, Seekpos, Shwomanyc, Xsgetn,
+    Underflow, Uflow, Overflow, Pbackfail, Xsputn, Sync
+};
+
+
+template <class charT>
+struct test_streambuf: std::basic_streambuf<charT, std::char_traits<charT> >
+{
+    typedef charT                                        char_type;
+    typedef std::char_traits<charT>                      traits_type;
+    typedef std::basic_streambuf<char_type, traits_type> Streambuf;
+    typedef typename Streambuf::int_type                 int_type;
+    typedef typename Streambuf::off_type                 off_type;
+    typedef typename Streambuf::pos_type                 pos_type;
+
+    test_streambuf (std::basic_ios<char_type, traits_type> *pstrm)
+        : Streambuf (), buf_ (0), bufsize_ (0),
+          throws_ (streambuf_failure ()), fails_ (streambuf_failure ()),
+          pstrm_ (pstrm) {
+        std::memset (ncalls_, 0, sizeof ncalls_);
+        this->setp (buf_, buf_);
+    }
+
+    test_streambuf (charT *buf, std::streamsize bufsize)
+        : Streambuf (), buf_ (buf), bufsize_ (bufsize),
+          throws_ (streambuf_failure ()), fails_ (streambuf_failure ()) {
+        std::memset (ncalls_, 0, sizeof ncalls_);
+        this->setp (buf_, buf_);
+    }
+
+    bool test (streambuf_failure) const;
+
+    virtual Streambuf* setbuf (char_type*, std::streamsize) {
+        return test (Setbuf) ? this : 0;
+    }
+
+    virtual pos_type
+    seekoff (off_type, std::ios_base::seekdir, std::ios_base::openmode) {
+        test (Seekoff);
+        return pos_type (off_type (-1));
+    }
+
+    virtual pos_type
+    seekpos (pos_type, std::ios_base::openmode) {
+        test (Seekpos);
+        return pos_type (off_type (-1));
+    }
+
+    virtual std::streamsize showmanyc () {
+        test (Shwomanyc);
+        return 0;
+    }
+
+    virtual std::streamsize xsgetn (char_type*, std::streamsize) {
+        test (Xsgetn);
+        return 0;
+    }
+
+    virtual int_type underflow () {
+        test (Underflow);
+        return traits_type::eof ();
+    }
+
+    virtual int_type uflow () {
+        test (Uflow);
+        return traits_type::eof ();
+    }
+
+    virtual int_type
+    overflow (int_type = traits_type::eof ());
+
+    virtual int_type
+    pbackfail (int_type = traits_type::eof ()) {
+        test (Pbackfail);
+        return traits_type::eof ();
+    }
+
+    virtual std::streamsize
+    xsputn (const char_type *buf, std::streamsize bufsize) {
+        if (!test (Xsputn))
+            return 0;
+        return Streambuf::xsputn (buf, bufsize);
+    }
+
+    virtual int sync () {
+        if (!test (Sync))
+            return -1;
+
+        if (pstrm_)
+            pstrm_->setstate (std::ios_base::failbit);
+
+        return 0;
+    }
+
+    char_type       *buf_;
+    std::streamsize  bufsize_;
+
+    int ncalls_ [Sync + 1];     // number of calls made to each function
+
+    streambuf_failure throws_;  // exception value to throw
+    streambuf_failure fails_;   // which function to fail
+
+    std::basic_ios<char_type, traits_type> *pstrm_;
+
+    static int fail_when_;      // call number on which to fail
+};
+
+
+template <class charT>
+int test_streambuf<charT>::fail_when_ = 1;
+
+
+template <class charT>
+bool
+test_streambuf<charT>::test (streambuf_failure which) const
+{
+    ++_RWSTD_CONST_CAST (test_streambuf*, this)->ncalls_ [which];
+
+    if (ncalls_ [which] == fail_when_ && throws_ == which)
+        throw which;
+
+    return fails_ != which || ncalls_ [which] != fail_when_;
+}
+
+
+template <class charT>
+typename test_streambuf<charT>::int_type
+test_streambuf<charT>::overflow (int_type c /* = traits_type::eof () */)
+{
+    if (!test (Overflow))
+        return traits_type::eof ();
+
+    if (traits_type::eq_int_type (c, traits_type::eof ()))
+        return traits_type::not_eof (c);
+
+    const std::ptrdiff_t pptr_off = this->pptr () - this->pbase ();
+
+    if (   this->pptr () == this->epptr ()
+        && this->epptr () < buf_ + bufsize_) {
+        this->setp (buf_, this->epptr () + 1);
+        this->pbump (pptr_off + 1);
+        *(this->pptr () - 1) = traits_type::to_char_type (c);
+        return c;
+    }
+
+    return traits_type::eof ();
+}
+
+
+
+enum num_put_overload {
+    Bool = Sync + 1, Long, ULong, Dbl, LDbl, PVoid, LLong, ULLong
+};
+
+
+#ifndef _RWSTD_NO_NATIVE_BOOL
+
+num_put_overload select_overload (bool)           { return Bool; }
+
+#endif   // _RWSTD_NO_NATIVE_BOOL
+
+template <class T>
+num_put_overload select_overload (T) { return num_put_overload (); }
+
+num_put_overload select_overload (short)          { return Long; }
+num_put_overload select_overload (unsigned short) { return ULong; }
+num_put_overload select_overload (int)            { return Long; }
+num_put_overload select_overload (unsigned int)   { return ULong; }
+num_put_overload select_overload (long)           { return Long; }
+num_put_overload select_overload (unsigned long)  { return ULong; }
+
+#ifdef _RWSTD_LONG_LONG
+
+num_put_overload select_overload (_RWSTD_LONG_LONG)          { return Long; }
+num_put_overload select_overload (unsigned _RWSTD_LONG_LONG) { return ULong; }
+
+#endif
+
+num_put_overload select_overload (float)          { return Dbl; }
+num_put_overload select_overload (double)         { return Dbl; }
+
+#ifndef _RWSTD_NO_LONG_DOUBLE
+
+num_put_overload select_overload (long double)    { return LDbl; }
+
+#endif   // _RWSTD_NO_LONG_DOUBLE
+
+num_put_overload select_overload (const void*)    { return PVoid; }
+
+
+template <class charT>
+struct test_num_put: std::num_put<charT, std::ostreambuf_iterator<charT> >
+{
+    typedef charT                           char_type;
+    typedef std::ostreambuf_iterator<charT> iter_type;
+    typedef std::num_put<charT, iter_type>  NumPut;
+    typedef std::ios_base                   Ios;
+
+    explicit test_num_put (std::size_t refs = 0)
+        : NumPut (refs),
+          throws_ (num_put_overload ()),
+          fails_ (num_put_overload ()) {
+        std::memset (ncalls_, 0, sizeof ncalls_);
+    }
+
+    iter_type test (iter_type, num_put_overload) const;
+
+#define TEST(it, val)   test (it, select_overload (val))
+
+#ifndef _RWSTD_NO_NATIVE_BOOL
+
+    virtual iter_type
+    do_put (iter_type it, Ios &fl, char_type fill, bool val) const {
+        return NumPut::do_put (TEST (it, val), fl, fill, val);
+    }
+
+#endif   // _RWSTD_NO_NATIVE_BOOL
+
+    virtual iter_type
+    do_put (iter_type it, Ios &fl, char_type fill, long val) const {
+        return NumPut::do_put (TEST (it, val), fl, fill, val);
+    }
+
+    virtual iter_type
+    do_put (iter_type it, Ios &fl, char_type fill, unsigned long val) const {
+        return NumPut::do_put (TEST (it, val), fl, fill, val);
+    }
+
+    virtual iter_type
+    do_put (iter_type it, Ios &fl, char_type fill, double val) const {
+        return NumPut::do_put (TEST (it, val), fl, fill, val);
+    }
+
+    virtual iter_type
+    do_put (iter_type it, Ios &fl, char_type fill, long double val) const {
+        return NumPut::do_put (TEST (it, val), fl, fill, val);
+    }
+
+    virtual iter_type
+    do_put (iter_type it, Ios &fl, char_type fill, const void *val) const {
+        return NumPut::do_put (TEST (it, val), fl, fill, val);
+    }
+
+#ifdef _RWSTD_LONG_LONG
+
+    // extensions
+    virtual iter_type
+    do_put (iter_type it, Ios &fl, char_type fill,
+            _RWSTD_LONG_LONG val) const {
+        return NumPut::do_put (TEST (it, val), fl, fill, val);
+    }
+
+    virtual iter_type
+    do_put (iter_type it, Ios &fl, char_type fill,
+            unsigned _RWSTD_LONG_LONG val) const {
+        return NumPut::do_put (TEST (it, val), fl, fill, val);
+    }
+
+#endif   // _RWSTD_LONG_LONG
+
+#undef TEST
+
+    int ncalls_ [ULLong + 1];
+    num_put_overload throws_;
+    num_put_overload fails_;
+};
+
+
+template <class charT>
+typename test_num_put<charT>::iter_type
+test_num_put<charT>::test (iter_type it, num_put_overload which) const
+{
+    ++_RWSTD_CONST_CAST (test_num_put*, this)->ncalls_ [which];
+
+    if (throws_ == which)
+        throw which;
+
+    if (fails_ == which) {
+
+        // construct an iter_type object in a failed state
+        test_streambuf<charT> tsb (0, 0);
+        iter_type failed (&tsb);
+        failed = char_type ();
+
+        _RWSTD_ASSERT (failed.failed ());
+
+        return failed;
+    }
+
+    return it;
+}
+
+/***************************************************************************/
+
+bool uncaught = false;
+
+
+template <class charT>
+struct DtorChek
+{
+    typedef std::basic_ostream<charT, std::char_traits<charT> > Ostream;
+    typedef typename Ostream::sentry                            Sentry;
+
+    Ostream *pstrm_;
+
+    ~DtorChek () {
+
+#ifndef _RWSTD_UNCAUGHT_EXCEPTION
+
+        uncaught = std::uncaught_exception ();
+
+#endif   // _RWSTD_UNCAUGHT_EXCEPTION
+
+        const Sentry guard (*pstrm_);
+    }
+};
+
+
+template <class charT>
+void test_sentry (charT)
+{
+    static const char* const cname = rw_any_t (charT ()).type_name ();
+
+    typedef std::basic_ostream<charT, std::char_traits<charT> > Ostream;
+    typedef typename Ostream::sentry                            Sentry;
+
+    const Sentry *pguard = 0;
+
+    {
+        rw_info (0, 0, __LINE__,
+                 "std::basic_ostream<%s>::sentry::sentry "
+                 "(basic_ostream&)", cname);
+
+        // verify that sentry ctor handles streams with rdbuf() == 0
+        static Ostream strm (0);
+
+        strm.setf (std::ios_base::unitbuf);
+
+        // pguard will be deleted in sentry dtor block
+        pguard = new Sentry (strm);
+    }
+
+    {
+        // verify 27.6.2.3, p2 and 3:
+        //
+        // explicit sentry(basic_ostream<charT,traits>& os);
+        //
+        // -2-  If os.good() is nonzero, prepares for formatted or
+        //      unformatted output. If os.tie() is not a null pointer,
+        //      calls os.tie()->flush().
+        // -3-  If, after any preparation is completed, os.good() is
+        //      true, ok_ == true otherwise, ok_ == false.
+
+        // verify that sentry ctor calls stream.tie()->flush() once
+        // and that the object returns true when converted to bool
+        test_streambuf<charT> tsb_tied (0);
+        test_streambuf<charT> tsb_strm (0);
+
+        Ostream tied (&tsb_tied);
+        Ostream strm (&tsb_strm);
+
+        strm.tie (&tied);
+
+        int nsyncs = tsb_tied.ncalls_ [Sync];
+
+        const Sentry guard (strm);
+
+        rw_assert (1 + nsyncs == tsb_tied.ncalls_ [Sync], 0, __LINE__,
+                   "std::basic_ostream<%s>::sentry::sentry "
+                   "(basic_ostream &s) called s.tie ()->flush() once; "
+                   "got %d times",
+                   cname, tsb_tied.ncalls_ [Sync] - nsyncs);
+
+        rw_info (0, 0, __LINE__, "std::basic_ostream<%s>::sentry::operator "
+                 "bool () const", cname);
+
+        rw_assert (bool (guard), 0, __LINE__,
+                   "std::basic_ostream<%s>::sentry::operator bool() == true "
+                   "after a successful construction", cname);
+    }
+
+    {
+        // verify 27.6.2.3, p3: i.e., same as above, but check that
+        // the ctor sets ok_ to false after the preparation fails
+        // (which is done by having stream.tie()->flush() call 
+        // stream.setf (failbit))
+
+        test_streambuf<charT> tsb_strm (0);
+        Ostream strm (&tsb_strm);
+
+        // create a use-defined streambuf object and associate it
+        // with the stream object, strm, constructed above so that
+        // when the latter calls strm.tie()->flush() the former
+        // can set failbit in strm
+        test_streambuf<charT> tsb_tied (&strm);
+        Ostream tied (&tsb_tied);
+
+        // tie the two streams together
+        strm.tie (&tied);
+
+        // sentry ctor calls strm.tie()->flush() which sets failbit
+        // in strm's; the sentry ctor should detect this condition
+        const Sentry guard (strm);
+
+        rw_assert (!guard, 0, __LINE__,
+                   "std::basic_ostream<%s>::sentry::operator bool() == "
+                   "false after a failed construction (stream.rdstate() "
+                   "== %{Is})", cname, strm.rdstate ());
+    }
+
+    {
+        // verify 27.6.2.3, p3: i.e., same as above, but check that
+        // stream.tie()->flush() is not called when stream.good() is
+        // false
+
+        test_streambuf<charT> tsb_strm (0);
+        Ostream strm (&tsb_strm);
+
+        // create a use-defined streambuf object and associate it
+        // with the stream object, strm, constructed above to keep
+        // track of the number of any calls to sync() from flush()
+        test_streambuf<charT> tsb_tied (&strm);
+        Ostream tied (&tsb_tied);
+
+        // tie the two streams together
+        strm.tie (&tied);
+
+        strm.setstate (std::ios_base::failbit);
+
+        // sentry ctor should not call strm.tie()->flush() if
+        // strm.good() returns false
+        const Sentry guard (strm);
+
+        rw_assert (!tsb_tied.ncalls_ [Sync], 0, __LINE__,
+                   "std::basic_ostream<%s>::sentry::sentry(basic_ostream&) "
+                   "unexpectedly called stream.tie()->flush() when "
+                   "stream.good() == false", cname);
+
+        rw_assert (!guard, 0, __LINE__,
+                   "std::basic_ostream<%s>::sentry::operator bool() == "
+                   "false for a stream whose stream.rdstate() = %{Is}",
+                   cname, strm.rdstate ());
+    }
+
+#ifndef _RWSTD_NO_EXCEPTIONS
+
+    if (0 <= rw_opt_exceptions) {
+
+        test_streambuf<charT> tsb_strm (0);
+        Ostream strm (&tsb_strm);
+
+        test_streambuf<charT> tsb_tied (&strm);
+        Ostream tied (&tsb_tied);
+
+        strm.tie (&tied);
+
+        tsb_tied.throws_ = Sync;
+
+        // verify that an exception thrown during the call to
+        // strm.tie()->flush() is caught and not propagated, and in
+        // response to it badbit is set in the tied stream, but that
+        // strm is not affected in any way
+        try {
+
+            // sentry ctor calls strm.tie()->flush() which should call
+            // strm.tie()->flush() (or its equivalent), which in turn
+            // calls rdbuf()->pubsync() which throws an exception (from
+            // the virtual overridden above)
+            // the sentry ctor must not prevent badbit from being set
+            // in the tied stream but it must not allow the exception
+            // to propagate to its caller
+            const Sentry guard (strm);
+
+            rw_assert (!!guard, 0, __LINE__,
+                       "std::basic_ostream<%s>::sentry::operator bool() == "
+                       "true after it failed to flush a tied stream due to "
+                       "an exception (stream.rdstate() == %{Is})",
+                       cname, strm.rdstate ());
+        }
+        catch (...) {
+            rw_assert (false, 0, __LINE__,
+                       "std::basic_ostream<%s>::sentry::sentry(basic_ostream&)"
+                       " unexpectedly allowed an exception to propagate",
+                       cname);
+        }
+
+        // verify that the sentry ctor did not affect the state of the stream
+        // as a result of the exception thrown during the flushing of the tied
+        // stream
+        rw_assert (strm.good (), 0, __LINE__,
+                   "std::basic_ostream<%s>::sentry::sentry(basic_ostream&) "
+                   "unexpectedly affected the state of the stream as a result "
+                   "pf an exception thrown during the flushing of a tied "
+                   "stream; stream state = %{Is}", cname, strm.rdstate ());
+
+        // verify that the the tied stream object's state has set badbit
+        // in response to the exception thrown from its stream buffer
+        rw_assert (tied.bad (), 0, __LINE__,
+                   "std::basic_ostream<%s>::sentry::sentry(basic_ostream&) "
+                   "failed to cause badbit to be set in stream's tied object "
+                   "after an exception; tied stream's state = %{Is}",
+                   cname, tied.rdstate ());
+    }
+
+#endif   // _RWSTD_NO_EXCEPTIONS
+
+    {
+        rw_info (0, 0, __LINE__,
+                 "std::basic_ostream<%s>::sentry::~sentry()", cname);
+
+        // verify that sentry dtor handles streams with rdbuf() == 0
+
+        // pguard dynamically constructed in sentry ctor block
+        delete pguard;
+    }
+
+    {
+        // verify 27.6.2.3, p4:
+        //
+        // ~sentry();
+        //
+        // -4-  If ((os.flags() & iose::unitbuf) && !uncaught_exception())
+        //      is true, calls os.flush().
+
+        test_streambuf<charT> tsb (0);
+        Ostream strm (&tsb);
+
+        int nsyncs;
+
+        // verify that os.flush() is not called if ios::unitbuf is clear
+        {
+            const Sentry guard (strm);
+
+            nsyncs = tsb.ncalls_ [Sync];
+        }
+
+        rw_assert (nsyncs == tsb.ncalls_ [Sync], 0, __LINE__,
+                   "std::basic_ostream<%s>::sentry::~sentry() unexpectedly "
+                   "called stream.flush () when ios::unitbuf is clear",
+                   cname);
+
+        // verify that os.flush() is called if ios::unitbuf is set
+        // (assuming uncaugt_exception() returns false
+        {
+            strm.setf (std::ios_base::unitbuf);
+
+            const Sentry guard (strm);
+
+            nsyncs = tsb.ncalls_ [Sync];
+        }
+
+        rw_assert (1 + nsyncs == tsb.ncalls_ [Sync], 0, __LINE__,
+                   "std::basic_ostream<%s>::sentry::~sentry() failed to call "
+                   "stream.flush () when ios::unitbuf is set",
+                   cname);
+
+#ifndef _RWSTD_NO_EXCEPTIONS
+#  ifndef _RWSTD_NO_UNCAUGHT_EXCEPTION
+
+        if (0 <= rw_opt_exceptions) {
+
+            // verify that os.flush() is not called if ios::unitbuf is set
+            // but uncaught_exception() returns true
+
+            nsyncs = tsb.ncalls_ [Sync];
+
+            try {
+                strm.setf (std::ios_base::unitbuf);
+
+                DtorChek<charT> to_be_destroyed;
+
+                to_be_destroyed.pstrm_ = &strm;
+
+                throw 0;
+            }
+            catch (...) {
+            }
+
+            rw_assert (nsyncs == tsb.ncalls_ [Sync], 0, __LINE__,
+                       "std::basic_ostream<%s>::sentry::~sentry() "
+                       "unexpectedly called stream.flush() when "
+                       "ios::unitbuf is set but uncaught_exception() "
+                       "returns true", cname);
+
+            rw_assert (uncaught, 0, __LINE__,
+                       "std::uncaught_exception () == true when an exception "
+                       "is pending (language runtime library error)");
+        }
+
+#  endif   // _RWSTD_NO_UNCAUGHT_EXCEPTION
+#endif   // _RWSTD_NO_EXCEPTIONS
+
+    }
+}
+
+
+/***************************************************************************/
+
+
+// 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
+
+#define Bad         std::ios_base::badbit
+#define Eof         std::ios_base::eofbit
+#define Fail        std::ios_base::failbit
+#define Good        std::ios_base::goodbit
+
+
+const int Throw = 1 << 16;
+
+
+template <class charT, class T>
+void test_formatted (charT, int line1, int line2,
+                     T           val,
+                     const char *str,
+                     int         fmtflags,
+                     int         width,
+                     int         fill,
+                     int         rdstate,
+                     int         exceptions,
+                     int         failure = 0,
+                     int         fail_when = 1)
+{
+    static const char* const cname = rw_any_t (charT ()).type_name ();
+    static const char* const tname = rw_any_t (T ()).type_name ();
+
+    typedef std::basic_ostream<charT, std::char_traits<charT> > Ostream;
+
+    charT charbuf [256] = { 0 };
+
+    // define prior to the definition of `tsb' below
+    // to guarantee the proper order of destruction
+    test_num_put<charT> tnp (1);
+
+    test_streambuf<charT> tsb (charbuf, sizeof charbuf / sizeof *charbuf);
+
+    if (failure & Throw) {
+        failure &= ~Throw;
+
+        if (failure < Bool)
+            tsb.throws_ = streambuf_failure (failure);
+        else
+            tnp.throws_ = num_put_overload (failure);
+    }
+    else {
+        if (failure < Bool)
+            tsb.fails_ = streambuf_failure (failure);
+        else
+            tnp.fails_ = num_put_overload (failure);
+    }
+
+    tsb.fail_when_ = fail_when;
+
+    Ostream os (&tsb);
+
+    if (select_overload (T ())) {
+
+        // for arithmetic types and void*, imbue a custom num_put facet
+        os.imbue (std::locale (std::locale::classic (), &tnp));
+    }
+
+    os.flags (std::ios_base::fmtflags (fmtflags));
+    os.width (std::streamsize (width));
+    os.exceptions (std::ios_base::iostate (exceptions));
+
+    if (-1 != fill)
+        os.fill (charT (fill));
+
+    enum { E_unknown = 1, E_failure };
+    int caught = 0;
+
+    const char *caught_what = "none (none thrown)";
+
+    try {
+        os << val;
+    }
+    catch (streambuf_failure e) {
+        caught = e;
+        caught_what = "streambuf_failure";
+    }
+    catch (num_put_overload e) {
+        caught = e;
+        caught_what = "num_put_overload";
+    }
+    catch (const std::ios_base::failure&) {
+        caught = E_failure;
+        caught_what = "std::ios_base::failure";
+    }
+    catch (...) {
+        caught = E_unknown;
+        caught_what = "unknown exception";
+    }
+
+    if (str) {
+        char cbuf [256] = "";
+        for (std::size_t i = 0; i != sizeof cbuf && str [i]; ++i)
+            cbuf [i] = char (charbuf [i]);
+
+        rw_assert (0 == std::strcmp (cbuf, str), __FILE__, line1,
+                   "%d. std::basic_ostream<%s>::operator<<(%s = %{#wc}) "
+                   "inserted \"%s\", expected \"%s\"",
+                   line2, cname, tname, cbuf, str);
+    }
+
+    // verify that stream is in the expected state
+    rw_assert (rdstate == os.rdstate (), __FILE__, line1,
+               "%d. std::basic_ostream<%s>::operator<<(%s = %{#wc})"
+               ".rdstate() == %{Is}, got %{Is}",
+               line2, cname, tname, val, rdstate, os.rdstate ());
+
+    if (!tsb.throws_ && !tnp.throws_) {
+
+        // verify that width(0) has been called (unless there are exceptions
+        // involved, in which case it's unspecified whether width(0) has or
+        // has not been called
+        bool pass =
+            !((!exceptions || !tsb.fails_ && !tnp.fails_) && os.width ());
+
+        rw_assert (pass, __FILE__, line1,
+                   "%d. std::basic_ostream<%s>::operator<<(%s = %{#wc})"
+                   ".width () == 0, got %d",
+                   line2, cname, tname, val, os.width  ());
+
+        // verify that ios_base::failure has been thrown (and caught)
+        // if badbit is set in exceptions
+        pass = !(exceptions & os.rdstate () && caught != E_failure);
+
+        rw_assert (pass, __FILE__, line1,
+                   "%d. std::basic_ostream<%s>::operator<<(%s = %{#wc}) "
+                   "set %{Is} but failed to throw ios_base::failure "
+                   "when the same bit is set in exceptions",
+                   line2, cname, tname, val, rdstate);
+    }
+
+    if (tsb.throws_) {
+
+        // verify that the same exception (and not ios_base::failure)
+        // as the one thrown from basic_filebuf has been propagated
+        // and caught when badbit is set in exceptions, and that no
+        // exception has been thrown if exceptions is clear
+        if (exceptions & Bad && caught != tsb.throws_) {
+
+            rw_assert (false, __FILE__, line1,
+                       "%d. std::basic_ostream<%s>::operator<<(%s = %{#wc}) "
+                       "failed to propagate an exception thrown by "
+                       "basic_filebuf; caught %s instead",
+                       line2, cname, tname, val, caught_what);
+        }
+        else {
+            rw_assert ((exceptions & Bad) || !caught, 0, line1,
+                       "%d. std::basic_ostream<%s>::operator<<(%s = %{#wc}) "
+                       "propagated an exception thrown by basic_filebuf "
+                       "when ios_base::badbit is clear in exceptions",
+                       line2, cname, tname, val);
+        }
+    }
+
+    if (tnp.throws_) {
+
+        // verify that the same exception (and not ios_base::failure)
+        // as the one thrown from num_put has been propagated and caught
+        // when badbit is set in exceptions, and that no exception has
+        // been thrown if exceptions is clear
+        if (exceptions & Bad)
+            rw_assert (caught == tnp.throws_, 0, line1,
+                       "%d. std::basic_ostream<%s>::operator<<(%s = %{#wc}) "
+                       "failed to propagate exception thrown by "
+                       "basic_filebuf; caught %s instead",
+                       line2, cname, tname, val, caught_what);
+        else
+            rw_assert (!caught, __FILE__, line1,
+                       "%d. std::basic_ostream<%s>::operator<<(%s = %{#wc}) "
+                       "propagated an exception thrown by basic_filebuf"
+                       "when ios_base::badbit is clear in exceptions",
+                       line2, cname, tname, val);
+    }
+}
+
+/***************************************************************************/
+
+template <class charT>
+bool is_char (charT) { return false; }
+
+bool is_char (char) { return true; }
+bool is_char (signed char) { return true; }
+bool is_char (unsigned char) { return true; }
+
+bool is_char (const char*) { return true; }
+bool is_char (const signed char*) { return true; }
+bool is_char (const unsigned char*) { return true; }
+
+template <class charT>
+bool is_wchar_t (charT) { return false; }
+
+#ifndef _RWSTD_NO_WCHAR_T
+
+bool is_wchar_t (wchar_t) { return true; }
+bool is_wchar_t (const wchar_t*) { return true; }
+
+#endif   // _RWSTD_NO_WCHAR_T
+
+
+template <class charT, class T>
+void test_formatted (charT, int line, T val, 
+                     int flags, int width, const char *str, int fill = -1)
+{
+    static const char* const cname = rw_any_t (charT ()).type_name ();
+    static const char* const tname = rw_any_t (T ()).type_name ();
+
+    static int done = 0;
+
+    if (!done++) {
+        // show message only the first time for each specialization
+
+        if (is_char (T ()) || is_wchar_t (T ()))
+            rw_info (0, 0, __LINE__,
+                     "std::operator<<(basic_ostream<%s>&, %s)", cname, tname);
+        else
+            rw_info (0, 0, __LINE__,
+                     "std::basic_ostream<%s>::operator<<(%s)", cname, tname);
+    }
+
+    // determine which overload of num_put::put() is expected
+    // to be called for a value of type T; 0 for non-numeric
+    const int npo = select_overload (val);
+
+    typedef std::basic_ostream<charT, std::char_traits<charT> > Ostream;
+
+#define T      charT (), line, __LINE__
+#define TEST   test_formatted
+
+    TEST (T, val, str, flags, width, fill, Good, 0, 0);
+
+    if (npo) {
+        // exercise the behavior of basic_ostream with exception bits
+        // clear when num_put fails by returning an ostreambuf_iterator
+        // in a failed state  (expect ios::badbit to be set w/o throwing
+        // an exception)
+        TEST (T, val, "", flags, width, fill, Bad, 0, npo);
+
+        // exercise the behavior of basic_ostream with ios::badbit
+        // set in exceptions when num_put fails by returning an
+        // ostreambuf_iterator in a failed state  (expect ios::badbit
+        // to be set and ios::failure to be thrown)
+        TEST (T, val, "", flags, width, fill, Bad, Bad, npo);
+
+        // exercise the behavior of basic_ostream with exceptions bits
+        // clear when num_put fails by throwing an exception (expect
+        // ios::badbit to be set and no exception to propagate)
+        TEST (T, val, "", flags, width, fill, Bad, 0, Throw | npo);
+
+        // exercise the behavior of basic_ostream with ios::badbit
+        // set in exceptions when num_put fails by throwing an exception
+        // (expect ios::badbit to be set and the original exception to
+        // propagate)
+        TEST (T, val, "", flags, width, fill, Bad, Bad, Throw | npo);
+    }
+
+    // exercise the behavior of basic_ostream with exception bits clear
+    // when basic_streambuf::overflow() fails by returning eof() (expect
+    // ios::badbit to be set w/o throwing an exception)
+    TEST (T, val, "", flags, width, fill, Bad, 0, Overflow);
+
+    // exercise the behavior of basic_ostream with ios::badbit set in
+    // exceptions when basic_streambuf::overlow() fails by returning
+    // eof() (expect ios::badbit to be set and ios::failure to be thrown)
+    TEST (T, val, "", flags, width, fill, Bad, Bad, Overflow);
+
+    // exercise the behavior of basic_ostream with exceptions bits clear
+    // when basic_streambuf::overlow() fails by throwing an exception
+    // (expect ios::badbit to be set and no exception to propagate)
+    TEST (T, val, "", flags, width, fill, Bad, 0, Throw | Overflow);
+
+    // exercise the behavior of basic_ostream with ios::badbit set in
+    // exceptions when basic_streambuf::overflow() fails by throwing
+    // an exception (expect ios::badbit to be set and the original
+    // exception to propagate)
+    TEST (T, val, "", flags, width, fill, Bad, Bad, Throw | Overflow);
+}
+
+/***************************************************************************/
+
+
+template <class charT>
+void test_formatted (charT)
+{
+#undef T
+#define T(val)   charT (), __LINE__, val
+
+#undef TEST
+#define TEST test_formatted
+
+    //////////////////////////////////////////////////////////////////
+    // exercise operator<< (basic_ostream, char)
+
+    //        +------------ character to insert
+    //        |    +------- fmtflags
+    //        |    |  +---- field width
+    //        |    |  |  +- expected output
+    //        |    |  |  |
+    //        v    v  v  v
+    TEST (T ('a'), 0, 0, "a");
+    TEST (T ('A'), 0, 0, "A");
+    TEST (T ('@'), 0, 1, "@");
+    TEST (T ('#'), 0, 2, " #");
+
+    if (is_wchar_t (charT ())) {
+
+#ifndef _RWSTD_NO_NATIVE_WCHAR_T
+
+        //////////////////////////////////////////////////////////////////
+        // exercise operator<< (basic_ostream, wchar_t)
+        TEST (T (L'b'), 0, 0, "b");
+        TEST (T (L'B'), 0, 0, "B");
+
+#endif   // _RWSTD_NO_NATIVE_WCHAR_T
+
+    }
+    else {
+
+        // no operator<< (basic_ostream<wchar_t>, {signed,unsigned} char)
+
+        //////////////////////////////////////////////////////////////////
+        // exercise operator<< (basic_ostream, signed char)
+        typedef signed char SChar;
+
+        TEST (T (SChar ('b')), 0, 0, "b");
+        TEST (T (SChar ('B')), 0, 0, "B");
+
+        //////////////////////////////////////////////////////////////////
+        // exercise operator<< (basic_ostream, signed char)
+        typedef unsigned char UChar;
+
+        TEST (T (UChar ('c')), 0, 0, "c");
+        TEST (T (UChar ('C')), 0, 0, "C");
+    }
+
+
+#ifndef _RWSTD_NO_NATIVE_BOOL
+
+    //////////////////////////////////////////////////////////////////
+    // exercise basic_ostream::operator<< (bool)
+    TEST (T (false), 0, 0, "0");
+    TEST (T (true),  0, 0, "1");
+
+    TEST (T (false), Hex | Showbase, 0, "0");
+    TEST (T (true),  Hex | Showbase, 0, "0x1");
+
+    TEST (T (false), Boolalpha, 0, "false");
+    TEST (T (true),  Boolalpha, 0, "true");
+
+#endif   // _RWSTD_NO_NATIVE_BOOL
+
+
+    //////////////////////////////////////////////////////////////////
+    // exercise basic_ostream::operator<< (short)
+    TEST (T (short ( 0)), 0, 0,  "0");
+    TEST (T (short ( 1)), 0, 0,  "1");
+    TEST (T (short (-1)), 0, 0, "-1");
+
+#if SHRT_MAX == 32767
+
+    TEST (T (short (SHRT_MAX)), 0, 0,  "32767");
+    TEST (T (short (SHRT_MIN)), 0, 0, "-32768");
+
+    TEST (T (short (SHRT_MAX)), Hex, 0, "7fff");
+    TEST (T (short (SHRT_MIN)), Hex, 0, "8000");
+
+#elif SHRT_MAX == 2147483647
+
+    TEST (T (short (SHRT_MAX)), 0, 0,  "2147483647");
+    TEST (T (short (SHRT_MIN)), 0, 0, "-2147483648");
+
+    TEST (T (short (SHRT_MAX)), Hex, 0, "ffffffff");
+    TEST (T (short (SHRT_MIN)), Hex, 0, "80000000");
+
+#endif   // SHRT_MAX
+
+    //////////////////////////////////////////////////////////////////
+    // exercise basic_ostream::operator<< (unsigned short)
+    typedef unsigned short UShort;
+
+    TEST (T (UShort (  0)), 0, 0,   "0");
+    TEST (T (UShort (  1)), 0, 0,   "1");
+    TEST (T (UShort (255)), 0, 0, "255");
+
+#if USHRT_MAX == 0xffffU
+
+    TEST (T (UShort (USHRT_MAX)), 0, 0,  "65535");
+    TEST (T (UShort (USHRT_MAX)), Hex, 0, "ffff");
+
+#elif USHRT_MAX == 0xffffffffU
+
+    TEST (T (UShort (SHRT_MAX)), 0, 0,   "4294967295");
+    TEST (T (UShort (SHRT_MAX)), Hex, 0,   "ffffffff");
+
+#endif   // USHRT_MAX
+
+    //////////////////////////////////////////////////////////////////
+    // exercise basic_ostream::operator<< (int)
+    TEST (T ( 0), 0, 0,  "0");
+    TEST (T ( 1), 0, 0,  "1");
+    TEST (T (-1), 0, 0, "-1");
+
+#if INT_MAX == 32767
+
+    TEST (T (INT_MAX), 0, 0,  "32767");
+    TEST (T (INT_MIN), 0, 0, "-32768");
+
+    TEST (T (INT_MAX), Hex, 0, "7fff");
+    TEST (T (INT_MIN), Hex, 0, "8000");
+
+#elif INT_MAX == 2147483647
+
+    TEST (T (INT_MAX), 0, 0,  "2147483647");
+    TEST (T (INT_MIN), 0, 0, "-2147483648");
+
+    TEST (T (INT_MAX), Hex, 0, "7fffffff");
+    TEST (T (INT_MIN), Hex, 0, "80000000");
+
+#elif INT_MAX == 9223372036854775807
+
+    TEST (T (INT_MAX), 0, 0,  "9223372036854775807");
+    TEST (T (INT_MIN), 0, 0, "-9223372036854775808");
+
+    TEST (T (INT_MAX), Hex, 0, "7fffffffffff");
+    TEST (T (INT_MIN), Hex, 0, "800000000000");
+
+#endif   // INT_MAX
+
+    //////////////////////////////////////////////////////////////////
+    // exercise basic_ostream::operator<< (unsigned int)
+    TEST (T (  0), 0, 0,   "0");
+    TEST (T (  1), 0, 0,   "1");
+    TEST (T (255), 0, 0, "255");
+
+#if UINT_MAX == 0xffffU
+
+    TEST (T (UINT_MAX), 0, 0,  "65535");
+    TEST (T (UINT_MAX), Hex, 0, "ffff");
+
+#elif UINT_MAX == 0xffffffffU
+
+    TEST (T (UINT_MAX), 0, 0,   "4294967295");
+    TEST (T (UINT_MAX), Hex, 0,   "ffffffff");
+
+#elif UINT_MAX == 0xffffffffffffffffU
+
+    TEST (T (UINT_MAX), 0, 0,   "18446744073709551615");
+    TEST (T (UINT_MAX), Hex, 0,     "ffffffffffffffff");
+
+#endif   // UINT_MAX
+
+    //////////////////////////////////////////////////////////////////
+    // exercise basic_ostream::operator<< (long)
+    TEST (T ( 0L), 0, 0,  "0");
+    TEST (T ( 1L), 0, 0,  "1");
+    TEST (T (-1L), 0, 0, "-1");
+
+#if LONG_MAX == 32767L
+
+    TEST (T (LONG_MAX), 0, 0,  "32767");
+    TEST (T (LONG_MIN), 0, 0, "-32768");
+
+    TEST (T (LONG_MAX), Hex, 0, "7fff");
+    TEST (T (LONG_MIN), Hex, 0, "8000");
+
+#elif LONG_MAX == 2147483647L
+
+    TEST (T (LONG_MAX), 0, 0,  "2147483647");
+    TEST (T (LONG_MIN), 0, 0, "-2147483648");
+
+    TEST (T (LONG_MAX), Hex, 0, "7fffffff");
+    TEST (T (LONG_MIN), Hex, 0, "80000000");
+
+#elif LONG_MAX == 9223372036854775807L
+
+    TEST (T (LONG_MAX), 0, 0,  "9223372036854775807");
+    TEST (T (LONG_MIN), 0, 0, "-9223372036854775808");
+
+    TEST (T (LONG_MAX), Hex, 0, "7fffffffffff");
+    TEST (T (LONG_MIN), Hex, 0, "800000000000");
+
+#endif   // LONG_MAX
+
+    //////////////////////////////////////////////////////////////////
+    // exercise basic_ostream::operator<< (unsigned int)
+
+    TEST (T (  0UL), 0, 0,   "0");
+    TEST (T (  1UL), 0, 0,   "1");
+    TEST (T (257UL), 0, 0, "257");
+
+#if ULONG_MAX == 0xffffUL
+
+    TEST (T (ULONG_MAX), 0, 0,  "65535");
+    TEST (T (ULONG_MAX), Hex, 0, "ffff");
+
+#elif ULONG_MAX == 0xffffffffUL
+
+    TEST (T (ULONG_MAX), 0, 0,   "4294967295");
+    TEST (T (ULONG_MAX), Hex, 0,   "ffffffff");
+
+#elif ULONG_MAX == 0xffffffffffffffffUL
+
+    TEST (T (ULONG_MAX), 0, 0,   "18446744073709551615");
+    TEST (T (ULONG_MAX), Hex, 0,     "ffffffffffffffff");
+
+#endif   // ULONG_MAX
+
+#ifdef _RWSTD_LONG_LONG
+
+    //////////////////////////////////////////////////////////////////
+    // exercise basic_ostream::operator<< (long long)
+    typedef _RWSTD_LONG_LONG LongLong;
+
+    TEST (T (LongLong ( 0)), 0, 0,  "0");
+    TEST (T (LongLong ( 1)), 0, 0,  "1");
+    TEST (T (LongLong (-1)), 0, 0, "-1");
+
+    // avoid using the preprocessor here to prevent warnings
+    // or errors about invalid preprocessor constants (e.g.,
+    // PR #28595)
+    if (_RWSTD_LLONG_MAX == 32767L) {
+
+        TEST (T (_RWSTD_LLONG_MAX), 0, 0,  "32767");
+        TEST (T (_RWSTD_LLONG_MIN), 0, 0, "-32768");
+
+        TEST (T (_RWSTD_LLONG_MAX), Hex, 0, "7fff");
+        TEST (T (_RWSTD_LLONG_MIN), Hex, 0, "8000");
+    }
+    else if (_RWSTD_LLONG_MAX == 2147483647L) {
+
+        TEST (T (_RWSTD_LLONG_MAX), 0, 0,  "2147483647");
+        TEST (T (_RWSTD_LLONG_MIN), 0, 0, "-2147483648");
+
+        TEST (T (_RWSTD_LLONG_MAX), Hex, 0, "7fffffff");
+        TEST (T (_RWSTD_LLONG_MIN), Hex, 0, "80000000");
+
+    }
+    else if (_RWSTD_LLONG_MAX > 2147483647L) {
+
+        TEST (T (_RWSTD_LLONG_MAX), 0, 0,  "9223372036854775807");
+        TEST (T (_RWSTD_LLONG_MIN), 0, 0, "-9223372036854775808");
+
+        TEST (T (_RWSTD_LLONG_MAX), Hex, 0, "7fffffffffff");
+        TEST (T (_RWSTD_LLONG_MIN), Hex, 0, "800000000000");
+
+    }
+
+    //////////////////////////////////////////////////////////////////
+    // exercise basic_ostream::operator<< (unsigned long long)
+
+    typedef unsigned _RWSTD_LONG_LONG ULongLong;
+
+    TEST (T (ULongLong (  0)), 0, 0,   "0");
+    TEST (T (ULongLong (  1)), 0, 0,   "1");
+    TEST (T (ULongLong (257)), 0, 0, "257");
+
+    if (_RWSTD_ULLONG_MAX == 0xffffUL) {
+        TEST (T (_RWSTD_ULLONG_MAX), 0, 0,  "65535");
+        TEST (T (_RWSTD_ULLONG_MAX), Hex, 0, "ffff");
+    }
+    else if (_RWSTD_ULLONG_MAX == 0xffffffffUL) {
+        TEST (T (_RWSTD_ULLONG_MAX), 0, 0,   "4294967295");
+        TEST (T (_RWSTD_ULLONG_MAX), Hex, 0,   "ffffffff");
+    }
+    else if (_RWSTD_ULLONG_MAX > 0xffffffffUL) {
+        TEST (T (_RWSTD_ULLONG_MAX), 0, 0,   "18446744073709551615");
+        TEST (T (_RWSTD_ULLONG_MAX), Hex, 0,     "ffffffffffffffff");
+    }
+
+#endif   // _RWSTD_LONG_LONG
+
+    //////////////////////////////////////////////////////////////////
+    // exercise basic_ostream::operator<< (float)
+    TEST (T ( 0.0f), 0, 0, "0");
+    TEST (T ( 1.0f), 0, 0, "1");
+    TEST (T (-2.1f), 0, 0, "-2.1");
+
+    // exercise the default precision of 6, which gives the maximum number
+    // of significant digits for the "%g" or "%G" conversion, which is
+    // the default for the default flags
+    TEST (T (3.1415926f), 0, 0,          "3.14159");
+    TEST (T (3.1415926f), Scientific, 0, "3.14159");
+
+    // exercise the default precision of 6, which gives the number of
+    // digits after the decimal point for the "%f" or "%F" conversion,
+    // which is used for the fixed flag
+    TEST (T (12.3456789f), Fixed, 0, "12.345679");
+
+    //////////////////////////////////////////////////////////////////
+    // exercise basic_ostream::operator<< (double)
+    TEST (T ( 0.0), 0, 0, "0");
+    TEST (T ( 2.0), 0, 0, "2");
+    TEST (T (-4.2), 0, 0, "-4.2");
+
+    // exercise the default precision of 6, which gives the maximum number
+    // of significant digits for the "%g" or "%G" conversion, which is
+    // the default for the default flags
+    TEST (T (1.23456789), 0, 0,          "1.23457");
+    TEST (T (9.87654321), Scientific, 0, "9.87654");
+
+    // exercise the default precision of 6, which gives the number of
+    // digits after the decimal point for the "%f" or "%F" conversion,
+    // which is used for the fixed flag
+    TEST (T (12.3456789), Fixed, 0, "12.345679");
+
+#ifndef _RWSTD_NO_LONG_DOUBLE
+
+    //////////////////////////////////////////////////////////////////
+    // exercise basic_ostream::operator<< (long double)
+    TEST (T ( 0.0L), 0, 0, "0");
+    TEST (T ( 3.0L), 0, 0, "3");
+    TEST (T (-5.3L), 0, 0, "-5.3");
+
+    // exercise the default precision of 6, which gives the maximum number
+    // of significant digits for the "%g" or "%G" conversion, which is
+    // the default for the default flags
+    TEST (T (1.23456789L), 0, 0,          "1.23457");
+    TEST (T (9.87654321L), Scientific, 0, "9.87654");
+
+    // exercise the default precision of 6, which gives the number of
+    // digits after the decimal point for the "%f" or "%F" conversion,
+    // which is used for the fixed flag
+    TEST (T (12.3456789L), Fixed, 0, "12.345679");
+
+#endif   // _RWSTD_NO_LONG_DOUBLE
+
+    //////////////////////////////////////////////////////////////////
+    // exercise basic_ostream::operator<< (const void*)
+    TEST (T ((void*)0),      0, 0, 0 /* format implementation-defined */);
+    TEST (T ((void*)1),      0, 0, 0);
+    TEST (T ((void*)0x2345), 0, 0, 0);
+
+    //////////////////////////////////////////////////////////////////
+    // exercise basic_ostream::operator<< (const char*)
+    TEST (T ("a"),     0,                        0, "a");
+    TEST (T ("b"),     0,                       -1, "b");
+    TEST (T ("ab"),    0,                        0, "ab");
+    TEST (T ("abc"),   0,                        4, " abc");
+    TEST (T ("def"),   Left,                     5, "def<<", '<');
+    TEST (T ("ghi"),   Right,                    6, ">>>ghi", '>');
+    TEST (T ("jklm"),  Internal,                 7, "   jklm");
+    TEST (T ("nopqr"), Left | Right,             8, "   nopqr");
+    TEST (T ("stuv"),  Left | Internal,          9, "     stuv");
+    TEST (T ("wxy"),   Right | Internal,        10, "       wxy");
+    TEST (T ("z"),     Left | Right | Internal, 11, "__________z", '_');
+
+    if (is_char (charT ())) {
+
+        // inserters overloaded on signed and unsigned char*
+        // defined only for basic_ostream<char>, not wchar_t
+
+        //////////////////////////////////////////////////////////////////
+        // exercise basic_ostream::operator<< (const signed char*)
+
+#undef SCH
+#define SCH(val)      charT (), __LINE__, (const signed char*)val
+
+        TEST (SCH ("A"),     0,                        0, "A");
+        TEST (SCH ("B"),     0,                       -1, "B");
+        TEST (SCH ("AB"),    0,                        0, "AB");
+        TEST (SCH ("ABC"),   0,                        4, " ABC");
+        TEST (SCH ("DEF"),   Left,                     5, "DEF++", '+');
+        TEST (SCH ("GHI"),   Right,                    6, "---GHI", '-');
+        TEST (SCH ("JKLM"),  Internal,                 7, "   JKLM");
+        TEST (SCH ("NOPQR"), Left | Right,             8, "   NOPQR");
+        TEST (SCH ("STUV"),  Left | Internal,          9, "     STUV");
+        TEST (SCH ("WXY"),   Right | Internal,        10, "       WXY");
+        TEST (SCH ("Z"),     Left | Right | Internal, 11, "##########Z", '#');
+
+        //////////////////////////////////////////////////////////////////
+        // exercise basic_ostream::operator<< (const unsigned char*)
+
+#undef UCH
+#define UCH(val)      charT (), __LINE__, (const unsigned char*)val
+
+        TEST (UCH ("Z"),     0,                        0, "Z");
+        TEST (UCH ("Y"),     0,                       -1, "Y");
+        TEST (UCH ("YZ"),    0,                        0, "YZ");
+        TEST (UCH ("XYZ"),   0,                        4, " XYZ");
+        TEST (UCH ("UVW"),   Left,                     5, "UVW\\\\", '\\');
+        TEST (UCH ("RST"),   Right,                    6, "///RST", '/');
+        TEST (UCH ("OPQR"),  Internal,                 7, "   OPQR");
+        TEST (UCH ("JKLMN"), Left | Right,             8, "   JKLMN");
+        TEST (UCH ("FGHI"),  Left | Internal,          9, "     FGHI");
+        TEST (UCH ("CDE"),   Right | Internal,        10, "       CDE");
+        TEST (UCH ("AB"),    Left | Right | Internal, 11, "^^^^^^^^^AB", '^');
+
+    }
+}
+
+/***************************************************************************/
+
+template <class charT>
+void test_flush (charT)
+{
+    static const char* const cname = rw_any_t (charT ()).type_name ();
+
+    rw_info (0, 0, __LINE__,
+             "std::basic_ostream<%s>::flush() ", cname);
+
+    typedef std::basic_ostream<charT, std::char_traits<charT> >   Ostream;
+    typedef std::basic_streambuf<charT, std::char_traits<charT> > Streambuf;
+
+    {
+        test_streambuf<charT> tsb (0);
+        Ostream strm (&tsb);
+
+        const int nsyncs = tsb.ncalls_ [Sync];
+
+        strm.flush ();
+
+        rw_assert (1 + nsyncs == tsb.ncalls_ [Sync], 0, __LINE__,
+                   "std::basic_ostream<%s>::flush() called rdbuf()->sync() "
+                   "once; got %d times",
+                   cname, tsb.ncalls_ [Sync] - nsyncs);
+    }
+
+    {
+        test_streambuf<charT> tsb (0);
+        Ostream strm (&tsb);
+
+        tsb.fails_     = Sync;
+        tsb.fail_when_ = 1;
+
+        const int nsyncs = tsb.ncalls_ [Sync];
+
+        strm.flush ();
+
+        rw_assert (1 + nsyncs == tsb.ncalls_ [Sync], 0, __LINE__,
+                   "std::basic_ostream<%s>::flush() called rdbuf()->sync() "
+                   "once; got %zu times",
+                   cname, tsb.ncalls_ [Sync] - nsyncs);
+
+        rw_assert (std::ios_base::badbit == strm.rdstate (), 0, __LINE__,
+                   "std::basic_ostream<%s>::flush() failed to set badbit "
+                   "after rdbuf()->pubsync() failed; state = %{Is}",
+                   cname, strm.rdstate ());
+    }
+
+    {
+        test_streambuf<charT> tsb (0);
+        Ostream strm (&tsb);
+
+        strm.setstate (std::ios_base::failbit);
+
+        const int nsyncs = tsb.ncalls_ [Sync];
+
+        strm.flush ();
+
+        rw_assert (nsyncs == tsb.ncalls_ [Sync], 0, __LINE__,
+                   "std::basic_ostream<%s>::flush() unexpectedly made "
+                   "%zu calls to rdbuf()->sync() when rdstate () == "
+                   "failbit",
+                   cname, tsb.ncalls_ [Sync] - nsyncs);
+
+        rw_assert (std::ios_base::failbit == strm.rdstate (), 0, __LINE__,
+                   "std::basic_ostream<%s>::flush() unexpectedly changed "
+                   "state from std::ios_base::failbit to %{Is}",
+                   cname, strm.rdstate ());
+    }
+}
+
+/***************************************************************************/
+
+template <class charT>
+void run_test (charT)
+{
+    // exercise ostream::sentry
+    if (rw_opt_sentry < 0)
+        rw_note (0, 0, __LINE__, "sentry tests disabled");
+    else
+        test_sentry (charT ());
+
+    // exercise formatted output functions
+    if (rw_opt_formatted < 0)
+        rw_note (0, 0, __LINE__, "tests of formatted functions disabled");
+    else
+        test_formatted (charT ());
+
+    // exercise formatted output functions
+    if (rw_opt_unformatted < 0)
+        rw_note (0, 0, __LINE__, "tests of unformatted functions disabled");
+    else {
+        // FIXME: implement this
+        // test_unformatted (charT ());
+    }
+
+    // exercise flush()
+    if (rw_opt_flush < 0)
+        rw_note (0, 0, __LINE__, "flush tests disabled");
+    else
+        test_flush (charT ());
+}
+
+/***************************************************************************/
+
+static int
+run_test (int, char**)
+{
+    run_test (char ());
+
+#ifndef _RWSTD_NO_WCHAR_T
+
+    run_test (wchar_t ());
+
+#endif   // _RWSTD_NO_WCHAR_T
+
+    return 0;
+}
+
+/***************************************************************************/
+
+int main (int argc, char *argv[])
+{
+    return rw_test (argc, argv, __FILE__,
+                    "lib.ostream",
+                    0 /* no comment */,
+                    run_test,
+                    "|-sentry~ "
+                    "|-formatted~ "
+                    "|-unformatted~ "
+                    "|-flush~ "
+                    "|-no-exceptions~ ",
+                    &rw_opt_sentry,
+                    &rw_opt_formatted,
+                    &rw_opt_unformatted,
+                    &rw_opt_flush,
+                    &rw_opt_exceptions);
+}

Propchange: incubator/stdcxx/trunk/tests/iostream/27.ostream.cpp
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: incubator/stdcxx/trunk/tests/iostream/27.ostream.cpp
------------------------------------------------------------------------------
    svn:keywords = Id



Mime
View raw message