Return-Path: Delivered-To: apmail-incubator-stdcxx-dev-archive@www.apache.org Received: (qmail 53172 invoked from network); 19 Apr 2006 17:13:27 -0000 Received: from hermes.apache.org (HELO mail.apache.org) (209.237.227.199) by minotaur.apache.org with SMTP; 19 Apr 2006 17:13:27 -0000 Received: (qmail 98303 invoked by uid 500); 19 Apr 2006 17:13:15 -0000 Delivered-To: apmail-incubator-stdcxx-dev-archive@incubator.apache.org Received: (qmail 98140 invoked by uid 500); 19 Apr 2006 17:13:15 -0000 Mailing-List: contact stdcxx-dev-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-dev@incubator.apache.org Received: (qmail 98076 invoked by uid 99); 19 Apr 2006 17:13:14 -0000 Received: from asf.osuosl.org (HELO asf.osuosl.org) (140.211.166.49) by apache.org (qpsmtpd/0.29) with ESMTP; Wed, 19 Apr 2006 10:13:14 -0700 X-ASF-Spam-Status: No, hits=-0.0 required=10.0 tests=SPF_PASS X-Spam-Check-By: apache.org Received-SPF: pass (asf.osuosl.org: domain of AntonP@moscow.vdiweb.com designates 195.210.189.132 as permitted sender) Received: from [195.210.189.132] (HELO exmsk.moscow.vdiweb.com) (195.210.189.132) by apache.org (qpsmtpd/0.29) with ESMTP; Wed, 19 Apr 2006 10:13:11 -0700 Received: from [10.11.0.125] ([10.11.0.125]) by exmsk.moscow.vdiweb.com with Microsoft SMTPSVC(6.0.3790.1830); Wed, 19 Apr 2006 19:34:27 +0400 Message-ID: <44465890.4090006@moscow.vdiweb.com> Date: Wed, 19 Apr 2006 19:34:40 +0400 From: Anton Pevtsov User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.0; en-US; rv:1.7) Gecko/20040514 X-Accept-Language: en-us, en MIME-Version: 1.0 To: stdcxx-dev@incubator.apache.org Subject: Tests for lib.string::find methods Content-Type: multipart/mixed; boundary="------------050603030909050800010708" X-OriginalArrivalTime: 19 Apr 2006 15:34:27.0072 (UTC) FILETIME=[BE1A8000:01C663C6] X-Virus-Checked: Checked by ClamAV on apache.org X-Spam-Rating: minotaur.apache.org 1.6.2 0/1000/N --------------050603030909050800010708 Content-Type: text/plain; charset=us-ascii; format=flowed Content-Transfer-Encoding: 7bit The attached file contains the test for lib.string.find methods. I've implemented the tests for other find methods too using the same test schema. But there is a question: shall I join the tests into one test .cpp file as it was in previous versions? Each test includes 7 test cases arrays, so I think that it will be more useful to keep them in separate .cpp files. With best wishes, Anton Pevtsov --------------050603030909050800010708 Content-Type: text/plain; name="21.string.find.cpp" Content-Transfer-Encoding: 7bit Content-Disposition: inline; filename="21.string.find.cpp" /*************************************************************************** * * 21.string.find.cpp - string test exercising lib.string.find * * $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 // for string #include // for free(), size_t #include // for length_error #include // for rw_enabled() #include // for rw_test() #include // for rw_asnprintf() #include // 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_ ("find") { /* 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 }; /**************************************************************************/ // for convenience and brevity #define LSTR long_string #define LLEN long_string_len static const std::size_t long_string_len = 4096; static char long_string [long_string_len]; static const char* const exp_exceptions[] = { "unknown exception", "length_error" }; /**************************************************************************/ typedef enum FindTags { // find (const charT* s) find_ptr = 1, // find (const basic_string& str) find_str = 2, // find (const charT* s, size_type pos) find_ptr_off = 3, // find (const charT* s, size_type pos, size_type n) find_ptr_off_size = 4, // find (const basic_string& str, size_type pos) find_str_off = 5, // find (charT c) find_val = 6, // find (charT c, size_type pos) find_val_off = 7 } FTags; /**************************************************************************/ struct TestCase { int line; int pos; int count; int ch; const char* str; std::size_t str_len; const char* src; std::size_t src_len; int res; int bthrow; }; /**************************************************************************/ 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_find_ptr; // for --no-find-ptr static int rw_opt_no_find_str; // for --no-find-str static int rw_opt_no_find_ptr_off; // for --no-find-ptr-off static int rw_opt_no_find_ptr_off_size; // for --no-find-ptr-off-size static int rw_opt_no_find_str_off; // for --no-find-str-off static int rw_opt_no_find_val; // for --no-find-val static int rw_opt_no_find_val_off; // for --no-find-val-off /**************************************************************************/ // used to exercise // find (const charT* s) static const TestCase ptr_test_cases [] = { #undef TEST #define TEST(str, src, res) \ { __LINE__, -1, -1, -1, str, sizeof str - 1, src, \ sizeof src - 1, res, 0 } // +----------------------------------- controlled sequence // | +--------------------- sequence to be found // | | +------ expected result // | | | // | | | // V V V TEST ("ab", "a", 0), TEST ("", "", 0), TEST ("", "\0", 0), TEST ("", "a", -1), TEST ("\0", "", 0), TEST ("\0", "\0", 0), TEST ("\0", "a", -1), TEST ("bbcdefghij", "a", -1), TEST ("abcdefghij", "a", 0), TEST ("abcdefghij", "f", 5), TEST ("abcdefghij", "j", 9), TEST ("edfcbbhjig", "cba", -1), TEST ("edfcbahjig", "cba", 3), TEST ("edfcbahcba", "cba", 3), TEST ("cbacbahjig", "cba", 0), TEST ("e\0cb\0\0g", "b\0\0g", 3), TEST ("e\0cb\0\0g", "ecb", -1), TEST ("\0cb\0\0ge", "\0\0ge", 0), TEST ("\0cb\0\0ge", "cb\0", 1), TEST ("e\0cbg\0\0", "bg", 3), TEST ("e\0cbg\0\0", "cba", -1), TEST ("bcbedfbjih", "a", -1), TEST ("bcaedfajih", "a", 2), TEST ("bcedfaajih", "a", 5), TEST ("bcaaedfaji", "a", 2), TEST ("aaaaaaaaaa", "aaaaaaaaaa", 0), TEST ("aaaaabaaaa", "aaaaaaaaaa", -1), TEST ("aaaabaaaaa", "aaaaa", 5), TEST ("aaaaaaaaaa", "aaaaaaaaa", 0), TEST ("aaaaaaaaa", "aaaaaaaaaa", -1), TEST (LSTR, "", 0), TEST (LSTR, "a", -1), TEST (LSTR, "x", 0), TEST (LSTR, "xxx", 0), TEST (LSTR, "xxa", -1), TEST ("abc", LSTR, -1), TEST ("xxxxxxxxxx", LSTR, -1), TEST ("abcdefghij", 0, 0), TEST ("\0cb\0\0ge", 0, 0), TEST (LSTR, 0, 0), TEST ("last test", "test", 5) }; /**************************************************************************/ // used to exercise // find (const basic_string& str) static const TestCase str_test_cases [] = { #undef TEST #define TEST(str, src, res) \ { __LINE__, -1, -1, -1, str, sizeof str - 1, src, \ sizeof src - 1, res, 0 } // +------------------------------------ controlled sequence // | +---------------------- sequence to be found // | | +------- expected result // | | | // | | | // V V V TEST ("ab", "a", 0), TEST ("", "", 0), TEST ("", "\0", -1), TEST ("", "a", -1), TEST ("\0", "", 0), TEST ("\0", "\0", 0), TEST ("\0", "\0\0", -1), TEST ("\0", "a", -1), TEST ("\0a", "a\0", -1), TEST ("bbcdefghij", "a", -1), TEST ("abcdefghij", "a", 0), TEST ("abcdefghij", "f", 5), TEST ("abcdefghij", "j", 9), TEST ("edfcbbhjig", "cba", -1), TEST ("edfcbahjig", "cba", 3), TEST ("edfcbahcba", "cba", 3), TEST ("cbacbahjig", "cba", 0), TEST ("e\0cb\0\0g", "b\0\0g", 3), TEST ("e\0cb\0\0g", "ecb", -1), TEST ("\0cb\0\0ge", "\0\0ge", 3), TEST ("\0cb\0\0ge", "cb\0", 1), TEST ("\0cb\0\0ge", "cb\0a", -1), TEST ("e\0cbg\0\0", "bg", 3), TEST ("e\0cbg\0\0", "\0\0", 5), TEST ("e\0cbg\0\0", "\0\0a", -1), TEST ("e\0cbg\0\0", "cba", -1), TEST ("bcbedfbjih", "a", -1), TEST ("bcaedfajih", "a", 2), TEST ("bcedfaajih", "a", 5), TEST ("bcaaedfaji", "a", 2), TEST ("aaaaaaaaaa", "aaaaaaaaaa", 0), TEST ("aaaaabaaaa", "aaaaaaaaaa", -1), TEST ("aaaabaaaaa", "aaaaa", 5), TEST ("aaaaaaaaaa", "aaaaaaaaa", 0), TEST ("aaaaaaaaa", "aaaaaaaaaa", -1), TEST (LSTR, "", 0), TEST (LSTR, "a", -1), TEST (LSTR, "x", 0), TEST (LSTR, "xxx", 0), TEST (LSTR, "xxa", -1), TEST ("abc", LSTR, -1), TEST ("xxxxxxxxxx", LSTR, -1), TEST ("abcdefghij", 0, 0), TEST ("\0cb\0\0ge", 0, 0), TEST (LSTR, 0, 0), TEST ("last test", "test", 5) }; /**************************************************************************/ // used to exercise // find (const charT* s, size_type pos) static const TestCase ptr_off_test_cases [] = { #undef TEST #define TEST(str, src, pos, res) \ { __LINE__, pos, -1, -1, str, sizeof str - 1, src, \ sizeof src - 1, res, 0 } // +-------------------------------------- controlled sequence // | +------------------------- sequence to be found // | | +--------- find() pos argument // | | | +----- expected result // | | | | // | | | | // V V V V TEST ("ab", "a", 0, 0), TEST ("", "", 0, 0), TEST ("", "\0", 0, 0), TEST ("", "a", 0, -1), TEST ("\0", "", 0, 0), TEST ("\0", "\0", 0, 0), TEST ("\0", "\0", 1, 1), TEST ("\0", "a", 0, -1), TEST ("bbcdefghij", "a", 0, -1), TEST ("abcdefghij", "a", 0, 0), TEST ("abcdefghij", "a", 2, -1), TEST ("abcdefghij", "f", 2, 5), TEST ("abcdefghij", "f", 7, -1), TEST ("abcdefghij", "j", 9, 9), TEST ("edfcbbhjig", "cba", 0, -1), TEST ("edfcbahjig", "cba", 1, 3), TEST ("edfcbahjig", "cba", 4, -1), TEST ("edfcbahcba", "cba", 1, 3), TEST ("edfcbahcba", "cba", 5, 7), TEST ("cbacbahjig", "cba", 5, -1), TEST ("e\0cb\0\0g", "b\0\0g", 0, 3), TEST ("e\0cb\0\0g", "b\0\0g", 4, -1), TEST ("e\0cb\0\0g", "ecb", 0, -1), TEST ("\0cb\0\0ge", "\0\0ge", 6, 6), TEST ("\0cb\0\0ge", "cb\0", 1, 1), TEST ("e\0cbg\0\0", "bg", 1, 3), TEST ("e\0cbg\0\0", "cba", 0, -1), TEST ("bcbedfbjih", "a", 0, -1), TEST ("bcaedfajih", "a", 1, 2), TEST ("bcedfaajih", "a", 6, 6), TEST ("bcaaedfaji", "a", 5, 7), TEST ("aaaaaaaaaa", "aaaaaaaaaa", 0, 0), TEST ("aaaaaaaaaa", "aaaaaaaaaa", 1, -1), TEST ("aaaaabaaaa", "aaaaaaaaaa", 0, -1), TEST ("aaaabaaaaa", "aaaaa", 0, 5), TEST ("aaaabaaaaa", "aaaaa", 6, -1), TEST ("aaaaaaaaaa", "aaaaaaaaa", 0, 0), TEST ("aaaaaaaaaa", "aaaaaaaaa", 1, 1), TEST ("aaaaaaaaaa", "aaaaaaaaa", 2, -1), TEST ("aaaaaaaaa", "aaaaaaaaaa", 0, -1), TEST (LSTR, "", 0, 0), TEST (LSTR, "a", 0, -1), TEST (LSTR, "x", 0, 0), TEST (LSTR, "xxx", 10, 10), TEST (LSTR, "xxa", 10, -1), TEST ("abc", LSTR, 2, -1), TEST ("xxxxxxxxxx", LSTR, 0, -1), TEST (LSTR, "xxx", LLEN - 4, LLEN - 4), TEST (LSTR, "xxx", LLEN - 3, -1), TEST ("abcdefghij", 0, 0, 0), TEST ("abcdefghij", 0, 1, -1), TEST ("\0cb\0\0ge", 0, 5, 5), TEST (LSTR, 0, 0, 0), TEST (LSTR, 0, 1, -1), TEST ("", "", 1, -1), TEST ("abcdefghij", "abc", 10, -1), TEST ("abcdefghij", "cba", 10, -1), TEST ("last test", "test", 0, 5) }; /**************************************************************************/ // used to exercise // find (const charT* s, size_type pos, size_type n) static const TestCase ptr_off_size_test_cases [] = { #undef TEST #define TEST(str, src, pos, count, res, bthrow) \ { __LINE__, pos, count, -1, str, sizeof str - 1, src, \ sizeof src - 1, res, bthrow } // +--------------------------------------- controlled sequence // | +-------------------------- sequence to be found // | | +---------- find() pos argument // | | | +------ find() n argument // | | | | +-- expected result // | | | | | exception info // | | | | | | 0 - no exception // | | | | | | 1 - length_error // | | | | | | // | | | | | +----+ // V V V V V V TEST ("ab", "a", 0, 1, 0, 0), TEST ("", "", 0, 0, 0, 0), TEST ("", "\0", 0, 0, 0, 0), TEST ("", "\0", 0, 1, -1, 0), TEST ("", "a", 0, 0, 0, 0), TEST ("", "a", 0, 1, -1, 0), TEST ("\0", "", 0, 0, 0, 0), TEST ("\0", "\0", 0, 1, 0, 0), TEST ("\0", "\0", 1, 1, -1, 0), TEST ("\0\0", "\0\0", 1, 1, 1, 0), TEST ("\0", "a", 0, 1, -1, 0), TEST ("edfcbbhjig", "cba", 0, 3, -1, 0), TEST ("edfcbbhjig", "cba", 0, 2, 3, 0), TEST ("edfcbahjig", "cba", 1, 3, 3, 0), TEST ("edfcbahjig", "cba", 4, 3, -1, 0), TEST ("edfcbahjig", "cba", 4, 1, -1, 0), TEST ("edfcbahcba", "cba", 1, 3, 3, 0), TEST ("edfcbehcba", "cba", 1, 2, 3, 0), TEST ("edfcbahcba", "cba", 5, 3, 7, 0), TEST ("cbacbahjig", "cba", 5, 3, -1, 0), TEST ("cbacbahjcg", "cba", 5, 1, 8, 0), TEST ("e\0cb\0\0g", "b\0\0g", 0, 4, 3, 0), TEST ("e\0cb\0\0g", "b\0\0g", 4, 4, -1, 0), TEST ("e\0cb\0\0b", "b\0\0g", 4, 1, 6, 0), TEST ("\0b\0\0gb\0","b\0\0g", 2, 2, 5, 0), TEST ("\0b\0\0gb\0","b\0\0g", 0, 2, 1, 0), TEST ("\0b\0\0gb\0","b\0\0g", 0, 3, 1, 0), TEST ("e\0cb\0\0g", "ecb", 0, 2, -1, 0), TEST ("\0cb\0\0ge", "\0\0ge", 6, 4, -1, 0), TEST ("\0cb\0\0ge", "\0\0ge", 6, 0, 6, 0), TEST ("\0cb\0\0ge", "cb\0", 1, 3, 1, 0), TEST ("e\0cbg\0\0", "bg", 1, 2, 3, 0), TEST ("e\0cbg\0\0", "cba", 0, 3, -1, 0), TEST ("e\0cbg\0\0", "cba", 0, 2, 2, 0), TEST ("e\0a\0", "e\0a\0\0", 0, 4, 0, 0), TEST ("e\0a\0", "e\0a\0\0", 0, 5, -1, 0), TEST ("ee\0a\0", "e\0a\0\0", 1, 4, 1, 0), TEST ("ee\0a\0", "e\0a\0\0", 1, 5, -1, 0), TEST ("aaaaaaaaaa", "aaaaaaaaaa", 0, 10, 0, 0), TEST ("aaaaaaaaaa", "aaaaaaaaaa", 1, 10, -1, 0), TEST ("aaaaaaaaaa", "aaaaaaaaaa", 1, 9, 1, 0), TEST ("aaaaabaaaa", "aaaaaaaaaa", 0, 10, -1, 0), TEST ("aaaaabaaaa", "aaaaaaaaaa", 1, 4, 1, 0), TEST ("aaaaabaaaa", "aaaaaaaaaa", 2, 4, 6, 0), TEST ("aaaabaaaaa", "aaaaa", 0, 5, 5, 0), TEST ("aaaabaaaaa", "aaaaa", 0, 4, 0, 0), TEST ("aaaabaaaaa", "aaaaa", 6, 5, -1, 0), TEST ("aaaaaaaaaa", "aaaaaaaaa", 0, 9, 0, 0), TEST ("aaaaaaaaaa", "aaaaaaaaa", 1, 9, 1, 0), TEST ("aaaaaaaaaa", "aaaaaaaaa", 2, 9, -1, 0), TEST ("aaaaaaaaaa", "aaaaaaaaa", 2, 8, 2, 0), TEST ("aaaaaaaaa", "aaaaaaaaaa", 0, 10, -1, 0), TEST ("aaaaaaaaa", "aaaaaaaaaa", 0, 7, 0, 0), TEST (LSTR, "", 0, 0, 0, 0), TEST (LSTR, "a", 0, 1, -1, 0), TEST (LSTR, "x", 0, 1, 0, 0), TEST (LSTR, "xxx", 10, 3, 10, 0), TEST (LSTR, "xxa", 10, 3, -1, 0), TEST (LSTR, "xxa", 10, 2, 10, 0), TEST ("abc", LSTR, 2, 10, -1, 0), TEST ("xxxxxxxxxx", LSTR, 0, LLEN - 1, -1, 0), TEST ("xxxxxxxxxx", LSTR, 2, 4, 2, 0), TEST (LSTR, "xxx", LLEN - 4, 3, LLEN - 4, 0), TEST (LSTR, "xxx", LLEN - 3, 3, -1, 0), TEST (LSTR, "xxx", LLEN - 3, 2, LLEN - 3, 0), TEST ("abcdefghij", 0, 0, 9, 0, 0), TEST ("abcdefghij", 0, 1, 9, -1, 0), TEST ("\0cb\0\0ge", 0, 5, 7, -1, 0), TEST ("\0cb\0ge\0", 0, 6, 1, 6, 0), TEST (LSTR, 0, 0, LLEN - 1, 0, 0), TEST (LSTR, 0, 1, LLEN - 1, -1, 0), TEST (LSTR, 0, 5, LLEN - 6, 5, 0), TEST ("", "", 1, 0, -1, 0), TEST ("abcdefghij", "abc", 10, 3, -1, 0), TEST ("abcdefghij", "cba", 10, 1, -1, 0), #ifndef _RWSTD_NO_EXCEPTIONS TEST ("", "cba", 0, -1, 0, 1), TEST ("abcdefghij", "cba", 0, -1, 0, 1), TEST (LSTR, "xxx", 0, -1, 0, 1), TEST ("abcdefghij", LSTR, 0, -1, 0, 1), #endif // _RWSTD_NO_EXCEPTIONS TEST ("last test", "test", 0, 4, 5, 0) }; /**************************************************************************/ // used to exercise // find (const basic_string& str, size_type pos) static const TestCase str_off_test_cases [] = { #undef TEST #define TEST(str, src, pos, res) \ { __LINE__, pos, -1, -1, str, sizeof str - 1, src, \ sizeof src - 1, res, 0 } // +--------------------------------------- controlled sequence // | +------------------------- sequence to be found // | | +---------- find() pos argument // | | | +------ expected result // | | | | // | | | | // V V V V TEST ("ab", "a", 0, 0), TEST ("", "", 0, 0), TEST ("", "\0", 0, -1), TEST ("", "a", 0, -1), TEST ("\0", "", 0, 0), TEST ("\0", "\0", 0, 0), TEST ("\0", "\0", 1, -1), TEST ("\0\0", "\0", 1, 1), TEST ("\0", "a", 0, -1), TEST ("bbcdefghij", "a", 0, -1), TEST ("abcdefghij", "a", 0, 0), TEST ("abcdefghij", "a", 2, -1), TEST ("abcdefghij", "f", 2, 5), TEST ("abcdefghij", "f", 7, -1), TEST ("abcdefghij", "j", 9, 9), TEST ("edfcbbhjig", "cba", 0, -1), TEST ("edfcbahjig", "cba", 1, 3), TEST ("edfcbahjig", "cba", 4, -1), TEST ("edfcbahcba", "cba", 1, 3), TEST ("edfcbahcba", "cba", 5, 7), TEST ("cbacbahjig", "cba", 5, -1), TEST ("e\0cb\0\0g", "b\0\0g", 0, 3), TEST ("e\0cb\0\0g", "b\0\0g", 4, -1), TEST ("e\0cb\0\0g", "ecb", 0, -1), TEST ("\0cb\0\0ge", "\0\0ge", 6, -1), TEST ("\0cb\0\0ge", "\0\0ge", 1, 3), TEST ("\0cb\0\0ge", "cb\0", 1, 1), TEST ("\0cbg\0\0e", "cb\0", 1, -1), TEST ("e\0cbg\0\0", "bg", 1, 3), TEST ("e\0cbg\0\0", "cba", 0, -1), TEST ("bcbedfbjih", "a", 0, -1), TEST ("bcaedfajih", "a", 1, 2), TEST ("bcedfaajih", "a", 6, 6), TEST ("bcaaedfaji", "a", 5, 7), TEST ("aaaaaaaaaa", "aaaaaaaaaa", 0, 0), TEST ("aaaaaaaaaa", "aaaaaaaaaa", 1, -1), TEST ("aaaaabaaaa", "aaaaaaaaaa", 0, -1), TEST ("aaaabaaaaa", "aaaaa", 0, 5), TEST ("aaaabaaaaa", "aaaaa", 6, -1), TEST ("aaaaaaaaaa", "aaaaaaaaa", 0, 0), TEST ("aaaaaaaaaa", "aaaaaaaaa", 1, 1), TEST ("aaaaaaaaaa", "aaaaaaaaa", 2, -1), TEST ("aaaaaaaaa", "aaaaaaaaaa", 0, -1), TEST (LSTR, "", 0, 0), TEST (LSTR, "a", 0, -1), TEST (LSTR, "x", 0, 0), TEST (LSTR, "xxx", 10, 10), TEST (LSTR, "xxa", 10, -1), TEST ("abc", LSTR, 2, -1), TEST ("xxxxxxxxxx", LSTR, 0, -1), TEST (LSTR, "xxx", LLEN - 4, LLEN - 4), TEST (LSTR, "xxx", LLEN - 3, -1), TEST ("abcdefghij", 0, 0, 0), TEST ("abcdefghij", 0, 1, -1), TEST ("\0cb\0\0ge", 0, 5, -1), TEST ("\0cb\0\0ge", 0, 0, 0), TEST (LSTR, 0, 0, 0), TEST (LSTR, 0, 1, -1), TEST ("", "", 1, -1), TEST ("abcdefghij", "abc", 10, -1), TEST ("abcdefghij", "cba", 10, -1), TEST ("last test", "test", 0, 5) }; /**************************************************************************/ // used to exercise // find (charT c) static const TestCase val_test_cases [] = { #undef TEST #define TEST(str, ch, res) \ { __LINE__, -1, -1, ch, str, sizeof str - 1, 0, 0, res, 0 } // +----------------------------- controlled sequence // | +-------------- character to be found // | | +-------- expected result // | | | // | | | // V V V TEST ("ab", 'a', 0), TEST ("", 'a', -1), TEST ("", '\0', -1), TEST ("\0", '\0', 0), TEST ("\0\0", '\0', 0), TEST ("\0", 'a', -1), TEST ("e\0cb\0\0g", '\0', 1), TEST ("e\0cb\0\0g", 'b', 3), TEST ("e\0cb\0\0g", 'a', -1), TEST ("\0cbge\0\0", '\0', 0), TEST ("\0cbge\0\0", 'b', 2), TEST ("\0cbge\0\0", 'a', -1), TEST (LSTR, 'x', 0), TEST (LSTR, '\0', -1), TEST (LSTR, 'a', -1), TEST ("last test", 't', 3) }; /**************************************************************************/ // used to exercise // find (charT c, size_type pos) static const TestCase val_off_test_cases [] = { #undef TEST #define TEST(str, ch, pos, res) \ { __LINE__, pos, -1, ch, str, sizeof str - 1, 0, 0, res, 0 } // +------------------------------ controlled sequence // | +--------------- character to be found // | | +--------- find() pos argument // | | | +----- expected result // | | | | // | | | | // V V V V TEST ("ab", 'a', 0, 0), TEST ("", 'a', 0, -1), TEST ("", '\0', 0, -1), TEST ("\0", '\0', 1, -1), TEST ("\0", 'a', 0, -1), TEST ("\0\0", '\0', 1, 1), TEST ("\0\0", 'a', 3, -1), TEST ("\0\0", '\0', 3, -1), TEST ("e\0cb\0\0g", '\0', 1, 1), TEST ("e\0cb\0\0g", '\0', 2, 4), TEST ("e\0cb\0\0g", '\0', 6, -1), TEST ("e\0cb\0\0g", 'b', 1, 3), TEST ("e\0cb\0\0g", 'b', 4, -1), TEST ("e\0cb\0\0g", 'a', 0, -1), TEST ("\0cbge\0\0", '\0', 0, 0), TEST ("\0cbge\0\0", '\0', 1, 5), TEST ("\0cbge\0\0", '\0', 9, -1), TEST ("\0cbge\0\0", 'b', 0, 2), TEST ("\0bgeb\0\0", 'b', 2, 4), TEST ("\0cbge\0\0", 'a', 1, -1), TEST (LSTR, 'x', 0, 0), TEST (LSTR, 'x', 5, 5), TEST (LSTR, '\0', 0, -1), TEST (LSTR, 'a', 3, -1), TEST (LSTR, 'x', LLEN - 1, -1), TEST (LSTR, 'x', LLEN - 2, LLEN - 2), TEST ("last test", 't', 0, 3) }; /**************************************************************************/ static const struct FunctionTag { FTags f_tag; const int *p_opt; const TestCase *t_cases; std::size_t n_cases; const char *str_hdr; } function_tags [] = { #undef TEST #define TEST(tag, opt, cases, hdr) \ { tag, &opt, cases, sizeof cases / sizeof *cases, hdr } TEST (find_ptr, rw_opt_no_find_ptr, ptr_test_cases, "find (const charT* s)"), TEST (find_str, rw_opt_no_find_str, str_test_cases, "find (const basic_string& str)"), TEST (find_ptr_off, rw_opt_no_find_ptr_off, ptr_off_test_cases, "find (const charT* s, size_type pos)"), TEST (find_ptr_off_size, rw_opt_no_find_ptr_off_size, ptr_off_size_test_cases, "find (const charT* s, size_type pos, size_type n)"), TEST (find_str_off, rw_opt_no_find_str_off, str_off_test_cases, "find (const basic_string& str, size_type pos)"), TEST (find_val, rw_opt_no_find_val, val_test_cases, "find (charT c)"), TEST (find_val_off, rw_opt_no_find_val_off, val_off_test_cases, "find (charT c, size_type pos)") }; /**************************************************************************/ template void test_find (charT, Traits*, const FTags which, const TestCase &cs, const char *find_fmt) { typedef std::basic_string > TestString; static charT wstr [LLEN]; static charT wsrc [LLEN]; rw_widen (wstr, cs.str, cs.str_len); rw_widen (wsrc, cs.src, cs.src_len); const TestString s_str (wstr, cs.str_len); const TestString s_src (wsrc, cs.src_len); std::size_t res = 0; std::size_t exp_res = -1 != cs.res ? cs.res : TestString::npos; std::size_t count = cs.count >= 0 ? cs.count : s_src.max_size () + 1; #ifndef _RWSTD_NO_EXCEPTIONS // is some exception expected ? const char* expected = 0; if (1 == cs.bthrow) expected = exp_exceptions [1]; const char* caught = 0; try { #endif // _RWSTD_NO_EXCEPTIONS switch (which) { case find_ptr: { res = s_str.find (cs.src ? wsrc : s_str.c_str ()); break; } case find_str: { res = s_str.find (cs.src ? s_src : s_str); break; } case find_ptr_off: { res = s_str.find (cs.src ? wsrc : s_str.c_str (), cs.pos); break; } case find_ptr_off_size: { res = s_str.find (cs.src ? wsrc : s_str.c_str (), cs.pos, count); break; } case find_str_off: { res = s_str.find (cs.src ? s_src : s_str, cs.pos); break; } case find_val: { res = s_str.find (make_char ((char) cs.ch, (charT*)0)); break; } case find_val_off: { res = s_str.find (make_char ((char) cs.ch, (charT*)0), cs.pos); break; } default: RW_ASSERT ("test logic error: unknown find overload"); return; } // verify the returned value rw_assert (exp_res == res, 0, cs.line, "line %d. %s == %{?}%zu%{;}%{?}npos%{;}, " "got %{?}%zu%{;}%{?}npos%{;}", __LINE__, find_fmt, -1 != cs.res, exp_res, -1 == cs.res, TestString::npos != res, res, TestString::npos == res); #ifndef _RWSTD_NO_EXCEPTIONS } catch (std::length_error) { 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, "line %d. %s %{?}expected %s, caught %s" "%{:}unexpectedly caught %s%{;}", __LINE__, find_fmt, 0 != expected, expected, caught, caught); } /**************************************************************************/ void get_find_format (char** pbuf, std::size_t* pbufsize, const MemFun *pfid, const FTags which, const TestCase& cs) { if ( MemFun::DefaultTraits == pfid->tid_ && (MemFun::Char == pfid->cid_ || MemFun::WChar == pfid->cid_)) rw_asnprintf (pbuf, pbufsize, "std::%{?}w%{;}string (%{#*s}).find", MemFun::WChar == pfid->cid_, int (cs.str_len), cs.str); else rw_asnprintf (pbuf, pbufsize, "std::basic_string<%s, %s<%1$s>, %s<%1$s>>(%{#*s})" ".find", pfid->cname_, pfid->tname_, pfid->aname_, int (cs.str_len), cs.str); const bool self = 0 == cs.src; switch (which) { case find_ptr: rw_asnprintf (pbuf, pbufsize, "%{+} (%{?}%{#*s}%{;}%{?}this->c_str ()%{;})", !self, int (cs.src_len), cs.src, self); break; case find_str: rw_asnprintf (pbuf, pbufsize, "%{+} (%{?}string (%{#*s})%{;}%{?}*this%{;})", !self, int (cs.src_len), cs.src, self); break; case find_ptr_off: rw_asnprintf (pbuf, pbufsize, "%{+} (" "%{?}%{#*s}%{;}%{?}this->c_str ()%{;}, %zu)", !self, int (cs.src_len), cs.src, self, cs.pos); break; case find_ptr_off_size: rw_asnprintf (pbuf, pbufsize, "%{+} (" "%{?}%{#*s}%{;}%{?}this->c_str ()%{;}, %zu, %zu)", !self, int (cs.src_len), cs.src, self, cs.pos, cs.count); break; case find_str_off: rw_asnprintf (pbuf, pbufsize, "%{+} (" "%{?}string (%{#*s})%{;}%{?}*this%{;}, %zu)", !self, int (cs.src_len), cs.src, self, cs.pos); break; case find_val: rw_asnprintf (pbuf, pbufsize, "%{+} (%#c)", cs.ch); break; case find_val_off: rw_asnprintf (pbuf, pbufsize, "%{+} (%#c, %zu)", cs.ch, cs.pos); break; } } /**************************************************************************/ void test_find (const MemFun *pfid, const FTags which, const TestCase& cs) { char* buf = 0; std::size_t buf_sz = 0; get_find_format (&buf, &buf_sz, pfid, which, cs); #undef TEST #define TEST(charT, Traits) \ test_find (charT(), (Traits*)0, which, cs, buf) if (MemFun:: DefaultTraits == pfid->tid_) { if (MemFun::Char == pfid->cid_) TEST (char, std::char_traits); #ifndef _RWSTD_NO_WCHAR_T else TEST (wchar_t, std::char_traits); #endif // _RWSTD_NO_WCHAR_T } else { if (MemFun::Char == pfid->cid_) TEST (char, UserTraits); #ifndef _RWSTD_NO_WCHAR_T else if (MemFun::WChar == pfid->cid_) TEST (wchar_t, UserTraits); #endif // _RWSTD_NO_WCHAR_T else TEST (UserChar, UserTraits); } free (buf); } /**************************************************************************/ static void test_find (const MemFun *pfid, const FunctionTag& ftag) { rw_info (0, 0, 0, "std::basic_string<%s, %s<%1$s>, %s<%1$s>>::%s", pfid->cname_, pfid->tname_, pfid->aname_, ftag.str_hdr); for (std::size_t i = 0; i != ftag.n_cases; ++i) { if (!rw_enabled (ftag.t_cases[i].line)) { rw_note (0, 0, __LINE__, "test on line %d disabled", ftag.t_cases[i].line); continue; } // do not exercise exceptions if they were disabled if (0 != rw_opt_no_exceptions && 0 != ftag.t_cases[i].bthrow) continue; test_find (pfid, ftag.f_tag, ftag.t_cases[i]); } } /**************************************************************************/ static void run_test (const MemFun *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::find exceptions tests disabled"); static const std::size_t ftags = sizeof function_tags / sizeof *function_tags; for (std::size_t i = 0; i < ftags; i++) { if (*function_tags[i].p_opt) rw_note (0, 0, 0, "std::basic_string<%s, %s<%1$s>, %s<%1$s>>::" "%s test disabled", pfid->cname_, pfid->tname_, pfid->aname_, function_tags[i].str_hdr); else test_find (pfid, function_tags[i]); } } } /**************************************************************************/ int run_test (int, char*[]) { if ('\0' == LSTR [0]) { // initialize LSTR 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::find 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::find 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.find", 0 /* no comment */, run_test, "|-no-char_traits# " "|-no-user_traits# " "|-no-user_chars# " "|-no-exceptions# " "|-no-find-ptr# " "|-no-find-str# " "|-no-find-ptr-off# " "|-no-find-ptr-off-size# " "|-no-find-str-off# " "|-no-find-val# " "|-no-find-val-off#", &rw_opt_no_char_traits, &rw_opt_no_user_traits, &rw_opt_no_user_chars, &rw_opt_no_exceptions, &rw_opt_no_find_ptr, &rw_opt_no_find_str, &rw_opt_no_find_ptr_off, &rw_opt_no_find_ptr_off_size, &rw_opt_no_find_str_off, &rw_opt_no_find_val, &rw_opt_no_find_val_off); } --------------050603030909050800010708--