stdcxx-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From se...@apache.org
Subject svn commit: r374549 - /incubator/stdcxx/trunk/tests/strings/21.cwchar.cpp
Date Fri, 03 Feb 2006 00:40:15 GMT
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  <sebor@roguewave.com>

	STDCXX-4
	* 21.cwchar.cpp: New test exercising lib.string.c.strings, header
	<cwchar>, 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 <cwchar>
+#include <any.h>      // for rw_any_t
+#include <driver.h>   // 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 <class StructTm>
+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 <class FileT, class WCharT>
+int fwprintf (FileT*, const WCharT*, ...) { return ncalls++; }
+
+template <class FileT, class WCharT>
+int fwscanf (FileT*, const WCharT*, ...) { return ncalls++; }
+
+template <class WCharT>
+int wprintf (const WCharT*, ...) { return ncalls++; }
+
+template <class WCharT>
+int wscanf (const WCharT*, ...) { return ncalls++; }
+
+template <class WCharT, class SizeT>
+int swprintf (WCharT*, SizeT, const WCharT*, ...) { return ncalls++; }
+
+template <class WCharT, class SizeT>
+int swscanf (const WCharT*, const WCharT*, ...) { return ncalls++; }
+
+template <class FileT, class WCharT, class SizeT, class VAList>
+int vfwprintf (FileT*, const WCharT*, VAList) { return ncalls++; }
+
+template <class WCharT, class VAList>
+int vwprintf (const WCharT*, VAList) { return ncalls++; }
+
+template <class WCharT, class SizeT, class VAList>
+int vswprintf (WCharT*, SizeT, const WCharT*, VAList) { return ncalls++; }
+
+template <class FileT>
+int fgetwc (FileT*) { return ncalls++; }
+
+template <class WCharT, class FileT>
+WCharT* fgetws (WCharT*, int, FileT*) { ncalls++; return 0; }
+
+template <class WCharT, class FileT>
+test_wint_t fputwc (WCharT, FileT*) { return ncalls++; }
+
+template <class WCharT, class FileT>
+int fputws (const WCharT*, FileT*) { return ncalls++; }
+
+template <class FileT>
+test_wint_t getwc (FileT*) { return ncalls++; }
+
+// cannot exercise
+// test_wint_t getwchar();
+
+template <class WCharT, class FileT>
+test_wint_t putwc (WCharT, FileT*) { return ncalls++; }
+
+template <class WCharT>
+test_wint_t putwchar (WCharT) { return ncalls++; }
+
+template <class WIntT, class FileT>
+test_wint_t ungetwc (WIntT, FileT*) { return ncalls++; }
+
+template <class FileT>
+int fwide (FileT*, int) { return ncalls++; }
+
+template <class WCharT>
+double wcstod (const WCharT*, WCharT**) { return ncalls++; }
+
+template <class WCharT>
+long wcstol (const WCharT*, WCharT**, int) { return ncalls++; }
+
+template <class WCharT>
+unsigned long wcstoul (const WCharT*, WCharT**, int) { return ncalls++; }
+
+template <class WCharT>
+WCharT* wcscpy (WCharT*, const WCharT*) { ncalls++; return 0; }
+
+template <class WCharT, class SizeT>
+WCharT* wcsncpy (WCharT*, const WCharT*, SizeT) { ncalls++; return 0; }
+
+template <class WCharT>
+WCharT* wcscat (WCharT*, const WCharT*) { ncalls++; return 0; }
+
+template <class WCharT, class SizeT>
+WCharT* wcsncat (WCharT*, const WCharT*, SizeT) { ncalls++; return 0; }
+
+template <class WCharT>
+int wcscmp (const WCharT*, const WCharT*) { return ncalls++; }
+
+template <class WCharT>
+int wcscoll (const WCharT*, const WCharT*) { return ncalls++; }
+
+template <class WCharT, class SizeT>
+int wcsncmp (const WCharT*, const WCharT*, SizeT) { return ncalls++; }
+
+template <class WCharT, class SizeT>
+SizeT wcsxfrm (WCharT*, const WCharT*, SizeT) { return ncalls++; }
+
+template <class WCharT>
+WCharT* wcschr (WCharT*, WCharT) { ncalls++; return 0; }
+
+template <class WCharT>
+test_size_t wcscspn (const WCharT*, const WCharT*) { return ncalls++; }
+
+template <class WCharT>
+WCharT* wcspbrk (WCharT*, const WCharT*) { ncalls++; return 0; }
+
+template <class WCharT>
+WCharT* wcsrchr (WCharT*, WCharT) { ncalls++; return 0; }
+
+template <class WCharT>
+test_size_t wcsspn (const WCharT*, const WCharT*) { return ncalls++; }
+
+template <class WCharT>
+WCharT* wcsstr (WCharT*, const WCharT*) { ncalls++; return 0; }
+
+template <class WCharT>
+WCharT* wcstok (WCharT*, const WCharT*, WCharT**) { ncalls++; return 0; }
+
+template <class WCharT>
+test_size_t wcslen (const WCharT*) { return ncalls++; }
+
+template <class WCharT, class SizeT>
+WCharT* wmemchr (WCharT*, WCharT, SizeT) { ncalls++; return 0; }
+
+template <class WCharT, class SizeT>
+int wmemcmp (const WCharT*, const WCharT*, SizeT) { return ncalls++; }
+
+template <class WCharT, class SizeT>
+WCharT* wmemcpy (WCharT*, const WCharT*, SizeT) { ncalls++; return 0; }
+
+template <class WCharT, class SizeT>
+WCharT* wmemmove (WCharT*, const WCharT*, SizeT) { ncalls++; return 0; }
+
+template <class WCharT, class SizeT>
+WCharT* wmemset (WCharT*, WCharT, SizeT) { ncalls++; return 0; }
+
+template <class WCharT, class SizeT, class StructTm>
+SizeT wcsftime (WCharT*, SizeT, const WCharT*, const StructTm*)
+{ return ncalls++; }
+
+template <class IntT>
+test_wint_t btowc (IntT) { return ncalls++; }
+
+template <class WIntT>
+int wctob (WIntT) { return ncalls++; }
+
+template <class MBStateT>
+int mbsinit (const MBStateT*) { return ncalls++; }
+
+template <class SizeT, class MBStateT>
+SizeT mbrlen (const char*, SizeT, MBStateT*) { return ncalls++; }
+
+template <class WCharT, class SizeT, class MBStateT>
+SizeT mbrtowc (WCharT*, const char*, SizeT, MBStateT*) { return ncalls++; }
+
+template <class WCharT, class MBStateT>
+test_size_t wcrtomb (char*, WCharT, MBStateT*) { return ncalls++; }
+
+template <class WCharT, class SizeT, class MBStateT>
+SizeT mbsrtowcs (WCharT*, const char**, SizeT, MBStateT*) { return ncalls++; }
+
+template <class WCharT, class SizeT, class MBStateT>
+SizeT wcsrtombs (char*, const WCharT**, SizeT, MBStateT*) { return ncalls++; }
+
+
+template <class WCharT>
+const WCharT* wcschr (const WCharT*, WCharT) { ncalls++; return 0; }
+
+template <class WCharT>
+const WCharT* wcspbrk (const WCharT*, const WCharT*) { ncalls++; return 0; }
+
+template <class WCharT>
+const WCharT* wcsrchr (const WCharT*, WCharT) { ncalls++; return 0; }
+
+template <class WCharT>
+const WCharT* wcsstr (const WCharT*, const WCharT*) { ncalls++; return 0; }
+
+template <class WCharT, class SizeT>
+const WCharT* wmemchr (const WCharT*, WCharT, SizeT) { ncalls++; return 0; }
+
+}   // namespace std
+
+
+struct UniqType;
+
+#define GET_TYPE_NAME(T)                                                \
+    template <class Type>                                               \
+    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 <cstdarg>       // for va_list
+#include <cstdio>        // for FILE
+#include <printf.h>      // 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 <cwchar>",
+                    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



Mime
View raw message