Make base::Value::TYPE a scoped enum.

base/json/json_reader_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_reader.h"
 
 #include <stddef.h>
 
 #include <memory>
 
 #include "base/base_paths.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/path_service.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 
 TEST(JSONReaderTest, Reading) {
   {
     // some whitespace checking
     std::unique_ptr<Value> root = JSONReader().ReadToValue("   null   ");
     ASSERT_TRUE(root);
-    EXPECT_TRUE(root->IsType(Value::TYPE_NULL));
+    EXPECT_TRUE(root->IsType(Value::Type::NONE));
   }
 
   {
     // Invalid JSON string
     EXPECT_FALSE(JSONReader().ReadToValue("nu"));
   }
 
   {
     // Simple bool
     std::unique_ptr<Value> root = JSONReader().ReadToValue("true  ");
     ASSERT_TRUE(root);
-    EXPECT_TRUE(root->IsType(Value::TYPE_BOOLEAN));
+    EXPECT_TRUE(root->IsType(Value::Type::BOOLEAN));
   }
 
   {
     // Embedded comment
     std::unique_ptr<Value> root = JSONReader().ReadToValue("/* comment */null");
     ASSERT_TRUE(root);
-    EXPECT_TRUE(root->IsType(Value::TYPE_NULL));
+    EXPECT_TRUE(root->IsType(Value::Type::NONE));
     root = JSONReader().ReadToValue("40 /* comment */");
     ASSERT_TRUE(root);
-    EXPECT_TRUE(root->IsType(Value::TYPE_INTEGER));
+    EXPECT_TRUE(root->IsType(Value::Type::INTEGER));
     root = JSONReader().ReadToValue("true // comment");
     ASSERT_TRUE(root);
-    EXPECT_TRUE(root->IsType(Value::TYPE_BOOLEAN));
+    EXPECT_TRUE(root->IsType(Value::Type::BOOLEAN));
     root = JSONReader().ReadToValue("/* comment */\"sample string\"");
     ASSERT_TRUE(root);
-    EXPECT_TRUE(root->IsType(Value::TYPE_STRING));
+    EXPECT_TRUE(root->IsType(Value::Type::STRING));
     std::string value;
     EXPECT_TRUE(root->GetAsString(&value));
     EXPECT_EQ("sample string", value);
     std::unique_ptr<ListValue> list = ListValue::From(
         JSONReader().ReadToValue("[1, /* comment, 2 ] */ \n 3]"));
     ASSERT_TRUE(list);
     EXPECT_EQ(2u, list->GetSize());
     int int_val = 0;
     EXPECT_TRUE(list->GetInteger(0, &int_val));
     EXPECT_EQ(1, int_val);
     EXPECT_TRUE(list->GetInteger(1, &int_val));
     EXPECT_EQ(3, int_val);
     list = ListValue::From(JSONReader().ReadToValue("[1, /*a*/2, 3]"));
     ASSERT_TRUE(list);
     EXPECT_EQ(3u, list->GetSize());
     root = JSONReader().ReadToValue("/* comment **/42");
     ASSERT_TRUE(root);
-    EXPECT_TRUE(root->IsType(Value::TYPE_INTEGER));
+    EXPECT_TRUE(root->IsType(Value::Type::INTEGER));
     EXPECT_TRUE(root->GetAsInteger(&int_val));
     EXPECT_EQ(42, int_val);
     root = JSONReader().ReadToValue(
         "/* comment **/\n"
         "// */ 43\n"
         "44");
     ASSERT_TRUE(root);
-    EXPECT_TRUE(root->IsType(Value::TYPE_INTEGER));
+    EXPECT_TRUE(root->IsType(Value::Type::INTEGER));
     EXPECT_TRUE(root->GetAsInteger(&int_val));
     EXPECT_EQ(44, int_val);
   }
 
   {
     // Test number formats
     std::unique_ptr<Value> root = JSONReader().ReadToValue("43");
     ASSERT_TRUE(root);
-    EXPECT_TRUE(root->IsType(Value::TYPE_INTEGER));
+    EXPECT_TRUE(root->IsType(Value::Type::INTEGER));
     int int_val = 0;
     EXPECT_TRUE(root->GetAsInteger(&int_val));
     EXPECT_EQ(43, int_val);
   }
 
   {
     // According to RFC4627, oct, hex, and leading zeros are invalid JSON.
     EXPECT_FALSE(JSONReader().ReadToValue("043"));
     EXPECT_FALSE(JSONReader().ReadToValue("0x43"));
     EXPECT_FALSE(JSONReader().ReadToValue("00"));
   }
 
   {
     // Test 0 (which needs to be special cased because of the leading zero
     // clause).
     std::unique_ptr<Value> root = JSONReader().ReadToValue("0");
     ASSERT_TRUE(root);
-    EXPECT_TRUE(root->IsType(Value::TYPE_INTEGER));
+    EXPECT_TRUE(root->IsType(Value::Type::INTEGER));
     int int_val = 1;
     EXPECT_TRUE(root->GetAsInteger(&int_val));
     EXPECT_EQ(0, int_val);
   }
 
   {
     // Numbers that overflow ints should succeed, being internally promoted to
     // storage as doubles
     std::unique_ptr<Value> root = JSONReader().ReadToValue("2147483648");
     ASSERT_TRUE(root);
     double double_val;
-    EXPECT_TRUE(root->IsType(Value::TYPE_DOUBLE));
+    EXPECT_TRUE(root->IsType(Value::Type::DOUBLE));
     double_val = 0.0;
     EXPECT_TRUE(root->GetAsDouble(&double_val));
     EXPECT_DOUBLE_EQ(2147483648.0, double_val);
     root = JSONReader().ReadToValue("-2147483649");
     ASSERT_TRUE(root);
-    EXPECT_TRUE(root->IsType(Value::TYPE_DOUBLE));
+    EXPECT_TRUE(root->IsType(Value::Type::DOUBLE));
     double_val = 0.0;
     EXPECT_TRUE(root->GetAsDouble(&double_val));
     EXPECT_DOUBLE_EQ(-2147483649.0, double_val);
   }
 
   {
     // Parse a double
     std::unique_ptr<Value> root = JSONReader().ReadToValue("43.1");
     ASSERT_TRUE(root);
-    EXPECT_TRUE(root->IsType(Value::TYPE_DOUBLE));
+    EXPECT_TRUE(root->IsType(Value::Type::DOUBLE));
     double double_val = 0.0;
     EXPECT_TRUE(root->GetAsDouble(&double_val));
     EXPECT_DOUBLE_EQ(43.1, double_val);
 
     root = JSONReader().ReadToValue("4.3e-1");
     ASSERT_TRUE(root);
-    EXPECT_TRUE(root->IsType(Value::TYPE_DOUBLE));
+    EXPECT_TRUE(root->IsType(Value::Type::DOUBLE));
     double_val = 0.0;
     EXPECT_TRUE(root->GetAsDouble(&double_val));
     EXPECT_DOUBLE_EQ(.43, double_val);
 
     root = JSONReader().ReadToValue("2.1e0");
     ASSERT_TRUE(root);
-    EXPECT_TRUE(root->IsType(Value::TYPE_DOUBLE));
+    EXPECT_TRUE(root->IsType(Value::Type::DOUBLE));
     double_val = 0.0;
     EXPECT_TRUE(root->GetAsDouble(&double_val));
     EXPECT_DOUBLE_EQ(2.1, double_val);
 
     root = JSONReader().ReadToValue("2.1e+0001");
     ASSERT_TRUE(root);
-    EXPECT_TRUE(root->IsType(Value::TYPE_DOUBLE));
+    EXPECT_TRUE(root->IsType(Value::Type::DOUBLE));
     double_val = 0.0;
     EXPECT_TRUE(root->GetAsDouble(&double_val));
     EXPECT_DOUBLE_EQ(21.0, double_val);
 
     root = JSONReader().ReadToValue("0.01");
     ASSERT_TRUE(root);
-    EXPECT_TRUE(root->IsType(Value::TYPE_DOUBLE));
+    EXPECT_TRUE(root->IsType(Value::Type::DOUBLE));
     double_val = 0.0;
     EXPECT_TRUE(root->GetAsDouble(&double_val));
     EXPECT_DOUBLE_EQ(0.01, double_val);
 
     root = JSONReader().ReadToValue("1.00");
     ASSERT_TRUE(root);
-    EXPECT_TRUE(root->IsType(Value::TYPE_DOUBLE));
+    EXPECT_TRUE(root->IsType(Value::Type::DOUBLE));
     double_val = 0.0;
     EXPECT_TRUE(root->GetAsDouble(&double_val));
     EXPECT_DOUBLE_EQ(1.0, double_val);
   }
 
   {
     // Fractional parts must have a digit before and after the decimal point.
     EXPECT_FALSE(JSONReader().ReadToValue("1."));
     EXPECT_FALSE(JSONReader().ReadToValue(".1"));
     EXPECT_FALSE(JSONReader().ReadToValue("1.e10"));
@@ skipping 19 matching lines @@
   {
     // Invalid number formats
     EXPECT_FALSE(JSONReader().ReadToValue("4.3.1"));
     EXPECT_FALSE(JSONReader().ReadToValue("4e3.1"));
   }
 
   {
     // Test string parser
     std::unique_ptr<Value> root = JSONReader().ReadToValue("\"hello world\"");
     ASSERT_TRUE(root);
-    EXPECT_TRUE(root->IsType(Value::TYPE_STRING));
+    EXPECT_TRUE(root->IsType(Value::Type::STRING));
     std::string str_val;
     EXPECT_TRUE(root->GetAsString(&str_val));
     EXPECT_EQ("hello world", str_val);
   }
 
   {
     // Empty string
     std::unique_ptr<Value> root = JSONReader().ReadToValue("\"\"");
     ASSERT_TRUE(root);
-    EXPECT_TRUE(root->IsType(Value::TYPE_STRING));
+    EXPECT_TRUE(root->IsType(Value::Type::STRING));
     std::string str_val;
     EXPECT_TRUE(root->GetAsString(&str_val));
     EXPECT_EQ("", str_val);
   }
 
   {
     // Test basic string escapes
     std::unique_ptr<Value> root =
         JSONReader().ReadToValue("\" \\\"\\\\\\/\\b\\f\\n\\r\\t\\v\"");
     ASSERT_TRUE(root);
-    EXPECT_TRUE(root->IsType(Value::TYPE_STRING));
+    EXPECT_TRUE(root->IsType(Value::Type::STRING));
     std::string str_val;
     EXPECT_TRUE(root->GetAsString(&str_val));
     EXPECT_EQ(" \"\\/\b\f\n\r\t\v", str_val);
   }
 
   {
     // Test hex and unicode escapes including the null character.
     std::unique_ptr<Value> root =
         JSONReader().ReadToValue("\"\\x41\\x00\\u1234\"");
     ASSERT_TRUE(root);
-    EXPECT_TRUE(root->IsType(Value::TYPE_STRING));
+    EXPECT_TRUE(root->IsType(Value::Type::STRING));
     std::string str_val;
     EXPECT_TRUE(root->GetAsString(&str_val));
     EXPECT_EQ(std::wstring(L"A\0\x1234", 3), UTF8ToWide(str_val));
   }
 
   {
     // Test invalid strings
     EXPECT_FALSE(JSONReader().ReadToValue("\"no closing quote"));
     EXPECT_FALSE(JSONReader().ReadToValue("\"\\z invalid escape char\""));
     EXPECT_FALSE(JSONReader().ReadToValue("\"\\xAQ invalid hex code\""));
@@ skipping 53 matching lines @@
   }
 
   {
     // Valid if we set |allow_trailing_comma| to true.
     std::unique_ptr<ListValue> list = ListValue::From(
         JSONReader::Read("[true,]", JSON_ALLOW_TRAILING_COMMAS));
     ASSERT_TRUE(list);
     EXPECT_EQ(1U, list->GetSize());
     Value* tmp_value = nullptr;
     ASSERT_TRUE(list->Get(0, &tmp_value));
-    EXPECT_TRUE(tmp_value->IsType(Value::TYPE_BOOLEAN));
+    EXPECT_TRUE(tmp_value->IsType(Value::Type::BOOLEAN));
     bool bool_value = false;
     EXPECT_TRUE(tmp_value->GetAsBoolean(&bool_value));
     EXPECT_TRUE(bool_value);
   }
 
   {
     // Don't allow empty elements, even if |allow_trailing_comma| is
     // true.
     EXPECT_FALSE(JSONReader::Read("[,]", JSON_ALLOW_TRAILING_COMMAS));
     EXPECT_FALSE(JSONReader::Read("[true,,]", JSON_ALLOW_TRAILING_COMMAS));
     EXPECT_FALSE(JSONReader::Read("[,true,]", JSON_ALLOW_TRAILING_COMMAS));
     EXPECT_FALSE(JSONReader::Read("[true,,false]", JSON_ALLOW_TRAILING_COMMAS));
   }
 
   {
     // Test objects
     std::unique_ptr<DictionaryValue> dict_val =
         DictionaryValue::From(JSONReader::Read("{}"));
     ASSERT_TRUE(dict_val);
 
     dict_val = DictionaryValue::From(JSONReader::Read(
         "{\"number\":9.87654321, \"null\":null , \"\\x53\" : \"str\" }"));
     ASSERT_TRUE(dict_val);
     double double_val = 0.0;
     EXPECT_TRUE(dict_val->GetDouble("number", &double_val));
     EXPECT_DOUBLE_EQ(9.87654321, double_val);
     Value* null_val = nullptr;
     ASSERT_TRUE(dict_val->Get("null", &null_val));
-    EXPECT_TRUE(null_val->IsType(Value::TYPE_NULL));
+    EXPECT_TRUE(null_val->IsType(Value::Type::NONE));
     std::string str_val;
     EXPECT_TRUE(dict_val->GetString("S", &str_val));
     EXPECT_EQ("str", str_val);
 
     std::unique_ptr<Value> root2 = JSONReader::Read(
         "{\"number\":9.87654321, \"null\":null , \"\\x53\" : \"str\", }",
         JSON_ALLOW_TRAILING_COMMAS);
     ASSERT_TRUE(root2);
     EXPECT_TRUE(dict_val->Equals(root2.get()));
 
@@ skipping 117 matching lines @@
         ListValue::From(JSONReader::Read(not_evil));
     ASSERT_TRUE(list);
     EXPECT_EQ(5001U, list->GetSize());
   }
 
   {
     // Test utf8 encoded input
     std::unique_ptr<Value> root =
         JSONReader().ReadToValue("\"\xe7\xbd\x91\xe9\xa1\xb5\"");
     ASSERT_TRUE(root);
-    EXPECT_TRUE(root->IsType(Value::TYPE_STRING));
+    EXPECT_TRUE(root->IsType(Value::Type::STRING));
     std::string str_val;
     EXPECT_TRUE(root->GetAsString(&str_val));
     EXPECT_EQ(L"\x7f51\x9875", UTF8ToWide(str_val));
 
     std::unique_ptr<DictionaryValue> dict_val =
         DictionaryValue::From(JSONReader().ReadToValue(
             "{\"path\": \"/tmp/\xc3\xa0\xc3\xa8\xc3\xb2.png\"}"));
     ASSERT_TRUE(dict_val);
     EXPECT_TRUE(dict_val->GetString("path", &str_val));
     EXPECT_EQ("/tmp/\xC3\xA0\xC3\xA8\xC3\xB2.png", str_val);
   }
 
   {
     // Test invalid utf8 encoded input
     EXPECT_FALSE(JSONReader().ReadToValue("\"345\xb0\xa1\xb0\xa2\""));
     EXPECT_FALSE(JSONReader().ReadToValue("\"123\xc0\x81\""));
     EXPECT_FALSE(JSONReader().ReadToValue("\"abc\xc0\xae\""));
   }
 
   {
     // Test utf16 encoded strings.
     std::unique_ptr<Value> root = JSONReader().ReadToValue("\"\\u20ac3,14\"");
     ASSERT_TRUE(root);
-    EXPECT_TRUE(root->IsType(Value::TYPE_STRING));
+    EXPECT_TRUE(root->IsType(Value::Type::STRING));
     std::string str_val;
     EXPECT_TRUE(root->GetAsString(&str_val));
     EXPECT_EQ(
         "\xe2\x82\xac"
         "3,14",
         str_val);
 
     root = JSONReader().ReadToValue("\"\\ud83d\\udca9\\ud83d\\udc6c\"");
     ASSERT_TRUE(root);
-    EXPECT_TRUE(root->IsType(Value::TYPE_STRING));
+    EXPECT_TRUE(root->IsType(Value::Type::STRING));
     str_val.clear();
     EXPECT_TRUE(root->GetAsString(&str_val));
     EXPECT_EQ("\xf0\x9f\x92\xa9\xf0\x9f\x91\xac", str_val);
   }
 
   {
     // Test invalid utf16 strings.
     const char* const cases[] = {
         "\"\\u123\"",          // Invalid scalar.
         "\"\\ud83d\"",         // Invalid scalar.
         "\"\\u$%@!\"",         // Invalid scalar.
         "\"\\uzz89\"",         // Invalid scalar.
         "\"\\ud83d\\udca\"",   // Invalid lower surrogate.
         "\"\\ud83d\\ud83d\"",  // Invalid lower surrogate.
         "\"\\ud83foo\"",       // No lower surrogate.
         "\"\\ud83\\foo\""      // No lower surrogate.
     };
     std::unique_ptr<Value> root;
     for (size_t i = 0; i < arraysize(cases); ++i) {
       root = JSONReader().ReadToValue(cases[i]);
       EXPECT_FALSE(root) << cases[i];
     }
   }
 
   {
     // Test literal root objects.
     std::unique_ptr<Value> root = JSONReader::Read("null");
-    EXPECT_TRUE(root->IsType(Value::TYPE_NULL));
+    EXPECT_TRUE(root->IsType(Value::Type::NONE));
 
     root = JSONReader::Read("true");
     ASSERT_TRUE(root);
     bool bool_value;
     EXPECT_TRUE(root->GetAsBoolean(&bool_value));
     EXPECT_TRUE(bool_value);
 
     root = JSONReader::Read("10");
     ASSERT_TRUE(root);
     int integer_value;
@@ skipping 13 matching lines @@
   ASSERT_TRUE(PathService::Get(base::DIR_TEST_DATA, &path));
   path = path.AppendASCII("json");
   ASSERT_TRUE(base::PathExists(path));
 
   std::string input;
   ASSERT_TRUE(ReadFileToString(path.AppendASCII("bom_feff.json"), &input));
 
   JSONReader reader;
   std::unique_ptr<Value> root(reader.ReadToValue(input));
   ASSERT_TRUE(root) << reader.GetErrorMessage();
-  EXPECT_TRUE(root->IsType(Value::TYPE_DICTIONARY));
+  EXPECT_TRUE(root->IsType(Value::Type::DICTIONARY));
 }
 
 // Tests that the root of a JSON object can be deleted safely while its
 // children outlive it.
 TEST(JSONReaderTest, StringOptimizations) {
   std::unique_ptr<Value> dict_literal_0;
   std::unique_ptr<Value> dict_literal_1;
   std::unique_ptr<Value> dict_string_0;
   std::unique_ptr<Value> dict_string_1;
   std::unique_ptr<Value> list_value_0;
@@ skipping 76 matching lines @@
 
 TEST(JSONReaderTest, IllegalTrailingNull) {
   const char json[] = { '"', 'n', 'u', 'l', 'l', '"', '\0' };
   std::string json_string(json, sizeof(json));
   JSONReader reader;
   EXPECT_FALSE(reader.ReadToValue(json_string));
   EXPECT_EQ(JSONReader::JSON_UNEXPECTED_DATA_AFTER_ROOT, reader.error_code());
 }
 
 }  // namespace base