165 lines
3.3 KiB
JavaScript
165 lines
3.3 KiB
JavaScript
let memor = require('.')
|
|
let assert = require('assert')
|
|
|
|
let func = () => ({})
|
|
let call = memor.memoize(func)
|
|
|
|
assert.equal(call([]), call([]))
|
|
|
|
{
|
|
let a = []
|
|
let r = call(a)
|
|
a.push(0)
|
|
assert.notEqual(call(a), r)
|
|
assert.equal(call(a), call([0]))
|
|
}
|
|
|
|
assert.equal(call([1, , 2]), call([1, , 2])) // eslint-disable-line no-sparse-arrays
|
|
|
|
assert.notEqual(call([1, , 2]), call([1, 2, ,])) // eslint-disable-line no-sparse-arrays
|
|
|
|
assert.notEqual(call([1, , 2]), call([1, undefined, 2])) // eslint-disable-line no-sparse-arrays
|
|
|
|
{
|
|
let a = []
|
|
let b = []
|
|
assert.equal(call(a), call(b))
|
|
b.x = 0
|
|
assert.notEqual(call(a), call(b))
|
|
}
|
|
|
|
assert.equal(call({}), call({}))
|
|
|
|
{
|
|
let a = {}
|
|
let r = call(a)
|
|
a.x = 0
|
|
assert.notEqual(call(a), r)
|
|
assert.equal(call(a), call({ x: 0 }))
|
|
}
|
|
|
|
assert.equal(call([{ a: 0 }]), call([{ a: 0 }]))
|
|
|
|
assert.notEqual(call({}), call({ a: undefined }))
|
|
|
|
assert.notEqual(call([[0, 0], [0]]), call([[0], [0, 0]]))
|
|
|
|
assert.notEqual(call([[0, 0], [0]]), call([[0, 0, [0]]]))
|
|
|
|
assert.equal(call({ a: 0, b: 1 }), call({ b: 1, a: 0 }))
|
|
|
|
{
|
|
let s = Symbol()
|
|
assert.notEqual(call({ a: 0, b: 1 }), call({ [s]: 2, b: 1, a: 0 }))
|
|
assert.equal(call({ a: 0, b: 1, [s]: 2 }), call({ [s]: 2, b: 1, a: 0 }))
|
|
assert.notEqual(call({ a: 0, b: 1, [s]: 2 }), call({ [s]: 3, b: 1, a: 0 }))
|
|
}
|
|
|
|
{
|
|
let s1 = Symbol()
|
|
let s2 = Symbol()
|
|
assert.equal(call({ a: 0, [s1]: 1, [s2]: 2 }), call({ [s2]: 2, [s1]: 1, a: 0 }))
|
|
}
|
|
|
|
assert.equal(call(new Date(2000, 0, 1)), call(new Date(2000, 0, 1, 0, 0, 0)))
|
|
|
|
assert.equal(call([new Date(2000, 0, 1)]), call([new Date(2000, 0, 1, 0, 0, 0)]))
|
|
|
|
{
|
|
let a = new Date(2000, 0, 1)
|
|
let r = call(a)
|
|
a.setFullYear(2001)
|
|
assert.notEqual(call(a), r)
|
|
assert.equal(call(a), call(new Date(2001, 0, 1)))
|
|
}
|
|
|
|
assert.equal(call(/a/), call(/a/))
|
|
|
|
assert.equal(call(/a/i), call(new RegExp('a', 'i')))
|
|
|
|
assert.notEqual(call(/a/), call(/a/i))
|
|
|
|
assert.equal(call(Buffer.from([])), call(Buffer.from([])))
|
|
|
|
assert.equal(call(Buffer.from([0])), call(Buffer.from([0])))
|
|
|
|
{
|
|
let a = Buffer.from([0])
|
|
let r = call(a)
|
|
a[0] = 1
|
|
assert.notEqual(call(a), r)
|
|
assert.equal(call(a), call(Buffer.from([1])))
|
|
}
|
|
|
|
assert.equal(call(), call())
|
|
|
|
assert.equal(call(null), call(null))
|
|
|
|
assert.notEqual(call(null), call())
|
|
|
|
assert.notEqual(call(true), call(true, undefined))
|
|
|
|
assert.equal(call(), memor.memoize(func)())
|
|
|
|
assert.equal(call(Object.create(null)), call(Object.create(null)))
|
|
|
|
assert.notEqual(call(Object.create(null)), call({}))
|
|
|
|
{
|
|
class Foo {}
|
|
memor.add(Foo)
|
|
let foo = new Foo()
|
|
let r1 = call(foo)
|
|
assert.notEqual(call({}), r1)
|
|
foo.bar = 0
|
|
let r2 = call(foo)
|
|
assert.notEqual(r1, r2)
|
|
foo = new Foo()
|
|
assert.equal(call(foo), r1)
|
|
foo.bar = 0
|
|
assert.equal(call(foo), r2)
|
|
}
|
|
|
|
{
|
|
class Bar {}
|
|
let sigil = {}
|
|
memor.addCustom(Bar, (obj, push, recurse) => {
|
|
push(sigil)
|
|
recurse(obj.baz)
|
|
})
|
|
let bar = new Bar()
|
|
let r1 = call(bar)
|
|
bar.quuz = 0
|
|
assert.equal(call(bar), r1)
|
|
bar.baz = 0
|
|
let r2 = call(bar)
|
|
assert.notEqual(r1, r2)
|
|
bar = new Bar()
|
|
assert.equal(call(bar), r1)
|
|
bar.baz = 0
|
|
assert.equal(call(bar), r2)
|
|
}
|
|
|
|
{
|
|
class Foo {}
|
|
class Bar {}
|
|
memor.add(Foo, Bar)
|
|
assert.equal(call(new Foo()), call(new Foo()))
|
|
assert.equal(call(new Bar()), call(new Bar()))
|
|
assert.notEqual(call(new Foo()), call(new Bar()))
|
|
}
|
|
|
|
assert.equal(call.original, func)
|
|
|
|
{
|
|
let r = call()
|
|
memor.clear(func)
|
|
assert.notEqual(call(), r)
|
|
}
|
|
|
|
{
|
|
let r = call()
|
|
memor.clear(call)
|
|
assert.notEqual(call(), r)
|
|
}
|