JSON Schema Compiler: Added event compilation.

tools/json_schema_compiler/test/arrays_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "tools/json_schema_compiler/test/arrays.h"
 
+#include "chrome/common/extensions/value_builder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using namespace test::api::arrays;
+using namespace extensions;
 
 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));
-  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 DictionaryBuilder()
+      .Set("numbers", ListBuilder().Append(6.1))
+      .Set("booleans", ListBuilder().AppendBoolean(false).AppendBoolean(true))
+      .Set("strings", ListBuilder().Append("a").Append("b").Append("c")
+                                   .Append("it's easy as"))
+      .Set("integers", ListBuilder().Append(1).Append(2).Append(3))
+      .Build().Pass();
 }
 
 static Value* CreateItemValue(int val) {
-  DictionaryValue* value(new DictionaryValue());
-  value->Set("val", Value::CreateIntegerValue(val));
-  return value;
+  return DictionaryBuilder().Set("val", val).Build().release();
 }
 
 }  // namespace
 
 TEST(JsonSchemaCompilerArrayTest, BasicArrayType) {
   {
     scoped_ptr<DictionaryValue> value = CreateBasicArrayTypeDictionary();
     scoped_ptr<BasicArrayType> basic_array_type(new BasicArrayType());
     EXPECT_TRUE(BasicArrayType::Populate(*value, basic_array_type.get()));
     EXPECT_TRUE(value->Equals(basic_array_type->ToValue().get()));
@@ skipping 136 matching lines @@
   EXPECT_TRUE(params.get());
   ASSERT_EQ(2u, params->refs.size());
   EXPECT_EQ(1, params->refs[0]->val);
   EXPECT_EQ(2, params->refs[1]->val);
 }
 
 TEST(JsonSchemaCompilerArrayTest, ReturnIntegerArrayResultCreate) {
   std::vector<int> integers;
   integers.push_back(1);
   integers.push_back(2);
-  scoped_ptr<Value> result(ReturnIntegerArray::Result::Create(integers));
-  ListValue* list = NULL;
-  EXPECT_TRUE(result->GetAsList(&list));
-  int temp;
-  ASSERT_EQ(2u, list->GetSize());
-  EXPECT_TRUE(list->GetInteger(0, &temp));
-  EXPECT_EQ(1, temp);
-  EXPECT_TRUE(list->GetInteger(1, &temp));
-  EXPECT_EQ(2, temp);
+  scoped_ptr<Value> results(ReturnIntegerArray::Result::Create(integers));
+
+  ListValue expected;
+  ListValue* expected_argument = new ListValue();
+  expected_argument->Append(Value::CreateIntegerValue(1));
+  expected_argument->Append(Value::CreateIntegerValue(2));
+  expected.Append(expected_argument);
+  EXPECT_TRUE(results->Equals(&expected));
 }
 
 TEST(JsonSchemaCompilerArrayTest, ReturnRefArrayResultCreate) {
   std::vector<linked_ptr<Item> > items;
   items.push_back(linked_ptr<Item>(new Item()));
   items.push_back(linked_ptr<Item>(new Item()));
   items[0]->val = 1;
   items[1]->val = 2;
-  scoped_ptr<Value> result(ReturnRefArray::Result::Create(items));
-  ListValue* list = NULL;
-  EXPECT_TRUE(result->GetAsList(&list));
-  ASSERT_EQ(2u, list->GetSize());
-  DictionaryValue* item_value = NULL;
-  int temp;
-  EXPECT_TRUE(list->GetDictionary(0, &item_value));
-  EXPECT_TRUE(item_value->GetInteger("val", &temp));
-  EXPECT_EQ(1, temp);
-  EXPECT_TRUE(list->GetDictionary(1, &item_value));
-  EXPECT_TRUE(item_value->GetInteger("val", &temp));
-  EXPECT_EQ(2, temp);
+  scoped_ptr<Value> results(ReturnRefArray::Result::Create(items));
+
+  ListValue expected;
+  ListValue* expected_argument = new ListValue();
+  DictionaryValue* first = new DictionaryValue();
+  first->SetInteger("val", 1);
+  expected_argument->Append(first);
+  DictionaryValue* second = new DictionaryValue();
+  second->SetInteger("val", 2);
+  expected_argument->Append(second);
+  expected.Append(expected_argument);
+  EXPECT_TRUE(results->Equals(&expected));
 }