21.strings.cpp

Go to the documentation of this file.

 
// expand _TEST_EXPORT macros
#define _RWSTD_TEST_SRC
 
#include <memory>         // for allocator
#include <string>         // for char_traits
 
#include <rw_strings.h>
#include <rw_cmdopt.h>      // for rw_enabled()
#include <rw_driver.h>      // for rw_info()
#include <rw_allocator.h>   // for UserAlloc
#include <rw_char.h>        // for rw_expand()
#include <rw_printf.h>      // for rw_asnprintf()
 
#include <ctype.h>          // for isdigit()
#include <stdarg.h>         // for va_arg, ...
#include <stddef.h>         // for size_t
#include <stdlib.h>         // for free()
#include <string.h>         // for memset()
 
 
static const char
_rw_this_file[] = __FILE__;
 
 
static const char* const
_rw_char_names[] = {
    "char", "wchar_t", "UserChar"
};
 
 
static const char* const
_rw_traits_names[] = {
    "char_traits", "UserTraits"
};
 
 
static const char* const
_rw_alloc_names[] = {
    "allocator", "UserAlloc"
};
 
 
static const char* const
_rw_iter_names[] = {
    "",
    "InputIterator", "ForwardIterator", "BidirectionalIterator",
    "RandomAccessIterator",
    "pointer", "const_pointer",
    "iterator", "const_iterator",
    "reverse_iterator", "const_reverse_iterator"
};
 
 
// order of elements depends on the values of StringIds::FuncId
static const char* const
_rw_func_names[] = {
    "append", "assign", "erase", "insert", "replace", "operator+=", "find", 
    "rfind", "find_first_of", "find_last_of", "find_first_not_of", 
    "find_last_not_of", "compare", "substr", "operator[]", "at", "copy",
    0 /* special handling for the ctor */, "operator=", "swap", "push_back",
    "operator+", "operator==", "operator!=", "operator<", "operator<=",
    "operator>", "operator>=", "size", "length", "max_size", "resize", 
    "capacity", "reserve", "clear", "empty", "begin", "end", "rbegin",
    "rend", "c_str", "data", "get_allocator", "operator>>", "operator<<",
    "getline"
};
 
 
const size_t MAX_OVERLOADS = 32;
 
// disabled (-1) or explicitly enabled (+1) for each overload
// of the string function being tested
static int
_rw_opt_func [MAX_OVERLOADS];
 
// array of tests each exercising a single string function
static const StringTest*
_rw_string_tests;
 
// size of the array above
static size_t
_rw_string_test_count;
 
static int
_rw_opt_char_types [sizeof _rw_char_names / sizeof *_rw_char_names];
 
static int
_rw_opt_traits_types [sizeof _rw_traits_names / sizeof *_rw_traits_names];
 
static int
_rw_opt_alloc_types [sizeof _rw_alloc_names / sizeof *_rw_alloc_names];
 
static int
_rw_opt_iter_types [sizeof _rw_iter_names / sizeof *_rw_iter_names];
 
static int
_rw_opt_no_exceptions;
 
static int
_rw_opt_no_exception_safety;
 
static int
_rw_opt_self_ref;
 
 
static size_t
_rw_get_func_inx (StringIds::OverloadId fid)
{
    size_t inx = _RWSTD_SIZE_MAX;
 
    for (size_t i = 0; _rw_string_test_count; ++i) {
        if (fid == _rw_string_tests [i].which) {
            inx = i;
            break;
        }
    }
 
    RW_ASSERT (inx < _RWSTD_SIZE_MAX);
 
    return inx;
}
 
 
int StringState::
assert_equal (const StringState &state, int line, int case_line,
              const char *when) const
{
    const int equal =
           data_ == state.data_
        && size_ == state.size_
        && capacity_ == state.capacity_;
 
    rw_assert (equal, 0, case_line,
               "line %d: %{$FUNCALL}: object state unexpectedly changed "
               "from { %#p, %zu, %zu } to { %#p, %zu, %zu } (data, size, "
               "capacity) after %s",
               line, data_, size_, capacity_,
               state.data_, state.size_, state.capacity_,
               when);
 
    return equal;
}
 
 
static const char*
_rw_class_name (const StringFunc &func)
{
    if (   StringIds::DefaultTraits == func.traits_id_
        && StringIds::DefaultAlloc == func.alloc_id_) {
 
        if (StringIds::Char == func.char_id_)
            return "string";
 
        if (StringIds::WChar == func.char_id_)
            return "wstring";
    }
 
    return "basic_string";
}
 
 
// appends the signature of the function specified by which
// to the provided buffer; when the second argument is null,
// appends the mnemonic representing the signature, including
// the name of the function, as specified by the third argument
static void
_rw_sigcat (char **pbuf, size_t *pbufsize,
            const StringFunc      *func,
            StringIds::OverloadId  which = StringIds::OverloadId ())
{
    // for convenience
    typedef StringIds Ids;
 
    if (func)
        which = func->which_;
 
    // determine whether the function is a member function
    const bool is_member = 0 != (Ids::bit_member & int (which));
 
    // get the bitmap describing the function's argument types
    int argmap = (~Ids::bit_member & int (which)) >> Ids::fid_bits;
 
    // determine whether the function is a const member function
    bool is_const_member =
        is_member && Ids::arg_cstr == (argmap & Ids::arg_mask);
 
    // remove the *this argument if the function is a member
    if (is_member)
        argmap >>= Ids::arg_bits;
 
    const char* funcname = 0;
 
    if (0 == func) {
        const int fid = StringIds::fid_mask & int (which);
 
        switch (fid) {
            // translate names with funky characters to mnemonics
        case Ids::fid_ctor:          funcname = "ctor"; break;
        case Ids::fid_op_plus_eq:    funcname = "op_plus_eq"; break;
        case Ids::fid_op_index:      funcname = "op_index"; break;
        case Ids::fid_op_set:        funcname = "op_assign"; break;
        case Ids::fid_op_plus:       funcname = "op_plus"; break;
        case Ids::fid_op_equal:      funcname = "op_equal"; break;
        case Ids::fid_op_not_equal:  funcname = "op_not_equal"; break;
        case Ids::fid_op_less:       funcname = "op_less"; break;
        case Ids::fid_op_less_equal: funcname = "op_less_equal"; break;
        case Ids::fid_op_greater:    funcname = "op_greater"; break;
        case Ids::fid_op_greater_equal: funcname = "op_greater_equal"; break;
        case Ids::fid_extractor:     funcname = "extractor"; break;
        case Ids::fid_inserter:      funcname = "inserter"; break;
 
        case Ids::fid_compare:
        case Ids::fid_copy:
        case Ids::fid_find:
        case Ids::fid_find_first_not_of:
        case Ids::fid_find_first_of:
        case Ids::fid_find_last_not_of:
        case Ids::fid_find_last_of:
        case Ids::fid_rfind:
        case Ids::fid_substr:
        case Ids::fid_c_str:
        case Ids::fid_data:
        case Ids::fid_get_allocator:
            // prevent appending the "_const" bit to the mnemonics
            // of member functions not overloaded on const
            is_const_member = false;
 
            // fall through
 
        default: {
            // determine the string function name (for brief output)
            const size_t nfuncs =
                sizeof _rw_func_names / sizeof *_rw_func_names;
 
            RW_ASSERT (size_t (fid) < nfuncs);
 
            funcname = _rw_func_names [fid];
            RW_ASSERT (0 != funcname);
            break;
        }
        }
    }
 
    // iterator name for member templates, empty string for other functions
    const char* const iname = func ? _rw_iter_names [func->iter_id_] : "";
 
    rw_asnprintf (pbuf, pbufsize,
                  "%{+}%{?}%s%{?}_const%{;}%{:}%{?}<%s>%{;}(%{;}",
                  0 == func, funcname, is_const_member, 0 != *iname, iname);
 
    char iname_buf [80];
    *iname_buf = '\0';
 
    // iterate through the map of argument types one field at a time
    // determining and formatting the type of each argument until
    // void is reached
    for (size_t argno = 0; argmap; ++argno, argmap >>= Ids::arg_bits) {
 
        const char* pfx = "";
        const char* sfx = "";
 
        const int argtype = argmap & Ids::arg_mask;
 
        const char* tname = 0;
 
        if (func) {
            switch (argtype) {
            case Ids::arg_size:  tname = "size_type"; break;
            case Ids::arg_val:   tname = "value_type"; break;
            case Ids::arg_ptr:   tname = "pointer"; break;
            case Ids::arg_cptr:  tname = "const_pointer"; break;
            case Ids::arg_ref:   tname = "reference"; break;
            case Ids::arg_cref:  tname = "const_reference"; break;
            case Ids::arg_iter:  tname = "iterator"; break;
            case Ids::arg_citer: tname = "const_iterator"; break;
            case Ids::arg_range:
                if ('\0' == *iname_buf) {
                    strcpy (iname_buf, iname);
                    strcat (iname_buf, ", ");
                    strcat (iname_buf, iname);
                }
                tname = iname_buf;
                break;
 
            case Ids::arg_alloc: tname = "const allocator_type&"; break;
            case Ids::arg_cstr:
                pfx   = "const ";
                // fall through
            case Ids::arg_str:
                tname = _rw_class_name (*func);
                sfx   = "&";
                break;
 
            case Ids::arg_istream: tname = "istream&"; break;
            case Ids::arg_ostream: tname = "ostream&"; break;
            }
        }
        else {
            switch (argtype) {
            case Ids::arg_size:  tname = "size"; break;
            case Ids::arg_val:   tname = "val"; break;
            case Ids::arg_ptr:   tname = "ptr"; break;
            case Ids::arg_cptr:  tname = "cptr"; break;
            case Ids::arg_ref:   tname = "ref"; break;
            case Ids::arg_cref:  tname = "cref"; break;
            case Ids::arg_iter:  tname = "iter"; break;
            case Ids::arg_citer: tname = "citer"; break;
            case Ids::arg_range: tname = "range"; break;
            case Ids::arg_alloc: tname = "alloc"; break;
            case Ids::arg_str:   tname = "str"; break;
            case Ids::arg_cstr:  tname = "cstr"; break;
            case Ids::arg_istream: tname = "istream"; break;
            case Ids::arg_ostream: tname = "ostream"; break;
            }
        }
 
        RW_ASSERT (0 != tname);
 
        if (   0 == func || is_member
            || Ids::arg_str != argtype && Ids::arg_cstr != argtype
            && Ids::arg_istream != argtype && Ids::arg_ostream != argtype) {
            // append the name or mnemonic of the argument type
            rw_asnprintf (pbuf, pbufsize, "%{+}%{?}_%{:}%{?}, %{;}%{;}%s%s%s",
                          0 == func, 0 < argno, pfx, tname, sfx);
        }
        else if (Ids::arg_istream == argtype || Ids::arg_ostream == argtype) {
            // in non-member functions use ${{I|O}STREAM} to format
            // the basic_{i|o}stream argument in order to expand
            // its template argument list
            rw_asnprintf (pbuf, pbufsize,
                "%{+}%{?}, %{;}%{?}%{$ISTREAM}%{:}%{$OSTREAM}%{;}&",
                0 < argno, Ids::arg_istream == argtype);
        }
        else {
            // in non-member functions use ${CLASS} to format
            // the basic_string argument in order to expand
            // its template argument list
            rw_asnprintf (pbuf, pbufsize,
                          "%{+}%{?}, %{;}%{?}const %{;}%{$CLASS}&",
                          0 < argno, Ids::arg_cstr == argtype);
            
        }
    }
 
    if (func)
        rw_asnprintf (pbuf, pbufsize, "%{+})%{?} const%{;}", is_const_member);
}
 
 
// returns the zero-based index of the argument type specified
// by arg in the function signature given by which
static int
_rw_argno (StringIds::OverloadId which, int arg)
{
    // get the bitmap describing the function's argument types
    int argmap = (which & ~StringIds::bit_member) >> StringIds::fid_bits;
 
    int argno = 0;
 
    // iterate over argument types looking for the first one
    // that equals arg
    for (; argmap; argmap >>= StringIds::arg_bits, ++argno) {
        if ((argmap & StringIds::arg_mask) == arg) {
            return argno;
        }
    }
 
    // return -1 when the function doesn't take an argument
    // of the specified type
    return -1;
}
 
 
_TEST_EXPORT void
rw_setvars (const StringFunc     &func,
            const StringTestCase *pcase /* = 0 */)
{
    char*  buf     = 0;
    size_t bufsize = 0;
 
    const char* const class_name = _rw_class_name (func);
 
    if (0 == pcase) {
        // set the {charT}, {Traits}, and {Allocator} environment
        // variables to the name of the character type and the
        // Traits and Allocator specializations
        rw_fprintf (0, "%{$charT!:*}", _rw_char_names [func.char_id_]);
 
        rw_fprintf (0, "%{$Traits!:*}", _rw_traits_names [func.traits_id_]);
 
        rw_fprintf (0, "%{$Allocator!:*}", _rw_alloc_names [func.alloc_id_]);
 
        rw_fprintf (0, "%{$Iterator!:*}", _rw_iter_names [func.iter_id_]);
 
        // set the {CLASS}, {FUNC}, and {FUNCSIG} environment variables
        // to the name of the specialization of the template, the name
        // of the string function, and the name of the overload of the
        // string function, respectively, when no test case is given
 
        if (   StringIds::DefaultTraits == func.traits_id_
            && StringIds::DefaultAlloc == func.alloc_id_
            && (   StringIds::Char == func.char_id_
                || StringIds::WChar == func.char_id_)) {
            // format std::string and std::wstring
            rw_asnprintf (&buf, &bufsize, "std::%{?}w%{;}string",
                          StringIds::WChar == func.char_id_);
        }
        else {
            // format std::basic_string specializations other than
            // std::string and std::wstring, leaving out the name
            // of the default allocator for brevity
            rw_asnprintf (&buf, &bufsize,
                          "std::basic_string<%s, %s<%1$s>%{?}, %s<%1$s>%{;}>",
                          _rw_char_names [func.char_id_],
                          _rw_traits_names [func.traits_id_],
                          StringIds::DefaultAlloc != func.alloc_id_,
                          _rw_alloc_names [func.alloc_id_]);
        }
 
        // set the {CLASS} variable to the name of the specialization
        // of basic_string
        rw_fprintf (0, "%{$CLASS!:*}", buf);
        free (buf);
        buf     = 0;
        bufsize = 0;
 
        // set the {ISTREAM} environment variable
        // to the name of the specialization of the template basic_istream
 
        if (   StringIds::DefaultTraits == func.traits_id_
            && (   StringIds::Char == func.char_id_
            || StringIds::WChar == func.char_id_)) {
                // format std::istream and std::wistream
                rw_asnprintf (&buf, &bufsize, "std::%{?}w%{;}istream",
                    StringIds::WChar == func.char_id_);
            }
        else {
            // format std::basic_istream specializations other than
            // std::istream and std::wistream
            rw_asnprintf (&buf, &bufsize,
                "std::basic_istream<%s, %s<%1$s>>",
                _rw_char_names [func.char_id_],
                _rw_traits_names [func.traits_id_]);
        }
 
        rw_fprintf (0, "%{$ISTREAM!:*}", buf);
        free (buf);
        buf     = 0;
        bufsize = 0;
 
        // set the {OSTREAM} environment variable
        // to the name of the specialization of the template basic_ostream
 
        if (   StringIds::DefaultTraits == func.traits_id_
            && (   StringIds::Char == func.char_id_
            || StringIds::WChar == func.char_id_)) {
                // format std::ostream and std::wostream
                rw_asnprintf (&buf, &bufsize, "std::%{?}w%{;}ostream",
                    StringIds::WChar == func.char_id_);
            }
        else {
            // format std::basic_ostream specializations other than
            // std::ostream and std::wostream
            rw_asnprintf (&buf, &bufsize,
                "std::basic_ostream<%s, %s<%1$s>>",
                _rw_char_names [func.char_id_],
                _rw_traits_names [func.traits_id_]);
        }
 
        rw_fprintf (0, "%{$OSTREAM!:*}", buf);
        free (buf);
        buf     = 0;
        bufsize = 0;
 
        // determine the string function name
        const size_t funcinx = StringIds::fid_mask & int (func.which_);
        const size_t nfuncs  = sizeof _rw_func_names / sizeof *_rw_func_names;
 
        RW_ASSERT (funcinx < nfuncs);
 
        // get the undecorated function name; ctors are treated
        // specially so that we can have string, wstring, or
        // basic_string, depending on the template arguments
        const char* const funcname = _rw_func_names [funcinx] ?
            _rw_func_names [funcinx] : class_name;
 
        // determine whether the function is a member function
        const bool is_member =
            0 != (StringIds::bit_member & int (func.which_));
 
        // set the {FUNC} variable to the unqualified/undecorated
        // name of the string function (member or otherwise)
        rw_asnprintf (&buf, &bufsize, "%{?}std::%{;}%s",
                      !is_member, funcname);
 
        rw_fprintf (0, "%{$FUNC!:*}", buf);
 
        // append the function signature
        _rw_sigcat (&buf, &bufsize, &func);
 
        rw_fprintf (0, "%{$FUNCSIG!:*}", buf);
        free (buf);
 
        return;
    }
 
    // do the function call arguments reference *this?
    const bool self = 0 == pcase->arg;
 
    char str_buf [256];
    char arg_buf [256];
    
    char *str;
    char *arg;
 
    size_t str_len = sizeof str_buf;
    size_t arg_len = sizeof arg_buf;
 
    if (pcase->str)
        str = rw_expand (str_buf, pcase->str, pcase->str_len, &str_len);
    else
        str = 0;
 
    if (pcase->arg)
        arg = rw_expand (arg_buf, pcase->arg, pcase->arg_len, &arg_len);
    else
        arg = 0;
 
    // determine whether the function is a member function
    const bool is_member =
        0 != (StringIds::bit_member & int (func.which_));
 
    // determine whether the function is a ctor
    const bool is_ctor =
        StringIds::fid_ctor == (StringIds::fid_mask & int (func.which_));
 
    if (is_ctor) {
        // for ctors append just the class name here
        // the class name will inserted below during argument
        // formatting
        rw_asnprintf (&buf, &bufsize, "%{$CLASS}::%s", class_name);
    }
    else if (is_member) {
        // for other members append the ctor argument(s) followed
        // by the string member function name
        rw_asnprintf (&buf, &bufsize,
                      "%{$CLASS} (%{?}%{#*s}%{;}).%{$FUNC}",
                      str != 0, int (str_len), str);
    }
    else {
        // for non-members append just the function name here
        // the class name will inserted below during argument
        // formatting
        rw_asnprintf (&buf, &bufsize, "%{$FUNC}");
    }
 
    // compute the end offsets for convenience
    const size_t range1_end = pcase->off + pcase->size;
    const size_t range2_end = pcase->off2 + pcase->size2;
 
    // determine whether the function takes an allocator_type argument
    const bool use_alloc = 0 < _rw_argno (func.which_, StringIds::arg_alloc);
 
    // format and append string function arguments abbreviating complex
    // expressions as much as possible to make them easy to understand
    switch (func.which_) {
    case StringIds::append_cptr:
    case StringIds::assign_cptr:
    case StringIds::op_plus_eq_cptr:
    case StringIds::find_cptr:
    case StringIds::rfind_cptr:
    case StringIds::find_first_of_cptr:
    case StringIds::find_last_of_cptr:
    case StringIds::find_first_not_of_cptr:
    case StringIds::find_last_not_of_cptr:
    case StringIds::compare_cptr:
    case StringIds::op_set_cptr:
    case StringIds::ctor_cptr:
    case StringIds::ctor_cptr_alloc:
        // format self-referential ptr argument without size as c_str()
        rw_asnprintf (&buf, &bufsize,
                      "%{+} (%{?}c_str()%{:}%{#*s}%{;}"
                      "%{?}, const allocator_type&%{;})",
                      self, int (arg_len), arg, use_alloc);
        break;
 
    case StringIds::append_cstr:
    case StringIds::assign_cstr:
    case StringIds::op_plus_eq_cstr:
    case StringIds::find_cstr:
    case StringIds::rfind_cstr:
    case StringIds::find_first_of_cstr:
    case StringIds::find_last_of_cstr:
    case StringIds::find_first_not_of_cstr:
    case StringIds::find_last_not_of_cstr:
    case StringIds::compare_cstr:
    case StringIds::ctor_cstr:
    case StringIds::op_set_cstr:
    case StringIds::swap_str:
        // format self-referential str argument as *this
        rw_asnprintf (&buf, &bufsize,
                      "%{+} (%{?}*this%{:}%s(%{#*s})%{;}"
                      "%{?}, const allocator_type&%{;})",
                      self, class_name, int (arg_len), arg, use_alloc);
        break;
 
    case StringIds::append_cptr_size:
    case StringIds::assign_cptr_size:
    case StringIds::copy_ptr_size:
    case StringIds::ctor_cptr_size:
    case StringIds::ctor_cptr_size_alloc:
        // format self-referential ptr argument with size as data()
        rw_asnprintf (&buf, &bufsize, "%{+} ("
                      "%{?}data()%{:}%{#*s}%{;}, %zu"
                      "%{?}, const allocator_type&%{;})",
                      self, int (arg_len), arg, pcase->size, use_alloc);
        break;
 
    case StringIds::find_cptr_size:
    case StringIds::rfind_cptr_size:
    case StringIds::find_first_of_cptr_size:
    case StringIds::find_last_of_cptr_size:
    case StringIds::find_first_not_of_cptr_size:
    case StringIds::find_last_not_of_cptr_size:
        // format self-referential ptr argument with size as data()
        rw_asnprintf (&buf, &bufsize, "%{+} ("
                      "%{?}data()%{:}%{#*s}%{;}, %zu)",
                      self, int (arg_len), arg, pcase->off);
        break;
 
    case StringIds::find_cstr_size:
    case StringIds::rfind_cstr_size:
    case StringIds::find_first_of_cstr_size:
    case StringIds::find_last_of_cstr_size:
    case StringIds::find_first_not_of_cstr_size:
    case StringIds::find_last_not_of_cstr_size:
    case StringIds::ctor_cstr_size:
    case StringIds::ctor_cstr_size_alloc:
        // format self-referential str argument as *this
        rw_asnprintf (&buf, &bufsize, "%{+} ("
                      "%{?}*this%{:}%s(%{#*s})%{;}, %zu"
                      "%{?}, const allocator_type%{;})",
                      self, class_name, int (arg_len), arg, pcase->off,
                      use_alloc);
        break;
 
    case StringIds::find_cptr_size_size:
    case StringIds::rfind_cptr_size_size:
    case StringIds::find_first_of_cptr_size_size:
    case StringIds::find_last_of_cptr_size_size:
    case StringIds::find_first_not_of_cptr_size_size:
    case StringIds::find_last_not_of_cptr_size_size:
        // format self-referential ptr argument with size as data()
        rw_asnprintf (&buf, &bufsize, "%{+} ("
                      "%{?}data()%{:}%{#*s}%{;}, %zu, %zu)",
                      self, int (arg_len), arg,
                      pcase->off, pcase->size);
        break;
 
    case StringIds::copy_ptr_size_size:
        // format self-referential ptr argument with size as data()
        rw_asnprintf (&buf, &bufsize, "%{+} ("
                      "%{?}data()%{:}%{#*s}%{;}, %zu, %zu)",
                      self, int (arg_len), arg,
                      pcase->size, pcase->off);
        break;
 
    case StringIds::append_cstr_size_size:
    case StringIds::assign_cstr_size_size:
    case StringIds::ctor_cstr_size_size:
    case StringIds::ctor_cstr_size_size_alloc:
        // format self-referential str argument as *this
        rw_asnprintf (&buf, &bufsize, "%{+} ("
                      "%{?}*this%{:}%s(%{#*s})%{;}, %zu, %zu"
                      "%{?}, const allocator_type%{;})",
                      self, class_name, int (arg_len), arg,
                      pcase->off, pcase->size, use_alloc);
        break;
 
    case StringIds::append_size_val:
    case StringIds::assign_size_val:
    case StringIds::ctor_size_val:
    case StringIds::ctor_size_val_alloc:
        rw_asnprintf (&buf, &bufsize,
                      "%{+} (%zu, %{#c}%{?}, const allocator_type&%{;})",
                      pcase->size, pcase->val, use_alloc);
        break;
 
    case StringIds::append_range:
    case StringIds::assign_range:
    case StringIds::ctor_range:
    case StringIds::ctor_range_alloc:
        rw_asnprintf (&buf, &bufsize, "%{+}<%{$Iterator:-Iterator}>("
                      "%{?}begin()%{:}%{$Iterator:-Iterator}(%{#*s})%{;}"
                      "%{?} + %zu%{;}, "
                      "%{?}begin()%{:}%{$Iterator:-Iterator}(...)%{;}"
                      "%{?} + %zu%{;}"
                      "%{?}, const allocator_type&%{;})",
                      self, int (arg_len), arg,
                      0 != pcase->off2, pcase->off2,
                      self, 0 != range2_end, range2_end, use_alloc);
        break;
 
    case StringIds::insert_size_cptr:
        // format self-referential ptr argument without size as c_str()
        rw_asnprintf (&buf, &bufsize, 
                      "%{+} (%zu, %{?}c_str()%{:}%{#*s}%{;})",
                      pcase->off, self, int (arg_len), arg);
        break;
 
    case StringIds::insert_size_cstr:
        // format self-referential str argument as *this
        rw_asnprintf (&buf, &bufsize,  
                      "%{+} (%zu, %{?}*this%{:}%s(%{#*s})%{;})",
                      pcase->off, self, class_name, int (arg_len), arg);
        break;
 
    case StringIds::insert_size_cptr_size:
        // format self-referential ptr argument with size as data()
        rw_asnprintf (&buf, &bufsize, "%{+} ("
                      "%zu, %{?}data()%{:}%{#*s}%{;}, %zu)", 
                      pcase->off, self, int (arg_len), arg,
                      pcase->size2);
        break;
 
    case StringIds::insert_size_cstr_size_size:
        // format self-referential str argument as *this
        rw_asnprintf (&buf, &bufsize, "%{+} ("
                      "%zu, %{?}*this%{:}%s(%{#*s})%{;}, %zu, %zu)",
                      pcase->off, self, class_name, int (arg_len), arg,
                      pcase->off2, pcase->size2);
        break;
 
    case StringIds::insert_size_size_val:
        rw_asnprintf (&buf, &bufsize,
                      "%{+} (%zu, %zu, %{#c})",
                      pcase->off, pcase->size2, pcase->val);
        break;
 
    case StringIds::insert_iter_val:
        rw_asnprintf (&buf, &bufsize,
                      "%{+} (begin()%{?} + %zu%{;}, %{#c})",
                      0 != pcase->off, pcase->off, pcase->val);
        break;
 
    case StringIds::insert_iter_size_val:
        rw_asnprintf (&buf, &bufsize,
                      "%{+} (begin()%{?} + %zu%{;}, %zu, %{#c})",
                      0 != pcase->off, pcase->off, pcase->size, pcase->val);
        break;
 
    case StringIds::insert_iter_range:
        rw_asnprintf (&buf, &bufsize, "%{+}<%{$Iterator:-Iterator}>"
                      "(begin()%{?} + %zu%{;}, "
                      "%{?}begin()%{:}%{$Iterator:-Iterator}(%{#*s})%{;}"
                      "%{?} + %zu%{;}, "
                      "%{?}begin()%{:}%{$Iterator:-Iterator}(...)"
                      "%{?} + %zu%{;})",
                      0 != pcase->off, pcase->off,
                      self, int (arg_len), arg,
                      0 != pcase->off2, pcase->off2,
                      self, 0 != range2_end, range2_end);
        break;
 
    case StringIds::replace_size_size_cptr:
    case StringIds::compare_size_size_cptr:
        // format self-referential ptr argument without size as c_str()
        rw_asnprintf (&buf, &bufsize, "%{+} ("
                      "%zu, %zu, %{?}c_str()%{:}%{#*s}%{;})",
                      pcase->off, pcase->size, self,
                      int (arg_len), arg);
        break;
 
    case StringIds::replace_size_size_cstr:
    case StringIds::compare_size_size_cstr:
        // format self-referential str argument as *this
        rw_asnprintf (&buf, &bufsize, "%{+} ("
                      "%zu, %zu, %{?}*this%{:}%s(%{#*s})%{;})",
                      pcase->off, pcase->size, self, class_name,
                      int (arg_len), arg);
        break;
 
    case StringIds::replace_size_size_cptr_size:
    case StringIds::compare_size_size_cptr_size:
        // format self-referential ptr argument with size as data()
        rw_asnprintf (&buf, &bufsize, "%{+} ("
                      "%zu, %zu, %{?}data()%{:}%{#*s}%{;}, %zu)", 
                      pcase->off, pcase->size, self,
                      int (arg_len), arg, pcase->size2);
        break;
 
    case StringIds::replace_size_size_cstr_size_size:
    case StringIds::compare_size_size_cstr_size_size:
        // format self-referential str argument as *this
        rw_asnprintf (&buf, &bufsize, "%{+} (%zu, %zu, "
                      "%{?}*this%{:}%s(%{#*s})%{;}, %zu, %zu)",
                      pcase->off, pcase->size,
                      self, class_name, int (arg_len), arg,
                      pcase->off2, pcase->size2);
        break;
 
    case StringIds::replace_size_size_size_val:
        rw_asnprintf (&buf, &bufsize, 
                      "%{+} (%zu, %zu, %zu, %{#c})",
                      pcase->off, pcase->size, pcase->size2, pcase->val);
        break;
 
    case StringIds::replace_iter_iter_cptr:
        // format self-referential ptr argument without size as c_str()
        rw_asnprintf (&buf, &bufsize, "%{+} (begin()%{?} + %zu%{;}, "
                      "begin()%{?} + %zu%{;}, "
                      "%{?}c_str()%{:}%{#*s}%{;})",
                      0 != pcase->off, pcase->off,
                      0 != range1_end, range1_end,
                      self, int (arg_len), arg);
        break;
 
    case StringIds::replace_iter_iter_cstr:
        // format self-referential str argument as *this
        rw_asnprintf (&buf, &bufsize, "%{+} (begin()%{?} + %zu%{;}, "
                      "begin()%{?} + %zu%{;}, "
                      "%{?}*this%{:}%s(%{#*s})%{;})",
                      0 != pcase->off, pcase->off,
                      0 != range1_end, range1_end,
                      self, class_name, int (arg_len), arg);
        break;
 
    case StringIds::replace_iter_iter_cptr_size:
        // format self-referential ptr argument with size as data()
        rw_asnprintf (&buf, &bufsize, "%{+} (begin()%{?} + %zu%{;}, "
                      "begin()%{?} + %zu%{;}, " 
                      "%{?}data()%{:}%{#*s}%{;}, %zu)", 
                      0 != pcase->off, pcase->off,
                      0 != range1_end, range1_end,
                      self, int (arg_len), arg, pcase->size2);
        break;
 
    case StringIds::replace_iter_iter_size_val:
        rw_asnprintf (&buf, &bufsize, 
                      "%{+} (begin()%{?} + %zu%{;}, begin()%{? + %zu%{;}, "
                      "%zu, %{#c})",
                      0 != pcase->off, pcase->off, 0 != range1_end, range1_end,
                      pcase->size2, pcase->val);
        break;
 
    case StringIds::replace_iter_iter_range:
        rw_asnprintf (&buf, &bufsize, "%{+}<%{$Iterator:-Iterator}>("
                      "begin()%{?} + %zu%{;}, "
                      "begin()%{?} + %zu%{;}, "
                      "%{?}begin()%{:}%{$Iterator:-Iterator}(%{#*s})%{;}"
                      "%{?} + %zu%{;}, "
                      "%{?}begin()%{:}%{$Iterator:-Iterator}(...)%{;}"
                      "%{?} + %zu%{;})",
                      0 != pcase->off, pcase->off,
                      0 != range1_end, range1_end,
                      self, int (arg_len), arg,
                      0 != pcase->off2, pcase->off2,
                      self, 0 != range2_end, range2_end);
        break;
 
    case StringIds::op_plus_eq_val:
    case StringIds::find_val:
    case StringIds::rfind_val:
    case StringIds::find_first_of_val:
    case StringIds::find_last_of_val:
    case StringIds::find_first_not_of_val:
    case StringIds::find_last_not_of_val:
    case StringIds::op_set_val:
    case StringIds::push_back_val:
        rw_asnprintf (&buf, &bufsize,
                      "%{+} (%{#c})", pcase->val);
        break;
 
    case StringIds::find_val_size:
    case StringIds::rfind_val_size:
    case StringIds::find_first_of_val_size:
    case StringIds::find_last_of_val_size:
    case StringIds::find_first_not_of_val_size:
    case StringIds::find_last_not_of_val_size:
        rw_asnprintf (&buf, &bufsize,
                      "%{+} (%{#c}, %zu)", pcase->val, pcase->off);
        break;
 
    case StringIds::erase_void:
    case StringIds::substr_void:
    case StringIds::ctor_void:
    case StringIds::size_void:
    case StringIds::length_void:
    case StringIds::max_size_void:
    case StringIds::capacity_void:
    case StringIds::reserve_void:
    case StringIds::clear_void:
    case StringIds::empty_void:
    case StringIds::begin_void:
    case StringIds::end_void:
    case StringIds::rbegin_void:
    case StringIds::rend_void:
    case StringIds::c_str_void:
    case StringIds::data_void:
    case StringIds::get_allocator_void:
        rw_asnprintf (&buf, &bufsize,
                      "%{+} ()");
        break;
 
    case StringIds::begin_const_void:
    case StringIds::end_const_void:
    case StringIds::rbegin_const_void:
    case StringIds::rend_const_void:
        rw_asnprintf (&buf, &bufsize,
            "%{+} () const");
        break;
 
    case StringIds::ctor_alloc:
        rw_asnprintf (&buf, &bufsize,
                      "%{+} (const allocator_type&)");
        break;
        
    case StringIds::erase_size:
    case StringIds::substr_size:
    case StringIds::op_index_size:
    case StringIds::at_size:
        rw_asnprintf (&buf, &bufsize,
                      "%{+} (%zu)", pcase->off);
        break;
 
    case StringIds::op_index_const_size:
    case StringIds::at_const_size:
        rw_asnprintf (&buf, &bufsize,
                      "%{+} (%zu) const", pcase->off);
        break;
 
    case StringIds::erase_size_size:
    case StringIds::substr_size_size:
        rw_asnprintf (&buf, &bufsize,
                      "%{+} (%zu, %zu)", pcase->off, pcase->size);
        break;
 
    case StringIds::erase_iter:
        rw_asnprintf (&buf, &bufsize,
                      "%{+} (begin()%{?} + %zu%{;})",
                      0 != pcase->off, pcase->off);
        break;
 
    case StringIds::erase_iter_iter:
        rw_asnprintf (&buf, &bufsize,
                      "%{+} (begin()%{?} + %zu%{;}, begin()%{?} + %zu%{;})", 
                      0 != pcase->off, pcase->off,
                      0 != range1_end, range1_end);
        break;
 
    case StringIds::op_plus_cptr_cstr:
    case StringIds::op_equal_cptr_cstr:
    case StringIds::op_not_equal_cptr_cstr:
    case StringIds::op_less_cptr_cstr:
    case StringIds::op_less_equal_cptr_cstr:
    case StringIds::op_greater_cptr_cstr:
    case StringIds::op_greater_equal_cptr_cstr:
        // format zero ptr argument without size as arg.c_str()
        rw_asnprintf (&buf, &bufsize,
                      "%{+} (%{?}arg2.c_str()%{:}%{#*s}%{;}, "
                      "%{$CLASS}(%{#*s}))",
                      0 == str, int (str_len), str, int (arg_len), arg);
        break;
 
    case StringIds::op_plus_cstr_cptr:
    case StringIds::op_equal_cstr_cptr:
    case StringIds::op_not_equal_cstr_cptr:
    case StringIds::op_less_cstr_cptr:
    case StringIds::op_less_equal_cstr_cptr:
    case StringIds::op_greater_cstr_cptr:
    case StringIds::op_greater_equal_cstr_cptr:
        // format zero ptr argument without size as arg.c_str()
        rw_asnprintf (&buf, &bufsize,
                      "%{+} (%{$CLASS}(%{#*s}), "
                      "%{?}arg1.c_str()%{:}%{#*s}%{;})",
                      int (str_len), str, self, int (arg_len), arg);
        break;
 
    case StringIds::op_plus_cstr_cstr:
    case StringIds::op_equal_cstr_cstr:
    case StringIds::op_not_equal_cstr_cstr:
    case StringIds::op_less_cstr_cstr:
    case StringIds::op_less_equal_cstr_cstr:
    case StringIds::op_greater_cstr_cstr:
    case StringIds::op_greater_equal_cstr_cstr:
        // format zero str argument without size as arg
        rw_asnprintf (&buf, &bufsize,
                      "%{+} (%{?}arg2%{:}%{$CLASS}(%{#*s})%{;}, "
                      "%{?}arg1%{:}%{$CLASS}(%{#*s})%{;})",
                      0 == str, int (str_len), str, self, int (arg_len), arg);
        break;
 
    case StringIds::op_plus_cstr_val:
        rw_asnprintf (&buf, &bufsize,
                      "%{+} (%{$CLASS}(%{#*s}), %{#c})",
                      int (arg_len), arg, pcase->val);
        break;
 
    case StringIds::op_plus_val_cstr:
        rw_asnprintf (&buf, &bufsize,
                      "%{+} (%{#c}, %{$CLASS}(%{#*s}))",
                      pcase->val, int (arg_len), arg);
        break;
 
    case StringIds::extractor_istream_str:
    case StringIds::getline_istream_str:
        rw_asnprintf (&buf, &bufsize,
                      "%{+} (%{$ISTREAM}&, %{$CLASS}(%{?}%{#*s}%{;}))",
                      0 < str_len, int (str_len), str);
        break;
 
    case StringIds::getline_istream_str_val:
        rw_asnprintf (&buf, &bufsize,
                      "%{+} (%{$ISTREAM}&, %{$CLASS}(%{?}%{#*s}%{;}), %{#c})",
                      0 < str_len, int (str_len), str, pcase->val);
        break;
 
    case StringIds::inserter_ostream_cstr:
        rw_asnprintf (&buf, &bufsize,
                      "%{+} (%{$OSTREAM}&, %{$CLASS}(%{?}%{#*s}%{;}))",
                      0 < str_len, int (str_len), str);
        break;
 
    case StringIds::resize_size_val:
        rw_asnprintf (&buf, &bufsize,
                      "%{+} (%zu, %{#c})", pcase->size, pcase->val);
        break;
 
    case StringIds::resize_size:
    case StringIds::reserve_size:
        rw_asnprintf (&buf, &bufsize,
                      "%{+} (%zu)", pcase->size);
        break;
 
    default:
        RW_ASSERT (!"test logic error: unknown overload");
    }
 
    rw_fprintf (0, "%{$FUNCALL!:*}", buf);
    free (buf);
 
    if (str != str_buf)
        delete[] str;
 
    if (arg != arg_buf)
        delete[] arg;
}
 
 
// helper function to reverse substring in the resulting sequence
_RWSTD_INTERNAL StringTestCase
_rw_reverse_results (const StringTestCase &tsrc,
                     size_t off, size_t ext)
{
    // expand expected results
    size_t res_len = 0;
    char* const new_res = rw_expand ((char*)0, tsrc.res, tsrc.nres, &res_len);
 
    // reverse them
    const size_t res_off = off;
    const size_t res_ext = (ext < res_len ? ext : res_len) - 1;
 
    char* beg = new_res + res_off;
    char* end = beg + res_ext;
 
    for (; beg < end; ++beg, --end) {
        const char tmp = *beg;
        *beg = *end;
        *end = tmp;
    }
 
    // form new test case
    const StringTestCase new_case = {
        tsrc.line, tsrc.off, tsrc.size, tsrc.off2,
        tsrc.size2, tsrc.val, tsrc.str, tsrc.str_len,
        tsrc.arg, tsrc.arg_len, new_res, res_len, tsrc.bthrow
    };
 
    return new_case;
}
 
 
template <class charT, class Traits, class Allocator>
void
_rw_dispatch (charT*, Traits*, Allocator*,
              VoidFunc* const      *farray,
              const StringFunc     &func,
              const StringTestCase &tcase)
{
    typedef StringTestCaseData<charT> Data;
    typedef void TestFunc (charT*, Traits*, Allocator*, const Data&);
 
    const size_t inx = func.char_id_ * 4 + func.traits_id_ * 2 + func.alloc_id_;
 
    TestFunc* const tfunc = _RWSTD_REINTERPRET_CAST (TestFunc*, farray [inx]);
 
    if (0 == tfunc) {
        rw_error (0, __FILE__, __LINE__,
                  "logic error: null test function for %{$FUNCSIG}");
        return;
    }
 
    const bool reverse_iter =
           StringIds::ReverseIterator == func.iter_id_ 
        || StringIds::ConstReverseIterator == func.iter_id_;
 
    const Data tdata (func, tcase);
 
    if (reverse_iter) {
        // special processing for reverse iterators
 
        const size_t func_id = StringIds::fid_mask & int (tdata.func_.which_);
 
        const bool like_ctor =    StringIds::fid_ctor == func_id 
                               || StringIds::fid_assign == func_id;
 
        // ctor and assignment operator require the full string reverse
        const size_t off = like_ctor ? 0 : tdata.off1_;
        const size_t ext = like_ctor ? tdata.reslen_ : tdata.ext2_;
 
        const StringTestCase rev_tcase =
            ::_rw_reverse_results (tcase, off, ext);
 
        const Data rev_tdata (func, rev_tcase);
 
        tfunc ((charT*)0, (Traits*)0, (Allocator*)0, rev_tdata);
 
        // clean up allocated memory, if any
        delete[] rev_tcase.res;
    }
    else
        tfunc ((charT*)0, (Traits*)0, (Allocator*)0, tdata);
}
 
 
template <class charT, class Traits>
void
_rw_dispatch (charT*, Traits*,
              VoidFunc* const      *farray,
              const StringFunc     &func,
              const StringTestCase &tcase)
{
    if (StringIds::DefaultAlloc == func.alloc_id_) {
        typedef std::allocator<charT> Alloc;
        _rw_dispatch ((charT*)0, (Traits*)0, (Alloc*)0, farray, func, tcase);
    }
    else if (StringIds::UserAlloc == func.alloc_id_) {
        typedef UserAlloc<charT> Alloc;
        _rw_dispatch ((charT*)0, (Traits*)0, (Alloc*)0, farray, func, tcase);
    }
    else {
        RW_ASSERT (!"logic error: unknown Allocator argument");
    }
}
 
 
template <class charT>
void
_rw_dispatch (charT*,
              VoidFunc* const     *farray,
              const StringFunc     &func,
              const StringTestCase &tcase)
{
    if (StringIds::DefaultTraits == func.traits_id_) {
        typedef std::char_traits<charT> Traits;
        _rw_dispatch ((charT*)0, (Traits*)0, farray, func, tcase);
    }
    else if (StringIds::UserTraits == func.traits_id_) {
        typedef UserTraits<charT> Traits;
        _rw_dispatch ((charT*)0, (Traits*)0, farray, func, tcase);
    }
    else {
        RW_ASSERT (!"logic error: unknown Traits argument");
    }
 
}
 
 
static void
_rw_dispatch (VoidFunc* const      *farray,
              const StringFunc     &func,
              const StringTestCase &tcase)
{
    if (StringIds::Char == func.char_id_) {
        _rw_dispatch ((char*)0, farray, func, tcase);
    }
    else if (StringIds::WChar == func.char_id_) {
        _rw_dispatch ((wchar_t*)0, farray, func, tcase);
    }
    else if (StringIds::UChar == func.char_id_) {
        if (StringIds::DefaultTraits == func.traits_id_) {
            RW_ASSERT (!"logic error: std::char_traits<UserChar> not allowed");
        }
        else if (StringIds::UserTraits == func.traits_id_) {
            typedef UserTraits<UserChar> Traits;
            _rw_dispatch ((UserChar*)0, (Traits*)0, farray, func, tcase);
        }
    }
    else {
        RW_ASSERT (!"logic error: unknown charT argument");
    }
}
 
 
// exercise a single test case for the given function
static void
_rw_test_case (const StringFunc     &func,
               const StringTestCase &tcase,
               StringTestFunc       *test_callback,
               VoidFunc* const      *farray)
{
    // check to see if this is an exception safety test case
    // and avoid running it when exception safety has been
    // disabled via a command line option
    if (-1 == tcase.bthrow && _rw_opt_no_exception_safety) {
 
        // issue only the first note
        rw_note (1 < _rw_opt_no_exception_safety++, _rw_this_file, __LINE__,
                 "exception safety tests disabled");
        return;
    }
 
    // check to see if this is a test case that involves the throwing
    // of an exception and avoid running it when exceptions have been
    // disabled
    if (tcase.bthrow && _rw_opt_no_exceptions) {
 
        // issue only the first note
        rw_note (1 < _rw_opt_no_exceptions++, _rw_this_file, __LINE__,
                 "exception tests disabled");
        return;
    }
 
    const bool self_ref = 0 == tcase.arg;
 
    // check for tests exercising self-referential modifications
    // (e.g., insert(1, *this))
    if (_rw_opt_self_ref < 0 && self_ref) {
        // issue only the first note
        rw_note (0, _rw_this_file, tcase.line,
                 "self-referential test disabled");
        return;
    }
    else if (0 < _rw_opt_self_ref && !self_ref) {
        // issue only the first note
        rw_note (0, _rw_this_file, tcase.line,
                 "non-self-referential test disabled");
        return;
    }
 
    // check to see if the test case is enabled
    if (rw_enabled (tcase.line)) {
 
        // set the {FUNCALL} environment variable to describe
        // the function call specified by this test case
        rw_setvars (func, &tcase);
 
        if (test_callback) {
            // invoke the test callback function
            test_callback (func, tcase);
        }
        else {
            _rw_dispatch (farray, func, tcase);
        }
    }
    else
        rw_note (0, _rw_this_file, tcase.line,
                 "test on line %d disabled", tcase.line);
}
 
 
static StringTestFunc*
_rw_test_callback;
 
 
static VoidFunc* const*
_rw_func_array;
 
 
// exercise all test cases defined for the given function
static void
_rw_run_cases (const StringFunc &func,
               const StringTest &test)
{
    // set the {CLASS}, {FUNC}, and {FUNCSIG} environment
    // variable to the name of the basic_string specializaton
    // and the string function being exercised
    rw_setvars (func);
 
    // determine whether the function is a member function
    const bool is_member = 0 != (StringIds::bit_member & int (test.which));
 
    // compute the function overload's 0-based index
    const size_t siginx = _rw_get_func_inx (test.which);
 
    // check if tests of the function overload
    // have been disabled
    if (0 == rw_note (0 <= _rw_opt_func [siginx], _rw_this_file, __LINE__,
                      "%{?}%{$CLASS}::%{;}%{$FUNCSIG} tests disabled",
                      is_member))
        return;
 
    rw_info (0, 0, 0, "%{?}%{$CLASS}::%{;}%{$FUNCSIG}", is_member);
 
    const size_t case_count = test.case_count;
 
    // iterate over all test cases for this function
    // overload invoking the test case handler for each
    // in turn
    for (size_t n = 0; n != case_count; ++n) {
 
        const StringTestCase& tcase = test.cases [n];
 
        _rw_test_case (func, tcase,  _rw_test_callback, _rw_func_array);
    }
}
 
 
static void
_rw_toggle_options (int *opts, size_t count)
{
    for (size_t i = 0; i != count; ++i) {
        if (0 < opts [i]) {
            // if one or more options has been explicitly enabled
            // treat all those that haven't been as if they had
            // been disabled
            for (i = 0; i != count; ++i) {
                if (0 == opts [i])
                    opts [i] = -1;
            }
            break;
        }
    }
}
 
 
static int
_rw_run_test (int, char*[])
{
#ifdef _RWSTD_NO_EXCEPTIONS
 
    rw_note (0, 0, 0, "exception tests disabled (macro "
             "_RWSTD_NO_EXCEPTIONS #defined)");
 
    // disable all exception tests and avoid further notes
    _rw_no_exceptions       = 2;
    _rw_no_exception_safety = 2;
 
#endif   // _RWSTD_NO_EXCEPTIONS
 
#ifdef _RWSTD_NO_WCHAR_T
 
    rw_note (0, 0, 0, "wchar_t tests disabled (macro "
             "_RWSTD_NO_WCHAR_T #defined)");
 
    // disable wchar_t tests and avoid further notes
    _rw_opt_char_types [StringIds::WChar] = -2;
 
#endif   // _RWSTD_NO_WCHAR_T
 
    // see if any option controlling a string function has been
    // explicitly enabled and if so disable all those that haven't
    // been (i.e., so that --enable-foo-size will have the effect
    // of specifying --disable-foo-val and --disable-foo-range,
    // given the three overloads of foo)
    const size_t nopts = sizeof _rw_opt_func / sizeof *_rw_opt_func;
    _rw_toggle_options (_rw_opt_func, nopts);
 
    static const StringIds::CharId char_types[] = {
        StringIds::Char, StringIds::WChar, StringIds::UChar
    };
 
    static const StringIds::TraitsId traits_types[] = {
        StringIds::DefaultTraits, StringIds::UserTraits
    };
 
    static const StringIds::AllocId alloc_types[] = {
        StringIds::DefaultAlloc, StringIds::UserAlloc
    };
 
    static const StringIds::IteratorId iter_types[] = {
        StringIds::Input, StringIds::Forward,
        StringIds::Bidir, StringIds::Random,
        StringIds::Pointer, StringIds::ConstPointer,
        StringIds::Iterator, StringIds::ConstIterator,
        StringIds::ReverseIterator, StringIds::ConstReverseIterator
    };
 
    const size_t n_char_types   = sizeof char_types / sizeof *char_types;
    const size_t n_traits_types = sizeof traits_types / sizeof *traits_types;
    const size_t n_alloc_types  = sizeof alloc_types / sizeof *alloc_types;
    const size_t n_iter_types   = sizeof iter_types / sizeof *iter_types;
 
    // see if any option controlling the basic_string template arguments
    // explicitly enabled and if so disable all those that haven't been
    _rw_toggle_options (_rw_opt_char_types, n_char_types);
    _rw_toggle_options (_rw_opt_traits_types, n_traits_types);
    _rw_toggle_options (_rw_opt_alloc_types, n_alloc_types);
    _rw_toggle_options (_rw_opt_iter_types, n_iter_types);
 
    // exercise different charT specializations last
    for (size_t i = 0; i != n_char_types; ++i) {
 
        if (_rw_opt_char_types [i] < 0) {
            // issue only the first note
            rw_note (-1 > _rw_opt_char_types [i]--,
                     _rw_this_file, __LINE__,
                     "%s tests disabled", _rw_char_names [i]);
            continue;
        }
 
        // exercise all specializations on Traits before those on charT
        for (size_t j = 0; j != n_traits_types; ++j) {
 
            if (0 == j && StringIds::UChar == char_types [i]) {
                // std::char_traits can only be instantiated on
                // char and wchar_t, only UserTraits may be used
                // with UserChar
                continue;
            }
 
            if (_rw_opt_traits_types [j] < 0) {
                // issue only the first note
                rw_note (-1 > _rw_opt_traits_types [j]--,
                         _rw_this_file, __LINE__,
                         "%s tests disabled", _rw_traits_names [j]);
                continue;
            }
 
            for (size_t k = 0; k != n_alloc_types; ++k) {
 
                if (_rw_opt_alloc_types [k] < 0) {
                    // issue only the first note
                    rw_note (-1 > _rw_opt_alloc_types [k]--,
                             _rw_this_file, __LINE__,
                             "%s tests disabled", _rw_alloc_names [k]);
                    continue;
                }
 
                for (size_t m = 0; m != _rw_string_test_count; ++m) {
 
                    const StringTest& test = _rw_string_tests [m];
 
                    // create an object uniquely identifying the overload
                    // of the string function exercised by the set of test
                    // cases defined to exercise it
                    StringFunc func = {
                        char_types [i],
                        traits_types [j],
                        alloc_types [k],
                        StringIds::None,
                        test.which
                    };
 
                    // determine whether the function is a template
                    if (-1 < _rw_argno (test.which, StringIds::arg_range)) {
 
                        // iterate over the standard iterator categories
                        // and iterator types the template might perhaps
                        // be specialized on
                        for (size_t l = 0; l != n_iter_types; ++l) {
 
                            if (_rw_opt_iter_types [l] < 0) {
                                // issue only the first note
                                rw_note (-1 > _rw_opt_iter_types [l]--,
                                         _rw_this_file, __LINE__,
                                         "%s tests disabled",
                                         _rw_iter_names [l]);
                                continue;
                            }
 
                            func.iter_id_ = iter_types [l];
 
                            // exercise all test cases defined for
                            // the function template
                            _rw_run_cases (func, test);
                        }
                    }
                    else {
                        // exercise all test cases defined for the ordinary
                        // (i.e., non-template) function
                        _rw_run_cases (func, test);
                    }
                }
            }
        }
    }
 
    return 0;
}
 
 
// add a bunch of toggle-type command line options based on the names array
static void
_rw_add_toggles (char **pbuf, size_t *pbufsize,
                 const char* const names[], size_t count)
{
    for (size_t i = 0; i != count; ++i) {
        rw_asnprintf (pbuf, pbufsize, "%{+}|-%s~ ", names [i]);
    }
}
 
 
static int
_rw_run_test  (int               argc,
               char             *argv [],
               const char       *file,
               const char       *clause,
               StringTestFunc   *test_callback,
               VoidFunc* const  *func_array,
               const StringTest *tests,
               size_t            test_count)
{
    // set the global variables accessed in _rw_run_test
    _rw_test_callback     = test_callback;
    _rw_func_array        = func_array,
    _rw_string_tests      = tests;
    _rw_string_test_count = test_count;
 
    // put together a command line option specification with options
    // to enable and disable tests exercising functions for all known
    // specializations of the functions specified by the test array
    char   *optbuf     = 0;
    size_t  optbufsize = 0;
 
    rw_asnprintf (&optbuf, &optbufsize,
                  "|-no-exceptions# "
                  "|-no-exception-safety# "
                  "|-self-ref~ ");
 
    const size_t n_chars  = sizeof _rw_char_names / sizeof *_rw_char_names;
    const size_t n_traits = sizeof _rw_traits_names / sizeof *_rw_traits_names;
    const size_t n_allocs = sizeof _rw_alloc_names / sizeof *_rw_alloc_names;
    const size_t n_iters  = sizeof _rw_iter_names / sizeof *_rw_iter_names;
 
    // see if any option has been explicitly enabled and if so,
    // uncodnitionally disable all those that have not been
    _rw_add_toggles (&optbuf, &optbufsize, _rw_char_names, n_chars);
    _rw_add_toggles (&optbuf, &optbufsize, _rw_traits_names, n_traits);
    _rw_add_toggles (&optbuf, &optbufsize, _rw_alloc_names, n_allocs);
    _rw_add_toggles (&optbuf, &optbufsize, _rw_iter_names + 1, n_iters - 1);
 
    for (size_t i = 0; i != test_count; ++i) {
 
        // for each function append a command line option specification
        // to allow to enable or disable it
        rw_asnprintf (&optbuf, &optbufsize, "%{+}|-");
        _rw_sigcat (&optbuf, &optbufsize, 0, tests [i].which);
        rw_asnprintf (&optbuf, &optbufsize, "%{+}~ ");
    }
 
    RW_ASSERT (test_count <= 32);
    RW_ASSERT (test_count <= MAX_OVERLOADS);
 
    // process command line arguments run tests
    const int status =
        rw_test (argc, argv, file, clause,
                 0,              // comment
                 _rw_run_test,   // test callback
                 optbuf,         // option specification
 
                 // handlers controlling exceptions
                 &_rw_opt_no_exceptions,
                 &_rw_opt_no_exception_safety,
 
                 // handler controlling self-referential modifiers
                 &_rw_opt_self_ref,
 
                 // handlers controlling specializations of the template
                 // ...on the charT template parameter
                 _rw_opt_char_types + 0,
                 _rw_opt_char_types + 1,
                 _rw_opt_char_types + 2,
 
                 // ...on the Traits template parameter
                 _rw_opt_traits_types + 0,
                 _rw_opt_traits_types + 1,
 
                 // ...on the Allocator template parameter
                 _rw_opt_alloc_types + 0,
                 _rw_opt_alloc_types + 1,
 
                 // FIXME: add handlers (and options) only for tests
                 // that exercise member templates
 
                 // handlers controlling specializations of the member
                 // template (if this is one) on the InputIterator
                 // template parameter
                 _rw_opt_iter_types + 0,
                 _rw_opt_iter_types + 1,
                 _rw_opt_iter_types + 2,
                 _rw_opt_iter_types + 3,
                 _rw_opt_iter_types + 4,
                 _rw_opt_iter_types + 5,
                 _rw_opt_iter_types + 6,
                 _rw_opt_iter_types + 7,
                 _rw_opt_iter_types + 8,
                 _rw_opt_iter_types + 9,
 
                 // FIXME: install exactly as many handlers (and options)
                 // as there are distinct functions being exercised
 
                 // handlers for up to 32 overloads
                 _rw_opt_func +  0,
                 _rw_opt_func +  1,
                 _rw_opt_func +  2,
                 _rw_opt_func +  3,
                 _rw_opt_func +  4,
                 _rw_opt_func +  5,
                 _rw_opt_func +  6,
                 _rw_opt_func +  7,
                 _rw_opt_func +  8,
                 _rw_opt_func +  9,
                 _rw_opt_func + 10,
                 _rw_opt_func + 11,
                 _rw_opt_func + 12,
                 _rw_opt_func + 13,
                 _rw_opt_func + 14,
                 _rw_opt_func + 15,
                 _rw_opt_func + 16,
                 _rw_opt_func + 17,
                 _rw_opt_func + 18,
                 _rw_opt_func + 19,
                 _rw_opt_func + 20,
                 _rw_opt_func + 21,
                 _rw_opt_func + 22,
                 _rw_opt_func + 23,
                 _rw_opt_func + 24,
                 _rw_opt_func + 25,
                 _rw_opt_func + 26,
                 _rw_opt_func + 27,
                 _rw_opt_func + 28,
                 _rw_opt_func + 29,
                 _rw_opt_func + 30,
                 _rw_opt_func + 31,
 
                 // sentinel
                 (void*)0);
 
    // free storage allocated for the option specification
    free (optbuf);
 
    return status;
}   
 
 
 
_TEST_EXPORT int
rw_run_string_test (int               argc,
                    char             *argv [],
                    const char       *file,
                    const char       *clause,
                    StringTestFunc   *callback,
                    const StringTest *tests,
                    size_t            count)
{
    return _rw_run_test (argc, argv, file, clause, callback, 0, tests, count);
}
 
 
_TEST_EXPORT int
rw_run_string_test (int               argc,
                    char             *argv [],
                    const char       *file,
                    const char       *clause,
                    VoidFunc* const  *farray,
                    const StringTest *tests,
                    size_t            count)
{
    return _rw_run_test (argc, argv, file, clause, 0, farray, tests, count);
}