tools/json_schema_compiler/test/simple_api_unittest.cc

   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
   9 using namespace test::api::simple_api;
  10
  11 namespace {
  12
  13 static 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
  24 TEST(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
  31 TEST(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
  40 TEST(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
  57 TEST(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
  76 TEST(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
  87 TEST(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
  97 TEST(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
 110 TEST(JsonSchemaCompilerSimpleTest, NoParamsResultCreate) {
 111   scoped_ptr<ListValue> results = OptionalString::Results::Create();
 112   ListValue expected;
 113   EXPECT_TRUE(results->Equals(&expected));
 114 }
 115
 116 TEST(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
 135 TEST(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
 148 TEST(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
 157 TEST(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
 166 TEST(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 }