Return-Path: Delivered-To: apmail-incubator-stdcxx-commits-archive@www.apache.org Received: (qmail 52676 invoked from network); 2 May 2006 08:42:05 -0000 Received: from hermes.apache.org (HELO mail.apache.org) (209.237.227.199) by minotaur.apache.org with SMTP; 2 May 2006 08:42:04 -0000 Received: (qmail 30577 invoked by uid 500); 2 May 2006 08:41:47 -0000 Delivered-To: apmail-incubator-stdcxx-commits-archive@incubator.apache.org Received: (qmail 30555 invoked by uid 500); 2 May 2006 08:41:47 -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 30544 invoked by uid 99); 2 May 2006 08:41:46 -0000 Received: from asf.osuosl.org (HELO asf.osuosl.org) (140.211.166.49) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 02 May 2006 01:41:46 -0700 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; Tue, 02 May 2006 01:41:45 -0700 Received: (qmail 52257 invoked by uid 65534); 2 May 2006 08:41:15 -0000 Message-ID: <20060502084115.52256.qmail@minotaur.apache.org> Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r398860 - /incubator/stdcxx/trunk/tests/strings/21.string.find.last.of.cpp Date: Tue, 02 May 2006 08:41:15 -0000 To: stdcxx-commits@incubator.apache.org From: antonp@apache.org X-Mailer: svnmailer-1.0.8 X-Virus-Checked: Checked by ClamAV on apache.org X-Spam-Rating: minotaur.apache.org 1.6.2 0/1000/N Author: antonp Date: Tue May 2 01:41:13 2006 New Revision: 398860 URL: http://svn.apache.org/viewcvs?rev=398860&view=rev Log: 2006-05-02 Anton Pevtsov STDCXX-4 * 21.string.find.last.of.cpp: New test exercising lib.string.find.last.of. Added: incubator/stdcxx/trunk/tests/strings/21.string.find.last.of.cpp (with props) Added: incubator/stdcxx/trunk/tests/strings/21.string.find.last.of.cpp URL: http://svn.apache.org/viewcvs/incubator/stdcxx/trunk/tests/strings/21.string.find.last.of.cpp?rev=398860&view=auto ============================================================================== --- incubator/stdcxx/trunk/tests/strings/21.string.find.last.of.cpp (added) +++ incubator/stdcxx/trunk/tests/strings/21.string.find.last.of.cpp Tue May 2 01:41:13 2006 @@ -0,0 +1,800 @@ +/*************************************************************************** + * + * 21.string.find.last.of.cpp - + * string test exercising lib.string.find.last.of + * + * $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 <21.strings.h> // for StringMembers +#include // for rw_test() +#include // for rw_widen() + +#define FindLastOf(which) StringMembers::find_last_of_ ## which + +typedef StringMembers::OverloadId OverloadId; +typedef StringMembers::TestCase TestCase; +typedef StringMembers::Test Test; +typedef StringMembers::Function MemFun; + +/**************************************************************************/ + +// for convenience and brevity +#define LSTR StringMembers::long_string +#define LLEN StringMembers::long_string_len + +static const char* const exceptions[] = { + "unknown exception", "out_of_range", "length_error", + "bad_alloc", "exception" +}; + +/**************************************************************************/ + +// used to exercise +// find_last_of (const value_type*) +static const TestCase ptr_test_cases [] = { + +#undef TEST +#define TEST(str, arg, res) \ + { __LINE__, -1, -1, -1, -1, -1, str, sizeof str - 1, arg, \ + sizeof arg - 1, 0, 0, res, 0 } + + // +----------------------------------- controlled sequence + // | +--------------------- sequence to be found + // | | +------ expected result + // | | | + // | | | + // V V V + TEST ("ab", "a", 0), + + TEST ("", "", -1), + TEST ("", "\0", -1), + TEST ("", "a", -1), + + TEST ("\0", "", -1), + TEST ("\0", "\0", -1), + TEST ("\0", "a", -1), + + TEST ("bbcdefghij", "a", -1), + TEST ("abcdefghij", "a", 0), + TEST ("abcdefghij", "f", 5), + TEST ("abcdefghij", "j", 9), + + TEST ("edfcbbhjig", "cba", 5), + TEST ("edfcbahjig", "bca", 5), + TEST ("edfcbahcba", "cba", 9), + TEST ("cbacbbhjig", "cab", 5), + + TEST ("e\0cb\0\0g", "b\0\0g", 3), + TEST ("e\0cb\0\0g", "ecb", 3), + TEST ("\0cb\0\0ge", "\0\0ge", -1), + TEST ("\0cb\0\0ge", "bc\0", 2), + TEST ("e\0cbg\0\0", "eg\0", 4), + TEST ("e\0cdg\0\0", "abc", 2), + TEST ("a\0b", "e\0gbg\0\0", -1), + TEST ("a\0b", "eb\0gg\0\0", 2), + TEST ("a\0b", "e\0gg\0\0a", -1), + + TEST ("bcbedfbjih", "a", -1), + TEST ("bcaedfajih", "a", 6), + TEST ("bcedfaajih", "a", 6), + TEST ("bcaaedfaji", "a", 7), + + TEST ("aaaaaaaaaa", "aaaaaaaaaa", 9), + TEST ("aaaaabaaaa", "cccccccccb", 5), + TEST ("aabaabaaaa", "cccccccccb", 5), + TEST ("bbb", "aaaaaaaaba", 2), + TEST ("bbb", "aaaaaaaaaa", -1), + + TEST (LSTR, "", -1), + TEST (LSTR, "a", -1), + TEST (LSTR, "x", LLEN - 2), + TEST (LSTR, "xxx", LLEN - 2), + TEST (LSTR, "aax", LLEN - 2), + TEST ("abc", LSTR, -1), + TEST ("xxxxxxxxxx", LSTR, 9), + + TEST ("abcdefghij", 0, 9), + TEST ("\0cb\0\0ge", 0, -1), + TEST (LSTR, 0, LLEN - 2), + + TEST ("last test", "test", 8) +}; + +/**************************************************************************/ + +// used to exercise +// find_last_of (const basic_string&) +static const TestCase str_test_cases [] = { + +#undef TEST +#define TEST(str, arg, res) \ + { __LINE__, -1, -1, -1, -1, -1, str, sizeof str - 1, arg, \ + sizeof arg - 1, 0, 0, res, 0 } + + // +------------------------------------ controlled sequence + // | +---------------------- sequence to be found + // | | +------- expected result + // | | | + // | | | + // V V V + TEST ("ab", "a", 0), + + TEST ("", "", -1), + TEST ("", "\0", -1), + TEST ("", "a", -1), + + TEST ("\0", "", -1), + 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", 5), + TEST ("edfcbahjig", "bca", 5), + TEST ("edfcbahcba", "cba", 9), + TEST ("cbacbbhjig", "cab", 5), + + TEST ("e\0cb\0\0g", "b\0\0g", 6), + TEST ("e\0cb\0\0g", "ecb", 3), + TEST ("\0cb\0\0ge", "\0\0ge", 6), + TEST ("\0cb\0\0ge", "bc\0", 4), + TEST ("e\0cbg\0\0", "eg\0", 6), + TEST ("\0cbdaaaaa", "eg\0", 0), + TEST ("e\0cdg\0\0", "abc", 2), + TEST ("a\0b", "e\0gbg\0\0", 2), + TEST ("a\0b", "ea\0gg\0\0", 1), + TEST ("\0ab", "e\0gg\0\0a", 1), + + TEST ("bcbedfbjih", "a", -1), + TEST ("bcaedfajih", "a", 6), + TEST ("bcedfaajih", "a", 6), + TEST ("bcaaedfaji", "a", 7), + + TEST ("aaaaaaaaaa", "aaaaaaaaaa", 9), + TEST ("aaaaabaaaa", "cccccccccb", 5), + TEST ("aabaabaaaa", "cccccccccb", 5), + TEST ("bbb", "aaaaaaaaba", 2), + TEST ("bbb", "aaaaaaaaaa", -1), + + TEST (LSTR, "", -1), + TEST (LSTR, "a", -1), + TEST (LSTR, "x", LLEN - 2), + TEST (LSTR, "xxx", LLEN - 2), + TEST (LSTR, "aax", LLEN - 2), + TEST ("abc", LSTR, -1), + TEST ("xxxxxxxxxx", LSTR, 9), + + TEST ("abcdefghij", 0, 9), + TEST ("\0cb\0\0ge", 0, 6), + TEST (LSTR, 0, LLEN - 2), + + TEST ("last test", "test", 8) +}; + +/**************************************************************************/ + +// used to exercise +// find_last_of (const value_type*, size_type) +static const TestCase ptr_size_test_cases [] = { + +#undef TEST +#define TEST(str, arg, off, res) \ + { __LINE__, off, -1, -1, -1, -1, str, sizeof str - 1, arg, \ + sizeof arg - 1, 0, 0, res, 0 } + + // +-------------------------------------- controlled sequence + // | +------------------------- sequence to be found + // | | +--------- find_last_of() off argument + // | | | +----- expected result + // | | | | + // | | | | + // V V V V + TEST ("ab", "a", 0, 0), + + TEST ("", "", 0, -1), + TEST ("", "\0", 0, -1), + TEST ("", "a", 0, -1), + + TEST ("\0", "", 0, -1), + TEST ("\0", "", 1, -1), + TEST ("\0", "\0", 0, -1), + TEST ("\0", "\0", 1, -1), + TEST ("\0", "a", 0, -1), + + TEST ("bbcdefghij", "a", 0, -1), + TEST ("abcdefghij", "a", 0, 0), + TEST ("abcdefghij", "a", 2, 0), + TEST ("abcdefghij", "f", 2, -1), + TEST ("abcdefghij", "f", 7, 5), + TEST ("abcdefghij", "j", 9, 9), + + TEST ("edfcbbhjig", "cba", 9, 5), + TEST ("edfcbahjag", "cba", 7, 5), + TEST ("edfcbahjig", "cba", 4, 4), + TEST ("edfcbahcba", "cba", 1, -1), + TEST ("edfcbahcba", "cba", 9, 9), + TEST ("edfcbahcba", "cba", 3, 3), + TEST ("cbacbahjig", "cba", 4, 4), + + TEST ("e\0cb\0\0g", "b\0\0g", 5, 3), + TEST ("e\0cb\0\0g", "b\0\0g", 2, -1), + TEST ("e\0cb\0\0g", "ecb", 7, 3), + TEST ("\0cb\0\0ge", "\0\0ge", 6, -1), + TEST ("\0cb\0\0ge", "cb\0", 0, -1), + TEST ("\0cb\0\0ge", "cb\0", 1, 1), + TEST ("\0cb\0\0ge", "cb\0", 2, 2), + TEST ("e\0cbg\0\0", "bg", 1, -1), + TEST ("e\0cbg\0\0", "bg", 5, 4), + TEST ("a\0b", "e\0gbg\0\0", 3, -1), + TEST ("a\0b", "eb\0gg\0\0", 3, 2), + TEST ("a\0b", "e\0gg\0\0a", 3, -1), + + TEST ("bcbedfbjih", "a", 0, -1), + TEST ("bcaedfajih", "a", 8, 6), + TEST ("bcedfaajih", "a", 6, 6), + TEST ("bcaaedfaji", "a", 8, 7), + + TEST ("aaaaaaaaaa", "aaaaaaaaaa", 9, 9), + TEST ("aaaaaaaaaa", "aaaaaaaaaa", 4, 4), + TEST ("aaaaabaaaa", "cccccccccb", 8, 5), + TEST ("aabaabaaaa", "cccccccccb", 9, 5), + TEST ("aabaabaaaa", "cccccccccb", 3, 2), + TEST ("bbb", "aaaaaaaaba", 2, 2), + TEST ("bab", "aaaaaaaaba", 0, 0), + TEST ("bbb", "aaaaaaaaaa", 3, -1), + + TEST (LSTR, "", LLEN - 1, -1), + TEST (LSTR, "a", LLEN - 1, -1), + TEST (LSTR, "x", LLEN - 1, LLEN - 2), + TEST (LSTR, "xxx", LLEN - 2, LLEN - 2), + TEST (LSTR, "xxx", 0, 0), + TEST (LSTR, "xxx", LLEN - 10, LLEN - 10), + TEST (LSTR, "aax", LLEN - 10, LLEN - 10), + TEST ("abc", LSTR, 2, -1), + TEST ("xxxxxxxxxx", LSTR, 6, 6), + + TEST (LSTR, "xxx", 3, 3), + TEST (LSTR, "xxx", 2, 2), + + TEST ("abcdefghij", 0, 0, 0), + TEST ("abcdefghij", 0, 9, 9), + TEST ("\0cb\0\0ge", 0, 5, -1), + TEST (LSTR, 0, 0, 0), + TEST (LSTR, 0, 1, 1), + + TEST ("", "", 1, -1), + TEST ("abcdefghij", "abc", 10, 2), + TEST ("abcdefghij", "cba", 10, 2), + + TEST ("last test", "test", 9, 8) +}; + +/**************************************************************************/ + +// used to exercise +// find_last_of (const value_type*, size_type, size_type) +static const TestCase ptr_size_size_test_cases [] = { + +#undef TEST +#define TEST(str, arg, off, size, res, bthrow) \ + { __LINE__, off, size, -1, -1, -1, str, sizeof str - 1, arg, \ + sizeof arg - 1, 0, 0, res, bthrow } + + // +--------------------------------------- controlled sequence + // | +-------------------------- sequence to be found + // | | +---------- find_last_of() off argument + // | | | +------ find_last_of() 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, -1, 0), + TEST ("", "\0", 0, 0, -1, 0), + TEST ("", "\0", 0, 1, -1, 0), + TEST ("", "a", 0, 0, -1, 0), + TEST ("", "a", 0, 1, -1, 0), + + TEST ("\0", "", 0, 0, -1, 0), + TEST ("\0", "\0", 0, 1, 0, 0), + TEST ("\0", "\0", 1, 1, 0, 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, -1, 0), + TEST ("edfcbbhjig", "cba", 9, 2, 5, 0), + TEST ("edfcbahjig", "cba", 8, 3, 5, 0), + TEST ("edfcbahjig", "cba", 2, 3, -1, 0), + TEST ("edfcbahjig", "cba", 2, 1, -1, 0), + TEST ("edfcbahcba", "cba", 8, 3, 8, 0), + TEST ("edfcbehcba", "cab", 8, 2, 7, 0), + TEST ("edfcbahcba", "cba", 9, 3, 9, 0), + TEST ("cbacbahjig", "cba", 5, 3, 5, 0), + TEST ("cbacbahjig", "cba", 2, 1, 0, 0), + TEST ("cbacbahjcg", "cba", 7, 1, 3, 0), + + TEST ("e\0cb\0\0g", "b\0\0g", 0, 4, -1, 0), + TEST ("e\0cb\0\0g", "b\0\0g", 7, 4, 6, 0), + TEST ("e\0cb\0\0b", "b\0\0g", 4, 1, 3, 0), + TEST ("\0b\0\0gb\0","b\0\0g", 7, 2, 6, 0), + TEST ("\0b\0\0gb\0","b\0\0g", 2, 2, 2, 0), + TEST ("\0b\0\0b\0g","b\0g\0", 7, 3, 6, 0), + TEST ("e\0cb\0\0g", "ecb", 7, 2, 2, 0), + TEST ("\0cb\0\0ge", "\0\0ge", 6, 4, 6, 0), + TEST ("\0cb\0\0ge", "\0\0ge", 2, 0, -1, 0), + TEST ("\0cb\0\0ge", "cb\0", 1, 3, 1, 0), + TEST ("e\0cbg\0\0", "bg", 1, 2, -1, 0), + TEST ("a\0b", "e\0gbg\0\0", 2, 1, -1, 0), + TEST ("a\0b", "eb\0gg\0\0", 1, 2, -1, 0), + TEST ("a\0b", "e\0gg\0\0a", 3, 6, 1, 0), + TEST ("a\0b", "e\0gg\0\0a", 0, 7, 0, 0), + TEST ("a\0b", "eb\0gg\0\0", 1, 3, 1, 0), + + TEST ("e\0a\0", "e\0a\0\0", 2, 4, 2, 0), + TEST ("e\0a\0", "e\0a\0\0", 3, 5, 3, 0), + TEST ("ee\0a\0", "b\0c\0\0", 3, 4, 2, 0), + TEST ("e\0a\0b", "fdbcb\0a", 3, 5, -1, 0), + + TEST ("aaaaaaaaaa", "aaaaaaaaaa", 9, 10, 9, 0), + TEST ("aaaaaaaaaa", "aaaaaaaaaa", 8, 10, 8, 0), + TEST ("aaaaabaaaa", "cccccccccc", 9, 10, -1, 0), + TEST ("aaaaabaaaa", "cccbcccccc", 8, 4, 5, 0), + TEST ("aaaabaaaaa", "cccca", 9, 5, 9, 0), + TEST ("aabaabaaaa", "cbccccccca", 7, 5, 5, 0), + TEST ("bbb", "aaaaaaaaba", 1, 2, -1, 0), + TEST ("bbb", "aaaaaaaaaa", 0, 9, -1, 0), + TEST ("bab", "aaaaaaaaba", 0, 0, -1, 0), + TEST ("bab", "ccccccccba", 1, 10, 1, 0), + + TEST (LSTR, "", LLEN - 1, 0, -1, 0), + TEST (LSTR, "a", LLEN - 1, 1, -1, 0), + TEST (LSTR, "x", LLEN - 1, 1, LLEN - 2, 0), + TEST (LSTR, "xxx", LLEN - 9, 3, LLEN - 9, 0), + TEST (LSTR, "axa", LLEN - 9, 3, LLEN - 9, 0), + TEST ("abc", LSTR, 2, 10, -1, 0), + TEST ("xxxxxxxxxx", LSTR, 0, LLEN - 1, 0, 0), + TEST ("xxxxxxxxxx", LSTR, 2, 4, 2, 0), + + TEST (LSTR, "xxx", LLEN - 4, 3, LLEN - 4, 0), + TEST (LSTR, "xxx", LLEN - 3, 3, LLEN - 3, 0), + TEST (LSTR, "xxx", LLEN - 3, 2, LLEN - 3, 0), + + TEST ("abcdefghij", 0, 0, 9, 0, 0), + TEST ("abcdefghij", 0, 8, 9, 8, 0), + TEST ("\0cb\0\0ge", 0, 5, 7, 5, 0), + TEST ("\0cb\0ge\0", 0, 6, 1, 6, 0), + TEST ("\0c\0e\0cg", 0, 6, 2, 5, 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 (LSTR, 0, LLEN - 6, 1, LLEN - 6, 0), + + TEST ("", "", 1, 0, -1, 0), + TEST ("abcdefghij", "abc", 10, 3, 2, 0), + TEST ("abcdefghij", "cba", 10, 1, 2, 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", 9, 4, 8, 0) +}; + +/**************************************************************************/ + +// used to exercise +// find_last_of (const basic_string&, size_type) +static const TestCase str_size_test_cases [] = { + +#undef TEST +#define TEST(str, arg, off, res) \ + { __LINE__, off, -1, -1, -1, -1, str, sizeof str - 1, arg, \ + sizeof arg - 1, 0, 0, res, 0 } + + // +--------------------------------------- controlled sequence + // | +------------------------- sequence to be found + // | | +---------- find_last_of() off argument + // | | | +------ expected result + // | | | | + // | | | | + // V V V V + TEST ("ab", "a", 0, 0), + + TEST ("", "", 0, -1), + TEST ("", "\0", 0, -1), + TEST ("", "a", 0, -1), + + TEST ("\0", "", 0, -1), + TEST ("\0", "", 1, -1), + TEST ("\0", "\0", 0, 0), + TEST ("\0", "\0", 1, 0), + TEST ("\0", "a", 0, -1), + + TEST ("bbcdefghij", "a", 0, -1), + TEST ("abcdefghij", "a", 0, 0), + TEST ("abcdefghij", "a", 2, 0), + TEST ("abcdefghij", "f", 2, -1), + TEST ("abcdefghij", "f", 7, 5), + TEST ("abcdefghij", "j", 9, 9), + + TEST ("edfcbbhjig", "cba", 9, 5), + TEST ("edfcbahjag", "cba", 7, 5), + TEST ("edfcbahjig", "cba", 4, 4), + TEST ("edfcbahcba", "cba", 1, -1), + TEST ("edfcbahcba", "cba", 9, 9), + TEST ("edfcbahcba", "cba", 3, 3), + TEST ("cbacbahjig", "cba", 4, 4), + + TEST ("e\0cb\0\0g", "b\0\0g", 5, 5), + TEST ("e\0cb\0\0g", "b\0\0g", 2, 1), + TEST ("e\0cb\0\0g", "ecb", 7, 3), + TEST ("\0cb\0\0ge", "\0\0ge", 6, 6), + TEST ("\0cb\0\0ge", "cb\0", 0, 0), + TEST ("\0cb\0\0ge", "cb\0", 1, 1), + TEST ("\0cb\0\0ge", "cb\0", 2, 2), + TEST ("e\0cbg\0\0", "bg", 1, -1), + TEST ("e\0cbg\0\0", "bg", 5, 4), + TEST ("a\0b", "e\0gbg\0\0", 2, 2), + TEST ("a\0b", "eb\0gg\0\0", 2, 2), + TEST ("a\0b", "e\0gg\0\0a", 3, 1), + + TEST ("bcbedfbjih", "a", 0, -1), + TEST ("bcaedfajih", "a", 8, 6), + TEST ("bcedfaajih", "a", 6, 6), + TEST ("bcaaedfaji", "a", 8, 7), + + TEST ("aaaaaaaaaa", "aaaaaaaaaa", 9, 9), + TEST ("aaaaaaaaaa", "aaaaaaaaaa", 4, 4), + TEST ("aaaaabaaaa", "cccccccccb", 8, 5), + TEST ("aabaabaaaa", "cccccccccb", 9, 5), + TEST ("aabaabaaaa", "cccccccccb", 3, 2), + TEST ("bbb", "aaaaaaaaba", 2, 2), + TEST ("bab", "aaaaaaaaba", 0, 0), + TEST ("bbb", "aaaaaaaaaa", 3, -1), + + TEST (LSTR, "", LLEN - 1, -1), + TEST (LSTR, "a", LLEN - 1, -1), + TEST (LSTR, "x", LLEN - 1, LLEN - 2), + TEST (LSTR, "xxx", LLEN - 2, LLEN - 2), + TEST (LSTR, "xxx", 0, 0), + TEST (LSTR, "xxx", LLEN - 10, LLEN - 10), + TEST (LSTR, "aax", LLEN - 10, LLEN - 10), + TEST ("abc", LSTR, 2, -1), + TEST ("xxxxxxxxxx", LSTR, 6, 6), + + TEST (LSTR, "xxx", 3, 3), + TEST (LSTR, "xxx", 2, 2), + + TEST ("abcdefghij", 0, 0, 0), + TEST ("abcdefghij", 0, 9, 9), + TEST ("\0cb\0\0ge", 0, 5, 5), + TEST (LSTR, 0, 0, 0), + TEST (LSTR, 0, 1, 1), + + TEST ("", "", 1, -1), + TEST ("abcdefghij", "abc", 10, 2), + TEST ("abcdefghij", "cba", 10, 2), + + TEST ("last test", "test", 9, 8) +}; + +/**************************************************************************/ + +// used to exercise +// find_last_of (value_type) +static const TestCase val_test_cases [] = { + +#undef TEST +#define TEST(str, val, res) \ + { __LINE__, -1, -1, -1, -1, val, str, sizeof str - 1, \ + 0, 0, 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', 1), + TEST ("\0", 'a', -1), + + TEST ("e\0cb\0\0g", '\0', 5), + TEST ("e\0cb\0\0g", 'b', 3), + TEST ("e\0cb\0\0g", 'a', -1), + TEST ("\0cbge\0\0", '\0', 6), + TEST ("\0cbge\0\0", 'b', 2), + TEST ("\0cbge\0\0", 'a', -1), + + TEST (LSTR, 'x', LLEN - 2), + TEST (LSTR, '\0', -1), + TEST (LSTR, 'a', -1), + + TEST ("last test", 't', 8) +}; + +/**************************************************************************/ + +// used to exercise +// find_last_of (value_type, size_type) +static const TestCase val_size_test_cases [] = { + +#undef TEST +#define TEST(str, val, off, res) \ + { __LINE__, off, -1, -1, -1, val, str, sizeof str - 1, \ + 0, 0, 0, 0, res, 0 } + + // +------------------------------ controlled sequence + // | +--------------- character to be found + // | | +--------- find_last_of() off argument + // | | | +----- expected result + // | | | | + // | | | | + // V V V V + TEST ("ab", 'a', 0, 0), + + TEST ("", 'a', 0, -1), + TEST ("", '\0', 0, -1), + + TEST ("\0", '\0', 1, 0), + TEST ("\0", 'a', 0, -1), + TEST ("\0\0", '\0', 2, 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', 5, 5), + TEST ("e\0cb\0\0g", '\0', 0, -1), + TEST ("e\0cb\0\0g", 'b', 1, -1), + TEST ("e\0cb\0\0g", 'b', 4, 3), + TEST ("e\0cb\0\0g", 'a', 6, -1), + TEST ("\0cbge\0\0", '\0', 0, 0), + TEST ("\0cbge\0\0", '\0', 5, 5), + TEST ("\0cbge\0\0", '\0', 9, 6), + TEST ("\0cbge\0\0", 'b', 5, 2), + TEST ("\0bgeb\0\0", 'b', 5, 4), + TEST ("\0cbge\0\0", 'a', 6, -1), + + TEST (LSTR, 'x', 0, 0), + TEST (LSTR, 'x', 5, 5), + TEST (LSTR, 'x', LLEN - 1, LLEN - 2), + TEST (LSTR, '\0', LLEN - 1, -1), + TEST (LSTR, 'a', LLEN - 3, -1), + TEST (LSTR, 'x', LLEN - 2, LLEN - 2), + TEST (LSTR, 'x', LLEN + 9, LLEN - 2), + + TEST ("last test", 't', 9, 8) +}; + +/**************************************************************************/ + +template +void test_find_last_of (charT, Traits*, + OverloadId which, + const TestCase &cs) +{ + typedef std::allocator Allocator; + typedef std::basic_string TestString; + typedef typename TestString::const_iterator ConstStringIter; + + static charT wstr [LLEN]; + static charT warg [LLEN]; + + rw_widen (wstr, cs.str, cs.str_len); + rw_widen (warg, cs.arg, cs.arg_len); + + const TestString s_str (wstr, cs.str_len); + const TestString s_arg (warg, cs.arg_len); + + std::size_t res = 0; + std::size_t exp_res = -1 != cs.nres ? cs.nres : TestString::npos; + + const std::size_t ssize = s_str.size (); + const std::size_t capacity = s_str.capacity (); + const ConstStringIter begin = s_str.begin (); + + const charT* const ptr_arg = cs.arg ? warg : s_str.c_str (); + const TestString& str_arg = cs.arg ? s_arg : s_str; + const charT arg_val = make_char (char (cs.val), (charT*)0); + + std::size_t size = cs.size >= 0 ? cs.size : s_arg.max_size () + 1; + +#ifndef _RWSTD_NO_EXCEPTIONS + + // is some exception expected ? + const char* expected = 0; + if (1 == cs.bthrow) + expected = exceptions [2]; + + const char* caught = 0; + +#else // if defined (_RWSTD_NO_EXCEPTIONS) + + if (cs.bthrow) + return; + +#endif // _RWSTD_NO_EXCEPTIONS + + try { + switch (which) { + case FindLastOf (ptr): { + res = s_str.find_last_of (ptr_arg); + break; + } + + case FindLastOf (str): { + res = s_str.find_last_of (str_arg); + break; + } + + case FindLastOf (ptr_size): { + res = s_str.find_last_of (ptr_arg, cs.off); + break; + } + + case FindLastOf (ptr_size_size): { + res = s_str.find_last_of (ptr_arg, cs.off, size); + break; + } + + case FindLastOf (str_size): { + res = s_str.find_last_of (str_arg, cs.off); + break; + } + + case FindLastOf (val): { + res = s_str.find_last_of (arg_val); + break; + } + + case FindLastOf (val_size): { + res = s_str.find_last_of (arg_val, cs.off); + break; + } + + default: + RW_ASSERT ("test logic error: unknown find_last_of overload"); + return; + } + + // verify the returned value + rw_assert (exp_res == res, 0, cs.line, + "line %d. %{$FUNCALL} == %{?}%zu%{;}%{?}npos%{;}, " + "got %{?}%zu%{;}%{?}npos%{;}", + __LINE__, -1 != cs.nres, exp_res, -1 == cs.nres, + TestString::npos != res, res, TestString::npos == res); + } + +#ifndef _RWSTD_NO_EXCEPTIONS + + catch (const std::length_error &ex) { + caught = exceptions [2]; + rw_assert (caught == expected, 0, cs.line, + "line %d. %{$FUNCALL} %{?}expected %s,%{:}" + "unexpectedly%{;} caught std::%s(%#s)", + __LINE__, 0 != expected, expected, caught, ex.what ()); + } + catch (const std::exception &ex) { + caught = exceptions [4]; + rw_assert (0, 0, cs.line, + "line %d. %{$FUNCALL} %{?}expected %s,%{:}" + "unexpectedly%{;} caught std::%s(%#s)", + __LINE__, 0 != expected, expected, caught, ex.what ()); + } + catch (...) { + caught = exceptions [0]; + rw_assert (0, 0, cs.line, + "line %d. %{$FUNCALL} %{?}expected %s,%{:}" + "unexpectedly%{;} caught %s", + __LINE__, 0 != expected, expected, caught); + } + + if (caught) { + // verify that an exception thrown during allocation + // didn't cause a change in the state of the object + + rw_assert (s_str.size () == ssize, 0, cs.line, + "line %d: %{$FUNCALL}: size unexpectedly changed " + "from %zu to %zu after an exception", + __LINE__, ssize, s_str.size ()); + + rw_assert (s_str.capacity () == capacity, 0, cs.line, + "line %d: %{$FUNCALL}: capacity unexpectedly " + "changed from %zu to %zu after an exception", + __LINE__, capacity, s_str.capacity ()); + + rw_assert (s_str.begin () == begin, 0, cs.line, + "line %d: %{$FUNCALL}: begin() unexpectedly " + "changed from after an exception by %d", + __LINE__, s_str.begin () - begin); + } + else if (-1 != cs.bthrow) { + rw_assert (caught == expected, 0, cs.line, + "line %d. %{$FUNCALL} %{?}expected %s, caught %s" + "%{:}unexpectedly caught %s%{;}", + __LINE__, 0 != expected, expected, caught, caught); + } + +#else // if defined (_RWSTD_NO_EXCEPTIONS) + + _RWSTD_UNUSED (ssize); + _RWSTD_UNUSED (capacity); + +#endif // _RWSTD_NO_EXCEPTIONS +} + +/**************************************************************************/ + +DEFINE_TEST_DISPATCH (test_find_last_of); + +int main (int argc, char** argv) +{ + static const StringMembers::Test + tests [] = { + +#undef TEST +#define TEST(tag) { \ + StringMembers::find_last_of_ ## tag, \ + tag ## _test_cases, \ + sizeof tag ## _test_cases / sizeof *tag ## _test_cases \ + } + + TEST (ptr), + TEST (str), + TEST (ptr_size), + TEST (ptr_size_size), + TEST (str_size), + TEST (val), + TEST (val_size) + }; + + const std::size_t test_count = sizeof tests / sizeof *tests; + + return StringMembers::run_test (argc, argv, __FILE__, + "lib.string.find.last.of", + test_find_last_of, tests, test_count); +} + Propchange: incubator/stdcxx/trunk/tests/strings/21.string.find.last.of.cpp ------------------------------------------------------------------------------ svn:eol-style = native Propchange: incubator/stdcxx/trunk/tests/strings/21.string.find.last.of.cpp ------------------------------------------------------------------------------ svn:keywords = Id