diff options
Diffstat (limited to 'chrome/browser/sync/notifier/base/string_unittest.cc')
| -rw-r--r-- | chrome/browser/sync/notifier/base/string_unittest.cc | 362 |
1 files changed, 362 insertions, 0 deletions
diff --git a/chrome/browser/sync/notifier/base/string_unittest.cc b/chrome/browser/sync/notifier/base/string_unittest.cc new file mode 100644 index 0000000..954315a --- /dev/null +++ b/chrome/browser/sync/notifier/base/string_unittest.cc @@ -0,0 +1,362 @@ +// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "chrome/browser/sync/notifier/base/string.h" +#include "notifier/testing/notifier/unittest.h" + +namespace notifier { + +TEST_NOTIFIER_F(StringTest); + +TEST_F(StringTest, StringToInt) { + ASSERT_EQ(StringToInt("625"), 625); + ASSERT_EQ(StringToInt("6"), 6); + ASSERT_EQ(StringToInt("0"), 0); + ASSERT_EQ(StringToInt(" 122"), 122); + ASSERT_EQ(StringToInt("a"), 0); + ASSERT_EQ(StringToInt(" a"), 0); + ASSERT_EQ(StringToInt("2147483647"), 2147483647); + ASSERT_EQ(StringToInt("-2147483648"), + static_cast<int>(0x80000000)); // Hex constant avoids gcc warning. + + int value = 0; + ASSERT_FALSE(ParseStringToInt("62.5", &value, true)); + ASSERT_FALSE(ParseStringToInt("625e", &value, true)); + ASSERT_FALSE(ParseStringToInt("2147483648", &value, true)); + ASSERT_FALSE(ParseStringToInt("-2147483649", &value, true)); + ASSERT_FALSE(ParseStringToInt("-4857004031", &value, true)); +} + +TEST_F(StringTest, StringToUint) { + ASSERT_EQ(StringToUint("625"), 625); + ASSERT_EQ(StringToUint("6"), 6); + ASSERT_EQ(StringToUint("0"), 0); + ASSERT_EQ(StringToUint(" 122"), 122); + ASSERT_EQ(StringToUint("a"), 0); + ASSERT_EQ(StringToUint(" a"), 0); + ASSERT_EQ(StringToUint("4294967295"), static_cast<uint32>(0xffffffff)); + + uint32 value = 0; + ASSERT_FALSE(ParseStringToUint("62.5", &value, true)); + ASSERT_FALSE(ParseStringToUint("625e", &value, true)); + ASSERT_FALSE(ParseStringToUint("4294967296", &value, true)); + ASSERT_FALSE(ParseStringToUint("-1", &value, true)); +} + +TEST_F(StringTest, StringToInt64) { + ASSERT_EQ(StringToInt64("119600064000000000"), + INT64_C(119600064000000000)); + ASSERT_EQ(StringToInt64(" 119600064000000000"), + INT64_C(119600064000000000)); + ASSERT_EQ(StringToInt64("625"), 625); + ASSERT_EQ(StringToInt64("6"), 6); + ASSERT_EQ(StringToInt64("0"), 0); + ASSERT_EQ(StringToInt64(" 122"), 122); + ASSERT_EQ(StringToInt64("a"), 0); + ASSERT_EQ(StringToInt64(" a"), 0); + ASSERT_EQ(StringToInt64("9223372036854775807"), INT64_C(9223372036854775807)); + ASSERT_EQ(StringToInt64("-9223372036854775808I64"), + static_cast<int64>(INT64_C(0x8000000000000000))); + + int64 value = 0; + ASSERT_FALSE(ParseStringToInt64("62.5", &value, true)); + ASSERT_FALSE(ParseStringToInt64("625e", &value, true)); + ASSERT_FALSE(ParseStringToInt64("9223372036854775808", &value, true)); + ASSERT_FALSE(ParseStringToInt64("-9223372036854775809", &value, true)); +} + +TEST_F(StringTest, StringToDouble) { + ASSERT_DOUBLE_EQ(StringToDouble("625"), 625); + ASSERT_DOUBLE_EQ(StringToDouble("-625"), -625); + ASSERT_DOUBLE_EQ(StringToDouble("-6.25"), -6.25); + ASSERT_DOUBLE_EQ(StringToDouble("6.25"), 6.25); + ASSERT_DOUBLE_EQ(StringToDouble("0.00"), 0); + ASSERT_DOUBLE_EQ(StringToDouble(" 55.1"), 55.1); + ASSERT_DOUBLE_EQ(StringToDouble(" 55.001"), 55.001); + ASSERT_DOUBLE_EQ(StringToDouble(" 1.001"), 1.001); + + double value = 0.0; + ASSERT_FALSE(ParseStringToDouble("62*5", &value, true)); +} + +TEST_F(StringTest, Int64ToHexString) { + ASSERT_STREQ("1a8e79fe1d58000", + Int64ToHexString(INT64_C(119600064000000000)).c_str()); + ASSERT_STREQ("271", Int64ToHexString(625).c_str()); + ASSERT_STREQ("0", Int64ToHexString(0).c_str()); +} + +TEST_F(StringTest, StringStartsWith) { + { std::string s(""); ASSERT_TRUE(StringStartsWith(s, "")); } + { std::string s("abc"); ASSERT_TRUE(StringStartsWith(s, "ab")); } + { std::string s("abc"); ASSERT_FALSE(StringStartsWith(s, "bc")); } +} + +TEST_F(StringTest, StringEndsWith) { + { std::string s(""); ASSERT_TRUE(StringEndsWith(s, "")); } + { std::string s("abc"); ASSERT_TRUE(StringEndsWith(s, "bc")); } + { std::string s("abc"); ASSERT_FALSE(StringEndsWith(s, "ab")); } +} + +TEST_F(StringTest, MakeStringEndWith) { + { + std::string s(""); + std::string t(MakeStringEndWith(s, "")); + ASSERT_STREQ(t.c_str(), ""); + } + { + std::string s("abc"); + std::string t(MakeStringEndWith(s, "def")); + ASSERT_STREQ(t.c_str(), "abcdef"); + } + { + std::string s("abc"); + std::string t(MakeStringEndWith(s, "bc")); + ASSERT_STREQ(t.c_str(), "abc"); + } +} + +TEST_F(StringTest, LowerString) { + { std::string s(""); LowerString(&s); ASSERT_STREQ(s.c_str(), ""); } + { std::string s("a"); LowerString(&s); ASSERT_STREQ(s.c_str(), "a"); } + { std::string s("A"); LowerString(&s); ASSERT_STREQ(s.c_str(), "a"); } + { std::string s("abc"); LowerString(&s); ASSERT_STREQ(s.c_str(), "abc"); } + { std::string s("ABC"); LowerString(&s); ASSERT_STREQ(s.c_str(), "abc"); } +} + +TEST_F(StringTest, UpperString) { + { std::string s(""); UpperString(&s); ASSERT_STREQ(s.c_str(), ""); } + { std::string s("A"); UpperString(&s); ASSERT_STREQ(s.c_str(), "A"); } + { std::string s("a"); UpperString(&s); ASSERT_STREQ(s.c_str(), "A"); } + { std::string s("ABC"); UpperString(&s); ASSERT_STREQ(s.c_str(), "ABC"); } + { std::string s("abc"); UpperString(&s); ASSERT_STREQ(s.c_str(), "ABC"); } +} + +TEST_F(StringTest, TrimString) { + const char* white = " \n\t"; + std::string s, c; + + // TrimStringLeft + s = ""; // empty + c = ""; + ASSERT_EQ(TrimStringLeft(&s, white), 0); + ASSERT_STREQ(s.c_str(), c.c_str()); + + s = " \n\t"; // all bad + c = ""; + ASSERT_EQ(TrimStringLeft(&s, white), 3); + ASSERT_STREQ(s.c_str(), c.c_str()); + + s = "dog"; // nothing bad + c = "dog"; + ASSERT_EQ(TrimStringLeft(&s, white), 0); + ASSERT_STREQ(s.c_str(), c.c_str()); + + s = " dog "; // some bad + c = "dog "; + ASSERT_EQ(TrimStringLeft(&s, white), 1); + ASSERT_STREQ(s.c_str(), c.c_str()); + + s = " \n\t\t I love my little dog \n\t "; + c = "I love my little dog \n\t "; + ASSERT_EQ(TrimStringLeft(&s, white), 5); + ASSERT_STREQ(s.c_str(), c.c_str()); + + // TrimStringRight + s = ""; + c = ""; + ASSERT_EQ(TrimStringRight(&s, white), 0); + ASSERT_STREQ(s.c_str(), c.c_str()); + + s = " \n\t"; + c = ""; + ASSERT_EQ(TrimStringRight(&s, white), 3); + ASSERT_STREQ(s.c_str(), c.c_str()); + + s = "dog"; + c = "dog"; + ASSERT_EQ(TrimStringRight(&s, white), 0); + ASSERT_STREQ(s.c_str(), c.c_str()); + + s = " dog "; + c = " dog"; + ASSERT_EQ(TrimStringRight(&s, white), 1); + ASSERT_STREQ(s.c_str(), c.c_str()); + + s = " \n\t\t I love my little dog \n\t "; + c = " \n\t\t I love my little dog"; + ASSERT_EQ(TrimStringRight(&s, white), 4); + ASSERT_STREQ(s.c_str(), c.c_str()); + + // TrimString + s = ""; + c = ""; + ASSERT_EQ(TrimString(&s, white), 0); + ASSERT_STREQ(s.c_str(), c.c_str()); + + s = " \n\t"; + c = ""; + ASSERT_EQ(TrimString(&s, white), 3); + ASSERT_STREQ(s.c_str(), c.c_str()); + + s = "dog"; + c = "dog"; + ASSERT_EQ(TrimString(&s, white), 0); + ASSERT_STREQ(s.c_str(), c.c_str()); + + s = " dog "; + c = "dog"; + ASSERT_EQ(TrimString(&s, white), 2); + ASSERT_STREQ(s.c_str(), c.c_str()); + + s = " \n\t\t I love my little dog \n\t "; + c = "I love my little dog"; + ASSERT_EQ(TrimString(&s, white), 9); + ASSERT_STREQ(s.c_str(), c.c_str()); +} + +TEST_F(StringTest, SplitOneStringToken) { + const char* teststrings[] = { + "alongword", + "alongword ", + "alongword ", + "alongword anotherword", + " alongword", + "", + }; + const char* source = NULL; + + source = teststrings[0]; + ASSERT_STREQ(SplitOneStringToken(&source, " ").c_str(), "alongword"); + ASSERT_STREQ(source, NULL); + + source = teststrings[1]; + ASSERT_STREQ(SplitOneStringToken(&source, " ").c_str(), "alongword"); + ASSERT_STREQ(source, teststrings[1] + strlen("alongword") + 1); + + source = teststrings[2]; + ASSERT_STREQ(SplitOneStringToken(&source, " ").c_str(), "alongword"); + ASSERT_STREQ(source, teststrings[2] + strlen("alongword") + 1); + + source = teststrings[3]; + ASSERT_STREQ(SplitOneStringToken(&source, " ").c_str(), "alongword"); + ASSERT_STREQ(source, teststrings[3] + strlen("alongword") + 1); + + source = teststrings[4]; + ASSERT_STREQ(SplitOneStringToken(&source, " ").c_str(), ""); + ASSERT_STREQ(source, teststrings[4] + 1); + + source = teststrings[5]; + ASSERT_STREQ(SplitOneStringToken(&source, " ").c_str(), ""); + ASSERT_STREQ(source, NULL); +} + +TEST_F(StringTest, FixedString) { + // Test basic operation. + const wchar_t kData[] = L"hello world"; + FixedString<wchar_t, 40> buf; + + buf.Append(kData); + EXPECT_EQ(arraysize(kData)-1, buf.size()); + EXPECT_EQ(0, wcscmp(kData, buf.get())); + + buf.Append(' '); + buf.Append(kData); + const wchar_t kExpected[] = L"hello world hello world"; + EXPECT_EQ(arraysize(kExpected)-1, buf.size()); + EXPECT_EQ(0, wcscmp(kExpected, buf.get())); + EXPECT_EQ(false, buf.was_truncated()); + + // Test overflow. + FixedString<wchar_t, 5> buf2; + buf2.Append(L"hello world"); + EXPECT_EQ(static_cast<size_t>(0), buf2.size()); + EXPECT_EQ(0, buf2.get()[0]); + EXPECT_EQ(true, buf2.was_truncated()); +} + +TEST_F(StringTest, LowerToPascalCase) { + EXPECT_STREQ("", LowerWithUnderToPascalCase("").c_str()); + EXPECT_STREQ("A", LowerWithUnderToPascalCase("a").c_str()); + EXPECT_STREQ("TestS", LowerWithUnderToPascalCase("test_s").c_str()); + EXPECT_STREQ("XQ", LowerWithUnderToPascalCase("x_q").c_str()); + EXPECT_STREQ("XQDNS", LowerWithUnderToPascalCase("x_qDNS").c_str()); +} + +TEST_F(StringTest, PascalCaseToLower) { + EXPECT_STREQ("", PascalCaseToLowerWithUnder("").c_str()); + EXPECT_STREQ("a", PascalCaseToLowerWithUnder("A").c_str()); + EXPECT_STREQ("test_s", PascalCaseToLowerWithUnder("TestS").c_str()); + EXPECT_STREQ("xq", PascalCaseToLowerWithUnder("XQ").c_str()); + EXPECT_STREQ("dns_name", PascalCaseToLowerWithUnder("DNSName").c_str()); + EXPECT_STREQ("xqdns", PascalCaseToLowerWithUnder("XQDNS").c_str()); + EXPECT_STREQ("xqdn_sa", PascalCaseToLowerWithUnder("XQDNSa").c_str()); + EXPECT_STREQ("dns1", PascalCaseToLowerWithUnder("DNS1").c_str()); +} + +TEST_F(StringTest, HtmlEncode) { + EXPECT_STREQ("dns", HtmlEncode("dns").c_str()); + EXPECT_STREQ("&", HtmlEncode("&").c_str()); + EXPECT_STREQ("&amp;", HtmlEncode("&").c_str()); + EXPECT_STREQ("<!>", HtmlEncode("<!>").c_str()); +} + +TEST_F(StringTest, HtmlDecode) { + EXPECT_STREQ("dns", HtmlDecode("dns").c_str()); + EXPECT_STREQ("&", HtmlDecode("&").c_str()); + EXPECT_STREQ("&", HtmlDecode("&amp;").c_str()); + EXPECT_STREQ("<!>", HtmlDecode("<!>").c_str()); +} + +TEST_F(StringTest, UrlEncode) { + EXPECT_STREQ("%26", UrlEncode("&").c_str()); + EXPECT_STREQ("%3f%20", UrlEncode("? ").c_str()); + EXPECT_STREQ("as%20dfdsa", UrlEncode("as dfdsa").c_str()); + EXPECT_STREQ("%3c!%3e", UrlEncode("<!>").c_str()); + EXPECT_STREQ("!%23!", UrlEncode("!#!").c_str()); + EXPECT_STREQ("!!", UrlEncode("!!").c_str()); +} + +TEST_F(StringTest, UrlDecode) { + EXPECT_STREQ("&", UrlDecode("%26").c_str()); + EXPECT_STREQ("? ", UrlDecode("%3f%20").c_str()); + EXPECT_STREQ("as dfdsa", UrlDecode("as%20dfdsa").c_str()); + EXPECT_STREQ("<!>", UrlDecode("%3c!%3e").c_str()); + EXPECT_STREQ("&", UrlDecode("&").c_str()); +} + +TEST_F(StringTest, StringReplace) { + // Test StringReplace core functionality. + std::string s = "<attribute name=abcd/>"; + StringReplace(&s, "=", " = ", false); + EXPECT_STREQ(s.c_str(), "<attribute name = abcd/>"); + + // Test for negative case. + s = "<attribute name=abcd/>"; + StringReplace(&s, "-", "=", false); + EXPECT_STREQ(s.c_str(), "<attribute name=abcd/>"); + + // Test StringReplace core functionality with replace_all flag set. + s = "<attribute name==abcd/>"; + StringReplace(&s, "=", " = ", true); + EXPECT_STREQ(s.c_str(), "<attribute name = = abcd/>"); + + // Input is an empty string. + s = ""; + StringReplace(&s, "=", " = ", false); + EXPECT_STREQ(s.c_str(), ""); + + // Input is an empty string and this is a request for repeated + // string replaces. + s = ""; + StringReplace(&s, "=", " = ", true); + EXPECT_STREQ(s.c_str(), ""); + + // Input and string to replace is an empty string. + s = ""; + StringReplace(&s, "", " = ", false); + EXPECT_STREQ(s.c_str(), ""); +} + +} // namespace notifier |