Remove base::StringValue

base/values_unittest.cc

 // 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/values.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <memory>
@@ skipping 25 matching lines @@
 }
 
 TEST(ValuesTest, ConstructDouble) {
   Value value(-4.655);
   EXPECT_EQ(Value::Type::DOUBLE, value.type());
   EXPECT_EQ(-4.655, value.GetDouble());
 }
 
 TEST(ValuesTest, ConstructStringFromConstCharPtr) {
   const char* str = "foobar";
-  StringValue value(str);
+  Value value(str);
   EXPECT_EQ(Value::Type::STRING, value.type());
   EXPECT_EQ("foobar", value.GetString());
 }
 
 TEST(ValuesTest, ConstructStringFromStdStringConstRef) {
   std::string str = "foobar";
-  StringValue value(str);
+  Value value(str);
   EXPECT_EQ(Value::Type::STRING, value.type());
   EXPECT_EQ("foobar", value.GetString());
 }
 
 TEST(ValuesTest, ConstructStringFromStdStringRefRef) {
   std::string str = "foobar";
-  StringValue value(std::move(str));
+  Value value(std::move(str));
   EXPECT_EQ(Value::Type::STRING, value.type());
   EXPECT_EQ("foobar", value.GetString());
 }
 
 TEST(ValuesTest, ConstructStringFromConstChar16Ptr) {
   string16 str = ASCIIToUTF16("foobar");
-  StringValue value(str.c_str());
+  Value value(str.c_str());
   EXPECT_EQ(Value::Type::STRING, value.type());
   EXPECT_EQ("foobar", value.GetString());
 }
 
 TEST(ValuesTest, ConstructStringFromString16) {
   string16 str = ASCIIToUTF16("foobar");
-  StringValue value(str);
+  Value value(str);
   EXPECT_EQ(Value::Type::STRING, value.type());
   EXPECT_EQ("foobar", value.GetString());
 }
 
 TEST(ValuesTest, ConstructStringFromStringPiece) {
   StringPiece str = "foobar";
-  StringValue value(str);
+  Value value(str);
   EXPECT_EQ(Value::Type::STRING, value.type());
   EXPECT_EQ("foobar", value.GetString());
 }
 
 TEST(ValuesTest, ConstructBinary) {
   BinaryValue value(std::vector<char>({0xF, 0x0, 0x0, 0xB, 0xA, 0x2}));
   EXPECT_EQ(Value::Type::BINARY, value.type());
   EXPECT_EQ(std::vector<char>({0xF, 0x0, 0x0, 0xB, 0xA, 0x2}), value.GetBlob());
 }
 
@@ skipping 52 matching lines @@
   EXPECT_EQ(value.GetDouble(), copied_value.GetDouble());
 
   Value blank;
 
   blank = value;
   EXPECT_EQ(value.type(), blank.type());
   EXPECT_EQ(value.GetDouble(), blank.GetDouble());
 }
 
 TEST(ValuesTest, CopyString) {
-  StringValue value("foobar");
-  StringValue copied_value(value);
+  Value value("foobar");
+  Value copied_value(value);
   EXPECT_EQ(value.type(), copied_value.type());
   EXPECT_EQ(value.GetString(), copied_value.GetString());
 
   Value blank;
 
   blank = value;
   EXPECT_EQ(value.type(), blank.type());
   EXPECT_EQ(value.GetString(), blank.GetString());
 }
 
@@ skipping 97 matching lines @@
   EXPECT_EQ(74.896, moved_value.GetDouble());
 
   Value blank;
 
   blank = Value(654.38);
   EXPECT_EQ(Value::Type::DOUBLE, blank.type());
   EXPECT_EQ(654.38, blank.GetDouble());
 }
 
 TEST(ValuesTest, MoveString) {
-  StringValue value("foobar");
-  StringValue moved_value(std::move(value));
+  Value value("foobar");
+  Value moved_value(std::move(value));
   EXPECT_EQ(Value::Type::STRING, moved_value.type());
   EXPECT_EQ("foobar", moved_value.GetString());
 
   Value blank;
 
-  blank = StringValue("foobar");
+  blank = Value("foobar");
   EXPECT_EQ(Value::Type::STRING, blank.type());
   EXPECT_EQ("foobar", blank.GetString());
 }
 
 TEST(ValuesTest, MoveBinary) {
   const std::vector<char> buffer = {0xF, 0x0, 0x0, 0xB, 0xA, 0x2};
   BinaryValue value(buffer);
   BinaryValue moved_value(std::move(value));
   EXPECT_EQ(Value::Type::BINARY, moved_value.type());
   EXPECT_EQ(buffer, moved_value.GetBlob());
@@ skipping 84 matching lines @@
   std::string bookmark_url;
   ASSERT_TRUE(bookmark->GetString("url", &bookmark_url));
   ASSERT_EQ(std::string("http://froogle.com"), bookmark_url);
 }
 
 TEST(ValuesTest, List) {
   std::unique_ptr<ListValue> mixed_list(new ListValue());
   mixed_list->Set(0, MakeUnique<Value>(true));
   mixed_list->Set(1, MakeUnique<Value>(42));
   mixed_list->Set(2, MakeUnique<Value>(88.8));
-  mixed_list->Set(3, MakeUnique<StringValue>("foo"));
+  mixed_list->Set(3, MakeUnique<Value>("foo"));
   ASSERT_EQ(4u, mixed_list->GetSize());
 
   Value *value = NULL;
   bool bool_value = false;
   int int_value = 0;
   double double_value = 0.0;
   std::string string_value;
 
   ASSERT_FALSE(mixed_list->Get(4, &value));
 
@@ skipping 56 matching lines @@
 
   // Test overloaded GetAsBinary.
   Value* narrow_value = binary.get();
   const BinaryValue* narrow_binary = NULL;
   ASSERT_TRUE(narrow_value->GetAsBinary(&narrow_binary));
   EXPECT_EQ(binary.get(), narrow_binary);
 }
 
 TEST(ValuesTest, StringValue) {
   // Test overloaded StringValue constructor.
-  std::unique_ptr<Value> narrow_value(new StringValue("narrow"));
+  std::unique_ptr<Value> narrow_value(new Value("narrow"));
   ASSERT_TRUE(narrow_value.get());
   ASSERT_TRUE(narrow_value->IsType(Value::Type::STRING));
-  std::unique_ptr<Value> utf16_value(new StringValue(ASCIIToUTF16("utf16")));
+  std::unique_ptr<Value> utf16_value(new Value(ASCIIToUTF16("utf16")));
   ASSERT_TRUE(utf16_value.get());
   ASSERT_TRUE(utf16_value->IsType(Value::Type::STRING));
 
   // Test overloaded GetAsString.
   std::string narrow = "http://google.com";
   string16 utf16 = ASCIIToUTF16("http://google.com");
-  const StringValue* string_value = NULL;
+  const Value* string_value = NULL;
   ASSERT_TRUE(narrow_value->GetAsString(&narrow));
   ASSERT_TRUE(narrow_value->GetAsString(&utf16));
   ASSERT_TRUE(narrow_value->GetAsString(&string_value));
   ASSERT_EQ(std::string("narrow"), narrow);
   ASSERT_EQ(ASCIIToUTF16("narrow"), utf16);
   ASSERT_EQ(string_value->GetString(), narrow);
 
   ASSERT_TRUE(utf16_value->GetAsString(&narrow));
   ASSERT_TRUE(utf16_value->GetAsString(&utf16));
   ASSERT_TRUE(utf16_value->GetAsString(&string_value));
   ASSERT_EQ(std::string("utf16"), narrow);
   ASSERT_EQ(ASCIIToUTF16("utf16"), utf16);
   ASSERT_EQ(string_value->GetString(), narrow);
 
   // Don't choke on NULL values.
   ASSERT_TRUE(narrow_value->GetAsString(static_cast<string16*>(NULL)));
   ASSERT_TRUE(narrow_value->GetAsString(static_cast<std::string*>(NULL)));
-  ASSERT_TRUE(narrow_value->GetAsString(
-                  static_cast<const StringValue**>(NULL)));
+  ASSERT_TRUE(narrow_value->GetAsString(static_cast<const Value**>(NULL)));
 }
 
 TEST(ValuesTest, ListDeletion) {
   ListValue list;
   list.Append(MakeUnique<Value>());
   EXPECT_FALSE(list.empty());
   list.Clear();
   EXPECT_TRUE(list.empty());
 }
 
@@ skipping 142 matching lines @@
   original_dict.Set("null", std::move(scoped_null));
   std::unique_ptr<Value> scoped_bool(new Value(true));
   Value* original_bool = scoped_bool.get();
   original_dict.Set("bool", std::move(scoped_bool));
   std::unique_ptr<Value> scoped_int(new Value(42));
   Value* original_int = scoped_int.get();
   original_dict.Set("int", std::move(scoped_int));
   std::unique_ptr<Value> scoped_double(new Value(3.14));
   Value* original_double = scoped_double.get();
   original_dict.Set("double", std::move(scoped_double));
-  std::unique_ptr<StringValue> scoped_string(new StringValue("hello"));
-  StringValue* original_string = scoped_string.get();
+  std::unique_ptr<Value> scoped_string(new Value("hello"));
+  Value* original_string = scoped_string.get();
   original_dict.Set("string", std::move(scoped_string));
-  std::unique_ptr<StringValue> scoped_string16(
-      new StringValue(ASCIIToUTF16("hello16")));
-  StringValue* original_string16 = scoped_string16.get();
+  std::unique_ptr<Value> scoped_string16(new Value(ASCIIToUTF16("hello16")));
+  Value* original_string16 = scoped_string16.get();
   original_dict.Set("string16", std::move(scoped_string16));
 
   std::vector<char> original_buffer(42, '!');
   std::unique_ptr<BinaryValue> scoped_binary(
       new BinaryValue(std::move(original_buffer)));
   BinaryValue* original_binary = scoped_binary.get();
   original_dict.Set("binary", std::move(scoped_binary));
 
   std::unique_ptr<ListValue> scoped_list(new ListValue());
   Value* original_list = scoped_list.get();
@@ skipping 189 matching lines @@
   original_dict.Set("null", std::move(scoped_null));
   std::unique_ptr<Value> scoped_bool(new Value(true));
   Value* original_bool = scoped_bool.get();
   original_dict.Set("bool", std::move(scoped_bool));
   std::unique_ptr<Value> scoped_int(new Value(42));
   Value* original_int = scoped_int.get();
   original_dict.Set("int", std::move(scoped_int));
   std::unique_ptr<Value> scoped_double(new Value(3.14));
   Value* original_double = scoped_double.get();
   original_dict.Set("double", std::move(scoped_double));
-  std::unique_ptr<StringValue> scoped_string(new StringValue("hello"));
+  std::unique_ptr<Value> scoped_string(new Value("hello"));
   Value* original_string = scoped_string.get();
   original_dict.Set("string", std::move(scoped_string));
-  std::unique_ptr<StringValue> scoped_string16(
-      new StringValue(ASCIIToUTF16("hello16")));
+  std::unique_ptr<Value> scoped_string16(new Value(ASCIIToUTF16("hello16")));
   Value* original_string16 = scoped_string16.get();
   original_dict.Set("string16", std::move(scoped_string16));
 
   std::vector<char> original_buffer(42, '!');
   std::unique_ptr<BinaryValue> scoped_binary(
       new BinaryValue(std::move(original_buffer)));
   Value* original_binary = scoped_binary.get();
   original_dict.Set("binary", std::move(scoped_binary));
 
   std::unique_ptr<ListValue> scoped_list(new ListValue());
@@ skipping 81 matching lines @@
     inner2->Set("empty_list", WrapUnique(new ListValue));
     root->Set("dict_with_empty_children", std::move(inner2));
     root = root->DeepCopyWithoutEmptyChildren();
     EXPECT_EQ(2U, root->size());
   }
 
   // Make sure nested values don't get pruned.
   {
     std::unique_ptr<ListValue> inner(new ListValue);
     std::unique_ptr<ListValue> inner2(new ListValue);
-    inner2->Append(MakeUnique<StringValue>("hello"));
+    inner2->Append(MakeUnique<Value>("hello"));
     inner->Append(WrapUnique(new DictionaryValue));
     inner->Append(std::move(inner2));
     root->Set("list_with_empty_children", std::move(inner));
     root = root->DeepCopyWithoutEmptyChildren();
     EXPECT_EQ(3U, root->size());
 
     ListValue* inner_value, *inner_value2;
     EXPECT_TRUE(root->GetList("list_with_empty_children", &inner_value));
     EXPECT_EQ(1U, inner_value->GetSize());  // Dictionary was pruned.
     EXPECT_TRUE(inner_value->GetList(0, &inner_value2));
@@ skipping 77 matching lines @@
   EXPECT_TRUE(ptr->GetString("test", &value));
   EXPECT_EQ("value", value);
 }
 
 TEST(ValuesTest, DictionaryIterator) {
   DictionaryValue dict;
   for (DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
     ADD_FAILURE();
   }
 
-  StringValue value1("value1");
+  Value value1("value1");
   dict.Set("key1", value1.CreateDeepCopy());
   bool seen1 = false;
   for (DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
     EXPECT_FALSE(seen1);
     EXPECT_EQ("key1", it.key());
     EXPECT_TRUE(value1.Equals(&it.value()));
     seen1 = true;
   }
   EXPECT_TRUE(seen1);
 
-  StringValue value2("value2");
+  Value value2("value2");
   dict.Set("key2", value2.CreateDeepCopy());
   bool seen2 = seen1 = false;
   for (DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
     if (it.key() == "key1") {
       EXPECT_FALSE(seen1);
       EXPECT_TRUE(value1.Equals(&it.value()));
       seen1 = true;
     } else if (it.key() == "key2") {
       EXPECT_FALSE(seen2);
       EXPECT_TRUE(value2.Equals(&it.value()));
       seen2 = true;
     } else {
       ADD_FAILURE();
     }
   }
   EXPECT_TRUE(seen1);
   EXPECT_TRUE(seen2);
 }
 
 // DictionaryValue/ListValue's Get*() methods should accept NULL as an out-value
 // and still return true/false based on success.
 TEST(ValuesTest, GetWithNullOutValue) {
   DictionaryValue main_dict;
   ListValue main_list;
 
   Value bool_value(false);
   Value int_value(1234);
   Value double_value(12.34567);
-  StringValue string_value("foo");
+  Value string_value("foo");
   BinaryValue binary_value(Value::Type::BINARY);
   DictionaryValue dict_value;
   ListValue list_value;
 
   main_dict.Set("bool", bool_value.CreateDeepCopy());
   main_dict.Set("int", int_value.CreateDeepCopy());
   main_dict.Set("double", double_value.CreateDeepCopy());
   main_dict.Set("string", string_value.CreateDeepCopy());
   main_dict.Set("binary", binary_value.CreateDeepCopy());
   main_dict.Set("dict", dict_value.CreateDeepCopy());
@@ skipping 256 matching lines @@
   EXPECT_FALSE(main_list.GetList(1, NULL));
   EXPECT_FALSE(main_list.GetList(2, NULL));
   EXPECT_FALSE(main_list.GetList(3, NULL));
   EXPECT_FALSE(main_list.GetList(4, NULL));
   EXPECT_FALSE(main_list.GetList(5, NULL));
   EXPECT_TRUE(main_list.GetList(6, NULL));
   EXPECT_FALSE(main_list.GetList(7, NULL));
 }
 
 }  // namespace base