DevTools: explicitly differentiate ints vs doubles in the protocol bindings.

third_party/WebKit/Source/platform/inspector_protocol/ParserTest.cpp

 // Copyright (c) 2016 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 "platform/inspector_protocol/Parser.h"
 
 #include "platform/inspector_protocol/String16.h"
 #include "platform/inspector_protocol/Values.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 23 matching lines @@
     EXPECT_EQ(Value::TypeBoolean, root->type());
 
     // Embedded comment
     root = parseJSON("40 /*/");
     EXPECT_FALSE(root.get());
     root = parseJSON("/* comment */null");
     ASSERT_TRUE(root.get());
     EXPECT_EQ(Value::TypeNull, root->type());
     root = parseJSON("40 /* comment */");
     ASSERT_TRUE(root.get());
-    EXPECT_EQ(Value::TypeNumber, root->type());
-    EXPECT_TRUE(root->asNumber(&intVal));
+    EXPECT_EQ(Value::TypeInteger, root->type());
+    EXPECT_TRUE(root->asInteger(&intVal));
     EXPECT_EQ(40, intVal);
     root = parseJSON("/**/ 40 /* multi-line\n comment */ // more comment");
     ASSERT_TRUE(root.get());
-    EXPECT_EQ(Value::TypeNumber, root->type());
-    EXPECT_TRUE(root->asNumber(&intVal));
+    EXPECT_EQ(Value::TypeInteger, root->type());
+    EXPECT_TRUE(root->asInteger(&intVal));
     EXPECT_EQ(40, intVal);
     root = parseJSON("true // comment");
     ASSERT_TRUE(root.get());
     EXPECT_EQ(Value::TypeBoolean, root->type());
     root = parseJSON("/* comment */\"sample string\"");
     ASSERT_TRUE(root.get());
     EXPECT_TRUE(root->asString(&strVal));
     EXPECT_EQ("sample string", strVal);
     root = parseJSON("[1, /* comment, 2 ] */ \n 3]");
     ASSERT_TRUE(root.get());
     protocol::ListValue* list = ListValue::cast(root.get());
     ASSERT_TRUE(list);
     EXPECT_EQ(2u, list->size());
     tmpValue = list->at(0);
     ASSERT_TRUE(tmpValue);
-    EXPECT_TRUE(tmpValue->asNumber(&intVal));
+    EXPECT_TRUE(tmpValue->asInteger(&intVal));
     EXPECT_EQ(1, intVal);
     tmpValue = list->at(1);
     ASSERT_TRUE(tmpValue);
-    EXPECT_TRUE(tmpValue->asNumber(&intVal));
+    EXPECT_TRUE(tmpValue->asInteger(&intVal));
     EXPECT_EQ(3, intVal);
     root = parseJSON("[1, /*a*/2, 3]");
     ASSERT_TRUE(root.get());
     list = ListValue::cast(root.get());
     ASSERT_TRUE(list);
     EXPECT_EQ(3u, list->size());
     root = parseJSON("/* comment **/42");
     ASSERT_TRUE(root.get());
-    EXPECT_EQ(Value::TypeNumber, root->type());
-    EXPECT_TRUE(root->asNumber(&intVal));
+    EXPECT_EQ(Value::TypeInteger, root->type());
+    EXPECT_TRUE(root->asInteger(&intVal));
     EXPECT_EQ(42, intVal);
     root = parseJSON(
         "/* comment **/\n"
         "// */ 43\n"
         "44");
     ASSERT_TRUE(root.get());
-    EXPECT_EQ(Value::TypeNumber, root->type());
-    EXPECT_TRUE(root->asNumber(&intVal));
+    EXPECT_EQ(Value::TypeInteger, root->type());
+    EXPECT_TRUE(root->asInteger(&intVal));
     EXPECT_EQ(44, intVal);
 
     // Test number formats
     root = parseJSON("43");
     ASSERT_TRUE(root.get());
-    EXPECT_EQ(Value::TypeNumber, root->type());
-    EXPECT_TRUE(root->asNumber(&intVal));
+    EXPECT_EQ(Value::TypeInteger, root->type());
+    EXPECT_TRUE(root->asInteger(&intVal));
     EXPECT_EQ(43, intVal);
 
     // According to RFC4627, oct, hex, and leading zeros are invalid JSON.
     root = parseJSON("043");
     EXPECT_FALSE(root.get());
     root = parseJSON("0x43");
     EXPECT_FALSE(root.get());
     root = parseJSON("00");
     EXPECT_FALSE(root.get());
 
     // Test 0 (which needs to be special cased because of the leading zero
     // clause).
     root = parseJSON("0");
     ASSERT_TRUE(root.get());
-    EXPECT_EQ(Value::TypeNumber, root->type());
+    EXPECT_EQ(Value::TypeInteger, root->type());
     intVal = 1;
-    EXPECT_TRUE(root->asNumber(&intVal));
+    EXPECT_TRUE(root->asInteger(&intVal));
     EXPECT_EQ(0, intVal);
 
     // Numbers that overflow ints should succeed, being internally promoted to
     // storage as doubles
     root = parseJSON("2147483648");
     ASSERT_TRUE(root.get());
     double doubleVal;
-    EXPECT_EQ(Value::TypeNumber, root->type());
+    EXPECT_EQ(Value::TypeDouble, root->type());
     doubleVal = 0.0;
-    EXPECT_TRUE(root->asNumber(&doubleVal));
+    EXPECT_TRUE(root->asDouble(&doubleVal));
     EXPECT_DOUBLE_EQ(2147483648.0, doubleVal);
     root = parseJSON("-2147483649");
     ASSERT_TRUE(root.get());
-    EXPECT_EQ(Value::TypeNumber, root->type());
+    EXPECT_EQ(Value::TypeDouble, root->type());
     doubleVal = 0.0;
-    EXPECT_TRUE(root->asNumber(&doubleVal));
+    EXPECT_TRUE(root->asDouble(&doubleVal));
     EXPECT_DOUBLE_EQ(-2147483649.0, doubleVal);
 
     // Parse a double
     root = parseJSON("43.1");
     ASSERT_TRUE(root.get());
-    EXPECT_EQ(Value::TypeNumber, root->type());
+    EXPECT_EQ(Value::TypeDouble, root->type());
     doubleVal = 0.0;
-    EXPECT_TRUE(root->asNumber(&doubleVal));
+    EXPECT_TRUE(root->asDouble(&doubleVal));
     EXPECT_DOUBLE_EQ(43.1, doubleVal);
 
     root = parseJSON("4.3e-1");
     ASSERT_TRUE(root.get());
-    EXPECT_EQ(Value::TypeNumber, root->type());
+    EXPECT_EQ(Value::TypeDouble, root->type());
     doubleVal = 0.0;
-    EXPECT_TRUE(root->asNumber(&doubleVal));
+    EXPECT_TRUE(root->asDouble(&doubleVal));
     EXPECT_DOUBLE_EQ(.43, doubleVal);
 
     root = parseJSON("2.1e0");
     ASSERT_TRUE(root.get());
-    EXPECT_EQ(Value::TypeNumber, root->type());
+    EXPECT_EQ(Value::TypeDouble, root->type());
     doubleVal = 0.0;
-    EXPECT_TRUE(root->asNumber(&doubleVal));
+    EXPECT_TRUE(root->asDouble(&doubleVal));
     EXPECT_DOUBLE_EQ(2.1, doubleVal);
 
     root = parseJSON("2.1e+0001");
     ASSERT_TRUE(root.get());
-    EXPECT_EQ(Value::TypeNumber, root->type());
+    EXPECT_EQ(Value::TypeInteger, root->type());
     doubleVal = 0.0;
-    EXPECT_TRUE(root->asNumber(&doubleVal));
+    EXPECT_TRUE(root->asDouble(&doubleVal));
     EXPECT_DOUBLE_EQ(21.0, doubleVal);
 
     root = parseJSON("0.01");
     ASSERT_TRUE(root.get());
-    EXPECT_EQ(Value::TypeNumber, root->type());
+    EXPECT_EQ(Value::TypeDouble, root->type());
     doubleVal = 0.0;
-    EXPECT_TRUE(root->asNumber(&doubleVal));
+    EXPECT_TRUE(root->asDouble(&doubleVal));
     EXPECT_DOUBLE_EQ(0.01, doubleVal);
 
     root = parseJSON("1.00");
     ASSERT_TRUE(root.get());
-    EXPECT_EQ(Value::TypeNumber, root->type());
+    EXPECT_EQ(Value::TypeInteger, root->type());
     doubleVal = 0.0;
-    EXPECT_TRUE(root->asNumber(&doubleVal));
+    EXPECT_TRUE(root->asDouble(&doubleVal));
     EXPECT_DOUBLE_EQ(1.0, doubleVal);
 
     // Fractional parts must have a digit before and after the decimal point.
     root = parseJSON("1.");
     EXPECT_FALSE(root.get());
     root = parseJSON(".1");
     EXPECT_FALSE(root.get());
     root = parseJSON("1.e10");
     EXPECT_FALSE(root.get());
 
@@ skipping 123 matching lines @@
     root = parseJSON("{}");
     ASSERT_TRUE(root.get());
     EXPECT_EQ(Value::TypeObject, root->type());
 
     root = parseJSON("{\"number\":9.87654321, \"null\":null , \"S\" : \"str\" }");
     ASSERT_TRUE(root.get());
     EXPECT_EQ(Value::TypeObject, root->type());
     protocol::DictionaryValue* objectVal = DictionaryValue::cast(root.get());
     ASSERT_TRUE(objectVal);
     doubleVal = 0.0;
-    EXPECT_TRUE(objectVal->getNumber("number", &doubleVal));
+    EXPECT_TRUE(objectVal->getDouble("number", &doubleVal));
     EXPECT_DOUBLE_EQ(9.87654321, doubleVal);
     protocol::Value* nullVal = objectVal->get("null");
     ASSERT_TRUE(nullVal);
     EXPECT_EQ(Value::TypeNull, nullVal->type());
     EXPECT_TRUE(objectVal->getString("S", &strVal));
     EXPECT_EQ("str", strVal);
 
     // Test newline equivalence.
     root2 = parseJSON(
         "{\n"
@@ skipping 30 matching lines @@
     innerObject = objectVal->getObject("d");
     EXPECT_TRUE(innerObject);
 
     // Test keys with periods
     root = parseJSON("{\"a.b\":3,\"c\":2,\"d.e.f\":{\"g.h.i.j\":1}}");
     ASSERT_TRUE(root.get());
     EXPECT_EQ(Value::TypeObject, root->type());
     objectVal = DictionaryValue::cast(root.get());
     ASSERT_TRUE(objectVal);
     int integerValue = 0;
-    EXPECT_TRUE(objectVal->getNumber("a.b", &integerValue));
+    EXPECT_TRUE(objectVal->getInteger("a.b", &integerValue));
     EXPECT_EQ(3, integerValue);
-    EXPECT_TRUE(objectVal->getNumber("c", &integerValue));
+    EXPECT_TRUE(objectVal->getInteger("c", &integerValue));
     EXPECT_EQ(2, integerValue);
     innerObject = objectVal->getObject("d.e.f");
     ASSERT_TRUE(innerObject);
     EXPECT_EQ(1U, innerObject->size());
-    EXPECT_TRUE(innerObject->getNumber("g.h.i.j", &integerValue));
+    EXPECT_TRUE(innerObject->getInteger("g.h.i.j", &integerValue));
     EXPECT_EQ(1, integerValue);
 
     root = parseJSON("{\"a\":{\"b\":2},\"a.b\":1}");
     ASSERT_TRUE(root.get());
     EXPECT_EQ(Value::TypeObject, root->type());
     objectVal = DictionaryValue::cast(root.get());
     ASSERT_TRUE(objectVal);
     innerObject = objectVal->getObject("a");
     ASSERT_TRUE(innerObject);
-    EXPECT_TRUE(innerObject->getNumber("b", &integerValue));
+    EXPECT_TRUE(innerObject->getInteger("b", &integerValue));
     EXPECT_EQ(2, integerValue);
-    EXPECT_TRUE(objectVal->getNumber("a.b", &integerValue));
+    EXPECT_TRUE(objectVal->getInteger("a.b", &integerValue));
     EXPECT_EQ(1, integerValue);
 
     // Invalid, no closing brace
     root = parseJSON("{\"a\": true");
     EXPECT_FALSE(root.get());
 
     // Invalid, keys must be quoted
     root = parseJSON("{foo:true}");
     EXPECT_FALSE(root.get());
 
@@ skipping 66 matching lines @@
     root = parseJSON("null");
     EXPECT_EQ(Value::TypeNull, root->type());
 
     root = parseJSON("true");
     ASSERT_TRUE(root.get());
     EXPECT_TRUE(root->asBoolean(&boolValue));
     EXPECT_TRUE(boolValue);
 
     root = parseJSON("10");
     ASSERT_TRUE(root.get());
-    EXPECT_TRUE(root->asNumber(&integerValue));
+    EXPECT_TRUE(root->asInteger(&integerValue));
     EXPECT_EQ(10, integerValue);
 
     root = parseJSON("\"root\"");
     ASSERT_TRUE(root.get());
     EXPECT_TRUE(root->asString(&strVal));
     EXPECT_EQ("root", strVal);
 }
 
 TEST(ParserTest, InvalidSanity)
 {
@@ skipping 12 matching lines @@
     };
 
     for (size_t i = 0; i < 11; ++i) {
         std::unique_ptr<protocol::Value> result = parseJSON(invalidJson[i]);
         EXPECT_FALSE(result.get());
     }
 }
 
 } // namespace protocol
 } // namespace blink