foster/denoland-deno
1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2025-01-11 08:33:43 -05:00
Code Issues Packages 1 Wiki Activity

Fix eslint warnings (#2151)

Browse source 
Co-authored-by: Bartek Iwańczuk <biwanczuk@gmail.com>
Co-authored-by: LE GOFF Vincent <g_n_s@hotmail.fr>
This commit is contained in:
Ryan Dahl 2019-04-21 16:40:10 -04:00 committed by GitHub
parent 6cded14bdf
commit 9dfebbc949
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
75 changed files with 1110 additions and 931 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
js/blob.ts
View file

@ -60,8 +60,8 @@ function processBlobParts(
// instead of dynamic allocation.
const uint8Arrays = toUint8Arrays(blobParts, normalizeLineEndingsToNative);
const byteLength = uint8Arrays
.map(u8 => u8.byteLength)
.reduce((a, b) => a + b, 0);
.map((u8): number => u8.byteLength)
.reduce((a, b): number => a + b, 0);
const ab = new ArrayBuffer(byteLength);
const bytes = new Uint8Array(ab);

8
js/blob_test.ts
View file

@ -1,14 +1,14 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
import { test, assert, assertEquals } from "./test_util.ts";
test(function blobString() {
test(function blobString(): void {
const b1 = new Blob(["Hello World"]);
const str = "Test";
const b2 = new Blob([b1, str]);
assertEquals(b2.size, b1.size + str.length);
});
test(function blobBuffer() {
test(function blobBuffer(): void {
const buffer = new ArrayBuffer(12);
const u8 = new Uint8Array(buffer);
const f1 = new Float32Array(buffer);
@ -18,7 +18,7 @@ test(function blobBuffer() {
assertEquals(b2.size, 3 * u8.length);
});
test(function blobSlice() {
test(function blobSlice(): void {
const blob = new Blob(["Deno", "Foo"]);
const b1 = blob.slice(0, 3, "Text/HTML");
assert(b1 instanceof Blob);
@ -32,7 +32,7 @@ test(function blobSlice() {
assertEquals(b4.size, blob.size);
});
test(function blobShouldNotThrowError() {
test(function blobShouldNotThrowError(): void {
let hasThrown = false;
try {

24
js/buffer_test.ts
View file

@ -76,13 +76,13 @@ function repeat(c: string, bytes: number): Uint8Array {
return ui8;
}
test(function bufferNewBuffer() {
test(function bufferNewBuffer(): void {
init();
const buf = new Buffer(testBytes.buffer as ArrayBuffer);
check(buf, testString);
});
test(async function bufferBasicOperations() {
test(async function bufferBasicOperations(): Promise<void> {
init();
let buf = new Buffer();
for (let i = 0; i < 5; i++) {
@ -120,7 +120,7 @@ test(async function bufferBasicOperations() {
}
});
test(async function bufferReadEmptyAtEOF() {
test(async function bufferReadEmptyAtEOF(): Promise<void> {
// check that EOF of 'buf' is not reached (even though it's empty) if
// results are written to buffer that has 0 length (ie. it can't store any data)
let buf = new Buffer();
@ -130,7 +130,7 @@ test(async function bufferReadEmptyAtEOF() {
assertEquals(result.eof, false);
});
test(async function bufferLargeByteWrites() {
test(async function bufferLargeByteWrites(): Promise<void> {
init();
const buf = new Buffer();
const limit = 9;
@ -141,7 +141,7 @@ test(async function bufferLargeByteWrites() {
check(buf, "");
});
test(async function bufferTooLargeByteWrites() {
test(async function bufferTooLargeByteWrites(): Promise<void> {
init();
const tmp = new Uint8Array(72);
const growLen = Number.MAX_VALUE;
@ -160,7 +160,7 @@ test(async function bufferTooLargeByteWrites() {
assertEquals(err.name, "TooLarge");
});
test(async function bufferLargeByteReads() {
test(async function bufferLargeByteReads(): Promise<void> {
init();
const buf = new Buffer();
for (let i = 3; i < 30; i += 3) {
@ -171,12 +171,12 @@ test(async function bufferLargeByteReads() {
check(buf, "");
});
test(function bufferCapWithPreallocatedSlice() {
test(function bufferCapWithPreallocatedSlice(): void {
const buf = new Buffer(new ArrayBuffer(10));
assertEquals(buf.capacity, 10);
});
test(async function bufferReadFrom() {
test(async function bufferReadFrom(): Promise<void> {
init();
const buf = new Buffer();
for (let i = 3; i < 30; i += 3) {
@ -193,7 +193,7 @@ test(async function bufferReadFrom() {
}
});
test(async function bufferReadFromSync() {
test(async function bufferReadFromSync(): Promise<void> {
init();
const buf = new Buffer();
for (let i = 3; i < 30; i += 3) {
@ -210,7 +210,7 @@ test(async function bufferReadFromSync() {
}
});
test(async function bufferTestGrow() {
test(async function bufferTestGrow(): Promise<void> {
const tmp = new Uint8Array(72);
for (let startLen of [0, 100, 1000, 10000, 100000]) {
const xBytes = repeat("x", startLen);
@ -234,7 +234,7 @@ test(async function bufferTestGrow() {
}
});
test(async function testReadAll() {
test(async function testReadAll(): Promise<void> {
init();
const reader = new Buffer(testBytes.buffer as ArrayBuffer);
const actualBytes = await readAll(reader);
@ -244,7 +244,7 @@ test(async function testReadAll() {
}
});
test(function testReadAllSync() {
test(function testReadAllSync(): void {
init();
const reader = new Buffer(testBytes.buffer as ArrayBuffer);
const actualBytes = readAllSync(reader);

4
js/build_test.ts
View file

@ -1,7 +1,7 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
import { test, assert } from "./test_util.ts";
test(function buildInfo() {
test(function buildInfo(): void {
// Deno.build is injected by rollup at compile time. Here
// we check it has been properly transformed.
const { arch, os } = Deno.build;
@ -9,6 +9,6 @@ test(function buildInfo() {
assert(os === "mac" || os === "win" || os === "linux");
});
test(function buildGnArgs() {
test(function buildGnArgs(): void {
assert(Deno.build.args.length > 100);
});

88
js/chmod_test.ts
View file

@ -3,7 +3,7 @@ import { testPerm, assertEquals } from "./test_util.ts";
const isNotWindows = Deno.build.os !== "win";
testPerm({ read: true, write: true }, function chmodSyncSuccess() {
testPerm({ read: true, write: true }, function chmodSyncSuccess(): void {
const enc = new TextEncoder();
const data = enc.encode("Hello");
const tempDir = Deno.makeTempDirSync();
@ -22,30 +22,33 @@ testPerm({ read: true, write: true }, function chmodSyncSuccess() {
// Check symlink when not on windows
if (isNotWindows) {
testPerm({ read: true, write: true }, function chmodSyncSymlinkSuccess() {
const enc = new TextEncoder();
const data = enc.encode("Hello");
const tempDir = Deno.makeTempDirSync();
testPerm(
{ read: true, write: true },
function chmodSyncSymlinkSuccess(): void {
const enc = new TextEncoder();
const data = enc.encode("Hello");
const tempDir = Deno.makeTempDirSync();
const filename = tempDir + "/test.txt";
Deno.writeFileSync(filename, data, { perm: 0o666 });
const symlinkName = tempDir + "/test_symlink.txt";
Deno.symlinkSync(filename, symlinkName);
const filename = tempDir + "/test.txt";
Deno.writeFileSync(filename, data, { perm: 0o666 });
const symlinkName = tempDir + "/test_symlink.txt";
Deno.symlinkSync(filename, symlinkName);
let symlinkInfo = Deno.lstatSync(symlinkName);
const symlinkMode = symlinkInfo.mode & 0o777; // platform dependent
let symlinkInfo = Deno.lstatSync(symlinkName);
const symlinkMode = symlinkInfo.mode & 0o777; // platform dependent
Deno.chmodSync(symlinkName, 0o777);
Deno.chmodSync(symlinkName, 0o777);
// Change actual file mode, not symlink
const fileInfo = Deno.statSync(filename);
assertEquals(fileInfo.mode & 0o777, 0o777);
symlinkInfo = Deno.lstatSync(symlinkName);
assertEquals(symlinkInfo.mode & 0o777, symlinkMode);
});
// Change actual file mode, not symlink
const fileInfo = Deno.statSync(filename);
assertEquals(fileInfo.mode & 0o777, 0o777);
symlinkInfo = Deno.lstatSync(symlinkName);
assertEquals(symlinkInfo.mode & 0o777, symlinkMode);
}
);
}
testPerm({ write: true }, function chmodSyncFailure() {
testPerm({ write: true }, function chmodSyncFailure(): void {
let err;
try {
const filename = "/badfile.txt";
@ -57,7 +60,7 @@ testPerm({ write: true }, function chmodSyncFailure() {
assertEquals(err.name, "NotFound");
});
testPerm({ write: false }, function chmodSyncPerm() {
testPerm({ write: false }, function chmodSyncPerm(): void {
let err;
try {
Deno.chmodSync("/somefile.txt", 0o777);
@ -68,7 +71,9 @@ testPerm({ write: false }, function chmodSyncPerm() {
assertEquals(err.name, "PermissionDenied");
});
testPerm({ read: true, write: true }, async function chmodSuccess() {
testPerm({ read: true, write: true }, async function chmodSuccess(): Promise<
void
> {
const enc = new TextEncoder();
const data = enc.encode("Hello");
const tempDir = Deno.makeTempDirSync();
@ -87,30 +92,33 @@ testPerm({ read: true, write: true }, async function chmodSuccess() {
// Check symlink when not on windows
if (isNotWindows) {
testPerm({ read: true, write: true }, async function chmodSymlinkSuccess() {
const enc = new TextEncoder();
const data = enc.encode("Hello");
const tempDir = Deno.makeTempDirSync();
testPerm(
{ read: true, write: true },
async function chmodSymlinkSuccess(): Promise<void> {
const enc = new TextEncoder();
const data = enc.encode("Hello");
const tempDir = Deno.makeTempDirSync();
const filename = tempDir + "/test.txt";
Deno.writeFileSync(filename, data, { perm: 0o666 });
const symlinkName = tempDir + "/test_symlink.txt";
Deno.symlinkSync(filename, symlinkName);
const filename = tempDir + "/test.txt";
Deno.writeFileSync(filename, data, { perm: 0o666 });
const symlinkName = tempDir + "/test_symlink.txt";
Deno.symlinkSync(filename, symlinkName);
let symlinkInfo = Deno.lstatSync(symlinkName);
const symlinkMode = symlinkInfo.mode & 0o777; // platform dependent
let symlinkInfo = Deno.lstatSync(symlinkName);
const symlinkMode = symlinkInfo.mode & 0o777; // platform dependent
await Deno.chmod(symlinkName, 0o777);
await Deno.chmod(symlinkName, 0o777);
// Just change actual file mode, not symlink
const fileInfo = Deno.statSync(filename);
assertEquals(fileInfo.mode & 0o777, 0o777);
symlinkInfo = Deno.lstatSync(symlinkName);
assertEquals(symlinkInfo.mode & 0o777, symlinkMode);
});
// Just change actual file mode, not symlink
const fileInfo = Deno.statSync(filename);
assertEquals(fileInfo.mode & 0o777, 0o777);
symlinkInfo = Deno.lstatSync(symlinkName);
assertEquals(symlinkInfo.mode & 0o777, symlinkMode);
}
);
}
testPerm({ write: true }, async function chmodFailure() {
testPerm({ write: true }, async function chmodFailure(): Promise<void> {
let err;
try {
const filename = "/badfile.txt";
@ -122,7 +130,7 @@ testPerm({ write: true }, async function chmodFailure() {
assertEquals(err.name, "NotFound");
});
testPerm({ write: false }, async function chmodPerm() {
testPerm({ write: false }, async function chmodPerm(): Promise<void> {
let err;
try {
await Deno.chmod("/somefile.txt", 0o777);

6
js/compiler.ts
View file

@ -349,7 +349,7 @@ class Compiler implements ts.LanguageServiceHost, ts.FormatDiagnosticsHost {
// so we will ignore complaints about this compiler setting.
...service
.getCompilerOptionsDiagnostics()
.filter(diagnostic => diagnostic.code !== 5070),
.filter((diagnostic): boolean => diagnostic.code !== 5070),
...service.getSyntacticDiagnostics(fileName),
...service.getSemanticDiagnostics(fileName)
];
@ -519,9 +519,9 @@ window.TextEncoder = TextEncoder;
// provide the "main" function that will be called by the privileged side when
// lazy instantiating the compiler web worker
window.compilerMain = function compilerMain() {
window.compilerMain = function compilerMain(): void {
// workerMain should have already been called since a compiler is a worker.
window.onmessage = ({ data }: { data: CompilerLookup }) => {
window.onmessage = ({ data }: { data: CompilerLookup }): void => {
const { specifier, referrer, cmdId } = data;
try {

88
js/console.ts
View file

@ -171,7 +171,7 @@ function createArrayString(
typeName: "Array",
displayName: "",
delims: ["[", "]"],
entryHandler: (el, ctx, level, maxLevel) =>
entryHandler: (el, ctx, level, maxLevel): string =>
stringifyWithQuotes(el, ctx, level + 1, maxLevel)
};
return createIterableString(value, ctx, level, maxLevel, printConfig);
@ -188,7 +188,7 @@ function createTypedArrayString(
typeName: typedArrayName,
displayName: typedArrayName,
delims: ["[", "]"],
entryHandler: (el, ctx, level, maxLevel) =>
entryHandler: (el, ctx, level, maxLevel): string =>
stringifyWithQuotes(el, ctx, level + 1, maxLevel)
};
return createIterableString(value, ctx, level, maxLevel, printConfig);
@ -204,7 +204,7 @@ function createSetString(
typeName: "Set",
displayName: "Set",
delims: ["{", "}"],
entryHandler: (el, ctx, level, maxLevel) =>
entryHandler: (el, ctx, level, maxLevel): string =>
stringifyWithQuotes(el, ctx, level + 1, maxLevel)
};
return createIterableString(value, ctx, level, maxLevel, printConfig);
@ -220,7 +220,7 @@ function createMapString(
typeName: "Map",
displayName: "Map",
delims: ["{", "}"],
entryHandler: (el, ctx, level, maxLevel) => {
entryHandler: (el, ctx, level, maxLevel): string => {
const [key, val] = el;
return `${stringifyWithQuotes(
key,
@ -288,18 +288,20 @@ function createRawObjectString(
shouldShowClassName = true;
}
const keys = Object.keys(value);
const entries: string[] = keys.map(key => {
if (keys.length > OBJ_ABBREVIATE_SIZE) {
return key;
} else {
return `${key}: ${stringifyWithQuotes(
value[key],
ctx,
level + 1,
maxLevel
)}`;
const entries: string[] = keys.map(
(key): string => {
if (keys.length > OBJ_ABBREVIATE_SIZE) {
return key;
} else {
return `${key}: ${stringifyWithQuotes(
value[key],
ctx,
level + 1,
maxLevel
)}`;
}
}
});
);
ctx.delete(value);
@ -514,7 +516,7 @@ export class Console {
info = this.log;
/** Writes the properties of the supplied `obj` to stdout */
dir = (obj: unknown, options: ConsoleOptions = {}) => {
dir = (obj: unknown, options: ConsoleOptions = {}): void => {
this.log(stringifyArgs([obj], options));
};
@ -601,7 +603,7 @@ export class Console {
const toTable = (header: string[], body: string[][]): void =>
this.log(cliTable(header, body));
const createColumn = (value: unknown, shift?: number): string[] => [
...(shift ? [...new Array(shift)].map(() => "") : []),
...(shift ? [...new Array(shift)].map((): string => "") : []),
stringifyValue(value)
];
@ -617,39 +619,43 @@ export class Console {
let idx = 0;
resultData = {};
data.forEach((v: unknown, k: unknown) => {
resultData[idx] = { Key: k, Values: v };
idx++;
});
data.forEach(
(v: unknown, k: unknown): void => {
resultData[idx] = { Key: k, Values: v };
idx++;
}
);
} else {
resultData = data!;
}
Object.keys(resultData).forEach((k, idx) => {
const value: unknown = resultData[k]!;
Object.keys(resultData).forEach(
(k, idx): void => {
const value: unknown = resultData[k]!;
if (value !== null && typeof value === "object") {
Object.entries(value as { [key: string]: unknown }).forEach(
([k, v]) => {
if (properties && !properties.includes(k)) {
return;
if (value !== null && typeof value === "object") {
Object.entries(value as { [key: string]: unknown }).forEach(
([k, v]): void => {
if (properties && !properties.includes(k)) {
return;
}
if (objectValues[k]) {
objectValues[k].push(stringifyValue(v));
} else {
objectValues[k] = createColumn(v, idx);
}
}
);
if (objectValues[k]) {
objectValues[k].push(stringifyValue(v));
} else {
objectValues[k] = createColumn(v, idx);
}
}
);
values.push("");
} else {
values.push(stringifyValue(value));
}
values.push("");
} else {
values.push(stringifyValue(value));
indexKeys.push(k);
}
indexKeys.push(k);
});
);
const headerKeys = Object.keys(objectValues);
const bodyValues = Object.values(objectValues);

8
js/console_table.ts
View file

@ -53,9 +53,9 @@ function renderRow(row: string[], columnWidths: number[]): string {
export function cliTable(head: string[], columns: string[][]): string {
const rows: string[][] = [];
const columnWidths = head.map((h: string) => countBytes(h));
const columnWidths = head.map((h: string): number => countBytes(h));
const longestColumn = columns.reduce(
(n: number, a: string[]) => Math.max(n, a.length),
(n: number, a: string[]): number => Math.max(n, a.length),
0
);
@ -72,8 +72,8 @@ export function cliTable(head: string[], columns: string[][]): string {
}
}
const divider = columnWidths.map((i: number) =>
tableChars.middleMiddle.repeat(i + 2)
const divider = columnWidths.map(
(i: number): string => tableChars.middleMiddle.repeat(i + 2)
);
let result =

371
js/console_test.ts
View file

@ -12,7 +12,7 @@ function stringify(...args: unknown[]): string {
// test cases from web-platform-tests
// via https://github.com/web-platform-tests/wpt/blob/master/console/console-is-a-namespace.any.js
test(function consoleShouldBeANamespace() {
test(function consoleShouldBeANamespace(): void {
const prototype1 = Object.getPrototypeOf(console);
const prototype2 = Object.getPrototypeOf(prototype1);
@ -20,12 +20,12 @@ test(function consoleShouldBeANamespace() {
assertEquals(prototype2, Object.prototype);
});
test(function consoleHasRightInstance() {
test(function consoleHasRightInstance(): void {
assert(console instanceof Console);
assertEquals({} instanceof Console, false);
});
test(function consoleTestAssertShouldNotThrowError() {
test(function consoleTestAssertShouldNotThrowError(): void {
console.assert(true);
let hasThrown = undefined;
@ -38,13 +38,13 @@ test(function consoleTestAssertShouldNotThrowError() {
assertEquals(hasThrown, false);
});
test(function consoleTestStringifyComplexObjects() {
test(function consoleTestStringifyComplexObjects(): void {
assertEquals(stringify("foo"), "foo");
assertEquals(stringify(["foo", "bar"]), `[ "foo", "bar" ]`);
assertEquals(stringify({ foo: "bar" }), `{ foo: "bar" }`);
});
test(function consoleTestStringifyLongStrings() {
test(function consoleTestStringifyLongStrings(): void {
const veryLongString = "a".repeat(200);
// If we stringify an object containing the long string, it gets abbreviated.
let actual = stringify({ veryLongString });
@ -55,15 +55,16 @@ test(function consoleTestStringifyLongStrings() {
assertEquals(actual, veryLongString);
});
test(function consoleTestStringifyCircular() {
/* eslint-disable @typescript-eslint/explicit-function-return-type */
test(function consoleTestStringifyCircular(): void {
class Base {
a = 1;
m1(): void {}
m1() {}
}
class Extended extends Base {
b = 2;
m2(): void {}
m2() {}
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
@ -121,8 +122,11 @@ test(function consoleTestStringifyCircular() {
assertEquals(stringify(null), "null");
assertEquals(stringify(undefined), "undefined");
assertEquals(stringify(new Extended()), "Extended { a: 1, b: 2 }");
assertEquals(stringify(function f() {}), "[Function: f]");
assertEquals(stringify(async function af() {}), "[AsyncFunction: af]");
assertEquals(stringify(function f(): void {}), "[Function: f]");
assertEquals(
stringify(async function af(): Promise<void> {}),
"[AsyncFunction: af]"
);
assertEquals(stringify(function* gf() {}), "[GeneratorFunction: gf]");
assertEquals(
stringify(async function* agf() {}),
@ -143,8 +147,9 @@ test(function consoleTestStringifyCircular() {
// test inspect is working the same
assertEquals(inspect(nestedObj), nestedObjExpected);
});
/* eslint-enable @typescript-eslint/explicit-function-return-type */
test(function consoleTestStringifyWithDepth() {
test(function consoleTestStringifyWithDepth(): void {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const nestedObj: any = { a: { b: { c: { d: { e: { f: 42 } } } } } };
assertEquals(
@ -167,7 +172,7 @@ test(function consoleTestStringifyWithDepth() {
);
});
test(function consoleTestWithIntegerFormatSpecifier() {
test(function consoleTestWithIntegerFormatSpecifier(): void {
assertEquals(stringify("%i"), "%i");
assertEquals(stringify("%i", 42.0), "42");
assertEquals(stringify("%i", 42), "42");
@ -186,7 +191,7 @@ test(function consoleTestWithIntegerFormatSpecifier() {
);
});
test(function consoleTestWithFloatFormatSpecifier() {
test(function consoleTestWithFloatFormatSpecifier(): void {
assertEquals(stringify("%f"), "%f");
assertEquals(stringify("%f", 42.0), "42");
assertEquals(stringify("%f", 42), "42");
@ -202,7 +207,7 @@ test(function consoleTestWithFloatFormatSpecifier() {
assertEquals(stringify("%f %f", 42), "42 %f");
});
test(function consoleTestWithStringFormatSpecifier() {
test(function consoleTestWithStringFormatSpecifier(): void {
assertEquals(stringify("%s"), "%s");
assertEquals(stringify("%s", undefined), "undefined");
assertEquals(stringify("%s", "foo"), "foo");
@ -213,7 +218,7 @@ test(function consoleTestWithStringFormatSpecifier() {
assertEquals(stringify("%s", Symbol("foo")), "Symbol(foo)");
});
test(function consoleTestWithObjectFormatSpecifier() {
test(function consoleTestWithObjectFormatSpecifier(): void {
assertEquals(stringify("%o"), "%o");
assertEquals(stringify("%o", 42), "42");
assertEquals(stringify("%o", "foo"), "foo");
@ -225,7 +230,7 @@ test(function consoleTestWithObjectFormatSpecifier() {
);
});
test(function consoleTestWithVariousOrInvalidFormatSpecifier() {
test(function consoleTestWithVariousOrInvalidFormatSpecifier(): void {
assertEquals(stringify("%s:%s"), "%s:%s");
assertEquals(stringify("%i:%i"), "%i:%i");
assertEquals(stringify("%d:%d"), "%d:%d");
@ -241,14 +246,14 @@ test(function consoleTestWithVariousOrInvalidFormatSpecifier() {
assertEquals(stringify("abc%", 1), "abc% 1");
});
test(function consoleTestCallToStringOnLabel() {
test(function consoleTestCallToStringOnLabel(): void {
const methods = ["count", "countReset", "time", "timeLog", "timeEnd"];
for (const method of methods) {
let hasCalled = false;
console[method]({
toString() {
toString(): void {
hasCalled = true;
}
});
@ -257,7 +262,7 @@ test(function consoleTestCallToStringOnLabel() {
}
});
test(function consoleTestError() {
test(function consoleTestError(): void {
class MyError extends Error {
constructor(errStr: string) {
super(errStr);
@ -275,12 +280,12 @@ test(function consoleTestError() {
}
});
test(function consoleTestClear() {
test(function consoleTestClear(): void {
const stdoutWrite = stdout.write;
const uint8 = new TextEncoder().encode("\x1b[1;1H" + "\x1b[0J");
let buffer = new Uint8Array(0);
stdout.write = async u8 => {
stdout.write = async (u8: Uint8Array): Promise<number> => {
const tmp = new Uint8Array(buffer.length + u8.length);
tmp.set(buffer, 0);
tmp.set(u8, buffer.length);
@ -294,7 +299,7 @@ test(function consoleTestClear() {
});
// Test bound this issue
test(function consoleDetachedLog() {
test(function consoleDetachedLog(): void {
const log = console.log;
const dir = console.dir;
const debug = console.debug;
@ -352,7 +357,7 @@ function mockConsole(f: ConsoleExamineFunc): void {
const err = new StringBuffer();
const both = new StringBuffer();
const csl = new Console(
(x: string, isErr: boolean, printsNewLine: boolean) => {
(x: string, isErr: boolean, printsNewLine: boolean): void => {
const content = x + (printsNewLine ? "\n" : "");
const buf = isErr ? err : out;
buf.add(content);
@ -363,27 +368,28 @@ function mockConsole(f: ConsoleExamineFunc): void {
}
// console.group test
test(function consoleGroup() {
mockConsole((console, out) => {
console.group("1");
console.log("2");
console.group("3");
console.log("4");
console.groupEnd();
console.groupEnd();
test(function consoleGroup(): void {
mockConsole(
(console, out): void => {
console.group("1");
console.log("2");
console.group("3");
console.log("4");
console.groupEnd();
console.groupEnd();
console.groupCollapsed("5");
console.log("6");
console.group("7");
console.log("8");
console.groupEnd();
console.groupEnd();
console.log("9");
console.log("10");
console.groupCollapsed("5");
console.log("6");
console.group("7");
console.log("8");
console.groupEnd();
console.groupEnd();
console.log("9");
console.log("10");
assertEquals(
out.toString(),
`1
assertEquals(
out.toString(),
`1
2
3
4
@ -391,36 +397,38 @@ test(function consoleGroup() {
9
10
`
);
});
);
}
);
});
// console.group with console.warn test
test(function consoleGroupWarn() {
mockConsole((console, _out, _err, both) => {
console.warn("1");
console.group();
console.warn("2");
console.group();
console.warn("3");
console.groupEnd();
console.warn("4");
console.groupEnd();
console.warn("5");
test(function consoleGroupWarn(): void {
mockConsole(
(console, _out, _err, both): void => {
console.warn("1");
console.group();
console.warn("2");
console.group();
console.warn("3");
console.groupEnd();
console.warn("4");
console.groupEnd();
console.warn("5");
console.groupCollapsed();
console.warn("6");
console.group();
console.warn("7");
console.groupEnd();
console.warn("8");
console.groupEnd();
console.groupCollapsed();
console.warn("6");
console.group();
console.warn("7");
console.groupEnd();
console.warn("8");
console.groupEnd();
console.warn("9");
console.warn("10");
assertEquals(
both.toString(),
`1
console.warn("9");
console.warn("10");
assertEquals(
both.toString(),
`1
2
3
4
@ -429,43 +437,49 @@ test(function consoleGroupWarn() {
9
10
`
);
});
);
}
);
});
// console.table test
test(function consoleTable() {
mockConsole((console, out) => {
console.table({ a: "test", b: 1 });
assertEquals(
out.toString(),
`┌─────────┬────────┐
test(function consoleTable(): void {
mockConsole(
(console, out): void => {
console.table({ a: "test", b: 1 });
assertEquals(
out.toString(),
`┌─────────┬────────┐
│ (index) │ Values │
├─────────┼────────┤
│ a │ "test" │
│ b │ 1 │
└─────────┴────────┘
`
);
});
mockConsole((console, out) => {
console.table({ a: { b: 10 }, b: { b: 20, c: 30 } }, ["c"]);
assertEquals(
out.toString(),
`┌─────────┬────┐
);
}
);
mockConsole(
(console, out): void => {
console.table({ a: { b: 10 }, b: { b: 20, c: 30 } }, ["c"]);
assertEquals(
out.toString(),
`┌─────────┬────┐
│ (index) │ c │
├─────────┼────┤
│ a │ │
│ b │ 30 │
└─────────┴────┘
`
);
});
mockConsole((console, out) => {
console.table([1, 2, [3, [4]], [5, 6], [[7], [8]]]);
assertEquals(
out.toString(),
`┌─────────┬───────┬───────┬────────┐
);
}
);
mockConsole(
(console, out): void => {
console.table([1, 2, [3, [4]], [5, 6], [[7], [8]]]);
assertEquals(
out.toString(),
`┌─────────┬───────┬───────┬────────┐
│ (index) │ 0 │ 1 │ Values │
├─────────┼───────┼───────┼────────┤
│ 0 │ │ │ 1 │
@ -475,13 +489,15 @@ test(function consoleTable() {
│ 4 │ [ 7 ] │ [ 8 ] │ │
└─────────┴───────┴───────┴────────┘
`
);
});
mockConsole((console, out) => {
console.table(new Set([1, 2, 3, "test"]));
assertEquals(
out.toString(),
`┌───────────────────┬────────┐
);
}
);
mockConsole(
(console, out): void => {
console.table(new Set([1, 2, 3, "test"]));
assertEquals(
out.toString(),
`┌───────────────────┬────────┐
│ (iteration index) │ Values │
├───────────────────┼────────┤
│ 0 │ 1 │
@ -490,32 +506,36 @@ test(function consoleTable() {
│ 3 │ "test" │
└───────────────────┴────────┘
`
);
});
mockConsole((console, out) => {
console.table(new Map([[1, "one"], [2, "two"]]));
assertEquals(
out.toString(),
`┌───────────────────┬─────┬────────┐
);
}
);
mockConsole(
(console, out): void => {
console.table(new Map([[1, "one"], [2, "two"]]));
assertEquals(
out.toString(),
`┌───────────────────┬─────┬────────┐
│ (iteration index) │ Key │ Values │
├───────────────────┼─────┼────────┤
│ 0 │ 1 │ "one" │
│ 1 │ 2 │ "two" │
└───────────────────┴─────┴────────┘
`
);
});
mockConsole((console, out) => {
console.table({
a: true,
b: { c: { d: 10 }, e: [1, 2, [5, 6]] },
f: "test",
g: new Set([1, 2, 3, "test"]),
h: new Map([[1, "one"]])
});
assertEquals(
out.toString(),
`┌─────────┬───────────┬───────────────────┬────────┐
);
}
);
mockConsole(
(console, out): void => {
console.table({
a: true,
b: { c: { d: 10 }, e: [1, 2, [5, 6]] },
f: "test",
g: new Set([1, 2, 3, "test"]),
h: new Map([[1, "one"]])
});
assertEquals(
out.toString(),
`┌─────────┬───────────┬───────────────────┬────────┐
│ (index) │ c │ e │ Values │
├─────────┼───────────┼───────────────────┼────────┤
│ a │ │ │ true │
@ -525,19 +545,21 @@ test(function consoleTable() {
│ h │ │ │ │
└─────────┴───────────┴───────────────────┴────────┘
`
);
});
mockConsole((console, out) => {
console.table([
1,
"test",
false,
{ a: 10 },
["test", { b: 20, c: "test" }]
]);
assertEquals(
out.toString(),
`┌─────────┬────────┬──────────────────────┬────┬────────┐
);
}
);
mockConsole(
(console, out): void => {
console.table([
1,
"test",
false,
{ a: 10 },
["test", { b: 20, c: "test" }]
]);
assertEquals(
out.toString(),
`┌─────────┬────────┬──────────────────────┬────┬────────┐
│ (index) │ 0 │ 1 │ a │ Values │
├─────────┼────────┼──────────────────────┼────┼────────┤
│ 0 │ │ │ │ 1 │
@ -547,60 +569,71 @@ test(function consoleTable() {
│ 4 │ "test" │ { b: 20, c: "test" } │ │ │
└─────────┴────────┴──────────────────────┴────┴────────┘
`
);
});
mockConsole((console, out) => {
console.table([]);
assertEquals(
out.toString(),
`┌─────────┐
);
}
);
mockConsole(
(console, out): void => {
console.table([]);
assertEquals(
out.toString(),
`┌─────────┐
│ (index) │
├─────────┤
└─────────┘
`
);
});
mockConsole((console, out) => {
console.table({});
assertEquals(
out.toString(),
`┌─────────┐
);
}
);
mockConsole(
(console, out): void => {
console.table({});
assertEquals(
out.toString(),
`┌─────────┐
│ (index) │
├─────────┤
└─────────┘
`
);
});
mockConsole((console, out) => {
console.table(new Set());
assertEquals(
out.toString(),
`┌───────────────────┐
);
}
);
mockConsole(
(console, out): void => {
console.table(new Set());
assertEquals(
out.toString(),
`┌───────────────────┐
│ (iteration index) │
├───────────────────┤
└───────────────────┘
`
);
});
mockConsole((console, out) => {
console.table(new Map());
assertEquals(
out.toString(),
`┌───────────────────┐
);
}
);
mockConsole(
(console, out): void => {
console.table(new Map());
assertEquals(
out.toString(),
`┌───────────────────┐
│ (iteration index) │
├───────────────────┤
└───────────────────┘
`
);
});
mockConsole((console, out) => {
console.table("test");
assertEquals(out.toString(), "test\n");
});
);
}
);
mockConsole(
(console, out): void => {
console.table("test");
assertEquals(out.toString(), "test\n");
}
);
});
// console.log(Error) test
test(function consoleLogShouldNotThrowError() {
test(function consoleLogShouldNotThrowError(): void {
let result = 0;
try {
console.log(new Error("foo"));
@ -611,8 +644,10 @@ test(function consoleLogShouldNotThrowError() {
assertEquals(result, 1);
// output errors to the console should not include "Uncaught"
mockConsole((console, out) => {
console.log(new Error("foo"));
assertEquals(out.toString().includes("Uncaught"), false);
});
mockConsole(
(console, out): void => {
console.log(new Error("foo"));
assertEquals(out.toString().includes("Uncaught"), false);
}
);
});

55
js/copy_file_test.ts
View file

@ -19,7 +19,7 @@ function assertSameContent(filename1: string, filename2: string): void {
assertEquals(data1, data2);
}
testPerm({ read: true, write: true }, function copyFileSyncSuccess() {
testPerm({ read: true, write: true }, function copyFileSyncSuccess(): void {
const tempDir = Deno.makeTempDirSync();
const fromFilename = tempDir + "/from.txt";
const toFilename = tempDir + "/to.txt";
@ -31,7 +31,7 @@ testPerm({ read: true, write: true }, function copyFileSyncSuccess() {
assertSameContent(fromFilename, toFilename);
});
testPerm({ write: true, read: true }, function copyFileSyncFailure() {
testPerm({ write: true, read: true }, function copyFileSyncFailure(): void {
const tempDir = Deno.makeTempDirSync();
const fromFilename = tempDir + "/from.txt";
const toFilename = tempDir + "/to.txt";
@ -47,7 +47,7 @@ testPerm({ write: true, read: true }, function copyFileSyncFailure() {
assertEquals(err.name, "NotFound");
});
testPerm({ write: true, read: false }, function copyFileSyncPerm1() {
testPerm({ write: true, read: false }, function copyFileSyncPerm1(): void {
let caughtError = false;
try {
Deno.copyFileSync("/from.txt", "/to.txt");
@ -59,7 +59,7 @@ testPerm({ write: true, read: false }, function copyFileSyncPerm1() {
assert(caughtError);
});
testPerm({ write: false, read: true }, function copyFileSyncPerm2() {
testPerm({ write: false, read: true }, function copyFileSyncPerm2(): void {
let caughtError = false;
try {
Deno.copyFileSync("/from.txt", "/to.txt");
@ -71,7 +71,7 @@ testPerm({ write: false, read: true }, function copyFileSyncPerm2() {
assert(caughtError);
});
testPerm({ read: true, write: true }, function copyFileSyncOverwrite() {
testPerm({ read: true, write: true }, function copyFileSyncOverwrite(): void {
const tempDir = Deno.makeTempDirSync();
const fromFilename = tempDir + "/from.txt";
const toFilename = tempDir + "/to.txt";
@ -85,7 +85,9 @@ testPerm({ read: true, write: true }, function copyFileSyncOverwrite() {
assertSameContent(fromFilename, toFilename);
});
testPerm({ read: true, write: true }, async function copyFileSuccess() {
testPerm({ read: true, write: true }, async function copyFileSuccess(): Promise<
void
> {
const tempDir = Deno.makeTempDirSync();
const fromFilename = tempDir + "/from.txt";
const toFilename = tempDir + "/to.txt";
@ -97,7 +99,9 @@ testPerm({ read: true, write: true }, async function copyFileSuccess() {
assertSameContent(fromFilename, toFilename);
});
testPerm({ read: true, write: true }, async function copyFileFailure() {
testPerm({ read: true, write: true }, async function copyFileFailure(): Promise<
void
> {
const tempDir = Deno.makeTempDirSync();
const fromFilename = tempDir + "/from.txt";
const toFilename = tempDir + "/to.txt";
@ -113,21 +117,26 @@ testPerm({ read: true, write: true }, async function copyFileFailure() {
assertEquals(err.name, "NotFound");
});
testPerm({ read: true, write: true }, async function copyFileOverwrite() {
const tempDir = Deno.makeTempDirSync();
const fromFilename = tempDir + "/from.txt";
const toFilename = tempDir + "/to.txt";
writeFileString(fromFilename, "Hello world!");
// Make Dest exist and have different content
writeFileString(toFilename, "Goodbye!");
await Deno.copyFile(fromFilename, toFilename);
// No change to original file
assertEquals(readFileString(fromFilename), "Hello world!");
// Original == Dest
assertSameContent(fromFilename, toFilename);
});
testPerm(
{ read: true, write: true },
async function copyFileOverwrite(): Promise<void> {
const tempDir = Deno.makeTempDirSync();
const fromFilename = tempDir + "/from.txt";
const toFilename = tempDir + "/to.txt";
writeFileString(fromFilename, "Hello world!");
// Make Dest exist and have different content
writeFileString(toFilename, "Goodbye!");
await Deno.copyFile(fromFilename, toFilename);
// No change to original file
assertEquals(readFileString(fromFilename), "Hello world!");
// Original == Dest
assertSameContent(fromFilename, toFilename);
}
);
testPerm({ read: false, write: true }, async function copyFilePerm1() {
testPerm({ read: false, write: true }, async function copyFilePerm1(): Promise<
void
> {
let caughtError = false;
try {
await Deno.copyFile("/from.txt", "/to.txt");
@ -139,7 +148,9 @@ testPerm({ read: false, write: true }, async function copyFilePerm1() {
assert(caughtError);
});
testPerm({ read: true, write: false }, async function copyFilePerm2() {
testPerm({ read: true, write: false }, async function copyFilePerm2(): Promise<
void
> {
let caughtError = false;
try {
await Deno.copyFile("/from.txt", "/to.txt");

4
js/custom_event_test.ts
View file

@ -1,7 +1,7 @@
// Copyright 2018 the Deno authors. All rights reserved. MIT license.
import { test, assertEquals } from "./test_util.ts";
test(function customEventInitializedWithDetail() {
test(function customEventInitializedWithDetail(): void {
const type = "touchstart";
const detail = { message: "hello" };
const customEventDict = new CustomEventInit({
@ -20,7 +20,7 @@ test(function customEventInitializedWithDetail() {
assertEquals(event.type, type);
});
test(function toStringShouldBeWebCompatibility() {
test(function toStringShouldBeWebCompatibility(): void {
const type = "touchstart";
const event = new CustomEvent(type, {});
assertEquals(event.toString(), "[object CustomEvent]");

8
js/dir_test.ts
View file

@ -1,11 +1,11 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
import { test, testPerm, assert, assertEquals } from "./test_util.ts";
test(function dirCwdNotNull() {
test(function dirCwdNotNull(): void {
assert(Deno.cwd() != null);
});
testPerm({ write: true }, function dirCwdChdirSuccess() {
testPerm({ write: true }, function dirCwdChdirSuccess(): void {
const initialdir = Deno.cwd();
const path = Deno.makeTempDirSync();
Deno.chdir(path);
@ -18,7 +18,7 @@ testPerm({ write: true }, function dirCwdChdirSuccess() {
Deno.chdir(initialdir);
});
testPerm({ write: true }, function dirCwdError() {
testPerm({ write: true }, function dirCwdError(): void {
// excluding windows since it throws resource busy, while removeSync
if (["linux", "mac"].includes(Deno.build.os)) {
const initialdir = Deno.cwd();
@ -39,7 +39,7 @@ testPerm({ write: true }, function dirCwdError() {
}
});
testPerm({ write: true }, function dirChdirError() {
testPerm({ write: true }, function dirChdirError(): void {
const path = Deno.makeTempDirSync() + "test";
try {
Deno.chdir(path);

2
js/event_target.ts
View file

@ -32,7 +32,7 @@ export class EventTarget implements domTypes.EventTarget {
requiredArguments("EventTarget.removeEventListener", arguments.length, 2);
if (hasOwnProperty(this.listeners, type) && callback !== null) {
this.listeners[type] = this.listeners[type].filter(
listener => listener !== callback
(listener): boolean => listener !== callback
);
}
}

16
js/event_target_test.ts
View file

@ -1,7 +1,7 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
import { test, assertEquals } from "./test_util.ts";
test(function addEventListenerTest() {
test(function addEventListenerTest(): void {
const document = new EventTarget();
assertEquals(document.addEventListener("x", null, false), undefined);
@ -9,7 +9,7 @@ test(function addEventListenerTest() {
assertEquals(document.addEventListener("x", null), undefined);
});
test(function constructedEventTargetCanBeUsedAsExpected() {
test(function constructedEventTargetCanBeUsedAsExpected(): void {
const target = new EventTarget();
const event = new Event("foo", { bubbles: true, cancelable: false });
let callCount = 0;
@ -32,7 +32,7 @@ test(function constructedEventTargetCanBeUsedAsExpected() {
assertEquals(callCount, 2);
});
test(function anEventTargetCanBeSubclassed() {
test(function anEventTargetCanBeSubclassed(): void {
class NicerEventTarget extends EventTarget {
on(type, callback?, options?): void {
this.addEventListener(type, callback, options);
@ -58,14 +58,14 @@ test(function anEventTargetCanBeSubclassed() {
assertEquals(callCount, 0);
});
test(function removingNullEventListenerShouldSucceed() {
test(function removingNullEventListenerShouldSucceed(): void {
const document = new EventTarget();
assertEquals(document.removeEventListener("x", null, false), undefined);
assertEquals(document.removeEventListener("x", null, true), undefined);
assertEquals(document.removeEventListener("x", null), undefined);
});
test(function constructedEventTargetUseObjectPrototype() {
test(function constructedEventTargetUseObjectPrototype(): void {
const target = new EventTarget();
const event = new Event("toString", { bubbles: true, cancelable: false });
let callCount = 0;
@ -88,12 +88,12 @@ test(function constructedEventTargetUseObjectPrototype() {
assertEquals(callCount, 2);
});
test(function toStringShouldBeWebCompatibility() {
test(function toStringShouldBeWebCompatibility(): void {
const target = new EventTarget();
assertEquals(target.toString(), "[object EventTarget]");
});
test(function dispatchEventShouldNotThrowError() {
test(function dispatchEventShouldNotThrowError(): void {
let hasThrown = false;
try {
@ -102,7 +102,7 @@ test(function dispatchEventShouldNotThrowError() {
bubbles: true,
cancelable: false
});
target.addEventListener("hasOwnProperty", () => {});
target.addEventListener("hasOwnProperty", (): void => {});
target.dispatchEvent(event);
} catch {
hasThrown = true;

14
js/event_test.ts
View file

@ -1,7 +1,7 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
import { test, assertEquals } from "./test_util.ts";
test(function eventInitializedWithType() {
test(function eventInitializedWithType(): void {
const type = "click";
const event = new Event(type);
@ -13,7 +13,7 @@ test(function eventInitializedWithType() {
assertEquals(event.cancelable, false);
});
test(function eventInitializedWithTypeAndDict() {
test(function eventInitializedWithTypeAndDict(): void {
const init = "submit";
const eventInitDict = new EventInit({ bubbles: true, cancelable: true });
const event = new Event(init, eventInitDict);
@ -26,7 +26,7 @@ test(function eventInitializedWithTypeAndDict() {
assertEquals(event.cancelable, true);
});
test(function eventComposedPathSuccess() {
test(function eventComposedPathSuccess(): void {
const type = "click";
const event = new Event(type);
const composedPath = event.composedPath();
@ -34,7 +34,7 @@ test(function eventComposedPathSuccess() {
assertEquals(composedPath, []);
});
test(function eventStopPropagationSuccess() {
test(function eventStopPropagationSuccess(): void {
const type = "click";
const event = new Event(type);
@ -43,7 +43,7 @@ test(function eventStopPropagationSuccess() {
assertEquals(event.cancelBubble, true);
});
test(function eventStopImmediatePropagationSuccess() {
test(function eventStopImmediatePropagationSuccess(): void {
const type = "click";
const event = new Event(type);
@ -54,7 +54,7 @@ test(function eventStopImmediatePropagationSuccess() {
assertEquals(event.cancelBubbleImmediately, true);
});
test(function eventPreventDefaultSuccess() {
test(function eventPreventDefaultSuccess(): void {
const type = "click";
const event = new Event(type);
@ -69,7 +69,7 @@ test(function eventPreventDefaultSuccess() {
assertEquals(cancelableEvent.defaultPrevented, true);
});
test(function eventInitializedWithNonStringType() {
test(function eventInitializedWithNonStringType(): void {
const type = undefined;
const event = new Event(type);

32
js/fetch.ts
View file

@ -19,10 +19,10 @@ function getHeaderValueParams(value: string): Map<string, string> {
value
.split(";")
.slice(1)
.map(s => s.trim().split("="))
.filter(arr => arr.length > 1)
.map(([k, v]) => [k, v.replace(/^"([^"]*)"$/, "$1")])
.forEach(([k, v]) => params.set(k, v));
.map((s): string[] => s.trim().split("="))
.filter((arr): boolean => arr.length > 1)
.map(([k, v]): [string, string] => [k, v.replace(/^"([^"]*)"$/, "$1")])
.forEach(([k, v]): Map<string, string> => params.set(k, v));
return params;
}
@ -116,7 +116,7 @@ class Body implements domTypes.Body, domTypes.ReadableStream, io.ReadCloser {
// (as long as it is not part of `delimiter`)
bodyParts = bodyPreambleTrimmed
.split(delimiter)
.map(s => s.replace(/^[\s\r\n\t]+/, ""));
.map((s): string => s.replace(/^[\s\r\n\t]+/, ""));
// TODO: LWSP definition is actually trickier,
// but should be fine in our case since without headers
// we should just discard the part
@ -184,17 +184,19 @@ class Body implements domTypes.Body, domTypes.ReadableStream, io.ReadCloser {
body
.trim()
.split("&")
.forEach(bytes => {
if (bytes) {
const split = bytes.split("=");
const name = split.shift()!.replace(/\+/g, " ");
const value = split.join("=").replace(/\+/g, " ");
formData.append(
decodeURIComponent(name),
decodeURIComponent(value)
);
.forEach(
(bytes): void => {
if (bytes) {
const split = bytes.split("=");
const name = split.shift()!.replace(/\+/g, " ");
const value = split.join("=").replace(/\+/g, " ");
formData.append(
decodeURIComponent(name),
decodeURIComponent(value)
);
}
}
});
);
} catch (e) {
throw new TypeError("Invalid form urlencoded format");
}

59
js/fetch_test.ts
View file

@ -1,13 +1,13 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
import { test, testPerm, assert, assertEquals } from "./test_util.ts";
testPerm({ net: true }, async function fetchJsonSuccess() {
testPerm({ net: true }, async function fetchJsonSuccess(): Promise<void> {
const response = await fetch("http://localhost:4545/package.json");
const json = await response.json();
assertEquals(json.name, "deno");
});
test(async function fetchPerm() {
test(async function fetchPerm(): Promise<void> {
let err;
try {
await fetch("http://localhost:4545/package.json");
@ -18,14 +18,14 @@ test(async function fetchPerm() {
assertEquals(err.name, "PermissionDenied");
});
testPerm({ net: true }, async function fetchHeaders() {
testPerm({ net: true }, async function fetchHeaders(): Promise<void> {
const response = await fetch("http://localhost:4545/package.json");
const headers = response.headers;
assertEquals(headers.get("Content-Type"), "application/json");
assert(headers.get("Server").startsWith("SimpleHTTP"));
});
testPerm({ net: true }, async function fetchBlob() {
testPerm({ net: true }, async function fetchBlob(): Promise<void> {
const response = await fetch("http://localhost:4545/package.json");
const headers = response.headers;
const blob = await response.blob();
@ -33,7 +33,7 @@ testPerm({ net: true }, async function fetchBlob() {
assertEquals(blob.size, Number(headers.get("Content-Length")));
});
testPerm({ net: true }, async function responseClone() {
testPerm({ net: true }, async function responseClone(): Promise<void> {
const response = await fetch("http://localhost:4545/package.json");
const response1 = response.clone();
assert(response !== response1);
@ -46,7 +46,7 @@ testPerm({ net: true }, async function responseClone() {
}
});
testPerm({ net: true }, async function fetchEmptyInvalid() {
testPerm({ net: true }, async function fetchEmptyInvalid(): Promise<void> {
let err;
try {
await fetch("");
@ -57,7 +57,9 @@ testPerm({ net: true }, async function fetchEmptyInvalid() {
assertEquals(err.name, "InvalidUri");
});
testPerm({ net: true }, async function fetchMultipartFormDataSuccess() {
testPerm({ net: true }, async function fetchMultipartFormDataSuccess(): Promise<
void
> {
const response = await fetch(
"http://localhost:4545/tests/subdir/multipart_form_data.txt"
);
@ -72,18 +74,21 @@ testPerm({ net: true }, async function fetchMultipartFormDataSuccess() {
// Currently we cannot read from file...
});
testPerm({ net: true }, async function fetchURLEncodedFormDataSuccess() {
const response = await fetch(
"http://localhost:4545/tests/subdir/form_urlencoded.txt"
);
const formData = await response.formData();
assert(formData.has("field_1"));
assertEquals(formData.get("field_1").toString(), "Hi");
assert(formData.has("field_2"));
assertEquals(formData.get("field_2").toString(), "<Deno>");
});
testPerm(
{ net: true },
async function fetchURLEncodedFormDataSuccess(): Promise<void> {
const response = await fetch(
"http://localhost:4545/tests/subdir/form_urlencoded.txt"
);
const formData = await response.formData();
assert(formData.has("field_1"));
assertEquals(formData.get("field_1").toString(), "Hi");
assert(formData.has("field_2"));
assertEquals(formData.get("field_2").toString(), "<Deno>");
}
);
testPerm({ net: true }, async function fetchInitStringBody() {
testPerm({ net: true }, async function fetchInitStringBody(): Promise<void> {
const data = "Hello World";
const response = await fetch("http://localhost:4545/echo_server", {
method: "POST",
@ -94,7 +99,9 @@ testPerm({ net: true }, async function fetchInitStringBody() {
assert(response.headers.get("content-type").startsWith("text/plain"));
});
testPerm({ net: true }, async function fetchInitTypedArrayBody() {
testPerm({ net: true }, async function fetchInitTypedArrayBody(): Promise<
void
> {
const data = "Hello World";
const response = await fetch("http://localhost:4545/echo_server", {
method: "POST",
@ -104,7 +111,9 @@ testPerm({ net: true }, async function fetchInitTypedArrayBody() {
assertEquals(text, data);
});
testPerm({ net: true }, async function fetchInitURLSearchParamsBody() {
testPerm({ net: true }, async function fetchInitURLSearchParamsBody(): Promise<
void
> {
const data = "param1=value1&param2=value2";
const params = new URLSearchParams(data);
const response = await fetch("http://localhost:4545/echo_server", {
@ -120,7 +129,7 @@ testPerm({ net: true }, async function fetchInitURLSearchParamsBody() {
);
});
testPerm({ net: true }, async function fetchInitBlobBody() {
testPerm({ net: true }, async function fetchInitBlobBody(): Promise<void> {
const data = "const a = 1";
const blob = new Blob([data], {
type: "text/javascript"
@ -153,7 +162,7 @@ testPerm({ net: true }, async function fetchInitBlobBody() {
// at Object.assertEquals (file:///C:/deno/js/testing/util.ts:29:11)
// at fetchPostBodyString (file
/*
/*
function bufferServer(addr: string): Deno.Buffer {
const listener = Deno.listen("tcp", addr);
const buf = new Deno.Buffer();
@ -177,7 +186,7 @@ function bufferServer(addr: string): Deno.Buffer {
return buf;
}
testPerm({ net: true }, async function fetchRequest() {
testPerm({ net: true }, async function fetchRequest():Promise<void> {
const addr = "127.0.0.1:4501";
const buf = bufferServer(addr);
const response = await fetch(`http://${addr}/blah`, {
@ -197,7 +206,7 @@ testPerm({ net: true }, async function fetchRequest() {
assertEquals(actual, expected);
});
testPerm({ net: true }, async function fetchPostBodyString() {
testPerm({ net: true }, async function fetchPostBodyString():Promise<void> {
const addr = "127.0.0.1:4502";
const buf = bufferServer(addr);
const body = "hello world";
@ -221,7 +230,7 @@ testPerm({ net: true }, async function fetchPostBodyString() {
assertEquals(actual, expected);
});
testPerm({ net: true }, async function fetchPostBodyTypedArray() {
testPerm({ net: true }, async function fetchPostBodyTypedArray():Promise<void> {
const addr = "127.0.0.1:4503";
const buf = bufferServer(addr);
const bodyStr = "hello world";

38
js/file_test.ts
View file

@ -9,47 +9,47 @@ function testFirstArgument(arg1, expectedSize): void {
assertEquals(file.type, "");
}
test(function fileEmptyFileBits() {
test(function fileEmptyFileBits(): void {
testFirstArgument([], 0);
});
test(function fileStringFileBits() {
test(function fileStringFileBits(): void {
testFirstArgument(["bits"], 4);
});
test(function fileUnicodeStringFileBits() {
test(function fileUnicodeStringFileBits(): void {
testFirstArgument(["𝓽𝓮𝔁𝓽"], 16);
});
test(function fileStringObjectFileBits() {
test(function fileStringObjectFileBits(): void {
testFirstArgument([new String("string object")], 13);
});
test(function fileEmptyBlobFileBits() {
test(function fileEmptyBlobFileBits(): void {
testFirstArgument([new Blob()], 0);
});
test(function fileBlobFileBits() {
test(function fileBlobFileBits(): void {
testFirstArgument([new Blob(["bits"])], 4);
});
test(function fileEmptyFileFileBits() {
test(function fileEmptyFileFileBits(): void {
testFirstArgument([new File([], "world.txt")], 0);
});
test(function fileFileFileBits() {
test(function fileFileFileBits(): void {
testFirstArgument([new File(["bits"], "world.txt")], 4);
});
test(function fileArrayBufferFileBits() {
test(function fileArrayBufferFileBits(): void {
testFirstArgument([new ArrayBuffer(8)], 8);
});
test(function fileTypedArrayFileBits() {
test(function fileTypedArrayFileBits(): void {
testFirstArgument([new Uint8Array([0x50, 0x41, 0x53, 0x53])], 4);
});
test(function fileVariousFileBits() {
test(function fileVariousFileBits(): void {
testFirstArgument(
[
"bits",
@ -63,15 +63,15 @@ test(function fileVariousFileBits() {
);
});
test(function fileNumberInFileBits() {
test(function fileNumberInFileBits(): void {
testFirstArgument([12], 2);
});
test(function fileArrayInFileBits() {
test(function fileArrayInFileBits(): void {
testFirstArgument([[1, 2, 3]], 5);
});
test(function fileObjectInFileBits() {
test(function fileObjectInFileBits(): void {
// "[object Object]"
testFirstArgument([{}], 15);
});
@ -82,22 +82,22 @@ function testSecondArgument(arg2, expectedFileName): void {
assertEquals(file.name, expectedFileName);
}
test(function fileUsingFileName() {
test(function fileUsingFileName(): void {
testSecondArgument("dummy", "dummy");
});
test(function fileUsingSpecialCharacterInFileName() {
test(function fileUsingSpecialCharacterInFileName(): void {
testSecondArgument("dummy/foo", "dummy:foo");
});
test(function fileUsingNullFileName() {
test(function fileUsingNullFileName(): void {
testSecondArgument(null, "null");
});
test(function fileUsingNumberFileName() {
test(function fileUsingNumberFileName(): void {
testSecondArgument(1, "1");
});
test(function fileUsingEmptyStringFileName() {
test(function fileUsingEmptyStringFileName(): void {
testSecondArgument("", "");
});

106
js/files_test.ts
View file

@ -1,13 +1,13 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
import { test, testPerm, assert, assertEquals } from "./test_util.ts";
test(function filesStdioFileDescriptors() {
test(function filesStdioFileDescriptors(): void {
assertEquals(Deno.stdin.rid, 0);
assertEquals(Deno.stdout.rid, 1);
assertEquals(Deno.stderr.rid, 2);
});
testPerm({ read: true }, async function filesCopyToStdout() {
testPerm({ read: true }, async function filesCopyToStdout(): Promise<void> {
const filename = "package.json";
const file = await Deno.open(filename);
assert(file.rid > 2);
@ -17,7 +17,7 @@ testPerm({ read: true }, async function filesCopyToStdout() {
console.log("bytes written", bytesWritten);
});
testPerm({ read: true }, async function filesToAsyncIterator() {
testPerm({ read: true }, async function filesToAsyncIterator(): Promise<void> {
const filename = "tests/hello.txt";
const file = await Deno.open(filename);
@ -29,7 +29,7 @@ testPerm({ read: true }, async function filesToAsyncIterator() {
assertEquals(totalSize, 12);
});
testPerm({ write: false }, async function writePermFailure() {
testPerm({ write: false }, async function writePermFailure(): Promise<void> {
const filename = "tests/hello.txt";
const writeModes: Deno.OpenMode[] = ["w", "a", "x"];
for (const mode of writeModes) {
@ -45,7 +45,7 @@ testPerm({ write: false }, async function writePermFailure() {
}
});
testPerm({ read: false }, async function readPermFailure() {
testPerm({ read: false }, async function readPermFailure(): Promise<void> {
let caughtError = false;
try {
await Deno.open("package.json", "r");
@ -57,23 +57,28 @@ testPerm({ read: false }, async function readPermFailure() {
assert(caughtError);
});
testPerm({ write: false, read: false }, async function readWritePermFailure() {
const filename = "tests/hello.txt";
const writeModes: Deno.OpenMode[] = ["r+", "w+", "a+", "x+"];
for (const mode of writeModes) {
let err;
try {
await Deno.open(filename, mode);
} catch (e) {
err = e;
testPerm(
{ write: false, read: false },
async function readWritePermFailure(): Promise<void> {
const filename = "tests/hello.txt";
const writeModes: Deno.OpenMode[] = ["r+", "w+", "a+", "x+"];
for (const mode of writeModes) {
let err;
try {
await Deno.open(filename, mode);
} catch (e) {
err = e;
}
assert(!!err);
assertEquals(err.kind, Deno.ErrorKind.PermissionDenied);
assertEquals(err.name, "PermissionDenied");
}
assert(!!err);
assertEquals(err.kind, Deno.ErrorKind.PermissionDenied);
assertEquals(err.name, "PermissionDenied");
}
});
);
testPerm({ read: true, write: true }, async function createFile() {
testPerm({ read: true, write: true }, async function createFile(): Promise<
void
> {
const tempDir = await Deno.makeTempDir();
const filename = tempDir + "/test.txt";
const f = await Deno.open(filename, "w");
@ -91,7 +96,9 @@ testPerm({ read: true, write: true }, async function createFile() {
await Deno.remove(tempDir, { recursive: true });
});
testPerm({ read: true, write: true }, async function openModeWrite() {
testPerm({ read: true, write: true }, async function openModeWrite(): Promise<
void
> {
const tempDir = Deno.makeTempDirSync();
const encoder = new TextEncoder();
const filename = tempDir + "hello.txt";
@ -125,32 +132,35 @@ testPerm({ read: true, write: true }, async function openModeWrite() {
await Deno.remove(tempDir, { recursive: true });
});
testPerm({ read: true, write: true }, async function openModeWriteRead() {
const tempDir = Deno.makeTempDirSync();
const encoder = new TextEncoder();
const filename = tempDir + "hello.txt";
const data = encoder.encode("Hello world!\n");
testPerm(
{ read: true, write: true },
async function openModeWriteRead(): Promise<void> {
const tempDir = Deno.makeTempDirSync();
const encoder = new TextEncoder();
const filename = tempDir + "hello.txt";
const data = encoder.encode("Hello world!\n");
const file = await Deno.open(filename, "w+");
// assert file was created
let fileInfo = Deno.statSync(filename);
assert(fileInfo.isFile());
assertEquals(fileInfo.len, 0);
// write some data
await file.write(data);
fileInfo = Deno.statSync(filename);
assertEquals(fileInfo.len, 13);
const file = await Deno.open(filename, "w+");
// assert file was created
let fileInfo = Deno.statSync(filename);
assert(fileInfo.isFile());
assertEquals(fileInfo.len, 0);
// write some data
await file.write(data);
fileInfo = Deno.statSync(filename);
assertEquals(fileInfo.len, 13);
const buf = new Uint8Array(20);
await file.seek(0, Deno.SeekMode.SEEK_START);
const result = await file.read(buf);
assertEquals(result.nread, 13);
file.close();
const buf = new Uint8Array(20);
await file.seek(0, Deno.SeekMode.SEEK_START);
const result = await file.read(buf);
assertEquals(result.nread, 13);
file.close();
await Deno.remove(tempDir, { recursive: true });
});
await Deno.remove(tempDir, { recursive: true });
}
);
testPerm({ read: true }, async function seekStart() {
testPerm({ read: true }, async function seekStart(): Promise<void> {
const filename = "tests/hello.txt";
const file = await Deno.open(filename);
// Deliberately move 1 step forward
@ -163,7 +173,7 @@ testPerm({ read: true }, async function seekStart() {
assertEquals(decoded, "world!");
});
testPerm({ read: true }, function seekSyncStart() {
testPerm({ read: true }, function seekSyncStart(): void {
const filename = "tests/hello.txt";
const file = Deno.openSync(filename);
// Deliberately move 1 step forward
@ -176,7 +186,7 @@ testPerm({ read: true }, function seekSyncStart() {
assertEquals(decoded, "world!");
});
testPerm({ read: true }, async function seekCurrent() {
testPerm({ read: true }, async function seekCurrent(): Promise<void> {
const filename = "tests/hello.txt";
const file = await Deno.open(filename);
// Deliberately move 1 step forward
@ -189,7 +199,7 @@ testPerm({ read: true }, async function seekCurrent() {
assertEquals(decoded, "world!");
});
testPerm({ read: true }, function seekSyncCurrent() {
testPerm({ read: true }, function seekSyncCurrent(): void {
const filename = "tests/hello.txt";
const file = Deno.openSync(filename);
// Deliberately move 1 step forward
@ -202,7 +212,7 @@ testPerm({ read: true }, function seekSyncCurrent() {
assertEquals(decoded, "world!");
});
testPerm({ read: true }, async function seekEnd() {
testPerm({ read: true }, async function seekEnd(): Promise<void> {
const filename = "tests/hello.txt";
const file = await Deno.open(filename);
await file.seek(-6, Deno.SeekMode.SEEK_END);
@ -212,7 +222,7 @@ testPerm({ read: true }, async function seekEnd() {
assertEquals(decoded, "world!");
});
testPerm({ read: true }, function seekSyncEnd() {
testPerm({ read: true }, function seekSyncEnd(): void {
const filename = "tests/hello.txt";
const file = Deno.openSync(filename);
file.seekSync(-6, Deno.SeekMode.SEEK_END);
@ -222,7 +232,7 @@ testPerm({ read: true }, function seekSyncEnd() {
assertEquals(decoded, "world!");
});
testPerm({ read: true }, async function seekMode() {
testPerm({ read: true }, async function seekMode(): Promise<void> {
const filename = "tests/hello.txt";
const file = await Deno.open(filename);
let err;

2
js/form_data.ts
View file

@ -89,7 +89,7 @@ class FormDataBase {
has(name: string): boolean {
requiredArguments("FormData.has", arguments.length, 1);
name = String(name);
return this[dataSymbol].some(entry => entry[0] === name);
return this[dataSymbol].some((entry): boolean => entry[0] === name);
}
/** Sets a new value for an existing key inside a `FormData` object, or

150
js/form_data_test.ts
View file

@ -1,17 +1,17 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
import { test, assert, assertEquals } from "./test_util.ts";
test(function formDataHasCorrectNameProp() {
test(function formDataHasCorrectNameProp(): void {
assertEquals(FormData.name, "FormData");
});
test(function formDataParamsAppendSuccess() {
test(function formDataParamsAppendSuccess(): void {
const formData = new FormData();
formData.append("a", "true");
assertEquals(formData.get("a"), "true");
});
test(function formDataParamsDeleteSuccess() {
test(function formDataParamsDeleteSuccess(): void {
const formData = new FormData();
formData.append("a", "true");
formData.append("b", "false");
@ -21,7 +21,7 @@ test(function formDataParamsDeleteSuccess() {
assertEquals(formData.get("b"), null);
});
test(function formDataParamsGetAllSuccess() {
test(function formDataParamsGetAllSuccess(): void {
const formData = new FormData();
formData.append("a", "true");
formData.append("b", "false");
@ -31,7 +31,7 @@ test(function formDataParamsGetAllSuccess() {
assertEquals(formData.getAll("c"), []);
});
test(function formDataParamsGetSuccess() {
test(function formDataParamsGetSuccess(): void {
const formData = new FormData();
formData.append("a", "true");
formData.append("b", "false");
@ -45,7 +45,7 @@ test(function formDataParamsGetSuccess() {
assertEquals(formData.get("e"), "null");
});
test(function formDataParamsHasSuccess() {
test(function formDataParamsHasSuccess(): void {
const formData = new FormData();
formData.append("a", "true");
formData.append("b", "false");
@ -54,7 +54,7 @@ test(function formDataParamsHasSuccess() {
assert(!formData.has("c"));
});
test(function formDataParamsSetSuccess() {
test(function formDataParamsSetSuccess(): void {
const formData = new FormData();
formData.append("a", "true");
formData.append("b", "false");
@ -69,7 +69,7 @@ test(function formDataParamsSetSuccess() {
assertEquals(formData.get("e"), "null");
});
test(function formDataSetEmptyBlobSuccess() {
test(function formDataSetEmptyBlobSuccess(): void {
const formData = new FormData();
formData.set("a", new Blob([]), "blank.txt");
formData.get("a");
@ -81,93 +81,99 @@ test(function formDataSetEmptyBlobSuccess() {
*/
});
test(function formDataParamsForEachSuccess() {
test(function formDataParamsForEachSuccess(): void {
const init = [["a", "54"], ["b", "true"]];
const formData = new FormData();
for (const [name, value] of init) {
formData.append(name, value);
}
let callNum = 0;
formData.forEach((value, key, parent) => {
assertEquals(formData, parent);
assertEquals(value, init[callNum][1]);
assertEquals(key, init[callNum][0]);
callNum++;
});
formData.forEach(
(value, key, parent): void => {
assertEquals(formData, parent);
assertEquals(value, init[callNum][1]);
assertEquals(key, init[callNum][0]);
callNum++;
}
);
assertEquals(callNum, init.length);
});
test(function formDataParamsArgumentsCheck() {
test(function formDataParamsArgumentsCheck(): void {
const methodRequireOneParam = ["delete", "getAll", "get", "has", "forEach"];
const methodRequireTwoParams = ["append", "set"];
methodRequireOneParam.forEach(method => {
const formData = new FormData();
let hasThrown = 0;
let errMsg = "";
try {
formData[method]();
hasThrown = 1;
} catch (err) {
errMsg = err.message;
if (err instanceof TypeError) {
hasThrown = 2;
} else {
hasThrown = 3;
methodRequireOneParam.forEach(
(method): void => {
const formData = new FormData();
let hasThrown = 0;
let errMsg = "";
try {
formData[method]();
hasThrown = 1;
} catch (err) {
errMsg = err.message;
if (err instanceof TypeError) {
hasThrown = 2;
} else {
hasThrown = 3;
}
}
assertEquals(hasThrown, 2);
assertEquals(
errMsg,
`FormData.${method} requires at least 1 argument, but only 0 present`
);
}
assertEquals(hasThrown, 2);
assertEquals(
errMsg,
`FormData.${method} requires at least 1 argument, but only 0 present`
);
});
);
methodRequireTwoParams.forEach(method => {
const formData = new FormData();
let hasThrown = 0;
let errMsg = "";
methodRequireTwoParams.forEach(
(method: string): void => {
const formData = new FormData();
let hasThrown = 0;
let errMsg = "";
try {
formData[method]();
hasThrown = 1;
} catch (err) {
errMsg = err.message;
if (err instanceof TypeError) {
hasThrown = 2;
} else {
hasThrown = 3;
try {
formData[method]();
hasThrown = 1;
} catch (err) {
errMsg = err.message;
if (err instanceof TypeError) {
hasThrown = 2;
} else {
hasThrown = 3;
}
}
}
assertEquals(hasThrown, 2);
assertEquals(
errMsg,
`FormData.${method} requires at least 2 arguments, but only 0 present`
);
assertEquals(hasThrown, 2);
assertEquals(
errMsg,
`FormData.${method} requires at least 2 arguments, but only 0 present`
);
hasThrown = 0;
errMsg = "";
try {
formData[method]("foo");
hasThrown = 1;
} catch (err) {
errMsg = err.message;
if (err instanceof TypeError) {
hasThrown = 2;
} else {
hasThrown = 3;
hasThrown = 0;
errMsg = "";
try {
formData[method]("foo");
hasThrown = 1;
} catch (err) {
errMsg = err.message;
if (err instanceof TypeError) {
hasThrown = 2;
} else {
hasThrown = 3;
}
}
assertEquals(hasThrown, 2);
assertEquals(
errMsg,
`FormData.${method} requires at least 2 arguments, but only 1 present`
);
}
assertEquals(hasThrown, 2);
assertEquals(
errMsg,
`FormData.${method} requires at least 2 arguments, but only 1 present`
);
});
);
});
test(function toStringShouldBeWebCompatibility() {
test(function toStringShouldBeWebCompatibility(): void {
const formData = new FormData();
assertEquals(formData.toString(), "[object FormData]");
});

18
js/globals_test.ts
View file

@ -1,40 +1,40 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
import { test, assert } from "./test_util.ts";
test(function globalThisExists() {
test(function globalThisExists(): void {
assert(globalThis != null);
});
test(function windowExists() {
test(function windowExists(): void {
assert(window != null);
});
test(function windowWindowExists() {
test(function windowWindowExists(): void {
assert(window.window === window);
});
test(function globalThisEqualsWindow() {
test(function globalThisEqualsWindow(): void {
// @ts-ignore (TypeScript thinks globalThis and window don't match)
assert(globalThis === window);
});
test(function DenoNamespaceExists() {
test(function DenoNamespaceExists(): void {
assert(Deno != null);
});
test(function DenoNamespaceEqualsWindowDeno() {
test(function DenoNamespaceEqualsWindowDeno(): void {
assert(Deno === window.Deno);
});
test(function DenoNamespaceIsFrozen() {
test(function DenoNamespaceIsFrozen(): void {
assert(Object.isFrozen(Deno));
});
test(function webAssemblyExists() {
test(function webAssemblyExists(): void {
assert(typeof WebAssembly.compile === "function");
});
test(function DenoNamespaceImmutable() {
test(function DenoNamespaceImmutable(): void {
const denoCopy = window.Deno;
try {
// @ts-ignore

176
js/headers_test.ts
View file

@ -4,7 +4,7 @@ import { test, assert, assertEquals } from "./test_util.ts";
// Logic heavily copied from web-platform-tests, make
// sure pass mostly header basic test
// ref: https://github.com/web-platform-tests/wpt/blob/7c50c216081d6ea3c9afe553ee7b64534020a1b2/fetch/api/headers/headers-basic.html
test(function newHeaderTest() {
test(function newHeaderTest(): void {
new Headers();
new Headers(undefined);
new Headers({});
@ -30,7 +30,7 @@ for (const name in headerDict) {
headerSeq.push([name, headerDict[name]]);
}
test(function newHeaderWithSequence() {
test(function newHeaderWithSequence(): void {
const headers = new Headers(headerSeq);
for (const name in headerDict) {
assertEquals(headers.get(name), String(headerDict[name]));
@ -38,14 +38,14 @@ test(function newHeaderWithSequence() {
assertEquals(headers.get("length"), null);
});
test(function newHeaderWithRecord() {
test(function newHeaderWithRecord(): void {
const headers = new Headers(headerDict);
for (const name in headerDict) {
assertEquals(headers.get(name), String(headerDict[name]));
}
});
test(function newHeaderWithHeadersInstance() {
test(function newHeaderWithHeadersInstance(): void {
const headers = new Headers(headerDict);
const headers2 = new Headers(headers);
for (const name in headerDict) {
@ -53,7 +53,7 @@ test(function newHeaderWithHeadersInstance() {
}
});
test(function headerAppendSuccess() {
test(function headerAppendSuccess(): void {
const headers = new Headers();
for (const name in headerDict) {
headers.append(name, headerDict[name]);
@ -61,7 +61,7 @@ test(function headerAppendSuccess() {
}
});
test(function headerSetSuccess() {
test(function headerSetSuccess(): void {
const headers = new Headers();
for (const name in headerDict) {
headers.set(name, headerDict[name]);
@ -69,7 +69,7 @@ test(function headerSetSuccess() {
}
});
test(function headerHasSuccess() {
test(function headerHasSuccess(): void {
const headers = new Headers(headerDict);
for (const name in headerDict) {
assert(headers.has(name), "headers has name " + name);
@ -80,7 +80,7 @@ test(function headerHasSuccess() {
}
});
test(function headerDeleteSuccess() {
test(function headerDeleteSuccess(): void {
const headers = new Headers(headerDict);
for (const name in headerDict) {
assert(headers.has(name), "headers have a header: " + name);
@ -89,7 +89,7 @@ test(function headerDeleteSuccess() {
}
});
test(function headerGetSuccess() {
test(function headerGetSuccess(): void {
const headers = new Headers(headerDict);
for (const name in headerDict) {
assertEquals(headers.get(name), String(headerDict[name]));
@ -97,7 +97,7 @@ test(function headerGetSuccess() {
}
});
test(function headerEntriesSuccess() {
test(function headerEntriesSuccess(): void {
const headers = new Headers(headerDict);
const iterators = headers.entries();
for (const it of iterators) {
@ -108,7 +108,7 @@ test(function headerEntriesSuccess() {
}
});
test(function headerKeysSuccess() {
test(function headerKeysSuccess(): void {
const headers = new Headers(headerDict);
const iterators = headers.keys();
for (const it of iterators) {
@ -116,7 +116,7 @@ test(function headerKeysSuccess() {
}
});
test(function headerValuesSuccess() {
test(function headerValuesSuccess(): void {
const headers = new Headers(headerDict);
const iterators = headers.values();
const entries = headers.entries();
@ -138,24 +138,28 @@ const headerEntriesDict = {
"Content-Types": "value6"
};
test(function headerForEachSuccess() {
test(function headerForEachSuccess(): void {
const headers = new Headers(headerEntriesDict);
const keys = Object.keys(headerEntriesDict);
keys.forEach(key => {
const value = headerEntriesDict[key];
const newkey = key.toLowerCase();
headerEntriesDict[newkey] = value;
});
keys.forEach(
(key): void => {
const value = headerEntriesDict[key];
const newkey = key.toLowerCase();
headerEntriesDict[newkey] = value;
}
);
let callNum = 0;
headers.forEach((value, key, container) => {
assertEquals(headers, container);
assertEquals(value, headerEntriesDict[key]);
callNum++;
});
headers.forEach(
(value, key, container): void => {
assertEquals(headers, container);
assertEquals(value, headerEntriesDict[key]);
callNum++;
}
);
assertEquals(callNum, keys.length);
});
test(function headerSymbolIteratorSuccess() {
test(function headerSymbolIteratorSuccess(): void {
assert(Symbol.iterator in Headers.prototype);
const headers = new Headers(headerEntriesDict);
for (const header of headers) {
@ -166,7 +170,7 @@ test(function headerSymbolIteratorSuccess() {
}
});
test(function headerTypesAvailable() {
test(function headerTypesAvailable(): void {
function newHeaders(): Headers {
return new Headers();
}
@ -176,7 +180,7 @@ test(function headerTypesAvailable() {
// Modified from https://github.com/bitinn/node-fetch/blob/7d3293200a91ad52b5ca7962f9d6fd1c04983edb/test/test.js#L2001-L2014
// Copyright (c) 2016 David Frank. MIT License.
test(function headerIllegalReject() {
test(function headerIllegalReject(): void {
let errorCount = 0;
try {
new Headers({ "He y": "ok" });
@ -230,7 +234,7 @@ test(function headerIllegalReject() {
});
// If pair does not contain exactly two items,then throw a TypeError.
test(function headerParamsShouldThrowTypeError() {
test(function headerParamsShouldThrowTypeError(): void {
let hasThrown = 0;
try {
@ -247,77 +251,81 @@ test(function headerParamsShouldThrowTypeError() {
assertEquals(hasThrown, 2);
});
test(function headerParamsArgumentsCheck() {
test(function headerParamsArgumentsCheck(): void {
const methodRequireOneParam = ["delete", "get", "has", "forEach"];
const methodRequireTwoParams = ["append", "set"];
methodRequireOneParam.forEach(method => {
const headers = new Headers();
let hasThrown = 0;
let errMsg = "";
try {
headers[method]();
hasThrown = 1;
} catch (err) {
errMsg = err.message;
if (err instanceof TypeError) {
hasThrown = 2;
} else {
hasThrown = 3;
methodRequireOneParam.forEach(
(method): void => {
const headers = new Headers();
let hasThrown = 0;
let errMsg = "";
try {
headers[method]();
hasThrown = 1;
} catch (err) {
errMsg = err.message;
if (err instanceof TypeError) {
hasThrown = 2;
} else {
hasThrown = 3;
}
}
assertEquals(hasThrown, 2);
assertEquals(
errMsg,
`Headers.${method} requires at least 1 argument, but only 0 present`
);
}
assertEquals(hasThrown, 2);
assertEquals(
errMsg,
`Headers.${method} requires at least 1 argument, but only 0 present`
);
});
);
methodRequireTwoParams.forEach(method => {
const headers = new Headers();
let hasThrown = 0;
let errMsg = "";
methodRequireTwoParams.forEach(
(method): void => {
const headers = new Headers();
let hasThrown = 0;
let errMsg = "";
try {
headers[method]();
hasThrown = 1;
} catch (err) {
errMsg = err.message;
if (err instanceof TypeError) {
hasThrown = 2;
} else {
hasThrown = 3;
try {
headers[method]();
hasThrown = 1;
} catch (err) {
errMsg = err.message;
if (err instanceof TypeError) {
hasThrown = 2;
} else {
hasThrown = 3;
}
}
}
assertEquals(hasThrown, 2);
assertEquals(
errMsg,
`Headers.${method} requires at least 2 arguments, but only 0 present`
);
assertEquals(hasThrown, 2);
assertEquals(
errMsg,
`Headers.${method} requires at least 2 arguments, but only 0 present`
);
hasThrown = 0;
errMsg = "";
try {
headers[method]("foo");
hasThrown = 1;
} catch (err) {
errMsg = err.message;
if (err instanceof TypeError) {
hasThrown = 2;
} else {
hasThrown = 3;
hasThrown = 0;
errMsg = "";
try {
headers[method]("foo");
hasThrown = 1;
} catch (err) {
errMsg = err.message;
if (err instanceof TypeError) {
hasThrown = 2;
} else {
hasThrown = 3;
}
}
assertEquals(hasThrown, 2);
assertEquals(
errMsg,
`Headers.${method} requires at least 2 arguments, but only 1 present`
);
}
assertEquals(hasThrown, 2);
assertEquals(
errMsg,
`Headers.${method} requires at least 2 arguments, but only 1 present`
);
});
);
});
test(function toStringShouldBeWebCompatibility() {
test(function toStringShouldBeWebCompatibility(): void {
const headers = new Headers();
assertEquals(headers.toString(), "[object Headers]");
});

2
js/io.ts
View file

@ -146,7 +146,7 @@ export function toAsyncIterator(r: Reader): AsyncIterableIterator<Uint8Array> {
const b = new Uint8Array(1024);
return {
[Symbol.asyncIterator]() {
[Symbol.asyncIterator](): AsyncIterableIterator<Uint8Array> {
return this;
},

12
js/link_test.ts
View file

@ -1,7 +1,7 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
import { test, testPerm, assert, assertEquals } from "./test_util.ts";
testPerm({ read: true, write: true }, function linkSyncSuccess() {
testPerm({ read: true, write: true }, function linkSyncSuccess(): void {
const testDir = Deno.makeTempDirSync();
const oldData = "Hardlink";
const oldName = testDir + "/oldname";
@ -28,7 +28,7 @@ testPerm({ read: true, write: true }, function linkSyncSuccess() {
assertEquals(newData3, new TextDecoder().decode(Deno.readFileSync(newName)));
});
testPerm({ read: true, write: true }, function linkSyncExists() {
testPerm({ read: true, write: true }, function linkSyncExists(): void {
const testDir = Deno.makeTempDirSync();
const oldName = testDir + "/oldname";
const newName = testDir + "/newname";
@ -48,7 +48,7 @@ testPerm({ read: true, write: true }, function linkSyncExists() {
assertEquals(err.name, "AlreadyExists");
});
testPerm({ read: true, write: true }, function linkSyncNotFound() {
testPerm({ read: true, write: true }, function linkSyncNotFound(): void {
const testDir = Deno.makeTempDirSync();
const oldName = testDir + "/oldname";
const newName = testDir + "/newname";
@ -65,7 +65,7 @@ testPerm({ read: true, write: true }, function linkSyncNotFound() {
assertEquals(err.name, "NotFound");
});
test(function linkSyncPerm() {
test(function linkSyncPerm(): void {
let err;
try {
Deno.linkSync("oldbaddir", "newbaddir");
@ -76,7 +76,9 @@ test(function linkSyncPerm() {
assertEquals(err.name, "PermissionDenied");
});
testPerm({ read: true, write: true }, async function linkSuccess() {
testPerm({ read: true, write: true }, async function linkSuccess(): Promise<
void
> {
const testDir = Deno.makeTempDirSync();
const oldData = "Hardlink";
const oldName = testDir + "/oldname";

2
js/location_test.ts
View file

@ -1,7 +1,7 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
import { test, assert } from "./test_util.ts";
test(function locationBasic() {
test(function locationBasic(): void {
// location example: file:///Users/rld/src/deno/js/unit_tests.ts
console.log("location", window.location.toString());
assert(window.location.toString().endsWith("unit_tests.ts"));

6
js/make_temp_dir_test.ts
View file

@ -1,7 +1,7 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
import { test, testPerm, assert, assertEquals } from "./test_util.ts";
testPerm({ write: true }, function makeTempDirSyncSuccess() {
testPerm({ write: true }, function makeTempDirSyncSuccess(): void {
const dir1 = Deno.makeTempDirSync({ prefix: "hello", suffix: "world" });
const dir2 = Deno.makeTempDirSync({ prefix: "hello", suffix: "world" });
// Check that both dirs are different.
@ -27,7 +27,7 @@ testPerm({ write: true }, function makeTempDirSyncSuccess() {
assertEquals(err.name, "NotFound");
});
test(function makeTempDirSyncPerm() {
test(function makeTempDirSyncPerm(): void {
// makeTempDirSync should require write permissions (for now).
let err;
try {
@ -39,7 +39,7 @@ test(function makeTempDirSyncPerm() {
assertEquals(err.name, "PermissionDenied");
});
testPerm({ write: true }, async function makeTempDirSuccess() {
testPerm({ write: true }, async function makeTempDirSuccess(): Promise<void> {
const dir1 = await Deno.makeTempDir({ prefix: "hello", suffix: "world" });
const dir2 = await Deno.makeTempDir({ prefix: "hello", suffix: "world" });
// Check that both dirs are different.

21
js/metrics_test.ts
View file

@ -1,7 +1,7 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
import { test, testPerm, assert } from "./test_util.ts";
test(async function metrics() {
test(async function metrics(): Promise<void> {
const m1 = Deno.metrics();
assert(m1.opsDispatched > 0);
assert(m1.opsCompleted > 0);
@ -22,7 +22,7 @@ test(async function metrics() {
assert(m2.bytesReceived > m1.bytesReceived);
});
testPerm({ write: true }, function metricsUpdatedIfNoResponseSync() {
testPerm({ write: true }, function metricsUpdatedIfNoResponseSync(): void {
const filename = Deno.makeTempDirSync() + "/test.txt";
const data = new Uint8Array([41, 42, 43]);
@ -32,12 +32,15 @@ testPerm({ write: true }, function metricsUpdatedIfNoResponseSync() {
assert(metrics.opsDispatched === metrics.opsCompleted);
});
testPerm({ write: true }, async function metricsUpdatedIfNoResponseAsync() {
const filename = Deno.makeTempDirSync() + "/test.txt";
testPerm(
{ write: true },
async function metricsUpdatedIfNoResponseAsync(): Promise<void> {
const filename = Deno.makeTempDirSync() + "/test.txt";
const data = new Uint8Array([41, 42, 43]);
await Deno.writeFile(filename, data, { perm: 0o666 });
const data = new Uint8Array([41, 42, 43]);
await Deno.writeFile(filename, data, { perm: 0o666 });
const metrics = Deno.metrics();
assert(metrics.opsDispatched === metrics.opsCompleted);
});
const metrics = Deno.metrics();
assert(metrics.opsDispatched === metrics.opsCompleted);
}
);

4
js/mixins/dom_iterable_test.ts
View file

@ -25,7 +25,7 @@ function setup() {
};
}
test(function testDomIterable() {
test(function testDomIterable(): void {
const { DomIterable, Base } = setup();
const fixture: Array<[string, number]> = [["foo", 1], ["bar", 2]];
@ -59,7 +59,7 @@ test(function testDomIterable() {
assertEquals(DomIterable.name, Base.name);
});
test(function testDomIterableScope() {
test(function testDomIterableScope(): void {
const { DomIterable } = setup();
const domIterable = new DomIterable([["foo", 1]]);

18
js/mkdir_test.ts
View file

@ -1,14 +1,14 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
import { testPerm, assert, assertEquals } from "./test_util.ts";
testPerm({ read: true, write: true }, function mkdirSyncSuccess() {
testPerm({ read: true, write: true }, function mkdirSyncSuccess(): void {
const path = Deno.makeTempDirSync() + "/dir";
Deno.mkdirSync(path);
const pathInfo = Deno.statSync(path);
assert(pathInfo.isDirectory());
});
testPerm({ read: true, write: true }, function mkdirSyncMode() {
testPerm({ read: true, write: true }, function mkdirSyncMode(): void {
const path = Deno.makeTempDirSync() + "/dir";
Deno.mkdirSync(path, false, 0o755); // no perm for x
const pathInfo = Deno.statSync(path);
@ -18,7 +18,7 @@ testPerm({ read: true, write: true }, function mkdirSyncMode() {
}
});
testPerm({ write: false }, function mkdirSyncPerm() {
testPerm({ write: false }, function mkdirSyncPerm(): void {
let err;
try {
Deno.mkdirSync("/baddir");
@ -29,14 +29,16 @@ testPerm({ write: false }, function mkdirSyncPerm() {
assertEquals(err.name, "PermissionDenied");
});
testPerm({ read: true, write: true }, async function mkdirSuccess() {
testPerm({ read: true, write: true }, async function mkdirSuccess(): Promise<
void
> {
const path = Deno.makeTempDirSync() + "/dir";
await Deno.mkdir(path);
const pathInfo = Deno.statSync(path);
assert(pathInfo.isDirectory());
});
testPerm({ write: true }, function mkdirErrIfExists() {
testPerm({ write: true }, function mkdirErrIfExists(): void {
let err;
try {
Deno.mkdirSync(".");
@ -47,14 +49,16 @@ testPerm({ write: true }, function mkdirErrIfExists() {
assertEquals(err.name, "AlreadyExists");
});
testPerm({ read: true, write: true }, function mkdirSyncRecursive() {
testPerm({ read: true, write: true }, function mkdirSyncRecursive(): void {
const path = Deno.makeTempDirSync() + "/nested/directory";
Deno.mkdirSync(path, true);
const pathInfo = Deno.statSync(path);
assert(pathInfo.isDirectory());
});
testPerm({ read: true, write: true }, async function mkdirRecursive() {
testPerm({ read: true, write: true }, async function mkdirRecursive(): Promise<
void
> {
const path = Deno.makeTempDirSync() + "/nested/directory";
await Deno.mkdir(path, true);
const pathInfo = Deno.statSync(path);

18
js/net_test.ts
View file

@ -1,12 +1,12 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
import { testPerm, assert, assertEquals } from "./test_util.ts";
testPerm({ net: true }, function netListenClose() {
testPerm({ net: true }, function netListenClose(): void {
const listener = Deno.listen("tcp", "127.0.0.1:4500");
listener.close();
});
testPerm({ net: true }, async function netCloseWhileAccept() {
testPerm({ net: true }, async function netCloseWhileAccept(): Promise<void> {
const listener = Deno.listen("tcp", ":4501");
const p = listener.accept();
listener.close();
@ -21,7 +21,7 @@ testPerm({ net: true }, async function netCloseWhileAccept() {
assertEquals(err.message, "Listener has been closed");
});
testPerm({ net: true }, async function netConcurrentAccept() {
testPerm({ net: true }, async function netConcurrentAccept(): Promise<void> {
const listener = Deno.listen("tcp", ":4502");
let acceptErrCount = 0;
const checkErr = (e): void => {
@ -42,12 +42,14 @@ testPerm({ net: true }, async function netConcurrentAccept() {
assertEquals(acceptErrCount, 1);
});
testPerm({ net: true }, async function netDialListen() {
testPerm({ net: true }, async function netDialListen(): Promise<void> {
const listener = Deno.listen("tcp", ":4500");
listener.accept().then(async conn => {
await conn.write(new Uint8Array([1, 2, 3]));
conn.close();
});
listener.accept().then(
async (conn): Promise<void> => {
await conn.write(new Uint8Array([1, 2, 3]));
conn.close();
}
);
const conn = await Deno.dial("tcp", "127.0.0.1:4500");
const buf = new Uint8Array(1024);
const readResult = await conn.read(buf);

2
js/os.ts
View file

@ -108,7 +108,7 @@ function createEnv(inner: msg.EnvironRes): { [index: string]: string } {
}
return new Proxy(env, {
set(obj, prop: string, value: string) {
set(obj, prop: string, value: string): boolean {
setEnv(prop, value);
return Reflect.set(obj, prop, value);
}

8
js/os_test.ts
View file

@ -1,7 +1,7 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
import { test, testPerm, assert, assertEquals } from "./test_util.ts";
testPerm({ env: true }, function envSuccess() {
testPerm({ env: true }, function envSuccess(): void {
const env = Deno.env();
assert(env !== null);
// eslint-disable-next-line @typescript-eslint/camelcase
@ -10,7 +10,7 @@ testPerm({ env: true }, function envSuccess() {
assertEquals(env.test_var, newEnv.test_var);
});
test(function envFailure() {
test(function envFailure(): void {
let caughtError = false;
try {
Deno.env();
@ -23,12 +23,12 @@ test(function envFailure() {
assert(caughtError);
});
test(function osPid() {
test(function osPid(): void {
console.log("pid", Deno.pid);
assert(Deno.pid > 0);
});
// See complete tests in tools/is_tty_test.py
test(function osIsTTYSmoke() {
test(function osIsTTYSmoke(): void {
console.log(Deno.isTTY());
});

4
js/performance_test.ts
View file

@ -1,9 +1,9 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
import { testPerm, assert } from "./test_util.ts";
testPerm({ highPrecision: false }, function now() {
testPerm({ highPrecision: false }, function now(): void {
const start = performance.now();
setTimeout(() => {
setTimeout((): void => {
const end = performance.now();
assert(end - start >= 10);
}, 10);

2
js/permissions_test.ts
View file

@ -11,7 +11,7 @@ const knownPermissions: Deno.Permission[] = [
];
for (let grant of knownPermissions) {
testPerm({ [grant]: true }, function envGranted() {
testPerm({ [grant]: true }, function envGranted(): void {
const perms = Deno.permissions();
assert(perms !== null);
for (const perm in perms) {

2
js/process.ts
View file

@ -150,7 +150,7 @@ export function run(opt: RunOptions): Process {
const builder = flatbuffers.createBuilder();
const argsOffset = msg.Run.createArgsVector(
builder,
opt.args.map(a => builder.createString(a))
opt.args.map((a): number => builder.createString(a))
);
const cwdOffset = opt.cwd == null ? 0 : builder.createString(opt.cwd);
const kvOffset: flatbuffers.Offset[] = [];

71
js/process_test.ts
View file

@ -2,7 +2,7 @@
import { test, testPerm, assert, assertEquals } from "./test_util.ts";
const { run, DenoError, ErrorKind } = Deno;
test(function runPermissions() {
test(function runPermissions(): void {
let caughtError = false;
try {
Deno.run({ args: ["python", "-c", "print('hello world')"] });
@ -14,7 +14,7 @@ test(function runPermissions() {
assert(caughtError);
});
testPerm({ run: true }, async function runSuccess() {
testPerm({ run: true }, async function runSuccess(): Promise<void> {
const p = run({
args: ["python", "-c", "print('hello world')"]
});
@ -26,7 +26,9 @@ testPerm({ run: true }, async function runSuccess() {
p.close();
});
testPerm({ run: true }, async function runCommandFailedWithCode() {
testPerm({ run: true }, async function runCommandFailedWithCode(): Promise<
void
> {
let p = run({
args: ["python", "-c", "import sys;sys.exit(41 + 1)"]
});
@ -37,7 +39,9 @@ testPerm({ run: true }, async function runCommandFailedWithCode() {
p.close();
});
testPerm({ run: true }, async function runCommandFailedWithSignal() {
testPerm({ run: true }, async function runCommandFailedWithSignal(): Promise<
void
> {
if (Deno.build.os === "win") {
return; // No signals on windows.
}
@ -51,7 +55,7 @@ testPerm({ run: true }, async function runCommandFailedWithSignal() {
p.close();
});
testPerm({ run: true }, function runNotFound() {
testPerm({ run: true }, function runNotFound(): void {
let error;
try {
run({ args: ["this file hopefully doesn't exist"] });
@ -63,13 +67,15 @@ testPerm({ run: true }, function runNotFound() {
assertEquals(error.kind, ErrorKind.NotFound);
});
testPerm({ write: true, run: true }, async function runWithCwdIsAsync() {
const enc = new TextEncoder();
const cwd = Deno.makeTempDirSync({ prefix: "deno_command_test" });
testPerm(
{ write: true, run: true },
async function runWithCwdIsAsync(): Promise<void> {
const enc = new TextEncoder();
const cwd = Deno.makeTempDirSync({ prefix: "deno_command_test" });
const exitCodeFile = "deno_was_here";
const pyProgramFile = "poll_exit.py";
const pyProgram = `
const exitCodeFile = "deno_was_here";
const pyProgramFile = "poll_exit.py";
const pyProgram = `
from sys import exit
from time import sleep
@ -85,25 +91,26 @@ while True:
pass
`;
Deno.writeFileSync(`${cwd}/${pyProgramFile}.py`, enc.encode(pyProgram));
const p = run({
cwd,
args: ["python", `${pyProgramFile}.py`]
});
Deno.writeFileSync(`${cwd}/${pyProgramFile}.py`, enc.encode(pyProgram));
const p = run({
cwd,
args: ["python", `${pyProgramFile}.py`]
});
// Write the expected exit code *after* starting python.
// This is how we verify that `run()` is actually asynchronous.
const code = 84;
Deno.writeFileSync(`${cwd}/${exitCodeFile}`, enc.encode(`${code}`));
// Write the expected exit code *after* starting python.
// This is how we verify that `run()` is actually asynchronous.
const code = 84;
Deno.writeFileSync(`${cwd}/${exitCodeFile}`, enc.encode(`${code}`));
const status = await p.status();
assertEquals(status.success, false);
assertEquals(status.code, code);
assertEquals(status.signal, undefined);
p.close();
});
const status = await p.status();
assertEquals(status.success, false);
assertEquals(status.code, code);
assertEquals(status.signal, undefined);
p.close();
}
);
testPerm({ run: true }, async function runStdinPiped() {
testPerm({ run: true }, async function runStdinPiped(): Promise<void> {
const p = run({
args: ["python", "-c", "import sys; assert 'hello' == sys.stdin.read();"],
stdin: "piped"
@ -124,7 +131,7 @@ testPerm({ run: true }, async function runStdinPiped() {
p.close();
});
testPerm({ run: true }, async function runStdoutPiped() {
testPerm({ run: true }, async function runStdoutPiped(): Promise<void> {
const p = run({
args: ["python", "-c", "import sys; sys.stdout.write('hello')"],
stdout: "piped"
@ -150,7 +157,7 @@ testPerm({ run: true }, async function runStdoutPiped() {
p.close();
});
testPerm({ run: true }, async function runStderrPiped() {
testPerm({ run: true }, async function runStderrPiped(): Promise<void> {
const p = run({
args: ["python", "-c", "import sys; sys.stderr.write('hello')"],
stderr: "piped"
@ -176,7 +183,7 @@ testPerm({ run: true }, async function runStderrPiped() {
p.close();
});
testPerm({ run: true }, async function runOutput() {
testPerm({ run: true }, async function runOutput(): Promise<void> {
const p = run({
args: ["python", "-c", "import sys; sys.stdout.write('hello')"],
stdout: "piped"
@ -187,7 +194,7 @@ testPerm({ run: true }, async function runOutput() {
p.close();
});
testPerm({ run: true }, async function runStderrOutput() {
testPerm({ run: true }, async function runStderrOutput(): Promise<void> {
const p = run({
args: ["python", "-c", "import sys; sys.stderr.write('error')"],
stderr: "piped"
@ -198,7 +205,7 @@ testPerm({ run: true }, async function runStderrOutput() {
p.close();
});
testPerm({ run: true }, async function runEnv() {
testPerm({ run: true }, async function runEnv(): Promise<void> {
const p = run({
args: [
"python",

12
js/read_dir_test.ts
View file

@ -22,12 +22,12 @@ function assertSameContent(files: FileInfo[]): void {
assertEquals(counter, 2);
}
testPerm({ read: true }, function readDirSyncSuccess() {
testPerm({ read: true }, function readDirSyncSuccess(): void {
const files = Deno.readDirSync("tests/");
assertSameContent(files);
});
testPerm({ read: false }, function readDirSyncPerm() {
testPerm({ read: false }, function readDirSyncPerm(): void {
let caughtError = false;
try {
Deno.readDirSync("tests/");
@ -39,7 +39,7 @@ testPerm({ read: false }, function readDirSyncPerm() {
assert(caughtError);
});
testPerm({ read: true }, function readDirSyncNotDir() {
testPerm({ read: true }, function readDirSyncNotDir(): void {
let caughtError = false;
let src;
@ -53,7 +53,7 @@ testPerm({ read: true }, function readDirSyncNotDir() {
assertEquals(src, undefined);
});
testPerm({ read: true }, function readDirSyncNotFound() {
testPerm({ read: true }, function readDirSyncNotFound(): void {
let caughtError = false;
let src;
@ -67,12 +67,12 @@ testPerm({ read: true }, function readDirSyncNotFound() {
assertEquals(src, undefined);
});
testPerm({ read: true }, async function readDirSuccess() {
testPerm({ read: true }, async function readDirSuccess(): Promise<void> {
const files = await Deno.readDir("tests/");
assertSameContent(files);
});
testPerm({ read: false }, async function readDirPerm() {
testPerm({ read: false }, async function readDirPerm(): Promise<void> {
let caughtError = false;
try {
await Deno.readDir("tests/");

10
js/read_file_test.ts
View file

@ -1,7 +1,7 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
import { testPerm, assert, assertEquals } from "./test_util.ts";
testPerm({ read: true }, function readFileSyncSuccess() {
testPerm({ read: true }, function readFileSyncSuccess(): void {
const data = Deno.readFileSync("package.json");
assert(data.byteLength > 0);
const decoder = new TextDecoder("utf-8");
@ -10,7 +10,7 @@ testPerm({ read: true }, function readFileSyncSuccess() {
assertEquals(pkg.name, "deno");
});
testPerm({ read: false }, function readFileSyncPerm() {
testPerm({ read: false }, function readFileSyncPerm(): void {
let caughtError = false;
try {
Deno.readFileSync("package.json");
@ -22,7 +22,7 @@ testPerm({ read: false }, function readFileSyncPerm() {
assert(caughtError);
});
testPerm({ read: true }, function readFileSyncNotFound() {
testPerm({ read: true }, function readFileSyncNotFound(): void {
let caughtError = false;
let data;
try {
@ -35,7 +35,7 @@ testPerm({ read: true }, function readFileSyncNotFound() {
assert(data === undefined);
});
testPerm({ read: true }, async function readFileSuccess() {
testPerm({ read: true }, async function readFileSuccess(): Promise<void> {
const data = await Deno.readFile("package.json");
assert(data.byteLength > 0);
const decoder = new TextDecoder("utf-8");
@ -44,7 +44,7 @@ testPerm({ read: true }, async function readFileSuccess() {
assertEquals(pkg.name, "deno");
});
testPerm({ read: false }, async function readFilePerm() {
testPerm({ read: false }, async function readFilePerm(): Promise<void> {
let caughtError = false;
try {
await Deno.readFile("package.json");

12
js/read_link_test.ts
View file

@ -1,7 +1,7 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
import { testPerm, assert, assertEquals } from "./test_util.ts";
testPerm({ write: true, read: true }, function readlinkSyncSuccess() {
testPerm({ write: true, read: true }, function readlinkSyncSuccess(): void {
const testDir = Deno.makeTempDirSync();
const target = testDir + "/target";
const symlink = testDir + "/symln";
@ -15,7 +15,7 @@ testPerm({ write: true, read: true }, function readlinkSyncSuccess() {
}
});
testPerm({ read: false }, async function readlinkSyncPerm() {
testPerm({ read: false }, async function readlinkSyncPerm(): Promise<void> {
let caughtError = false;
try {
Deno.readlinkSync("/symlink");
@ -27,7 +27,7 @@ testPerm({ read: false }, async function readlinkSyncPerm() {
assert(caughtError);
});
testPerm({ read: true }, function readlinkSyncNotFound() {
testPerm({ read: true }, function readlinkSyncNotFound(): void {
let caughtError = false;
let data;
try {
@ -40,7 +40,9 @@ testPerm({ read: true }, function readlinkSyncNotFound() {
assertEquals(data, undefined);
});
testPerm({ write: true, read: true }, async function readlinkSuccess() {
testPerm({ write: true, read: true }, async function readlinkSuccess(): Promise<
void
> {
const testDir = Deno.makeTempDirSync();
const target = testDir + "/target";
const symlink = testDir + "/symln";
@ -54,7 +56,7 @@ testPerm({ write: true, read: true }, async function readlinkSuccess() {
}
});
testPerm({ read: false }, async function readlinkPerm() {
testPerm({ read: false }, async function readlinkPerm(): Promise<void> {
let caughtError = false;
try {
await Deno.readlink("/symlink");

32
js/remove_test.ts
View file

@ -3,7 +3,7 @@ import { testPerm, assert, assertEquals } from "./test_util.ts";
// SYNC
testPerm({ write: true }, function removeSyncDirSuccess() {
testPerm({ write: true }, function removeSyncDirSuccess(): void {
// REMOVE EMPTY DIRECTORY
const path = Deno.makeTempDirSync() + "/dir/subdir";
Deno.mkdirSync(path);
@ -22,7 +22,7 @@ testPerm({ write: true }, function removeSyncDirSuccess() {
assertEquals(err.name, "NotFound");
});
testPerm({ write: true }, function removeSyncFileSuccess() {
testPerm({ write: true }, function removeSyncFileSuccess(): void {
// REMOVE FILE
const enc = new TextEncoder();
const data = enc.encode("Hello");
@ -43,7 +43,7 @@ testPerm({ write: true }, function removeSyncFileSuccess() {
assertEquals(err.name, "NotFound");
});
testPerm({ write: true }, function removeSyncFail() {
testPerm({ write: true }, function removeSyncFail(): void {
// NON-EMPTY DIRECTORY
const path = Deno.makeTempDirSync() + "/dir/subdir";
const subPath = path + "/subsubdir";
@ -74,7 +74,7 @@ testPerm({ write: true }, function removeSyncFail() {
assertEquals(err.name, "NotFound");
});
testPerm({ write: false }, function removeSyncPerm() {
testPerm({ write: false }, function removeSyncPerm(): void {
let err;
try {
Deno.removeSync("/baddir");
@ -85,7 +85,7 @@ testPerm({ write: false }, function removeSyncPerm() {
assertEquals(err.name, "PermissionDenied");
});
testPerm({ write: true }, function removeAllSyncDirSuccess() {
testPerm({ write: true }, function removeAllSyncDirSuccess(): void {
// REMOVE EMPTY DIRECTORY
let path = Deno.makeTempDirSync() + "/dir/subdir";
Deno.mkdirSync(path);
@ -123,7 +123,7 @@ testPerm({ write: true }, function removeAllSyncDirSuccess() {
assertEquals(err.name, "NotFound");
});
testPerm({ write: true }, function removeAllSyncFileSuccess() {
testPerm({ write: true }, function removeAllSyncFileSuccess(): void {
// REMOVE FILE
const enc = new TextEncoder();
const data = enc.encode("Hello");
@ -144,7 +144,7 @@ testPerm({ write: true }, function removeAllSyncFileSuccess() {
assertEquals(err.name, "NotFound");
});
testPerm({ write: true }, function removeAllSyncFail() {
testPerm({ write: true }, function removeAllSyncFail(): void {
// NON-EXISTENT DIRECTORY/FILE
let err;
try {
@ -157,7 +157,7 @@ testPerm({ write: true }, function removeAllSyncFail() {
assertEquals(err.name, "NotFound");
});
testPerm({ write: false }, function removeAllSyncPerm() {
testPerm({ write: false }, function removeAllSyncPerm(): void {
let err;
try {
Deno.removeSync("/baddir", { recursive: true });
@ -170,7 +170,7 @@ testPerm({ write: false }, function removeAllSyncPerm() {
// ASYNC
testPerm({ write: true }, async function removeDirSuccess() {
testPerm({ write: true }, async function removeDirSuccess(): Promise<void> {
// REMOVE EMPTY DIRECTORY
const path = Deno.makeTempDirSync() + "/dir/subdir";
Deno.mkdirSync(path);
@ -189,7 +189,7 @@ testPerm({ write: true }, async function removeDirSuccess() {
assertEquals(err.name, "NotFound");
});
testPerm({ write: true }, async function removeFileSuccess() {
testPerm({ write: true }, async function removeFileSuccess(): Promise<void> {
// REMOVE FILE
const enc = new TextEncoder();
const data = enc.encode("Hello");
@ -210,7 +210,7 @@ testPerm({ write: true }, async function removeFileSuccess() {
assertEquals(err.name, "NotFound");
});
testPerm({ write: true }, async function removeFail() {
testPerm({ write: true }, async function removeFail(): Promise<void> {
// NON-EMPTY DIRECTORY
const path = Deno.makeTempDirSync() + "/dir/subdir";
const subPath = path + "/subsubdir";
@ -240,7 +240,7 @@ testPerm({ write: true }, async function removeFail() {
assertEquals(err.name, "NotFound");
});
testPerm({ write: false }, async function removePerm() {
testPerm({ write: false }, async function removePerm(): Promise<void> {
let err;
try {
await Deno.remove("/baddir");
@ -251,7 +251,7 @@ testPerm({ write: false }, async function removePerm() {
assertEquals(err.name, "PermissionDenied");
});
testPerm({ write: true }, async function removeAllDirSuccess() {
testPerm({ write: true }, async function removeAllDirSuccess(): Promise<void> {
// REMOVE EMPTY DIRECTORY
let path = Deno.makeTempDirSync() + "/dir/subdir";
Deno.mkdirSync(path);
@ -289,7 +289,7 @@ testPerm({ write: true }, async function removeAllDirSuccess() {
assertEquals(err.name, "NotFound");
});
testPerm({ write: true }, async function removeAllFileSuccess() {
testPerm({ write: true }, async function removeAllFileSuccess(): Promise<void> {
// REMOVE FILE
const enc = new TextEncoder();
const data = enc.encode("Hello");
@ -310,7 +310,7 @@ testPerm({ write: true }, async function removeAllFileSuccess() {
assertEquals(err.name, "NotFound");
});
testPerm({ write: true }, async function removeAllFail() {
testPerm({ write: true }, async function removeAllFail(): Promise<void> {
// NON-EXISTENT DIRECTORY/FILE
let err;
try {
@ -323,7 +323,7 @@ testPerm({ write: true }, async function removeAllFail() {
assertEquals(err.name, "NotFound");
});
testPerm({ write: false }, async function removeAllPerm() {
testPerm({ write: false }, async function removeAllPerm(): Promise<void> {
let err;
try {
await Deno.remove("/baddir", { recursive: true });

8
js/rename_test.ts
View file

@ -1,7 +1,7 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
import { testPerm, assert, assertEquals } from "./test_util.ts";
testPerm({ read: true, write: true }, function renameSyncSuccess() {
testPerm({ read: true, write: true }, function renameSyncSuccess(): void {
const testDir = Deno.makeTempDirSync();
const oldpath = testDir + "/oldpath";
const newpath = testDir + "/newpath";
@ -23,7 +23,7 @@ testPerm({ read: true, write: true }, function renameSyncSuccess() {
assertEquals(oldPathInfo, undefined);
});
testPerm({ read: true, write: false }, function renameSyncPerm() {
testPerm({ read: true, write: false }, function renameSyncPerm(): void {
let err;
try {
const oldpath = "/oldbaddir";
@ -36,7 +36,9 @@ testPerm({ read: true, write: false }, function renameSyncPerm() {
assertEquals(err.name, "PermissionDenied");
});
testPerm({ read: true, write: true }, async function renameSuccess() {
testPerm({ read: true, write: true }, async function renameSuccess(): Promise<
void
> {
const testDir = Deno.makeTempDirSync();
const oldpath = testDir + "/oldpath";
const newpath = testDir + "/newpath";

4
js/repl.ts
View file

@ -16,12 +16,12 @@ const helpMsg = [
const replCommands = {
exit: {
get() {
get(): void {
exit(0);
}
},
help: {
get() {
get(): string {
return helpMsg;
}
}

24
js/resources_test.ts
View file

@ -1,7 +1,7 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
import { test, testPerm, assertEquals } from "./test_util.ts";
test(function resourcesStdio() {
test(function resourcesStdio(): void {
const res = Deno.resources();
assertEquals(res[0], "stdin");
@ -9,7 +9,7 @@ test(function resourcesStdio() {
assertEquals(res[2], "stderr");
});
testPerm({ net: true }, async function resourcesNet() {
testPerm({ net: true }, async function resourcesNet(): Promise<void> {
const addr = "127.0.0.1:4501";
const listener = Deno.listen("tcp", addr);
@ -17,15 +17,21 @@ testPerm({ net: true }, async function resourcesNet() {
const listenerConn = await listener.accept();
const res = Deno.resources();
assertEquals(Object.values(res).filter(r => r === "tcpListener").length, 1);
assertEquals(Object.values(res).filter(r => r === "tcpStream").length, 2);
assertEquals(
Object.values(res).filter((r): boolean => r === "tcpListener").length,
1
);
assertEquals(
Object.values(res).filter((r): boolean => r === "tcpStream").length,
2
);
listenerConn.close();
dialerConn.close();
listener.close();
});
testPerm({ read: true }, async function resourcesFile() {
testPerm({ read: true }, async function resourcesFile(): Promise<void> {
const resourcesBefore = Deno.resources();
await Deno.open("tests/hello.txt");
const resourcesAfter = Deno.resources();
@ -35,8 +41,10 @@ testPerm({ read: true }, async function resourcesFile() {
Object.keys(resourcesAfter).length,
Object.keys(resourcesBefore).length + 1
);
const newRid = Object.keys(resourcesAfter).find(rid => {
return !resourcesBefore.hasOwnProperty(rid);
});
const newRid = Object.keys(resourcesAfter).find(
(rid): boolean => {
return !resourcesBefore.hasOwnProperty(rid);
}
);
assertEquals(resourcesAfter[newRid], "fsFile");
});

24
js/stat_test.ts
View file

@ -3,7 +3,7 @@ import { testPerm, assert, assertEquals } from "./test_util.ts";
// TODO Add tests for modified, accessed, and created fields once there is a way
// to create temp files.
testPerm({ read: true }, async function statSyncSuccess() {
testPerm({ read: true }, async function statSyncSuccess(): Promise<void> {
const packageInfo = Deno.statSync("package.json");
assert(packageInfo.isFile());
assert(!packageInfo.isSymlink());
@ -17,7 +17,7 @@ testPerm({ read: true }, async function statSyncSuccess() {
assert(!testsInfo.isSymlink());
});
testPerm({ read: false }, async function statSyncPerm() {
testPerm({ read: false }, async function statSyncPerm(): Promise<void> {
let caughtError = false;
try {
Deno.statSync("package.json");
@ -29,7 +29,7 @@ testPerm({ read: false }, async function statSyncPerm() {
assert(caughtError);
});
testPerm({ read: true }, async function statSyncNotFound() {
testPerm({ read: true }, async function statSyncNotFound(): Promise<void> {
let caughtError = false;
let badInfo;
@ -45,7 +45,7 @@ testPerm({ read: true }, async function statSyncNotFound() {
assertEquals(badInfo, undefined);
});
testPerm({ read: true }, async function lstatSyncSuccess() {
testPerm({ read: true }, async function lstatSyncSuccess(): Promise<void> {
const packageInfo = Deno.lstatSync("package.json");
assert(packageInfo.isFile());
assert(!packageInfo.isSymlink());
@ -59,7 +59,7 @@ testPerm({ read: true }, async function lstatSyncSuccess() {
assert(!testsInfo.isSymlink());
});
testPerm({ read: false }, async function lstatSyncPerm() {
testPerm({ read: false }, async function lstatSyncPerm(): Promise<void> {
let caughtError = false;
try {
Deno.lstatSync("package.json");
@ -71,7 +71,7 @@ testPerm({ read: false }, async function lstatSyncPerm() {
assert(caughtError);
});
testPerm({ read: true }, async function lstatSyncNotFound() {
testPerm({ read: true }, async function lstatSyncNotFound(): Promise<void> {
let caughtError = false;
let badInfo;
@ -87,7 +87,7 @@ testPerm({ read: true }, async function lstatSyncNotFound() {
assertEquals(badInfo, undefined);
});
testPerm({ read: true }, async function statSuccess() {
testPerm({ read: true }, async function statSuccess(): Promise<void> {
const packageInfo = await Deno.stat("package.json");
assert(packageInfo.isFile());
assert(!packageInfo.isSymlink());
@ -101,7 +101,7 @@ testPerm({ read: true }, async function statSuccess() {
assert(!testsInfo.isSymlink());
});
testPerm({ read: false }, async function statPerm() {
testPerm({ read: false }, async function statPerm(): Promise<void> {
let caughtError = false;
try {
await Deno.stat("package.json");
@ -113,7 +113,7 @@ testPerm({ read: false }, async function statPerm() {
assert(caughtError);
});
testPerm({ read: true }, async function statNotFound() {
testPerm({ read: true }, async function statNotFound(): Promise<void> {
let caughtError = false;
let badInfo;
@ -129,7 +129,7 @@ testPerm({ read: true }, async function statNotFound() {
assertEquals(badInfo, undefined);
});
testPerm({ read: true }, async function lstatSuccess() {
testPerm({ read: true }, async function lstatSuccess(): Promise<void> {
const packageInfo = await Deno.lstat("package.json");
assert(packageInfo.isFile());
assert(!packageInfo.isSymlink());
@ -143,7 +143,7 @@ testPerm({ read: true }, async function lstatSuccess() {
assert(!testsInfo.isSymlink());
});
testPerm({ read: false }, async function lstatPerm() {
testPerm({ read: false }, async function lstatPerm(): Promise<void> {
let caughtError = false;
try {
await Deno.lstat("package.json");
@ -155,7 +155,7 @@ testPerm({ read: false }, async function lstatPerm() {
assert(caughtError);
});
testPerm({ read: true }, async function lstatNotFound() {
testPerm({ read: true }, async function lstatNotFound(): Promise<void> {
let caughtError = false;
let badInfo;

10
js/symlink_test.ts
View file

@ -1,7 +1,7 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
import { test, testPerm, assert, assertEquals } from "./test_util.ts";
testPerm({ read: true, write: true }, function symlinkSyncSuccess() {
testPerm({ read: true, write: true }, function symlinkSyncSuccess(): void {
const testDir = Deno.makeTempDirSync();
const oldname = testDir + "/oldname";
const newname = testDir + "/newname";
@ -24,7 +24,7 @@ testPerm({ read: true, write: true }, function symlinkSyncSuccess() {
}
});
test(function symlinkSyncPerm() {
test(function symlinkSyncPerm(): void {
let err;
try {
Deno.symlinkSync("oldbaddir", "newbaddir");
@ -36,7 +36,7 @@ test(function symlinkSyncPerm() {
});
// Just for now, until we implement symlink for Windows.
testPerm({ write: true }, function symlinkSyncNotImplemented() {
testPerm({ write: true }, function symlinkSyncNotImplemented(): void {
let err;
try {
Deno.symlinkSync("oldname", "newname", "dir");
@ -46,7 +46,9 @@ testPerm({ write: true }, function symlinkSyncNotImplemented() {
assertEquals(err.message, "Not implemented");
});
testPerm({ read: true, write: true }, async function symlinkSuccess() {
testPerm({ read: true, write: true }, async function symlinkSuccess(): Promise<
void
> {
const testDir = Deno.makeTempDirSync();
const oldname = testDir + "/oldname";
const newname = testDir + "/newname";

4
js/test_util.ts
View file

@ -77,7 +77,7 @@ export function test(fn: testing.TestFunction): void {
);
}
test(function permSerialization() {
test(function permSerialization(): void {
for (const write of [true, false]) {
for (const net of [true, false]) {
for (const env of [true, false]) {
@ -103,7 +103,7 @@ test(function permSerialization() {
// To better catch internal errors, permFromString should throw if it gets an
// invalid permission string.
test(function permFromStringThrows() {
test(function permFromStringThrows(): void {
let threw = false;
try {
permFromString("bad");

18
js/text_encoding.ts
View file

@ -289,18 +289,24 @@ for (const key of Object.keys(encodingMap)) {
// A map of functions that return new instances of a decoder indexed by the
// encoding type.
const decoders = new Map<string, (options: DecoderOptions) => Decoder>();
decoders.set("utf-8", (options: DecoderOptions) => {
return new UTF8Decoder(options);
});
decoders.set(
"utf-8",
(options: DecoderOptions): UTF8Decoder => {
return new UTF8Decoder(options);
}
);
// Single byte decoders are an array of code point lookups
const encodingIndexes = new Map<string, number[]>();
// prettier-ignore
encodingIndexes.set("windows-1252", [8364,129,8218,402,8222,8230,8224,8225,710,8240,352,8249,338,141,381,143,144,8216,8217,8220,8221,8226,8211,8212,732,8482,353,8250,339,157,382,376,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255]);
for (const [key, index] of encodingIndexes) {
decoders.set(key, (options: DecoderOptions) => {
return new SingleByteDecoder(index, options);
});
decoders.set(
key,
(options: DecoderOptions): SingleByteDecoder => {
return new SingleByteDecoder(index, options);
}
);
}
function codePointsToString(codePoints: number[]): string {

20
js/text_encoding_test.ts
View file

@ -1,19 +1,19 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
import { test, assert, assertEquals } from "./test_util.ts";
test(function atobSuccess() {
test(function atobSuccess(): void {
const text = "hello world";
const encoded = btoa(text);
assertEquals(encoded, "aGVsbG8gd29ybGQ=");
});
test(function btoaSuccess() {
test(function btoaSuccess(): void {
const encoded = "aGVsbG8gd29ybGQ=";
const decoded = atob(encoded);
assertEquals(decoded, "hello world");
});
test(function btoaFailed() {
test(function btoaFailed(): void {
const text = "你好";
let err;
try {
@ -25,7 +25,7 @@ test(function btoaFailed() {
assertEquals(err.name, "InvalidInput");
});
test(function textDecoder2() {
test(function textDecoder2(): void {
// prettier-ignore
const fixture = new Uint8Array([
0xf0, 0x9d, 0x93, 0xbd,
@ -37,13 +37,13 @@ test(function textDecoder2() {
assertEquals(decoder.decode(fixture), "𝓽𝓮𝔁𝓽");
});
test(function textDecoderASCII() {
test(function textDecoderASCII(): void {
const fixture = new Uint8Array([0x89, 0x95, 0x9f, 0xbf]);
const decoder = new TextDecoder("ascii");
assertEquals(decoder.decode(fixture), "‰•Ÿ¿");
});
test(function textDecoderErrorEncoding() {
test(function textDecoderErrorEncoding(): void {
let didThrow = false;
try {
new TextDecoder("foo");
@ -54,7 +54,7 @@ test(function textDecoderErrorEncoding() {
assert(didThrow);
});
test(function textEncoder2() {
test(function textEncoder2(): void {
const fixture = "𝓽𝓮𝔁𝓽";
const encoder = new TextEncoder();
// prettier-ignore
@ -66,7 +66,7 @@ test(function textEncoder2() {
]);
});
test(function textDecoderSharedUint8Array() {
test(function textDecoderSharedUint8Array(): void {
const ab = new SharedArrayBuffer(6);
const dataView = new DataView(ab);
const charCodeA = "A".charCodeAt(0);
@ -79,7 +79,7 @@ test(function textDecoderSharedUint8Array() {
assertEquals(actual, "ABCDEF");
});
test(function textDecoderSharedInt32Array() {
test(function textDecoderSharedInt32Array(): void {
const ab = new SharedArrayBuffer(8);
const dataView = new DataView(ab);
const charCodeA = "A".charCodeAt(0);
@ -92,7 +92,7 @@ test(function textDecoderSharedInt32Array() {
assertEquals(actual, "ABCDEFGH");
});
test(function toStringShouldBeWebCompatibility() {
test(function toStringShouldBeWebCompatibility(): void {
const encoder = new TextEncoder();
assertEquals(encoder.toString(), "[object TextEncoder]");

48
js/timers_test.ts
View file

@ -9,10 +9,12 @@ function deferred(): {
} {
let resolve;
let reject;
const promise = new Promise((res, rej) => {
resolve = res;
reject = rej;
});
const promise = new Promise(
(res, rej): void => {
resolve = res;
reject = rej;
}
);
return {
promise,
resolve,
@ -21,13 +23,13 @@ function deferred(): {
}
async function waitForMs(ms): Promise<number> {
return new Promise(resolve => setTimeout(resolve, ms));
return new Promise((resolve): number => setTimeout(resolve, ms));
}
test(async function timeoutSuccess() {
test(async function timeoutSuccess(): Promise<void> {
const { promise, resolve } = deferred();
let count = 0;
setTimeout(() => {
setTimeout((): void => {
count++;
resolve();
}, 500);
@ -36,11 +38,11 @@ test(async function timeoutSuccess() {
assertEquals(count, 1);
});
test(async function timeoutArgs() {
test(async function timeoutArgs(): Promise<void> {
const { promise, resolve } = deferred();
const arg = 1;
setTimeout(
(a, b, c) => {
(a, b, c): void => {
assertEquals(a, arg);
assertEquals(b, arg.toString());
assertEquals(c, [arg]);
@ -54,9 +56,9 @@ test(async function timeoutArgs() {
await promise;
});
test(async function timeoutCancelSuccess() {
test(async function timeoutCancelSuccess(): Promise<void> {
let count = 0;
const id = setTimeout(() => {
const id = setTimeout((): void => {
count++;
}, 1);
// Cancelled, count should not increment
@ -65,7 +67,7 @@ test(async function timeoutCancelSuccess() {
assertEquals(count, 0);
});
test(async function timeoutCancelMultiple() {
test(async function timeoutCancelMultiple(): Promise<void> {
function uncalled(): never {
throw new Error("This function should not be called.");
}
@ -90,11 +92,11 @@ test(async function timeoutCancelMultiple() {
await waitForMs(50);
});
test(async function timeoutCancelInvalidSilentFail() {
test(async function timeoutCancelInvalidSilentFail(): Promise<void> {
// Expect no panic
const { promise, resolve } = deferred();
let count = 0;
const id = setTimeout(() => {
const id = setTimeout((): void => {
count++;
// Should have no effect
clearTimeout(id);
@ -107,10 +109,10 @@ test(async function timeoutCancelInvalidSilentFail() {
clearTimeout(2147483647);
});
test(async function intervalSuccess() {
test(async function intervalSuccess(): Promise<void> {
const { promise, resolve } = deferred();
let count = 0;
const id = setInterval(() => {
const id = setInterval((): void => {
count++;
clearInterval(id);
resolve();
@ -122,9 +124,9 @@ test(async function intervalSuccess() {
assertEquals(count, 1);
});
test(async function intervalCancelSuccess() {
test(async function intervalCancelSuccess(): Promise<void> {
let count = 0;
const id = setInterval(() => {
const id = setInterval((): void => {
count++;
}, 1);
clearInterval(id);
@ -132,7 +134,7 @@ test(async function intervalCancelSuccess() {
assertEquals(count, 0);
});
test(async function intervalOrdering() {
test(async function intervalOrdering(): Promise<void> {
const timers = [];
let timeouts = 0;
function onTimeout(): void {
@ -148,14 +150,16 @@ test(async function intervalOrdering() {
assertEquals(timeouts, 1);
});
test(async function intervalCancelInvalidSilentFail() {
test(async function intervalCancelInvalidSilentFail(): Promise<void> {
// Should silently fail (no panic)
clearInterval(2147483647);
});
test(async function fireCallbackImmediatelyWhenDelayOverMaxValue() {
test(async function fireCallbackImmediatelyWhenDelayOverMaxValue(): Promise<
void
> {
let count = 0;
setTimeout(() => {
setTimeout((): void => {
count++;
}, 2 ** 31);
await waitForMs(1);

10
js/truncate_test.ts
View file

@ -15,7 +15,7 @@ async function readData(name: string): Promise<string> {
return text;
}
testPerm({ read: true, write: true }, function truncateSyncSuccess() {
testPerm({ read: true, write: true }, function truncateSyncSuccess(): void {
const enc = new TextEncoder();
const d = enc.encode("Hello");
const filename = Deno.makeTempDirSync() + "/test_truncateSync.txt";
@ -32,7 +32,9 @@ testPerm({ read: true, write: true }, function truncateSyncSuccess() {
Deno.removeSync(filename);
});
testPerm({ read: true, write: true }, async function truncateSuccess() {
testPerm({ read: true, write: true }, async function truncateSuccess(): Promise<
void
> {
const enc = new TextEncoder();
const d = enc.encode("Hello");
const filename = Deno.makeTempDirSync() + "/test_truncate.txt";
@ -49,7 +51,7 @@ testPerm({ read: true, write: true }, async function truncateSuccess() {
await Deno.remove(filename);
});
testPerm({ write: false }, function truncateSyncPerm() {
testPerm({ write: false }, function truncateSyncPerm(): void {
let err;
try {
Deno.mkdirSync("/test_truncateSyncPermission.txt");
@ -60,7 +62,7 @@ testPerm({ write: false }, function truncateSyncPerm() {
assertEquals(err.name, "PermissionDenied");
});
testPerm({ write: false }, async function truncatePerm() {
testPerm({ write: false }, async function truncatePerm(): Promise<void> {
let err;
try {
await Deno.mkdir("/test_truncatePermission.txt");

2
js/url.ts
View file

@ -73,7 +73,7 @@ export class URL {
for (const methodName of searchParamsMethods) {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const method: (...args: any[]) => any = searchParams[methodName];
searchParams[methodName] = (...args: unknown[]) => {
searchParams[methodName] = (...args: unknown[]): void => {
method.apply(searchParams, args);
this.search = searchParams.toString();
};

8
js/url_search_params.ts
View file

@ -112,7 +112,7 @@ export class URLSearchParams {
has(name: string): boolean {
requiredArguments("URLSearchParams.has", arguments.length, 1);
name = String(name);
return this.params.some(entry => entry[0] === name);
return this.params.some((entry): boolean => entry[0] === name);
}
/** Sets the value associated with a given search parameter to the
@ -159,8 +159,8 @@ export class URLSearchParams {
* searchParams.sort();
*/
sort(): void {
this.params = this.params.sort((a, b) =>
a[0] === b[0] ? 0 : a[0] > b[0] ? 1 : -1
this.params = this.params.sort(
(a, b): number => (a[0] === b[0] ? 0 : a[0] > b[0] ? 1 : -1)
);
}
@ -244,7 +244,7 @@ export class URLSearchParams {
toString(): string {
return this.params
.map(
tuple =>
(tuple): string =>
`${encodeURIComponent(tuple[0])}=${encodeURIComponent(tuple[1])}`
)
.join("&");

106
js/url_search_params_test.ts
View file

@ -1,7 +1,7 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
import { test, assert, assertEquals } from "./test_util.ts";
test(function urlSearchParamsInitString() {
test(function urlSearchParamsInitString(): void {
const init = "c=4&a=2&b=3&%C3%A1=1";
const searchParams = new URLSearchParams(init);
assert(
@ -10,32 +10,32 @@ test(function urlSearchParamsInitString() {
);
});
test(function urlSearchParamsInitIterable() {
test(function urlSearchParamsInitIterable(): void {
const init = [["a", "54"], ["b", "true"]];
const searchParams = new URLSearchParams(init);
assertEquals(searchParams.toString(), "a=54&b=true");
});
test(function urlSearchParamsInitRecord() {
test(function urlSearchParamsInitRecord(): void {
const init = { a: "54", b: "true" };
const searchParams = new URLSearchParams(init);
assertEquals(searchParams.toString(), "a=54&b=true");
});
test(function urlSearchParamsAppendSuccess() {
test(function urlSearchParamsAppendSuccess(): void {
const searchParams = new URLSearchParams();
searchParams.append("a", "true");
assertEquals(searchParams.toString(), "a=true");
});
test(function urlSearchParamsDeleteSuccess() {
test(function urlSearchParamsDeleteSuccess(): void {
const init = "a=54&b=true";
const searchParams = new URLSearchParams(init);
searchParams.delete("b");
assertEquals(searchParams.toString(), "a=54");
});
test(function urlSearchParamsGetAllSuccess() {
test(function urlSearchParamsGetAllSuccess(): void {
const init = "a=54&b=true&a=true";
const searchParams = new URLSearchParams(init);
assertEquals(searchParams.getAll("a"), ["54", "true"]);
@ -43,7 +43,7 @@ test(function urlSearchParamsGetAllSuccess() {
assertEquals(searchParams.getAll("c"), []);
});
test(function urlSearchParamsGetSuccess() {
test(function urlSearchParamsGetSuccess(): void {
const init = "a=54&b=true&a=true";
const searchParams = new URLSearchParams(init);
assertEquals(searchParams.get("a"), "54");
@ -51,7 +51,7 @@ test(function urlSearchParamsGetSuccess() {
assertEquals(searchParams.get("c"), null);
});
test(function urlSearchParamsHasSuccess() {
test(function urlSearchParamsHasSuccess(): void {
const init = "a=54&b=true&a=true";
const searchParams = new URLSearchParams(init);
assert(searchParams.has("a"));
@ -59,62 +59,64 @@ test(function urlSearchParamsHasSuccess() {
assert(!searchParams.has("c"));
});
test(function urlSearchParamsSetReplaceFirstAndRemoveOthers() {
test(function urlSearchParamsSetReplaceFirstAndRemoveOthers(): void {
const init = "a=54&b=true&a=true";
const searchParams = new URLSearchParams(init);
searchParams.set("a", "false");
assertEquals(searchParams.toString(), "a=false&b=true");
});
test(function urlSearchParamsSetAppendNew() {
test(function urlSearchParamsSetAppendNew(): void {
const init = "a=54&b=true&a=true";
const searchParams = new URLSearchParams(init);
searchParams.set("c", "foo");
assertEquals(searchParams.toString(), "a=54&b=true&a=true&c=foo");
});
test(function urlSearchParamsSortSuccess() {
test(function urlSearchParamsSortSuccess(): void {
const init = "c=4&a=2&b=3&a=1";
const searchParams = new URLSearchParams(init);
searchParams.sort();
assertEquals(searchParams.toString(), "a=2&a=1&b=3&c=4");
});
test(function urlSearchParamsForEachSuccess() {
test(function urlSearchParamsForEachSuccess(): void {
const init = [["a", "54"], ["b", "true"]];
const searchParams = new URLSearchParams(init);
let callNum = 0;
searchParams.forEach((value, key, parent) => {
assertEquals(searchParams, parent);
assertEquals(value, init[callNum][1]);
assertEquals(key, init[callNum][0]);
callNum++;
});
searchParams.forEach(
(value, key, parent): void => {
assertEquals(searchParams, parent);
assertEquals(value, init[callNum][1]);
assertEquals(key, init[callNum][0]);
callNum++;
}
);
assertEquals(callNum, init.length);
});
test(function urlSearchParamsMissingName() {
test(function urlSearchParamsMissingName(): void {
const init = "=4";
const searchParams = new URLSearchParams(init);
assertEquals(searchParams.get(""), "4");
assertEquals(searchParams.toString(), "=4");
});
test(function urlSearchParamsMissingValue() {
test(function urlSearchParamsMissingValue(): void {
const init = "4=";
const searchParams = new URLSearchParams(init);
assertEquals(searchParams.get("4"), "");
assertEquals(searchParams.toString(), "4=");
});
test(function urlSearchParamsMissingEqualSign() {
test(function urlSearchParamsMissingEqualSign(): void {
const init = "4";
const searchParams = new URLSearchParams(init);
assertEquals(searchParams.get("4"), "");
assertEquals(searchParams.toString(), "4=");
});
test(function urlSearchParamsMissingPair() {
test(function urlSearchParamsMissingPair(): void {
const init = "c=4&&a=54&";
const searchParams = new URLSearchParams(init);
assertEquals(searchParams.toString(), "c=4&a=54");
@ -122,7 +124,7 @@ test(function urlSearchParamsMissingPair() {
// If pair does not contain exactly two items, then throw a TypeError.
// ref https://url.spec.whatwg.org/#interface-urlsearchparams
test(function urlSearchParamsShouldThrowTypeError() {
test(function urlSearchParamsShouldThrowTypeError(): void {
let hasThrown = 0;
try {
@ -139,40 +141,44 @@ test(function urlSearchParamsShouldThrowTypeError() {
assertEquals(hasThrown, 2);
});
test(function urlSearchParamsAppendArgumentsCheck() {
test(function urlSearchParamsAppendArgumentsCheck(): void {
const methodRequireOneParam = ["delete", "getAll", "get", "has", "forEach"];
const methodRequireTwoParams = ["append", "set"];
methodRequireOneParam.concat(methodRequireTwoParams).forEach(method => {
const searchParams = new URLSearchParams();
let hasThrown = 0;
try {
searchParams[method]();
hasThrown = 1;
} catch (err) {
if (err instanceof TypeError) {
hasThrown = 2;
} else {
hasThrown = 3;
methodRequireOneParam.concat(methodRequireTwoParams).forEach(
(method: string): void => {
const searchParams = new URLSearchParams();
let hasThrown = 0;
try {
searchParams[method]();
hasThrown = 1;
} catch (err) {
if (err instanceof TypeError) {
hasThrown = 2;
} else {
hasThrown = 3;
}
}
assertEquals(hasThrown, 2);
}
assertEquals(hasThrown, 2);
});
);
methodRequireTwoParams.forEach(method => {
const searchParams = new URLSearchParams();
let hasThrown = 0;
try {
searchParams[method]("foo");
hasThrown = 1;
} catch (err) {
if (err instanceof TypeError) {
hasThrown = 2;
} else {
hasThrown = 3;
methodRequireTwoParams.forEach(
(method: string): void => {
const searchParams = new URLSearchParams();
let hasThrown = 0;
try {
searchParams[method]("foo");
hasThrown = 1;
} catch (err) {
if (err instanceof TypeError) {
hasThrown = 2;
} else {
hasThrown = 3;
}
}
assertEquals(hasThrown, 2);
}
assertEquals(hasThrown, 2);
});
);
});

16
js/url_test.ts
View file

@ -1,7 +1,7 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
import { test, assert, assertEquals } from "./test_util.ts";
test(function urlParsing() {
test(function urlParsing(): void {
const url = new URL(
"https://foo:bar@baz.qat:8000/qux/quux?foo=bar&baz=12#qat"
);
@ -31,7 +31,7 @@ test(function urlParsing() {
);
});
test(function urlModifications() {
test(function urlModifications(): void {
const url = new URL(
"https://foo:bar@baz.qat:8000/qux/quux?foo=bar&baz=12#qat"
);
@ -86,7 +86,7 @@ test(function urlModifications() {
);
});
test(function urlModifyHref() {
test(function urlModifyHref(): void {
const url = new URL("http://example.com/");
url.href = "https://foo:bar@example.com:8080/baz/qat#qux";
assertEquals(url.protocol, "https:");
@ -98,7 +98,7 @@ test(function urlModifyHref() {
assertEquals(url.hash, "#qux");
});
test(function urlModifyPathname() {
test(function urlModifyPathname(): void {
const url = new URL("http://foo.bar/baz%qat/qux%quux");
assertEquals(url.pathname, "/baz%qat/qux%quux");
url.pathname = url.pathname;
@ -109,7 +109,7 @@ test(function urlModifyPathname() {
assertEquals(url.pathname, "/baz%23qat%20qux");
});
test(function urlModifyHash() {
test(function urlModifyHash(): void {
const url = new URL("http://foo.bar");
url.hash = "%foo bar/qat%qux#bar";
assertEquals(url.hash, "#%foo%20bar/qat%qux#bar");
@ -117,7 +117,7 @@ test(function urlModifyHash() {
assertEquals(url.hash, "#%foo%20bar/qat%qux#bar");
});
test(function urlSearchParamsReuse() {
test(function urlSearchParamsReuse(): void {
const url = new URL(
"https://foo:bar@baz.qat:8000/qux/quux?foo=bar&baz=12#qat"
);
@ -126,7 +126,7 @@ test(function urlSearchParamsReuse() {
assert(sp === url.searchParams, "Search params should be reused.");
});
test(function urlBaseURL() {
test(function urlBaseURL(): void {
const base = new URL(
"https://foo:bar@baz.qat:8000/qux/quux?foo=bar&baz=12#qat"
);
@ -134,7 +134,7 @@ test(function urlBaseURL() {
assertEquals(url.href, "https://foo:bar@baz.qat:8000/foo/bar?baz=foo#qux");
});
test(function urlBaseString() {
test(function urlBaseString(): void {
const url = new URL(
"/foo/bar?baz=foo#qux",
"https://foo:bar@baz.qat:8000/qux/quux?foo=bar&baz=12#qat"

17
js/util.ts
View file

@ -71,9 +71,11 @@ export type Resolvable<T> = Promise<T> & ResolvableMethods<T>;
// @internal
export function createResolvable<T>(): Resolvable<T> {
let methods: ResolvableMethods<T>;
const promise = new Promise<T>((resolve, reject) => {
methods = { resolve, reject };
});
const promise = new Promise<T>(
(resolve, reject): void => {
methods = { resolve, reject };
}
);
// TypeScript doesn't know that the Promise callback occurs synchronously
// therefore use of not null assertion (`!`)
return Object.assign(promise, methods!) as Resolvable<T>;
@ -92,9 +94,12 @@ export function unreachable(): never {
// @internal
export function hexdump(u8: Uint8Array): string {
return Array.prototype.map
.call(u8, (x: number) => {
return ("00" + x.toString(16)).slice(-2);
})
.call(
u8,
(x: number): string => {
return ("00" + x.toString(16)).slice(-2);
}
)
.join(" ");
}

2
js/version_test.ts
View file

@ -1,6 +1,6 @@
import { test, assert } from "./test_util.ts";
test(function version() {
test(function version(): void {
const pattern = /^\d+\.\d+\.\d+$/;
assert(pattern.test(Deno.version.deno));
assert(pattern.test(Deno.version.v8));

8
js/workers.ts
View file

@ -161,9 +161,11 @@ export class WorkerImpl implements Worker {
this.rid = createWorker(specifier);
this.run();
this.isClosedPromise = hostGetWorkerClosed(this.rid);
this.isClosedPromise.then(() => {
this.isClosing = true;
});
this.isClosedPromise.then(
(): void => {
this.isClosing = true;
}
);
}
get closed(): Promise<void> {

101
js/write_file_test.ts
View file

@ -1,7 +1,7 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
import { testPerm, assert, assertEquals } from "./test_util.ts";
testPerm({ read: true, write: true }, function writeFileSyncSuccess() {
testPerm({ read: true, write: true }, function writeFileSyncSuccess(): void {
const enc = new TextEncoder();
const data = enc.encode("Hello");
const filename = Deno.makeTempDirSync() + "/test.txt";
@ -12,7 +12,7 @@ testPerm({ read: true, write: true }, function writeFileSyncSuccess() {
assertEquals("Hello", actual);
});
testPerm({ write: true }, function writeFileSyncFail() {
testPerm({ write: true }, function writeFileSyncFail(): void {
const enc = new TextEncoder();
const data = enc.encode("Hello");
const filename = "/baddir/test.txt";
@ -28,7 +28,7 @@ testPerm({ write: true }, function writeFileSyncFail() {
assert(caughtError);
});
testPerm({ write: false }, function writeFileSyncPerm() {
testPerm({ write: false }, function writeFileSyncPerm(): void {
const enc = new TextEncoder();
const data = enc.encode("Hello");
const filename = "/baddir/test.txt";
@ -44,7 +44,7 @@ testPerm({ write: false }, function writeFileSyncPerm() {
assert(caughtError);
});
testPerm({ read: true, write: true }, function writeFileSyncUpdatePerm() {
testPerm({ read: true, write: true }, function writeFileSyncUpdatePerm(): void {
if (Deno.build.os !== "win") {
const enc = new TextEncoder();
const data = enc.encode("Hello");
@ -56,7 +56,7 @@ testPerm({ read: true, write: true }, function writeFileSyncUpdatePerm() {
}
});
testPerm({ read: true, write: true }, function writeFileSyncCreate() {
testPerm({ read: true, write: true }, function writeFileSyncCreate(): void {
const enc = new TextEncoder();
const data = enc.encode("Hello");
const filename = Deno.makeTempDirSync() + "/test.txt";
@ -80,7 +80,7 @@ testPerm({ read: true, write: true }, function writeFileSyncCreate() {
assertEquals("Hello", actual);
});
testPerm({ read: true, write: true }, function writeFileSyncAppend() {
testPerm({ read: true, write: true }, function writeFileSyncAppend(): void {
const enc = new TextEncoder();
const data = enc.encode("Hello");
const filename = Deno.makeTempDirSync() + "/test.txt";
@ -102,34 +102,42 @@ testPerm({ read: true, write: true }, function writeFileSyncAppend() {
assertEquals("Hello", actual);
});
testPerm({ read: true, write: true }, async function writeFileSuccess() {
const enc = new TextEncoder();
const data = enc.encode("Hello");
const filename = Deno.makeTempDirSync() + "/test.txt";
await Deno.writeFile(filename, data);
const dataRead = Deno.readFileSync(filename);
const dec = new TextDecoder("utf-8");
const actual = dec.decode(dataRead);
assertEquals("Hello", actual);
});
testPerm({ read: true, write: true }, async function writeFileNotFound() {
const enc = new TextEncoder();
const data = enc.encode("Hello");
const filename = "/baddir/test.txt";
// The following should fail because /baddir doesn't exist (hopefully).
let caughtError = false;
try {
testPerm(
{ read: true, write: true },
async function writeFileSuccess(): Promise<void> {
const enc = new TextEncoder();
const data = enc.encode("Hello");
const filename = Deno.makeTempDirSync() + "/test.txt";
await Deno.writeFile(filename, data);
} catch (e) {
caughtError = true;
assertEquals(e.kind, Deno.ErrorKind.NotFound);
assertEquals(e.name, "NotFound");
const dataRead = Deno.readFileSync(filename);
const dec = new TextDecoder("utf-8");
const actual = dec.decode(dataRead);
assertEquals("Hello", actual);
}
assert(caughtError);
});
);
testPerm({ read: true, write: false }, async function writeFilePerm() {
testPerm(
{ read: true, write: true },
async function writeFileNotFound(): Promise<void> {
const enc = new TextEncoder();
const data = enc.encode("Hello");
const filename = "/baddir/test.txt";
// The following should fail because /baddir doesn't exist (hopefully).
let caughtError = false;
try {
await Deno.writeFile(filename, data);
} catch (e) {
caughtError = true;
assertEquals(e.kind, Deno.ErrorKind.NotFound);
assertEquals(e.name, "NotFound");
}
assert(caughtError);
}
);
testPerm({ read: true, write: false }, async function writeFilePerm(): Promise<
void
> {
const enc = new TextEncoder();
const data = enc.encode("Hello");
const filename = "/baddir/test.txt";
@ -145,19 +153,24 @@ testPerm({ read: true, write: false }, async function writeFilePerm() {
assert(caughtError);
});
testPerm({ read: true, write: true }, async function writeFileUpdatePerm() {
if (Deno.build.os !== "win") {
const enc = new TextEncoder();
const data = enc.encode("Hello");
const filename = Deno.makeTempDirSync() + "/test.txt";
await Deno.writeFile(filename, data, { perm: 0o755 });
assertEquals(Deno.statSync(filename).mode & 0o777, 0o755);
await Deno.writeFile(filename, data, { perm: 0o666 });
assertEquals(Deno.statSync(filename).mode & 0o777, 0o666);
testPerm(
{ read: true, write: true },
async function writeFileUpdatePerm(): Promise<void> {
if (Deno.build.os !== "win") {
const enc = new TextEncoder();
const data = enc.encode("Hello");
const filename = Deno.makeTempDirSync() + "/test.txt";
await Deno.writeFile(filename, data, { perm: 0o755 });
assertEquals(Deno.statSync(filename).mode & 0o777, 0o755);
await Deno.writeFile(filename, data, { perm: 0o666 });
assertEquals(Deno.statSync(filename).mode & 0o777, 0o666);
}
}
});
);
testPerm({ read: true, write: true }, async function writeFileCreate() {
testPerm({ read: true, write: true }, async function writeFileCreate(): Promise<
void
> {
const enc = new TextEncoder();
const data = enc.encode("Hello");
const filename = Deno.makeTempDirSync() + "/test.txt";
@ -181,7 +194,9 @@ testPerm({ read: true, write: true }, async function writeFileCreate() {
assertEquals("Hello", actual);
});
testPerm({ read: true, write: true }, async function writeFileAppend() {
testPerm({ read: true, write: true }, async function writeFileAppend(): Promise<
void
> {
const enc = new TextEncoder();
const data = enc.encode("Hello");
const filename = Deno.makeTempDirSync() + "/test.txt";

4
tests/004_set_timeout.ts
View file

@ -1,10 +1,10 @@
setTimeout(() => {
setTimeout((): void => {
console.log("World");
}, 10);
console.log("Hello");
const id = setTimeout(() => {
const id = setTimeout((): void => {
console.log("Not printed");
}, 10000);

10
tests/012_async.ts
View file

@ -1,9 +1,11 @@
// Check that we can use the async keyword.
async function main(): Promise<void> {
await new Promise(resolve => {
console.log("2");
setTimeout(resolve, 100);
});
await new Promise(
(resolve): void => {
console.log("2");
setTimeout(resolve, 100);
}
);
console.log("3");
}

2
tests/013_dynamic_import.ts
View file

@ -1,4 +1,4 @@
(async () => {
(async (): Promise<void> => {
const {
returnsHi,
returnsFoo2,

2
tests/014_duplicate_import.ts
View file

@ -4,6 +4,6 @@ import "./subdir/auto_print_hello.ts";
import "./subdir/auto_print_hello.ts";
(async () => {
(async (): Promise<void> => {
await import("./subdir/auto_print_hello.ts");
})();

2
tests/016_double_await.ts
View file

@ -1,6 +1,6 @@
// This is to test if Deno would die at 2nd await
// See https://github.com/denoland/deno/issues/919
(async () => {
(async (): Promise<void> => {
const currDirInfo = await Deno.stat(".");
const parentDirInfo = await Deno.stat("..");
console.log(currDirInfo.isDirectory());

2
tests/018_async_catch.ts
View file

@ -11,4 +11,4 @@ async function call(): Promise<void> {
}
console.log("after try-catch");
}
call().catch(() => console.log("outer catch"));
call().catch((): void => console.log("outer catch"));

4
tests/026_workers.ts
View file

@ -1,11 +1,11 @@
const jsWorker = new Worker("./tests/subdir/test_worker.js");
const tsWorker = new Worker("./tests/subdir/test_worker.ts");
tsWorker.onmessage = e => {
tsWorker.onmessage = (e): void => {
console.log("Received ts: " + e.data);
};
jsWorker.onmessage = e => {
jsWorker.onmessage = (e): void => {
console.log("Received js: " + e.data);
tsWorker.postMessage("Hello World");

8
tests/028_args.ts
View file

@ -1,3 +1,5 @@
Deno.args.forEach(arg => {
console.log(arg);
});
Deno.args.forEach(
(arg): void => {
console.log(arg);
}
);

12
tests/echo_server.ts
View file

@ -2,8 +2,10 @@ const { args, listen, copy } = Deno;
const addr = args[1] || "127.0.0.1:4544";
const listener = listen("tcp", addr);
console.log("listening on", addr);
listener.accept().then(async conn => {
await copy(conn, conn);
conn.close();
listener.close();
});
listener.accept().then(
async (conn): Promise<void> => {
await copy(conn, conn);
conn.close();
listener.close();
}
);

2
tests/error_005_missing_dynamic_import.ts
View file

@ -1,4 +1,4 @@
(async () => {
(async (): Promise<void> => {
// eslint-disable-next-line
const badModule = await import("bad-module.ts");
})();

2
tests/fetch_deps.ts
View file

@ -7,7 +7,7 @@ async function main(): Promise<void> {
const json = await response.json();
const deps = Object.keys(json.devDependencies);
console.log("Deno JS Deps");
console.log(deps.map(d => `* ${d}`).join("\n"));
console.log(deps.map((d): string => `* ${d}`).join("\n"));
assert(deps.includes("typescript"));
}

2
tests/subdir/bench_worker.ts
View file

@ -1,4 +1,4 @@
onmessage = function(e) {
onmessage = function(e): void {
const { cmdId, action, data } = e.data;
switch (action) {
case 0: // Static response

2
tests/subdir/test_worker.ts
View file

@ -1,4 +1,4 @@
onmessage = function(e) {
onmessage = function(e): void {
console.log(e.data);
postMessage(e.data);

22
tests/workers_round_robin_bench.ts
View file

@ -15,9 +15,11 @@ export type Resolvable<T> = Promise<T> & ResolvableMethods<T>;
export function createResolvable<T>(): Resolvable<T> {
let methods: ResolvableMethods<T>;
const promise = new Promise<T>((resolve, reject) => {
methods = { resolve, reject };
});
const promise = new Promise<T>(
(resolve, reject): void => {
methods = { resolve, reject };
}
);
// TypeScript doesn't know that the Promise callback occurs synchronously
// therefore use of not null assertion (`!`)
return Object.assign(promise, methods!) as Resolvable<T>;
@ -38,18 +40,20 @@ async function main(): Promise<void> {
const workers: Array<[Map<number, Resolvable<string>>, Worker]> = [];
for (var i = 1; i <= workerCount; ++i) {
const worker = new Worker("tests/subdir/bench_worker.ts");
const promise = new Promise(resolve => {
worker.onmessage = e => {
if (e.data.cmdId === 0) resolve();
};
});
const promise = new Promise(
(resolve): void => {
worker.onmessage = (e): void => {
if (e.data.cmdId === 0) resolve();
};
}
);
worker.postMessage({ cmdId: 0, action: 2 });
await promise;
workers.push([new Map(), worker]);
}
// assign callback function
for (const [promiseTable, worker] of workers) {
worker.onmessage = e => {
worker.onmessage = (e): void => {
handleAsyncMsgFromWorker(promiseTable, e.data);
};
}

12
tests/workers_startup_bench.ts
View file

@ -5,11 +5,13 @@ async function bench(): Promise<void> {
const workers: Worker[] = [];
for (var i = 1; i <= workerCount; ++i) {
const worker = new Worker("tests/subdir/bench_worker.ts");
const promise = new Promise(resolve => {
worker.onmessage = e => {
if (e.data.cmdId === 0) resolve();
};
});
const promise = new Promise(
(resolve): void => {
worker.onmessage = (e): void => {
if (e.data.cmdId === 0) resolve();
};
}
);
worker.postMessage({ cmdId: 0, action: 2 });
await promise;
workers.push(worker);

4
tools/lint.py
View file

@ -20,8 +20,8 @@ run([
])
run([
"node", eslint, "./js/**/*.{ts,js}", "./core/**/*.{ts,js}",
"./tests/**/*.{ts,js}"
"node", eslint, "--max-warnings=0", "./js/**/*.{ts,js}",
"./core/**/*.{ts,js}", "./tests/**/*.{ts,js}"
])
run([sys.executable, "third_party/depot_tools/pylint.py"] +