240 lines
4.6 KiB
Go
240 lines
4.6 KiB
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 path
|
|
|
|
import (
|
|
"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"},
|
|
{"/", "/"},
|
|
|
|
// 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"},
|
|
|
|
// Combinations
|
|
{"abc/./../def", "def"},
|
|
{"abc//./../def", "def"},
|
|
{"abc/../../././../def", "../../def"},
|
|
}
|
|
|
|
func TestClean(t *testing.T) {
|
|
for _, test := range cleantests {
|
|
if s := Clean(test.path); s != test.result {
|
|
t.Errorf("Clean(%q) = %q, want %q", test.path, s, test.result)
|
|
}
|
|
if s := Clean(test.result); s != test.result {
|
|
t.Errorf("Clean(%q) = %q, want %q", test.result, s, test.result)
|
|
}
|
|
}
|
|
|
|
if runtime.GOMAXPROCS(0) > 1 {
|
|
t.Log("skipping AllocsPerRun checks; GOMAXPROCS>1")
|
|
return
|
|
}
|
|
|
|
t.Log("Skipping AllocsPerRun for gccgo")
|
|
return
|
|
|
|
for _, test := range cleantests {
|
|
allocs := testing.AllocsPerRun(100, func() { Clean(test.result) })
|
|
if allocs > 0 {
|
|
t.Errorf("Clean(%q): %v allocs, want zero", test.result, allocs)
|
|
}
|
|
}
|
|
}
|
|
|
|
type SplitTest struct {
|
|
path, dir, file string
|
|
}
|
|
|
|
var splittests = []SplitTest{
|
|
{"a/b", "a/", "b"},
|
|
{"a/b/", "a/b/", ""},
|
|
{"a/", "a/", ""},
|
|
{"a", "", "a"},
|
|
{"/", "/", ""},
|
|
}
|
|
|
|
func TestSplit(t *testing.T) {
|
|
for _, test := range splittests {
|
|
if d, f := Split(test.path); d != test.dir || f != test.file {
|
|
t.Errorf("Split(%q) = %q, %q, want %q, %q", test.path, d, f, test.dir, test.file)
|
|
}
|
|
}
|
|
}
|
|
|
|
type JoinTest struct {
|
|
elem []string
|
|
path string
|
|
}
|
|
|
|
var jointests = []JoinTest{
|
|
// zero parameters
|
|
{[]string{}, ""},
|
|
|
|
// one parameter
|
|
{[]string{""}, ""},
|
|
{[]string{"a"}, "a"},
|
|
|
|
// two parameters
|
|
{[]string{"a", "b"}, "a/b"},
|
|
{[]string{"a", ""}, "a"},
|
|
{[]string{"", "b"}, "b"},
|
|
{[]string{"/", "a"}, "/a"},
|
|
{[]string{"/", ""}, "/"},
|
|
{[]string{"a/", "b"}, "a/b"},
|
|
{[]string{"a/", ""}, "a"},
|
|
{[]string{"", ""}, ""},
|
|
}
|
|
|
|
// join takes a []string and passes it to Join.
|
|
func join(elem []string, args ...string) string {
|
|
args = elem
|
|
return Join(args...)
|
|
}
|
|
|
|
func TestJoin(t *testing.T) {
|
|
for _, test := range jointests {
|
|
if p := join(test.elem); p != test.path {
|
|
t.Errorf("join(%q) = %q, want %q", test.elem, p, test.path)
|
|
}
|
|
}
|
|
}
|
|
|
|
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 _, test := range exttests {
|
|
if x := Ext(test.path); x != test.ext {
|
|
t.Errorf("Ext(%q) = %q, want %q", test.path, x, test.ext)
|
|
}
|
|
}
|
|
}
|
|
|
|
var basetests = []PathTest{
|
|
// Already clean
|
|
{"", "."},
|
|
{".", "."},
|
|
{"/.", "."},
|
|
{"/", "/"},
|
|
{"////", "/"},
|
|
{"x/", "x"},
|
|
{"abc", "abc"},
|
|
{"abc/def", "def"},
|
|
{"a/b/.x", ".x"},
|
|
{"a/b/c.", "c."},
|
|
{"a/b/c.x", "c.x"},
|
|
}
|
|
|
|
func TestBase(t *testing.T) {
|
|
for _, test := range basetests {
|
|
if s := Base(test.path); s != test.result {
|
|
t.Errorf("Base(%q) = %q, want %q", test.path, s, test.result)
|
|
}
|
|
}
|
|
}
|
|
|
|
var dirtests = []PathTest{
|
|
{"", "."},
|
|
{".", "."},
|
|
{"/.", "/"},
|
|
{"/", "/"},
|
|
{"////", "/"},
|
|
{"/foo", "/"},
|
|
{"x/", "x"},
|
|
{"abc", "."},
|
|
{"abc/def", "abc"},
|
|
{"abc////def", "abc"},
|
|
{"a/b/.x", "a/b"},
|
|
{"a/b/c.", "a/b"},
|
|
{"a/b/c.x", "a/b"},
|
|
}
|
|
|
|
func TestDir(t *testing.T) {
|
|
for _, test := range dirtests {
|
|
if s := Dir(test.path); s != test.result {
|
|
t.Errorf("Dir(%q) = %q, want %q", test.path, 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},
|
|
}
|
|
|
|
func TestIsAbs(t *testing.T) {
|
|
for _, test := range isAbsTests {
|
|
if r := IsAbs(test.path); r != test.isAbs {
|
|
t.Errorf("IsAbs(%q) = %v, want %v", test.path, r, test.isAbs)
|
|
}
|
|
}
|
|
}
|