1161 lines
42 KiB
C++
1161 lines
42 KiB
C++
/***************************************************************************
|
|
*
|
|
* 21.string.cons.cpp - test exercising string constructors [lib.string.cons]
|
|
*
|
|
* $Id: 21.string.cons.cpp 648752 2008-04-16 17:01:56Z faridz $
|
|
*
|
|
***************************************************************************
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed
|
|
* with this work for additional information regarding copyright
|
|
* ownership. The ASF licenses this file to you 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 <stdexcept> // for out_of_range, length_error
|
|
#include <cstddef> // for size_t
|
|
|
|
#include <21.strings.h>
|
|
#include <alg_test.h> // for InputIter
|
|
#include <driver.h> // for rw_test()
|
|
#include <rw_allocator.h> // for UserAlloc
|
|
#include <rw_char.h> // for rw_expand()
|
|
#include <rw_new.h> // for bad_alloc, replacement operator new
|
|
|
|
/**************************************************************************/
|
|
|
|
// for convenience and brevity
|
|
#define Cons(sig) StringIds::ctor_ ## sig
|
|
#define OpSet(sig) StringIds::op_set_ ## sig
|
|
|
|
static const char* const exceptions[] = {
|
|
"unknown exception", "out_of_range", "length_error",
|
|
"bad_alloc", "exception"
|
|
};
|
|
|
|
/**************************************************************************/
|
|
|
|
// exercises:
|
|
// basic_string (void)
|
|
static const StringTestCase
|
|
void_test_cases [] = {
|
|
|
|
#define alloc_test_cases void_test_cases
|
|
|
|
#undef TEST
|
|
#define TEST(dummy) { \
|
|
__LINE__, -1, -1, -1, -1, -1, \
|
|
0, 0, dummy, sizeof dummy - 1, \
|
|
"", 0, 0 \
|
|
}
|
|
|
|
// +--------------------- dummy argument
|
|
// |
|
|
// V
|
|
TEST ("ab"),
|
|
|
|
TEST ("last test")
|
|
};
|
|
|
|
/**************************************************************************/
|
|
|
|
// exercises:
|
|
// basic_string (const value_type*)
|
|
static const StringTestCase
|
|
cptr_test_cases [] = {
|
|
|
|
#define cptr_alloc_test_cases cptr_test_cases
|
|
|
|
#undef TEST
|
|
#define TEST(arg, res) { \
|
|
__LINE__, -1, -1, -1, -1, -1, \
|
|
0, 0, arg, sizeof arg - 1, \
|
|
res, sizeof res - 1, 0 \
|
|
}
|
|
|
|
// +----------------------------------------- source sequence
|
|
// | +------------------------- expected result sequence
|
|
// | |
|
|
// | |
|
|
// V V
|
|
TEST ("ab", "ab"),
|
|
|
|
TEST ("", ""),
|
|
TEST ("<U0>", ""),
|
|
|
|
TEST ("a", "a"),
|
|
TEST ("bcd", "bcd"),
|
|
TEST ("cdefaihjb", "cdefaihjb"),
|
|
|
|
TEST ("<U0>@2ab", ""),
|
|
TEST ("a<U0>@2b", "a"),
|
|
TEST ("ab<U0>@2", "ab"),
|
|
TEST ("abefdcc<U0>a", "abefdcc"),
|
|
|
|
TEST ("x@128", "x@128"),
|
|
TEST ("x@207", "x@207"),
|
|
TEST ("x@334", "x@334"),
|
|
TEST ("x@540", "x@540"),
|
|
TEST ("x@873", "x@873"),
|
|
TEST ("x@1412", "x@1412"),
|
|
TEST ("x@3695", "x@3695"),
|
|
TEST ("x@4096", "x@4096"),
|
|
|
|
TEST ("last test", "last test")
|
|
};
|
|
|
|
/**************************************************************************/
|
|
|
|
// exercises:
|
|
// basic_string (const basic_string&)
|
|
static const StringTestCase
|
|
cstr_test_cases [] = {
|
|
|
|
#undef TEST
|
|
#define TEST(arg, res) { \
|
|
__LINE__, -1, -1, -1, -1, -1, \
|
|
0, 0, arg, sizeof arg - 1, \
|
|
res, sizeof res - 1, 0 \
|
|
}
|
|
|
|
// +----------------------------------------- source sequence
|
|
// | +------------------------- expected result sequence
|
|
// | |
|
|
// | |
|
|
// V V
|
|
TEST ("ab", "ab"),
|
|
|
|
TEST ("", ""),
|
|
TEST ("<U0>", "<U0>"),
|
|
TEST ("<U0>@2", "<U0>@2"),
|
|
|
|
TEST ("a", "a"),
|
|
TEST ("bcd", "bcd"),
|
|
TEST ("cdefaihjb", "cdefaihjb"),
|
|
|
|
TEST ("<U0>@2ab", "<U0>@2ab"),
|
|
TEST ("a<U0>@2b", "a<U0>@2b"),
|
|
TEST ("ab<U0>@2", "ab<U0>@2"),
|
|
TEST ("abefdcc<U0>a", "abefdcc<U0>a"),
|
|
|
|
TEST ("x@128", "x@128"),
|
|
TEST ("x@207", "x@207"),
|
|
TEST ("x@334", "x@334"),
|
|
TEST ("x@540", "x@540"),
|
|
TEST ("x@873", "x@873"),
|
|
TEST ("x@1412", "x@1412"),
|
|
TEST ("x@3695", "x@3695"),
|
|
TEST ("x@4096", "x@4096"),
|
|
|
|
TEST ("last test", "last test")
|
|
};
|
|
|
|
/**************************************************************************/
|
|
|
|
// exercises:
|
|
// basic_string (const value_type*, size_type)
|
|
static const StringTestCase
|
|
cptr_size_test_cases [] = {
|
|
|
|
#define cptr_size_alloc_test_cases cptr_size_test_cases
|
|
|
|
#undef TEST
|
|
#define TEST(arg, size, res) { \
|
|
__LINE__, -1, size, -1, -1, -1, \
|
|
0, 0, arg, sizeof arg - 1, \
|
|
res, sizeof res - 1, 0 \
|
|
}
|
|
|
|
// +----------------------------------------- source sequence
|
|
// | +------------------------- ctor n argument
|
|
// | | +---------------------- expected result sequence
|
|
// | | |
|
|
// | | |
|
|
// V V V
|
|
TEST ("ab", 2, "ab"),
|
|
|
|
TEST ("", 0, ""),
|
|
TEST ("<U0>", 1, "<U0>"),
|
|
|
|
TEST ("a", 1, "a"),
|
|
TEST ("bcd", 3, "bcd"),
|
|
TEST ("cdefaihjb", 9, "cdefaihjb"),
|
|
|
|
TEST ("<U0>@2ab", 1, "<U0>"),
|
|
TEST ("<U0>@2ab", 4, "<U0>@2ab"),
|
|
TEST ("a<U0>@2b", 4, "a<U0>@2b"),
|
|
TEST ("ab<U0>@2", 3, "ab<U0>"),
|
|
TEST ("abefdcc<U0>a", 7, "abefdcc"),
|
|
TEST ("abefdcc<U0>a", 8, "abefdcc<U0>"),
|
|
TEST ("abefdcc<U0>a", 9, "abefdcc<U0>a"),
|
|
|
|
TEST ("x@207", 207, "x@207"),
|
|
TEST ("x@334", 207, "x@207"),
|
|
TEST ("x@207", 128, "x@128"),
|
|
TEST ("x@1412", 873, "x@873"),
|
|
TEST ("x@1412", 1412, "x@1412"),
|
|
TEST ("x@1412", 540, "x@540"),
|
|
TEST ("x@873", 873, "x@873"),
|
|
TEST ("x@3695", 2284, "x@2284"),
|
|
TEST ("x@4096", 4096, "x@4096"),
|
|
|
|
TEST ("last test", 9, "last test")
|
|
};
|
|
|
|
/**************************************************************************/
|
|
|
|
// exercises:
|
|
// basic_string (const basic_string&, size_type)
|
|
static const StringTestCase
|
|
cstr_size_test_cases [] = {
|
|
|
|
#undef TEST
|
|
#define TEST(arg, off, res, bthrow) { \
|
|
__LINE__, off, -1, -1, -1, -1, \
|
|
0, 0, arg, sizeof arg - 1, \
|
|
res, sizeof res - 1, bthrow \
|
|
}
|
|
|
|
// +----------------------------------------- source sequence
|
|
// | +------------------------- ctor off argument
|
|
// | | +---------------------- expected result sequence
|
|
// | | | +------ exception info
|
|
// | | | | 0 - no exception
|
|
// | | | | 1 - out_of_range
|
|
// | | | |
|
|
// | | | |
|
|
// V V V V
|
|
TEST ("ab", 0, "ab", 0),
|
|
|
|
TEST ("", 0, "", 0),
|
|
TEST ("<U0>", 0, "<U0>", 0),
|
|
TEST ("<U0>@2", 0, "<U0>@2", 0),
|
|
TEST ("<U0>@2", 1, "<U0>", 0),
|
|
TEST ("<U0>@2", 2, "", 0),
|
|
|
|
TEST ("a", 0, "a", 0),
|
|
TEST ("bcd", 0, "bcd", 0),
|
|
TEST ("cdefaihjb", 0, "cdefaihjb", 0),
|
|
|
|
TEST ("<U0>@2ab", 0, "<U0>@2ab", 0),
|
|
TEST ("<U0>@2ab", 1, "<U0>ab", 0),
|
|
TEST ("a<U0>@2b", 0, "a<U0>@2b", 0),
|
|
TEST ("a<U0>@2b", 1, "<U0>@2b", 0),
|
|
TEST ("a<U0>@2b", 2, "<U0>b", 0),
|
|
TEST ("ab<U0>@2", 0, "ab<U0>@2", 0),
|
|
TEST ("ab<U0>@2", 2, "<U0>@2", 0),
|
|
TEST ("ab<U0>@2", 4, "", 0),
|
|
TEST ("abefdcc<U0>a", 0, "abefdcc<U0>a", 0),
|
|
TEST ("abefdcc<U0>a", 7, "<U0>a", 0),
|
|
|
|
TEST ("x@207", 0, "x@207", 0),
|
|
TEST ("x@334", 127, "x@207", 0),
|
|
TEST ("x@1412", 872, "x@540", 0),
|
|
TEST ("x@1412", 0, "x@1412", 0),
|
|
TEST ("x@1412", 539, "x@873", 0),
|
|
TEST ("x@873", 0, "x@873", 0),
|
|
TEST ("x@3695", 0, "x@3695", 0),
|
|
TEST ("x@4096", 0, "x@4096", 0),
|
|
|
|
TEST ("abc", 5, "abc", 1),
|
|
TEST ("x@4096", 4106, "x@4096", 1),
|
|
|
|
TEST ("last test", 0, "last test", 0)
|
|
};
|
|
|
|
/**************************************************************************/
|
|
|
|
// exercises:
|
|
// basic_string (const basic_string&, size_type, size_type)
|
|
// basic_string (InputIterator, InputIterator)
|
|
static const StringTestCase
|
|
cstr_size_size_test_cases [] = {
|
|
|
|
#define range_test_cases cstr_size_size_test_cases
|
|
#define cstr_size_size_alloc_test_cases cstr_size_size_test_cases
|
|
#define range_alloc_test_cases cstr_size_size_test_cases
|
|
|
|
#undef TEST
|
|
#define TEST(arg, off, size, res, bthrow) { \
|
|
__LINE__, -1, -1, off, size, -1, \
|
|
0, 0, arg, sizeof arg - 1, \
|
|
res, sizeof res - 1, bthrow \
|
|
}
|
|
|
|
// +----------------------------------------- source sequence
|
|
// | +------------------------- ctor off argument
|
|
// | | +--------------------- ctor n argument
|
|
// | | | +---------------- expected result sequence
|
|
// | | | | +--- exception info
|
|
// | | | | | 0 - no exception
|
|
// | | | | | 1 - out_of_range
|
|
// | | | | |
|
|
// | | | | |
|
|
// V V V V V
|
|
TEST ("ab", 0, 2, "ab", 0),
|
|
|
|
TEST ("", 0, 0, "", 0),
|
|
TEST ("<U0>", 0, 1, "<U0>", 0),
|
|
TEST ("<U0>@2", 0, 2, "<U0>@2", 0),
|
|
|
|
TEST ("a", 0, 1, "a", 0),
|
|
TEST ("bcd", 0, 3, "bcd", 0),
|
|
TEST ("cdefaihjb", 0, 9, "cdefaihjb", 0),
|
|
|
|
TEST ("<U0>@2ab", 0, 4, "<U0>@2ab", 0),
|
|
TEST ("a<U0>@2b", 0, 4, "a<U0>@2b", 0),
|
|
TEST ("ab<U0>@2", 0, 4, "ab<U0>@2", 0),
|
|
TEST ("abefdcc<U0>a", 0, 9, "abefdcc<U0>a", 0),
|
|
|
|
TEST ("x@207", 0, 207, "x@207", 0),
|
|
TEST ("x@334", 10, 207, "x@207", 0),
|
|
TEST ("x@207", 50, 128, "x@128", 0),
|
|
TEST ("x@1412", 128, 873, "x@873", 0),
|
|
TEST ("x@1412", 0, 1412, "x@1412", 0),
|
|
TEST ("x@1412", 207, 540, "x@540", 0),
|
|
TEST ("x@874", 1, 873, "x@873", 0),
|
|
TEST ("x@3695", 10, 2284, "x@2284", 0),
|
|
TEST ("x@4096", 0, 4096, "x@4096", 0),
|
|
|
|
TEST ("abc", 5, 3, "", 1),
|
|
TEST ("x@4096", 4106, 3, "", 1),
|
|
|
|
TEST ("last test", 0, 9, "last test", 0)
|
|
};
|
|
|
|
/**************************************************************************/
|
|
|
|
// exercises:
|
|
// basic_string (size_type, value_type)
|
|
static const StringTestCase
|
|
size_val_test_cases [] = {
|
|
|
|
#define size_val_alloc_test_cases size_val_test_cases
|
|
|
|
#undef TEST
|
|
#define TEST(size, val, res) { \
|
|
__LINE__, -1, size, -1, -1, val, \
|
|
0, 0, 0, 0, \
|
|
res, sizeof res - 1, 0 \
|
|
}
|
|
|
|
// +---------------------------------------- ctor n argument
|
|
// | +----------------------------- source value
|
|
// | | +------------------------ expected result sequence
|
|
// | | |
|
|
// | | |
|
|
// V V V
|
|
TEST (1, 'a', "a"),
|
|
TEST (1, '\0', "<U0>"),
|
|
|
|
TEST (2, 'a', "aa"),
|
|
TEST (2, '\0', "<U0>@2"),
|
|
|
|
TEST (5, '\0', "<U0>@5"),
|
|
TEST (10, 'a', "aaaaaaaaaa"),
|
|
|
|
TEST (128, 'x', "x@128"),
|
|
TEST (207, 'x', "x@207"),
|
|
TEST (540, 'x', "x@540"),
|
|
TEST (873, 'x', "x@873"),
|
|
TEST (1412, 'x', "x@1412"),
|
|
TEST (3695, 'x', "x@3695"),
|
|
|
|
TEST (4096, 'x', "x@4096"),
|
|
|
|
TEST (4, 't', "tttt")
|
|
};
|
|
|
|
/**************************************************************************/
|
|
// exercises:
|
|
// operator= (const value_type*)
|
|
static const StringTestCase
|
|
cptr_op_set_test_cases [] = {
|
|
|
|
#undef TEST
|
|
#define TEST(str, arg, res, bthrow) { \
|
|
__LINE__, -1, -1, -1, -1, -1, \
|
|
str, sizeof str - 1, arg, sizeof arg - 1, \
|
|
res, sizeof res - 1, bthrow \
|
|
}
|
|
|
|
// +----------------------------------------- source sequence
|
|
// | +------------------------------ argument sequence
|
|
// | | +-------------- expected result sequence
|
|
// | | | +--- exception info
|
|
// | | | | 0 - no exception
|
|
// | | | | -1 - excpetion safety
|
|
// | | | |
|
|
// | | | |
|
|
// V V V V
|
|
TEST ("", "ab", "ab", 0),
|
|
|
|
TEST ("", "", "", 0),
|
|
TEST ("abc", "", "", 0),
|
|
TEST ("", "<U0>", "", 0),
|
|
TEST ("abc", "<U0>", "", 0),
|
|
|
|
TEST ("", "a", "a", 0),
|
|
TEST ("<U0>@2", "a", "a", 0),
|
|
TEST ("a", "bcd", "bcd", 0),
|
|
TEST ("x@4096", "bcd", "bcd", 0),
|
|
TEST ("", "cdefaihjb", "cdefaihjb", 0),
|
|
TEST ("a<U0>b", "cdefaihjb", "cdefaihjb", 0),
|
|
|
|
TEST ("", "<U0>@2ab", "", 0),
|
|
TEST ("c<U0>d", "<U0>@2ab", "", 0),
|
|
TEST ("", "a<U0>@2b", "a", 0),
|
|
TEST ("bcd", "a<U0>@2b", "a", 0),
|
|
TEST ("<U0>", "ab<U0>@2", "ab", 0),
|
|
TEST ("x@4096", "ab<U0>@2", "ab", 0),
|
|
TEST ("<U0>a", "abefdcc<U0>a", "abefdcc", 0),
|
|
TEST ("x@4096", "abefdcc<U0>a", "abefdcc", 0),
|
|
|
|
TEST ("", "x@207", "x@207", 0),
|
|
TEST ("x@128", "x@207", "x@207", 0),
|
|
TEST ("x@540", "x@207", "x@207", 0),
|
|
TEST ("", "x@1412", "x@1412", 0),
|
|
TEST ("x@128", "x@1412", "x@1412", 0),
|
|
TEST ("x@3695", "x@1412", "x@1412", 0),
|
|
TEST ("x@872", "x@873", "x@873", 0),
|
|
TEST ("x@873", "x@3695", "x@3695", 0),
|
|
|
|
TEST ("abc", "x@4096", "x@4096", 0),
|
|
|
|
TEST ("", 0, "", 0),
|
|
TEST ("a<U0>b<U0>", 0, "a", 0),
|
|
TEST ("x@4096", 0, "x@4096", 0),
|
|
|
|
TEST ("abcd", "x@4096", "x@4096", 0),
|
|
|
|
TEST ("", "last test", "last test", 0)
|
|
};
|
|
|
|
/**************************************************************************/
|
|
// exercises:
|
|
// operator= (const basic_string&)
|
|
static const StringTestCase
|
|
cstr_op_set_test_cases [] = {
|
|
|
|
#undef TEST
|
|
#define TEST(str, arg, res, bthrow) { \
|
|
__LINE__, -1, -1, -1, -1, -1, \
|
|
str, sizeof str - 1, arg, sizeof arg - 1, \
|
|
res, sizeof res - 1, bthrow \
|
|
}
|
|
|
|
// +----------------------------------------- source sequence
|
|
// | +------------------------------ argument sequence
|
|
// | | +--------------- expected result sequence
|
|
// | | | +- exception info
|
|
// | | | | 0 - no exception
|
|
// | | | | -1 - excpetion safety
|
|
// | | | |
|
|
// | | | |
|
|
// V V V V
|
|
TEST ("", "ab", "ab", 0),
|
|
|
|
TEST ("", "", "", 0),
|
|
TEST ("abc", "", "", 0),
|
|
TEST ("", "<U0>", "<U0>", 0),
|
|
TEST ("abc", "<U0>", "<U0>", 0),
|
|
|
|
TEST ("", "a", "a", 0),
|
|
TEST ("<U0>@2", "a", "a", 0),
|
|
TEST ("a", "bcd", "bcd", 0),
|
|
TEST ("x@4096", "bcd", "bcd", 0),
|
|
TEST ("", "cdefaihjb", "cdefaihjb", 0),
|
|
TEST ("a<U0>b", "cdefaihjb", "cdefaihjb", 0),
|
|
|
|
TEST ("", "<U0>@2ab", "<U0>@2ab", 0),
|
|
TEST ("c<U0>d", "<U0>@2ab", "<U0>@2ab", 0),
|
|
TEST ("", "a<U0>@2b", "a<U0>@2b", 0),
|
|
TEST ("bcd", "a<U0>@2b", "a<U0>@2b", 0),
|
|
TEST ("<U0>", "ab<U0>@2", "ab<U0>@2", 0),
|
|
TEST ("x@4096", "ab<U0>@2", "ab<U0>@2", 0),
|
|
TEST ("<U0>a", "abefdcc<U0>a", "abefdcc<U0>a", 0),
|
|
TEST ("x@4096", "abefdcc<U0>a", "abefdcc<U0>a", 0),
|
|
|
|
TEST ("", "x@207", "x@207", 0),
|
|
TEST ("x@128", "x@207", "x@207", 0),
|
|
TEST ("x@540", "x@207", "x@207", 0),
|
|
TEST ("", "x@1412", "x@1412", 0),
|
|
TEST ("x@128", "x@1412", "x@1412", 0),
|
|
TEST ("x@3695", "x@1412", "x@1412", 0),
|
|
TEST ("x@872", "x@873", "x@873", 0),
|
|
TEST ("x@873", "x@3695", "x@3695", 0),
|
|
|
|
TEST ("abc", "x@4096", "x@4096", 0),
|
|
|
|
TEST ("", 0, "", 0),
|
|
TEST ("a<U0>b<U0>", 0, "a<U0>b<U0>", 0),
|
|
TEST ("x@4096", 0, "x@4096", 0),
|
|
|
|
TEST ("", "last test", "last test", 0)
|
|
};
|
|
|
|
|
|
/**************************************************************************/
|
|
|
|
// exercises:
|
|
// operator= (value_type)
|
|
static const StringTestCase
|
|
val_op_set_test_cases [] = {
|
|
|
|
#undef TEST
|
|
#define TEST(str, val, res) { \
|
|
__LINE__, -1, -1, -1, -1, val, \
|
|
str, sizeof str - 1, 0, 0, \
|
|
res, sizeof res - 1, 0 \
|
|
}
|
|
|
|
// +----------------------------------- initial sequence
|
|
// | +------------------------ source value
|
|
// | | +------------------- expected result sequence
|
|
// | | |
|
|
// | | |
|
|
// V V V
|
|
TEST ("", 'a', "a"),
|
|
TEST ("abcdef", 'a', "a"),
|
|
TEST ("", '\0', "<U0>"),
|
|
TEST ("a", '\0', "<U0>"),
|
|
TEST ("<U0>@2", 'x', "x"),
|
|
|
|
TEST ("x@207", 'a', "a"),
|
|
TEST ("x@873", '\0', "<U0>"),
|
|
TEST ("x@2284", 't', "t"),
|
|
TEST ("x@4096", 'x', "x"),
|
|
|
|
TEST ("", 't', "t")
|
|
};
|
|
|
|
/**************************************************************************/
|
|
|
|
// invokes specializations of the member function template
|
|
// on the required iterator categories
|
|
template <class String, class Iterator>
|
|
struct ConsRange: RangeBase<String> {
|
|
|
|
typedef typename String::iterator StringIter;
|
|
typedef typename String::value_type StringChar;
|
|
typedef typename String::allocator_type StringAlloc;
|
|
|
|
ConsRange () { }
|
|
|
|
virtual String&
|
|
operator() (String&, const StringTestCaseData<StringChar>& tdata) const {
|
|
|
|
const StringChar* const beg = tdata.arg_ + tdata.off2_;
|
|
const StringChar* const end = beg + tdata.ext2_;
|
|
|
|
const Iterator first (beg, beg, end);
|
|
const Iterator last (end, beg, end);
|
|
|
|
if (Cons (range_alloc) == tdata.func_.which_) {
|
|
StringAlloc alloc;
|
|
String* tmp = new String (first, last, alloc);
|
|
return *tmp;
|
|
}
|
|
|
|
String* tmp = new String (first, last);
|
|
return *tmp;
|
|
}
|
|
};
|
|
|
|
/**************************************************************************/
|
|
|
|
// invokes possible overloads of the member function template
|
|
// on common RandomAccessIterator types
|
|
template <class String, class Iterator>
|
|
struct ConsRangeOverload: RangeBase<String>
|
|
{
|
|
typedef typename String::iterator StringIter;
|
|
typedef typename String::value_type StringChar;
|
|
typedef typename String::allocator_type StringAlloc;
|
|
|
|
ConsRangeOverload () { }
|
|
|
|
virtual String&
|
|
operator() (String& str_arg,
|
|
const StringTestCaseData<StringChar>& tdata) const {
|
|
|
|
bool reverse_iter = StringIds::ReverseIterator == tdata.func_.iter_id_
|
|
|| StringIds::ConstReverseIterator == tdata.func_.iter_id_;
|
|
|
|
const std::size_t off = reverse_iter ?
|
|
tdata.arglen_ - tdata.off2_ - tdata.ext2_ : tdata.off2_;
|
|
const std::size_t ext = tdata.ext2_;
|
|
|
|
const Iterator first (this->begin (str_arg, (Iterator*)0) + off);
|
|
const Iterator last (first + ext);
|
|
|
|
if (Cons (range_alloc) == tdata.func_.which_) {
|
|
StringAlloc alloc;
|
|
String* tmp = new String (first, last, alloc);
|
|
return *tmp;
|
|
}
|
|
|
|
String* tmp = new String (first, last);
|
|
return *tmp;
|
|
}
|
|
};
|
|
|
|
/**************************************************************************/
|
|
|
|
template <class charT, class Traits, class Allocator>
|
|
void test_cons (charT*, Traits*, Allocator*, const RangeBase<
|
|
std::basic_string <charT, Traits, Allocator> > &rng,
|
|
const StringTestCaseData<charT> &tdata)
|
|
{
|
|
typedef std::basic_string <charT, Traits, Allocator> String;
|
|
|
|
const StringFunc &func = tdata.func_;
|
|
const StringTestCase &tcase = tdata.tcase_;
|
|
|
|
// construct the argument string
|
|
/* const */ String arg (tdata.arg_, tdata.arglen_);
|
|
|
|
// offset and extent function arguments
|
|
const std::size_t arg_off = -1 != tcase.off ?
|
|
std::size_t (tcase.off) : std::size_t (tcase.off2);
|
|
const std::size_t arg_size = -1 != tcase.size ?
|
|
std::size_t (tcase.size) : std::size_t (tcase.size2);
|
|
|
|
// string function argument
|
|
const charT* const arg_ptr = arg.c_str ();
|
|
const String& arg_str = arg;
|
|
const charT arg_val = make_char (char (tcase.val), (charT*)0);
|
|
const Allocator arg_alc;
|
|
|
|
// (name of) expected and caught exception
|
|
const char* expected = 0;
|
|
const char* caught = 0;
|
|
|
|
#ifndef _RWSTD_NO_EXCEPTIONS
|
|
|
|
if (1 == tcase.bthrow && Cons (range) != func.which_
|
|
&& Cons (range_alloc) != func.which_)
|
|
expected = exceptions [1]; // out_of_range
|
|
else if (2 == tcase.bthrow)
|
|
expected = exceptions [2]; // length_error
|
|
|
|
#else // if defined (_RWSTD_NO_EXCEPTIONS)
|
|
|
|
if (tcase.bthrow)
|
|
return;
|
|
|
|
#endif // _RWSTD_NO_EXCEPTIONS
|
|
|
|
// pointer to the returned reference
|
|
String* ret_ptr = 0;
|
|
|
|
// start checking for memory leaks
|
|
rwt_check_leaks (0, 0);
|
|
|
|
try {
|
|
switch (func.which_) {
|
|
|
|
case Cons (void):
|
|
ret_ptr = new String ();
|
|
break;
|
|
|
|
case Cons (alloc):
|
|
ret_ptr = new String (arg_alc);
|
|
break;
|
|
|
|
case Cons (cptr):
|
|
ret_ptr = new String (arg_ptr);
|
|
break;
|
|
|
|
case Cons (cptr_alloc):
|
|
ret_ptr = new String (arg_ptr, arg_alc);
|
|
break;
|
|
|
|
case Cons (cstr):
|
|
ret_ptr = new String (arg_str);
|
|
break;
|
|
|
|
case Cons (cptr_size):
|
|
ret_ptr = new String (arg_ptr, arg_size);
|
|
break;
|
|
|
|
case Cons (cptr_size_alloc):
|
|
ret_ptr = new String (arg_ptr, arg_size, arg_alc);
|
|
break;
|
|
|
|
case Cons (cstr_size):
|
|
ret_ptr = new String (arg_str, arg_off);
|
|
break;
|
|
|
|
case Cons (cstr_size_size):
|
|
ret_ptr = new String (arg_str, arg_off, arg_size);
|
|
break;
|
|
|
|
case Cons (cstr_size_size_alloc):
|
|
ret_ptr = new String (arg_str, arg_off, arg_size, arg_alc);
|
|
break;
|
|
|
|
case Cons (size_val):
|
|
ret_ptr = new String (arg_size, arg_val);
|
|
break;
|
|
|
|
case Cons (size_val_alloc):
|
|
ret_ptr = new String (arg_size, arg_val, arg_alc);
|
|
break;
|
|
|
|
case Cons (range):
|
|
ret_ptr = &rng (arg, tdata);
|
|
break;
|
|
|
|
case Cons (range_alloc):
|
|
ret_ptr = &rng (arg, tdata);
|
|
break;
|
|
|
|
default:
|
|
RW_ASSERT (!"logic error: unknown constructor overload");
|
|
}
|
|
|
|
// for convenience
|
|
static const int cwidth = sizeof (charT);
|
|
|
|
// verify that returned pointer is valid
|
|
rw_assert (0 != ret_ptr, 0, tcase.line,
|
|
"line %d. %{$FUNCALL} expected %{/*.*Gs}, got null",
|
|
__LINE__, cwidth, int (tdata.reslen_), tdata.res_);
|
|
|
|
if (0 != ret_ptr) {
|
|
|
|
// verfiy that the length of the resulting string
|
|
rw_assert (tdata.reslen_ == ret_ptr->size (), 0, tcase.line,
|
|
"line %d. %{$FUNCALL} expected %{/*.*Gs} with "
|
|
"length %zu, got %{/*.*Gs} with length %zu",
|
|
__LINE__,
|
|
cwidth, int (tdata.reslen_), tdata.res_,
|
|
tdata.reslen_, cwidth, int (ret_ptr->size ()),
|
|
ret_ptr->data (), ret_ptr->size ());
|
|
|
|
if (Cons (void) != func.which_) {
|
|
// verify the capacity of the resulting string
|
|
rw_assert (ret_ptr->size () <= ret_ptr->capacity (), 0,
|
|
tcase.line, "line %d. %{$FUNCALL} expected "
|
|
"capacity () >= size (), got capacity () == "
|
|
"%zu, size () == %zu", __LINE__,
|
|
ret_ptr->capacity (), ret_ptr->size ());
|
|
}
|
|
|
|
if (tdata.reslen_ == ret_ptr->size ()) {
|
|
// if the result length matches the expected length
|
|
// (and only then), also verify that the modified
|
|
// string matches the expected result
|
|
const std::size_t match =
|
|
rw_match (tcase.res, ret_ptr->c_str (), ret_ptr->size ());
|
|
|
|
rw_assert (match == tdata.reslen_, 0, tcase.line,
|
|
"line %d. %{$FUNCALL} expected %{/*.*Gs}, "
|
|
"got %{/*.*Gs}, difference at offset %zu",
|
|
__LINE__,
|
|
cwidth, int (tdata.reslen_), tdata.res_,
|
|
cwidth, int (ret_ptr->size ()),
|
|
ret_ptr->data (), match);
|
|
}
|
|
|
|
delete ret_ptr;
|
|
}
|
|
}
|
|
|
|
#ifndef _RWSTD_NO_EXCEPTIONS
|
|
|
|
catch (const std::out_of_range &ex) {
|
|
caught = exceptions [1];
|
|
rw_assert (caught == expected, 0, tcase.line,
|
|
"line %d. %{$FUNCALL} %{?}expected %s,%{:}"
|
|
"unexpectedly%{;} caught std::%s(%#s)",
|
|
__LINE__, 0 != expected, expected, caught, ex.what ());
|
|
}
|
|
catch (const std::length_error &ex) {
|
|
caught = exceptions [2];
|
|
rw_assert (caught == expected, 0, tcase.line,
|
|
"line %d. %{$FUNCALL} %{?}expected %s,%{:}"
|
|
"unexpectedly%{;} caught std::%s(%#s)",
|
|
__LINE__, 0 != expected, expected, caught, ex.what ());
|
|
}
|
|
catch (const std::bad_alloc &ex) {
|
|
caught = exceptions [3];
|
|
rw_assert (-1 == tcase.bthrow, 0, tcase.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, tcase.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, tcase.line,
|
|
"line %d. %{$FUNCALL} %{?}expected %s,%{:}"
|
|
"unexpectedly%{;} caught %s",
|
|
__LINE__, 0 != expected, expected, caught);
|
|
}
|
|
|
|
#endif // _RWSTD_NO_EXCEPTIONS
|
|
|
|
/* const */ std::size_t nbytes;
|
|
const std::size_t nblocks = rwt_check_leaks (&nbytes, 0);
|
|
|
|
// FIXME: verify the number of blocks the function call
|
|
// is expected to allocate and detect any memory leaks
|
|
const std::size_t expect_blocks = nblocks;
|
|
|
|
rw_assert (nblocks == expect_blocks, 0, tcase.line,
|
|
"line %d. %{$FUNCALL} allocated %td bytes in %td blocks",
|
|
__LINE__, nbytes, expect_blocks);
|
|
}
|
|
|
|
/**************************************************************************/
|
|
|
|
template <class charT, class Traits, class Allocator>
|
|
void test_op_set (charT*, Traits*, Allocator*,
|
|
const StringTestCaseData<charT> &tdata)
|
|
{
|
|
typedef std::basic_string <charT, Traits, Allocator> String;
|
|
typedef typename UserTraits<charT>::MemFun TraitsFunc;
|
|
|
|
const StringFunc &func = tdata.func_;
|
|
const StringTestCase &tcase = tdata.tcase_;
|
|
|
|
// construct the string object to be modified
|
|
// and the (possibly unused) argument string
|
|
/* const */ String str (tdata.str_, tdata.strlen_, Allocator ());
|
|
const String arg (tdata.arg_, tdata.arglen_, Allocator ());
|
|
|
|
// save the state of the string object before the call
|
|
// to detect wxception safety violations (changes to
|
|
// the state of the object after an exception)
|
|
const StringState str_state (rw_get_string_state (str));
|
|
|
|
// string function argument
|
|
const charT* const arg_ptr = tcase.arg ? arg.data () : str.data ();
|
|
const String& arg_str = tcase.arg ? arg : str;
|
|
const charT arg_val = make_char (char (tcase.val), (charT*)0);
|
|
|
|
std::size_t total_length_calls = 0;
|
|
std::size_t n_length_calls = 0;
|
|
std::size_t* const rg_calls = OpSet (cptr) == func.which_ ?
|
|
rw_get_call_counters ((Traits*)0, (charT*)0) : 0;
|
|
|
|
if (rg_calls)
|
|
total_length_calls = rg_calls [TraitsFunc::length];
|
|
|
|
rwt_free_store* const pst = rwt_get_free_store (0);
|
|
SharedAlloc* const pal = SharedAlloc::instance ();
|
|
|
|
// iterate for`throw_after' starting at the next call to operator new,
|
|
// forcing each call to throw an exception, until the function finally
|
|
// succeeds (i.e, no exception is thrown)
|
|
std::size_t throw_count;
|
|
for (throw_count = 0; ; ++throw_count) {
|
|
|
|
// (name of) expected and caught exception
|
|
const char* expected = 0;
|
|
const char* caught = 0;
|
|
|
|
#ifndef _RWSTD_NO_EXCEPTIONS
|
|
|
|
if (0 == tcase.bthrow) {
|
|
// by default excercise the exception safety of the function
|
|
// by iteratively inducing an exception at each call to operator
|
|
// new or Allocator::allocate() until the call succeeds
|
|
expected = exceptions [3]; // bad_alloc
|
|
*pst->throw_at_calls_ [0] = pst->new_calls_ [0] + throw_count + 1;
|
|
pal->throw_at_calls_ [pal->m_allocate] =
|
|
pal->throw_at_calls_ [pal->m_allocate] + throw_count + 1;
|
|
}
|
|
else {
|
|
// exceptions disabled for this test case
|
|
}
|
|
|
|
#else // if defined (_RWSTD_NO_EXCEPTIONS)
|
|
|
|
if (tcase.bthrow) {
|
|
return;
|
|
}
|
|
|
|
#endif // _RWSTD_NO_EXCEPTIONS
|
|
|
|
// start checking for memory leaks
|
|
rw_check_leaks (str.get_allocator ());
|
|
|
|
try {
|
|
switch (func.which_) {
|
|
|
|
case OpSet (cptr):
|
|
str = arg_ptr;
|
|
break;
|
|
|
|
case OpSet (cstr):
|
|
str = arg_str;
|
|
break;
|
|
|
|
case OpSet (val):
|
|
str = arg_val;
|
|
break;
|
|
|
|
default:
|
|
RW_ASSERT (!"logic error: unknown operator= overload");
|
|
}
|
|
|
|
// for convenience
|
|
static const int cwidth = sizeof (charT);
|
|
|
|
// verfiy that the length of the resulting string
|
|
rw_assert (tdata.reslen_ == str.size (), 0, tcase.line,
|
|
"line %d. %{$FUNCALL} expected %{/*.*Gs} with "
|
|
"length %zu, got %{/*.*Gs} with length %zu",
|
|
__LINE__,
|
|
cwidth, int (tdata.reslen_), tdata.res_,
|
|
tdata.reslen_, cwidth, int (str.size ()), str.data (),
|
|
str.size ());
|
|
|
|
if (tdata.reslen_ == str.size ()) {
|
|
// if the result length matches the expected length
|
|
// (and only then), also verify that the modified
|
|
// string matches the expected result
|
|
const std::size_t match =
|
|
rw_match (tcase.res, str.c_str (), str.size ());
|
|
|
|
rw_assert (match == tdata.reslen_, 0, tcase.line,
|
|
"line %d. %{$FUNCALL} expected %{/*.*Gs}, "
|
|
"got %{/*.*Gs}, difference at offset %zu",
|
|
__LINE__,
|
|
cwidth, int (tdata.reslen_), tdata.res_,
|
|
cwidth, int (str.size ()),str.data (), match);
|
|
}
|
|
|
|
// verify that Traits::length was used
|
|
if (rg_calls) {
|
|
rw_assert (n_length_calls - total_length_calls > 0,
|
|
0, tcase.line, "line %d. %{$FUNCALL} doesn't "
|
|
"use traits::length()", __LINE__);
|
|
}
|
|
}
|
|
|
|
#ifndef _RWSTD_NO_EXCEPTIONS
|
|
|
|
catch (const std::bad_alloc &ex) {
|
|
caught = exceptions [3];
|
|
rw_assert (0 == tcase.bthrow, 0, tcase.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, tcase.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, tcase.line,
|
|
"line %d. %{$FUNCALL} %{?}expected %s,%{:}"
|
|
"unexpectedly%{;} caught %s",
|
|
__LINE__, 0 != expected, expected, caught);
|
|
}
|
|
|
|
#endif // _RWSTD_NO_EXCEPTIONS
|
|
|
|
// FIXME: verify the number of blocks the function call
|
|
// is expected to allocate and detect any memory leaks
|
|
rw_check_leaks (str.get_allocator (), tcase.line,
|
|
std::size_t (-1), std::size_t (-1));
|
|
|
|
if (caught) {
|
|
// verify that an exception thrown during allocation
|
|
// didn't cause a change in the state of the object
|
|
str_state.assert_equal (rw_get_string_state (str),
|
|
__LINE__, tcase.line, caught);
|
|
|
|
if (0 == tcase.bthrow) {
|
|
// allow this call to operator new to succeed and try
|
|
// to make the next one to fail during the next call
|
|
// to the same function again
|
|
continue;
|
|
}
|
|
}
|
|
else if (0 < tcase.bthrow) {
|
|
rw_assert (caught == expected, 0, tcase.line,
|
|
"line %d. %{$FUNCALL} %{?}expected %s, caught %s"
|
|
"%{:}unexpectedly caught %s%{;}",
|
|
__LINE__, 0 != expected, expected, caught, caught);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
std::size_t expect_throws = 0;
|
|
|
|
if (OpSet (cstr) != func.which_) {
|
|
|
|
#ifndef _RWSTD_NO_REPLACEABLE_NEW_DELETE
|
|
|
|
// verify that if exceptions are enabled and when capacity changes
|
|
// at least one exception is thrown
|
|
expect_throws = str_state.capacity_ < str.capacity ();
|
|
|
|
#else // if defined (_RWSTD_NO_REPLACEABLE_NEW_DELETE)
|
|
|
|
expect_throws = StringIds::UserAlloc == func.alloc_id_ ?
|
|
str_state.capacity_ < str.capacity () : 0;
|
|
|
|
#endif // _RWSTD_NO_REPLACEABLE_NEW_DELETE
|
|
|
|
}
|
|
|
|
rw_assert (expect_throws == throw_count, 0, tcase.line,
|
|
"line %d: %{$FUNCALL}: expected exactly 1 %s exception "
|
|
"while changing capacity from %zu to %zu, got %zu",
|
|
__LINE__, exceptions [3],
|
|
str_state.capacity_, str.capacity (), throw_count);
|
|
|
|
// disable bad_alloc exceptions
|
|
*pst->throw_at_calls_ [0] = 0;
|
|
pal->throw_at_calls_ [pal->m_allocate] = 0;
|
|
}
|
|
|
|
/**************************************************************************/
|
|
|
|
template <class charT, class Traits, class Allocator>
|
|
void test_cons (charT*, Traits*, Allocator*,
|
|
const StringTestCaseData<charT> &tdata)
|
|
{
|
|
typedef std::basic_string<charT, Traits, Allocator> String;
|
|
|
|
const int fid = int (tdata.func_.which_) & StringIds::fid_mask;
|
|
|
|
if (StringIds::fid_op_set == fid) {
|
|
test_op_set ((charT*)0, (Traits*)0, (Allocator*)0, tdata);
|
|
return;
|
|
}
|
|
|
|
if (tdata.func_.which_ == Cons (range)
|
|
|| tdata.func_.which_ == Cons (range_alloc)) {
|
|
|
|
switch (tdata.func_.iter_id_) {
|
|
|
|
// exercise possible overloads of the member function template
|
|
// on common RandomAccessIterator types
|
|
#undef TEST
|
|
#define TEST(Iterator) do { \
|
|
typedef typename String::Iterator Iter; \
|
|
static const \
|
|
ConsRangeOverload<String, Iter> rng; \
|
|
test_cons ((charT*)0, (Traits*)0, (Allocator*)0, rng, tdata); \
|
|
} while (0)
|
|
|
|
case StringIds::Pointer: TEST (pointer); break;
|
|
case StringIds::ConstPointer: TEST (const_pointer); break;
|
|
case StringIds::Iterator: TEST (iterator); break;
|
|
case StringIds::ConstIterator: TEST (const_iterator); break;
|
|
|
|
case StringIds::ReverseIterator: TEST (reverse_iterator); break;
|
|
case StringIds::ConstReverseIterator: TEST (const_reverse_iterator);
|
|
break;
|
|
|
|
// exercise specializations of the member function template
|
|
// on the required iterator categories
|
|
|
|
#undef TEST
|
|
#define TEST(Iterator) do { \
|
|
typedef Iterator<charT> Iter; \
|
|
static const \
|
|
ConsRange<String, Iter> rng; \
|
|
test_cons ((charT*)0, (Traits*)0, (Allocator*)0, rng, tdata); \
|
|
} while (0)
|
|
|
|
case StringIds::Input: TEST (InputIter); break;
|
|
case StringIds::Forward: TEST (ConstFwdIter); break;
|
|
case StringIds::Bidir: TEST (ConstBidirIter); break;
|
|
case StringIds::Random: TEST (ConstRandomAccessIter); break;
|
|
|
|
default:
|
|
rw_error (0, 0, __LINE__, "bad iterator id");
|
|
}
|
|
}
|
|
else {
|
|
// exercise ordinary overloads of the member function
|
|
static const RangeBase<String> rng;
|
|
test_cons ((charT*)0, (Traits*)0, (Allocator*)0, rng, tdata);
|
|
}
|
|
}
|
|
|
|
/**************************************************************************/
|
|
|
|
DEFINE_STRING_TEST_FUNCTIONS (test_cons);
|
|
|
|
int main (int argc, char** argv)
|
|
{
|
|
static const StringTest
|
|
tests [] = {
|
|
|
|
#undef TEST
|
|
#define TEST(sig) { \
|
|
Cons (sig), sig ## _test_cases, \
|
|
sizeof sig ## _test_cases / sizeof *sig ## _test_cases \
|
|
}
|
|
|
|
TEST (void),
|
|
TEST (alloc),
|
|
TEST (cptr),
|
|
TEST (cptr_alloc),
|
|
TEST (cstr),
|
|
TEST (cptr_size),
|
|
TEST (cptr_size_alloc),
|
|
TEST (cstr_size),
|
|
TEST (cstr_size_size),
|
|
TEST (cstr_size_size_alloc),
|
|
TEST (size_val),
|
|
TEST (size_val_alloc),
|
|
TEST (range),
|
|
TEST (range_alloc),
|
|
|
|
#undef TEST
|
|
#define TEST(sig) { \
|
|
OpSet (sig), sig ## _op_set_test_cases, \
|
|
sizeof sig ## _op_set_test_cases \
|
|
/ sizeof *sig ## _op_set_test_cases \
|
|
}
|
|
|
|
TEST (cptr),
|
|
TEST (cstr),
|
|
TEST (val)
|
|
|
|
};
|
|
|
|
const std::size_t test_count = sizeof tests / sizeof *tests;
|
|
|
|
const int status =
|
|
rw_run_string_test (argc, argv, __FILE__,
|
|
"lib.string.cons",
|
|
test_cons_func_array, tests, test_count);
|
|
|
|
return status;
|
|
}
|