Remove base::FundamentalValue

dbus/values_util_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 "dbus/values_util.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <cmath>
@@ skipping 37 matching lines @@
   writer.AppendString(kEmptyStringValue);
   const ObjectPath kObjectPathValue("/ObjectPath");
   writer.AppendObjectPath(kObjectPathValue);
 
   MessageReader reader(response.get());
   std::unique_ptr<base::Value> value;
   std::unique_ptr<base::Value> expected_value;
   // Pop a byte.
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
-  expected_value.reset(new base::FundamentalValue(kByteValue));
+  expected_value.reset(new base::Value(kByteValue));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop a bool.
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
-  expected_value.reset(new base::FundamentalValue(kBoolValue));
+  expected_value.reset(new base::Value(kBoolValue));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop an int16_t.
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
-  expected_value.reset(new base::FundamentalValue(kInt16Value));
+  expected_value.reset(new base::Value(kInt16Value));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop a uint16_t.
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
-  expected_value.reset(new base::FundamentalValue(kUint16Value));
+  expected_value.reset(new base::Value(kUint16Value));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop an int32_t.
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
-  expected_value.reset(new base::FundamentalValue(kInt32Value));
+  expected_value.reset(new base::Value(kInt32Value));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop a uint32_t.
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
-  expected_value.reset(
-      new base::FundamentalValue(static_cast<double>(kUint32Value)));
+  expected_value.reset(new base::Value(static_cast<double>(kUint32Value)));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop an int64_t.
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
-  expected_value.reset(
-      new base::FundamentalValue(static_cast<double>(kInt64Value)));
+  expected_value.reset(new base::Value(static_cast<double>(kInt64Value)));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop a uint64_t.
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
-  expected_value.reset(
-      new base::FundamentalValue(static_cast<double>(kUint64Value)));
+  expected_value.reset(new base::Value(static_cast<double>(kUint64Value)));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop a double.
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
-  expected_value.reset(new base::FundamentalValue(kDoubleValue));
+  expected_value.reset(new base::Value(kDoubleValue));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop a string.
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   expected_value.reset(new base::StringValue(kStringValue));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop an empty string.
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   expected_value.reset(new base::StringValue(kEmptyStringValue));
@@ skipping 17 matching lines @@
   writer.AppendVariantOfDouble(kDoubleValue);
   const std::string kStringValue = "fifty";
   writer.AppendVariantOfString(kStringValue);
 
   MessageReader reader(response.get());
   std::unique_ptr<base::Value> value;
   std::unique_ptr<base::Value> expected_value;
   // Pop a bool.
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
-  expected_value.reset(new base::FundamentalValue(kBoolValue));
+  expected_value.reset(new base::Value(kBoolValue));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop an int32_t.
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
-  expected_value.reset(new base::FundamentalValue(kInt32Value));
+  expected_value.reset(new base::Value(kInt32Value));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop a double.
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
-  expected_value.reset(new base::FundamentalValue(kDoubleValue));
+  expected_value.reset(new base::Value(kDoubleValue));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop a string.
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   expected_value.reset(new base::StringValue(kStringValue));
   EXPECT_TRUE(value->Equals(expected_value.get()));
 }
 
 // Pop extremely large integers which cannot be precisely represented in
 // double.
 TEST(ValuesUtilTest, PopExtremelyLargeIntegers) {
   std::unique_ptr<Response> response(Response::CreateEmpty());
   // Append large integers.
   MessageWriter writer(response.get());
   const int64_t kInt64Value = -123456789012345689LL;
   writer.AppendInt64(kInt64Value);
   const uint64_t kUint64Value = 9876543210987654321ULL;
   writer.AppendUint64(kUint64Value);
 
   MessageReader reader(response.get());
   std::unique_ptr<base::Value> value;
   std::unique_ptr<base::Value> expected_value;
   double double_value = 0;
   // Pop an int64_t.
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
-  expected_value.reset(
-      new base::FundamentalValue(static_cast<double>(kInt64Value)));
+  expected_value.reset(new base::Value(static_cast<double>(kInt64Value)));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   ASSERT_TRUE(value->GetAsDouble(&double_value));
   EXPECT_NE(kInt64Value, static_cast<int64_t>(double_value));
   // Pop a uint64_t.
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
-  expected_value.reset(
-      new base::FundamentalValue(static_cast<double>(kUint64Value)));
+  expected_value.reset(new base::Value(static_cast<double>(kUint64Value)));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   ASSERT_TRUE(value->GetAsDouble(&double_value));
   EXPECT_NE(kUint64Value, static_cast<uint64_t>(double_value));
 }
 
 TEST(ValuesUtilTest, PopIntArray) {
   std::unique_ptr<Response> response(Response::CreateEmpty());
   // Append an int32_t array.
   MessageWriter writer(response.get());
   MessageWriter sub_writer(NULL);
@@ skipping 140 matching lines @@
   sub_writer.OpenDictEntry(&entry_writer);
   const std::string kKey3 = "example.";  // String ending with a dot.
   entry_writer.AppendString(kKey3);
   const double kDoubleValue = 4.9;
   entry_writer.AppendVariantOfDouble(kDoubleValue);
   sub_writer.CloseContainer(&entry_writer);
   writer.CloseContainer(&sub_writer);
 
   // Create the expected value.
   base::DictionaryValue dictionary_value;
-  dictionary_value.SetWithoutPathExpansion(
-      kKey1, new base::FundamentalValue(kBoolValue));
-  dictionary_value.SetWithoutPathExpansion(
-      kKey2, new base::FundamentalValue(kInt32Value));
-  dictionary_value.SetWithoutPathExpansion(
-      kKey3, new base::FundamentalValue(kDoubleValue));
+  dictionary_value.SetWithoutPathExpansion(kKey1, new base::Value(kBoolValue));
+  dictionary_value.SetWithoutPathExpansion(kKey2, new base::Value(kInt32Value));
+  dictionary_value.SetWithoutPathExpansion(kKey3,
+                                           new base::Value(kDoubleValue));
 
   // Pop a dictinoary.
   MessageReader reader(response.get());
   std::unique_ptr<base::Value> value(PopDataAsValue(&reader));
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&dictionary_value));
 }
 
 TEST(ValuesUtilTest, PopDoubleToIntDictionary) {
   // Create test data.
@@ skipping 14 matching lines @@
     entry_writer.AppendDouble(keys[i]);
     entry_writer.AppendInt32(values[i]);
     sub_writer.CloseContainer(&entry_writer);
   }
   writer.CloseContainer(&sub_writer);
 
   // Create the expected value.
   base::DictionaryValue dictionary_value;
   for (size_t i = 0; i != values.size(); ++i) {
     std::string key_string;
-    base::JSONWriter::Write(base::FundamentalValue(keys[i]), &key_string);
+    base::JSONWriter::Write(base::Value(keys[i]), &key_string);
     dictionary_value.SetIntegerWithoutPathExpansion(key_string, values[i]);
   }
 
   // Pop a dictionary.
   MessageReader reader(response.get());
   std::unique_ptr<base::Value> value(PopDataAsValue(&reader));
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&dictionary_value));
 }
 
 TEST(ValuesUtilTest, AppendBasicTypes) {
-  const base::FundamentalValue kBoolValue(false);
-  const base::FundamentalValue kIntegerValue(42);
-  const base::FundamentalValue kDoubleValue(4.2);
+  const base::Value kBoolValue(false);
+  const base::Value kIntegerValue(42);
+  const base::Value kDoubleValue(4.2);
   const base::StringValue kStringValue("string");
 
   std::unique_ptr<Response> response(Response::CreateEmpty());
   MessageWriter writer(response.get());
   AppendBasicTypeValueData(&writer, kBoolValue);
   AppendBasicTypeValueData(&writer, kIntegerValue);
   AppendBasicTypeValueData(&writer, kDoubleValue);
   AppendBasicTypeValueData(&writer, kStringValue);
 
   MessageReader reader(response.get());
   std::unique_ptr<base::Value> value;
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&kBoolValue));
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&kIntegerValue));
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&kDoubleValue));
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&kStringValue));
 }
 
 TEST(ValuesUtilTest, AppendBasicTypesAsVariant) {
-  const base::FundamentalValue kBoolValue(false);
-  const base::FundamentalValue kIntegerValue(42);
-  const base::FundamentalValue kDoubleValue(4.2);
+  const base::Value kBoolValue(false);
+  const base::Value kIntegerValue(42);
+  const base::Value kDoubleValue(4.2);
   const base::StringValue kStringValue("string");
 
   std::unique_ptr<Response> response(Response::CreateEmpty());
   MessageWriter writer(response.get());
   AppendBasicTypeValueDataAsVariant(&writer, kBoolValue);
   AppendBasicTypeValueDataAsVariant(&writer, kIntegerValue);
   AppendBasicTypeValueDataAsVariant(&writer, kDoubleValue);
   AppendBasicTypeValueDataAsVariant(&writer, kStringValue);
 
   MessageReader reader(response.get());
   std::unique_ptr<base::Value> value;
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&kBoolValue));
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&kIntegerValue));
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&kDoubleValue));
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&kStringValue));
 }
 
 TEST(ValuesUtilTest, AppendValueDataBasicTypes) {
-  const base::FundamentalValue kBoolValue(false);
-  const base::FundamentalValue kIntegerValue(42);
-  const base::FundamentalValue kDoubleValue(4.2);
+  const base::Value kBoolValue(false);
+  const base::Value kIntegerValue(42);
+  const base::Value kDoubleValue(4.2);
   const base::StringValue kStringValue("string");
 
   std::unique_ptr<Response> response(Response::CreateEmpty());
   MessageWriter writer(response.get());
   AppendValueData(&writer, kBoolValue);
   AppendValueData(&writer, kIntegerValue);
   AppendValueData(&writer, kDoubleValue);
   AppendValueData(&writer, kStringValue);
 
   MessageReader reader(response.get());
   std::unique_ptr<base::Value> value;
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&kBoolValue));
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&kIntegerValue));
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&kDoubleValue));
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&kStringValue));
 }
 
 TEST(ValuesUtilTest, AppendValueDataAsVariantBasicTypes) {
-  const base::FundamentalValue kBoolValue(false);
-  const base::FundamentalValue kIntegerValue(42);
-  const base::FundamentalValue kDoubleValue(4.2);
+  const base::Value kBoolValue(false);
+  const base::Value kIntegerValue(42);
+  const base::Value kDoubleValue(4.2);
   const base::StringValue kStringValue("string");
 
   std::unique_ptr<Response> response(Response::CreateEmpty());
   MessageWriter writer(response.get());
   AppendValueDataAsVariant(&writer, kBoolValue);
   AppendValueDataAsVariant(&writer, kIntegerValue);
   AppendValueDataAsVariant(&writer, kDoubleValue);
   AppendValueDataAsVariant(&writer, kStringValue);
 
   MessageReader reader(response.get());
@@ skipping 38 matching lines @@
   test_dictionary.SetBoolean(kKey1, kBoolValue);
   test_dictionary.SetInteger(kKey2, kInt32Value);
   test_dictionary.SetDouble(kKey3, kDoubleValue);
   test_dictionary.SetString(kKey4, kStringValue);
   test_dictionary.Set(kKey5, list_value);  // takes ownership
   test_dictionary.Set(kKey6, dictionary_value);  // takes ownership
 
   std::unique_ptr<Response> response(Response::CreateEmpty());
   MessageWriter writer(response.get());
   AppendValueData(&writer, test_dictionary);
-  base::FundamentalValue int_value(kInt32Value);
+  base::Value int_value(kInt32Value);
   AppendValueData(&writer, int_value);
 
   // Read the data.
   MessageReader reader(response.get());
   std::unique_ptr<base::Value> value;
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&test_dictionary));
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
@@ skipping 26 matching lines @@
   test_dictionary.SetBoolean(kKey1, kBoolValue);
   test_dictionary.SetInteger(kKey2, kInt32Value);
   test_dictionary.SetDouble(kKey3, kDoubleValue);
   test_dictionary.SetString(kKey4, kStringValue);
   test_dictionary.Set(kKey5, list_value);  // takes ownership
   test_dictionary.Set(kKey6, dictionary_value);  // takes ownership
 
   std::unique_ptr<Response> response(Response::CreateEmpty());
   MessageWriter writer(response.get());
   AppendValueDataAsVariant(&writer, test_dictionary);
-  base::FundamentalValue int_value(kInt32Value);
+  base::Value int_value(kInt32Value);
   AppendValueData(&writer, int_value);
 
   // Read the data.
   MessageReader reader(response.get());
   std::unique_ptr<base::Value> value;
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&test_dictionary));
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
@@ skipping 23 matching lines @@
   test_list.AppendBoolean(kBoolValue);
   test_list.AppendInteger(kInt32Value);
   test_list.AppendDouble(kDoubleValue);
   test_list.AppendString(kStringValue);
   test_list.Append(std::move(list_value));
   test_list.Append(std::move(dictionary_value));
 
   std::unique_ptr<Response> response(Response::CreateEmpty());
   MessageWriter writer(response.get());
   AppendValueData(&writer, test_list);
-  base::FundamentalValue int_value(kInt32Value);
+  base::Value int_value(kInt32Value);
   AppendValueData(&writer, int_value);
 
   // Read the data.
   MessageReader reader(response.get());
   std::unique_ptr<base::Value> value;
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&test_list));
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
@@ skipping 23 matching lines @@
   test_list.AppendBoolean(kBoolValue);
   test_list.AppendInteger(kInt32Value);
   test_list.AppendDouble(kDoubleValue);
   test_list.AppendString(kStringValue);
   test_list.Append(std::move(list_value));
   test_list.Append(std::move(dictionary_value));
 
   std::unique_ptr<Response> response(Response::CreateEmpty());
   MessageWriter writer(response.get());
   AppendValueDataAsVariant(&writer, test_list);
-  base::FundamentalValue int_value(kInt32Value);
+  base::Value int_value(kInt32Value);
   AppendValueData(&writer, int_value);
 
   // Read the data.
   MessageReader reader(response.get());
   std::unique_ptr<base::Value> value;
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&test_list));
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&int_value));
 }
 
 }  // namespace dbus