chore: move cli/tests/ -> tests/ (#22369)

This looks like a massive PR, but it's only a move from cli/tests ->
tests, and updates of relative paths for files.

This is the first step towards aggregate all of the integration test
files under tests/, which will lead to a set of integration tests that
can run without the CLI binary being built.

While we could leave these tests under `cli`, it would require us to
keep a more complex directory structure for the various test runners. In
addition, we have a lot of complexity to ignore various test files in
the `cli` project itself (cargo publish exclusion rules, autotests =
false, etc).

And finally, the `tests/` folder will eventually house the `test_ffi`,
`test_napi` and other testing code, reducing the size of the root repo
directory.

For easier review, the extremely large and noisy "move" is in the first
commit (with no changes -- just a move), while the remainder of the
changes to actual files is in the second commit.

1 files changed, 322 insertions, 0 deletions

diff --git a/tests/unit_node/_fs/_fs_read_test.ts b/tests/unit_node/_fs/_fs_read_test.ts
new file mode 100644
index 000000000..de741e377
--- /dev/null
+++ b/tests/unit_node/_fs/_fs_read_test.ts
@@ -0,0 +1,322 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+import {
+  assertEquals,
+  assertFalse,
+  assertMatch,
+  assertStrictEquals,
+} from "@test_util/std/assert/mod.ts";
+import { read, readSync } from "node:fs";
+import { open, openSync } from "node:fs";
+import { Buffer } from "node:buffer";
+import * as path from "@test_util/std/path/mod.ts";
+import { closeSync } from "node:fs";
+
+async function readTest(
+  testData: string,
+  buffer: Buffer,
+  offset: number,
+  length: number,
+  position: number | null = null,
+  expected: (
+    fd: number,
+    bytesRead: number | null,
+    data: Buffer | undefined,
+  ) => void,
+) {
+  let fd1 = 0;
+  await new Promise<{
+    fd: number;
+    bytesRead: number | null;
+    data: Buffer | undefined;
+  }>((resolve, reject) => {
+    open(testData, "r", (err, fd) => {
+      if (err) reject(err);
+      read(fd, buffer, offset, length, position, (err, bytesRead, data) => {
+        if (err) reject(err);
+        resolve({ fd, bytesRead, data });
+      });
+    });
+  })
+    .then(({ fd, bytesRead, data }) => {
+      fd1 = fd;
+      expected(fd, bytesRead, data);
+    })
+    .finally(() => closeSync(fd1));
+}
+
+Deno.test({
+  name: "readSuccess",
+  async fn() {
+    const moduleDir = path.dirname(path.fromFileUrl(import.meta.url));
+    const testData = path.resolve(moduleDir, "testdata", "hello.txt");
+    const buf = Buffer.alloc(1024);
+    await readTest(
+      testData,
+      buf,
+      buf.byteOffset,
+      buf.byteLength,
+      null,
+      (_fd, bytesRead, data) => {
+        assertStrictEquals(bytesRead, 11);
+        assertEquals(data instanceof Buffer, true);
+        assertMatch((data as Buffer).toString(), /hello world/);
+      },
+    );
+  },
+});
+
+Deno.test({
+  name:
+    "[std/node/fs] Read only five bytes, so that the position moves to five",
+  async fn() {
+    const moduleDir = path.dirname(path.fromFileUrl(import.meta.url));
+    const testData = path.resolve(moduleDir, "testdata", "hello.txt");
+    const buf = Buffer.alloc(5);
+    await readTest(
+      testData,
+      buf,
+      buf.byteOffset,
+      5,
+      null,
+      (_fd, bytesRead, data) => {
+        assertStrictEquals(bytesRead, 5);
+        assertEquals(data instanceof Buffer, true);
+        assertEquals((data as Buffer).toString(), "hello");
+      },
+    );
+  },
+});
+
+Deno.test({
+  name:
+    "[std/node/fs] position option of fs.read() specifies where to begin reading from in the file",
+  async fn() {
+    const moduleDir = path.dirname(path.fromFileUrl(import.meta.url));
+    const testData = path.resolve(moduleDir, "testdata", "hello.txt");
+    const fd = openSync(testData, "r");
+    const buf = Buffer.alloc(5);
+    const positions = [6, 0, -1, null];
+    const expected = [
+      [119, 111, 114, 108, 100],
+      [104, 101, 108, 108, 111],
+      [104, 101, 108, 108, 111],
+      [32, 119, 111, 114, 108],
+    ];
+    for (const [i, position] of positions.entries()) {
+      await new Promise((resolve) => {
+        read(
+          fd,
+          {
+            buffer: buf,
+            offset: buf.byteOffset,
+            length: buf.byteLength,
+            position,
+          },
+          (err, bytesRead, data) => {
+            assertEquals(err, null);
+            assertStrictEquals(bytesRead, 5);
+            assertEquals(
+              data,
+              Buffer.from(expected[i]),
+            );
+            return resolve(true);
+          },
+        );
+      });
+    }
+    closeSync(fd);
+  },
+});
+
+Deno.test({
+  name: "[std/node/fs] Read fs.read(fd, options, cb) signature",
+  async fn() {
+    const { promise, reject, resolve } = Promise.withResolvers<void>();
+    const file = Deno.makeTempFileSync();
+    Deno.writeTextFileSync(file, "hi there");
+    const fd = openSync(file, "r+");
+    const buf = Buffer.alloc(11);
+    read(
+      fd,
+      {
+        buffer: buf,
+        offset: buf.byteOffset,
+        length: buf.byteLength,
+        position: null,
+      },
+      (err, bytesRead, data) => {
+        try {
+          assertEquals(err, null);
+          assertStrictEquals(bytesRead, 8);
+          assertEquals(
+            data,
+            Buffer.from([104, 105, 32, 116, 104, 101, 114, 101, 0, 0, 0]),
+          );
+        } catch (e) {
+          reject(e);
+          return;
+        }
+        resolve();
+      },
+    );
+    closeSync(fd);
+    await promise;
+  },
+});
+
+Deno.test({
+  name: "[std/node/fs] Read fs.read(fd, cb) signature",
+  async fn() {
+    const { promise, resolve, reject } = Promise.withResolvers<void>();
+    const file = Deno.makeTempFileSync();
+    Deno.writeTextFileSync(file, "hi deno");
+    const fd = openSync(file, "r+");
+    read(fd, (err, bytesRead, data) => {
+      try {
+        assertEquals(err, null);
+        assertStrictEquals(bytesRead, 7);
+        assertStrictEquals(data?.byteLength, 16384);
+      } catch (e) {
+        reject(e);
+        return;
+      }
+      resolve();
+    });
+    closeSync(fd);
+    await promise;
+  },
+});
+
+Deno.test({
+  name: "SYNC: readSuccess",
+  fn() {
+    const moduleDir = path.dirname(path.fromFileUrl(import.meta.url));
+    const testData = path.resolve(moduleDir, "testdata", "hello.txt");
+    const buffer = Buffer.alloc(1024);
+    const fd = openSync(testData, "r");
+    const bytesRead = readSync(
+      fd,
+      buffer,
+      buffer.byteOffset,
+      buffer.byteLength,
+      null,
+    );
+    assertStrictEquals(bytesRead, 11);
+    closeSync(fd);
+  },
+});
+
+Deno.test({
+  name: "[std/node/fs] Read only two bytes, so that the position moves to two",
+  fn() {
+    const moduleDir = path.dirname(path.fromFileUrl(import.meta.url));
+    const testData = path.resolve(moduleDir, "testdata", "hello.txt");
+    const buffer = Buffer.alloc(2);
+    const fd = openSync(testData, "r");
+    const bytesRead = readSync(fd, buffer, buffer.byteOffset, 2, null);
+    assertStrictEquals(bytesRead, 2);
+    closeSync(fd);
+  },
+});
+
+Deno.test({
+  name:
+    "[std/node/fs] position option of fs.readSync() specifies where to begin reading from in the file",
+  fn() {
+    const moduleDir = path.dirname(path.fromFileUrl(import.meta.url));
+    const testData = path.resolve(moduleDir, "testdata", "hello.txt");
+    const fd = openSync(testData, "r");
+    const buf = Buffer.alloc(5);
+    const positions = [6, 0, -1, null];
+    const expected = [
+      [119, 111, 114, 108, 100],
+      [104, 101, 108, 108, 111],
+      [104, 101, 108, 108, 111],
+      [32, 119, 111, 114, 108],
+    ];
+    for (const [i, position] of positions.entries()) {
+      const bytesRead = readSync(
+        fd,
+        buf,
+        buf.byteOffset,
+        buf.byteLength,
+        position,
+      );
+      assertStrictEquals(bytesRead, 5);
+      assertEquals(
+        buf,
+        Buffer.from(expected[i]),
+      );
+    }
+    closeSync(fd);
+  },
+});
+
+Deno.test({
+  name: "[std/node/fs] Read fs.readSync(fd, buffer[, options]) signature",
+  fn() {
+    const file = Deno.makeTempFileSync();
+    Deno.writeTextFileSync(file, "hello deno");
+    const buffer = Buffer.alloc(1024);
+    const fd = openSync(file, "r+");
+    const bytesRead = readSync(fd, buffer, {
+      length: buffer.byteLength,
+      offset: buffer.byteOffset,
+      position: null,
+    });
+    assertStrictEquals(bytesRead, 10);
+    closeSync(fd);
+  },
+});
+
+Deno.test({
+  name: "[std/node/fs] fs.read is async",
+  async fn(t) {
+    const file = await Deno.makeTempFile();
+    await Deno.writeTextFile(file, "abc");
+
+    await t.step("without position option", async () => {
+      const { promise, resolve } = Promise.withResolvers<void>();
+      let called = false;
+      const fd = openSync(file, "r");
+      read(fd, () => {
+        called = true;
+        closeSync(fd);
+        resolve();
+      });
+      assertFalse(called);
+      await promise;
+    });
+
+    await t.step("with position option", async () => {
+      const { promise, resolve } = Promise.withResolvers<void>();
+      let called = false;
+      const buffer = Buffer.alloc(2);
+      const fd = openSync(file, "r");
+      read(fd, { position: 1, buffer, offset: 0, length: 2 }, () => {
+        called = true;
+        closeSync(fd);
+        resolve();
+      });
+      assertFalse(called);
+      await promise;
+    });
+
+    await Deno.remove(file);
+  },
+});
+
+Deno.test({
+  name: "SYNC: read with no offsetOropts argument",
+  fn() {
+    const moduleDir = path.dirname(path.fromFileUrl(import.meta.url));
+    const testData = path.resolve(moduleDir, "testdata", "hello.txt");
+    const buffer = Buffer.alloc(1024);
+    const fd = openSync(testData, "r");
+    const _bytesRead = readSync(
+      fd,
+      buffer,
+    );
+    closeSync(fd);
+  },
+});