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::test::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::test::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::test::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::test::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::test::ParseJson("{ \"bar\": null }").get(),

[battre, 2012/12/17 09:36:49]

Is this one guaranteed to be correct? I can see that the Value returned by
ParseJson can be discarded after calling get().

[Jeffrey Yasskin, 2012/12/17 18:09:27]

The scoped_ptr is destroyed, destroying the Value, at the end of the
"full-expression", roughly at the semicolon. Inside EXPECT(), it'll definitely
get destroyed after all the function calls it appears in, although likely before
(for example) other arguments are streamed into the EXPECT's failure message.
Since it's only used inside the Value::Equals() call, this is safe.

+                            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::test::ParseJson("[ null, null, null ]").get(),

[battre, 2012/12/17 09:36:49]

same here.

[Jeffrey Yasskin, 2012/12/17 18:09:27]

same here. :)

+                            actual_array.get()));
 }
 
 }  // namespace content