Remove base::FundamentalValue

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>
 #include <utility>
 #include <vector>
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 
 // Group of tests for the value constructors.
 TEST(ValuesTest, ConstructBool) {
-  FundamentalValue true_value(true);
+  Value true_value(true);
   EXPECT_EQ(Value::Type::BOOLEAN, true_value.type());
   EXPECT_TRUE(true_value.GetBool());
 
-  FundamentalValue false_value(false);
+  Value false_value(false);
   EXPECT_EQ(Value::Type::BOOLEAN, false_value.type());
   EXPECT_FALSE(false_value.GetBool());
 }
 
 TEST(ValuesTest, ConstructInt) {
-  FundamentalValue value(-37);
+  Value value(-37);
   EXPECT_EQ(Value::Type::INTEGER, value.type());
   EXPECT_EQ(-37, value.GetInt());
 }
 
 TEST(ValuesTest, ConstructDouble) {
-  FundamentalValue value(-4.655);
+  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);
   EXPECT_EQ(Value::Type::STRING, value.type());
   EXPECT_EQ("foobar", value.GetString());
 }
@@ skipping 46 matching lines @@
 
 TEST(ValuesTest, ConstructList) {
   ListValue value;
   EXPECT_EQ(Value::Type::LIST, value.type());
 }
 
 // Group of tests for the copy constructors and copy-assigmnent. For equality
 // checks comparisons of the interesting fields are done instead of relying on
 // Equals being correct.
 TEST(ValuesTest, CopyBool) {
-  FundamentalValue true_value(true);
-  FundamentalValue copied_true_value(true_value);
+  Value true_value(true);
+  Value copied_true_value(true_value);
   EXPECT_EQ(true_value.type(), copied_true_value.type());
   EXPECT_EQ(true_value.GetBool(), copied_true_value.GetBool());
 
-  FundamentalValue false_value(false);
-  FundamentalValue copied_false_value(false_value);
+  Value false_value(false);
+  Value copied_false_value(false_value);
   EXPECT_EQ(false_value.type(), copied_false_value.type());
   EXPECT_EQ(false_value.GetBool(), copied_false_value.GetBool());
 
   Value blank;
 
   blank = true_value;
   EXPECT_EQ(true_value.type(), blank.type());
   EXPECT_EQ(true_value.GetBool(), blank.GetBool());
 
   blank = false_value;
   EXPECT_EQ(false_value.type(), blank.type());
   EXPECT_EQ(false_value.GetBool(), blank.GetBool());
 }
 
 TEST(ValuesTest, CopyInt) {
-  FundamentalValue value(74);
-  FundamentalValue copied_value(value);
+  Value value(74);
+  Value copied_value(value);
   EXPECT_EQ(value.type(), copied_value.type());
   EXPECT_EQ(value.GetInt(), copied_value.GetInt());
 
   Value blank;
 
   blank = value;
   EXPECT_EQ(value.type(), blank.type());
   EXPECT_EQ(value.GetInt(), blank.GetInt());
 }
 
 TEST(ValuesTest, CopyDouble) {
-  FundamentalValue value(74.896);
-  FundamentalValue copied_value(value);
+  Value value(74.896);
+  Value copied_value(value);
   EXPECT_EQ(value.type(), copied_value.type());
   EXPECT_EQ(value.GetDouble(), copied_value.GetDouble());
 
   Value blank;
 
   blank = value;
   EXPECT_EQ(value.type(), blank.type());
   EXPECT_EQ(value.GetDouble(), blank.GetDouble());
 }
 
@@ skipping 62 matching lines @@
 
   *blank = value;
   EXPECT_EQ(Value::Type::LIST, blank->type());
 
   static_cast<ListValue*>(blank.get())->GetInteger(0, &copy);
   EXPECT_EQ(123, copy);
 }
 
 // Group of tests for the move constructors and move-assigmnent.
 TEST(ValuesTest, MoveBool) {
-  FundamentalValue true_value(true);
-  FundamentalValue moved_true_value(std::move(true_value));
+  Value true_value(true);
+  Value moved_true_value(std::move(true_value));
   EXPECT_EQ(Value::Type::BOOLEAN, moved_true_value.type());
   EXPECT_TRUE(moved_true_value.GetBool());
 
-  FundamentalValue false_value(false);
-  FundamentalValue moved_false_value(std::move(false_value));
+  Value false_value(false);
+  Value moved_false_value(std::move(false_value));
   EXPECT_EQ(Value::Type::BOOLEAN, moved_false_value.type());
   EXPECT_FALSE(moved_false_value.GetBool());
 
   Value blank;
 
-  blank = FundamentalValue(true);
+  blank = Value(true);
   EXPECT_EQ(Value::Type::BOOLEAN, blank.type());
   EXPECT_TRUE(blank.GetBool());
 
-  blank = FundamentalValue(false);
+  blank = Value(false);
   EXPECT_EQ(Value::Type::BOOLEAN, blank.type());
   EXPECT_FALSE(blank.GetBool());
 }
 
 TEST(ValuesTest, MoveInt) {
-  FundamentalValue value(74);
-  FundamentalValue moved_value(std::move(value));
+  Value value(74);
+  Value moved_value(std::move(value));
   EXPECT_EQ(Value::Type::INTEGER, moved_value.type());
   EXPECT_EQ(74, moved_value.GetInt());
 
   Value blank;
 
-  blank = FundamentalValue(47);
+  blank = Value(47);
   EXPECT_EQ(Value::Type::INTEGER, blank.type());
   EXPECT_EQ(47, blank.GetInt());
 }
 
 TEST(ValuesTest, MoveDouble) {
-  FundamentalValue value(74.896);
-  FundamentalValue moved_value(std::move(value));
+  Value value(74.896);
+  Value moved_value(std::move(value));
   EXPECT_EQ(Value::Type::DOUBLE, moved_value.type());
   EXPECT_EQ(74.896, moved_value.GetDouble());
 
   Value blank;
 
-  blank = FundamentalValue(654.38);
+  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));
   EXPECT_EQ(Value::Type::STRING, moved_value.type());
   EXPECT_EQ("foobar", moved_value.GetString());
 
@@ skipping 94 matching lines @@
   std::string bookmark_name = "Unnamed";
   ASSERT_TRUE(bookmark->GetString("name", &bookmark_name));
   ASSERT_EQ(std::string("Froogle"), bookmark_name);
   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<FundamentalValue>(true));
-  mixed_list->Set(1, MakeUnique<FundamentalValue>(42));
-  mixed_list->Set(2, MakeUnique<FundamentalValue>(88.8));
+  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"));
   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 15 matching lines @@
   ASSERT_EQ(42, int_value);
   // implicit conversion from Integer to Double should be possible.
   ASSERT_TRUE(mixed_list->GetDouble(1, &double_value));
   ASSERT_EQ(42, double_value);
   ASSERT_TRUE(mixed_list->GetDouble(2, &double_value));
   ASSERT_EQ(88.8, double_value);
   ASSERT_TRUE(mixed_list->GetString(3, &string_value));
   ASSERT_EQ("foo", string_value);
 
   // Try searching in the mixed list.
-  base::FundamentalValue sought_value(42);
-  base::FundamentalValue not_found_value(false);
+  base::Value sought_value(42);
+  base::Value not_found_value(false);
 
   ASSERT_NE(mixed_list->end(), mixed_list->Find(sought_value));
   ASSERT_TRUE((*mixed_list->Find(sought_value))->GetAsInteger(&int_value));
   ASSERT_EQ(42, int_value);
   ASSERT_EQ(mixed_list->end(), mixed_list->Find(not_found_value));
 }
 
 TEST(ValuesTest, BinaryValue) {
   // Default constructor creates a BinaryValue with a buffer of size 0.
   auto binary = MakeUnique<Value>(Value::Type::BINARY);
@@ skipping 203 matching lines @@
   ASSERT_TRUE(removed_item);
   EXPECT_TRUE(removed_item->IsType(base::Value::Type::BOOLEAN));
   EXPECT_TRUE(dict.empty());
 }
 
 TEST(ValuesTest, DeepCopy) {
   DictionaryValue original_dict;
   std::unique_ptr<Value> scoped_null = Value::CreateNullValue();
   Value* original_null = scoped_null.get();
   original_dict.Set("null", std::move(scoped_null));
-  std::unique_ptr<FundamentalValue> scoped_bool(new FundamentalValue(true));
-  FundamentalValue* original_bool = scoped_bool.get();
+  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<FundamentalValue> scoped_int(new FundamentalValue(42));
-  FundamentalValue* original_int = scoped_int.get();
+  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<FundamentalValue> scoped_double(new FundamentalValue(3.14));
-  FundamentalValue* original_double = scoped_double.get();
+  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();
   original_dict.Set("string", std::move(scoped_string));
   std::unique_ptr<StringValue> scoped_string16(
       new StringValue(ASCIIToUTF16("hello16")));
   StringValue* 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();
-  std::unique_ptr<FundamentalValue> scoped_list_element_0(
-      new FundamentalValue(0));
+  std::unique_ptr<Value> scoped_list_element_0(new Value(0));
   Value* original_list_element_0 = scoped_list_element_0.get();
   scoped_list->Append(std::move(scoped_list_element_0));
-  std::unique_ptr<FundamentalValue> scoped_list_element_1(
-      new FundamentalValue(1));
+  std::unique_ptr<Value> scoped_list_element_1(new Value(1));
   Value* original_list_element_1 = scoped_list_element_1.get();
   scoped_list->Append(std::move(scoped_list_element_1));
   original_dict.Set("list", std::move(scoped_list));
 
   std::unique_ptr<DictionaryValue> scoped_nested_dictionary(
       new DictionaryValue());
   Value* original_nested_dictionary = scoped_nested_dictionary.get();
   scoped_nested_dictionary->SetString("key", "value");
   original_dict.Set("dictionary", std::move(scoped_nested_dictionary));
 
@@ skipping 102 matching lines @@
   ASSERT_TRUE(copy_nested_dictionary);
   EXPECT_TRUE(copy_nested_dictionary->HasKey("key"));
 }
 
 TEST(ValuesTest, Equals) {
   std::unique_ptr<Value> null1(Value::CreateNullValue());
   std::unique_ptr<Value> null2(Value::CreateNullValue());
   EXPECT_NE(null1.get(), null2.get());
   EXPECT_TRUE(null1->Equals(null2.get()));
 
-  FundamentalValue boolean(false);
+  Value boolean(false);
   EXPECT_FALSE(null1->Equals(&boolean));
 
   DictionaryValue dv;
   dv.SetBoolean("a", false);
   dv.SetInteger("b", 2);
   dv.SetDouble("c", 2.5);
   dv.SetString("d1", "string");
   dv.SetString("d2", ASCIIToUTF16("http://google.com"));
   dv.Set("e", Value::CreateNullValue());
 
   std::unique_ptr<DictionaryValue> copy = dv.CreateDeepCopy();
   EXPECT_TRUE(dv.Equals(copy.get()));
 
   std::unique_ptr<ListValue> list(new ListValue);
   ListValue* original_list = list.get();
   list->Append(Value::CreateNullValue());
   list->Append(WrapUnique(new DictionaryValue));
   std::unique_ptr<Value> list_copy(list->CreateDeepCopy());
 
   dv.Set("f", std::move(list));
   EXPECT_FALSE(dv.Equals(copy.get()));
   copy->Set("f", std::move(list_copy));
   EXPECT_TRUE(dv.Equals(copy.get()));
 
-  original_list->Append(MakeUnique<FundamentalValue>(true));
+  original_list->Append(MakeUnique<Value>(true));
   EXPECT_FALSE(dv.Equals(copy.get()));
 
   // Check if Equals detects differences in only the keys.
   copy = dv.CreateDeepCopy();
   EXPECT_TRUE(dv.Equals(copy.get()));
   copy->Remove("a", NULL);
   copy->SetBoolean("aa", false);
   EXPECT_FALSE(dv.Equals(copy.get()));
 }
 
 TEST(ValuesTest, StaticEquals) {
   std::unique_ptr<Value> null1(Value::CreateNullValue());
   std::unique_ptr<Value> null2(Value::CreateNullValue());
   EXPECT_TRUE(Value::Equals(null1.get(), null2.get()));
   EXPECT_TRUE(Value::Equals(NULL, NULL));
 
-  std::unique_ptr<Value> i42(new FundamentalValue(42));
-  std::unique_ptr<Value> j42(new FundamentalValue(42));
-  std::unique_ptr<Value> i17(new FundamentalValue(17));
+  std::unique_ptr<Value> i42(new Value(42));
+  std::unique_ptr<Value> j42(new Value(42));
+  std::unique_ptr<Value> i17(new Value(17));
   EXPECT_TRUE(Value::Equals(i42.get(), i42.get()));
   EXPECT_TRUE(Value::Equals(j42.get(), i42.get()));
   EXPECT_TRUE(Value::Equals(i42.get(), j42.get()));
   EXPECT_FALSE(Value::Equals(i42.get(), i17.get()));
   EXPECT_FALSE(Value::Equals(i42.get(), NULL));
   EXPECT_FALSE(Value::Equals(NULL, i42.get()));
 
   // NULL and Value::CreateNullValue() are intentionally different: We need
   // support for NULL as a return value for "undefined" without caring for
   // ownership of the pointer.
   EXPECT_FALSE(Value::Equals(null1.get(), NULL));
   EXPECT_FALSE(Value::Equals(NULL, null1.get()));
 }
 
 TEST(ValuesTest, DeepCopyCovariantReturnTypes) {
   DictionaryValue original_dict;
   std::unique_ptr<Value> scoped_null(Value::CreateNullValue());
   Value* original_null = scoped_null.get();
   original_dict.Set("null", std::move(scoped_null));
-  std::unique_ptr<FundamentalValue> scoped_bool(new FundamentalValue(true));
+  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<FundamentalValue> scoped_int(new FundamentalValue(42));
+  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<FundamentalValue> scoped_double(new FundamentalValue(3.14));
+  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"));
   Value* original_string = scoped_string.get();
   original_dict.Set("string", std::move(scoped_string));
   std::unique_ptr<StringValue> scoped_string16(
       new StringValue(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());
   Value* original_list = scoped_list.get();
-  std::unique_ptr<FundamentalValue> scoped_list_element_0(
-      new FundamentalValue(0));
+  std::unique_ptr<Value> scoped_list_element_0(new Value(0));
   scoped_list->Append(std::move(scoped_list_element_0));
-  std::unique_ptr<FundamentalValue> scoped_list_element_1(
-      new FundamentalValue(1));
+  std::unique_ptr<Value> scoped_list_element_1(new Value(1));
   scoped_list->Append(std::move(scoped_list_element_1));
   original_dict.Set("list", std::move(scoped_list));
 
   std::unique_ptr<Value> copy_dict = original_dict.CreateDeepCopy();
   std::unique_ptr<Value> copy_null = original_null->CreateDeepCopy();
   std::unique_ptr<Value> copy_bool = original_bool->CreateDeepCopy();
   std::unique_ptr<Value> copy_int = original_int->CreateDeepCopy();
   std::unique_ptr<Value> copy_double = original_double->CreateDeepCopy();
   std::unique_ptr<Value> copy_string = original_string->CreateDeepCopy();
   std::unique_ptr<Value> copy_string16 = original_string16->CreateDeepCopy();
@@ skipping 202 matching lines @@
   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;
 
-  FundamentalValue bool_value(false);
-  FundamentalValue int_value(1234);
-  FundamentalValue double_value(12.34567);
+  Value bool_value(false);
+  Value int_value(1234);
+  Value double_value(12.34567);
   StringValue 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());
@@ skipping 257 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