OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "tools/json_schema_compiler/test/simple_api.h" | 5 #include "tools/json_schema_compiler/test/simple_api.h" |
6 | 6 |
7 #include "testing/gtest/include/gtest/gtest.h" | 7 #include "testing/gtest/include/gtest/gtest.h" |
8 | 8 |
9 using namespace test::api::simple_api; | 9 using namespace test::api::simple_api; |
10 | 10 |
11 namespace { | 11 namespace { |
12 | 12 |
13 static scoped_ptr<base::DictionaryValue> CreateTestTypeDictionary() { | 13 static std::unique_ptr<base::DictionaryValue> CreateTestTypeDictionary() { |
14 scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue()); | 14 std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue()); |
15 value->SetWithoutPathExpansion("number", new base::FundamentalValue(1.1)); | 15 value->SetWithoutPathExpansion("number", new base::FundamentalValue(1.1)); |
16 value->SetWithoutPathExpansion("integer", new base::FundamentalValue(4)); | 16 value->SetWithoutPathExpansion("integer", new base::FundamentalValue(4)); |
17 value->SetWithoutPathExpansion("string", new base::StringValue("bling")); | 17 value->SetWithoutPathExpansion("string", new base::StringValue("bling")); |
18 value->SetWithoutPathExpansion("boolean", new base::FundamentalValue(true)); | 18 value->SetWithoutPathExpansion("boolean", new base::FundamentalValue(true)); |
19 return value; | 19 return value; |
20 } | 20 } |
21 | 21 |
22 } // namespace | 22 } // namespace |
23 | 23 |
24 TEST(JsonSchemaCompilerSimpleTest, IncrementIntegerResultCreate) { | 24 TEST(JsonSchemaCompilerSimpleTest, IncrementIntegerResultCreate) { |
25 scoped_ptr<base::ListValue> results = IncrementInteger::Results::Create(5); | 25 std::unique_ptr<base::ListValue> results = |
| 26 IncrementInteger::Results::Create(5); |
26 base::ListValue expected; | 27 base::ListValue expected; |
27 expected.Append(new base::FundamentalValue(5)); | 28 expected.Append(new base::FundamentalValue(5)); |
28 EXPECT_TRUE(results->Equals(&expected)); | 29 EXPECT_TRUE(results->Equals(&expected)); |
29 } | 30 } |
30 | 31 |
31 TEST(JsonSchemaCompilerSimpleTest, IncrementIntegerParamsCreate) { | 32 TEST(JsonSchemaCompilerSimpleTest, IncrementIntegerParamsCreate) { |
32 scoped_ptr<base::ListValue> params_value(new base::ListValue()); | 33 std::unique_ptr<base::ListValue> params_value(new base::ListValue()); |
33 params_value->Append(new base::FundamentalValue(6)); | 34 params_value->Append(new base::FundamentalValue(6)); |
34 scoped_ptr<IncrementInteger::Params> params( | 35 std::unique_ptr<IncrementInteger::Params> params( |
35 IncrementInteger::Params::Create(*params_value)); | 36 IncrementInteger::Params::Create(*params_value)); |
36 EXPECT_TRUE(params.get()); | 37 EXPECT_TRUE(params.get()); |
37 EXPECT_EQ(6, params->num); | 38 EXPECT_EQ(6, params->num); |
38 } | 39 } |
39 | 40 |
40 TEST(JsonSchemaCompilerSimpleTest, NumberOfParams) { | 41 TEST(JsonSchemaCompilerSimpleTest, NumberOfParams) { |
41 { | 42 { |
42 scoped_ptr<base::ListValue> params_value(new base::ListValue()); | 43 std::unique_ptr<base::ListValue> params_value(new base::ListValue()); |
43 params_value->Append(new base::StringValue("text")); | 44 params_value->Append(new base::StringValue("text")); |
44 params_value->Append(new base::StringValue("text")); | 45 params_value->Append(new base::StringValue("text")); |
45 scoped_ptr<OptionalString::Params> params( | 46 std::unique_ptr<OptionalString::Params> params( |
46 OptionalString::Params::Create(*params_value)); | 47 OptionalString::Params::Create(*params_value)); |
47 EXPECT_FALSE(params.get()); | 48 EXPECT_FALSE(params.get()); |
48 } | 49 } |
49 { | 50 { |
50 scoped_ptr<base::ListValue> params_value(new base::ListValue()); | 51 std::unique_ptr<base::ListValue> params_value(new base::ListValue()); |
51 scoped_ptr<IncrementInteger::Params> params( | 52 std::unique_ptr<IncrementInteger::Params> params( |
52 IncrementInteger::Params::Create(*params_value)); | 53 IncrementInteger::Params::Create(*params_value)); |
53 EXPECT_FALSE(params.get()); | 54 EXPECT_FALSE(params.get()); |
54 } | 55 } |
55 } | 56 } |
56 | 57 |
57 TEST(JsonSchemaCompilerSimpleTest, OptionalStringParamsCreate) { | 58 TEST(JsonSchemaCompilerSimpleTest, OptionalStringParamsCreate) { |
58 { | 59 { |
59 scoped_ptr<base::ListValue> params_value(new base::ListValue()); | 60 std::unique_ptr<base::ListValue> params_value(new base::ListValue()); |
60 scoped_ptr<OptionalString::Params> params( | 61 std::unique_ptr<OptionalString::Params> params( |
61 OptionalString::Params::Create(*params_value)); | 62 OptionalString::Params::Create(*params_value)); |
62 EXPECT_TRUE(params.get()); | 63 EXPECT_TRUE(params.get()); |
63 EXPECT_FALSE(params->str.get()); | 64 EXPECT_FALSE(params->str.get()); |
64 } | 65 } |
65 { | 66 { |
66 scoped_ptr<base::ListValue> params_value(new base::ListValue()); | 67 std::unique_ptr<base::ListValue> params_value(new base::ListValue()); |
67 params_value->Append(new base::StringValue("asdf")); | 68 params_value->Append(new base::StringValue("asdf")); |
68 scoped_ptr<OptionalString::Params> params( | 69 std::unique_ptr<OptionalString::Params> params( |
69 OptionalString::Params::Create(*params_value)); | 70 OptionalString::Params::Create(*params_value)); |
70 EXPECT_TRUE(params.get()); | 71 EXPECT_TRUE(params.get()); |
71 EXPECT_TRUE(params->str.get()); | 72 EXPECT_TRUE(params->str.get()); |
72 EXPECT_EQ("asdf", *params->str); | 73 EXPECT_EQ("asdf", *params->str); |
73 } | 74 } |
74 } | 75 } |
75 | 76 |
76 TEST(JsonSchemaCompilerSimpleTest, OptionalParamsTakingNull) { | 77 TEST(JsonSchemaCompilerSimpleTest, OptionalParamsTakingNull) { |
77 { | 78 { |
78 scoped_ptr<base::ListValue> params_value(new base::ListValue()); | 79 std::unique_ptr<base::ListValue> params_value(new base::ListValue()); |
79 params_value->Append(base::Value::CreateNullValue()); | 80 params_value->Append(base::Value::CreateNullValue()); |
80 scoped_ptr<OptionalString::Params> params( | 81 std::unique_ptr<OptionalString::Params> params( |
81 OptionalString::Params::Create(*params_value)); | 82 OptionalString::Params::Create(*params_value)); |
82 EXPECT_TRUE(params.get()); | 83 EXPECT_TRUE(params.get()); |
83 EXPECT_FALSE(params->str.get()); | 84 EXPECT_FALSE(params->str.get()); |
84 } | 85 } |
85 } | 86 } |
86 | 87 |
87 TEST(JsonSchemaCompilerSimpleTest, OptionalStringParamsWrongType) { | 88 TEST(JsonSchemaCompilerSimpleTest, OptionalStringParamsWrongType) { |
88 { | 89 { |
89 scoped_ptr<base::ListValue> params_value(new base::ListValue()); | 90 std::unique_ptr<base::ListValue> params_value(new base::ListValue()); |
90 params_value->Append(new base::FundamentalValue(5)); | 91 params_value->Append(new base::FundamentalValue(5)); |
91 scoped_ptr<OptionalString::Params> params( | 92 std::unique_ptr<OptionalString::Params> params( |
92 OptionalString::Params::Create(*params_value)); | 93 OptionalString::Params::Create(*params_value)); |
93 EXPECT_FALSE(params.get()); | 94 EXPECT_FALSE(params.get()); |
94 } | 95 } |
95 } | 96 } |
96 | 97 |
97 TEST(JsonSchemaCompilerSimpleTest, OptionalBeforeRequired) { | 98 TEST(JsonSchemaCompilerSimpleTest, OptionalBeforeRequired) { |
98 { | 99 { |
99 scoped_ptr<base::ListValue> params_value(new base::ListValue()); | 100 std::unique_ptr<base::ListValue> params_value(new base::ListValue()); |
100 params_value->Append(base::Value::CreateNullValue()); | 101 params_value->Append(base::Value::CreateNullValue()); |
101 params_value->Append(new base::StringValue("asdf")); | 102 params_value->Append(new base::StringValue("asdf")); |
102 scoped_ptr<OptionalBeforeRequired::Params> params( | 103 std::unique_ptr<OptionalBeforeRequired::Params> params( |
103 OptionalBeforeRequired::Params::Create(*params_value)); | 104 OptionalBeforeRequired::Params::Create(*params_value)); |
104 EXPECT_TRUE(params.get()); | 105 EXPECT_TRUE(params.get()); |
105 EXPECT_FALSE(params->first.get()); | 106 EXPECT_FALSE(params->first.get()); |
106 EXPECT_EQ("asdf", params->second); | 107 EXPECT_EQ("asdf", params->second); |
107 } | 108 } |
108 } | 109 } |
109 | 110 |
110 TEST(JsonSchemaCompilerSimpleTest, NoParamsResultCreate) { | 111 TEST(JsonSchemaCompilerSimpleTest, NoParamsResultCreate) { |
111 scoped_ptr<base::ListValue> results = OptionalString::Results::Create(); | 112 std::unique_ptr<base::ListValue> results = OptionalString::Results::Create(); |
112 base::ListValue expected; | 113 base::ListValue expected; |
113 EXPECT_TRUE(results->Equals(&expected)); | 114 EXPECT_TRUE(results->Equals(&expected)); |
114 } | 115 } |
115 | 116 |
116 TEST(JsonSchemaCompilerSimpleTest, TestTypePopulate) { | 117 TEST(JsonSchemaCompilerSimpleTest, TestTypePopulate) { |
117 { | 118 { |
118 scoped_ptr<TestType> test_type(new TestType()); | 119 std::unique_ptr<TestType> test_type(new TestType()); |
119 scoped_ptr<base::DictionaryValue> value = CreateTestTypeDictionary(); | 120 std::unique_ptr<base::DictionaryValue> value = CreateTestTypeDictionary(); |
120 EXPECT_TRUE(TestType::Populate(*value, test_type.get())); | 121 EXPECT_TRUE(TestType::Populate(*value, test_type.get())); |
121 EXPECT_EQ("bling", test_type->string); | 122 EXPECT_EQ("bling", test_type->string); |
122 EXPECT_EQ(1.1, test_type->number); | 123 EXPECT_EQ(1.1, test_type->number); |
123 EXPECT_EQ(4, test_type->integer); | 124 EXPECT_EQ(4, test_type->integer); |
124 EXPECT_EQ(true, test_type->boolean); | 125 EXPECT_EQ(true, test_type->boolean); |
125 EXPECT_TRUE(value->Equals(test_type->ToValue().get())); | 126 EXPECT_TRUE(value->Equals(test_type->ToValue().get())); |
126 } | 127 } |
127 { | 128 { |
128 scoped_ptr<TestType> test_type(new TestType()); | 129 std::unique_ptr<TestType> test_type(new TestType()); |
129 scoped_ptr<base::DictionaryValue> value = CreateTestTypeDictionary(); | 130 std::unique_ptr<base::DictionaryValue> value = CreateTestTypeDictionary(); |
130 value->Remove("number", NULL); | 131 value->Remove("number", NULL); |
131 EXPECT_FALSE(TestType::Populate(*value, test_type.get())); | 132 EXPECT_FALSE(TestType::Populate(*value, test_type.get())); |
132 } | 133 } |
133 } | 134 } |
134 | 135 |
135 TEST(JsonSchemaCompilerSimpleTest, GetTestType) { | 136 TEST(JsonSchemaCompilerSimpleTest, GetTestType) { |
136 { | 137 { |
137 scoped_ptr<base::DictionaryValue> value = CreateTestTypeDictionary(); | 138 std::unique_ptr<base::DictionaryValue> value = CreateTestTypeDictionary(); |
138 scoped_ptr<TestType> test_type(new TestType()); | 139 std::unique_ptr<TestType> test_type(new TestType()); |
139 EXPECT_TRUE(TestType::Populate(*value, test_type.get())); | 140 EXPECT_TRUE(TestType::Populate(*value, test_type.get())); |
140 scoped_ptr<base::ListValue> results = | 141 std::unique_ptr<base::ListValue> results = |
141 GetTestType::Results::Create(*test_type); | 142 GetTestType::Results::Create(*test_type); |
142 | 143 |
143 base::DictionaryValue* result = NULL; | 144 base::DictionaryValue* result = NULL; |
144 results->GetDictionary(0, &result); | 145 results->GetDictionary(0, &result); |
145 EXPECT_TRUE(result->Equals(value.get())); | 146 EXPECT_TRUE(result->Equals(value.get())); |
146 } | 147 } |
147 } | 148 } |
148 | 149 |
149 TEST(JsonSchemaCompilerSimpleTest, OnIntegerFiredCreate) { | 150 TEST(JsonSchemaCompilerSimpleTest, OnIntegerFiredCreate) { |
150 { | 151 { |
151 scoped_ptr<base::ListValue> results(OnIntegerFired::Create(5)); | 152 std::unique_ptr<base::ListValue> results(OnIntegerFired::Create(5)); |
152 base::ListValue expected; | 153 base::ListValue expected; |
153 expected.Append(new base::FundamentalValue(5)); | 154 expected.Append(new base::FundamentalValue(5)); |
154 EXPECT_TRUE(results->Equals(&expected)); | 155 EXPECT_TRUE(results->Equals(&expected)); |
155 } | 156 } |
156 } | 157 } |
157 | 158 |
158 TEST(JsonSchemaCompilerSimpleTest, OnStringFiredCreate) { | 159 TEST(JsonSchemaCompilerSimpleTest, OnStringFiredCreate) { |
159 { | 160 { |
160 scoped_ptr<base::ListValue> results(OnStringFired::Create("yo dawg")); | 161 std::unique_ptr<base::ListValue> results(OnStringFired::Create("yo dawg")); |
161 base::ListValue expected; | 162 base::ListValue expected; |
162 expected.Append(new base::StringValue("yo dawg")); | 163 expected.Append(new base::StringValue("yo dawg")); |
163 EXPECT_TRUE(results->Equals(&expected)); | 164 EXPECT_TRUE(results->Equals(&expected)); |
164 } | 165 } |
165 } | 166 } |
166 | 167 |
167 TEST(JsonSchemaCompilerSimpleTest, OnTestTypeFiredCreate) { | 168 TEST(JsonSchemaCompilerSimpleTest, OnTestTypeFiredCreate) { |
168 { | 169 { |
169 TestType some_test_type; | 170 TestType some_test_type; |
170 scoped_ptr<base::DictionaryValue> expected = CreateTestTypeDictionary(); | 171 std::unique_ptr<base::DictionaryValue> expected = |
| 172 CreateTestTypeDictionary(); |
171 ASSERT_TRUE(expected->GetDouble("number", &some_test_type.number)); | 173 ASSERT_TRUE(expected->GetDouble("number", &some_test_type.number)); |
172 ASSERT_TRUE(expected->GetString("string", &some_test_type.string)); | 174 ASSERT_TRUE(expected->GetString("string", &some_test_type.string)); |
173 ASSERT_TRUE(expected->GetInteger("integer", &some_test_type.integer)); | 175 ASSERT_TRUE(expected->GetInteger("integer", &some_test_type.integer)); |
174 ASSERT_TRUE(expected->GetBoolean("boolean", &some_test_type.boolean)); | 176 ASSERT_TRUE(expected->GetBoolean("boolean", &some_test_type.boolean)); |
175 | 177 |
176 scoped_ptr<base::ListValue> results( | 178 std::unique_ptr<base::ListValue> results( |
177 OnTestTypeFired::Create(some_test_type)); | 179 OnTestTypeFired::Create(some_test_type)); |
178 base::DictionaryValue* result = NULL; | 180 base::DictionaryValue* result = NULL; |
179 results->GetDictionary(0, &result); | 181 results->GetDictionary(0, &result); |
180 EXPECT_TRUE(result->Equals(expected.get())); | 182 EXPECT_TRUE(result->Equals(expected.get())); |
181 } | 183 } |
182 } | 184 } |
OLD | NEW |