structure, layout and automation

node_modules/memoizee/test/lib/configure-map.js

@@ -0,0 +1,156 @@
+/* eslint id-length: 0, no-shadow: 0, no-unused-vars: 0 */
+
+"use strict";
+
+var aFrom   = require("es5-ext/array/from")
+  , memoize = require("../..");
+
+module.exports = function () {
+	return {
+		"One arg": function (a) {
+			var i = 0
+			  , fn = function (x) {
+				++i;
+				return x;
+			}
+			  , mfn
+			  , y = {
+				toString: function () {
+					return "foo";
+				}
+			};
+			mfn = memoize(fn, { primitive: true });
+			a(mfn(y), y, "#1");
+			a(mfn("foo"), y, "#2");
+			a(i, 1, "Called once");
+		},
+		"No args": function (a) {
+			var i = 0
+			  , fn = function () {
+				++i;
+				return "foo";
+			}
+			  , mfn
+			  , y = {
+				toString: function () {
+					return "foo";
+				}
+			};
+			mfn = memoize(fn);
+			a(mfn._has(), false);
+			a(mfn(), "foo", "#1");
+			a(mfn._has(), true);
+			mfn();
+			a(i, 1, "Called once");
+		},
+		"Clear cache": function (a) {
+			var i = 0
+			  , fn = function (x, y, z) {
+				++i;
+				return x + y + z;
+			}
+			  , mfn
+			  , y = {
+				toString: function () {
+					return "foo";
+				}
+			};
+			mfn = memoize(fn, { primitive: true });
+			a(mfn(y, "bar", "zeta"), "foobarzeta", "#1");
+			a(mfn("foo", "bar", "zeta"), "foobarzeta", "#2");
+			a(i, 1, "Called once");
+			mfn.delete(
+				"foo",
+				{
+					toString: function () {
+						return "bar";
+					}
+				},
+				"zeta"
+			);
+			a(mfn(y, "bar", "zeta"), "foobarzeta", "#3");
+			a(i, 2, "Called twice");
+		},
+		"_get": function (a) {
+			var fn = function (x) {
+				return x;
+			}
+			  , mfn;
+			mfn = memoize(fn);
+			a(mfn._get("foo"), undefined);
+			mfn("foo");
+			a(mfn._get("foo"), "foo");
+		},
+		"_has": function (a) {
+			var fn = function (x) {
+				return x;
+			}
+			  , mfn;
+			mfn = memoize(fn);
+			a(mfn._has("foo"), false);
+			mfn("foo");
+			a(mfn._has("foo"), true);
+		},
+		"Circular": function (a) {
+			var i = 0, fn;
+			fn = memoize(function (x) {
+				if (++i < 2) fn(x);
+			});
+			a.throws(function () {
+				fn("foo");
+			}, "CIRCULAR_INVOCATION");
+
+			i = 0;
+			fn = memoize(function (x, y) {
+				if (++i < 2) fn(x, y);
+			});
+			a.throws(function () {
+				fn("foo", "bar");
+			}, "CIRCULAR_INVOCATION");
+		},
+		"Resolvers": function () {
+			var i = 0, fn, r;
+			fn = memoize(
+				function () {
+					++i;
+					return arguments;
+				},
+				{ length: 3, resolvers: [Boolean, String] }
+			);
+			return {
+				"No args": function (a) {
+					i = 0;
+					a.deep(aFrom(r = fn()), [false, "undefined"], "First");
+					a(fn(), r, "Second");
+					a(fn(), r, "Third");
+					a(i, 1, "Called once");
+				},
+				"One arg": function (a) {
+					var fn = memoize(
+						function (elo) {
+							++i;
+							return arguments;
+						},
+						{ resolvers: [Boolean] }
+					);
+					a.deep(aFrom(r = fn("elo")), [true], "First");
+				},
+				"Some Args": function (a) {
+					var x = {};
+					i = 0;
+					a.deep(aFrom(r = fn(0, 34, x, 45)), [false, "34", x, 45], "First");
+					a(fn(0, 34, x, 22), r, "Second");
+					a(fn(0, 34, x, false), r, "Third");
+					a(i, 1, "Called once");
+					return {
+						Other: function (a) {
+							a.deep(aFrom(r = fn(1, 34, x, 34)), [true, "34", x, 34], "Second");
+							a(fn(1, 34, x, 89), r, "Third");
+							a(i, 2, "Called once");
+						}
+					};
+				}
+			};
+		}
+	};
+};

node_modules/memoizee/test/lib/methods.js

@@ -0,0 +1,50 @@
+/* eslint id-length: 0 */
+
+"use strict";
+
+var d       = require("d")
+  , memoize = require("../..");
+
+require("../ext/dispose");
+require("../ext/ref-counter");
+
+module.exports = function (t, a) {
+	var value = [], obj = {};
+	t = t(memoize);
+	Object.defineProperties(
+		obj,
+		t({
+			someFn: d(
+				function (x, y) {
+					a(this, obj);
+					return x + y;
+				},
+				{
+					refCounter: true,
+					dispose: function (val) {
+						value.push(val);
+					}
+				}
+			)
+		})
+	);
+
+	obj = Object.create(obj);
+	obj.someFn(3, 7);
+	obj.someFn(5, 8);
+	obj.someFn(12, 4);
+	a.deep(value, [], "Pre");
+	obj.someFn(5, 8);
+	obj.someFn.deleteRef(5, 8);
+	a.deep(value, [], "Pre");
+	obj.someFn.deleteRef(5, 8);
+	a.deep(value, [13], "#1");
+	value = [];
+	obj.someFn.deleteRef(12, 4);
+	a.deep(value, [16], "#2");
+
+	value = [];
+	obj.someFn(77, 11);
+	obj.someFn.clear();
+	a.deep(value, [10, 88], "Clear");
+};

node_modules/memoizee/test/lib/registered-extensions.js

@@ -0,0 +1,6 @@
+"use strict";
+
+module.exports = function (t, a) {
+	require("../../ext/async");
+	a(typeof t.async, "function");
+};

node_modules/memoizee/test/lib/resolve-length.js

@@ -0,0 +1,10 @@
+"use strict";
+
+module.exports = function (t, a) {
+	a(t(1, 2), 1, "Options");
+	a(t(1, 2, true), 1, "Options: Async ");
+	a(t(undefined, 2), 2, "Function");
+	a(t(undefined, 2, true), 1, "Function: Async");
+	a(t(undefined, undefined, false), 1, "Unknown");
+	a(t(undefined, undefined, true), 1, "Unknown: async");
+};

node_modules/memoizee/test/lib/resolve-normalize.js

@@ -0,0 +1,9 @@
+/* eslint no-empty-function: 0 */
+
+"use strict";
+
+module.exports = function (t, a) {
+	var fn = function () {}, resolved = t(fn);
+	a.deep(resolved, { get: fn, set: fn });
+	a.deep(t(resolved), { get: fn, set: fn });
+};

node_modules/memoizee/test/lib/resolve-resolve.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = function (t, a) {
+	a.deep(t([String, null, Number])([23, "foo", "45", "elo"]), ["23", "foo", 45, "elo"]);
+};

node_modules/memoizee/test/lib/weak.js

@@ -0,0 +1,53 @@
+/* eslint id-length: 0, no-shadow: 0, no-unused-vars: 0 */
+
+"use strict";
+
+var memoize = require("../..");
+
+require("../ext/dispose");
+require("../ext/ref-counter");
+
+module.exports = function (t, a) {
+	var value = [], obj = {}, memoized, count = 0, x, y, z;
+	t = t(memoize);
+	memoized = t(
+		function (arg, x, y) {
+			a(arg, obj);
+			return x + y;
+		},
+		{
+			refCounter: true,
+			dispose: function (val) {
+				value.push(val);
+			}
+		}
+	);
+
+	a(memoized(obj, 3, 7), 10);
+	a(memoized(obj, 5, 8), 13);
+	a(memoized(obj, 12, 4), 16);
+	a.deep(value, [], "Pre");
+	a(memoized(obj, 5, 8), 13);
+	memoized.deleteRef(obj, 5, 8);
+	a.deep(value, [], "Pre");
+	memoized.deleteRef(obj, 5, 8);
+	a.deep(value, [13], "#1");
+	value = [];
+	memoized.deleteRef(obj, 12, 4);
+	a.deep(value, [16], "#2");
+
+	value = [];
+	memoized(obj, 77, 11);
+
+	x = {};
+	y = {};
+	z = {};
+	memoized = t(function (arg) {
+		return ++count;
+	});
+	a(memoized(x), 1);
+	a(memoized(y), 2);
+	a(memoized(x), 1);
+	a(memoized(z), 3);
+	a(count, 3);
+};