FM / test

/home/techb158/balavpn.abdallabala.com/node_modules/es-iterator-helpers/test/

/home/techb158/balavpn.abdallabala.com/node_modules/es-iterator-helpers/test

Name	Size	Mode	Actions
helpers/	-	0777	rm
aos.js	7877	0666	edit dl rm
implementation.js	388	0666	edit dl rm
index.js	391	0666	edit dl rm
Iterator.concat.js	18765	0666	edit dl rm
Iterator.from.js	11210	0666	edit dl rm
Iterator.js	4618	0666	edit dl rm
Iterator.prototype.constructor.js	2945	0666	edit dl rm
Iterator.prototype.drop.js	14428	0666	edit dl rm
Iterator.prototype.every.js	9980	0666	edit dl rm
Iterator.prototype.filter.js	17285	0666	edit dl rm
Iterator.prototype.find.js	9995	0666	edit dl rm
Iterator.prototype.flatMap.js	11660	0666	edit dl rm
Iterator.prototype.forEach.js	7857	0666	edit dl rm
Iterator.prototype.includes.js	5735	0666	edit dl rm
Iterator.prototype.js	3529	0666	edit dl rm
Iterator.prototype.map.js	16396	0666	edit dl rm
Iterator.prototype.reduce.js	10915	0666	edit dl rm
Iterator.prototype.some.js	9942	0666	edit dl rm
Iterator.prototype.take.js	12463	0666	edit dl rm
Iterator.prototype.toArray.js	7759	0666	edit dl rm
Iterator.zip.js	16977	0666	edit dl rm
Iterator.zipKeyed.js	18771	0666	edit dl rm
shimmed.js	2490	0666	edit dl rm
tests.js	932	0666	edit dl rm

Edit: /home/techb158/balavpn.abdallabala.com/node_modules/es-iterator-helpers/test/Iterator.js (4618B)

'use strict';

var defineProperties = require('define-properties');
var test = require('tape');
var functionsHaveNames = require('functions-have-names')();
var mockProperty = require('mock-property');
var hasProto = require('has-proto')();
var requireStash = require('require-stash');

var index = require('../Iterator');
var impl = require('../Iterator/implementation');

var isEnumerable = Object.prototype.propertyIsEnumerable;

module.exports = {
	tests: function (Iter, name, t) {
		t.equal(typeof Iter, 'function', name + ' is a function');

t['throws'](
			function () { Iter(); }, // eslint-disable-line new-cap
			TypeError,
			name + ' throws when Call-ed'
		);

t['throws'](
			function () { return new Iter(); },
			TypeError,
			name + ' throws when Construct-ed'
		);

var SubIter;
		var SubSubIter;
		try {
			/* eslint no-new-func: 0 */
			SubIter = Function('Iter', 'return class SubIter extends Iter {};')(Iter);
			SubSubIter = Function('SubIter', 'return class SubSubIter extends SubIter {};')(SubIter);
		} catch (e) { /**/ }

t.test('class inheritance', { skip: !SubIter }, function (st) {
			st.doesNotThrow(
				function () { return new SubIter(); },
				'Extending ' + name + ' does not throw when Construct-ed'
			);
			st.doesNotThrow(
				function () { return new SubSubIter(); },
				'Extending ' + name + ' twice does not throw when Construct-ed'
			);

st.end();
		});
	},
	index: function () {
		test('Iterator: index', function (t) {
			module.exports.tests(index, 'Iterator', t);

t.end();
		});
	},
	implementation: function () {
		test('Iterator: implementation', function (t) {
			module.exports.tests(impl, 'Iterator', t);

t.end();
		});

test('Iterator: implementation polyfill path', { skip: typeof Iterator !== 'function' }, function (t) {
			var restore = mockProperty(global, 'Iterator', { 'delete': true });

// evict the module cache so implementation re-evaluates without native Iterator
			var restoreImpl = requireStash(__dirname, '../Iterator/implementation');

var polyfillImpl = require('../Iterator/implementation'); // eslint-disable-line global-require

t.equal(typeof polyfillImpl, 'function', 'polyfill is a function');

t['throws'](
				function () { polyfillImpl(); },
				TypeError,
				'polyfill throws when Call-ed (not instanceof)'
			);

t['throws'](
				function () { return new polyfillImpl(); }, // eslint-disable-line new-cap
				TypeError,
				'polyfill throws when Construct-ed directly'
			);

t.test('polyfill prototype chain check', { skip: !hasProto }, function (st) {
				function BadSub() {}
				BadSub.prototype = Object.create(polyfillImpl.prototype);
				Object.defineProperty(BadSub.prototype, 'constructor', { value: BadSub, configurable: true, writable: true });
				// do NOT set Object.setPrototypeOf(BadSub, polyfillImpl)
				// so polyfillImpl is NOT in BadSub's [[Prototype]] chain

var instance = new BadSub();

st['throws'](
					function () { polyfillImpl.call(instance); },
					TypeError,
					'polyfill throws when constructor lacks Iterator in its prototype chain'
				);

st.end();
			});

t.test('polyfill subclass succeeds', { skip: !hasProto }, function (st) {
				function GoodSub() { return polyfillImpl.call(this); }
				GoodSub.prototype = Object.create(polyfillImpl.prototype);
				Object.defineProperty(GoodSub.prototype, 'constructor', { value: GoodSub, configurable: true, writable: true });
				Object.setPrototypeOf(GoodSub, polyfillImpl);

st.doesNotThrow(
					function () { return new GoodSub(); },
					'polyfill does not throw for a proper subclass'
				);

st.end();
			});

// restore the module cache and native Iterator
			restoreImpl();
			restore();

t.end();
		});
	},
	shimmed: function () {
		test('Iterator: shimmed', function (t) {
			t.test('Function name', { skip: !functionsHaveNames }, function (st) {
				st.equal(Iterator.name, 'Iterator', 'Iterator has name "Iterator"');
				st.end();
			});

t.test('enumerability', { skip: !defineProperties.supportsDescriptors }, function (et) {
				et.equal(false, isEnumerable.call(global, Iterator), 'Iterator is not enumerable');
				et.end();
			});

t.test('prototype descriptor', { skip: !defineProperties.supportsDescriptors }, function (pt) {
				var desc = Object.getOwnPropertyDescriptor(Iterator, 'prototype');
				pt.deepEqual(
					desc,
					{
						configurable: false,
						enumerable: false,
						value: Iterator.prototype,
						writable: false
					}
				);

pt.end();
			});

module.exports.tests(Iterator, 'Iterator', t);

t.end();
		});
	}
};

cmd: