diff options
author | Zeno Albisser <zeno.albisser@digia.com> | 2013-08-15 21:46:11 +0200 |
---|---|---|
committer | Zeno Albisser <zeno.albisser@digia.com> | 2013-08-15 21:46:11 +0200 |
commit | 679147eead574d186ebf3069647b4c23e8ccace6 (patch) | |
tree | fc247a0ac8ff119f7c8550879ebb6d3dd8d1ff69 /chromium/base/strings/string_split_unittest.cc |
Initial import.
Diffstat (limited to 'chromium/base/strings/string_split_unittest.cc')
-rw-r--r-- | chromium/base/strings/string_split_unittest.cc | 318 |
1 files changed, 318 insertions, 0 deletions
diff --git a/chromium/base/strings/string_split_unittest.cc b/chromium/base/strings/string_split_unittest.cc new file mode 100644 index 00000000000..eb69b68fcbd --- /dev/null +++ b/chromium/base/strings/string_split_unittest.cc @@ -0,0 +1,318 @@ +// Copyright (c) 2012 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 "base/strings/string_split.h" + +#include "base/strings/utf_string_conversions.h" +#include "testing/gmock/include/gmock/gmock.h" +#include "testing/gtest/include/gtest/gtest.h" + +using ::testing::ElementsAre; + +namespace base { + +namespace { + +#if !defined(WCHAR_T_IS_UTF16) +// Overload SplitString with a wide-char version to make it easier to +// test the string16 version with wide character literals. +void SplitString(const std::wstring& str, + wchar_t c, + std::vector<std::wstring>* result) { + std::vector<string16> result16; + SplitString(WideToUTF16(str), c, &result16); + for (size_t i = 0; i < result16.size(); ++i) + result->push_back(UTF16ToWide(result16[i])); +} +#endif + +} // anonymous namespace + +class SplitStringIntoKeyValuesTest : public testing::Test { + protected: + std::string key; + std::vector<std::string> values; +}; + +TEST_F(SplitStringIntoKeyValuesTest, EmptyInputMultipleValues) { + EXPECT_FALSE(SplitStringIntoKeyValues(std::string(), // Empty input + '\t', // Key separators + &key, + &values)); + EXPECT_TRUE(key.empty()); + EXPECT_TRUE(values.empty()); +} + +TEST_F(SplitStringIntoKeyValuesTest, EmptyValueInputMultipleValues) { + EXPECT_FALSE(SplitStringIntoKeyValues("key_with_no_value\t", + '\t', // Key separators + &key, &values)); + EXPECT_EQ("key_with_no_value", key); + EXPECT_TRUE(values.empty()); +} + +TEST_F(SplitStringIntoKeyValuesTest, EmptyKeyInputMultipleValues) { + EXPECT_TRUE(SplitStringIntoKeyValues("\tvalue for empty key", + '\t', // Key separators + &key, &values)); + EXPECT_TRUE(key.empty()); + ASSERT_EQ(1U, values.size()); +} + +TEST_F(SplitStringIntoKeyValuesTest, KeyWithMultipleValues) { + EXPECT_TRUE(SplitStringIntoKeyValues("key1\tvalue1, value2 value3", + '\t', // Key separators + &key, &values)); + EXPECT_EQ("key1", key); + ASSERT_EQ(1U, values.size()); + EXPECT_EQ("value1, value2 value3", values[0]); +} + +TEST_F(SplitStringIntoKeyValuesTest, EmptyInputSingleValue) { + EXPECT_FALSE(SplitStringIntoKeyValues(std::string(), // Empty input + '\t', // Key separators + &key, + &values)); + EXPECT_TRUE(key.empty()); + EXPECT_TRUE(values.empty()); +} + +TEST_F(SplitStringIntoKeyValuesTest, EmptyValueInputSingleValue) { + EXPECT_FALSE(SplitStringIntoKeyValues("key_with_no_value\t", + '\t', // Key separators + &key, &values)); + EXPECT_EQ("key_with_no_value", key); + EXPECT_TRUE(values.empty()); +} + +TEST_F(SplitStringIntoKeyValuesTest, EmptyKeyInputSingleValue) { + EXPECT_TRUE(SplitStringIntoKeyValues("\tvalue for empty key", + '\t', // Key separators + &key, &values)); + EXPECT_TRUE(key.empty()); + ASSERT_EQ(1U, values.size()); + EXPECT_EQ("value for empty key", values[0]); +} + +TEST_F(SplitStringIntoKeyValuesTest, KeyWithSingleValue) { + EXPECT_TRUE(SplitStringIntoKeyValues("key1\tvalue1, value2 value3", + '\t', // Key separators + &key, &values)); + EXPECT_EQ("key1", key); + ASSERT_EQ(1U, values.size()); + EXPECT_EQ("value1, value2 value3", values[0]); +} + +class SplitStringIntoKeyValuePairsTest : public testing::Test { + protected: + std::vector<std::pair<std::string, std::string> > kv_pairs; +}; + +TEST_F(SplitStringIntoKeyValuePairsTest, EmptyString) { + EXPECT_TRUE(SplitStringIntoKeyValuePairs(std::string(), + ':', // Key-value delimiters + ',', // Key-value pair delims + &kv_pairs)); + EXPECT_TRUE(kv_pairs.empty()); +} + +TEST_F(SplitStringIntoKeyValuePairsTest, EmptySecondPair) { + EXPECT_TRUE(SplitStringIntoKeyValuePairs("key1:value1,,key3:value3", + ':', // Key-value delimiters + ',', // Key-value pair delims + &kv_pairs)); + ASSERT_EQ(2U, kv_pairs.size()); + EXPECT_EQ("key1", kv_pairs[0].first); + EXPECT_EQ("value1", kv_pairs[0].second); + EXPECT_EQ("key3", kv_pairs[1].first); + EXPECT_EQ("value3", kv_pairs[1].second); +} + +TEST_F(SplitStringIntoKeyValuePairsTest, EmptySecondValue) { + EXPECT_FALSE(SplitStringIntoKeyValuePairs("key1:value1 , key2:", + ':', // Key-value delimiters + ',', // Key-value pair delims + &kv_pairs)); + ASSERT_EQ(2U, kv_pairs.size()); + EXPECT_EQ("key1", kv_pairs[0].first); + EXPECT_EQ("value1", kv_pairs[0].second); + EXPECT_EQ("key2", kv_pairs[1].first); + EXPECT_EQ("", kv_pairs[1].second); +} + +TEST_F(SplitStringIntoKeyValuePairsTest, DelimiterInValue) { + EXPECT_TRUE(SplitStringIntoKeyValuePairs("key1:va:ue1 , key2:value2", + ':', // Key-value delimiters + ',', // Key-value pair delims + &kv_pairs)); + ASSERT_EQ(2U, kv_pairs.size()); + EXPECT_EQ("key1", kv_pairs[0].first); + EXPECT_EQ("va:ue1", kv_pairs[0].second); + EXPECT_EQ("key2", kv_pairs[1].first); + EXPECT_EQ("value2", kv_pairs[1].second); +} + +TEST(SplitStringUsingSubstrTest, EmptyString) { + std::vector<std::string> results; + SplitStringUsingSubstr(std::string(), "DELIMITER", &results); + ASSERT_EQ(1u, results.size()); + EXPECT_THAT(results, ElementsAre("")); +} + +// Test for SplitString +TEST(StringUtilTest, SplitString) { + std::vector<std::wstring> r; + + SplitString(std::wstring(), L',', &r); + EXPECT_EQ(0U, r.size()); + r.clear(); + + SplitString(L"a,b,c", L',', &r); + ASSERT_EQ(3U, r.size()); + EXPECT_EQ(r[0], L"a"); + EXPECT_EQ(r[1], L"b"); + EXPECT_EQ(r[2], L"c"); + r.clear(); + + SplitString(L"a, b, c", L',', &r); + ASSERT_EQ(3U, r.size()); + EXPECT_EQ(r[0], L"a"); + EXPECT_EQ(r[1], L"b"); + EXPECT_EQ(r[2], L"c"); + r.clear(); + + SplitString(L"a,,c", L',', &r); + ASSERT_EQ(3U, r.size()); + EXPECT_EQ(r[0], L"a"); + EXPECT_EQ(r[1], L""); + EXPECT_EQ(r[2], L"c"); + r.clear(); + + SplitString(L" ", L'*', &r); + EXPECT_EQ(0U, r.size()); + r.clear(); + + SplitString(L"foo", L'*', &r); + ASSERT_EQ(1U, r.size()); + EXPECT_EQ(r[0], L"foo"); + r.clear(); + + SplitString(L"foo ,", L',', &r); + ASSERT_EQ(2U, r.size()); + EXPECT_EQ(r[0], L"foo"); + EXPECT_EQ(r[1], L""); + r.clear(); + + SplitString(L",", L',', &r); + ASSERT_EQ(2U, r.size()); + EXPECT_EQ(r[0], L""); + EXPECT_EQ(r[1], L""); + r.clear(); + + SplitString(L"\t\ta\t", L'\t', &r); + ASSERT_EQ(4U, r.size()); + EXPECT_EQ(r[0], L""); + EXPECT_EQ(r[1], L""); + EXPECT_EQ(r[2], L"a"); + EXPECT_EQ(r[3], L""); + r.clear(); + + SplitString(L"\ta\t\nb\tcc", L'\n', &r); + ASSERT_EQ(2U, r.size()); + EXPECT_EQ(r[0], L"a"); + EXPECT_EQ(r[1], L"b\tcc"); + r.clear(); +} + +TEST(SplitStringUsingSubstrTest, StringWithNoDelimiter) { + std::vector<std::string> results; + SplitStringUsingSubstr("alongwordwithnodelimiter", "DELIMITER", &results); + ASSERT_EQ(1u, results.size()); + EXPECT_THAT(results, ElementsAre("alongwordwithnodelimiter")); +} + +TEST(SplitStringUsingSubstrTest, LeadingDelimitersSkipped) { + std::vector<std::string> results; + SplitStringUsingSubstr( + "DELIMITERDELIMITERDELIMITERoneDELIMITERtwoDELIMITERthree", + "DELIMITER", + &results); + ASSERT_EQ(6u, results.size()); + EXPECT_THAT(results, ElementsAre("", "", "", "one", "two", "three")); +} + +TEST(SplitStringUsingSubstrTest, ConsecutiveDelimitersSkipped) { + std::vector<std::string> results; + SplitStringUsingSubstr( + "unoDELIMITERDELIMITERDELIMITERdosDELIMITERtresDELIMITERDELIMITERcuatro", + "DELIMITER", + &results); + ASSERT_EQ(7u, results.size()); + EXPECT_THAT(results, ElementsAre("uno", "", "", "dos", "tres", "", "cuatro")); +} + +TEST(SplitStringUsingSubstrTest, TrailingDelimitersSkipped) { + std::vector<std::string> results; + SplitStringUsingSubstr( + "unDELIMITERdeuxDELIMITERtroisDELIMITERquatreDELIMITERDELIMITERDELIMITER", + "DELIMITER", + &results); + ASSERT_EQ(7u, results.size()); + EXPECT_THAT( + results, ElementsAre("un", "deux", "trois", "quatre", "", "", "")); +} + +TEST(StringSplitTest, StringSplitDontTrim) { + std::vector<std::string> r; + + SplitStringDontTrim(" ", '*', &r); + ASSERT_EQ(1U, r.size()); + EXPECT_EQ(r[0], " "); + + SplitStringDontTrim("\t \ta\t ", '\t', &r); + ASSERT_EQ(4U, r.size()); + EXPECT_EQ(r[0], ""); + EXPECT_EQ(r[1], " "); + EXPECT_EQ(r[2], "a"); + EXPECT_EQ(r[3], " "); + + SplitStringDontTrim("\ta\t\nb\tcc", '\n', &r); + ASSERT_EQ(2U, r.size()); + EXPECT_EQ(r[0], "\ta\t"); + EXPECT_EQ(r[1], "b\tcc"); +} + +TEST(StringSplitTest, SplitStringAlongWhitespace) { + struct TestData { + const char* input; + const size_t expected_result_count; + const char* output1; + const char* output2; + } data[] = { + { "a", 1, "a", "" }, + { " ", 0, "", "" }, + { " a", 1, "a", "" }, + { " ab ", 1, "ab", "" }, + { " ab c", 2, "ab", "c" }, + { " ab c ", 2, "ab", "c" }, + { " ab cd", 2, "ab", "cd" }, + { " ab cd ", 2, "ab", "cd" }, + { " \ta\t", 1, "a", "" }, + { " b\ta\t", 2, "b", "a" }, + { " b\tat", 2, "b", "at" }, + { "b\tat", 2, "b", "at" }, + { "b\t at", 2, "b", "at" }, + }; + for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) { + std::vector<std::string> results; + SplitStringAlongWhitespace(data[i].input, &results); + ASSERT_EQ(data[i].expected_result_count, results.size()); + if (data[i].expected_result_count > 0) + ASSERT_EQ(data[i].output1, results[0]); + if (data[i].expected_result_count > 1) + ASSERT_EQ(data[i].output2, results[1]); + } +} + +} // namespace base |