diff --git a/test/migrate_test/test_group1.cpp b/test/migrate_test/test_group1.cpp new file mode 100644 index 000000000..f4bcd7e27 --- /dev/null +++ b/test/migrate_test/test_group1.cpp @@ -0,0 +1,145 @@ +#define BOOST_TEST_MODULE TestGroup1 +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +using namespace boost::algorithm; + +#include + +const string foo = "foo"; +const string bar = "bar"; +const string foobar = "foobar"; +const string FOO = "FOO"; +const string BAR = "BAR"; +const string FOOBAR = "FOOBAR"; + +const wstring CharU20000 = L"\xD840\xDC00"; +const wstring CharU20001 = L"\xD840\xDC01"; + +const wstring CharUSuppCharHigh = L"\xDC00"; +const wstring CharUSuppCharLow= L"\xD840"; + +//test1 verify if the prefix of a string matches a specified prefix. +BOOST_AUTO_TEST_CASE(testStartsWith) { + + BOOST_CHECK(starts_with("","")); + BOOST_CHECK(starts_with(FOOBAR,"")); + BOOST_CHECK(!starts_with("",FOO)); + + BOOST_CHECK(starts_with(foobar,foo)); + BOOST_CHECK(starts_with(FOOBAR,FOO)); + BOOST_CHECK(!starts_with(foobar,FOO)); + BOOST_CHECK(!starts_with(FOOBAR,foo)); + + BOOST_CHECK(!starts_with(foo,foobar)); + BOOST_CHECK(!starts_with(bar,foobar)); + + BOOST_CHECK(!starts_with(foobar,bar)); + BOOST_CHECK(!starts_with(FOOBAR,BAR)); + BOOST_CHECK(!starts_with(foobar,BAR)); + BOOST_CHECK(!starts_with(FOOBAR,bar)); +} + +//test2 verify if it can remove leading and trailing whitespace from a string. +BOOST_AUTO_TEST_CASE(testTrim) { + BOOST_CHECK_EQUAL(FOO, trim_copy(FOO + " ")); + BOOST_CHECK_EQUAL(FOO, trim_copy(" " + FOO + " ")); + BOOST_CHECK_EQUAL(FOO, trim_copy(" " + FOO)); + BOOST_CHECK_EQUAL(FOO, trim_copy(FOO + "")); + // BOOST_CHECK_EQUAL("", trim_copy(string(" \t\r\n "))); + // \b + BOOST_CHECK_EQUAL("", trim_copy(string(" \t\r\n\b "))); +} + + +//test3 verify if a string is entirely composed of whitespace characters. +BOOST_AUTO_TEST_CASE(testIsBlank) +{ + BOOST_CHECK(!all_of("", is_space())); + BOOST_CHECK(all_of(string(""), is_space())); + BOOST_CHECK(!all_of("foo", is_space())); + BOOST_CHECK(!all_of(" foo ", is_space())); +} + +// test4 verify if a string is not entirely composed of whitespace characters. +BOOST_AUTO_TEST_CASE(testIsNotBlank){ + BOOST_CHECK(!all_of("a", is_space())); + BOOST_CHECK(!all_of("foo", is_space())); + BOOST_CHECK(!all_of(" foo ", is_space())); +} + +//test5 verify if one string contains another string. +BOOST_AUTO_TEST_CASE(testContains_String) { + BOOST_CHECK(contains("", "")); + BOOST_CHECK(!contains("", "a")); + BOOST_CHECK(contains("abc", "a")); + BOOST_CHECK(contains("abc", "b")); + BOOST_CHECK(contains("abc", "c")); + BOOST_CHECK(contains("abc", "abc")); + BOOST_CHECK(!contains("abc", "z")); +} + + +// test6 verify if a character is present in a string. +BOOST_AUTO_TEST_CASE(testContains_Char) { + BOOST_CHECK(!contains(string(""), string(1, ' '))); + BOOST_CHECK(contains(string("abc"), string(1, 'a'))); + BOOST_CHECK(contains(string("abc"), string(1, 'b'))); + BOOST_CHECK(contains(string("abc"), string(1, 'c'))); + BOOST_CHECK(!contains(string("abc"), string(1, 'z'))); +} + + +//test7 verify if a string contains Unicode supplementary characters +BOOST_AUTO_TEST_CASE(testContains_StringWithSupplementaryChars) { + BOOST_CHECK(contains(CharU20000 + CharU20001, CharU20000)); + BOOST_CHECK(contains(CharU20000 + CharU20001, CharU20001)); + BOOST_CHECK(contains(CharU20000, CharU20000)); + BOOST_CHECK(!contains(CharU20000, CharU20001)); +} + +//test8 verify if a string contains invalid Unicode supplementary characters. +BOOST_AUTO_TEST_CASE(testContains_StringWithBadSupplementaryChars) { + BOOST_CHECK(!contains(CharUSuppCharHigh, CharU20001)); + BOOST_CHECK(!contains(CharUSuppCharLow, CharU20001)); + BOOST_CHECK(!contains(CharU20001, CharUSuppCharHigh)); + // + BOOST_CHECK(contains(CharU20001, CharUSuppCharLow)); + + BOOST_CHECK(contains(CharU20001 + CharUSuppCharLow + L"a", L"a")); + BOOST_CHECK(contains(CharU20001 + CharUSuppCharHigh + L"a", L"a")); +} + + +//test9 verify if two strings are equal. +BOOST_AUTO_TEST_CASE(testEquals) +{ + string fooCs = FOO; + string barCs = BAR; + string foobarCs = FOOBAR; + + BOOST_CHECK(equals(fooCs, fooCs)); + BOOST_CHECK(!equals(fooCs, string("foo"))); + + BOOST_CHECK(iequals(fooCs, string("fOo"))); + BOOST_CHECK(!equals(fooCs, barCs)); + BOOST_CHECK(!equals(fooCs, foobarCs)); + BOOST_CHECK(!equals(foobarCs, fooCs)); +} + +//test10 verify if two strings are equal. +BOOST_AUTO_TEST_CASE(testEqualsOnStrings) { + BOOST_CHECK(equals(FOO, FOO)); + BOOST_CHECK(!equals(FOO, string("foo"))); + BOOST_CHECK(!equals(FOO, string("fOo"))); + BOOST_CHECK(!equals(FOO, BAR)); + BOOST_CHECK(!equals(FOO, FOOBAR)); + BOOST_CHECK(!equals(FOOBAR, FOO)); +} + diff --git a/test/migrate_test/test_group2.cpp b/test/migrate_test/test_group2.cpp new file mode 100644 index 000000000..b3467bee5 --- /dev/null +++ b/test/migrate_test/test_group2.cpp @@ -0,0 +1,171 @@ +#define BOOST_TEST_MODULE TestGroup2 +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +using namespace boost::algorithm; + +#include + +const string foo = "foo"; +const string bar = "bar"; +const string foobar = "foobar"; +const string FOO = "FOO"; +const string BAR = "BAR"; +const string FOOBAR = "FOOBAR"; + +const wstring CharU20000 = L"\xD840\xDC00"; +const wstring CharU20001 = L"\xD840\xDC01"; + +const wstring CharUSuppCharHigh = L"\xDC00"; +const wstring CharUSuppCharLow= L"\xD840"; + +const string TEXT_LIST_NOSEP = "foobarbaz"; +const string SEPARATOR_CHAR = ";"; +const string COMMA_SEPARATOR_CHAR = ","; +const string TEXT_LIST_CHAR = "foo;bar;baz"; + +const vector ARRAY_LIST = {"foo", "bar", "baz"}; +const vector EMPTY_ARRAY_LIST = {}; +const vector MIXED_ARRAY_LIST = {"", "foo"}; +const vector MIXED_TYPE_LIST = {"foo", to_string(2L)}; +const vector PRIM_LIST = {"1", "2"}; +const vector STRING_LIST = {"foo", "bar", "baz"}; +const vector EMPTY_STRING_LIST = {}; +const vector ARRAY_FALSE_FALSE = {"false", "false"}; +const vector ARRAY_FALSE_TRUE = {"false", "true"}; +const vector ARRAY_FALSE_TRUE_FALSE = {"false", "true", "false"}; + + +//test11 verify if a string is equal to any of a set of other strings. +BOOST_AUTO_TEST_CASE(testEqualsAny) { + BOOST_CHECK(!equals(FOO, "")); + BOOST_CHECK(!equals(FOO, string(""))); + + BOOST_CHECK(equals(FOO, FOO)); + BOOST_CHECK(!equals(FOO, "foo")); + BOOST_CHECK(!equals(FOO, "fOo")); + BOOST_CHECK(!equals(FOO, "bar")); +} + +// test12 verify if a string contains only alphabetic characters. +BOOST_AUTO_TEST_CASE(testIsAlpha) { + BOOST_CHECK(all(string(""), is_alpha())); + + BOOST_CHECK(!all(string(" "), is_alpha())); + BOOST_CHECK(all(string("a"), is_alpha())); + BOOST_CHECK(all(string("A"), is_alpha())); + BOOST_CHECK(all(string("kgKgKgKgkgkGkjkjlJlOKLgHdGdHgl"), is_alpha())); + BOOST_CHECK(!all(string("ham kso"), is_alpha())); + BOOST_CHECK(!all(string("1"), is_alpha())); + // 6，7，87 + BOOST_CHECK(!all(string("hkHKHik6iUGHKJgU7tUJgKJGI87GIkug"), is_alpha())); + BOOST_CHECK(!all(string("_"), is_alpha())); + // * + BOOST_CHECK(!all(string("hkHKHik*khbkuh"), is_alpha())); +} + +//test13 verify if it can join a vector of strings using a specified delimiter. +BOOST_AUTO_TEST_CASE(testJoin_Objects) { + BOOST_CHECK_EQUAL("abc", join(vector({"a", "b", "c"}), "")); + BOOST_CHECK_EQUAL("a", join(vector({"", "", "a"}), "")); + BOOST_CHECK(join(vector({}), "").empty()); +} + +//test14 verify if it can join an array of strings using a specified delimiter. +BOOST_AUTO_TEST_CASE(testJoin_Objectarray) { + BOOST_CHECK(join(vector({}), "").empty()); + + BOOST_CHECK_EQUAL("", join(vector({}), "")); + BOOST_CHECK_EQUAL("", join(vector({""}), "")); + + BOOST_CHECK_EQUAL("", join(EMPTY_ARRAY_LIST, "")); + BOOST_CHECK_EQUAL("abc", join(vector({"a", "b", "c"}), "")); + BOOST_CHECK_EQUAL("a", join(vector({ "", "a", "" }), "")); + BOOST_CHECK_EQUAL("foo", join(MIXED_ARRAY_LIST, "")); + BOOST_CHECK_EQUAL("foo2", join(MIXED_TYPE_LIST, "")); +} + +// test15 verify if it can join an array of strings without using a delimiter. +BOOST_AUTO_TEST_CASE(testJoin_ArrayString_EmptyDelimiter) { + BOOST_CHECK(join(vector({}), "").empty()); + + BOOST_CHECK_EQUAL(TEXT_LIST_NOSEP, join(ARRAY_LIST, "")); + BOOST_CHECK_EQUAL(TEXT_LIST_NOSEP, join(ARRAY_LIST, "")); + + BOOST_CHECK_EQUAL("", join(EMPTY_ARRAY_LIST, "")); + BOOST_CHECK_EQUAL("", join(EMPTY_ARRAY_LIST, "")); + + BOOST_CHECK_EQUAL("", join(vector(MIXED_ARRAY_LIST.begin(), MIXED_ARRAY_LIST.end() - 1), "")); +} + +//test16 verify if it can join an array of doubles using a specified delimiter. +BOOST_AUTO_TEST_CASE(testJoin_ArrayOfDoubles) { + BOOST_CHECK(join(vector({}), "").empty()); + + BOOST_CHECK_EQUAL("1;2", join(PRIM_LIST, SEPARATOR_CHAR)); + BOOST_CHECK("2" != join(PRIM_LIST, SEPARATOR_CHAR)); + BOOST_CHECK("" != join(PRIM_LIST, SEPARATOR_CHAR)); +} + +//test17 verify if it can join an array of Number using a specified delimiter. +BOOST_AUTO_TEST_CASE(testJoin_ArrayOfFloats) { + BOOST_CHECK(join(vector({}), "").empty()); + + BOOST_CHECK_EQUAL("1;2", join(PRIM_LIST, SEPARATOR_CHAR)); + BOOST_CHECK("2" != join(PRIM_LIST, SEPARATOR_CHAR)); + BOOST_CHECK("" != join(PRIM_LIST, SEPARATOR_CHAR)); +} + +//test18 verify if it can join an array of booleans using a specified delimiter. +BOOST_AUTO_TEST_CASE(testJoin_ArrayOfBooleans) { + BOOST_CHECK_EQUAL("false;false", join(ARRAY_FALSE_FALSE, SEPARATOR_CHAR)); + // BOOST_CHECK_EQUAL("", join("", SEPARATOR_CHAR)); + BOOST_CHECK_EQUAL("false,true,false", join(ARRAY_FALSE_TRUE_FALSE, COMMA_SEPARATOR_CHAR)); + BOOST_CHECK_EQUAL("false;true", join(ARRAY_FALSE_TRUE, SEPARATOR_CHAR)); + BOOST_CHECK("" != join(ARRAY_FALSE_FALSE, SEPARATOR_CHAR)); + BOOST_CHECK("" != join(ARRAY_FALSE_TRUE_FALSE, SEPARATOR_CHAR)); +} + +//test19 verify if it can join an array of shorts using a specified delimiter. +BOOST_AUTO_TEST_CASE(testJoin_ArrayOfShorts) { + BOOST_CHECK_EQUAL("1;2", join(PRIM_LIST, SEPARATOR_CHAR)); + BOOST_CHECK("2" != join(PRIM_LIST, SEPARATOR_CHAR)); +} + +//test20 verify if it can join an array of strings using a specified character delimiter. +BOOST_AUTO_TEST_CASE(testJoin_ArrayCharSeparator) { + BOOST_CHECK_EQUAL( TEXT_LIST_CHAR ,join( ARRAY_LIST, SEPARATOR_CHAR)); + BOOST_CHECK_EQUAL("", join( EMPTY_ARRAY_LIST, SEPARATOR_CHAR)); + BOOST_CHECK_EQUAL(";foo", join( MIXED_ARRAY_LIST, SEPARATOR_CHAR)); + BOOST_CHECK_EQUAL("foo;2", join( MIXED_TYPE_LIST, SEPARATOR_CHAR)); +} + +//test21 verify if it can join an array of ints using a specified delimiter. +BOOST_AUTO_TEST_CASE(testJoin_ArrayOfInts) { + BOOST_CHECK_EQUAL("1;2", join(PRIM_LIST, SEPARATOR_CHAR)); + BOOST_CHECK("2" != join(PRIM_LIST, SEPARATOR_CHAR)); +} + +//test22 verify if it can join a list of strings without using a delimiter. +BOOST_AUTO_TEST_CASE(testJoin_List_EmptyDelimiter) { + BOOST_CHECK_EQUAL(TEXT_LIST_NOSEP, join(STRING_LIST, "")); + BOOST_CHECK_EQUAL("", join(EMPTY_STRING_LIST, "")); + } + +//test23 verify if it can replace all occurrences of a substring in a string with a specified replacement string. +BOOST_AUTO_TEST_CASE(testreplace_all_copy_StringStringString){ + string emptyStr =""; + string FOO ="FOO"; + string foofoofoo= "foofoofoo"; + BOOST_CHECK_EQUAL("", replace_all_copy (emptyStr, "any", "any")); + BOOST_CHECK_EQUAL ("FOO",replace_all_copy (FOO,"","any")); + BOOST_CHECK_EQUAL ("", replace_all_copy (foofoofoo,"foo","")); + BOOST_CHECK_EQUAL ("barbarbar", replace_all_copy (foofoofoo,"foo","bar")); + BOOST_CHECK_EQUAL ("farfarfar", replace_all_copy (foofoofoo,"oo","ar")); +}