Clean up recent string conversion function changes, part 1: Remove unnecessar...

base/utf_string_conversions_unittest.cc

 // 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 "base/basictypes.h"
 #include "base/string_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 
@@ skipping 209 matching lines @@
   EXPECT_EQ(arraysize(wmulti) - 1, wmultistring.length());
   std::string expected;
   memcpy(WriteInto(&expected, arraysize(multi)), multi, sizeof(multi));
   EXPECT_EQ(arraysize(multi) - 1, expected.length());
   const std::string& converted = WideToUTF8(wmultistring);
   EXPECT_EQ(arraysize(multi) - 1, converted.length());
   EXPECT_EQ(expected, converted);
 }
 
 TEST(UTFStringConversionsTest, AdjustOffset) {
-  // Under the hood, all the functions call the same converter function, so we
-  // don't need to exhaustively check every case.
-  struct WideToUTF8Case {
-    const wchar_t* wide;
-    size_t input_offset;
-    size_t output_offset;
-  } wide_to_utf8_cases[] = {
-    {L"", 0, std::string::npos},
-    {L"\x4f60\x597d", 0, 0},
-    {L"\x4f60\x597d", 1, 3},
-    {L"\x4f60\x597d", 2, std::string::npos},
-    {L"\x4f60\x597d", std::wstring::npos, std::string::npos},
-    {L"\xd800\x597dz", 1, 0},
-    {L"\xd800\x597dz", 2, 3},
-  };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(wide_to_utf8_cases); ++i) {
-    size_t offset = wide_to_utf8_cases[i].input_offset;
-    WideToUTF8AndAdjustOffset(wide_to_utf8_cases[i].wide, &offset);
-    EXPECT_EQ(wide_to_utf8_cases[i].output_offset, offset);
-  }
-
   struct UTF8ToWideCase {
     const char* utf8;
     size_t input_offset;
     size_t output_offset;
   } utf8_to_wide_cases[] = {
+    {"", 0, std::wstring::npos},
     {"\xe4\xbd\xa0\xe5\xa5\xbd", 1, std::wstring::npos},
     {"\xe4\xbd\xa0\xe5\xa5\xbd", 3, 1},
     {"\xed\xb0\x80z", 3, 0},
     {"A\xF0\x90\x8C\x80z", 1, 1},
     {"A\xF0\x90\x8C\x80z", 2, std::wstring::npos},
 #if defined(WCHAR_T_IS_UTF16)
     {"A\xF0\x90\x8C\x80z", 5, 3},
 #elif defined(WCHAR_T_IS_UTF32)
     {"A\xF0\x90\x8C\x80z", 5, 2},
 #endif
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(utf8_to_wide_cases); ++i) {
     size_t offset = utf8_to_wide_cases[i].input_offset;
     UTF8ToWideAndAdjustOffset(utf8_to_wide_cases[i].utf8, &offset);
     EXPECT_EQ(utf8_to_wide_cases[i].output_offset, offset);
   }
 
 #if defined(WCHAR_T_IS_UTF32)
-  struct WideToUTF16Case {
-    const wchar_t* wide;
-    size_t input_offset;
-    size_t output_offset;
-  } wide_to_utf16_cases[] = {
-    {L"\x4F60\x597D", 1, 1},
-    {L"\x20000\x4E00", 1, 2},
-  };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(wide_to_utf16_cases); ++i) {
-    size_t offset = wide_to_utf16_cases[i].input_offset;
-    WideToUTF16AndAdjustOffset(wide_to_utf16_cases[i].wide, &offset);
-    EXPECT_EQ(wide_to_utf16_cases[i].output_offset, offset);
-  }
-
   struct UTF16ToWideCase {
     const wchar_t* wide;
     size_t input_offset;
     size_t output_offset;
   } utf16_to_wide_cases[] = {
     {L"\xD840\xDC00\x4E00", 0, 0},
     {L"\xD840\xDC00\x4E00", 1, std::wstring::npos},
     {L"\xD840\xDC00\x4E00", 2, 1},
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(utf16_to_wide_cases); ++i) {
     size_t offset = utf16_to_wide_cases[i].input_offset;
     UTF16ToWideAndAdjustOffset(BuildString16(utf16_to_wide_cases[i].wide),
                                &offset);
     EXPECT_EQ(utf16_to_wide_cases[i].output_offset, offset);
   }
 #endif
 }
 
 }  // namaspace base