const std::locale
make_locale (const CharT*, const Traits*, const LocaleData &data)
{
// construct a locale with the appropriate ctype and numpunct
// facets installed
const std::locale tmp (make_locale ((CharT*)0, data));
typedef std::istreambuf_iterator<CharT, Traits> Iterator;
typedef std::num_get<CharT, Iterator> NumGet;
// check to see if num_get for this charater type and traits
// is installed and install it if it isn't (i.e., when Traits
// is other than std::char_traits<CharT>)
if (std::has_facet<NumGet>(tmp))
return tmp;
return std::locale (tmp, new NumGet);
}
/** creates a small world and some stuff in it.
* two terrains: 'plain' and 'ocean'
* one race: 'human'
* one ship_type: 'boat'
* one building_type: 'castle'
* in 0.0 and 1.0 is an island of two plains, around it is ocean.
*/
void test_create_world(void)
{
terrain_type *t_plain, *t_ocean;
region *island[2];
int i;
const char * names[] = { "horse", "horse_p", "boat", "boat_p", "iron", "iron_p", "stone", "stone_p" };
make_locale("de");
init_resources();
assert(!olditemtype[I_HORSE]);
olditemtype[I_HORSE] = test_create_itemtype(names+0);
olditemtype[I_IRON] = test_create_itemtype(names+4);
olditemtype[I_STONE] = test_create_itemtype(names+6);
t_plain = test_create_terrain("plain", LAND_REGION | FOREST_REGION | WALK_INTO | CAVALRY_REGION);
t_plain->size = 1000;
t_ocean = test_create_terrain("ocean", SEA_REGION | SAIL_INTO | SWIM_INTO);
t_ocean->size = 0;
island[0] = test_create_region(0, 0, t_plain);
island[1] = test_create_region(1, 0, t_plain);
for (i = 0; i != 2; ++i) {
int j;
region *r = island[i];
for (j = 0; j != MAXDIRECTIONS; ++j) {
region *rn = r_connect(r, (direction_t)j);
if (!rn) {
rn = test_create_region(r->x + delta_x[j], r->y + delta_y[j], t_ocean);
}
}
}
test_create_race("human");
test_create_buildingtype("castle");
test_create_shiptype(names+2);
}
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);
}
