Diffusion Ant (master) Code

ant/tests/test_iterator_result_fast_path.cjs
457d5953e6c8master

test_iterator_result_fast_path.cjs
View Options

			function assert(cond, msg) {
			if (!cond) throw new Error(msg);
			}

			function assertEq(actual, expected, msg) {
			if (actual !== expected) {
			throw new Error(msg + " (expected " + expected + ", got " + actual + ")");
			}
			}

			function makeOwnDataIterable(limit) {
			return {
			[Symbol.iterator]() {
			let i = 0;
			const result = { done: false, value: 0 };
			return {
			next() {
			if (i < limit) {
			result.done = false;
			result.value = i++;
			} else {
			result.done = true;
			result.value = undefined;
			}
			return result;
			}
			};
			}
			};
			}

			function makeInheritedIterable(limit) {
			return {
			[Symbol.iterator]() {
			let i = 0;
			const proto = { done: false, value: 0 };
			const result = Object.create(proto);
			return {
			next() {
			if (i < limit) {
			proto.done = false;
			proto.value = i++;
			} else {
			proto.done = true;
			proto.value = undefined;
			}
			return result;
			}
			};
			}
			};
			}

			function makeAccessorIterable(limit, counts) {
			return {
			[Symbol.iterator]() {
			let i = 0;
			let done = false;
			let value = undefined;
			const result = {};

			Object.defineProperty(result, "done", {
			get() {
			counts.done++;
			return done;
			},
			enumerable: true,
			configurable: true,
			});

			Object.defineProperty(result, "value", {
			get() {
			counts.value++;
			return value;
			},
			enumerable: true,
			configurable: true,
			});

			return {
			next() {
			if (i < limit) {
			done = false;
			value = i++;
			} else {
			done = true;
			value = undefined;
			}
			return result;
			}
			};
			}
			};
			}

			async function collectAsync(iterable) {
			let sum = 0;
			for await (const v of iterable) sum += v;
			return sum;
			}

			function makeAsyncOwnDataIterable(limit) {
			return {
			[Symbol.asyncIterator]() {
			let i = 0;
			const result = { done: false, value: 0 };
			return {
			async next() {
			if (i < limit) {
			result.done = false;
			result.value = i++;
			} else {
			result.done = true;
			result.value = undefined;
			}
			return result;
			}
			};
			}
			};
			}

			async function main() {
			console.log("iterator result fast-path regression");

			console.log("\nTest 1: own data properties stay fast-path compatible");
			{
			let sum = 0;
			for (const v of makeOwnDataIterable(8)) sum += v;
			assertEq(sum, 28, "own data result object should iterate correctly");
			}
			console.log("PASS");

			console.log("\nTest 2: inherited done/value still fall back correctly");
			{
			let sum = 0;
			for (const v of makeInheritedIterable(8)) sum += v;
			assertEq(sum, 28, "inherited iterator result properties should still work");
			}
			console.log("PASS");

			console.log("\nTest 3: accessor done/value still invoke getters");
			{
			const counts = { done: 0, value: 0 };
			let sum = 0;
			for (const v of makeAccessorIterable(5, counts)) sum += v;
			assertEq(sum, 10, "accessor-backed iterator result should still iterate correctly");
			assert(counts.done >= 6, "done getter should be observed for each step");
			assert(counts.value >= 5, "value getter should be observed for yielded steps");
			}
			console.log("PASS");

			console.log("\nTest 4: array destructuring still consumes reusable results");
			{
			const [a, b, c] = makeOwnDataIterable(3);
			assertEq(a, 0, "first destructured value should match");
			assertEq(b, 1, "second destructured value should match");
			assertEq(c, 2, "third destructured value should match");
			}
			console.log("PASS");

			console.log("\nTest 5: async iterator reusable result still works");
			{
			const sum = await collectAsync(makeAsyncOwnDataIterable(6));
			assertEq(sum, 15, "async iterator result object should still work");
			}
			console.log("PASS");

			console.log("\nAll iterator result fast-path tests passed");
			}

			main().catch((err) => {
			console.error(err && err.stack ? err.stack : String(err));
			throw err;
			});

Owner Packages

No Owners