Remove FundamentalValue

base/json/json_writer_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/json/json_writer.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 
 TEST(JSONWriterTest, BasicTypes) {
   std::string output_js;
 
   // Test null.
   EXPECT_TRUE(JSONWriter::Write(*Value::CreateNullValue(), &output_js));
   EXPECT_EQ("null", output_js);
 
   // Test empty dict.
   EXPECT_TRUE(JSONWriter::Write(DictionaryValue(), &output_js));
   EXPECT_EQ("{}", output_js);
 
   // Test empty list.
   EXPECT_TRUE(JSONWriter::Write(ListValue(), &output_js));
   EXPECT_EQ("[]", output_js);
 
   // Test integer values.
-  EXPECT_TRUE(JSONWriter::Write(FundamentalValue(42), &output_js));
+  EXPECT_TRUE(JSONWriter::Write(Value(42), &output_js));
   EXPECT_EQ("42", output_js);
 
   // Test boolean values.
-  EXPECT_TRUE(JSONWriter::Write(FundamentalValue(true), &output_js));
+  EXPECT_TRUE(JSONWriter::Write(Value(true), &output_js));
   EXPECT_EQ("true", output_js);
 
   // Test Real values should always have a decimal or an 'e'.
-  EXPECT_TRUE(JSONWriter::Write(FundamentalValue(1.0), &output_js));
+  EXPECT_TRUE(JSONWriter::Write(Value(1.0), &output_js));
   EXPECT_EQ("1.0", output_js);
 
   // Test Real values in the the range (-1, 1) must have leading zeros
-  EXPECT_TRUE(JSONWriter::Write(FundamentalValue(0.2), &output_js));
+  EXPECT_TRUE(JSONWriter::Write(Value(0.2), &output_js));
   EXPECT_EQ("0.2", output_js);
 
   // Test Real values in the the range (-1, 1) must have leading zeros
-  EXPECT_TRUE(JSONWriter::Write(FundamentalValue(-0.8), &output_js));
+  EXPECT_TRUE(JSONWriter::Write(Value(-0.8), &output_js));
   EXPECT_EQ("-0.8", output_js);
 
   // Test String values.
   EXPECT_TRUE(JSONWriter::Write(StringValue("foo"), &output_js));
   EXPECT_EQ("\"foo\"", output_js);
 }
 
 TEST(JSONWriterTest, NestedTypes) {
   std::string output_js;
 
@@ skipping 55 matching lines @@
   // Binary values should return errors unless suppressed via the
   // OPTIONS_OMIT_BINARY_VALUES flag.
   std::unique_ptr<Value> root(BinaryValue::CreateWithCopiedBuffer("asdf", 4));
   EXPECT_FALSE(JSONWriter::Write(*root, &output_js));
   EXPECT_TRUE(JSONWriter::WriteWithOptions(
       *root, JSONWriter::OPTIONS_OMIT_BINARY_VALUES, &output_js));
   EXPECT_TRUE(output_js.empty());
 
   ListValue binary_list;
   binary_list.Append(BinaryValue::CreateWithCopiedBuffer("asdf", 4));
-  binary_list.Append(MakeUnique<FundamentalValue>(5));
+  binary_list.Append(MakeUnique<Value>(5));
   binary_list.Append(BinaryValue::CreateWithCopiedBuffer("asdf", 4));
-  binary_list.Append(MakeUnique<FundamentalValue>(2));
+  binary_list.Append(MakeUnique<Value>(2));
   binary_list.Append(BinaryValue::CreateWithCopiedBuffer("asdf", 4));
   EXPECT_FALSE(JSONWriter::Write(binary_list, &output_js));
   EXPECT_TRUE(JSONWriter::WriteWithOptions(
       binary_list, JSONWriter::OPTIONS_OMIT_BINARY_VALUES, &output_js));
   EXPECT_EQ("[5,2]", output_js);
 
   DictionaryValue binary_dict;
   binary_dict.Set("a", BinaryValue::CreateWithCopiedBuffer("asdf", 4));
   binary_dict.SetInteger("b", 5);
   binary_dict.Set("c", BinaryValue::CreateWithCopiedBuffer("asdf", 4));
   binary_dict.SetInteger("d", 2);
   binary_dict.Set("e", BinaryValue::CreateWithCopiedBuffer("asdf", 4));
   EXPECT_FALSE(JSONWriter::Write(binary_dict, &output_js));
   EXPECT_TRUE(JSONWriter::WriteWithOptions(
       binary_dict, JSONWriter::OPTIONS_OMIT_BINARY_VALUES, &output_js));
   EXPECT_EQ("{\"b\":5,\"d\":2}", output_js);
 }
 
 TEST(JSONWriterTest, DoublesAsInts) {
   std::string output_js;
 
   // Test allowing a double with no fractional part to be written as an integer.
-  FundamentalValue double_value(1e10);
+  Value double_value(1e10);
   EXPECT_TRUE(JSONWriter::WriteWithOptions(
       double_value, JSONWriter::OPTIONS_OMIT_DOUBLE_TYPE_PRESERVATION,
       &output_js));
   EXPECT_EQ("10000000000", output_js);
 }
 
 }  // namespace base