Add SCOPED_TRACEs to ICUStringConversionsTest...

base/i18n/icu_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 <math.h>
 #include <stdarg.h>
 
 #include <limits>
 #include <sstream>
 
 #include "base/basictypes.h"
+#include "base/format_macros.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/logging.h"
+#include "base/stringprintf.h"
 #include "base/string_piece.h"
 #include "base/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 
 namespace {
 
 // Given a null-terminated string of wchar_t with each wchar_t representing
 // a UTF-16 code unit, returns a string16 made up of wchar_t's in the input.
@@ skipping 41 matching lines @@
   // ?????  (Mathematical Alphanumeric Symbols (U+011d40 - U+011d44 : A,B,C,D,E)
   L"\x11d40\x11d41\x11d42\x11d43\x11d44",
 #endif
 };
 
 }  // namespace
 
 TEST(ICUStringConversionsTest, ConvertCodepageUTF8) {
   // Make sure WideToCodepage works like WideToUTF8.
   for (size_t i = 0; i < arraysize(kConvertRoundtripCases); ++i) {
+    SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: %ls",
+                                    i, kConvertRoundtripCases[i]));
+
     std::string expected(WideToUTF8(kConvertRoundtripCases[i]));
     std::string utf8;
     EXPECT_TRUE(WideToCodepage(kConvertRoundtripCases[i], kCodepageUTF8,
                                OnStringConversionError::SKIP, &utf8));
     EXPECT_EQ(expected, utf8);
   }
 }
 
 // kConverterCodepageCases is not comprehensive. There are a number of cases
 // to add if we really want to have a comprehensive coverage of various
@@ skipping 145 matching lines @@
    "\xCA\xC7\xD1\xCA\xB4\xD5" "\xA4\xC3\xD1\xBA",
    OnStringConversionError::FAIL,
    true,
    L"\x0E2A\x0E27\x0E31\x0E2A\x0E14\x0E35"
    L"\x0E04\x0E23\x0e31\x0E1A",
    NULL},
 };
 
 TEST(ICUStringConversionsTest, ConvertBetweenCodepageAndWide) {
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kConvertCodepageCases); ++i) {
+    SCOPED_TRACE(base::StringPrintf(
+                     "Test[%" PRIuS "]: <encoded: %s> <codepage: %s>", i,
+                     kConvertCodepageCases[i].encoded,
+                     kConvertCodepageCases[i].codepage_name));
+
     std::wstring wide;
     bool success = CodepageToWide(kConvertCodepageCases[i].encoded,
                                   kConvertCodepageCases[i].codepage_name,
                                   kConvertCodepageCases[i].on_error,
                                   &wide);
     EXPECT_EQ(kConvertCodepageCases[i].success, success);
     EXPECT_EQ(kConvertCodepageCases[i].wide, wide);
 
     // When decoding was successful and nothing was skipped, we also check the
     // reverse conversion. Not all conversions are round-trippable, but
@@ skipping 42 matching lines @@
                              OnStringConversionError::SKIP, &encoded));
   EXPECT_STREQ("az", encoded.c_str());
 
   // Invalid codepages should fail.
   EXPECT_FALSE(WideToCodepage(L"Hello, world", "awesome-8571-2",
                               OnStringConversionError::SKIP, &encoded));
 }
 
 TEST(ICUStringConversionsTest, ConvertBetweenCodepageAndUTF16) {
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kConvertCodepageCases); ++i) {
+    SCOPED_TRACE(base::StringPrintf(
+                     "Test[%" PRIuS "]: <encoded: %s> <codepage: %s>", i,
+                     kConvertCodepageCases[i].encoded,
+                     kConvertCodepageCases[i].codepage_name));
+
     string16 utf16;
     bool success = CodepageToUTF16(kConvertCodepageCases[i].encoded,
                                    kConvertCodepageCases[i].codepage_name,
                                    kConvertCodepageCases[i].on_error,
                                    &utf16);
     string16 utf16_expected;
     if (kConvertCodepageCases[i].u16_wide == NULL)
       utf16_expected = BuildString16(kConvertCodepageCases[i].wide);
     else
       utf16_expected = BuildString16(kConvertCodepageCases[i].u16_wide);
@@ skipping 28 matching lines @@
   {"foo-a\xcc\x88.html", "utf-8", true, "foo-\xc3\xa4.html"},
   {"\x95\x32\x82\x36\xD2\xBB", "gb18030", true, "\xF0\xA0\x80\x80\xE4\xB8\x80"},
   {"\xA7\x41\xA6\x6E", "big5", true, "\xE4\xBD\xA0\xE5\xA5\xBD"},
   // Windows-1258 does have a combining character at xD2 (which is U+0309).
   // The sequence of (U+00E2, U+0309) is also encoded as U+1EA9.
   {"foo\xE2\xD2", "windows-1258", true, "foo\xE1\xBA\xA9"},
 };
 TEST(ICUStringConversionsTest, ConvertToUtf8AndNormalize) {
   std::string result;
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kConvertAndNormalizeCases); ++i) {
+    SCOPED_TRACE(base::StringPrintf(
+                     "Test[%" PRIuS "]: <encoded: %s> <codepage: %s>", i,
+                     kConvertAndNormalizeCases[i].encoded,
+                     kConvertAndNormalizeCases[i].codepage_name));
+
     bool success = ConvertToUtf8AndNormalize(
         kConvertAndNormalizeCases[i].encoded,
         kConvertAndNormalizeCases[i].codepage_name, &result);
     EXPECT_EQ(kConvertAndNormalizeCases[i].expected_success, success);
     EXPECT_EQ(kConvertAndNormalizeCases[i].expected_value, result);
   }
 }
 
 }  // namespace base