// format the template-id of the iterator
void fmtnam (const ParamNames &pn)
{
// omit names of unspecified (default) template arguments
const char* const id = pn.cname ? pn.trname ? pn.dname ?
"<%s, %s, %s, %s>" : "<%s, %s, %s>" : "<%s, %s>" : "<%s>";
rw_fprintf (0, "%{$ITER!:@}",
"istream_iterator%{@}",
id, pn.tname, pn.cname, pn.trname, pn.dname);
}
void info (const char *cname, const char *tname, const char *type)
{
// format the CLASS environment variable w/o writing out any output
rw_fprintf (0,
"%{$CLASS!:@}",
"%{?}istream%{:}%{?}wistream"
"%{:}basic_istream<%s, %s>%{;}%{;}",
'c' == *cname && 's' == *tname,
'w' == *cname && 's' == *tname,
cname, tname);
rw_info (0, 0, __LINE__, "std::%{$CLASS}::operator>>(%s&)", type);
}
_TEST_EXPORT rw_pid_t
rw_process_create (const char* path, char* const argv[])
{
#if defined (_WIN32)
return rw_process_create ("\"%s\" %{ As}", path, argv + 1);
#else // #if !defined (_WIN32)
if (0 == access (path, X_OK)) {
const rw_pid_t child_pid = fork ();
if (0 == child_pid) {
// the child process
execvp (path, argv);
// the execvp returns only if an error occurs
rw_fprintf (rw_stderr, "%s:%d execvp (%#s, %{As}) failed: "
"errno = %{#m} (%{m})\n",
__FILE__, __LINE__, path, argv);
exit (1);
}
else if (-1 == child_pid)
rw_error (0, __FILE__, __LINE__,
"fork () failed: errno = %{#m} (%{m})");
return child_pid;
}
else
rw_error (0, __FILE__, __LINE__,
"access (%#s, X_OK) failed: errno = %{#m} (%{m})",
path);
return -1;
#endif // #if defined (_WIN32)
}
void
test_extractor (CharT*, Traits*, ArithmeticType*,
const char *cname,
const char *tname,
const char *aname,
int line,
// printf formatting directive for ArithmeticType
const char *valfmt,
// character buffer (input sequence)
const char *cbuf,
// number of characters in buffer:
std::size_t cbuf_size,
// ctype and numpunct data
const LocaleData &locale_data,
// stream flags():
int flags,
// initial stream rdstate():
int init_state,
// unmasked exceptions:
int exceptions,
// expected exception:
int expect_exception,
// expected stream state after extraction:
int expect_state,
// expected number of extracted characters:
int expect_extract,
// have streambuf fail (or throw) after so many calls
// to underflow() (each call extracts a single chracter):
int fail_when,
// initial value of the argument to extractor:
ArithmeticType init_value,
// expected value of the argument after extraction:
ArithmeticType expect_value)
{
_RWSTD_UNUSED (cname);
_RWSTD_UNUSED (tname);
typedef std::basic_istream<CharT, Traits> Istream;
typedef MyStreambuf<CharT, Traits> Streambuf;
const char *fail_desc = 0;
int fail_how = 0;
if (fail_when < 0) {
// have the stream buffer object's underflow() fail (by throwing
// an exception if possible) after `fail_when' characters have
// been extracted (this object calls underflow() for every char)
fail_how = Underflow | Throw;
fail_when = -fail_when;
fail_desc = "threw";
}
else if (0 < fail_when) {
// have the stream buffer object's underflow() fail by returning
// eof after `fail_when' characters have been extracted (this
// object calls underflow() for every char)
fail_how = Underflow;
fail_desc = "returned EOF";
}
// construct a stream buffer object and initialize its read sequence
// with the character buffer
Streambuf sb (cbuf, cbuf_size, fail_how, fail_when);
// construct an istream object and initialize it with the user
// defined streambuf object
Istream is (&sb);
if (-1 == flags) {
// get the initial stream object's format control flags
flags = is.flags ();
}
else {
// set the stream object's format control flags
is.flags (std::ios::fmtflags (flags));
}
if (-1 == exceptions) {
// get the initial stream object's exceptions
exceptions = is.exceptions ();
}
else {
// unmask the stream objects exceptions (must be done
// before calling setstate() to prevent the latter from
// throwing ios::failure)
is.exceptions (std::ios::iostate (exceptions));
}
if (-1 == init_state) {
// get the initial stream object's state
init_state = is.rdstate ();
}
else {
// set the stream object's initial state
#ifndef _RWSTD_NO_EXCEPTIONS
try {
is.setstate (std::ios::iostate (init_state));
}
catch (...) {
// ignore exceptions
}
#else // if defined ( _RWSTD_NO_EXCEPTIONS)
is.setstate (std::ios::iostate (init_state));
#endif // _RWSTD_NO_EXCEPTIONS
}
// construct a locale object that treats only the specified `white'
// characters as whitespace (all others are treated normally)
const std::locale loc =
is.imbue (make_locale ((CharT*)0, (Traits*)0, locale_data));
// imbue the previous locale into the stream buffer to verify that
// the ws manipulator uses the locale imbued in the stream object
// and not the one in the stream buffer
sb.pubimbue (loc);
// initialize the variable to the initial value to detect
// the extractor setting it when it's not supposed to
ArithmeticType value = init_value;
// format the FUNCALL environment variable w/o writing out any output
rw_fprintf (0,
"%{$FUNCALL!:@}",
"%{$CLASS}(%{*Ac}).operator>>(%s& = %{@}): "
"initial flags() = %{If}, rdstate() = %{Is}, "
"exceptions() = %{Is}, whitespace = %{#s}, numpunct = { "
".dp=%{#c}, .ts=%{#c}, .grp=%{#s}, .fn=%{#s}, .tn=%{#s} }",
int (sizeof *cbuf), cbuf, aname, valfmt, init_value,
flags, init_state,
exceptions, locale_data.whitespace,
locale_data.decimal_point, locale_data.thousands_sep,
locale_data.grouping, locale_data.falsename,
locale_data.truename);
#ifndef _RWSTD_NO_EXCEPTIONS
int caught = 0;
try {
is >> value;
}
catch (Exception&) {
caught = 1;
}
catch (std::ios_base::failure &ex) {
caught = 2;
rw_assert (caught == expect_exception, 0, line,
"line %d. %{$FUNCALL}: unexpectedly threw "
"ios_base::failure(%{#s})", __LINE__, ex.what ());
}
catch (...) {
caught = -1;
rw_assert (false, 0, line,
"line %d. %{$FUNCALL}: unexpectely threw an exception "
"of unknown type", __LINE__);
}
//////////////////////////////////////////////////////////////////
// verify that the function propagates exceptions thrown from the
// streambuf object only when badbit is set in the stream object's
// exceptions()
rw_assert (caught == expect_exception, 0, line,
"line %d. %{$FUNCALL}: "
"%{?}failed to throw"
"%{:}unexpectedly propagated"
"%{;} exception",
__LINE__, expect_exception);
#else // if defined (_RWSTD_NO_EXCEPTIONS)
is >> value;
#endif // _RWSTD_NO_EXCEPTIONS
// clear the text describing the type of failure when streambuf
// didn't actually fail (or throw)
if (sb.failed_ == None && sb.threw_ == None)
fail_desc = 0;
//////////////////////////////////////////////////////////////////
// verify that the expected number of characters have been
// extracted from the stream
const int extracted = int (sb.pubgptr () - sb.pubeback ());
rw_assert (expect_extract == extracted, 0, line,
"%d. %{$FUNCALL}: expected to extract %d characters, "
"got %d%{?} (underflow() %s at extraction %u)%{;}",
__LINE__, expect_extract,
extracted, 0 != fail_desc, fail_desc, fail_when);
//////////////////////////////////////////////////////////////////
// verify that gcount() is not affected
if (0 == opt_no_gcount)
rw_assert (0 == is.gcount (), 0, line,
"%d. %{$FUNCALL}: gcount() == 0, got %d "
"%{?} (underflow() %s at extraction %u)%{;}",
__LINE__, is.gcount (),
0 != fail_desc, fail_desc, fail_when);
//////////////////////////////////////////////////////////////////
// verify the state of the stream object after the function call
rw_assert (is.rdstate () == expect_state, 0, line,
"line %d. %{$FUNCALL}: rdstate() == %{Is}, got %{Is}"
"%{?} (underflow() %s at extraction %u)%{;}",
__LINE__, expect_state, is.rdstate(),
0 != fail_desc, fail_desc, fail_when);
//////////////////////////////////////////////////////////////////
// verify the extracted value matches the expected value
rw_assert (expect_value == value, 0, line,
"line %d. %{$FUNCALL}: expected value %{@}, got %{@}",
__LINE__, valfmt, expect_value, valfmt, value);
}