1 files changed, 0 insertions, 527 deletions
diff --git a/cli/js/tests/net_test.ts b/cli/js/tests/net_test.ts
deleted file mode 100644
index 9e9a1e5e8..000000000
--- a/cli/js/tests/net_test.ts
+++ /dev/null
@@ -1,527 +0,0 @@
-// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-import {
-  unitTest,
-  assert,
-  assertEquals,
-  createResolvable,
-} from "./test_util.ts";
-
-unitTest({ perms: { net: true } }, function netTcpListenClose(): void {
-  const listener = Deno.listen({ hostname: "127.0.0.1", port: 3500 });
-  assert(listener.addr.transport === "tcp");
-  assertEquals(listener.addr.hostname, "127.0.0.1");
-  assertEquals(listener.addr.port, 3500);
-  listener.close();
-});
-
-unitTest(
-  {
-    perms: { net: true },
-    // TODO:
-    ignore: Deno.build.os === "windows",
-  },
-  function netUdpListenClose(): void {
-    const socket = Deno.listenDatagram({
-      hostname: "127.0.0.1",
-      port: 3500,
-      transport: "udp",
-    });
-    assert(socket.addr.transport === "udp");
-    assertEquals(socket.addr.hostname, "127.0.0.1");
-    assertEquals(socket.addr.port, 3500);
-    socket.close();
-  }
-);
-
-unitTest(
-  { ignore: Deno.build.os === "windows", perms: { read: true, write: true } },
-  function netUnixListenClose(): void {
-    const filePath = Deno.makeTempFileSync();
-    const socket = Deno.listen({
-      path: filePath,
-      transport: "unix",
-    });
-    assert(socket.addr.transport === "unix");
-    assertEquals(socket.addr.path, filePath);
-    socket.close();
-  }
-);
-
-unitTest(
-  { ignore: Deno.build.os === "windows", perms: { read: true, write: true } },
-  function netUnixPacketListenClose(): void {
-    const filePath = Deno.makeTempFileSync();
-    const socket = Deno.listenDatagram({
-      path: filePath,
-      transport: "unixpacket",
-    });
-    assert(socket.addr.transport === "unixpacket");
-    assertEquals(socket.addr.path, filePath);
-    socket.close();
-  }
-);
-
-unitTest(
-  {
-    perms: { net: true },
-  },
-  async function netTcpCloseWhileAccept(): Promise<void> {
-    const listener = Deno.listen({ port: 4501 });
-    const p = listener.accept();
-    listener.close();
-    let err;
-    try {
-      await p;
-    } catch (e) {
-      err = e;
-    }
-    assert(!!err);
-    assert(err instanceof Error);
-    assertEquals(err.message, "Listener has been closed");
-  }
-);
-
-unitTest(
-  { ignore: Deno.build.os === "windows", perms: { read: true, write: true } },
-  async function netUnixCloseWhileAccept(): Promise<void> {
-    const filePath = await Deno.makeTempFile();
-    const listener = Deno.listen({
-      path: filePath,
-      transport: "unix",
-    });
-    const p = listener.accept();
-    listener.close();
-    let err;
-    try {
-      await p;
-    } catch (e) {
-      err = e;
-    }
-    assert(!!err);
-    assert(err instanceof Error);
-    assertEquals(err.message, "Listener has been closed");
-  }
-);
-
-unitTest(
-  { perms: { net: true } },
-  async function netTcpConcurrentAccept(): Promise<void> {
-    const listener = Deno.listen({ port: 4502 });
-    let acceptErrCount = 0;
-    const checkErr = (e: Error): void => {
-      if (e.message === "Listener has been closed") {
-        assertEquals(acceptErrCount, 1);
-      } else if (e.message === "Another accept task is ongoing") {
-        acceptErrCount++;
-      } else {
-        throw new Error("Unexpected error message");
-      }
-    };
-    const p = listener.accept().catch(checkErr);
-    const p1 = listener.accept().catch(checkErr);
-    await Promise.race([p, p1]);
-    listener.close();
-    await Promise.all([p, p1]);
-    assertEquals(acceptErrCount, 1);
-  }
-);
-
-// TODO(jsouto): Enable when tokio updates mio to v0.7!
-unitTest(
-  { ignore: true, perms: { read: true, write: true } },
-  async function netUnixConcurrentAccept(): Promise<void> {
-    const filePath = await Deno.makeTempFile();
-    const listener = Deno.listen({ transport: "unix", path: filePath });
-    let acceptErrCount = 0;
-    const checkErr = (e: Error): void => {
-      if (e.message === "Listener has been closed") {
-        assertEquals(acceptErrCount, 1);
-      } else if (e.message === "Another accept task is ongoing") {
-        acceptErrCount++;
-      } else {
-        throw new Error("Unexpected error message");
-      }
-    };
-    const p = listener.accept().catch(checkErr);
-    const p1 = listener.accept().catch(checkErr);
-    await Promise.race([p, p1]);
-    listener.close();
-    await [p, p1];
-    assertEquals(acceptErrCount, 1);
-  }
-);
-
-unitTest({ perms: { net: true } }, async function netTcpDialListen(): Promise<
-  void
-> {
-  const listener = Deno.listen({ port: 3500 });
-  listener.accept().then(
-    async (conn): Promise<void> => {
-      assert(conn.remoteAddr != null);
-      assert(conn.localAddr.transport === "tcp");
-      assertEquals(conn.localAddr.hostname, "127.0.0.1");
-      assertEquals(conn.localAddr.port, 3500);
-      await conn.write(new Uint8Array([1, 2, 3]));
-      conn.close();
-    }
-  );
-
-  const conn = await Deno.connect({ hostname: "127.0.0.1", port: 3500 });
-  assert(conn.remoteAddr.transport === "tcp");
-  assertEquals(conn.remoteAddr.hostname, "127.0.0.1");
-  assertEquals(conn.remoteAddr.port, 3500);
-  assert(conn.localAddr != null);
-  const buf = new Uint8Array(1024);
-  const readResult = await conn.read(buf);
-  assertEquals(3, readResult);
-  assertEquals(1, buf[0]);
-  assertEquals(2, buf[1]);
-  assertEquals(3, buf[2]);
-  assert(conn.rid > 0);
-
-  assert(readResult !== null);
-
-  const readResult2 = await conn.read(buf);
-  assertEquals(readResult2, null);
-
-  listener.close();
-  conn.close();
-});
-
-unitTest(
-  { ignore: Deno.build.os === "windows", perms: { read: true, write: true } },
-  async function netUnixDialListen(): Promise<void> {
-    const filePath = await Deno.makeTempFile();
-    const listener = Deno.listen({ path: filePath, transport: "unix" });
-    listener.accept().then(
-      async (conn): Promise<void> => {
-        assert(conn.remoteAddr != null);
-        assert(conn.localAddr.transport === "unix");
-        assertEquals(conn.localAddr.path, filePath);
-        await conn.write(new Uint8Array([1, 2, 3]));
-        conn.close();
-      }
-    );
-    const conn = await Deno.connect({ path: filePath, transport: "unix" });
-    assert(conn.remoteAddr.transport === "unix");
-    assertEquals(conn.remoteAddr.path, filePath);
-    assert(conn.remoteAddr != null);
-    const buf = new Uint8Array(1024);
-    const readResult = await conn.read(buf);
-    assertEquals(3, readResult);
-    assertEquals(1, buf[0]);
-    assertEquals(2, buf[1]);
-    assertEquals(3, buf[2]);
-    assert(conn.rid > 0);
-
-    assert(readResult !== null);
-
-    const readResult2 = await conn.read(buf);
-    assertEquals(readResult2, null);
-
-    listener.close();
-    conn.close();
-  }
-);
-
-unitTest(
-  { ignore: Deno.build.os === "windows", perms: { net: true } },
-  async function netUdpSendReceive(): Promise<void> {
-    const alice = Deno.listenDatagram({ port: 3500, transport: "udp" });
-    assert(alice.addr.transport === "udp");
-    assertEquals(alice.addr.port, 3500);
-    assertEquals(alice.addr.hostname, "127.0.0.1");
-
-    const bob = Deno.listenDatagram({ port: 4501, transport: "udp" });
-    assert(bob.addr.transport === "udp");
-    assertEquals(bob.addr.port, 4501);
-    assertEquals(bob.addr.hostname, "127.0.0.1");
-
-    const sent = new Uint8Array([1, 2, 3]);
-    await alice.send(sent, bob.addr);
-
-    const [recvd, remote] = await bob.receive();
-    assert(remote.transport === "udp");
-    assertEquals(remote.port, 3500);
-    assertEquals(recvd.length, 3);
-    assertEquals(1, recvd[0]);
-    assertEquals(2, recvd[1]);
-    assertEquals(3, recvd[2]);
-    alice.close();
-    bob.close();
-  }
-);
-
-unitTest(
-  { ignore: Deno.build.os === "windows", perms: { read: true, write: true } },
-  async function netUnixPacketSendReceive(): Promise<void> {
-    const filePath = await Deno.makeTempFile();
-    const alice = Deno.listenDatagram({
-      path: filePath,
-      transport: "unixpacket",
-    });
-    assert(alice.addr.transport === "unixpacket");
-    assertEquals(alice.addr.path, filePath);
-
-    const bob = Deno.listenDatagram({
-      path: filePath,
-      transport: "unixpacket",
-    });
-    assert(bob.addr.transport === "unixpacket");
-    assertEquals(bob.addr.path, filePath);
-
-    const sent = new Uint8Array([1, 2, 3]);
-    await alice.send(sent, bob.addr);
-
-    const [recvd, remote] = await bob.receive();
-    assert(remote.transport === "unixpacket");
-    assertEquals(remote.path, filePath);
-    assertEquals(recvd.length, 3);
-    assertEquals(1, recvd[0]);
-    assertEquals(2, recvd[1]);
-    assertEquals(3, recvd[2]);
-    alice.close();
-    bob.close();
-  }
-);
-
-unitTest(
-  { perms: { net: true } },
-  async function netTcpListenIteratorBreakClosesResource(): Promise<void> {
-    const promise = createResolvable();
-
-    async function iterate(listener: Deno.Listener): Promise<void> {
-      let i = 0;
-
-      for await (const conn of listener) {
-        conn.close();
-        i++;
-
-        if (i > 1) {
-          break;
-        }
-      }
-
-      promise.resolve();
-    }
-
-    const addr = { hostname: "127.0.0.1", port: 8888 };
-    const listener = Deno.listen(addr);
-    iterate(listener);
-
-    await new Promise((resolve: () => void, _) => {
-      setTimeout(resolve, 100);
-    });
-    const conn1 = await Deno.connect(addr);
-    conn1.close();
-    const conn2 = await Deno.connect(addr);
-    conn2.close();
-
-    await promise;
-  }
-);
-
-unitTest(
-  { perms: { net: true } },
-  async function netTcpListenCloseWhileIterating(): Promise<void> {
-    const listener = Deno.listen({ port: 8000 });
-    const nextWhileClosing = listener[Symbol.asyncIterator]().next();
-    listener.close();
-    assertEquals(await nextWhileClosing, { value: undefined, done: true });
-
-    const nextAfterClosing = listener[Symbol.asyncIterator]().next();
-    assertEquals(await nextAfterClosing, { value: undefined, done: true });
-  }
-);
-
-unitTest(
-  { ignore: Deno.build.os === "windows", perms: { net: true } },
-  async function netUdpListenCloseWhileIterating(): Promise<void> {
-    const socket = Deno.listenDatagram({ port: 8000, transport: "udp" });
-    const nextWhileClosing = socket[Symbol.asyncIterator]().next();
-    socket.close();
-    assertEquals(await nextWhileClosing, { value: undefined, done: true });
-
-    const nextAfterClosing = socket[Symbol.asyncIterator]().next();
-    assertEquals(await nextAfterClosing, { value: undefined, done: true });
-  }
-);
-
-unitTest(
-  { ignore: Deno.build.os === "windows", perms: { read: true, write: true } },
-  async function netUnixListenCloseWhileIterating(): Promise<void> {
-    const filePath = Deno.makeTempFileSync();
-    const socket = Deno.listen({ path: filePath, transport: "unix" });
-    const nextWhileClosing = socket[Symbol.asyncIterator]().next();
-    socket.close();
-    assertEquals(await nextWhileClosing, { value: undefined, done: true });
-
-    const nextAfterClosing = socket[Symbol.asyncIterator]().next();
-    assertEquals(await nextAfterClosing, { value: undefined, done: true });
-  }
-);
-
-unitTest(
-  { ignore: Deno.build.os === "windows", perms: { read: true, write: true } },
-  async function netUnixPacketListenCloseWhileIterating(): Promise<void> {
-    const filePath = Deno.makeTempFileSync();
-    const socket = Deno.listenDatagram({
-      path: filePath,
-      transport: "unixpacket",
-    });
-    const nextWhileClosing = socket[Symbol.asyncIterator]().next();
-    socket.close();
-    assertEquals(await nextWhileClosing, { value: undefined, done: true });
-
-    const nextAfterClosing = socket[Symbol.asyncIterator]().next();
-    assertEquals(await nextAfterClosing, { value: undefined, done: true });
-  }
-);
-
-unitTest(
-  {
-    // FIXME(bartlomieju)
-    ignore: true,
-    perms: { net: true },
-  },
-  async function netListenAsyncIterator(): Promise<void> {
-    const addr = { hostname: "127.0.0.1", port: 3500 };
-    const listener = Deno.listen(addr);
-    const runAsyncIterator = async (): Promise<void> => {
-      for await (const conn of listener) {
-        await conn.write(new Uint8Array([1, 2, 3]));
-        conn.close();
-      }
-    };
-    runAsyncIterator();
-    const conn = await Deno.connect(addr);
-    const buf = new Uint8Array(1024);
-    const readResult = await conn.read(buf);
-    assertEquals(3, readResult);
-    assertEquals(1, buf[0]);
-    assertEquals(2, buf[1]);
-    assertEquals(3, buf[2]);
-    assert(conn.rid > 0);
-
-    assert(readResult !== null);
-
-    const readResult2 = await conn.read(buf);
-    assertEquals(readResult2, null);
-
-    listener.close();
-    conn.close();
-  }
-);
-
-unitTest(
-  {
-    // FIXME(bartlomieju)
-    ignore: true,
-    perms: { net: true },
-  },
-  async function netCloseWriteSuccess() {
-    const addr = { hostname: "127.0.0.1", port: 3500 };
-    const listener = Deno.listen(addr);
-    const closeDeferred = createResolvable();
-    listener.accept().then(async (conn) => {
-      await conn.write(new Uint8Array([1, 2, 3]));
-      await closeDeferred;
-      conn.close();
-    });
-    const conn = await Deno.connect(addr);
-    conn.closeWrite(); // closing write
-    const buf = new Uint8Array(1024);
-    // Check read not impacted
-    const readResult = await conn.read(buf);
-    assertEquals(3, readResult);
-    assertEquals(1, buf[0]);
-    assertEquals(2, buf[1]);
-    assertEquals(3, buf[2]);
-    // Check write should be closed
-    let err;
-    try {
-      await conn.write(new Uint8Array([1, 2, 3]));
-    } catch (e) {
-      err = e;
-    }
-    assert(!!err);
-    assert(err instanceof Deno.errors.BrokenPipe);
-    closeDeferred.resolve();
-    listener.close();
-    conn.close();
-  }
-);
-
-unitTest(
-  {
-    // FIXME(bartlomieju)
-    ignore: true,
-    perms: { net: true },
-  },
-  async function netDoubleCloseWrite() {
-    const addr = { hostname: "127.0.0.1", port: 3500 };
-    const listener = Deno.listen(addr);
-    const closeDeferred = createResolvable();
-    listener.accept().then(async (conn) => {
-      await closeDeferred;
-      conn.close();
-    });
-    const conn = await Deno.connect(addr);
-    conn.closeWrite(); // closing write
-    let err;
-    try {
-      // Duplicated close should throw error
-      conn.closeWrite();
-    } catch (e) {
-      err = e;
-    }
-    assert(!!err);
-    assert(err instanceof Deno.errors.NotConnected);
-    closeDeferred.resolve();
-    listener.close();
-    conn.close();
-  }
-);
-
-unitTest(
-  {
-    perms: { net: true },
-  },
-  async function netHangsOnClose() {
-    let acceptedConn: Deno.Conn;
-    const resolvable = createResolvable();
-
-    async function iteratorReq(listener: Deno.Listener): Promise<void> {
-      const p = new Uint8Array(10);
-      const conn = await listener.accept();
-      acceptedConn = conn;
-
-      try {
-        while (true) {
-          const nread = await conn.read(p);
-          if (nread === null) {
-            break;
-          }
-          await conn.write(new Uint8Array([1, 2, 3]));
-        }
-      } catch (err) {
-        assert(!!err);
-        assert(err instanceof Deno.errors.BadResource);
-      }
-
-      resolvable.resolve();
-    }
-
-    const addr = { hostname: "127.0.0.1", port: 3500 };
-    const listener = Deno.listen(addr);
-    iteratorReq(listener);
-    const conn = await Deno.connect(addr);
-    await conn.write(new Uint8Array([1, 2, 3, 4]));
-    const buf = new Uint8Array(10);
-    await conn.read(buf);
-    conn!.close();
-    acceptedConn!.close();
-    listener.close();
-    await resolvable;
-  }
-);