anchor.diff:  	
   	public void function testDifference() {
   	    var result = _.difference([1, 2, 3], [2, 30, 40]);
  -	    assertEquals(result, [1, 3], 'takes the difference of two arrays');
  +	    assertEquals([1, 3], result, 'takes the difference of two arrays');
   
   	    var result = _.difference([1, 2, 3, 4], [[2, 30, 40], [1, 11, 111]]);
  -	    assertEquals(result, [3, 4], 'takes the difference of three arrays');
  +	    assertEquals([3, 4], result, 'takes the difference of three arrays');
   	}
   	
   	public void function testZip() {
  
positive.code: 	    list[33] = "hi";
  
  	    var result = _.uniq(list, true);
  		assertEquals(result, [2, 5, 8, "hi"], "Works with sorted sparse arrays where `undefined` elements are elided");
  		assertEquals(arrayLen(result), 4, "The resulting array should not be sparse");
  	}
  	
  	public void function testIntersection() {
  	    var stooges = ['moe', 'curly', 'larry'];
  	    var leaders = ['moe', 'groucho'];
  	    assertEquals(_.intersection(stooges, leaders), ['moe'], 'can take the set intersection of two arrays');
  	    // assertEquals(_(stooges).intersection(leaders).join(''), 'moe', 'can perform an OO-style intersection');
  	    // var result = (function(){ return _.intersection(arguments, leaders); })('moe', 'curly', 'larry');
  	    // equal(result.join(''), 'moe', 'works on an arguments object');
  	}
  	
  	public void function testUnion() {
  
negative.code: component extends="mxunit.framework.TestCase" {
  	public void function testFirst() {
  	    var firstWrapper = function (x) {return _.first(x);};
  	    assertEquals(1, _.first([1,2,3]), 'can pull out the first element of an array');
  	    // assertEquals(_([1, 2, 3]).first(), 1, 'can perform OO-style "first()"');
  	    assertEquals([],        _.first([1,2,3], 0), 'can pass an index to first');
  	    assertEquals([1, 2],    _.first([1,2,3], 2), 'can pass an index to first');
  	    assertEquals([1, 2, 3], _.first([1,2,3], 5), 'can pass an index to first');
  	    var result = _.map([[1,2,3], [1,2,3]], firstWrapper);
  	    assertEquals([1,1], result, 'works well with _.map');
  	    result = function() { return _.take([1,2,3], 2); };
  	    assertEquals([1,2], result(), 'aliased as take');
  	    result = function() { return _.head([1,2,3], 2); };
  	    assertEquals([1,2], result(), 'aliased as head');
  	}
  	
  	public void function testRest() {
  		var numbers = [1, 2, 3, 4];
  		var restWrapper = function (x) { return _.rest(x); };
  		var result = _.map([[1,2,3],[1,2,3]], restWrapper);
  		assertEquals([2, 3, 4],    _.rest(numbers), 'working rest()');
  		assertEquals([1, 2, 3, 4], _.rest(numbers, 1), 'working rest(0)');
  		assertEquals([3, 4],       _.rest(numbers, 3), 'rest can take an index');
  		assertEquals([2,3,2,3],    _.flatten(result), 'works well with _.map');		
  	}
  	
  	public void function testInitial() {
  		var initialWrapper = function (x) { return _.initial(x); };
  		var result = _.map([[1,2,3],[1,2,3]], initialWrapper);
  		assertEquals([1, 2, 3, 4], _.initial([1,2,3,4,5]), 'working initial()');
  		assertEquals([1, 2],       _.initial([1,2,3,4],2), 'initial can take an index');
  		assertEquals([1,2,1,2],    _.flatten(result), 'initial works with _.map');		
  	}
  	
  	public void function testLast() {
  		var lastWrapper = function (x) { return _.last(x); };
  		var result = _.map([[1,2,3],[1,2,3]], lastWrapper);
  		assertEquals(3,         _.last([1,2,3]), 'can pull out the last element of an array');
  		assertEquals([],        _.last([1,2,3], 0), 'can pass an index to last');
  		assertEquals([2, 3],    _.last([1,2,3], 2), 'can pass an index to last');
  		assertEquals([1, 2, 3], _.last([1,2,3], 5), 'can pass an index to last');
  		assertEquals([3,3],     result, 'works well with _.map');		
  	}
  	
  	public void function testCompact() {
  		assertEquals(3, arrayLen(_.compact([0, 1, false, 2, false, 3])), 'can trim out all falsy values');
  	}
  	
  	public void function testFlatten() {
  		var list = [1, [2], [3, [[[4]]]]];
  		assertEquals([1,2,3,4],       _.flatten(list), 'can flatten nested arrays');
  		assertEquals([1,2,3,[[[4]]]], _.flatten(list, true), 'can shallowly flatten nested arrays');
  	}
  	
  	public void function testWithout() {
  		var list = [1, 2, 1, 0, 3, 1, 4];
  		assertEquals([2, 3, 4], _.without(list, [0, 1]), 'can remove all instances of an object');
  		list = [{one: 1}, {two: 2}];
  		assertEquals(1, arrayLen(_.without(list, [{one: 1}])), 'works with structs');
  	}
  		
  	public void function testUniq() {
  	    var list = [1, 2, 1, 3, 1, 4];
  	    assertEquals([1, 2, 3, 4], _.uniq(list), 'can find the unique values of an unsorted array');
  
  	    var list = [1, 1, 1, 2, 2, 3];
  	    assertEquals([1, 2, 3], _.uniq(list, true), '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; };
  	    assertEquals(['moe', 'curly', 'larry'], _.map(_.uniq(list, false, iterator), iterator), '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];
  	    assertEquals([1, 2, 3, 4], _.uniq(list, true, iterator), 'iterator works with sorted array');
  
  	    var list = [];
  	    list[8] = 2;
  