LocaleTest Class Reference

#include <locale_test.h>

Inheritance diagram for LocaleTest:

Collaboration diagram for LocaleTest:

Public Member Functions
void	locale_by_name ()
void	loc_has_facet ()
void	num_put_get ()
void	numpunct_by_name ()
void	time_put_get ()
void	time_by_name ()
void	collate_facet ()
void	collate_by_name ()
void	ctype_facet ()
void	ctype_by_name ()
void	locale_init_problem ()
void	money_put_get ()
void	money_put_X_bug ()
void	moneypunct_by_name ()
void	default_locale ()
void	combine ()
void	messages_by_name ()

Private Member Functions
	CPPUNIT_TEST_SUITE (LocaleTest)
	CPPUNIT_TEST (locale_by_name)
	CPPUNIT_TEST (moneypunct_by_name)
	CPPUNIT_TEST (time_by_name)
	CPPUNIT_TEST (numpunct_by_name)
	CPPUNIT_TEST (ctype_by_name)
	CPPUNIT_TEST (collate_by_name)
	CPPUNIT_TEST (messages_by_name)
	CPPUNIT_TEST (loc_has_facet)
	CPPUNIT_TEST (num_put_get)
	CPPUNIT_TEST (money_put_get)
	CPPUNIT_TEST (money_put_X_bug)
	CPPUNIT_TEST (time_put_get)
	CPPUNIT_TEST (collate_facet)
	CPPUNIT_TEST (ctype_facet)
	CPPUNIT_TEST (locale_init_problem)
	CPPUNIT_TEST (default_locale)
	CPPUNIT_TEST (combine)
	CPPUNIT_TEST_SUITE_END ()
void	_loc_has_facet (const STD locale &)
void	_num_put_get (const STD locale &, const ref_locale *)
void	_time_put_get (const STD locale &)
void	_ctype_facet (const STD locale &)
void	_ctype_facet_w (const STD locale &)
void	_locale_init_problem (const STD locale &)
void	_money_put_get (const STD locale &, const ref_monetary *)
void	_money_put_get2 (const STD locale &loc, const STD locale &streamLoc, const ref_monetary *)
void	_money_put_X_bug (const STD locale &, const ref_monetary *)

Static Private Member Functions
static const ref_monetary *	_get_ref_monetary (size_t)
static const char *	_get_ref_monetary_name (const ref_monetary *)

Private Attributes
	CPPUNIT_STOP_IGNORE
	CPPUNIT_IGNORE

Detailed Description

Definition at line 20 of file locale_test.h.

Member Function Documentation

_ctype_facet()

void LocaleTest::_ctype_facet ( const STD locale &  )

private

Definition at line 27 of file ctype_facets_test.cpp.

{
  CPPUNIT_ASSERT( has_facet<ctype<char> >(loc) );
  ctype<char> const& ct = use_facet<ctype<char> >(loc);
  //is
  {
    CPPUNIT_ASSERT( ct.is(ctype_base::digit, '0') );
    CPPUNIT_ASSERT( ct.is(ctype_base::upper, 'A') );
    CPPUNIT_ASSERT( ct.is(ctype_base::lower, 'a') );
    CPPUNIT_ASSERT( ct.is(ctype_base::alpha, 'A') );
    CPPUNIT_ASSERT( ct.is(ctype_base::space, ' ') );
    CPPUNIT_ASSERT( !ct.is(ctype_base::space, '2') );
    CPPUNIT_ASSERT( ct.is(ctype_base::punct, '.') );
    CPPUNIT_ASSERT( ct.is(ctype_base::xdigit, 'a') );
  }
 
  //is range
  {
    char values[] = "0Aa .";
    ctype_base::mask res[sizeof(values)];
    ct.is(values, values + sizeof(values), res);
    // '0'
    CPPUNIT_ASSERT( (res[0] & ctype_base::print) != 0 );
    CPPUNIT_ASSERT( (res[0] & ctype_base::digit) != 0 );
    CPPUNIT_ASSERT( (res[0] & ctype_base::xdigit) != 0 );
    // 'A'
    CPPUNIT_ASSERT( (res[1] & ctype_base::print) != 0 );
    CPPUNIT_ASSERT( (res[1] & ctype_base::alpha) != 0 );
    CPPUNIT_ASSERT( (res[1] & ctype_base::xdigit) != 0 );
    CPPUNIT_ASSERT( (res[1] & ctype_base::upper) != 0 );
    // 'a'
    CPPUNIT_ASSERT( (res[2] & ctype_base::print) != 0 );
    CPPUNIT_ASSERT( (res[2] & ctype_base::alpha) != 0 );
    CPPUNIT_ASSERT( (res[2] & ctype_base::xdigit) != 0 );
    CPPUNIT_ASSERT( (res[2] & ctype_base::lower) != 0 );
    CPPUNIT_ASSERT( (res[2] & ctype_base::space) == 0 );
    // ' '
    CPPUNIT_ASSERT( (res[3] & ctype_base::print) != 0 );
    CPPUNIT_ASSERT( (res[3] & ctype_base::space) != 0 );
    CPPUNIT_ASSERT( (res[3] & ctype_base::digit) == 0 );
    // '.'
    CPPUNIT_ASSERT( (res[4] & ctype_base::print) != 0 );
    CPPUNIT_ASSERT( (res[4] & ctype_base::punct) != 0 );
    CPPUNIT_ASSERT( (res[4] & ctype_base::digit) == 0 );
  }
 
  //scan_is
  {
    char range[] = "abAc123 .";
    const char *rbeg = range;
    const char *rend = range + sizeof(range);
 
    const char *res;
    res = ct.scan_is((ctype_base::mask)(ctype_base::alpha | ctype_base::lower), rbeg, rend);
    CPPUNIT_ASSERT( res != rend );
    CPPUNIT_ASSERT( *res == 'a' );
 
    res = ct.scan_is(ctype_base::upper, rbeg, rend);
    CPPUNIT_ASSERT( res != rend );
    CPPUNIT_ASSERT( *res == 'A' );
 
    res = ct.scan_is(ctype_base::punct, rbeg, rend);
    CPPUNIT_ASSERT( res != rend );
    CPPUNIT_ASSERT( *res == '.' );
  }
 
  //scan_not
  {
    char range[] = "abAc123 .";
    const char *rbeg = range;
    const char *rend = range + sizeof(range);
 
    const char *res;
    res = ct.scan_not((ctype_base::mask)(ctype_base::alpha | ctype_base::lower), rbeg, rend);
    CPPUNIT_ASSERT( res != rend );
    CPPUNIT_ASSERT( *res == '1' );
 
    res = ct.scan_not(ctype_base::alpha, rbeg, rend);
    CPPUNIT_ASSERT( res != rend );
    CPPUNIT_ASSERT( *res == '1' );
 
    res = ct.scan_not(ctype_base::punct, rbeg, rend);
    CPPUNIT_ASSERT( res != rend );
    CPPUNIT_ASSERT( *res == 'a' );
  }
 
  //toupper
  {
    CPPUNIT_ASSERT( ct.toupper('a') == 'A' );
    CPPUNIT_ASSERT( ct.toupper('A') == 'A' );
    CPPUNIT_ASSERT( ct.toupper('1') == '1' );
  }
 
  //toupper range
  {
    char range[] = "abAc1";
    char expected_range[] = "ABAC1";
    ct.toupper(range, range + sizeof(range));
    CPPUNIT_ASSERT( equal(range, range + sizeof(range), expected_range) );
  }
 
  //tolower
  {
    CPPUNIT_ASSERT( ct.tolower('A') == 'a' );
    CPPUNIT_ASSERT( ct.tolower('a') == 'a' );
    CPPUNIT_ASSERT( ct.tolower('1') == '1' );
  }
 
  //tolower range
  {
    char range[] = "ABaC1";
    char expected_range[] = "abac1";
    ct.tolower(range, range + sizeof(range));
    CPPUNIT_ASSERT( equal(range, range + sizeof(range), expected_range) );
  }
 
  //widen
  {
    CPPUNIT_ASSERT( ct.widen('a') == 'a' );
  }
 
  //widen range
  {
    char range[] = "ABaC1";
    char res[sizeof(range)];
    ct.widen(range, range + sizeof(range), res);
    CPPUNIT_ASSERT( equal(range, range + sizeof(range), res) );
  }
 
  //narrow
  {
    CPPUNIT_ASSERT( ct.narrow('a', 'b') == 'a' );
  }
 
  //narrow range
  {
    char range[] = "ABaC1";
    char res[sizeof(range)];
    ct.narrow(range, range + sizeof(range), 'b', res);
    CPPUNIT_ASSERT( equal(range, range + sizeof(range), res) );
  }
}

Referenced by ctype_facet().

_ctype_facet_w()

void LocaleTest::_ctype_facet_w ( const STD locale &  )

private

Definition at line 170 of file ctype_facets_test.cpp.

{
# ifndef _STLP_NO_WCHAR_T
  CPPUNIT_ASSERT( has_facet<ctype<wchar_t> >(loc) );
  ctype<wchar_t> const& wct = use_facet<ctype<wchar_t> >(loc);
  //is
  {
    CPPUNIT_CHECK( wct.is(ctype_base::digit, L'0') );
    CPPUNIT_CHECK( wct.is(ctype_base::upper, L'A') );
    CPPUNIT_CHECK( wct.is(ctype_base::lower, L'a') );
    CPPUNIT_CHECK( wct.is(ctype_base::alpha, L'A') );
    CPPUNIT_CHECK( wct.is(ctype_base::space, L' ') );
    CPPUNIT_CHECK( !wct.is(ctype_base::space, L'2') );
    CPPUNIT_CHECK( wct.is(ctype_base::punct, L'.') );
    CPPUNIT_CHECK( wct.is(ctype_base::xdigit, L'a') );
  }
 
  //is range
  {
    wchar_t values[] = L"0Aa .";
    ctype_base::mask res[sizeof(values) / sizeof(wchar_t)];
    wct.is(values, values + (sizeof(values) / sizeof(wchar_t)), res);
    // '0'
    CPPUNIT_CHECK( (res[0] & ctype_base::print) != 0 );
    CPPUNIT_CHECK( (res[0] & ctype_base::digit) != 0 );
    CPPUNIT_CHECK( (res[0] & ctype_base::xdigit) != 0 );
    // 'A'
    CPPUNIT_CHECK( (res[1] & ctype_base::print) != 0 );
    CPPUNIT_CHECK( (res[1] & ctype_base::alpha) != 0 );
    CPPUNIT_CHECK( (res[1] & ctype_base::xdigit) != 0 );
    CPPUNIT_CHECK( (res[1] & ctype_base::upper) != 0 );
    // 'a'
    CPPUNIT_CHECK( (res[2] & ctype_base::print) != 0 );
    CPPUNIT_CHECK( (res[2] & ctype_base::alpha) != 0 );
    CPPUNIT_CHECK( (res[2] & ctype_base::xdigit) != 0 );
    CPPUNIT_CHECK( (res[2] & ctype_base::lower) != 0 );
    CPPUNIT_CHECK( (res[2] & ctype_base::space) == 0 );
    // ' '
    CPPUNIT_CHECK( (res[3] & ctype_base::print) != 0 );
    CPPUNIT_CHECK( (res[3] & ctype_base::space) != 0 );
    CPPUNIT_CHECK( (res[3] & ctype_base::digit) == 0 );
    // '.'
    CPPUNIT_CHECK( (res[4] & ctype_base::print) != 0 );
    CPPUNIT_CHECK( (res[4] & ctype_base::punct) != 0 );
    CPPUNIT_CHECK( (res[4] & ctype_base::digit) == 0 );
  }
 
  //scan_is
  {
    wchar_t range[] = L"abAc123 .";
    const wchar_t *rbeg = range;
    const wchar_t *rend = range + (sizeof(range) / sizeof(wchar_t));
 
    const wchar_t *res;
    res = wct.scan_is((ctype_base::mask)(ctype_base::alpha | ctype_base::lower), rbeg, rend);
    CPPUNIT_CHECK( res != rend );
    CPPUNIT_CHECK( *res == L'a' );
 
    res = wct.scan_is(ctype_base::upper, rbeg, rend);
    CPPUNIT_CHECK( res != rend );
    CPPUNIT_CHECK( *res == L'A' );
 
    res = wct.scan_is(ctype_base::punct, rbeg, rend);
    CPPUNIT_CHECK( res != rend );
    CPPUNIT_CHECK( *res == L'.' );
  }
 
  //scan_not
  {
    wchar_t range[] = L"abAc123 .";
    const wchar_t *rbeg = range;
    const wchar_t *rend = range + (sizeof(range) / sizeof(wchar_t));
 
    const wchar_t *res;
    res = wct.scan_not((ctype_base::mask)(ctype_base::alpha | ctype_base::lower), rbeg, rend);
    CPPUNIT_CHECK( res != rend );
    CPPUNIT_CHECK( *res == L'1' );
 
    res = wct.scan_not(ctype_base::alpha, rbeg, rend);
    CPPUNIT_CHECK( res != rend );
    CPPUNIT_CHECK( *res == L'1' );
 
    res = wct.scan_not(ctype_base::punct, rbeg, rend);
    CPPUNIT_CHECK( res != rend );
    CPPUNIT_CHECK( *res == L'a' );
  }
 
  //toupper
  {
    CPPUNIT_CHECK( wct.toupper(L'a') == L'A' );
    CPPUNIT_CHECK( wct.toupper(L'A') == L'A' );
    CPPUNIT_CHECK( wct.toupper(L'1') == L'1' );
  }
 
  //toupper range
  {
    wchar_t range[] = L"abAc1";
    wchar_t expected_range[] = L"ABAC1";
    wct.toupper(range, range + sizeof(range) / sizeof(wchar_t));
    CPPUNIT_CHECK( equal(range, range + sizeof(range) / sizeof(wchar_t), expected_range) );
  }
 
  //tolower
  {
    CPPUNIT_CHECK( wct.tolower(L'A') == L'a' );
    CPPUNIT_CHECK( wct.tolower(L'a') == L'a' );
    CPPUNIT_CHECK( wct.tolower(L'1') == L'1' );
  }
 
  //tolower range
  {
    wchar_t range[] = L"ABaC1";
    wchar_t expected_range[] = L"abac1";
    wct.tolower(range, range + sizeof(range) / sizeof(wchar_t));
    CPPUNIT_CHECK( equal(range, range + sizeof(range) / sizeof(wchar_t), expected_range) );
  }
 
  //widen
  {
    CPPUNIT_CHECK( wct.widen('a') == L'a' );
  }
 
  //widen range
  {
    char range[] = "ABaC1";
    wchar_t res[sizeof(range)];
    wchar_t expected_res[] = L"ABaC1";
    wct.widen(range, range + sizeof(range), res);
    CPPUNIT_CHECK( equal(expected_res, expected_res + sizeof(range), res) );
  }
 
  //narrow
  {
    CPPUNIT_CHECK( wct.narrow(L'a', 'b') == L'a' );
  }
 
  //narrow range
  {
    wchar_t range[] = L"ABaC1";
    char res[sizeof(range) / sizeof(wchar_t)];
    char expected_res[] = "ABaC1";
    wct.narrow(range, range + sizeof(range) / sizeof(wchar_t), 'b', res);
    CPPUNIT_CHECK( equal(expected_res, expected_res + sizeof(range) / sizeof(wchar_t), res) );
  }
# endif
}

Referenced by ctype_facet().

_get_ref_monetary()

const ref_monetary * LocaleTest::_get_ref_monetary ( size_t  i )

staticprivate

Definition at line 39 of file money_facets_test.cpp.

{
  if (i < sizeof(tested_locales) / sizeof(tested_locales[0])) {
    return tested_locales + i;
  }
  return 0;
}

Referenced by combine().

_get_ref_monetary_name()

const char * LocaleTest::_get_ref_monetary_name ( const ref_monetary *  _ref )

staticprivate

Definition at line 47 of file money_facets_test.cpp.

{
  return _ref->name;
}

Referenced by combine().

_loc_has_facet()

void LocaleTest::_loc_has_facet ( const STD locale &  )

private

_locale_init_problem()

void LocaleTest::_locale_init_problem ( const STD locale &  )

private

Definition at line 170 of file locale_test.cpp.

{
#    if !defined (__APPLE__) && !defined (__FreeBSD__) || \
        !defined(__GNUC__) || ((__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__> 3)))
  typedef codecvt<char,char,mbstate_t> my_facet;
#    else
// std::mbstate_t required for gcc 3.3.2 on FreeBSD...
// I am not sure what key here---FreeBSD or 3.3.2...
//      - ptr 2005-04-04
  typedef codecvt<char,char,std::mbstate_t> my_facet;
#    endif
 
  locale loc_ref(global_loc);
  {
    locale gloc( loc_ref, new my_facet() );
    CPPUNIT_ASSERT( has_facet<my_facet>( gloc ) );
    //The following code is just here to try to confuse the reference counting underlying mecanism:
    locale::global( locale::classic() );
    locale::global( gloc );
  }
 
#      if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
  try {
#      endif
    ostringstream os("test") ;
    locale loc2( loc, new my_facet() );
    CPPUNIT_ASSERT( has_facet<my_facet>( loc2 ) );
    os.imbue( loc2 );
#      if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
  }
  catch ( runtime_error& ) {
    CPPUNIT_FAIL;
  }
  catch ( ... ) {
   CPPUNIT_FAIL;
  }
#      endif
 
#      if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
  try {
#      endif
    ostringstream os2("test2");
#      if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
  }
  catch ( runtime_error& ) {
    CPPUNIT_FAIL;
  }
  catch ( ... ) {
    CPPUNIT_FAIL;
  }
#  endif
}

Referenced by locale_init_problem().

_money_put_get()

void LocaleTest::_money_put_get ( const STD locale &  , const ref_monetary *    )

private

Definition at line 52 of file money_facets_test.cpp.

{
  _money_put_get2(loc, loc, rl);
}

Referenced by money_put_get().

_money_put_get2()

void LocaleTest::_money_put_get2 ( const STD locale &  loc, const STD locale &  streamLoc, const ref_monetary *    )

private

Definition at line 57 of file money_facets_test.cpp.

{
  const ref_monetary &rl = *prl;
  CPPUNIT_ASSERT( has_facet<money_put<char> >(loc) );
  money_put<char> const& fmp = use_facet<money_put<char> >(loc);
  CPPUNIT_ASSERT( has_facet<money_get<char> >(loc) );
  money_get<char> const& fmg = use_facet<money_get<char> >(loc);
 
  ostringstream ostr;
  ostr.imbue(streamLoc);
  ostr << showbase;
 
  //Check a positive value (international format)
  {
    string str_res;
    //money_put
    {
      CPPUNIT_ASSERT( (has_facet<moneypunct<char, true> >(loc)) );
      moneypunct<char, true> const& intl_fmp = use_facet<moneypunct<char, true> >(loc);
 
      ostreambuf_iterator<char, char_traits<char> > res = fmp.put(ostr, true, ostr, ' ', 123456);
 
      CPPUNIT_ASSERT( !res.failed() );
      str_res = ostr.str();
      //CPPUNIT_MESSAGE(str_res.c_str());
 
      size_t fieldIndex = 0;
      size_t index = 0;
 
      //On a positive value we skip the sign field if exists:
      if (intl_fmp.pos_format().field[fieldIndex] == money_base::sign) {
        ++fieldIndex;
      }
      // international currency abbreviation, if it is before value
 
      /*
       * int_curr_symbol
       *
       *   The international currency symbol. The operand is a four-character
       *   string, with the first three characters containing the alphabetic
       *   international currency symbol in accordance with those specified
       *   in the ISO 4217 specification. The fourth character is the character used
       *   to separate the international currency symbol from the monetary quantity.
       *
       * (http://www.opengroup.org/onlinepubs/7990989775/xbd/locale.html)
       */
      string::size_type p = strlen( rl.money_int_prefix );
      if (p != 0) {
        CPPUNIT_ASSERT( intl_fmp.pos_format().field[fieldIndex] == money_base::symbol );
        string::size_type p_old = strlen( rl.money_int_prefix_old );
        CPPUNIT_ASSERT( (str_res.substr(index, p) == rl.money_int_prefix) ||
                        ((p_old != 0) &&
                         (str_res.substr(index, p_old) == rl.money_int_prefix_old)) );
        if ( str_res.substr(index, p) == rl.money_int_prefix ) {
          index += p;
        } else {
          index += p_old;
        }
        ++fieldIndex;
      }
 
      // space after currency
      if (intl_fmp.pos_format().field[fieldIndex] == money_base::space ||
          intl_fmp.pos_format().field[fieldIndex] == money_base::none) {
        // iternational currency symobol has four chars, one of these chars
        // is separator, so if format has space on this place, it should
        // be skipped.
        ++fieldIndex;
      }
 
      // sign
      if (intl_fmp.pos_format().field[fieldIndex] == money_base::sign) {
        ++fieldIndex;
      }
 
      // value
      CPPUNIT_ASSERT( str_res[index++] == '1' );
      if (!intl_fmp.grouping().empty()) {
        CPPUNIT_ASSERT( str_res[index++] == /* intl_fmp.thousands_sep() */ *rl.money_thousands_sep );
      }
      CPPUNIT_ASSERT( str_res[index++] == '2' );
      CPPUNIT_ASSERT( str_res[index++] == '3' );
      CPPUNIT_ASSERT( str_res[index++] == '4' );
      if (intl_fmp.frac_digits() != 0) {
        CPPUNIT_ASSERT( str_res[index++] == /* intl_fmp.decimal_point() */ *rl.money_decimal_point );
      }
      CPPUNIT_ASSERT( str_res[index++] == '5' );
      CPPUNIT_ASSERT( str_res[index++] == '6' );
      ++fieldIndex;
 
      // sign
      if (intl_fmp.pos_format().field[fieldIndex] == money_base::sign) {
        ++fieldIndex;
      }
 
      // space
      if (intl_fmp.pos_format().field[fieldIndex] == money_base::space ) {
        CPPUNIT_ASSERT( str_res[index++] == ' ' );
        ++fieldIndex;
      }
 
      // sign
      if (intl_fmp.pos_format().field[fieldIndex] == money_base::sign) {
        ++fieldIndex;
      }
 
      //as space cannot be last the only left format can be none:
      while ( fieldIndex < 3 ) {
        CPPUNIT_ASSERT( intl_fmp.pos_format().field[fieldIndex] == money_base::none );
        ++fieldIndex;
      }
    }
 
    //money_get
    {
      ios_base::iostate err = ios_base::goodbit;
      string digits;
 
      istringstream istr(str_res);
      ostr.str( "" );
      ostr.clear();
      fmg.get(istr, istreambuf_iterator<char, char_traits<char> >(), true, ostr, err, digits);
      CPPUNIT_ASSERT( (err & (ios_base::failbit | ios_base::badbit)) == 0 );
      CPPUNIT_ASSERT( digits == "123456" );
    }
  }
 
  ostr.str("");
  //Check a negative value (national format)
  {
    CPPUNIT_ASSERT( (has_facet<moneypunct<char, false> >(loc)) );
    moneypunct<char, false> const& dom_fmp = use_facet<moneypunct<char, false> >(loc);
    string str_res;
    //Check money_put
    {
      ostreambuf_iterator<char, char_traits<char> > res = fmp.put(ostr, false, ostr, ' ', -123456);
 
      CPPUNIT_ASSERT( !res.failed() );
      str_res = ostr.str();
      //CPPUNIT_MESSAGE(str_res.c_str());
 
      size_t fieldIndex = 0;
      size_t index = 0;
 
      if (dom_fmp.neg_format().field[fieldIndex] == money_base::sign) {
        CPPUNIT_ASSERT( str_res.substr(index, dom_fmp.negative_sign().size()) == dom_fmp.negative_sign() );
        index += dom_fmp.negative_sign().size();
        ++fieldIndex;
      }
 
      string::size_type p = strlen( rl.money_prefix );
      if (p != 0) {
        CPPUNIT_ASSERT( str_res.substr(index, p) == rl.money_prefix );
        index += p;
        ++fieldIndex;
      }
      if (dom_fmp.neg_format().field[fieldIndex] == money_base::space ||
          dom_fmp.neg_format().field[fieldIndex] == money_base::none) {
        CPPUNIT_ASSERT( str_res[index++] == ' ' );
        ++fieldIndex;
      }
 
      CPPUNIT_ASSERT( str_res[index++] == '1' );
      if (!dom_fmp.grouping().empty()) {
        CPPUNIT_ASSERT( str_res[index++] == dom_fmp.thousands_sep() );
      }
      CPPUNIT_ASSERT( str_res[index++] == '2' );
      CPPUNIT_ASSERT( str_res[index++] == '3' );
      CPPUNIT_ASSERT( str_res[index++] == '4' );
      if (dom_fmp.frac_digits() != 0) {
        CPPUNIT_ASSERT( str_res[index++] == dom_fmp.decimal_point() );
      }
      CPPUNIT_ASSERT( str_res[index++] == '5' );
      CPPUNIT_ASSERT( str_res[index++] == '6' );
      ++fieldIndex;
 
      //space cannot be last:
      if ((fieldIndex < 3) &&
          dom_fmp.neg_format().field[fieldIndex] == money_base::space) {
        CPPUNIT_ASSERT( str_res[index++] == ' ' );
        ++fieldIndex;
      }
 
      if (fieldIndex == 3) {
        //If none is last we should not add anything to the resulting string:
        if (dom_fmp.neg_format().field[fieldIndex] == money_base::none) {
          CPPUNIT_ASSERT( index == str_res.size() );
        } else {
          CPPUNIT_ASSERT( dom_fmp.neg_format().field[fieldIndex] == money_base::symbol );
          CPPUNIT_ASSERT( str_res.substr(index, strlen(rl.money_suffix)) == rl.money_suffix );
        }
      }
    }
 
    //money_get
    {
      ios_base::iostate err = ios_base::goodbit;
#  if defined (STLPORT)
      _STLP_LONGEST_FLOAT_TYPE val;
#  else
      long double val;
#  endif
 
      istringstream istr(str_res);
      fmg.get(istr, istreambuf_iterator<char, char_traits<char> >(), false, ostr, err, val);
      CPPUNIT_ASSERT( (err & (ios_base::failbit | ios_base::badbit)) == 0 );
      if (dom_fmp.negative_sign().empty()) {
        //Without negative sign there is no way to guess the resulting amount sign ("C" locale):
        CPPUNIT_ASSERT( val == 123456 );
      }
      else {
        CPPUNIT_ASSERT( val == -123456 );
      }
    }
  }
}

Referenced by _money_put_get(), and combine().

_money_put_X_bug()

void LocaleTest::_money_put_X_bug ( const STD locale &  , const ref_monetary *    )

private

Definition at line 279 of file money_facets_test.cpp.

{
  const ref_monetary &rl = *prl;
  CPPUNIT_ASSERT( has_facet<money_put<char> >(loc) );
  money_put<char> const& fmp = use_facet<money_put<char> >(loc);
 
  ostringstream ostr;
  ostr.imbue(loc);
  ostr << showbase;
 
  // ostr.str("");
  // Check value with one decimal digit:
  {
    CPPUNIT_ASSERT( (has_facet<moneypunct<char, false> >(loc)) );
    moneypunct<char, false> const& dom_fmp = use_facet<moneypunct<char, false> >(loc);
    string str_res;
    // Check money_put
    {
      ostreambuf_iterator<char, char_traits<char> > res = fmp.put(ostr, false, ostr, ' ', 9);
 
      CPPUNIT_ASSERT( !res.failed() );
      str_res = ostr.str();
 
      size_t fieldIndex = 0;
      size_t index = 0;
 
      if (dom_fmp.pos_format().field[fieldIndex] == money_base::sign) {
        CPPUNIT_ASSERT( str_res.substr(index, dom_fmp.positive_sign().size()) == dom_fmp.positive_sign() );
        index += dom_fmp.positive_sign().size();
        ++fieldIndex;
      }
 
      string::size_type p = strlen( rl.money_prefix );
      if (p != 0) {
        CPPUNIT_ASSERT( str_res.substr(index, p) == rl.money_prefix );
        index += p;
        ++fieldIndex;
      }
      if (dom_fmp.neg_format().field[fieldIndex] == money_base::space ||
          dom_fmp.neg_format().field[fieldIndex] == money_base::none) {
        CPPUNIT_ASSERT( str_res[index++] == ' ' );
        ++fieldIndex;
      }
      if (dom_fmp.frac_digits() != 0) {
        CPPUNIT_ASSERT( str_res[index++] == '0' );
        CPPUNIT_ASSERT( str_res[index++] == dom_fmp.decimal_point() );
        for ( int fd = 1; fd < dom_fmp.frac_digits(); ++fd ) {
          CPPUNIT_ASSERT( str_res[index++] == '0' );
        }
      }
      CPPUNIT_ASSERT( str_res[index++] == '9' );
      ++fieldIndex;
 
      //space cannot be last:
      if ((fieldIndex < 3) &&
          dom_fmp.neg_format().field[fieldIndex] == money_base::space) {
        CPPUNIT_ASSERT( str_res[index++] == ' ' );
        ++fieldIndex;
      }
 
      if (fieldIndex == 3) {
        //If none is last we should not add anything to the resulting string:
        if (dom_fmp.neg_format().field[fieldIndex] == money_base::none) {
          CPPUNIT_ASSERT( index == str_res.size() );
        } else {
          CPPUNIT_ASSERT( dom_fmp.neg_format().field[fieldIndex] == money_base::symbol );
          CPPUNIT_ASSERT( str_res.substr(index, strlen(rl.money_suffix)) == rl.money_suffix );
        }
      }
    }
  }
 
  ostr.str("");
  // Check value with two decimal digit:
  {
    CPPUNIT_ASSERT( (has_facet<moneypunct<char, false> >(loc)) );
    moneypunct<char, false> const& dom_fmp = use_facet<moneypunct<char, false> >(loc);
    string str_res;
    // Check money_put
    {
      ostreambuf_iterator<char, char_traits<char> > res = fmp.put(ostr, false, ostr, ' ', 90);
 
      CPPUNIT_ASSERT( !res.failed() );
      str_res = ostr.str();
 
      size_t fieldIndex = 0;
      size_t index = 0;
 
      if (dom_fmp.pos_format().field[fieldIndex] == money_base::sign) {
        CPPUNIT_ASSERT( str_res.substr(index, dom_fmp.positive_sign().size()) == dom_fmp.positive_sign() );
        index += dom_fmp.positive_sign().size();
        ++fieldIndex;
      }
 
      string::size_type p = strlen( rl.money_prefix );
      if (p != 0) {
        CPPUNIT_ASSERT( str_res.substr(index, p) == rl.money_prefix );
        index += p;
        ++fieldIndex;
      }
      if (dom_fmp.neg_format().field[fieldIndex] == money_base::space ||
          dom_fmp.neg_format().field[fieldIndex] == money_base::none) {
        CPPUNIT_ASSERT( str_res[index++] == ' ' );
        ++fieldIndex;
      }
      if (dom_fmp.frac_digits() != 0) {
        CPPUNIT_ASSERT( str_res[index++] == '0' );
        CPPUNIT_ASSERT( str_res[index++] == dom_fmp.decimal_point() );
        for ( int fd = 1; fd < dom_fmp.frac_digits() - 1; ++fd ) {
          CPPUNIT_ASSERT( str_res[index++] == '0' );
        }
      }
      CPPUNIT_ASSERT( str_res[index++] == '9' );
      if (dom_fmp.frac_digits() != 0) {
        CPPUNIT_ASSERT( str_res[index++] == '0' );
      }
      ++fieldIndex;
 
      //space cannot be last:
      if ((fieldIndex < 3) &&
          dom_fmp.neg_format().field[fieldIndex] == money_base::space) {
        CPPUNIT_ASSERT( str_res[index++] == ' ' );
        ++fieldIndex;
      }
 
      if (fieldIndex == 3) {
        //If none is last we should not add anything to the resulting string:
        if (dom_fmp.neg_format().field[fieldIndex] == money_base::none) {
          CPPUNIT_ASSERT( index == str_res.size() );
        } else {
          CPPUNIT_ASSERT( dom_fmp.neg_format().field[fieldIndex] == money_base::symbol );
          CPPUNIT_ASSERT( str_res.substr(index, strlen(rl.money_suffix)) == rl.money_suffix );
        }
      }
    }
  }
}

Referenced by money_put_X_bug().

_num_put_get()

void LocaleTest::_num_put_get ( const STD locale &  , const ref_locale *    )

private

Definition at line 34 of file num_facets_test.cpp.

                                                                        {
  const ref_locale& rl = *prl;
  CPPUNIT_ASSERT( has_facet<numpunct<char> >(loc) );
  numpunct<char> const& npct = use_facet<numpunct<char> >(loc);
  CPPUNIT_ASSERT( npct.decimal_point() == *rl.decimal_point );
 
  float val = 1234.56f;
  ostringstream fostr;
  fostr.imbue(loc);
  fostr << val;
 
  string ref = "1";
  if (!npct.grouping().empty()) {
    ref += npct.thousands_sep();
  }
  ref += "234";
  ref += npct.decimal_point();
  ref += "56";
  //cout << "In " << loc.name() << " 1234.56 is written: " << fostr.str() << endl;
  CPPUNIT_ASSERT( fostr.str() == ref );
 
  val = 12345678.9f;
  ref = "1";
  ref += npct.decimal_point();
  ref += "23457e+";
  string digits = "7";
  complete_digits(digits);
  ref += digits;
  fostr.str("");
  fostr << val;
  CPPUNIT_ASSERT( fostr.str() == ref );
 
  val = 1000000000.0f;
  fostr.str("");
  fostr << val;
  digits = "9";
  complete_digits(digits);
  CPPUNIT_ASSERT( fostr.str() == string("1e+") + digits );
 
  val = 1234.0f;
  ref = "1";
  if (!npct.grouping().empty()) {
    ref += npct.thousands_sep();
  }
  ref += "234";
  fostr.str("");
  fostr << val;
  CPPUNIT_ASSERT( fostr.str() == ref );
 
  val = 10000001.0f;
  fostr.str("");
  fostr << val;
  digits = "7";
  complete_digits(digits);
  CPPUNIT_ASSERT( fostr.str() == string("1e+") + digits );
 
  if (npct.grouping().size() == 1 && npct.grouping()[0] == 3) {
    int ival = 1234567890;
    fostr.str("");
    fostr << ival;
    ref = "1";
    ref += npct.thousands_sep();
    ref += "234";
    ref += npct.thousands_sep();
    ref += "567";
    ref += npct.thousands_sep();
    ref += "890";
    CPPUNIT_ASSERT( fostr.str() == ref );
  }
 
#if defined (__BORLANDC__)
  num_put<char> const& nput = use_facet<num_put<char> >(loc);
  typedef numeric_limits<double> limd;
  fostr.setf(ios_base::uppercase | ios_base::showpos);
 
  if (limd::has_infinity) {
    double infinity = limd::infinity();
    fostr.str("");
    nput.put(fostr, fostr, ' ', infinity);
    CPPUNIT_ASSERT( fostr.str() == string("+Inf") );
  }
 
  if (limd::has_quiet_NaN) {
    /* Ignore FPU exceptions */
    unsigned int _float_control_word = _control87(0, 0);
    _control87(EM_INVALID|EM_INEXACT, MCW_EM);
    double qnan = limd::quiet_NaN();
    /* Reset floating point control word */
    _clear87();
    _control87(_float_control_word, MCW_EM);
    fostr.str("");
    nput.put(fostr, fostr, ' ', qnan);
    CPPUNIT_ASSERT( fostr.str() == string("+NaN") );
  }
#endif
}

Referenced by num_put_get().

_time_put_get()

void LocaleTest::_time_put_get ( const STD locale &  )

private

Definition at line 25 of file time_facets_test.cpp.

{
  {
    typedef time_put<char, ostreambuf_iterator<char, char_traits<char> > > time_put_facet;
    CPPUNIT_ASSERT( has_facet<time_put_facet>(loc) );
    const time_put_facet& tmp = use_facet<time_put_facet>(loc);
 
    struct tm xmas = { 0, 0, 12, 25, 11, 93 };
    ostringstream ostr;
    ostr.imbue(loc);
    string format = "%B %d %Y";
 
    time_put_facet::iter_type ret = tmp.put(ostr, ostr, ' ', &xmas, format.data(), format.data() + format.size());
    CPPUNIT_ASSERT( !ret.failed() );
 
    /*
     * In other words, user conformation is required for reliable parsing
     * of user-entered dates and times, but machine-generated formats can be
     * parsed reliably. This allows parsers to be aggressive about interpreting
     * user variations on standard format.
     *
     *                                             ISO/IEC 14882, 22.2.5.1
     */
    typedef time_get<char, istreambuf_iterator<char, char_traits<char> > > time_get_facet;
    CPPUNIT_ASSERT( has_facet<time_get_facet>(loc) );
    const time_get_facet& tmg = use_facet<time_get_facet>(loc);
    basic_ios<char> io(0);
    io.imbue(loc);
 
    istringstream istr( ostr.str() );
    istreambuf_iterator<char, char_traits<char> > i( istr );
    istreambuf_iterator<char, char_traits<char> > e;
    ios_base::iostate err = ios_base::goodbit;
    struct tm other = { 15, 20, 9, 14, 7, 105 };
 
    i = tmg.get_monthname( i, e, io, err, &other );
    CPPUNIT_ASSERT( err == ios_base::goodbit );
    CPPUNIT_ASSERT( other.tm_mon == xmas.tm_mon );
 
    ++i; ++i; ++i; ++i; // skip day of month and spaces around it
    i = tmg.get_year( i, e, io, err, &other );
 
    CPPUNIT_ASSERT( err == ios_base::eofbit );
    CPPUNIT_ASSERT( other.tm_year == xmas.tm_year );
 
    ostringstream ostrX;
    ostrX.imbue(loc);
    format = "%x %X";
 
    ret = tmp.put(ostrX, ostrX, ' ', &xmas, format.data(), format.data() + format.size());
    CPPUNIT_ASSERT( !ret.failed() );
 
    istringstream istrX( ostrX.str() );
    istreambuf_iterator<char, char_traits<char> > j( istrX );
 
    err = ios_base::goodbit;
 
    struct tm yet_more = { 15, 20, 9, 14, 7, 105 };
 
    j = tmg.get_date( j, e, io, err, &yet_more );
 
    CPPUNIT_ASSERT( err == ios_base::goodbit );
 
    CPPUNIT_ASSERT( yet_more.tm_sec != xmas.tm_sec );
    CPPUNIT_ASSERT( yet_more.tm_min != xmas.tm_min );
    CPPUNIT_ASSERT( yet_more.tm_hour != xmas.tm_hour );
    CPPUNIT_ASSERT( yet_more.tm_mday == xmas.tm_mday );
    CPPUNIT_ASSERT( yet_more.tm_mon == xmas.tm_mon );
    CPPUNIT_ASSERT( yet_more.tm_year == xmas.tm_year );
 
    ++j; // skip space
 
    j = tmg.get_time( j, e, io, err, &yet_more );
 
    CPPUNIT_ASSERT( err == ios_base::eofbit || err == ios_base::goodbit );
 
    CPPUNIT_ASSERT( yet_more.tm_sec == xmas.tm_sec );
    CPPUNIT_ASSERT( yet_more.tm_min == xmas.tm_min );
    CPPUNIT_ASSERT( yet_more.tm_hour == xmas.tm_hour );
    CPPUNIT_ASSERT( yet_more.tm_mday == xmas.tm_mday );
    CPPUNIT_ASSERT( yet_more.tm_mon == xmas.tm_mon );
    CPPUNIT_ASSERT( yet_more.tm_year == xmas.tm_year );
  }
#  if !defined (STLPORT) || !defined (_STLP_NO_WCHAR_T)
  {
    typedef time_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > > time_put_facet;
    CPPUNIT_ASSERT( has_facet<time_put_facet>(loc) );
    const time_put_facet& tmp = use_facet<time_put_facet>(loc);
 
    struct tm xmas = { 0, 0, 12, 25, 11, 93 };
    wostringstream ostr;
    ostr.imbue(loc);
    wstring format = L"%B %d %Y";
 
    time_put_facet::iter_type ret = tmp.put(ostr, ostr, ' ', &xmas, format.data(), format.data() + format.size());
    CPPUNIT_ASSERT( !ret.failed() );
 
    /*
     * In other words, user conformation is required for reliable parsing
     * of user-entered dates and times, but machine-generated formats can be
     * parsed reliably. This allows parsers to be aggressive about interpreting
     * user variations on standard format.
     *
     *                                             ISO/IEC 14882, 22.2.5.1
     */
    typedef time_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > > time_get_facet;
    CPPUNIT_ASSERT( has_facet<time_get_facet>(loc) );
    const time_get_facet& tmg = use_facet<time_get_facet>(loc);
    // Intentional instantiation with char to show a bug in a previous STLport version.
    basic_ios<char> io(0);
    io.imbue(loc);
 
    wistringstream istr( ostr.str() );
    istreambuf_iterator<wchar_t, char_traits<wchar_t> > i( istr );
    istreambuf_iterator<wchar_t, char_traits<wchar_t> > e;
    ios_base::iostate err = ios_base::goodbit;
    struct tm other = { 15, 20, 9, 14, 7, 105 };
 
    i = tmg.get_monthname( i, e, io, err, &other );
    CPPUNIT_ASSERT( err == ios_base::goodbit );
    CPPUNIT_ASSERT( other.tm_mon == xmas.tm_mon );
 
    ++i; ++i; ++i; ++i; // skip day of month and spaces around it
    i = tmg.get_year( i, e, io, err, &other );
 
    CPPUNIT_ASSERT( err == ios_base::eofbit );
    CPPUNIT_ASSERT( other.tm_year == xmas.tm_year );
 
    wostringstream ostrX;
    ostrX.imbue(loc);
    format = L"%x %X";
 
    ret = tmp.put(ostrX, ostrX, ' ', &xmas, format.data(), format.data() + format.size());
    CPPUNIT_ASSERT( !ret.failed() );
 
    wistringstream istrX( ostrX.str() );
    istreambuf_iterator<wchar_t, char_traits<wchar_t> > j( istrX );
 
    err = ios_base::goodbit;
 
    struct tm yet_more = { 15, 20, 9, 14, 7, 105 };
 
    j = tmg.get_date( j, e, io, err, &yet_more );
 
    CPPUNIT_ASSERT( err == ios_base::goodbit );
 
    CPPUNIT_ASSERT( yet_more.tm_sec != xmas.tm_sec );
    CPPUNIT_ASSERT( yet_more.tm_min != xmas.tm_min );
    CPPUNIT_ASSERT( yet_more.tm_hour != xmas.tm_hour );
    CPPUNIT_ASSERT( yet_more.tm_mday == xmas.tm_mday );
    CPPUNIT_ASSERT( yet_more.tm_mon == xmas.tm_mon );
    CPPUNIT_ASSERT( yet_more.tm_year == xmas.tm_year );
 
    ++j; // skip space
 
    j = tmg.get_time( j, e, io, err, &yet_more );
 
    CPPUNIT_ASSERT( err == ios_base::eofbit || err == ios_base::goodbit );
 
    CPPUNIT_ASSERT( yet_more.tm_sec == xmas.tm_sec );
    CPPUNIT_ASSERT( yet_more.tm_min == xmas.tm_min );
    CPPUNIT_ASSERT( yet_more.tm_hour == xmas.tm_hour );
    CPPUNIT_ASSERT( yet_more.tm_mday == xmas.tm_mday );
    CPPUNIT_ASSERT( yet_more.tm_mon == xmas.tm_mon );
    CPPUNIT_ASSERT( yet_more.tm_year == xmas.tm_year );
  }
#  endif
}

Referenced by time_put_get().

collate_by_name()

void LocaleTest::collate_by_name

(

)

Definition at line 141 of file collate_facets_test.cpp.

{
  /*
   * Check of the 22.1.1.2.7 standard point. Construction of a locale
   * instance from a null pointer or an unknown name should result in
   * a runtime_error exception.
   */
#  if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
#    if defined (STLPORT) || !defined (__GNUC__)
  try {
    locale loc(locale::classic(), new collate_byname<char>(static_cast<char const*>(0)));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const& /* e */) {
    //CPPUNIT_MESSAGE( e.what() );
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
#    endif
 
  try {
    locale loc(locale::classic(), new collate_byname<char>("yasli_language"));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const& /* e */) {
    //CPPUNIT_MESSAGE( e.what() );
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
  try {
    string veryLongFacetName("LC_COLLATE=");
    veryLongFacetName.append(512, '?');
    locale loc(locale::classic(), new collate_byname<char>(veryLongFacetName.c_str()));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const& /* e */) {
    //CPPUNIT_MESSAGE( e.what() );
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
  try {
    locale loc(locale::classic(), "C", locale::collate);
  }
  catch (runtime_error const& e) {
    CPPUNIT_MESSAGE( e.what() );
    CPPUNIT_FAIL;
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
  try {
    // On platform without real localization support we should rely on the "C" facet.
    locale loc(locale::classic(), "", locale::collate);
  }
  catch (runtime_error const& e) {
    CPPUNIT_MESSAGE( e.what() );
    CPPUNIT_FAIL;
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
  try {
    locale loc(locale::classic(), new collate_byname<char>("C"));
 
    //We check that the C locale gives a lexicographical comparison:
    collate<char> const& cfacet_byname = use_facet<collate<char> >(loc);
    collate<char> const& cfacet = use_facet<collate<char> >(locale::classic());
 
    char const str1[] = "abcdef1";
    char const str2[] = "abcdef2";
    const size_t size1 = sizeof(str1) / sizeof(str1[0]) - 1;
    const size_t size2 = sizeof(str2) / sizeof(str2[0]) - 1;
 
    CPPUNIT_ASSERT( cfacet_byname.compare(str1, str1 + size1 - 1, str2, str2 + size2 - 1) ==
                    cfacet.compare(str1, str1 + size1 - 1, str2, str2 + size2 - 1) );
    CPPUNIT_ASSERT( cfacet_byname.compare(str1, str1 + size1, str2, str2 + size2) ==
                    cfacet.compare(str1, str1 + size1, str2, str2 + size2) );
 
    //Smallest string should be before largest one:
    CPPUNIT_ASSERT( cfacet_byname.compare(str1, str1 + size1 - 2, str2, str2 + size2 - 1) ==
                    cfacet.compare(str1, str1 + size1 - 2, str2, str2 + size2 - 1) );
    CPPUNIT_ASSERT( cfacet_byname.compare(str1, str1 + size1 - 1, str2, str2 + size2 - 2) ==
                    cfacet.compare(str1, str1 + size1 - 1, str2, str2 + size2 - 2) );
 
    // We cannot play with 'ç' char here because doing so would make test result
    // dependant on char being consider as signed or not...
    string strs[] = {"abdd", /* "abçd",*/ "abbd", "abcd"};
 
    vector<string> v1(strs, strs + sizeof(strs) / sizeof(strs[0]));
    sort(v1.begin(), v1.end(), loc);
    vector<string> v2(strs, strs + sizeof(strs) / sizeof(strs[0]));
    sort(v2.begin(), v2.end(), locale::classic());
    CPPUNIT_ASSERT( v1 == v2 );
 
    CPPUNIT_ASSERT( (cfacet_byname.transform(v1[0].data(), v1[0].data() + v1[0].size()).compare(cfacet_byname.transform(v1[1].data(), v1[1].data() + v1[1].size())) ==
                    v1[0].compare(v1[1])) );
  }
  catch (runtime_error const& /* e */) {
    /* CPPUNIT_MESSAGE( e.what() ); */
    CPPUNIT_FAIL;
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
#    if !defined (STLPORT) || !defined (_STLP_NO_WCHAR_T)
#      if defined (STLPORT) || !defined (__GNUC__)
  try {
    locale loc(locale::classic(), new collate_byname<wchar_t>(static_cast<char const*>(0)));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const&) {
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
#      endif
 
  try {
    locale loc(locale::classic(), new collate_byname<wchar_t>("yasli_language"));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const&) {
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
#    endif
#  endif
}

collate_facet()

void LocaleTest::collate_facet

(

)

Definition at line 16 of file collate_facets_test.cpp.

{
  {
    CPPUNIT_ASSERT( has_facet<collate<char> >(locale::classic()) );
    collate<char> const& col = use_facet<collate<char> >(locale::classic());
 
    char const str1[] = "abcdef1";
    char const str2[] = "abcdef2";
    const size_t size1 = sizeof(str1) / sizeof(str1[0]) - 1;
    const size_t size2 = sizeof(str2) / sizeof(str2[0]) - 1;
 
    CPPUNIT_ASSERT( col.compare(str1, str1 + size1 - 1, str2, str2 + size2 - 1) == 0 );
    CPPUNIT_ASSERT( col.compare(str1, str1 + size1, str2, str2 + size2) == -1 );
 
    //Smallest string should be before largest one:
    CPPUNIT_ASSERT( col.compare(str1, str1 + size1 - 2, str2, str2 + size2 - 1) == -1 );
    CPPUNIT_ASSERT( col.compare(str1, str1 + size1 - 1, str2, str2 + size2 - 2) == 1 );
  }
 
#  if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
  try {
    locale loc("fr_FR");
    {
      CPPUNIT_ASSERT( has_facet<collate<char> >(loc) );
      collate<char> const& col = use_facet<collate<char> >(loc);
 
      char const str1[] = "abcdef1";
      char const str2[] = "abcdef2";
      const size_t size1 = sizeof(str1) / sizeof(str1[0]) - 1;
      const size_t size2 = sizeof(str2) / sizeof(str2[0]) - 1;
 
      CPPUNIT_ASSERT( col.compare(str1, str1 + size1 - 1, str2, str2 + size2 - 1) == 0 );
      CPPUNIT_ASSERT( col.compare(str1, str1 + size1, str2, str2 + size2) == -1 );
 
      //Smallest string should be before largest one:
      CPPUNIT_ASSERT( col.compare(str1, str1 + size1 - 2, str2, str2 + size2 - 1) == -1 );
      CPPUNIT_ASSERT( col.compare(str1, str1 + size1 - 1, str2, str2 + size2 - 2) == 1 );
    }
    {
      CPPUNIT_ASSERT( has_facet<collate<char> >(loc) );
      collate<char> const& col = use_facet<collate<char> >(loc);
 
      string strs[] = {"abdd", "abçd", "abbd", "abcd"};
 
      string transformed[4];
      for (size_t i = 0; i < 4; ++i) {
        transformed[i] = col.transform(strs[i].data(), strs[i].data() + strs[i].size());
      }
 
      sort(strs, strs + 4, loc);
      CPPUNIT_ASSERT( strs[0] == "abbd" );
      CPPUNIT_ASSERT( strs[1] == "abcd" );
      CPPUNIT_ASSERT( strs[2] == "abçd" );
      CPPUNIT_ASSERT( strs[3] == "abdd" );
 
      sort(transformed, transformed + 4);
 
      CPPUNIT_ASSERT( col.transform(strs[0].data(), strs[0].data() + strs[0].size()) == transformed[0] );
      CPPUNIT_ASSERT( col.transform(strs[1].data(), strs[1].data() + strs[1].size()) == transformed[1] );
      CPPUNIT_ASSERT( col.transform(strs[2].data(), strs[2].data() + strs[2].size()) == transformed[2] );
      CPPUNIT_ASSERT( col.transform(strs[3].data(), strs[3].data() + strs[3].size()) == transformed[3] );
 
      // Check empty string result in empty key.
      CPPUNIT_ASSERT( col.transform(strs[0].data(), strs[0].data()).empty() );
 
      // Check that only characters that matter are taken into accout to build the key.
      CPPUNIT_ASSERT( col.transform(strs[0].data(), strs[0].data() + 2) == col.transform(strs[1].data(), strs[1].data() + 2) );
    }
#    if !defined (STLPORT) || !defined (_STLP_NO_WCHAR_T)
    {
      CPPUNIT_ASSERT( has_facet<collate<wchar_t> >(loc) );
      collate<wchar_t> const& col = use_facet<collate<wchar_t> >(loc);
 
      wchar_t const str1[] = L"abcdef1";
      wchar_t const str2[] = L"abcdef2";
      const size_t size1 = sizeof(str1) / sizeof(str1[0]) - 1;
      const size_t size2 = sizeof(str2) / sizeof(str2[0]) - 1;
 
      CPPUNIT_ASSERT( col.compare(str1, str1 + size1 - 1, str2, str2 + size2 - 1) == 0 );
      CPPUNIT_ASSERT( col.compare(str1, str1 + size1, str2, str2 + size2) == -1 );
 
      //Smallest string should be before largest one:
      CPPUNIT_ASSERT( col.compare(str1, str1 + size1 - 2, str2, str2 + size2 - 1) == -1 );
      CPPUNIT_ASSERT( col.compare(str1, str1 + size1 - 1, str2, str2 + size2 - 2) == 1 );
    }
    {
      size_t i;
      CPPUNIT_ASSERT( has_facet<collate<wchar_t> >(loc) );
      collate<wchar_t> const& col = use_facet<collate<wchar_t> >(loc);
 
      // Here we would like to use L"abçd" but it looks like all compilers
      // do not support storage of unicode characters in exe resulting in
      // compilation error. We avoid this test for the moment.
      wstring strs[] = {L"abdd", L"abcd", L"abbd", L"abcd"};
 
      wstring transformed[4];
      for (i = 0; i < 4; ++i) {
        transformed[i] = col.transform(strs[i].data(), strs[i].data() + strs[i].size());
      }
 
      sort(strs, strs + 4, loc);
      CPPUNIT_ASSERT( strs[0] == L"abbd" );
      CPPUNIT_ASSERT( strs[1] == L"abcd" );
      CPPUNIT_ASSERT( strs[2] == L"abcd" );
      CPPUNIT_ASSERT( strs[3] == L"abdd" );
 
      sort(transformed, transformed + 4);
 
      CPPUNIT_ASSERT( col.transform(strs[0].data(), strs[0].data() + strs[0].size()) == transformed[0] );
      CPPUNIT_ASSERT( col.transform(strs[1].data(), strs[1].data() + strs[1].size()) == transformed[1] );
      CPPUNIT_ASSERT( col.transform(strs[2].data(), strs[2].data() + strs[2].size()) == transformed[2] );
      CPPUNIT_ASSERT( col.transform(strs[3].data(), strs[3].data() + strs[3].size()) == transformed[3] );
 
      CPPUNIT_ASSERT( col.transform(strs[0].data(), strs[0].data()).empty() );
 
      CPPUNIT_ASSERT( col.transform(strs[0].data(), strs[0].data() + 2) == col.transform(strs[1].data(), strs[1].data() + 2) );
    }
#    endif
  }
  catch (runtime_error const&) {
    CPPUNIT_MESSAGE("No french locale to check collate facet");
  }
#  endif
}

combine()

void LocaleTest::combine

(

)

Definition at line 236 of file locale_test.cpp.

{
#  if (!defined (STLPORT) || \
       (defined (_STLP_USE_EXCEPTIONS) && !defined (_STLP_NO_MEMBER_TEMPLATES) && !defined (_STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS)))
  {
    try {
      locale loc("");
      if (!has_facet<messages<char> >(loc)) {
        loc.combine<messages<char> >(loc);
        CPPUNIT_FAIL;
      }
    }
    catch (const runtime_error & /* e */) {
      /* CPPUNIT_MESSAGE( e.what() ); */
    }
 
    try {
      locale loc;
      if (!has_facet<dummy_facet>(loc)) {
        loc.combine<dummy_facet>(loc);
        CPPUNIT_FAIL;
      }
    }
    catch (const runtime_error & /* e */) {
      /* CPPUNIT_MESSAGE( e.what() ); */
    }
  }
 
  locale loc1(locale::classic()), loc2;
  size_t loc1_index = 0;
  for (size_t i = 0; _get_ref_monetary(i) != 0; ++i) {
    try {
      {
        locale loc(_get_ref_monetary_name(_get_ref_monetary(i)));
        if (loc1 == locale::classic())
        {
          loc1 = loc;
          loc1_index = i;
          continue;
        }
        else
        {
          loc2 = loc;
        }
      }
 
      //We can start the test
      ostringstream ostr;
      ostr << "combining '" << loc2.name() << "' money facets with '" << loc1.name() << "'";
      CPPUNIT_MESSAGE( ostr.str().c_str() );
 
      //We are going to combine money facets as all formats are different.
      {
        //We check that resulting locale has correctly acquire loc2 facets.
        locale loc = loc1.combine<moneypunct<char, true> >(loc2);
        loc = loc.combine<moneypunct<char, false> >(loc2);
        loc = loc.combine<money_put<char> >(loc2);
        loc = loc.combine<money_get<char> >(loc2);
 
        //Check loc has the correct facets:
        _money_put_get2(loc2, loc, _get_ref_monetary(i));
 
        //Check loc1 has not been impacted:
        _money_put_get2(loc1, loc1, _get_ref_monetary(loc1_index));
 
        //Check loc2 has not been impacted:
        _money_put_get2(loc2, loc2, _get_ref_monetary(i));
      }
      {
        //We check that resulting locale has not wrongly acquire loc1 facets that hasn't been combine:
        locale loc = loc2.combine<numpunct<char> >(loc1);
        loc = loc.combine<time_put<char> >(loc1);
        loc = loc.combine<time_get<char> >(loc1);
 
        //Check loc has the correct facets:
        _money_put_get2(loc2, loc, _get_ref_monetary(i));
 
        //Check loc1 has not been impacted:
        _money_put_get2(loc1, loc1, _get_ref_monetary(loc1_index));
 
        //Check loc2 has not been impacted:
        _money_put_get2(loc2, loc2, _get_ref_monetary(i));
      }
 
      {
        // Check auto combination do not result in weird reference counting behavior
        // (might generate a crash).
        loc1.combine<numpunct<char> >(loc1);
      }
 
      loc1 = loc2;
      loc1_index = i;
    }
    catch (runtime_error const&) {
      //This locale is not supported.
      continue;
    }
  }
#  endif
}

CPPUNIT_TEST() [1/17]

LocaleTest::CPPUNIT_TEST ( collate_by_name  )

private

CPPUNIT_TEST() [2/17]

LocaleTest::CPPUNIT_TEST ( collate_facet  )

private

CPPUNIT_TEST() [3/17]

LocaleTest::CPPUNIT_TEST ( combine  )

private

CPPUNIT_TEST() [4/17]

LocaleTest::CPPUNIT_TEST ( ctype_by_name  )

private

CPPUNIT_TEST() [5/17]

LocaleTest::CPPUNIT_TEST ( ctype_facet  )

private

CPPUNIT_TEST() [6/17]

LocaleTest::CPPUNIT_TEST ( default_locale  )

private

CPPUNIT_TEST() [7/17]

LocaleTest::CPPUNIT_TEST ( loc_has_facet  )

private

CPPUNIT_TEST() [8/17]

LocaleTest::CPPUNIT_TEST ( locale_by_name  )

private

CPPUNIT_TEST() [9/17]

LocaleTest::CPPUNIT_TEST ( locale_init_problem  )

private

CPPUNIT_TEST() [10/17]

LocaleTest::CPPUNIT_TEST ( messages_by_name  )

private

CPPUNIT_TEST() [11/17]

LocaleTest::CPPUNIT_TEST ( money_put_get  )

private

CPPUNIT_TEST() [12/17]

LocaleTest::CPPUNIT_TEST ( money_put_X_bug  )

private

CPPUNIT_TEST() [13/17]

LocaleTest::CPPUNIT_TEST ( moneypunct_by_name  )

private

CPPUNIT_TEST() [14/17]

LocaleTest::CPPUNIT_TEST ( num_put_get  )

private

CPPUNIT_TEST() [15/17]

LocaleTest::CPPUNIT_TEST ( numpunct_by_name  )

private

CPPUNIT_TEST() [16/17]

LocaleTest::CPPUNIT_TEST ( time_by_name  )

private

CPPUNIT_TEST() [17/17]

LocaleTest::CPPUNIT_TEST ( time_put_get  )

private

CPPUNIT_TEST_SUITE()

LocaleTest::CPPUNIT_TEST_SUITE ( LocaleTest  )

private

CPPUNIT_TEST_SUITE_END()

LocaleTest::CPPUNIT_TEST_SUITE_END ( )

private

ctype_by_name()

void LocaleTest::ctype_by_name

(

)

Definition at line 366 of file ctype_facets_test.cpp.

{
  /*
   * Check of the 22.1.1.2.7 standard point. Construction of a locale
   * instance from a null pointer or an unknown name should result in
   * a runtime_error exception.
   */
#  if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
#    if  defined (STLPORT) || (!defined(__GNUC__) && (!defined (_MSC_VER) || (_MSC_VER > 1400)))
   // libstdc++ call freelocate on bad locale
  try {
    locale loc(locale::classic(), new ctype_byname<char>(static_cast<char const*>(0)));
    CPPUNIT_ASSERT( false );
  }
  catch (runtime_error const& /* e */) {
    //CPPUNIT_MESSAGE( e.what() );
  }
  catch (...) {
    CPPUNIT_ASSERT( false );
  }
#    endif
 
  try {
    locale loc(locale::classic(), new ctype_byname<char>("yasli_language"));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const& /* e */) {
    //CPPUNIT_MESSAGE( e.what() );
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
#    if  defined(STLPORT) || !defined(__GNUC__)
  try {
    locale loc(locale::classic(), new codecvt_byname<char, char, mbstate_t>(static_cast<char const*>(0)));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const& /* e */) {
    //CPPUNIT_MESSAGE( e.what() );
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
#    endif
 
  try {
    locale loc(locale::classic(), new codecvt_byname<char, char, mbstate_t>("yasli_language"));
    //STLport implementation do not care about name pass to this facet.
#    if !defined (STLPORT)
    CPPUNIT_FAIL;
#    endif
  }
  catch (runtime_error const& /* e */) {
    //CPPUNIT_MESSAGE( e.what() );
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
  try {
    locale loc(locale::classic(), new ctype_byname<char>("fr_FR"));
    CPPUNIT_ASSERT( has_facet<ctype<char> >(loc) );
    ctype<char> const& ct = use_facet<ctype<char> >(loc);
    CPPUNIT_ASSERT( ct.is(ctype_base::mask(ctype_base::print | ctype_base::lower | ctype_base::alpha), 'ç') );
  }
  catch (runtime_error const& /* e */) {
    //CPPUNIT_MESSAGE( e.what() );
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
  try {
    locale loc(locale::classic(), new ctype_byname<char>("C"));
    ctype<char> const& cfacet_byname = use_facet<ctype<char> >(loc);
    ctype<char> const& cfacet = use_facet<ctype<char> >(locale::classic());
 
    for (char c = 0;; ++c) {
      CPPUNIT_CHECK(cfacet_byname.is(ctype_base::space, c) == cfacet.is(ctype_base::space, c));
      if (cfacet_byname.is(ctype_base::print, c) != cfacet.is(ctype_base::print, c))
      {
        CPPUNIT_CHECK(cfacet_byname.is(ctype_base::print, c) == cfacet.is(ctype_base::print, c));
      }
      CPPUNIT_CHECK(cfacet_byname.is(ctype_base::cntrl, c) == cfacet.is(ctype_base::cntrl, c));
      CPPUNIT_CHECK(cfacet_byname.is(ctype_base::upper, c) == cfacet.is(ctype_base::upper, c));
      CPPUNIT_CHECK(cfacet_byname.is(ctype_base::lower, c) == cfacet.is(ctype_base::lower, c));
      CPPUNIT_CHECK(cfacet_byname.is(ctype_base::alpha, c) == cfacet.is(ctype_base::alpha, c));
      CPPUNIT_CHECK(cfacet_byname.is(ctype_base::digit, c) == cfacet.is(ctype_base::digit, c));
      CPPUNIT_CHECK(cfacet_byname.is(ctype_base::punct, c) == cfacet.is(ctype_base::punct, c));
      CPPUNIT_CHECK(cfacet_byname.is(ctype_base::xdigit, c) == cfacet.is(ctype_base::xdigit, c));
      CPPUNIT_CHECK(cfacet_byname.is(ctype_base::alnum, c) == cfacet.is(ctype_base::alnum, c));
      CPPUNIT_CHECK(cfacet_byname.is(ctype_base::graph, c) == cfacet.is(ctype_base::graph, c));
      if (c == 127) break;
    }
  }
  catch (runtime_error const& /* e */) {
    /* CPPUNIT_MESSAGE( e.what() ); */
    CPPUNIT_FAIL;
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
#    if !defined (STLPORT) || !defined (_STLP_NO_WCHAR_T)
#      if  defined(STLPORT) || !defined(__GNUC__)
  try {
    locale loc(locale::classic(), new ctype_byname<wchar_t>(static_cast<char const*>(0)));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const&) {
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
#      endif
 
  try {
    locale loc(locale::classic(), new ctype_byname<wchar_t>("yasli_language"));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const&) {
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
#      if  defined(STLPORT) || !defined(__GNUC__)
  try {
    locale loc(locale::classic(), new codecvt_byname<wchar_t, char, mbstate_t>(static_cast<char const*>(0)));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const& /* e */) {
    //CPPUNIT_MESSAGE( e.what() );
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
#      endif
 
  try {
    locale loc(locale::classic(), new codecvt_byname<wchar_t, char, mbstate_t>("yasli_language"));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const& /* e */) {
    //CPPUNIT_MESSAGE( e.what() );
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
#    endif
#  endif
}

ctype_facet()

void LocaleTest::ctype_facet

(

)

Definition at line 358 of file ctype_facets_test.cpp.

{
  test_supported_locale(*this, &LocaleTest::_ctype_facet);
#ifndef _STLP_NO_WCHAR_T
  test_supported_locale(*this, &LocaleTest::_ctype_facet_w);
#endif
}

default_locale()

void LocaleTest::default_locale

(

)

Definition at line 224 of file locale_test.cpp.

{
  locale loc( "" );
}

loc_has_facet()

void LocaleTest::loc_has_facet

(

)

Definition at line 145 of file locale_test.cpp.

                               {
  locale loc("C");
  typedef numpunct<char> implemented_facet;
  CPPUNIT_ASSERT( has_facet<implemented_facet>(loc) );
  /*
  typedef num_put<char, back_insert_iterator<string> > not_implemented_facet;
  CPPUNIT_ASSERT( !has_facet<not_implemented_facet>(loc) );
  */
}

locale_by_name()

void LocaleTest::locale_by_name

(

)

Definition at line 51 of file locale_test.cpp.

                                {
#  if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
  /*
   * Check of the 22.1.1.2.7 standard point. Construction of a locale
   * instance from a null pointer or an unknown name should result in
   * a runtime_error exception.
   */
  try {
    locale loc(static_cast<char const*>(0));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const&) {
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
  try {
    locale loc("yasli_language");
    CPPUNIT_FAIL;
  }
  catch (runtime_error const& /* e */) {
    //CPPUNIT_MESSAGE( e.what() );
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
  try {
    string very_large_locale_name(1024, '?');
    locale loc(very_large_locale_name.c_str());
    CPPUNIT_FAIL;
  }
  catch (runtime_error const& /* e */) {
    //CPPUNIT_MESSAGE( e.what() );
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
#if defined (STLPORT) || !defined (_MSC_VER) || (_MSC_VER > 1400)
  try {
    string very_large_locale_name("LC_CTYPE=");
    very_large_locale_name.append(1024, '?');
    locale loc(very_large_locale_name.c_str());
    CPPUNIT_FAIL;
  }
  catch (runtime_error const& /* e */) {
    //CPPUNIT_MESSAGE( e.what() );
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
  try {
    string very_large_locale_name("LC_ALL=");
    very_large_locale_name.append(1024, '?');
    locale loc(very_large_locale_name.c_str());
    CPPUNIT_FAIL;
  }
  catch (runtime_error const& /* e */) {
    //CPPUNIT_MESSAGE( e.what() );
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
#endif
 
  try {
    locale loc("C");
  }
  catch (runtime_error const& /* e */) {
    /* CPPUNIT_MESSAGE( e.what() ); */
    CPPUNIT_FAIL;
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
  try {
    // On platform without real localization support we should rely on the "C" locale facet.
    locale loc("");
  }
  catch (runtime_error const& /* e */) {
    /* CPPUNIT_MESSAGE( e.what() ); */
    CPPUNIT_FAIL;
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
#  endif
}

locale_init_problem()

void LocaleTest::locale_init_problem

(

)

Definition at line 155 of file locale_test.cpp.

                                     {
#  if !defined (STLPORT) || !defined (_STLP_NO_MEMBER_TEMPLATES)
  test_supported_locale(*this, &LocaleTest::_locale_init_problem);
#  endif
}

messages_by_name()

void LocaleTest::messages_by_name

(

)

Definition at line 14 of file messages_facets_test.cpp.

{
  /*
   * Check of the 22.1.1.2.7 standard point. Construction of a locale
   * instance from a null pointer or an unknown name should result in
   * a runtime_error exception.
   */
#  if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
#    if defined (STLPORT) || !defined (__GNUC__)
  try {
    locale loc(locale::classic(), new messages_byname<char>(static_cast<char const*>(0)));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const& /* e */) {
    //CPPUNIT_MESSAGE( e.what() );
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
#    endif
 
  try {
    locale loc(locale::classic(), new messages_byname<char>("yasli_language"));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const& /* e */) {
    //CPPUNIT_MESSAGE( e.what() );
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
  /*
  try {
    locale loc(locale::classic(), new messages_byname<char>(""));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const& e) {
    CPPUNIT_MESSAGE( e.what() );
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
  */
 
#    if !defined (STLPORT) || !defined (_STLP_NO_WCHAR_T)
#      if defined (STLPORT) || !defined (__GNUC__)
  try {
    locale loc(locale::classic(), new messages_byname<wchar_t>(static_cast<char const*>(0)));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const&) {
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
#    endif
 
  try {
    locale loc(locale::classic(), new messages_byname<wchar_t>("yasli_language"));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const&) {
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
#    endif
#  endif
}

money_put_get()

void LocaleTest::money_put_get

(

)

Definition at line 453 of file money_facets_test.cpp.

{ test_supported_locale(*this, &LocaleTest::_money_put_get); }

money_put_X_bug()

void LocaleTest::money_put_X_bug

(

)

Definition at line 456 of file money_facets_test.cpp.

{ test_supported_locale(*this, &LocaleTest::_money_put_X_bug); }

moneypunct_by_name()

void LocaleTest::moneypunct_by_name

(

)

Definition at line 459 of file money_facets_test.cpp.

{
  /*
   * Check of the 22.1.1.2.7 standard point. Construction of a locale
   * instance from a null pointer or an unknown name should result in
   * a runtime_error exception.
   */
#  if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
#    if defined (STLPORT) || !defined (__GNUC__)
  try {
    locale loc(locale::classic(), new moneypunct_byname<char, true>(static_cast<char const*>(0)));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const&) {
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
#    endif
 
  try {
    locale loc(locale::classic(), new moneypunct_byname<char, true>("yasli_language"));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const&) {
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
  try {
    string veryLongFacetName("LC_MONETARY=");
    veryLongFacetName.append(512, '?');
    locale loc(locale::classic(), new moneypunct_byname<char, true>(veryLongFacetName.c_str()));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const& /* e */) {
    //CPPUNIT_MESSAGE( e.what() );
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
#    if defined (STLPORT) || !defined (__GNUC__)
  try {
    locale loc(locale::classic(), new moneypunct_byname<char, false>(static_cast<char const*>(0)));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const&) {
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
#    endif
 
  try {
    locale loc(locale::classic(), new moneypunct_byname<char, false>("yasli_language"));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const&) {
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
  try {
    string veryLongFacetName("LC_MONETARY=");
    veryLongFacetName.append(512, '?');
    locale loc(locale::classic(), new moneypunct_byname<char, false>(veryLongFacetName.c_str()));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const& /* e */) {
    //CPPUNIT_MESSAGE( e.what() );
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
  try {
    locale loc(locale::classic(), new moneypunct_byname<char, false>("C"));
    moneypunct<char, false> const& cfacet_byname = use_facet<moneypunct<char, false> >(loc);
    moneypunct<char, false> const& cfacet = use_facet<moneypunct<char, false> >(locale::classic());
 
    money_base::pattern cp = cfacet.pos_format();
    money_base::pattern cp_bn = cfacet_byname.pos_format();
    CPPUNIT_CHECK( cp_bn.field[0] == cp.field[0] );
    CPPUNIT_CHECK( cp_bn.field[1] == cp.field[1] );
    CPPUNIT_CHECK( cp_bn.field[2] == cp.field[2] );
    CPPUNIT_CHECK( cp_bn.field[3] == cp.field[3] );
 
    CPPUNIT_CHECK( cfacet_byname.frac_digits() == cfacet.frac_digits() );
    if (cfacet_byname.frac_digits() != 0)
      CPPUNIT_CHECK( cfacet_byname.decimal_point() == cfacet.decimal_point() );
    CPPUNIT_CHECK( cfacet_byname.grouping() == cfacet.grouping() );
    if (!cfacet_byname.grouping().empty())
      CPPUNIT_CHECK( cfacet_byname.thousands_sep() == cfacet.thousands_sep() );
    CPPUNIT_CHECK( cfacet_byname.positive_sign() == cfacet.positive_sign() );
    CPPUNIT_CHECK( cfacet_byname.negative_sign() == cfacet.negative_sign() );
  }
  catch (runtime_error const& /* e */) {
    /* CPPUNIT_MESSAGE( e.what() ); */
    CPPUNIT_FAIL;
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
  try {
    locale loc(locale::classic(), new moneypunct_byname<char, true>("C"));
    moneypunct<char, true> const& cfacet_byname = use_facet<moneypunct<char, true> >(loc);
    moneypunct<char, true> const& cfacet = use_facet<moneypunct<char, true> >(locale::classic());
 
    money_base::pattern cp = cfacet.pos_format();
    money_base::pattern cp_bn = cfacet_byname.pos_format();
    CPPUNIT_CHECK( cp_bn.field[0] == cp.field[0] );
    CPPUNIT_CHECK( cp_bn.field[1] == cp.field[1] );
    CPPUNIT_CHECK( cp_bn.field[2] == cp.field[2] );
    CPPUNIT_CHECK( cp_bn.field[3] == cp.field[3] );
 
    CPPUNIT_CHECK( cfacet_byname.frac_digits() == cfacet.frac_digits() );
    if (cfacet_byname.frac_digits() != 0)
      CPPUNIT_CHECK( cfacet_byname.decimal_point() == cfacet.decimal_point() );
    CPPUNIT_CHECK( cfacet_byname.grouping() == cfacet.grouping() );
    if (!cfacet_byname.grouping().empty())
      CPPUNIT_CHECK( cfacet_byname.thousands_sep() == cfacet.thousands_sep() );
    CPPUNIT_CHECK( cfacet_byname.positive_sign() == cfacet.positive_sign() );
    CPPUNIT_CHECK( cfacet_byname.negative_sign() == cfacet.negative_sign() );
  }
  catch (runtime_error const& /* e */) {
    /* CPPUNIT_MESSAGE( e.what() ); */
    CPPUNIT_FAIL;
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
  try {
    // On platform without real localization support we should rely on the "C" locale facet.
    locale loc(locale::classic(), new moneypunct_byname<char, false>(""));
  }
  catch (runtime_error const& /* e */) {
    /* CPPUNIT_MESSAGE( e.what() ); */
    CPPUNIT_FAIL;
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
#    if !defined (STLPORT) || !defined (_STLP_NO_WCHAR_T)
#      if defined (STLPORT) || !defined (__GNUC__)
  try {
    locale loc(locale::classic(), new moneypunct_byname<wchar_t, true>(static_cast<char const*>(0)));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const&) {
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
#      endif
 
  try {
    locale loc(locale::classic(), new moneypunct_byname<wchar_t, true>("yasli_language"));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const&) {
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
#      if defined (STLPORT) || !defined (__GNUC__)
  try {
    locale loc(locale::classic(), new moneypunct_byname<wchar_t, false>(static_cast<char const*>(0)));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const&) {
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
#      endif
 
  try {
    locale loc(locale::classic(), new moneypunct_byname<wchar_t, false>("yasli_language"));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const&) {
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
#    endif
#  endif
}

num_put_get()

void LocaleTest::num_put_get

(

)

Definition at line 166 of file num_facets_test.cpp.

{ test_supported_locale(*this, &LocaleTest::_num_put_get); }

numpunct_by_name()

void LocaleTest::numpunct_by_name

(

)

Definition at line 169 of file num_facets_test.cpp.

{
  /*
   * Check of the 22.1.1.2.7 standard point. Construction of a locale
   * instance from a null pointer or an unknown name should result in
   * a runtime_error exception.
   */
#  if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
#    if defined (STLPORT) || !defined (__GNUC__)
  try {
    locale loc(locale::classic(), new numpunct_byname<char>(static_cast<char const*>(0)));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const& /* e */) {
    //CPPUNIT_MESSAGE( e.what() );
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
#    endif
 
  try {
    locale loc(locale::classic(), new numpunct_byname<char>("yasli_language"));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const& /* e */) {
    //CPPUNIT_MESSAGE( e.what() );
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
  try {
    string veryLongFacetName("LC_NUMERIC=");
    veryLongFacetName.append(512, '?');
    locale loc(locale::classic(), new numpunct_byname<char>(veryLongFacetName.c_str()));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const& /* e */) {
    //CPPUNIT_MESSAGE( e.what() );
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
  try {
    locale loc(locale::classic(), "C", locale::numeric);
  }
  catch (runtime_error const& e) {
    CPPUNIT_MESSAGE( e.what() );
    CPPUNIT_FAIL;
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
  try {
    // On platform without real localization support we should rely on the "C" facet.
    locale loc(locale::classic(), "", locale::numeric);
  }
  catch (runtime_error const& e) {
    CPPUNIT_MESSAGE( e.what() );
    CPPUNIT_FAIL;
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
  try {
    locale loc(locale::classic(), new numpunct_byname<char>("C"));
    numpunct<char> const& cfacet_byname = use_facet<numpunct<char> >(loc);
    numpunct<char> const& cfacet = use_facet<numpunct<char> >(locale::classic());
 
    CPPUNIT_CHECK( cfacet_byname.decimal_point() == cfacet.decimal_point() );
    CPPUNIT_CHECK( cfacet_byname.grouping() == cfacet.grouping() );
    if (!cfacet.grouping().empty())
      CPPUNIT_CHECK( cfacet_byname.thousands_sep() == cfacet.thousands_sep() );
#    if !defined (STLPORT) || !defined (__GLIBC__)
    CPPUNIT_CHECK( cfacet_byname.truename() == cfacet.truename() );
    CPPUNIT_CHECK( cfacet_byname.falsename() == cfacet.falsename() );
#    endif
  }
  catch (runtime_error const& /* e */) {
    //CPPUNIT_MESSAGE( e.what() );
    CPPUNIT_FAIL;
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
  try {
    // On platform without real localization support we should rely on the "C" locale facet.
    locale loc(locale::classic(), new numpunct_byname<char>(""));
  }
  catch (runtime_error const& e) {
    CPPUNIT_MESSAGE( e.what() );
    CPPUNIT_FAIL;
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
#    if !defined (STLPORT) || !defined (_STLP_NO_WCHAR_T)
#      if defined (STLPORT) || !defined (__GNUC__)
  try {
    locale loc(locale::classic(), new numpunct_byname<wchar_t>(static_cast<char const*>(0)));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const&) {
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
#      endif
 
  try {
    locale loc(locale::classic(), new numpunct_byname<wchar_t>("yasli_language"));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const&) {
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
#    endif
#  endif
}

time_by_name()

void LocaleTest::time_by_name

(

)

Definition at line 235 of file time_facets_test.cpp.

{
#  if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
  /*
   * Check of the 22.1.1.2.7 standard point. Construction of a locale
   * instance from a null pointer or an unknown name should result in
   * a runtime_error exception.
   */
#    if defined (STLPORT) || !defined (_MSC_VER) || (_MSC_VER > 1400)
  try {
    locale loc(locale::classic(), new time_put_byname<char, ostreambuf_iterator<char, char_traits<char> > >(static_cast<char const*>(0)));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const&) {
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
#    endif
 
  try {
    locale loc(locale::classic(), new time_put_byname<char, ostreambuf_iterator<char, char_traits<char> > >("yasli_language"));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const&) {
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
  try {
    string veryLongFacetName("LC_TIME=");
    veryLongFacetName.append(512, '?');
    locale loc(locale::classic(), new time_put_byname<char, ostreambuf_iterator<char, char_traits<char> > >(veryLongFacetName.c_str()));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const& /* e */) {
    //CPPUNIT_MESSAGE( e.what() );
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
  try {
    locale loc(locale::classic(), new time_get_byname<char, istreambuf_iterator<char, char_traits<char> > >(static_cast<char const*>(0)));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const&) {
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
  try {
    locale loc(locale::classic(), new time_get_byname<char, istreambuf_iterator<char, char_traits<char> > >("yasli_language"));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const&) {
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
  try {
    string veryLongFacetName("LC_TIME=");
    veryLongFacetName.append(512, '?');
    locale loc(locale::classic(), new time_get_byname<char, istreambuf_iterator<char, char_traits<char> > >(veryLongFacetName.c_str()));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const& /* e */) {
    //CPPUNIT_MESSAGE( e.what() );
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
  try {
    locale loc(locale::classic(), "C", locale::time);
  }
  catch (runtime_error const& /* e */) {
    /* CPPUNIT_MESSAGE( e.what() ); */
    CPPUNIT_FAIL;
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
  try {
    // On platform without real localization support we should rely on the "C" facet.
    locale loc(locale::classic(), "", locale::time);
  }
  catch (runtime_error const& /* e */) {
    /* CPPUNIT_MESSAGE( e.what() ); */
    CPPUNIT_FAIL;
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
  try {
    locale loc(locale::classic(), new time_get_byname<char, istreambuf_iterator<char, char_traits<char> > >("C"));
  }
  catch (runtime_error const& /* e */) {
    /* CPPUNIT_MESSAGE( e.what() ); */
    CPPUNIT_FAIL;
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
  try {
    // On platform without real localization support we should rely on the "C" locale facet.
    locale loc(locale::classic(), new time_get_byname<char, istreambuf_iterator<char, char_traits<char> > >(""));
  }
  catch (runtime_error const& /* e */) {
    /* CPPUNIT_MESSAGE( e.what() ); */
    CPPUNIT_FAIL;
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
#    if !defined (STLPORT) || !defined (_STLP_NO_WCHAR_T)
  try {
    locale loc(locale::classic(), new time_put_byname<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >(static_cast<char const*>(0)));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const&) {
  }
  catch (...) {
    CPPUNIT_FAIL;
    }
 
  try {
    locale loc(locale::classic(), new time_put_byname<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >("yasli_language"));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const&) {
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
  try {
    locale loc(locale::classic(), new time_get_byname<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >(static_cast<char const*>(0)));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const&) {
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
  try {
    locale loc(locale::classic(), new time_get_byname<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >("yasli_language"));
    CPPUNIT_FAIL;
  }
  catch (runtime_error const&) {
  }
  catch (...) {
    CPPUNIT_FAIL;
  }
 
#    endif
#  endif
}

time_put_get()

void LocaleTest::time_put_get

(

)

Definition at line 232 of file time_facets_test.cpp.

{ test_supported_locale(*this, &LocaleTest::_time_put_get); }

Member Data Documentation

CPPUNIT_IGNORE

LocaleTest::CPPUNIT_IGNORE

private

Definition at line 48 of file locale_test.h.

CPPUNIT_STOP_IGNORE

LocaleTest::CPPUNIT_STOP_IGNORE

private

Definition at line 33 of file locale_test.h.

---

The documentation for this class was generated from the following files:

• sdk/lib/3rdparty/stlport/test/unit/locale_test.h
• sdk/lib/3rdparty/stlport/test/unit/collate_facets_test.cpp
• sdk/lib/3rdparty/stlport/test/unit/ctype_facets_test.cpp
• sdk/lib/3rdparty/stlport/test/unit/locale_test.cpp
• sdk/lib/3rdparty/stlport/test/unit/messages_facets_test.cpp
• sdk/lib/3rdparty/stlport/test/unit/money_facets_test.cpp
• sdk/lib/3rdparty/stlport/test/unit/num_facets_test.cpp
• sdk/lib/3rdparty/stlport/test/unit/time_facets_test.cpp