Debian Codegraph @

jridgewell-resolve-uri/test/generate-tests.js

raw
1 const { readFileSync, mkdirSync, writeFileSync } = require('fs');
2 const { posix, win32 } = require('path');
3 const prettier = require('prettier');
4 const prettierConfig = require('./prettier.config.js');
5 const resolve = require('@jridgewell/resolve-uri');
6
7 let buffer;
8 let cwd = __dirname;
9
10 function getOrigin(url) {
11 let index = 0;
12 if (!url) return '';
13 if (url.startsWith('C:')) return '';
14 if (url.startsWith('file://') && !url.startsWith('file:///')) {
15 index = url.indexOf('/', 'file://'.length);
16 } else if (url.startsWith('file:')) {
17 return 'file://';
18 } else if (url.startsWith('https://')) {
19 index = url.indexOf('/', 'https://'.length);
20 } else if (url.startsWith('//')) {
21 index = url.indexOf('/', '//'.length);
22 } else {
23 return '';
24 }
25 if (index === -1) return url;
26 return url.slice(0, index);
27 }
28
29 function getProtocol(url) {
30 if (!url) return '';
31 if (url.startsWith('file:')) return 'file:';
32 if (url.startsWith('https://')) return 'https:';
33 return '';
34 }
35
36 function getPath(base, input) {
37 const origin = getOrigin(input);
38 if (origin) {
39 if (origin.startsWith('//')) return new URL('https:' + input).pathname;
40 return new URL(input).pathname;
41 }
42
43 if (!base) {
44 if (input.startsWith('C:')) {
45 return toWindows(resolve('file:///' + toPosix(input)).slice('file:///'.length));
46 }
47 if (input.includes('\\')) {
48 return toWindows(resolve(toPosix(input)));
49 }
50 return resolve(input);
51 }
52
53 const bOrigin = getOrigin(base);
54 if (bOrigin) {
55 if (input.startsWith('C:')) {
56 if (bOrigin === 'file://') {
57 input = 'file:///' + input;
58 } else {
59 input = input.slice('C:'.length);
60 }
61 }
62 input = input.replace(/\\\\/g, '/');
63 if (bOrigin.startsWith('//')) return new URL(input, 'https:' + base).pathname;
64 return new URL(input, base).pathname;
65 }
66
67 if (input.startsWith('C:')) {
68 return toWindows(new URL('file:///' + toPosix(input)).href.slice('file:///'.length));
69 }
70
71 if (base.startsWith('C:')) {
72 return toWindows(new URL(toPosix(input), 'file:///' + toPosix(base)).href.slice('file:///'.length));
73 }
74
75 if (!base.includes('\\') && !input.includes('\\')) {
76 return resolve(input, base);
77 }
78 base = toPosix(base);
79 input = toPosix(input);
80 return toWindows(resolve(input, base));
81 }
82
83 function getQuery(input) {
84 if (input === undefined) return '';
85 const q = /\?[^#]*/.exec(input);
86 return q ? q[0] : '';
87 }
88
89 function getHash(input) {
90 if (input === undefined) return '';
91 const h = /#.*/.exec(input);
92 return h ? h[0] : '';
93 }
94
95 function toPosix(input) {
96 return input.replace(/\\{1,2}/g, '/');
97 }
98
99 function toWindows(input) {
100 return input.replace(/\//g, '\\\\');
101 }
102
103 function normalizeBasePath(base, input) {
104 if (!base && !input) return '';
105 if (base === undefined) return '';
106 const strip = base.replace(/[?#].*/, '');
107
108 if (strip.startsWith('file:')) return new URL(strip).href;
109 if (strip.startsWith('https://')) return new URL(strip).href;
110 if (strip.startsWith('//')) return new URL('https:' + strip).href.slice('https:'.length);
111
112 let b = strip.includes('\\') ? win32.normalize(strip).replace(/\\/g, '/') : posix.normalize(strip);
113 if (b === './' || b === '.') {
114 if (/^[?#]/.test(input || base)) return '';
115 return '.';
116 }
117 if (b.endsWith('../')) b = b.slice(0, -1);
118 if (!b.startsWith('.') && strip.startsWith('.')) b = './' + b;
119 return strip.includes('\\') ? b.replace(/\//g, '\\\\') : b;
120 }
121
122 function suite(base) {
123 const init = JSON.stringify(base);
124 buffer.push(`
125 describe(\`base = ${init}\`, () => {
126 describe('with absolute input', () => {
127 it('returns input', () => {
128 const base = ${init};
129 const input = 'https://absolute.com/main.js.map';
130 const resolved = resolve(input, base);
131 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
132 });
133
134 it('returns input with query', () => {
135 const base = ${init};
136 const input = 'https://absolute.com/main.js.map?input';
137 const resolved = resolve(input, base);
138 assert.strictEqual(resolved, 'https://absolute.com/main.js.map?input');
139 });
140
141 it('normalizes input path', () => {
142 const base = ${init};
143 const input = 'https://absolute.com/foo/./bar/../main.js.map';
144 const resolved = resolve(input, base);
145 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map');
146 });
147
148 it('normalizes input path with query', () => {
149 const base = ${init};
150 const input = 'https://absolute.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
151 const resolved = resolve(input, base);
152 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map?input!webpack://foo/./bar');
153 });
154
155 it('normalizes pathless input', () => {
156 const base = ${init};
157 const input = 'https://absolute.com';
158 const resolved = resolve(input, base);
159 assert.strictEqual(resolved, 'https://absolute.com/');
160 });
161
162 it('normalizes pathless input with query', () => {
163 const base = ${init};
164 const input = 'https://absolute.com?input';
165 const resolved = resolve(input, base);
166 assert.strictEqual(resolved, 'https://absolute.com/?input');
167 });
168
169 it('normalizes current directory', () => {
170 const base = ${init};
171 const input = 'https://absolute.com/./main.js.map';
172 const resolved = resolve(input, base);
173 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
174 });
175
176 it('normalizes too many parent accessors', () => {
177 const base = ${init};
178 const input = 'https://absolute.com/../../../main.js.map';
179 const resolved = resolve(input, base);
180 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
181 });
182
183 it('normalizes too many parent accessors, late', () => {
184 const base = ${init};
185 const input = 'https://absolute.com/foo/../../../main.js.map';
186 const resolved = resolve(input, base);
187 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
188 });
189
190 it('normalizes file protocol 1', () => {
191 const base = ${init};
192 const input = 'file:///root/main.js.map';
193 const resolved = resolve(input, base);
194 assert.strictEqual(resolved, 'file:///root/main.js.map');
195 });
196
197 it('normalizes file protocol 2', () => {
198 const base = ${init};
199 const input = 'file://root/main.js.map';
200 const resolved = resolve(input, base);
201 assert.strictEqual(resolved, 'file://root/main.js.map');
202 });
203
204 it('normalizes file protocol 2.5', () => {
205 const base = ${init};
206 const input = 'file://root';
207 const resolved = resolve(input, base);
208 assert.strictEqual(resolved, 'file://root/');
209 });
210
211 it('normalizes file protocol 3', () => {
212 const base = ${init};
213 const input = 'file:/root/main.js.map';
214 const resolved = resolve(input, base);
215 assert.strictEqual(resolved, 'file:///root/main.js.map');
216 });
217
218 it('normalizes file protocol 4', () => {
219 const base = ${init};
220 const input = 'file:root/main.js.map';
221 const resolved = resolve(input, base);
222 assert.strictEqual(resolved, 'file:///root/main.js.map');
223 });
224
225 it('normalizes file protocol 1 with query', () => {
226 const base = ${init};
227 const input = 'file:///root/main.js.map?input';
228 const resolved = resolve(input, base);
229 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
230 });
231
232 it('normalizes file protocol 2 with query', () => {
233 const base = ${init};
234 const input = 'file://root/main.js.map?input';
235 const resolved = resolve(input, base);
236 assert.strictEqual(resolved, 'file://root/main.js.map?input');
237 });
238
239 it('normalizes file protocol 2.5 with query', () => {
240 const base = ${init};
241 const input = 'file://root?input';
242 const resolved = resolve(input, base);
243 assert.strictEqual(resolved, 'file://root/?input');
244 });
245
246 it('normalizes file protocol 3 with query', () => {
247 const base = ${init};
248 const input = 'file:/root/main.js.map?input';
249 const resolved = resolve(input, base);
250 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
251 });
252
253 it('normalizes file protocol 4 with query', () => {
254 const base = ${init};
255 const input = 'file:root/main.js.map?input';
256 const resolved = resolve(input, base);
257 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
258 });
259 });
260
261 describe('with protocol relative input', () => {
262 it('resolves relative to the base protocol', () => {
263 const base = ${init};
264 const input = '//protocol-relative.com/main.js.map';
265 const resolved = resolve(input, base);
266 assert.strictEqual(resolved, '${getProtocol(base)}//protocol-relative.com/main.js.map');
267 });
268
269 it('resolves relative to the base protocol with query', () => {
270 const base = ${init};
271 const input = '//protocol-relative.com/main.js.map?input';
272 const resolved = resolve(input, base);
273 assert.strictEqual(resolved, '${getProtocol(base)}//protocol-relative.com/main.js.map?input');
274 });
275
276 it('normalizes input path', () => {
277 const base = ${init};
278 const input = '//protocol-relative.com/foo/./bar/../main.js.map';
279 const resolved = resolve(input, base);
280 assert.strictEqual(resolved, '${getProtocol(base)}//protocol-relative.com/foo/main.js.map');
281 });
282
283 it('normalizes input path with query', () => {
284 const base = ${init};
285 const input = '//protocol-relative.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
286 const resolved = resolve(input, base);
287 assert.strictEqual(resolved, '${getProtocol(base)}//protocol-relative.com/foo/main.js.map?input!webpack://foo/./bar');
288 });
289
290 it('normalizes pathless input', () => {
291 const base = ${init};
292 const input = '//protocol-relative.com';
293 const resolved = resolve(input, base);
294 assert.strictEqual(resolved, '${getProtocol(base)}//protocol-relative.com/');
295 });
296
297 it('normalizes pathless input with query', () => {
298 const base = ${init};
299 const input = '//protocol-relative.com?input';
300 const resolved = resolve(input, base);
301 assert.strictEqual(resolved, '${getProtocol(base)}//protocol-relative.com/?input');
302 });
303
304 it('normalizes current directory', () => {
305 const base = ${init};
306 const input = '//protocol-relative.com/./main.js.map';
307 const resolved = resolve(input, base);
308 assert.strictEqual(resolved, '${getProtocol(base)}//protocol-relative.com/main.js.map');
309 });
310
311 it('normalizes too many parent accessors', () => {
312 const base = ${init};
313 const input = '//protocol-relative.com/../main.js.map';
314 const resolved = resolve(input, base);
315 assert.strictEqual(resolved, '${getProtocol(base)}//protocol-relative.com/main.js.map');
316 });
317
318 it('normalizes too many parent accessors, late', () => {
319 const base = ${init};
320 const input = '//protocol-relative.com/foo/../../main.js.map';
321 const resolved = resolve(input, base);
322 assert.strictEqual(resolved, '${getProtocol(base)}//protocol-relative.com/main.js.map');
323 });
324 });
325
326 describe('with absolute path input', () => {
327 it('remains absolute path', () => {
328 const base = ${init};
329 const input = '/assets/main.js.map';
330 const resolved = resolve(input, base);
331 assert.strictEqual(resolved, '${getOrigin(base)}${getPath(base, '/assets/main.js.map')}');
332 });
333
334 it('remains absolute path with query', () => {
335 const base = ${init};
336 const input = '/assets/main.js.map?input';
337 const resolved = resolve(input, base);
338 assert.strictEqual(resolved, '${getOrigin(base)}${getPath(base, '/assets/main.js.map')}?input');
339 });
340
341 it('trims to root', () => {
342 const base = ${init};
343 const input = '/';
344 const resolved = resolve(input, base);
345 assert.strictEqual(resolved, '${getOrigin(base)}${getPath(base, '/')}');
346 });
347
348 it('normalizes input path', () => {
349 const base = ${init};
350 const input = '/foo/./bar/../main.js.map';
351 const resolved = resolve(input, base);
352 assert.strictEqual(resolved, '${getOrigin(base)}${getPath(base, '/foo/main.js.map')}');
353 });
354
355 it('normalizes current directory', () => {
356 const base = ${init};
357 const input = '/./main.js.map';
358 const resolved = resolve(input, base);
359 assert.strictEqual(resolved, '${getOrigin(base)}${getPath(base, '/main.js.map')}');
360 });
361
362 it('normalizes too many parent accessors', () => {
363 const base = ${init};
364 const input = '/../../../main.js.map';
365 const resolved = resolve(input, base);
366 assert.strictEqual(resolved, '${getOrigin(base)}${getPath(base, '/main.js.map')}');
367 });
368
369 it('normalizes too many parent accessors with query 1', () => {
370 const base = ${init};
371 const input = '/../../../?input';
372 const resolved = resolve(input, base);
373 assert.strictEqual(resolved, '${getOrigin(base)}${getPath(base, '/')}?input');
374 });
375
376 it('normalizes too many parent accessors with query 2', () => {
377 const base = ${init};
378 const input = '/../../..?input';
379 const resolved = resolve(input, base);
380 assert.strictEqual(resolved, '${getOrigin(base)}${getPath(base, '/')}?input');
381 });
382
383 it('normalizes too many parent accessors, late', () => {
384 const base = ${init};
385 const input = '/foo/../../../main.js.map';
386 const resolved = resolve(input, base);
387 assert.strictEqual(resolved, '${getOrigin(base)}${getPath(base, '/main.js.map')}');
388 });
389 });
390
391 describe('with leading dot relative input', () => {
392 it('resolves relative to current directory', () => {
393 const base = ${init};
394 const input = './bar/main.js.map';
395 const resolved = resolve(input, base);
396 assert.strictEqual(resolved, '${getOrigin(base)}${getPath(base, './bar/main.js.map')}');
397 });
398
399 it('resolves relative to current directory with query', () => {
400 const base = ${init};
401 const input = './bar/main.js.map?input';
402 const resolved = resolve(input, base);
403 assert.strictEqual(resolved, '${getOrigin(base)}${getPath(base, './bar/main.js.map')}?input');
404 });
405
406 it('resolves relative to parent directory', () => {
407 const base = ${init};
408 const input = '../bar/main.js.map';
409 const resolved = resolve(input, base);
410 assert.strictEqual(resolved, '${getOrigin(base)}${getPath(base, '../bar/main.js.map')}');
411 });
412
413 it('resolves relative to parent directory with query', () => {
414 const base = ${init};
415 const input = '../bar/main.js.map?input';
416 const resolved = resolve(input, base);
417 assert.strictEqual(resolved, '${getOrigin(base)}${getPath(base, '../bar/main.js.map')}?input');
418 });
419
420 it('resolves relative to parent multiple directory', () => {
421 const base = ${init};
422 const input = '../../../bar/main.js.map';
423 const resolved = resolve(input, base);
424 assert.strictEqual(resolved, '${getOrigin(base)}${getPath(base, '../../../bar/main.js.map')}');
425 });
426
427 it('resolves relative to parent multiple directory with query 1', () => {
428 const base = ${init};
429 const input = '../../../?input';
430 const resolved = resolve(input, base);
431 assert.strictEqual(resolved, '${getOrigin(base)}${getPath(base, '../../../')}?input');
432 });
433
434 it('resolves relative to parent multiple directory with query 2', () => {
435 const base = ${init};
436 const input = '../../..?input';
437 const resolved = resolve(input, base);
438 assert.strictEqual(resolved, '${getOrigin(base)}${getPath(base, '../../..')}?input');
439 });
440
441 it('normalizes input path', () => {
442 const base = ${init};
443 const input = './foo/./bar/../main.js.map';
444 const resolved = resolve(input, base);
445 assert.strictEqual(resolved, '${getOrigin(base)}${getPath(base, './foo/./bar/../main.js.map')}');
446 });
447 });
448
449 describe('with relative path input', () => {
450 it('resolves relative to current directory', () => {
451 const base = ${init};
452 const input = 'bar/main.js.map';
453 const resolved = resolve(input, base);
454 assert.strictEqual(resolved, '${getOrigin(base)}${getPath(base, 'bar/main.js.map')}');
455 });
456
457 it('resolves relative to current directory with query', () => {
458 const base = ${init};
459 const input = 'bar/main.js.map?input';
460 const resolved = resolve(input, base);
461 assert.strictEqual(resolved, '${getOrigin(base)}${getPath(base, 'bar/main.js.map')}?input');
462 });
463
464 it('resolves relative to parent multiple directory, later', () => {
465 const base = ${init};
466 const input = 'foo/../../../bar/main.js.map';
467 const resolved = resolve(input, base);
468 assert.strictEqual(resolved, '${getOrigin(base)}${getPath(base, 'foo/../../../bar/main.js.map')}');
469 });
470
471 it('normalizes input path', () => {
472 const base = ${init};
473 const input = 'foo/./bar/../main.js.map';
474 const resolved = resolve(input, base);
475 assert.strictEqual(resolved, '${getOrigin(base)}${getPath(base, 'foo/./bar/../main.js.map')}');
476 });
477
478 it('resolves node_module scope as path', () => {
479 const base = ${init};
480 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
481 const resolved = resolve(input, base);
482 assert.strictEqual(resolved, '${getOrigin(base)}${getPath(base, 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js')}');
483 });
484
485 it('resolves package scope as path', () => {
486 const base = ${init};
487 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
488 const resolved = resolve(input, base);
489 assert.strictEqual(resolved, '${getOrigin(base)}${getPath(base, '@babel/runtime/helpers/esm/arrayLikeToArray.js')}');
490 });
491 });
492
493 describe('with query input', () => {
494 it('resolves relative to path', () => {
495 const base = ${init};
496 const input = '?input';
497 const resolved = resolve(input, base);
498 assert.strictEqual(resolved, '${normalizeBasePath(base, '?input')}?input');
499 });
500 });
501
502 describe('with hash input', () => {
503 it('resolves relative to path', () => {
504 const base = ${init};
505 const input = '#input';
506 const resolved = resolve(input, base);
507 assert.strictEqual(resolved, '${normalizeBasePath(base, '#input')}${getQuery(base)}#input');
508 });
509 });
510
511 describe('empty input', () => {
512 it('normalizes base', () => {
513 const base = ${init};
514 const input = '';
515 const resolved = resolve(input, base);
516 assert.strictEqual(resolved, '${normalizeBasePath(base, '')}${getQuery(base)}${getHash(base)}');
517 });
518 });
519 });
520 `);
521 }
522
523 function dir(name, fn) {
524 const old = cwd;
525 cwd += '/' + name.replace(/ /g, '-');
526 try {
527 mkdirSync(cwd);
528 } catch {
529 /**/
530 }
531 fn();
532 cwd = old;
533 }
534
535 function describe(name, fn) {
536 const dir = posix.relative(cwd, `${__dirname}/..`);
537 buffer = [`const resolve = require('${dir}');`, `const assert = require('assert');\n`, `describe('${name}', () => {`];
538
539 fn();
540
541 buffer.push(`});`);
542
543 writeFileSync(
544 `${cwd}/${name.replace(/ /g, '-')}.test.js`,
545 prettier.format(buffer.join('\n'), {
546 ...prettierConfig,
547 parser: 'babel',
548 })
549 );
550 }
551
552 dir('resolve', () => {
553 describe('without base', () => {
554 suite(undefined);
555 suite('');
556 });
557
558 describe('with absolute base', () => {
559 suite('https://foo.com');
560 suite('https://foo.com/');
561 suite('https://foo.com/file');
562 suite('https://foo.com/dir/');
563 suite('https://foo.com/dir/file');
564 suite('https://foo.com/..');
565 suite('https://foo.com/../');
566 suite('https://foo.com/dir/..');
567 suite('https://foo.com/file?baseQuery');
568 suite('https://foo.com/file?baseQuery#baseHash');
569 suite('https://foo.com/file#baseHash');
570
571 suite('https://g');
572 suite('https://g/');
573 suite('https://g/file');
574 suite('https://g/dir/');
575 suite('https://g/dir/file');
576 suite('https://g/..');
577 suite('https://g/../');
578 suite('https://g/dir/..');
579 suite('https://g/file?baseQuery');
580 suite('https://g/file?baseQuery#baseHash');
581 suite('https://g/file#baseHash');
582
583 suite('file:///foo');
584 suite('file:///foo/');
585 suite('file:///foo/file');
586 suite('file:///foo/dir/');
587 suite('file:///foo/dir/file');
588 suite('file:///foo/..');
589 suite('file:///foo/../');
590 suite('file:///foo/dir/..');
591 suite('file:///foo/file?baseQuery');
592 suite('file:///foo/file?baseQuery#baseHash');
593 suite('file:///foo/file#baseHash');
594
595 suite('file://foo');
596 suite('file://foo/');
597 suite('file://foo/file');
598 suite('file://foo/dir/');
599 suite('file://foo/dir/file');
600 suite('file://foo/..');
601 suite('file://foo/../');
602 suite('file://foo/dir/..');
603 suite('file://foo/file?baseQuery');
604 suite('file://foo/file?baseQuery#baseHash');
605 suite('file://foo/file#baseHash');
606
607 suite('file:/foo');
608 suite('file:/foo/');
609 suite('file:/foo/file');
610 suite('file:/foo/dir/');
611 suite('file:/foo/dir/file');
612 suite('file:/foo/..');
613 suite('file:/foo/../');
614 suite('file:/foo/dir/..');
615 suite('file:/foo/file?baseQuery');
616 suite('file:/foo/file?baseQuery#baseHash');
617 suite('file:/foo/file#baseHash');
618
619 suite('file:foo');
620 suite('file:foo/');
621 suite('file:foo/file');
622 suite('file:foo/dir/');
623 suite('file:foo/dir/file');
624 suite('file:foo/..');
625 suite('file:foo/../');
626 suite('file:foo/dir/..');
627 suite('file:foo/file?baseQuery');
628 suite('file:foo/file?baseQuery#baseHash');
629 suite('file:foo/file#baseHash');
630 suite('file:foo/file?baseQuery');
631 suite('file:foo/file?baseQuery#baseHash');
632 suite('file:foo/file#baseHash');
633 suite('file:file?baseQuery');
634 suite('file:file?baseQuery#baseHash');
635 suite('file:file#baseHash');
636 suite('file:?baseQuery');
637 suite('file:?baseQuery#baseHash');
638 suite('file:#baseHash');
639 });
640
641 describe('with protocol relative base', () => {
642 suite('//foo.com');
643 suite('//foo.com/');
644 suite('//foo.com/file');
645 suite('//foo.com/dir/');
646 suite('//foo.com/dir/file');
647 suite('//foo.com/..');
648 suite('//foo.com/../');
649 suite('//foo.com/dir/..');
650 suite('//foo.com/file?baseQuery');
651 suite('//foo.com/file?baseQuery#baseHash');
652 suite('//foo.com/file#baseHash');
653
654 suite('//g');
655 suite('//g/');
656 suite('//g/file');
657 suite('//g/dir/');
658 suite('//g/dir/file');
659 suite('//g/..');
660 suite('//g/../');
661 suite('//g/dir/..');
662 suite('//g/file?baseQuery');
663 suite('//g/file?baseQuery#baseHash');
664 suite('//g/file#baseHash');
665 });
666
667 describe('with absolute path base', () => {
668 suite('/');
669 suite('/root');
670 suite('/root/');
671 suite('/root/file');
672 suite('/root/dir/');
673 suite('/..');
674 suite('/../');
675 suite('/root/..');
676 suite('/root/../');
677 suite('/root?baseQuery');
678 suite('/root?baseQuery#baseHash');
679 suite('/root#baseHash');
680 });
681
682 describe('with relative path base', () => {
683 suite('file');
684 suite('dir/');
685 suite('dir/file');
686 suite('deep/dir/');
687 suite('./file');
688 suite('./dir/');
689 suite('./deep/file');
690 suite('./deep/dir/');
691 suite('../file');
692 suite('../dir/');
693 suite('../deep/file');
694 suite('../deep/dir/');
695 suite('..');
696 suite('../');
697 suite('dir/..');
698 suite('deep/../');
699 suite('./..');
700 suite('./../');
701 suite('./deep/..');
702 suite('./deep/../');
703 suite('../..');
704 suite('../../');
705 suite('../deep/..');
706 suite('../deep/../');
707 suite('file?baseQuery');
708 suite('file?baseQuery#baseHash');
709 suite('file#baseHash');
710 });
711
712 describe('with query base', () => {
713 suite('?baseQuery');
714 suite('?baseQuery#baseHash');
715 });
716
717 describe('with hash base', () => {
718 suite('#baseHash');
719 });
720
721 describe('readme', () => {
722 const readme = readFileSync(`${__dirname}/../README.md`, 'utf8');
723 const tables = extractTables(readme);
724
725 function extractTables(markdown) {
726 const regex = /(\|.*)\n\|\s*---.*\n((\|.*\n)*)/g;
727 let tables = [];
728 let match;
729 while ((match = regex.exec(markdown))) {
730 const head = match[1].split('\n')[0];
731 const headers = head
732 .split('|')
733 .map((s) => s.trim())
734 .slice(1, -1);
735
736 const table = [];
737 tables.push(table);
738 const body = match[2].split('\n').slice(0, -1);
739 for (const row of body) {
740 const data = row
741 .split('|')
742 .map((s) => s.trim())
743 .slice(1, -1);
744
745 const obj = {};
746 data.forEach((d, i) => (obj[headers[i]] = d));
747 table.push(obj);
748 }
749 }
750 return tables;
751 }
752
753 function escape(str) {
754 return str.replace(/\\/g, '\\\\');
755 }
756
757 buffer.push(`const _any_ = 'https://foo/';`);
758 buffer.push(`const _rest_ = 'foo';`);
759
760 for (let i = 0; i < tables.length; i++) {
761 const table = tables[i];
762 buffer.push(`describe('table ${i}', () => {`);
763 for (let j = 0; j < table.length; j++) {
764 const row = table[j];
765 buffer.push(`
766 it('input = ${escape(row.Input)}, base = ${escape(row.Base)}', () => {
767 const input = ${escape(row.Input)};
768 const base = ${escape(row.Base)};
769 const expected = ${escape(row.Resolution)};
770
771 assert.strictEqual(resolve(input, base), expected);
772 });
773 `);
774 }
775 buffer.push('})');
776 }
777 });
778 });