[Extensions Bindings] Add argument parsing errors

extensions/renderer/argument_spec_unittest.cc

 // Copyright 2016 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 "extensions/renderer/argument_spec.h"
 #include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "extensions/renderer/api_binding_test_util.h"
+#include "extensions/renderer/api_invocation_errors.h"
 #include "extensions/renderer/api_type_reference_map.h"
-#include "extensions/renderer/argument_spec.h"
 #include "gin/converter.h"
 #include "gin/public/isolate_holder.h"
 #include "gin/test/v8_test.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "v8/include/v8.h"
 
 namespace extensions {
 
 class ArgumentSpecUnitTest : public gin::V8Test {
  protected:
   ArgumentSpecUnitTest()
       : type_refs_(APITypeReferenceMap::InitializeTypeCallback()) {}
   ~ArgumentSpecUnitTest() override {}
+
+  enum class TestResult {
+    PASS,
+    FAIL,
+    THROW,
+  };
+
+  struct RunTestParams {
+    RunTestParams(const ArgumentSpec& spec,
+                  base::StringPiece script_source,
+                  TestResult result)
+        : spec(spec), script_source(script_source), expected_result(result) {}
+
+    const ArgumentSpec& spec;
+    base::StringPiece script_source;
+    TestResult expected_result;
+    base::StringPiece expected_json;
+    base::StringPiece expected_error;
+    base::StringPiece expected_thrown_message;
+    const base::Value* expected_value = nullptr;
+    bool should_convert = true;
+  };
+
   void ExpectSuccess(const ArgumentSpec& spec,
                      const std::string& script_source,
                      const std::string& expected_json_single_quotes) {
-    RunTest(spec, script_source, true, TestResult::PASS,
-            ReplaceSingleQuotes(expected_json_single_quotes), nullptr,
-            std::string());
+    RunTestParams params(spec, script_source, TestResult::PASS);
+    std::string expected_json =
+        ReplaceSingleQuotes(expected_json_single_quotes);
+    params.expected_json = expected_json;
+    RunTest(params);
   }
 
   void ExpectSuccess(const ArgumentSpec& spec,
                      const std::string& script_source,
                      const base::Value& expected_value) {
-    RunTest(spec, script_source, true, TestResult::PASS, std::string(),
-            &expected_value, std::string());
+    RunTestParams params(spec, script_source, TestResult::PASS);
+    params.expected_value = &expected_value;
+    RunTest(params);
   }
 
   void ExpectSuccessWithNoConversion(const ArgumentSpec& spec,
                                      const std::string& script_source) {
-    RunTest(spec, script_source, false, TestResult::PASS, std::string(),
-            nullptr, std::string());
+    RunTestParams params(spec, script_source, TestResult::PASS);
+    params.should_convert = false;
+    RunTest(params);
   }
 
   void ExpectFailure(const ArgumentSpec& spec,
-                     const std::string& script_source) {
-    RunTest(spec, script_source, true, TestResult::FAIL, std::string(), nullptr,
-            std::string());
+                     const std::string& script_source,
+                     const std::string& expected_error) {
+    RunTestParams params(spec, script_source, TestResult::FAIL);
+    params.expected_error = expected_error;
+    RunTest(params);
   }
 
   void ExpectFailureWithNoConversion(const ArgumentSpec& spec,
-                                     const std::string& script_source) {
-    RunTest(spec, script_source, false, TestResult::FAIL, std::string(),
-            nullptr, std::string());
+                                     const std::string& script_source,
+                                     const std::string& expected_error) {
+    RunTestParams params(spec, script_source, TestResult::FAIL);
+    params.should_convert = false;
+    params.expected_error = expected_error;
+    RunTest(params);
   }
 
   void ExpectThrow(const ArgumentSpec& spec,
                    const std::string& script_source,
                    const std::string& expected_thrown_message) {
-    RunTest(spec, script_source, true, TestResult::THROW, std::string(),
-            nullptr, expected_thrown_message);
+    RunTestParams params(spec, script_source, TestResult::THROW);
+    params.expected_thrown_message = expected_thrown_message;
+    RunTest(params);
   }
 
   void AddTypeRef(const std::string& id, std::unique_ptr<ArgumentSpec> spec) {
     type_refs_.AddSpec(id, std::move(spec));
   }
 
  private:
-  enum class TestResult { PASS, FAIL, THROW, };
-
-  void RunTest(const ArgumentSpec& spec,
-               const std::string& script_source,
-               bool should_convert,
-               TestResult expected_result,
-               const std::string& expected_json,
-               const base::Value* expected_value,
-               const std::string& expected_thrown_message);
+  void RunTest(const RunTestParams& params);
 
   APITypeReferenceMap type_refs_;
 
   DISALLOW_COPY_AND_ASSIGN(ArgumentSpecUnitTest);
 };
 
-void ArgumentSpecUnitTest::RunTest(const ArgumentSpec& spec,
-                                   const std::string& script_source,
-                                   bool should_convert,
-                                   TestResult expected_result,
-                                   const std::string& expected_json,
-                                   const base::Value* expected_value,
-                                   const std::string& expected_thrown_message) {
+void ArgumentSpecUnitTest::RunTest(const RunTestParams& params) {
   v8::Isolate* isolate = instance_->isolate();
   v8::HandleScope handle_scope(instance_->isolate());
 
   v8::Local<v8::Context> context =
       v8::Local<v8::Context>::New(instance_->isolate(), context_);
   v8::TryCatch try_catch(isolate);
-  v8::Local<v8::Value> val = V8ValueFromScriptSource(context, script_source);
-  ASSERT_FALSE(val.IsEmpty()) << script_source;
+  v8::Local<v8::Value> val =
+      V8ValueFromScriptSource(context, params.script_source);
+  ASSERT_FALSE(val.IsEmpty()) << params.script_source;
 
   std::string error;
   std::unique_ptr<base::Value> out_value;
-  bool did_succeed =
-      spec.ParseArgument(context, val, type_refs_,
-                         should_convert ? &out_value : nullptr, &error);
-  bool should_succeed = expected_result == TestResult::PASS;
-  ASSERT_EQ(should_succeed, did_succeed) << script_source << ", " << error;
-  ASSERT_EQ(did_succeed && should_convert, !!out_value);
-  bool should_throw = expected_result == TestResult::THROW;
-  ASSERT_EQ(should_throw, try_catch.HasCaught()) << script_source;
-  if (should_succeed && should_convert) {
+  bool did_succeed = params.spec.ParseArgument(
+      context, val, type_refs_, params.should_convert ? &out_value : nullptr,
+      &error);
+  bool should_succeed = params.expected_result == TestResult::PASS;
+  ASSERT_EQ(should_succeed, did_succeed)
+      << params.script_source << ", " << error;
+  ASSERT_EQ(did_succeed && params.should_convert, !!out_value);
+  bool should_throw = params.expected_result == TestResult::THROW;
+  ASSERT_EQ(should_throw, try_catch.HasCaught()) << params.script_source;
+
+  if (!params.expected_error.empty())
+    EXPECT_EQ(params.expected_error, error) << params.script_source;
+
+  if (should_succeed && params.should_convert) {
     ASSERT_TRUE(out_value);
-    if (expected_value)
-      EXPECT_TRUE(expected_value->Equals(out_value.get())) << script_source;
+    if (params.expected_value)
+      EXPECT_TRUE(params.expected_value->Equals(out_value.get()))
+          << params.script_source;
     else
-      EXPECT_EQ(expected_json, ValueToString(*out_value));
+      EXPECT_EQ(params.expected_json, ValueToString(*out_value));
   } else if (should_throw) {
-    EXPECT_EQ(expected_thrown_message,
+    EXPECT_EQ(params.expected_thrown_message,
               gin::V8ToString(try_catch.Message()->Get()));
   }
 }
 
 TEST_F(ArgumentSpecUnitTest, Test) {
+  using namespace api_errors;
+
+  // Shorthand for getting an invalid type error.
+  auto invalid_type = [](const char* expected, const char* actual) {
+    return GetError(kInvalidType, expected, actual);
+  };
+
   {
     ArgumentSpec spec(*ValueFromString("{'type': 'integer'}"));
     ExpectSuccess(spec, "1", "1");
     ExpectSuccess(spec, "-1", "-1");
     ExpectSuccess(spec, "0", "0");
     ExpectSuccess(spec, "0.0", "0");
-    ExpectFailure(spec, "undefined");
-    ExpectFailure(spec, "null");
-    ExpectFailure(spec, "1.1");
-    ExpectFailure(spec, "'foo'");
-    ExpectFailure(spec, "'1'");
-    ExpectFailure(spec, "{}");
-    ExpectFailure(spec, "[1]");
+    ExpectFailure(spec, "undefined",
+                  invalid_type(kTypeInteger, kTypeUndefined));
+    ExpectFailure(spec, "null", invalid_type(kTypeInteger, kTypeNull));
+    ExpectFailure(spec, "1.1", invalid_type(kTypeInteger, kTypeDouble));
+    ExpectFailure(spec, "'foo'", invalid_type(kTypeInteger, kTypeString));
+    ExpectFailure(spec, "'1'", invalid_type(kTypeInteger, kTypeString));
+    ExpectFailure(spec, "({})", invalid_type(kTypeInteger, kTypeObject));
+    ExpectFailure(spec, "[1]", invalid_type(kTypeInteger, kTypeList));
   }
 
   {
     ArgumentSpec spec(*ValueFromString("{'type': 'number'}"));
     ExpectSuccess(spec, "1", "1.0");
     ExpectSuccess(spec, "-1", "-1.0");
     ExpectSuccess(spec, "0", "0.0");
     ExpectSuccess(spec, "1.1", "1.1");
     ExpectSuccess(spec, "1.", "1.0");
     ExpectSuccess(spec, ".1", "0.1");
-    ExpectFailure(spec, "undefined");
-    ExpectFailure(spec, "null");
-    ExpectFailure(spec, "'foo'");
-    ExpectFailure(spec, "'1.1'");
-    ExpectFailure(spec, "{}");
-    ExpectFailure(spec, "[1.1]");
+    ExpectFailure(spec, "undefined", invalid_type(kTypeDouble, kTypeUndefined));
+    ExpectFailure(spec, "null", invalid_type(kTypeDouble, kTypeNull));
+    ExpectFailure(spec, "'foo'", invalid_type(kTypeDouble, kTypeString));
+    ExpectFailure(spec, "'1.1'", invalid_type(kTypeDouble, kTypeString));
+    ExpectFailure(spec, "({})", invalid_type(kTypeDouble, kTypeObject));
+    ExpectFailure(spec, "[1.1]", invalid_type(kTypeDouble, kTypeList));
   }
 
   {
     ArgumentSpec spec(*ValueFromString("{'type': 'integer', 'minimum': 1}"));
     ExpectSuccess(spec, "2", "2");
     ExpectSuccess(spec, "1", "1");
-    ExpectFailure(spec, "0");
-    ExpectFailure(spec, "-1");
+    ExpectFailure(spec, "0", GetError(kNumberTooSmall, 1));
+    ExpectFailure(spec, "-1", GetError(kNumberTooSmall, 1));
   }
 
   {
     ArgumentSpec spec(*ValueFromString("{'type': 'integer', 'maximum': 10}"));
     ExpectSuccess(spec, "10", "10");
     ExpectSuccess(spec, "1", "1");
-    ExpectFailure(spec, "11");
+    ExpectFailure(spec, "11", GetError(kNumberTooLarge, 10));
   }
 
   {
     ArgumentSpec spec(*ValueFromString("{'type': 'string'}"));
     ExpectSuccess(spec, "'foo'", "'foo'");
     ExpectSuccess(spec, "''", "''");
-    ExpectFailure(spec, "1");
-    ExpectFailure(spec, "{}");
-    ExpectFailure(spec, "['foo']");
+    ExpectFailure(spec, "1", invalid_type(kTypeString, kTypeInteger));
+    ExpectFailure(spec, "({})", invalid_type(kTypeString, kTypeObject));
+    ExpectFailure(spec, "['foo']", invalid_type(kTypeString, kTypeList));
   }
 
   {
     ArgumentSpec spec(
         *ValueFromString("{'type': 'string', 'enum': ['foo', 'bar']}"));
     ExpectSuccess(spec, "'foo'", "'foo'");
     ExpectSuccess(spec, "'bar'", "'bar'");
-    ExpectFailure(spec, "['foo']");
-    ExpectFailure(spec, "'fo'");
-    ExpectFailure(spec, "'foobar'");
-    ExpectFailure(spec, "'baz'");
-    ExpectFailure(spec, "''");
+    ExpectFailure(spec, "['foo']", invalid_type(kTypeString, kTypeList));
+    ExpectFailure(spec, "'fo'", GetError(kInvalidEnumValue, "bar, foo"));
+    ExpectFailure(spec, "'foobar'", GetError(kInvalidEnumValue, "bar, foo"));
+    ExpectFailure(spec, "'baz'", GetError(kInvalidEnumValue, "bar, foo"));
+    ExpectFailure(spec, "''", GetError(kInvalidEnumValue, "bar, foo"));
   }
 
   {
     ArgumentSpec spec(*ValueFromString(
         "{'type': 'string', 'enum': [{'name': 'foo'}, {'name': 'bar'}]}"));
     ExpectSuccess(spec, "'foo'", "'foo'");
     ExpectSuccess(spec, "'bar'", "'bar'");
-    ExpectFailure(spec, "['foo']");
-    ExpectFailure(spec, "'fo'");
-    ExpectFailure(spec, "'foobar'");
-    ExpectFailure(spec, "'baz'");
-    ExpectFailure(spec, "''");
+    ExpectFailure(spec, "['foo']", invalid_type(kTypeString, kTypeList));
+    ExpectFailure(spec, "'fo'", GetError(kInvalidEnumValue, "bar, foo"));
+    ExpectFailure(spec, "'foobar'", GetError(kInvalidEnumValue, "bar, foo"));
+    ExpectFailure(spec, "'baz'", GetError(kInvalidEnumValue, "bar, foo"));
+    ExpectFailure(spec, "''", GetError(kInvalidEnumValue, "bar, foo"));
   }
 
   {
     ArgumentSpec spec(*ValueFromString("{'type': 'boolean'}"));
     ExpectSuccess(spec, "true", "true");
     ExpectSuccess(spec, "false", "false");
-    ExpectFailure(spec, "1");
-    ExpectFailure(spec, "'true'");
-    ExpectFailure(spec, "null");
+    ExpectFailure(spec, "1", invalid_type(kTypeBoolean, kTypeInteger));
+    ExpectFailure(spec, "'true'", invalid_type(kTypeBoolean, kTypeString));
+    ExpectFailure(spec, "null", invalid_type(kTypeBoolean, kTypeNull));
   }
 
   {
     ArgumentSpec spec(
         *ValueFromString("{'type': 'array', 'items': {'type': 'string'}}"));
     ExpectSuccess(spec, "[]", "[]");
     ExpectSuccess(spec, "['foo']", "['foo']");
     ExpectSuccess(spec, "['foo', 'bar']", "['foo','bar']");
     ExpectSuccess(spec, "var x = new Array(); x[0] = 'foo'; x;", "['foo']");
-    ExpectFailure(spec, "'foo'");
-    ExpectFailure(spec, "[1, 2]");
-    ExpectFailure(spec, "['foo', 1]");
+    ExpectFailure(spec, "'foo'", invalid_type(kTypeList, kTypeString));
+    ExpectFailure(spec, "[1, 2]",
+                  GetIndexError(0u, invalid_type(kTypeString, kTypeInteger)));
+    ExpectFailure(spec, "['foo', 1]",
+                  GetIndexError(1u, invalid_type(kTypeString, kTypeInteger)));
     ExpectFailure(spec,
                   "var x = ['a', 'b', 'c'];"
                   "x[4] = 'd';"  // x[3] is undefined, violating the spec.
-                  "x;");
+                  "x;",
+                  GetIndexError(3u, invalid_type(kTypeString, kTypeUndefined)));
     ExpectThrow(
         spec,
         "var x = [];"
         "Object.defineProperty("
         "    x, 0,"
         "    { get: () => { throw new Error('Badness'); } });"
         "x;",
         "Uncaught Error: Badness");
   }
 
   {
     const char kObjectSpec[] =
         "{"
         "  'type': 'object',"
         "  'properties': {"
         "    'prop1': {'type': 'string'},"
         "    'prop2': {'type': 'integer', 'optional': true}"
         "  }"
         "}";
     ArgumentSpec spec(*ValueFromString(kObjectSpec));
     ExpectSuccess(spec, "({prop1: 'foo', prop2: 2})",
                   "{'prop1':'foo','prop2':2}");
     ExpectSuccess(spec, "({prop1: 'foo'})", "{'prop1':'foo'}");
     ExpectSuccess(spec, "({prop1: 'foo', prop2: null})", "{'prop1':'foo'}");
     ExpectSuccess(spec, "x = {}; x.prop1 = 'foo'; x;", "{'prop1':'foo'}");
-    ExpectFailure(spec, "({prop1: 'foo', prop2: 'bar'})");
-    ExpectFailure(spec, "({prop2: 2})");
+    ExpectFailure(
+        spec, "({prop1: 'foo', prop2: 'bar'})",
+        GetPropertyError("prop2", invalid_type(kTypeInteger, kTypeString)));
+    ExpectFailure(spec, "({prop2: 2})",
+                  GetError(kMissingRequiredProperty, "prop1"));
     // Unknown properties are not allowed.
-    ExpectFailure(spec, "({prop1: 'foo', prop2: 2, prop3: 'blah'})");
+    ExpectFailure(spec, "({prop1: 'foo', prop2: 2, prop3: 'blah'})",
+                  GetError(kUnexpectedProperty, "prop3"));
     // We only consider properties on the object itself, not its prototype
     // chain.
     ExpectFailure(spec,
                   "function X() {}\n"
                   "X.prototype = { prop1: 'foo' };\n"
                   "var x = new X();\n"
-                  "x;");
+                  "x;",
+                  GetError(kMissingRequiredProperty, "prop1"));
     ExpectFailure(spec,
                   "function X() {}\n"
                   "X.prototype = { prop1: 'foo' };\n"
                   "function Y() { this.__proto__ = X.prototype; }\n"
                   "var z = new Y();\n"
-                  "z;");
+                  "z;",
+                  GetError(kMissingRequiredProperty, "prop1"));
     // Self-referential fun. Currently we don't have to worry about these much
     // because the spec won't match at some point (and V8ValueConverter has
     // cycle detection and will fail).
-    ExpectFailure(spec, "x = {}; x.prop1 = x; x;");
+    ExpectFailure(
+        spec, "x = {}; x.prop1 = x; x;",
+        GetPropertyError("prop1", invalid_type(kTypeString, kTypeObject)));
     ExpectThrow(
         spec,
         "({ get prop1() { throw new Error('Badness'); }});",
         "Uncaught Error: Badness");
     ExpectThrow(spec,
                 "x = {prop1: 'foo'};\n"
                 "Object.defineProperty(\n"
                 "    x, 'prop2',\n"
                 "    {\n"
                 "      get: () => { throw new Error('Badness'); },\n"
@@ skipping 13 matching lines @@
   }
 
   {
     const char kFunctionSpec[] = "{ 'type': 'function' }";
     ArgumentSpec spec(*ValueFromString(kFunctionSpec));
     // Functions are serialized as empty dictionaries.
     ExpectSuccess(spec, "(function() {})", "{}");
     ExpectSuccessWithNoConversion(spec, "(function() {})");
     ExpectSuccessWithNoConversion(spec, "(function(a, b) { a(); b(); })");
     ExpectSuccessWithNoConversion(spec, "(function(a, b) { a(); b(); })");
-    ExpectFailureWithNoConversion(spec, "({a: function() {}})");
-    ExpectFailureWithNoConversion(spec, "([function() {}])");
-    ExpectFailureWithNoConversion(spec, "1");
+    ExpectFailureWithNoConversion(spec, "({a: function() {}})",
+                                  invalid_type(kTypeFunction, kTypeObject));
+    ExpectFailureWithNoConversion(spec, "([function() {}])",
+                                  invalid_type(kTypeFunction, kTypeList));
+    ExpectFailureWithNoConversion(spec, "1",
+                                  invalid_type(kTypeFunction, kTypeInteger));
   }
 
   {
     const char kBinarySpec[] = "{ 'type': 'binary' }";
     ArgumentSpec spec(*ValueFromString(kBinarySpec));
     // Simple case: empty ArrayBuffer -> empty BinaryValue.
     ExpectSuccess(spec, "(new ArrayBuffer())",
                   base::Value(base::Value::Type::BINARY));
     {
       // A non-empty (but zero-filled) ArrayBufferView.
@@ skipping 11 matching lines @@
       ASSERT_TRUE(expected_value);
       ExpectSuccess(spec,
                     "var b = new ArrayBuffer(4);\n"
                     "var v = new Uint8Array(b);\n"
                     "var s = 'ping';\n"
                     "for (var i = 0; i < s.length; ++i)\n"
                     "  v[i] = s.charCodeAt(i);\n"
                     "b;",
                     *expected_value);
     }
-    ExpectFailure(spec, "1");
+    ExpectFailure(spec, "1", invalid_type(kTypeBinary, kTypeInteger));
   }
   {
     const char kAnySpec[] = "{ 'type': 'any' }";
     ArgumentSpec spec(*ValueFromString(kAnySpec));
     ExpectSuccess(spec, "42", "42");
     ExpectSuccess(spec, "'foo'", "'foo'");
     ExpectSuccess(spec, "({prop1:'bar'})", "{'prop1':'bar'}");
     ExpectSuccess(spec, "[1, 2, 3]", "[1,2,3]");
     ExpectSuccess(spec, "[1, 'a']", "[1,'a']");
     ExpectSuccess(spec, "null", base::Value());
     ExpectSuccess(spec, "({prop1: 'alpha', prop2: null})",
                   "{'prop1':'alpha','prop2':null}");
     ExpectSuccess(spec,
                   "x = {alpha: 'alpha'};\n"
                   "y = {beta: 'beta', x: x};\n"
                   "y;",
                   "{'beta':'beta','x':{'alpha':'alpha'}}");
     // We don't serialize undefined.
     // TODO(devlin): This matches current behavior, but should it? Part of the
     // problem is that base::Values don't differentiate between undefined and
     // null, which is a potentially important distinction. However, this means
     // that in serialization of an object {a: 1, foo:undefined}, we lose the
     // 'foo' property.
-    ExpectFailure(spec, "undefined");
+    ExpectFailure(spec, "undefined", kUnserializableValue);
+
     ExpectSuccess(spec, "({prop1: 1, prop2: undefined})", "{'prop1':1}");
   }
 }
 
 TEST_F(ArgumentSpecUnitTest, TypeRefsTest) {
+  using namespace api_errors;
   const char kObjectType[] =
       "{"
       "  'id': 'refObj',"
       "  'type': 'object',"
       "  'properties': {"
       "    'prop1': {'type': 'string'},"
       "    'prop2': {'type': 'integer', 'optional': true}"
       "  }"
       "}";
   const char kEnumType[] =
       "{'id': 'refEnum', 'type': 'string', 'enum': ['alpha', 'beta']}";
   AddTypeRef("refObj",
              base::MakeUnique<ArgumentSpec>(*ValueFromString(kObjectType)));
   AddTypeRef("refEnum",
              base::MakeUnique<ArgumentSpec>(*ValueFromString(kEnumType)));
 
   {
     const char kObjectWithRefEnumSpec[] =
         "{"
         "  'name': 'objWithRefEnum',"
         "  'type': 'object',"
         "  'properties': {"
         "    'e': {'$ref': 'refEnum'},"
         "    'sub': {'type': 'integer'}"
         "  }"
         "}";
     ArgumentSpec spec(*ValueFromString(kObjectWithRefEnumSpec));
     ExpectSuccess(spec, "({e: 'alpha', sub: 1})", "{'e':'alpha','sub':1}");
     ExpectSuccess(spec, "({e: 'beta', sub: 1})", "{'e':'beta','sub':1}");
-    ExpectFailure(spec, "({e: 'gamma', sub: 1})");
-    ExpectFailure(spec, "({e: 'alpha'})");
+    ExpectFailure(
+        spec, "({e: 'gamma', sub: 1})",
+        GetPropertyError("e", GetError(kInvalidEnumValue, "alpha, beta")));
+    ExpectFailure(spec, "({e: 'alpha'})",
+                  GetError(kMissingRequiredProperty, "sub"));
   }
 
   {
     const char kObjectWithRefObjectSpec[] =
         "{"
         "  'name': 'objWithRefObject',"
         "  'type': 'object',"
         "  'properties': {"
         "    'o': {'$ref': 'refObj'}"
         "  }"
         "}";
     ArgumentSpec spec(*ValueFromString(kObjectWithRefObjectSpec));
     ExpectSuccess(spec, "({o: {prop1: 'foo'}})", "{'o':{'prop1':'foo'}}");
     ExpectSuccess(spec, "({o: {prop1: 'foo', prop2: 2}})",
                   "{'o':{'prop1':'foo','prop2':2}}");
-    ExpectFailure(spec, "({o: {prop1: 1}})");
+    ExpectFailure(
+        spec, "({o: {prop1: 1}})",
+        GetPropertyError(
+            "o", GetPropertyError("prop1", GetError(kInvalidType, kTypeString,
+                                                    kTypeInteger))));
   }
 
   {
     const char kRefEnumListSpec[] =
         "{'type': 'array', 'items': {'$ref': 'refEnum'}}";
     ArgumentSpec spec(*ValueFromString(kRefEnumListSpec));
     ExpectSuccess(spec, "['alpha']", "['alpha']");
     ExpectSuccess(spec, "['alpha', 'alpha']", "['alpha','alpha']");
     ExpectSuccess(spec, "['alpha', 'beta']", "['alpha','beta']");
-    ExpectFailure(spec, "['alpha', 'beta', 'gamma']");
+    ExpectFailure(
+        spec, "['alpha', 'beta', 'gamma']",
+        GetIndexError(2u, GetError(kInvalidEnumValue, "alpha, beta")));
   }
 }
 
 TEST_F(ArgumentSpecUnitTest, TypeChoicesTest) {
+  using namespace api_errors;
   {
     const char kSimpleChoices[] =
         "{'choices': [{'type': 'string'}, {'type': 'integer'}]}";
     ArgumentSpec spec(*ValueFromString(kSimpleChoices));
     ExpectSuccess(spec, "'alpha'", "'alpha'");
     ExpectSuccess(spec, "42", "42");
-    ExpectFailure(spec, "true");
+    ExpectFailure(spec, "true", kInvalidChoice);
   }
 
   {
     const char kComplexChoices[] =
         "{"
         "  'choices': ["
         "    {'type': 'array', 'items': {'type': 'string'}},"
         "    {'type': 'object', 'properties': {'prop1': {'type': 'string'}}}"
         "  ]"
         "}";
     ArgumentSpec spec(*ValueFromString(kComplexChoices));
     ExpectSuccess(spec, "['alpha']", "['alpha']");
     ExpectSuccess(spec, "['alpha', 'beta']", "['alpha','beta']");
     ExpectSuccess(spec, "({prop1: 'alpha'})", "{'prop1':'alpha'}");
-    ExpectFailure(spec, "({prop1: 1})");
-    ExpectFailure(spec, "'alpha'");
-    ExpectFailure(spec, "42");
+    ExpectFailure(spec, "({prop1: 1})", kInvalidChoice);
+    ExpectFailure(spec, "'alpha'", kInvalidChoice);
+    ExpectFailure(spec, "42", kInvalidChoice);
   }
 }
 
 TEST_F(ArgumentSpecUnitTest, AdditionalPropertiesTest) {
+  using namespace api_errors;
   {
     const char kOnlyAnyAdditionalProperties[] =
         "{"
         "  'type': 'object',"
         "  'additionalProperties': {'type': 'any'}"
         "}";
     ArgumentSpec spec(*ValueFromString(kOnlyAnyAdditionalProperties));
     ExpectSuccess(spec, "({prop1: 'alpha', prop2: 42, prop3: {foo: 'bar'}})",
                   "{'prop1':'alpha','prop2':42,'prop3':{'foo':'bar'}}");
     ExpectSuccess(spec, "({})", "{}");
@@ skipping 60 matching lines @@
         "  'properties': {"
         "    'prop1': {'type': 'string'}"
         "  },"
         "  'additionalProperties': {'type': 'any'}"
         "}";
     ArgumentSpec spec(*ValueFromString(kPropertiesAndAnyAdditionalProperties));
     ExpectSuccess(spec, "({prop1: 'alpha', prop2: 42, prop3: {foo: 'bar'}})",
                   "{'prop1':'alpha','prop2':42,'prop3':{'foo':'bar'}}");
     // Additional properties are optional.
     ExpectSuccess(spec, "({prop1: 'foo'})", "{'prop1':'foo'}");
-    ExpectFailure(spec, "({prop2: 42, prop3: {foo: 'bar'}})");
-    ExpectFailure(spec, "({prop1: 42})");
+    ExpectFailure(spec, "({prop2: 42, prop3: {foo: 'bar'}})",
+                  GetError(kMissingRequiredProperty, "prop1"));
+    ExpectFailure(spec, "({prop1: 42})",
+                  GetPropertyError("prop1", GetError(kInvalidType, kTypeString,
+                                                     kTypeInteger)));
   }
   {
     const char kTypedAdditionalProperties[] =
         "{"
         "  'type': 'object',"
         "  'additionalProperties': {'type': 'string'}"
         "}";
     ArgumentSpec spec(*ValueFromString(kTypedAdditionalProperties));
     ExpectSuccess(spec, "({prop1: 'alpha', prop2: 'beta', prop3: 'gamma'})",
                   "{'prop1':'alpha','prop2':'beta','prop3':'gamma'}");
-    ExpectFailure(spec, "({prop1: 'alpha', prop2: 42})");
+    ExpectFailure(spec, "({prop1: 'alpha', prop2: 42})",
+                  GetPropertyError("prop2", GetError(kInvalidType, kTypeString,
+                                                     kTypeInteger)));
   }
 }
 
 TEST_F(ArgumentSpecUnitTest, InstanceOfTest) {
+  using namespace api_errors;
   {
     const char kInstanceOfRegExp[] =
         "{"
         "  'type': 'object',"
         "  'isInstanceOf': 'RegExp'"
         "}";
     ArgumentSpec spec(*ValueFromString(kInstanceOfRegExp));
     ExpectSuccess(spec, "(new RegExp())", "{}");
     ExpectSuccess(spec, "({ __proto__: RegExp.prototype })", "{}");
     ExpectSuccess(spec,
                   "(function() {\n"
                   "  function subRegExp() {}\n"
                   "  subRegExp.prototype = { __proto__: RegExp.prototype };\n"
                   "  return new subRegExp();\n"
                   "})()",
                   "{}");
     ExpectSuccess(spec,
                   "(function() {\n"
                   "  function RegExp() {}\n"
                   "  return new RegExp();\n"
                   "})()",
                   "{}");
-    ExpectFailure(spec, "({})");
-    ExpectFailure(spec, "('')");
-    ExpectFailure(spec, "('.*')");
-    ExpectFailure(spec, "({ __proto__: Date.prototype })");
+    ExpectFailure(spec, "({})", GetError(kNotAnInstance, "RegExp"));
+    ExpectFailure(spec, "('')", GetError(kInvalidType, "RegExp", kTypeString));
+    ExpectFailure(spec, "('.*')",
+                  GetError(kInvalidType, "RegExp", kTypeString));
+    ExpectFailure(spec, "({ __proto__: Date.prototype })",
+                  GetError(kNotAnInstance, "RegExp"));
   }
 
   {
     const char kInstanceOfCustomClass[] =
         "{"
         "  'type': 'object',"
         "  'isInstanceOf': 'customClass'"
         "}";
     ArgumentSpec spec(*ValueFromString(kInstanceOfCustomClass));
     ExpectSuccess(spec,
                   "(function() {\n"
                   "  function customClass() {}\n"
                   "  return new customClass();\n"
                   "})()",
                   "{}");
     ExpectSuccess(spec,
                   "(function() {\n"
                   "  function customClass() {}\n"
                   "  function otherClass() {}\n"
                   "  otherClass.prototype = \n"
                   "      { __proto__: customClass.prototype };\n"
                   "  return new otherClass();\n"
                   "})()",
                   "{}");
-    ExpectFailure(spec, "({})");
+    ExpectFailure(spec, "({})", GetError(kNotAnInstance, "customClass"));
     ExpectFailure(spec,
                   "(function() {\n"
                   "  function otherClass() {}\n"
                   "  return new otherClass();\n"
-                  "})()");
+                  "})()",
+                  GetError(kNotAnInstance, "customClass"));
   }
 }
 
 TEST_F(ArgumentSpecUnitTest, MinAndMaxLengths) {
+  using namespace api_errors;
   {
     const char kMinLengthString[] = "{'type': 'string', 'minLength': 3}";
     ArgumentSpec spec(*ValueFromString(kMinLengthString));
     ExpectSuccess(spec, "'aaa'", "'aaa'");
     ExpectSuccess(spec, "'aaaa'", "'aaaa'");
-    ExpectFailure(spec, "'aa'");
-    ExpectFailure(spec, "''");
+    ExpectFailure(spec, "'aa'", GetError(kTooFewStringChars, 3));
+    ExpectFailure(spec, "''", GetError(kTooFewStringChars, 3));
   }
 
   {
     const char kMaxLengthString[] = "{'type': 'string', 'maxLength': 3}";
     ArgumentSpec spec(*ValueFromString(kMaxLengthString));
     ExpectSuccess(spec, "'aaa'", "'aaa'");
     ExpectSuccess(spec, "'aa'", "'aa'");
     ExpectSuccess(spec, "''", "''");
-    ExpectFailure(spec, "'aaaa'");
+    ExpectFailure(spec, "'aaaa'", GetError(kTooManyStringChars, 3));
   }
 
   {
     const char kMinLengthArray[] =
         "{'type': 'array', 'items': {'type': 'integer'}, 'minItems': 3}";
     ArgumentSpec spec(*ValueFromString(kMinLengthArray));
     ExpectSuccess(spec, "[1, 2, 3]", "[1,2,3]");
     ExpectSuccess(spec, "[1, 2, 3, 4]", "[1,2,3,4]");
-    ExpectFailure(spec, "[1, 2]");
-    ExpectFailure(spec, "[]");
+    ExpectFailure(spec, "[1, 2]", GetError(kTooFewArrayItems, 3));
+    ExpectFailure(spec, "[]", GetError(kTooFewArrayItems, 3));
   }
 
   {
     const char kMaxLengthArray[] =
         "{'type': 'array', 'items': {'type': 'integer'}, 'maxItems': 3}";
     ArgumentSpec spec(*ValueFromString(kMaxLengthArray));
     ExpectSuccess(spec, "[1, 2, 3]", "[1,2,3]");
     ExpectSuccess(spec, "[1, 2]", "[1,2]");
     ExpectSuccess(spec, "[]", "[]");
-    ExpectFailure(spec, "[1, 2, 3, 4]");
+    ExpectFailure(spec, "[1, 2, 3, 4]", GetError(kTooManyArrayItems, 3));
   }
 }
 
 }  // namespace extensions