aid.js
Version:
A Bundle of Javascript util Library to help developers. No dependency to other Libraries.
1,602 lines (1,246 loc) • 131 kB
JavaScript
'use strict';
describe('aid.js', function() {
// sample - http://jasmine.github.io/2.0/introduction.html
describe('aid', function() {
describe('.existy()', function() {
it('input undefined, return false', function() {
expect(aid.existy(undefined)).toEqual(false);
});
it('input "undefined", return true', function() {
expect(aid.existy('undefined')).toEqual(true);
});
it('input null, return false', function() {
expect(aid.existy(null)).toEqual(false);
});
it('input false, return true', function() {
expect(aid.existy(false)).toEqual(true);
});
it('input true, return true', function() {
expect(aid.existy(true)).toEqual(true);
});
it('input 0, return true', function() {
expect(aid.existy(0)).toEqual(true);
});
it('input "", return true', function() {
expect(aid.existy('')).toEqual(true);
});
it('input {}, return true', function() {
expect(aid.existy({})).toEqual(true);
});
});
describe('.isDefined()', function() {
it('input undefined, return false', function() {
expect(aid.isDefined(undefined)).toEqual(false);
});
it('input "undefined", return true', function() {
expect(aid.isDefined('undefined')).toEqual(true);
});
it('input null, return false', function() {
expect(aid.isDefined(null)).toEqual(false);
});
it('input false, return true', function() {
expect(aid.isDefined(false)).toEqual(true);
});
it('input true, return true', function() {
expect(aid.isDefined(true)).toEqual(true);
});
it('input 0, return true', function() {
expect(aid.isDefined(0)).toEqual(true);
});
it('input "", return true', function() {
expect(aid.isDefined('')).toEqual(true);
});
it('input {}, return true', function() {
expect(aid.isDefined({})).toEqual(true);
});
});
describe('.isBoolean()', function() {
it('input undefined, return false', function() {
expect(aid.isBoolean(undefined)).toEqual(false);
});
it('input "undefined", return false', function() {
expect(aid.isBoolean('undefined')).toEqual(false);
});
it('input null, return false', function() {
expect(aid.isBoolean(null)).toEqual(false);
});
it('input false, return true', function() {
expect(aid.isBoolean(false)).toEqual(true);
});
it('input true, return true', function() {
expect(aid.isBoolean(true)).toEqual(true);
});
it('input 0, return false', function() {
expect(aid.isBoolean(0)).toEqual(false);
});
it('input "", return false', function() {
expect(aid.isBoolean('')).toEqual(false);
});
it('input {}, return false', function() {
expect(aid.isBoolean({})).toEqual(false);
});
});
describe('.isNumber()', function() {
it('input undefined, return false', function() {
expect(aid.isNumber(undefined)).toEqual(false);
});
it('input "undefined", return false', function() {
expect(aid.isNumber('undefined')).toEqual(false);
});
it('input null, return false', function() {
expect(aid.isNumber(null)).toEqual(false);
});
it('input false, return false', function() {
expect(aid.isNumber(false)).toEqual(false);
});
it('input true, return false', function() {
expect(aid.isNumber(true)).toEqual(false);
});
it('input "", return false', function() {
expect(aid.isNumber('')).toEqual(false);
});
it('input {}, return false', function() {
expect(aid.isNumber({})).toEqual(false);
});
it('input 0, return true', function() {
expect(aid.isNumber(0)).toEqual(true);
});
it('input -1, return true', function() {
expect(aid.isNumber(-1)).toEqual(true);
});
it('input Infinity, return true', function() {
expect(aid.isNumber(Infinity)).toEqual(true);
});
it('input NaN, return false', function() {
expect(aid.isNumber(NaN)).toEqual(false);
});
it('input Number.NaN, return false', function() {
expect(aid.isNumber(Number.NaN)).toEqual(false);
});
it('input Number.MAX_VALUE, return true', function() {
expect(aid.isNumber(Number.MAX_VALUE)).toEqual(true);
});
it('input Number.MIN_VALUE, return true', function() {
expect(aid.isNumber(Number.MIN_VALUE)).toEqual(true);
});
it('input Number.POSITIVE_INFINITY, return true', function() {
expect(aid.isNumber(Number.POSITIVE_INFINITY)).toEqual(true);
});
it('input Number.NEGATIVE_INFINITY, return true', function() {
expect(aid.isNumber(Number.NEGATIVE_INFINITY)).toEqual(true);
});
});
describe('.isInteger()', function() {
it('input undefined, return false', function() {
expect(aid.isInteger(undefined)).toEqual(false);
});
it('input "undefined", return false', function() {
expect(aid.isInteger('undefined')).toEqual(false);
});
it('input null, return false', function() {
expect(aid.isInteger(null)).toEqual(false);
});
it('input false, return false', function() {
expect(aid.isInteger(false)).toEqual(false);
});
it('input true, return false', function() {
expect(aid.isInteger(true)).toEqual(false);
});
it('input "", return false', function() {
expect(aid.isInteger('')).toEqual(false);
});
it('input {}, return false', function() {
expect(aid.isInteger({})).toEqual(false);
});
it('input infinity, return true', function() {
expect(aid.isInteger(Infinity)).toEqual(false);
expect(aid.isInteger(-Infinity)).toEqual(false);
});
it('input float, return true', function() {
expect(aid.isInteger(-0.99)).toEqual(false);
expect(aid.isInteger(0.99)).toEqual(false);
});
it('input int, return true', function() {
expect(aid.isInteger(-99)).toEqual(true);
expect(aid.isInteger(0)).toEqual(true);
expect(aid.isInteger(99)).toEqual(true);
});
});
describe('.isString()', function() {
it('input undefined, return false', function() {
expect(aid.isString(undefined)).toEqual(false);
});
it('input "undefined", return true', function() {
expect(aid.isString('undefined')).toEqual(true);
});
it('input null, return false', function() {
expect(aid.isString(null)).toEqual(false);
});
it('input false, return true', function() {
expect(aid.isString(false)).toEqual(false);
});
it('input true, return true', function() {
expect(aid.isString(true)).toEqual(false);
});
it('input 0, return false', function() {
expect(aid.isString(0)).toEqual(false);
});
it('input "", return true', function() {
expect(aid.isString('')).toEqual(true);
});
it('input {}, return false', function() {
expect(aid.isString({})).toEqual(false);
});
});
describe('.isArray()', function() {
it('input undefined, return false', function() {
expect(aid.isArray(undefined)).toEqual(false);
});
it('input "undefined", return false', function() {
expect(aid.isArray('undefined')).toEqual(false);
});
it('input null, return false', function() {
expect(aid.isArray(null)).toEqual(false);
});
it('input false, return false', function() {
expect(aid.isArray(false)).toEqual(false);
});
it('input true, return false', function() {
expect(aid.isArray(true)).toEqual(false);
});
it('input 0, return false', function() {
expect(aid.isArray(0)).toEqual(false);
});
it('input "", return false', function() {
expect(aid.isArray('')).toEqual(false);
});
it('input {}, return false', function() {
expect(aid.isArray({})).toEqual(false);
});
it('input [], return true', function() {
expect(aid.isArray([])).toEqual(true);
});
});
describe('.isObject()', function() {
it('input undefined, return false', function() {
expect(aid.isObject(undefined)).toEqual(false);
});
it('input "undefined", return false', function() {
expect(aid.isObject('undefined')).toEqual(false);
});
it('input null, return false', function() {
expect(aid.isObject(null)).toEqual(false);
});
it('input false, return false', function() {
expect(aid.isObject(false)).toEqual(false);
});
it('input true, return false', function() {
expect(aid.isObject(true)).toEqual(false);
});
it('input 0, return false', function() {
expect(aid.isObject(0)).toEqual(false);
});
it('input "", return false', function() {
expect(aid.isObject('')).toEqual(false);
});
it('input {}, return true', function() {
expect(aid.isObject({})).toEqual(true);
});
it('input [], return false', function() {
expect(aid.isObject([])).toEqual(false);
});
});
describe('.isFunction()', function() {
it('input undefined, return false', function() {
expect(aid.isFunction(undefined)).toEqual(false);
});
it('input "undefined", return false', function() {
expect(aid.isFunction('undefined')).toEqual(false);
});
it('input null, return false', function() {
expect(aid.isFunction(null)).toEqual(false);
});
it('input false, return false', function() {
expect(aid.isFunction(false)).toEqual(false);
});
it('input true, return false', function() {
expect(aid.isFunction(true)).toEqual(false);
});
it('input 0, return false', function() {
expect(aid.isFunction(0)).toEqual(false);
});
it('input "", return false', function() {
expect(aid.isFunction('')).toEqual(false);
});
it('input {}, return false', function() {
expect(aid.isFunction({})).toEqual(false);
});
it('input [], return false', function() {
expect(aid.isFunction([])).toEqual(false);
});
it('input function(){}, return true', function() {
expect(aid.isFunction(function() {})).toEqual(true);
});
it('input literal function, return true', function() {
var func = function() {};
expect(aid.isFunction(func)).toEqual(true);
});
});
describe('.isRegExp()', function() {
it('input undefined, return false', function() {
expect(aid.isRegExp(undefined)).toEqual(false);
});
it('input "undefined", return false', function() {
expect(aid.isRegExp('undefined')).toEqual(false);
});
it('input null, return false', function() {
expect(aid.isRegExp(null)).toEqual(false);
});
it('input false, return false', function() {
expect(aid.isRegExp(false)).toEqual(false);
});
it('input true, return false', function() {
expect(aid.isRegExp(true)).toEqual(false);
});
it('input 0, return false', function() {
expect(aid.isRegExp(0)).toEqual(false);
});
it('input "", return false', function() {
expect(aid.isRegExp('')).toEqual(false);
});
it('input {}, return false', function() {
expect(aid.isRegExp({})).toEqual(false);
});
it('input [], return false', function() {
expect(aid.isRegExp([])).toEqual(false);
});
it('input function(){}, return false', function() {
expect(aid.isRegExp(function() {})).toEqual(false);
});
it('input RegExp object, return true', function() {
expect(aid.isRegExp(new RegExp('^aid'))).toEqual(true);
});
it('input RegExp literal, return true', function() {
expect(aid.isRegExp(/^aid/)).toEqual(true);
});
});
describe('.isError()', function() {
it('input undefined, return false', function() {
expect(aid.isError(undefined)).toEqual(false);
});
it('input "undefined", return false', function() {
expect(aid.isError('undefined')).toEqual(false);
});
it('input null, return false', function() {
expect(aid.isError(null)).toEqual(false);
});
it('input false, return false', function() {
expect(aid.isError(false)).toEqual(false);
});
it('input true, return false', function() {
expect(aid.isError(true)).toEqual(false);
});
it('input 0, return false', function() {
expect(aid.isError(0)).toEqual(false);
});
it('input "", return false', function() {
expect(aid.isError('')).toEqual(false);
});
it('input {}, return false', function() {
expect(aid.isError({})).toEqual(false);
});
it('input [], return false', function() {
expect(aid.isError([])).toEqual(false);
});
it('input function(){}, return false', function() {
expect(aid.isError(function() {})).toEqual(false);
});
it('input RegExp object, return false', function() {
expect(aid.isError(new RegExp('^aid'))).toEqual(false);
});
it('input RegExp literal, return false', function() {
expect(aid.isError(/^aid/)).toEqual(false);
});
it('input Error, return true', function() {
expect(aid.isError(new Error('error'))).toEqual(true);
expect(aid.isError(new EvalError('error'))).toEqual(true);
expect(aid.isError(new RangeError('error'))).toEqual(true);
expect(aid.isError(new ReferenceError('error'))).toEqual(true);
expect(aid.isError(new SyntaxError('error'))).toEqual(true);
expect(aid.isError(new TypeError('error'))).toEqual(true);
expect(aid.isError(new URIError('error'))).toEqual(true);
});
it('input Error and Error type, return true', function() {
expect(aid.isError(new Error('error'), Error)).toEqual(true);
expect(aid.isError(new Error('error'), EvalError)).toEqual(false);
expect(aid.isError(new Error('error'), RangeError)).toEqual(false);
expect(aid.isError(new Error('error'), ReferenceError)).toEqual(false);
expect(aid.isError(new Error('error'), SyntaxError)).toEqual(false);
expect(aid.isError(new Error('error'), TypeError)).toEqual(false);
expect(aid.isError(new Error('error'), URIError)).toEqual(false);
expect(aid.isError(new EvalError('error'), Error)).toEqual(false);
expect(aid.isError(new EvalError('error'), EvalError)).toEqual(true);
expect(aid.isError(new EvalError('error'), RangeError)).toEqual(false);
expect(aid.isError(new EvalError('error'), ReferenceError)).toEqual(false);
expect(aid.isError(new EvalError('error'), SyntaxError)).toEqual(false);
expect(aid.isError(new EvalError('error'), TypeError)).toEqual(false);
expect(aid.isError(new EvalError('error'), URIError)).toEqual(false);
expect(aid.isError(new RangeError('error'), Error)).toEqual(false);
expect(aid.isError(new RangeError('error'), EvalError)).toEqual(false);
expect(aid.isError(new RangeError('error'), RangeError)).toEqual(true);
expect(aid.isError(new RangeError('error'), ReferenceError)).toEqual(false);
expect(aid.isError(new RangeError('error'), SyntaxError)).toEqual(false);
expect(aid.isError(new RangeError('error'), TypeError)).toEqual(false);
expect(aid.isError(new RangeError('error'), URIError)).toEqual(false);
expect(aid.isError(new ReferenceError('error'), Error)).toEqual(false);
expect(aid.isError(new ReferenceError('error'), EvalError)).toEqual(false);
expect(aid.isError(new ReferenceError('error'), RangeError)).toEqual(false);
expect(aid.isError(new ReferenceError('error'), ReferenceError)).toEqual(true);
expect(aid.isError(new ReferenceError('error'), SyntaxError)).toEqual(false);
expect(aid.isError(new ReferenceError('error'), TypeError)).toEqual(false);
expect(aid.isError(new ReferenceError('error'), URIError)).toEqual(false);
expect(aid.isError(new SyntaxError('error'), Error)).toEqual(false);
expect(aid.isError(new SyntaxError('error'), EvalError)).toEqual(false);
expect(aid.isError(new SyntaxError('error'), RangeError)).toEqual(false);
expect(aid.isError(new SyntaxError('error'), ReferenceError)).toEqual(false);
expect(aid.isError(new SyntaxError('error'), SyntaxError)).toEqual(true);
expect(aid.isError(new SyntaxError('error'), TypeError)).toEqual(false);
expect(aid.isError(new SyntaxError('error'), URIError)).toEqual(false);
expect(aid.isError(new TypeError('error'), Error)).toEqual(false);
expect(aid.isError(new TypeError('error'), EvalError)).toEqual(false);
expect(aid.isError(new TypeError('error'), RangeError)).toEqual(false);
expect(aid.isError(new TypeError('error'), ReferenceError)).toEqual(false);
expect(aid.isError(new TypeError('error'), SyntaxError)).toEqual(false);
expect(aid.isError(new TypeError('error'), TypeError)).toEqual(true);
expect(aid.isError(new TypeError('error'), URIError)).toEqual(false);
expect(aid.isError(new URIError('error'), Error)).toEqual(false);
expect(aid.isError(new URIError('error'), EvalError)).toEqual(false);
expect(aid.isError(new URIError('error'), RangeError)).toEqual(false);
expect(aid.isError(new URIError('error'), ReferenceError)).toEqual(false);
expect(aid.isError(new URIError('error'), SyntaxError)).toEqual(false);
expect(aid.isError(new URIError('error'), TypeError)).toEqual(false);
expect(aid.isError(new URIError('error'), URIError)).toEqual(true);
});
});
describe('.isElement()', function() {
it('input undefined, return false', function() {
expect(aid.isElement(undefined)).toEqual(false);
});
it('input "undefined", return false', function() {
expect(aid.isElement('undefined')).toEqual(false);
});
it('input null, return false', function() {
expect(aid.isElement(null)).toEqual(false);
});
it('input false, return false', function() {
expect(aid.isElement(false)).toEqual(false);
});
it('input true, return false', function() {
expect(aid.isElement(true)).toEqual(false);
});
it('input 0, return false', function() {
expect(aid.isElement(0)).toEqual(false);
});
it('input "", return false', function() {
expect(aid.isElement('')).toEqual(false);
});
it('input {}, return false', function() {
expect(aid.isElement({})).toEqual(false);
});
it('input [], return false', function() {
expect(aid.isElement([])).toEqual(false);
});
it('input function(){}, return false', function() {
expect(aid.isElement(function() {})).toEqual(false);
});
it('input RegExp object, return false', function() {
expect(aid.isElement(new RegExp('^aid'))).toEqual(false);
});
it('input RegExp literal, return false', function() {
expect(aid.isElement(/^aid/)).toEqual(false);
});
it('input Error, return true', function() {
expect(aid.isElement(new Error('error'))).toEqual(false);
expect(aid.isElement(new EvalError('error'))).toEqual(false);
expect(aid.isElement(new RangeError('error'))).toEqual(false);
expect(aid.isElement(new ReferenceError('error'))).toEqual(false);
expect(aid.isElement(new SyntaxError('error'))).toEqual(false);
expect(aid.isElement(new TypeError('error'))).toEqual(false);
expect(aid.isElement(new URIError('error'))).toEqual(false);
});
it('input HTML Element, return true', function() {
expect(aid.isElement(document.createElement('div'))).toEqual(true);
expect(aid.isElement(document.createElement('p'))).toEqual(true);
});
});
describe('.extend()', function() {
var ERROR_MSG = '[aid.extend] Type of destination parameter must be instance of Object, and object.';
it('whether destination parameter type is not object or instance of object, throw Error', function() {
expect(function() {
aid.extend(undefined, { say: 'hello, world' });
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.extend(null, { say: 'hello, world' });
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.extend(false, { say: 'hello, world' });
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.extend(true, { say: 'hello, world' });
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.extend(0, { say: 'hello, world' });
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.extend('', { say: 'hello, world' });
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.extend(NaN, { say: 'hello, world' });
}).toThrowError(TypeError, ERROR_MSG);
});
it('if source parameter type is not object type, throw Error', function() {
var ERROR_MSG = '[aid.extend] Type of source parameter must be Object.';
expect(function() {
aid.extend({}, undefined);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.extend({}, null);
}).not.toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.extend({}, false);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.extend({}, true);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.extend({}, 0);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.extend({}, '');
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.extend({}, NaN);
}).toThrowError(TypeError, ERROR_MSG);
});
it('input two objects, return extended object', function() {
var destination = {
name: 'destination',
type: 'json',
},
source = {
name: 'source',
say: 'hello, world',
sayHello: function() {
return 'hello';
},
};
aid.extend(destination, source);
expect(destination.name).toEqual('source');
expect(destination.type).toEqual('json');
expect(destination.say).toEqual('hello, world');
expect(destination.sayHello).toBeDefined();
});
it('input prototype of class function, object has methods. return extended class function', function() {
function Destination() {
this.name = 'destination';
this.type = 'json';
}
var source = {
getName: function() {
return this.name;
},
getType: function() {
return this.type;
},
};
aid.extend(Destination.prototype, source);
var destination = new Destination();
expect(destination.name).toEqual('destination');
expect(destination.hasOwnProperty('name')).toBeTruthy();
expect(destination.type).toEqual('json');
expect(destination.hasOwnProperty('type')).toBeTruthy();
expect(destination.getName).toBeDefined();
expect(destination.hasOwnProperty('getName')).toBeFalsy();
expect(destination.getType).toBeDefined();
expect(destination.hasOwnProperty('getType')).toBeFalsy();
});
});
describe('.inherit()', function() {
var Parent = function() {
this.name = 'daddy';
};
Parent.prototype.getName = function() {
return this.name;
};
var Child = function() {
this.name = 'son';
};
aid.inherit(Child, Parent);
var child = new Child();
it('child has getName() method', function() {
expect(typeof child.getName).toEqual('function');
});
it('child.getName() is "son"', function() {
expect(child.getName()).toEqual('son');
});
it('child.hasOwnProperty("name") is true', function() {
expect(child.hasOwnProperty('name')).toEqual(true);
});
});
describe('.namespace()', function() {
it('if namespace parameter type is not string, throw Error', function() {
var ERROR_MSG = '[aid.namespace] Type of namespace parameter must be String.';
expect(function() {
aid.namespace(undefined);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.namespace(null);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.namespace(false);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.namespace(true);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.namespace(0);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.namespace([]);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.namespace(NaN);
}).toThrowError(TypeError, ERROR_MSG);
});
it('if parent parameter type is not object or null or undefined, throw Error', function() {
var ERROR_MSG = '[aid.namespace] Type of parent parameter must be Object or null or undefined.';
expect(function() {
var obj = {};
aid.namespace('first.second', obj);
}).not.toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.namespace('first.second', undefined);
}).not.toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.namespace('first.second', null);
}).not.toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.namespace('first.second', false);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.namespace('first.second', true);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.namespace('first.second', 0);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.namespace('first.second', []);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.namespace('first.second', NaN);
}).toThrowError(TypeError, ERROR_MSG);
});
it('input aid.second.third string, set aid.second.third object', function() {
aid.namespace('aid.second.third');
expect(aid.second.third).toBeDefined();
});
it('input first.second string, set first.second object', function() {
aid.namespace('first.second');
expect(first).toBeDefined();
expect(first.second).toBeDefined();
});
it('input first.second.third.fourth string, set first.second.third.fourth object', function() {
aid.namespace('first.second.third.fourth');
expect(first.second.third.fourth).toBeDefined();
});
it('input first.second.third.fourth string, set first.second.third.fourth object', function() {
var p = {};
aid.namespace('first.second.third', p);
expect(p.first.second.third).toBeDefined();
});
});
describe('.memoize()', function() {
it('if func parameter type is not function, throw Error', function() {
var ERROR_MSG = '[aid.memoize] Type of func parameter must be Function.';
expect(function() {
aid.memoize(undefined);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.memoize(null);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.memoize(false);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.memoize(true);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.memoize(0);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.memoize('aid');
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.memoize([]);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.memoize(NaN);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.memoize(/aid.js/);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.memoize(function() {});
}).not.toThrowError(TypeError, ERROR_MSG);
});
it('if hasher parameter is defined but type is not function, throw Error', function() {
var ERROR_MSG = '[aid.memoize] Type of hasher parameter must be undefined or null or Function.';
expect(function() {
aid.memoize(function() {}, false);
}).toThrowError(Error, ERROR_MSG);
expect(function() {
aid.memoize(function() {}, true);
}).toThrowError(Error, ERROR_MSG);
expect(function() {
aid.memoize(function() {}, 0);
}).toThrowError(Error, ERROR_MSG);
expect(function() {
aid.memoize(function() {}, NaN);
}).toThrowError(Error, ERROR_MSG);
expect(function() {
aid.memoize(function() {}, '');
}).toThrowError(Error, ERROR_MSG);
expect(function() {
aid.memoize(function() {}, {});
}).toThrowError(Error, ERROR_MSG);
expect(function() {
aid.memoize(function() {}, []);
}).toThrowError(Error, ERROR_MSG);
expect(function() {
aid.memoize(function() {}, /aid.js/);
}).toThrowError(Error, ERROR_MSG);
expect(function() {
aid.memoize(function() {}, function() {});
}).not.toThrowError(Error, ERROR_MSG);
});
it('return memoized value, after memoize a function', function() {
var obj = {
plus: function(a, b) {
return a + b;
},
};
expect(obj.plus('google', '.js')).toBe('google.js');
var memoized = aid.memoize(obj.plus);
var cache = memoized.cache;
expect(cache.get('google')).toBe(undefined);
expect(memoized('google', '.js')).toBe('google.js');
expect(cache.has('google')).toBe(true);
expect(cache.get('google')).toBe('google.js');
obj.plus = memoized;
expect(obj.plus('google', '.js')).toBe('google.js');
});
it('return memoized value when use a hasher function', function() {
var obj = {
plus: function(a, b) {
return a + b;
},
};
var memoized = aid.memoize(obj.plus, function(a, b) {
return a + '_foo_' + b;
});
var cache = memoized.cache;
expect(cache.get('google_foo_.js')).toBe(undefined);
expect(memoized('google', '.js')).toBe('google.js');
expect(cache.has('google_foo_.js')).toBe(true);
expect(cache.get('google_foo_.js')).toBe('google.js');
obj.plus = memoized;
expect(obj.plus('google', '.js')).toBe('google.js');
});
});
describe('.borrow()', function() {
var borrower = {},
donor = {
say: function() {
return 'hello, world';
},
};
beforeEach(function() {
borrower = {};
});
it('if borrower parameter is not Object type, throw TypeError', function() {
var ERROR_MSG = '[aid.borrow] Type of borrower, donor parameters must be Object.';
expect(function() {
aid.borrow(undefined, donor, 'say');
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.borrow(null, donor, 'say');
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.borrow(false, donor, 'say');
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.borrow(true, donor, 'say');
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.borrow('', donor, 'say');
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.borrow(0, donor, 'say');
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.borrow(NaN, donor, 'say');
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.borrow([], donor, 'say');
}).toThrowError(TypeError, ERROR_MSG);
});
it('if donor parameter is not Object type, throw TypeError', function() {
var ERROR_MSG = '[aid.borrow] Type of borrower, donor parameters must be Object.';
expect(function() {
aid.borrow(borrower, undefined, 'say');
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.borrow(borrower, null, 'say');
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.borrow(borrower, false, 'say');
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.borrow(borrower, true, 'say');
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.borrow(borrower, '', 'say');
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.borrow(borrower, 0, 'say');
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.borrow(borrower, NaN, 'say');
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.borrow(borrower, [], 'say');
}).toThrowError(TypeError, ERROR_MSG);
});
it('if funcName parameter is not String type, throw TypeError', function() {
var ERROR_MSG = '[aid.borrow] Type of funcName parameter must be String.';
expect(function() {
aid.borrow(borrower, donor, undefined);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.borrow(borrower, donor, null);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.borrow(borrower, donor, false);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.borrow(borrower, donor, true);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.borrow(borrower, donor, 0);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.borrow(borrower, donor, NaN);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.borrow(borrower, donor, {});
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.borrow(borrower, donor, []);
}).toThrowError(TypeError, ERROR_MSG);
});
it('if donor has not function with funcName, throw Error', function() {
var ERROR_MSG = '[aid.borrow] donor object parameter has not function with funcName parameter.';
expect(function() {
aid.borrow(borrower, donor, 'hello');
}).toThrowError(Error, ERROR_MSG);
});
it('if borrower already has function with funcName, throw Error', function() {
var ERROR_MSG = '[aid.borrow] borrower object parameter already has function with funcName parameter.';
borrower = {
say: function() {
return "this method is borrower's";
},
};
expect(function() {
aid.borrow(borrower, donor, 'say');
}).toThrowError(Error, ERROR_MSG);
borrower = {};
expect(function() {
aid.borrow(borrower, donor, 'say');
}).not.toThrowError(Error, ERROR_MSG);
});
it('after input borrower, donor, "say" parameters, borrower has say method', function() {
expect(borrower.say).not.toBeDefined();
aid.borrow(borrower, donor, 'say');
expect(borrower.say).toBeDefined();
expect(borrower.say()).toEqual('hello, world');
});
});
describe('.bind()', function() {
it('if func parameter is not Function type, throw TypeError', function() {
var ERROR_MSG = '[aid.bind] Type of func parameter must be Function.';
expect(function() {
aid.bind(undefined);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.bind(null);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.bind(false);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.bind(true);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.bind(0);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.bind(NaN);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.bind('');
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.bind({});
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.bind([]);
}).toThrowError(TypeError, ERROR_MSG);
expect(function() {
aid.bind(/^aid/);
}).toThrowError(TypeError, ERROR_MSG);
});
it('return value type is function', function() {
var obj = {
title: 'obj - aid.js',
getTitle: function() {
return this.title;
},
};
var getObjTitle = aid.bind(obj.getTitle, obj);
expect(aid.isFunction(getObjTitle)).toBeTruthy();
});
});
describe('.compose()', function() {
it('if func_a parameter type is not function, throw Error', function() {
expect(function() {
aid.compose(
undefined,
function() {}
);
}).toThrowError();
expect(function() {
aid.compose(
null,
function() {}
);
}).toThrowError();
expect(function() {
aid.compose(
false,
function() {}
);
}).toThrowError();
expect(function() {
aid.compose(
true,
function() {}
);
}).toThrowError();
expect(function() {
aid.compose(
0,
function() {}
);
}).toThrowError();
expect(function() {
aid.compose(
NaN,
function() {}
);
}).toThrowError();
expect(function() {
aid.compose(
'',
function() {}
);
}).toThrowError();
expect(function() {
aid.compose(
[],
function() {}
);
}).toThrowError();
expect(function() {
aid.compose(
{},
function() {}
);
}).toThrowError();
});
it('if func_b parameter type is not function, throw Error', function() {
expect(function() {
aid.compose(
function() {},
undefined
);
}).toThrowError();
expect(function() {
aid.compose(
function() {},
null
);
}).toThrowError();
expect(function() {
aid.compose(
function() {},
false
);
}).toThrowError();
expect(function() {
aid.compose(
function() {},
true
);
}).toThrowError();
expect(function() {
aid.compose(
function() {},
0
);
}).toThrowError();
expect(function() {
aid.compose(
function() {},
NaN
);
}).toThrowError();
expect(function() {
aid.compose(
function() {},
''
);
}).toThrowError();
expect(function() {
aid.compose(
function() {},
[]
);
}).toThrowError();
expect(function() {
aid.compose(
function() {},
{}
);
}).toThrowError();
});
it('return value type is function', function() {
var isNotNaN = aid.compose(
function(object) {
return !object;
},
isNaN
);
var isFunction = aid.isFunction(isNotNaN);
expect(isFunction).toBeTruthy();
});
});
describe('.not()', function() {
it('if func parameter type is not function, throw Error', function() {
expect(function() {
aid.not(undefined);
}).toThrowError();
expect(function() {
aid.not(null);
}).toThrowError();
expect(function() {
aid.not(false);
}).toThrowError();
expect(function() {
aid.not(true);
}).toThrowError();
expect(function() {
aid.not(0);
}).toThrowError();
expect(function() {
aid.not('');
}).toThrowError();
expect(function() {
aid.not(NaN);
}).toThrowError();
});
it('func parameter type is function, does not throw Error', function() {
expect(function() {
aid.not(function() {
return true;
});
}).not.toThrowError();
});
describe('negate aid.existy', function() {
var notExisty = aid.not(aid.existy);
it('return function', function() {
expect(aid.isFunction(notExisty)).toEqual(true);
});
it('input undefined to aid.not(aid.existy), return true', function() {
expect(notExisty(undefined)).toEqual(true);
});
it('input "undefined" to aid.not(aid.existy), return false', function() {
expect(notExisty('undefined')).toEqual(false);
});
it('input null to aid.not(aid.existy), return true', function() {
expect(notExisty(null)).toEqual(true);
});
it('input false to aid.not(aid.existy), return false', function() {
expect(notExisty(false)).toEqual(false);
});
it('input true to aid.not(aid.existy), return false', function() {
expect(notExisty(true)).toEqual(false);
});
it('input 0 to aid.not(aid.existy), return false', function() {
expect(notExisty(0)).toEqual(false);
});
it('input "" to aid.not(aid.existy), return false', function() {
expect(notExisty('')).toEqual(false);
});
it('input {} to aid.not(aid.existy), return false', function() {
expect(notExisty({})).toEqual(false);
});
});
describe('negate isNaN', function() {
var isNotNaN = aid.not(isNaN);
it('input undefined to aid.not(isNaN), return false', function() {
expect(isNotNaN(undefined)).toEqual(false);
});
it('input 0 to aid.not(isNaN), return true', function() {
expect(isNotNaN(0)).toEqual(true);
});
});
});
describe('.each()', function() {
it('whether dataCanLoop parameter is not string or array, throw TypeError', function() {
expect(function() {
aid.each(undefined, function() {}, null);
}).toThrowError(Error);
expect(function() {
aid.each(null, function() {}, null);
}).toThrowError(Error);
expect(function() {
aid.each(false, function() {}, null);
}).toThrowError(Error);
expect(function() {
aid.each(true, function() {}, null);
}).toThrowError(Error);
expect(function() {
aid.each('', function() {}, null);
}).not.toThrowError(Error);
expect(function() {
aid.each(0, function() {}, null);
}).toThrowError(Error);
expect(function() {
aid.each(NaN, function() {}, null);
}).toThrowError(Error);
expect(function() {
aid.each([], function() {}, null);
}).not.toThrowError(Error);
});
it('input string, apply functions based on characters', function() {
var result = [];
aid.each(
'aid.js',
function(v) {
result.push(v);
},
null
);
expect(result.join('')).toEqual('aid.js');
});
it('input array, apply functions based on elements', function() {
var result = [];
aid.each(
[1, 2, 3, 4, 5],
function(v) {
result.push(v);
},
null
);
expect(result.join('')).toEqual('12345');
});
});
describe('.truthy()', function() {
var isBoolRegex = /true|false/;
it('input undefined, return booblean', function() {
expect(aid.truthy(undefined)).toMatch(isBoolRegex);
});
it('input "undefined", return booblean', function() {
expect(aid.truthy('undefined')).toMatch(isBoolRegex);
});
it('input null, return booblean', function() {
expect(aid.truthy(null)).toMatch(isBoolRegex);
});
it('input false, return booblean', function() {
expect(aid.truthy(false)).toMatch(isBoolRegex);
});
it('input true, return booblean', function() {
expect(aid.truthy(true)).toMatch(isBoolRegex);
});
it('input 0, return booblean', function() {
expect(aid.truthy(0)).toMatch(isBoolRegex);
});
it('input "", return booblean', function() {
expect(aid.truthy('')).toMatch(isBoolRegex);
});
it('input [], return booblean', function() {
expect(aid.truthy([])).toMatch(isBoolRegex);
});
it('input function, return booblean', function() {
expect(aid.truthy(function() {})).toMatch(isBoolRegex);
});
it('input {}, return booblean', function() {
expect(aid.truthy({})).toMatch(isBoolRegex);
});
});
describe('.falsy()', function() {
var isBoolRegex = /true|false/;
it('input undefined, return booblean', function() {
expect(aid.falsy(undefined)).toMatch(isBoolRegex);
});
it('input "undefined", return booblean', function() {
expect(aid.falsy('undefined')).toMatch(isBoolRegex);
});
it('input null, return booblean', function() {
expect(aid.falsy(null)).toMatch(isBoolRegex);
});
it('input false, return booblean', function() {
expect(aid.falsy(false)).toMatch(isBoolRegex);
});
it('input true, return booblean', function() {
expect(aid.falsy(true)).toMatch(isBoolRegex);
});
it('input 0, return booblean', function() {
expect(aid.falsy(0)).toMatch(isBoolRegex);
});
it('input "", return booblean', function() {
expect(aid.falsy('')).toMatch(isBoolRegex);
});
it('input [], return booblean', function() {
expect(aid.falsy([])).toMatch(isBoolRegex);
});
it('input function, return booblean', function() {
expect(aid.falsy(function() {})).toMatch(isBoolRegex);
});
it('input {}, return booblean', function() {
expect(aid.falsy({})).toMatch(isBoolRegex);
});
});
describe('.nth()', function() {
it('whether dataCanLoop parameter type is not string or array, throw TypeError', function() {
expect(function() {
aid.nth(undefined, 0);
}).toThrowError();
expect(function() {
aid.nth(null, 0);
}).toThrowError();
expect(function() {
aid.nth(false, 0);
}).toThrowError();
expect(function() {