base: Add three helper functions to Values API.

chrome/common/json_schema_validator_unittest_base.cc

 // Copyright (c) 2011 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 "chrome/common/json_schema_validator_unittest_base.h"
 
 #include <cfloat>
 #include <cmath>
 #include <limits>
 
@@ skipping 121 matching lines @@
 void JSONSchemaValidatorTestBase::TestEnum() {
   scoped_ptr<DictionaryValue> schema(LoadDictionary("enum_schema.json"));
 
   ExpectValid(TEST_SOURCE,
               scoped_ptr<Value>(Value::CreateStringValue("foo")).get(),
               schema.get(), NULL);
   ExpectValid(TEST_SOURCE,
               scoped_ptr<Value>(Value::CreateIntegerValue(42)).get(),
               schema.get(), NULL);
   ExpectValid(TEST_SOURCE,
-              scoped_ptr<Value>(Value::CreateBooleanValue(false)).get(),
+              scoped_ptr<Value>(base::FalseValue()).get(),
               schema.get(), NULL);
 
   ExpectNotValid(TEST_SOURCE,
                  scoped_ptr<Value>(Value::CreateStringValue("42")).get(),
                  schema.get(), NULL, "", JSONSchemaValidator::kInvalidEnum);
   ExpectNotValid(TEST_SOURCE,
-                 scoped_ptr<Value>(Value::CreateNullValue()).get(),
+                 scoped_ptr<Value>(base::NullValue()).get(),
                  schema.get(), NULL, "", JSONSchemaValidator::kInvalidEnum);
 }
 
 void JSONSchemaValidatorTestBase::TestChoices() {
   scoped_ptr<DictionaryValue> schema(LoadDictionary("choices_schema.json"));
 
   ExpectValid(TEST_SOURCE,
-              scoped_ptr<Value>(Value::CreateNullValue()).get(),
+              scoped_ptr<Value>(base::NullValue()).get(),
               schema.get(), NULL);
   ExpectValid(TEST_SOURCE,
               scoped_ptr<Value>(Value::CreateIntegerValue(42)).get(),
               schema.get(), NULL);
 
   scoped_ptr<DictionaryValue> instance(new DictionaryValue());
   instance->SetString("foo", "bar");
   ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
 
   ExpectNotValid(TEST_SOURCE,
@@ skipping 61 matching lines @@
   DictionaryValue* properties = NULL;
   DictionaryValue* bar_property = NULL;
   ASSERT_TRUE(schema->GetDictionary("properties", &properties));
   ASSERT_TRUE(properties->GetDictionary("bar", &bar_property));
 
   bar_property->SetBoolean("optional", true);
   instance->Remove("extra", NULL);
   ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
   instance->Remove("bar", NULL);
   ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
-  instance->Set("bar", Value::CreateNullValue());
+  instance->Set("bar", base::NullValue());
   ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL,
                  "bar", JSONSchemaValidator::FormatErrorMessage(
                      JSONSchemaValidator::kInvalidType, "integer", "null"));
   instance->SetString("bar", "42");
   ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL,
                  "bar", JSONSchemaValidator::FormatErrorMessage(
                      JSONSchemaValidator::kInvalidType, "integer", "string"));
 }
 
 void JSONSchemaValidatorTestBase::TestTypeReference() {
@@ skipping 87 matching lines @@
   instance->Set(0, Value::CreateStringValue("42"));
   instance->Append(Value::CreateStringValue("anything"));
   ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
   instance->Set(2, new ListValue());
   ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
 
   additional_properties->SetString("type", "boolean");
   ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "2",
                  JSONSchemaValidator::FormatErrorMessage(
                      JSONSchemaValidator::kInvalidType, "boolean", "array"));
-  instance->Set(2, Value::CreateBooleanValue(false));
+  instance->Set(2, base::FalseValue());
   ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
 
   ListValue* items_schema = NULL;
   DictionaryValue* item0_schema = NULL;
   ASSERT_TRUE(schema->GetList("items", &items_schema));
   ASSERT_TRUE(items_schema->GetDictionary(0, &item0_schema));
   item0_schema->SetBoolean("optional", true);
   instance->Remove(2, NULL);
   ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
   // TODO(aa): I think this is inconsistent with the handling of NULL+optional
   // for objects.
-  instance->Set(0, Value::CreateNullValue());
+  instance->Set(0, base::NullValue());
   ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
   instance->Set(0, Value::CreateIntegerValue(42));
   ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "0",
                  JSONSchemaValidator::FormatErrorMessage(
                      JSONSchemaValidator::kInvalidType, "string", "integer"));
 }
 
 void JSONSchemaValidatorTestBase::TestArrayNonTuple() {
   scoped_ptr<DictionaryValue> schema(new DictionaryValue());
   schema->SetString("type", "array");
@@ skipping 83 matching lines @@
   ExpectNotValid(
       TEST_SOURCE,
       scoped_ptr<Value>(Value::CreateDoubleValue(100.1)).get(),
       schema.get(), NULL, "",
       JSONSchemaValidator::FormatErrorMessage(
           JSONSchemaValidator::kNumberMaximum, "100"));
 }
 
 void JSONSchemaValidatorTestBase::TestTypeClassifier() {
   EXPECT_EQ("boolean", JSONSchemaValidator::GetJSONSchemaType(
-      scoped_ptr<Value>(Value::CreateBooleanValue(true)).get()));
+      scoped_ptr<Value>(base::TrueValue()).get()));
   EXPECT_EQ("boolean", JSONSchemaValidator::GetJSONSchemaType(
-      scoped_ptr<Value>(Value::CreateBooleanValue(false)).get()));
+      scoped_ptr<Value>(base::FalseValue()).get()));
 
   // It doesn't matter whether the C++ type is 'integer' or 'real'. If the
   // number is integral and within the representable range of integers in
   // double, it's classified as 'integer'.
   EXPECT_EQ("integer", JSONSchemaValidator::GetJSONSchemaType(
       scoped_ptr<Value>(Value::CreateIntegerValue(42)).get()));
   EXPECT_EQ("integer", JSONSchemaValidator::GetJSONSchemaType(
       scoped_ptr<Value>(Value::CreateIntegerValue(0)).get()));
   EXPECT_EQ("integer", JSONSchemaValidator::GetJSONSchemaType(
       scoped_ptr<Value>(Value::CreateDoubleValue(42)).get()));
@@ skipping 15 matching lines @@
       scoped_ptr<Value>(Value::CreateDoubleValue(
           pow(-2.0, DBL_MANT_DIG) * 2)).get()));
 
   EXPECT_EQ("string", JSONSchemaValidator::GetJSONSchemaType(
       scoped_ptr<Value>(Value::CreateStringValue("foo")).get()));
   EXPECT_EQ("array", JSONSchemaValidator::GetJSONSchemaType(
       scoped_ptr<Value>(new ListValue()).get()));
   EXPECT_EQ("object", JSONSchemaValidator::GetJSONSchemaType(
       scoped_ptr<Value>(new DictionaryValue()).get()));
   EXPECT_EQ("null", JSONSchemaValidator::GetJSONSchemaType(
-      scoped_ptr<Value>(Value::CreateNullValue()).get()));
+      scoped_ptr<Value>(base::NullValue()).get()));
 }
 
 void JSONSchemaValidatorTestBase::TestTypes() {
   scoped_ptr<DictionaryValue> schema(new DictionaryValue());
 
   // valid
   schema->SetString("type", "object");
   ExpectValid(TEST_SOURCE, scoped_ptr<Value>(new DictionaryValue()).get(),
               schema.get(), NULL);
 
@@ skipping 34 matching lines @@
               scoped_ptr<Value>(
                   Value::CreateDoubleValue(pow(2.0, DBL_MANT_DIG))).get(),
               schema.get(), NULL);
   ExpectValid(TEST_SOURCE,
               scoped_ptr<Value>(
                   Value::CreateDoubleValue(pow(-2.0, DBL_MANT_DIG))).get(),
               schema.get(), NULL);
 
   schema->SetString("type", "boolean");
   ExpectValid(TEST_SOURCE,
-              scoped_ptr<Value>(Value::CreateBooleanValue(false)).get(),
+              scoped_ptr<Value>(base::FalseValue()).get(),
               schema.get(), NULL);
   ExpectValid(TEST_SOURCE,
-              scoped_ptr<Value>(Value::CreateBooleanValue(true)).get(),
+              scoped_ptr<Value>(base::TrueValue()).get(),
               schema.get(), NULL);
 
   schema->SetString("type", "null");
   ExpectValid(TEST_SOURCE,
-              scoped_ptr<Value>(Value::CreateNullValue()).get(),
+              scoped_ptr<Value>(base::NullValue()).get(),
               schema.get(), NULL);
 
   // not valid
   schema->SetString("type", "object");
   ExpectNotValid(TEST_SOURCE, scoped_ptr<Value>(new ListValue()).get(),
                  schema.get(), NULL, "",
                  JSONSchemaValidator::FormatErrorMessage(
                      JSONSchemaValidator::kInvalidType, "object", "array"));
 
   schema->SetString("type", "object");
-  ExpectNotValid(TEST_SOURCE, scoped_ptr<Value>(Value::CreateNullValue()).get(),
+  ExpectNotValid(TEST_SOURCE, scoped_ptr<Value>(base::NullValue()).get(),
                  schema.get(), NULL, "",
                  JSONSchemaValidator::FormatErrorMessage(
                      JSONSchemaValidator::kInvalidType, "object", "null"));
 
   schema->SetString("type", "array");
   ExpectNotValid(TEST_SOURCE,
                  scoped_ptr<Value>(Value::CreateIntegerValue(42)).get(),
                  schema.get(), NULL, "",
                  JSONSchemaValidator::FormatErrorMessage(
                      JSONSchemaValidator::kInvalidType, "array", "integer"));
@@ skipping 28 matching lines @@
 
   schema->SetString("type", "boolean");
   ExpectNotValid(TEST_SOURCE,
                  scoped_ptr<Value>(Value::CreateIntegerValue(1)).get(),
                  schema.get(), NULL, "",
                  JSONSchemaValidator::FormatErrorMessage(
                      JSONSchemaValidator::kInvalidType, "boolean", "integer"));
 
   schema->SetString("type", "null");
   ExpectNotValid(TEST_SOURCE,
-                 scoped_ptr<Value>(Value::CreateBooleanValue(false)).get(),
+                 scoped_ptr<Value>(base::FalseValue()).get(),
                  schema.get(), NULL, "",
                  JSONSchemaValidator::FormatErrorMessage(
                      JSONSchemaValidator::kInvalidType, "null", "boolean"));
 }