Switch various ValueTypeToString()s to base::Value::GetTypeName().

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"
 
 using namespace test::api::error_generation;
 using base::FundamentalValue;
 using json_schema_compiler::test_util::Dictionary;
 using json_schema_compiler::test_util::List;
 
 template <typename T>
 base::string16 GetPopulateError(const base::Value& value) {
   base::string16 error;
   T test_type;
   T::Populate(value, &test_type, &error);
   return error;
 }
 
 testing::AssertionResult EqualsUtf16(const std::string& expected,
                                      const base::string16& actual) {
-  if (base::ASCIIToUTF16(expected) != actual)
-    return testing::AssertionFailure() << expected << " != " << actual;
-  return testing::AssertionSuccess();
+  if (base::ASCIIToUTF16(expected) == actual)
+    return testing::AssertionSuccess();
+  return testing::AssertionFailure() << "\n    actual:     " << actual
+                                     << "\n    expected:   " << expected;
 }
 
 // GenerateTypePopulate errors
 
 TEST(JsonSchemaCompilerErrorTest, RequiredPropertyPopulate) {
   {
     std::unique_ptr<base::DictionaryValue> value =
         Dictionary("string", new base::StringValue("bling"));
     EXPECT_TRUE(EqualsUtf16("", GetPopulateError<TestType>(*value)));
   }
@@ skipping 72 matching lines @@
 
 TEST(JsonSchemaCompilerErrorTest, WrongPropertyValueType) {
   {
     std::unique_ptr<base::DictionaryValue> value =
         Dictionary("string", new base::StringValue("yes"));
     EXPECT_TRUE(EqualsUtf16("", GetPopulateError<TestType>(*value)));
   }
   {
     std::unique_ptr<base::DictionaryValue> value =
         Dictionary("string", new FundamentalValue(1.1));
-    EXPECT_TRUE(EqualsUtf16("'string': expected string, got number",
+    EXPECT_TRUE(EqualsUtf16("'string': expected string, got double",
         GetPopulateError<TestType>(*value)));
   }
 }
 
 TEST(JsonSchemaCompilerErrorTest, WrongParameterCreationType) {
   {
     base::string16 error;
     std::unique_ptr<base::ListValue> params_value =
         List(new base::StringValue("Yeah!"));
     EXPECT_TRUE(TestString::Params::Create(*params_value, &error));
@@ skipping 12 matching lines @@
   {
     std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
     EXPECT_TRUE(EqualsUtf16("", GetPopulateError<ObjectType>(*value)));
   }
   {
     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",
+    EXPECT_TRUE(EqualsUtf16("'otherType': expected dictionary, got double",
         error));
     EXPECT_EQ(NULL, out.other_type.get());
   }
 }
 
 TEST(JsonSchemaCompilerErrorTest, UnableToPopulateArray) {
   {
     std::unique_ptr<base::ListValue> params_value =
         List(new FundamentalValue(5));
     EXPECT_TRUE(EqualsUtf16("",
@@ skipping 10 matching lines @@
 
 TEST(JsonSchemaCompilerErrorTest, BinaryTypeExpected) {
   {
     std::unique_ptr<base::DictionaryValue> value =
         Dictionary("data", new base::BinaryValue());
     EXPECT_TRUE(EqualsUtf16("", GetPopulateError<BinaryData>(*value)));
   }
   {
     std::unique_ptr<base::DictionaryValue> value =
         Dictionary("data", new FundamentalValue(1.1));
-    EXPECT_TRUE(EqualsUtf16("'data': expected binary, got number",
+    EXPECT_TRUE(EqualsUtf16("'data': expected binary, got double",
         GetPopulateError<BinaryData>(*value)));
   }
 }
 
 TEST(JsonSchemaCompilerErrorTest, ListExpected) {
   {
     std::unique_ptr<base::DictionaryValue> value =
         Dictionary("TheArray", new base::ListValue());
     EXPECT_TRUE(EqualsUtf16("", GetPopulateError<ArrayObject>(*value)));
   }
@@ skipping 128 matching lines @@
     EXPECT_TRUE(EqualsUtf16("", GetPopulateError<TestType>(*value)));
   }
   {
     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)));
   }
 }