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