summaryrefslogtreecommitdiff
path: root/std/node/_util
diff options
context:
space:
mode:
Diffstat (limited to 'std/node/_util')
-rw-r--r--std/node/_util/_util_callbackify_test.ts334
-rw-r--r--std/node/_util/_util_promisify_test.ts141
-rw-r--r--std/node/_util/_util_types_test.ts156
3 files changed, 332 insertions, 299 deletions
diff --git a/std/node/_util/_util_callbackify_test.ts b/std/node/_util/_util_callbackify_test.ts
index 630e4d0e7..d6a5d8664 100644
--- a/std/node/_util/_util_callbackify_test.ts
+++ b/std/node/_util/_util_callbackify_test.ts
@@ -20,8 +20,6 @@
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-const { test } = Deno;
import { assert, assertStrictEquals } from "../../testing/asserts.ts";
import { callbackify } from "./_util_callbackify.ts";
@@ -76,159 +74,174 @@ class TestQueue {
}
}
-test("callbackify passes the resolution value as the second argument to the callback", async () => {
- const testQueue = new TestQueue();
+Deno.test(
+ "callbackify passes the resolution value as the second argument to the callback",
+ async () => {
+ const testQueue = new TestQueue();
- for (const value of values) {
- // eslint-disable-next-line require-await
- async function asyncFn(): Promise<typeof value> {
- return value;
- }
- const cbAsyncFn = callbackify(asyncFn);
- testQueue.enqueue((done) => {
- cbAsyncFn((err: unknown, ret: unknown) => {
- assertStrictEquals(err, null);
- assertStrictEquals(ret, value);
- done();
+ for (const value of values) {
+ // eslint-disable-next-line require-await
+ async function asyncFn(): Promise<typeof value> {
+ return value;
+ }
+ const cbAsyncFn = callbackify(asyncFn);
+ testQueue.enqueue((done) => {
+ cbAsyncFn((err: unknown, ret: unknown) => {
+ assertStrictEquals(err, null);
+ assertStrictEquals(ret, value);
+ done();
+ });
});
- });
- function promiseFn(): Promise<typeof value> {
- return Promise.resolve(value);
- }
- const cbPromiseFn = callbackify(promiseFn);
- testQueue.enqueue((done) => {
- cbPromiseFn((err: unknown, ret: unknown) => {
- assertStrictEquals(err, null);
- assertStrictEquals(ret, value);
- done();
+ function promiseFn(): Promise<typeof value> {
+ return Promise.resolve(value);
+ }
+ const cbPromiseFn = callbackify(promiseFn);
+ testQueue.enqueue((done) => {
+ cbPromiseFn((err: unknown, ret: unknown) => {
+ assertStrictEquals(err, null);
+ assertStrictEquals(ret, value);
+ done();
+ });
});
- });
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- function thenableFn(): PromiseLike<any> {
- return {
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- then(onfulfilled): PromiseLike<any> {
- assert(onfulfilled);
- onfulfilled(value);
- return this;
- },
- };
- }
- const cbThenableFn = callbackify(thenableFn);
- testQueue.enqueue((done) => {
- cbThenableFn((err: unknown, ret: unknown) => {
- assertStrictEquals(err, null);
- assertStrictEquals(ret, value);
- done();
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ function thenableFn(): PromiseLike<any> {
+ return {
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ then(onfulfilled): PromiseLike<any> {
+ assert(onfulfilled);
+ onfulfilled(value);
+ return this;
+ },
+ };
+ }
+ const cbThenableFn = callbackify(thenableFn);
+ testQueue.enqueue((done) => {
+ cbThenableFn((err: unknown, ret: unknown) => {
+ assertStrictEquals(err, null);
+ assertStrictEquals(ret, value);
+ done();
+ });
});
- });
- }
+ }
- await testQueue.waitForCompletion();
-});
+ await testQueue.waitForCompletion();
+ }
+);
-test("callbackify passes the rejection value as the first argument to the callback", async () => {
- const testQueue = new TestQueue();
+Deno.test(
+ "callbackify passes the rejection value as the first argument to the callback",
+ async () => {
+ const testQueue = new TestQueue();
- for (const value of values) {
- // eslint-disable-next-line require-await
- async function asyncFn(): Promise<never> {
- return Promise.reject(value);
- }
- const cbAsyncFn = callbackify(asyncFn);
- assertStrictEquals(cbAsyncFn.length, 1);
- assertStrictEquals(cbAsyncFn.name, "asyncFnCallbackified");
- testQueue.enqueue((done) => {
- cbAsyncFn((err: unknown, ret: unknown) => {
- assertStrictEquals(ret, undefined);
- if (err instanceof Error) {
- if ("reason" in err) {
- assert(!value);
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- assertStrictEquals((err as any).code, "ERR_FALSY_VALUE_REJECTION");
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- assertStrictEquals((err as any).reason, value);
+ for (const value of values) {
+ // eslint-disable-next-line require-await
+ async function asyncFn(): Promise<never> {
+ return Promise.reject(value);
+ }
+ const cbAsyncFn = callbackify(asyncFn);
+ assertStrictEquals(cbAsyncFn.length, 1);
+ assertStrictEquals(cbAsyncFn.name, "asyncFnCallbackified");
+ testQueue.enqueue((done) => {
+ cbAsyncFn((err: unknown, ret: unknown) => {
+ assertStrictEquals(ret, undefined);
+ if (err instanceof Error) {
+ if ("reason" in err) {
+ assert(!value);
+ assertStrictEquals(
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ (err as any).code,
+ "ERR_FALSY_VALUE_REJECTION"
+ );
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ assertStrictEquals((err as any).reason, value);
+ } else {
+ assertStrictEquals(String(value).endsWith(err.message), true);
+ }
} else {
- assertStrictEquals(String(value).endsWith(err.message), true);
+ assertStrictEquals(err, value);
}
- } else {
- assertStrictEquals(err, value);
- }
- done();
+ done();
+ });
});
- });
- function promiseFn(): Promise<never> {
- return Promise.reject(value);
- }
- const obj = {};
- Object.defineProperty(promiseFn, "name", {
- value: obj,
- writable: false,
- enumerable: false,
- configurable: true,
- });
+ function promiseFn(): Promise<never> {
+ return Promise.reject(value);
+ }
+ const obj = {};
+ Object.defineProperty(promiseFn, "name", {
+ value: obj,
+ writable: false,
+ enumerable: false,
+ configurable: true,
+ });
- const cbPromiseFn = callbackify(promiseFn);
- assertStrictEquals(promiseFn.name, obj);
- testQueue.enqueue((done) => {
- cbPromiseFn((err: unknown, ret: unknown) => {
- assertStrictEquals(ret, undefined);
- if (err instanceof Error) {
- if ("reason" in err) {
- assert(!value);
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- assertStrictEquals((err as any).code, "ERR_FALSY_VALUE_REJECTION");
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- assertStrictEquals((err as any).reason, value);
+ const cbPromiseFn = callbackify(promiseFn);
+ assertStrictEquals(promiseFn.name, obj);
+ testQueue.enqueue((done) => {
+ cbPromiseFn((err: unknown, ret: unknown) => {
+ assertStrictEquals(ret, undefined);
+ if (err instanceof Error) {
+ if ("reason" in err) {
+ assert(!value);
+ assertStrictEquals(
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ (err as any).code,
+ "ERR_FALSY_VALUE_REJECTION"
+ );
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ assertStrictEquals((err as any).reason, value);
+ } else {
+ assertStrictEquals(String(value).endsWith(err.message), true);
+ }
} else {
- assertStrictEquals(String(value).endsWith(err.message), true);
+ assertStrictEquals(err, value);
}
- } else {
- assertStrictEquals(err, value);
- }
- done();
+ done();
+ });
});
- });
-
- function thenableFn(): PromiseLike<never> {
- return {
- then(onfulfilled, onrejected): PromiseLike<never> {
- assert(onrejected);
- onrejected(value);
- return this;
- },
- };
- }
- const cbThenableFn = callbackify(thenableFn);
- testQueue.enqueue((done) => {
- cbThenableFn((err: unknown, ret: unknown) => {
- assertStrictEquals(ret, undefined);
- if (err instanceof Error) {
- if ("reason" in err) {
- assert(!value);
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- assertStrictEquals((err as any).code, "ERR_FALSY_VALUE_REJECTION");
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- assertStrictEquals((err as any).reason, value);
+ function thenableFn(): PromiseLike<never> {
+ return {
+ then(onfulfilled, onrejected): PromiseLike<never> {
+ assert(onrejected);
+ onrejected(value);
+ return this;
+ },
+ };
+ }
+
+ const cbThenableFn = callbackify(thenableFn);
+ testQueue.enqueue((done) => {
+ cbThenableFn((err: unknown, ret: unknown) => {
+ assertStrictEquals(ret, undefined);
+ if (err instanceof Error) {
+ if ("reason" in err) {
+ assert(!value);
+ assertStrictEquals(
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ (err as any).code,
+ "ERR_FALSY_VALUE_REJECTION"
+ );
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ assertStrictEquals((err as any).reason, value);
+ } else {
+ assertStrictEquals(String(value).endsWith(err.message), true);
+ }
} else {
- assertStrictEquals(String(value).endsWith(err.message), true);
+ assertStrictEquals(err, value);
}
- } else {
- assertStrictEquals(err, value);
- }
- done();
+ done();
+ });
});
- });
- }
+ }
- await testQueue.waitForCompletion();
-});
+ await testQueue.waitForCompletion();
+ }
+);
-test("callbackify passes arguments to the original", async () => {
+Deno.test("callbackify passes arguments to the original", async () => {
const testQueue = new TestQueue();
for (const value of values) {
@@ -276,7 +289,7 @@ test("callbackify passes arguments to the original", async () => {
await testQueue.waitForCompletion();
});
-test("callbackify preserves the `this` binding", async () => {
+Deno.test("callbackify preserves the `this` binding", async () => {
const testQueue = new TestQueue();
for (const value of values) {
@@ -325,7 +338,7 @@ test("callbackify preserves the `this` binding", async () => {
await testQueue.waitForCompletion();
});
-test("callbackify throws with non-function inputs", () => {
+Deno.test("callbackify throws with non-function inputs", () => {
["foo", null, undefined, false, 0, {}, Symbol(), []].forEach((value) => {
try {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -344,31 +357,34 @@ test("callbackify throws with non-function inputs", () => {
});
});
-test("callbackify returns a function that throws if the last argument is not a function", () => {
- // eslint-disable-next-line require-await
- async function asyncFn(): Promise<number> {
- return 42;
- }
+Deno.test(
+ "callbackify returns a function that throws if the last argument is not a function",
+ () => {
+ // eslint-disable-next-line require-await
+ async function asyncFn(): Promise<number> {
+ return 42;
+ }
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- const cb = callbackify(asyncFn) as any;
- const args: unknown[] = [];
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ const cb = callbackify(asyncFn) as any;
+ const args: unknown[] = [];
- ["foo", null, undefined, false, 0, {}, Symbol(), []].forEach((value) => {
- args.push(value);
+ ["foo", null, undefined, false, 0, {}, Symbol(), []].forEach((value) => {
+ args.push(value);
- try {
- cb(...args);
- throw Error("We should never reach this error");
- } catch (err) {
- assert(err instanceof TypeError);
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- assertStrictEquals((err as any).code, "ERR_INVALID_ARG_TYPE");
- assertStrictEquals(err.name, "TypeError");
- assertStrictEquals(
- err.message,
- "The last argument must be of type function."
- );
- }
- });
-});
+ try {
+ cb(...args);
+ throw Error("We should never reach this error");
+ } catch (err) {
+ assert(err instanceof TypeError);
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ assertStrictEquals((err as any).code, "ERR_INVALID_ARG_TYPE");
+ assertStrictEquals(err.name, "TypeError");
+ assertStrictEquals(
+ err.message,
+ "The last argument must be of type function."
+ );
+ }
+ });
+ }
+);
diff --git a/std/node/_util/_util_promisify_test.ts b/std/node/_util/_util_promisify_test.ts
index a583d8cfe..c6dbbd45a 100644
--- a/std/node/_util/_util_promisify_test.ts
+++ b/std/node/_util/_util_promisify_test.ts
@@ -20,27 +20,26 @@
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
import {
assert,
assertEquals,
assertStrictEquals,
assertThrowsAsync,
} from "../../testing/asserts.ts";
-
import { promisify } from "./_util_promisify.ts";
import * as fs from "../fs.ts";
-const { test } = Deno;
-
const readFile = promisify(fs.readFile);
const customPromisifyArgs = Symbol.for("deno.nodejs.util.promisify.customArgs");
-test("Errors should reject the promise", async function testPromiseRejection() {
- await assertThrowsAsync(() => readFile("/dontexist"), Deno.errors.NotFound);
-});
+Deno.test(
+ "Errors should reject the promise",
+ async function testPromiseRejection() {
+ await assertThrowsAsync(() => readFile("/dontexist"), Deno.errors.NotFound);
+ }
+);
-test("Promisify.custom", async function testPromisifyCustom() {
+Deno.test("Promisify.custom", async function testPromisifyCustom() {
function fn(): void {}
function promisifedFn(): void {}
@@ -56,7 +55,7 @@ test("Promisify.custom", async function testPromisifyCustom() {
await promisifiedFnB;
});
-test("promiisfy.custom symbol", function testPromisifyCustomSymbol() {
+Deno.test("promiisfy.custom symbol", function testPromisifyCustomSymbol() {
function fn(): void {}
function promisifiedFn(): void {}
@@ -72,7 +71,7 @@ test("promiisfy.custom symbol", function testPromisifyCustomSymbol() {
assertStrictEquals(promisify(promisify(fn)), promisifiedFn);
});
-test("Invalid argument should throw", function testThrowInvalidArgument() {
+Deno.test("Invalid argument should throw", function testThrowInvalidArgument() {
function fn(): void {}
// @ts-ignore TypeScript (as of 3.7) does not support indexing namespaces by symbol
fn[promisify.custom] = 42;
@@ -84,7 +83,7 @@ test("Invalid argument should throw", function testThrowInvalidArgument() {
}
});
-test("Custom promisify args", async function testPromisifyCustomArgs() {
+Deno.test("Custom promisify args", async function testPromisifyCustomArgs() {
const firstValue = 5;
const secondValue = 17;
@@ -99,50 +98,65 @@ test("Custom promisify args", async function testPromisifyCustomArgs() {
assertEquals(obj, { first: firstValue, second: secondValue });
});
-test("Multiple callback args without custom promisify args", async function testPromisifyWithoutCustomArgs() {
- function fn(callback: Function): void {
- callback(null, "foo", "bar");
+Deno.test(
+ "Multiple callback args without custom promisify args",
+ async function testPromisifyWithoutCustomArgs() {
+ function fn(callback: Function): void {
+ callback(null, "foo", "bar");
+ }
+ const value = await promisify(fn)();
+ assertStrictEquals(value, "foo");
}
- const value = await promisify(fn)();
- assertStrictEquals(value, "foo");
-});
+);
-test("Undefined resolved value", async function testPromisifyWithUndefinedResolvedValue() {
- function fn(callback: Function): void {
- callback(null);
+Deno.test(
+ "Undefined resolved value",
+ async function testPromisifyWithUndefinedResolvedValue() {
+ function fn(callback: Function): void {
+ callback(null);
+ }
+ const value = await promisify(fn)();
+ assertStrictEquals(value, undefined);
}
- const value = await promisify(fn)();
- assertStrictEquals(value, undefined);
-});
+);
-test("Undefined resolved value II", async function testPromisifyWithUndefinedResolvedValueII() {
- function fn(callback: Function): void {
- callback();
+Deno.test(
+ "Undefined resolved value II",
+ async function testPromisifyWithUndefinedResolvedValueII() {
+ function fn(callback: Function): void {
+ callback();
+ }
+ const value = await promisify(fn)();
+ assertStrictEquals(value, undefined);
}
- const value = await promisify(fn)();
- assertStrictEquals(value, undefined);
-});
+);
-test("Resolved value: number", async function testPromisifyWithNumberResolvedValue() {
- function fn(err: Error | null, val: number, callback: Function): void {
- callback(err, val);
+Deno.test(
+ "Resolved value: number",
+ async function testPromisifyWithNumberResolvedValue() {
+ function fn(err: Error | null, val: number, callback: Function): void {
+ callback(err, val);
+ }
+ const value = await promisify(fn)(null, 42);
+ assertStrictEquals(value, 42);
}
- const value = await promisify(fn)(null, 42);
- assertStrictEquals(value, 42);
-});
+);
-test("Rejected value", async function testPromisifyWithNumberRejectedValue() {
- function fn(err: Error | null, val: null, callback: Function): void {
- callback(err, val);
+Deno.test(
+ "Rejected value",
+ async function testPromisifyWithNumberRejectedValue() {
+ function fn(err: Error | null, val: null, callback: Function): void {
+ callback(err, val);
+ }
+ await assertThrowsAsync(
+ () => promisify(fn)(new Error("oops"), null),
+ Error,
+ "oops"
+ );
}
- await assertThrowsAsync(
- () => promisify(fn)(new Error("oops"), null),
- Error,
- "oops"
- );
-});
+);
-test("Rejected value", async function testPromisifyWithAsObjectMethod() {
+Deno.test("Rejected value", async function testPromisifyWithAsObjectMethod() {
const o: { fn?: Function } = {};
const fn = promisify(function (cb: Function): void {
// @ts-ignore TypeScript
@@ -155,21 +169,26 @@ test("Rejected value", async function testPromisifyWithAsObjectMethod() {
assert(val);
});
-test("Multiple callback", async function testPromisifyWithMultipleCallback() {
- const err = new Error("Should not have called the callback with the error.");
- const stack = err.stack;
-
- const fn = promisify(function (cb: Function): void {
- cb(null);
- cb(err);
- });
-
- await fn();
- await Promise.resolve();
- return assertStrictEquals(stack, err.stack);
-});
+Deno.test(
+ "Multiple callback",
+ async function testPromisifyWithMultipleCallback() {
+ const err = new Error(
+ "Should not have called the callback with the error."
+ );
+ const stack = err.stack;
+
+ const fn = promisify(function (cb: Function): void {
+ cb(null);
+ cb(err);
+ });
+
+ await fn();
+ await Promise.resolve();
+ return assertStrictEquals(stack, err.stack);
+ }
+);
-test("Promisify a promise", function testPromisifyPromise() {
+Deno.test("Promisify a promise", function testPromisifyPromise() {
function c(): void {}
const a = promisify(function (): void {});
const b = promisify(a);
@@ -177,7 +196,7 @@ test("Promisify a promise", function testPromisifyPromise() {
assertStrictEquals(a, b);
});
-test("Test error", async function testInvalidArguments() {
+Deno.test("Test error", async function testInvalidArguments() {
let errToThrow;
const thrower = promisify(function (
@@ -198,7 +217,7 @@ test("Test error", async function testInvalidArguments() {
}
});
-test("Test invalid arguments", function testInvalidArguments() {
+Deno.test("Test invalid arguments", function testInvalidArguments() {
[undefined, null, true, 0, "str", {}, [], Symbol()].forEach((input) => {
try {
// @ts-ignore TypeScript
diff --git a/std/node/_util/_util_types_test.ts b/std/node/_util/_util_types_test.ts
index 2d4307e77..f6dfcfe89 100644
--- a/std/node/_util/_util_types_test.ts
+++ b/std/node/_util/_util_types_test.ts
@@ -20,8 +20,6 @@
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-const { test } = Deno;
import { assertStrictEquals } from "../../testing/asserts.ts";
import {
isDate,
@@ -68,19 +66,19 @@ import {
import * as testModuleNamespaceOpbject from "./_util_types.ts";
// isAnyArrayBuffer
-test("Should return true for valid ArrayBuffer types", () => {
+Deno.test("Should return true for valid ArrayBuffer types", () => {
assertStrictEquals(isAnyArrayBuffer(new ArrayBuffer(0)), true);
assertStrictEquals(isAnyArrayBuffer(new SharedArrayBuffer(0)), true);
});
-test("Should return false for invalid ArrayBuffer types", () => {
+Deno.test("Should return false for invalid ArrayBuffer types", () => {
assertStrictEquals(isAnyArrayBuffer({}), false);
assertStrictEquals(isAnyArrayBuffer([]), false);
assertStrictEquals(isAnyArrayBuffer(new Error()), false);
});
// isArrayBufferView
-test("Should return true for valid ArrayBufferView types", () => {
+Deno.test("Should return true for valid ArrayBufferView types", () => {
assertStrictEquals(isArrayBufferView(new Int8Array(0)), true);
assertStrictEquals(isArrayBufferView(new Uint8Array(0)), true);
assertStrictEquals(isArrayBufferView(new Uint8ClampedArray(0)), true);
@@ -93,7 +91,7 @@ test("Should return true for valid ArrayBufferView types", () => {
assertStrictEquals(isArrayBufferView(new DataView(new ArrayBuffer(0))), true);
});
-test("Should return false for invalid ArrayBufferView types", () => {
+Deno.test("Should return false for invalid ArrayBufferView types", () => {
assertStrictEquals(isArrayBufferView({}), false);
assertStrictEquals(isArrayBufferView([]), false);
assertStrictEquals(isArrayBufferView(new Error()), false);
@@ -103,18 +101,18 @@ test("Should return false for invalid ArrayBufferView types", () => {
// isArgumentsObject
// Note: not testable in TS
-test("Should return false for invalid Argument types", () => {
+Deno.test("Should return false for invalid Argument types", () => {
assertStrictEquals(isArgumentsObject({}), false);
assertStrictEquals(isArgumentsObject([]), false);
assertStrictEquals(isArgumentsObject(new Error()), false);
});
// isArrayBuffer
-test("Should return true for valid ArrayBuffer types", () => {
+Deno.test("Should return true for valid ArrayBuffer types", () => {
assertStrictEquals(isArrayBuffer(new ArrayBuffer(0)), true);
});
-test("Should return false for invalid ArrayBuffer types", () => {
+Deno.test("Should return false for invalid ArrayBuffer types", () => {
assertStrictEquals(isArrayBuffer(new SharedArrayBuffer(0)), false);
assertStrictEquals(isArrayBuffer({}), false);
assertStrictEquals(isArrayBuffer([]), false);
@@ -122,12 +120,12 @@ test("Should return false for invalid ArrayBuffer types", () => {
});
// isAsyncFunction
-test("Should return true for valid async function types", () => {
+Deno.test("Should return true for valid async function types", () => {
const asyncFunction = async (): Promise<void> => {};
assertStrictEquals(isAsyncFunction(asyncFunction), true);
});
-test("Should return false for invalid async function types", () => {
+Deno.test("Should return false for invalid async function types", () => {
const syncFunction = (): void => {};
assertStrictEquals(isAsyncFunction(syncFunction), false);
assertStrictEquals(isAsyncFunction({}), false);
@@ -136,34 +134,34 @@ test("Should return false for invalid async function types", () => {
});
// isBigInt64Array
-test("Should return true for valid BigInt64Array types", () => {
+Deno.test("Should return true for valid BigInt64Array types", () => {
assertStrictEquals(isBigInt64Array(new BigInt64Array()), true);
});
-test("Should return false for invalid BigInt64Array types", () => {
+Deno.test("Should return false for invalid BigInt64Array types", () => {
assertStrictEquals(isBigInt64Array(new BigUint64Array()), false);
assertStrictEquals(isBigInt64Array(new Float32Array()), false);
assertStrictEquals(isBigInt64Array(new Int32Array()), false);
});
// isBigUint64Array
-test("Should return true for valid isBigUint64Array types", () => {
+Deno.test("Should return true for valid isBigUint64Array types", () => {
assertStrictEquals(isBigUint64Array(new BigUint64Array()), true);
});
-test("Should return false for invalid isBigUint64Array types", () => {
+Deno.test("Should return false for invalid isBigUint64Array types", () => {
assertStrictEquals(isBigUint64Array(new BigInt64Array()), false);
assertStrictEquals(isBigUint64Array(new Float32Array()), false);
assertStrictEquals(isBigUint64Array(new Int32Array()), false);
});
// isBooleanObject
-test("Should return true for valid Boolean object types", () => {
+Deno.test("Should return true for valid Boolean object types", () => {
assertStrictEquals(isBooleanObject(new Boolean(false)), true);
assertStrictEquals(isBooleanObject(new Boolean(true)), true);
});
-test("Should return false for invalid isBigUint64Array types", () => {
+Deno.test("Should return false for invalid isBigUint64Array types", () => {
assertStrictEquals(isBooleanObject(false), false);
assertStrictEquals(isBooleanObject(true), false);
assertStrictEquals(isBooleanObject(Boolean(false)), false);
@@ -171,35 +169,35 @@ test("Should return false for invalid isBigUint64Array types", () => {
});
// isBoxedPrimitive
-test("Should return true for valid boxed primitive values", () => {
+Deno.test("Should return true for valid boxed primitive values", () => {
assertStrictEquals(isBoxedPrimitive(new Boolean(false)), true);
assertStrictEquals(isBoxedPrimitive(Object(Symbol("foo"))), true);
assertStrictEquals(isBoxedPrimitive(Object(BigInt(5))), true);
assertStrictEquals(isBoxedPrimitive(new String("foo")), true);
});
-test("Should return false for invalid boxed primitive values", () => {
+Deno.test("Should return false for invalid boxed primitive values", () => {
assertStrictEquals(isBoxedPrimitive(false), false);
assertStrictEquals(isBoxedPrimitive(Symbol("foo")), false);
});
// isDateView
-test("Should return true for valid DataView types", () => {
+Deno.test("Should return true for valid DataView types", () => {
assertStrictEquals(isDataView(new DataView(new ArrayBuffer(0))), true);
});
-test("Should return false for invalid DataView types", () => {
+Deno.test("Should return false for invalid DataView types", () => {
assertStrictEquals(isDataView(new Float64Array(0)), false);
});
// isDate
-test("Should return true for valid date types", () => {
+Deno.test("Should return true for valid date types", () => {
assertStrictEquals(isDate(new Date()), true);
assertStrictEquals(isDate(new Date(0)), true);
assertStrictEquals(isDate(new (eval("Date"))()), true);
});
-test("Should return false for invalid date types", () => {
+Deno.test("Should return false for invalid date types", () => {
assertStrictEquals(isDate(Date()), false);
assertStrictEquals(isDate({}), false);
assertStrictEquals(isDate([]), false);
@@ -208,34 +206,34 @@ test("Should return false for invalid date types", () => {
});
// isFloat32Array
-test("Should return true for valid Float32Array types", () => {
+Deno.test("Should return true for valid Float32Array types", () => {
assertStrictEquals(isFloat32Array(new Float32Array(0)), true);
});
-test("Should return false for invalid Float32Array types", () => {
+Deno.test("Should return false for invalid Float32Array types", () => {
assertStrictEquals(isFloat32Array(new ArrayBuffer(0)), false);
assertStrictEquals(isFloat32Array(new Float64Array(0)), false);
});
// isFloat64Array
-test("Should return true for valid Float64Array types", () => {
+Deno.test("Should return true for valid Float64Array types", () => {
assertStrictEquals(isFloat64Array(new Float64Array(0)), true);
});
-test("Should return false for invalid Float64Array types", () => {
+Deno.test("Should return false for invalid Float64Array types", () => {
assertStrictEquals(isFloat64Array(new ArrayBuffer(0)), false);
assertStrictEquals(isFloat64Array(new Uint8Array(0)), false);
});
// isGeneratorFunction
-test("Should return true for valid generator functions", () => {
+Deno.test("Should return true for valid generator functions", () => {
assertStrictEquals(
isGeneratorFunction(function* foo() {}),
true
);
});
-test("Should return false for invalid generator functions", () => {
+Deno.test("Should return false for invalid generator functions", () => {
assertStrictEquals(
isGeneratorFunction(function foo() {}),
false
@@ -243,12 +241,12 @@ test("Should return false for invalid generator functions", () => {
});
// isGeneratorObject
-test("Should return true for valid generator object types", () => {
+Deno.test("Should return true for valid generator object types", () => {
function* foo(): Iterator<void> {}
assertStrictEquals(isGeneratorObject(foo()), true);
});
-test("Should return false for invalid generation object types", () => {
+Deno.test("Should return false for invalid generation object types", () => {
assertStrictEquals(
isGeneratorObject(function* foo() {}),
false
@@ -256,52 +254,52 @@ test("Should return false for invalid generation object types", () => {
});
// isInt8Array
-test("Should return true for valid Int8Array types", () => {
+Deno.test("Should return true for valid Int8Array types", () => {
assertStrictEquals(isInt8Array(new Int8Array(0)), true);
});
-test("Should return false for invalid Int8Array types", () => {
+Deno.test("Should return false for invalid Int8Array types", () => {
assertStrictEquals(isInt8Array(new ArrayBuffer(0)), false);
assertStrictEquals(isInt8Array(new Float64Array(0)), false);
});
// isInt16Array
-test("Should return true for valid Int16Array types", () => {
+Deno.test("Should return true for valid Int16Array types", () => {
assertStrictEquals(isInt16Array(new Int16Array(0)), true);
});
-test("Should return false for invalid Int16Array type", () => {
+Deno.test("Should return false for invalid Int16Array type", () => {
assertStrictEquals(isInt16Array(new ArrayBuffer(0)), false);
assertStrictEquals(isInt16Array(new Float64Array(0)), false);
});
// isInt32Array
-test("Should return true for valid isInt32Array types", () => {
+Deno.test("Should return true for valid isInt32Array types", () => {
assertStrictEquals(isInt32Array(new Int32Array(0)), true);
});
-test("Should return false for invalid isInt32Array type", () => {
+Deno.test("Should return false for invalid isInt32Array type", () => {
assertStrictEquals(isInt32Array(new ArrayBuffer(0)), false);
assertStrictEquals(isInt32Array(new Float64Array(0)), false);
});
// isStringObject
-test("Should return true for valid String types", () => {
+Deno.test("Should return true for valid String types", () => {
assertStrictEquals(isStringObject(new String("")), true);
assertStrictEquals(isStringObject(new String("Foo")), true);
});
-test("Should return false for invalid String types", () => {
+Deno.test("Should return false for invalid String types", () => {
assertStrictEquals(isStringObject(""), false);
assertStrictEquals(isStringObject("Foo"), false);
});
// isMap
-test("Should return true for valid Map types", () => {
+Deno.test("Should return true for valid Map types", () => {
assertStrictEquals(isMap(new Map()), true);
});
-test("Should return false for invalid Map types", () => {
+Deno.test("Should return false for invalid Map types", () => {
assertStrictEquals(isMap({}), false);
assertStrictEquals(isMap([]), false);
assertStrictEquals(isMap(new Date()), false);
@@ -309,7 +307,7 @@ test("Should return false for invalid Map types", () => {
});
// isMapIterator
-test("Should return true for valid Map Iterator types", () => {
+Deno.test("Should return true for valid Map Iterator types", () => {
const map = new Map();
assertStrictEquals(isMapIterator(map.keys()), true);
assertStrictEquals(isMapIterator(map.values()), true);
@@ -317,7 +315,7 @@ test("Should return true for valid Map Iterator types", () => {
assertStrictEquals(isMapIterator(map[Symbol.iterator]()), true);
});
-test("Should return false for invalid Map iterator types", () => {
+Deno.test("Should return false for invalid Map iterator types", () => {
assertStrictEquals(isMapIterator(new Map()), false);
assertStrictEquals(isMapIterator([]), false);
assertStrictEquals(isMapIterator(new Date()), false);
@@ -325,70 +323,70 @@ test("Should return false for invalid Map iterator types", () => {
});
// isModuleNamespaceObject
-test("Should return true for valid module namespace objects", () => {
+Deno.test("Should return true for valid module namespace objects", () => {
assertStrictEquals(isModuleNamespaceObject(testModuleNamespaceOpbject), true);
});
-test("Should return false for invalid module namespace objects", () => {
+Deno.test("Should return false for invalid module namespace objects", () => {
assertStrictEquals(isModuleNamespaceObject(assertStrictEquals), false);
});
// isNativeError
-test("Should return true for valid Error types", () => {
+Deno.test("Should return true for valid Error types", () => {
assertStrictEquals(isNativeError(new Error()), true);
assertStrictEquals(isNativeError(new TypeError()), true);
assertStrictEquals(isNativeError(new RangeError()), true);
});
-test("Should return false for invalid Error types", () => {
+Deno.test("Should return false for invalid Error types", () => {
assertStrictEquals(isNativeError(null), false);
assertStrictEquals(isNativeError(NaN), false);
});
// isNumberObject
-test("Should return true for valid number objects", () => {
+Deno.test("Should return true for valid number objects", () => {
assertStrictEquals(isNumberObject(new Number(0)), true);
});
-test("Should return false for invalid number types", () => {
+Deno.test("Should return false for invalid number types", () => {
assertStrictEquals(isNumberObject(0), false);
});
// isBigIntObject
-test("Should return true for valid number objects", () => {
+Deno.test("Should return true for valid number objects", () => {
assertStrictEquals(isBigIntObject(new Object(BigInt(42))), true);
});
-test("Should return false for invalid number types", () => {
+Deno.test("Should return false for invalid number types", () => {
assertStrictEquals(isBigIntObject(BigInt(42)), false);
});
// isPromise
-test("Should return true for valid Promise types", () => {
+Deno.test("Should return true for valid Promise types", () => {
assertStrictEquals(isPromise(Promise.resolve(42)), true);
});
-test("Should return false for invalid Promise types", () => {
+Deno.test("Should return false for invalid Promise types", () => {
assertStrictEquals(isPromise(new Object()), false);
});
// isRegExp
-test("Should return true for valid RegExp", () => {
+Deno.test("Should return true for valid RegExp", () => {
assertStrictEquals(isRegExp(/abc/), true);
assertStrictEquals(isRegExp(new RegExp("abc")), true);
});
-test("Should return false for invalid RegExp types", () => {
+Deno.test("Should return false for invalid RegExp types", () => {
assertStrictEquals(isRegExp({}), false);
assertStrictEquals(isRegExp("/abc/"), false);
});
// isSet
-test("Should return true for valid Set types", () => {
+Deno.test("Should return true for valid Set types", () => {
assertStrictEquals(isSet(new Set()), true);
});
-test("Should return false for invalid Set types", () => {
+Deno.test("Should return false for invalid Set types", () => {
assertStrictEquals(isSet({}), false);
assertStrictEquals(isSet([]), false);
assertStrictEquals(isSet(new Map()), false);
@@ -396,7 +394,7 @@ test("Should return false for invalid Set types", () => {
});
// isSetIterator
-test("Should return true for valid Set Iterator types", () => {
+Deno.test("Should return true for valid Set Iterator types", () => {
const set = new Set();
assertStrictEquals(isSetIterator(set.keys()), true);
assertStrictEquals(isSetIterator(set.values()), true);
@@ -404,7 +402,7 @@ test("Should return true for valid Set Iterator types", () => {
assertStrictEquals(isSetIterator(set[Symbol.iterator]()), true);
});
-test("Should return false for invalid Set Iterator types", () => {
+Deno.test("Should return false for invalid Set Iterator types", () => {
assertStrictEquals(isSetIterator(new Set()), false);
assertStrictEquals(isSetIterator([]), false);
assertStrictEquals(isSetIterator(new Map()), false);
@@ -412,100 +410,100 @@ test("Should return false for invalid Set Iterator types", () => {
});
// isSharedArrayBuffer
-test("Should return true for valid SharedArrayBuffer types", () => {
+Deno.test("Should return true for valid SharedArrayBuffer types", () => {
assertStrictEquals(isSharedArrayBuffer(new SharedArrayBuffer(0)), true);
});
-test("Should return false for invalid SharedArrayBuffer types", () => {
+Deno.test("Should return false for invalid SharedArrayBuffer types", () => {
assertStrictEquals(isSharedArrayBuffer(new ArrayBuffer(0)), false);
});
// isStringObject
-test("Should return true for valid String Object types", () => {
+Deno.test("Should return true for valid String Object types", () => {
assertStrictEquals(isStringObject(new String("")), true);
assertStrictEquals(isStringObject(new String("Foo")), true);
});
-test("Should return false for invalid String Object types", () => {
+Deno.test("Should return false for invalid String Object types", () => {
assertStrictEquals(isStringObject(""), false);
assertStrictEquals(isStringObject("Foo"), false);
});
// isSymbolObject
-test("Should return true for valid Symbol types", () => {
+Deno.test("Should return true for valid Symbol types", () => {
assertStrictEquals(isSymbolObject(Object(Symbol("foo"))), true);
});
-test("Should return false for invalid Symbol types", () => {
+Deno.test("Should return false for invalid Symbol types", () => {
assertStrictEquals(isSymbolObject(Symbol("foo")), false);
});
// isTypedArray
-test("Should return true for valid TypedArray types", () => {
+Deno.test("Should return true for valid TypedArray types", () => {
assertStrictEquals(isTypedArray(new Uint8Array(0)), true);
assertStrictEquals(isTypedArray(new Float64Array(0)), true);
});
-test("Should return false for invalid TypedArray types", () => {
+Deno.test("Should return false for invalid TypedArray types", () => {
assertStrictEquals(isTypedArray(new ArrayBuffer(0)), false);
});
// isUint8Array
-test("Should return true for valid Uint8Array types", () => {
+Deno.test("Should return true for valid Uint8Array types", () => {
assertStrictEquals(isUint8Array(new Uint8Array(0)), true);
});
-test("Should return false for invalid Uint8Array types", () => {
+Deno.test("Should return false for invalid Uint8Array types", () => {
assertStrictEquals(isUint8Array(new ArrayBuffer(0)), false);
assertStrictEquals(isUint8Array(new Float64Array(0)), false);
});
// isUint8ClampedArray
-test("Should return true for valid Uint8ClampedArray types", () => {
+Deno.test("Should return true for valid Uint8ClampedArray types", () => {
assertStrictEquals(isUint8ClampedArray(new Uint8ClampedArray(0)), true);
});
-test("Should return false for invalid Uint8Array types", () => {
+Deno.test("Should return false for invalid Uint8Array types", () => {
assertStrictEquals(isUint8ClampedArray(new ArrayBuffer(0)), false);
assertStrictEquals(isUint8ClampedArray(new Float64Array(0)), false);
});
// isUint16Array
-test("Should return true for valid isUint16Array types", () => {
+Deno.test("Should return true for valid isUint16Array types", () => {
assertStrictEquals(isUint16Array(new Uint16Array(0)), true);
});
-test("Should return false for invalid Uint16Array types", () => {
+Deno.test("Should return false for invalid Uint16Array types", () => {
assertStrictEquals(isUint16Array(new ArrayBuffer(0)), false);
assertStrictEquals(isUint16Array(new Float64Array(0)), false);
});
// isUint32Array
-test("Should return true for valid Uint32Array types", () => {
+Deno.test("Should return true for valid Uint32Array types", () => {
assertStrictEquals(isUint32Array(new Uint32Array(0)), true);
});
-test("Should return false for invalid isUint16Array types", () => {
+Deno.test("Should return false for invalid isUint16Array types", () => {
assertStrictEquals(isUint32Array(new ArrayBuffer(0)), false);
assertStrictEquals(isUint32Array(new Float64Array(0)), false);
});
// isWeakMap
-test("Should return true for valid WeakMap types", () => {
+Deno.test("Should return true for valid WeakMap types", () => {
assertStrictEquals(isWeakMap(new WeakMap()), true);
});
-test("Should return false for invalid WeakMap types", () => {
+Deno.test("Should return false for invalid WeakMap types", () => {
assertStrictEquals(isWeakMap(new Set()), false);
assertStrictEquals(isWeakMap(new Map()), false);
});
// isWeakSet
-test("Should return true for valid WeakSet types", () => {
+Deno.test("Should return true for valid WeakSet types", () => {
assertStrictEquals(isWeakSet(new WeakSet()), true);
});
-test("Should return false for invalid WeakSet types", () => {
+Deno.test("Should return false for invalid WeakSet types", () => {
assertStrictEquals(isWeakSet(new Set()), false);
assertStrictEquals(isWeakSet(new Map()), false);
});
generated by cgit v1.2.3 (git 2.25.1) at 2025-06-27 17:44:15 +0000