Port dart:io Path tests to package:path.

pkg/path/test/posix_test.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library path.test.posix_test;
 
 import 'package:unittest/unittest.dart';
 import 'package:path/path.dart' as path;
 
 main() {
@@ skipping 147 matching lines @@
       expect(builder.join('', ''), '');
       expect(builder.join('', 'a'), 'a');
       expect(builder.join('a', '', 'b', '', '', '', 'c'), 'a/b/c');
       expect(builder.join('a', 'b', ''), 'a/b');
     });
 
     test('disallows intermediate nulls', () {
       expect(() => builder.join('a', null, 'b'), throwsArgumentError);
       expect(() => builder.join(null, 'a'), throwsArgumentError);
     });
+
+    test('misc join tests ported from Path class', () {
+      expect(builder.join('a/', 'b/c/'), 'a/b/c/');

[Bob Nystrom, 2013/07/18 20:45:08]

How about making a "preserves trailing separators" group that includes this and
line 176?

[Bill Hesse, 2013/07/22 11:35:22]

Done.

+      expect(builder.join('a/b/./c/..//', 'd/.././..//e/f//'),
+             'a/b/./c/..//d/.././..//e/f//');
+      expect(builder.join('a/b', 'c/../../../..'), 'a/b/c/../../../..');

[Bob Nystrom, 2013/07/18 20:45:08]

This is a good test. Might be nice to have something similar for "/./". How
about a group for "preserves '..' and '.'"?

[Bill Hesse, 2013/07/22 11:35:22]

Done.

+      expect(builder.join('', ''), '');

[Bob Nystrom, 2013/07/18 20:45:08]

This is covered by line 158.

[Bill Hesse, 2013/07/22 11:35:22]

Done.

+      expect(builder.join('a/b/c/', '/d'), '/d');

[Bob Nystrom, 2013/07/18 20:45:08]

This is covered by line 140.

[Bill Hesse, 2013/07/22 11:35:22]

Done.

+      expect(builder.join('a', 'b${builder.separator}'), 'a/b/');

[Bob Nystrom, 2013/07/18 20:45:08]

You can just do "/" instead of ${builder.separator} here since this test is
specifically for POSIX paths.

[Bill Hesse, 2013/07/22 11:35:22]

We already have a test for literal / at the end.
Since this is the idiom that is needed for platform-independent creation of a
trailing slash, we should test it.

[Bob Nystrom, 2013/07/22 20:53:11]

We already test what builder.separator returns, so I don't think this adds much
value. Since builder is a explicitly a POSIX builder, this test is exactly
identical to using an explicit "/". If, for some reason, separator were to ever
return something different, the separator test would already fail.

[Bill Hesse, 2013/07/23 16:07:00]

Removed - I'm used to writing VM tests, where more tests, testing the same thing
but written differently, are useful to find errors in the compiler and
optimizer.  If we assume the VM is working correctly, then this test is not
needed.

+    });
   });
 
   group('joinAll', () {
     test('allows more than eight parts', () {
       expect(builder.joinAll(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']),
           'a/b/c/d/e/f/g/h/i');
     });
 
     test('does not add separator if a part ends in one', () {
       expect(builder.joinAll(['a/', 'b', 'c/', 'd']), 'a/b/c/d');
@@ skipping 27 matching lines @@
     });
 
     test('includes the root for absolute paths', () {
       expect(builder.split('/foo/bar/baz'), equals(['/', 'foo', 'bar', 'baz']));
       expect(builder.split('/'), equals(['/']));
     });
   });
 
   group('normalize', () {
     test('simple cases', () {
-      expect(builder.normalize(''), '');
+      expect(builder.normalize(''), '.');
       expect(builder.normalize('.'), '.');
       expect(builder.normalize('..'), '..');
       expect(builder.normalize('a'), 'a');
       expect(builder.normalize('/'), '/');
       expect(builder.normalize(r'\'), r'\');
+      expect(builder.normalize('C:/'), 'C:');
+      expect(builder.normalize(r'C:\'), r'C:\');
+      expect(builder.normalize(r'\\'), r'\\');

[Bob Nystrom, 2013/07/18 20:45:08]

Yay tests!

     });
 
     test('collapses redundant separators', () {
       expect(builder.normalize(r'a/b/c'), r'a/b/c');
       expect(builder.normalize(r'a//b///c////d'), r'a/b/c/d');
     });
 
     test('does not collapse separators for other platform', () {
       expect(builder.normalize(r'a\\b\\\c'), r'a\\b\\\c');
     });
@@ skipping 11 matching lines @@
     });
 
     test('eliminates ".." parts', () {
       expect(builder.normalize('..'), '..');
       expect(builder.normalize('../'), '..');
       expect(builder.normalize('../../..'), '../../..');
       expect(builder.normalize('../../../'), '../../..');
       expect(builder.normalize('/..'), '/');
       expect(builder.normalize('/../../..'), '/');
       expect(builder.normalize('/../../../a'), '/a');
+      expect(builder.normalize('c:/..'), '.');
+      expect(builder.normalize('A:/../../..'), '../..');

[Bob Nystrom, 2013/07/18 20:45:08]

Nice.

       expect(builder.normalize('a/..'), '.');
       expect(builder.normalize('a/b/..'), 'a');
       expect(builder.normalize('a/../b'), 'b');
       expect(builder.normalize('a/./../b'), 'b');
       expect(builder.normalize('a/b/c/../../d/e/..'), 'a/d');
       expect(builder.normalize('a/b/../../../../c'), '../../c');
+      expect(builder.normalize(r'z/a/b/../../..\../c'), r'z/..\../c');
+      expect(builder.normalize(r'a/b\c/../d'), 'a/d');
     });
 
     test('does not walk before root on absolute paths', () {
       expect(builder.normalize('..'), '..');
       expect(builder.normalize('../'), '..');
+      expect(builder.normalize('http://dartlang.org/..'), 'http:');
+      expect(builder.normalize('http://dartlang.org/../../a'), 'a');
+      expect(builder.normalize('file:///..'), '.');
+      expect(builder.normalize('file:///../../a'), '../a');
       expect(builder.normalize('/..'), '/');
       expect(builder.normalize('a/..'), '.');
+      expect(builder.normalize('../a'), '../a');
+      expect(builder.normalize('/../a'), '/a');
+      expect(builder.normalize('c:/../a'), 'a');
+      expect(builder.normalize('/../a'), '/a');
       expect(builder.normalize('a/b/..'), 'a');
+      expect(builder.normalize('../a/b/..'), '../a');
       expect(builder.normalize('a/../b'), 'b');
       expect(builder.normalize('a/./../b'), 'b');
       expect(builder.normalize('a/b/c/../../d/e/..'), 'a/d');
       expect(builder.normalize('a/b/../../../../c'), '../../c');
+      expect(builder.normalize('a/b/c/../../..d/./.e/f././'), 'a/..d/.e/f.');
     });
 
     test('removes trailing separators', () {
       expect(builder.normalize('./'), '.');
       expect(builder.normalize('.//'), '.');
       expect(builder.normalize('a/'), 'a');
       expect(builder.normalize('a/b/'), 'a/b');
+      expect(builder.normalize(r'a/b\'), r'a/b\');
       expect(builder.normalize('a/b///'), 'a/b');
     });
   });
 
   group('relative', () {
     group('from absolute root', () {
       test('given absolute path in root', () {
         expect(builder.relative('/'), '../..');
         expect(builder.relative('/root'), '..');
         expect(builder.relative('/root/path'), '.');
@@ skipping 135 matching lines @@
   });
 
   test('toUri', () {
     expect(builder.toUri('/path/to/foo'), Uri.parse('file:///path/to/foo'));
     expect(builder.toUri('/path/to/foo/'), Uri.parse('file:///path/to/foo/'));
     expect(builder.toUri('/'), Uri.parse('file:///'));
     expect(builder.toUri('foo/bar'), Uri.parse('foo/bar'));
     expect(builder.toUri('/path/to/foo#bar'),
         Uri.parse('file:///path/to/foo%23bar'));
   });
+
+  void testGetters(String p, List components, String properties) {

[Bob Nystrom, 2013/07/18 20:45:08]

Do you think it's worth adding these? I find them a bit hard to read and I feel
like the other tests for those functions probably cover this.

[Bill Hesse, 2013/07/22 11:35:22]

Removed.  Some tests, like for '.', '..', and 'gule fisk.a b', added elsewhere.

+    final int DIRNAME = 0;
+    final int FILENAME = 1;
+    final int FILENAME_NO_EXTENSION = 2;
+    final int WITHOUT_EXTENSION = 3;
+    final int EXTENSION = 4;
+    final int ROOT_PREFIX = 5;
+    expect(components[DIRNAME], builder.dirname(p));
+    expect(components[FILENAME], builder.basename(p));
+    expect(components[FILENAME_NO_EXTENSION],
+           builder.basenameWithoutExtension(p));
+    expect(components[WITHOUT_EXTENSION],
+           builder.withoutExtension(p));
+    expect(components[EXTENSION], builder.extension(p));
+    expect(builder.isAbsolute(p), properties.contains('absolute'));
+    expect(components[ROOT_PREFIX], builder.rootPrefix(p));
+    if (properties.contains('normalized')) {
+      expect(p, builder.normalize(p));
+    } else {
+      expect(p, isNot(equals(builder.normalize(p))));
+    }
+  }
+
+  test('getters', () {
+    testGetters("/foo/bar/fisk.hest",
+                ['/foo/bar', 'fisk.hest', 'fisk', '/foo/bar/fisk',
+                 '.hest', '/'],
+                'absolute normalized');
+    testGetters('',
+                ['.', '', '', '', '', ''],
+                '');  // Issue with normalize('') == '.' change.
+    // This corner case leaves a trailing slash for the root.
+    testGetters('/',
+                ['/', '/', '/', '/', '', '/'],
+                'absolute normalized');
+    testGetters('.',
+                ['.', '.', '.', '.', '', ''],
+                'normalized');
+    testGetters('..',
+                ['.', '..', '..', '..', '', ''],
+                'normalized');
+    testGetters('/ab,;- .c.d',
+                ['/', 'ab,;- .c.d', 'ab,;- .c', '/ab,;- .c', '.d', '/'],
+                'absolute normalized');
+
+    // Normalized and non-normalized cases
+    testGetters("a/b/../c/./d/e",
+                ['a/b/../c/./d', 'e', 'e', 'a/b/../c/./d/e', '', ''],
+                '');
+    testGetters("a./b../..c/.d/e",
+                ['a./b../..c/.d', 'e', 'e', 'a./b../..c/.d/e', '', ''],
+                'normalized');
+    testGetters("a/b/",
+                ['a', 'b', 'b', 'a/b/', '', ''],
+                '');
+    // .. is allowed at the beginning of a normalized relative path.
+    testGetters("../../a/b/c/d",
+                ['../../a/b/c', 'd', 'd', '../../a/b/c/d', '', ''],
+                'normalized');
+
+    // '.' at the end of a path is not considered an extension.
+    testGetters("a/b.c/.",
+                ['a/b.c', '.', '.', 'a/b.c/.', '', ''],
+                '');
+    // '..' at the end of a path is not considered an extension.
+    testGetters("a/bc/../..",
+        ['a/bc/..', '..', '..', 'a/bc/../..', '', ''],
+                '');
+    // '.foo' at the end of a path is not considered an extension.
+    testGetters("a/bc/../.foo",
+        ['a/bc/..', '.foo', '.foo', 'a/bc/../.foo', '', ''],
+                '');
+    // '.foo.bar' at the end of a path is has extension '.bar'.
+    testGetters("a/bc/../.foo.bar",
+        ['a/bc/..', '.foo.bar', '.foo', 'a/bc/../.foo', '.bar', ''],
+                '');
+
+    // Make sure that backslashes are uninterpreted on other platforms.
+    testGetters(r"c:\foo\bar\fisk.hest",
+                ['.', r'c:\foo\bar\fisk.hest', r'c:\foo\bar\fisk',
+                 r'c:\foo\bar\fisk', '.hest', ''],
+                'normalized');
+    testGetters(r"/foo\bar/bif/fisk.hest",
+                [r'/foo\bar/bif', 'fisk.hest', 'fisk', r'/foo\bar/bif/fisk',
+                 '.hest', '/'],
+                'absolute normalized');
+    testGetters(r"//foo\bar///bif////fisk.hest",
+                [r'//foo\bar///bif', 'fisk.hest', 'fisk',
+                 r'//foo\bar///bif////fisk', '.hest', '/'],
+                'absolute');
+    testGetters(r"/foo\ bar/bif/gule\ fisk.hest",
+                [r'/foo\ bar/bif', r'gule\ fisk.hest', r'gule\ fisk',
+                 r'/foo\ bar/bif/gule\ fisk', '.hest', '/'],
+                'absolute normalized');
+  });
 }