0.ctype.cpp

Go to the documentation of this file.

 
#include <rw_char.h>     // for UserChar
#include <rw_ctype.h>    // for UserCtype
#include <rw_printf.h>   // for rw_printf
#include <rw_driver.h>
 
#include <stdlib.h>      // for free()
#include <string.h>      // for memset(), size_t, strlen()
 
 
extern const char
cntrl[] = {
 
#if 'A' == 0x41   // ASCII
    "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
    "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\x7f"
#elif 'A' == 0xc1   // EBCDIC
    ""
#endif
 
};
 
extern const std::size_t
n_cntrl = sizeof cntrl - 1;
 
extern const char
digits[] = "0123456789";
 
extern const std::size_t
n_digits = sizeof digits - 1;
 
extern const char
graph[] = "!\"#$%&\\()*+,-./0123456789:;<=>?@[]^_`{|}~";
 
extern const std::size_t
n_graph = sizeof graph - 1;
 
extern const char
lower[] = "abcdefghijklmnopqrstuvwxyz";
 
extern const std::size_t
n_lower = sizeof lower - 1;
 
extern const char
punct[] = "!#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~";
 
extern const std::size_t
n_punct = sizeof punct - 1;
 
extern const char
print[] = {
    "!\"#$%&\\()*+,-./0123456789:;<=>?@[]^_`{|}~"
    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "abcdefghijklmnopqrstuvwxyz"
};
 
extern const std::size_t
n_print = sizeof print - 1;
 
extern const char
spaces[] = " \t\v\f\r\n";
 
extern const std::size_t
n_spaces = sizeof spaces - 1;
 
extern const char
upper[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 
extern const std::size_t
n_upper = sizeof upper - 1;
 
extern const char
xdigits[] = "0123456789ABCDEFabcdef";
 
extern const std::size_t
n_xdigits = sizeof xdigits - 1;
 
 
template <class charT>
void
test_id (charT*, const char *cname)
{
    rw_info (0, 0, __LINE__, "UserCtype<%s>::id", cname);
 
    std::locale::id* const pid_b = &std::ctype<charT>::id;
    std::locale::id* const pid_d = &UserCtype<charT>::id;
 
    rw_assert (pid_b == pid_d, 0, __LINE__,
               "&ctype<%s>::id == &UserCtype<%1$s>::id "
               "(%#p == %2$#p, got %#p)",
               cname, pid_b, pid_d);
}
 
 
template <class charT>
void
test_is (charT*, const char *cname,
         std::ctype_base::mask m,
         const char *chars, std::size_t n_chars)
{
    UserCtype<charT> ctp;
 
    std::size_t n_calls  = ctp.n_calls_ [ctp.mf_is];
    std::size_t n_throws = ctp.n_throws_ [ctp.mf_is];
 
    std::size_t expect_calls  = 0;
    std::size_t expect_throws = 0;
 
    for (std::size_t i = 0; i != n_chars; ++i) {
        const charT ch = make_char (chars [i], (charT*)0);
 
        unsigned result = -1;
 
#ifndef _RWSTD_NO_EXCEPTIONS
 
        // let the first call call succeed and trigger an exception
        // on the second call to UserCtype::is()
        ctp.throw_at_calls_ [ctp.mf_is] =
            ctp.n_calls_ [ctp.mf_is] + 2;
 
        for (int j = 0; j != 2; ++j) {
 
            if (1 < sizeof (charT)) {
                // can only count UserCtype<charT>::is() calls when
                // charT != char since there is no virtual do_is()
                // in the char explicit specialization
                ++expect_calls;
            }
            else if (j) {
                // cannot induce an exception out of UserCtype<char>::is()
                // since there is no virtual do_is() in the specialization
                break;
            }
 
            if (j)
                ++expect_throws;
 
            unsigned threw = 0;
 
            try {
                result = ctp.is (m, ch);
            }
            catch (...) {
                threw = 1;
            }
 
            rw_assert (j == threw, 0, __LINE__,
                       "UserCtype<%s>::is(%{LC}, %{#c}) "
                       "%{?}unexpectedly threw%{:}failed to throw%{;}",
                       cname, m, ch, j == threw);
        }
 
#else   // if defined (_RWSTD_NO_EXCEPTIONS)
 
        ++expect_calls;
        result = ctp.is (m, ch);
 
#endif   // _RWSTD_NO_EXCEPTIONS
 
        rw_assert (result, 0, __LINE__,
                   "UserCtype<%s>::is(%{LC}, %{#c}) == true",
                   cname, m, chars [i]);
    }
 
    n_calls = ctp.n_calls_ [ctp.mf_is] - n_calls;
 
    rw_assert (expect_calls == n_calls, 0, __LINE__,
               "expected %zu calls to UserCtype<%s>::is(%{LC}, char_type), "
               "got %zu", expect_calls, cname, m, n_calls);
 
    n_throws = ctp.n_throws_ [ctp.mf_is] - n_throws;
 
    rw_assert (expect_throws == n_throws, 0, __LINE__,
               "expected %zu exceptions thrown by UserCtype<%s>::is(%{LC}, "
               "char_type), got %zu", expect_throws, cname, m, n_throws);
}
 
template <class charT>
void
test_is (charT*, const char *cname)
{
    rw_info (0, 0, __LINE__, "UserCtype<%s>::is"
             "(mask, char_type) const", cname);
 
    // exercise default behavior
 
    test_is ((charT*)0, cname, std::ctype_base::alnum,  lower,   n_lower);
    test_is ((charT*)0, cname, std::ctype_base::alnum,  upper,   n_upper);
    test_is ((charT*)0, cname, std::ctype_base::alnum,  digits,  n_digits);
    test_is ((charT*)0, cname, std::ctype_base::alnum,  xdigits, n_xdigits);
    test_is ((charT*)0, cname, std::ctype_base::alpha,  lower,   n_lower);
    test_is ((charT*)0, cname, std::ctype_base::alpha,  upper,   n_upper);
    test_is ((charT*)0, cname, std::ctype_base::cntrl,  cntrl,   n_cntrl);
    test_is ((charT*)0, cname, std::ctype_base::digit,  digits,  n_digits);
    test_is ((charT*)0, cname, std::ctype_base::graph,  graph,   n_graph);
    test_is ((charT*)0, cname, std::ctype_base::lower,  lower,   n_lower);
    test_is ((charT*)0, cname, std::ctype_base::print,  print,   n_print);
    test_is ((charT*)0, cname, std::ctype_base::punct,  punct,   n_punct);
    test_is ((charT*)0, cname, std::ctype_base::space,  spaces,  n_spaces);
    test_is ((charT*)0, cname, std::ctype_base::xdigit, xdigits, n_xdigits);
 
    // exercise custom behavior
 
    static const unsigned chars[] = {
        '0', '1', '2', '3', 'a', 'b', 'c',
        0x100, 0x7fff, 0x8000, 0xffff,
#if 2 < _RWSTD_INT_SIZE
        0x10000, 0x7fffffff, 0x80000000, 0xffffffff,
#else
        0x1ff, 0x700, 0x8fff, 0xf000,
#endif
        0xFF   // end of chars
    };
 
    static const unsigned masks[] = {
        /* '0'        */ std::ctype_base::alpha,
        /* '1'        */ std::ctype_base::cntrl,
        /* '2'        */ std::ctype_base::digit,
        /* '3'        */ std::ctype_base::lower,
        /* 'a'        */ std::ctype_base::print,
        /* 'b'        */ std::ctype_base::punct,
        /* 'c'        */ std::ctype_base::space,
        /* 0x100      */ std::ctype_base::upper,
        /* 0x7fff     */ std::ctype_base::xdigit,
        /* 0x8000     */ std::ctype_base::alpha | std::ctype_base::cntrl,
        /* 0xffff     */ std::ctype_base::cntrl | std::ctype_base::digit,
        /* 0x10000    */ std::ctype_base::digit | std::ctype_base::lower,
        /* 0x7fffffff */ std::ctype_base::lower | std::ctype_base::print,
        /* 0x80000000 */ std::ctype_base::print | std::ctype_base::punct,
        /* 0xffffffff */ std::ctype_base::punct | std::ctype_base::space,
        0xFF            // end of masks
    };
 
    static const unsigned mask_all = 
          std::ctype_base::alpha
        | std::ctype_base::cntrl
        | std::ctype_base::digit
        | std::ctype_base::lower
        | std::ctype_base::print
        | std::ctype_base::punct
        | std::ctype_base::space
        | std::ctype_base::upper
        | std::ctype_base::xdigit;
 
    const UserCtype<charT> cust (chars, masks);
 
    for (std::size_t i = 0; 0 <= chars [i]; ++i) {
 
        // FIXME: enable tests of characters greater than CHAR_MAX
        if (   _RWSTD_UCHAR_MAX < std::size_t (chars [i])
            /* && sizeof (char) == sizeof (charT) */) {
            // when charT == char break out when the character
            // value is greater than CHAR_MAX
            break;
        }
 
        const charT ch = make_char (chars [i], (charT*)0);
 
        const std::ctype_base::mask m_is =
            std::ctype_base::mask (masks [i]);
 
        rw_assert (cust.is (m_is, ch),
                   0, __LINE__,
                   "UserCtype<%s>::is(%{LC}, %{#lc}) == true",
                   cname, m_is, chars [i]);
 
        const std::ctype_base::mask m_not =
            std::ctype_base::mask (~m_is & mask_all);
 
        rw_assert (!cust.is (m_not, ch), 0, __LINE__,
                   "UserCtype<%s>::is(%{LC}, %{#lc}) == false",
                   cname, m_not, chars [i]);
    }
}
 
 
template <class charT>
void
test_scan_is (charT*, const char *cname)
{
    rw_info (0, 0, __LINE__, "UserCtype<%s>::scan_is"
             "(mask, const char_type*, const char_type*) const", cname);
 
    rw_warn (0, 0, __LINE__, "UserCtype<%s>::scan_is"
             "(mask, const char_type*, const char_type*) const"
             " not exercised", cname);
}
 
 
template <class charT>
void
test_scan_not (charT*, const char *cname)
{
    rw_info (0, 0, __LINE__, "UserCtype<%s>::scan_not"
             "(mask, const char_type*, const char_type*) const", cname);
 
    rw_warn (0, 0, __LINE__, "UserCtype<%s>::scan_not"
             "(mask, const char_type*, const char_type*) const "
             "not exercised", cname);
}
 
 
template <class charT>
void
test_toupper (charT*, const char *cname)
{
    rw_info (0, 0, __LINE__, "UserCtype<%s>::toupper"
             "(char_type) const", cname);
 
    rw_warn (0, 0, __LINE__, "UserCtype<%s>::toupper"
             "(char_type) const not exercised", cname);
 
    rw_info (0, 0, __LINE__, "UserCtype<%s>::toupper"
             "(char_type*, const char_type) const", cname);
 
    rw_warn (0, 0, __LINE__, "UserCtype<%s>::toupper"
             "(char_type*, const char_type) const not exercised", cname);
}
 
 
template <class charT>
void
test_tolower (charT*, const char *cname)
{
    rw_info (0, 0, __LINE__, "UserCtype<%s>::tolower"
             "(char_type) const", cname);
 
    rw_warn (0, 0, __LINE__, "UserCtype<%s>::tolower"
             "(char_type) const not exercised", cname);
 
    rw_info (0, 0, __LINE__, "UserCtype<%s>::tolower"
             "(char_type*, const char_type) const", cname);
 
    rw_warn (0, 0, __LINE__, "UserCtype<%s>::tolower"
             "(char_type*, const char_type) const not exercised", cname);
}
 
 
template <class charT>
void
test_widen (charT*, const char *cname)
{
    rw_info (0, 0, __LINE__, "UserCtype<%s>::widen"
             "(char) const", cname);
 
    rw_warn (0, 0, __LINE__, "UserCtype<%s>::widen"
             "(char) const not exercised", cname);
 
    rw_info (0, 0, __LINE__, "UserCtype<%s>::widen"
             "(const char*, const char*, char_type*) const", cname);
 
    rw_warn (0, 0, __LINE__, "UserCtype<%s>::widen"
             "(const char*, const char*, char_type*) const not exercised",
             cname);
}
 
 
template <class charT>
void
test_narrow (charT*, const char *cname)
{
    rw_info (0, 0, __LINE__, "UserCtype<%s>::narrow"
             "(char_type, char) const", cname);
 
    rw_warn (0, 0, __LINE__, "UserCtype<%s>::narrow"
             "(char_type, char) const not exercised", cname);
 
    rw_info (0, 0, __LINE__, "UserCtype<%s>::narrow"
             "(const char_type*, const char_type*, char, char*) const",
             cname);
 
    rw_warn (0, 0, __LINE__, "UserCtype<%s>::narrow"
             "(const char_type*, const char_type*, char, char*) const"
             " not exercised",
             cname);
}
 
 
/* extern */ unsigned opt_id;
 
/* extern */ unsigned opt_is;
/* extern */ unsigned opt_scan_is;
/* extern */ unsigned opt_scan_not;
 
/* extern */ unsigned opt_toupper;
/* extern */ unsigned opt_tolower;
 
/* extern */ unsigned opt_widen;
/* extern */ unsigned opt_narrow;
 
 
template <class charT>
void
test (charT*, const char *cname)
{
#define TEST(func)                                      \
    if (0 <= opt_ ## func)                              \
        test_ ## func ((charT*)0, cname);               \
    else                                                \
        rw_note (0, 0, __LINE__,                        \
                 "UserCtype<%s>::%s() tests disabled",  \
                 cname, # func)
 
    TEST (id);
 
    TEST (is);
    TEST (scan_is);
    TEST (scan_not);
 
    TEST (toupper);
    TEST (tolower);
 
    TEST (widen);
    TEST (narrow);
}
 
 
static int
run_test (int, char**)
{
    test ((char*)0, "char");
 
#ifndef _RWSTD_NO_WCHAR_T
    test ((wchar_t*)0, "wchar_t");
#endif   // _RWSTD_NO_WCHAR_T
 
    test ((UserChar*)0, "UserChar");
 
    return 0;
}
 
 
int main (int argc, char *argv[])
{
    return rw_test (argc, argv, __FILE__,
                    "",
                    0,
                    run_test,
                    "|-id~ "
                    "|-is~ "
                    "|-scan_is~ "
                    "|-scan_not~ "
                    "|-toupper~ "
                    "|-tolower~ "
                    "|-widen~ "
                    "|-narrow~ ",
                    &opt_id,
                    &opt_is,
                    &opt_scan_is,
                    &opt_scan_not,
                    &opt_toupper,
                    &opt_tolower,
                    &opt_widen,
                    &opt_narrow,
                    (void*)0 /* sentinel */);
}