Пример #1
0
void checkNotStartWith(const Sid::String& test, const Sid::String& prefix)
{
    const char* origData = test.data();
    CPPUNIT_ASSERT_PRINTF(!test.startWith(prefix),
    			"startsWith() did not return false for "
    			"\n%s\n%s\n",
    			prefix.isNull() ? "(NULL)" : prefix.data(),
    			test.isNull() ? "(NULL)" : test.data());
    CPPUNIT_ASSERT_MESSAGE("startWith() causes object to relinquish its reference!",
                            origData == test.data());
}
Пример #2
0
void checkUnescaping(const Sid::String& test, const Sid::String& expected)
{
    const char* origData = test.data();
    Sid::String unescaped=test.unescape();
    CPPUNIT_ASSERT_PRINTF(unescaped == expected,
    			"Unescaping \"%s\" did not yield \"%s\" as "
    			"expected, instead yielded \"%s\"\n",
    			!test.isNull() ? test.data() : "(NULL)",
    			!expected.isNull() ? expected.data() : "(NULL)",
    			!unescaped.isNull() ? unescaped.data() : "(NULL)");
    CPPUNIT_ASSERT_MESSAGE("unescape() causes object to relinquish its reference!",
                            origData == test.data());
}
Пример #3
0
void checkHexRepresentation(const Sid::String& test, const Sid::String& expected)
{
    const char* origData = test.data();
    Sid::String res = test.getHexRepresentation();
    CPPUNIT_ASSERT_PRINTF(res == expected,
                            "getHexRepresentation() yielded unexpected result for value "
                            "\"%s\", should have been \"%s\", instead got \"%s\"\n",
                            test.isNull() ? "(NULL)" : test.data(),
                            expected.isNull() ? "(NULL)" : expected.data(),
                            res.isNull() ? "(NULL)" : res.data());    
    CPPUNIT_ASSERT_MESSAGE("getHexRepresentation() causes object to relinquish its reference!",
                            origData == test.data());
}
Пример #4
0
void checkFrom(bool b, const Sid::String& expected)
{
    Sid::String from = Sid::String::from(b);
    CPPUNIT_ASSERT_PRINTF(from == expected,
                            "from((bool)%s) yielded unexpected result \"%s\"\n",
                            b ? "true" : "false",
                            from.isNull() ? "(NULL)" : from.data());
}
Пример #5
0
void checkFrom(char c, const Sid::String& expected)
{
    Sid::String from = Sid::String::from(c);
    CPPUNIT_ASSERT_PRINTF(from == expected,
                            "from((char)%c) yielded unexpected result \"%s\"\n",
                            c,
                            from.isNull() ? "(NULL)" : from.data());
}
Пример #6
0
void checkFrom(uint64 n, const Sid::String& expected)
{
    Sid::String from = Sid::String::from(n);
    CPPUNIT_ASSERT_PRINTF(from == expected,
                            "from((uint64)%llu) yielded unexpected result \"%s\"\n",
                            n, 
                            from.isNull() ? "(NULL)" : from.data());
}
Пример #7
0
void checkRight(const Sid::String& test, 
    	unsigned int len,
    	const Sid::String& expected)
{
    const char* origData = test.data();
    Sid::String right = test.right(len);
    CPPUNIT_ASSERT_PRINTF(right == expected,
    			"right(%d) did not yield expected result for:\n"
    			"%s\n%*s (got)\n%*s (expected)\n",
    			len,
    			test.isNull() ? "(NULL)" : test.data(),
    			test.size(),
    			right.isNull() ? "(NULL)" : right.data(),
    			test.size(),
    			expected.isNull() ? "(NULL)" : expected.data());
    CPPUNIT_ASSERT_MESSAGE("right() causes object to relinquish its reference!",
                            origData == test.data());
}
Пример #8
0
void checkFrom(unsigned int u, unsigned int base, const Sid::String& expected)
{
    Sid::String from = Sid::String::from(u, base);
    CPPUNIT_ASSERT_PRINTF(from == expected,
                            "from((unsigned int)%u, (unsigned int)%u) yielded unexpected result \"%s\"\n",
                            u,
                            base,
                            from.isNull() ? "(NULL)" : from.data());
}
Пример #9
0
void checkKeyValue(const Sid::String& key,
    		const Sid::String& value,
    		const Sid::String& expected)
{
    const char* keyData = key.data();
    const char* valueData = value.data();
    Sid::String keyValue=Sid::String::keyValue(key, value);
    CPPUNIT_ASSERT_PRINTF(keyValue == expected,
    			"keyValue(\"%s\", \"%s\") did not yield \"%s\","
    			" instead got \"%s\"\n",
    			key.isNull() ? "(NULL)" : key.data(),
    			value.isNull() ? "(NULL)" : value.data(),
    			expected.isNull() ? "(NULL)" : expected.data(), 
    			keyValue.isNull() ? "(NULL)" : keyValue.data());
    CPPUNIT_ASSERT_MESSAGE("keyValue() causes key to relinquish its reference!",
                            keyData == key.data());
    CPPUNIT_ASSERT_MESSAGE("keyValue() causes value to relinquish its reference!",
                            valueData == value.data());
}
Пример #10
0
void checkAssignment(const Sid::String& test,
                        const Sid::String& rhs,
                        const Sid::String& expected)
{
    Sid::String copy(test);
    const char* rhsData = rhs.data();
    copy = rhs;
    CPPUNIT_ASSERT_PRINTF(copy == expected,
                            "Assignment operator yielded unexpected result:\n"
                            "\"%s\" (lhs)\n"
                            "\"%s\" (rhs)\n"
                            "\"%s\" (expected)\n"
                            "\"%s\" (got)\n",
                            test.isNull() ? "(NULL)" : test.data(),
                            rhs.isNull() ? "(NULL)" : rhs.data(),
                            expected.isNull() ? "(NULL)" : rhs.data(),
                            copy.isNull() ? "(NULL)" : copy.data());
    CPPUNIT_ASSERT_MESSAGE("Assignment operator caused rhs to relinquish its reference!",
                            rhs.data() == rhsData);
}
Пример #11
0
void checkConversion(const Sid::String& test, const char* expected)
{
    const char* origData = test.data();
    CPPUNIT_ASSERT_PRINTF(!strcmp(test, expected),
    			"operator const char* did not yield \"%s\" as "
    			"expected, got \"%s\" instead.\n",
    			test.isNull() ? "(NULL)" : (const char*)test,
    			expected);
    CPPUNIT_ASSERT_MESSAGE("operator const char*() causes object to relinquish its reference!",
                            origData == test.data());
}
Пример #12
0
void checkAppend(const Sid::String& lhs, 
                    const char* rhs, 
                    const Sid::String& expected)
{
    Sid::String test(lhs);
    CPPUNIT_ASSERT(test == lhs);
    test += rhs;
    CPPUNIT_ASSERT_PRINTF(test == expected,
                            "operator+=(const char*) yielded unexpected"
                            " result:\n"
                            "lhs was  \"%s\"\n"
                            "rhs was  \"%s\"\n"
                            "expected \"%s\"\n"
                            "got      \"%s\"\n",
                            lhs.isNull() ? "(NULL)" : lhs.data(),
                            rhs ?  rhs : "(NULL)",
                            expected.isNull() ? "(NULL)" : expected.data(),
                            test.isNull() ? "(NULL)" : test.data());

    checkAppend(lhs, Sid::String(rhs), expected);
}
Пример #13
0
void checkAppend(const Sid::String& lhs, 
                    const Sid::String& rhs, 
                    const Sid::String& expected)
{
    const char* origData = rhs.data();
    Sid::String test(lhs);
    test += rhs;
    CPPUNIT_ASSERT_PRINTF(test == expected,
                            "operator+=(const Sid::String&) yielded unexpected"
                            " result:\n"
                            "lhs was  \"%s\"\n"
                            "rhs was  \"%s\"\n"
                            "expected \"%s\"\n"
                            "got      \"%s\"\n",
                            lhs.isNull() ? "(NULL)" : lhs.data(),
                            rhs.isNull() ? "(NULL)" : rhs.data(),
                            expected.isNull() ? "(NULL)" : expected.data(),
                            test.isNull() ? "(NULL)" : test.data());
    CPPUNIT_ASSERT_MESSAGE("operator+=() causes rhs to relinquish its reference!",
                            origData == rhs.data());
}
Пример #14
0
void checkToBool(const Sid::String& test, bool expected)
{
    const char* origData = test.data();
    bool res = test.toBool();
    CPPUNIT_ASSERT_PRINTF(res == expected,
                            "toBool() yielded unexpected result for value "
                            "\"%s\", should have been %s\n",
                            test.isNull() ? "(NULL)" : test.data(),
                            expected ? "true" : "false");
    CPPUNIT_ASSERT_MESSAGE("toBool() causes object to relinquish its reference!",
                            origData == test.data());
}
Пример #15
0
void StringListTestCase::appendEmptyStringTest()
{
	Sid::List_String test1;
	Sid::String string;
	CPPUNIT_ASSERT(string.isNull());

	test1.append(string);

	CPPUNIT_ASSERT(test1.size() == 1);
	CPPUNIT_ASSERT(!test1[0].isNull());
	CPPUNIT_ASSERT(test1[0] == "");
}
Пример #16
0
void checkToUInt64(const Sid::String& test, uint64 expected)
{
    const char* origData = test.data();
    uint64 res = test.toUInt64();
    CPPUNIT_ASSERT_PRINTF(res == expected,
                            "toUInt64() yielded unexpected result for value "
                            "\"%s\", should have been %ull, instead got %ull\n",
                            test.isNull() ? "(NULL)" : test.data(),
                            expected,
                            res);
    CPPUNIT_ASSERT_MESSAGE("toUInt64() causes object to relinquish its reference!",
                            origData == test.data());
}
Пример #17
0
void checkTrim(const Sid::String& test,
    	const Sid::String& toTrim,
    	const Sid::String& expected)
{
    const char* origData = test.data();
    Sid::String trimmed = test.trim(toTrim);
    CPPUNIT_ASSERT_PRINTF(trimmed == expected,
    			"trim(\"%s\") did not yield expected result:\n"
    			"%s (prefix to remove)\n"
    			"%*s (expected result)\n"
    			"%s (string to trim)\n"
    			"%*s (instead got)\n",
    			toTrim.isNull() ? "(NULL)" : toTrim.data(),
    			toTrim.isNull() ? "(NULL)" : toTrim.data(),
    			test.size(),
    			expected.isNull() ? "(NULL)" : expected.data(),
    			test.isNull() ? "(NULL)" : test.data(),
    			test.size(),
    			trimmed.isNull() ? "(NULL)" : trimmed.data());
    CPPUNIT_ASSERT_MESSAGE("trim() causes object to relinquish its reference!",
                            origData == test.data());
}
Пример #18
0
void checkFind(const Sid::String& test, 
    			char toFind,
    			int expected)
{
    int res = test.find(toFind);
    CPPUNIT_ASSERT_PRINTF(res == expected,
    						"find(%u) yielded unexpected result %d for string:\n"
    						"%s\n"
    						"expected %d\n",
    						toFind,
    						res,
    						test.isNull() ? "(NULL)" : test.data(),
    						expected);
}
Пример #19
0
void checkToBinary(const Sid::String& test, const char* expected, size_t expectedSize, const Sid::String& hex)
{
    const char* origData = test.data();
    checkToBinary(test, expected, expectedSize);
    Sid::String expHex(hex);
    Sid::String resHex = test.getHexRepresentation();
    CPPUNIT_ASSERT_PRINTF(expHex == resHex,
                            "getHexRepresentation() yielded unexpected "
                            "result:\n"
                            "\"%s\" (expected)\n"
                            "\"%s\" (result)\n",
                            expHex.isNull() ? "(NULL)" : expHex.data(),
                            resHex.isNull() ? "(NULL)" : resHex.data());

    CPPUNIT_ASSERT_MESSAGE("toBinary() causes object to relinquish its reference!",
                            origData == test.data());
}
Пример #20
0
void StringTestCase::substrTest()
{
    // Sunny day
    {
    	Sid::String str("foobajooba");
    	Sid::String sub = str.substr(0,0);

    	CPPUNIT_ASSERT_PRINTF( sub == "f",
    				"Basic substr logic is broken (input was %s, 0, 0)\nSubstring was %s\n",
    				str.data(),
    				sub.data());

    	sub = str.substr(0, 9);
    	CPPUNIT_ASSERT_PRINTF( sub == "foobajooba",
    				"Basic substr logic is broken (input was %s, 0, 9)\nSubstring was %s\n",
    				str.data(),
    				sub.data());

    	sub = str.substr(0, 8);
    	CPPUNIT_ASSERT_PRINTF( sub == "foobajoob",
    				"Basic substr logic is broken (input was %s, 0, 8)\nSubstring was %s\n",
    				str.data(),
    				sub.data());

    	sub = str.substr(1, 9);
    	CPPUNIT_ASSERT_PRINTF( sub == "oobajooba",
    				"Basic substr logic is broken (input was %s, 1, 9)\nSubstring was %s\n",
    				str.data(),
    				sub.data());

    	sub = str.substr(1, 8);
    	CPPUNIT_ASSERT_PRINTF( sub == "oobajoob",
    				"Basic substr logic is broken (input was %s, 1, 8)\nSubstring was %s\n",
    				str.data(),
    				sub.data());
    }

    // Null string
    {
    	Sid::String str;
    	Sid::String sub = str.substr(0,0);
    	CPPUNIT_ASSERT_MESSAGE("Substring (0,0) of a null string somehow is not null. Fascinating!\n",
    				sub.isNull());

    	sub = str.substr(0, -1);
    	CPPUNIT_ASSERT_MESSAGE( "Substring (0,-1) of a null string somehow is not null. Fascinating!\n",
    				sub.isNull());
    }

    // Empty string
    {
    	Sid::String str("");
    	Sid::String sub = str.substr(0,0);
    	CPPUNIT_ASSERT_MESSAGE("Substring (0,0) of an empty string somehow is not empty. Fascinating!\n",
    				sub.isEmpty() && !sub.isNull());

    	sub = str.substr(0, -1);
    	CPPUNIT_ASSERT_MESSAGE( "Substring (0,-1) of an empty string somehow is not empty. Fascinating!\n",
    				sub.isEmpty() && !sub.isNull());
    }

    // boundary fixup
    {
    	Sid::String str("foobajooba");
    	Sid::String sub = str.substr(0, -1);
    	CPPUNIT_ASSERT_PRINTF( sub == "foobajoob",
    				"Negative index code is somehow broken (input was %s, 0, -1)\nSubstring was %s\n",
    				str.data(), 
    				sub.data());

    	sub = str.substr(0, -9);

    	CPPUNIT_ASSERT_PRINTF( sub == "f",
    				"Negative index code is somehow broken (input was %s, 0, -9)\nSubstring was %s\n",
    				str.data(), 
    				sub.data());

    	sub = str.substr(0, -9999999);
    	CPPUNIT_ASSERT_PRINTF( sub == "f",
    			"Negative index modulus code is somehow broken (input was %s, 0, -9999999)\nSubstring was %s\n",
    			str.data(), 
    			sub.data());

    	sub = str.substr(-5, 2);
    	CPPUNIT_ASSERT_PRINTF( sub == "foo",
    				"Negative leading bound fixup seems to not be working (input was %s, -5, 2)\nSubstring was %s\n",
    				str.data(),
    				sub.data());

    	sub = str.substr(5, 2);
    	CPPUNIT_ASSERT_PRINTF( sub == "obaj",
    				"Bound swapping fixup seems to not be working (input was %s, 5, 2)\nSubstring was %s\n",
    				str.data(),
    				sub.data());

    	sub = str.substr(5, 900);
    	CPPUNIT_ASSERT_PRINTF( sub == "jooba",
    				"Large upper bound fixup seems to not be working (input was %s, 5, 900)\nSubstring was %s\n",
    				str.data(),
    				sub.data());

    	sub = str.substr(9, 900);
    	CPPUNIT_ASSERT_PRINTF( sub == "a",
    				"Large upper bound fixup seems to not be working (input was %s, 9, 900)\nSubstring was %s\n",
    				str.data(),
    				sub.data());

    	sub = str.substr(10, 9);
    	CPPUNIT_ASSERT_PRINTF( sub == "foobajooba",
    				"Large lower bound fixup seems to not be working (input was %s, 10, 900)\nSubstring was %s\n",
    				str.data(),
    				sub.data());

    	sub = str.substr(400, 9);
    	CPPUNIT_ASSERT_PRINTF( sub == "foobajooba",
    				"Large lower bound fixup seems to not be working (input was %s, 400, 900)\nSubstring was %s\n",
    				str.data(),
    				sub.data());
    }

}