Migrate all remaining fixtures to jest expect

packages/babel-plugin-proposal-object-rest-spread/test/fixtures/object-rest/impure-computed-exec/exec.js

@@ -2,20 +2,20 @@ var key, x, y, z;
 // impure
 key = 1;
 var { [key++]: y, ...x } = { 1: 1, a: 1 };
-assert.deepEqual({ a: 1 }, x);
-assert.equal(key, 2);
-assert.equal(1, y);
+expect(x).toEqual({ a: 1 });
+expect(key).toBe(2);
+expect(1).toBe(y);
 
 // takes care of the order
 
 key = 1;
 var { [++key]: y, [++key]: z, ...rest} = {2: 2, 3: 3};
-assert.equal(y, 2);
-assert.equal(z, 3);
+expect(y).toBe(2);
+expect(z).toBe(3);
 
 // pure, computed property should remain as-is
 key = 2;
 ({ [key]: y, z, ...x } = {2: "two", z: "zee"});
-assert.equal(y, "two");
-assert.deepEqual(x, {});
-assert.equal(z, "zee");
+expect(y).toBe("two");
+expect(x).toEqual({});
+expect(z).toBe("zee");

packages/babel-plugin-proposal-object-rest-spread/test/fixtures/object-rest/impure-computed/input.js

@@ -2,20 +2,20 @@ var key, x, y, z;
 // impure
 key = 1;
 var { [key++]: y, ...x } = { 1: 1, a: 1 };
-assert.deepEqual({ a: 1 }, x);
-assert.equal(key, 2);
-assert.equal(1, y);
+expect(x).toEqual({ a: 1 });
+expect(key).toBe(2);
+expect(y).toBe(1);
 
 // takes care of the order
 
 key = 1;
 var { [++key]: y, [++key]: z, ...rest} = {2: 2, 3: 3};
-assert.equal(y, 2);
-assert.equal(z, 3);
+expect(y).toBe(2);
+expect(z).toBe(3);
 
 // pure, computed property should remain as-is
 key = 2;
 ({ [key]: y, z, ...x } = {2: "two", z: "zee"});
-assert.equal(y, "two");
-assert.deepEqual(x, {});
-assert.equal(z, "zee");
+expect(y).toBe("two");
+expect(x).toEqual({});
+expect(z).toBe("zee");

packages/babel-plugin-proposal-object-rest-spread/test/fixtures/object-rest/impure-computed/output.js

@@ -12,11 +12,11 @@ var _$a = {
 } = _$a,
     x = babelHelpers.objectWithoutProperties(_$a, [_ref].map(babelHelpers.toPropertyKey));
 
-assert.deepEqual({
+expect(x).toEqual({
   a: 1
-}, x);
-assert.equal(key, 2);
-assert.equal(1, y); // takes care of the order
+});
+expect(key).toBe(2);
+expect(y).toBe(1); // takes care of the order
 
 key = 1;
 
@@ -32,8 +32,8 @@ var _$ = {
 } = _$,
     rest = babelHelpers.objectWithoutProperties(_$, [_ref2, _ref3].map(babelHelpers.toPropertyKey));
 
-assert.equal(y, 2);
-assert.equal(z, 3); // pure, computed property should remain as-is
+expect(y).toBe(2);
+expect(z).toBe(3); // pure, computed property should remain as-is
 
 key = 2;
 var _$z = {
@@ -46,6 +46,6 @@ var _$z = {
 } = _$z);
 x = babelHelpers.objectWithoutProperties(_$z, [key, "z"].map(babelHelpers.toPropertyKey));
 _$z;
-assert.equal(y, "two");
-assert.deepEqual(x, {});
-assert.equal(z, "zee");
+expect(y).toBe("two");
+expect(x).toEqual({});
+expect(z).toBe("zee");

packages/babel-plugin-proposal-object-rest-spread/test/fixtures/object-rest/nested-order/exec.js

@@ -18,4 +18,4 @@ var obj = {
 
 var { a: { ...bar }, b: { ...baz }, ...foo } = obj;
 
-assert.strictEqual(result, "barbazfoo");
+expect(result).toBe("barbazfoo");

packages/babel-plugin-proposal-object-rest-spread/test/fixtures/object-rest/non-string-computed-exec/exec.js

@@ -8,8 +8,8 @@ const {
   ...rest
 } = a;
 
-assert.deepEqual(rest, {"foo": "bar"});
-assert.equal(omit, "three");
+expect(rest).toEqual({"foo": "bar"});
+expect(omit).toBe("three");
 
 const [k1, k2, k3, k4, k5] = [null, undefined, true, false, {toString() { return "warrior"; }}];
 const c = {
@@ -29,12 +29,12 @@ const {
   ...vrest
 } = c;
 
-assert.equal(v1, "1");
-assert.equal(v2, "2");
-assert.equal(v3, "3");
-assert.equal(v4, "4");
-assert.equal(v5, "5");
-assert.deepEqual(vrest, {});
+expect(v1).toBe("1");
+expect(v2).toBe("2");
+expect(v3).toBe("3");
+expect(v4).toBe("4");
+expect(v5).toBe("5");
+expect(vrest).toEqual({});
 
 // shouldn't convert symbols to strings
 const sx = Symbol();
@@ -50,5 +50,5 @@ const {
   [sy]: dy
 } = d;
 
-assert.equal(dx, "sx");
-assert.equal(dy, "sy");
+expect(dx).toBe("sx");
+expect(dy).toBe("sy");

packages/babel-plugin-proposal-object-rest-spread/test/fixtures/object-rest/non-string-computed/input.js

@@ -8,8 +8,8 @@ const {
   ...rest
 } = a;
 
-assert.deepEqual(rest, {"foo": "bar"});
-assert.equal(omit, "three");
+expect(rest).toEqual({"foo": "bar"});
+expect(omit).toBe("three");
 
 const [k1, k2, k3, k4, k5] = [null, undefined, true, false, {toString() { return "warrior"; }}];
 const c = {
@@ -29,12 +29,12 @@ const {
   ...vrest
 } = c;
 
-assert.equal(v1, "1");
-assert.equal(v2, "2");
-assert.equal(v3, "3");
-assert.equal(v4, "4");
-assert.equal(v5, "5");
-assert.deepEqual(vrest, {});
+expect(v1).toBe("1");
+expect(v2).toBe("2");
+expect(v3).toBe("3");
+expect(v4).toBe("4");
+expect(v5).toBe("5");
+expect(vrest).toEqual({});
 
 // shouldn't convert symbols to strings
 const sx = Symbol();
@@ -50,5 +50,5 @@ const {
   [sy]: dy
 } = d;
 
-assert.equal(dx, "sx");
-assert.equal(dy, "sy");
+expect(dx).toBe("sx");
+expect(dy).toBe("sy");

packages/babel-plugin-proposal-object-rest-spread/test/fixtures/object-rest/non-string-computed/output.js

@@ -6,10 +6,10 @@ const {
   [3]: omit
 } = a,
       rest = babelHelpers.objectWithoutProperties(a, ["3"]);
-assert.deepEqual(rest, {
+expect(rest).toEqual({
   "foo": "bar"
 });
-assert.equal(omit, "three");
+expect(omit).toBe("three");
 const [k1, k2, k3, k4, k5] = [null, undefined, true, false, {
   toString() {
     return "warrior";
@@ -31,12 +31,12 @@ const {
   [k5]: v5
 } = c,
       vrest = babelHelpers.objectWithoutProperties(c, [k1, k2, k3, k4, k5].map(babelHelpers.toPropertyKey));
-assert.equal(v1, "1");
-assert.equal(v2, "2");
-assert.equal(v3, "3");
-assert.equal(v4, "4");
-assert.equal(v5, "5");
-assert.deepEqual(vrest, {}); // shouldn't convert symbols to strings
+expect(v1).toBe("1");
+expect(v2).toBe("2");
+expect(v3).toBe("3");
+expect(v4).toBe("4");
+expect(v5).toBe("5");
+expect(vrest).toEqual({}); // shouldn't convert symbols to strings
 
 const sx = Symbol();
 const sy = Symbol();
@@ -48,5 +48,5 @@ const {
   [sx]: dx,
   [sy]: dy
 } = d;
-assert.equal(dx, "sx");
-assert.equal(dy, "sy");
+expect(dx).toBe("sx");
+expect(dy).toBe("sy");

packages/babel-plugin-proposal-object-rest-spread/test/fixtures/object-rest/symbol-exec/exec.js

@@ -8,13 +8,13 @@ Object.defineProperty(src, sym2, { value: "not enumerable" });
 
 const {...rest} = src;
 
-assert.strictEqual(rest[sym], "symbol");
-assert.strictEqual(rest.a, "string");
-assert.deepEqual(Object.getOwnPropertyNames(rest), ["a"]);
-assert.deepEqual(Object.getOwnPropertySymbols(rest), [sym]);
+expect(rest[sym]).toBe("symbol");
+expect(rest.a).toBe("string");
+expect(Object.getOwnPropertyNames(rest)).toEqual(["a"]);
+expect(Object.getOwnPropertySymbols(rest)).toEqual([sym]);
 
 const { [sym]: dst, ...noSym } = src;
 
-assert.strictEqual(dst, "symbol");
-assert.strictEqual(noSym.a, "string");
-assert.deepEqual(Object.getOwnPropertySymbols(noSym), []);
+expect(dst).toBe("symbol");
+expect(noSym.a).toBe("string");
+expect(Object.getOwnPropertySymbols(noSym)).toEqual([]);

packages/babel-plugin-proposal-object-rest-spread/test/fixtures/object-spread/no-object-assign-exec/exec.js

@@ -20,21 +20,21 @@ const obj2 = { NOSET: 123, NOWRITE: 456 };
 // (spread defines them)
 const obj2Spread = { ...obj2 };
 
-assert.deepEqual(obj, objSpread);
-assert.deepEqual(obj2, obj2Spread);
+expect(objSpread).toEqual(obj);
+expect(obj2Spread).toEqual(obj2);
 
 const KEY = Symbol('key');
 const obj3Spread = { ...{ get foo () { return 'bar' } }, [KEY]: 'symbol' };
-assert.equal(Object.getOwnPropertyDescriptor(obj3Spread, 'foo').value, 'bar');
-assert.equal(Object.getOwnPropertyDescriptor(obj3Spread, KEY).value, 'symbol');
+expect(Object.getOwnPropertyDescriptor(obj3Spread, 'foo').value).toBe('bar');
+expect(Object.getOwnPropertyDescriptor(obj3Spread, KEY).value).toBe('symbol');
 
 const obj4Spread = { ...Object.prototype };
-assert.isUndefined(Object.getOwnPropertyDescriptor(obj4Spread, 'hasOwnProperty'));
+expect(Object.getOwnPropertyDescriptor(obj4Spread, 'hasOwnProperty')).toBeUndefined();
 
-assert.doesNotThrow(() => ({ ...null, ...undefined }));
+expect(() => ({ ...null, ...undefined })).not.toThrow();
 
 const o = Object.create(null);
 o.a = 'foo';
 o.__proto__ = [];
 const o2 = { ...o };
-assert.equal(false, Array.isArray(Object.getPrototypeOf(o2)));
+expect(Array.isArray(Object.getPrototypeOf(o2))).toBe(false);