add traceur test suite

test/fixtures/traceur/ArrayExtras/Fill.js

@@ -0,0 +1,47 @@
+// should have a length of 1
+assert.equal(Array.prototype.fill.length, 1);
+
+// should fill from basic case
+assert.deepEqual([1, 2, 3].fill(5), [5, 5, 5]);
+
+// should fill from start
+assert.deepEqual([1, 2, 3].fill(5, 1), [1, 5, 5]);
+
+// should fill from start to end
+assert.deepEqual([1, 2, 3].fill(5, 1, 2), [1, 5, 3]);
+
+// should fill from negative start
+assert.deepEqual([1, 2, 3].fill(5, -1), [1, 2, 5]);
+
+// should fill from negative start to positive end
+assert.deepEqual([1, 2, 3].fill(5, -2, 3), [1, 5, 5]);
+
+// should fill from negative start to negative end
+assert.deepEqual([1, 2, 3].fill(5, -3, -1), [5, 5, 3]);
+
+// should fill from positive start to negative end
+assert.deepEqual([1, 2, 3].fill(5, 1, -1), [1, 5, 3]);
+
+// should fill custom object
+assert.deepEqual(Array.prototype.fill.call({'0': 1, 'length': 3}, 5), {'0': 5, '1': 5, '2': 5, 'length': 3});
+
+// should handle custom object with negative length
+assert.deepEqual(Array.prototype.fill.call({'0': 2, 'length': -1}, 5), {'0': 2, 'length': -1});
+
+// should handle no elements
+assert.deepEqual([].fill(5), []);
+
+// should handle bad start
+assert.deepEqual([1, 2, 3].fill(5, 'hello'), [5, 5, 5]);
+
+// should handle bad end
+assert.deepEqual([1, 2, 3].fill(5, 1, {}), [1, 2, 3]);
+
+// should handle bad start and end
+assert.deepEqual([1, 2, 3].fill(5, 'hello', {}), [1, 2, 3]);
+
+
+// should handle bad this
+assert.throws(function() {
+  Array.prototype.fill.call(null, 5)
+}, TypeError);

test/fixtures/traceur/ArrayExtras/Find.js

@@ -0,0 +1,88 @@
+// should have a length of 1
+assert.equal(Array.prototype.find.length, 1);
+
+// should handle basic case
+assert.equal([1, 2, 3].find(function(v) {
+  return v * v === 4;
+}), 2);
+
+// should handle arrow functions
+assert.equal([1, 2, 3].find(v => v * v === 4), 2);
+
+// should return undefined when not found
+assert.equal([1, 2, 3].find(v => v > 10), undefined);
+
+// should return first match
+assert.equal([2, 2, 3].find(v => v * v === 4), 2);
+
+// should handle custom objects
+assert.equal(Array.prototype.find.call({
+  'length': 2,
+  '0': false,
+  '1': true
+}, v => v), true);
+
+// should handle bad predicate
+assert.throws(function() {
+  [1, 2, 3].find(1)
+}, TypeError);
+
+// should handle bad this
+assert.throws(function() {
+  Array.prototype.find.call(null, function() {})
+}, TypeError);
+
+// should correctly handle this
+var global = this;
+({
+  assert: function() {
+    var self = this;
+
+    // should be global this
+    [1, 2, 3].find(function() {
+      assert.notEqual(this, self);
+      assert.equal(this, global);
+    });
+
+    // should be the same this
+    [1, 2, 3].find(function() {
+      assert.equal(this, self);
+    }, self);
+
+    // should not have an effect on arrow functions
+    [1, 2, 3].find(() => assert.equal(this, self));
+    [1, 2, 3].find(() => assert.equal(this, self), self);
+
+    // should call with correct args
+    var arr = [5];
+    arr.find(function(value, i, object) {
+      assert.equal(value, 5);
+      assert.equal(i, 0);
+      assert.equal(arr, object);
+    });
+  }
+}).assert();
+
+var lengthCalls = 0;
+var itemCalls = 0;
+var callbackCalls = 0;
+var object = {
+  length: {
+    valueOf() {
+      lengthCalls++;
+      return 3;
+    }
+  },
+  get 2() {
+    itemCalls++;
+    return 'a';
+  }
+};
+
+assert.equal(Array.prototype.find.call(object, (v) => {
+  callbackCalls++;
+  return v === 'a';
+}), 'a');
+assert.equal(lengthCalls, 1);
+assert.equal(itemCalls, 1);
+assert.equal(callbackCalls, 3);

test/fixtures/traceur/ArrayExtras/FindIndex.js

@@ -0,0 +1,47 @@
+// should have a length of 1
+assert.equal(Array.prototype.findIndex.length, 1);
+
+// should handle basic case
+assert.equal([1, 2, 3].findIndex(function(v) {
+  return v * v === 4;
+}), 1);
+
+// should handle arrow functions
+assert.equal([1, 2, 3].findIndex(v => v * v === 4), 1);
+
+// should return -1 when not found
+assert.equal([1, 2, 3].findIndex(v => v > 10), -1);
+
+// should return first match
+assert.equal([2, 2, 3].findIndex(v => v * v === 4), 0);
+
+// should handle custom objects
+assert.equal(Array.prototype.findIndex.call({
+  'length': 2,
+  '0': false,
+  '1': true
+}, v => v), 1);
+
+var lengthCalls = 0;
+var itemCalls = 0;
+var callbackCalls = 0;
+var object = {
+  length: {
+    valueOf() {
+      lengthCalls++;
+      return 3;
+    }
+  },
+  get 2() {
+    itemCalls++;
+    return 'a';
+  }
+};
+
+assert.equal(Array.prototype.findIndex.call(object, (v) => {
+  callbackCalls++;
+  return v === 'a';
+}), 2);
+assert.equal(lengthCalls, 1);
+assert.equal(itemCalls, 1);
+assert.equal(callbackCalls, 3);

test/fixtures/traceur/ArrayExtras/From.js

@@ -0,0 +1,155 @@
+// should have a length of 1
+//assert.equal(Array.from.length, 1);
+var arr;
+var obj;
+
+// should make an array from arguments
+function arrayFromArgs() {
+  return Array.from(arguments);
+}
+arr = arrayFromArgs('a', 1);
+
+assert.equal(arr.length, 2);
+assert.deepEqual(arr, ['a', 1]);
+assert.isTrue(Array.isArray(arr));
+
+// should handle undefined values
+var arrayLike = {0: 'a', 2: 'c', length: 3};
+arr = Array.from(arrayLike);
+
+assert.equal(arr.length, 3);
+assert.deepEqual(arr, ['a', undefined, 'c']);
+assert.isTrue(Array.isArray(arr));
+
+// should use a mapFn
+arr = Array.from([{'a': 1}, {'a': 2}], function(item, i) {
+  return item.a + i;
+});
+
+assert.deepEqual(arr, [1, 3]);
+
+// should set this in mapFn
+var thisObj = {a: 10};
+arr = Array.from([{'a': 1}, {'a': 2}], function(item, i) {
+  return this.a + item.a + i;
+}, thisObj);
+
+assert.deepEqual(arr, [11, 13]);
+
+// should map on array-like object
+arr = Array.from({0: {'a': 5}, length: 1}, function(item, i) {
+  return item.a + i;
+});
+
+assert.deepEqual(arr, [5]);
+
+// should throw on bad map fn
+assert.throws(function() {
+  Array.from([], null)
+}, TypeError);
+
+// should make from an array-like object
+var arrayLikeObj = function(len) {
+  this.length = len;
+};
+arrayLikeObj.from = Array.from;
+obj = arrayLikeObj.from(['a', 'b', 'c']);
+
+assert.equal(obj.length, 3);
+assert.deepEqual(obj, {0: 'a', 1: 'b', 2: 'c', length: 3});
+
+// should make from a non-array iterable
+var calledIterator = 0;
+var Iterable = function(len) {
+  var self = this;
+
+  self.length = len;
+  self[Symbol.iterator] = function*() {
+    for (var i = 0; i < self.length; i++) {
+      calledIterator++;
+      yield self[i];
+    }
+  };
+};
+var it = new Iterable(3);
+it[0] = 'a';
+it[1] = 'b';
+it[2] = 'c';
+obj = Array.from(it);
+
+assert.equal(obj.length, 3);
+assert.equal(obj[0], 'a');
+assert.equal(obj[1], 'b');
+assert.equal(obj[2], 'c');
+assert.equal(calledIterator, 3);
+
+// should make from a sub-classed array
+var length = 0;
+var constructorCounter = 0;
+var lengthSetCounter = 0;
+var lengthGetCounter = 0;
+
+class MyArray extends Array {
+  constructor(v) {
+    constructorCounter++;
+    assert.isUndefined(v);
+  }
+
+  set length(v) {
+    lengthSetCounter++;
+    length = v;
+  }
+
+  get length() {
+    lengthGetCounter++;
+    return length;
+  }
+}
+
+var ma = MyArray.from(['a', 'b']);
+assert.instanceOf(ma, MyArray);
+assert.equal(constructorCounter, 1);
+assert.equal(lengthSetCounter, 1);
+assert.equal(lengthGetCounter, 0);
+assert.isTrue(ma.hasOwnProperty('0'));
+assert.isTrue(ma.hasOwnProperty('1'));
+assert.isFalse(ma.hasOwnProperty('length'));
+assert.equal(ma[0], 'a');
+assert.equal(ma[1], 'b');
+assert.equal(ma.length, 2);
+
+// should make from a sub-classed array without iterable
+length = 0;
+constructorCounter = 0;
+lengthSetCounter = 0;
+lengthGetCounter = 0;
+
+class MyArray2 extends MyArray {
+  constructor(v) {
+    constructorCounter++;
+    assert.equal(v, 2);
+  }
+};
+MyArray2.prototype[Symbol.iterator] = undefined;
+
+class MyArray3 extends Array {
+  constructor(v) {
+    this.length = v;
+  }
+}
+MyArray3.prototype[Symbol.iterator] = undefined;
+
+var ma3 = new MyArray3(2);
+ma3[0] = 'a';
+ma3[1] = 'b';
+ma = MyArray2.from(ma3);
+assert.instanceOf(ma, MyArray2);
+assert.equal(constructorCounter, 1);
+assert.equal(lengthSetCounter, 1);
+assert.equal(lengthGetCounter, 0);
+assert.isTrue(ma.hasOwnProperty('0'));
+assert.isTrue(ma.hasOwnProperty('1'));
+assert.isFalse(ma.hasOwnProperty('length'));
+assert.equal(ma[0], 'a');
+assert.equal(ma[1], 'b');
+assert.equal(ma.length, 2);

test/fixtures/traceur/ArrayExtras/Of.js

@@ -0,0 +1,37 @@
+var arr;
+
+// should have a length of 0
+assert.equal(Array.of.length, 0);
+
+//should return an array from arguments
+arr = Array.of(1, 'a', 3);
+assert.deepEqual(arr, [1, 'a', 3]);
+assert.isTrue(arr instanceof Array);
+
+//should work with no arguments
+arr = Array.of();
+assert.deepEqual(arr, []);
+assert.isTrue(arr instanceof Array);
+
+//should work with sub-classed array
+class MyArray extends Array {}
+
+arr = MyArray.of(4, 'b');
+assert.equal(arr[0], 4);
+assert.equal(arr[1], 'b');
+assert.equal(arr.length, 2);
+assert.isTrue(arr instanceof MyArray);
+
+//should call with exotic array
+class ExoticArray {
+  constructor(len) {
+    this.length = len;
+  }
+}
+arr = Array.of.call(ExoticArray, 5, 'c', 6, 'd');
+assert.equal(arr[0], 5);
+assert.equal(arr[1], 'c');
+assert.equal(arr[2], 6);
+assert.equal(arr[3], 'd');
+assert.equal(arr.length, 4);
+assert.isTrue(arr instanceof ExoticArray);