@zenfs/devel 0.0.1 → 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (71) hide show
  1. package/dist/bin/zenfs-test.js +3 -2
  2. package/dist/tests/common.js +1 -1
  3. package/dist/tests/fs/append.test.d.ts +1 -0
  4. package/dist/tests/fs/append.test.js +27 -0
  5. package/dist/tests/fs/concurrency.test.d.ts +1 -0
  6. package/dist/tests/fs/concurrency.test.js +76 -0
  7. package/dist/tests/fs/dir.test.d.ts +1 -0
  8. package/dist/tests/fs/dir.test.js +83 -0
  9. package/dist/tests/fs/directory.test.d.ts +1 -0
  10. package/dist/tests/fs/directory.test.js +151 -0
  11. package/dist/tests/fs/errors.test.d.ts +1 -0
  12. package/dist/tests/fs/errors.test.js +141 -0
  13. package/dist/tests/fs/exists.test.d.ts +1 -0
  14. package/dist/tests/fs/exists.test.js +19 -0
  15. package/dist/tests/fs/links.test.d.ts +1 -0
  16. package/dist/tests/fs/links.test.js +248 -0
  17. package/dist/tests/fs/open.test.d.ts +1 -0
  18. package/dist/tests/fs/open.test.js +95 -0
  19. package/dist/tests/fs/permissions.test.d.ts +1 -0
  20. package/dist/tests/fs/permissions.test.js +346 -0
  21. package/dist/tests/fs/read.test.d.ts +1 -0
  22. package/dist/tests/fs/read.test.js +149 -0
  23. package/dist/tests/fs/readFile.test.d.ts +1 -0
  24. package/dist/tests/fs/readFile.test.js +110 -0
  25. package/dist/tests/fs/rename.test.d.ts +1 -0
  26. package/dist/tests/fs/rename.test.js +70 -0
  27. package/dist/tests/fs/scaling.test.d.ts +1 -0
  28. package/dist/tests/fs/scaling.test.js +27 -0
  29. package/dist/tests/fs/stat.test.d.ts +1 -0
  30. package/dist/tests/fs/stat.test.js +93 -0
  31. package/dist/tests/fs/streams.test.d.ts +1 -0
  32. package/dist/tests/fs/streams.test.js +161 -0
  33. package/dist/tests/fs/tempdir.test.d.ts +1 -0
  34. package/dist/tests/fs/tempdir.test.js +118 -0
  35. package/dist/tests/fs/times.test.d.ts +7 -0
  36. package/dist/tests/fs/times.test.js +134 -0
  37. package/dist/tests/fs/truncate.test.d.ts +1 -0
  38. package/dist/tests/fs/truncate.test.js +62 -0
  39. package/dist/tests/fs/watch.test.d.ts +1 -0
  40. package/dist/tests/fs/watch.test.js +320 -0
  41. package/dist/tests/fs/write.test.d.ts +1 -0
  42. package/dist/tests/fs/write.test.js +83 -0
  43. package/dist/tests/fs/xattr.test.d.ts +1 -0
  44. package/dist/tests/fs/xattr.test.js +137 -0
  45. package/dist/tests/setup/memory.d.ts +1 -0
  46. package/dist/tests/setup/memory.js +3 -0
  47. package/package.json +5 -5
  48. package/tests/readme.md +2 -2
  49. package/tests/fs/append.test.ts +0 -34
  50. package/tests/fs/concurrency.test.ts +0 -113
  51. package/tests/fs/dir.test.ts +0 -103
  52. package/tests/fs/directory.test.ts +0 -189
  53. package/tests/fs/errors.test.ts +0 -159
  54. package/tests/fs/exists.test.ts +0 -23
  55. package/tests/fs/links.test.ts +0 -308
  56. package/tests/fs/open.test.ts +0 -23
  57. package/tests/fs/permissions.test.ts +0 -344
  58. package/tests/fs/read.test.ts +0 -94
  59. package/tests/fs/readFile.test.ts +0 -58
  60. package/tests/fs/rename.test.ts +0 -93
  61. package/tests/fs/scaling.test.ts +0 -35
  62. package/tests/fs/stat.test.ts +0 -115
  63. package/tests/fs/streams.test.ts +0 -204
  64. package/tests/fs/tempdir.test.ts +0 -64
  65. package/tests/fs/times.test.ts +0 -85
  66. package/tests/fs/truncate.test.ts +0 -89
  67. package/tests/fs/watch.test.ts +0 -246
  68. package/tests/fs/write.test.ts +0 -118
  69. package/tests/fs/xattr.test.ts +0 -96
  70. package/tests/setup/memory.ts +0 -3
  71. package/tests/tsconfig.json +0 -8
@@ -0,0 +1,248 @@
1
+ // SPDX-License-Identifier: LGPL-3.0-or-later
2
+ import { join } from '@zenfs/core/path';
3
+ import assert from 'node:assert/strict';
4
+ import { suite, test } from 'node:test';
5
+ import { config, fs } from '../common.js';
6
+ suite('Links', config('symlinks'), () => {
7
+ const target = '/a1.js', symlink = 'symlink1.js', hardlink = 'link1.js';
8
+ test('symlink', async () => {
9
+ await fs.promises.symlink(target, symlink);
10
+ });
11
+ test('lstat', async () => {
12
+ const stats = await fs.promises.lstat(symlink);
13
+ assert(stats.isSymbolicLink());
14
+ });
15
+ test('symlinks have mode 0o777 #326', async () => {
16
+ assert.equal((await fs.promises.lstat(symlink)).mode & 0o7777, 0o777);
17
+ fs.symlinkSync(target, 'symlink-sync.js');
18
+ const stats = fs.lstatSync('symlink-sync.js');
19
+ assert(stats.isSymbolicLink());
20
+ assert.equal(stats.mode & 0o7777, 0o777);
21
+ fs.unlinkSync('symlink-sync.js');
22
+ });
23
+ test('lstat file inside symlinked directory #241', async () => {
24
+ await fs.promises.mkdir('/a');
25
+ await fs.promises.writeFile('/a/hello.txt', 'hello world');
26
+ await fs.promises.symlink('/a', '/b');
27
+ const stat = await fs.promises.lstat('/b/hello.txt');
28
+ assert(stat.isFile());
29
+ });
30
+ test('readlink', async () => {
31
+ const destination = await fs.promises.readlink(symlink);
32
+ assert.equal(destination, target);
33
+ assert.throws(() => fs.readlinkSync(destination));
34
+ });
35
+ test('read target contents', async () => {
36
+ assert.equal(await fs.promises.readFile(target, 'utf-8'), await fs.promises.readFile(symlink, 'utf-8'));
37
+ });
38
+ test('nested symlinks', async () => {
39
+ // Create the real directory structure
40
+ const realDir = '/real-dir';
41
+ const realFile = '/real-dir/realfile.txt';
42
+ const fileContent = 'hello world';
43
+ await fs.promises.mkdir(realDir);
44
+ await fs.promises.writeFile(realFile, fileContent);
45
+ // Create first symlink (symlink-dir -> real-dir)
46
+ const symlinkDir = '/symlink-dir';
47
+ await fs.promises.symlink(realDir, symlinkDir);
48
+ const symfile = 'symfile.txt';
49
+ const symlinkFile = join(realDir, symfile);
50
+ // Create second symlink (symlink-dir -> real-dir)
51
+ await fs.promises.symlink(realFile, symlinkFile);
52
+ // Now access file through nested symlinks
53
+ const nestedPath = join(symlinkDir, symfile);
54
+ // Verify realpath resolution
55
+ const resolvedPath = await fs.promises.realpath(nestedPath);
56
+ assert.equal(resolvedPath, realFile);
57
+ // Verify content can be read through nested symlinks
58
+ const content = await fs.promises.readFile(nestedPath, 'utf8');
59
+ assert.notEqual(content, '/real-dir/realfile.txt');
60
+ assert.equal(content, fileContent);
61
+ });
62
+ test('unlink', async () => {
63
+ await fs.promises.unlink(symlink);
64
+ assert(!(await fs.promises.stat(symlink, { throwIfNoEntry: false })));
65
+ assert(await fs.promises.stat(target, { throwIfNoEntry: false }));
66
+ });
67
+ test('link', config('links'), async () => {
68
+ await fs.promises.link(target, hardlink);
69
+ const targetContent = await fs.promises.readFile(target, 'utf8');
70
+ const linkContent = await fs.promises.readFile(hardlink, 'utf8');
71
+ assert.equal(targetContent, linkContent);
72
+ });
73
+ test('file inside symlinked directory', async () => {
74
+ await fs.promises.symlink('.', 'link');
75
+ const targetContent = await fs.promises.readFile(target, 'utf8');
76
+ const link = join('link', target);
77
+ assert((await fs.promises.realpath(link)) === target);
78
+ const linkContent = await fs.promises.readFile(link, 'utf8');
79
+ assert.equal(targetContent, linkContent);
80
+ });
81
+ test('mkdir does not follow a symlink at the final component', config('async'), async () => {
82
+ await fs.promises.mkdir('/mkdir-real');
83
+ await fs.promises.symlink('/mkdir-real', '/mkdir-link');
84
+ await fs.promises.writeFile('/mkdir-file', 'contents');
85
+ await fs.promises.symlink('/mkdir-file', '/mkdir-flink');
86
+ await fs.promises.symlink('/mkdir-missing', '/mkdir-dangling');
87
+ await assert.rejects(fs.promises.mkdir('/mkdir-link'), { code: 'EEXIST' });
88
+ await assert.rejects(fs.promises.mkdir('/mkdir-dangling'), { code: 'EEXIST' });
89
+ await assert.rejects(fs.promises.mkdir('/mkdir-flink', { recursive: true }), { code: 'EEXIST' });
90
+ await assert.rejects(fs.promises.mkdir('/mkdir-dangling', { recursive: true }), { code: 'ENOENT' });
91
+ // A link pointing at a directory satisfies a recursive mkdir and is left as a link
92
+ assert.equal(await fs.promises.mkdir('/mkdir-link', { recursive: true }), undefined);
93
+ assert((await fs.promises.lstat('/mkdir-link')).isSymbolicLink());
94
+ assert(!(await fs.promises.stat('/mkdir-missing', { throwIfNoEntry: false })));
95
+ });
96
+ test('mkdir follows symlinks for intermediate components', config('async'), async () => {
97
+ assert.equal(await fs.promises.mkdir('/mkdir-link/direct'), undefined);
98
+ assert.equal(await fs.promises.mkdir('/mkdir-link/nested/deep', { recursive: true }), '/mkdir-link/nested');
99
+ assert.deepEqual((await fs.promises.readdir('/mkdir-real')).sort(), ['direct', 'nested']);
100
+ assert((await fs.promises.stat('/mkdir-real/nested/deep')).isDirectory());
101
+ await assert.rejects(fs.promises.mkdir('/mkdir-flink/x', { recursive: true }), { code: 'ENOTDIR' });
102
+ // Node reports the link itself here, unlike `mkdirSync` which reports the requested path with ENOENT
103
+ await assert.rejects(fs.promises.mkdir('/mkdir-dangling/x', { recursive: true }), { code: 'ENOTDIR', path: '/mkdir-dangling' });
104
+ assert(!(await fs.promises.stat('/mkdir-missing', { throwIfNoEntry: false })));
105
+ });
106
+ test('mkdirSync does not follow a symlink at the final component', config('sync'), () => {
107
+ fs.mkdirSync('/mkdirS-real');
108
+ fs.symlinkSync('/mkdirS-real', '/mkdirS-link');
109
+ fs.writeFileSync('/mkdirS-file', 'contents');
110
+ fs.symlinkSync('/mkdirS-file', '/mkdirS-flink');
111
+ fs.symlinkSync('/mkdirS-missing', '/mkdirS-dangling');
112
+ assert.throws(() => fs.mkdirSync('/mkdirS-link'), { code: 'EEXIST' });
113
+ assert.throws(() => fs.mkdirSync('/mkdirS-dangling'), { code: 'EEXIST' });
114
+ assert.throws(() => fs.mkdirSync('/mkdirS-flink', { recursive: true }), { code: 'EEXIST' });
115
+ assert.throws(() => fs.mkdirSync('/mkdirS-dangling', { recursive: true }), { code: 'ENOENT' });
116
+ assert.equal(fs.mkdirSync('/mkdirS-link', { recursive: true }), undefined);
117
+ assert(fs.lstatSync('/mkdirS-link').isSymbolicLink());
118
+ assert(!fs.existsSync('/mkdirS-missing'));
119
+ });
120
+ test('mkdirSync follows symlinks for intermediate components', config('sync'), () => {
121
+ assert.equal(fs.mkdirSync('/mkdirS-link/direct'), undefined);
122
+ assert.equal(fs.mkdirSync('/mkdirS-link/nested/deep', { recursive: true }), '/mkdirS-link/nested');
123
+ assert.deepEqual(fs.readdirSync('/mkdirS-real').sort(), ['direct', 'nested']);
124
+ assert(fs.statSync('/mkdirS-real/nested/deep').isDirectory());
125
+ assert.throws(() => fs.mkdirSync('/mkdirS-flink/x', { recursive: true }), { code: 'ENOTDIR' });
126
+ assert.throws(() => fs.mkdirSync('/mkdirS-dangling/x', { recursive: true }), { code: 'ENOENT', path: '/mkdirS-dangling/x' });
127
+ assert(!fs.existsSync('/mkdirS-missing'));
128
+ });
129
+ test('writeFile and appendFile follow symlinks', config('async'), async () => {
130
+ await fs.promises.mkdir('/wf-real');
131
+ await fs.promises.symlink('/wf-real', '/wf-link');
132
+ await fs.promises.writeFile('/wf-real/f.txt', 'original');
133
+ await fs.promises.symlink('/wf-real/f.txt', '/wf-flink');
134
+ await fs.promises.symlink('/wf-missing.txt', '/wf-dangling');
135
+ await fs.promises.writeFile('/wf-link/new.txt', 'hi');
136
+ assert.equal(await fs.promises.readFile('/wf-real/new.txt', 'utf8'), 'hi');
137
+ // A link to a file is written through, not replaced
138
+ await fs.promises.writeFile('/wf-flink', 'replaced');
139
+ await fs.promises.appendFile('/wf-flink', '+');
140
+ assert.equal(await fs.promises.readFile('/wf-real/f.txt', 'utf8'), 'replaced+');
141
+ assert((await fs.promises.lstat('/wf-flink')).isSymbolicLink());
142
+ // Writing through a dangling link creates its target
143
+ await fs.promises.writeFile('/wf-dangling', 'made');
144
+ assert.equal(await fs.promises.readFile('/wf-missing.txt', 'utf8'), 'made');
145
+ assert((await fs.promises.lstat('/wf-dangling')).isSymbolicLink());
146
+ });
147
+ test('writeFileSync and appendFileSync follow symlinks', config('sync'), () => {
148
+ fs.mkdirSync('/wfS-real');
149
+ fs.symlinkSync('/wfS-real', '/wfS-link');
150
+ fs.writeFileSync('/wfS-real/f.txt', 'original');
151
+ fs.symlinkSync('/wfS-real/f.txt', '/wfS-flink');
152
+ fs.symlinkSync('/wfS-missing.txt', '/wfS-dangling');
153
+ fs.writeFileSync('/wfS-link/new.txt', 'hi');
154
+ assert.equal(fs.readFileSync('/wfS-real/new.txt', 'utf8'), 'hi');
155
+ fs.writeFileSync('/wfS-flink', 'replaced');
156
+ fs.appendFileSync('/wfS-flink', '+');
157
+ assert.equal(fs.readFileSync('/wfS-real/f.txt', 'utf8'), 'replaced+');
158
+ assert(fs.lstatSync('/wfS-flink').isSymbolicLink());
159
+ fs.writeFileSync('/wfS-dangling', 'made');
160
+ assert.equal(fs.readFileSync('/wfS-missing.txt', 'utf8'), 'made');
161
+ assert(fs.lstatSync('/wfS-dangling').isSymbolicLink());
162
+ });
163
+ test('operations follow symlinks in parent directories', config('async'), async () => {
164
+ await fs.promises.mkdir('/parent-real');
165
+ await fs.promises.symlink('/parent-real', '/parent-link');
166
+ await fs.promises.writeFile('/parent-real/unlink', 'x');
167
+ await fs.promises.writeFile('/parent-real/rename', 'x');
168
+ await fs.promises.mkdir('/parent-real/rmdir');
169
+ await fs.promises.symlink('/parent-real/renamed', '/parent-real/symlink');
170
+ await fs.promises.symlink('/parent-real/rmdir', '/parent-real/dir-link');
171
+ await fs.promises.unlink('/parent-link/unlink');
172
+ await fs.promises.rename('/parent-link/rename', '/parent-link/renamed');
173
+ assert.equal(await fs.promises.readlink('/parent-link/symlink'), '/parent-real/renamed');
174
+ await fs.promises.lutimes('/parent-link/symlink', 1, 1);
175
+ assert.equal((await fs.promises.lstat('/parent-real/symlink')).mtimeMs, 1000);
176
+ await assert.rejects(fs.promises.rmdir('/parent-link/dir-link'), { code: 'ENOTDIR' });
177
+ await fs.promises.unlink('/parent-link/dir-link');
178
+ await fs.promises.rmdir('/parent-link/rmdir');
179
+ assert.deepEqual((await fs.promises.readdir('/parent-real')).sort(), ['renamed', 'symlink']);
180
+ });
181
+ test('operations follow symlinks in parent directories (sync)', config('sync'), () => {
182
+ fs.mkdirSync('/parentS-real');
183
+ fs.symlinkSync('/parentS-real', '/parentS-link');
184
+ fs.writeFileSync('/parentS-real/unlink', 'x');
185
+ fs.writeFileSync('/parentS-real/rename', 'x');
186
+ fs.mkdirSync('/parentS-real/rmdir');
187
+ fs.symlinkSync('/parentS-real/renamed', '/parentS-real/symlink');
188
+ fs.symlinkSync('/parentS-real/rmdir', '/parentS-real/dir-link');
189
+ fs.unlinkSync('/parentS-link/unlink');
190
+ fs.renameSync('/parentS-link/rename', '/parentS-link/renamed');
191
+ assert.equal(fs.readlinkSync('/parentS-link/symlink'), '/parentS-real/renamed');
192
+ fs.lutimesSync('/parentS-link/symlink', 1, 1);
193
+ assert.equal(fs.lstatSync('/parentS-real/symlink').mtimeMs, 1000);
194
+ assert.throws(() => fs.rmdirSync('/parentS-link/dir-link'), { code: 'ENOTDIR' });
195
+ fs.unlinkSync('/parentS-link/dir-link');
196
+ fs.rmdirSync('/parentS-link/rmdir');
197
+ assert.deepEqual(fs.readdirSync('/parentS-real').sort(), ['renamed', 'symlink']);
198
+ });
199
+ test('link follows symlinks in parent directories', config('links'), async () => {
200
+ await fs.promises.link('/parent-link/renamed', '/parent-link/hard');
201
+ assert.equal(await fs.promises.readFile('/parent-real/hard', 'utf8'), 'x');
202
+ fs.linkSync('/parentS-link/renamed', '/parentS-link/hard');
203
+ assert.equal(fs.readFileSync('/parentS-real/hard', 'utf8'), 'x');
204
+ });
205
+ test('xattr follows symlinks unless noFollow is set', config('xattr'), async () => {
206
+ await fs.xattr.set('/parent-link/renamed', 'user.parent', 'async');
207
+ assert.equal(await fs.xattr.get('/parent-real/renamed', 'user.parent', { encoding: 'utf8' }), 'async');
208
+ fs.xattr.setSync('/parentS-link/renamed', 'user.parent', 'sync');
209
+ assert.equal(fs.xattr.getSync('/parentS-real/renamed', 'user.parent', { encoding: 'utf8' }), 'sync');
210
+ await fs.xattr.set('/parent-link/symlink', 'user.link', 'on link', { noFollow: true });
211
+ assert.equal(await fs.xattr.get('/parent-real/symlink', 'user.link', { encoding: 'utf8', noFollow: true }), 'on link');
212
+ await assert.rejects(fs.xattr.get('/parent-real/renamed', 'user.link'), { code: 'ENODATA' });
213
+ assert.deepEqual(await fs.xattr.list('/parent-link/symlink'), ['user.parent']);
214
+ await fs.xattr.remove('/parent-link/renamed', 'user.parent');
215
+ assert.deepEqual(fs.xattr.listSync('/parent-real/renamed'), []);
216
+ });
217
+ test('cp preserves a symlink by default #304', async () => {
218
+ await fs.promises.mkdir('/cp-src');
219
+ await fs.promises.writeFile('/cp-src/real.txt', 'contents');
220
+ await fs.promises.symlink('real.txt', '/cp-src/link.txt');
221
+ await fs.promises.cp('/cp-src', '/cp-dst', { recursive: true });
222
+ const stats = await fs.promises.lstat('/cp-dst/link.txt');
223
+ assert(stats.isSymbolicLink());
224
+ // A relative target is resolved against the link's directory, so the copy points at the original file
225
+ assert.equal(await fs.promises.readlink('/cp-dst/link.txt'), '/cp-src/real.txt');
226
+ });
227
+ test('cp with verbatimSymlinks keeps the target unresolved', async () => {
228
+ await fs.promises.cp('/cp-src', '/cp-verbatim', { recursive: true, verbatimSymlinks: true });
229
+ assert((await fs.promises.lstat('/cp-verbatim/link.txt')).isSymbolicLink());
230
+ assert.equal(await fs.promises.readlink('/cp-verbatim/link.txt'), 'real.txt');
231
+ });
232
+ test('cp with dereference copies the symlink target contents #304', async () => {
233
+ await fs.promises.cp('/cp-src', '/cp-deref', { recursive: true, dereference: true });
234
+ const stats = await fs.promises.lstat('/cp-deref/link.txt');
235
+ assert(!stats.isSymbolicLink());
236
+ assert.equal(await fs.promises.readFile('/cp-deref/link.txt', 'utf8'), 'contents');
237
+ });
238
+ test('cpSync preserves a symlink #304', () => {
239
+ fs.writeFileSync('/cp-sync-target.txt', 'contents');
240
+ fs.symlinkSync('cp-sync-target.txt', '/cp-sync-link');
241
+ fs.cpSync('/cp-sync-link', '/cp-sync-link-copy');
242
+ const stats = fs.lstatSync('/cp-sync-link-copy');
243
+ assert(stats.isSymbolicLink());
244
+ assert.equal(fs.readlinkSync('/cp-sync-link-copy'), '/cp-sync-target.txt');
245
+ fs.cpSync('/cp-sync-link', '/cp-sync-link-verbatim', { verbatimSymlinks: true });
246
+ assert.equal(fs.readlinkSync('/cp-sync-link-verbatim'), 'cp-sync-target.txt');
247
+ });
248
+ });
@@ -0,0 +1 @@
1
+ export {};
@@ -0,0 +1,95 @@
1
+ var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
2
+ if (value !== null && value !== void 0) {
3
+ if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
4
+ var dispose, inner;
5
+ if (async) {
6
+ if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
7
+ dispose = value[Symbol.asyncDispose];
8
+ }
9
+ if (dispose === void 0) {
10
+ if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
11
+ dispose = value[Symbol.dispose];
12
+ if (async) inner = dispose;
13
+ }
14
+ if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
15
+ if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
16
+ env.stack.push({ value: value, dispose: dispose, async: async });
17
+ }
18
+ else if (async) {
19
+ env.stack.push({ async: true });
20
+ }
21
+ return value;
22
+ };
23
+ var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
24
+ return function (env) {
25
+ function fail(e) {
26
+ env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
27
+ env.hasError = true;
28
+ }
29
+ var r, s = 0;
30
+ function next() {
31
+ while (r = env.stack.pop()) {
32
+ try {
33
+ if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
34
+ if (r.dispose) {
35
+ var result = r.dispose.call(r.value);
36
+ if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
37
+ }
38
+ else s |= 1;
39
+ }
40
+ catch (e) {
41
+ fail(e);
42
+ }
43
+ }
44
+ if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
45
+ if (env.hasError) throw env.error;
46
+ }
47
+ return next();
48
+ };
49
+ })(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
50
+ var e = new Error(message);
51
+ return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
52
+ });
53
+ // SPDX-License-Identifier: LGPL-3.0-or-later
54
+ import assert from 'node:assert/strict';
55
+ import { suite, test } from 'node:test';
56
+ import { config, fs } from '../common.js';
57
+ suite('Opening files', () => {
58
+ const filename = 'a.js';
59
+ test('throw ENOENT when opening non-existent file', config('sync', 'async'), async () => {
60
+ assert.throws(() => fs.openSync('/path/to/file/that/does/not/exist', 'r'), { code: 'ENOENT' });
61
+ await assert.rejects(fs.promises.open('/path/to/file/that/does/not/exist', 'r'), { code: 'ENOENT' });
62
+ });
63
+ test('open file with mode "r"', config('async'), async () => {
64
+ const env_1 = { stack: [], error: void 0, hasError: false };
65
+ try {
66
+ const handle = __addDisposableResource(env_1, await fs.promises.open(filename, 'r'), true);
67
+ assert(handle.fd >= -Infinity);
68
+ }
69
+ catch (e_1) {
70
+ env_1.error = e_1;
71
+ env_1.hasError = true;
72
+ }
73
+ finally {
74
+ const result_1 = __disposeResources(env_1);
75
+ if (result_1)
76
+ await result_1;
77
+ }
78
+ });
79
+ test('open file with mode "rs"', config('async'), async () => {
80
+ const env_2 = { stack: [], error: void 0, hasError: false };
81
+ try {
82
+ const handle = __addDisposableResource(env_2, await fs.promises.open(filename, 'rs'), true);
83
+ assert(handle.fd >= -Infinity);
84
+ }
85
+ catch (e_2) {
86
+ env_2.error = e_2;
87
+ env_2.hasError = true;
88
+ }
89
+ finally {
90
+ const result_2 = __disposeResources(env_2);
91
+ if (result_2)
92
+ await result_2;
93
+ }
94
+ });
95
+ });
@@ -0,0 +1 @@
1
+ export {};