--- a/testing/marionette/session.js
+++ b/testing/marionette/session.js
@@ -50,35 +50,39 @@ session.Timeouts = class {
     return {
       implicit: this.implicit,
       pageLoad: this.pageLoad,
       script: this.script,
     };
   }
 
   static fromJSON(json) {
-    assert.object(json);
+    assert.object(json,
+        pprint`Expected "timeouts" to be an object, got ${json}`);
     let t = new session.Timeouts();
 
-    for (let [typ, ms] of Object.entries(json)) {
-      switch (typ) {
+    for (let [type, ms] of Object.entries(json)) {
+      switch (type) {
         case "implicit":
-          t.implicit = assert.positiveInteger(ms);
+          t.implicit = assert.positiveInteger(ms,
+              pprint`Expected ${type} to be a positive integer, got ${ms}`);
           break;
 
         case "script":
-          t.script = assert.positiveInteger(ms);
+          t.script = assert.positiveInteger(ms,
+              pprint`Expected ${type} to be a positive integer, got ${ms}`);
           break;
 
         case "pageLoad":
-          t.pageLoad = assert.positiveInteger(ms);
+          t.pageLoad = assert.positiveInteger(ms,
+              pprint`Expected ${type} to be a positive integer, got ${ms}`);
           break;
 
         default:
-          throw new InvalidArgumentError("Unrecognised timeout: " + typ);
+          throw new InvalidArgumentError("Unrecognised timeout: " + type);
       }
     }
 
     return t;
   }
 };
 
 /**
@@ -283,17 +287,18 @@ session.Proxy = class {
         if (typeof json.httpProxy != "undefined") {
           [p.httpProxy, p.httpProxyPort] = fromHost("http", json.httpProxy);
         }
         if (typeof json.sslProxy != "undefined") {
           [p.sslProxy, p.sslProxyPort] = fromHost("https", json.sslProxy);
         }
         if (typeof json.socksProxy != "undefined") {
           [p.socksProxy, p.socksProxyPort] = fromHost("socks", json.socksProxy);
-          p.socksVersion = assert.positiveInteger(json.socksVersion);
+          p.socksVersion = assert.positiveInteger(json.socksVersion,
+              pprint`Expected "socksVersion" to be a positive integer, got ${json.socksVersion}`);
         }
         if (typeof json.noProxy != "undefined") {
           let entries = assert.array(json.noProxy,
               pprint`Expected "noProxy" to be an array, got ${json.noProxy}`);
           p.noProxy = entries.map(entry => {
             assert.string(entry,
                 pprint`Expected "noProxy" entry to be a string, got ${entry}`);
             return stripBracketsFromIpv6Hostname(entry);
@@ -417,37 +422,40 @@ session.Capabilities = class extends Map
    *
    * @return {session.Capabilities}
    *     Internal representation of WebDriver capabilities.
    */
   static fromJSON(json) {
     if (typeof json == "undefined" || json === null) {
       json = {};
     }
-    assert.object(json);
+    assert.object(json,
+        pprint`Expected "capabilities" to be an object, got ${json}"`);
 
     return session.Capabilities.match_(json);
   }
 
   // Matches capabilities as described by WebDriver.
   static match_(json = {}) {
     let matched = new session.Capabilities();
 
     for (let [k, v] of Object.entries(json)) {
       switch (k) {
         case "acceptInsecureCerts":
-          assert.boolean(v);
+          assert.boolean(v,
+              pprint`Expected ${k} to be a boolean, got ${v}`);
           matched.set("acceptInsecureCerts", v);
           break;
 
         case "pageLoadStrategy":
           if (v === null) {
             matched.set("pageLoadStrategy", session.PageLoadStrategy.Normal);
           } else {
-            assert.string(v);
+            assert.string(v,
+                pprint`Expected ${k} to be a string, got ${v}`);
 
             if (Object.values(session.PageLoadStrategy).includes(v)) {
               matched.set("pageLoadStrategy", v);
             } else {
               throw new InvalidArgumentError(
                   "Unknown page load strategy: " + v);
             }
           }
@@ -460,27 +468,30 @@ session.Capabilities = class extends Map
           break;
 
         case "timeouts":
           let timeouts = session.Timeouts.fromJSON(v);
           matched.set("timeouts", timeouts);
           break;
 
         case "moz:accessibilityChecks":
-          assert.boolean(v);
+          assert.boolean(v,
+              pprint`Expected ${k} to be a boolean, got ${v}`);
           matched.set("moz:accessibilityChecks", v);
           break;
 
         case "moz:useNonSpecCompliantPointerOrigin":
-          assert.boolean(v);
+          assert.boolean(v,
+              pprint`Expected ${k} to be a boolean, got ${v}`);
           matched.set("moz:useNonSpecCompliantPointerOrigin", v);
           break;
 
         case "moz:webdriverClick":
-          assert.boolean(v);
+          assert.boolean(v,
+              pprint`Expected ${k} to be a boolean, got ${v}`);
           matched.set("moz:webdriverClick", v);
           break;
       }
     }
 
     return matched;
   }
 };

--- a/testing/marionette/test/unit/test_session.js
+++ b/testing/marionette/test/unit/test_session.js
@@ -61,28 +61,28 @@ add_test(function test_Timeouts_fromJSON
   run_next_test();
 });
 
 add_test(function test_Timeouts_fromJSON_invalid_type() {
   try {
     session.Timeouts.fromJSON({script: "foobar"});
   } catch (e) {
     equal(e.name, InvalidArgumentError.name);
-    equal(e.message, "Expected [object String] \"foobar\" to be an integer");
+    equal(e.message, "Expected [object String] \"script\" to be a positive integer, got [object String] \"foobar\"");
   }
 
   run_next_test();
 });
 
 add_test(function test_Timeouts_fromJSON_bounds() {
   try {
     session.Timeouts.fromJSON({script: -42});
   } catch (e) {
     equal(e.name, InvalidArgumentError.name);
-    equal(e.message, "Expected [object Number] -42 to be >= 0");
+    equal(e.message, "Expected [object String] \"script\" to be a positive integer, got [object Number] -42");
   }
 
   run_next_test();
 });
 
 add_test(function test_PageLoadStrategy() {
   equal(session.PageLoadStrategy.None, "none");
   equal(session.PageLoadStrategy.Eager, "eager");