Diffusion Ant (bytecode) Code

ant/tests/test_async_await_integration.cjs
da28911c0817bytecode

test_async_await_integration.cjs
View Options

			// Integration test for async/await functionality
			console.log('=== Async/Await Integration Tests ===');

			// Test 1: Async function that returns a value, consumed with await
			console.log('\nTest 1: Async function consumed with await');
			async function getData() {
			return 'data from async';
			}

			async function consumeData() {
			const data = await getData();
			console.log('Consumed: ' + data);
			return data;
			}

			consumeData().then(v => console.log('Integration Test 1: ' + v));

			// Test 2: Chain of async/await functions
			console.log('\nTest 2: Chain of async/await');
			async function step1() {
			const val = await Promise.resolve(10);
			return val * 2;
			}

			async function step2() {
			const val = await step1();
			return val + 5;
			}

			async function step3() {
			const val = await step2();
			return val * 3;
			}

			step3().then(v => console.log('Integration Test 2: ' + v));

			// Test 3: Await with Promise.resolve and transformation
			console.log('\nTest 3: Await with transformations');
			async function transform() {
			const a = await Promise.resolve(5);
			const b = await Promise.resolve(10);
			const c = await Promise.resolve(a + b);
			return c * 2;
			}

			transform().then(v => console.log('Integration Test 3: ' + v));

			// Test 4: Async arrow with await
			console.log('\nTest 4: Async arrow with await');
			const asyncArrow = async (x) => {
			const doubled = await Promise.resolve(x * 2);
			return doubled + 10;
			};

			asyncArrow(5).then(v => console.log('Integration Test 4: ' + v));

			// Test 5: Nested async calls with await
			console.log('\nTest 5: Nested async with await');
			async function inner() {
			return await Promise.resolve('inner value');
			}

			async function middle() {
			const val = await inner();
			return 'middle wraps: ' + val;
			}

			async function outer() {
			const val = await middle();
			return 'outer wraps: ' + val;
			}

			outer().then(v => console.log('Integration Test 5: ' + v));

			// Test 6: Await in conditional branches
			console.log('\nTest 6: Conditional await');
			async function conditionalAwait(flag) {
			if (flag) {
			const val = await Promise.resolve(100);
			return val;
			} else {
			const val = await Promise.resolve(200);
			return val;
			}
			}

			conditionalAwait(true).then(v => console.log('Integration Test 6a: ' + v));
			conditionalAwait(false).then(v => console.log('Integration Test 6b: ' + v));

			// Test 7: Multiple awaits with operations
			console.log('\nTest 7: Multiple awaits with math');
			async function calculate() {
			const x = await Promise.resolve(3);
			const y = await Promise.resolve(4);
			const z = await Promise.resolve(5);
			return x * x + y * y;
			}

			calculate().then(v => console.log('Integration Test 7: ' + v));

			// Test 8: Await with object manipulation
			console.log('\nTest 8: Await with objects');
			async function objectTest() {
			const obj = await Promise.resolve({ name: 'test', value: 42 });
			obj.value = obj.value * 2;
			return obj.value;
			}

			objectTest().then(v => console.log('Integration Test 8: ' + v));

			// Test 9: Await with array manipulation
			console.log('\nTest 9: Await with arrays');
			async function arrayTest() {
			const arr = await Promise.resolve([1, 2, 3]);
			const first = arr[0];
			const second = arr[1];
			return first + second;
			}

			arrayTest().then(v => console.log('Integration Test 9: ' + v));

			// Test 10: Await in async method
			console.log('\nTest 10: Await in object method');
			const calculator = {
			multiplier: 3,
			asyncMultiply: async function(n) {
			const base = await Promise.resolve(n);
			return base * this.multiplier;
			}
			};

			calculator.asyncMultiply(7).then(v => console.log('Integration Test 10: ' + v));

			// Test 11: Immediate await vs deferred
			console.log('\nTest 11: Immediate vs deferred await');
			async function immediate() {
			return await Promise.resolve('immediate');
			}

			async function deferred() {
			const promise = Promise.resolve('deferred');
			const result = await promise;
			return result;
			}

			immediate().then(v => console.log('Integration Test 11a: ' + v));
			deferred().then(v => console.log('Integration Test 11b: ' + v));

			// Test 12: Await non-promise values directly
			console.log('\nTest 12: Await non-promises');
			async function awaitNonPromise() {
			const a = await 10;
			const b = await 'string';
			const c = await true;
			return a;
			}

			awaitNonPromise().then(v => console.log('Integration Test 12: ' + v));

			// Test 13: Complex expression with await
			console.log('\nTest 13: Complex await expression');
			async function complexExpr() {
			const result = (await Promise.resolve(5)) + (await Promise.resolve(3)) * 2;
			return result;
			}

			complexExpr().then(v => console.log('Integration Test 13: ' + v));

			// Test 14: Await with string concatenation
			console.log('\nTest 14: Await with string ops');
			async function stringOps() {
			const part1 = await Promise.resolve('Hello');
			const part2 = await Promise.resolve(' ');
			const part3 = await Promise.resolve('Await!');
			return part1 + part2 + part3;
			}

			stringOps().then(v => console.log('Integration Test 14: ' + v));

			// Test 15: Return statement with await
			console.log('\nTest 15: Direct return await');
			async function directReturn() {
			return await Promise.resolve('direct return');
			}

			directReturn().then(v => console.log('Integration Test 15: ' + v));

			console.log('\n=== All integration tests initiated ===');

Owner Packages

No Owners