Convert //tools to use std::unique_ptr

tools/json_schema_compiler/test/error_generation_unittest.cc

 // Copyright 2013 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/error_generation.h"
 
 #include "base/json/json_writer.h"
 #include "base/strings/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "tools/json_schema_compiler/test/test_util.h"
@@ skipping 15 matching lines @@
                                      const base::string16& actual) {
   if (base::ASCIIToUTF16(expected) != actual)
     return testing::AssertionFailure() << expected << " != " << actual;
   return testing::AssertionSuccess();
 }
 
 // GenerateTypePopulate errors
 
 TEST(JsonSchemaCompilerErrorTest, RequiredPropertyPopulate) {
   {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "string", new base::StringValue("bling"));
+    std::unique_ptr<base::DictionaryValue> value =
+        Dictionary("string", new base::StringValue("bling"));
     EXPECT_TRUE(EqualsUtf16("", GetPopulateError<TestType>(*value)));
   }
   {
-    scoped_ptr<base::BinaryValue> value(new base::BinaryValue());
+    std::unique_ptr<base::BinaryValue> value(new base::BinaryValue());
     EXPECT_TRUE(EqualsUtf16("expected dictionary, got binary",
         GetPopulateError<TestType>(*value)));
   }
 }
 
 TEST(JsonSchemaCompilerErrorTest, UnexpectedTypePopulation) {
   {
-    scoped_ptr<base::ListValue> value(new base::ListValue());
+    std::unique_ptr<base::ListValue> value(new base::ListValue());
     EXPECT_TRUE(EqualsUtf16("",
         GetPopulateError<ChoiceType::Integers>(*value)));
   }
   {
-    scoped_ptr<base::BinaryValue> value(new base::BinaryValue());
+    std::unique_ptr<base::BinaryValue> value(new base::BinaryValue());
     EXPECT_TRUE(EqualsUtf16("expected integers or integer, got binary",
         GetPopulateError<ChoiceType::Integers>(*value)));
   }
 }
 
 // GenerateTypePopulateProperty errors
 
 TEST(JsonSchemaCompilerErrorTest, TypeIsRequired) {
   {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "integers", new FundamentalValue(5));
+    std::unique_ptr<base::DictionaryValue> value =
+        Dictionary("integers", new FundamentalValue(5));
     EXPECT_TRUE(EqualsUtf16("", GetPopulateError<ChoiceType>(*value)));
   }
   {
-    scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+    std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
     EXPECT_TRUE(EqualsUtf16("'integers' is required",
         GetPopulateError<ChoiceType>(*value)));
   }
 }
 
 // GenerateParamsCheck errors
 
 TEST(JsonSchemaCompilerErrorTest, TooManyParameters) {
   {
-    scoped_ptr<base::ListValue> params_value = List(
-        new FundamentalValue(5));
+    std::unique_ptr<base::ListValue> params_value =
+        List(new FundamentalValue(5));
     base::string16 error;
     EXPECT_TRUE(TestFunction::Params::Create(*params_value, &error));
   }
   {
-    scoped_ptr<base::ListValue> params_value = List(
-        new FundamentalValue(5),
-        new FundamentalValue(5));
+    std::unique_ptr<base::ListValue> params_value =
+        List(new FundamentalValue(5), new FundamentalValue(5));
     base::string16 error;
     EXPECT_FALSE(TestFunction::Params::Create(*params_value, &error));
     EXPECT_TRUE(EqualsUtf16("expected 1 arguments, got 2", error));
   }
 }
 
 // GenerateFunctionParamsCreate errors
 
 TEST(JsonSchemaCompilerErrorTest, ParamIsRequired) {
   {
-    scoped_ptr<base::ListValue> params_value = List(
-        new FundamentalValue(5));
+    std::unique_ptr<base::ListValue> params_value =
+        List(new FundamentalValue(5));
     base::string16 error;
     EXPECT_TRUE(TestFunction::Params::Create(*params_value, &error));
   }
   {
-    scoped_ptr<base::ListValue> params_value =
+    std::unique_ptr<base::ListValue> params_value =
         List(base::Value::CreateNullValue().release());
     base::string16 error;
     EXPECT_FALSE(TestFunction::Params::Create(*params_value, &error));
     EXPECT_TRUE(EqualsUtf16("'num' is required", error));
   }
 }
 
 // GeneratePopulateVariableFromValue errors
 
 TEST(JsonSchemaCompilerErrorTest, WrongPropertyValueType) {
   {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-      "string", new base::StringValue("yes"));
+    std::unique_ptr<base::DictionaryValue> value =
+        Dictionary("string", new base::StringValue("yes"));
     EXPECT_TRUE(EqualsUtf16("", GetPopulateError<TestType>(*value)));
   }
   {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "string", new FundamentalValue(1.1));
+    std::unique_ptr<base::DictionaryValue> value =
+        Dictionary("string", new FundamentalValue(1.1));
     EXPECT_TRUE(EqualsUtf16("'string': expected string, got number",
         GetPopulateError<TestType>(*value)));
   }
 }
 
 TEST(JsonSchemaCompilerErrorTest, WrongParameterCreationType) {
   {
     base::string16 error;
-    scoped_ptr<base::ListValue> params_value = List(
-        new base::StringValue("Yeah!"));
+    std::unique_ptr<base::ListValue> params_value =
+        List(new base::StringValue("Yeah!"));
     EXPECT_TRUE(TestString::Params::Create(*params_value, &error));
   }
   {
-    scoped_ptr<base::ListValue> params_value = List(
-        new FundamentalValue(5));
+    std::unique_ptr<base::ListValue> params_value =
+        List(new FundamentalValue(5));
     base::string16 error;
     EXPECT_FALSE(TestTypeInObject::Params::Create(*params_value, &error));
     EXPECT_TRUE(EqualsUtf16("'paramObject': expected dictionary, got integer",
         error));
   }
 }
 
 TEST(JsonSchemaCompilerErrorTest, WrongTypeValueType) {
   {
-    scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+    std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
     EXPECT_TRUE(EqualsUtf16("", GetPopulateError<ObjectType>(*value)));
   }
   {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "otherType", new FundamentalValue(1.1));
+    std::unique_ptr<base::DictionaryValue> value =
+        Dictionary("otherType", new FundamentalValue(1.1));
     ObjectType out;
     base::string16 error;
     EXPECT_TRUE(ObjectType::Populate(*value, &out, &error));
     EXPECT_TRUE(EqualsUtf16("'otherType': expected dictionary, got number",
         error));
     EXPECT_EQ(NULL, out.other_type.get());
   }
 }
 
 TEST(JsonSchemaCompilerErrorTest, UnableToPopulateArray) {
   {
-    scoped_ptr<base::ListValue> params_value = List(
-        new FundamentalValue(5));
+    std::unique_ptr<base::ListValue> params_value =
+        List(new FundamentalValue(5));
     EXPECT_TRUE(EqualsUtf16("",
         GetPopulateError<ChoiceType::Integers>(*params_value)));
   }
   {
-    scoped_ptr<base::ListValue> params_value = List(
-        new FundamentalValue(5),
-        new FundamentalValue(false));
+    std::unique_ptr<base::ListValue> params_value =
+        List(new FundamentalValue(5), new FundamentalValue(false));
     EXPECT_TRUE(EqualsUtf16(
         "expected integer, got boolean; unable to populate array 'integers'",
         GetPopulateError<ChoiceType::Integers>(*params_value)));
   }
 }
 
 TEST(JsonSchemaCompilerErrorTest, BinaryTypeExpected) {
   {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "data", new base::BinaryValue());
+    std::unique_ptr<base::DictionaryValue> value =
+        Dictionary("data", new base::BinaryValue());
     EXPECT_TRUE(EqualsUtf16("", GetPopulateError<BinaryData>(*value)));
   }
   {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "data", new FundamentalValue(1.1));
+    std::unique_ptr<base::DictionaryValue> value =
+        Dictionary("data", new FundamentalValue(1.1));
     EXPECT_TRUE(EqualsUtf16("'data': expected binary, got number",
         GetPopulateError<BinaryData>(*value)));
   }
 }
 
 TEST(JsonSchemaCompilerErrorTest, ListExpected) {
   {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "TheArray", new base::ListValue());
+    std::unique_ptr<base::DictionaryValue> value =
+        Dictionary("TheArray", new base::ListValue());
     EXPECT_TRUE(EqualsUtf16("", GetPopulateError<ArrayObject>(*value)));
   }
   {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "TheArray", new FundamentalValue(5));
+    std::unique_ptr<base::DictionaryValue> value =
+        Dictionary("TheArray", new FundamentalValue(5));
     EXPECT_TRUE(EqualsUtf16("'TheArray': expected list, got integer",
         GetPopulateError<ArrayObject>(*value)));
   }
 }
 
 // GenerateStringToEnumConversion errors
 
 TEST(JsonSchemaCompilerErrorTest, BadEnumValue) {
   {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "enumeration", new base::StringValue("one"));
+    std::unique_ptr<base::DictionaryValue> value =
+        Dictionary("enumeration", new base::StringValue("one"));
     EXPECT_TRUE(EqualsUtf16("", GetPopulateError<HasEnumeration>(*value)));
   }
   {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "enumeration", new base::StringValue("bad sauce"));
+    std::unique_ptr<base::DictionaryValue> value =
+        Dictionary("enumeration", new base::StringValue("bad sauce"));
     EXPECT_TRUE(EqualsUtf16("'Enumeration': expected \"one\" or \"two\" "
               "or \"three\", got \"bad sauce\"",
         GetPopulateError<HasEnumeration>(*value)));
   }
 }
 
 // Warn but don't fail out errors
 
 TEST(JsonSchemaCompilerErrorTest, WarnOnOptionalFailure) {
   {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "string", new base::StringValue("bling"));
+    std::unique_ptr<base::DictionaryValue> value =
+        Dictionary("string", new base::StringValue("bling"));
     EXPECT_TRUE(EqualsUtf16("", GetPopulateError<OptionalTestType>(*value)));
   }
   {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "string", new base::FundamentalValue(1));
+    std::unique_ptr<base::DictionaryValue> value =
+        Dictionary("string", new base::FundamentalValue(1));
 
     OptionalTestType out;
     base::string16 error;
     EXPECT_TRUE(OptionalTestType::Populate(*value, &out, &error));
     EXPECT_TRUE(EqualsUtf16("'string': expected string, got integer",
         error));
     EXPECT_EQ(NULL, out.string.get());
   }
 }
 
 TEST(JsonSchemaCompilerErrorTest, OptionalBinaryTypeFailure) {
   {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "data", new base::BinaryValue());
+    std::unique_ptr<base::DictionaryValue> value =
+        Dictionary("data", new base::BinaryValue());
     EXPECT_TRUE(EqualsUtf16("", GetPopulateError<OptionalBinaryData>(*value)));
   }
   {
     // There's a bug with silent failures if the key doesn't exist.
-    scoped_ptr<base::DictionaryValue> value = Dictionary("data",
-        new base::FundamentalValue(1));
+    std::unique_ptr<base::DictionaryValue> value =
+        Dictionary("data", new base::FundamentalValue(1));
 
     OptionalBinaryData out;
     base::string16 error;
     EXPECT_TRUE(OptionalBinaryData::Populate(*value, &out, &error));
     EXPECT_TRUE(EqualsUtf16("'data': expected binary, got integer",
         error));
     EXPECT_EQ(NULL, out.data.get());
   }
 }
 
 TEST(JsonSchemaCompilerErrorTest, OptionalArrayTypeFailure) {
   {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "TheArray", new base::ListValue());
+    std::unique_ptr<base::DictionaryValue> value =
+        Dictionary("TheArray", new base::ListValue());
     EXPECT_TRUE(EqualsUtf16("", GetPopulateError<ArrayObject>(*value)));
   }
   {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "TheArray", new FundamentalValue(5));
+    std::unique_ptr<base::DictionaryValue> value =
+        Dictionary("TheArray", new FundamentalValue(5));
     ArrayObject out;
     base::string16 error;
     EXPECT_TRUE(ArrayObject::Populate(*value, &out, &error));
     EXPECT_TRUE(EqualsUtf16("'TheArray': expected list, got integer",
         error));
     EXPECT_EQ(NULL, out.the_array.get());
   }
 }
 
 TEST(JsonSchemaCompilerErrorTest, OptionalUnableToPopulateArray) {
   {
-    scoped_ptr<base::ListValue> params_value = List(
-        new FundamentalValue(5));
+    std::unique_ptr<base::ListValue> params_value =
+        List(new FundamentalValue(5));
     EXPECT_TRUE(EqualsUtf16("",
         GetPopulateError<OptionalChoiceType::Integers>(*params_value)));
   }
   {
-    scoped_ptr<base::ListValue> params_value = List(
-        new FundamentalValue(5),
-        new FundamentalValue(false));
+    std::unique_ptr<base::ListValue> params_value =
+        List(new FundamentalValue(5), new FundamentalValue(false));
     OptionalChoiceType::Integers out;
     base::string16 error;
     EXPECT_TRUE(OptionalChoiceType::Integers::Populate(*params_value, &out,
         &error));
     EXPECT_TRUE(EqualsUtf16(
         "expected integer, got boolean; unable to populate array 'integers'",
         error));
     EXPECT_EQ(NULL, out.as_integer.get());
   }
 }
 
 TEST(JsonSchemaCompilerErrorTest, MultiplePopulationErrors) {
   {
-
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "TheArray", new FundamentalValue(5));
+    std::unique_ptr<base::DictionaryValue> value =
+        Dictionary("TheArray", new FundamentalValue(5));
     ArrayObject out;
     base::string16 error;
     EXPECT_TRUE(ArrayObject::Populate(*value, &out, &error));
     EXPECT_TRUE(EqualsUtf16("'TheArray': expected list, got integer",
         error));
     EXPECT_EQ(NULL, out.the_array.get());
 
     EXPECT_TRUE(ArrayObject::Populate(*value, &out, &error));
     EXPECT_TRUE(EqualsUtf16("'TheArray': expected list, got integer; "
         "'TheArray': expected list, got integer",
         error));
     EXPECT_EQ(NULL, out.the_array.get());
   }
 }
 
 TEST(JsonSchemaCompilerErrorTest, TooManyKeys) {
   {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-      "string", new base::StringValue("yes"));
+    std::unique_ptr<base::DictionaryValue> value =
+        Dictionary("string", new base::StringValue("yes"));
     EXPECT_TRUE(EqualsUtf16("", GetPopulateError<TestType>(*value)));
   }
   {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "string", new base::StringValue("yes"),
-        "ohno", new base::StringValue("many values"));
+    std::unique_ptr<base::DictionaryValue> value =
+        Dictionary("string", new base::StringValue("yes"), "ohno",
+                   new base::StringValue("many values"));
     EXPECT_TRUE(EqualsUtf16("found unexpected key 'ohno'",
         GetPopulateError<TestType>(*value)));
   }
 }