Added std::string to Value via Set/GetString overloading.

base/values_unittest.cc

 // Copyright (c) 2006-2008 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/values.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 class ValuesTest: public testing::Test {
@@ skipping 75 matching lines @@
   memset(stack_buffer, '!', 42);
   binary = BinaryValue::CreateWithCopiedBuffer(stack_buffer, 42);
   ASSERT_TRUE(binary);
   ASSERT_TRUE(binary->GetBuffer());
   ASSERT_NE(stack_buffer, binary->GetBuffer());
   ASSERT_EQ(42U, binary->GetSize());
   ASSERT_EQ(0, memcmp(stack_buffer, binary->GetBuffer(), binary->GetSize()));
   delete binary;
 }
 
+TEST(ValuesTest, StringValue) {
+  // Test overloaded CreateStringValue.
+  Value* narrow_value = Value::CreateStringValue("narrow");
+  ASSERT_TRUE(narrow_value);
+  ASSERT_TRUE(narrow_value->IsType(Value::TYPE_STRING));
+  Value* wide_value = Value::CreateStringValue(L"wide");
+  ASSERT_TRUE(wide_value);
+  ASSERT_TRUE(wide_value->IsType(Value::TYPE_STRING));
+
+  // Test overloaded GetString.
+  std::string narrow = "http://google.com";
+  std::wstring wide = L"http://google.com";
+  ASSERT_TRUE(narrow_value->GetAsString(&narrow));
+  ASSERT_TRUE(narrow_value->GetAsString(&wide));
+  ASSERT_EQ(std::string("narrow"), narrow);
+  ASSERT_EQ(std::wstring(L"narrow"), wide);
+  ASSERT_TRUE(wide_value->GetAsString(&narrow));
+  ASSERT_TRUE(wide_value->GetAsString(&wide));
+  ASSERT_EQ(std::string("wide"), narrow);
+  ASSERT_EQ(std::wstring(L"wide"), wide);
+  delete narrow_value;
+  delete wide_value;
+}
+
 // 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:
   DeletionTestValue(bool* deletion_flag) : Value(TYPE_NULL) {
     Init(deletion_flag);  // Separate function so that we can use ASSERT_*
   }
 
   void Init(bool* deletion_flag) {
     ASSERT_TRUE(deletion_flag);
@@ skipping 129 matching lines @@
 TEST(ValuesTest, DeepCopy) {
   DictionaryValue original_dict;
   Value* original_null = Value::CreateNullValue();
   original_dict.Set(L"null", original_null);
   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(L"peek-a-boo");
+  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);
 
   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);
   Value* original_list_element_1 = Value::CreateIntegerValue(1);
@@ skipping 36 matching lines @@
   ASSERT_TRUE(copy_real->IsType(Value::TYPE_REAL));
   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(L"string", &copy_string));
   ASSERT_TRUE(copy_string);
   ASSERT_NE(copy_string, original_string);
   ASSERT_TRUE(copy_string->IsType(Value::TYPE_STRING));
-  std::wstring copy_string_value;
+  std::string copy_string_value;
+  std::wstring copy_wstring_value;
   ASSERT_TRUE(copy_string->GetAsString(&copy_string_value));
-  ASSERT_EQ(std::wstring(L"peek-a-boo"), copy_string_value);
+  ASSERT_TRUE(copy_string->GetAsString(&copy_wstring_value));
+  ASSERT_EQ(std::string("hello"), copy_string_value);
+  ASSERT_EQ(std::wstring(L"hello"), copy_wstring_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_EQ(std::string("peek-a-boo"), copy_string_value);
+  ASSERT_EQ(std::wstring(L"peek-a-boo"), copy_wstring_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(),
     static_cast<BinaryValue*>(copy_binary)->GetBuffer());
   ASSERT_EQ(original_binary->GetSize(),
     static_cast<BinaryValue*>(copy_binary)->GetSize());
@@ skipping 37 matching lines @@
   Value* boolean = Value::CreateBooleanValue(false);
   EXPECT_FALSE(null1->Equals(boolean));
   delete null1;
   delete null2;
   delete boolean;
 
   DictionaryValue dv;
   dv.SetBoolean(L"a", false);
   dv.SetInteger(L"b", 2);
   dv.SetReal(L"c", 2.5);
-  dv.SetString(L"d", L"string");
+  dv.SetString(L"d1", "string");
+  dv.SetString(L"d2", L"string");
   dv.Set(L"e", Value::CreateNullValue());
 
   DictionaryValue* copy = static_cast<DictionaryValue*>(dv.DeepCopy());
   EXPECT_TRUE(dv.Equals(copy));
 
   ListValue* list = new ListValue;
   list->Append(Value::CreateNullValue());
   list->Append(new DictionaryValue);
   dv.Set(L"f", list);
 
   EXPECT_FALSE(dv.Equals(copy));
   copy->Set(L"f", list->DeepCopy());
   EXPECT_TRUE(dv.Equals(copy));
 
   list->Append(Value::CreateBooleanValue(true));
   EXPECT_FALSE(dv.Equals(copy));
   delete copy;
 }