import * as observer from 'test:async-values/observer';
import { WrappedStream } from 'test:async-values/observer';
export async function runFuture() {
await Promise.resolve();
return 42;
}
export async function runOptionalFuture(mode) {
await Promise.resolve();
return mode === 0 ? 23 : undefined;
}
export async function runNestedOptionalFuture(mode) {
return { value: runOptionalFuture(mode) };
}
const checkpointReason = new Error('raw future checkpoint');
let checkpointCount = 0;
process.on('unhandledRejection', (reason) => {
if (reason === checkpointReason) checkpointCount += 1;
});
export async function runCheckpointFuture() {
Promise.reject(checkpointReason);
return 7;
}
export function readCheckpointCount() {
return checkpointCount;
}
export async function runStream() {
async function* gen() {
for (let i = 1; i <= 5; i++) {
await Promise.resolve();
yield i;
}
}
return gen();
}
export async function runGcStream() {
async function* gen() {
const captured = { value: 42, native: globalThis.__wasm_rquickjs_new_gc_probe() };
try {
for (let n = 0; n < 3; n++) {
const before = globalThis.__wasm_rquickjs_gc_snapshot()[3];
for (let i = 0; i < 20000; i++) {
const cycle = { data: new Uint8Array(4096), native: globalThis.__wasm_rquickjs_new_gc_probe() };
cycle.self = cycle;
}
if (globalThis.__wasm_rquickjs_gc_snapshot()[3] <= before) throw new Error('GC pressure did not collect cycles');
await Promise.resolve();
yield captured.value + n;
}
} finally {
observer.cleanupComplete();
}
}
return gen();
}
export async function disposeWrappedResources() {
const first = await WrappedStream.wrap([]);
if (typeof first[Symbol.dispose] !== 'function') throw new Error('missing engine dispose symbol');
first[Symbol.dispose]();
{
using second = await WrappedStream.wrap([]);
}
return true;
}
export async function runSiblingStreams() {
return [
[1, 2],
Array.from({ length: 64 }, (_, index) => index),
];
}
export async function runWrappedSiblingStreams() {
return [
await WrappedStream.wrap([1, 2]),
await WrappedStream.wrap(Array.from({ length: 64 }, (_, index) => index)),
];
}
export async function runWrappedStreamAfterGate(id) {
await observer.gate(id);
return await WrappedStream.wrap(Array.from({ length: 64 }, (_, index) => index));
}
export async function scheduleCleanup(gateId, delayMs) {
setTimeout(async () => {
await observer.gate(gateId);
observer.cleanupComplete();
}, delayMs);
}
class StreamingConstructor {
constructor() {
this.wrapped = WrappedStream.wrap(Array.from({ length: 64 }, (_, index) => index));
}
}
class DeferredStreamingConstructor {
constructor() {
Promise.resolve().then(() => {
this.wrapped = WrappedStream.wrap(Array.from({ length: 64 }, (_, index) => index));
});
}
}
export const constructorApi = {
StreamingConstructor,
DeferredStreamingConstructor,
};
export async function runNested() {
async function* stdout() {
for (const byte of [6, 7, 8]) {
await new Promise((resolve) => setTimeout(resolve, 1));
yield byte;
}
}
async function* stderr() {
for (const byte of [9, 10]) {
await Promise.resolve();
yield byte;
}
}
await Promise.resolve();
return {
label: 'nested-ok',
futureValue: Promise.resolve(99),
stdout: stdout(),
stderr: stderr(),
};
}
export async function runNestedError() {
throw 'nested-error';
}
export async function takeFuture(f) {
const v = await f;
return v + 1;
}
let retainedUnobservedFuture;
export function inspectFuture(mode, f) {
if (mode === 0) {
retainedUnobservedFuture = f;
return 42;
}
if (mode === 1) return f;
return (async () => {
const first = await f.then(value => value + 1);
const [second, third] = await Promise.all([f, f]);
let finallyCalls = 0;
const fourth = await f.finally(() => { finallyCalls++; });
const fifth = await f.catch(() => 999);
return first + 2 * second + 3 * third + 4 * fourth + 5 * fifth + finallyCalls;
})();
}
export async function takeStream(s) {
let sum = 0;
for await (const x of s) {
sum += x;
}
return sum;
}
export async function inspectStreamCompletion(s) {
const iterator = s[Symbol.asyncIterator]();
const values = [];
while (true) {
const result = await iterator.next();
if (result.done) {
return `${values.join(',')}|${result.done}|${result.value === undefined}`;
}
values.push(result.value);
}
}
export async function breakStream(s) {
for await (const value of s) {
return value;
}
throw new Error('component stream ended before yielding an item');
}
export async function returnStream(s) {
const iterator = s[Symbol.asyncIterator]();
const first = await iterator.next();
const closed = await iterator.return();
return `${first.value}|${closed.done}|${closed.value === undefined}`;
}
export async function throwStream(s) {
const iterator = s[Symbol.asyncIterator]();
const first = await iterator.next();
try {
await iterator.throw(new Error('consumer-stop'));
return 'throw-resolved';
} catch (error) {
return `${first.value}|${error.message}`;
}
}
export async function closePendingStream(s) {
const pending = s[Symbol.asyncIterator]().next();
await new Promise(resolve => setTimeout(resolve, 1));
const closed = await s[Symbol.asyncIterator]().return('closed');
const pendingResult = await pending;
const closedAgain = await s[Symbol.asyncIterator]().return('closed-again');
const nextAfterClose = await s[Symbol.asyncIterator]().next();
return [
closed.done,
closed.value,
pendingResult.done,
pendingResult.value === undefined,
closedAgain.done,
closedAgain.value,
nextAfterClose.done,
nextAfterClose.value === undefined,
].join('|');
}
export async function runNestedObservedStream(cleanupFailure) {
let nextValue = 0;
const stdout = {
[Symbol.asyncIterator]() {
return {
async next() {
nextValue += 1;
return { done: false, value: nextValue };
},
async return() {
await new Promise(resolve => setTimeout(resolve, 1));
observer.cleanupComplete();
if (cleanupFailure) {
throw new Error('nested-cleanup-failed');
}
return { done: true, value: undefined };
},
};
},
};
return {
label: 'nested-observed',
futureValue: Promise.resolve(1),
stdout,
stderr: null,
};
}
let observedStreamState;
export async function runObservedStream() {
let resolveCleanup;
const cleanupCompleted = new Promise(resolve => { resolveCleanup = resolve; });
observedStreamState = {
nextCalls: 0,
returnStarted: 0,
returnFinished: 0,
cleanupCompleted,
};
return {
[Symbol.asyncIterator]() {
return {
async next() {
observedStreamState.nextCalls += 1;
return { done: false, value: observedStreamState.nextCalls };
},
async return() {
observedStreamState.returnStarted += 1;
await Promise.resolve();
observedStreamState.returnFinished += 1;
resolveCleanup();
return { done: true, value: undefined };
},
};
},
};
}
export async function runInvalidObservedStream() {
async function* invalid() {
try {
yield 'not-a-u8';
} finally {
observer.cleanupComplete();
throw new Error('secondary-export-cleanup-failed');
}
}
return invalid();
}
export async function readObservedStreamState() {
await Promise.race([
observedStreamState.cleanupCompleted,
new Promise(resolve => setTimeout(resolve, 1000)),
]);
return `${observedStreamState.nextCalls}|${observedStreamState.returnStarted}|${observedStreamState.returnFinished}`;
}