Use expect instead of unittest for json_lib_test.

pkg/dev_compiler/test/codegen_expected/expect.js

 define(['dart_sdk'], function(dart_sdk) {
   'use strict';
   const core = dart_sdk.core;
   const dart = dart_sdk.dart;
   const dartx = dart_sdk.dartx;
   const expect = Object.create(null);
   let VoidTovoid = () => (VoidTovoid = dart.constFn(dart.functionType(dart.void, [])))();
   let dynamicAnddynamicTobool = () => (dynamicAnddynamicTobool = dart.constFn(dart.definiteFunctionType(core.bool, [dart.dynamic, dart.dynamic])))();
   expect.Expect = class Expect extends core.Object {
     static _truncateString(string, start, end, length) {
@@ skipping 190 matching lines @@
         sb.write(dart.str`${val} `);
       }
       if (!dart.test(extraSet.isEmpty)) {
         sb.write('\nExpected collection should not contain: ');
       }
       for (let val of extraSet) {
         sb.write(dart.str`${val} `);
       }
       expect.Expect._fail(sb.toString());
     }
+    static deepEquals(expected, actual) {
+      if (dart.equals(expected, actual)) return;
+      if (core.List.is(expected) && core.List.is(actual)) {
+        let n = dart.notNull(expected[dartx.length]) < dart.notNull(actual[dartx.length]) ? expected[dartx.length] : actual[dartx.length];
+        for (let i = 0; i < dart.notNull(n); i++) {
+          expect.Expect.deepEquals(expected[dartx.get](i), actual[dartx.get](i));
+        }
+        if (expected[dartx.length] != actual[dartx.length]) {
+          expect.Expect._fail('Expect.deepEquals(list length, ' + dart.str`expected: <${expected[dartx.length]}>, actual: <${actual[dartx.length]}>) ` + 'fails: Next element <' + dart.str`${dart.notNull(expected[dartx.length]) > dart.notNull(n) ? expected[dartx.get](n) : actual[dartx.get](n)}>`);
+        }
+      } else if (core.Map.is(expected) && core.Map.is(actual)) {
+        for (let key of expected[dartx.keys]) {
+          if (!dart.test(actual[dartx.containsKey](key))) {
+            expect.Expect._fail(dart.str`Expect.deepEquals(missing expected key: <${key}>) fails`);
+          }
+          expect.Expect.deepEquals(expected[dartx.get](key), actual[dartx.get](key));
+        }
+        for (let key of actual[dartx.keys]) {
+          if (!dart.test(expected[dartx.containsKey](key))) {
+            expect.Expect._fail(dart.str`Expect.deepEquals(unexpected key: <${key}>) fails`);
+          }
+        }
+      } else if (typeof expected == 'string' && typeof actual == 'string') {
+        let stringDifference = expect.Expect._stringDifference(expected, actual);
+        dart.assert(stringDifference != null);
+        expect.Expect._fail(dart.str`Expect.deepEquals(${stringDifference}) fails.`);
+      } else {
+        expect.Expect._fail(dart.str`Expect.deepEquals(expected: <${expected}>, actual: <${actual}>) ` + "fails.");
+      }
+    }
     static throws(f, check, reason) {
       if (check === void 0) check = null;
       if (reason === void 0) reason = null;
       let msg = reason == null ? "" : dart.str`(${reason})`;
       if (!expect._Nullary.is(f)) {
         expect.Expect._fail(dart.str`Expect.throws${msg}: Function f not callable with zero arguments`);
       }
       try {
         f();
       } catch (e) {
@@ skipping 25 matching lines @@
       isNull: dart.definiteFunctionType(dart.void, [dart.dynamic], [core.String]),
       isNotNull: dart.definiteFunctionType(dart.void, [dart.dynamic], [core.String]),
       identical: dart.definiteFunctionType(dart.void, [dart.dynamic, dart.dynamic], [core.String]),
       fail: dart.definiteFunctionType(dart.void, [core.String]),
       approxEquals: dart.definiteFunctionType(dart.void, [core.num, core.num], [core.num, core.String]),
       notEquals: dart.definiteFunctionType(dart.void, [dart.dynamic, dart.dynamic], [core.String]),
       listEquals: dart.definiteFunctionType(dart.void, [core.List, core.List], [core.String]),
       mapEquals: dart.definiteFunctionType(dart.void, [core.Map, core.Map], [core.String]),
       stringEquals: dart.definiteFunctionType(dart.void, [core.String, core.String], [core.String]),
       setEquals: dart.definiteFunctionType(dart.void, [core.Iterable, core.Iterable], [core.String]),
+      deepEquals: dart.definiteFunctionType(dart.void, [core.Object, core.Object]),
       throws: dart.definiteFunctionType(dart.void, [VoidTovoid()], [expect._CheckExceptionFn, core.String]),
       _getMessage: dart.definiteFunctionType(core.String, [core.String]),
       _fail: dart.definiteFunctionType(dart.void, [core.String])
     }),
-    names: ['_truncateString', '_stringDifference', 'equals', 'isTrue', 'isFalse', 'isNull', 'isNotNull', 'identical', 'fail', 'approxEquals', 'notEquals', 'listEquals', 'mapEquals', 'stringEquals', 'setEquals', 'throws', '_getMessage', '_fail']
+    names: ['_truncateString', '_stringDifference', 'equals', 'isTrue', 'isFalse', 'isNull', 'isNotNull', 'identical', 'fail', 'approxEquals', 'notEquals', 'listEquals', 'mapEquals', 'stringEquals', 'setEquals', 'deepEquals', 'throws', '_getMessage', '_fail']
   });
   expect._identical = function(a, b) {
     return core.identical(a, b);
   };
   dart.fn(expect._identical, dynamicAnddynamicTobool());
   expect._CheckExceptionFn = dart.typedef('_CheckExceptionFn', () => dart.functionType(core.bool, [dart.dynamic]));
   expect._Nullary = dart.typedef('_Nullary', () => dart.functionType(dart.dynamic, []));
   expect.ExpectException = class ExpectException extends core.Object {
     new(message) {
       this.message = message;
@@ skipping 26 matching lines @@
     }
   };
   dart.setSignature(expect.AssumeDynamic, {
     constructors: () => ({new: dart.definiteFunctionType(expect.AssumeDynamic, [])})
   });
   // Exports:
   return {
     expect: expect
   };
 });