Remove Value/StringValue's ...UTF16() methods in favour of overloading.

base/values_unittest.cc

 // Copyright (c) 2010 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 <limits>
 
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/string16.h"
 #include "base/values.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 class ValuesTest: public testing::Test {
 };
 
 // TODO(viettrungluu): I changed the keys for DictionaryValue from std::wstring
 // to std::string. I've temporarily kept the old methods taking std::wstring for
 // compatibility. The ...Deprecated tests are the old tests which use these
 // methods, and remain to test compatibility. They will be removed once the old
-// methods are removed.
+// methods are removed. There are also parts of tests marked DEPRECATED which
+// are to be deleted.
 
 TEST(ValuesTest, Basic) {
   // Test basic dictionary getting/setting
   DictionaryValue settings;
   std::string homepage = "http://google.com";
   ASSERT_FALSE(settings.GetString("global.homepage", &homepage));
   ASSERT_EQ(std::string("http://google.com"), homepage);
 
   ASSERT_FALSE(settings.Get("global", NULL));
   settings.Set("global", Value::CreateBooleanValue(true));
@@ skipping 143 matching lines @@
   ASSERT_NE(stack_buffer, binary->GetBuffer());
   ASSERT_EQ(42U, binary->GetSize());
   ASSERT_EQ(0, memcmp(stack_buffer, binary->GetBuffer(), binary->GetSize()));
 }
 
 TEST(ValuesTest, StringValue) {
   // Test overloaded CreateStringValue.
   scoped_ptr<Value> narrow_value(Value::CreateStringValue("narrow"));
   ASSERT_TRUE(narrow_value.get());
   ASSERT_TRUE(narrow_value->IsType(Value::TYPE_STRING));
+  scoped_ptr<Value> utf16_value(
+      Value::CreateStringValue(ASCIIToUTF16("utf16")));
+  ASSERT_TRUE(utf16_value.get());
+  ASSERT_TRUE(utf16_value->IsType(Value::TYPE_STRING));
+
+  // Test overloaded GetString.
+  std::string narrow = "http://google.com";
+  string16 utf16 = ASCIIToUTF16("http://google.com");
+  ASSERT_TRUE(narrow_value->GetAsString(&narrow));
+  ASSERT_TRUE(narrow_value->GetAsString(&utf16));
+  ASSERT_EQ(std::string("narrow"), narrow);
+  ASSERT_EQ(ASCIIToUTF16("narrow"), utf16);
+
+  ASSERT_TRUE(utf16_value->GetAsString(&narrow));
+  ASSERT_TRUE(utf16_value->GetAsString(&utf16));
+  ASSERT_EQ(std::string("utf16"), narrow);
+  ASSERT_EQ(ASCIIToUTF16("utf16"), utf16);
+}
+
+// TODO(viettrungluu): deprecate:
+TEST(ValuesTest, StringValueDeprecated) {
+  // Test overloaded CreateStringValue.
+  scoped_ptr<Value> narrow_value(Value::CreateStringValue("narrow"));
+  ASSERT_TRUE(narrow_value.get());
+  ASSERT_TRUE(narrow_value->IsType(Value::TYPE_STRING));
   scoped_ptr<Value> wide_value(Value::CreateStringValue(L"wide"));
   ASSERT_TRUE(wide_value.get());
   ASSERT_TRUE(wide_value->IsType(Value::TYPE_STRING));
   scoped_ptr<Value> utf16_value(
-      Value::CreateStringValueFromUTF16(ASCIIToUTF16("utf16")));
+      Value::CreateStringValue(ASCIIToUTF16("utf16")));
   ASSERT_TRUE(utf16_value.get());
   ASSERT_TRUE(utf16_value->IsType(Value::TYPE_STRING));
 
   // Test overloaded GetString.
   std::string narrow = "http://google.com";
   std::wstring wide = L"http://google.com";
   string16 utf16 = ASCIIToUTF16("http://google.com");
   ASSERT_TRUE(narrow_value->GetAsString(&narrow));
   ASSERT_TRUE(narrow_value->GetAsString(&wide));
-  ASSERT_TRUE(narrow_value->GetAsUTF16(&utf16));
+  ASSERT_TRUE(narrow_value->GetAsString(&utf16));
   ASSERT_EQ(std::string("narrow"), narrow);
   ASSERT_EQ(std::wstring(L"narrow"), wide);
   ASSERT_EQ(ASCIIToUTF16("narrow"), utf16);
 
   ASSERT_TRUE(wide_value->GetAsString(&narrow));
   ASSERT_TRUE(wide_value->GetAsString(&wide));
-  ASSERT_TRUE(wide_value->GetAsUTF16(&utf16));
+  ASSERT_TRUE(wide_value->GetAsString(&utf16));
   ASSERT_EQ(std::string("wide"), narrow);
   ASSERT_EQ(std::wstring(L"wide"), wide);
   ASSERT_EQ(ASCIIToUTF16("wide"), utf16);
 
   ASSERT_TRUE(utf16_value->GetAsString(&narrow));
   ASSERT_TRUE(utf16_value->GetAsString(&wide));
-  ASSERT_TRUE(utf16_value->GetAsUTF16(&utf16));
+  ASSERT_TRUE(utf16_value->GetAsString(&utf16));
   ASSERT_EQ(std::string("utf16"), narrow);
   ASSERT_EQ(std::wstring(L"utf16"), wide);
   ASSERT_EQ(ASCIIToUTF16("utf16"), utf16);
 }
 
 // This is a Value object that allows us to tell if it's been
 // properly deleted by modifying the value of external flag on destruction.
 class DeletionTestValue : public Value {
  public:
   explicit DeletionTestValue(bool* deletion_flag) : Value(TYPE_NULL) {
@@ skipping 252 matching lines @@
   Value* original_null = Value::CreateNullValue();
   original_dict.Set("null", original_null);
   Value* original_bool = Value::CreateBooleanValue(true);
   original_dict.Set("bool", original_bool);
   Value* original_int = Value::CreateIntegerValue(42);
   original_dict.Set("int", original_int);
   Value* original_real = Value::CreateRealValue(3.14);
   original_dict.Set("real", original_real);
   Value* original_string = Value::CreateStringValue("hello");
   original_dict.Set("string", original_string);
-  Value* original_wstring = Value::CreateStringValue(L"peek-a-boo");
-  original_dict.Set("wstring", original_wstring);
-  Value* original_utf16 =
-      Value::CreateStringValueFromUTF16(ASCIIToUTF16("hello16"));
-  original_dict.Set("utf16", original_utf16);
+  Value* original_string16 = Value::CreateStringValue(ASCIIToUTF16("hello16"));
+  original_dict.Set("string16", original_string16);
 
   char* original_buffer = new char[42];
   memset(original_buffer, '!', 42);
   BinaryValue* original_binary = Value::CreateBinaryValue(original_buffer, 42);
   original_dict.Set("binary", original_binary);
 
   ListValue* original_list = new ListValue();
   Value* original_list_element_0 = Value::CreateIntegerValue(0);
   original_list->Append(original_list_element_0);
   Value* original_list_element_1 = Value::CreateIntegerValue(1);
@@ skipping 37 matching lines @@
   double copy_real_value = 0;
   ASSERT_TRUE(copy_real->GetAsReal(&copy_real_value));
   ASSERT_EQ(3.14, copy_real_value);
 
   Value* copy_string = NULL;
   ASSERT_TRUE(copy_dict->Get("string", &copy_string));
   ASSERT_TRUE(copy_string);
   ASSERT_NE(copy_string, original_string);
   ASSERT_TRUE(copy_string->IsType(Value::TYPE_STRING));
   std::string copy_string_value;
-  std::wstring copy_wstring_value;
-  string16 copy_utf16_value;
+  string16 copy_string16_value;
   ASSERT_TRUE(copy_string->GetAsString(&copy_string_value));
-  ASSERT_TRUE(copy_string->GetAsString(&copy_wstring_value));
-  ASSERT_TRUE(copy_string->GetAsUTF16(&copy_utf16_value));
+  ASSERT_TRUE(copy_string->GetAsString(&copy_string16_value));
   ASSERT_EQ(std::string("hello"), copy_string_value);
-  ASSERT_EQ(std::wstring(L"hello"), copy_wstring_value);
-  ASSERT_EQ(ASCIIToUTF16("hello"), copy_utf16_value);
+  ASSERT_EQ(ASCIIToUTF16("hello"), copy_string16_value);
 
-  Value* copy_wstring = NULL;
-  ASSERT_TRUE(copy_dict->Get("wstring", &copy_wstring));
-  ASSERT_TRUE(copy_wstring);
-  ASSERT_NE(copy_wstring, original_wstring);
-  ASSERT_TRUE(copy_wstring->IsType(Value::TYPE_STRING));
-  ASSERT_TRUE(copy_wstring->GetAsString(&copy_string_value));
-  ASSERT_TRUE(copy_wstring->GetAsString(&copy_wstring_value));
-  ASSERT_TRUE(copy_wstring->GetAsUTF16(&copy_utf16_value));
-  ASSERT_EQ(std::string("peek-a-boo"), copy_string_value);
-  ASSERT_EQ(std::wstring(L"peek-a-boo"), copy_wstring_value);
-  ASSERT_EQ(ASCIIToUTF16("peek-a-boo"), copy_utf16_value);
-
-  Value* copy_utf16 = NULL;
-  ASSERT_TRUE(copy_dict->Get("utf16", &copy_utf16));
-  ASSERT_TRUE(copy_utf16);
-  ASSERT_NE(copy_utf16, original_utf16);
-  ASSERT_TRUE(copy_utf16->IsType(Value::TYPE_STRING));
-  ASSERT_TRUE(copy_utf16->GetAsString(&copy_string_value));
-  ASSERT_TRUE(copy_utf16->GetAsString(&copy_wstring_value));
-  ASSERT_TRUE(copy_utf16->GetAsUTF16(&copy_utf16_value));
+  Value* copy_string16 = NULL;
+  ASSERT_TRUE(copy_dict->Get("string16", &copy_string16));
+  ASSERT_TRUE(copy_string16);
+  ASSERT_NE(copy_string16, original_string16);
+  ASSERT_TRUE(copy_string16->IsType(Value::TYPE_STRING));
+  ASSERT_TRUE(copy_string16->GetAsString(&copy_string_value));
+  ASSERT_TRUE(copy_string16->GetAsString(&copy_string16_value));
   ASSERT_EQ(std::string("hello16"), copy_string_value);
-  ASSERT_EQ(std::wstring(L"hello16"), copy_wstring_value);
-  ASSERT_EQ(ASCIIToUTF16("hello16"), copy_utf16_value);
+  ASSERT_EQ(ASCIIToUTF16("hello16"), copy_string16_value);
 
   Value* copy_binary = NULL;
   ASSERT_TRUE(copy_dict->Get("binary", &copy_binary));
   ASSERT_TRUE(copy_binary);
   ASSERT_NE(copy_binary, original_binary);
   ASSERT_TRUE(copy_binary->IsType(Value::TYPE_BINARY));
   ASSERT_NE(original_binary->GetBuffer(),
     static_cast<BinaryValue*>(copy_binary)->GetBuffer());
   ASSERT_EQ(original_binary->GetSize(),
     static_cast<BinaryValue*>(copy_binary)->GetSize());
@@ skipping 34 matching lines @@
   Value* original_bool = Value::CreateBooleanValue(true);
   original_dict.Set(L"bool", original_bool);
   Value* original_int = Value::CreateIntegerValue(42);
   original_dict.Set(L"int", original_int);
   Value* original_real = Value::CreateRealValue(3.14);
   original_dict.Set(L"real", original_real);
   Value* original_string = Value::CreateStringValue("hello");
   original_dict.Set(L"string", original_string);
   Value* original_wstring = Value::CreateStringValue(L"peek-a-boo");
   original_dict.Set(L"wstring", original_wstring);
-  Value* original_utf16 =
-      Value::CreateStringValueFromUTF16(ASCIIToUTF16("hello16"));
+  Value* original_utf16 = Value::CreateStringValue(ASCIIToUTF16("hello16"));
   original_dict.Set(L"utf16", original_utf16);
 
   char* original_buffer = new char[42];
   memset(original_buffer, '!', 42);
   BinaryValue* original_binary = Value::CreateBinaryValue(original_buffer, 42);
   original_dict.Set(L"binary", original_binary);
 
   ListValue* original_list = new ListValue();
   Value* original_list_element_0 = Value::CreateIntegerValue(0);
   original_list->Append(original_list_element_0);
@@ skipping 42 matching lines @@
   Value* copy_string = NULL;
   ASSERT_TRUE(copy_dict->Get(L"string", &copy_string));
   ASSERT_TRUE(copy_string);
   ASSERT_NE(copy_string, original_string);
   ASSERT_TRUE(copy_string->IsType(Value::TYPE_STRING));
   std::string copy_string_value;
   std::wstring copy_wstring_value;
   string16 copy_utf16_value;
   ASSERT_TRUE(copy_string->GetAsString(&copy_string_value));
   ASSERT_TRUE(copy_string->GetAsString(&copy_wstring_value));
-  ASSERT_TRUE(copy_string->GetAsUTF16(&copy_utf16_value));
+  ASSERT_TRUE(copy_string->GetAsString(&copy_utf16_value));
   ASSERT_EQ(std::string("hello"), copy_string_value);
   ASSERT_EQ(std::wstring(L"hello"), copy_wstring_value);
   ASSERT_EQ(ASCIIToUTF16("hello"), copy_utf16_value);
 
   Value* copy_wstring = NULL;
   ASSERT_TRUE(copy_dict->Get(L"wstring", &copy_wstring));
   ASSERT_TRUE(copy_wstring);
   ASSERT_NE(copy_wstring, original_wstring);
   ASSERT_TRUE(copy_wstring->IsType(Value::TYPE_STRING));
   ASSERT_TRUE(copy_wstring->GetAsString(&copy_string_value));
   ASSERT_TRUE(copy_wstring->GetAsString(&copy_wstring_value));
-  ASSERT_TRUE(copy_wstring->GetAsUTF16(&copy_utf16_value));
+  ASSERT_TRUE(copy_wstring->GetAsString(&copy_utf16_value));
   ASSERT_EQ(std::string("peek-a-boo"), copy_string_value);
   ASSERT_EQ(std::wstring(L"peek-a-boo"), copy_wstring_value);
   ASSERT_EQ(ASCIIToUTF16("peek-a-boo"), copy_utf16_value);
 
   Value* copy_utf16 = NULL;
   ASSERT_TRUE(copy_dict->Get(L"utf16", &copy_utf16));
   ASSERT_TRUE(copy_utf16);
   ASSERT_NE(copy_utf16, original_utf16);
   ASSERT_TRUE(copy_utf16->IsType(Value::TYPE_STRING));
   ASSERT_TRUE(copy_utf16->GetAsString(&copy_string_value));
   ASSERT_TRUE(copy_utf16->GetAsString(&copy_wstring_value));
-  ASSERT_TRUE(copy_utf16->GetAsUTF16(&copy_utf16_value));
+  ASSERT_TRUE(copy_utf16->GetAsString(&copy_utf16_value));
   ASSERT_EQ(std::string("hello16"), copy_string_value);
   ASSERT_EQ(std::wstring(L"hello16"), copy_wstring_value);
   ASSERT_EQ(ASCIIToUTF16("hello16"), copy_utf16_value);
 
   Value* copy_binary = NULL;
   ASSERT_TRUE(copy_dict->Get(L"binary", &copy_binary));
   ASSERT_TRUE(copy_binary);
   ASSERT_NE(copy_binary, original_binary);
   ASSERT_TRUE(copy_binary->IsType(Value::TYPE_BINARY));
   ASSERT_NE(original_binary->GetBuffer(),
@@ skipping 338 matching lines @@
   EXPECT_TRUE(res_sub_dict->GetString(L"sub_base_key", &sub_base_key_value));
   EXPECT_EQ("sub_base_key_value_base", sub_base_key_value); // Preserved.
   std::string sub_collide_key_value;
   EXPECT_TRUE(res_sub_dict->GetString(L"sub_collide_key",
                                       &sub_collide_key_value));
   EXPECT_EQ("sub_collide_key_value_merge", sub_collide_key_value); // Replaced.
   std::string sub_merge_key_value;
   EXPECT_TRUE(res_sub_dict->GetString(L"sub_merge_key", &sub_merge_key_value));
   EXPECT_EQ("sub_merge_key_value_merge", sub_merge_key_value); // Merged in.
 }