Google Git
Sign in
apache / stdcxx / refs/heads/4.3.x / . / tests / iostream / 27.std.manip.cpp
blob: 7b19f9476d9f4e58a556f2f2d8270e54117d1919 [file] [log] [blame]
/***********************************************************************
*
* 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 <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);
}