1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2024-11-29 16:30:56 -05:00
denoland-deno/cli/tests/unit/timers_test.ts

776 lines
18 KiB
TypeScript
Raw Normal View History

// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
import {
assert,
assertEquals,
assertNotEquals,
Deferred,
deferred,
delay,
execCode,
unreachable,
} from "./test_util.ts";
Deno.test(async function functionParameterBindingSuccess() {
const promise = deferred();
let count = 0;
const nullProto = (newCount: number) => {
count = newCount;
promise.resolve();
};
Reflect.setPrototypeOf(nullProto, null);
setTimeout(nullProto, 500, 1);
await promise;
// count should be reassigned
assertEquals(count, 1);
});
Deno.test(async function stringifyAndEvalNonFunctions() {
// eval can only access global scope
const global = globalThis as unknown as {
globalPromise: ReturnType<typeof deferred>;
globalCount: number;
};
global.globalPromise = deferred();
global.globalCount = 0;
const notAFunction =
"globalThis.globalCount++; globalThis.globalPromise.resolve();" as unknown as () =>
void;
setTimeout(notAFunction, 500);
await global.globalPromise;
// count should be incremented
assertEquals(global.globalCount, 1);
Reflect.deleteProperty(global, "globalPromise");
Reflect.deleteProperty(global, "globalCount");
});
Deno.test(async function timeoutSuccess() {
const promise = deferred();
let count = 0;
setTimeout(() => {
count++;
2020-09-25 12:34:20 -04:00
promise.resolve();
}, 500);
await promise;
// count should increment
assertEquals(count, 1);
});
Deno.test(async function timeoutEvalNoScopeLeak() {
// eval can only access global scope
const global = globalThis as unknown as {
globalPromise: Deferred<Error>;
};
global.globalPromise = deferred();
setTimeout(
`
try {
console.log(core);
globalThis.globalPromise.reject(new Error("Didn't throw."));
} catch (error) {
globalThis.globalPromise.resolve(error);
}` as unknown as () => void,
0,
);
const error = await global.globalPromise;
assertEquals(error.name, "ReferenceError");
Reflect.deleteProperty(global, "globalPromise");
});
Deno.test(async function evalPrimordial() {
const global = globalThis as unknown as {
globalPromise: ReturnType<typeof deferred>;
};
global.globalPromise = deferred();
const originalEval = globalThis.eval;
let wasCalled = false;
globalThis.eval = (argument) => {
wasCalled = true;
return originalEval(argument);
};
setTimeout(
"globalThis.globalPromise.resolve();" as unknown as () => void,
0,
);
await global.globalPromise;
assert(!wasCalled);
Reflect.deleteProperty(global, "globalPromise");
globalThis.eval = originalEval;
});
Deno.test(async function timeoutArgs() {
const promise = deferred();
const arg = 1;
let capturedArgs: unknown[] = [];
2018-10-08 02:58:44 -04:00
setTimeout(
function () {
capturedArgs = [...arguments];
2020-09-25 12:34:20 -04:00
promise.resolve();
2018-10-08 02:58:44 -04:00
},
10,
arg,
arg.toString(),
[arg],
2018-10-08 02:58:44 -04:00
);
await promise;
assertEquals(capturedArgs, [
arg,
arg.toString(),
[arg],
]);
});
Deno.test(async function timeoutCancelSuccess() {
let count = 0;
const id = setTimeout(() => {
count++;
2019-04-21 14:06:57 -04:00
}, 1);
// Cancelled, count should not increment
clearTimeout(id);
await delay(600);
assertEquals(count, 0);
});
Deno.test(async function timeoutCancelMultiple() {
function uncalled(): never {
throw new Error("This function should not be called.");
}
// Set timers and cancel them in the same order.
const t1 = setTimeout(uncalled, 10);
const t2 = setTimeout(uncalled, 10);
const t3 = setTimeout(uncalled, 10);
clearTimeout(t1);
clearTimeout(t2);
clearTimeout(t3);
// Set timers and cancel them in reverse order.
const t4 = setTimeout(uncalled, 20);
const t5 = setTimeout(uncalled, 20);
const t6 = setTimeout(uncalled, 20);
clearTimeout(t6);
clearTimeout(t5);
clearTimeout(t4);
// Sleep until we're certain that the cancelled timers aren't gonna fire.
await delay(50);
});
Deno.test(async function timeoutCancelInvalidSilentFail() {
// Expect no panic
const promise = deferred();
let count = 0;
const id = setTimeout(() => {
count++;
// Should have no effect
clearTimeout(id);
2020-09-25 12:34:20 -04:00
promise.resolve();
}, 500);
await promise;
assertEquals(count, 1);
// Should silently fail (no panic)
clearTimeout(2147483647);
});
Deno.test(async function intervalSuccess() {
const promise = deferred();
let count = 0;
const id = setInterval(() => {
count++;
2019-04-21 14:06:57 -04:00
clearInterval(id);
2020-09-25 12:34:20 -04:00
promise.resolve();
2019-04-21 14:06:57 -04:00
}, 100);
await promise;
// Clear interval
clearInterval(id);
// count should increment twice
2019-04-21 14:06:57 -04:00
assertEquals(count, 1);
// Similar false async leaking alarm.
// Force next round of polling.
await delay(0);
});
Deno.test(async function intervalCancelSuccess() {
let count = 0;
const id = setInterval(() => {
count++;
2019-04-17 13:02:32 -04:00
}, 1);
clearInterval(id);
await delay(500);
assertEquals(count, 0);
});
Deno.test(async function intervalOrdering() {
const timers: number[] = [];
let timeouts = 0;
function onTimeout() {
++timeouts;
for (let i = 1; i < timers.length; i++) {
clearTimeout(timers[i]);
}
}
for (let i = 0; i < 10; i++) {
2019-04-17 13:02:32 -04:00
timers[i] = setTimeout(onTimeout, 1);
}
await delay(500);
assertEquals(timeouts, 1);
});
Deno.test(function intervalCancelInvalidSilentFail() {
// Should silently fail (no panic)
clearInterval(2147483647);
});
Deno.test(async function callbackTakesLongerThanInterval() {
const promise = deferred();
let timeEndOfFirstCallback: number | undefined;
const interval = setInterval(() => {
if (timeEndOfFirstCallback === undefined) {
// First callback
Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 300);
timeEndOfFirstCallback = Date.now();
} else {
// Second callback
assert(Date.now() - 100 >= timeEndOfFirstCallback);
clearInterval(interval);
promise.resolve();
}
}, 100);
await promise;
});
// https://github.com/denoland/deno/issues/11398
Deno.test(async function clearTimeoutAfterNextTimerIsDue1() {
const promise = deferred();
setTimeout(() => {
promise.resolve();
}, 300);
const interval = setInterval(() => {
Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 400);
// Both the interval and the timeout's due times are now in the past.
clearInterval(interval);
}, 100);
await promise;
});
// https://github.com/denoland/deno/issues/11398
Deno.test(async function clearTimeoutAfterNextTimerIsDue2() {
const promise = deferred();
const timeout1 = setTimeout(unreachable, 100);
setTimeout(() => {
promise.resolve();
}, 200);
Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 300);
// Both of the timeouts' due times are now in the past.
clearTimeout(timeout1);
await promise;
});
Deno.test(async function fireCallbackImmediatelyWhenDelayOverMaxValue() {
let count = 0;
setTimeout(() => {
count++;
}, 2 ** 31);
await delay(1);
assertEquals(count, 1);
});
Deno.test(async function timeoutCallbackThis() {
const promise = deferred();
let capturedThis: unknown;
const obj = {
foo() {
capturedThis = this;
2020-09-25 12:34:20 -04:00
promise.resolve();
},
};
setTimeout(obj.foo, 1);
await promise;
assertEquals(capturedThis, window);
});
Deno.test(async function timeoutBindThis() {
const thisCheckPassed = [null, undefined, window, globalThis];
const thisCheckFailed = [
0,
"",
true,
false,
{},
[],
"foo",
() => {},
Object.prototype,
];
for (const thisArg of thisCheckPassed) {
const resolvable = deferred();
let hasThrown = 0;
try {
setTimeout.call(thisArg, () => resolvable.resolve(), 1);
hasThrown = 1;
} catch (err) {
if (err instanceof TypeError) {
hasThrown = 2;
} else {
hasThrown = 3;
}
}
await resolvable;
assertEquals(hasThrown, 1);
}
for (const thisArg of thisCheckFailed) {
let hasThrown = 0;
try {
setTimeout.call(thisArg, () => {}, 1);
hasThrown = 1;
} catch (err) {
if (err instanceof TypeError) {
hasThrown = 2;
} else {
hasThrown = 3;
}
}
assertEquals(hasThrown, 2);
}
});
Deno.test(function clearTimeoutShouldConvertToNumber() {
let called = false;
const obj = {
valueOf(): number {
called = true;
return 1;
},
};
clearTimeout((obj as unknown) as number);
assert(called);
});
Deno.test(function setTimeoutShouldThrowWithBigint() {
let hasThrown = 0;
try {
setTimeout(() => {}, (1n as unknown) as number);
hasThrown = 1;
} catch (err) {
if (err instanceof TypeError) {
hasThrown = 2;
} else {
hasThrown = 3;
}
}
assertEquals(hasThrown, 2);
});
Deno.test(function clearTimeoutShouldThrowWithBigint() {
let hasThrown = 0;
try {
clearTimeout((1n as unknown) as number);
hasThrown = 1;
} catch (err) {
if (err instanceof TypeError) {
hasThrown = 2;
} else {
hasThrown = 3;
}
}
assertEquals(hasThrown, 2);
});
Deno.test(function testFunctionName() {
assertEquals(clearTimeout.name, "clearTimeout");
assertEquals(clearInterval.name, "clearInterval");
});
Deno.test(function testFunctionParamsLength() {
2019-07-18 06:09:32 -04:00
assertEquals(setTimeout.length, 1);
assertEquals(setInterval.length, 1);
assertEquals(clearTimeout.length, 0);
assertEquals(clearInterval.length, 0);
});
Deno.test(function clearTimeoutAndClearIntervalNotBeEquals() {
assertNotEquals(clearTimeout, clearInterval);
});
2019-10-19 17:09:24 -04:00
Deno.test(async function timerMaxCpuBug() {
2019-10-19 17:09:24 -04:00
// There was a bug where clearing a timeout would cause Deno to use 100% CPU.
clearTimeout(setTimeout(() => {}, 1000));
// We can check this by counting how many ops have triggered in the interim.
// Certainly less than 10 ops should have been dispatched in next 100 ms.
const { ops: pre } = Deno.metrics();
await delay(100);
const { ops: post } = Deno.metrics();
const before = pre.op_sleep.opsDispatched;
const after = post.op_sleep.opsDispatched;
assert(after - before < 10);
2019-10-19 17:09:24 -04:00
});
2019-12-03 22:19:03 -05:00
Deno.test(async function timerOrdering() {
const array: number[] = [];
const donePromise = deferred();
function push(n: number) {
array.push(n);
if (array.length === 6) {
donePromise.resolve();
}
}
setTimeout(() => {
push(1);
setTimeout(() => push(4));
}, 0);
setTimeout(() => {
push(2);
setTimeout(() => push(5));
}, 0);
setTimeout(() => {
push(3);
setTimeout(() => push(6));
}, 0);
await donePromise;
assertEquals(array, [1, 2, 3, 4, 5, 6]);
});
Deno.test(async function timerBasicMicrotaskOrdering() {
2019-12-03 22:19:03 -05:00
let s = "";
let count = 0;
const promise = deferred();
2019-12-03 22:19:03 -05:00
setTimeout(() => {
Promise.resolve().then(() => {
count++;
s += "de";
if (count === 2) {
2020-09-25 12:34:20 -04:00
promise.resolve();
2019-12-03 22:19:03 -05:00
}
});
});
setTimeout(() => {
count++;
s += "no";
if (count === 2) {
2020-09-25 12:34:20 -04:00
promise.resolve();
2019-12-03 22:19:03 -05:00
}
});
await promise;
assertEquals(s, "deno");
});
Deno.test(async function timerNestedMicrotaskOrdering() {
2019-12-03 22:19:03 -05:00
let s = "";
const promise = deferred();
2019-12-03 22:19:03 -05:00
s += "0";
setTimeout(() => {
s += "4";
setTimeout(() => (s += "A"));
Promise.resolve()
.then(() => {
setTimeout(() => {
s += "B";
2020-09-25 12:34:20 -04:00
promise.resolve();
});
})
.then(() => {
s += "5";
2019-12-03 22:19:03 -05:00
});
});
setTimeout(() => (s += "6"));
2019-12-03 22:19:03 -05:00
Promise.resolve().then(() => (s += "2"));
Promise.resolve().then(() =>
setTimeout(() => {
s += "7";
Promise.resolve()
.then(() => (s += "8"))
.then(() => {
s += "9";
});
2019-12-03 22:19:03 -05:00
})
);
Promise.resolve().then(() => Promise.resolve().then(() => (s += "3")));
s += "1";
await promise;
assertEquals(s, "0123456789AB");
2019-12-03 22:19:03 -05:00
});
Deno.test(function testQueueMicrotask() {
assertEquals(typeof queueMicrotask, "function");
});
Deno.test(async function timerIgnoresDateOverride() {
const OriginalDate = Date;
const promise = deferred();
let hasThrown = 0;
try {
const overrideCalled: () => number = () => {
2020-09-25 12:34:20 -04:00
promise.reject("global Date override used over original Date object");
return 0;
};
const DateOverride = () => {
overrideCalled();
};
globalThis.Date = DateOverride as DateConstructor;
globalThis.Date.now = overrideCalled;
globalThis.Date.UTC = overrideCalled;
globalThis.Date.parse = overrideCalled;
2020-09-25 12:34:20 -04:00
queueMicrotask(promise.resolve);
await promise;
hasThrown = 1;
} catch (err) {
if (typeof err === "string") {
assertEquals(err, "global Date override used over original Date object");
hasThrown = 2;
} else if (err instanceof TypeError) {
hasThrown = 3;
} else {
hasThrown = 4;
}
} finally {
globalThis.Date = OriginalDate;
}
assertEquals(hasThrown, 1);
});
Deno.test({
name: "unrefTimer",
permissions: { run: true, read: true },
fn: async () => {
const [statusCode, output] = await execCode(`
const timer = setTimeout(() => console.log("1"), 1);
Deno.unrefTimer(timer);
`);
assertEquals(statusCode, 0);
assertEquals(output, "");
},
});
Deno.test({
name: "unrefTimer - mix ref and unref 1",
permissions: { run: true, read: true },
fn: async () => {
const [statusCode, output] = await execCode(`
const timer1 = setTimeout(() => console.log("1"), 200);
const timer2 = setTimeout(() => console.log("2"), 400);
const timer3 = setTimeout(() => console.log("3"), 600);
Deno.unrefTimer(timer3);
`);
assertEquals(statusCode, 0);
assertEquals(output, "1\n2\n");
},
});
Deno.test({
name: "unrefTimer - mix ref and unref 2",
permissions: { run: true, read: true },
fn: async () => {
const [statusCode, output] = await execCode(`
const timer1 = setTimeout(() => console.log("1"), 200);
const timer2 = setTimeout(() => console.log("2"), 400);
const timer3 = setTimeout(() => console.log("3"), 600);
Deno.unrefTimer(timer1);
Deno.unrefTimer(timer2);
`);
assertEquals(statusCode, 0);
assertEquals(output, "1\n2\n3\n");
},
});
Deno.test({
name: "unrefTimer - unref interval",
permissions: { run: true, read: true },
fn: async () => {
const [statusCode, output] = await execCode(`
let i = 0;
const timer1 = setInterval(() => {
console.log("1");
i++;
if (i === 5) {
Deno.unrefTimer(timer1);
}
}, 10);
`);
assertEquals(statusCode, 0);
assertEquals(output, "1\n1\n1\n1\n1\n");
},
});
Deno.test({
name: "unrefTimer - unref then ref 1",
permissions: { run: true, read: true },
fn: async () => {
const [statusCode, output] = await execCode(`
const timer1 = setTimeout(() => console.log("1"), 10);
Deno.unrefTimer(timer1);
Deno.refTimer(timer1);
`);
assertEquals(statusCode, 0);
assertEquals(output, "1\n");
},
});
Deno.test({
name: "unrefTimer - unref then ref",
permissions: { run: true, read: true },
fn: async () => {
const [statusCode, output] = await execCode(`
const timer1 = setTimeout(() => {
console.log("1");
Deno.refTimer(timer2);
}, 10);
const timer2 = setTimeout(() => console.log("2"), 20);
Deno.unrefTimer(timer2);
`);
assertEquals(statusCode, 0);
assertEquals(output, "1\n2\n");
},
});
Deno.test({
name: "unrefTimer - invalid calls do nothing",
fn: () => {
Deno.unrefTimer(NaN);
Deno.refTimer(NaN);
},
});
Deno.test({
name: "AbortSignal.timeout() with no listeners",
permissions: { run: true, read: true },
fn: async () => {
const [statusCode, output] = await execCode(`
const signal = AbortSignal.timeout(2000);
// This unref timer expires before the signal, and if it does expire, then
// it means the signal has kept the event loop alive.
const timer = setTimeout(() => console.log("Unexpected!"), 1500);
Deno.unrefTimer(timer);
`);
assertEquals(statusCode, 0);
assertEquals(output, "");
},
});
Deno.test({
name: "AbortSignal.timeout() with listeners",
permissions: { run: true, read: true },
fn: async () => {
const [statusCode, output] = await execCode(`
const signal = AbortSignal.timeout(1000);
signal.addEventListener("abort", () => console.log("Event fired!"));
`);
assertEquals(statusCode, 0);
assertEquals(output, "Event fired!\n");
},
});
Deno.test({
name: "AbortSignal.timeout() with removed listeners",
permissions: { run: true, read: true },
fn: async () => {
const [statusCode, output] = await execCode(`
const signal = AbortSignal.timeout(2000);
const callback = () => console.log("Unexpected: Event fired");
signal.addEventListener("abort", callback);
setTimeout(() => {
console.log("Removing the listener.");
signal.removeEventListener("abort", callback);
}, 500);
Deno.unrefTimer(
setTimeout(() => console.log("Unexpected: Unref timer"), 1500)
);
`);
assertEquals(statusCode, 0);
assertEquals(output, "Removing the listener.\n");
},
});
Deno.test({
name: "AbortSignal.timeout() with listener for a non-abort event",
permissions: { run: true, read: true },
fn: async () => {
const [statusCode, output] = await execCode(`
const signal = AbortSignal.timeout(2000);
signal.addEventListener("someOtherEvent", () => {
console.log("Unexpected: someOtherEvent called");
});
Deno.unrefTimer(
setTimeout(() => console.log("Unexpected: Unref timer"), 1500)
);
`);
assertEquals(statusCode, 0);
assertEquals(output, "");
},
});
// Regression test for https://github.com/denoland/deno/issues/19866
Deno.test({
name: "regression for #19866",
fn: async () => {
const timeoutsFired = [];
// deno-lint-ignore require-await
async function start(n: number) {
let i = 0;
const intervalId = setInterval(() => {
i++;
if (i > 2) {
clearInterval(intervalId!);
}
timeoutsFired.push(n);
}, 20);
}
for (let n = 0; n < 100; n++) {
start(n);
}
// 3s should be plenty of time for all the intervals to fire
// but it might still be flaky on CI.
await new Promise((resolve) => setTimeout(resolve, 3000));
assertEquals(timeoutsFired.length, 300);
},
});
// Regression test for https://github.com/denoland/deno/issues/20367
Deno.test({
name: "regression for #20367",
fn: async () => {
const promise = deferred<number>();
const start = performance.now();
setTimeout(() => {
const end = performance.now();
promise.resolve(end - start);
}, 1000);
clearTimeout(setTimeout(() => {}, 1000));
const result = await promise;
assert(result >= 1000);
},
});