[Extensions Bindings] Add argument parsing errors

extensions/renderer/argument_spec_unittest.cc

Index: extensions/renderer/argument_spec_unittest.cc
diff --git a/extensions/renderer/argument_spec_unittest.cc b/extensions/renderer/argument_spec_unittest.cc
index 4bf8d256907215398643ac866457d2cf37a0de30..fd89e5f423159dee1699d857f84850da7378c889 100644
--- a/extensions/renderer/argument_spec_unittest.cc
+++ b/extensions/renderer/argument_spec_unittest.cc
@@ -2,11 +2,12 @@
 // 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"
@@ -20,44 +21,77 @@ class ArgumentSpecUnitTest : public gin::V8Test {
   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) {
@@ -65,73 +99,74 @@ class ArgumentSpecUnitTest : public gin::V8Test {
   }
 
  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));
   }
 
   {
@@ -142,36 +177,36 @@ TEST_F(ArgumentSpecUnitTest, Test) {
     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));
   }
 
   {
@@ -179,11 +214,11 @@ TEST_F(ArgumentSpecUnitTest, Test) {
         *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"));
   }
 
   {
@@ -191,20 +226,20 @@ TEST_F(ArgumentSpecUnitTest, Test) {
         "{'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));
   }
 
   {
@@ -214,13 +249,16 @@ TEST_F(ArgumentSpecUnitTest, Test) {
     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 = [];"
@@ -246,27 +284,35 @@ TEST_F(ArgumentSpecUnitTest, Test) {
     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'); }});",
@@ -300,9 +346,12 @@ TEST_F(ArgumentSpecUnitTest, Test) {
     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));
   }
 
   {
@@ -334,7 +383,7 @@ TEST_F(ArgumentSpecUnitTest, Test) {
                     "b;",
                     *expected_value);
     }
-    ExpectFailure(spec, "1");
+    ExpectFailure(spec, "1", invalid_type(kTypeBinary, kTypeInteger));
   }
   {
     const char kAnySpec[] = "{ 'type': 'any' }";
@@ -358,12 +407,14 @@ TEST_F(ArgumentSpecUnitTest, Test) {
     // 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',"
@@ -393,8 +444,11 @@ TEST_F(ArgumentSpecUnitTest, TypeRefsTest) {
     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"));
   }
 
   {
@@ -410,7 +464,11 @@ TEST_F(ArgumentSpecUnitTest, TypeRefsTest) {
     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))));
   }
 
   {
@@ -420,18 +478,21 @@ TEST_F(ArgumentSpecUnitTest, TypeRefsTest) {
     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);
   }
 
   {
@@ -446,13 +507,14 @@ TEST_F(ArgumentSpecUnitTest, TypeChoicesTest) {
     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[] =
         "{"
@@ -533,8 +595,11 @@ TEST_F(ArgumentSpecUnitTest, AdditionalPropertiesTest) {
                   "{'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[] =
@@ -545,11 +610,14 @@ TEST_F(ArgumentSpecUnitTest, AdditionalPropertiesTest) {
     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[] =
         "{"
@@ -572,10 +640,12 @@ TEST_F(ArgumentSpecUnitTest, InstanceOfTest) {
                   "  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"));
   }
 
   {
@@ -600,23 +670,25 @@ TEST_F(ArgumentSpecUnitTest, InstanceOfTest) {
                   "  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));
   }
 
   {
@@ -625,7 +697,7 @@ TEST_F(ArgumentSpecUnitTest, MinAndMaxLengths) {
     ExpectSuccess(spec, "'aaa'", "'aaa'");
     ExpectSuccess(spec, "'aa'", "'aa'");
     ExpectSuccess(spec, "''", "''");
-    ExpectFailure(spec, "'aaaa'");
+    ExpectFailure(spec, "'aaaa'", GetError(kTooManyStringChars, 3));
   }
 
   {
@@ -634,8 +706,8 @@ TEST_F(ArgumentSpecUnitTest, MinAndMaxLengths) {
     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));
   }
 
   {
@@ -645,7 +717,7 @@ TEST_F(ArgumentSpecUnitTest, MinAndMaxLengths) {
     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));
   }
 }