C++ String::isNull方法代码示例

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());
}

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());
}

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());
}

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());
}

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());
}

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());
}

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);
}

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());
}

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);
}

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());
}

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] == "");
}

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());
}

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());
}

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);
}

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());
}