var runArrayTests = function (it) {
  'use strict';

  var Sym = typeof Symbol === 'undefined' ? {} : Symbol;
  var isSymbol = function (sym) {
    return typeof Sym === 'function' && typeof sym === 'symbol';
  };
  var functionsHaveNames = (function foo() {}).name === 'foo';
  var ifFunctionsHaveNamesIt = functionsHaveNames ? it : it.skip;
  var ifSymbolIteratorIt = isSymbol(Sym.iterator) ? it : it.skip;
  var ifSymbolIteratorAndArrayValuesIt = isSymbol(Sym.iterator) && Array.prototype.values ? it : it.skip;
  var ifSymbolUnscopablesIt = isSymbol(Sym.unscopables) ? it : it.skip;
  var ifShimIt = (typeof process !== 'undefined' && process.env.NO_ES6_SHIM) ? it.skip : it;
  var ifSupportsDescriptorsIt = Object.getOwnPropertyDescriptor ? it : it.skip;
  var ifHasDunderProtoIt = [].__proto__ === Array.prototype ? it : it.skip; // eslint-disable-line no-proto

  var isNegativeZero = function (x) {
    return (1 / x) < 0;
  };

  describe('Array', function () {
    var list = [5, 10, 15, 20];

    ifShimIt('is on the exported object', function () {
      var exported = require('../');
      expect(exported.Array).to.equal(Array);
    });

    describe('@@iterator', function () {
      ifSymbolIteratorIt('uses Symbol.iterator if available', function () {
        var b = {};
        var c = {};
        var a = [b, c];
        var iteratorFn = a[Sym.iterator];
        var iterator = iteratorFn.call(a);
        expect(iterator.next()).to.eql({ done: false, value: b });
        expect(iterator.next()).to.eql({ done: false, value: c });
        expect(iterator.next()).to.eql({ done: true, value: undefined });
      });

      ifSymbolIteratorAndArrayValuesIt('has the right default iteration function', function () {
        // fixed in Webkit https://bugs.webkit.org/show_bug.cgi?id=143838
        expect(Array.prototype).to.have.property(Sym.iterator, Array.prototype.values);
      });
    });

    describe('.from()', function () {
      if (!Object.prototype.hasOwnProperty.call(Array, 'from')) {
        return it('exists', function () {
          expect(Array).to.have.property('from');
        });
      }

      ifFunctionsHaveNamesIt('has the correct name', function () {
        expect(Array.from).to.have.property('name', 'from');
      });

      it('has the right arity', function () {
        expect(Array.from).to.have.property('length', 1);
      });

      it('is not enumerable', function () {
        expect(Array).ownPropertyDescriptor('from').to.have.property('enumerable', false);
      });

      it('works with primitives', function () {
        expect(Array.from(false)).to.eql([]);
        expect(Array.from(true)).to.eql([]);
        expect(Array.from(-Infinity)).to.eql([]);
        expect(Array.from(-0)).to.eql([]);
        expect(Array.from(0)).to.eql([]);
        expect(Array.from(1)).to.eql([]);
        expect(Array.from(Infinity)).to.eql([]);
      });

      it('should create correct array from iterable', function () {
        (function () {
          expect(Array.from(arguments)).to.eql([0, 1, 2]);
        }(0, 1, 2));

        expect(Array.from([null, undefined, 0.1248, -0, 0])).to.eql([null, undefined, 0.1248, -0, 0]);

        if (Array.prototype.values) {
          expect(Array.from([null, undefined, 0.1248, -0, 0].values())).to.eql([null, undefined, 0.1248, -0, 0]);
        }
      });

      it('works with arraylike objects', function () {
        expect(Array.from({ length: 1 })).to.eql([undefined]);
        expect(Array.from({ 0: 'a', 1: 'b', length: 2 })).to.eql(['a', 'b']);
      });

      it('swallows negative lengths', function () {
        expect(Array.from({ length: -1 })).to.have.property('length', 0);
        expect(Array.from({ length: -Infinity })).to.have.property('length', 0);
        expect(Array.from({ length: -0 })).to.have.property('length', 0);
        expect(Array.from({ length: -42 })).to.have.property('length', 0);
      });

      it('works with strings', function () {
        expect(Array.from('')).to.eql([]);
        expect(Array.from('abc')).to.eql('abc'.split(''));
      });

      it('should handle empty iterables correctly', function () {
        (function () {
          expect(Array.from(arguments)).to.eql([]);
        }());
        expect(Array.from([])).to.eql([]);
        expect(Array.from({})).to.eql([]);
        expect(Array.from({ a: 1 })).to.eql([]);
      });

      it('should work with other constructors', function () {
        var Foo = function FooBar(length, args) {
          this.args = args;
          this.length = length;
        };
        var args = ['a', 'b', 'c'];
        var expected = new Foo(args.length);
        args.forEach(function (arg, index) {
          expected[index] = arg;
        });
        expect(Array.from.call(Foo, args)).to.be.an.instanceOf(Foo);
        expect(Array.from.call(Foo, args)).to.eql(expected);
      });

      describe('map functions', function () {
        it('supports a map function', function () {
          var original = [1, 2, 3];
          var mapper = function (item) {
            return item * 2;
          };
          var mapped = Array.from(original, mapper);
          expect(mapped).to.eql([2, 4, 6]);
        });

        it('passes both (and only) the item and the current index to the map function', function () {
          var original = [1, 2, 3];
          var expectedItems = [1, 2, 3];
          var expectedIndices = [0, 1, 2];

          var actualItems = [];
          var actualIndices = [];
          var mapper = function (item, index) {
            actualItems.push(item);
            actualIndices.push(index);
            expect(arguments).to.have.property('length', 2);
            return item;
          };

          var mapped = Array.from(original, mapper);
          expect(mapped).to.eql(expectedItems);
          expect(actualItems).to.eql(expectedItems);
          expect(actualIndices).to.eql(expectedIndices);
        });

        it('passes both the item and the current index to the map function with a "this" value', function () {
          var original = [1, 2, 3];
          var expectedItems = [1, 2, 3];
          var expectedIndices = [0, 1, 2];
          var expectedContext = {};

          var actualItems = [];
          var actualIndices = [];
          var mapper = function (item, index) {
            actualItems.push(item);
            actualIndices.push(index);
            expect(arguments).to.have.property('length', 2);
            expect(this).to.eql(expectedContext);
            return item;
          };

          var mapped = Array.from(original, mapper, expectedContext);
          expect(mapped).to.eql(expectedItems);
          expect(actualItems).to.eql(expectedItems);
          expect(actualIndices).to.eql(expectedIndices);
        });

        it('accepts an object thisArg', function () {
          var context = {};
          Array.from([1, 2, 3], function () {
            expect(this).to.equal(context);
          }, context);
        });

        it('accepts a primitive thisArg', function () {
          Array.from([1, 2, 3], function () {
            expect(this.valueOf()).to.equal(42);
            expect(Object.prototype.toString.call(this)).to.equal('[object Number]');
          }, 42);
        });

        it('accepts a falsy thisArg', function () {
          Array.from([1, 2, 3], function () {
            expect(this.valueOf()).to.equal(false);
            expect(Object.prototype.toString.call(this)).to.equal('[object Boolean]');
          }, false);
        });
      });

      it('does not throw when provided an undefined second arg', function () {
        expect(Array.from([], undefined)).to.eql([]);
      });

      it('throws when provided a nonfunction second arg', function () {
        expect(function () { Array.from([], null); }).to['throw'](TypeError);
        expect(function () { Array.from([], false); }).to['throw'](TypeError);
        expect(function () { Array.from([], true); }).to['throw'](TypeError);
        expect(function () { Array.from([], /a/g); }).to['throw'](TypeError);
        expect(function () { Array.from([], {}); }).to['throw'](TypeError);
        expect(function () { Array.from([], []); }).to['throw'](TypeError);
        expect(function () { Array.from([], ''); }).to['throw'](TypeError);
        expect(function () { Array.from([], 3); }).to['throw'](TypeError);
      });

      it('supports a this arg', function () {
        var original = [1, 2, 3];
        var context = {};
        var mapper = function (item) {
          expect(this).to.equal(context);
          return item * 2;
        };
        var mapped = Array.from(original, mapper, context);
        expect(mapped).to.eql([2, 4, 6]);
      });

      it('throws when provided null or undefined', function () {
        expect(function () { Array.from(); }).to['throw'](TypeError);
        expect(function () { Array.from(undefined); }).to['throw'](TypeError);
        expect(function () { Array.from(null); }).to['throw'](TypeError);
      });

      it('removes holes', function () {
        /* eslint-disable no-sparse-arrays */
        var input = [0, , 2];
        var result = Array.from([0, , 2]);
        /* eslint-enable no-sparse-arrays */
        expect(1 in input).to.equal(false);
        expect(1 in result).to.equal(true);
        expect(result).to.eql([0, undefined, 2]);
      });

      it('works with this flaky example', function () {
        expect(Array.from([1, NaN, false])).to.eql([1, NaN, false]);
      });

      ifSupportsDescriptorsIt('works when Object.prototype has a throwing setter', function () {
        // TODO: breaks in Chrome 17, IE 9, Safari 5.1-6
        var key = 10;
        /* eslint no-extend-native: 0 */
        Object.defineProperty(Object.prototype, key, {
          configurable: true,
          get: function () {}, // eslint-disable-line getter-return
          set: function (v) { throw new EvalError('boom'); }
        });
        expect(function () {
          var arr = [];
          arr[key] = 42;
        }).to['throw'](EvalError); // assert thrower

        expect(function () { Array.from({ length: key + 1 }); }).not.to['throw']();

        delete Object.prototype[key];
        expect(key in Object.prototype).to.equal(false); // assert cleanup
      });
    });

    describe('.of()', function () {
      if (!Object.prototype.hasOwnProperty.call(Array, 'of')) {
        return it('exists', function () {
          expect(Array).to.have.property('of');
        });
      }

      ifFunctionsHaveNamesIt('has the correct name', function () {
        expect(Array.of).to.have.property('name', 'of');
      });

      it('has the right arity', function () {
        expect(Array.of).to.have.property('length', 0);
      });

      it('is not enumerable', function () {
        expect(Array).ownPropertyDescriptor('of').to.have.property('enumerable', false);
      });

      it('should create correct array from arguments', function () {
        expect(Array.of(1, null, undefined)).to.eql([1, null, undefined]);
      });

      it('should work with other constructors', function () {
        var Foo = function FooBar(length) {
          this.args = Array.prototype.slice.call(arguments, 1);
          this.length = length;
        };
        var args = ['a', 'b', 'c'];
        var expected = new Foo(args.length);
        args.forEach(function (arg, index) {
          expected[index] = arg;
        });
        expect(Array.of.apply(Foo, args)).to.be.an.instanceOf(Foo);
        expect(Array.of.apply(Foo, args)).to.eql(expected);
      });

      describe('without Array.from', function () {
        var originalFrom = Array.from;
        beforeEach(function () {
          Array.from = 42;
        });

        afterEach(function () {
          Array.from = originalFrom;
        });

        it('still works', function () {
          expect(Array.of(1, 2, 3)).to.eql([1, 2, 3]);
        });
      });
    });

    describe('#copyWithin()', function () {
      if (!Object.prototype.hasOwnProperty.call(Array.prototype, 'copyWithin')) {
        return it('exists', function () {
          expect(Array.prototype).to.have.property('copyWithin');
        });
      }

      ifFunctionsHaveNamesIt('has the correct name', function () {
        expect(Array.prototype.copyWithin).to.have.property('name', 'copyWithin');
      });

      it('has the right arity', function () {
        expect(Array.prototype.copyWithin).to.have.property('length', 2);
      });

      it('is not enumerable', function () {
        expect(Array.prototype).ownPropertyDescriptor('copyWithin').to.have.property('enumerable', false);
      });

      it('modifies the object in-place', function () {
        var arr = [1, 2, 3, 4, 5];
        expect(arr.copyWithin(0, 3)).to.eql([4, 5, 3, 4, 5]);
        expect(arr).to.eql([4, 5, 3, 4, 5]);
      });

      it('works with 2 args', function () {
        expect([1, 2, 3, 4, 5].copyWithin(0, 3)).to.eql([4, 5, 3, 4, 5]);
        expect([1, 2, 3, 4, 5].copyWithin(1, 3)).to.eql([1, 4, 5, 4, 5]);
        expect([1, 2, 3, 4, 5].copyWithin(1, 2)).to.eql([1, 3, 4, 5, 5]);
        expect([1, 2, 3, 4, 5].copyWithin(2, 2)).to.eql([1, 2, 3, 4, 5]);
      });

      it('works with 3 args', function () {
        expect([1, 2, 3, 4, 5].copyWithin(0, 3, 4)).to.eql([4, 2, 3, 4, 5]);
        expect([1, 2, 3, 4, 5].copyWithin(1, 3, 4)).to.eql([1, 4, 3, 4, 5]);
        expect([1, 2, 3, 4, 5].copyWithin(1, 2, 4)).to.eql([1, 3, 4, 4, 5]);
      });

      it('works with negative args', function () {
        expect([1, 2, 3, 4, 5].copyWithin(0, -2)).to.eql([4, 5, 3, 4, 5]);
        expect([1, 2, 3, 4, 5].copyWithin(0, -2, -1)).to.eql([4, 2, 3, 4, 5]);
        expect([1, 2, 3, 4, 5].copyWithin(-4, -3, -2)).to.eql([1, 3, 3, 4, 5]);
        expect([1, 2, 3, 4, 5].copyWithin(-4, -3, -1)).to.eql([1, 3, 4, 4, 5]);
        expect([1, 2, 3, 4, 5].copyWithin(-4, -3)).to.eql([1, 3, 4, 5, 5]);
      });

      it('works with arraylike objects', function () {
        var args = (function () { return arguments; }(1, 2, 3));
        expect(Array.isArray(args)).to.equal(false);
        var argsClass = Object.prototype.toString.call(args);
        expect(Array.prototype.slice.call(args)).to.eql([1, 2, 3]);
        Array.prototype.copyWithin.call(args, -2, 0);
        expect(Array.prototype.slice.call(args)).to.eql([1, 1, 2]);
        expect(Object.prototype.toString.call(args)).to.equal(argsClass);
      });

      ifSymbolUnscopablesIt('should be unscopable if Symbols exist', function () {
        var unscopables = Array.prototype[Sym.unscopables];
        expect(!!unscopables).to.equal(true);
        expect(unscopables.copyWithin).to.equal(true);
      });

      it('should delete the target key if the source key is not present', function () {
        /* eslint-disable no-sparse-arrays */
        expect([, 1, 2].copyWithin(1, 0)).to.eql([, , 1]);
        /* eslint-enable no-sparse-arrays */
      });

      it('should check inherited properties as well', function () {
        var Parent = function Parent() {};
        Parent.prototype[0] = 'foo';
        var sparse = new Parent();
        sparse[1] = 1;
        sparse[2] = 2;
        sparse.length = 3;
        var result = Array.prototype.copyWithin.call(sparse, 1, 0);
        expect(result).to.have.property('0');
        expect(result).not.to.have.ownProperty('0');
        expect(result).to.have.ownProperty('1');
        expect(result).to.eql({ 0: 'foo', 1: 'foo', 2: 1, length: 3 });
      });

      // https://github.com/tc39/test262/pull/2443
      describe('security issues', function () {
        // make a long integer Array
        var longDenseArray = function longDenseArray() {
          var a = [0];
          for (var i = 0; i < 1024; i++) {
            a[i] = i;
          }
          return a;
        };

        describe('coerced-values-start-change-start', function () {
          var currArray;
          var shorten = function shorten() {
            currArray.length = 20;
            return 1000;
          };

          it('coercion side-effect makes start out of bounds', function () {
            currArray = longDenseArray();
            var array = [];
            array.length = 20;

            expect(currArray.copyWithin(0, { valueOf: shorten })).to.deep.equal(array);
          });

          ifHasDunderProtoIt('coercion side-effect makes start out of bounds with prototype', function () {
            currArray = longDenseArray();
            Object.setPrototypeOf(currArray, longDenseArray());

            var array2 = longDenseArray();
            array2.length = 20;
            for (var i = 0; i < 24; i++) {
              array2[i] = Object.getPrototypeOf(currArray)[i + 1000];
            }

            expect(currArray.copyWithin(0, { valueOf: shorten })).to.have.deep.members(array2);
          });
        });

        describe('coerced-values-start-change-target', function () {
          it('coercion side-effect makes target out of bounds', function () {
            var shorten = function shorten() {
              currArray.length = 20;
              return 1;
            };

            var array = longDenseArray();
            array.length = 20;
            for (var i = 0; i < 19; i++) {
              array[i + 1000] = array[i + 1];
            }

            var currArray = longDenseArray();

            expect(currArray.copyWithin(1000, { valueOf: shorten })).to.deep.equal(array);
          });
        });
      });
    });

    describe('#find()', function () {
      if (!Object.prototype.hasOwnProperty.call(Array.prototype, 'find')) {
        return it('exists', function () {
          expect(Array.prototype).to.have.property('find');
        });
      }

      ifFunctionsHaveNamesIt('has the correct name', function () {
        expect(Array.prototype.find).to.have.property('name', 'find');
      });

      it('should have the right arity', function () {
        expect(Array.prototype.find).to.have.property('length', 1);
      });

      it('is not enumerable', function () {
        expect(Array.prototype).ownPropertyDescriptor('find').to.have.property('enumerable', false);
      });

      it('should find item by predicate', function () {
        var result = list.find(function (item) { return item === 15; });
        expect(result).to.equal(15);
      });

      it('should return undefined when nothing matched', function () {
        var result = list.find(function (item) { return item === 'a'; });
        expect(result).to.equal(undefined);
      });

      it('should throw TypeError when function was not passed', function () {
        expect(function () { list.find(); }).to['throw'](TypeError);
      });

      it('should receive all three parameters', function () {
        var foundIndex = list.find(function (value, index, arr) {
          expect(list).to.have.property(index, value);
          expect(list).to.eql(arr);
          return false;
        });
        expect(foundIndex).to.equal(undefined);
      });

      it('should work with the context argument', function () {
        var context = {};
        [1].find(function () { expect(this).to.equal(context); }, context);
      });

      it('should work with an array-like object', function () {
        var obj = { 0: 1, 1: 2, 2: 3, length: 3 };
        var found = Array.prototype.find.call(obj, function (item) { return item === 2; });
        expect(found).to.equal(2);
      });

      it('should work with an array-like object with negative length', function () {
        var obj = { 0: 1, 1: 2, 2: 3, length: -3 };
        var found = Array.prototype.find.call(obj, function () {
          throw new Error('should not reach here');
        });
        expect(found).to.equal(undefined);
      });

      it('should work with a sparse array', function () {
        /* eslint-disable no-sparse-arrays */
        var obj = [1, , undefined];
        /* eslint-enable no-sparse-arrays */
        expect(1 in obj).to.equal(false);
        var seen = [];
        var found = obj.find(function (item, idx) {
          seen.push([idx, item]);
          return false;
        });
        expect(found).to.equal(undefined);
        expect(seen).to.eql([[0, 1], [1, undefined], [2, undefined]]);
      });

      it('should work with a sparse array-like object', function () {
        var obj = { 0: 1, 2: undefined, length: 3.2 };
        var seen = [];
        var found = Array.prototype.find.call(obj, function (item, idx) {
          seen.push([idx, item]);
          return false;
        });
        expect(found).to.equal(undefined);
        expect(seen).to.eql([[0, 1], [1, undefined], [2, undefined]]);
      });

      ifSymbolUnscopablesIt('should be unscopable if Symbols exist', function () {
        var unscopables = Array.prototype[Sym.unscopables];
        expect(!!unscopables).to.equal(true);
        expect(unscopables.find).to.equal(true);
      });
    });

    describe('#findIndex()', function () {
      if (!Object.prototype.hasOwnProperty.call(Array.prototype, 'findIndex')) {
        return it('exists', function () {
          expect(Array.prototype).to.have.property('findIndex');
        });
      }

      ifFunctionsHaveNamesIt('has the correct name', function () {
        expect(Array.prototype.findIndex).to.have.property('name', 'findIndex');
      });

      it('should have the right arity', function () {
        expect(Array.prototype.findIndex).to.have.property('length', 1);
      });

      it('is not enumerable', function () {
        expect(Array.prototype).ownPropertyDescriptor('findIndex').to.have.property('enumerable', false);
      });

      it('should find item key by predicate', function () {
        var result = list.findIndex(function (item) { return item === 15; });
        expect(result).to.equal(2);
      });

      it('should return -1 when nothing matched', function () {
        var result = list.findIndex(function (item) { return item === 'a'; });
        expect(result).to.equal(-1);
      });

      it('should throw TypeError when function was not passed', function () {
        expect(function () { list.findIndex(); }).to['throw'](TypeError);
      });

      it('should receive all three parameters', function () {
        var foundIndex = list.findIndex(function (value, index, arr) {
          expect(list[index]).to.equal(value);
          expect(list).to.eql(arr);
          return false;
        });
        expect(foundIndex).to.equal(-1);
      });

      it('should work with the context argument', function () {
        var context = {};
        [1].findIndex(function () { expect(this).to.equal(context); }, context);
      });

      it('should work with an array-like object', function () {
        var obj = { 0: 1, 1: 2, 2: 3, length: 3 };
        var foundIndex = Array.prototype.findIndex.call(obj, function (item) { return item === 2; });
        expect(foundIndex).to.equal(1);
      });

      it('should work with an array-like object with negative length', function () {
        var obj = { 0: 1, 1: 2, 2: 3, length: -3 };
        var foundIndex = Array.prototype.findIndex.call(obj, function () {
          throw new Error('should not reach here');
        });
        expect(foundIndex).to.equal(-1);
      });

      it('should work with a sparse array', function () {
        /* eslint-disable no-sparse-arrays */
        var obj = [1, , undefined];
        /* eslint-enable no-sparse-arrays */
        expect(1 in obj).to.equal(false);
        var seen = [];
        var foundIndex = obj.findIndex(function (item, idx) {
          seen.push([idx, item]);
          return item === undefined && idx === 2;
        });
        expect(foundIndex).to.equal(2);
        expect(seen).to.eql([[0, 1], [1, undefined], [2, undefined]]);
      });

      it('should work with a sparse array-like object', function () {
        var obj = { 0: 1, 2: undefined, length: 3.2 };
        var seen = [];
        var foundIndex = Array.prototype.findIndex.call(obj, function (item, idx) {
          seen.push([idx, item]);
          return false;
        });
        expect(foundIndex).to.equal(-1);
        expect(seen).to.eql([[0, 1], [1, undefined], [2, undefined]]);
      });

      ifSymbolUnscopablesIt('should be unscopable if Symbols exist', function () {
        var unscopables = Array.prototype[Sym.unscopables];
        expect(!!unscopables).to.equal(true);
        expect(unscopables.findIndex).to.equal(true);
      });
    });

    describe('ArrayIterator', function () {
      if (!Object.prototype.hasOwnProperty.call(Array.prototype, 'keys')) {
        return it('can be tested', function () {
          expect(Array.prototype).to.have.property('keys');
        });
      }

      var arrayIterator;
      beforeEach(function () {
        arrayIterator = [1, 2, 3].keys();
      });

      describe('#next()', function () {
        it('should work when applied to an ArrayIterator', function () {
          expect(arrayIterator.next.apply(arrayIterator)).to.eql({ value: 0, done: false });
          expect(arrayIterator.next.apply(arrayIterator)).to.eql({ value: 1, done: false });
          expect(arrayIterator.next.apply(arrayIterator)).to.eql({ value: 2, done: false });
          expect(arrayIterator.next.apply(arrayIterator)).to.eql({ value: undefined, done: true });
        });

        it('throws when not applied to an ArrayIterator', function () {
          expect(function () { arrayIterator.next.apply({}); }).to['throw'](TypeError);
        });
      });
    });

    describe('#keys()', function () {
      if (!Object.prototype.hasOwnProperty.call(Array.prototype, 'keys')) {
        return it('exists', function () {
          expect(Array.prototype).to.have.property('keys');
        });
      }

      ifFunctionsHaveNamesIt('has the correct name', function () {
        expect(Array.prototype.keys).to.have.property('name', 'keys');
      });

      it('should have the right arity ', function () {
        expect(Array.prototype.keys.length).to.equal(0);
      });

      it('is not enumerable', function () {
        expect(Array.prototype).ownPropertyDescriptor('keys').to.have.property('enumerable', false);
      });

      describe('basic keys iteration', function () {
        var mylist = [5, 10, 15, 20];
        var keys;
        beforeEach(function () {
          if (!keys) {
            keys = mylist.keys();
          }
        });

        it('should return 0 on first object', function () {
          expect(keys.next()).to.eql({ value: 0, done: false });
        });

        it('should return 1 on second object', function () {
          expect(keys.next()).to.eql({ value: 1, done: false });
        });

        it('should return 2 on third object', function () {
          expect(keys.next()).to.eql({ value: 2, done: false });
        });

        it('should return 3 on fourth object', function () {
          expect(keys.next()).to.eql({ value: 3, done: false });
        });

        it('should set done on completing iteration', function () {
          expect(keys.next()).to.eql({ value: undefined, done: true });
        });

        it('once done it should stay done', function () {
          mylist.push(4);
          expect(keys.next()).to.eql({ value: undefined, done: true });
        });
      });

      it('should not skip sparse keys', function () {
        var sparse = [1];
        sparse[2] = 3;
        var keys = sparse.keys();
        expect(keys.next()).to.eql({ value: 0, done: false });
        expect(keys.next()).to.eql({ value: 1, done: false });
        expect(keys.next()).to.eql({ value: 2, done: false });
        expect(keys.next()).to.eql({ value: undefined, done: true });
      });

      ifSymbolUnscopablesIt('should be unscopable if Symbols exist', function () {
        var unscopables = Array.prototype[Sym.unscopables];
        expect(!!unscopables).to.equal(true);
        expect(unscopables.keys).to.equal(true);
      });
    });

    describe('#values()', function () {
      if (!Object.prototype.hasOwnProperty.call(Array.prototype, 'values')) {
        return it('exists', function () {
          expect(Array.prototype).to.have.property('values');
        });
      }

      ifFunctionsHaveNamesIt('has the correct name', function () {
        expect(Array.prototype.values).to.have.property('name', 'values');
      });

      it('has the right arity', function () {
        expect(Array.prototype.values).to.have.property('length', 0);
      });

      it('is not enumerable', function () {
        expect(Array.prototype).ownPropertyDescriptor('values').to.have.property('enumerable', false);
      });

      describe('basic list iteration', function () {
        var mylist = [5, 10, 15, 20];
        var values;
        beforeEach(function () {
          if (!values) {
            values = mylist.values();
          }
        });

        it('should return 5 on first object', function () {
          expect(values.next()).to.eql({ value: 5, done: false });
        });

        it('should return 10 on second object', function () {
          expect(values.next()).to.eql({ value: 10, done: false });
        });

        it('should return 15 on third object', function () {
          expect(values.next()).to.eql({ value: 15, done: false });
        });

        it('should return 20 on fourth object', function () {
          expect(values.next()).to.eql({ value: 20, done: false });
        });

        it('should set done on completing iteration', function () {
          expect(values.next()).to.eql({ value: undefined, done: true });
        });

        it('once done it should stay done', function () {
          mylist.push(4);
          expect(values.next()).to.eql({ value: undefined, done: true });
        });
      });

      it('should not skip sparse values', function () {
        var sparse = [1];
        sparse[2] = 3;
        var values = sparse.values();
        expect(values.next()).to.eql({ value: 1, done: false });
        expect(values.next()).to.eql({ value: undefined, done: false });
        expect(values.next()).to.eql({ value: 3, done: false });
        expect(values.next()).to.eql({ value: undefined, done: true });
      });

      ifSymbolUnscopablesIt('should be unscopable if Symbols exist', function () {
        var unscopables = Array.prototype[Sym.unscopables];
        expect(!!unscopables).to.equal(true);
        expect(unscopables.values).to.equal(true);
      });
    });

    describe('#entries()', function () {
      if (!Object.prototype.hasOwnProperty.call(Array.prototype, 'entries')) {
        return it('exists', function () {
          expect(Array.prototype).to.have.property('entries');
        });
      }

      ifFunctionsHaveNamesIt('has the correct name', function () {
        expect(Array.prototype.entries).to.have.property('name', 'entries');
      });

      it('has the right arity', function () {
        expect(Array.prototype.entries).to.have.property('length', 0);
      });

      it('is not enumerable', function () {
        expect(Array.prototype).ownPropertyDescriptor('entries').to.have.property('enumerable', false);
      });

      describe('basic list iteration', function () {
        var mylist = [5, 10, 15, 20];
        var entries;
        beforeEach(function () {
          if (!entries) {
            entries = mylist.entries();
          }
        });

        it('should return [0, 5] on first object', function () {
          var val = entries.next();
          expect(val).to.eql({ value: [0, 5], done: false });
        });

        it('should return [1, 10] on second object', function () {
          var val = entries.next();
          expect(val).to.eql({ value: [1, 10], done: false });
        });

        it('should return [2, 15] on third object', function () {
          var val = entries.next();
          expect(val).to.eql({ value: [2, 15], done: false });
        });

        it('should return [3, 20] on fourth object', function () {
          var val = entries.next();
          expect(val).to.eql({ value: [3, 20], done: false });
        });

        it('should set done on completing iteration', function () {
          var val = entries.next();
          expect(val).to.eql({ value: undefined, done: true });
        });

        it('once done it should stay done', function () {
          mylist.push(4);
          var val = entries.next();
          expect(val).to.eql({ value: undefined, done: true });
        });
      });

      it('should not skip sparse entries', function () {
        var sparse = [1];
        sparse[2] = 3;
        var entries = sparse.entries();
        expect(entries.next()).to.eql({ value: [0, 1], done: false });
        expect(entries.next()).to.eql({ value: [1, undefined], done: false });
        expect(entries.next()).to.eql({ value: [2, 3], done: false });
        expect(entries.next()).to.eql({ value: undefined, done: true });
      });

      ifSymbolUnscopablesIt('should be unscopable if Symbols exist', function () {
        var unscopables = Array.prototype[Sym.unscopables];
        expect(!!unscopables).to.equal(true);
        expect(unscopables.entries).to.equal(true);
      });
    });

    describe('#fill()', function () {
      if (!Object.prototype.hasOwnProperty.call(Array.prototype, 'fill')) {
        return it('exists', function () {
          expect(Array.prototype).to.have.property('fill');
        });
      }

      ifFunctionsHaveNamesIt('has the correct name', function () {
        expect(Array.prototype.fill).to.have.property('name', 'fill');
      });

      it('has the right arity', function () {
        expect(Array.prototype.fill).to.have.property('length', 1);
      });

      it('is not enumerable', function () {
        expect(Array.prototype).ownPropertyDescriptor('fill').to.have.property('enumerable', false);
      });

      it('works with just a value', function () {
        var original = [1, 2, 3, 4, 5, 6];
        var filled = [-1, -1, -1, -1, -1, -1];

        expect(original.fill(-1)).to.eql(filled);
      });

      it('accepts a positive start index', function () {
        var original = [1, 2, 3, 4, 5, 6];
        var filled = [1, 2, 3, -1, -1, -1];

        expect(original.fill(-1, 3)).to.eql(filled);
      });

      it('accepts a negative start index', function () {
        var original = [1, 2, 3, 4, 5, 6];
        var filled = [1, 2, 3, -1, -1, -1];

        expect(original.fill(-1, -3)).to.eql(filled);
      });

      it('accepts a negative end index', function () {
        var original = [1, 2, 3];
        var filled = [4, 2, 3];

        expect(original.fill(4, -3, -2)).to.eql(filled);
      });

      it('accepts a large start index', function () {
        var original = [1, 2, 3, 4, 5, 6];
        var filled = [1, 2, 3, 4, 5, 6];

        expect(original.fill(-1, 9)).to.eql(filled);
      });

      ifSymbolUnscopablesIt('should be unscopable if Symbols exist', function () {
        var unscopables = Array.prototype[Sym.unscopables];
        expect(!!unscopables).to.equal(true);
        expect(unscopables.fill).to.equal(true);
      });
    });

    // this length converts to "1", preventing a crazy crash in older FF
    var negativeLength = { 0: 1, length: -Math.pow(2, 32) + 1 };
    var throwRangeError = function (v, i) {
      if (i === negativeLength.length >>> 0) {
        return v;
      }
      // note: in nonconforming browsers, this will be called
      // -1 >>> 0 times, which is 4294967295, so the throw matters.
      throw new RangeError('should not reach here: length of -1 should clamp to length of 0');
    };
    var throwRangeErrorReduce = function throwRangeErrorReduce(acc, v, i) {
      return throwRangeErrorReduce(v, i);
    };

    describe('#forEach()', function () {
      it('uses ToLength to clamp negative values to zero', function () {
        expect(function () {
          Array.prototype.forEach.call(negativeLength, throwRangeError);
        }).not.to['throw']();
      });
    });

    describe('#map()', function () {
      it('uses ToLength to clamp negative values to zero', function () {
        var mapped;
        expect(function () {
          mapped = Array.prototype.map.call(negativeLength, throwRangeError);
        }).not.to['throw']();
        expect(mapped).to.eql([]);
      });
    });

    describe('#filter()', function () {
      it('uses ToLength to clamp negative values to zero', function () {
        var filtered;
        expect(function () {
          filtered = Array.prototype.filter.call(negativeLength, throwRangeError);
        }).not.to['throw']();
        expect(filtered).to.eql([]);
      });
    });

    describe('#some()', function () {
      it('uses ToLength to clamp negative values to zero', function () {
        var result;
        expect(function () {
          result = Array.prototype.some.call(negativeLength, throwRangeError);
        }).not.to['throw']();
        expect(result).to.equal([].some(Object));
      });
    });

    describe('#every()', function () {
      it('uses ToLength to clamp negative values to zero', function () {
        var result;
        expect(function () {
          result = Array.prototype.every.call(negativeLength, throwRangeError);
        }).not.to['throw']();
        expect(result).to.equal([].every(Object));
      });
    });

    describe('#reduce()', function () {
      it('uses ToLength to clamp negative values to zero', function () {
        var accumulator = {};
        var reduced;
        expect(function () {
          reduced = Array.prototype.reduce.call(negativeLength, throwRangeErrorReduce, accumulator);
        }).not.to['throw']();
        expect(reduced).to.equal(accumulator);
      });
    });

    describe('#reduceRight()', function () {
      it('uses ToLength to clamp negative values to zero', function () {
        var negativeOneToUint32minusOne = (-1 >>> 0) - 1;
        var obj = { length: -1 };
        obj[negativeOneToUint32minusOne] = true;
        var accumulator = {};
        var reduced;
        expect(function () {
          reduced = Array.prototype.reduceRight.call(obj, throwRangeErrorReduce, accumulator);
        }).not.to['throw']();
        expect(reduced).to.equal(accumulator);
      });
    });

    describe('#indexOf()', function () {
      it('converts second argument from -0 to +0', function () {
        expect(isNegativeZero([true].indexOf(true, -0))).to.equal(false);
      });
    });
  });
};

describe('clean Object.prototype', function () {
  'use strict';

  runArrayTests.call(this, it);
});

describe('polluted Object.prototype', function () {
  'use strict';

  var shimmedIt = function () {
    /* eslint-disable no-extend-native */
    Object.prototype[1] = 42;
    /* eslint-enable no-extend-native */
    it.apply(this, arguments);
    delete Object.prototype[1];
  };
  shimmedIt.skip = it.skip;
  return runArrayTests.call(this, shimmedIt);
});
