Home | History | Annotate | Download | only in test 
      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 #include "tools/json_schema_compiler/test/crossref.h"
      7 
      8 #include "testing/gtest/include/gtest/gtest.h"
      9 
     10 using namespace test::api::crossref;
     11 
     12 namespace {
     13 
     14 static scoped_ptr<base::DictionaryValue> CreateTestTypeDictionary() {
     15   base::DictionaryValue* value(new base::DictionaryValue());
     16   value->SetWithoutPathExpansion("number", new base::FundamentalValue(1.1));
     17   value->SetWithoutPathExpansion("integer", new base::FundamentalValue(4));
     18   value->SetWithoutPathExpansion("string", new base::StringValue("bling"));
     19   value->SetWithoutPathExpansion("boolean", new base::FundamentalValue(true));
     20   return scoped_ptr<base::DictionaryValue>(value);
     21 }
     22 
     23 }  // namespace
     24 
     25 TEST(JsonSchemaCompilerCrossrefTest, CrossrefTypePopulate) {
     26   scoped_ptr<CrossrefType> crossref_type(new CrossrefType());
     27   scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
     28   value->Set("testType", CreateTestTypeDictionary().release());
     29   EXPECT_TRUE(CrossrefType::Populate(*value, crossref_type.get()));
     30   EXPECT_TRUE(crossref_type->test_type.get());
     31   EXPECT_TRUE(CreateTestTypeDictionary()->Equals(
     32         crossref_type->test_type->ToValue().get()));
     33   EXPECT_TRUE(value->Equals(crossref_type->ToValue().get()));
     34 }
     35 
     36 TEST(JsonSchemaCompilerCrossrefTest, TestTypeOptionalParamCreate) {
     37   scoped_ptr<base::ListValue> params_value(new base::ListValue());
     38   params_value->Append(CreateTestTypeDictionary().release());
     39   scoped_ptr<TestTypeOptionalParam::Params> params(
     40       TestTypeOptionalParam::Params::Create(*params_value));
     41   EXPECT_TRUE(params.get());
     42   EXPECT_TRUE(params->test_type.get());
     43   EXPECT_TRUE(
     44       CreateTestTypeDictionary()->Equals(params->test_type->ToValue().get()));
     45 }
     46 
     47 TEST(JsonSchemaCompilerCrossrefTest, TestTypeOptionalParamFail) {
     48   scoped_ptr<base::ListValue> params_value(new base::ListValue());
     49   scoped_ptr<base::DictionaryValue> test_type_value =
     50       CreateTestTypeDictionary();
     51   test_type_value->RemoveWithoutPathExpansion("number", NULL);
     52   params_value->Append(test_type_value.release());
     53   scoped_ptr<TestTypeOptionalParam::Params> params(
     54       TestTypeOptionalParam::Params::Create(*params_value));
     55   EXPECT_FALSE(params.get());
     56 }
     57 
     58 TEST(JsonSchemaCompilerCrossrefTest, GetTestType) {
     59   scoped_ptr<base::DictionaryValue> value = CreateTestTypeDictionary();
     60   scoped_ptr<test::api::simple_api::TestType> test_type(
     61       new test::api::simple_api::TestType());
     62   EXPECT_TRUE(
     63       test::api::simple_api::TestType::Populate(*value, test_type.get()));
     64 
     65   scoped_ptr<base::ListValue> results =
     66       GetTestType::Results::Create(*test_type);
     67   base::DictionaryValue* result_dict = NULL;
     68   results->GetDictionary(0, &result_dict);
     69   EXPECT_TRUE(value->Equals(result_dict));
     70 }
     71 
     72 TEST(JsonSchemaCompilerCrossrefTest, TestTypeInObjectParamsCreate) {
     73   {
     74     scoped_ptr<base::ListValue> params_value(new base::ListValue());
     75     scoped_ptr<base::DictionaryValue> param_object_value(
     76         new base::DictionaryValue());
     77     param_object_value->Set("testType", CreateTestTypeDictionary().release());
     78     param_object_value->Set("boolean", new base::FundamentalValue(true));
     79     params_value->Append(param_object_value.release());
     80     scoped_ptr<TestTypeInObject::Params> params(
     81         TestTypeInObject::Params::Create(*params_value));
     82     EXPECT_TRUE(params.get());
     83     EXPECT_TRUE(params->param_object.test_type.get());
     84     EXPECT_TRUE(params->param_object.boolean);
     85     EXPECT_TRUE(CreateTestTypeDictionary()->Equals(
     86           params->param_object.test_type->ToValue().get()));
     87   }
     88   {
     89     scoped_ptr<base::ListValue> params_value(new base::ListValue());
     90     scoped_ptr<base::DictionaryValue> param_object_value(
     91         new base::DictionaryValue());
     92     param_object_value->Set("boolean", new base::FundamentalValue(true));
     93     params_value->Append(param_object_value.release());
     94     scoped_ptr<TestTypeInObject::Params> params(
     95         TestTypeInObject::Params::Create(*params_value));
     96     EXPECT_TRUE(params.get());
     97     EXPECT_FALSE(params->param_object.test_type.get());
     98     EXPECT_TRUE(params->param_object.boolean);
     99   }
    100   {
    101     scoped_ptr<base::ListValue> params_value(new base::ListValue());
    102     scoped_ptr<base::DictionaryValue> param_object_value(
    103         new base::DictionaryValue());
    104     param_object_value->Set("testType", new base::StringValue("invalid"));
    105     param_object_value->Set("boolean", new base::FundamentalValue(true));
    106     params_value->Append(param_object_value.release());
    107     scoped_ptr<TestTypeInObject::Params> params(
    108         TestTypeInObject::Params::Create(*params_value));
    109     EXPECT_FALSE(params.get());
    110   }
    111   {
    112     scoped_ptr<base::ListValue> params_value(new base::ListValue());
    113     scoped_ptr<base::DictionaryValue> param_object_value(
    114         new base::DictionaryValue());
    115     param_object_value->Set("testType", CreateTestTypeDictionary().release());
    116     params_value->Append(param_object_value.release());
    117     scoped_ptr<TestTypeInObject::Params> params(
    118         TestTypeInObject::Params::Create(*params_value));
    119     EXPECT_FALSE(params.get());
    120   }
    121 }
    122