stdcxx-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ant...@apache.org
Subject svn commit: r389436 - /incubator/stdcxx/trunk/tests/strings/21.string.copy.cpp
Date Tue, 28 Mar 2006 08:19:53 GMT
Author: antonp
Date: Tue Mar 28 00:19:51 2006
New Revision: 389436

URL: http://svn.apache.org/viewcvs?rev=389436&view=rev
Log:
2006-03-28  Anton Pevtsov  <antonp@moscow.vdiweb.com>

	STDCXX-4
	* 21.string.copy.cpp: New test exercising lib.string.copy.

Added:
    incubator/stdcxx/trunk/tests/strings/21.string.copy.cpp   (with props)

Added: incubator/stdcxx/trunk/tests/strings/21.string.copy.cpp
URL: http://svn.apache.org/viewcvs/incubator/stdcxx/trunk/tests/strings/21.string.copy.cpp?rev=389436&view=auto
==============================================================================
--- incubator/stdcxx/trunk/tests/strings/21.string.copy.cpp (added)
+++ incubator/stdcxx/trunk/tests/strings/21.string.copy.cpp Tue Mar 28 00:19:51 2006
@@ -0,0 +1,434 @@
+/***************************************************************************
+ *
+ * 21.string.copy.cpp - string test exercising [lib.string::copy]
+ *
+ * $Id$ 
+ *
+ ***************************************************************************
+ *
+ * Copyright 2006 The Apache Software Foundation or its licensors,
+ * as applicable.
+ *
+ * Copyright 2006 Rogue Wave Software.
+ *
+ * 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.
+ * 
+ **************************************************************************/
+
+#include <string>       // for string
+#include <cstddef>      // for size_t
+#include <stdexcept>    // for out_of_range
+
+#include <cmdopt.h>     // for rw_enabled()
+#include <driver.h>     // for rw_test()
+
+#include <rw_char.h>    // for rw_widen()
+
+/**************************************************************************/
+
+struct MemFun
+{
+    enum charT  { Char, WChar, UChar };
+    enum Traits { DefaultTraits, UserTraits };
+
+    MemFun (charT cid, const char *cname,
+          Traits tid, const char *tname)
+        : cid_ (cid), tid_ (tid), 
+          cname_ (cname), tname_ (tname), aname_ ("allocator"),
+          fname_ ("copy") { /* empty */ }
+
+    charT       cid_;     // character type id (char or wchar_t)
+    Traits      tid_;     // traits type id (default or user-defined)
+    const char *cname_;   // character type name
+    const char *tname_;   // traits name
+    const char *aname_;   // allocator name
+    const char *fname_;   // function name
+};
+
+/**************************************************************************/
+
+static const int long_string_len = 4096;
+static char long_string [long_string_len];
+
+// for convenience and brevity
+#define LSTR long_string
+#define LLEN long_string_len
+
+static const char* exp_exceptions[] = 
+    { "unknown exception", "out_of_range" };
+
+/**************************************************************************/
+
+static const struct TestCase {
+
+    int  line;
+
+    int  cnt;
+    int  pos;
+
+    const char* str;
+    std::size_t str_len;
+
+    const char* res;
+    std::size_t res_len;
+
+    int bthrow;
+
+} test_cases [] = {
+
+#undef TEST
+#define TEST(str, cnt, pos, res, bthrow)                                    \
+    { __LINE__, cnt, pos, str, sizeof str - 1, res, sizeof res - 1, bthrow }
+
+    //    +------------------------------------------ controlled sequence
+    //    |                 +------------------------ copy() n argument
+    //    |                 |   +-------------------- copy() pos argument
+    //    |                 |   |  +----------------- expected result sequence
+    //    |                 |   |  |             +--- exception info:
+    //    |                 |   |  |             |      0 - no exception    
+    //    |                 |   |  |             |      1 - out_of_range        
+    //    V                 V   V  V             V  
+    TEST ("ab",             2, -1, "ab",         0),
+
+    TEST ("",               0, -1, "",           0),
+    TEST ("",              10, -1, "",           0),
+
+    TEST ("\0",             1, -1, "\0",         0),
+    TEST ("\0\0",           1,  1, "\0",         0),
+    TEST ("\0\0",           2, -1, "\0\0",       0),
+
+    TEST ("abc",            1, -1, "a",          0),
+    TEST ("abc",            1,  1, "b",          0),
+    TEST ("abc",            1,  2, "c",          0),
+
+    TEST ("abc",            0, -1, "",           0),
+    TEST ("abc",            2, -1, "ab",         0),
+    TEST ("abc",            2,  1, "bc",         0),
+    TEST ("abc",            3, -1, "abc",        0),
+    TEST ("abc",           10,  1, "bc",         0),
+    TEST ("abc",            3,  2, "c",          0),
+
+    TEST ("a\0b\0\0c",     10,  1, "\0b\0\0c",   0),
+    TEST ("a\0b\0\0c",     10, -1, "a\0b\0\0c",  0),
+    TEST ("a\0b\0\0c",      1,  1, "\0",         0),
+
+    TEST ("\0ab\0\0\0c\0", 10,  1, "ab\0\0\0c\0",0),
+    TEST ("\0ab\0\0\0c\0",  5, -1, "\0ab\0\0",   0),
+    TEST ("\0ab\0\0\0c\0",  3,  3, "\0\0\0",     0),
+
+    TEST ("\0\0ab\0\0c\0",  6, -1, "\0\0ab\0\0", 0),
+    TEST ("\0\0ab\0\0c\0",  4,  1, "\0ab\0",     0),
+
+    TEST (LSTR,      LLEN - 1,        -1, LSTR,  0),
+    TEST (LSTR,             2,         1, "xx",  0),
+    TEST (LSTR,      LLEN - 1, LLEN -  2, "x",   0),
+
+#ifndef _RWSTD_NO_EXCEPTIONS
+
+    TEST ("\0",     0,          2, "", 1),
+    TEST ("a",      0,         10, "", 1),
+    TEST (LSTR,     0,  LLEN + 10, "", 1),
+
+#endif   // _RWSTD_NO_EXCEPTIONS
+
+    TEST ("last",           4, -1, "last",       0)
+};
+
+/**************************************************************************/
+
+template <class charT, class Traits>
+void test_copy (charT, Traits*,                 
+                const MemFun   *pfid, 
+                const TestCase &cs)
+{
+    RW_ASSERT (0 != pfid);
+
+    typedef std::basic_string <charT, Traits, 
+                               std::allocator<charT> > TestString;
+
+    static charT wstr [LLEN];
+    static const charT eos = charT ();
+
+    const bool use_pos = -1 != cs.pos;
+
+    // construct strings
+    rw_widen (wstr, cs.str, cs.str_len);
+    const TestString str (wstr, cs.str_len);
+
+    const std::size_t min_len =
+        cs.str_len < std::size_t (cs.cnt) ? cs.str_len : cs.cnt;
+
+    // create destination array and initialize it with garbage
+    charT* const s_res = new charT [min_len + 1];
+
+    char cgb = '@';
+    charT wcgb = make_char (cgb, (charT*)0);
+    Traits::assign (s_res, min_len + 1, wcgb);
+
+#ifndef _RWSTD_NO_EXCEPTIONS
+
+    // is some exception expected?
+    const char* const expected =
+        cs.bthrow && use_pos ? exp_exceptions [1] : 0;
+    const char* caught = 0;
+
+    try {
+
+#endif   // _RWSTD_NO_EXCEPTIONS
+
+    const typename TestString::size_type res = use_pos ? 
+        str.copy (s_res, cs.cnt, cs.pos)
+      : str.copy (s_res, cs.cnt);
+
+#define CALLFMAT                                                \
+    "line %d. std::basic_string<%s, %s<%2$s>, %s<%2$s>>"        \
+    "(%{#*s}).copy (%{#*s}, %zu%{?}, %zu%{;})"
+
+#define CALLARGS                                                \
+    __LINE__, pfid->cname_, pfid->tname_, pfid->aname_,         \
+    int (cs.str_len), cs.str, 1, &eos, cs.cnt,                  \
+    use_pos, cs.pos
+
+    // verify the returned value
+    rw_assert (res == cs.res_len, 0, cs.line,
+               CALLFMAT " == %zu, got %zu", 
+               CALLARGS, cs.res_len, res);
+
+    std::size_t match = rw_match (cs.res, s_res, cs.res_len);
+    bool success = match == cs.res_len;
+
+    rw_assert (success, 0, cs.line,
+               CALLFMAT " expected %{#*s}, got %{/*.*Gs}, differ at pos %zu",
+               CALLARGS, int (cs.res_len), cs.res, 
+               int (sizeof (charT)), int (res), s_res, match);
+
+    success = 1 == rw_match (&cgb, &s_res [min_len], 1);
+    rw_assert (success, 0, cs.line,
+               CALLFMAT " detected writing past the end of "
+               "the provided buffer", CALLARGS);
+
+#ifndef _RWSTD_NO_EXCEPTIONS
+
+    }
+    catch (std::out_of_range) {
+        caught = exp_exceptions [1];
+    }
+    catch (...) {
+        caught = exp_exceptions [0];
+    }
+
+#else   // if defined (_RWSTD_NO_EXCEPTIONS)
+    _RWSTD_UNUSED (should_throw);
+#endif   // _RWSTD_NO_EXCEPTIONS
+
+    rw_assert (caught == expected, 0, cs.line,
+               CALLFMAT " %{?}expected %s, caught %s"
+               "%{:}unexpectedly caught %s%{;}",
+               CALLARGS, 0 != expected, expected, caught, caught);
+
+    delete[] s_res;
+}
+
+/**************************************************************************/
+
+static int rw_opt_no_char_traits;              // for --no-char_traits
+static int rw_opt_no_user_traits;              // for --no-user_traits
+
+static int rw_opt_no_user_chars;               // for --no-user_chars
+static int rw_opt_no_exceptions;               // for --no-exceptions
+
+static int rw_opt_no_copy;                     // for --no-copy
+static int rw_opt_no_copy_pos;                 // for --no-copy-pos
+
+/**************************************************************************/
+
+static void 
+note_test_disabled (const MemFun *pfid, bool use_pos)
+{
+    RW_ASSERT (0 != pfid);
+
+    rw_note (0, 0, 0, "std::basic_string<%s, %s<%1$s>, %s<%1$s>>::"
+             "copy (charT* s, size_type n%{?}, size_type pos%{;}) "
+             "test disbled",
+             pfid->cname_, pfid->tname_, pfid->aname_, use_pos);
+}
+
+static void 
+test_copy (const MemFun *pfid) 
+{
+    RW_ASSERT (0 != pfid);
+
+    rw_info (0, 0, 0, "std::basic_string<%s, %s<%1$s>, %s<%1$s>>::"
+             "copy (charT* s, size_type n, size_type pos = 0)",
+             pfid->cname_, pfid->tname_, pfid->aname_);
+
+    if (rw_opt_no_copy)
+        note_test_disabled (pfid, false);
+
+    if (rw_opt_no_copy_pos) 
+        note_test_disabled (pfid, true);
+
+#undef TEST
+#define TEST(charT, Traits, cs)	                            \
+        test_copy (charT(), (Traits*)0, pfid, cs)
+
+    static const std::size_t ncases = sizeof test_cases / sizeof *test_cases;
+
+    for (std::size_t i = 0; i != ncases; ++i) {
+
+        if (!rw_enabled (test_cases[i].line)) {
+            rw_note (0, 0, __LINE__, 
+                     "test on line %d disabled", test_cases[i].line);
+            continue;
+        }
+
+        // do not exercise copy (charT* s, size_type n)
+        if (rw_opt_no_copy && -1 == test_cases[i].pos)
+            continue;
+
+        // do not exercise copy (charT* s, size_type n, size_type pos)
+        if (rw_opt_no_copy_pos && -1 != test_cases[i].pos)
+            continue;
+
+        // do not exercise exceptions if they were disabled
+        if (0 != rw_opt_no_exceptions && 0 != test_cases[i].bthrow)
+            continue;
+
+        if (MemFun:: DefaultTraits == pfid->tid_) {
+            if (MemFun::Char == pfid->cid_)
+                TEST (char, std::char_traits<char>, test_cases[i]);
+
+#ifndef _RWSTD_NO_WCHAR_T
+            else
+                TEST (wchar_t, std::char_traits<wchar_t>, test_cases[i]);
+#endif   // _RWSTD_NO_WCHAR_T
+
+        }
+        else {
+            if (MemFun::Char == pfid->cid_)
+                TEST (char, UserTraits<char>, test_cases[i]);
+
+#ifndef _RWSTD_NO_WCHAR_T
+            else if (MemFun::WChar == pfid->cid_)
+                TEST (wchar_t, UserTraits<wchar_t>, test_cases[i]);
+#endif   // _RWSTD_NO_WCHAR_T
+
+            else
+                TEST (UserChar, UserTraits<UserChar>, test_cases[i]);
+        }
+    }
+}
+
+/**************************************************************************/
+
+static void
+run_test (const MemFun *pfid)
+{
+    RW_ASSERT (0 != pfid);
+
+    if (MemFun::UserTraits == pfid->tid_ && rw_opt_no_user_traits) {
+        rw_note (1 < rw_opt_no_user_traits++, 0, 0,
+                 "user defined traits test disabled");
+    }
+    else if (MemFun::DefaultTraits == pfid->tid_  && rw_opt_no_char_traits) {
+        rw_note (1 < rw_opt_no_char_traits++, 0, 0,
+                 "char_traits test disabled");
+    }
+    else {
+
+        if (rw_opt_no_exceptions)
+            rw_note (1 < rw_opt_no_exceptions++, 0, 0,
+                     "string::copy exceptions tests disabled");
+
+        test_copy (pfid);
+    }
+}
+
+/**************************************************************************/
+
+int run_test (int, char*[])
+{
+    if ('\0' == LSTR [0]) {
+        // initialize long_string
+        for (std::size_t i = 0; i != sizeof LSTR - 1; ++i)
+            LSTR [i] = 'x';
+    }
+
+    if (rw_enabled ("char")) {
+
+        MemFun fid (MemFun::Char, "char", MemFun::DefaultTraits, 0);
+
+        fid.tname_ = "char_traits";
+
+        run_test (&fid);
+
+        fid.tid_   = MemFun::UserTraits;
+        fid.tname_ = "UserTraits";
+
+        run_test (&fid);
+    }
+    else
+        rw_note (0, 0, 0, "string::copy char tests disabled");
+
+    if (rw_enabled ("wchar_t")) {
+
+        MemFun fid (MemFun::WChar, "wchar_t", MemFun::DefaultTraits, 0);
+
+        fid.tname_ = "char_traits";
+
+        run_test (&fid);
+
+        fid.tid_   = MemFun::UserTraits;
+        fid.tname_ = "UserTraits";
+
+        run_test (&fid);
+    }
+    else
+        rw_note (0, 0, 0, "string::copy wchar tests disabled");
+
+    if (rw_opt_no_user_chars) {
+        rw_note (0, 0, 0, "user defined chars test disabled");
+    }
+    else {
+        MemFun fid (MemFun::UChar, "UserChar", MemFun::UserTraits, 0);
+        fid.tname_ = "UserTraits";
+        run_test (&fid);
+    }
+
+    // silence a bogus EDG eccp remark #550-D:
+    // variable "exp_exceptions" was set but never used
+    _RWSTD_UNUSED (exp_exceptions);
+
+    return 0;
+}
+
+/**************************************************************************/
+
+int main (int argc, char** argv)
+{
+    return rw_test (argc, argv, __FILE__,
+                    "lib.string.copy",
+                    0 /* no comment */, run_test,
+                    "|-no-char_traits# "
+                    "|-no-user_traits# "
+                    "|-no-user_chars# "
+                    "|-no-exceptions# "
+                    "|-no-copy# "
+                    "|-no-copy-pos#",
+                    &rw_opt_no_char_traits,
+                    &rw_opt_no_user_traits,
+                    &rw_opt_no_user_chars,
+                    &rw_opt_no_exceptions,
+                    &rw_opt_no_copy,
+                    &rw_opt_no_copy_pos);
+}

Propchange: incubator/stdcxx/trunk/tests/strings/21.string.copy.cpp
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: incubator/stdcxx/trunk/tests/strings/21.string.copy.cpp
------------------------------------------------------------------------------
    svn:keywords = Id



Mime
View raw message