Return-Path: Delivered-To: apmail-incubator-stdcxx-commits-archive@www.apache.org Received: (qmail 94658 invoked from network); 3 Feb 2006 00:40:38 -0000 Received: from hermes.apache.org (HELO mail.apache.org) (209.237.227.199) by minotaur.apache.org with SMTP; 3 Feb 2006 00:40:38 -0000 Received: (qmail 16943 invoked by uid 500); 3 Feb 2006 00:40:38 -0000 Delivered-To: apmail-incubator-stdcxx-commits-archive@incubator.apache.org Received: (qmail 16926 invoked by uid 500); 3 Feb 2006 00:40:37 -0000 Mailing-List: contact stdcxx-commits-help@incubator.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: stdcxx-dev@incubator.apache.org Delivered-To: mailing list stdcxx-commits@incubator.apache.org Received: (qmail 16915 invoked by uid 500); 3 Feb 2006 00:40:37 -0000 Delivered-To: apmail-incubator-stdcxx-cvs@incubator.apache.org Received: (qmail 16906 invoked by uid 99); 3 Feb 2006 00:40:37 -0000 Received: from asf.osuosl.org (HELO asf.osuosl.org) (140.211.166.49) by apache.org (qpsmtpd/0.29) with ESMTP; Thu, 02 Feb 2006 16:40:37 -0800 X-ASF-Spam-Status: No, hits=-9.4 required=10.0 tests=ALL_TRUSTED,NO_REAL_NAME X-Spam-Check-By: apache.org Received: from [209.237.227.194] (HELO minotaur.apache.org) (209.237.227.194) by apache.org (qpsmtpd/0.29) with SMTP; Thu, 02 Feb 2006 16:40:35 -0800 Received: (qmail 94505 invoked by uid 65534); 3 Feb 2006 00:40:15 -0000 Message-ID: <20060203004015.94504.qmail@minotaur.apache.org> Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r374549 - /incubator/stdcxx/trunk/tests/strings/21.cwchar.cpp Date: Fri, 03 Feb 2006 00:40:15 -0000 To: stdcxx-cvs@incubator.apache.org From: sebor@apache.org X-Mailer: svnmailer-1.0.5 X-Virus-Checked: Checked by ClamAV on apache.org X-Spam-Rating: minotaur.apache.org 1.6.2 0/1000/N Author: sebor Date: Thu Feb 2 16:40:07 2006 New Revision: 374549 URL: http://svn.apache.org/viewcvs?rev=374549&view=rev Log: 2006-02-02 Martin Sebor STDCXX-4 * 21.cwchar.cpp: New test exercising lib.string.c.strings, header , including STDCXX-129. Added: incubator/stdcxx/trunk/tests/strings/21.cwchar.cpp (with props) Added: incubator/stdcxx/trunk/tests/strings/21.cwchar.cpp URL: http://svn.apache.org/viewcvs/incubator/stdcxx/trunk/tests/strings/21.cwchar.cpp?rev=374549&view=auto ============================================================================== --- incubator/stdcxx/trunk/tests/strings/21.cwchar.cpp (added) +++ incubator/stdcxx/trunk/tests/strings/21.cwchar.cpp Thu Feb 2 16:40:07 2006 @@ -0,0 +1,1070 @@ +/*************************************************************************** + * + * 21.cwchar.cpp - test exercising [lib.string.c.strings], Table 48 + * + * $Id$ + * + *************************************************************************** + * + * Copyright (c) 1994-2005 Quovadx, Inc., acting through its Rogue Wave + * Software division. Licensed under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance with the + * License. You may obtain a copy of the License at + * http://www.apache.org/licenses/LICENSE-2.0. Unless required by + * applicable law or agreed to in writing, software distributed under + * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR + * CONDITIONS OF ANY KIND, either express or implied. See the License + * for the specific language governing permissions and limitations under + * the License. + * + **************************************************************************/ + +// used in the EVAL() macro below purely to make diagnostic messages +// more informative (i.e., to display which config macros are defined +// when a function isn't declared -- it may not make sense to declare +// some functions if they are not defined in the C library) +enum { + _RWSTD_NO_BTOWC = 1, _RWSTD_NO_BTOWC_IN_LIBC = 1, + _RWSTD_NO_FGETWC = 1, _RWSTD_NO_FGETWC_IN_LIBC = 1, + _RWSTD_NO_FGETWS = 1, _RWSTD_NO_FGETWS_IN_LIBC = 1, + _RWSTD_NO_FPUTWC = 1, _RWSTD_NO_FPUTWC_IN_LIBC = 1, + _RWSTD_NO_FPUTWS = 1, _RWSTD_NO_FPUTWS_IN_LIBC = 1, + _RWSTD_NO_FWIDE = 1, _RWSTD_NO_FWIDE_IN_LIBC = 1, + _RWSTD_NO_FWPRINTF = 1, _RWSTD_NO_FWPRINTF_IN_LIBC = 1, + _RWSTD_NO_FWSCANF = 1, _RWSTD_NO_FWSCANF_IN_LIBC = 1, + _RWSTD_NO_GETWC = 1, _RWSTD_NO_GETWC_IN_LIBC = 1, + _RWSTD_NO_GETWCHAR = 1, _RWSTD_NO_GETWCHAR_IN_LIBC = 1, + _RWSTD_NO_MBRLEN = 1, _RWSTD_NO_MBRLEN_IN_LIBC = 1, + _RWSTD_NO_MBRTOWC = 1, _RWSTD_NO_MBRTOWC_IN_LIBC = 1, + _RWSTD_NO_MBSINIT = 1, _RWSTD_NO_MBSINIT_IN_LIBC = 1, + _RWSTD_NO_MBSRTOWCS = 1, _RWSTD_NO_MBSRTOWCS_IN_LIBC = 1, + _RWSTD_NO_PUTWC = 1, _RWSTD_NO_PUTWC_IN_LIBC = 1, + _RWSTD_NO_PUTWCHAR = 1, _RWSTD_NO_PUTWCHAR_IN_LIBC = 1, + _RWSTD_NO_SWPRINTF = 1, _RWSTD_NO_SWPRINTF_IN_LIBC = 1, + _RWSTD_NO_SWSCANF = 1, _RWSTD_NO_SWSCANF_IN_LIBC = 1, + _RWSTD_NO_UNGETWC = 1, _RWSTD_NO_UNGETWC_IN_LIBC = 1, + _RWSTD_NO_VFWPRINTF = 1, _RWSTD_NO_VFWPRINTF_IN_LIBC = 1, + _RWSTD_NO_VSWPRINTF = 1, _RWSTD_NO_VSWPRINTF_IN_LIBC = 1, + _RWSTD_NO_VWPRINTF = 1, _RWSTD_NO_VWPRINTF_IN_LIBC = 1, + _RWSTD_NO_WCRTOMB = 1, _RWSTD_NO_WCRTOMB_IN_LIBC = 1, + _RWSTD_NO_WCSCAT = 1, _RWSTD_NO_WCSCAT_IN_LIBC = 1, + _RWSTD_NO_WCSCHR = 1, _RWSTD_NO_WCSCHR_IN_LIBC = 1, + _RWSTD_NO_WCSCMP = 1, _RWSTD_NO_WCSCMP_IN_LIBC = 1, + _RWSTD_NO_WCSCOLL = 1, _RWSTD_NO_WCSCOLL_IN_LIBC = 1, + _RWSTD_NO_WCSCPY = 1, _RWSTD_NO_WCSCPY_IN_LIBC = 1, + _RWSTD_NO_WCSCSPN = 1, _RWSTD_NO_WCSCSPN_IN_LIBC = 1, + _RWSTD_NO_WCSFTIME = 1, _RWSTD_NO_WCSFTIME_IN_LIBC = 1, + _RWSTD_NO_WCSLEN = 1, _RWSTD_NO_WCSLEN_IN_LIBC = 1, + _RWSTD_NO_WCSNCAT = 1, _RWSTD_NO_WCSNCAT_IN_LIBC = 1, + _RWSTD_NO_WCSNCMP = 1, _RWSTD_NO_WCSNCMP_IN_LIBC = 1, + _RWSTD_NO_WCSNCPY = 1, _RWSTD_NO_WCSNCPY_IN_LIBC = 1, + _RWSTD_NO_WCSPBRK = 1, _RWSTD_NO_WCSPBRK_IN_LIBC = 1, + _RWSTD_NO_WCSRCHR = 1, _RWSTD_NO_WCSRCHR_IN_LIBC = 1, + _RWSTD_NO_WCSRTOMBS = 1, _RWSTD_NO_WCSRTOMBS_IN_LIBC = 1, + _RWSTD_NO_WCSSPN = 1, _RWSTD_NO_WCSSPN_IN_LIBC = 1, + _RWSTD_NO_WCSSTR = 1, _RWSTD_NO_WCSSTR_IN_LIBC = 1, + _RWSTD_NO_WCSTOD = 1, _RWSTD_NO_WCSTOD_IN_LIBC = 1, + _RWSTD_NO_WCSTOK = 1, _RWSTD_NO_WCSTOK_IN_LIBC = 1, + _RWSTD_NO_WCSTOL = 1, _RWSTD_NO_WCSTOL_IN_LIBC = 1, + _RWSTD_NO_WCSTOUL = 1, _RWSTD_NO_WCSTOUL_IN_LIBC = 1, + _RWSTD_NO_WCSXFRM = 1, _RWSTD_NO_WCSXFRM_IN_LIBC = 1, + _RWSTD_NO_WCTOB = 1, _RWSTD_NO_WCTOB_IN_LIBC = 1, + _RWSTD_NO_WMEMCHR = 1, _RWSTD_NO_WMEMCHR_IN_LIBC = 1, + _RWSTD_NO_WMEMCMP = 1, _RWSTD_NO_WMEMCMP_IN_LIBC = 1, + _RWSTD_NO_WMEMCPY = 1, _RWSTD_NO_WMEMCPY_IN_LIBC = 1, + _RWSTD_NO_WMEMMOVE = 1, _RWSTD_NO_WMEMMOVE_IN_LIBC = 1, + _RWSTD_NO_WMEMSET = 1, _RWSTD_NO_WMEMSET_IN_LIBC = 1, + _RWSTD_NO_WPRINTF = 1, _RWSTD_NO_WPRINTF_IN_LIBC = 1, + _RWSTD_NO_WSCANF = 1, _RWSTD_NO_WSCANF_IN_LIBC = 1 +}; + +/**************************************************************************/ + +#include +#include // for rw_any_t +#include // for rw_test(), ... + +/**************************************************************************/ + +// detect missing macros +const char* const missing_macros [] = { + +#ifndef NULL + "NULL", +#else // if defined (NULL) + "", +#endif // NULL + +#ifndef WCHAR_MIN + "WCHAR_MIN", +#else // if defined (WCHAR_MIN) + "", +#endif // WCHAR_MIN + +#ifndef WCHAR_MAX + "WCHAR_MAX", +#else // if defined (WCHAR_MAX) + "", +#endif // WCHAR_MAX + +#ifndef WEOF + "WEOF", +#else // if defined (WEOF) + "", +#endif // WEOF + + 0 +}; + +/**************************************************************************/ + +// detect masking macros and undefine them to avoid compilation errors +// they might cause otherwise +const char* const masking_macros [] = { + +#ifdef fwprintf + "fwprintf", +# undef fwprintf +#else + "", +#endif // fwprintf + +#ifdef fwscanf + "fwscanf", +# undef fwscanf +#else + "", +#endif // fwscanf + +#ifdef wprintf + "wprintf", +# undef wprintf +#else + "", +#endif // wprintf + +#ifdef wscanf + "wscanf", +# undef wscanf +#else + "", +#endif // wscanf + +#ifdef swprintf + "swprintf", +# undef swprintf +#else + "", +#endif // swprintf + +#ifdef swscanf + "swscanf", +# undef swscanf +#else + "", +#endif // swscanf + +#ifdef vfwprintf + "vfwprintf", +# undef vfwprintf +#else + "", +#endif // vfwprintf + +#ifdef vwprintf + "vwprintf", +# undef vwprintf +#else + "", +#endif // vwprintf + +#ifdef vswprintf + "vswprintf", +# undef vswprintf +#else + "", +#endif // vswprintf + +#ifdef fgetwc + "fgetwc", +# undef fgetwc +#else + "", +#endif // fgetwc + +#ifdef fgetws + "fgetws", +# undef fgetws +#else + "", +#endif // fgetws + +#ifdef fputwc + "fputwc", +# undef fputwc +#else + "", +#endif // fputwc + +#ifdef fputws + "fputws", +# undef fputws +#else + "", +#endif // fputws + +#ifdef getwc + "getwc", +# undef getwc +#else + "", +#endif // getwc + +#ifdef getwchar + "getwchar", +# undef getwchar +#else + "", +#endif // getwchar + +#ifdef putwc + "putwc", +# undef putwc +#else + "", +#endif // putwc + +#ifdef putwchar + "putwchar", +# undef putwchar +#else + "", +#endif // putwchar + +#ifdef ungetwc + "ungetwc", +# undef ungetwc +#else + "", +#endif // ungetwc + +#ifdef fwide + "fwide", +# undef fwide +#else + "", +#endif // fwide + +#ifdef wcstod + "wcstod", +# undef wcstod +#else + "", +#endif // wcstod + +#ifdef wcstol + "wcstol", +# undef wcstol +#else + "", +#endif // wcstol + +#ifdef wcstoul + "wcstoul", +# undef wcstoul +#else + "", +#endif // wcstoul + +#ifdef wcscpy + "wcscpy", +# undef wcscpy +#else + "", +#endif // wcscpy + +#ifdef wcsncpy + "wcsncpy", +# undef wcsncpy +#else + "", +#endif // wcsncpy + +#ifdef wcscat + "wcscat", +# undef wcscat +#else + "", +#endif // wcscat + +#ifdef wcsncat + "wcsncat", +# undef wcsncat +#else + "", +#endif // wcsncat + +#ifdef wcscmp + "wcscmp", +# undef wcscmp +#else + "", +#endif // wcscmp + +#ifdef wcscoll + "wcscoll", +# undef wcscoll +#else + "", +#endif // wcscoll + +#ifdef wcsncmp + "wcsncmp", +# undef wcsncmp +#else + "", +#endif // wcsncmp + +#ifdef wcsxfrm + "wcsxfrm", +# undef wcsxfrm +#else + "", +#endif // wcsxfrm + +#ifdef wcschr + "wcschr", +# undef wcschr +#else + "", +#endif // wcschr + +#ifdef wcscspn + "wcscspn", +# undef wcscspn +#else + "", +#endif // wcscspn + +#ifdef wcspbrk + "wcspbrk", +# undef wcspbrk +#else + "", +#endif // wcspbrk + +#ifdef wcsrchr + "wcsrchr", +# undef wcsrchr +#else + "", +#endif // wcsrchr + +#ifdef wcsspn + "wcsspn", +# undef wcsspn +#else + "", +#endif // wcsspn + +#ifdef wcsstr + "wcsstr", +# undef wcsstr +#else + "", +#endif // wcsstr + +#ifdef wcstok + "wcstok", +# undef wcstok +#else + "", +#endif // wcstok + +#ifdef wcslen + "wcslen", +# undef wcslen +#else + "", +#endif // wcslen + +#ifdef wmemchr + "wmemchr", +# undef wmemchr +#else + "", +#endif // wmemchr + +#ifdef wmemcmp + "wmemcmp", +# undef wmemcmp +#else + "", +#endif // wmemcmp + +#ifdef wmemcpy + "wmemcpy", +# undef wmemcpy +#else + "", +#endif // wmemcpy + +#ifdef wmemmove + "wmemmove", +# undef wmemmove +#else + "", +#endif // wmemmove + +#ifdef wmemset + "wmemset", +# undef wmemset +#else + "", +#endif // wmemset + +#ifdef wcsftime + "wcsftime", +# undef wcsftime +#else + "", +#endif // wcsftime + +#ifdef btowc + "btowc", +# undef btowc +#else + "", +#endif // btowc + +#ifdef wctob + "wctob", +# undef wctob +#else + "", +#endif // wctob + +#ifdef mbsinit + "mbsinit", +# undef mbsinit +#else + "", +#endif // mbsinit + +#ifdef mbrlen + "mbrlen", +# undef mbrlen +#else + "", +#endif // mbrlen + +#ifdef mbrtowc + "mbrtowc", +# undef mbrtowc +#else + "", +#endif // mbrtowc + +#ifdef wcrtomb + "wcrtomb", +# undef wcrtomb +#else + "", +#endif // wcrtomb + +#ifdef mbsrtowcs + "mbsrtowcs", +# undef mbsrtowcs +#else + "", +#endif // mbsrtowcs + +#ifdef wcsrtombs + "wcsrtombs", +# undef wcsrtombs +#else + "", +#endif // wcsrtombs + + 0 +}; + +/**************************************************************************/ + +static void +test_macros () +{ + rw_info (0, 0, 0, "checking for missing and masking macros"); + + for (unsigned i = 0; missing_macros [i]; ++i) { + rw_assert ('\0' == missing_macros [i][0], 0, __LINE__, + "macro %s not defined", missing_macros [i]); + } + + for (unsigned i = 0; masking_macros [i]; ++i) { + rw_assert ('\0' == masking_macros [i][0], 0, __LINE__, + "masking macro %s unexpectedly defined", + masking_macros [i]); + } +} + +/**************************************************************************/ + +#ifndef _RWSTD_NO_NAMESPACE + +// check types + +namespace Fallback { + +struct size_t { + int i_; + char dummy_ [256]; // make sure we're bigger than the real thing + + // this (fake) size_t emulates a scalar type + size_t (int i): i_ (i) { } + operator int () const { return i_; } +}; + +struct mbstate_t { + char dummy_ [256]; // make sure we're bigger than the real thing +}; + +struct wint_t { + int i_; + char dummy_ [256]; // make sure we're bigger than the real thing + + // this (fake) wint_t emulates a scalar type + wint_t (int i): i_ (i) { } + operator int () const { return i_; } +}; + +struct FILE; + +struct tm; + +} // namespace Fallback + +namespace std { + +// define test functions in namespace std to detect the presece +// or absence of the required types + +namespace Nested { + +using namespace Fallback; + +// each test_xxx_t typedef aliases std::xxx_t if the corresponding +// type is defined in namespace std, or Fallback::xxx_t otherwise +typedef size_t test_size_t; +typedef mbstate_t test_mbstate_t; +typedef wint_t test_wint_t; +typedef tm test_tm; + +} // namespace Nested + +} // namespace std + +typedef std::Nested::test_size_t test_size_t; +typedef std::Nested::test_mbstate_t test_mbstate_t; +typedef std::Nested::test_wint_t test_wint_t; +typedef std::Nested::test_tm test_tm; + + +template +int tm_defined (const StructTm*) { return 1; } +int tm_defined (const Fallback::tm*) { return 0; } + + +const char std_name[] = "std"; + +static void +test_types () +{ + rw_info (0, 0, 0, + "types %s::size_t, %1$s::mbstate_t, %1$s::wint_t, and %1$s::tm", + std_name); + + rw_assert (sizeof (test_size_t) != sizeof (Fallback::size_t), 0, 0, + "%s::size_t not defined", std_name); + rw_assert (sizeof (test_mbstate_t) != sizeof (Fallback::mbstate_t), 0, 0, + "%s::mbstate_t not defined", std_name); + rw_assert (sizeof (test_wint_t) != sizeof (Fallback::wint_t), 0, 0, + "%s::wint_t not defined", std_name); + + rw_assert (tm_defined ((const test_tm*)0), 0, 0, + "%s::tm not defined", std_name); +} + +#else // if defined (_RWSTD_NO_NAMESPACE) + +const char std_name[] = ""; + +static void +test_types () +{ + rw_info (0, 0, 0, + "types %s::size_t, %1$s::mbstate_t, %1$s::wint_t, and %1$s::tm", + std_name); + + rw_note (0, 0, 0, "_RWSTD_NO_NAMESPACE defined, cannot test"); +} + +#endif // _RWSTD_NO_NAMESPACE + +/**************************************************************************/ + +int ncalls; + +_RWSTD_NAMESPACE (std) { + +template +int fwprintf (FileT*, const WCharT*, ...) { return ncalls++; } + +template +int fwscanf (FileT*, const WCharT*, ...) { return ncalls++; } + +template +int wprintf (const WCharT*, ...) { return ncalls++; } + +template +int wscanf (const WCharT*, ...) { return ncalls++; } + +template +int swprintf (WCharT*, SizeT, const WCharT*, ...) { return ncalls++; } + +template +int swscanf (const WCharT*, const WCharT*, ...) { return ncalls++; } + +template +int vfwprintf (FileT*, const WCharT*, VAList) { return ncalls++; } + +template +int vwprintf (const WCharT*, VAList) { return ncalls++; } + +template +int vswprintf (WCharT*, SizeT, const WCharT*, VAList) { return ncalls++; } + +template +int fgetwc (FileT*) { return ncalls++; } + +template +WCharT* fgetws (WCharT*, int, FileT*) { ncalls++; return 0; } + +template +test_wint_t fputwc (WCharT, FileT*) { return ncalls++; } + +template +int fputws (const WCharT*, FileT*) { return ncalls++; } + +template +test_wint_t getwc (FileT*) { return ncalls++; } + +// cannot exercise +// test_wint_t getwchar(); + +template +test_wint_t putwc (WCharT, FileT*) { return ncalls++; } + +template +test_wint_t putwchar (WCharT) { return ncalls++; } + +template +test_wint_t ungetwc (WIntT, FileT*) { return ncalls++; } + +template +int fwide (FileT*, int) { return ncalls++; } + +template +double wcstod (const WCharT*, WCharT**) { return ncalls++; } + +template +long wcstol (const WCharT*, WCharT**, int) { return ncalls++; } + +template +unsigned long wcstoul (const WCharT*, WCharT**, int) { return ncalls++; } + +template +WCharT* wcscpy (WCharT*, const WCharT*) { ncalls++; return 0; } + +template +WCharT* wcsncpy (WCharT*, const WCharT*, SizeT) { ncalls++; return 0; } + +template +WCharT* wcscat (WCharT*, const WCharT*) { ncalls++; return 0; } + +template +WCharT* wcsncat (WCharT*, const WCharT*, SizeT) { ncalls++; return 0; } + +template +int wcscmp (const WCharT*, const WCharT*) { return ncalls++; } + +template +int wcscoll (const WCharT*, const WCharT*) { return ncalls++; } + +template +int wcsncmp (const WCharT*, const WCharT*, SizeT) { return ncalls++; } + +template +SizeT wcsxfrm (WCharT*, const WCharT*, SizeT) { return ncalls++; } + +template +WCharT* wcschr (WCharT*, WCharT) { ncalls++; return 0; } + +template +test_size_t wcscspn (const WCharT*, const WCharT*) { return ncalls++; } + +template +WCharT* wcspbrk (WCharT*, const WCharT*) { ncalls++; return 0; } + +template +WCharT* wcsrchr (WCharT*, WCharT) { ncalls++; return 0; } + +template +test_size_t wcsspn (const WCharT*, const WCharT*) { return ncalls++; } + +template +WCharT* wcsstr (WCharT*, const WCharT*) { ncalls++; return 0; } + +template +WCharT* wcstok (WCharT*, const WCharT*, WCharT**) { ncalls++; return 0; } + +template +test_size_t wcslen (const WCharT*) { return ncalls++; } + +template +WCharT* wmemchr (WCharT*, WCharT, SizeT) { ncalls++; return 0; } + +template +int wmemcmp (const WCharT*, const WCharT*, SizeT) { return ncalls++; } + +template +WCharT* wmemcpy (WCharT*, const WCharT*, SizeT) { ncalls++; return 0; } + +template +WCharT* wmemmove (WCharT*, const WCharT*, SizeT) { ncalls++; return 0; } + +template +WCharT* wmemset (WCharT*, WCharT, SizeT) { ncalls++; return 0; } + +template +SizeT wcsftime (WCharT*, SizeT, const WCharT*, const StructTm*) +{ return ncalls++; } + +template +test_wint_t btowc (IntT) { return ncalls++; } + +template +int wctob (WIntT) { return ncalls++; } + +template +int mbsinit (const MBStateT*) { return ncalls++; } + +template +SizeT mbrlen (const char*, SizeT, MBStateT*) { return ncalls++; } + +template +SizeT mbrtowc (WCharT*, const char*, SizeT, MBStateT*) { return ncalls++; } + +template +test_size_t wcrtomb (char*, WCharT, MBStateT*) { return ncalls++; } + +template +SizeT mbsrtowcs (WCharT*, const char**, SizeT, MBStateT*) { return ncalls++; } + +template +SizeT wcsrtombs (char*, const WCharT**, SizeT, MBStateT*) { return ncalls++; } + + +template +const WCharT* wcschr (const WCharT*, WCharT) { ncalls++; return 0; } + +template +const WCharT* wcspbrk (const WCharT*, const WCharT*) { ncalls++; return 0; } + +template +const WCharT* wcsrchr (const WCharT*, WCharT) { ncalls++; return 0; } + +template +const WCharT* wcsstr (const WCharT*, const WCharT*) { ncalls++; return 0; } + +template +const WCharT* wmemchr (const WCharT*, WCharT, SizeT) { ncalls++; return 0; } + +} // namespace std + + +struct UniqType; + +#define GET_TYPE_NAME(T) \ + template \ + const char* get_type_name (T, Type) { \ + return rw_any_t (Type ()).type_name (); \ + } \ + const char* get_type_name (T, T) { return 0; } \ + typedef void unused_typedef /* allow a terminating semicolon */ + +GET_TYPE_NAME (short); +GET_TYPE_NAME (unsigned short); +GET_TYPE_NAME (int); +GET_TYPE_NAME (unsigned int); +GET_TYPE_NAME (long); +GET_TYPE_NAME (unsigned long); +GET_TYPE_NAME (double); +GET_TYPE_NAME (wchar_t); +GET_TYPE_NAME (wchar_t*); +GET_TYPE_NAME (const wchar_t*); + + +#define EVAL2(macro) !!(macro - 1) +#define EVAL(name) EVAL2 (_RWSTD_NO_ ## name + 0) +#define EVAL_IN_LIBC(name) EVAL (name ## _IN_LIBC) + + +static int rw_opt_no_macros; // for --no-macros +static int rw_opt_no_types; // for --no-types +static int rw_opt_no_functions; // for --no-functions +static int rw_opt_no_overloads; // for --no-overloads + + +void test_functions () +{ +#define TEST(T, fun, args, macro, overload) \ + do { \ + cstr = (str = array); \ + wcstr = (wstr = warray); \ + *str = '\0'; *wstr = L'\0'; \ + ncalls = 0; \ + rw_info (0, 0, __LINE__, "%s::%s(" \ + "%{?}%{:}/* %{?}non-%{;}const overload */%{;})", \ + std_name, #fun, overload < 0, 0 == overload); \ + const char* const return_type_name = \ + get_type_name ((T)0, std::fun args); \ + rw_assert (0 == ncalls, 0, __LINE__, \ + "%s::%s(" \ + "%{?}%{:}/* %{?}non-%{;}const overload */%{;}) " \ + "not declared (_RWSTD_NO_%s = %d, " \ + "_RWSTD_NO_%s_IN_LIBC = %d)", \ + std_name, #fun, overload < 0, 0 == overload, \ + #macro, EVAL (macro), #macro, EVAL_IN_LIBC (macro)); \ + if (0 == ncalls) \ + rw_assert (0 == return_type_name, 0, __LINE__, "%s::%s(" \ + "%{?}%{:}/* %{?}non-%{;}const overload */%{;}) " \ + "expected return type %s, got %s", \ + std_name, #fun, overload < 0, 0 == overload, \ + #T, return_type_name); \ + } while (0) + + char array [4] = ""; + + char* str = array; + const char* cstr = array; + + wchar_t warray [32] = L""; + + /* */ wchar_t* /* */ wstr = warray; + const wchar_t* /* */ wcstr = warray; + + test_size_t size = 0; + + const UniqType* const uniqptr = 0; + + const test_wint_t wi = 0; + + const int i = 0; + TEST (int, wprintf, (L""), WPRINTF, -1); + TEST (int, wprintf, (L"", uniqptr), WPRINTF, -1); + + TEST (int, wscanf, (L""), WSCANF, -1); + TEST (int, wscanf, (L"", uniqptr), WSCANF, -1); + + TEST (int, swprintf, (wstr, size, L""), SWPRINTF, -1); + TEST (int, swprintf, (wstr, size, L"", uniqptr), SWPRINTF, -1); + + TEST (int, swscanf, (wstr, L""), SWSCANF, -1); + TEST (int, swscanf, (wstr, L"", uniqptr), SWSCANF, -1); + + TEST (double, wcstod, (L"", &wstr), WCSTOD, -1); + TEST (long, wcstol, (L"", &wstr, i), WCSTOL, -1); + TEST (unsigned long, wcstoul, (L"", &wstr, i), WCSTOUL, -1); + + TEST (wchar_t*, wcscpy, (wstr, L""), WCSCPY, -1); + TEST (wchar_t*, wcsncpy, (wstr, L"", size), WCSNCPY, -1); + TEST (wchar_t*, wcscat, (wstr, L""), WCSCAT, -1); + TEST (int, wcscmp, (wstr, L""), WCSCMP, -1); + TEST (int, wcsncmp, (wstr, L"", size), WCSNCMP, -1); + TEST (test_size_t, wcsxfrm, (wstr, L"", size), WCSXFRM, -1); + + TEST (test_size_t, wcscspn, (L"", L""), WCSCSPN, -1); + + TEST (test_size_t, wcsspn, (L"", L""), WCSSPN, -1); + TEST (wchar_t*, wcstok, (wstr, L"", &wstr), WCSTOK, -1); + + TEST (test_size_t, wcslen, (L""), WCSLEN, -1); + TEST (int, wmemcmp, (L"", L"", size), WMEMCMP, -1); + TEST (wchar_t*, wmemcpy, (wstr, L"", size), WMEMCPY, -1); + TEST (wchar_t*, wmemmove, (wstr, L"", size), WMEMMOVE, -1); + TEST (wchar_t*, wmemset, (wstr, L'\0', size), WMEMSET, -1); + + const int tm_buf [16] = { 0 }; + const test_tm* tmb = (const test_tm*)&tm_buf; + + TEST (test_size_t, wcsftime, (wstr, size, L"", tmb), WCSFTIME, -1); + + TEST (test_wint_t, btowc, (i), BTOWC, -1); + TEST (int, wctob, (wi), WCTOB, -1); + + test_mbstate_t state = test_mbstate_t (); + + TEST (int, mbsinit, (&state), MBSINIT, -1); + TEST (test_size_t, mbrlen, ("", size, &state), MBRLEN, -1); + TEST (test_size_t, mbrtowc, (wstr, "", size, &state), MBRTOWC, -1); + TEST (test_size_t, wcrtomb, (str, L'\0', &state), WCRTOMB, -1); + + TEST (test_size_t, mbsrtowcs, (wstr, &cstr, size, &state), MBSRTOWCS, -1); + TEST (test_size_t, wcsrtombs, (str, &wcstr, size, &state), WCSRTOMBS, -1); + + if (rw_opt_no_overloads) { + // exercise the traditional C (const-incorrect) functions + TEST (/* const */ wchar_t*, wmemchr, (L"", L'\0', size), WMEMCHR, -1); + TEST (/* const */ wchar_t*, wcspbrk, (wcstr, L""), WCSPBRK, -1); + TEST (/* const */ wchar_t*, wcsrchr, (L"", L'\0'), WCSRCHR, -1); + TEST (/* const */ wchar_t*, wcsstr, (L"", L""), WCSSTR, -1); + TEST (/* const */ wchar_t*, wcschr, (L"", L'\0'), WCSCHR, -1); + } + else { + // exercise const and non-const overloads that C++ replaces + // the traditional C functions with + TEST (const wchar_t*, wmemchr, (L"", L'\0', size), WMEMCHR, 1); + TEST (wchar_t*, wmemchr, (wstr, L'\0', size), WMEMCHR, 0); + + TEST (const wchar_t*, wcspbrk, (wcstr, L""), WCSPBRK, 1); + TEST (wchar_t*, wcspbrk, (wstr, L""), WCSPBRK, 0); + + TEST (const wchar_t*, wcsrchr, (L"", L'\0'), WCSRCHR, 1); + TEST (wchar_t*, wcsrchr, (wstr, L'\0'), WCSRCHR, 0); + + TEST (const wchar_t*, wcsstr, (L"", L""), WCSSTR, 1); + TEST (wchar_t*, wcsstr, (wstr, L""), WCSSTR, 0); + + TEST (const wchar_t*, wcschr, (L"", L'\0'), WCSCHR, 1); + TEST (wchar_t*, wcschr, (wstr, L'\0'), WCSCHR, 0); + } +} + +/**************************************************************************/ + +// included here to avoid namespace pollution +#include // for va_list +#include // for FILE +#include // for rw_stdout + +namespace std { + +// define test types in namespace std to detect the presece +// or absence of the required types + +namespace Nested { + +using namespace Fallback; + +typedef FILE test_FILE; +typedef va_list test_va_list; + +} // namespace Nested + +} // namespace std + +typedef std::Nested::test_FILE test_FILE; +typedef std::Nested::test_va_list test_va_list; + + +void test_file_functions (int dummy, ...) +{ + char array [4] = ""; + + /* */ char* str = array; + const char* cstr = array; + + wchar_t warray [32] = L""; + + /* */ wchar_t* /* */ wstr = warray; + const wchar_t* /* */ wcstr = warray; + + const int i = 0; + + const UniqType* const uniqptr = 0; + + const test_wint_t wi = 0; + + // cast rw_stdout to FILE* via void* since the latter may be + // an incomplete type and casts between two non-void pointers + // require that the types be complete (in case they are related + // by inheritance and need to be adjusted) + test_FILE* const fp = (test_FILE*)(void*)rw_stdout; + test_va_list va; + va_start (va, dummy); + + TEST (int, fwprintf, (fp, L""), FWPRINTF, -1); + TEST (int, fwprintf, (fp, L"", uniqptr), FWPRINTF, -1); + + TEST (int, fwscanf, (fp, L""), FWSCANF, -1); + TEST (int, fwscanf, (fp, L"", uniqptr), FWSCANF, -1); + + TEST (int, vfwprintf, (fp, L"", va), VFWPRINTF, -1); + + TEST (test_wint_t, fgetwc, (fp), FGETWC, -1); + TEST (wchar_t*, fgetws, (wstr, i, fp), FGETWS, -1); + TEST (test_wint_t, fputwc, (L'\0', fp), FPUTWC, -1); + TEST (int, fputws, (L"", fp), FPUTWS, -1); + TEST (test_wint_t, getwc, (fp), GETWC, -1); + TEST (test_wint_t, putwc, (L'\0', fp), PUTWC, -1); + TEST (test_wint_t, ungetwc, (wi, fp), UNGETWC, -1); + TEST (int, fwide, (fp, i), FWIDE, -1); + + _RWSTD_UNUSED (str); + _RWSTD_UNUSED (cstr); + _RWSTD_UNUSED (wcstr); +} + +/**************************************************************************/ + +static int +run_test (int, char**) +{ + if (rw_opt_no_macros) + rw_note (0, 0, 0, "test for macros disabled"); + else + test_macros (); + + if (rw_opt_no_types) + rw_note (0, 0, 0, "test for types disabled"); + else + test_types (); + + if (rw_opt_no_functions) + rw_note (0, 0, 0, "test for functions disabled"); + else { + test_functions (); + test_file_functions (0 /* dummy */); + } + + return 0; +} + +/**************************************************************************/ + +int main (int argc, char *argv[]) +{ + return rw_test (argc, argv, __FILE__, + "lib.c.strings", + "header ", + run_test, + "|-no-macros#0-1 " + "|-no-types#0-1 " + "|-no-functions#0-1 " + "|-no-overloads#0-1 ", + &rw_opt_no_macros, + &rw_opt_no_types, + &rw_opt_no_functions, + &rw_opt_no_overloads); +} Propchange: incubator/stdcxx/trunk/tests/strings/21.cwchar.cpp ------------------------------------------------------------------------------ svn:eol-style = native Propchange: incubator/stdcxx/trunk/tests/strings/21.cwchar.cpp ------------------------------------------------------------------------------ svn:keywords = Id