",
7 | "repository" : {"type": "git", "url": "git://github.com/documentcloud/underscore.git"},
8 | "main" : "underscore.js",
9 | "version" : "1.4.3"
10 | }
11 |
--------------------------------------------------------------------------------
/components/underscore/test/arrays.js:
--------------------------------------------------------------------------------
1 | $(document).ready(function() {
2 |
3 | module("Arrays");
4 |
5 | test("first", function() {
6 | equal(_.first([1,2,3]), 1, 'can pull out the first element of an array');
7 | equal(_([1, 2, 3]).first(), 1, 'can perform OO-style "first()"');
8 | equal(_.first([1,2,3], 0).join(', '), "", 'can pass an index to first');
9 | equal(_.first([1,2,3], 2).join(', '), '1, 2', 'can pass an index to first');
10 | equal(_.first([1,2,3], 5).join(', '), '1, 2, 3', 'can pass an index to first');
11 | var result = (function(){ return _.first(arguments); })(4, 3, 2, 1);
12 | equal(result, 4, 'works on an arguments object.');
13 | result = _.map([[1,2,3],[1,2,3]], _.first);
14 | equal(result.join(','), '1,1', 'works well with _.map');
15 | result = (function() { return _.take([1,2,3], 2); })();
16 | equal(result.join(','), '1,2', 'aliased as take');
17 |
18 | equal(_.first(null), undefined, 'handles nulls');
19 | });
20 |
21 | test("rest", function() {
22 | var numbers = [1, 2, 3, 4];
23 | equal(_.rest(numbers).join(", "), "2, 3, 4", 'working rest()');
24 | equal(_.rest(numbers, 0).join(", "), "1, 2, 3, 4", 'working rest(0)');
25 | equal(_.rest(numbers, 2).join(', '), '3, 4', 'rest can take an index');
26 | var result = (function(){ return _(arguments).tail(); })(1, 2, 3, 4);
27 | equal(result.join(', '), '2, 3, 4', 'aliased as tail and works on arguments object');
28 | result = _.map([[1,2,3],[1,2,3]], _.rest);
29 | equal(_.flatten(result).join(','), '2,3,2,3', 'works well with _.map');
30 | result = (function(){ return _(arguments).drop(); })(1, 2, 3, 4);
31 | equal(result.join(', '), '2, 3, 4', 'aliased as drop and works on arguments object');
32 | });
33 |
34 | test("initial", function() {
35 | equal(_.initial([1,2,3,4,5]).join(", "), "1, 2, 3, 4", 'working initial()');
36 | equal(_.initial([1,2,3,4],2).join(", "), "1, 2", 'initial can take an index');
37 | var result = (function(){ return _(arguments).initial(); })(1, 2, 3, 4);
38 | equal(result.join(", "), "1, 2, 3", 'initial works on arguments object');
39 | result = _.map([[1,2,3],[1,2,3]], _.initial);
40 | equal(_.flatten(result).join(','), '1,2,1,2', 'initial works with _.map');
41 | });
42 |
43 | test("last", function() {
44 | equal(_.last([1,2,3]), 3, 'can pull out the last element of an array');
45 | equal(_.last([1,2,3], 0).join(', '), "", 'can pass an index to last');
46 | equal(_.last([1,2,3], 2).join(', '), '2, 3', 'can pass an index to last');
47 | equal(_.last([1,2,3], 5).join(', '), '1, 2, 3', 'can pass an index to last');
48 | var result = (function(){ return _(arguments).last(); })(1, 2, 3, 4);
49 | equal(result, 4, 'works on an arguments object');
50 | result = _.map([[1,2,3],[1,2,3]], _.last);
51 | equal(result.join(','), '3,3', 'works well with _.map');
52 |
53 | equal(_.last(null), undefined, 'handles nulls');
54 | });
55 |
56 | test("compact", function() {
57 | equal(_.compact([0, 1, false, 2, false, 3]).length, 3, 'can trim out all falsy values');
58 | var result = (function(){ return _.compact(arguments).length; })(0, 1, false, 2, false, 3);
59 | equal(result, 3, 'works on an arguments object');
60 | });
61 |
62 | test("flatten", function() {
63 | var list = [1, [2], [3, [[[4]]]]];
64 | deepEqual(_.flatten(list), [1,2,3,4], 'can flatten nested arrays');
65 | deepEqual(_.flatten(list, true), [1,2,3,[[[4]]]], 'can shallowly flatten nested arrays');
66 | var result = (function(){ return _.flatten(arguments); })(1, [2], [3, [[[4]]]]);
67 | deepEqual(result, [1,2,3,4], 'works on an arguments object');
68 | });
69 |
70 | test("without", function() {
71 | var list = [1, 2, 1, 0, 3, 1, 4];
72 | equal(_.without(list, 0, 1).join(', '), '2, 3, 4', 'can remove all instances of an object');
73 | var result = (function(){ return _.without(arguments, 0, 1); })(1, 2, 1, 0, 3, 1, 4);
74 | equal(result.join(', '), '2, 3, 4', 'works on an arguments object');
75 |
76 | var list = [{one : 1}, {two : 2}];
77 | ok(_.without(list, {one : 1}).length == 2, 'uses real object identity for comparisons.');
78 | ok(_.without(list, list[0]).length == 1, 'ditto.');
79 | });
80 |
81 | test("uniq", function() {
82 | var list = [1, 2, 1, 3, 1, 4];
83 | equal(_.uniq(list).join(', '), '1, 2, 3, 4', 'can find the unique values of an unsorted array');
84 |
85 | var list = [1, 1, 1, 2, 2, 3];
86 | equal(_.uniq(list, true).join(', '), '1, 2, 3', 'can find the unique values of a sorted array faster');
87 |
88 | var list = [{name:'moe'}, {name:'curly'}, {name:'larry'}, {name:'curly'}];
89 | var iterator = function(value) { return value.name; };
90 | equal(_.map(_.uniq(list, false, iterator), iterator).join(', '), 'moe, curly, larry', 'can find the unique values of an array using a custom iterator');
91 |
92 | equal(_.map(_.uniq(list, iterator), iterator).join(', '), 'moe, curly, larry', 'can find the unique values of an array using a custom iterator without specifying whether array is sorted');
93 |
94 | var iterator = function(value) { return value +1; };
95 | var list = [1, 2, 2, 3, 4, 4];
96 | equal(_.uniq(list, true, iterator).join(', '), '1, 2, 3, 4', 'iterator works with sorted array');
97 |
98 | var result = (function(){ return _.uniq(arguments); })(1, 2, 1, 3, 1, 4);
99 | equal(result.join(', '), '1, 2, 3, 4', 'works on an arguments object');
100 | });
101 |
102 | test("intersection", function() {
103 | var stooges = ['moe', 'curly', 'larry'], leaders = ['moe', 'groucho'];
104 | equal(_.intersection(stooges, leaders).join(''), 'moe', 'can take the set intersection of two arrays');
105 | equal(_(stooges).intersection(leaders).join(''), 'moe', 'can perform an OO-style intersection');
106 | var result = (function(){ return _.intersection(arguments, leaders); })('moe', 'curly', 'larry');
107 | equal(result.join(''), 'moe', 'works on an arguments object');
108 | });
109 |
110 | test("union", function() {
111 | var result = _.union([1, 2, 3], [2, 30, 1], [1, 40]);
112 | equal(result.join(' '), '1 2 3 30 40', 'takes the union of a list of arrays');
113 |
114 | var result = _.union([1, 2, 3], [2, 30, 1], [1, 40, [1]]);
115 | equal(result.join(' '), '1 2 3 30 40 1', 'takes the union of a list of nested arrays');
116 | });
117 |
118 | test("difference", function() {
119 | var result = _.difference([1, 2, 3], [2, 30, 40]);
120 | equal(result.join(' '), '1 3', 'takes the difference of two arrays');
121 |
122 | var result = _.difference([1, 2, 3, 4], [2, 30, 40], [1, 11, 111]);
123 | equal(result.join(' '), '3 4', 'takes the difference of three arrays');
124 | });
125 |
126 | test('zip', function() {
127 | var names = ['moe', 'larry', 'curly'], ages = [30, 40, 50], leaders = [true];
128 | var stooges = _.zip(names, ages, leaders);
129 | equal(String(stooges), 'moe,30,true,larry,40,,curly,50,', 'zipped together arrays of different lengths');
130 | });
131 |
132 | test('object', function() {
133 | var result = _.object(['moe', 'larry', 'curly'], [30, 40, 50]);
134 | var shouldBe = {moe: 30, larry: 40, curly: 50};
135 | ok(_.isEqual(result, shouldBe), 'two arrays zipped together into an object');
136 |
137 | result = _.object([['one', 1], ['two', 2], ['three', 3]]);
138 | shouldBe = {one: 1, two: 2, three: 3};
139 | ok(_.isEqual(result, shouldBe), 'an array of pairs zipped together into an object');
140 |
141 | var stooges = {moe: 30, larry: 40, curly: 50};
142 | ok(_.isEqual(_.object(_.pairs(stooges)), stooges), 'an object converted to pairs and back to an object');
143 |
144 | ok(_.isEqual(_.object(null), {}), 'handles nulls');
145 | });
146 |
147 | test("indexOf", function() {
148 | var numbers = [1, 2, 3];
149 | numbers.indexOf = null;
150 | equal(_.indexOf(numbers, 2), 1, 'can compute indexOf, even without the native function');
151 | var result = (function(){ return _.indexOf(arguments, 2); })(1, 2, 3);
152 | equal(result, 1, 'works on an arguments object');
153 | equal(_.indexOf(null, 2), -1, 'handles nulls properly');
154 |
155 | var numbers = [10, 20, 30, 40, 50], num = 35;
156 | var index = _.indexOf(numbers, num, true);
157 | equal(index, -1, '35 is not in the list');
158 |
159 | numbers = [10, 20, 30, 40, 50]; num = 40;
160 | index = _.indexOf(numbers, num, true);
161 | equal(index, 3, '40 is in the list');
162 |
163 | numbers = [1, 40, 40, 40, 40, 40, 40, 40, 50, 60, 70]; num = 40;
164 | index = _.indexOf(numbers, num, true);
165 | equal(index, 1, '40 is in the list');
166 |
167 | numbers = [1, 2, 3, 1, 2, 3, 1, 2, 3];
168 | index = _.indexOf(numbers, 2, 5);
169 | equal(index, 7, 'supports the fromIndex argument');
170 | });
171 |
172 | test("lastIndexOf", function() {
173 | var numbers = [1, 0, 1];
174 | equal(_.lastIndexOf(numbers, 1), 2);
175 |
176 | numbers = [1, 0, 1, 0, 0, 1, 0, 0, 0];
177 | numbers.lastIndexOf = null;
178 | equal(_.lastIndexOf(numbers, 1), 5, 'can compute lastIndexOf, even without the native function');
179 | equal(_.lastIndexOf(numbers, 0), 8, 'lastIndexOf the other element');
180 | var result = (function(){ return _.lastIndexOf(arguments, 1); })(1, 0, 1, 0, 0, 1, 0, 0, 0);
181 | equal(result, 5, 'works on an arguments object');
182 | equal(_.indexOf(null, 2), -1, 'handles nulls properly');
183 |
184 | numbers = [1, 2, 3, 1, 2, 3, 1, 2, 3];
185 | index = _.lastIndexOf(numbers, 2, 2);
186 | equal(index, 1, 'supports the fromIndex argument');
187 | });
188 |
189 | test("range", function() {
190 | equal(_.range(0).join(''), '', 'range with 0 as a first argument generates an empty array');
191 | equal(_.range(4).join(' '), '0 1 2 3', 'range with a single positive argument generates an array of elements 0,1,2,...,n-1');
192 | equal(_.range(5, 8).join(' '), '5 6 7', 'range with two arguments a & b, a<b generates an array of elements a,a+1,a+2,...,b-2,b-1');
193 | equal(_.range(8, 5).join(''), '', 'range with two arguments a & b, b<a generates an empty array');
194 | equal(_.range(3, 10, 3).join(' '), '3 6 9', 'range with three arguments a & b & c, c < b-a, a < b generates an array of elements a,a+c,a+2c,...,b - (multiplier of a) < c');
195 | equal(_.range(3, 10, 15).join(''), '3', 'range with three arguments a & b & c, c > b-a, a < b generates an array with a single element, equal to a');
196 | equal(_.range(12, 7, -2).join(' '), '12 10 8', 'range with three arguments a & b & c, a > b, c < 0 generates an array of elements a,a-c,a-2c and ends with the number not less than b');
197 | equal(_.range(0, -10, -1).join(' '), '0 -1 -2 -3 -4 -5 -6 -7 -8 -9', 'final example in the Python docs');
198 | });
199 |
200 | });
201 |
--------------------------------------------------------------------------------
/components/underscore/test/chaining.js:
--------------------------------------------------------------------------------
1 | $(document).ready(function() {
2 |
3 | module("Chaining");
4 |
5 | test("map/flatten/reduce", function() {
6 | var lyrics = [
7 | "I'm a lumberjack and I'm okay",
8 | "I sleep all night and I work all day",
9 | "He's a lumberjack and he's okay",
10 | "He sleeps all night and he works all day"
11 | ];
12 | var counts = _(lyrics).chain()
13 | .map(function(line) { return line.split(''); })
14 | .flatten()
15 | .reduce(function(hash, l) {
16 | hash[l] = hash[l] || 0;
17 | hash[l]++;
18 | return hash;
19 | }, {}).value();
20 | ok(counts['a'] == 16 && counts['e'] == 10, 'counted all the letters in the song');
21 | });
22 |
23 | test("select/reject/sortBy", function() {
24 | var numbers = [1,2,3,4,5,6,7,8,9,10];
25 | numbers = _(numbers).chain().select(function(n) {
26 | return n % 2 == 0;
27 | }).reject(function(n) {
28 | return n % 4 == 0;
29 | }).sortBy(function(n) {
30 | return -n;
31 | }).value();
32 | equal(numbers.join(', '), "10, 6, 2", "filtered and reversed the numbers");
33 | });
34 |
35 | test("select/reject/sortBy in functional style", function() {
36 | var numbers = [1,2,3,4,5,6,7,8,9,10];
37 | numbers = _.chain(numbers).select(function(n) {
38 | return n % 2 == 0;
39 | }).reject(function(n) {
40 | return n % 4 == 0;
41 | }).sortBy(function(n) {
42 | return -n;
43 | }).value();
44 | equal(numbers.join(', '), "10, 6, 2", "filtered and reversed the numbers");
45 | });
46 |
47 | test("reverse/concat/unshift/pop/map", function() {
48 | var numbers = [1,2,3,4,5];
49 | numbers = _(numbers).chain()
50 | .reverse()
51 | .concat([5, 5, 5])
52 | .unshift(17)
53 | .pop()
54 | .map(function(n){ return n * 2; })
55 | .value();
56 | equal(numbers.join(', '), "34, 10, 8, 6, 4, 2, 10, 10", 'can chain together array functions.');
57 | });
58 |
59 | });
60 |
--------------------------------------------------------------------------------
/components/underscore/test/collections.js:
--------------------------------------------------------------------------------
1 | $(document).ready(function() {
2 |
3 | module("Collections");
4 |
5 | test("each", function() {
6 | _.each([1, 2, 3], function(num, i) {
7 | equal(num, i + 1, 'each iterators provide value and iteration count');
8 | });
9 |
10 | var answers = [];
11 | _.each([1, 2, 3], function(num){ answers.push(num * this.multiplier);}, {multiplier : 5});
12 | equal(answers.join(', '), '5, 10, 15', 'context object property accessed');
13 |
14 | answers = [];
15 | _.forEach([1, 2, 3], function(num){ answers.push(num); });
16 | equal(answers.join(', '), '1, 2, 3', 'aliased as "forEach"');
17 |
18 | answers = [];
19 | var obj = {one : 1, two : 2, three : 3};
20 | obj.constructor.prototype.four = 4;
21 | _.each(obj, function(value, key){ answers.push(key); });
22 | equal(answers.join(", "), 'one, two, three', 'iterating over objects works, and ignores the object prototype.');
23 | delete obj.constructor.prototype.four;
24 |
25 | answer = null;
26 | _.each([1, 2, 3], function(num, index, arr){ if (_.include(arr, num)) answer = true; });
27 | ok(answer, 'can reference the original collection from inside the iterator');
28 |
29 | answers = 0;
30 | _.each(null, function(){ ++answers; });
31 | equal(answers, 0, 'handles a null properly');
32 | });
33 |
34 | test('map', function() {
35 | var doubled = _.map([1, 2, 3], function(num){ return num * 2; });
36 | equal(doubled.join(', '), '2, 4, 6', 'doubled numbers');
37 |
38 | doubled = _.collect([1, 2, 3], function(num){ return num * 2; });
39 | equal(doubled.join(', '), '2, 4, 6', 'aliased as "collect"');
40 |
41 | var tripled = _.map([1, 2, 3], function(num){ return num * this.multiplier; }, {multiplier : 3});
42 | equal(tripled.join(', '), '3, 6, 9', 'tripled numbers with context');
43 |
44 | var doubled = _([1, 2, 3]).map(function(num){ return num * 2; });
45 | equal(doubled.join(', '), '2, 4, 6', 'OO-style doubled numbers');
46 |
47 | if (document.querySelectorAll) {
48 | var ids = _.map(document.querySelectorAll('#map-test *'), function(n){ return n.id; });
49 | deepEqual(ids, ['id1', 'id2'], 'Can use collection methods on NodeLists.');
50 | }
51 |
52 | var ids = _.map($('#map-test').children(), function(n){ return n.id; });
53 | deepEqual(ids, ['id1', 'id2'], 'Can use collection methods on jQuery Array-likes.');
54 |
55 | var ids = _.map(document.images, function(n){ return n.id; });
56 | ok(ids[0] == 'chart_image', 'can use collection methods on HTMLCollections');
57 |
58 | var ifnull = _.map(null, function(){});
59 | ok(_.isArray(ifnull) && ifnull.length === 0, 'handles a null properly');
60 | });
61 |
62 | test('reduce', function() {
63 | var sum = _.reduce([1, 2, 3], function(sum, num){ return sum + num; }, 0);
64 | equal(sum, 6, 'can sum up an array');
65 |
66 | var context = {multiplier : 3};
67 | sum = _.reduce([1, 2, 3], function(sum, num){ return sum + num * this.multiplier; }, 0, context);
68 | equal(sum, 18, 'can reduce with a context object');
69 |
70 | sum = _.inject([1, 2, 3], function(sum, num){ return sum + num; }, 0);
71 | equal(sum, 6, 'aliased as "inject"');
72 |
73 | sum = _([1, 2, 3]).reduce(function(sum, num){ return sum + num; }, 0);
74 | equal(sum, 6, 'OO-style reduce');
75 |
76 | var sum = _.reduce([1, 2, 3], function(sum, num){ return sum + num; });
77 | equal(sum, 6, 'default initial value');
78 |
79 | var ifnull;
80 | try {
81 | _.reduce(null, function(){});
82 | } catch (ex) {
83 | ifnull = ex;
84 | }
85 | ok(ifnull instanceof TypeError, 'handles a null (without inital value) properly');
86 |
87 | ok(_.reduce(null, function(){}, 138) === 138, 'handles a null (with initial value) properly');
88 | equal(_.reduce([], function(){}, undefined), undefined, 'undefined can be passed as a special case');
89 | raises(function() { _.reduce([], function(){}); }, TypeError, 'throws an error for empty arrays with no initial value');
90 | });
91 |
92 | test('reduceRight', function() {
93 | var list = _.reduceRight(["foo", "bar", "baz"], function(memo, str){ return memo + str; }, '');
94 | equal(list, 'bazbarfoo', 'can perform right folds');
95 |
96 | var list = _.foldr(["foo", "bar", "baz"], function(memo, str){ return memo + str; }, '');
97 | equal(list, 'bazbarfoo', 'aliased as "foldr"');
98 |
99 | var list = _.foldr(["foo", "bar", "baz"], function(memo, str){ return memo + str; });
100 | equal(list, 'bazbarfoo', 'default initial value');
101 |
102 | var ifnull;
103 | try {
104 | _.reduceRight(null, function(){});
105 | } catch (ex) {
106 | ifnull = ex;
107 | }
108 | ok(ifnull instanceof TypeError, 'handles a null (without inital value) properly');
109 |
110 | var sum = _.reduceRight({a: 1, b: 2, c: 3}, function(sum, num){ return sum + num; });
111 | equal(sum, 6, 'default initial value on object');
112 |
113 | ok(_.reduceRight(null, function(){}, 138) === 138, 'handles a null (with initial value) properly');
114 |
115 | equal(_.reduceRight([], function(){}, undefined), undefined, 'undefined can be passed as a special case');
116 | raises(function() { _.reduceRight([], function(){}); }, TypeError, 'throws an error for empty arrays with no initial value');
117 |
118 | // Assert that the correct arguments are being passed.
119 |
120 | var args,
121 | memo = {},
122 | object = {a: 1, b: 2},
123 | lastKey = _.keys(object).pop();
124 |
125 | var expected = lastKey == 'a'
126 | ? [memo, 1, 'a', object]
127 | : [memo, 2, 'b', object];
128 |
129 | _.reduceRight(object, function() {
130 | args || (args = _.toArray(arguments));
131 | }, memo);
132 |
133 | deepEqual(args, expected);
134 |
135 | // And again, with numeric keys.
136 |
137 | object = {'2': 'a', '1': 'b'};
138 | lastKey = _.keys(object).pop();
139 | args = null;
140 |
141 | expected = lastKey == '2'
142 | ? [memo, 'a', '2', object]
143 | : [memo, 'b', '1', object];
144 |
145 | _.reduceRight(object, function() {
146 | args || (args = _.toArray(arguments));
147 | }, memo);
148 |
149 | deepEqual(args, expected);
150 | });
151 |
152 | test('find', function() {
153 | var array = [1, 2, 3, 4];
154 | strictEqual(_.find(array, function(n) { return n > 2; }), 3, 'should return first found `value`');
155 | strictEqual(_.find(array, function() { return false; }), void 0, 'should return `undefined` if `value` is not found');
156 | });
157 |
158 | test('detect', function() {
159 | var result = _.detect([1, 2, 3], function(num){ return num * 2 == 4; });
160 | equal(result, 2, 'found the first "2" and broke the loop');
161 | });
162 |
163 | test('select', function() {
164 | var evens = _.select([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
165 | equal(evens.join(', '), '2, 4, 6', 'selected each even number');
166 |
167 | evens = _.filter([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
168 | equal(evens.join(', '), '2, 4, 6', 'aliased as "filter"');
169 | });
170 |
171 | test('reject', function() {
172 | var odds = _.reject([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
173 | equal(odds.join(', '), '1, 3, 5', 'rejected each even number');
174 |
175 | var context = "obj";
176 |
177 | var evens = _.reject([1, 2, 3, 4, 5, 6], function(num){
178 | equal(context, "obj");
179 | return num % 2 != 0;
180 | }, context);
181 | equal(evens.join(', '), '2, 4, 6', 'rejected each odd number');
182 | });
183 |
184 | test('all', function() {
185 | ok(_.all([], _.identity), 'the empty set');
186 | ok(_.all([true, true, true], _.identity), 'all true values');
187 | ok(!_.all([true, false, true], _.identity), 'one false value');
188 | ok(_.all([0, 10, 28], function(num){ return num % 2 == 0; }), 'even numbers');
189 | ok(!_.all([0, 11, 28], function(num){ return num % 2 == 0; }), 'an odd number');
190 | ok(_.all([1], _.identity) === true, 'cast to boolean - true');
191 | ok(_.all([0], _.identity) === false, 'cast to boolean - false');
192 | ok(_.every([true, true, true], _.identity), 'aliased as "every"');
193 | ok(!_.all([undefined, undefined, undefined], _.identity), 'works with arrays of undefined');
194 | });
195 |
196 | test('any', function() {
197 | var nativeSome = Array.prototype.some;
198 | Array.prototype.some = null;
199 | ok(!_.any([]), 'the empty set');
200 | ok(!_.any([false, false, false]), 'all false values');
201 | ok(_.any([false, false, true]), 'one true value');
202 | ok(_.any([null, 0, 'yes', false]), 'a string');
203 | ok(!_.any([null, 0, '', false]), 'falsy values');
204 | ok(!_.any([1, 11, 29], function(num){ return num % 2 == 0; }), 'all odd numbers');
205 | ok(_.any([1, 10, 29], function(num){ return num % 2 == 0; }), 'an even number');
206 | ok(_.any([1], _.identity) === true, 'cast to boolean - true');
207 | ok(_.any([0], _.identity) === false, 'cast to boolean - false');
208 | ok(_.some([false, false, true]), 'aliased as "some"');
209 | Array.prototype.some = nativeSome;
210 | });
211 |
212 | test('include', function() {
213 | ok(_.include([1,2,3], 2), 'two is in the array');
214 | ok(!_.include([1,3,9], 2), 'two is not in the array');
215 | ok(_.contains({moe:1, larry:3, curly:9}, 3) === true, '_.include on objects checks their values');
216 | ok(_([1,2,3]).include(2), 'OO-style include');
217 | });
218 |
219 | test('invoke', function() {
220 | var list = [[5, 1, 7], [3, 2, 1]];
221 | var result = _.invoke(list, 'sort');
222 | equal(result[0].join(', '), '1, 5, 7', 'first array sorted');
223 | equal(result[1].join(', '), '1, 2, 3', 'second array sorted');
224 | });
225 |
226 | test('invoke w/ function reference', function() {
227 | var list = [[5, 1, 7], [3, 2, 1]];
228 | var result = _.invoke(list, Array.prototype.sort);
229 | equal(result[0].join(', '), '1, 5, 7', 'first array sorted');
230 | equal(result[1].join(', '), '1, 2, 3', 'second array sorted');
231 | });
232 |
233 | // Relevant when using ClojureScript
234 | test('invoke when strings have a call method', function() {
235 | String.prototype.call = function() {
236 | return 42;
237 | };
238 | var list = [[5, 1, 7], [3, 2, 1]];
239 | var s = "foo";
240 | equal(s.call(), 42, "call function exists");
241 | var result = _.invoke(list, 'sort');
242 | equal(result[0].join(', '), '1, 5, 7', 'first array sorted');
243 | equal(result[1].join(', '), '1, 2, 3', 'second array sorted');
244 | delete String.prototype.call;
245 | equal(s.call, undefined, "call function removed");
246 | });
247 |
248 | test('pluck', function() {
249 | var people = [{name : 'moe', age : 30}, {name : 'curly', age : 50}];
250 | equal(_.pluck(people, 'name').join(', '), 'moe, curly', 'pulls names out of objects');
251 | });
252 |
253 | test('where', function() {
254 | var list = [{a: 1, b: 2}, {a: 2, b: 2}, {a: 1, b: 3}, {a: 1, b: 4}];
255 | var result = _.where(list, {a: 1});
256 | equal(result.length, 3);
257 | equal(result[result.length - 1].b, 4);
258 | result = _.where(list, {b: 2});
259 | equal(result.length, 2);
260 | equal(result[0].a, 1);
261 | });
262 |
263 | test('max', function() {
264 | equal(3, _.max([1, 2, 3]), 'can perform a regular Math.max');
265 |
266 | var neg = _.max([1, 2, 3], function(num){ return -num; });
267 | equal(neg, 1, 'can perform a computation-based max');
268 |
269 | equal(-Infinity, _.max({}), 'Maximum value of an empty object');
270 | equal(-Infinity, _.max([]), 'Maximum value of an empty array');
271 | equal(_.max({'a': 'a'}), -Infinity, 'Maximum value of a non-numeric collection');
272 |
273 | equal(299999, _.max(_.range(1,300000)), "Maximum value of a too-big array");
274 | });
275 |
276 | test('min', function() {
277 | equal(1, _.min([1, 2, 3]), 'can perform a regular Math.min');
278 |
279 | var neg = _.min([1, 2, 3], function(num){ return -num; });
280 | equal(neg, 3, 'can perform a computation-based min');
281 |
282 | equal(Infinity, _.min({}), 'Minimum value of an empty object');
283 | equal(Infinity, _.min([]), 'Minimum value of an empty array');
284 | equal(_.min({'a': 'a'}), Infinity, 'Minimum value of a non-numeric collection');
285 |
286 | var now = new Date(9999999999);
287 | var then = new Date(0);
288 | equal(_.min([now, then]), then);
289 |
290 | equal(1, _.min(_.range(1,300000)), "Minimum value of a too-big array");
291 | });
292 |
293 | test('sortBy', function() {
294 | var people = [{name : 'curly', age : 50}, {name : 'moe', age : 30}];
295 | people = _.sortBy(people, function(person){ return person.age; });
296 | equal(_.pluck(people, 'name').join(', '), 'moe, curly', 'stooges sorted by age');
297 |
298 | var list = [undefined, 4, 1, undefined, 3, 2];
299 | equal(_.sortBy(list, _.identity).join(','), '1,2,3,4,,', 'sortBy with undefined values');
300 |
301 | var list = ["one", "two", "three", "four", "five"];
302 | var sorted = _.sortBy(list, 'length');
303 | equal(sorted.join(' '), 'one two four five three', 'sorted by length');
304 |
305 | function Pair(x, y) {
306 | this.x = x;
307 | this.y = y;
308 | }
309 |
310 | var collection = [
311 | new Pair(1, 1), new Pair(1, 2),
312 | new Pair(1, 3), new Pair(1, 4),
313 | new Pair(1, 5), new Pair(1, 6),
314 | new Pair(2, 1), new Pair(2, 2),
315 | new Pair(2, 3), new Pair(2, 4),
316 | new Pair(2, 5), new Pair(2, 6),
317 | new Pair(undefined, 1), new Pair(undefined, 2),
318 | new Pair(undefined, 3), new Pair(undefined, 4),
319 | new Pair(undefined, 5), new Pair(undefined, 6)
320 | ];
321 |
322 | var actual = _.sortBy(collection, function(pair) {
323 | return pair.x;
324 | });
325 |
326 | deepEqual(actual, collection, 'sortBy should be stable');
327 | });
328 |
329 | test('groupBy', function() {
330 | var parity = _.groupBy([1, 2, 3, 4, 5, 6], function(num){ return num % 2; });
331 | ok('0' in parity && '1' in parity, 'created a group for each value');
332 | equal(parity[0].join(', '), '2, 4, 6', 'put each even number in the right group');
333 |
334 | var list = ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"];
335 | var grouped = _.groupBy(list, 'length');
336 | equal(grouped['3'].join(' '), 'one two six ten');
337 | equal(grouped['4'].join(' '), 'four five nine');
338 | equal(grouped['5'].join(' '), 'three seven eight');
339 |
340 | var context = {};
341 | _.groupBy([{}], function(){ ok(this === context); }, context);
342 |
343 | grouped = _.groupBy([4.2, 6.1, 6.4], function(num) {
344 | return Math.floor(num) > 4 ? 'hasOwnProperty' : 'constructor';
345 | });
346 | equal(grouped.constructor.length, 1);
347 | equal(grouped.hasOwnProperty.length, 2);
348 |
349 | var array = [{}];
350 | _.groupBy(array, function(value, index, obj){ ok(obj === array); });
351 |
352 | var array = [1, 2, 1, 2, 3];
353 | var grouped = _.groupBy(array);
354 | equal(grouped['1'].length, 2);
355 | equal(grouped['3'].length, 1);
356 | });
357 |
358 | test('countBy', function() {
359 | var parity = _.countBy([1, 2, 3, 4, 5], function(num){ return num % 2 == 0; });
360 | equal(parity['true'], 2);
361 | equal(parity['false'], 3);
362 |
363 | var list = ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"];
364 | var grouped = _.countBy(list, 'length');
365 | equal(grouped['3'], 4);
366 | equal(grouped['4'], 3);
367 | equal(grouped['5'], 3);
368 |
369 | var context = {};
370 | _.countBy([{}], function(){ ok(this === context); }, context);
371 |
372 | grouped = _.countBy([4.2, 6.1, 6.4], function(num) {
373 | return Math.floor(num) > 4 ? 'hasOwnProperty' : 'constructor';
374 | });
375 | equal(grouped.constructor, 1);
376 | equal(grouped.hasOwnProperty, 2);
377 |
378 | var array = [{}];
379 | _.countBy(array, function(value, index, obj){ ok(obj === array); });
380 |
381 | var array = [1, 2, 1, 2, 3];
382 | var grouped = _.countBy(array);
383 | equal(grouped['1'], 2);
384 | equal(grouped['3'], 1);
385 | });
386 |
387 | test('sortedIndex', function() {
388 | var numbers = [10, 20, 30, 40, 50], num = 35;
389 | var indexForNum = _.sortedIndex(numbers, num);
390 | equal(indexForNum, 3, '35 should be inserted at index 3');
391 |
392 | var indexFor30 = _.sortedIndex(numbers, 30);
393 | equal(indexFor30, 2, '30 should be inserted at index 2');
394 |
395 | var objects = [{x: 10}, {x: 20}, {x: 30}, {x: 40}];
396 | var iterator = function(obj){ return obj.x; };
397 | strictEqual(_.sortedIndex(objects, {x: 25}, iterator), 2);
398 | strictEqual(_.sortedIndex(objects, {x: 35}, 'x'), 3);
399 |
400 | var context = {1: 2, 2: 3, 3: 4};
401 | iterator = function(obj){ return this[obj]; };
402 | strictEqual(_.sortedIndex([1, 3], 2, iterator, context), 1);
403 | });
404 |
405 | test('shuffle', function() {
406 | var numbers = _.range(10);
407 | var shuffled = _.shuffle(numbers).sort();
408 | notStrictEqual(numbers, shuffled, 'original object is unmodified');
409 | equal(shuffled.join(','), numbers.join(','), 'contains the same members before and after shuffle');
410 | });
411 |
412 | test('toArray', function() {
413 | ok(!_.isArray(arguments), 'arguments object is not an array');
414 | ok(_.isArray(_.toArray(arguments)), 'arguments object converted into array');
415 | var a = [1,2,3];
416 | ok(_.toArray(a) !== a, 'array is cloned');
417 | equal(_.toArray(a).join(', '), '1, 2, 3', 'cloned array contains same elements');
418 |
419 | var numbers = _.toArray({one : 1, two : 2, three : 3});
420 | equal(numbers.join(', '), '1, 2, 3', 'object flattened into array');
421 |
422 | // test in IE < 9
423 | try {
424 | var actual = _.toArray(document.childNodes);
425 | } catch(ex) { }
426 |
427 | ok(_.isArray(actual), 'should not throw converting a node list');
428 | });
429 |
430 | test('size', function() {
431 | equal(_.size({one : 1, two : 2, three : 3}), 3, 'can compute the size of an object');
432 | equal(_.size([1, 2, 3]), 3, 'can compute the size of an array');
433 |
434 | var func = function() {
435 | return _.size(arguments);
436 | };
437 |
438 | equal(func(1, 2, 3, 4), 4, 'can test the size of the arguments object');
439 |
440 | equal(_.size('hello'), 5, 'can compute the size of a string');
441 |
442 | equal(_.size(null), 0, 'handles nulls');
443 | });
444 |
445 | });
446 |
--------------------------------------------------------------------------------
/components/underscore/test/functions.js:
--------------------------------------------------------------------------------
1 | $(document).ready(function() {
2 |
3 | module("Functions");
4 |
5 | test("bind", function() {
6 | var context = {name : 'moe'};
7 | var func = function(arg) { return "name: " + (this.name || arg); };
8 | var bound = _.bind(func, context);
9 | equal(bound(), 'name: moe', 'can bind a function to a context');
10 |
11 | bound = _(func).bind(context);
12 | equal(bound(), 'name: moe', 'can do OO-style binding');
13 |
14 | bound = _.bind(func, null, 'curly');
15 | equal(bound(), 'name: curly', 'can bind without specifying a context');
16 |
17 | func = function(salutation, name) { return salutation + ': ' + name; };
18 | func = _.bind(func, this, 'hello');
19 | equal(func('moe'), 'hello: moe', 'the function was partially applied in advance');
20 |
21 | var func = _.bind(func, this, 'curly');
22 | equal(func(), 'hello: curly', 'the function was completely applied in advance');
23 |
24 | var func = function(salutation, firstname, lastname) { return salutation + ': ' + firstname + ' ' + lastname; };
25 | func = _.bind(func, this, 'hello', 'moe', 'curly');
26 | equal(func(), 'hello: moe curly', 'the function was partially applied in advance and can accept multiple arguments');
27 |
28 | func = function(context, message) { equal(this, context, message); };
29 | _.bind(func, 0, 0, 'can bind a function to `0`')();
30 | _.bind(func, '', '', 'can bind a function to an empty string')();
31 | _.bind(func, false, false, 'can bind a function to `false`')();
32 |
33 | // These tests are only meaningful when using a browser without a native bind function
34 | // To test this with a modern browser, set underscore's nativeBind to undefined
35 | var F = function () { return this; };
36 | var Boundf = _.bind(F, {hello: "moe curly"});
37 | var newBoundf = new Boundf();
38 | equal(newBoundf.hello, undefined, "function should not be bound to the context, to comply with ECMAScript 5");
39 | equal(Boundf().hello, "moe curly", "When called without the new operator, it's OK to be bound to the context");
40 | ok(newBoundf instanceof F, "a bound instance is an instance of the original function");
41 | });
42 |
43 | test("bindAll", function() {
44 | var curly = {name : 'curly'}, moe = {
45 | name : 'moe',
46 | getName : function() { return 'name: ' + this.name; },
47 | sayHi : function() { return 'hi: ' + this.name; }
48 | };
49 | curly.getName = moe.getName;
50 | _.bindAll(moe, 'getName', 'sayHi');
51 | curly.sayHi = moe.sayHi;
52 | equal(curly.getName(), 'name: curly', 'unbound function is bound to current object');
53 | equal(curly.sayHi(), 'hi: moe', 'bound function is still bound to original object');
54 |
55 | curly = {name : 'curly'};
56 | moe = {
57 | name : 'moe',
58 | getName : function() { return 'name: ' + this.name; },
59 | sayHi : function() { return 'hi: ' + this.name; }
60 | };
61 | _.bindAll(moe);
62 | curly.sayHi = moe.sayHi;
63 | equal(curly.sayHi(), 'hi: moe', 'calling bindAll with no arguments binds all functions to the object');
64 | });
65 |
66 | test("memoize", function() {
67 | var fib = function(n) {
68 | return n < 2 ? n : fib(n - 1) + fib(n - 2);
69 | };
70 | var fastFib = _.memoize(fib);
71 | equal(fib(10), 55, 'a memoized version of fibonacci produces identical results');
72 | equal(fastFib(10), 55, 'a memoized version of fibonacci produces identical results');
73 |
74 | var o = function(str) {
75 | return str;
76 | };
77 | var fastO = _.memoize(o);
78 | equal(o('toString'), 'toString', 'checks hasOwnProperty');
79 | equal(fastO('toString'), 'toString', 'checks hasOwnProperty');
80 | });
81 |
82 | asyncTest("delay", 2, function() {
83 | var delayed = false;
84 | _.delay(function(){ delayed = true; }, 100);
85 | setTimeout(function(){ ok(!delayed, "didn't delay the function quite yet"); }, 50);
86 | setTimeout(function(){ ok(delayed, 'delayed the function'); start(); }, 150);
87 | });
88 |
89 | asyncTest("defer", 1, function() {
90 | var deferred = false;
91 | _.defer(function(bool){ deferred = bool; }, true);
92 | _.delay(function(){ ok(deferred, "deferred the function"); start(); }, 50);
93 | });
94 |
95 | asyncTest("throttle", 2, function() {
96 | var counter = 0;
97 | var incr = function(){ counter++; };
98 | var throttledIncr = _.throttle(incr, 100);
99 | throttledIncr(); throttledIncr(); throttledIncr();
100 | setTimeout(throttledIncr, 70);
101 | setTimeout(throttledIncr, 120);
102 | setTimeout(throttledIncr, 140);
103 | setTimeout(throttledIncr, 190);
104 | setTimeout(throttledIncr, 220);
105 | setTimeout(throttledIncr, 240);
106 | _.delay(function(){ equal(counter, 1, "incr was called immediately"); }, 30);
107 | _.delay(function(){ equal(counter, 4, "incr was throttled"); start(); }, 400);
108 | });
109 |
110 | asyncTest("throttle arguments", 2, function() {
111 | var value = 0;
112 | var update = function(val){ value = val; };
113 | var throttledUpdate = _.throttle(update, 100);
114 | throttledUpdate(1); throttledUpdate(2); throttledUpdate(3);
115 | setTimeout(function(){ throttledUpdate(4); }, 120);
116 | setTimeout(function(){ throttledUpdate(5); }, 140);
117 | setTimeout(function(){ throttledUpdate(6); }, 250);
118 | _.delay(function(){ equal(value, 1, "updated to latest value"); }, 40);
119 | _.delay(function(){ equal(value, 6, "updated to latest value"); start(); }, 400);
120 | });
121 |
122 | asyncTest("throttle once", 2, function() {
123 | var counter = 0;
124 | var incr = function(){ return ++counter; };
125 | var throttledIncr = _.throttle(incr, 100);
126 | var result = throttledIncr();
127 | _.delay(function(){
128 | equal(result, 1, "throttled functions return their value");
129 | equal(counter, 1, "incr was called once"); start();
130 | }, 220);
131 | });
132 |
133 | asyncTest("throttle twice", 1, function() {
134 | var counter = 0;
135 | var incr = function(){ counter++; };
136 | var throttledIncr = _.throttle(incr, 100);
137 | throttledIncr(); throttledIncr();
138 | _.delay(function(){ equal(counter, 2, "incr was called twice"); start(); }, 220);
139 | });
140 |
141 | asyncTest("throttle repeatedly with results", 9, function() {
142 | var counter = 0;
143 | var incr = function(){ return ++counter; };
144 | var throttledIncr = _.throttle(incr, 100);
145 | var results = [];
146 | var saveResult = function() { results.push(throttledIncr()); };
147 | saveResult(); saveResult(); saveResult();
148 | setTimeout(saveResult, 70);
149 | setTimeout(saveResult, 120);
150 | setTimeout(saveResult, 140);
151 | setTimeout(saveResult, 190);
152 | setTimeout(saveResult, 240);
153 | setTimeout(saveResult, 260);
154 | _.delay(function() {
155 | equal(results[0], 1, "incr was called once");
156 | equal(results[1], 1, "incr was throttled");
157 | equal(results[2], 1, "incr was throttled");
158 | equal(results[3], 1, "incr was throttled");
159 | equal(results[4], 2, "incr was called twice");
160 | equal(results[5], 2, "incr was throttled");
161 | equal(results[6], 2, "incr was throttled");
162 | equal(results[7], 3, "incr was called thrice");
163 | equal(results[8], 3, "incr was throttled");
164 | start();
165 | }, 400);
166 | });
167 |
168 | asyncTest("throttle triggers trailing call after repeatedly invoked", 2, function() {
169 | var actual;
170 | var counter = 0;
171 | var limit = 80;
172 | var incr = function(){ counter++; };
173 | var throttledIncr = _.throttle(incr, 32);
174 |
175 | var stamp = new Date;
176 | while ((new Date - stamp) < limit) {
177 | throttledIncr();
178 | }
179 | _.delay(function() {
180 | actual = counter + 2;
181 | throttledIncr();
182 | throttledIncr();
183 | }, 64);
184 |
185 | _.delay(function() {
186 | equal(counter, actual);
187 | start();
188 | }, 128);
189 |
190 | ok(counter > 1);
191 | });
192 |
193 | asyncTest("debounce", 1, function() {
194 | var counter = 0;
195 | var incr = function(){ counter++; };
196 | var debouncedIncr = _.debounce(incr, 50);
197 | debouncedIncr(); debouncedIncr(); debouncedIncr();
198 | setTimeout(debouncedIncr, 30);
199 | setTimeout(debouncedIncr, 60);
200 | setTimeout(debouncedIncr, 90);
201 | setTimeout(debouncedIncr, 120);
202 | setTimeout(debouncedIncr, 150);
203 | _.delay(function(){ equal(counter, 1, "incr was debounced"); start(); }, 220);
204 | });
205 |
206 | asyncTest("debounce asap", 5, function() {
207 | var a, b, c;
208 | var counter = 0;
209 | var incr = function(){ return ++counter; };
210 | var debouncedIncr = _.debounce(incr, 50, true);
211 | a = debouncedIncr();
212 | b = debouncedIncr();
213 | c = debouncedIncr();
214 | equal(a, 1);
215 | equal(b, 1);
216 | equal(c, 1);
217 | equal(counter, 1, 'incr was called immediately');
218 | setTimeout(debouncedIncr, 30);
219 | setTimeout(debouncedIncr, 60);
220 | setTimeout(debouncedIncr, 90);
221 | setTimeout(debouncedIncr, 120);
222 | setTimeout(debouncedIncr, 150);
223 | _.delay(function(){ equal(counter, 1, "incr was debounced"); start(); }, 220);
224 | });
225 |
226 | asyncTest("debounce asap recursively", 2, function() {
227 | var counter = 0;
228 | var debouncedIncr = _.debounce(function(){
229 | counter++;
230 | if (counter < 5) debouncedIncr();
231 | }, 50, true);
232 | debouncedIncr();
233 | equal(counter, 1, 'incr was called immediately');
234 | _.delay(function(){ equal(counter, 1, "incr was debounced"); start(); }, 70);
235 | });
236 |
237 | test("once", function() {
238 | var num = 0;
239 | var increment = _.once(function(){ num++; });
240 | increment();
241 | increment();
242 | equal(num, 1);
243 | });
244 |
245 | test("wrap", function() {
246 | var greet = function(name){ return "hi: " + name; };
247 | var backwards = _.wrap(greet, function(func, name){ return func(name) + ' ' + name.split('').reverse().join(''); });
248 | equal(backwards('moe'), 'hi: moe eom', 'wrapped the saluation function');
249 |
250 | var inner = function(){ return "Hello "; };
251 | var obj = {name : "Moe"};
252 | obj.hi = _.wrap(inner, function(fn){ return fn() + this.name; });
253 | equal(obj.hi(), "Hello Moe");
254 |
255 | var noop = function(){};
256 | var wrapped = _.wrap(noop, function(fn){ return Array.prototype.slice.call(arguments, 0); });
257 | var ret = wrapped(['whats', 'your'], 'vector', 'victor');
258 | deepEqual(ret, [noop, ['whats', 'your'], 'vector', 'victor']);
259 | });
260 |
261 | test("compose", function() {
262 | var greet = function(name){ return "hi: " + name; };
263 | var exclaim = function(sentence){ return sentence + '!'; };
264 | var composed = _.compose(exclaim, greet);
265 | equal(composed('moe'), 'hi: moe!', 'can compose a function that takes another');
266 |
267 | composed = _.compose(greet, exclaim);
268 | equal(composed('moe'), 'hi: moe!', 'in this case, the functions are also commutative');
269 | });
270 |
271 | test("after", function() {
272 | var testAfter = function(afterAmount, timesCalled) {
273 | var afterCalled = 0;
274 | var after = _.after(afterAmount, function() {
275 | afterCalled++;
276 | });
277 | while (timesCalled--) after();
278 | return afterCalled;
279 | };
280 |
281 | equal(testAfter(5, 5), 1, "after(N) should fire after being called N times");
282 | equal(testAfter(5, 4), 0, "after(N) should not fire unless called N times");
283 | equal(testAfter(0, 0), 1, "after(0) should fire immediately");
284 | });
285 |
286 | });
287 |
--------------------------------------------------------------------------------
/components/underscore/test/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | Underscore Test Suite
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
27 |
28 |
29 |
30 | A representative sample of the functions are benchmarked here, to provide
31 | a sense of how fast they might run in different browsers.
32 | Each iteration runs on an array of 1000 elements.
33 | For example, the 'intersection' test measures the number of times you can
34 | find the intersection of two thousand-element arrays in one second.
35 |
36 |
37 |
43 |
44 |
45 |
--------------------------------------------------------------------------------
/components/underscore/test/objects.js:
--------------------------------------------------------------------------------
1 | $(document).ready(function() {
2 |
3 | module("Objects");
4 |
5 | test("keys", function() {
6 | equal(_.keys({one : 1, two : 2}).join(', '), 'one, two', 'can extract the keys from an object');
7 | // the test above is not safe because it relies on for-in enumeration order
8 | var a = []; a[1] = 0;
9 | equal(_.keys(a).join(', '), '1', 'is not fooled by sparse arrays; see issue #95');
10 | raises(function() { _.keys(null); }, TypeError, 'throws an error for `null` values');
11 | raises(function() { _.keys(void 0); }, TypeError, 'throws an error for `undefined` values');
12 | raises(function() { _.keys(1); }, TypeError, 'throws an error for number primitives');
13 | raises(function() { _.keys('a'); }, TypeError, 'throws an error for string primitives');
14 | raises(function() { _.keys(true); }, TypeError, 'throws an error for boolean primitives');
15 | });
16 |
17 | test("values", function() {
18 | equal(_.values({one: 1, two: 2}).join(', '), '1, 2', 'can extract the values from an object');
19 | equal(_.values({one: 1, two: 2, length: 3}).join(', '), '1, 2, 3', '... even when one of them is "length"');
20 | });
21 |
22 | test("pairs", function() {
23 | deepEqual(_.pairs({one: 1, two: 2}), [['one', 1], ['two', 2]], 'can convert an object into pairs');
24 | deepEqual(_.pairs({one: 1, two: 2, length: 3}), [['one', 1], ['two', 2], ['length', 3]], '... even when one of them is "length"');
25 | });
26 |
27 | test("invert", function() {
28 | var obj = {first: 'Moe', second: 'Larry', third: 'Curly'};
29 | equal(_.keys(_.invert(obj)).join(' '), 'Moe Larry Curly', 'can invert an object');
30 | ok(_.isEqual(_.invert(_.invert(obj)), obj), 'two inverts gets you back where you started');
31 |
32 | var obj = {length: 3};
33 | ok(_.invert(obj)['3'] == 'length', 'can invert an object with "length"')
34 | });
35 |
36 | test("functions", function() {
37 | var obj = {a : 'dash', b : _.map, c : (/yo/), d : _.reduce};
38 | ok(_.isEqual(['b', 'd'], _.functions(obj)), 'can grab the function names of any passed-in object');
39 |
40 | var Animal = function(){};
41 | Animal.prototype.run = function(){};
42 | equal(_.functions(new Animal).join(''), 'run', 'also looks up functions on the prototype');
43 | });
44 |
45 | test("extend", function() {
46 | var result;
47 | equal(_.extend({}, {a:'b'}).a, 'b', 'can extend an object with the attributes of another');
48 | equal(_.extend({a:'x'}, {a:'b'}).a, 'b', 'properties in source override destination');
49 | equal(_.extend({x:'x'}, {a:'b'}).x, 'x', 'properties not in source dont get overriden');
50 | result = _.extend({x:'x'}, {a:'a'}, {b:'b'});
51 | ok(_.isEqual(result, {x:'x', a:'a', b:'b'}), 'can extend from multiple source objects');
52 | result = _.extend({x:'x'}, {a:'a', x:2}, {a:'b'});
53 | ok(_.isEqual(result, {x:2, a:'b'}), 'extending from multiple source objects last property trumps');
54 | result = _.extend({}, {a: void 0, b: null});
55 | equal(_.keys(result).join(''), 'ab', 'extend does not copy undefined values');
56 |
57 | try {
58 | result = {};
59 | _.extend(result, null, undefined, {a:1});
60 | } catch(ex) {}
61 |
62 | equal(result.a, 1, 'should not error on `null` or `undefined` sources');
63 | });
64 |
65 | test("pick", function() {
66 | var result;
67 | result = _.pick({a:1, b:2, c:3}, 'a', 'c');
68 | ok(_.isEqual(result, {a:1, c:3}), 'can restrict properties to those named');
69 | result = _.pick({a:1, b:2, c:3}, ['b', 'c']);
70 | ok(_.isEqual(result, {b:2, c:3}), 'can restrict properties to those named in an array');
71 | result = _.pick({a:1, b:2, c:3}, ['a'], 'b');
72 | ok(_.isEqual(result, {a:1, b:2}), 'can restrict properties to those named in mixed args');
73 |
74 | var Obj = function(){};
75 | Obj.prototype = {a: 1, b: 2, c: 3};
76 | ok(_.isEqual(_.pick(new Obj, 'a', 'c'), {a:1, c: 3}), 'include prototype props');
77 | });
78 |
79 | test("omit", function() {
80 | var result;
81 | result = _.omit({a:1, b:2, c:3}, 'b');
82 | ok(_.isEqual(result, {a:1, c:3}), 'can omit a single named property');
83 | result = _.omit({a:1, b:2, c:3}, 'a', 'c');
84 | ok(_.isEqual(result, {b:2}), 'can omit several named properties');
85 | result = _.omit({a:1, b:2, c:3}, ['b', 'c']);
86 | ok(_.isEqual(result, {a:1}), 'can omit properties named in an array');
87 |
88 | var Obj = function(){};
89 | Obj.prototype = {a: 1, b: 2, c: 3};
90 | ok(_.isEqual(_.omit(new Obj, 'b'), {a:1, c: 3}), 'include prototype props');
91 | });
92 |
93 | test("defaults", function() {
94 | var result;
95 | var options = {zero: 0, one: 1, empty: "", nan: NaN, string: "string"};
96 |
97 | _.defaults(options, {zero: 1, one: 10, twenty: 20});
98 | equal(options.zero, 0, 'value exists');
99 | equal(options.one, 1, 'value exists');
100 | equal(options.twenty, 20, 'default applied');
101 |
102 | _.defaults(options, {empty: "full"}, {nan: "nan"}, {word: "word"}, {word: "dog"});
103 | equal(options.empty, "", 'value exists');
104 | ok(_.isNaN(options.nan), "NaN isn't overridden");
105 | equal(options.word, "word", 'new value is added, first one wins');
106 |
107 | try {
108 | options = {};
109 | _.defaults(options, null, undefined, {a:1});
110 | } catch(ex) {}
111 |
112 | equal(options.a, 1, 'should not error on `null` or `undefined` sources');
113 | });
114 |
115 | test("clone", function() {
116 | var moe = {name : 'moe', lucky : [13, 27, 34]};
117 | var clone = _.clone(moe);
118 | equal(clone.name, 'moe', 'the clone as the attributes of the original');
119 |
120 | clone.name = 'curly';
121 | ok(clone.name == 'curly' && moe.name == 'moe', 'clones can change shallow attributes without affecting the original');
122 |
123 | clone.lucky.push(101);
124 | equal(_.last(moe.lucky), 101, 'changes to deep attributes are shared with the original');
125 |
126 | equal(_.clone(undefined), void 0, 'non objects should not be changed by clone');
127 | equal(_.clone(1), 1, 'non objects should not be changed by clone');
128 | equal(_.clone(null), null, 'non objects should not be changed by clone');
129 | });
130 |
131 | test("isEqual", function() {
132 | function First() {
133 | this.value = 1;
134 | }
135 | First.prototype.value = 1;
136 | function Second() {
137 | this.value = 1;
138 | }
139 | Second.prototype.value = 2;
140 |
141 | // Basic equality and identity comparisons.
142 | ok(_.isEqual(null, null), "`null` is equal to `null`");
143 | ok(_.isEqual(), "`undefined` is equal to `undefined`");
144 |
145 | ok(!_.isEqual(0, -0), "`0` is not equal to `-0`");
146 | ok(!_.isEqual(-0, 0), "Commutative equality is implemented for `0` and `-0`");
147 | ok(!_.isEqual(null, undefined), "`null` is not equal to `undefined`");
148 | ok(!_.isEqual(undefined, null), "Commutative equality is implemented for `null` and `undefined`");
149 |
150 | // String object and primitive comparisons.
151 | ok(_.isEqual("Curly", "Curly"), "Identical string primitives are equal");
152 | ok(_.isEqual(new String("Curly"), new String("Curly")), "String objects with identical primitive values are equal");
153 | ok(_.isEqual(new String("Curly"), "Curly"), "String primitives and their corresponding object wrappers are equal");
154 | ok(_.isEqual("Curly", new String("Curly")), "Commutative equality is implemented for string objects and primitives");
155 |
156 | ok(!_.isEqual("Curly", "Larry"), "String primitives with different values are not equal");
157 | ok(!_.isEqual(new String("Curly"), new String("Larry")), "String objects with different primitive values are not equal");
158 | ok(!_.isEqual(new String("Curly"), {toString: function(){ return "Curly"; }}), "String objects and objects with a custom `toString` method are not equal");
159 |
160 | // Number object and primitive comparisons.
161 | ok(_.isEqual(75, 75), "Identical number primitives are equal");
162 | ok(_.isEqual(new Number(75), new Number(75)), "Number objects with identical primitive values are equal");
163 | ok(_.isEqual(75, new Number(75)), "Number primitives and their corresponding object wrappers are equal");
164 | ok(_.isEqual(new Number(75), 75), "Commutative equality is implemented for number objects and primitives");
165 | ok(!_.isEqual(new Number(0), -0), "`new Number(0)` and `-0` are not equal");
166 | ok(!_.isEqual(0, new Number(-0)), "Commutative equality is implemented for `new Number(0)` and `-0`");
167 |
168 | ok(!_.isEqual(new Number(75), new Number(63)), "Number objects with different primitive values are not equal");
169 | ok(!_.isEqual(new Number(63), {valueOf: function(){ return 63; }}), "Number objects and objects with a `valueOf` method are not equal");
170 |
171 | // Comparisons involving `NaN`.
172 | ok(_.isEqual(NaN, NaN), "`NaN` is equal to `NaN`");
173 | ok(!_.isEqual(61, NaN), "A number primitive is not equal to `NaN`");
174 | ok(!_.isEqual(new Number(79), NaN), "A number object is not equal to `NaN`");
175 | ok(!_.isEqual(Infinity, NaN), "`Infinity` is not equal to `NaN`");
176 |
177 | // Boolean object and primitive comparisons.
178 | ok(_.isEqual(true, true), "Identical boolean primitives are equal");
179 | ok(_.isEqual(new Boolean, new Boolean), "Boolean objects with identical primitive values are equal");
180 | ok(_.isEqual(true, new Boolean(true)), "Boolean primitives and their corresponding object wrappers are equal");
181 | ok(_.isEqual(new Boolean(true), true), "Commutative equality is implemented for booleans");
182 | ok(!_.isEqual(new Boolean(true), new Boolean), "Boolean objects with different primitive values are not equal");
183 |
184 | // Common type coercions.
185 | ok(!_.isEqual(true, new Boolean(false)), "Boolean objects are not equal to the boolean primitive `true`");
186 | ok(!_.isEqual("75", 75), "String and number primitives with like values are not equal");
187 | ok(!_.isEqual(new Number(63), new String(63)), "String and number objects with like values are not equal");
188 | ok(!_.isEqual(75, "75"), "Commutative equality is implemented for like string and number values");
189 | ok(!_.isEqual(0, ""), "Number and string primitives with like values are not equal");
190 | ok(!_.isEqual(1, true), "Number and boolean primitives with like values are not equal");
191 | ok(!_.isEqual(new Boolean(false), new Number(0)), "Boolean and number objects with like values are not equal");
192 | ok(!_.isEqual(false, new String("")), "Boolean primitives and string objects with like values are not equal");
193 | ok(!_.isEqual(12564504e5, new Date(2009, 9, 25)), "Dates and their corresponding numeric primitive values are not equal");
194 |
195 | // Dates.
196 | ok(_.isEqual(new Date(2009, 9, 25), new Date(2009, 9, 25)), "Date objects referencing identical times are equal");
197 | ok(!_.isEqual(new Date(2009, 9, 25), new Date(2009, 11, 13)), "Date objects referencing different times are not equal");
198 | ok(!_.isEqual(new Date(2009, 11, 13), {
199 | getTime: function(){
200 | return 12606876e5;
201 | }
202 | }), "Date objects and objects with a `getTime` method are not equal");
203 | ok(!_.isEqual(new Date("Curly"), new Date("Curly")), "Invalid dates are not equal");
204 |
205 | // Functions.
206 | ok(!_.isEqual(First, Second), "Different functions with identical bodies and source code representations are not equal");
207 |
208 | // RegExps.
209 | ok(_.isEqual(/(?:)/gim, /(?:)/gim), "RegExps with equivalent patterns and flags are equal");
210 | ok(!_.isEqual(/(?:)/g, /(?:)/gi), "RegExps with equivalent patterns and different flags are not equal");
211 | ok(!_.isEqual(/Moe/gim, /Curly/gim), "RegExps with different patterns and equivalent flags are not equal");
212 | ok(!_.isEqual(/(?:)/gi, /(?:)/g), "Commutative equality is implemented for RegExps");
213 | ok(!_.isEqual(/Curly/g, {source: "Larry", global: true, ignoreCase: false, multiline: false}), "RegExps and RegExp-like objects are not equal");
214 |
215 | // Empty arrays, array-like objects, and object literals.
216 | ok(_.isEqual({}, {}), "Empty object literals are equal");
217 | ok(_.isEqual([], []), "Empty array literals are equal");
218 | ok(_.isEqual([{}], [{}]), "Empty nested arrays and objects are equal");
219 | ok(!_.isEqual({length: 0}, []), "Array-like objects and arrays are not equal.");
220 | ok(!_.isEqual([], {length: 0}), "Commutative equality is implemented for array-like objects");
221 |
222 | ok(!_.isEqual({}, []), "Object literals and array literals are not equal");
223 | ok(!_.isEqual([], {}), "Commutative equality is implemented for objects and arrays");
224 |
225 | // Arrays with primitive and object values.
226 | ok(_.isEqual([1, "Larry", true], [1, "Larry", true]), "Arrays containing identical primitives are equal");
227 | ok(_.isEqual([(/Moe/g), new Date(2009, 9, 25)], [(/Moe/g), new Date(2009, 9, 25)]), "Arrays containing equivalent elements are equal");
228 |
229 | // Multi-dimensional arrays.
230 | var a = [new Number(47), false, "Larry", /Moe/, new Date(2009, 11, 13), ['running', 'biking', new String('programming')], {a: 47}];
231 | var b = [new Number(47), false, "Larry", /Moe/, new Date(2009, 11, 13), ['running', 'biking', new String('programming')], {a: 47}];
232 | ok(_.isEqual(a, b), "Arrays containing nested arrays and objects are recursively compared");
233 |
234 | // Overwrite the methods defined in ES 5.1 section 15.4.4.
235 | a.forEach = a.map = a.filter = a.every = a.indexOf = a.lastIndexOf = a.some = a.reduce = a.reduceRight = null;
236 | b.join = b.pop = b.reverse = b.shift = b.slice = b.splice = b.concat = b.sort = b.unshift = null;
237 |
238 | // Array elements and properties.
239 | ok(_.isEqual(a, b), "Arrays containing equivalent elements and different non-numeric properties are equal");
240 | a.push("White Rocks");
241 | ok(!_.isEqual(a, b), "Arrays of different lengths are not equal");
242 | a.push("East Boulder");
243 | b.push("Gunbarrel Ranch", "Teller Farm");
244 | ok(!_.isEqual(a, b), "Arrays of identical lengths containing different elements are not equal");
245 |
246 | // Sparse arrays.
247 | ok(_.isEqual(Array(3), Array(3)), "Sparse arrays of identical lengths are equal");
248 | ok(!_.isEqual(Array(3), Array(6)), "Sparse arrays of different lengths are not equal when both are empty");
249 |
250 | // Simple objects.
251 | ok(_.isEqual({a: "Curly", b: 1, c: true}, {a: "Curly", b: 1, c: true}), "Objects containing identical primitives are equal");
252 | ok(_.isEqual({a: /Curly/g, b: new Date(2009, 11, 13)}, {a: /Curly/g, b: new Date(2009, 11, 13)}), "Objects containing equivalent members are equal");
253 | ok(!_.isEqual({a: 63, b: 75}, {a: 61, b: 55}), "Objects of identical sizes with different values are not equal");
254 | ok(!_.isEqual({a: 63, b: 75}, {a: 61, c: 55}), "Objects of identical sizes with different property names are not equal");
255 | ok(!_.isEqual({a: 1, b: 2}, {a: 1}), "Objects of different sizes are not equal");
256 | ok(!_.isEqual({a: 1}, {a: 1, b: 2}), "Commutative equality is implemented for objects");
257 | ok(!_.isEqual({x: 1, y: undefined}, {x: 1, z: 2}), "Objects with identical keys and different values are not equivalent");
258 |
259 | // `A` contains nested objects and arrays.
260 | a = {
261 | name: new String("Moe Howard"),
262 | age: new Number(77),
263 | stooge: true,
264 | hobbies: ["acting"],
265 | film: {
266 | name: "Sing a Song of Six Pants",
267 | release: new Date(1947, 9, 30),
268 | stars: [new String("Larry Fine"), "Shemp Howard"],
269 | minutes: new Number(16),
270 | seconds: 54
271 | }
272 | };
273 |
274 | // `B` contains equivalent nested objects and arrays.
275 | b = {
276 | name: new String("Moe Howard"),
277 | age: new Number(77),
278 | stooge: true,
279 | hobbies: ["acting"],
280 | film: {
281 | name: "Sing a Song of Six Pants",
282 | release: new Date(1947, 9, 30),
283 | stars: [new String("Larry Fine"), "Shemp Howard"],
284 | minutes: new Number(16),
285 | seconds: 54
286 | }
287 | };
288 | ok(_.isEqual(a, b), "Objects with nested equivalent members are recursively compared");
289 |
290 | // Instances.
291 | ok(_.isEqual(new First, new First), "Object instances are equal");
292 | ok(!_.isEqual(new First, new Second), "Objects with different constructors and identical own properties are not equal");
293 | ok(!_.isEqual({value: 1}, new First), "Object instances and objects sharing equivalent properties are not equal");
294 | ok(!_.isEqual({value: 2}, new Second), "The prototype chain of objects should not be examined");
295 |
296 | // Circular Arrays.
297 | (a = []).push(a);
298 | (b = []).push(b);
299 | ok(_.isEqual(a, b), "Arrays containing circular references are equal");
300 | a.push(new String("Larry"));
301 | b.push(new String("Larry"));
302 | ok(_.isEqual(a, b), "Arrays containing circular references and equivalent properties are equal");
303 | a.push("Shemp");
304 | b.push("Curly");
305 | ok(!_.isEqual(a, b), "Arrays containing circular references and different properties are not equal");
306 |
307 | // More circular arrays #767.
308 | a = ["everything is checked but", "this", "is not"];
309 | a[1] = a;
310 | b = ["everything is checked but", ["this", "array"], "is not"];
311 | ok(!_.isEqual(a, b), "Comparison of circular references with non-circular references are not equal");
312 |
313 | // Circular Objects.
314 | a = {abc: null};
315 | b = {abc: null};
316 | a.abc = a;
317 | b.abc = b;
318 | ok(_.isEqual(a, b), "Objects containing circular references are equal");
319 | a.def = 75;
320 | b.def = 75;
321 | ok(_.isEqual(a, b), "Objects containing circular references and equivalent properties are equal");
322 | a.def = new Number(75);
323 | b.def = new Number(63);
324 | ok(!_.isEqual(a, b), "Objects containing circular references and different properties are not equal");
325 |
326 | // More circular objects #767.
327 | a = {everything: "is checked", but: "this", is: "not"};
328 | a.but = a;
329 | b = {everything: "is checked", but: {that:"object"}, is: "not"};
330 | ok(!_.isEqual(a, b), "Comparison of circular references with non-circular object references are not equal");
331 |
332 | // Cyclic Structures.
333 | a = [{abc: null}];
334 | b = [{abc: null}];
335 | (a[0].abc = a).push(a);
336 | (b[0].abc = b).push(b);
337 | ok(_.isEqual(a, b), "Cyclic structures are equal");
338 | a[0].def = "Larry";
339 | b[0].def = "Larry";
340 | ok(_.isEqual(a, b), "Cyclic structures containing equivalent properties are equal");
341 | a[0].def = new String("Larry");
342 | b[0].def = new String("Curly");
343 | ok(!_.isEqual(a, b), "Cyclic structures containing different properties are not equal");
344 |
345 | // Complex Circular References.
346 | a = {foo: {b: {foo: {c: {foo: null}}}}};
347 | b = {foo: {b: {foo: {c: {foo: null}}}}};
348 | a.foo.b.foo.c.foo = a;
349 | b.foo.b.foo.c.foo = b;
350 | ok(_.isEqual(a, b), "Cyclic structures with nested and identically-named properties are equal");
351 |
352 | // Chaining.
353 | ok(!_.isEqual(_({x: 1, y: undefined}).chain(), _({x: 1, z: 2}).chain()), 'Chained objects containing different values are not equal');
354 |
355 | a = _({x: 1, y: 2}).chain();
356 | b = _({x: 1, y: 2}).chain();
357 | equal(_.isEqual(a.isEqual(b), _(true)), true, '`isEqual` can be chained');
358 |
359 | // Objects from another frame.
360 | ok(_.isEqual({}, iObject));
361 | });
362 |
363 | test("isEmpty", function() {
364 | ok(!_([1]).isEmpty(), '[1] is not empty');
365 | ok(_.isEmpty([]), '[] is empty');
366 | ok(!_.isEmpty({one : 1}), '{one : 1} is not empty');
367 | ok(_.isEmpty({}), '{} is empty');
368 | ok(_.isEmpty(new RegExp('')), 'objects with prototype properties are empty');
369 | ok(_.isEmpty(null), 'null is empty');
370 | ok(_.isEmpty(), 'undefined is empty');
371 | ok(_.isEmpty(''), 'the empty string is empty');
372 | ok(!_.isEmpty('moe'), 'but other strings are not');
373 |
374 | var obj = {one : 1};
375 | delete obj.one;
376 | ok(_.isEmpty(obj), 'deleting all the keys from an object empties it');
377 | });
378 |
379 | // Setup remote variables for iFrame tests.
380 | var iframe = document.createElement('iframe');
381 | jQuery(iframe).appendTo(document.body);
382 | var iDoc = iframe.contentDocument || iframe.contentWindow.document;
383 | iDoc.write(
384 | ""
399 | );
400 | iDoc.close();
401 |
402 | test("isElement", function() {
403 | ok(!_.isElement('div'), 'strings are not dom elements');
404 | ok(_.isElement($('html')[0]), 'the html tag is a DOM element');
405 | ok(_.isElement(iElement), 'even from another frame');
406 | });
407 |
408 | test("isArguments", function() {
409 | var args = (function(){ return arguments; })(1, 2, 3);
410 | ok(!_.isArguments('string'), 'a string is not an arguments object');
411 | ok(!_.isArguments(_.isArguments), 'a function is not an arguments object');
412 | ok(_.isArguments(args), 'but the arguments object is an arguments object');
413 | ok(!_.isArguments(_.toArray(args)), 'but not when it\'s converted into an array');
414 | ok(!_.isArguments([1,2,3]), 'and not vanilla arrays.');
415 | ok(_.isArguments(iArguments), 'even from another frame');
416 | });
417 |
418 | test("isObject", function() {
419 | ok(_.isObject(arguments), 'the arguments object is object');
420 | ok(_.isObject([1, 2, 3]), 'and arrays');
421 | ok(_.isObject($('html')[0]), 'and DOM element');
422 | ok(_.isObject(iElement), 'even from another frame');
423 | ok(_.isObject(function () {}), 'and functions');
424 | ok(_.isObject(iFunction), 'even from another frame');
425 | ok(!_.isObject(null), 'but not null');
426 | ok(!_.isObject(undefined), 'and not undefined');
427 | ok(!_.isObject('string'), 'and not string');
428 | ok(!_.isObject(12), 'and not number');
429 | ok(!_.isObject(true), 'and not boolean');
430 | ok(_.isObject(new String('string')), 'but new String()');
431 | });
432 |
433 | test("isArray", function() {
434 | ok(!_.isArray(arguments), 'the arguments object is not an array');
435 | ok(_.isArray([1, 2, 3]), 'but arrays are');
436 | ok(_.isArray(iArray), 'even from another frame');
437 | });
438 |
439 | test("isString", function() {
440 | ok(!_.isString(document.body), 'the document body is not a string');
441 | ok(_.isString([1, 2, 3].join(', ')), 'but strings are');
442 | ok(_.isString(iString), 'even from another frame');
443 | });
444 |
445 | test("isNumber", function() {
446 | ok(!_.isNumber('string'), 'a string is not a number');
447 | ok(!_.isNumber(arguments), 'the arguments object is not a number');
448 | ok(!_.isNumber(undefined), 'undefined is not a number');
449 | ok(_.isNumber(3 * 4 - 7 / 10), 'but numbers are');
450 | ok(_.isNumber(NaN), 'NaN *is* a number');
451 | ok(_.isNumber(Infinity), 'Infinity is a number');
452 | ok(_.isNumber(iNumber), 'even from another frame');
453 | ok(!_.isNumber('1'), 'numeric strings are not numbers');
454 | });
455 |
456 | test("isBoolean", function() {
457 | ok(!_.isBoolean(2), 'a number is not a boolean');
458 | ok(!_.isBoolean("string"), 'a string is not a boolean');
459 | ok(!_.isBoolean("false"), 'the string "false" is not a boolean');
460 | ok(!_.isBoolean("true"), 'the string "true" is not a boolean');
461 | ok(!_.isBoolean(arguments), 'the arguments object is not a boolean');
462 | ok(!_.isBoolean(undefined), 'undefined is not a boolean');
463 | ok(!_.isBoolean(NaN), 'NaN is not a boolean');
464 | ok(!_.isBoolean(null), 'null is not a boolean');
465 | ok(_.isBoolean(true), 'but true is');
466 | ok(_.isBoolean(false), 'and so is false');
467 | ok(_.isBoolean(iBoolean), 'even from another frame');
468 | });
469 |
470 | test("isFunction", function() {
471 | ok(!_.isFunction([1, 2, 3]), 'arrays are not functions');
472 | ok(!_.isFunction('moe'), 'strings are not functions');
473 | ok(_.isFunction(_.isFunction), 'but functions are');
474 | ok(_.isFunction(iFunction), 'even from another frame');
475 | });
476 |
477 | test("isDate", function() {
478 | ok(!_.isDate(100), 'numbers are not dates');
479 | ok(!_.isDate({}), 'objects are not dates');
480 | ok(_.isDate(new Date()), 'but dates are');
481 | ok(_.isDate(iDate), 'even from another frame');
482 | });
483 |
484 | test("isRegExp", function() {
485 | ok(!_.isRegExp(_.identity), 'functions are not RegExps');
486 | ok(_.isRegExp(/identity/), 'but RegExps are');
487 | ok(_.isRegExp(iRegExp), 'even from another frame');
488 | });
489 |
490 | test("isFinite", function() {
491 | ok(!_.isFinite(undefined), 'undefined is not Finite');
492 | ok(!_.isFinite(null), 'null is not Finite');
493 | ok(!_.isFinite(NaN), 'NaN is not Finite');
494 | ok(!_.isFinite(Infinity), 'Infinity is not Finite');
495 | ok(!_.isFinite(-Infinity), '-Infinity is not Finite');
496 | ok(_.isFinite('12'), 'Numeric strings are numbers');
497 | ok(!_.isFinite('1a'), 'Non numeric strings are not numbers');
498 | ok(!_.isFinite(''), 'Empty strings are not numbers');
499 | var obj = new Number(5);
500 | ok(_.isFinite(obj), 'Number instances can be finite');
501 | ok(_.isFinite(0), '0 is Finite');
502 | ok(_.isFinite(123), 'Ints are Finite');
503 | ok(_.isFinite(-12.44), 'Floats are Finite');
504 | });
505 |
506 | test("isNaN", function() {
507 | ok(!_.isNaN(undefined), 'undefined is not NaN');
508 | ok(!_.isNaN(null), 'null is not NaN');
509 | ok(!_.isNaN(0), '0 is not NaN');
510 | ok(_.isNaN(NaN), 'but NaN is');
511 | ok(_.isNaN(iNaN), 'even from another frame');
512 | ok(_.isNaN(new Number(NaN)), 'wrapped NaN is still NaN');
513 | });
514 |
515 | test("isNull", function() {
516 | ok(!_.isNull(undefined), 'undefined is not null');
517 | ok(!_.isNull(NaN), 'NaN is not null');
518 | ok(_.isNull(null), 'but null is');
519 | ok(_.isNull(iNull), 'even from another frame');
520 | });
521 |
522 | test("isUndefined", function() {
523 | ok(!_.isUndefined(1), 'numbers are defined');
524 | ok(!_.isUndefined(null), 'null is defined');
525 | ok(!_.isUndefined(false), 'false is defined');
526 | ok(!_.isUndefined(NaN), 'NaN is defined');
527 | ok(_.isUndefined(), 'nothing is undefined');
528 | ok(_.isUndefined(undefined), 'undefined is undefined');
529 | ok(_.isUndefined(iUndefined), 'even from another frame');
530 | });
531 |
532 | if (window.ActiveXObject) {
533 | test("IE host objects", function() {
534 | var xml = new ActiveXObject("Msxml2.DOMDocument.3.0");
535 | ok(!_.isNumber(xml));
536 | ok(!_.isBoolean(xml));
537 | ok(!_.isNaN(xml));
538 | ok(!_.isFunction(xml));
539 | ok(!_.isNull(xml));
540 | ok(!_.isUndefined(xml));
541 | });
542 | }
543 |
544 | test("tap", function() {
545 | var intercepted = null;
546 | var interceptor = function(obj) { intercepted = obj; };
547 | var returned = _.tap(1, interceptor);
548 | equal(intercepted, 1, "passes tapped object to interceptor");
549 | equal(returned, 1, "returns tapped object");
550 |
551 | returned = _([1,2,3]).chain().
552 | map(function(n){ return n * 2; }).
553 | max().
554 | tap(interceptor).
555 | value();
556 | ok(returned == 6 && intercepted == 6, 'can use tapped objects in a chain');
557 | });
558 | });
559 |
--------------------------------------------------------------------------------
/components/underscore/test/speed.js:
--------------------------------------------------------------------------------
1 | (function() {
2 |
3 | var numbers = [];
4 | for (var i=0; i<1000; i++) numbers.push(i);
5 | var objects = _.map(numbers, function(n){ return {num : n}; });
6 | var randomized = _.sortBy(numbers, function(){ return Math.random(); });
7 | var deep = _.map(_.range(100), function() { return _.range(1000); });
8 |
9 | JSLitmus.test('_.each()', function() {
10 | var timesTwo = [];
11 | _.each(numbers, function(num){ timesTwo.push(num * 2); });
12 | return timesTwo;
13 | });
14 |
15 | JSLitmus.test('_(list).each()', function() {
16 | var timesTwo = [];
17 | _(numbers).each(function(num){ timesTwo.push(num * 2); });
18 | return timesTwo;
19 | });
20 |
21 | JSLitmus.test('jQuery.each()', function() {
22 | var timesTwo = [];
23 | jQuery.each(numbers, function(){ timesTwo.push(this * 2); });
24 | return timesTwo;
25 | });
26 |
27 | JSLitmus.test('_.map()', function() {
28 | return _.map(objects, function(obj){ return obj.num; });
29 | });
30 |
31 | JSLitmus.test('jQuery.map()', function() {
32 | return jQuery.map(objects, function(obj){ return obj.num; });
33 | });
34 |
35 | JSLitmus.test('_.pluck()', function() {
36 | return _.pluck(objects, 'num');
37 | });
38 |
39 | JSLitmus.test('_.uniq()', function() {
40 | return _.uniq(randomized);
41 | });
42 |
43 | JSLitmus.test('_.uniq() (sorted)', function() {
44 | return _.uniq(numbers, true);
45 | });
46 |
47 | JSLitmus.test('_.sortBy()', function() {
48 | return _.sortBy(numbers, function(num){ return -num; });
49 | });
50 |
51 | JSLitmus.test('_.isEqual()', function() {
52 | return _.isEqual(numbers, randomized);
53 | });
54 |
55 | JSLitmus.test('_.keys()', function() {
56 | return _.keys(objects);
57 | });
58 |
59 | JSLitmus.test('_.values()', function() {
60 | return _.values(objects);
61 | });
62 |
63 | JSLitmus.test('_.intersection()', function() {
64 | return _.intersection(numbers, randomized);
65 | });
66 |
67 | JSLitmus.test('_.range()', function() {
68 | return _.range(1000);
69 | });
70 |
71 | JSLitmus.test('_.flatten()', function() {
72 | return _.flatten(deep);
73 | });
74 |
75 | })();
76 |
--------------------------------------------------------------------------------
/components/underscore/test/utility.js:
--------------------------------------------------------------------------------
1 | $(document).ready(function() {
2 |
3 | var templateSettings;
4 |
5 | module("Utility", {
6 |
7 | setup: function() {
8 | templateSettings = _.clone(_.templateSettings);
9 | },
10 |
11 | teardown: function() {
12 | _.templateSettings = templateSettings;
13 | }
14 |
15 | });
16 |
17 | test("#750 - Return _ instance.", 2, function() {
18 | var instance = _([]);
19 | ok(_(instance) === instance);
20 | ok(new _(instance) === instance);
21 | });
22 |
23 | test("identity", function() {
24 | var moe = {name : 'moe'};
25 | equal(_.identity(moe), moe, 'moe is the same as his identity');
26 | });
27 |
28 | test("uniqueId", function() {
29 | var ids = [], i = 0;
30 | while(i++ < 100) ids.push(_.uniqueId());
31 | equal(_.uniq(ids).length, ids.length, 'can generate a globally-unique stream of ids');
32 | });
33 |
34 | test("times", function() {
35 | var vals = [];
36 | _.times(3, function (i) { vals.push(i); });
37 | ok(_.isEqual(vals, [0,1,2]), "is 0 indexed");
38 | //
39 | vals = [];
40 | _(3).times(function(i) { vals.push(i); });
41 | ok(_.isEqual(vals, [0,1,2]), "works as a wrapper");
42 | // collects return values
43 | ok(_.isEqual([0, 1, 2], _.times(3, function(i) { return i; })), "collects return values");
44 | });
45 |
46 | test("mixin", function() {
47 | _.mixin({
48 | myReverse: function(string) {
49 | return string.split('').reverse().join('');
50 | }
51 | });
52 | equal(_.myReverse('panacea'), 'aecanap', 'mixed in a function to _');
53 | equal(_('champ').myReverse(), 'pmahc', 'mixed in a function to the OOP wrapper');
54 | });
55 |
56 | test("_.escape", function() {
57 | equal(_.escape("Curly & Moe"), "Curly & Moe");
58 | equal(_.escape("Curly & Moe"), "Curly & Moe");
59 | equal(_.escape(null), '');
60 | });
61 |
62 | test("_.unescape", function() {
63 | var string = "Curly & Moe";
64 | equal(_.unescape("Curly & Moe"), string);
65 | equal(_.unescape("Curly & Moe"), "Curly & Moe");
66 | equal(_.unescape(null), '');
67 | equal(_.unescape(_.escape(string)), string);
68 | });
69 |
70 | test("template", function() {
71 | var basicTemplate = _.template("<%= thing %> is gettin' on my noives!");
72 | var result = basicTemplate({thing : 'This'});
73 | equal(result, "This is gettin' on my noives!", 'can do basic attribute interpolation');
74 |
75 | var sansSemicolonTemplate = _.template("A <% this %> B");
76 | equal(sansSemicolonTemplate(), "A B");
77 |
78 | var backslashTemplate = _.template("<%= thing %> is \\ridanculous");
79 | equal(backslashTemplate({thing: 'This'}), "This is \\ridanculous");
80 |
81 | var escapeTemplate = _.template('<%= a ? "checked=\\"checked\\"" : "" %>');
82 | equal(escapeTemplate({a: true}), 'checked="checked"', 'can handle slash escapes in interpolations.');
83 |
84 | var fancyTemplate = _.template("<% \
85 | for (key in people) { \
86 | %>- <%= people[key] %>
<% } %>
");
87 | result = fancyTemplate({people : {moe : "Moe", larry : "Larry", curly : "Curly"}});
88 | equal(result, "", 'can run arbitrary javascript in templates');
89 |
90 | var escapedCharsInJavascriptTemplate = _.template("<% _.each(numbers.split('\\n'), function(item) { %>- <%= item %>
<% }) %>
");
91 | result = escapedCharsInJavascriptTemplate({numbers: "one\ntwo\nthree\nfour"});
92 | equal(result, "", 'Can use escaped characters (e.g. \\n) in Javascript');
93 |
94 | var namespaceCollisionTemplate = _.template("<%= pageCount %> <%= thumbnails[pageCount] %> <% _.each(thumbnails, function(p) { %>\">
<% }); %>");
95 | result = namespaceCollisionTemplate({
96 | pageCount: 3,
97 | thumbnails: {
98 | 1: "p1-thumbnail.gif",
99 | 2: "p2-thumbnail.gif",
100 | 3: "p3-thumbnail.gif"
101 | }
102 | });
103 | equal(result, "3 p3-thumbnail.gif ");
104 |
105 | var noInterpolateTemplate = _.template("Just some text. Hey, I know this is silly but it aids consistency.
Just some text. Hey, I know this is silly but it aids consistency.