Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(2212)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: base/string_util_unittest.cc

Issue 3056029: Move the number conversions from string_util to a new file.... (Closed) Base URL: svn://chrome-svn/chrome/trunk/src/
Patch Set: '' Created 10 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « base/string_number_conversions_unittest.cc ('k') | base/version.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: base/string_util_unittest.cc
===================================================================
--- base/string_util_unittest.cc (revision 54340)
+++ base/string_util_unittest.cc (working copy)
@@ -633,365 +633,6 @@
}
}
-namespace {
-
-template <typename INT>
-struct IntToStringTest {
- INT num;
- const char* sexpected;
- const char* uexpected;
-};
-
-} // namespace
-
-TEST(StringUtilTest, IntToString) {
- static const IntToStringTest<int> int_tests[] = {
- { 0, "0", "0" },
- { -1, "-1", "4294967295" },
- { std::numeric_limits<int>::max(), "2147483647", "2147483647" },
- { std::numeric_limits<int>::min(), "-2147483648", "2147483648" },
- };
- static const IntToStringTest<int64> int64_tests[] = {
- { 0, "0", "0" },
- { -1, "-1", "18446744073709551615" },
- { std::numeric_limits<int64>::max(),
- "9223372036854775807",
- "9223372036854775807", },
- { std::numeric_limits<int64>::min(),
- "-9223372036854775808",
- "9223372036854775808" },
- };
-
- for (size_t i = 0; i < arraysize(int_tests); ++i) {
- const IntToStringTest<int>* test = &int_tests[i];
- EXPECT_EQ(IntToString(test->num), test->sexpected);
- EXPECT_EQ(IntToWString(test->num), UTF8ToWide(test->sexpected));
- EXPECT_EQ(UintToString(test->num), test->uexpected);
- EXPECT_EQ(UintToWString(test->num), UTF8ToWide(test->uexpected));
- }
- for (size_t i = 0; i < arraysize(int64_tests); ++i) {
- const IntToStringTest<int64>* test = &int64_tests[i];
- EXPECT_EQ(Int64ToString(test->num), test->sexpected);
- EXPECT_EQ(Int64ToWString(test->num), UTF8ToWide(test->sexpected));
- EXPECT_EQ(Uint64ToString(test->num), test->uexpected);
- EXPECT_EQ(Uint64ToWString(test->num), UTF8ToWide(test->uexpected));
- }
-}
-
-TEST(StringUtilTest, Uint64ToString) {
- static const struct {
- uint64 input;
- std::string output;
- } cases[] = {
- {0, "0"},
- {42, "42"},
- {INT_MAX, "2147483647"},
- {kuint64max, "18446744073709551615"},
- };
-
- for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i)
- EXPECT_EQ(cases[i].output, Uint64ToString(cases[i].input));
-}
-
-TEST(StringUtilTest, StringToInt) {
- static const struct {
- std::string input;
- int output;
- bool success;
- } cases[] = {
- {"0", 0, true},
- {"42", 42, true},
- {"-2147483648", INT_MIN, true},
- {"2147483647", INT_MAX, true},
- {"", 0, false},
- {" 42", 42, false},
- {"42 ", 42, false},
- {"\t\n\v\f\r 42", 42, false},
- {"blah42", 0, false},
- {"42blah", 42, false},
- {"blah42blah", 0, false},
- {"-273.15", -273, false},
- {"+98.6", 98, false},
- {"--123", 0, false},
- {"++123", 0, false},
- {"-+123", 0, false},
- {"+-123", 0, false},
- {"-", 0, false},
- {"-2147483649", INT_MIN, false},
- {"-99999999999", INT_MIN, false},
- {"2147483648", INT_MAX, false},
- {"99999999999", INT_MAX, false},
- };
-
- for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
- EXPECT_EQ(cases[i].output, StringToInt(cases[i].input));
- int output;
- EXPECT_EQ(cases[i].success, StringToInt(cases[i].input, &output));
- EXPECT_EQ(cases[i].output, output);
-
- std::wstring wide_input = ASCIIToWide(cases[i].input);
- EXPECT_EQ(cases[i].output, StringToInt(WideToUTF16Hack(wide_input)));
- EXPECT_EQ(cases[i].success, StringToInt(WideToUTF16Hack(wide_input),
- &output));
- EXPECT_EQ(cases[i].output, output);
- }
-
- // One additional test to verify that conversion of numbers in strings with
- // embedded NUL characters. The NUL and extra data after it should be
- // interpreted as junk after the number.
- const char input[] = "6\06";
- std::string input_string(input, arraysize(input) - 1);
- int output;
- EXPECT_FALSE(StringToInt(input_string, &output));
- EXPECT_EQ(6, output);
-
- std::wstring wide_input = ASCIIToWide(input_string);
- EXPECT_FALSE(StringToInt(WideToUTF16Hack(wide_input), &output));
- EXPECT_EQ(6, output);
-}
-
-TEST(StringUtilTest, StringToInt64) {
- static const struct {
- std::string input;
- int64 output;
- bool success;
- } cases[] = {
- {"0", 0, true},
- {"42", 42, true},
- {"-2147483648", INT_MIN, true},
- {"2147483647", INT_MAX, true},
- {"-2147483649", GG_INT64_C(-2147483649), true},
- {"-99999999999", GG_INT64_C(-99999999999), true},
- {"2147483648", GG_INT64_C(2147483648), true},
- {"99999999999", GG_INT64_C(99999999999), true},
- {"9223372036854775807", kint64max, true},
- {"-9223372036854775808", kint64min, true},
- {"09", 9, true},
- {"-09", -9, true},
- {"", 0, false},
- {" 42", 42, false},
- {"42 ", 42, false},
- {"\t\n\v\f\r 42", 42, false},
- {"blah42", 0, false},
- {"42blah", 42, false},
- {"blah42blah", 0, false},
- {"-273.15", -273, false},
- {"+98.6", 98, false},
- {"--123", 0, false},
- {"++123", 0, false},
- {"-+123", 0, false},
- {"+-123", 0, false},
- {"-", 0, false},
- {"-9223372036854775809", kint64min, false},
- {"-99999999999999999999", kint64min, false},
- {"9223372036854775808", kint64max, false},
- {"99999999999999999999", kint64max, false},
- };
-
- for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
- EXPECT_EQ(cases[i].output, StringToInt64(cases[i].input));
- int64 output;
- EXPECT_EQ(cases[i].success, StringToInt64(cases[i].input, &output));
- EXPECT_EQ(cases[i].output, output);
-
- std::wstring wide_input = ASCIIToWide(cases[i].input);
- EXPECT_EQ(cases[i].output, StringToInt64(WideToUTF16Hack(wide_input)));
- EXPECT_EQ(cases[i].success, StringToInt64(WideToUTF16Hack(wide_input),
- &output));
- EXPECT_EQ(cases[i].output, output);
- }
-
- // One additional test to verify that conversion of numbers in strings with
- // embedded NUL characters. The NUL and extra data after it should be
- // interpreted as junk after the number.
- const char input[] = "6\06";
- std::string input_string(input, arraysize(input) - 1);
- int64 output;
- EXPECT_FALSE(StringToInt64(input_string, &output));
- EXPECT_EQ(6, output);
-
- std::wstring wide_input = ASCIIToWide(input_string);
- EXPECT_FALSE(StringToInt64(WideToUTF16Hack(wide_input), &output));
- EXPECT_EQ(6, output);
-}
-
-TEST(StringUtilTest, HexStringToInt) {
- static const struct {
- std::string input;
- int output;
- bool success;
- } cases[] = {
- {"0", 0, true},
- {"42", 66, true},
- {"-42", -66, true},
- {"+42", 66, true},
- {"7fffffff", INT_MAX, true},
- {"80000000", INT_MIN, true},
- {"ffffffff", -1, true},
- {"DeadBeef", 0xdeadbeef, true},
- {"0x42", 66, true},
- {"-0x42", -66, true},
- {"+0x42", 66, true},
- {"0x7fffffff", INT_MAX, true},
- {"0x80000000", INT_MIN, true},
- {"0xffffffff", -1, true},
- {"0XDeadBeef", 0xdeadbeef, true},
- {"0x0f", 15, true},
- {"0f", 15, true},
- {" 45", 0x45, false},
- {"\t\n\v\f\r 0x45", 0x45, false},
- {" 45", 0x45, false},
- {"45 ", 0x45, false},
- {"efgh", 0xef, false},
- {"0xefgh", 0xef, false},
- {"hgfe", 0, false},
- {"100000000", -1, false}, // don't care about |output|, just |success|
- {"-", 0, false},
- {"", 0, false},
- };
-
- for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
- EXPECT_EQ(cases[i].output, HexStringToInt(cases[i].input));
- int output;
- EXPECT_EQ(cases[i].success, HexStringToInt(cases[i].input, &output));
- EXPECT_EQ(cases[i].output, output);
-
- std::wstring wide_input = ASCIIToWide(cases[i].input);
- EXPECT_EQ(cases[i].output, HexStringToInt(WideToUTF16Hack(wide_input)));
- EXPECT_EQ(cases[i].success, HexStringToInt(WideToUTF16Hack(wide_input),
- &output));
- EXPECT_EQ(cases[i].output, output);
- }
- // One additional test to verify that conversion of numbers in strings with
- // embedded NUL characters. The NUL and extra data after it should be
- // interpreted as junk after the number.
- const char input[] = "0xc0ffee\09";
- std::string input_string(input, arraysize(input) - 1);
- int output;
- EXPECT_FALSE(HexStringToInt(input_string, &output));
- EXPECT_EQ(0xc0ffee, output);
-
- std::wstring wide_input = ASCIIToWide(input_string);
- EXPECT_FALSE(HexStringToInt(WideToUTF16Hack(wide_input), &output));
- EXPECT_EQ(0xc0ffee, output);
-}
-
-TEST(StringUtilTest, HexStringToBytes) {
- static const struct {
- const std::string input;
- const char* output;
- size_t output_len;
- bool success;
- } cases[] = {
- {"0", "", 0, false}, // odd number of characters fails
- {"00", "\0", 1, true},
- {"42", "\x42", 1, true},
- {"-42", "", 0, false}, // any non-hex value fails
- {"+42", "", 0, false},
- {"7fffffff", "\x7f\xff\xff\xff", 4, true},
- {"80000000", "\x80\0\0\0", 4, true},
- {"deadbeef", "\xde\xad\xbe\xef", 4, true},
- {"DeadBeef", "\xde\xad\xbe\xef", 4, true},
- {"0x42", "", 0, false}, // leading 0x fails (x is not hex)
- {"0f", "\xf", 1, true},
- {"45 ", "\x45", 1, false},
- {"efgh", "\xef", 1, false},
- {"", "", 0, false},
- {"0123456789ABCDEF", "\x01\x23\x45\x67\x89\xAB\xCD\xEF", 8, true},
- {"0123456789ABCDEF012345",
- "\x01\x23\x45\x67\x89\xAB\xCD\xEF\x01\x23\x45", 11, true},
- };
-
-
- for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
- std::vector<uint8> output;
- std::vector<uint8> compare;
- EXPECT_EQ(cases[i].success, HexStringToBytes(cases[i].input, &output)) <<
- i << ": " << cases[i].input;
- for (size_t j = 0; j < cases[i].output_len; ++j)
- compare.push_back(static_cast<uint8>(cases[i].output[j]));
- ASSERT_EQ(output.size(), compare.size()) << i << ": " << cases[i].input;
- EXPECT_TRUE(std::equal(output.begin(), output.end(), compare.begin())) <<
- i << ": " << cases[i].input;
-
- output.clear();
- compare.clear();
-
- std::wstring wide_input = ASCIIToWide(cases[i].input);
- EXPECT_EQ(cases[i].success,
- HexStringToBytes(WideToUTF16Hack(wide_input), &output)) <<
- i << ": " << cases[i].input;
- for (size_t j = 0; j < cases[i].output_len; ++j)
- compare.push_back(static_cast<uint8>(cases[i].output[j]));
- ASSERT_EQ(output.size(), compare.size()) << i << ": " << cases[i].input;
- EXPECT_TRUE(std::equal(output.begin(), output.end(), compare.begin())) <<
- i << ": " << cases[i].input;
- }
-}
-
-TEST(StringUtilTest, StringToDouble) {
- static const struct {
- std::string input;
- double output;
- bool success;
- } cases[] = {
- {"0", 0.0, true},
- {"42", 42.0, true},
- {"-42", -42.0, true},
- {"123.45", 123.45, true},
- {"-123.45", -123.45, true},
- {"+123.45", 123.45, true},
- {"2.99792458e8", 299792458.0, true},
- {"149597870.691E+3", 149597870691.0, true},
- {"6.", 6.0, true},
- {"9e99999999999999999999", HUGE_VAL, false},
- {"-9e99999999999999999999", -HUGE_VAL, false},
- {"1e-2", 0.01, true},
- {" 1e-2", 0.01, false},
- {"1e-2 ", 0.01, false},
- {"-1E-7", -0.0000001, true},
- {"01e02", 100, true},
- {"2.3e15", 2.3e15, true},
- {"\t\n\v\f\r -123.45e2", -12345.0, false},
- {"+123 e4", 123.0, false},
- {"123e ", 123.0, false},
- {"123e", 123.0, false},
- {" 2.99", 2.99, false},
- {"1e3.4", 1000.0, false},
- {"nothing", 0.0, false},
- {"-", 0.0, false},
- {"+", 0.0, false},
- {"", 0.0, false},
- };
-
- for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
- EXPECT_DOUBLE_EQ(cases[i].output, StringToDouble(cases[i].input));
- double output;
- EXPECT_EQ(cases[i].success, StringToDouble(cases[i].input, &output));
- EXPECT_DOUBLE_EQ(cases[i].output, output);
-
- std::wstring wide_input = ASCIIToWide(cases[i].input);
- EXPECT_DOUBLE_EQ(cases[i].output,
- StringToDouble(WideToUTF16Hack(wide_input)));
- EXPECT_EQ(cases[i].success, StringToDouble(WideToUTF16Hack(wide_input),
- &output));
- EXPECT_DOUBLE_EQ(cases[i].output, output);
- }
-
- // One additional test to verify that conversion of numbers in strings with
- // embedded NUL characters. The NUL and extra data after it should be
- // interpreted as junk after the number.
- const char input[] = "3.14\0159";
- std::string input_string(input, arraysize(input) - 1);
- double output;
- EXPECT_FALSE(StringToDouble(input_string, &output));
- EXPECT_DOUBLE_EQ(3.14, output);
-
- std::wstring wide_input = ASCIIToWide(input_string);
- EXPECT_FALSE(StringToDouble(WideToUTF16Hack(wide_input), &output));
- EXPECT_DOUBLE_EQ(3.14, output);
-}
-
// This checks where we can use the assignment operator for a va_list. We need
// a way to do this since Visual C doesn't support va_copy, but assignment on
// va_list is not guaranteed to be a copy. See StringAppendVT which uses this
@@ -1655,14 +1296,6 @@
}
}
-TEST(StringUtilTest, HexEncode) {
- std::string hex(HexEncode(NULL, 0));
- EXPECT_EQ(hex.length(), 0U);
- unsigned char bytes[] = {0x01, 0xff, 0x02, 0xfe, 0x03, 0x80, 0x81};
- hex = HexEncode(bytes, sizeof(bytes));
- EXPECT_EQ(hex.compare("01FF02FE038081"), 0);
-}
-
TEST(StringUtilTest, RemoveChars) {
const char* kRemoveChars = "-/+*";
std::string input = "A-+bc/d!*";
« no previous file with comments | « base/string_number_conversions_unittest.cc ('k') | base/version.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698