code review 4981049: path/filepath: added Rel as the complement of Abs

src/pkg/path/filepath/path_test.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package filepath_test
 
 import (
         "os"
         "path/filepath"
         "reflect"
@@ skipping 554 matching lines @@
         }
         testEvalSymlinks(t, tests)
 }
 
 // Test paths relative to $GOROOT/src
 var abstests = []string{
         "../AUTHORS",
         "pkg/../../AUTHORS",
         "Make.pkg",
         "pkg/Makefile",
-
-        // Already absolute
+        ".",
         "$GOROOT/src/Make.pkg",
         "$GOROOT/src/../src/Make.pkg",
+        "$GOROOT/misc/cgo",
+        "$GOROOT",
 }
 
 func TestAbs(t *testing.T) {
         oldwd, err := os.Getwd()
         if err != nil {
                 t.Fatal("Getwd failed: " + err.String())
         }
         defer os.Chdir(oldwd)
         goroot := os.Getenv("GOROOT")
         cwd := filepath.Join(goroot, "src")
         os.Chdir(cwd)
         for _, path := range abstests {
                 path = strings.Replace(path, "$GOROOT", goroot, -1)
+                info, err := os.Stat(path)
+                if err != nil {
+                        t.Errorf("%s: %s", path, err)
+                }
+
                 abspath, err := filepath.Abs(path)
                 if err != nil {
                         t.Errorf("Abs(%q) error: %v", path, err)
                 }
-                info, err := os.Stat(path)
-                if err != nil {
-                        t.Errorf("%s: %s", path, err)
-                }
                 absinfo, err := os.Stat(abspath)
                 if err != nil || absinfo.Ino != info.Ino {
                         t.Errorf("Abs(%q)=%q, not the same file", path, abspath)
                 }
                 if !filepath.IsAbs(abspath) {
                         t.Errorf("Abs(%q)=%q, not an absolute path", path, abspath)
                 }
                 if filepath.IsAbs(path) && abspath != filepath.Clean(path) {
                         t.Errorf("Abs(%q)=%q, isn't clean", path, abspath)
                 }
         }
 }
 
+type RelTests struct {
+        root, path, want string
+}
+
+var reltests = []RelTests{
+        {"a/b", "a/b", "."},

[r, 2011/10/03 19:53:47]

you should include at least one example with elements longer than one character

[niemeyer, 2011/10/04 00:59:34]

There were already entries in lines 625, 626, 636 and 637, but I've increased
the length of elements to make it more obvious anyway.

+        {"a/b/.", "a/b", "."},
+        {"a/b", "a/b/.", "."},
+        {"./a/b", "a/b", "."},
+        {"a/b", "./a/b", "."},
+        {"a/b", "a/bc", "../bc"},
+        {"a/bc", "a/b", "../b"},
+        {"a/b", "a/b/c/d", "c/d"},
+        {"a/b", "a/b/../c", "../c"},
+        {"a/b/../c", "a/b", "../b"},
+        {"a/b/c", "a/c/d", "../../c/d"},
+        {"a/b", "c/d", "../../c/d"},
+        {"../../a/b", "../../a/b/c/d", "c/d"},
+        {"/a/b", "/a/b", "."},
+        {"/a/b/.", "/a/b", "."},
+        {"/a/b", "/a/b/.", "."},
+        {"/a/b", "/a/bc", "../bc"},
+        {"/a/bc", "/a/b", "../b"},
+        {"/a/b", "/a/b/c/d", "c/d"},
+        {"/a/b", "/a/b/../c", "../c"},
+        {"/a/b/../c", "/a/b", "../b"},
+        {"/a/b/c", "/a/c/d", "../../c/d"},
+        {"/a/b", "/c/d", "../../c/d"},
+        {"/../../a/b", "/../../a/b/c/d", "c/d"},
+        {".", "a/b", "a/b"},
+        {".", "..", ".."},
+
+        // can't do purely lexically
+        {"..", ".", "err"},
+        {"..", "a", "err"},
+        {"../..", "..", "err"},
+        {"a", "/a", "err"},
+        {"/a", "a", "err"},
+}
+
+var winreltests = []RelTests{
+        {`C:a\b\c`, `C:a/b/d`, `..\d`},
+        {`C:\`, `D:\`, `err`},
+        {`C:`, `D:`, `err`},
+}
+
+func TestRel(t *testing.T) {
+        tests := append([]RelTests{}, reltests...)
+        if runtime.GOOS == "windows" {
+                tests = append(tests, winreltests...)
+        }
+        for _, test := range tests {
+                got, err := filepath.Rel(test.root, test.path)
+                if test.want == "err" {
+                        if err == nil {
+                                t.Errorf("Rel(%q, %q)=%q, want error", test.root, test.path, got)
+                        }
+                        continue
+                }
+                if err != nil {
+                        t.Errorf("Rel(%q, %q): want %q, got error: %s", test.root, test.path, test.want, err)
+                }
+                if got != test.want {
+                        t.Errorf("Rel(%q, %q)=%q, want %q", test.root, test.path, got, test.want)
+                }
+        }
+}
+
 type VolumeNameTest struct {
         path string
         vol  string
 }
 
 var volumenametests = []VolumeNameTest{
         {`c:/foo/bar`, `c:`},
         {`c:`, `c:`},
         {``, ``},
         {`\\\host`, ``},
@@ skipping 19 matching lines @@
 func TestVolumeName(t *testing.T) {
         if runtime.GOOS != "windows" {
                 return
         }
         for _, v := range volumenametests {
                 if vol := filepath.VolumeName(v.path); vol != v.vol {
                         t.Errorf("VolumeName(%q)=%q, want %q", v.path, vol, v.vol)
                 }
         }
 }