RubyGems - cssesc-source - Versions diffs - 0.1.0 → 1.0.1 - Mend

cssesc-source 0.1.0 → 1.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (908) hide show

data/vendor/node_modules/grunt/node_modules/underscore.string/test/strings_standalone.js DELETED Viewed

@@ -1,12 +0,0 @@
-$(document).ready(function() {
-  module("String extensions");
-  test("underscore not included", function() {
-    raises(function() { _("foo") }, /TypeError/);
-  });
-  test("provides standalone functions", function() {
-    equals(typeof _.str.trim, "function");
-  });
-});

data/vendor/node_modules/grunt/node_modules/underscore.string/test/test.html DELETED Viewed

@@ -1,31 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-<head>
-  <meta charset="utf-8">
-  <title>Underscore.strings Test Suite</title>
-  <link rel="stylesheet" href="test_underscore/vendor/qunit.css" type="text/css" media="screen" />
-  <script type="text/javascript" src="test_underscore/vendor/jquery.js"></script>
-  <script type="text/javascript" src="test_underscore/vendor/qunit.js"></script>
-  <script type="text/javascript" src="test_underscore/vendor/jslitmus.js"></script>
-  <script type="text/javascript" src="underscore.js"></script>
-  <script type="text/javascript" src="../lib/underscore.string.js"></script>
-  <script type="text/javascript" src="strings.js"></script>
-  <script type="text/javascript" src="speed.js"></script>
-</head>
-<body>
-  <h1 id="qunit-header">Underscore.string Test Suite</h1>
-  <h2 id="qunit-banner"></h2>
-  <h2 id="qunit-userAgent"></h2>
-  <ol id="qunit-tests"></ol>
-  <br />
-  <h1 class="qunit-header">Underscore.string Speed Suite</h1>
-  <!-- <h2 class="qunit-userAgent">
-    A representative sample of the functions are benchmarked here, to provide
-    a sense of how fast they might run in different browsers.
-    Each iteration runs on an array of 1000 elements.<br /><br />
-    For example, the 'intersect' test measures the number of times you can
-    find the intersection of two thousand-element arrays in one second.
-  </h2> -->
-  <br />
-</body>
-</html>

data/vendor/node_modules/grunt/node_modules/underscore.string/test/test_standalone.html DELETED Viewed

@@ -1,18 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-<head>
-  <title>Underscore.strings Test Suite</title>
-  <link rel="stylesheet" href="test_underscore/vendor/qunit.css" type="text/css" media="screen" />
-  <script type="text/javascript" src="test_underscore/vendor/jquery.js"></script>
-  <script type="text/javascript" src="test_underscore/vendor/qunit.js"></script>
-  <script type="text/javascript" src="../lib/underscore.string.js"></script>
-  <script type="text/javascript" src="strings_standalone.js"></script>
-</head>
-<body>
-  <h1 id="qunit-header">Underscore.string Test Suite</h1>
-  <h2 id="qunit-banner"></h2>
-  <h2 id="qunit-userAgent"></h2>
-  <ol id="qunit-tests"></ol>
-</body>
-</html>

data/vendor/node_modules/grunt/node_modules/underscore.string/test/test_underscore/arrays.js DELETED Viewed

@@ -1,166 +0,0 @@
-$(document).ready(function() {
-  module("Arrays");
-  test("arrays: first", function() {
-    equals(_.first([1,2,3]), 1, 'can pull out the first element of an array');
-    equals(_([1, 2, 3]).first(), 1, 'can perform OO-style "first()"');
-    equals(_.first([1,2,3], 0).join(', '), "", 'can pass an index to first');
-    equals(_.first([1,2,3], 2).join(', '), '1, 2', 'can pass an index to first');
-    equals(_.first([1,2,3], 5).join(', '), '1, 2, 3', 'can pass an index to first');
-    var result = (function(){ return _.first(arguments); })(4, 3, 2, 1);
-    equals(result, 4, 'works on an arguments object.');
-    result = _.map([[1,2,3],[1,2,3]], _.first);
-    equals(result.join(','), '1,1', 'works well with _.map');
-  });
-  test("arrays: rest", function() {
-    var numbers = [1, 2, 3, 4];
-    equals(_.rest(numbers).join(", "), "2, 3, 4", 'working rest()');
-    equals(_.rest(numbers, 0).join(", "), "1, 2, 3, 4", 'working rest(0)');
-    equals(_.rest(numbers, 2).join(', '), '3, 4', 'rest can take an index');
-    var result = (function(){ return _(arguments).tail(); })(1, 2, 3, 4);
-    equals(result.join(', '), '2, 3, 4', 'aliased as tail and works on arguments object');
-    result = _.map([[1,2,3],[1,2,3]], _.rest);
-    equals(_.flatten(result).join(','), '2,3,2,3', 'works well with _.map');
-  });
-  test("arrays: initial", function() {
-    equals(_.initial([1,2,3,4,5]).join(", "), "1, 2, 3, 4", 'working initial()');
-    equals(_.initial([1,2,3,4],2).join(", "), "1, 2", 'initial can take an index');
-    var result = (function(){ return _(arguments).initial(); })(1, 2, 3, 4);
-    equals(result.join(", "), "1, 2, 3", 'initial works on arguments object');
-    result = _.map([[1,2,3],[1,2,3]], _.initial);
-    equals(_.flatten(result).join(','), '1,2,1,2', 'initial works with _.map');
-  });
-  test("arrays: last", function() {
-    equals(_.last([1,2,3]), 3, 'can pull out the last element of an array');
-    equals(_.last([1,2,3], 0).join(', '), "", 'can pass an index to last');
-    equals(_.last([1,2,3], 2).join(', '), '2, 3', 'can pass an index to last');
-    equals(_.last([1,2,3], 5).join(', '), '1, 2, 3', 'can pass an index to last');
-    var result = (function(){ return _(arguments).last(); })(1, 2, 3, 4);
-    equals(result, 4, 'works on an arguments object');
-    result = _.map([[1,2,3],[1,2,3]], _.last);
-    equals(result.join(','), '3,3', 'works well with _.map');
-  });
-  test("arrays: compact", function() {
-    equals(_.compact([0, 1, false, 2, false, 3]).length, 3, 'can trim out all falsy values');
-    var result = (function(){ return _(arguments).compact().length; })(0, 1, false, 2, false, 3);
-    equals(result, 3, 'works on an arguments object');
-  });
-  test("arrays: flatten", function() {
-    if (window.JSON) {
-      var list = [1, [2], [3, [[[4]]]]];
-      equals(JSON.stringify(_.flatten(list)), '[1,2,3,4]', 'can flatten nested arrays');
-      equals(JSON.stringify(_.flatten(list, true)), '[1,2,3,[[[4]]]]', 'can shallowly flatten nested arrays');
-      var result = (function(){ return _.flatten(arguments); })(1, [2], [3, [[[4]]]]);
-      equals(JSON.stringify(result), '[1,2,3,4]', 'works on an arguments object');
-    }
-  });
-  test("arrays: without", function() {
-    var list = [1, 2, 1, 0, 3, 1, 4];
-    equals(_.without(list, 0, 1).join(', '), '2, 3, 4', 'can remove all instances of an object');
-    var result = (function(){ return _.without(arguments, 0, 1); })(1, 2, 1, 0, 3, 1, 4);
-    equals(result.join(', '), '2, 3, 4', 'works on an arguments object');
-    var list = [{one : 1}, {two : 2}];
-    ok(_.without(list, {one : 1}).length == 2, 'uses real object identity for comparisons.');
-    ok(_.without(list, list[0]).length == 1, 'ditto.');
-  });
-  test("arrays: uniq", function() {
-    var list = [1, 2, 1, 3, 1, 4];
-    equals(_.uniq(list).join(', '), '1, 2, 3, 4', 'can find the unique values of an unsorted array');
-    var list = [1, 1, 1, 2, 2, 3];
-    equals(_.uniq(list, true).join(', '), '1, 2, 3', 'can find the unique values of a sorted array faster');
-    var list = [{name:'moe'}, {name:'curly'}, {name:'larry'}, {name:'curly'}];
-    var iterator = function(value) { return value.name; };
-    equals(_.map(_.uniq(list, false, iterator), iterator).join(', '), 'moe, curly, larry', 'can find the unique values of an array using a custom iterator');
-    var iterator = function(value) { return value +1; };
-    var list = [1, 2, 2, 3, 4, 4];
-    equals(_.uniq(list, true, iterator).join(', '), '1, 2, 3, 4', 'iterator works with sorted array');
-    var result = (function(){ return _.uniq(arguments); })(1, 2, 1, 3, 1, 4);
-    equals(result.join(', '), '1, 2, 3, 4', 'works on an arguments object');
-  });
-  test("arrays: intersection", function() {
-    var stooges = ['moe', 'curly', 'larry'], leaders = ['moe', 'groucho'];
-    equals(_.intersection(stooges, leaders).join(''), 'moe', 'can take the set intersection of two arrays');
-    equals(_(stooges).intersection(leaders).join(''), 'moe', 'can perform an OO-style intersection');
-    var result = (function(){ return _.intersection(arguments, leaders); })('moe', 'curly', 'larry');
-    equals(result.join(''), 'moe', 'works on an arguments object');
-  });
-  test("arrays: union", function() {
-    var result = _.union([1, 2, 3], [2, 30, 1], [1, 40]);
-    equals(result.join(' '), '1 2 3 30 40', 'takes the union of a list of arrays');
-    var result = _.union([1, 2, 3], [2, 30, 1], [1, 40, [1]]);
-    equals(result.join(' '), '1 2 3 30 40 1', 'takes the union of a list of nested arrays');
-  });
-  test("arrays: difference", function() {
-    var result = _.difference([1, 2, 3], [2, 30, 40]);
-    equals(result.join(' '), '1 3', 'takes the difference of two arrays');
-    var result = _.difference([1, 2, 3, 4], [2, 30, 40], [1, 11, 111]);
-    equals(result.join(' '), '3 4', 'takes the difference of three arrays');
-  });
-  test('arrays: zip', function() {
-    var names = ['moe', 'larry', 'curly'], ages = [30, 40, 50], leaders = [true];
-    var stooges = _.zip(names, ages, leaders);
-    equals(String(stooges), 'moe,30,true,larry,40,,curly,50,', 'zipped together arrays of different lengths');
-  });
-  test("arrays: indexOf", function() {
-    var numbers = [1, 2, 3];
-    numbers.indexOf = null;
-    equals(_.indexOf(numbers, 2), 1, 'can compute indexOf, even without the native function');
-    var result = (function(){ return _.indexOf(arguments, 2); })(1, 2, 3);
-    equals(result, 1, 'works on an arguments object');
-    equals(_.indexOf(null, 2), -1, 'handles nulls properly');
-    var numbers = [10, 20, 30, 40, 50], num = 35;
-    var index = _.indexOf(numbers, num, true);
-    equals(index, -1, '35 is not in the list');
-    numbers = [10, 20, 30, 40, 50]; num = 40;
-    index = _.indexOf(numbers, num, true);
-    equals(index, 3, '40 is in the list');
-    numbers = [1, 40, 40, 40, 40, 40, 40, 40, 50, 60, 70]; num = 40;
-    index = _.indexOf(numbers, num, true);
-    equals(index, 1, '40 is in the list');
-  });
-  test("arrays: lastIndexOf", function() {
-    var numbers = [1, 0, 1, 0, 0, 1, 0, 0, 0];
-    numbers.lastIndexOf = null;
-    equals(_.lastIndexOf(numbers, 1), 5, 'can compute lastIndexOf, even without the native function');
-    equals(_.lastIndexOf(numbers, 0), 8, 'lastIndexOf the other element');
-    var result = (function(){ return _.lastIndexOf(arguments, 1); })(1, 0, 1, 0, 0, 1, 0, 0, 0);
-    equals(result, 5, 'works on an arguments object');
-    equals(_.indexOf(null, 2), -1, 'handles nulls properly');
-  });
-  test("arrays: range", function() {
-    equals(_.range(0).join(''), '', 'range with 0 as a first argument generates an empty array');
-    equals(_.range(4).join(' '), '0 1 2 3', 'range with a single positive argument generates an array of elements 0,1,2,...,n-1');
-    equals(_.range(5, 8).join(' '), '5 6 7', 'range with two arguments a &amp; b, a&lt;b generates an array of elements a,a+1,a+2,...,b-2,b-1');
-    equals(_.range(8, 5).join(''), '', 'range with two arguments a &amp; b, b&lt;a generates an empty array');
-    equals(_.range(3, 10, 3).join(' '), '3 6 9', 'range with three arguments a &amp; b &amp; c, c &lt; b-a, a &lt; b generates an array of elements a,a+c,a+2c,...,b - (multiplier of a) &lt; c');
-    equals(_.range(3, 10, 15).join(''), '3', 'range with three arguments a &amp; b &amp; c, c &gt; b-a, a &lt; b generates an array with a single element, equal to a');
-    equals(_.range(12, 7, -2).join(' '), '12 10 8', 'range with three arguments a &amp; b &amp; c, a &gt; b, c &lt; 0 generates an array of elements a,a-c,a-2c and ends with the number not less than b');
-    equals(_.range(0, -10, -1).join(' '), '0 -1 -2 -3 -4 -5 -6 -7 -8 -9', 'final example in the Python docs');
-  });
-});

data/vendor/node_modules/grunt/node_modules/underscore.string/test/test_underscore/chaining.js DELETED Viewed

@@ -1,59 +0,0 @@
-$(document).ready(function() {
-  module("Chaining");
-  test("chaining: map/flatten/reduce", function() {
-    var lyrics = [
-      "I'm a lumberjack and I'm okay",
-      "I sleep all night and I work all day",
-      "He's a lumberjack and he's okay",
-      "He sleeps all night and he works all day"
-    ];
-    var counts = _(lyrics).chain()
-      .map(function(line) { return line.split(''); })
-      .flatten()
-      .reduce(function(hash, l) {
-        hash[l] = hash[l] || 0;
-        hash[l]++;
-        return hash;
-    }, {}).value();
-    ok(counts['a'] == 16 && counts['e'] == 10, 'counted all the letters in the song');
-  });
-  test("chaining: select/reject/sortBy", function() {
-    var numbers = [1,2,3,4,5,6,7,8,9,10];
-    numbers = _(numbers).chain().select(function(n) {
-      return n % 2 == 0;
-    }).reject(function(n) {
-      return n % 4 == 0;
-    }).sortBy(function(n) {
-      return -n;
-    }).value();
-    equals(numbers.join(', '), "10, 6, 2", "filtered and reversed the numbers");
-  });
-  test("chaining: select/reject/sortBy in functional style", function() {
-    var numbers = [1,2,3,4,5,6,7,8,9,10];
-    numbers = _.chain(numbers).select(function(n) {
-      return n % 2 == 0;
-    }).reject(function(n) {
-      return n % 4 == 0;
-    }).sortBy(function(n) {
-      return -n;
-    }).value();
-    equals(numbers.join(', '), "10, 6, 2", "filtered and reversed the numbers");
-  });
-  test("chaining: reverse/concat/unshift/pop/map", function() {
-    var numbers = [1,2,3,4,5];
-    numbers = _(numbers).chain()
-      .reverse()
-      .concat([5, 5, 5])
-      .unshift(17)
-      .pop()
-      .map(function(n){ return n * 2; })
-      .value();
-    equals(numbers.join(', '), "34, 10, 8, 6, 4, 2, 10, 10", 'can chain together array functions.');
-  });
-});

data/vendor/node_modules/grunt/node_modules/underscore.string/test/test_underscore/collections.js DELETED Viewed

@@ -1,270 +0,0 @@
-$(document).ready(function() {
-  module("Collections");
-  test("collections: each", function() {
-    _.each([1, 2, 3], function(num, i) {
-      equals(num, i + 1, 'each iterators provide value and iteration count');
-    });
-    var answers = [];
-    _.each([1, 2, 3], function(num){ answers.push(num * this.multiplier);}, {multiplier : 5});
-    equals(answers.join(', '), '5, 10, 15', 'context object property accessed');
-    answers = [];
-    _.forEach([1, 2, 3], function(num){ answers.push(num); });
-    equals(answers.join(', '), '1, 2, 3', 'aliased as "forEach"');
-    answers = [];
-    var obj = {one : 1, two : 2, three : 3};
-    obj.constructor.prototype.four = 4;
-    _.each(obj, function(value, key){ answers.push(key); });
-    equals(answers.join(", "), 'one, two, three', 'iterating over objects works, and ignores the object prototype.');
-    delete obj.constructor.prototype.four;
-    answer = null;
-    _.each([1, 2, 3], function(num, index, arr){ if (_.include(arr, num)) answer = true; });
-    ok(answer, 'can reference the original collection from inside the iterator');
-    answers = 0;
-    _.each(null, function(){ ++answers; });
-    equals(answers, 0, 'handles a null properly');
-  });
-  test('collections: map', function() {
-    var doubled = _.map([1, 2, 3], function(num){ return num * 2; });
-    equals(doubled.join(', '), '2, 4, 6', 'doubled numbers');
-    doubled = _.collect([1, 2, 3], function(num){ return num * 2; });
-    equals(doubled.join(', '), '2, 4, 6', 'aliased as "collect"');
-    var tripled = _.map([1, 2, 3], function(num){ return num * this.multiplier; }, {multiplier : 3});
-    equals(tripled.join(', '), '3, 6, 9', 'tripled numbers with context');
-    var doubled = _([1, 2, 3]).map(function(num){ return num * 2; });
-    equals(doubled.join(', '), '2, 4, 6', 'OO-style doubled numbers');
-    var ids = _.map($('div.underscore-test').children(), function(n){ return n.id; });
-    ok(_.include(ids, 'qunit-header'), 'can use collection methods on NodeLists');
-    var ids = _.map(document.images, function(n){ return n.id; });
-    ok(ids[0] == 'chart_image', 'can use collection methods on HTMLCollections');
-    var ifnull = _.map(null, function(){});
-    ok(_.isArray(ifnull) && ifnull.length === 0, 'handles a null properly');
-    var length = _.map(Array(2), function(v) { return v; }).length;
-    equals(length, 2, "can preserve a sparse array's length");
-  });
-  test('collections: reduce', function() {
-    var sum = _.reduce([1, 2, 3], function(sum, num){ return sum + num; }, 0);
-    equals(sum, 6, 'can sum up an array');
-    var context = {multiplier : 3};
-    sum = _.reduce([1, 2, 3], function(sum, num){ return sum + num * this.multiplier; }, 0, context);
-    equals(sum, 18, 'can reduce with a context object');
-    sum = _.inject([1, 2, 3], function(sum, num){ return sum + num; }, 0);
-    equals(sum, 6, 'aliased as "inject"');
-    sum = _([1, 2, 3]).reduce(function(sum, num){ return sum + num; }, 0);
-    equals(sum, 6, 'OO-style reduce');
-    var sum = _.reduce([1, 2, 3], function(sum, num){ return sum + num; });
-    equals(sum, 6, 'default initial value');
-    var ifnull;
-    try {
-      _.reduce(null, function(){});
-    } catch (ex) {
-      ifnull = ex;
-    }
-    ok(ifnull instanceof TypeError, 'handles a null (without inital value) properly');
-    ok(_.reduce(null, function(){}, 138) === 138, 'handles a null (with initial value) properly');
-    equals(_.reduce([], function(){}, undefined), undefined, 'undefined can be passed as a special case');
-    raises(function() { _.reduce([], function(){}); }, TypeError, 'throws an error for empty arrays with no initial value');
-    var sparseArray = [];
-    sparseArray[0] = 20;
-    sparseArray[2] = -5;
-    equals(_.reduce(sparseArray, function(a, b){ return a - b; }), 25, 'initially-sparse arrays with no memo');
-  });
-  test('collections: reduceRight', function() {
-    var list = _.reduceRight(["foo", "bar", "baz"], function(memo, str){ return memo + str; }, '');
-    equals(list, 'bazbarfoo', 'can perform right folds');
-    var list = _.foldr(["foo", "bar", "baz"], function(memo, str){ return memo + str; }, '');
-    equals(list, 'bazbarfoo', 'aliased as "foldr"');
-    var list = _.foldr(["foo", "bar", "baz"], function(memo, str){ return memo + str; });
-    equals(list, 'bazbarfoo', 'default initial value');
-    var ifnull;
-    try {
-      _.reduceRight(null, function(){});
-    } catch (ex) {
-      ifnull = ex;
-    }
-    ok(ifnull instanceof TypeError, 'handles a null (without inital value) properly');
-    ok(_.reduceRight(null, function(){}, 138) === 138, 'handles a null (with initial value) properly');
-    equals(_.reduceRight([], function(){}, undefined), undefined, 'undefined can be passed as a special case');
-    raises(function() { _.reduceRight([], function(){}); }, TypeError, 'throws an error for empty arrays with no initial value');
-    var sparseArray = [];
-    sparseArray[0] = 20;
-    sparseArray[2] = -5;
-    equals(_.reduceRight(sparseArray, function(a, b){ return a - b; }), -25, 'initially-sparse arrays with no memo');
-  });
-  test('collections: detect', function() {
-    var result = _.detect([1, 2, 3], function(num){ return num * 2 == 4; });
-    equals(result, 2, 'found the first "2" and broke the loop');
-  });
-  test('collections: select', function() {
-    var evens = _.select([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
-    equals(evens.join(', '), '2, 4, 6', 'selected each even number');
-    evens = _.filter([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
-    equals(evens.join(', '), '2, 4, 6', 'aliased as "filter"');
-  });
-  test('collections: reject', function() {
-    var odds = _.reject([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
-    equals(odds.join(', '), '1, 3, 5', 'rejected each even number');
-  });
-  test('collections: all', function() {
-    ok(_.all([], _.identity), 'the empty set');
-    ok(_.all([true, true, true], _.identity), 'all true values');
-    ok(!_.all([true, false, true], _.identity), 'one false value');
-    ok(_.all([0, 10, 28], function(num){ return num % 2 == 0; }), 'even numbers');
-    ok(!_.all([0, 11, 28], function(num){ return num % 2 == 0; }), 'an odd number');
-    ok(_.every([true, true, true], _.identity), 'aliased as "every"');
-  });
-  test('collections: any', function() {
-    var nativeSome = Array.prototype.some;
-    Array.prototype.some = null;
-    ok(!_.any([]), 'the empty set');
-    ok(!_.any([false, false, false]), 'all false values');
-    ok(_.any([false, false, true]), 'one true value');
-    ok(_.any([null, 0, 'yes', false]), 'a string');
-    ok(!_.any([null, 0, '', false]), 'falsy values');
-    ok(!_.any([1, 11, 29], function(num){ return num % 2 == 0; }), 'all odd numbers');
-    ok(_.any([1, 10, 29], function(num){ return num % 2 == 0; }), 'an even number');
-    ok(_.some([false, false, true]), 'aliased as "some"');
-    Array.prototype.some = nativeSome;
-  });
-  test('collections: include', function() {
-    ok(_.include([1,2,3], 2), 'two is in the array');
-    ok(!_.include([1,3,9], 2), 'two is not in the array');
-    ok(_.contains({moe:1, larry:3, curly:9}, 3) === true, '_.include on objects checks their values');
-    ok(_([1,2,3]).include(2), 'OO-style include');
-  });
-  test('collections: invoke', function() {
-    var list = [[5, 1, 7], [3, 2, 1]];
-    var result = _.invoke(list, 'sort');
-    equals(result[0].join(', '), '1, 5, 7', 'first array sorted');
-    equals(result[1].join(', '), '1, 2, 3', 'second array sorted');
-  });
-  test('collections: invoke w/ function reference', function() {
-    var list = [[5, 1, 7], [3, 2, 1]];
-    var result = _.invoke(list, Array.prototype.sort);
-    equals(result[0].join(', '), '1, 5, 7', 'first array sorted');
-    equals(result[1].join(', '), '1, 2, 3', 'second array sorted');
-  });
-  // Relevant when using ClojureScript
-  test('collections: invoke when strings have a call method', function() {
-    String.prototype.call = function(){return 42;}
-    var list = [[5, 1, 7], [3, 2, 1]];
-    var s = "foo";
-    equals(s.call(), 42, "call function exists");
-    var result = _.invoke(list, 'sort');
-    equals(result[0].join(', '), '1, 5, 7', 'first array sorted');
-    equals(result[1].join(', '), '1, 2, 3', 'second array sorted');
-    delete String.prototype.call;
-    equals(s.call, undefined, "call function removed");
-  });
-  test('collections: pluck', function() {
-    var people = [{name : 'moe', age : 30}, {name : 'curly', age : 50}];
-    equals(_.pluck(people, 'name').join(', '), 'moe, curly', 'pulls names out of objects');
-  });
-  test('collections: max', function() {
-    equals(3, _.max([1, 2, 3]), 'can perform a regular Math.max');
-    var neg = _.max([1, 2, 3], function(num){ return -num; });
-    equals(neg, 1, 'can perform a computation-based max');
-    equals(-Infinity, _.max({}), 'Maximum value of an empty object');
-    equals(-Infinity, _.max([]), 'Maximum value of an empty array');
-  });
-  test('collections: min', function() {
-    equals(1, _.min([1, 2, 3]), 'can perform a regular Math.min');
-    var neg = _.min([1, 2, 3], function(num){ return -num; });
-    equals(neg, 3, 'can perform a computation-based min');
-    equals(Infinity, _.min({}), 'Minimum value of an empty object');
-    equals(Infinity, _.min([]), 'Minimum value of an empty array');
-  });
-  test('collections: sortBy', function() {
-    var people = [{name : 'curly', age : 50}, {name : 'moe', age : 30}];
-    people = _.sortBy(people, function(person){ return person.age; });
-    equals(_.pluck(people, 'name').join(', '), 'moe, curly', 'stooges sorted by age');
-  });
-  test('collections: groupBy', function() {
-    var parity = _.groupBy([1, 2, 3, 4, 5, 6], function(num){ return num % 2; });
-    ok('0' in parity && '1' in parity, 'created a group for each value');
-    equals(parity[0].join(', '), '2, 4, 6', 'put each even number in the right group');
-    var list = ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"];
-    var grouped = _.groupBy(list, 'length');
-    equals(grouped['3'].join(' '), 'one two six ten');
-    equals(grouped['4'].join(' '), 'four five nine');
-    equals(grouped['5'].join(' '), 'three seven eight');
-  });
-  test('collections: sortedIndex', function() {
-    var numbers = [10, 20, 30, 40, 50], num = 35;
-    var index = _.sortedIndex(numbers, num);
-    equals(index, 3, '35 should be inserted at index 3');
-  });
-  test('collections: shuffle', function() {
-    var numbers = _.range(10);
-	var shuffled = _.shuffle(numbers).sort();
-	notStrictEqual(numbers, shuffled, 'original object is unmodified');
-    equals(shuffled.join(','), numbers.join(','), 'contains the same members before and after shuffle');
-  });
-  test('collections: toArray', function() {
-    ok(!_.isArray(arguments), 'arguments object is not an array');
-    ok(_.isArray(_.toArray(arguments)), 'arguments object converted into array');
-    var a = [1,2,3];
-    ok(_.toArray(a) !== a, 'array is cloned');
-    equals(_.toArray(a).join(', '), '1, 2, 3', 'cloned array contains same elements');
-    var numbers = _.toArray({one : 1, two : 2, three : 3});
-    equals(numbers.join(', '), '1, 2, 3', 'object flattened into array');
-  });
-  test('collections: size', function() {
-    equals(_.size({one : 1, two : 2, three : 3}), 3, 'can compute the size of an object');
-  });
-});