blob: 61381c69b3f4ff1621f9316d6a5693c7d1f2f0b3 [file] [log] [blame]
// Copyright 2020 CUE Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// 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 path
import (
"reflect"
"runtime"
"testing"
)
type PathTest struct {
path, result string
}
var cleantests = []PathTest{
// Already clean
{"abc", "abc"},
{"abc/def", "abc/def"},
{"a/b/c", "a/b/c"},
{".", "."},
{"..", ".."},
{"../..", "../.."},
{"../../abc", "../../abc"},
{"/abc", "/abc"},
{"/", "/"},
// Empty is current dir
{"", "."},
// Remove trailing slash
{"abc/", "abc"},
{"abc/def/", "abc/def"},
{"a/b/c/", "a/b/c"},
{"./", "."},
{"../", ".."},
{"../../", "../.."},
{"/abc/", "/abc"},
// Remove doubled slash
{"abc//def//ghi", "abc/def/ghi"},
{"//abc", "/abc"},
{"///abc", "/abc"},
{"//abc//", "/abc"},
{"abc//", "abc"},
// Remove . elements
{"abc/./def", "abc/def"},
{"/./abc/def", "/abc/def"},
{"abc/.", "abc"},
// Remove .. elements
{"abc/def/ghi/../jkl", "abc/def/jkl"},
{"abc/def/../ghi/../jkl", "abc/jkl"},
{"abc/def/..", "abc"},
{"abc/def/../..", "."},
{"/abc/def/../..", "/"},
{"abc/def/../../..", ".."},
{"/abc/def/../../..", "/"},
{"abc/def/../../../ghi/jkl/../../../mno", "../../mno"},
{"/../abc", "/abc"},
// Combinations
{"abc/./../def", "def"},
{"abc//./../def", "def"},
{"abc/../../././../def", "../../def"},
}
var wincleantests = []PathTest{
{`c:`, `c:.`},
{`c:\`, `c:\`},
{`c:\abc`, `c:\abc`},
{`c:abc\..\..\.\.\..\def`, `c:..\..\def`},
{`c:\abc\def\..\..`, `c:\`},
{`c:\..\abc`, `c:\abc`},
{`c:..\abc`, `c:..\abc`},
{`\`, `\`},
{`/`, `\`},
{`\\i\..\c$`, `\c$`},
{`\\i\..\i\c$`, `\i\c$`},
{`\\i\..\I\c$`, `\I\c$`},
{`\\host\share\foo\..\bar`, `\\host\share\bar`},
{`//host/share/foo/../baz`, `\\host\share\baz`},
{`\\a\b\..\c`, `\\a\b\c`},
{`\\a\b`, `\\a\b`},
}
func TestClean(t *testing.T) {
tests := cleantests
for _, os := range []OS{Unix, Windows, Plan9} {
if os == Windows {
for i := range tests {
tests[i].result = FromSlash(tests[i].result, os)
}
tests = append(tests, wincleantests...)
}
for _, test := range tests {
if s := Clean(test.path, os); s != test.result {
t.Errorf("Clean(%q) = %q, want %q", test.path, s, test.result)
}
if s := Clean(test.result, os); s != test.result {
t.Errorf("Clean(%q) = %q, want %q", test.result, s, test.result)
}
}
if testing.Short() {
t.Skip("skipping malloc count in short mode")
}
if runtime.GOMAXPROCS(0) > 1 {
t.Log("skipping AllocsPerRun checks; GOMAXPROCS>1")
return
}
for _, test := range tests {
allocs := testing.AllocsPerRun(100, func() { Clean(test.result, os) })
if allocs > 0 {
t.Errorf("Clean(%q): %v allocs, want zero", test.result, allocs)
}
}
}
}
func TestFromAndToSlash(t *testing.T) {
for _, o := range []OS{Unix, Windows, Plan9} {
sep := getOS(o).Separator
var slashtests = []PathTest{
{"", ""},
{"/", string(sep)},
{"/a/b", string([]byte{sep, 'a', sep, 'b'})},
{"a//b", string([]byte{'a', sep, sep, 'b'})},
}
for _, test := range slashtests {
if s := FromSlash(test.path, o); s != test.result {
t.Errorf("FromSlash(%q) = %q, want %q", test.path, s, test.result)
}
if s := ToSlash(test.result, o); s != test.path {
t.Errorf("ToSlash(%q) = %q, want %q", test.result, s, test.path)
}
}
}
}
type SplitListTest struct {
list string
result []string
}
var winsplitlisttests = []SplitListTest{
// quoted
{`"a"`, []string{`a`}},
// semicolon
{`";"`, []string{`;`}},
{`"a;b"`, []string{`a;b`}},
{`";";`, []string{`;`, ``}},
{`;";"`, []string{``, `;`}},
// partially quoted
{`a";"b`, []string{`a;b`}},
{`a; ""b`, []string{`a`, ` b`}},
{`"a;b`, []string{`a;b`}},
{`""a;b`, []string{`a`, `b`}},
{`"""a;b`, []string{`a;b`}},
{`""""a;b`, []string{`a`, `b`}},
{`a";b`, []string{`a;b`}},
{`a;b";c`, []string{`a`, `b;c`}},
{`"a";b";c`, []string{`a`, `b;c`}},
}
func TestSplitList(t *testing.T) {
for _, os := range []OS{Unix, Windows, Plan9} {
sep := getOS(os).ListSeparator
tests := []SplitListTest{
{"", []string{}},
{string([]byte{'a', sep, 'b'}), []string{"a", "b"}},
{string([]byte{sep, 'a', sep, 'b'}), []string{"", "a", "b"}},
}
if os == Windows {
tests = append(tests, winsplitlisttests...)
}
for _, test := range tests {
if l := SplitList(test.list, os); !reflect.DeepEqual(l, test.result) {
t.Errorf("SplitList(%#q, %q) = %#q, want %#q", test.list, os, l, test.result)
}
}
}
}
type SplitTest struct {
path, dir, file string
}
var unixsplittests = []SplitTest{
{"a/b", "a/", "b"},
{"a/b/", "a/b/", ""},
{"a/", "a/", ""},
{"a", "", "a"},
{"/", "/", ""},
}
var winsplittests = []SplitTest{
{`c:`, `c:`, ``},
{`c:/`, `c:/`, ``},
{`c:/foo`, `c:/`, `foo`},
{`c:/foo/bar`, `c:/foo/`, `bar`},
{`//host/share`, `//host/share`, ``},
{`//host/share/`, `//host/share/`, ``},
{`//host/share/foo`, `//host/share/`, `foo`},
{`\\host\share`, `\\host\share`, ``},
{`\\host\share\`, `\\host\share\`, ``},
{`\\host\share\foo`, `\\host\share\`, `foo`},
}
func TestSplit(t *testing.T) {
for _, os := range []OS{Windows, Unix} {
var splittests []SplitTest
splittests = unixsplittests
if os == Windows {
splittests = append(splittests, winsplittests...)
}
for _, test := range splittests {
pair := Split(test.path, os)
d, f := pair[0], pair[1]
if d != test.dir || f != test.file {
t.Errorf("Split(%q, %q) = %q, %q, want %q, %q",
test.path, os, d, f, test.dir, test.file)
}
}
}
}
type JoinTest struct {
elem []string
path string
}
var jointests = []JoinTest{
// zero parameters
{[]string{}, ""},
// one parameter
{[]string{""}, ""},
{[]string{"/"}, "/"},
{[]string{"a"}, "a"},
// two parameters
{[]string{"a", "b"}, "a/b"},
{[]string{"a", ""}, "a"},
{[]string{"", "b"}, "b"},
{[]string{"/", "a"}, "/a"},
{[]string{"/", "a/b"}, "/a/b"},
{[]string{"/", ""}, "/"},
{[]string{"//", "a"}, "/a"},
{[]string{"/a", "b"}, "/a/b"},
{[]string{"a/", "b"}, "a/b"},
{[]string{"a/", ""}, "a"},
{[]string{"", ""}, ""},
// three parameters
{[]string{"/", "a", "b"}, "/a/b"},
}
var winjointests = []JoinTest{
{[]string{`directory`, `file`}, `directory\file`},
{[]string{`C:\Windows\`, `System32`}, `C:\Windows\System32`},
{[]string{`C:\Windows\`, ``}, `C:\Windows`},
{[]string{`C:\`, `Windows`}, `C:\Windows`},
{[]string{`C:`, `a`}, `C:a`},
{[]string{`C:`, `a\b`}, `C:a\b`},
{[]string{`C:`, `a`, `b`}, `C:a\b`},
{[]string{`C:`, ``, `b`}, `C:b`},
{[]string{`C:`, ``, ``, `b`}, `C:b`},
{[]string{`C:`, ``}, `C:.`},
{[]string{`C:`, ``, ``}, `C:.`},
{[]string{`C:.`, `a`}, `C:a`},
{[]string{`C:a`, `b`}, `C:a\b`},
{[]string{`C:a`, `b`, `d`}, `C:a\b\d`},
{[]string{`\\host\share`, `foo`}, `\\host\share\foo`},
{[]string{`\\host\share\foo`}, `\\host\share\foo`},
{[]string{`//host/share`, `foo/bar`}, `\\host\share\foo\bar`},
{[]string{`\`}, `\`},
{[]string{`\`, ``}, `\`},
{[]string{`\`, `a`}, `\a`},
{[]string{`\\`, `a`}, `\a`},
{[]string{`\`, `a`, `b`}, `\a\b`},
{[]string{`\\`, `a`, `b`}, `\a\b`},
{[]string{`\`, `\\a\b`, `c`}, `\a\b\c`},
{[]string{`\\a`, `b`, `c`}, `\a\b\c`},
{[]string{`\\a\`, `b`, `c`}, `\a\b\c`},
}
func TestJoin(t *testing.T) {
for _, os := range []OS{Unix, Windows} {
if os == Windows {
jointests = append(jointests, winjointests...)
}
for _, test := range jointests {
expected := FromSlash(test.path, os)
if p := Join(test.elem, os); p != expected {
t.Errorf("join(%q, %q) = %q, want %q", test.elem, os, p, expected)
}
}
}
}
type ExtTest struct {
path, ext string
}
var exttests = []ExtTest{
{"path.go", ".go"},
{"path.pb.go", ".go"},
{"a.dir/b", ""},
{"a.dir/b.go", ".go"},
{"a.dir/", ""},
}
func TestExt(t *testing.T) {
for _, os := range []OS{Unix, Windows} {
for _, test := range exttests {
if x := Ext(test.path, os); x != test.ext {
t.Errorf("Ext(%q, %q) = %q, want %q", test.path, os, x, test.ext)
}
}
}
}
var basetests = []PathTest{
{"", "."},
{".", "."},
{"/.", "."},
{"/", "/"},
{"////", "/"},
{"x/", "x"},
{"abc", "abc"},
{"abc/def", "def"},
{"a/b/.x", ".x"},
{"a/b/c.", "c."},
{"a/b/c.x", "c.x"},
}
var winbasetests = []PathTest{
{`c:\`, `\`},
{`c:.`, `.`},
{`c:\a\b`, `b`},
{`c:a\b`, `b`},
{`c:a\b\c`, `c`},
{`\\host\share\`, `\`},
{`\\host\share\a`, `a`},
{`\\host\share\a\b`, `b`},
}
func TestBase(t *testing.T) {
tests := basetests
for _, os := range []OS{Unix, Windows} {
if os == Windows {
// make unix tests work on windows
for i := range tests {
tests[i].result = Clean(tests[i].result, os)
}
// add windows specific tests
tests = append(tests, winbasetests...)
}
for _, test := range tests {
if s := Base(test.path, os); s != test.result {
t.Errorf("Base(%q, %q) = %q, want %q", test.path, os, s, test.result)
}
}
}
}
var dirtests = []PathTest{
{"", "."},
{".", "."},
{"/.", "/"},
{"/", "/"},
{"////", "/"},
{"/foo", "/"},
{"x/", "x"},
{"abc", "."},
{"abc/def", "abc"},
{"a/b/.x", "a/b"},
{"a/b/c.", "a/b"},
{"a/b/c.x", "a/b"},
}
var windirtests = []PathTest{
{`c:\`, `c:\`},
{`c:.`, `c:.`},
{`c:\a\b`, `c:\a`},
{`c:a\b`, `c:a`},
{`c:a\b\c`, `c:a\b`},
{`\\host\share`, `\\host\share`},
{`\\host\share\`, `\\host\share\`},
{`\\host\share\a`, `\\host\share\`},
{`\\host\share\a\b`, `\\host\share\a`},
}
func TestDir(t *testing.T) {
for _, os := range []OS{Unix, Windows} {
tests := dirtests
if os == Windows {
// make unix tests work on windows
for i := range tests {
tests[i].result = Clean(tests[i].result, os)
}
// add windows specific tests
tests = append(tests, windirtests...)
}
for _, test := range tests {
if s := Dir(test.path, os); s != test.result {
t.Errorf("Dir(%q, %q) = %q, want %q", test.path, os, s, test.result)
}
}
}
}
type IsAbsTest struct {
path string
isAbs bool
}
var isabstests = []IsAbsTest{
{"", false},
{"/", true},
{"/usr/bin/gcc", true},
{"..", false},
{"/a/../bb", true},
{".", false},
{"./", false},
{"lala", false},
}
var winisabstests = []IsAbsTest{
{`C:\`, true},
{`c\`, false},
{`c::`, false},
{`c:`, false},
{`/`, false},
{`\`, false},
{`\Windows`, false},
{`c:a\b`, false},
{`c:\a\b`, true},
{`c:/a/b`, true},
{`\\host\share\foo`, true},
{`//host/share/foo/bar`, true},
}
func TestIsAbs(t *testing.T) {
for _, os := range []OS{Unix, Windows} {
var tests []IsAbsTest
if os == Windows {
tests = append(tests, winisabstests...)
// All non-windows tests should fail, because they have no volume letter.
for _, test := range isabstests {
tests = append(tests, IsAbsTest{test.path, false})
}
// All non-windows test should work as intended if prefixed with volume letter.
for _, test := range isabstests {
tests = append(tests, IsAbsTest{"c:" + test.path, test.isAbs})
}
// Test reserved names.
// tests = append(tests, IsAbsTest{"/dev/null", true})
tests = append(tests, IsAbsTest{"NUL", true})
tests = append(tests, IsAbsTest{"nul", true})
tests = append(tests, IsAbsTest{"CON", true})
} else {
tests = isabstests
}
for _, test := range tests {
if r := IsAbs(test.path, os); r != test.isAbs {
t.Errorf("IsAbs(%q, %q) = %v, want %v", test.path, os, r, test.isAbs)
}
}
}
}
// // simpleJoin builds a file name from the directory and path.
// // It does not use Join because we don't want ".." to be evaluated.
// func simpleJoin(dir, path string) string {
// return dir + string(Separator) + path
// }
// Test directories relative to temporary directory.
// The tests are run in absTestDirs[0].
var absTestDirs = []string{
"a",
"a/b",
"a/b/c",
}
// Test paths relative to temporary directory. $ expands to the directory.
// The tests are run in absTestDirs[0].
// We create absTestDirs first.
var absTests = []string{
".",
"b",
"b/",
"../a",
"../a/b",
"../a/b/./c/../../.././a",
"../a/b/./c/../../.././a/",
"$",
"$/.",
"$/a/../a/b",
"$/a/b/c/../../.././a",
"$/a/b/c/../../.././a/",
}
type RelTests struct {
root, path, want string
}
var reltests = []RelTests{
{"a/b", "a/b", "."},
{"a/b/.", "a/b", "."},
{"a/b", "a/b/.", "."},
{"./a/b", "a/b", "."},
{"a/b", "./a/b", "."},
{"ab/cd", "ab/cde", "../cde"},
{"ab/cd", "ab/c", "../c"},
{"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/c/d", "a/b", "../.."},
{"a/b/c/d", "a/b/", "../.."},
{"a/b/c/d/", "a/b", "../.."},
{"a/b/c/d/", "a/b/", "../.."},
{"../../a/b", "../../a/b/c/d", "c/d"},
{"/a/b", "/a/b", "."},
{"/a/b/.", "/a/b", "."},
{"/a/b", "/a/b/.", "."},
{"/ab/cd", "/ab/cde", "../cde"},
{"/ab/cd", "/ab/c", "../c"},
{"/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/c/d", "/a/b", "../.."},
{"/a/b/c/d", "/a/b/", "../.."},
{"/a/b/c/d/", "/a/b", "../.."},
{"/a/b/c/d/", "/a/b/", "../.."},
{"/../../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`},
{`C:\Projects`, `c:\projects\src`, `src`},
{`C:\Projects`, `c:\projects`, `.`},
{`C:\Projects\a\..`, `c:\projects`, `.`},
}
func TestRel(t *testing.T) {
for _, os := range []OS{Unix, Windows} {
tests := append([]RelTests{}, reltests...)
if os == Windows {
for i := range tests {
tests[i].want = FromSlash(tests[i].want, Windows)
}
tests = append(tests, winreltests...)
}
for _, test := range tests {
got, err := Rel(test.root, test.path, os)
if test.want == "err" {
if err == nil {
t.Errorf("Rel(%q, %q, %q)=%q, want error", test.root, test.path, os, got)
}
continue
}
if err != nil {
t.Errorf("Rel(%q, %q, %q): want %q, got error: %s", test.root, test.path, os, test.want, err)
}
if got != test.want {
t.Errorf("Rel(%q, %q, %q)=%q, want %q", test.root, test.path, os, got, test.want)
}
}
}
}
type VolumeNameTest struct {
path string
vol string
}
var volumenametests = []VolumeNameTest{
{`c:/foo/bar`, `c:`},
{`c:`, `c:`},
{`2:`, ``},
{``, ``},
{`\\\host`, ``},
{`\\\host\`, ``},
{`\\\host\share`, ``},
{`\\\host\\share`, ``},
{`\\host`, ``},
{`//host`, ``},
{`\\host\`, ``},
{`//host/`, ``},
{`\\host\share`, `\\host\share`},
{`//host/share`, `//host/share`},
{`\\host\share\`, `\\host\share`},
{`//host/share/`, `//host/share`},
{`\\host\share\foo`, `\\host\share`},
{`//host/share/foo`, `//host/share`},
{`\\host\share\\foo\\\bar\\\\baz`, `\\host\share`},
{`//host/share//foo///bar////baz`, `//host/share`},
{`\\host\share\foo\..\bar`, `\\host\share`},
{`//host/share/foo/../bar`, `//host/share`},
}
func TestVolumeName(t *testing.T) {
for _, os := range []OS{Unix, Windows} {
if os != Windows {
return
}
for _, v := range volumenametests {
if vol := VolumeName(v.path, os); vol != v.vol {
t.Errorf("VolumeName(%q, %q)=%q, want %q", v.path, os, vol, v.vol)
}
}
}
}