Source file
src/path/path_test.go
1
2
3
4
5 package path_test
6
7 import (
8 . "path"
9 "runtime"
10 "testing"
11 )
12
13 type PathTest struct {
14 path, result string
15 }
16
17 var cleantests = []PathTest{
18
19 {"", "."},
20 {"abc", "abc"},
21 {"abc/def", "abc/def"},
22 {"a/b/c", "a/b/c"},
23 {".", "."},
24 {"..", ".."},
25 {"../..", "../.."},
26 {"../../abc", "../../abc"},
27 {"/abc", "/abc"},
28 {"/", "/"},
29
30
31 {"abc/", "abc"},
32 {"abc/def/", "abc/def"},
33 {"a/b/c/", "a/b/c"},
34 {"./", "."},
35 {"../", ".."},
36 {"../../", "../.."},
37 {"/abc/", "/abc"},
38
39
40 {"abc//def//ghi", "abc/def/ghi"},
41 {"//abc", "/abc"},
42 {"///abc", "/abc"},
43 {"//abc//", "/abc"},
44 {"abc//", "abc"},
45
46
47 {"abc/./def", "abc/def"},
48 {"/./abc/def", "/abc/def"},
49 {"abc/.", "abc"},
50
51
52 {"abc/def/ghi/../jkl", "abc/def/jkl"},
53 {"abc/def/../ghi/../jkl", "abc/jkl"},
54 {"abc/def/..", "abc"},
55 {"abc/def/../..", "."},
56 {"/abc/def/../..", "/"},
57 {"abc/def/../../..", ".."},
58 {"/abc/def/../../..", "/"},
59 {"abc/def/../../../ghi/jkl/../../../mno", "../../mno"},
60
61
62 {"abc/./../def", "def"},
63 {"abc//./../def", "def"},
64 {"abc/../../././../def", "../../def"},
65 }
66
67 func TestClean(t *testing.T) {
68 for _, test := range cleantests {
69 if s := Clean(test.path); s != test.result {
70 t.Errorf("Clean(%q) = %q, want %q", test.path, s, test.result)
71 }
72 if s := Clean(test.result); s != test.result {
73 t.Errorf("Clean(%q) = %q, want %q", test.result, s, test.result)
74 }
75 }
76 }
77
78 func TestCleanMallocs(t *testing.T) {
79 if testing.Short() {
80 t.Skip("skipping malloc count in short mode")
81 }
82 if runtime.GOMAXPROCS(0) > 1 {
83 t.Log("skipping AllocsPerRun checks; GOMAXPROCS>1")
84 return
85 }
86
87 for _, test := range cleantests {
88 allocs := testing.AllocsPerRun(100, func() { Clean(test.result) })
89 if allocs > 0 {
90 t.Errorf("Clean(%q): %v allocs, want zero", test.result, allocs)
91 }
92 }
93 }
94
95 type SplitTest struct {
96 path, dir, file string
97 }
98
99 var splittests = []SplitTest{
100 {"a/b", "a/", "b"},
101 {"a/b/", "a/b/", ""},
102 {"a/", "a/", ""},
103 {"a", "", "a"},
104 {"/", "/", ""},
105 }
106
107 func TestSplit(t *testing.T) {
108 for _, test := range splittests {
109 if d, f := Split(test.path); d != test.dir || f != test.file {
110 t.Errorf("Split(%q) = %q, %q, want %q, %q", test.path, d, f, test.dir, test.file)
111 }
112 }
113 }
114
115 type JoinTest struct {
116 elem []string
117 path string
118 }
119
120 var jointests = []JoinTest{
121
122 {[]string{}, ""},
123
124
125 {[]string{""}, ""},
126 {[]string{"a"}, "a"},
127
128
129 {[]string{"a", "b"}, "a/b"},
130 {[]string{"a", ""}, "a"},
131 {[]string{"", "b"}, "b"},
132 {[]string{"/", "a"}, "/a"},
133 {[]string{"/", ""}, "/"},
134 {[]string{"a/", "b"}, "a/b"},
135 {[]string{"a/", ""}, "a"},
136 {[]string{"", ""}, ""},
137 }
138
139 func TestJoin(t *testing.T) {
140 for _, test := range jointests {
141 if p := Join(test.elem...); p != test.path {
142 t.Errorf("Join(%q) = %q, want %q", test.elem, p, test.path)
143 }
144 }
145 }
146
147 type ExtTest struct {
148 path, ext string
149 }
150
151 var exttests = []ExtTest{
152 {"path.go", ".go"},
153 {"path.pb.go", ".go"},
154 {"a.dir/b", ""},
155 {"a.dir/b.go", ".go"},
156 {"a.dir/", ""},
157 }
158
159 func TestExt(t *testing.T) {
160 for _, test := range exttests {
161 if x := Ext(test.path); x != test.ext {
162 t.Errorf("Ext(%q) = %q, want %q", test.path, x, test.ext)
163 }
164 }
165 }
166
167 var basetests = []PathTest{
168
169 {"", "."},
170 {".", "."},
171 {"/.", "."},
172 {"/", "/"},
173 {"////", "/"},
174 {"x/", "x"},
175 {"abc", "abc"},
176 {"abc/def", "def"},
177 {"a/b/.x", ".x"},
178 {"a/b/c.", "c."},
179 {"a/b/c.x", "c.x"},
180 }
181
182 func TestBase(t *testing.T) {
183 for _, test := range basetests {
184 if s := Base(test.path); s != test.result {
185 t.Errorf("Base(%q) = %q, want %q", test.path, s, test.result)
186 }
187 }
188 }
189
190 var dirtests = []PathTest{
191 {"", "."},
192 {".", "."},
193 {"/.", "/"},
194 {"/", "/"},
195 {"////", "/"},
196 {"/foo", "/"},
197 {"x/", "x"},
198 {"abc", "."},
199 {"abc/def", "abc"},
200 {"abc////def", "abc"},
201 {"a/b/.x", "a/b"},
202 {"a/b/c.", "a/b"},
203 {"a/b/c.x", "a/b"},
204 }
205
206 func TestDir(t *testing.T) {
207 for _, test := range dirtests {
208 if s := Dir(test.path); s != test.result {
209 t.Errorf("Dir(%q) = %q, want %q", test.path, s, test.result)
210 }
211 }
212 }
213
214 type IsAbsTest struct {
215 path string
216 isAbs bool
217 }
218
219 var isAbsTests = []IsAbsTest{
220 {"", false},
221 {"/", true},
222 {"/usr/bin/gcc", true},
223 {"..", false},
224 {"/a/../bb", true},
225 {".", false},
226 {"./", false},
227 {"lala", false},
228 }
229
230 func TestIsAbs(t *testing.T) {
231 for _, test := range isAbsTests {
232 if r := IsAbs(test.path); r != test.isAbs {
233 t.Errorf("IsAbs(%q) = %v, want %v", test.path, r, test.isAbs)
234 }
235 }
236 }
237
View as plain text