diff options
| author | avi@chromium.org <avi@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> | 2013-12-24 15:31:21 +0000 |
|---|---|---|
| committer | avi@chromium.org <avi@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> | 2013-12-24 15:31:21 +0000 |
| commit | a644f1e204545af25d94225f7806a12a2b8f0b5d (patch) | |
| tree | 36ad7037e0171ac0648d84e1ac551e70ab93e34f /tools | |
| parent | e35005d00a8cb7b6842bcb328c37cf033bf920a5 (diff) | |
| download | chromium_src-a644f1e204545af25d94225f7806a12a2b8f0b5d.zip chromium_src-a644f1e204545af25d94225f7806a12a2b8f0b5d.tar.gz chromium_src-a644f1e204545af25d94225f7806a12a2b8f0b5d.tar.bz2 | |
Remove the Value class names from the global namespace.
BUG=88666
TEST=no change
TBR=ben@chromium.org
Review URL: https://codereview.chromium.org/116543010
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@242440 0039d316-1c4b-4281-b951-d872f2087c98
Diffstat (limited to 'tools')
15 files changed, 358 insertions, 333 deletions
diff --git a/tools/json_schema_compiler/test/additional_properties_unittest.cc b/tools/json_schema_compiler/test/additional_properties_unittest.cc index 5e08d5e..ac0a0f2 100644 --- a/tools/json_schema_compiler/test/additional_properties_unittest.cc +++ b/tools/json_schema_compiler/test/additional_properties_unittest.cc @@ -10,10 +10,10 @@ using namespace test::api::additional_properties; TEST(JsonSchemaCompilerAdditionalPropertiesTest, AdditionalPropertiesTypePopulate) { { - scoped_ptr<ListValue> list_value(new ListValue()); - list_value->Append(Value::CreateStringValue("asdf")); - list_value->Append(Value::CreateIntegerValue(4)); - scoped_ptr<DictionaryValue> type_value(new DictionaryValue()); + scoped_ptr<base::ListValue> list_value(new base::ListValue()); + list_value->Append(base::Value::CreateStringValue("asdf")); + list_value->Append(base::Value::CreateIntegerValue(4)); + scoped_ptr<base::DictionaryValue> type_value(new base::DictionaryValue()); type_value->SetString("string", "value"); type_value->SetInteger("other", 9); type_value->Set("another", list_value.release()); @@ -22,7 +22,7 @@ TEST(JsonSchemaCompilerAdditionalPropertiesTest, EXPECT_TRUE(type->additional_properties.Equals(type_value.get())); } { - scoped_ptr<DictionaryValue> type_value(new DictionaryValue()); + scoped_ptr<base::DictionaryValue> type_value(new base::DictionaryValue()); type_value->SetInteger("string", 3); scoped_ptr<AdditionalPropertiesType> type(new AdditionalPropertiesType()); EXPECT_FALSE(AdditionalPropertiesType::Populate(*type_value, type.get())); @@ -31,10 +31,11 @@ TEST(JsonSchemaCompilerAdditionalPropertiesTest, TEST(JsonSchemaCompilerAdditionalPropertiesTest, AdditionalPropertiesParamsCreate) { - scoped_ptr<DictionaryValue> param_object_value(new DictionaryValue()); + scoped_ptr<base::DictionaryValue> param_object_value( + new base::DictionaryValue()); param_object_value->SetString("str", "a"); param_object_value->SetInteger("num", 1); - scoped_ptr<ListValue> params_value(new ListValue()); + scoped_ptr<base::ListValue> params_value(new base::ListValue()); params_value->Append(param_object_value->DeepCopy()); scoped_ptr<AdditionalProperties::Params> params( AdditionalProperties::Params::Create(*params_value)); @@ -49,15 +50,15 @@ TEST(JsonSchemaCompilerAdditionalPropertiesTest, result_object.integer = 5; result_object.additional_properties["key"] = "value"; - ListValue expected; + base::ListValue expected; { - DictionaryValue* dict = new DictionaryValue(); + base::DictionaryValue* dict = new base::DictionaryValue(); dict->SetInteger("integer", 5); dict->SetString("key", "value"); expected.Append(dict); } - EXPECT_TRUE(Value::Equals( + EXPECT_TRUE(base::Value::Equals( ReturnAdditionalProperties::Results::Create(result_object).get(), &expected)); } diff --git a/tools/json_schema_compiler/test/any_unittest.cc b/tools/json_schema_compiler/test/any_unittest.cc index 81fd681..7e3215f 100644 --- a/tools/json_schema_compiler/test/any_unittest.cc +++ b/tools/json_schema_compiler/test/any_unittest.cc @@ -10,33 +10,35 @@ using namespace test::api::any; TEST(JsonSchemaCompilerAnyTest, AnyTypePopulate) { { AnyType any_type; - scoped_ptr<DictionaryValue> any_type_value(new DictionaryValue()); + scoped_ptr<base::DictionaryValue> any_type_value( + new base::DictionaryValue()); any_type_value->SetString("any", "value"); EXPECT_TRUE(AnyType::Populate(*any_type_value, &any_type)); - scoped_ptr<Value> any_type_to_value(any_type.ToValue()); + scoped_ptr<base::Value> any_type_to_value(any_type.ToValue()); EXPECT_TRUE(any_type_value->Equals(any_type_to_value.get())); } { AnyType any_type; - scoped_ptr<DictionaryValue> any_type_value(new DictionaryValue()); + scoped_ptr<base::DictionaryValue> any_type_value( + new base::DictionaryValue()); any_type_value->SetInteger("any", 5); EXPECT_TRUE(AnyType::Populate(*any_type_value, &any_type)); - scoped_ptr<Value> any_type_to_value(any_type.ToValue()); + scoped_ptr<base::Value> any_type_to_value(any_type.ToValue()); EXPECT_TRUE(any_type_value->Equals(any_type_to_value.get())); } } TEST(JsonSchemaCompilerAnyTest, OptionalAnyParamsCreate) { { - scoped_ptr<ListValue> params_value(new ListValue()); + scoped_ptr<base::ListValue> params_value(new base::ListValue()); scoped_ptr<OptionalAny::Params> params( OptionalAny::Params::Create(*params_value)); EXPECT_TRUE(params.get()); EXPECT_FALSE(params->any_name.get()); } { - scoped_ptr<ListValue> params_value(new ListValue()); - scoped_ptr<Value> param(Value::CreateStringValue("asdf")); + scoped_ptr<base::ListValue> params_value(new base::ListValue()); + scoped_ptr<base::Value> param(base::Value::CreateStringValue("asdf")); params_value->Append(param->DeepCopy()); scoped_ptr<OptionalAny::Params> params( OptionalAny::Params::Create(*params_value)); @@ -45,8 +47,8 @@ TEST(JsonSchemaCompilerAnyTest, OptionalAnyParamsCreate) { EXPECT_TRUE(params->any_name->Equals(param.get())); } { - scoped_ptr<ListValue> params_value(new ListValue()); - scoped_ptr<Value> param(Value::CreateBooleanValue(true)); + scoped_ptr<base::ListValue> params_value(new base::ListValue()); + scoped_ptr<base::Value> param(base::Value::CreateBooleanValue(true)); params_value->Append(param->DeepCopy()); scoped_ptr<OptionalAny::Params> params( OptionalAny::Params::Create(*params_value)); diff --git a/tools/json_schema_compiler/test/arrays_unittest.cc b/tools/json_schema_compiler/test/arrays_unittest.cc index e480c8e..f3fb058 100644 --- a/tools/json_schema_compiler/test/arrays_unittest.cc +++ b/tools/json_schema_compiler/test/arrays_unittest.cc @@ -11,32 +11,32 @@ using namespace test::api::arrays; namespace { // TODO(calamity): Change to AppendString etc once kalman's patch goes through -static scoped_ptr<DictionaryValue> CreateBasicArrayTypeDictionary() { - DictionaryValue* value = new DictionaryValue(); - ListValue* strings_value = new ListValue(); - strings_value->Append(Value::CreateStringValue("a")); - strings_value->Append(Value::CreateStringValue("b")); - strings_value->Append(Value::CreateStringValue("c")); - strings_value->Append(Value::CreateStringValue("it's easy as")); - ListValue* integers_value = new ListValue(); - integers_value->Append(Value::CreateIntegerValue(1)); - integers_value->Append(Value::CreateIntegerValue(2)); - integers_value->Append(Value::CreateIntegerValue(3)); - ListValue* booleans_value = new ListValue(); - booleans_value->Append(Value::CreateBooleanValue(false)); - booleans_value->Append(Value::CreateBooleanValue(true)); - ListValue* numbers_value = new ListValue(); - numbers_value->Append(Value::CreateDoubleValue(6.1)); +static scoped_ptr<base::DictionaryValue> CreateBasicArrayTypeDictionary() { + base::DictionaryValue* value = new base::DictionaryValue(); + base::ListValue* strings_value = new base::ListValue(); + strings_value->Append(base::Value::CreateStringValue("a")); + strings_value->Append(base::Value::CreateStringValue("b")); + strings_value->Append(base::Value::CreateStringValue("c")); + strings_value->Append(base::Value::CreateStringValue("it's easy as")); + base::ListValue* integers_value = new base::ListValue(); + integers_value->Append(base::Value::CreateIntegerValue(1)); + integers_value->Append(base::Value::CreateIntegerValue(2)); + integers_value->Append(base::Value::CreateIntegerValue(3)); + base::ListValue* booleans_value = new base::ListValue(); + booleans_value->Append(base::Value::CreateBooleanValue(false)); + booleans_value->Append(base::Value::CreateBooleanValue(true)); + base::ListValue* numbers_value = new base::ListValue(); + numbers_value->Append(base::Value::CreateDoubleValue(6.1)); value->Set("numbers", numbers_value); value->Set("booleans", booleans_value); value->Set("strings", strings_value); value->Set("integers", integers_value); - return scoped_ptr<DictionaryValue>(value); + return scoped_ptr<base::DictionaryValue>(value); } -static Value* CreateItemValue(int val) { - DictionaryValue* value(new DictionaryValue()); - value->Set("val", Value::CreateIntegerValue(val)); +static base::Value* CreateItemValue(int val) { + base::DictionaryValue* value(new base::DictionaryValue()); + value->Set("val", base::Value::CreateIntegerValue(val)); return value; } @@ -44,7 +44,7 @@ static Value* CreateItemValue(int val) { TEST(JsonSchemaCompilerArrayTest, BasicArrayType) { { - scoped_ptr<DictionaryValue> value = CreateBasicArrayTypeDictionary(); + scoped_ptr<base::DictionaryValue> value = CreateBasicArrayTypeDictionary(); scoped_ptr<BasicArrayType> basic_array_type(new BasicArrayType()); ASSERT_TRUE(BasicArrayType::Populate(*value, basic_array_type.get())); EXPECT_TRUE(value->Equals(basic_array_type->ToValue().get())); @@ -57,11 +57,11 @@ TEST(JsonSchemaCompilerArrayTest, EnumArrayType) { enums.push_back(EnumArrayType::TYPES_TYPE_TWO); enums.push_back(EnumArrayType::TYPES_TYPE_THREE); - scoped_ptr<ListValue> types(new ListValue()); + scoped_ptr<base::ListValue> types(new base::ListValue()); for (size_t i = 0; i < enums.size(); ++i) types->Append(new base::StringValue(EnumArrayType::ToString(enums[i]))); - DictionaryValue value; + base::DictionaryValue value; value.Set("types", types.release()); EnumArrayType enum_array_type; @@ -76,13 +76,13 @@ TEST(JsonSchemaCompilerArrayTest, OptionalEnumArrayType) { enums.push_back(OptionalEnumArrayType::TYPES_TYPE_TWO); enums.push_back(OptionalEnumArrayType::TYPES_TYPE_THREE); - scoped_ptr<ListValue> types(new ListValue()); + scoped_ptr<base::ListValue> types(new base::ListValue()); for (size_t i = 0; i < enums.size(); ++i) { types->Append(new base::StringValue( OptionalEnumArrayType::ToString(enums[i]))); } - DictionaryValue value; + base::DictionaryValue value; value.Set("types", types.release()); OptionalEnumArrayType enum_array_type; @@ -90,9 +90,9 @@ TEST(JsonSchemaCompilerArrayTest, OptionalEnumArrayType) { EXPECT_EQ(enums, *enum_array_type.types); } { - DictionaryValue value; - scoped_ptr<ListValue> enum_array(new ListValue()); - enum_array->Append(Value::CreateStringValue("invalid")); + base::DictionaryValue value; + scoped_ptr<base::ListValue> enum_array(new base::ListValue()); + enum_array->Append(base::Value::CreateStringValue("invalid")); value.Set("types", enum_array.release()); OptionalEnumArrayType enum_array_type; @@ -103,8 +103,8 @@ TEST(JsonSchemaCompilerArrayTest, OptionalEnumArrayType) { TEST(JsonSchemaCompilerArrayTest, RefArrayType) { { - scoped_ptr<DictionaryValue> value(new DictionaryValue()); - scoped_ptr<ListValue> ref_array(new ListValue()); + scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue()); + scoped_ptr<base::ListValue> ref_array(new base::ListValue()); ref_array->Append(CreateItemValue(1)); ref_array->Append(CreateItemValue(2)); ref_array->Append(CreateItemValue(3)); @@ -117,10 +117,10 @@ TEST(JsonSchemaCompilerArrayTest, RefArrayType) { EXPECT_EQ(3, ref_array_type->refs[2]->val); } { - scoped_ptr<DictionaryValue> value(new DictionaryValue()); - scoped_ptr<ListValue> not_ref_array(new ListValue()); + scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue()); + scoped_ptr<base::ListValue> not_ref_array(new base::ListValue()); not_ref_array->Append(CreateItemValue(1)); - not_ref_array->Append(Value::CreateIntegerValue(3)); + not_ref_array->Append(base::Value::CreateIntegerValue(3)); value->Set("refs", not_ref_array.release()); scoped_ptr<RefArrayType> ref_array_type(new RefArrayType()); EXPECT_FALSE(RefArrayType::Populate(*value, ref_array_type.get())); @@ -128,11 +128,11 @@ TEST(JsonSchemaCompilerArrayTest, RefArrayType) { } TEST(JsonSchemaCompilerArrayTest, IntegerArrayParamsCreate) { - scoped_ptr<ListValue> params_value(new ListValue()); - scoped_ptr<ListValue> integer_array(new ListValue()); - integer_array->Append(Value::CreateIntegerValue(2)); - integer_array->Append(Value::CreateIntegerValue(4)); - integer_array->Append(Value::CreateIntegerValue(8)); + scoped_ptr<base::ListValue> params_value(new base::ListValue()); + scoped_ptr<base::ListValue> integer_array(new base::ListValue()); + integer_array->Append(base::Value::CreateIntegerValue(2)); + integer_array->Append(base::Value::CreateIntegerValue(4)); + integer_array->Append(base::Value::CreateIntegerValue(8)); params_value->Append(integer_array.release()); scoped_ptr<IntegerArray::Params> params( IntegerArray::Params::Create(*params_value)); @@ -144,10 +144,10 @@ TEST(JsonSchemaCompilerArrayTest, IntegerArrayParamsCreate) { } TEST(JsonSchemaCompilerArrayTest, AnyArrayParamsCreate) { - scoped_ptr<ListValue> params_value(new ListValue()); - scoped_ptr<ListValue> any_array(new ListValue()); - any_array->Append(Value::CreateIntegerValue(1)); - any_array->Append(Value::CreateStringValue("test")); + scoped_ptr<base::ListValue> params_value(new base::ListValue()); + scoped_ptr<base::ListValue> any_array(new base::ListValue()); + any_array->Append(base::Value::CreateIntegerValue(1)); + any_array->Append(base::Value::CreateStringValue("test")); any_array->Append(CreateItemValue(2)); params_value->Append(any_array.release()); scoped_ptr<AnyArray::Params> params( @@ -160,8 +160,8 @@ TEST(JsonSchemaCompilerArrayTest, AnyArrayParamsCreate) { } TEST(JsonSchemaCompilerArrayTest, ObjectArrayParamsCreate) { - scoped_ptr<ListValue> params_value(new ListValue()); - scoped_ptr<ListValue> item_array(new ListValue()); + scoped_ptr<base::ListValue> params_value(new base::ListValue()); + scoped_ptr<base::ListValue> item_array(new base::ListValue()); item_array->Append(CreateItemValue(1)); item_array->Append(CreateItemValue(2)); params_value->Append(item_array.release()); @@ -174,8 +174,8 @@ TEST(JsonSchemaCompilerArrayTest, ObjectArrayParamsCreate) { } TEST(JsonSchemaCompilerArrayTest, RefArrayParamsCreate) { - scoped_ptr<ListValue> params_value(new ListValue()); - scoped_ptr<ListValue> item_array(new ListValue()); + scoped_ptr<base::ListValue> params_value(new base::ListValue()); + scoped_ptr<base::ListValue> item_array(new base::ListValue()); item_array->Append(CreateItemValue(1)); item_array->Append(CreateItemValue(2)); params_value->Append(item_array.release()); @@ -191,12 +191,13 @@ TEST(JsonSchemaCompilerArrayTest, ReturnIntegerArrayResultCreate) { std::vector<int> integers; integers.push_back(1); integers.push_back(2); - scoped_ptr<ListValue> results = ReturnIntegerArray::Results::Create(integers); + scoped_ptr<base::ListValue> results = + ReturnIntegerArray::Results::Create(integers); - ListValue expected; - ListValue* expected_argument = new ListValue(); - expected_argument->Append(Value::CreateIntegerValue(1)); - expected_argument->Append(Value::CreateIntegerValue(2)); + base::ListValue expected; + base::ListValue* expected_argument = new base::ListValue(); + expected_argument->Append(base::Value::CreateIntegerValue(1)); + expected_argument->Append(base::Value::CreateIntegerValue(2)); expected.Append(expected_argument); EXPECT_TRUE(results->Equals(&expected)); } @@ -207,14 +208,15 @@ TEST(JsonSchemaCompilerArrayTest, ReturnRefArrayResultCreate) { items.push_back(linked_ptr<Item>(new Item())); items[0]->val = 1; items[1]->val = 2; - scoped_ptr<ListValue> results = ReturnRefArray::Results::Create(items); + scoped_ptr<base::ListValue> results = + ReturnRefArray::Results::Create(items); - ListValue expected; - ListValue* expected_argument = new ListValue(); - DictionaryValue* first = new DictionaryValue(); + base::ListValue expected; + base::ListValue* expected_argument = new base::ListValue(); + base::DictionaryValue* first = new base::DictionaryValue(); first->SetInteger("val", 1); expected_argument->Append(first); - DictionaryValue* second = new DictionaryValue(); + base::DictionaryValue* second = new base::DictionaryValue(); second->SetInteger("val", 2); expected_argument->Append(second); expected.Append(expected_argument); diff --git a/tools/json_schema_compiler/test/callbacks_unittest.cc b/tools/json_schema_compiler/test/callbacks_unittest.cc index 163a6c0..e69289e 100644 --- a/tools/json_schema_compiler/test/callbacks_unittest.cc +++ b/tools/json_schema_compiler/test/callbacks_unittest.cc @@ -11,11 +11,12 @@ using namespace test::api::callbacks; TEST(JsonSchemaCompilerCallbacksTest, ReturnsObjectResultCreate) { ReturnsObject::Results::SomeObject some_object; some_object.state = ReturnsObject::Results::SomeObject::STATE_FOO; - scoped_ptr<ListValue> results = ReturnsObject::Results::Create(some_object); + scoped_ptr<base::ListValue> results = + ReturnsObject::Results::Create(some_object); - DictionaryValue* expected_dict = new DictionaryValue(); + base::DictionaryValue* expected_dict = new base::DictionaryValue(); expected_dict->SetString("state", "foo"); - ListValue expected; + base::ListValue expected; expected.Append(expected_dict); EXPECT_TRUE(results->Equals(&expected)); } @@ -23,13 +24,13 @@ TEST(JsonSchemaCompilerCallbacksTest, ReturnsObjectResultCreate) { TEST(JsonSchemaCompilerCallbacksTest, ReturnsMultipleResultCreate) { ReturnsMultiple::Results::SomeObject some_object; some_object.state = ReturnsMultiple::Results::SomeObject::STATE_FOO; - scoped_ptr<ListValue> results = + scoped_ptr<base::ListValue> results = ReturnsMultiple::Results::Create(5, some_object); - DictionaryValue* expected_dict = new DictionaryValue(); + base::DictionaryValue* expected_dict = new base::DictionaryValue(); expected_dict->SetString("state", "foo"); - ListValue expected; - expected.Append(Value::CreateIntegerValue(5)); + base::ListValue expected; + expected.Append(base::Value::CreateIntegerValue(5)); expected.Append(expected_dict); EXPECT_TRUE(results->Equals(&expected)); } diff --git a/tools/json_schema_compiler/test/choices_unittest.cc b/tools/json_schema_compiler/test/choices_unittest.cc index fec9c88..5be117c3 100644 --- a/tools/json_schema_compiler/test/choices_unittest.cc +++ b/tools/json_schema_compiler/test/choices_unittest.cc @@ -19,21 +19,21 @@ using json_schema_compiler::test_util::Vector; TEST(JsonSchemaCompilerChoicesTest, TakesIntegersParamsCreate) { { scoped_ptr<TakesIntegers::Params> params(TakesIntegers::Params::Create( - *List(Value::CreateBooleanValue(true)))); + *List(base::Value::CreateBooleanValue(true)))); EXPECT_FALSE(params); } { scoped_ptr<TakesIntegers::Params> params(TakesIntegers::Params::Create( - *List(Value::CreateIntegerValue(6)))); + *List(base::Value::CreateIntegerValue(6)))); ASSERT_TRUE(params); EXPECT_FALSE(params->nums.as_integers); EXPECT_EQ(6, *params->nums.as_integer); } { scoped_ptr<TakesIntegers::Params> params(TakesIntegers::Params::Create( - *List(List(Value::CreateIntegerValue(2), - Value::CreateIntegerValue(6), - Value::CreateIntegerValue(8)).release()))); + *List(List(base::Value::CreateIntegerValue(2), + base::Value::CreateIntegerValue(6), + base::Value::CreateIntegerValue(8)).release()))); ASSERT_TRUE(params); ASSERT_TRUE(params->nums.as_integers); EXPECT_EQ(Vector(2, 6, 8), *params->nums.as_integers); @@ -69,32 +69,32 @@ TEST(JsonSchemaCompilerChoicesTest, ObjectWithChoicesParamsCreate) { TEST(JsonSchemaCompilerChoicesTest, ObjectWithChoicesParamsCreateFail) { { - scoped_ptr<DictionaryValue> object_param(new DictionaryValue()); + scoped_ptr<base::DictionaryValue> object_param(new base::DictionaryValue()); object_param->SetWithoutPathExpansion("strings", - Value::CreateIntegerValue(5)); - scoped_ptr<ListValue> params_value(new ListValue()); + base::Value::CreateIntegerValue(5)); + scoped_ptr<base::ListValue> params_value(new base::ListValue()); params_value->Append(object_param.release()); scoped_ptr<ObjectWithChoices::Params> params( ObjectWithChoices::Params::Create(*params_value)); EXPECT_FALSE(params.get()); } { - scoped_ptr<DictionaryValue> object_param(new DictionaryValue()); + scoped_ptr<base::DictionaryValue> object_param(new base::DictionaryValue()); object_param->SetWithoutPathExpansion("strings", - Value::CreateStringValue("asdf")); + base::Value::CreateStringValue("asdf")); object_param->SetWithoutPathExpansion("integers", - Value::CreateStringValue("asdf")); - scoped_ptr<ListValue> params_value(new ListValue()); + base::Value::CreateStringValue("asdf")); + scoped_ptr<base::ListValue> params_value(new base::ListValue()); params_value->Append(object_param.release()); scoped_ptr<ObjectWithChoices::Params> params( ObjectWithChoices::Params::Create(*params_value)); EXPECT_FALSE(params.get()); } { - scoped_ptr<DictionaryValue> object_param(new DictionaryValue()); + scoped_ptr<base::DictionaryValue> object_param(new base::DictionaryValue()); object_param->SetWithoutPathExpansion("integers", - Value::CreateIntegerValue(6)); - scoped_ptr<ListValue> params_value(new ListValue()); + base::Value::CreateIntegerValue(6)); + scoped_ptr<base::ListValue> params_value(new base::ListValue()); params_value->Append(object_param.release()); scoped_ptr<ObjectWithChoices::Params> params( ObjectWithChoices::Params::Create(*params_value)); @@ -107,11 +107,11 @@ TEST(JsonSchemaCompilerChoicesTest, PopulateChoiceType) { std::string("of"), std::string("strings")); - ListValue* strings_value = new ListValue(); + base::ListValue* strings_value = new base::ListValue(); for (size_t i = 0; i < strings.size(); ++i) - strings_value->Append(Value::CreateStringValue(strings[i])); + strings_value->Append(base::Value::CreateStringValue(strings[i])); - DictionaryValue value; + base::DictionaryValue value; value.SetInteger("integers", 4); value.Set("strings", strings_value); @@ -127,12 +127,12 @@ TEST(JsonSchemaCompilerChoicesTest, PopulateChoiceType) { } TEST(JsonSchemaCompilerChoicesTest, ChoiceTypeToValue) { - ListValue* strings_value = new ListValue(); - strings_value->Append(Value::CreateStringValue("list")); - strings_value->Append(Value::CreateStringValue("of")); - strings_value->Append(Value::CreateStringValue("strings")); + base::ListValue* strings_value = new base::ListValue(); + strings_value->Append(base::Value::CreateStringValue("list")); + strings_value->Append(base::Value::CreateStringValue("of")); + strings_value->Append(base::Value::CreateStringValue("strings")); - DictionaryValue value; + base::DictionaryValue value; value.SetInteger("integers", 5); value.Set("strings", strings_value); diff --git a/tools/json_schema_compiler/test/crossref_unittest.cc b/tools/json_schema_compiler/test/crossref_unittest.cc index d2747fd..df91b2d2 100644 --- a/tools/json_schema_compiler/test/crossref_unittest.cc +++ b/tools/json_schema_compiler/test/crossref_unittest.cc @@ -11,20 +11,22 @@ using namespace test::api::crossref; namespace { -static scoped_ptr<DictionaryValue> CreateTestTypeDictionary() { - DictionaryValue* value(new DictionaryValue()); - value->SetWithoutPathExpansion("number", Value::CreateDoubleValue(1.1)); - value->SetWithoutPathExpansion("integer", Value::CreateIntegerValue(4)); - value->SetWithoutPathExpansion("string", Value::CreateStringValue("bling")); - value->SetWithoutPathExpansion("boolean", Value::CreateBooleanValue(true)); - return scoped_ptr<DictionaryValue>(value); +static scoped_ptr<base::DictionaryValue> CreateTestTypeDictionary() { + base::DictionaryValue* value(new base::DictionaryValue()); + value->SetWithoutPathExpansion("number", base::Value::CreateDoubleValue(1.1)); + value->SetWithoutPathExpansion("integer", base::Value::CreateIntegerValue(4)); + value->SetWithoutPathExpansion("string", + base::Value::CreateStringValue("bling")); + value->SetWithoutPathExpansion("boolean", + base::Value::CreateBooleanValue(true)); + return scoped_ptr<base::DictionaryValue>(value); } } // namespace TEST(JsonSchemaCompilerCrossrefTest, CrossrefTypePopulate) { scoped_ptr<CrossrefType> crossref_type(new CrossrefType()); - scoped_ptr<DictionaryValue> value(new DictionaryValue()); + scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue()); value->Set("testType", CreateTestTypeDictionary().release()); EXPECT_TRUE(CrossrefType::Populate(*value, crossref_type.get())); EXPECT_TRUE(crossref_type->test_type.get()); @@ -34,7 +36,7 @@ TEST(JsonSchemaCompilerCrossrefTest, CrossrefTypePopulate) { } TEST(JsonSchemaCompilerCrossrefTest, TestTypeOptionalParamCreate) { - scoped_ptr<ListValue> params_value(new ListValue()); + scoped_ptr<base::ListValue> params_value(new base::ListValue()); params_value->Append(CreateTestTypeDictionary().release()); scoped_ptr<TestTypeOptionalParam::Params> params( TestTypeOptionalParam::Params::Create(*params_value)); @@ -45,8 +47,9 @@ TEST(JsonSchemaCompilerCrossrefTest, TestTypeOptionalParamCreate) { } TEST(JsonSchemaCompilerCrossrefTest, TestTypeOptionalParamFail) { - scoped_ptr<ListValue> params_value(new ListValue()); - scoped_ptr<DictionaryValue> test_type_value = CreateTestTypeDictionary(); + scoped_ptr<base::ListValue> params_value(new base::ListValue()); + scoped_ptr<base::DictionaryValue> test_type_value = + CreateTestTypeDictionary(); test_type_value->RemoveWithoutPathExpansion("number", NULL); params_value->Append(test_type_value.release()); scoped_ptr<TestTypeOptionalParam::Params> params( @@ -55,24 +58,26 @@ TEST(JsonSchemaCompilerCrossrefTest, TestTypeOptionalParamFail) { } TEST(JsonSchemaCompilerCrossrefTest, GetTestType) { - scoped_ptr<DictionaryValue> value = CreateTestTypeDictionary(); + scoped_ptr<base::DictionaryValue> value = CreateTestTypeDictionary(); scoped_ptr<test::api::simple_api::TestType> test_type( new test::api::simple_api::TestType()); EXPECT_TRUE( test::api::simple_api::TestType::Populate(*value, test_type.get())); - scoped_ptr<ListValue> results = GetTestType::Results::Create(*test_type); - DictionaryValue* result_dict = NULL; + scoped_ptr<base::ListValue> results = + GetTestType::Results::Create(*test_type); + base::DictionaryValue* result_dict = NULL; results->GetDictionary(0, &result_dict); EXPECT_TRUE(value->Equals(result_dict)); } TEST(JsonSchemaCompilerCrossrefTest, TestTypeInObjectParamsCreate) { { - scoped_ptr<ListValue> params_value(new ListValue()); - scoped_ptr<DictionaryValue> param_object_value(new DictionaryValue()); + scoped_ptr<base::ListValue> params_value(new base::ListValue()); + scoped_ptr<base::DictionaryValue> param_object_value( + new base::DictionaryValue()); param_object_value->Set("testType", CreateTestTypeDictionary().release()); - param_object_value->Set("boolean", Value::CreateBooleanValue(true)); + param_object_value->Set("boolean", base::Value::CreateBooleanValue(true)); params_value->Append(param_object_value.release()); scoped_ptr<TestTypeInObject::Params> params( TestTypeInObject::Params::Create(*params_value)); @@ -83,9 +88,10 @@ TEST(JsonSchemaCompilerCrossrefTest, TestTypeInObjectParamsCreate) { params->param_object.test_type->ToValue().get())); } { - scoped_ptr<ListValue> params_value(new ListValue()); - scoped_ptr<DictionaryValue> param_object_value(new DictionaryValue()); - param_object_value->Set("boolean", Value::CreateBooleanValue(true)); + scoped_ptr<base::ListValue> params_value(new base::ListValue()); + scoped_ptr<base::DictionaryValue> param_object_value( + new base::DictionaryValue()); + param_object_value->Set("boolean", base::Value::CreateBooleanValue(true)); params_value->Append(param_object_value.release()); scoped_ptr<TestTypeInObject::Params> params( TestTypeInObject::Params::Create(*params_value)); @@ -94,18 +100,21 @@ TEST(JsonSchemaCompilerCrossrefTest, TestTypeInObjectParamsCreate) { EXPECT_TRUE(params->param_object.boolean); } { - scoped_ptr<ListValue> params_value(new ListValue()); - scoped_ptr<DictionaryValue> param_object_value(new DictionaryValue()); - param_object_value->Set("testType", Value::CreateStringValue("invalid")); - param_object_value->Set("boolean", Value::CreateBooleanValue(true)); + scoped_ptr<base::ListValue> params_value(new base::ListValue()); + scoped_ptr<base::DictionaryValue> param_object_value( + new base::DictionaryValue()); + param_object_value->Set("testType", + base::Value::CreateStringValue("invalid")); + param_object_value->Set("boolean", base::Value::CreateBooleanValue(true)); params_value->Append(param_object_value.release()); scoped_ptr<TestTypeInObject::Params> params( TestTypeInObject::Params::Create(*params_value)); EXPECT_FALSE(params.get()); } { - scoped_ptr<ListValue> params_value(new ListValue()); - scoped_ptr<DictionaryValue> param_object_value(new DictionaryValue()); + scoped_ptr<base::ListValue> params_value(new base::ListValue()); + scoped_ptr<base::DictionaryValue> param_object_value( + new base::DictionaryValue()); param_object_value->Set("testType", CreateTestTypeDictionary().release()); params_value->Append(param_object_value.release()); scoped_ptr<TestTypeInObject::Params> params( diff --git a/tools/json_schema_compiler/test/enums_unittest.cc b/tools/json_schema_compiler/test/enums_unittest.cc index 144c3cc..be7a381 100644 --- a/tools/json_schema_compiler/test/enums_unittest.cc +++ b/tools/json_schema_compiler/test/enums_unittest.cc @@ -13,24 +13,24 @@ using json_schema_compiler::test_util::List; TEST(JsonSchemaCompilerEnumsTest, EnumTypePopulate) { { EnumType enum_type; - DictionaryValue value; - value.Set("type", Value::CreateStringValue("one")); + base::DictionaryValue value; + value.Set("type", base::Value::CreateStringValue("one")); EXPECT_TRUE(EnumType::Populate(value, &enum_type)); EXPECT_EQ(EnumType::TYPE_ONE, enum_type.type); EXPECT_TRUE(value.Equals(enum_type.ToValue().get())); } { EnumType enum_type; - DictionaryValue value; - value.Set("type", Value::CreateStringValue("invalid")); + base::DictionaryValue value; + value.Set("type", base::Value::CreateStringValue("invalid")); EXPECT_FALSE(EnumType::Populate(value, &enum_type)); } } TEST(JsonSchemaCompilerEnumsTest, EnumsAsTypes) { { - ListValue args; - args.Append(Value::CreateStringValue("one")); + base::ListValue args; + args.Append(base::Value::CreateStringValue("one")); scoped_ptr<TakesEnumAsType::Params> params( TakesEnumAsType::Params::Create(args)); @@ -42,14 +42,14 @@ TEST(JsonSchemaCompilerEnumsTest, EnumsAsTypes) { } { HasEnumeration enumeration; - DictionaryValue value; + base::DictionaryValue value; ASSERT_FALSE(HasEnumeration::Populate(value, &enumeration)); - value.Set("enumeration", Value::CreateStringValue("one")); + value.Set("enumeration", base::Value::CreateStringValue("one")); ASSERT_TRUE(HasEnumeration::Populate(value, &enumeration)); EXPECT_TRUE(value.Equals(enumeration.ToValue().get())); - value.Set("optional_enumeration", Value::CreateStringValue("two")); + value.Set("optional_enumeration", base::Value::CreateStringValue("two")); ASSERT_TRUE(HasEnumeration::Populate(value, &enumeration)); EXPECT_TRUE(value.Equals(enumeration.ToValue().get())); } @@ -57,9 +57,9 @@ TEST(JsonSchemaCompilerEnumsTest, EnumsAsTypes) { TEST(JsonSchemaCompilerEnumsTest, EnumsArrayAsType) { { - ListValue params_value; - params_value.Append(List(Value::CreateStringValue("one"), - Value::CreateStringValue("two")).release()); + base::ListValue params_value; + params_value.Append(List(base::Value::CreateStringValue("one"), + base::Value::CreateStringValue("two")).release()); scoped_ptr<TakesEnumArrayAsType::Params> params( TakesEnumArrayAsType::Params::Create(params_value)); ASSERT_TRUE(params); @@ -68,8 +68,9 @@ TEST(JsonSchemaCompilerEnumsTest, EnumsArrayAsType) { EXPECT_EQ(ENUMERATION_TWO, params->values[1]); } { - ListValue params_value; - params_value.Append(List(Value::CreateStringValue("invalid")).release()); + base::ListValue params_value; + params_value.Append( + List(base::Value::CreateStringValue("invalid")).release()); scoped_ptr<TakesEnumArrayAsType::Params> params( TakesEnumArrayAsType::Params::Create(params_value)); EXPECT_FALSE(params); @@ -79,28 +80,28 @@ TEST(JsonSchemaCompilerEnumsTest, EnumsArrayAsType) { TEST(JsonSchemaCompilerEnumsTest, ReturnsEnumCreate) { { ReturnsEnum::Results::State state = ReturnsEnum::Results::STATE_FOO; - scoped_ptr<Value> result( + scoped_ptr<base::Value> result( new base::StringValue(ReturnsEnum::Results::ToString(state))); - scoped_ptr<Value> expected(Value::CreateStringValue("foo")); + scoped_ptr<base::Value> expected(base::Value::CreateStringValue("foo")); EXPECT_TRUE(result->Equals(expected.get())); } { ReturnsEnum::Results::State state = ReturnsEnum::Results::STATE_FOO; - scoped_ptr<ListValue> results = ReturnsEnum::Results::Create(state); - ListValue expected; - expected.Append(Value::CreateStringValue("foo")); + scoped_ptr<base::ListValue> results = ReturnsEnum::Results::Create(state); + base::ListValue expected; + expected.Append(base::Value::CreateStringValue("foo")); EXPECT_TRUE(results->Equals(&expected)); } } TEST(JsonSchemaCompilerEnumsTest, ReturnsTwoEnumsCreate) { { - scoped_ptr<ListValue> results = ReturnsTwoEnums::Results::Create( + scoped_ptr<base::ListValue> results = ReturnsTwoEnums::Results::Create( ReturnsTwoEnums::Results::FIRST_STATE_FOO, ReturnsTwoEnums::Results::SECOND_STATE_HAM); - ListValue expected; - expected.Append(Value::CreateStringValue("foo")); - expected.Append(Value::CreateStringValue("ham")); + base::ListValue expected; + expected.Append(base::Value::CreateStringValue("foo")); + expected.Append(base::Value::CreateStringValue("ham")); EXPECT_TRUE(results->Equals(&expected)); } } @@ -108,39 +109,39 @@ TEST(JsonSchemaCompilerEnumsTest, ReturnsTwoEnumsCreate) { TEST(JsonSchemaCompilerEnumsTest, OptionalEnumTypePopulate) { { OptionalEnumType enum_type; - DictionaryValue value; - value.Set("type", Value::CreateStringValue("two")); + base::DictionaryValue value; + value.Set("type", base::Value::CreateStringValue("two")); EXPECT_TRUE(OptionalEnumType::Populate(value, &enum_type)); EXPECT_EQ(OptionalEnumType::TYPE_TWO, enum_type.type); EXPECT_TRUE(value.Equals(enum_type.ToValue().get())); } { OptionalEnumType enum_type; - DictionaryValue value; + base::DictionaryValue value; EXPECT_TRUE(OptionalEnumType::Populate(value, &enum_type)); EXPECT_EQ(OptionalEnumType::TYPE_NONE, enum_type.type); EXPECT_TRUE(value.Equals(enum_type.ToValue().get())); } { OptionalEnumType enum_type; - DictionaryValue value; - value.Set("type", Value::CreateStringValue("invalid")); + base::DictionaryValue value; + value.Set("type", base::Value::CreateStringValue("invalid")); EXPECT_FALSE(OptionalEnumType::Populate(value, &enum_type)); } } TEST(JsonSchemaCompilerEnumsTest, TakesEnumParamsCreate) { { - ListValue params_value; - params_value.Append(Value::CreateStringValue("baz")); + base::ListValue params_value; + params_value.Append(base::Value::CreateStringValue("baz")); scoped_ptr<TakesEnum::Params> params( TakesEnum::Params::Create(params_value)); EXPECT_TRUE(params.get()); EXPECT_EQ(TakesEnum::Params::STATE_BAZ, params->state); } { - ListValue params_value; - params_value.Append(Value::CreateStringValue("invalid")); + base::ListValue params_value; + params_value.Append(base::Value::CreateStringValue("invalid")); scoped_ptr<TakesEnum::Params> params( TakesEnum::Params::Create(params_value)); EXPECT_FALSE(params.get()); @@ -149,9 +150,9 @@ TEST(JsonSchemaCompilerEnumsTest, TakesEnumParamsCreate) { TEST(JsonSchemaCompilerEnumsTest, TakesEnumArrayParamsCreate) { { - ListValue params_value; - params_value.Append(List(Value::CreateStringValue("foo"), - Value::CreateStringValue("bar")).release()); + base::ListValue params_value; + params_value.Append(List(base::Value::CreateStringValue("foo"), + base::Value::CreateStringValue("bar")).release()); scoped_ptr<TakesEnumArray::Params> params( TakesEnumArray::Params::Create(params_value)); ASSERT_TRUE(params); @@ -160,8 +161,9 @@ TEST(JsonSchemaCompilerEnumsTest, TakesEnumArrayParamsCreate) { EXPECT_EQ(TakesEnumArray::Params::VALUES_TYPE_BAR, params->values[1]); } { - ListValue params_value; - params_value.Append(List(Value::CreateStringValue("invalid")).release()); + base::ListValue params_value; + params_value.Append( + List(base::Value::CreateStringValue("invalid")).release()); scoped_ptr<TakesEnumArray::Params> params( TakesEnumArray::Params::Create(params_value)); EXPECT_FALSE(params); @@ -170,23 +172,23 @@ TEST(JsonSchemaCompilerEnumsTest, TakesEnumArrayParamsCreate) { TEST(JsonSchemaCompilerEnumsTest, TakesOptionalEnumParamsCreate) { { - ListValue params_value; - params_value.Append(Value::CreateStringValue("baz")); + base::ListValue params_value; + params_value.Append(base::Value::CreateStringValue("baz")); scoped_ptr<TakesOptionalEnum::Params> params( TakesOptionalEnum::Params::Create(params_value)); EXPECT_TRUE(params.get()); EXPECT_EQ(TakesOptionalEnum::Params::STATE_BAZ, params->state); } { - ListValue params_value; + base::ListValue params_value; scoped_ptr<TakesOptionalEnum::Params> params( TakesOptionalEnum::Params::Create(params_value)); EXPECT_TRUE(params.get()); EXPECT_EQ(TakesOptionalEnum::Params::STATE_NONE, params->state); } { - ListValue params_value; - params_value.Append(Value::CreateStringValue("invalid")); + base::ListValue params_value; + params_value.Append(base::Value::CreateStringValue("invalid")); scoped_ptr<TakesOptionalEnum::Params> params( TakesOptionalEnum::Params::Create(params_value)); EXPECT_FALSE(params.get()); @@ -195,9 +197,9 @@ TEST(JsonSchemaCompilerEnumsTest, TakesOptionalEnumParamsCreate) { TEST(JsonSchemaCompilerEnumsTest, TakesMultipleOptionalEnumsParamsCreate) { { - ListValue params_value; - params_value.Append(Value::CreateStringValue("foo")); - params_value.Append(Value::CreateStringValue("foo")); + base::ListValue params_value; + params_value.Append(base::Value::CreateStringValue("foo")); + params_value.Append(base::Value::CreateStringValue("foo")); scoped_ptr<TakesMultipleOptionalEnums::Params> params( TakesMultipleOptionalEnums::Params::Create(params_value)); EXPECT_TRUE(params.get()); @@ -205,8 +207,8 @@ TEST(JsonSchemaCompilerEnumsTest, TakesMultipleOptionalEnumsParamsCreate) { EXPECT_EQ(TakesMultipleOptionalEnums::Params::TYPE_FOO, params->type); } { - ListValue params_value; - params_value.Append(Value::CreateStringValue("foo")); + base::ListValue params_value; + params_value.Append(base::Value::CreateStringValue("foo")); scoped_ptr<TakesMultipleOptionalEnums::Params> params( TakesMultipleOptionalEnums::Params::Create(params_value)); EXPECT_TRUE(params.get()); @@ -214,7 +216,7 @@ TEST(JsonSchemaCompilerEnumsTest, TakesMultipleOptionalEnumsParamsCreate) { EXPECT_EQ(TakesMultipleOptionalEnums::Params::TYPE_NONE, params->type); } { - ListValue params_value; + base::ListValue params_value; scoped_ptr<TakesMultipleOptionalEnums::Params> params( TakesMultipleOptionalEnums::Params::Create(params_value)); EXPECT_TRUE(params.get()); @@ -222,9 +224,9 @@ TEST(JsonSchemaCompilerEnumsTest, TakesMultipleOptionalEnumsParamsCreate) { EXPECT_EQ(TakesMultipleOptionalEnums::Params::TYPE_NONE, params->type); } { - ListValue params_value; - params_value.Append(Value::CreateStringValue("baz")); - params_value.Append(Value::CreateStringValue("invalid")); + base::ListValue params_value; + params_value.Append(base::Value::CreateStringValue("baz")); + params_value.Append(base::Value::CreateStringValue("invalid")); scoped_ptr<TakesMultipleOptionalEnums::Params> params( TakesMultipleOptionalEnums::Params::Create(params_value)); EXPECT_FALSE(params.get()); @@ -234,28 +236,28 @@ TEST(JsonSchemaCompilerEnumsTest, TakesMultipleOptionalEnumsParamsCreate) { TEST(JsonSchemaCompilerEnumsTest, OnEnumFiredCreate) { { OnEnumFired::SomeEnum some_enum = OnEnumFired::SOME_ENUM_FOO; - scoped_ptr<Value> result( + scoped_ptr<base::Value> result( new base::StringValue(OnEnumFired::ToString(some_enum))); - scoped_ptr<Value> expected(Value::CreateStringValue("foo")); + scoped_ptr<base::Value> expected(base::Value::CreateStringValue("foo")); EXPECT_TRUE(result->Equals(expected.get())); } { OnEnumFired::SomeEnum some_enum = OnEnumFired::SOME_ENUM_FOO; - scoped_ptr<ListValue> results(OnEnumFired::Create(some_enum)); - ListValue expected; - expected.Append(Value::CreateStringValue("foo")); + scoped_ptr<base::ListValue> results(OnEnumFired::Create(some_enum)); + base::ListValue expected; + expected.Append(base::Value::CreateStringValue("foo")); EXPECT_TRUE(results->Equals(&expected)); } } TEST(JsonSchemaCompilerEnumsTest, OnTwoEnumsFiredCreate) { { - scoped_ptr<Value> results(OnTwoEnumsFired::Create( + scoped_ptr<base::Value> results(OnTwoEnumsFired::Create( OnTwoEnumsFired::FIRST_ENUM_FOO, OnTwoEnumsFired::SECOND_ENUM_HAM)); - ListValue expected; - expected.Append(Value::CreateStringValue("foo")); - expected.Append(Value::CreateStringValue("ham")); + base::ListValue expected; + expected.Append(base::Value::CreateStringValue("foo")); + expected.Append(base::Value::CreateStringValue("ham")); EXPECT_TRUE(results->Equals(&expected)); } } diff --git a/tools/json_schema_compiler/test/error_generation_unittest.cc b/tools/json_schema_compiler/test/error_generation_unittest.cc index baf7b51..f5a24fa 100644 --- a/tools/json_schema_compiler/test/error_generation_unittest.cc +++ b/tools/json_schema_compiler/test/error_generation_unittest.cc @@ -33,8 +33,8 @@ testing::AssertionResult EqualsUtf16(const std::string& expected, TEST(JsonSchemaCompilerErrorTest, RequiredPropertyPopulate) { { - scoped_ptr<DictionaryValue> value = Dictionary( - "string", new StringValue("bling")); + scoped_ptr<base::DictionaryValue> value = Dictionary( + "string", new base::StringValue("bling")); EXPECT_TRUE(EqualsUtf16("", GetPopulateError<TestType>(*value))); } { @@ -61,7 +61,7 @@ TEST(JsonSchemaCompilerErrorTest, UnexpectedTypePopulation) { TEST(JsonSchemaCompilerErrorTest, TypeIsRequired) { { - scoped_ptr<DictionaryValue> value = Dictionary( + scoped_ptr<base::DictionaryValue> value = Dictionary( "integers", new FundamentalValue(5)); EXPECT_TRUE(EqualsUtf16("", GetPopulateError<ChoiceType>(*value))); } @@ -100,7 +100,7 @@ TEST(JsonSchemaCompilerErrorTest, ParamIsRequired) { } { scoped_ptr<base::ListValue> params_value = List( - Value::CreateNullValue()); + base::Value::CreateNullValue()); base::string16 error; EXPECT_FALSE(TestFunction::Params::Create(*params_value, &error)); EXPECT_TRUE(EqualsUtf16("'num' is required", error)); @@ -111,12 +111,12 @@ TEST(JsonSchemaCompilerErrorTest, ParamIsRequired) { TEST(JsonSchemaCompilerErrorTest, WrongPropertyValueType) { { - scoped_ptr<DictionaryValue> value = Dictionary( - "string", new StringValue("yes")); + scoped_ptr<base::DictionaryValue> value = Dictionary( + "string", new base::StringValue("yes")); EXPECT_TRUE(EqualsUtf16("", GetPopulateError<TestType>(*value))); } { - scoped_ptr<DictionaryValue> value = Dictionary( + scoped_ptr<base::DictionaryValue> value = Dictionary( "string", new FundamentalValue(1.1)); EXPECT_TRUE(EqualsUtf16("'string': expected string, got number", GetPopulateError<TestType>(*value))); @@ -126,7 +126,7 @@ TEST(JsonSchemaCompilerErrorTest, WrongPropertyValueType) { TEST(JsonSchemaCompilerErrorTest, WrongParameterCreationType) { { scoped_ptr<base::ListValue> params_value = List( - new StringValue("Yeah!")); + new base::StringValue("Yeah!")); EXPECT_TRUE(TestString::Params::Create(*params_value)); } { @@ -145,7 +145,7 @@ TEST(JsonSchemaCompilerErrorTest, WrongTypeValueType) { EXPECT_TRUE(EqualsUtf16("", GetPopulateError<ObjectType>(*value))); } { - scoped_ptr<DictionaryValue> value = Dictionary( + scoped_ptr<base::DictionaryValue> value = Dictionary( "otherType", new FundamentalValue(1.1)); EXPECT_TRUE(EqualsUtf16("'otherType': expected dictionary, got number", GetPopulateError<ObjectType>(*value))); @@ -170,12 +170,12 @@ TEST(JsonSchemaCompilerErrorTest, UnableToPopulateArray) { TEST(JsonSchemaCompilerErrorTest, BinaryTypeExpected) { { - scoped_ptr<DictionaryValue> value = Dictionary( + scoped_ptr<base::DictionaryValue> value = Dictionary( "data", new base::BinaryValue()); EXPECT_TRUE(EqualsUtf16("", GetPopulateError<BinaryData>(*value))); } { - scoped_ptr<DictionaryValue> value = Dictionary( + scoped_ptr<base::DictionaryValue> value = Dictionary( "data", new FundamentalValue(1.1)); EXPECT_TRUE(EqualsUtf16("'data': expected binary, got number", GetPopulateError<BinaryData>(*value))); @@ -184,12 +184,12 @@ TEST(JsonSchemaCompilerErrorTest, BinaryTypeExpected) { TEST(JsonSchemaCompilerErrorTest, ListExpected) { { - scoped_ptr<DictionaryValue> value = Dictionary( + scoped_ptr<base::DictionaryValue> value = Dictionary( "TheArray", new base::ListValue()); EXPECT_TRUE(EqualsUtf16("", GetPopulateError<ArrayObject>(*value))); } { - scoped_ptr<DictionaryValue> value = Dictionary( + scoped_ptr<base::DictionaryValue> value = Dictionary( "TheArray", new FundamentalValue(5)); EXPECT_TRUE(EqualsUtf16("'TheArray': expected list, got integer", GetPopulateError<ArrayObject>(*value))); @@ -200,13 +200,13 @@ TEST(JsonSchemaCompilerErrorTest, ListExpected) { TEST(JsonSchemaCompilerErrorTest, BadEnumValue) { { - scoped_ptr<DictionaryValue> value = Dictionary( - "enumeration", new StringValue("one")); + scoped_ptr<base::DictionaryValue> value = Dictionary( + "enumeration", new base::StringValue("one")); EXPECT_TRUE(EqualsUtf16("", GetPopulateError<HasEnumeration>(*value))); } { - scoped_ptr<DictionaryValue> value = Dictionary( - "enumeration", new StringValue("bad sauce")); + scoped_ptr<base::DictionaryValue> value = Dictionary( + "enumeration", new base::StringValue("bad sauce")); EXPECT_TRUE(EqualsUtf16("'enumeration': expected \"one\" or \"two\" " "or \"three\", got \"bad sauce\"", GetPopulateError<HasEnumeration>(*value))); diff --git a/tools/json_schema_compiler/test/functions_as_parameters_unittest.cc b/tools/json_schema_compiler/test/functions_as_parameters_unittest.cc index f53e434..ce7a2f9 100644 --- a/tools/json_schema_compiler/test/functions_as_parameters_unittest.cc +++ b/tools/json_schema_compiler/test/functions_as_parameters_unittest.cc @@ -12,13 +12,13 @@ TEST(JsonSchemaCompilerFunctionsAsParametersTest, PopulateRequiredFunction) { // The expectation is that if any value is set for the function, then // the function is "present". { - DictionaryValue empty_value; + base::DictionaryValue empty_value; FunctionType out; EXPECT_FALSE(FunctionType::Populate(empty_value, &out)); } { - DictionaryValue value; - DictionaryValue function_dict; + base::DictionaryValue value; + base::DictionaryValue function_dict; value.Set("event_callback", function_dict.DeepCopy()); FunctionType out; ASSERT_TRUE(FunctionType::Populate(value, &out)); @@ -28,8 +28,8 @@ TEST(JsonSchemaCompilerFunctionsAsParametersTest, PopulateRequiredFunction) { TEST(JsonSchemaCompilerFunctionsAsParametersTest, RequiredFunctionToValue) { { - DictionaryValue value; - DictionaryValue function_dict; + base::DictionaryValue value; + base::DictionaryValue function_dict; value.Set("event_callback", function_dict.DeepCopy()); FunctionType out; @@ -37,9 +37,9 @@ TEST(JsonSchemaCompilerFunctionsAsParametersTest, RequiredFunctionToValue) { EXPECT_TRUE(value.Equals(out.ToValue().get())); } { - DictionaryValue value; - DictionaryValue expected_value; - DictionaryValue function_dict; + base::DictionaryValue value; + base::DictionaryValue expected_value; + base::DictionaryValue function_dict; value.Set("event_callback", function_dict.DeepCopy()); expected_value.Set("event_callback", function_dict.DeepCopy()); @@ -51,22 +51,22 @@ TEST(JsonSchemaCompilerFunctionsAsParametersTest, RequiredFunctionToValue) { TEST(JsonSchemaCompilerFunctionsAsParametersTest, PopulateOptionalFunction) { { - DictionaryValue empty_value; + base::DictionaryValue empty_value; OptionalFunctionType out; ASSERT_TRUE(OptionalFunctionType::Populate(empty_value, &out)); EXPECT_FALSE(out.event_callback.get()); } { - DictionaryValue value; - DictionaryValue function_value; + base::DictionaryValue value; + base::DictionaryValue function_value; value.Set("event_callback", function_value.DeepCopy()); OptionalFunctionType out; ASSERT_TRUE(OptionalFunctionType::Populate(value, &out)); EXPECT_TRUE(out.event_callback.get()); } { - DictionaryValue value; - DictionaryValue function_value; + base::DictionaryValue value; + base::DictionaryValue function_value; value.Set("event_callback", function_value.DeepCopy()); OptionalFunctionType out; ASSERT_TRUE(OptionalFunctionType::Populate(value, &out)); @@ -76,15 +76,15 @@ TEST(JsonSchemaCompilerFunctionsAsParametersTest, PopulateOptionalFunction) { TEST(JsonSchemaCompilerFunctionsAsParametersTest, OptionalFunctionToValue) { { - DictionaryValue empty_value; + base::DictionaryValue empty_value; OptionalFunctionType out; ASSERT_TRUE(OptionalFunctionType::Populate(empty_value, &out)); // event_callback should not be set in the return from ToValue. EXPECT_TRUE(empty_value.Equals(out.ToValue().get())); } { - DictionaryValue value; - DictionaryValue function_value; + base::DictionaryValue value; + base::DictionaryValue function_value; value.Set("event_callback", function_value.DeepCopy()); OptionalFunctionType out; diff --git a/tools/json_schema_compiler/test/functions_on_types_unittest.cc b/tools/json_schema_compiler/test/functions_on_types_unittest.cc index 6fe4526..f96a5f7 100644 --- a/tools/json_schema_compiler/test/functions_on_types_unittest.cc +++ b/tools/json_schema_compiler/test/functions_on_types_unittest.cc @@ -10,22 +10,22 @@ using namespace test::api::functions_on_types; TEST(JsonSchemaCompilerFunctionsOnTypesTest, StorageAreaGetParamsCreate) { { - scoped_ptr<ListValue> params_value(new ListValue()); + scoped_ptr<base::ListValue> params_value(new base::ListValue()); scoped_ptr<StorageArea::Get::Params> params( StorageArea::Get::Params::Create(*params_value)); ASSERT_TRUE(params); EXPECT_FALSE(params->keys); } { - scoped_ptr<ListValue> params_value(new ListValue()); - params_value->Append(Value::CreateIntegerValue(9)); + scoped_ptr<base::ListValue> params_value(new base::ListValue()); + params_value->Append(base::Value::CreateIntegerValue(9)); scoped_ptr<StorageArea::Get::Params> params( StorageArea::Get::Params::Create(*params_value)); EXPECT_FALSE(params); } { - scoped_ptr<ListValue> params_value(new ListValue()); - params_value->Append(Value::CreateStringValue("test")); + scoped_ptr<base::ListValue> params_value(new base::ListValue()); + params_value->Append(base::Value::CreateStringValue("test")); scoped_ptr<StorageArea::Get::Params> params( StorageArea::Get::Params::Create(*params_value)); ASSERT_TRUE(params); @@ -33,10 +33,11 @@ TEST(JsonSchemaCompilerFunctionsOnTypesTest, StorageAreaGetParamsCreate) { EXPECT_EQ("test", *params->keys->as_string); } { - scoped_ptr<DictionaryValue> keys_object_value(new DictionaryValue()); + scoped_ptr<base::DictionaryValue> keys_object_value( + new base::DictionaryValue()); keys_object_value->SetInteger("integer", 5); keys_object_value->SetString("string", "string"); - scoped_ptr<ListValue> params_value(new ListValue()); + scoped_ptr<base::ListValue> params_value(new base::ListValue()); params_value->Append(keys_object_value->DeepCopy()); scoped_ptr<StorageArea::Get::Params> params( StorageArea::Get::Params::Create(*params_value)); @@ -51,16 +52,17 @@ TEST(JsonSchemaCompilerFunctionsOnTypesTest, StorageAreaGetResultCreate) { StorageArea::Get::Results::Items items; items.additional_properties.SetDouble("asdf", 0.1); items.additional_properties.SetString("sdfg", "zxcv"); - scoped_ptr<ListValue> results = StorageArea::Get::Results::Create(items); - DictionaryValue* item_result = NULL; + scoped_ptr<base::ListValue> results = + StorageArea::Get::Results::Create(items); + base::DictionaryValue* item_result = NULL; ASSERT_TRUE(results->GetDictionary(0, &item_result)); EXPECT_TRUE(item_result->Equals(&items.additional_properties)); } TEST(JsonSchemaCompilerFunctionsOnTypesTest, ChromeSettingGetParamsCreate) { - scoped_ptr<DictionaryValue> details_value(new DictionaryValue()); + scoped_ptr<base::DictionaryValue> details_value(new base::DictionaryValue()); details_value->SetBoolean("incognito", true); - scoped_ptr<ListValue> params_value(new ListValue()); + scoped_ptr<base::ListValue> params_value(new base::ListValue()); params_value->Append(details_value.release()); scoped_ptr<ChromeSetting::Get::Params> params( ChromeSetting::Get::Params::Create(*params_value)); diff --git a/tools/json_schema_compiler/test/idl_schemas_unittest.cc b/tools/json_schema_compiler/test/idl_schemas_unittest.cc index 233c8d2..59e0d8b 100644 --- a/tools/json_schema_compiler/test/idl_schemas_unittest.cc +++ b/tools/json_schema_compiler/test/idl_schemas_unittest.cc @@ -29,21 +29,21 @@ TEST(IdlCompiler, Basics) { MyType1 a; a.x = 5; a.y = std::string("foo"); - scoped_ptr<DictionaryValue> serialized = a.ToValue(); + scoped_ptr<base::DictionaryValue> serialized = a.ToValue(); MyType1 b; EXPECT_TRUE(MyType1::Populate(*serialized.get(), &b)); EXPECT_EQ(a.x, b.x); EXPECT_EQ(a.y, b.y); // Test Function2, which takes an integer parameter. - ListValue list; - list.Append(Value::CreateIntegerValue(5)); + base::ListValue list; + list.Append(base::Value::CreateIntegerValue(5)); scoped_ptr<Function2::Params> f2_params = Function2::Params::Create(list); EXPECT_EQ(5, f2_params->x); // Test Function3, which takes a MyType1 parameter. list.Clear(); - DictionaryValue* tmp = new DictionaryValue(); + base::DictionaryValue* tmp = new base::DictionaryValue(); tmp->SetInteger("x", 17); tmp->SetString("y", "hello"); tmp->SetString("z", "zstring"); @@ -57,17 +57,17 @@ TEST(IdlCompiler, Basics) { // Test functions that take a callback function as a parameter, with varying // callback signatures. - scoped_ptr<ListValue> f4_results = Function4::Results::Create(); - ListValue expected; + scoped_ptr<base::ListValue> f4_results = Function4::Results::Create(); + base::ListValue expected; EXPECT_TRUE(f4_results->Equals(&expected)); - scoped_ptr<ListValue> f5_results(Function5::Results::Create(13)); - Value* f5_result_int = NULL; + scoped_ptr<base::ListValue> f5_results(Function5::Results::Create(13)); + base::Value* f5_result_int = NULL; ASSERT_TRUE(f5_results->Get(0, &f5_result_int)); - EXPECT_TRUE(f5_result_int->IsType(Value::TYPE_INTEGER)); + EXPECT_TRUE(f5_result_int->IsType(base::Value::TYPE_INTEGER)); - scoped_ptr<ListValue> f6_results(Function6::Results::Create(a)); - Value* f6_result_dict = NULL; + scoped_ptr<base::ListValue> f6_results(Function6::Results::Create(a)); + base::Value* f6_result_dict = NULL; ASSERT_TRUE(f6_results->Get(0, &f6_result_dict)); MyType1 c; EXPECT_TRUE(MyType1::Populate(*f6_result_dict, &c)); @@ -78,21 +78,21 @@ TEST(IdlCompiler, Basics) { TEST(IdlCompiler, OptionalArguments) { // Test a function that takes one optional argument, both without and with // that argument. - ListValue list; + base::ListValue list; scoped_ptr<Function7::Params> f7_params = Function7::Params::Create(list); EXPECT_EQ(NULL, f7_params->arg.get()); - list.Append(Value::CreateIntegerValue(7)); + list.Append(base::Value::CreateIntegerValue(7)); f7_params = Function7::Params::Create(list); EXPECT_EQ(7, *(f7_params->arg)); // Similar to above, but a function with one required and one optional // argument. list.Clear(); - list.Append(Value::CreateIntegerValue(8)); + list.Append(base::Value::CreateIntegerValue(8)); scoped_ptr<Function8::Params> f8_params = Function8::Params::Create(list); EXPECT_EQ(8, f8_params->arg1); EXPECT_EQ(NULL, f8_params->arg2.get()); - list.Append(Value::CreateStringValue("foo")); + list.Append(base::Value::CreateStringValue("foo")); f8_params = Function8::Params::Create(list); EXPECT_EQ(8, f8_params->arg1); EXPECT_EQ("foo", *(f8_params->arg2)); @@ -102,7 +102,7 @@ TEST(IdlCompiler, OptionalArguments) { scoped_ptr<Function9::Params> f9_params = Function9::Params::Create(list); EXPECT_EQ(NULL, f9_params->arg.get()); list.Clear(); - DictionaryValue* tmp = new DictionaryValue(); + base::DictionaryValue* tmp = new base::DictionaryValue(); tmp->SetInteger("x", 17); tmp->SetString("y", "hello"); tmp->SetString("z", "zstring"); @@ -120,9 +120,9 @@ TEST(IdlCompiler, OptionalArguments) { TEST(IdlCompiler, ArrayTypes) { // Tests of a function that takes an integer and an array of integers. First // use an empty array. - ListValue list; - list.Append(Value::CreateIntegerValue(33)); - list.Append(new ListValue); + base::ListValue list; + list.Append(base::Value::CreateIntegerValue(33)); + list.Append(new base::ListValue); scoped_ptr<Function10::Params> f10_params = Function10::Params::Create(list); ASSERT_TRUE(f10_params != NULL); EXPECT_EQ(33, f10_params->x); @@ -130,10 +130,10 @@ TEST(IdlCompiler, ArrayTypes) { // Same function, but this time with 2 values in the array. list.Clear(); - list.Append(Value::CreateIntegerValue(33)); - ListValue* sublist = new ListValue; - sublist->Append(Value::CreateIntegerValue(34)); - sublist->Append(Value::CreateIntegerValue(35)); + list.Append(base::Value::CreateIntegerValue(33)); + base::ListValue* sublist = new base::ListValue; + sublist->Append(base::Value::CreateIntegerValue(34)); + sublist->Append(base::Value::CreateIntegerValue(35)); list.Append(sublist); f10_params = Function10::Params::Create(list); ASSERT_TRUE(f10_params != NULL); @@ -150,7 +150,7 @@ TEST(IdlCompiler, ArrayTypes) { b.x = 6; a.y = std::string("foo"); b.y = std::string("bar"); - ListValue* sublist2 = new ListValue; + base::ListValue* sublist2 = new base::ListValue; sublist2->Append(a.ToValue().release()); sublist2->Append(b.ToValue().release()); list.Append(sublist2); @@ -167,7 +167,7 @@ TEST(IdlCompiler, ObjectTypes) { // Test the FooType type. FooType f1; f1.x = 3; - scoped_ptr<DictionaryValue> serialized_foo = f1.ToValue(); + scoped_ptr<base::DictionaryValue> serialized_foo = f1.ToValue(); FooType f2; EXPECT_TRUE(FooType::Populate(*serialized_foo.get(), &f2)); EXPECT_EQ(f1.x, f2.x); @@ -175,7 +175,7 @@ TEST(IdlCompiler, ObjectTypes) { // Test the BarType type. BarType b1; b1.x.reset(new base::FundamentalValue(7)); - scoped_ptr<DictionaryValue> serialized_bar = b1.ToValue(); + scoped_ptr<base::DictionaryValue> serialized_bar = b1.ToValue(); BarType b2; EXPECT_TRUE(BarType::Populate(*serialized_bar.get(), &b2)); int tmp_int = 0; @@ -183,12 +183,12 @@ TEST(IdlCompiler, ObjectTypes) { EXPECT_EQ(7, tmp_int); // Test the params to the ObjectFunction1 function. - scoped_ptr<DictionaryValue> icon_props(new DictionaryValue()); + scoped_ptr<base::DictionaryValue> icon_props(new base::DictionaryValue()); icon_props->SetString("hello", "world"); ObjectFunction1::Params::Icon icon; EXPECT_TRUE(ObjectFunction1::Params::Icon::Populate(*(icon_props.get()), &icon)); - ListValue list; + base::ListValue list; list.Append(icon_props.release()); scoped_ptr<ObjectFunction1::Params> params = ObjectFunction1::Params::Create(list); diff --git a/tools/json_schema_compiler/test/objects_unittest.cc b/tools/json_schema_compiler/test/objects_unittest.cc index 5a4248d..c0af2e1 100644 --- a/tools/json_schema_compiler/test/objects_unittest.cc +++ b/tools/json_schema_compiler/test/objects_unittest.cc @@ -11,15 +11,15 @@ using namespace test::api::objects; TEST(JsonSchemaCompilerObjectsTest, ObjectParamParamsCreate) { { - scoped_ptr<ListValue> strings(new ListValue()); - strings->Append(Value::CreateStringValue("one")); - strings->Append(Value::CreateStringValue("two")); - scoped_ptr<DictionaryValue> info_value(new DictionaryValue()); + scoped_ptr<base::ListValue> strings(new base::ListValue()); + strings->Append(base::Value::CreateStringValue("one")); + strings->Append(base::Value::CreateStringValue("two")); + scoped_ptr<base::DictionaryValue> info_value(new base::DictionaryValue()); info_value->Set("strings", strings.release()); - info_value->Set("integer", Value::CreateIntegerValue(5)); - info_value->Set("boolean", Value::CreateBooleanValue(true)); + info_value->Set("integer", base::Value::CreateIntegerValue(5)); + info_value->Set("boolean", base::Value::CreateBooleanValue(true)); - scoped_ptr<ListValue> params_value(new ListValue()); + scoped_ptr<base::ListValue> params_value(new base::ListValue()); params_value->Append(info_value.release()); scoped_ptr<ObjectParam::Params> params( ObjectParam::Params::Create(*params_value)); @@ -31,14 +31,14 @@ TEST(JsonSchemaCompilerObjectsTest, ObjectParamParamsCreate) { EXPECT_TRUE(params->info.boolean); } { - scoped_ptr<ListValue> strings(new ListValue()); - strings->Append(Value::CreateStringValue("one")); - strings->Append(Value::CreateStringValue("two")); - scoped_ptr<DictionaryValue> info_value(new DictionaryValue()); + scoped_ptr<base::ListValue> strings(new base::ListValue()); + strings->Append(base::Value::CreateStringValue("one")); + strings->Append(base::Value::CreateStringValue("two")); + scoped_ptr<base::DictionaryValue> info_value(new base::DictionaryValue()); info_value->Set("strings", strings.release()); - info_value->Set("integer", Value::CreateIntegerValue(5)); + info_value->Set("integer", base::Value::CreateIntegerValue(5)); - scoped_ptr<ListValue> params_value(new ListValue()); + scoped_ptr<base::ListValue> params_value(new base::ListValue()); params_value->Append(info_value.release()); scoped_ptr<ObjectParam::Params> params( ObjectParam::Params::Create(*params_value)); @@ -49,11 +49,11 @@ TEST(JsonSchemaCompilerObjectsTest, ObjectParamParamsCreate) { TEST(JsonSchemaCompilerObjectsTest, ReturnsObjectResultCreate) { ReturnsObject::Results::Info info; info.state = ReturnsObject::Results::Info::STATE_FOO; - scoped_ptr<ListValue> results = ReturnsObject::Results::Create(info); + scoped_ptr<base::ListValue> results = ReturnsObject::Results::Create(info); - DictionaryValue expected; + base::DictionaryValue expected; expected.SetString("state", "foo"); - DictionaryValue* result = NULL; + base::DictionaryValue* result = NULL; ASSERT_TRUE(results->GetDictionary(0, &result)); ASSERT_TRUE(result->Equals(&expected)); } @@ -61,11 +61,11 @@ TEST(JsonSchemaCompilerObjectsTest, ReturnsObjectResultCreate) { TEST(JsonSchemaCompilerObjectsTest, OnObjectFiredCreate) { OnObjectFired::SomeObject object; object.state = OnObjectFired::SomeObject::STATE_BAR; - scoped_ptr<ListValue> results(OnObjectFired::Create(object)); + scoped_ptr<base::ListValue> results(OnObjectFired::Create(object)); - DictionaryValue expected; + base::DictionaryValue expected; expected.SetString("state", "bar"); - DictionaryValue* result = NULL; + base::DictionaryValue* result = NULL; ASSERT_TRUE(results->GetDictionary(0, &result)); ASSERT_TRUE(result->Equals(&expected)); } diff --git a/tools/json_schema_compiler/test/simple_api_unittest.cc b/tools/json_schema_compiler/test/simple_api_unittest.cc index bce1838..f34b9fc 100644 --- a/tools/json_schema_compiler/test/simple_api_unittest.cc +++ b/tools/json_schema_compiler/test/simple_api_unittest.cc @@ -10,27 +10,31 @@ using namespace test::api::simple_api; namespace { -static scoped_ptr<DictionaryValue> CreateTestTypeDictionary() { - scoped_ptr<DictionaryValue> value(new DictionaryValue()); - value->SetWithoutPathExpansion("number", Value::CreateDoubleValue(1.1)); - value->SetWithoutPathExpansion("integer", Value::CreateIntegerValue(4)); - value->SetWithoutPathExpansion("string", Value::CreateStringValue("bling")); - value->SetWithoutPathExpansion("boolean", Value::CreateBooleanValue(true)); +static scoped_ptr<base::DictionaryValue> CreateTestTypeDictionary() { + scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue()); + value->SetWithoutPathExpansion("number", + base::Value::CreateDoubleValue(1.1)); + value->SetWithoutPathExpansion("integer", + base::Value::CreateIntegerValue(4)); + value->SetWithoutPathExpansion("string", + base::Value::CreateStringValue("bling")); + value->SetWithoutPathExpansion("boolean", + base::Value::CreateBooleanValue(true)); return value.Pass(); } } // namespace TEST(JsonSchemaCompilerSimpleTest, IncrementIntegerResultCreate) { - scoped_ptr<ListValue> results = IncrementInteger::Results::Create(5); - ListValue expected; - expected.Append(Value::CreateIntegerValue(5)); + scoped_ptr<base::ListValue> results = IncrementInteger::Results::Create(5); + base::ListValue expected; + expected.Append(base::Value::CreateIntegerValue(5)); EXPECT_TRUE(results->Equals(&expected)); } TEST(JsonSchemaCompilerSimpleTest, IncrementIntegerParamsCreate) { - scoped_ptr<ListValue> params_value(new ListValue()); - params_value->Append(Value::CreateIntegerValue(6)); + scoped_ptr<base::ListValue> params_value(new base::ListValue()); + params_value->Append(base::Value::CreateIntegerValue(6)); scoped_ptr<IncrementInteger::Params> params( IncrementInteger::Params::Create(*params_value)); EXPECT_TRUE(params.get()); @@ -39,15 +43,15 @@ TEST(JsonSchemaCompilerSimpleTest, IncrementIntegerParamsCreate) { TEST(JsonSchemaCompilerSimpleTest, NumberOfParams) { { - scoped_ptr<ListValue> params_value(new ListValue()); - params_value->Append(Value::CreateStringValue("text")); - params_value->Append(Value::CreateStringValue("text")); + scoped_ptr<base::ListValue> params_value(new base::ListValue()); + params_value->Append(base::Value::CreateStringValue("text")); + params_value->Append(base::Value::CreateStringValue("text")); scoped_ptr<OptionalString::Params> params( OptionalString::Params::Create(*params_value)); EXPECT_FALSE(params.get()); } { - scoped_ptr<ListValue> params_value(new ListValue()); + scoped_ptr<base::ListValue> params_value(new base::ListValue()); scoped_ptr<IncrementInteger::Params> params( IncrementInteger::Params::Create(*params_value)); EXPECT_FALSE(params.get()); @@ -56,15 +60,15 @@ TEST(JsonSchemaCompilerSimpleTest, NumberOfParams) { TEST(JsonSchemaCompilerSimpleTest, OptionalStringParamsCreate) { { - scoped_ptr<ListValue> params_value(new ListValue()); + scoped_ptr<base::ListValue> params_value(new base::ListValue()); scoped_ptr<OptionalString::Params> params( OptionalString::Params::Create(*params_value)); EXPECT_TRUE(params.get()); EXPECT_FALSE(params->str.get()); } { - scoped_ptr<ListValue> params_value(new ListValue()); - params_value->Append(Value::CreateStringValue("asdf")); + scoped_ptr<base::ListValue> params_value(new base::ListValue()); + params_value->Append(base::Value::CreateStringValue("asdf")); scoped_ptr<OptionalString::Params> params( OptionalString::Params::Create(*params_value)); EXPECT_TRUE(params.get()); @@ -75,8 +79,8 @@ TEST(JsonSchemaCompilerSimpleTest, OptionalStringParamsCreate) { TEST(JsonSchemaCompilerSimpleTest, OptionalParamsTakingNull) { { - scoped_ptr<ListValue> params_value(new ListValue()); - params_value->Append(Value::CreateNullValue()); + scoped_ptr<base::ListValue> params_value(new base::ListValue()); + params_value->Append(base::Value::CreateNullValue()); scoped_ptr<OptionalString::Params> params( OptionalString::Params::Create(*params_value)); EXPECT_TRUE(params.get()); @@ -86,8 +90,8 @@ TEST(JsonSchemaCompilerSimpleTest, OptionalParamsTakingNull) { TEST(JsonSchemaCompilerSimpleTest, OptionalStringParamsWrongType) { { - scoped_ptr<ListValue> params_value(new ListValue()); - params_value->Append(Value::CreateIntegerValue(5)); + scoped_ptr<base::ListValue> params_value(new base::ListValue()); + params_value->Append(base::Value::CreateIntegerValue(5)); scoped_ptr<OptionalString::Params> params( OptionalString::Params::Create(*params_value)); EXPECT_FALSE(params.get()); @@ -96,9 +100,9 @@ TEST(JsonSchemaCompilerSimpleTest, OptionalStringParamsWrongType) { TEST(JsonSchemaCompilerSimpleTest, OptionalBeforeRequired) { { - scoped_ptr<ListValue> params_value(new ListValue()); - params_value->Append(Value::CreateNullValue()); - params_value->Append(Value::CreateStringValue("asdf")); + scoped_ptr<base::ListValue> params_value(new base::ListValue()); + params_value->Append(base::Value::CreateNullValue()); + params_value->Append(base::Value::CreateStringValue("asdf")); scoped_ptr<OptionalBeforeRequired::Params> params( OptionalBeforeRequired::Params::Create(*params_value)); EXPECT_TRUE(params.get()); @@ -108,15 +112,15 @@ TEST(JsonSchemaCompilerSimpleTest, OptionalBeforeRequired) { } TEST(JsonSchemaCompilerSimpleTest, NoParamsResultCreate) { - scoped_ptr<ListValue> results = OptionalString::Results::Create(); - ListValue expected; + scoped_ptr<base::ListValue> results = OptionalString::Results::Create(); + base::ListValue expected; EXPECT_TRUE(results->Equals(&expected)); } TEST(JsonSchemaCompilerSimpleTest, TestTypePopulate) { { scoped_ptr<TestType> test_type(new TestType()); - scoped_ptr<DictionaryValue> value = CreateTestTypeDictionary(); + scoped_ptr<base::DictionaryValue> value = CreateTestTypeDictionary(); EXPECT_TRUE(TestType::Populate(*value, test_type.get())); EXPECT_EQ("bling", test_type->string); EXPECT_EQ(1.1, test_type->number); @@ -126,7 +130,7 @@ TEST(JsonSchemaCompilerSimpleTest, TestTypePopulate) { } { scoped_ptr<TestType> test_type(new TestType()); - scoped_ptr<DictionaryValue> value = CreateTestTypeDictionary(); + scoped_ptr<base::DictionaryValue> value = CreateTestTypeDictionary(); value->Remove("number", NULL); EXPECT_FALSE(TestType::Populate(*value, test_type.get())); } @@ -134,12 +138,13 @@ TEST(JsonSchemaCompilerSimpleTest, TestTypePopulate) { TEST(JsonSchemaCompilerSimpleTest, GetTestType) { { - scoped_ptr<DictionaryValue> value = CreateTestTypeDictionary(); + scoped_ptr<base::DictionaryValue> value = CreateTestTypeDictionary(); scoped_ptr<TestType> test_type(new TestType()); EXPECT_TRUE(TestType::Populate(*value, test_type.get())); - scoped_ptr<ListValue> results = GetTestType::Results::Create(*test_type); + scoped_ptr<base::ListValue> results = + GetTestType::Results::Create(*test_type); - DictionaryValue* result = NULL; + base::DictionaryValue* result = NULL; results->GetDictionary(0, &result); EXPECT_TRUE(result->Equals(value.get())); } @@ -147,18 +152,18 @@ TEST(JsonSchemaCompilerSimpleTest, GetTestType) { TEST(JsonSchemaCompilerSimpleTest, OnIntegerFiredCreate) { { - scoped_ptr<ListValue> results(OnIntegerFired::Create(5)); - ListValue expected; - expected.Append(Value::CreateIntegerValue(5)); + scoped_ptr<base::ListValue> results(OnIntegerFired::Create(5)); + base::ListValue expected; + expected.Append(base::Value::CreateIntegerValue(5)); EXPECT_TRUE(results->Equals(&expected)); } } TEST(JsonSchemaCompilerSimpleTest, OnStringFiredCreate) { { - scoped_ptr<ListValue> results(OnStringFired::Create("yo dawg")); - ListValue expected; - expected.Append(Value::CreateStringValue("yo dawg")); + scoped_ptr<base::ListValue> results(OnStringFired::Create("yo dawg")); + base::ListValue expected; + expected.Append(base::Value::CreateStringValue("yo dawg")); EXPECT_TRUE(results->Equals(&expected)); } } @@ -166,14 +171,15 @@ TEST(JsonSchemaCompilerSimpleTest, OnStringFiredCreate) { TEST(JsonSchemaCompilerSimpleTest, OnTestTypeFiredCreate) { { TestType some_test_type; - scoped_ptr<DictionaryValue> expected = CreateTestTypeDictionary(); + scoped_ptr<base::DictionaryValue> expected = CreateTestTypeDictionary(); ASSERT_TRUE(expected->GetDouble("number", &some_test_type.number)); ASSERT_TRUE(expected->GetString("string", &some_test_type.string)); ASSERT_TRUE(expected->GetInteger("integer", &some_test_type.integer)); ASSERT_TRUE(expected->GetBoolean("boolean", &some_test_type.boolean)); - scoped_ptr<ListValue> results(OnTestTypeFired::Create(some_test_type)); - DictionaryValue* result = NULL; + scoped_ptr<base::ListValue> results( + OnTestTypeFired::Create(some_test_type)); + base::DictionaryValue* result = NULL; results->GetDictionary(0, &result); EXPECT_TRUE(result->Equals(expected.get())); } diff --git a/tools/json_schema_compiler/util.cc b/tools/json_schema_compiler/util.cc index d0e7765..2806cfc 100644 --- a/tools/json_schema_compiler/util.cc +++ b/tools/json_schema_compiler/util.cc @@ -70,23 +70,23 @@ void AddItemToList(const linked_ptr<base::DictionaryValue>& from, out->Append(static_cast<base::Value*>(from->DeepCopy())); } -std::string ValueTypeToString(Value::Type type) { +std::string ValueTypeToString(base::Value::Type type) { switch(type) { - case Value::TYPE_NULL: + case base::Value::TYPE_NULL: return "null"; - case Value::TYPE_BOOLEAN: + case base::Value::TYPE_BOOLEAN: return "boolean"; - case Value::TYPE_INTEGER: + case base::Value::TYPE_INTEGER: return "integer"; - case Value::TYPE_DOUBLE: + case base::Value::TYPE_DOUBLE: return "number"; - case Value::TYPE_STRING: + case base::Value::TYPE_STRING: return "string"; - case Value::TYPE_BINARY: + case base::Value::TYPE_BINARY: return "binary"; - case Value::TYPE_DICTIONARY: + case base::Value::TYPE_DICTIONARY: return "dictionary"; - case Value::TYPE_LIST: + case base::Value::TYPE_LIST: return "list"; } NOTREACHED(); diff --git a/tools/json_schema_compiler/util.h b/tools/json_schema_compiler/util.h index b775be7..228eced 100644 --- a/tools/json_schema_compiler/util.h +++ b/tools/json_schema_compiler/util.h @@ -173,7 +173,7 @@ scoped_ptr<base::Value> CreateValueFromOptionalArray( return scoped_ptr<base::Value>(); } -std::string ValueTypeToString(Value::Type type); +std::string ValueTypeToString(base::Value::Type type); } // namespace util } // namespace json_schema_compiler |