Add a base::ParseJson() function to help tests construct Values.

content/renderer/v8_value_converter_impl_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 <cmath>
 
 #include "base/memory/scoped_ptr.h"
+#include "base/test/values_test_util.h"
 #include "base/values.h"
 #include "content/renderer/v8_value_converter_impl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "v8/include/v8.h"
 
 namespace content {
 
 namespace {
 
 // A dumb getter for an object's named callback.
@@ skipping 139 matching lines @@
       ASSERT_TRUE(list->Get(0, &temp));
       EXPECT_EQ(Value::TYPE_NULL, temp->GetType());
     }
   }
 
   // Context for the JavaScript in the test.
   v8::Persistent<v8::Context> context_;
 };
 
 TEST_F(V8ValueConverterImplTest, BasicRoundTrip) {
-  DictionaryValue original_root;
-  original_root.Set("null", Value::CreateNullValue());
-  original_root.Set("true", Value::CreateBooleanValue(true));
-  original_root.Set("false", Value::CreateBooleanValue(false));
-  original_root.Set("positive-int", Value::CreateIntegerValue(42));
-  original_root.Set("negative-int", Value::CreateIntegerValue(-42));
-  original_root.Set("zero", Value::CreateIntegerValue(0));
-  original_root.Set("double", Value::CreateDoubleValue(88.8));
-  original_root.Set("big-integral-double",
-                    Value::CreateDoubleValue(pow(2.0, 53)));
-  original_root.Set("string", Value::CreateStringValue("foobar"));
-  original_root.Set("empty-string", Value::CreateStringValue(""));
-
-  DictionaryValue* original_sub1 = new DictionaryValue();
-  original_sub1->Set("foo", Value::CreateStringValue("bar"));
-  original_sub1->Set("hot", Value::CreateStringValue("dog"));
-  original_root.Set("dictionary", original_sub1);
-  original_root.Set("empty-dictionary", new DictionaryValue());
-
-  ListValue* original_sub2 = new ListValue();
-  original_sub2->Append(Value::CreateStringValue("monkey"));
-  original_sub2->Append(Value::CreateStringValue("balls"));
-  original_root.Set("list", original_sub2);
-  original_root.Set("empty-list", new ListValue());
+  scoped_ptr<Value> original_root = base::ParseJson(
+      "{ \n"
+      "  \"null\": null, \n"
+      "  \"true\": true, \n"
+      "  \"false\": false, \n"
+      "  \"positive-int\": 42, \n"
+      "  \"negative-int\": -42, \n"
+      "  \"zero\": 0, \n"
+      "  \"double\": 88.8, \n"
+      "  \"big-integral-double\": 9007199254740992.0, \n" // 2.0^53
+      "  \"string\": \"foobar\", \n"
+      "  \"empty-string\": \"\", \n"
+      "  \"dictionary\": { \n"
+      "    \"foo\": \"bar\",\n"
+      "    \"hot\": \"dog\",\n"
+      "  }, \n"
+      "  \"empty-dictionary\": {}, \n"
+      "  \"list\": [ \"monkey\", \"balls\" ], \n"
+      "  \"empty-list\": [], \n"
+      "}");
 
   v8::Context::Scope context_scope(context_);
   v8::HandleScope handle_scope;
 
   V8ValueConverterImpl converter;
   v8::Handle<v8::Object> v8_object =
-      converter.ToV8Value(&original_root, context_).As<v8::Object>();
+      converter.ToV8Value(original_root.get(), context_).As<v8::Object>();
   ASSERT_FALSE(v8_object.IsEmpty());
 
-  EXPECT_EQ(original_root.size(), v8_object->GetPropertyNames()->Length());
+  EXPECT_EQ(static_cast<const DictionaryValue&>(*original_root).size(),
+            v8_object->GetPropertyNames()->Length());
   EXPECT_TRUE(v8_object->Get(v8::String::New("null"))->IsNull());
   EXPECT_TRUE(v8_object->Get(v8::String::New("true"))->IsTrue());
   EXPECT_TRUE(v8_object->Get(v8::String::New("false"))->IsFalse());
   EXPECT_TRUE(v8_object->Get(v8::String::New("positive-int"))->IsInt32());
   EXPECT_TRUE(v8_object->Get(v8::String::New("negative-int"))->IsInt32());
   EXPECT_TRUE(v8_object->Get(v8::String::New("zero"))->IsInt32());
   EXPECT_TRUE(v8_object->Get(v8::String::New("double"))->IsNumber());
   EXPECT_TRUE(
       v8_object->Get(v8::String::New("big-integral-double"))->IsNumber());
   EXPECT_TRUE(v8_object->Get(v8::String::New("string"))->IsString());
   EXPECT_TRUE(v8_object->Get(v8::String::New("empty-string"))->IsString());
   EXPECT_TRUE(v8_object->Get(v8::String::New("dictionary"))->IsObject());
   EXPECT_TRUE(v8_object->Get(v8::String::New("empty-dictionary"))->IsObject());
   EXPECT_TRUE(v8_object->Get(v8::String::New("list"))->IsArray());
   EXPECT_TRUE(v8_object->Get(v8::String::New("empty-list"))->IsArray());
 
   scoped_ptr<Value> new_root(converter.FromV8Value(v8_object, context_));
-  EXPECT_NE(&original_root, new_root.get());
-  EXPECT_TRUE(original_root.Equals(new_root.get()));
+  EXPECT_NE(original_root.get(), new_root.get());
+  EXPECT_TRUE(original_root->Equals(new_root.get()));
 }
 
 TEST_F(V8ValueConverterImplTest, KeysWithDots) {
-  DictionaryValue original;
-  original.SetWithoutPathExpansion("foo.bar", Value::CreateStringValue("baz"));
+  scoped_ptr<Value> original = base::ParseJson("{ \"foo.bar\": \"baz\" }");
 
   v8::Context::Scope context_scope(context_);
   v8::HandleScope handle_scope;
 
   V8ValueConverterImpl converter;
   scoped_ptr<Value> copy(
       converter.FromV8Value(
-          converter.ToV8Value(&original, context_), context_));
+          converter.ToV8Value(original.get(), context_), context_));
 
-  EXPECT_TRUE(original.Equals(copy.get()));
+  EXPECT_TRUE(original->Equals(copy.get()));
 }
 
 TEST_F(V8ValueConverterImplTest, ObjectExceptions) {
   v8::Context::Scope context_scope(context_);
   v8::HandleScope handle_scope;
 
   // Set up objects to throw when reading or writing 'foo'.
   const char* source =
       "Object.prototype.__defineSetter__('foo', "
       "    function() { throw new Error('muah!'); });"
@@ skipping 47 matching lines @@
   // Converting from v8 value should replace the first item with null.
   V8ValueConverterImpl converter;
   scoped_ptr<ListValue> converted(static_cast<ListValue*>(
       converter.FromV8Value(array, context_)));
   ASSERT_TRUE(converted.get());
   // http://code.google.com/p/v8/issues/detail?id=1342
   EXPECT_EQ(2u, converted->GetSize());
   EXPECT_TRUE(IsNull(converted.get(), 0));
 
   // Converting to v8 value should drop the first item and leave a hole.
-  converted.reset(new ListValue());
-  converted->Append(Value::CreateStringValue("foo"));
-  converted->Append(Value::CreateStringValue("bar"));
+  converted.reset(static_cast<ListValue*>(
+      base::ParseJson("[ \"foo\", \"bar\" ]").release()));
   v8::Handle<v8::Array> copy =
       converter.ToV8Value(converted.get(), context_).As<v8::Array>();
   ASSERT_FALSE(copy.IsEmpty());
   EXPECT_EQ(2u, copy->Length());
   EXPECT_EQ("bar", GetString(copy, 1));
 }
 
 TEST_F(V8ValueConverterImplTest, WeirdTypes) {
   v8::Context::Scope context_scope(context_);
   v8::HandleScope handle_scope;
@@ skipping 154 matching lines @@
       "};"
       "})();";
 
   v8::Handle<v8::Script> script(v8::Script::New(v8::String::New(source)));
   v8::Handle<v8::Object> object = script->Run().As<v8::Object>();
   ASSERT_FALSE(object.IsEmpty());
 
   V8ValueConverterImpl converter;
   scoped_ptr<Value> actual(converter.FromV8Value(object, context_));
 
-  DictionaryValue expected;
-  expected.SetString("1", "foo");
-  expected.SetString("2", "bar");
-  expected.SetString("true", "baz");
-  expected.SetString("false", "qux");
-  expected.SetString("null", "quux");
-  expected.SetString("undefined", "oops");
+  scoped_ptr<Value> expected = base::ParseJson(
+      "{ \n"
+      "  \"1\": \"foo\", \n"
+      "  \"2\": \"bar\", \n"
+      "  \"true\": \"baz\", \n"
+      "  \"false\": \"qux\", \n"
+      "  \"null\": \"quux\", \n"
+      "  \"undefined\": \"oops\", \n"
+      "}");
 
-  EXPECT_TRUE(expected.Equals(actual.get()));
+  EXPECT_TRUE(expected->Equals(actual.get()));
 }
 
 TEST_F(V8ValueConverterImplTest, ArrayGetters) {
   v8::Context::Scope context_scope(context_);
   v8::HandleScope handle_scope;
 
   const char* source = "(function() {"
       "var a = [0];"
       "a.__defineGetter__(1, function() { return 'bar'; });"
       "return a;"
@@ skipping 29 matching lines @@
     const char* source = "(function() {"
         "return [ undefined, null, function(){} ];"
         "})();";
     v8::Handle<v8::Script> script(v8::Script::New(v8::String::New(source)));
     array = script->Run().As<v8::Array>();
     ASSERT_FALSE(array.IsEmpty());
   }
 
   V8ValueConverterImpl converter;
 
-  DictionaryValue expected_object;
-  expected_object.Set("bar", Value::CreateNullValue());
   scoped_ptr<Value> actual_object(converter.FromV8Value(object, context_));
-  EXPECT_TRUE(Value::Equals(&expected_object, actual_object.get()));
+  EXPECT_TRUE(Value::Equals(base::ParseJson("{ \"bar\": null }").get(),
+                            actual_object.get()));
 
-  ListValue expected_array;
   // Everything is null because JSON stringification preserves array length.
-  expected_array.Append(Value::CreateNullValue());
-  expected_array.Append(Value::CreateNullValue());
-  expected_array.Append(Value::CreateNullValue());
   scoped_ptr<Value> actual_array(converter.FromV8Value(array, context_));
-  EXPECT_TRUE(Value::Equals(&expected_array, actual_array.get()));
+  EXPECT_TRUE(Value::Equals(base::ParseJson("[ null, null, null ]").get(),
+                            actual_array.get()));
 }
 
 }  // namespace content