test: add known issue tests for fs.cp

test/known_issues/test-fs-cp-async-buffer.js

@@ -0,0 +1,21 @@
+'use strict';
+
+// We expect this test to fail because the implementation of fsPromise.cp
+// does not properly support the use of Buffer as the source or destination
+// argument like fs.cpSync does.
+
+const common = require('../common');
+const { mkdirSync, promises } = require('fs');
+const { join } = require('path');
+const tmpdir = require('../common/tmpdir');
+
+tmpdir.refresh();
+
+const tmpA = join(tmpdir.path, 'a');
+const tmpB = join(tmpdir.path, 'b');
+
+mkdirSync(tmpA, { recursive: true });
+
+promises.cp(Buffer.from(tmpA), Buffer.from(tmpB), {
+  recursive: true,
+}).then(common.mustCall());

test/known_issues/test-fs-cp-filter.js

@@ -0,0 +1,32 @@
+'use strict';
+
+// This test will fail because the the implementation does not properly
+// handle the case when the `src` or `dest` is a Buffer and the `filter`
+// function is utilized when recursively copying directories.
+
+const common = require('../common');
+
+const {
+  cpSync,
+  mkdirSync,
+} = require('fs');
+
+const {
+  join,
+} = require('path');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+const pathA = join(tmpdir.path, 'a');
+const pathAC = join(pathA, 'c');
+const pathB = join(tmpdir.path, 'b');
+mkdirSync(pathAC, { recursive: true });
+
+cpSync(Buffer.from(pathA), Buffer.from(pathB), {
+  recursive: true,
+  // This should be called multiple times, once for each file/directory,
+  // but it's only called once in this test because we're expecting this
+  // to fail.
+  filter: common.mustCall(() => true, 1),
+});

test/known_issues/test-fs-cp-non-utf8.js

@@ -0,0 +1,51 @@
+'use strict';
+
+const common = require('../common');
+
+if (!common.isLinux) {
+  common.skip('This test is only applicable to Linux');
+}
+
+const { ok, strictEqual } = require('assert');
+const { join } = require('path');
+const path = require('path');
+const tmpdir = require('../common/tmpdir');
+const {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  writeFileSync,
+  readFileSync,
+} = require('fs');
+tmpdir.refresh();
+
+const tmpdirPath = Buffer.from(join(tmpdir.path, 'a', 'c'));
+const sepBuf = Buffer.from(path.sep);
+
+mkdirSync(tmpdirPath, { recursive: true });
+
+// The name is the Shift-JIS encoded version of こんにちは世界,
+// or "Hello, World" in Japanese. On Linux systems, this name is
+// a valid path name and should be handled correctly by the copy
+// operation. However, the implementation of cp makes the assumption
+// that the path names are UTF-8 encoded, so while we can create the
+// file and check its existence using a Buffer, the recursive cp
+// operation will fail because it tries to interpret every file name
+// as UTF-8.
+const name = Buffer.from([
+  0x82, 0xB1, 0x82, 0xF1, 0x82, 0xC9, 0x82,
+  0xBF, 0x82, 0xCD, 0x90, 0x6C, 0x8C, 0x8E,
+]);
+const testPath = Buffer.concat([tmpdirPath, sepBuf, name]);
+
+writeFileSync(testPath, 'test content');
+ok(existsSync(testPath));
+strictEqual(readFileSync(testPath, 'utf8'), 'test content');
+
+// The cpSync is expected to fail because the implementation does not
+// properly handle non-UTF8 names in the path.
+
+cpSync(join(tmpdir.path, 'a'), join(tmpdir.path, 'b'), {
+  recursive: true,
+  filter: common.mustCall(() => true, 1),
+});