replace assert.strictEqual with assert.deepStrictEqual

gcanti · Dec 21, 2019 · 998c74f · 998c74f
1 parent c901b6d
commit 998c74f
Show file tree

Hide file tree

Showing 39 changed files with 554 additions and 554 deletions.
diff --git a/test/Array.ts b/test/Array.ts
@@ -91,40 +91,40 @@ describe('Array', () => {
 
   it('getEq', () => {
     const O = getEq(ordString)
-    assert.strictEqual(O.equals([], []), true, '[] ]')
-    assert.strictEqual(O.equals(['a'], ['a']), true, '[a], [a]')
-    assert.strictEqual(O.equals(['a', 'b'], ['a', 'b']), true, '[a, b], [a, b]')
-    assert.strictEqual(O.equals(['a'], []), false, '[a] []')
-    assert.strictEqual(O.equals([], ['a']), false, '[], [a]')
-    assert.strictEqual(O.equals(['a'], ['b']), false, '[a], [b]')
-    assert.strictEqual(O.equals(['a', 'b'], ['b', 'a']), false, '[a, b], [b, a]')
-    assert.strictEqual(O.equals(['a', 'a'], ['a']), false, '[a, a], [a]')
+    assert.deepStrictEqual(O.equals([], []), true, '[] ]')
+    assert.deepStrictEqual(O.equals(['a'], ['a']), true, '[a], [a]')
+    assert.deepStrictEqual(O.equals(['a', 'b'], ['a', 'b']), true, '[a, b], [a, b]')
+    assert.deepStrictEqual(O.equals(['a'], []), false, '[a] []')
+    assert.deepStrictEqual(O.equals([], ['a']), false, '[], [a]')
+    assert.deepStrictEqual(O.equals(['a'], ['b']), false, '[a], [b]')
+    assert.deepStrictEqual(O.equals(['a', 'b'], ['b', 'a']), false, '[a, b], [b, a]')
+    assert.deepStrictEqual(O.equals(['a', 'a'], ['a']), false, '[a, a], [a]')
   })
 
   it('getOrd', () => {
     const O = getOrd(ordString)
-    assert.strictEqual(O.compare([], []), 0, '[] ]')
-    assert.strictEqual(O.compare(['a'], ['a']), 0, '[a], [a]')
+    assert.deepStrictEqual(O.compare([], []), 0, '[] ]')
+    assert.deepStrictEqual(O.compare(['a'], ['a']), 0, '[a], [a]')
 
-    assert.strictEqual(O.compare(['b'], ['a']), 1, '[b], [a]')
-    assert.strictEqual(O.compare(['a'], ['b']), -1, '[a], [b]')
+    assert.deepStrictEqual(O.compare(['b'], ['a']), 1, '[b], [a]')
+    assert.deepStrictEqual(O.compare(['a'], ['b']), -1, '[a], [b]')
 
-    assert.strictEqual(O.compare(['a'], []), 1, '[a] []')
-    assert.strictEqual(O.compare([], ['a']), -1, '[], [a]')
-    assert.strictEqual(O.compare(['a', 'a'], ['a']), 1, '[a, a], [a]')
-    assert.strictEqual(O.compare(['a', 'a'], ['b']), -1, '[a, a], [a]')
+    assert.deepStrictEqual(O.compare(['a'], []), 1, '[a] []')
+    assert.deepStrictEqual(O.compare([], ['a']), -1, '[], [a]')
+    assert.deepStrictEqual(O.compare(['a', 'a'], ['a']), 1, '[a, a], [a]')
+    assert.deepStrictEqual(O.compare(['a', 'a'], ['b']), -1, '[a, a], [a]')
 
-    assert.strictEqual(O.compare(['a', 'a'], ['a', 'a']), 0, '[a, a], [a, a]')
-    assert.strictEqual(O.compare(['a', 'b'], ['a', 'b']), 0, '[a, b], [a, b]')
+    assert.deepStrictEqual(O.compare(['a', 'a'], ['a', 'a']), 0, '[a, a], [a, a]')
+    assert.deepStrictEqual(O.compare(['a', 'b'], ['a', 'b']), 0, '[a, b], [a, b]')
 
-    assert.strictEqual(O.compare(['a', 'a'], ['a', 'b']), -1, '[a, a], [a, b]')
-    assert.strictEqual(O.compare(['a', 'b'], ['a', 'a']), 1, '[a, b], [a, a]')
+    assert.deepStrictEqual(O.compare(['a', 'a'], ['a', 'b']), -1, '[a, a], [a, b]')
+    assert.deepStrictEqual(O.compare(['a', 'b'], ['a', 'a']), 1, '[a, b], [a, a]')
 
-    assert.strictEqual(O.compare(['a', 'b'], ['b', 'a']), -1, '[a, b], [b, a]')
-    assert.strictEqual(O.compare(['b', 'a'], ['a', 'a']), 1, '[b, a], [a, a]')
-    assert.strictEqual(O.compare(['b', 'a'], ['a', 'b']), 1, '[b, b], [a, a]')
-    assert.strictEqual(O.compare(['b', 'b'], ['b', 'a']), 1, '[b, b], [b, a]')
-    assert.strictEqual(O.compare(['b', 'a'], ['b', 'b']), -1, '[b, a], [b, b]')
+    assert.deepStrictEqual(O.compare(['a', 'b'], ['b', 'a']), -1, '[a, b], [b, a]')
+    assert.deepStrictEqual(O.compare(['b', 'a'], ['a', 'a']), 1, '[b, a], [a, a]')
+    assert.deepStrictEqual(O.compare(['b', 'a'], ['a', 'b']), 1, '[b, b], [a, a]')
+    assert.deepStrictEqual(O.compare(['b', 'b'], ['b', 'a']), 1, '[b, b], [b, a]')
+    assert.deepStrictEqual(O.compare(['b', 'a'], ['b', 'b']), -1, '[b, a], [b, b]')
   })
 
   it('ap', () => {
@@ -153,13 +153,13 @@ describe('Array', () => {
   })
 
   it('isEmpty', () => {
-    assert.strictEqual(isEmpty(as), false)
-    assert.strictEqual(isEmpty([]), true)
+    assert.deepStrictEqual(isEmpty(as), false)
+    assert.deepStrictEqual(isEmpty([]), true)
   })
 
   it('isNotEmpty', () => {
-    assert.strictEqual(isNonEmpty(as), true)
-    assert.strictEqual(isNonEmpty([]), false)
+    assert.deepStrictEqual(isNonEmpty(as), true)
+    assert.deepStrictEqual(isNonEmpty([]), false)
   })
 
   it('cons', () => {
@@ -342,7 +342,7 @@ describe('Array', () => {
     const x = { a: 1 }
     const as = [x]
     const result = unsafeUpdateAt(0, x, as)
-    assert.strictEqual(result, as)
+    assert.deepStrictEqual(result, as)
   })
 
   it('updateAt', () => {
@@ -448,7 +448,7 @@ describe('Array', () => {
     const xs = [1, 2, 3]
     const ys = copy([1, 2, 3])
     assert.deepStrictEqual(xs, ys)
-    assert.strictEqual(xs !== ys, true)
+    assert.deepStrictEqual(xs !== ys, true)
   })
 
   it('chain', () => {
@@ -473,35 +473,35 @@ describe('Array', () => {
     const foldMap = array.foldMap(monoidString)
     const x1 = ['a', 'b', 'c']
     const f1 = identity
-    assert.strictEqual(foldMap(x1, f1), 'abc')
+    assert.deepStrictEqual(foldMap(x1, f1), 'abc')
     const x2: Array<string> = []
-    assert.strictEqual(foldMap(x2, f1), '')
+    assert.deepStrictEqual(foldMap(x2, f1), '')
   })
 
   it('reduceRight', () => {
     const reduceRight = array.reduceRight
     const x1 = ['a', 'b', 'c']
     const init1 = ''
     const f1 = (a: string, acc: string) => acc + a
-    assert.strictEqual(reduceRight(x1, init1, f1), 'cba')
+    assert.deepStrictEqual(reduceRight(x1, init1, f1), 'cba')
     const x2: Array<string> = []
-    assert.strictEqual(reduceRight(x2, init1, f1), '')
+    assert.deepStrictEqual(reduceRight(x2, init1, f1), '')
   })
 
   it('foldLeft', () => {
     const len: <A>(as: Array<A>) => number = foldLeft(
       () => 0,
       (_, tail) => 1 + len(tail)
     )
-    assert.strictEqual(len([1, 2, 3]), 3)
+    assert.deepStrictEqual(len([1, 2, 3]), 3)
   })
 
   it('foldRight', () => {
     const len: <A>(as: Array<A>) => number = foldRight(
       () => 0,
       (init, _) => 1 + len(init)
     )
-    assert.strictEqual(len([1, 2, 3]), 3)
+    assert.deepStrictEqual(len([1, 2, 3]), 3)
   })
 
   it('scanLeft', () => {
@@ -846,8 +846,8 @@ describe('Array', () => {
 
   it('getShow', () => {
     const S = getShow(showString)
-    assert.strictEqual(S.show([]), `[]`)
-    assert.strictEqual(S.show(['a']), `["a"]`)
-    assert.strictEqual(S.show(['a', 'b']), `["a", "b"]`)
+    assert.deepStrictEqual(S.show([]), `[]`)
+    assert.deepStrictEqual(S.show(['a']), `["a"]`)
+    assert.deepStrictEqual(S.show(['a', 'b']), `["a", "b"]`)
   })
 })
diff --git a/test/BooleanAlgebra.ts b/test/BooleanAlgebra.ts
@@ -9,81 +9,81 @@ import {
 describe('BooleanAlgebra', () => {
   it('booleanAlgebraBoolean', () => {
     const BA = booleanAlgebraBoolean
-    assert.strictEqual(BA.implies(true, true), true)
-    assert.strictEqual(BA.implies(true, false), false)
-    assert.strictEqual(BA.implies(false, true), true)
-    assert.strictEqual(BA.implies(false, false), true)
+    assert.deepStrictEqual(BA.implies(true, true), true)
+    assert.deepStrictEqual(BA.implies(true, false), false)
+    assert.deepStrictEqual(BA.implies(false, true), true)
+    assert.deepStrictEqual(BA.implies(false, false), true)
 
-    assert.strictEqual(BA.join(true, true), true)
-    assert.strictEqual(BA.join(true, false), true)
-    assert.strictEqual(BA.join(false, true), true)
-    assert.strictEqual(BA.join(false, false), false)
+    assert.deepStrictEqual(BA.join(true, true), true)
+    assert.deepStrictEqual(BA.join(true, false), true)
+    assert.deepStrictEqual(BA.join(false, true), true)
+    assert.deepStrictEqual(BA.join(false, false), false)
 
-    assert.strictEqual(BA.meet(true, true), true)
-    assert.strictEqual(BA.meet(true, false), false)
+    assert.deepStrictEqual(BA.meet(true, true), true)
+    assert.deepStrictEqual(BA.meet(true, false), false)
 
-    assert.strictEqual(BA.not(true), false)
-    assert.strictEqual(BA.not(false), true)
+    assert.deepStrictEqual(BA.not(true), false)
+    assert.deepStrictEqual(BA.not(false), true)
 
-    assert.strictEqual(BA.one, true)
-    assert.strictEqual(BA.zero, false)
+    assert.deepStrictEqual(BA.one, true)
+    assert.deepStrictEqual(BA.zero, false)
   })
 
   it('booleanAlgebraVoid', () => {
     const BA = booleanAlgebraVoid
-    assert.strictEqual(BA.implies(undefined, undefined), undefined)
+    assert.deepStrictEqual(BA.implies(undefined, undefined), undefined)
 
-    assert.strictEqual(BA.join(undefined, undefined), undefined)
+    assert.deepStrictEqual(BA.join(undefined, undefined), undefined)
 
-    assert.strictEqual(BA.meet(undefined, undefined), undefined)
+    assert.deepStrictEqual(BA.meet(undefined, undefined), undefined)
 
-    assert.strictEqual(BA.not(undefined), undefined)
+    assert.deepStrictEqual(BA.not(undefined), undefined)
 
-    assert.strictEqual(BA.one, undefined)
-    assert.strictEqual(BA.zero, undefined)
+    assert.deepStrictEqual(BA.one, undefined)
+    assert.deepStrictEqual(BA.zero, undefined)
   })
 
   it('getFunctionBooleanAlgebra', () => {
     const BA = getFunctionBooleanAlgebra(booleanAlgebraBoolean)<number>()
     const f = (n: number) => n >= 0
     const g = (n: number) => n < 2
-    assert.strictEqual(BA.implies(f, g)(1), true)
-    assert.strictEqual(BA.implies(f, g)(-1), true)
+    assert.deepStrictEqual(BA.implies(f, g)(1), true)
+    assert.deepStrictEqual(BA.implies(f, g)(-1), true)
 
-    assert.strictEqual(BA.join(f, g)(1), true)
-    assert.strictEqual(BA.join(f, g)(-1), true)
+    assert.deepStrictEqual(BA.join(f, g)(1), true)
+    assert.deepStrictEqual(BA.join(f, g)(-1), true)
 
-    assert.strictEqual(BA.meet(f, g)(1), true)
-    assert.strictEqual(BA.meet(f, g)(-1), false)
+    assert.deepStrictEqual(BA.meet(f, g)(1), true)
+    assert.deepStrictEqual(BA.meet(f, g)(-1), false)
 
-    assert.strictEqual(BA.not(f)(1), false)
-    assert.strictEqual(BA.not(f)(-1), true)
+    assert.deepStrictEqual(BA.not(f)(1), false)
+    assert.deepStrictEqual(BA.not(f)(-1), true)
 
-    assert.strictEqual(BA.one(1), true)
-    assert.strictEqual(BA.one(-1), true)
-    assert.strictEqual(BA.zero(1), false)
-    assert.strictEqual(BA.zero(-1), false)
+    assert.deepStrictEqual(BA.one(1), true)
+    assert.deepStrictEqual(BA.one(-1), true)
+    assert.deepStrictEqual(BA.zero(1), false)
+    assert.deepStrictEqual(BA.zero(-1), false)
   })
 
   it('getDualBooleanAlgebra', () => {
     const BA = getDualBooleanAlgebra(booleanAlgebraBoolean)
-    assert.strictEqual(BA.implies(true, true), true)
-    assert.strictEqual(BA.implies(true, false), false)
-    assert.strictEqual(BA.implies(false, true), true)
-    assert.strictEqual(BA.implies(false, false), true)
+    assert.deepStrictEqual(BA.implies(true, true), true)
+    assert.deepStrictEqual(BA.implies(true, false), false)
+    assert.deepStrictEqual(BA.implies(false, true), true)
+    assert.deepStrictEqual(BA.implies(false, false), true)
 
-    assert.strictEqual(BA.join(true, true), true)
-    assert.strictEqual(BA.join(true, false), false)
-    assert.strictEqual(BA.join(false, true), false)
-    assert.strictEqual(BA.join(false, false), false)
+    assert.deepStrictEqual(BA.join(true, true), true)
+    assert.deepStrictEqual(BA.join(true, false), false)
+    assert.deepStrictEqual(BA.join(false, true), false)
+    assert.deepStrictEqual(BA.join(false, false), false)
 
-    assert.strictEqual(BA.meet(true, true), true)
-    assert.strictEqual(BA.meet(true, false), true)
+    assert.deepStrictEqual(BA.meet(true, true), true)
+    assert.deepStrictEqual(BA.meet(true, false), true)
 
-    assert.strictEqual(BA.not(true), false)
-    assert.strictEqual(BA.not(false), true)
+    assert.deepStrictEqual(BA.not(true), false)
+    assert.deepStrictEqual(BA.not(false), true)
 
-    assert.strictEqual(BA.one, false)
-    assert.strictEqual(BA.zero, true)
+    assert.deepStrictEqual(BA.one, false)
+    assert.deepStrictEqual(BA.zero, true)
   })
 })
diff --git a/test/BoundedDistributiveLattice.ts b/test/BoundedDistributiveLattice.ts
@@ -5,9 +5,9 @@ import { ordNumber } from '../src/Ord'
 describe('BoundedDistributiveLattice', () => {
   it('getMinMaxBoundedDistributiveLattice', () => {
     const BDL = getMinMaxBoundedDistributiveLattice(ordNumber)(0, 1)
-    assert.strictEqual(BDL.join(0.2, 0.4), 0.4)
-    assert.strictEqual(BDL.meet(0.2, 0.4), 0.2)
-    assert.strictEqual(BDL.one, 1)
-    assert.strictEqual(BDL.zero, 0)
+    assert.deepStrictEqual(BDL.join(0.2, 0.4), 0.4)
+    assert.deepStrictEqual(BDL.meet(0.2, 0.4), 0.2)
+    assert.deepStrictEqual(BDL.one, 1)
+    assert.deepStrictEqual(BDL.zero, 0)
   })
 })
diff --git a/test/Const.ts b/test/Const.ts
@@ -9,13 +9,13 @@ describe('Const', () => {
   it('map', () => {
     const fa = make('foo')
     const double = (n: number): number => n * 2
-    assert.strictEqual(const_.map(fa, double), fa)
+    assert.deepStrictEqual(const_.map(fa, double), fa)
   })
 
   it('contramap', () => {
     const fa: Const<string, number> = make('foo')
     const double = (n: number): number => n * 2
-    assert.strictEqual(const_.contramap(fa, double), fa)
+    assert.deepStrictEqual(const_.contramap(fa, double), fa)
   })
 
   it('getApplicative', () => {
@@ -25,8 +25,8 @@ describe('Const', () => {
 
   it('getEq', () => {
     const S = getEq(eqNumber)
-    assert.strictEqual(S.equals(make(1), make(1)), true)
-    assert.strictEqual(S.equals(make(1), make(2)), false)
+    assert.deepStrictEqual(S.equals(make(1), make(1)), true)
+    assert.deepStrictEqual(S.equals(make(1), make(2)), false)
   })
 
   it('getApplicative', () => {
@@ -38,6 +38,6 @@ describe('Const', () => {
   it('getShow', () => {
     const S = getShow(showString)
     const x: Const<string, number> = make('a')
-    assert.strictEqual(S.show(x), `make("a")`)
+    assert.deepStrictEqual(S.show(x), `make("a")`)
   })
 })
diff --git a/test/Date.ts b/test/Date.ts
@@ -5,13 +5,13 @@ describe('Date', () => {
   it('create', () => {
     const d1 = create()
     const m2 = new Date().getTime()
-    assert.strictEqual(d1 instanceof Date, true)
-    assert.strictEqual(d1.getTime(), m2)
+    assert.deepStrictEqual(d1 instanceof Date, true)
+    assert.deepStrictEqual(d1.getTime(), m2)
   })
 
   it('now', () => {
     const m1 = now()
     const m2 = new Date().getTime()
-    assert.strictEqual(m1, m2)
+    assert.deepStrictEqual(m1, m2)
   })
 })