OLD | NEW |
1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file |
2 // for details. All rights reserved. Use of this source code is governed by a | 2 // for details. All rights reserved. Use of this source code is governed by a |
3 // BSD-style license that can be found in the LICENSE file. | 3 // BSD-style license that can be found in the LICENSE file. |
4 | 4 |
5 library path.test.windows_test; | 5 library path.test.windows_test; |
6 | 6 |
7 import 'package:unittest/unittest.dart'; | 7 import 'package:unittest/unittest.dart'; |
8 import 'package:path/path.dart' as path; | 8 import 'package:path/path.dart' as path; |
9 | 9 |
10 import 'utils.dart'; | 10 import 'utils.dart'; |
11 | 11 |
12 main() { | 12 main() { |
13 var builder = new path.Builder(style: path.Style.windows, | 13 var context = new path.Context(style: path.Style.windows, |
14 root: r'C:\root\path'); | 14 current: r'C:\root\path'); |
15 | |
16 if (new path.Builder().style == path.Style.windows) { | |
17 group('absolute', () { | |
18 expect(path.absolute(r'a\b.txt'), path.join(path.current, r'a\b.txt')); | |
19 expect(path.absolute(r'C:\a\b.txt'), r'C:\a\b.txt'); | |
20 expect(path.absolute(r'\\a\b.txt'), r'\\a\b.txt'); | |
21 }); | |
22 } | |
23 | 15 |
24 group('separator', () { | 16 group('separator', () { |
25 expect(builder.separator, '\\'); | 17 expect(context.separator, '\\'); |
26 }); | 18 }); |
27 | 19 |
28 test('extension', () { | 20 test('extension', () { |
29 expect(builder.extension(''), ''); | 21 expect(context.extension(''), ''); |
30 expect(builder.extension('.'), ''); | 22 expect(context.extension('.'), ''); |
31 expect(builder.extension('..'), ''); | 23 expect(context.extension('..'), ''); |
32 expect(builder.extension('a/..'), ''); | 24 expect(context.extension('a/..'), ''); |
33 expect(builder.extension('foo.dart'), '.dart'); | 25 expect(context.extension('foo.dart'), '.dart'); |
34 expect(builder.extension('foo.dart.js'), '.js'); | 26 expect(context.extension('foo.dart.js'), '.js'); |
35 expect(builder.extension('foo bar\gule fisk.dart.js'), '.js'); | 27 expect(context.extension('foo bar\gule fisk.dart.js'), '.js'); |
36 expect(builder.extension(r'a.b\c'), ''); | 28 expect(context.extension(r'a.b\c'), ''); |
37 expect(builder.extension('a.b/c.d'), '.d'); | 29 expect(context.extension('a.b/c.d'), '.d'); |
38 expect(builder.extension(r'~\.bashrc'), ''); | 30 expect(context.extension(r'~\.bashrc'), ''); |
39 expect(builder.extension(r'a.b/c'), r''); | 31 expect(context.extension(r'a.b/c'), r''); |
40 expect(builder.extension(r'foo.dart\'), '.dart'); | 32 expect(context.extension(r'foo.dart\'), '.dart'); |
41 expect(builder.extension(r'foo.dart\\'), '.dart'); | 33 expect(context.extension(r'foo.dart\\'), '.dart'); |
42 }); | 34 }); |
43 | 35 |
44 test('rootPrefix', () { | 36 test('rootPrefix', () { |
45 expect(builder.rootPrefix(''), ''); | 37 expect(context.rootPrefix(''), ''); |
46 expect(builder.rootPrefix('a'), ''); | 38 expect(context.rootPrefix('a'), ''); |
47 expect(builder.rootPrefix(r'a\b'), ''); | 39 expect(context.rootPrefix(r'a\b'), ''); |
48 expect(builder.rootPrefix(r'C:\a\c'), r'C:\'); | 40 expect(context.rootPrefix(r'C:\a\c'), r'C:\'); |
49 expect(builder.rootPrefix('C:\\'), r'C:\'); | 41 expect(context.rootPrefix('C:\\'), r'C:\'); |
50 expect(builder.rootPrefix('C:/'), 'C:/'); | 42 expect(context.rootPrefix('C:/'), 'C:/'); |
51 expect(builder.rootPrefix(r'\\server\share\a\b'), r'\\server\share'); | 43 expect(context.rootPrefix(r'\\server\share\a\b'), r'\\server\share'); |
52 expect(builder.rootPrefix(r'\a\b'), r'\'); | 44 expect(context.rootPrefix(r'\a\b'), r'\'); |
53 expect(builder.rootPrefix(r'/a/b'), r'/'); | 45 expect(context.rootPrefix(r'/a/b'), r'/'); |
54 expect(builder.rootPrefix(r'\'), r'\'); | 46 expect(context.rootPrefix(r'\'), r'\'); |
55 expect(builder.rootPrefix(r'/'), r'/'); | 47 expect(context.rootPrefix(r'/'), r'/'); |
56 }); | 48 }); |
57 | 49 |
58 test('dirname', () { | 50 test('dirname', () { |
59 expect(builder.dirname(r''), '.'); | 51 expect(context.dirname(r''), '.'); |
60 expect(builder.dirname(r'a'), '.'); | 52 expect(context.dirname(r'a'), '.'); |
61 expect(builder.dirname(r'a\b'), 'a'); | 53 expect(context.dirname(r'a\b'), 'a'); |
62 expect(builder.dirname(r'a\b\c'), r'a\b'); | 54 expect(context.dirname(r'a\b\c'), r'a\b'); |
63 expect(builder.dirname(r'a\b.c'), 'a'); | 55 expect(context.dirname(r'a\b.c'), 'a'); |
64 expect(builder.dirname(r'a\'), '.'); | 56 expect(context.dirname(r'a\'), '.'); |
65 expect(builder.dirname('a/'), '.'); | 57 expect(context.dirname('a/'), '.'); |
66 expect(builder.dirname(r'a\.'), 'a'); | 58 expect(context.dirname(r'a\.'), 'a'); |
67 expect(builder.dirname(r'a\b/c'), r'a\b'); | 59 expect(context.dirname(r'a\b/c'), r'a\b'); |
68 expect(builder.dirname(r'C:\a'), r'C:\'); | 60 expect(context.dirname(r'C:\a'), r'C:\'); |
69 expect(builder.dirname(r'C:\\\a'), r'C:\'); | 61 expect(context.dirname(r'C:\\\a'), r'C:\'); |
70 expect(builder.dirname(r'C:\'), r'C:\'); | 62 expect(context.dirname(r'C:\'), r'C:\'); |
71 expect(builder.dirname(r'C:\\\'), r'C:\'); | 63 expect(context.dirname(r'C:\\\'), r'C:\'); |
72 expect(builder.dirname(r'a\b\'), r'a'); | 64 expect(context.dirname(r'a\b\'), r'a'); |
73 expect(builder.dirname(r'a/b\c'), 'a/b'); | 65 expect(context.dirname(r'a/b\c'), 'a/b'); |
74 expect(builder.dirname(r'a\\'), r'.'); | 66 expect(context.dirname(r'a\\'), r'.'); |
75 expect(builder.dirname(r'a\b\\'), 'a'); | 67 expect(context.dirname(r'a\b\\'), 'a'); |
76 expect(builder.dirname(r'a\\b'), 'a'); | 68 expect(context.dirname(r'a\\b'), 'a'); |
77 expect(builder.dirname(r'foo bar\gule fisk'), 'foo bar'); | 69 expect(context.dirname(r'foo bar\gule fisk'), 'foo bar'); |
78 expect(builder.dirname(r'\\server\share'), r'\\server\share'); | 70 expect(context.dirname(r'\\server\share'), r'\\server\share'); |
79 expect(builder.dirname(r'\\server\share\dir'), r'\\server\share'); | 71 expect(context.dirname(r'\\server\share\dir'), r'\\server\share'); |
80 expect(builder.dirname(r'\a'), r'\'); | 72 expect(context.dirname(r'\a'), r'\'); |
81 expect(builder.dirname(r'/a'), r'/'); | 73 expect(context.dirname(r'/a'), r'/'); |
82 expect(builder.dirname(r'\'), r'\'); | 74 expect(context.dirname(r'\'), r'\'); |
83 expect(builder.dirname(r'/'), r'/'); | 75 expect(context.dirname(r'/'), r'/'); |
84 }); | 76 }); |
85 | 77 |
86 test('basename', () { | 78 test('basename', () { |
87 expect(builder.basename(r''), ''); | 79 expect(context.basename(r''), ''); |
88 expect(builder.basename(r'.'), '.'); | 80 expect(context.basename(r'.'), '.'); |
89 expect(builder.basename(r'..'), '..'); | 81 expect(context.basename(r'..'), '..'); |
90 expect(builder.basename(r'.hest'), '.hest'); | 82 expect(context.basename(r'.hest'), '.hest'); |
91 expect(builder.basename(r'a'), 'a'); | 83 expect(context.basename(r'a'), 'a'); |
92 expect(builder.basename(r'a\b'), 'b'); | 84 expect(context.basename(r'a\b'), 'b'); |
93 expect(builder.basename(r'a\b\c'), 'c'); | 85 expect(context.basename(r'a\b\c'), 'c'); |
94 expect(builder.basename(r'a\b.c'), 'b.c'); | 86 expect(context.basename(r'a\b.c'), 'b.c'); |
95 expect(builder.basename(r'a\'), 'a'); | 87 expect(context.basename(r'a\'), 'a'); |
96 expect(builder.basename(r'a/'), 'a'); | 88 expect(context.basename(r'a/'), 'a'); |
97 expect(builder.basename(r'a\.'), '.'); | 89 expect(context.basename(r'a\.'), '.'); |
98 expect(builder.basename(r'a\b/c'), r'c'); | 90 expect(context.basename(r'a\b/c'), r'c'); |
99 expect(builder.basename(r'C:\a'), 'a'); | 91 expect(context.basename(r'C:\a'), 'a'); |
100 expect(builder.basename(r'C:\'), r'C:\'); | 92 expect(context.basename(r'C:\'), r'C:\'); |
101 expect(builder.basename(r'a\b\'), 'b'); | 93 expect(context.basename(r'a\b\'), 'b'); |
102 expect(builder.basename(r'a/b\c'), 'c'); | 94 expect(context.basename(r'a/b\c'), 'c'); |
103 expect(builder.basename(r'a\\'), 'a'); | 95 expect(context.basename(r'a\\'), 'a'); |
104 expect(builder.basename(r'a\b\\'), 'b'); | 96 expect(context.basename(r'a\b\\'), 'b'); |
105 expect(builder.basename(r'a\\b'), 'b'); | 97 expect(context.basename(r'a\\b'), 'b'); |
106 expect(builder.basename(r'a\\b'), 'b'); | 98 expect(context.basename(r'a\\b'), 'b'); |
107 expect(builder.basename(r'a\fisk hest.ma pa'), 'fisk hest.ma pa'); | 99 expect(context.basename(r'a\fisk hest.ma pa'), 'fisk hest.ma pa'); |
108 expect(builder.basename(r'\\server\share'), r'\\server\share'); | 100 expect(context.basename(r'\\server\share'), r'\\server\share'); |
109 expect(builder.basename(r'\\server\share\dir'), r'dir'); | 101 expect(context.basename(r'\\server\share\dir'), r'dir'); |
110 expect(builder.basename(r'\a'), r'a'); | 102 expect(context.basename(r'\a'), r'a'); |
111 expect(builder.basename(r'/a'), r'a'); | 103 expect(context.basename(r'/a'), r'a'); |
112 expect(builder.basename(r'\'), r'\'); | 104 expect(context.basename(r'\'), r'\'); |
113 expect(builder.basename(r'/'), r'/'); | 105 expect(context.basename(r'/'), r'/'); |
114 }); | 106 }); |
115 | 107 |
116 test('basenameWithoutExtension', () { | 108 test('basenameWithoutExtension', () { |
117 expect(builder.basenameWithoutExtension(''), ''); | 109 expect(context.basenameWithoutExtension(''), ''); |
118 expect(builder.basenameWithoutExtension('.'), '.'); | 110 expect(context.basenameWithoutExtension('.'), '.'); |
119 expect(builder.basenameWithoutExtension('..'), '..'); | 111 expect(context.basenameWithoutExtension('..'), '..'); |
120 expect(builder.basenameWithoutExtension('.hest'), '.hest'); | 112 expect(context.basenameWithoutExtension('.hest'), '.hest'); |
121 expect(builder.basenameWithoutExtension('a'), 'a'); | 113 expect(context.basenameWithoutExtension('a'), 'a'); |
122 expect(builder.basenameWithoutExtension(r'a\b'), 'b'); | 114 expect(context.basenameWithoutExtension(r'a\b'), 'b'); |
123 expect(builder.basenameWithoutExtension(r'a\b\c'), 'c'); | 115 expect(context.basenameWithoutExtension(r'a\b\c'), 'c'); |
124 expect(builder.basenameWithoutExtension(r'a\b.c'), 'b'); | 116 expect(context.basenameWithoutExtension(r'a\b.c'), 'b'); |
125 expect(builder.basenameWithoutExtension(r'a\'), 'a'); | 117 expect(context.basenameWithoutExtension(r'a\'), 'a'); |
126 expect(builder.basenameWithoutExtension(r'a\.'), '.'); | 118 expect(context.basenameWithoutExtension(r'a\.'), '.'); |
127 expect(builder.basenameWithoutExtension(r'a\b/c'), r'c'); | 119 expect(context.basenameWithoutExtension(r'a\b/c'), r'c'); |
128 expect(builder.basenameWithoutExtension(r'a\.bashrc'), '.bashrc'); | 120 expect(context.basenameWithoutExtension(r'a\.bashrc'), '.bashrc'); |
129 expect(builder.basenameWithoutExtension(r'a\b\c.d.e'), 'c.d'); | 121 expect(context.basenameWithoutExtension(r'a\b\c.d.e'), 'c.d'); |
130 expect(builder.basenameWithoutExtension(r'a\\'), 'a'); | 122 expect(context.basenameWithoutExtension(r'a\\'), 'a'); |
131 expect(builder.basenameWithoutExtension(r'a\b\\'), 'b'); | 123 expect(context.basenameWithoutExtension(r'a\b\\'), 'b'); |
132 expect(builder.basenameWithoutExtension(r'a\\b'), 'b'); | 124 expect(context.basenameWithoutExtension(r'a\\b'), 'b'); |
133 expect(builder.basenameWithoutExtension(r'a\b.c\'), 'b'); | 125 expect(context.basenameWithoutExtension(r'a\b.c\'), 'b'); |
134 expect(builder.basenameWithoutExtension(r'a\b.c\\'), 'b'); | 126 expect(context.basenameWithoutExtension(r'a\b.c\\'), 'b'); |
135 expect(builder.basenameWithoutExtension(r'C:\f h.ma pa.f s'), 'f h.ma pa'); | 127 expect(context.basenameWithoutExtension(r'C:\f h.ma pa.f s'), 'f h.ma pa'); |
136 }); | 128 }); |
137 | 129 |
138 test('isAbsolute', () { | 130 test('isAbsolute', () { |
139 expect(builder.isAbsolute(''), false); | 131 expect(context.isAbsolute(''), false); |
140 expect(builder.isAbsolute('.'), false); | 132 expect(context.isAbsolute('.'), false); |
141 expect(builder.isAbsolute('..'), false); | 133 expect(context.isAbsolute('..'), false); |
142 expect(builder.isAbsolute('a'), false); | 134 expect(context.isAbsolute('a'), false); |
143 expect(builder.isAbsolute(r'a\b'), false); | 135 expect(context.isAbsolute(r'a\b'), false); |
144 expect(builder.isAbsolute(r'\a\b'), true); | 136 expect(context.isAbsolute(r'\a\b'), true); |
145 expect(builder.isAbsolute(r'\'), true); | 137 expect(context.isAbsolute(r'\'), true); |
146 expect(builder.isAbsolute(r'/a/b'), true); | 138 expect(context.isAbsolute(r'/a/b'), true); |
147 expect(builder.isAbsolute(r'/'), true); | 139 expect(context.isAbsolute(r'/'), true); |
148 expect(builder.isAbsolute('~'), false); | 140 expect(context.isAbsolute('~'), false); |
149 expect(builder.isAbsolute('.'), false); | 141 expect(context.isAbsolute('.'), false); |
150 expect(builder.isAbsolute(r'..\a'), false); | 142 expect(context.isAbsolute(r'..\a'), false); |
151 expect(builder.isAbsolute(r'a:/a\b'), true); | 143 expect(context.isAbsolute(r'a:/a\b'), true); |
152 expect(builder.isAbsolute(r'D:/a/b'), true); | 144 expect(context.isAbsolute(r'D:/a/b'), true); |
153 expect(builder.isAbsolute(r'c:\'), true); | 145 expect(context.isAbsolute(r'c:\'), true); |
154 expect(builder.isAbsolute(r'B:\'), true); | 146 expect(context.isAbsolute(r'B:\'), true); |
155 expect(builder.isAbsolute(r'c:\a'), true); | 147 expect(context.isAbsolute(r'c:\a'), true); |
156 expect(builder.isAbsolute(r'C:\a'), true); | 148 expect(context.isAbsolute(r'C:\a'), true); |
157 expect(builder.isAbsolute(r'\\server\share'), true); | 149 expect(context.isAbsolute(r'\\server\share'), true); |
158 expect(builder.isAbsolute(r'\\server\share\path'), true); | 150 expect(context.isAbsolute(r'\\server\share\path'), true); |
159 }); | 151 }); |
160 | 152 |
161 test('isRelative', () { | 153 test('isRelative', () { |
162 expect(builder.isRelative(''), true); | 154 expect(context.isRelative(''), true); |
163 expect(builder.isRelative('.'), true); | 155 expect(context.isRelative('.'), true); |
164 expect(builder.isRelative('..'), true); | 156 expect(context.isRelative('..'), true); |
165 expect(builder.isRelative('a'), true); | 157 expect(context.isRelative('a'), true); |
166 expect(builder.isRelative(r'a\b'), true); | 158 expect(context.isRelative(r'a\b'), true); |
167 expect(builder.isRelative(r'\a\b'), false); | 159 expect(context.isRelative(r'\a\b'), false); |
168 expect(builder.isRelative(r'\'), false); | 160 expect(context.isRelative(r'\'), false); |
169 expect(builder.isRelative(r'/a/b'), false); | 161 expect(context.isRelative(r'/a/b'), false); |
170 expect(builder.isRelative(r'/'), false); | 162 expect(context.isRelative(r'/'), false); |
171 expect(builder.isRelative('~'), true); | 163 expect(context.isRelative('~'), true); |
172 expect(builder.isRelative('.'), true); | 164 expect(context.isRelative('.'), true); |
173 expect(builder.isRelative(r'..\a'), true); | 165 expect(context.isRelative(r'..\a'), true); |
174 expect(builder.isRelative(r'a:/a\b'), false); | 166 expect(context.isRelative(r'a:/a\b'), false); |
175 expect(builder.isRelative(r'D:/a/b'), false); | 167 expect(context.isRelative(r'D:/a/b'), false); |
176 expect(builder.isRelative(r'c:\'), false); | 168 expect(context.isRelative(r'c:\'), false); |
177 expect(builder.isRelative(r'B:\'), false); | 169 expect(context.isRelative(r'B:\'), false); |
178 expect(builder.isRelative(r'c:\a'), false); | 170 expect(context.isRelative(r'c:\a'), false); |
179 expect(builder.isRelative(r'C:\a'), false); | 171 expect(context.isRelative(r'C:\a'), false); |
180 expect(builder.isRelative(r'\\server\share'), false); | 172 expect(context.isRelative(r'\\server\share'), false); |
181 expect(builder.isRelative(r'\\server\share\path'), false); | 173 expect(context.isRelative(r'\\server\share\path'), false); |
182 }); | 174 }); |
183 | 175 |
184 test('isRootRelative', () { | 176 test('isRootRelative', () { |
185 expect(builder.isRootRelative(''), false); | 177 expect(context.isRootRelative(''), false); |
186 expect(builder.isRootRelative('.'), false); | 178 expect(context.isRootRelative('.'), false); |
187 expect(builder.isRootRelative('..'), false); | 179 expect(context.isRootRelative('..'), false); |
188 expect(builder.isRootRelative('a'), false); | 180 expect(context.isRootRelative('a'), false); |
189 expect(builder.isRootRelative(r'a\b'), false); | 181 expect(context.isRootRelative(r'a\b'), false); |
190 expect(builder.isRootRelative(r'\a\b'), true); | 182 expect(context.isRootRelative(r'\a\b'), true); |
191 expect(builder.isRootRelative(r'\'), true); | 183 expect(context.isRootRelative(r'\'), true); |
192 expect(builder.isRootRelative(r'/a/b'), true); | 184 expect(context.isRootRelative(r'/a/b'), true); |
193 expect(builder.isRootRelative(r'/'), true); | 185 expect(context.isRootRelative(r'/'), true); |
194 expect(builder.isRootRelative('~'), false); | 186 expect(context.isRootRelative('~'), false); |
195 expect(builder.isRootRelative('.'), false); | 187 expect(context.isRootRelative('.'), false); |
196 expect(builder.isRootRelative(r'..\a'), false); | 188 expect(context.isRootRelative(r'..\a'), false); |
197 expect(builder.isRootRelative(r'a:/a\b'), false); | 189 expect(context.isRootRelative(r'a:/a\b'), false); |
198 expect(builder.isRootRelative(r'D:/a/b'), false); | 190 expect(context.isRootRelative(r'D:/a/b'), false); |
199 expect(builder.isRootRelative(r'c:\'), false); | 191 expect(context.isRootRelative(r'c:\'), false); |
200 expect(builder.isRootRelative(r'B:\'), false); | 192 expect(context.isRootRelative(r'B:\'), false); |
201 expect(builder.isRootRelative(r'c:\a'), false); | 193 expect(context.isRootRelative(r'c:\a'), false); |
202 expect(builder.isRootRelative(r'C:\a'), false); | 194 expect(context.isRootRelative(r'C:\a'), false); |
203 expect(builder.isRootRelative(r'\\server\share'), false); | 195 expect(context.isRootRelative(r'\\server\share'), false); |
204 expect(builder.isRootRelative(r'\\server\share\path'), false); | 196 expect(context.isRootRelative(r'\\server\share\path'), false); |
205 }); | 197 }); |
206 | 198 |
207 group('join', () { | 199 group('join', () { |
208 test('allows up to eight parts', () { | 200 test('allows up to eight parts', () { |
209 expect(builder.join('a'), 'a'); | 201 expect(context.join('a'), 'a'); |
210 expect(builder.join('a', 'b'), r'a\b'); | 202 expect(context.join('a', 'b'), r'a\b'); |
211 expect(builder.join('a', 'b', 'c'), r'a\b\c'); | 203 expect(context.join('a', 'b', 'c'), r'a\b\c'); |
212 expect(builder.join('a', 'b', 'c', 'd'), r'a\b\c\d'); | 204 expect(context.join('a', 'b', 'c', 'd'), r'a\b\c\d'); |
213 expect(builder.join('a', 'b', 'c', 'd', 'e'), r'a\b\c\d\e'); | 205 expect(context.join('a', 'b', 'c', 'd', 'e'), r'a\b\c\d\e'); |
214 expect(builder.join('a', 'b', 'c', 'd', 'e', 'f'), r'a\b\c\d\e\f'); | 206 expect(context.join('a', 'b', 'c', 'd', 'e', 'f'), r'a\b\c\d\e\f'); |
215 expect(builder.join('a', 'b', 'c', 'd', 'e', 'f', 'g'), r'a\b\c\d\e\f\g'); | 207 expect(context.join('a', 'b', 'c', 'd', 'e', 'f', 'g'), r'a\b\c\d\e\f\g'); |
216 expect(builder.join('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'), | 208 expect(context.join('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'), |
217 r'a\b\c\d\e\f\g\h'); | 209 r'a\b\c\d\e\f\g\h'); |
218 }); | 210 }); |
219 | 211 |
220 test('does not add separator if a part ends or begins in one', () { | 212 test('does not add separator if a part ends or begins in one', () { |
221 expect(builder.join(r'a\', 'b', r'c\', 'd'), r'a\b\c\d'); | 213 expect(context.join(r'a\', 'b', r'c\', 'd'), r'a\b\c\d'); |
222 expect(builder.join('a/', 'b'), r'a/b'); | 214 expect(context.join('a/', 'b'), r'a/b'); |
223 }); | 215 }); |
224 | 216 |
225 test('ignores parts before an absolute path', () { | 217 test('ignores parts before an absolute path', () { |
226 expect(builder.join('a', r'\b', r'\c', 'd'), r'\c\d'); | 218 expect(context.join('a', r'\b', r'\c', 'd'), r'\c\d'); |
227 expect(builder.join('a', '/b', '/c', 'd'), r'/c\d'); | 219 expect(context.join('a', '/b', '/c', 'd'), r'/c\d'); |
228 expect(builder.join('a', r'c:\b', 'c', 'd'), r'c:\b\c\d'); | 220 expect(context.join('a', r'c:\b', 'c', 'd'), r'c:\b\c\d'); |
229 expect(builder.join('a', r'\\b\c', r'\\d\e', 'f'), r'\\d\e\f'); | 221 expect(context.join('a', r'\\b\c', r'\\d\e', 'f'), r'\\d\e\f'); |
230 expect(builder.join('a', r'c:\b', r'\c', 'd'), r'c:\c\d'); | 222 expect(context.join('a', r'c:\b', r'\c', 'd'), r'c:\c\d'); |
231 expect(builder.join('a', r'\\b\c\d', r'\e', 'f'), r'\\b\c\e\f'); | 223 expect(context.join('a', r'\\b\c\d', r'\e', 'f'), r'\\b\c\e\f'); |
232 }); | 224 }); |
233 | 225 |
234 test('ignores trailing nulls', () { | 226 test('ignores trailing nulls', () { |
235 expect(builder.join('a', null), equals('a')); | 227 expect(context.join('a', null), equals('a')); |
236 expect(builder.join('a', 'b', 'c', null, null), equals(r'a\b\c')); | 228 expect(context.join('a', 'b', 'c', null, null), equals(r'a\b\c')); |
237 }); | 229 }); |
238 | 230 |
239 test('ignores empty strings', () { | 231 test('ignores empty strings', () { |
240 expect(builder.join(''), ''); | 232 expect(context.join(''), ''); |
241 expect(builder.join('', ''), ''); | 233 expect(context.join('', ''), ''); |
242 expect(builder.join('', 'a'), 'a'); | 234 expect(context.join('', 'a'), 'a'); |
243 expect(builder.join('a', '', 'b', '', '', '', 'c'), r'a\b\c'); | 235 expect(context.join('a', '', 'b', '', '', '', 'c'), r'a\b\c'); |
244 expect(builder.join('a', 'b', ''), r'a\b'); | 236 expect(context.join('a', 'b', ''), r'a\b'); |
245 }); | 237 }); |
246 | 238 |
247 test('disallows intermediate nulls', () { | 239 test('disallows intermediate nulls', () { |
248 expect(() => builder.join('a', null, 'b'), throwsArgumentError); | 240 expect(() => context.join('a', null, 'b'), throwsArgumentError); |
249 expect(() => builder.join(null, 'a'), throwsArgumentError); | 241 expect(() => context.join(null, 'a'), throwsArgumentError); |
250 }); | 242 }); |
251 | 243 |
252 test('join does not modify internal ., .., or trailing separators', () { | 244 test('join does not modify internal ., .., or trailing separators', () { |
253 expect(builder.join('a/', 'b/c/'), 'a/b/c/'); | 245 expect(context.join('a/', 'b/c/'), 'a/b/c/'); |
254 expect(builder.join(r'a\b\./c\..\\', r'd\..\.\..\\e\f\\'), | 246 expect(context.join(r'a\b\./c\..\\', r'd\..\.\..\\e\f\\'), |
255 r'a\b\./c\..\\d\..\.\..\\e\f\\'); | 247 r'a\b\./c\..\\d\..\.\..\\e\f\\'); |
256 expect(builder.join(r'a\b', r'c\..\..\..\..'), r'a\b\c\..\..\..\..'); | 248 expect(context.join(r'a\b', r'c\..\..\..\..'), r'a\b\c\..\..\..\..'); |
257 expect(builder.join(r'a', 'b${builder.separator}'), r'a\b\'); | 249 expect(context.join(r'a', 'b${context.separator}'), r'a\b\'); |
258 }); | 250 }); |
259 }); | 251 }); |
260 | 252 |
261 group('joinAll', () { | 253 group('joinAll', () { |
262 test('allows more than eight parts', () { | 254 test('allows more than eight parts', () { |
263 expect(builder.joinAll(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']), | 255 expect(context.joinAll(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']), |
264 r'a\b\c\d\e\f\g\h\i'); | 256 r'a\b\c\d\e\f\g\h\i'); |
265 }); | 257 }); |
266 | 258 |
267 test('does not add separator if a part ends or begins in one', () { | 259 test('does not add separator if a part ends or begins in one', () { |
268 expect(builder.joinAll([r'a\', 'b', r'c\', 'd']), r'a\b\c\d'); | 260 expect(context.joinAll([r'a\', 'b', r'c\', 'd']), r'a\b\c\d'); |
269 expect(builder.joinAll(['a/', 'b']), r'a/b'); | 261 expect(context.joinAll(['a/', 'b']), r'a/b'); |
270 }); | 262 }); |
271 | 263 |
272 test('ignores parts before an absolute path', () { | 264 test('ignores parts before an absolute path', () { |
273 expect(builder.joinAll(['a', r'\b', r'\c', 'd']), r'\c\d'); | 265 expect(context.joinAll(['a', r'\b', r'\c', 'd']), r'\c\d'); |
274 expect(builder.joinAll(['a', '/b', '/c', 'd']), r'/c\d'); | 266 expect(context.joinAll(['a', '/b', '/c', 'd']), r'/c\d'); |
275 expect(builder.joinAll(['a', r'c:\b', 'c', 'd']), r'c:\b\c\d'); | 267 expect(context.joinAll(['a', r'c:\b', 'c', 'd']), r'c:\b\c\d'); |
276 expect(builder.joinAll(['a', r'\\b\c', r'\\d\e', 'f']), r'\\d\e\f'); | 268 expect(context.joinAll(['a', r'\\b\c', r'\\d\e', 'f']), r'\\d\e\f'); |
277 expect(builder.joinAll(['a', r'c:\b', r'\c', 'd']), r'c:\c\d'); | 269 expect(context.joinAll(['a', r'c:\b', r'\c', 'd']), r'c:\c\d'); |
278 expect(builder.joinAll(['a', r'\\b\c\d', r'\e', 'f']), r'\\b\c\e\f'); | 270 expect(context.joinAll(['a', r'\\b\c\d', r'\e', 'f']), r'\\b\c\e\f'); |
279 }); | 271 }); |
280 }); | 272 }); |
281 | 273 |
282 group('split', () { | 274 group('split', () { |
283 test('simple cases', () { | 275 test('simple cases', () { |
284 expect(builder.split(''), []); | 276 expect(context.split(''), []); |
285 expect(builder.split('.'), ['.']); | 277 expect(context.split('.'), ['.']); |
286 expect(builder.split('..'), ['..']); | 278 expect(context.split('..'), ['..']); |
287 expect(builder.split('foo'), equals(['foo'])); | 279 expect(context.split('foo'), equals(['foo'])); |
288 expect(builder.split(r'foo\bar.txt'), equals(['foo', 'bar.txt'])); | 280 expect(context.split(r'foo\bar.txt'), equals(['foo', 'bar.txt'])); |
289 expect(builder.split(r'foo\bar/baz'), equals(['foo', 'bar', 'baz'])); | 281 expect(context.split(r'foo\bar/baz'), equals(['foo', 'bar', 'baz'])); |
290 expect(builder.split(r'foo\..\bar\.\baz'), | 282 expect(context.split(r'foo\..\bar\.\baz'), |
291 equals(['foo', '..', 'bar', '.', 'baz'])); | 283 equals(['foo', '..', 'bar', '.', 'baz'])); |
292 expect(builder.split(r'foo\\bar\\\baz'), equals(['foo', 'bar', 'baz'])); | 284 expect(context.split(r'foo\\bar\\\baz'), equals(['foo', 'bar', 'baz'])); |
293 expect(builder.split(r'foo\/\baz'), equals(['foo', 'baz'])); | 285 expect(context.split(r'foo\/\baz'), equals(['foo', 'baz'])); |
294 expect(builder.split('.'), equals(['.'])); | 286 expect(context.split('.'), equals(['.'])); |
295 expect(builder.split(''), equals([])); | 287 expect(context.split(''), equals([])); |
296 expect(builder.split('foo/'), equals(['foo'])); | 288 expect(context.split('foo/'), equals(['foo'])); |
297 expect(builder.split(r'C:\'), equals([r'C:\'])); | 289 expect(context.split(r'C:\'), equals([r'C:\'])); |
298 }); | 290 }); |
299 | 291 |
300 test('includes the root for absolute paths', () { | 292 test('includes the root for absolute paths', () { |
301 expect(builder.split(r'C:\foo\bar\baz'), | 293 expect(context.split(r'C:\foo\bar\baz'), |
302 equals([r'C:\', 'foo', 'bar', 'baz'])); | 294 equals([r'C:\', 'foo', 'bar', 'baz'])); |
303 expect(builder.split(r'C:\\'), equals([r'C:\'])); | 295 expect(context.split(r'C:\\'), equals([r'C:\'])); |
304 | 296 |
305 expect(builder.split(r'\\server\share\foo\bar\baz'), | 297 expect(context.split(r'\\server\share\foo\bar\baz'), |
306 equals([r'\\server\share', 'foo', 'bar', 'baz'])); | 298 equals([r'\\server\share', 'foo', 'bar', 'baz'])); |
307 expect(builder.split(r'\\server\share'), equals([r'\\server\share'])); | 299 expect(context.split(r'\\server\share'), equals([r'\\server\share'])); |
308 | 300 |
309 expect(builder.split(r'\foo\bar\baz'), | 301 expect(context.split(r'\foo\bar\baz'), |
310 equals([r'\', 'foo', 'bar', 'baz'])); | 302 equals([r'\', 'foo', 'bar', 'baz'])); |
311 expect(builder.split(r'\'), equals([r'\'])); | 303 expect(context.split(r'\'), equals([r'\'])); |
312 }); | 304 }); |
313 }); | 305 }); |
314 | 306 |
315 group('normalize', () { | 307 group('normalize', () { |
316 test('simple cases', () { | 308 test('simple cases', () { |
317 expect(builder.normalize(''), '.'); | 309 expect(context.normalize(''), '.'); |
318 expect(builder.normalize('.'), '.'); | 310 expect(context.normalize('.'), '.'); |
319 expect(builder.normalize('..'), '..'); | 311 expect(context.normalize('..'), '..'); |
320 expect(builder.normalize('a'), 'a'); | 312 expect(context.normalize('a'), 'a'); |
321 expect(builder.normalize('/a/b'), r'\a\b'); | 313 expect(context.normalize('/a/b'), r'\a\b'); |
322 expect(builder.normalize(r'\'), r'\'); | 314 expect(context.normalize(r'\'), r'\'); |
323 expect(builder.normalize(r'\a\b'), r'\a\b'); | 315 expect(context.normalize(r'\a\b'), r'\a\b'); |
324 expect(builder.normalize('/'), r'\'); | 316 expect(context.normalize('/'), r'\'); |
325 expect(builder.normalize('C:/'), r'C:\'); | 317 expect(context.normalize('C:/'), r'C:\'); |
326 expect(builder.normalize(r'C:\'), r'C:\'); | 318 expect(context.normalize(r'C:\'), r'C:\'); |
327 expect(builder.normalize(r'\\server\share'), r'\\server\share'); | 319 expect(context.normalize(r'\\server\share'), r'\\server\share'); |
328 expect(builder.normalize('a\\.\\\xc5\u0bf8-;\u{1f085}\u{00}\\c\\d\\..\\'), | 320 expect(context.normalize('a\\.\\\xc5\u0bf8-;\u{1f085}\u{00}\\c\\d\\..\\'), |
329 'a\\\xc5\u0bf8-;\u{1f085}\u{00}\x5cc'); | 321 'a\\\xc5\u0bf8-;\u{1f085}\u{00}\x5cc'); |
330 }); | 322 }); |
331 | 323 |
332 test('collapses redundant separators', () { | 324 test('collapses redundant separators', () { |
333 expect(builder.normalize(r'a\b\c'), r'a\b\c'); | 325 expect(context.normalize(r'a\b\c'), r'a\b\c'); |
334 expect(builder.normalize(r'a\\b\\\c\\\\d'), r'a\b\c\d'); | 326 expect(context.normalize(r'a\\b\\\c\\\\d'), r'a\b\c\d'); |
335 }); | 327 }); |
336 | 328 |
337 test('eliminates "." parts', () { | 329 test('eliminates "." parts', () { |
338 expect(builder.normalize(r'.\'), '.'); | 330 expect(context.normalize(r'.\'), '.'); |
339 expect(builder.normalize(r'c:\.'), r'c:\'); | 331 expect(context.normalize(r'c:\.'), r'c:\'); |
340 expect(builder.normalize(r'B:\.\'), r'B:\'); | 332 expect(context.normalize(r'B:\.\'), r'B:\'); |
341 expect(builder.normalize(r'\\server\share\.'), r'\\server\share'); | 333 expect(context.normalize(r'\\server\share\.'), r'\\server\share'); |
342 expect(builder.normalize(r'.\.'), '.'); | 334 expect(context.normalize(r'.\.'), '.'); |
343 expect(builder.normalize(r'a\.\b'), r'a\b'); | 335 expect(context.normalize(r'a\.\b'), r'a\b'); |
344 expect(builder.normalize(r'a\.b\c'), r'a\.b\c'); | 336 expect(context.normalize(r'a\.b\c'), r'a\.b\c'); |
345 expect(builder.normalize(r'a\./.\b\.\c'), r'a\b\c'); | 337 expect(context.normalize(r'a\./.\b\.\c'), r'a\b\c'); |
346 expect(builder.normalize(r'.\./a'), 'a'); | 338 expect(context.normalize(r'.\./a'), 'a'); |
347 expect(builder.normalize(r'a/.\.'), 'a'); | 339 expect(context.normalize(r'a/.\.'), 'a'); |
348 expect(builder.normalize(r'\.'), r'\'); | 340 expect(context.normalize(r'\.'), r'\'); |
349 expect(builder.normalize('/.'), r'\'); | 341 expect(context.normalize('/.'), r'\'); |
350 }); | 342 }); |
351 | 343 |
352 test('eliminates ".." parts', () { | 344 test('eliminates ".." parts', () { |
353 expect(builder.normalize('..'), '..'); | 345 expect(context.normalize('..'), '..'); |
354 expect(builder.normalize(r'..\'), '..'); | 346 expect(context.normalize(r'..\'), '..'); |
355 expect(builder.normalize(r'..\..\..'), r'..\..\..'); | 347 expect(context.normalize(r'..\..\..'), r'..\..\..'); |
356 expect(builder.normalize(r'../..\..\'), r'..\..\..'); | 348 expect(context.normalize(r'../..\..\'), r'..\..\..'); |
357 expect(builder.normalize(r'\\server\share\..'), r'\\server\share'); | 349 expect(context.normalize(r'\\server\share\..'), r'\\server\share'); |
358 expect(builder.normalize(r'\\server\share\..\../..\a'), | 350 expect(context.normalize(r'\\server\share\..\../..\a'), |
359 r'\\server\share\a'); | 351 r'\\server\share\a'); |
360 expect(builder.normalize(r'c:\..'), r'c:\'); | 352 expect(context.normalize(r'c:\..'), r'c:\'); |
361 expect(builder.normalize(r'A:/..\..\..'), r'A:\'); | 353 expect(context.normalize(r'A:/..\..\..'), r'A:\'); |
362 expect(builder.normalize(r'b:\..\..\..\a'), r'b:\a'); | 354 expect(context.normalize(r'b:\..\..\..\a'), r'b:\a'); |
363 expect(builder.normalize(r'b:\r\..\..\..\a\c\.\..'), r'b:\a'); | 355 expect(context.normalize(r'b:\r\..\..\..\a\c\.\..'), r'b:\a'); |
364 expect(builder.normalize(r'a\..'), '.'); | 356 expect(context.normalize(r'a\..'), '.'); |
365 expect(builder.normalize(r'..\a'), r'..\a'); | 357 expect(context.normalize(r'..\a'), r'..\a'); |
366 expect(builder.normalize(r'c:\..\a'), r'c:\a'); | 358 expect(context.normalize(r'c:\..\a'), r'c:\a'); |
367 expect(builder.normalize(r'\..\a'), r'\a'); | 359 expect(context.normalize(r'\..\a'), r'\a'); |
368 expect(builder.normalize(r'a\b\..'), 'a'); | 360 expect(context.normalize(r'a\b\..'), 'a'); |
369 expect(builder.normalize(r'..\a\b\..'), r'..\a'); | 361 expect(context.normalize(r'..\a\b\..'), r'..\a'); |
370 expect(builder.normalize(r'a\..\b'), 'b'); | 362 expect(context.normalize(r'a\..\b'), 'b'); |
371 expect(builder.normalize(r'a\.\..\b'), 'b'); | 363 expect(context.normalize(r'a\.\..\b'), 'b'); |
372 expect(builder.normalize(r'a\b\c\..\..\d\e\..'), r'a\d'); | 364 expect(context.normalize(r'a\b\c\..\..\d\e\..'), r'a\d'); |
373 expect(builder.normalize(r'a\b\..\..\..\..\c'), r'..\..\c'); | 365 expect(context.normalize(r'a\b\..\..\..\..\c'), r'..\..\c'); |
374 expect(builder.normalize(r'a/b/c/../../..d/./.e/f././'), r'a\..d\.e\f.'); | 366 expect(context.normalize(r'a/b/c/../../..d/./.e/f././'), r'a\..d\.e\f.'); |
375 }); | 367 }); |
376 | 368 |
377 test('removes trailing separators', () { | 369 test('removes trailing separators', () { |
378 expect(builder.normalize(r'.\'), '.'); | 370 expect(context.normalize(r'.\'), '.'); |
379 expect(builder.normalize(r'.\\'), '.'); | 371 expect(context.normalize(r'.\\'), '.'); |
380 expect(builder.normalize(r'a/'), 'a'); | 372 expect(context.normalize(r'a/'), 'a'); |
381 expect(builder.normalize(r'a\b\'), r'a\b'); | 373 expect(context.normalize(r'a\b\'), r'a\b'); |
382 expect(builder.normalize(r'a\b\\\'), r'a\b'); | 374 expect(context.normalize(r'a\b\\\'), r'a\b'); |
383 }); | 375 }); |
384 | 376 |
385 test('normalizes separators', () { | 377 test('normalizes separators', () { |
386 expect(builder.normalize(r'a/b\c'), r'a\b\c'); | 378 expect(context.normalize(r'a/b\c'), r'a\b\c'); |
387 }); | 379 }); |
388 }); | 380 }); |
389 | 381 |
390 group('relative', () { | 382 group('relative', () { |
391 group('from absolute root', () { | 383 group('from absolute root', () { |
392 test('given absolute path in root', () { | 384 test('given absolute path in root', () { |
393 expect(builder.relative(r'C:\'), r'..\..'); | 385 expect(context.relative(r'C:\'), r'..\..'); |
394 expect(builder.relative(r'C:\root'), '..'); | 386 expect(context.relative(r'C:\root'), '..'); |
395 expect(builder.relative(r'\root'), '..'); | 387 expect(context.relative(r'\root'), '..'); |
396 expect(builder.relative(r'C:\root\path'), '.'); | 388 expect(context.relative(r'C:\root\path'), '.'); |
397 expect(builder.relative(r'\root\path'), '.'); | 389 expect(context.relative(r'\root\path'), '.'); |
398 expect(builder.relative(r'C:\root\path\a'), 'a'); | 390 expect(context.relative(r'C:\root\path\a'), 'a'); |
399 expect(builder.relative(r'\root\path\a'), 'a'); | 391 expect(context.relative(r'\root\path\a'), 'a'); |
400 expect(builder.relative(r'C:\root\path\a\b.txt'), r'a\b.txt'); | 392 expect(context.relative(r'C:\root\path\a\b.txt'), r'a\b.txt'); |
401 expect(builder.relative(r'C:\root\a\b.txt'), r'..\a\b.txt'); | 393 expect(context.relative(r'C:\root\a\b.txt'), r'..\a\b.txt'); |
402 expect(builder.relative(r'C:/'), r'..\..'); | 394 expect(context.relative(r'C:/'), r'..\..'); |
403 expect(builder.relative(r'C:/root'), '..'); | 395 expect(context.relative(r'C:/root'), '..'); |
404 expect(builder.relative(r'c:\'), r'..\..'); | 396 expect(context.relative(r'c:\'), r'..\..'); |
405 expect(builder.relative(r'c:\root'), '..'); | 397 expect(context.relative(r'c:\root'), '..'); |
406 }); | 398 }); |
407 | 399 |
408 test('given absolute path outside of root', () { | 400 test('given absolute path outside of root', () { |
409 expect(builder.relative(r'C:\a\b'), r'..\..\a\b'); | 401 expect(context.relative(r'C:\a\b'), r'..\..\a\b'); |
410 expect(builder.relative(r'\a\b'), r'..\..\a\b'); | 402 expect(context.relative(r'\a\b'), r'..\..\a\b'); |
411 expect(builder.relative(r'C:\root\path\a'), 'a'); | 403 expect(context.relative(r'C:\root\path\a'), 'a'); |
412 expect(builder.relative(r'C:\root\path\a\b.txt'), r'a\b.txt'); | 404 expect(context.relative(r'C:\root\path\a\b.txt'), r'a\b.txt'); |
413 expect(builder.relative(r'C:\root\a\b.txt'), r'..\a\b.txt'); | 405 expect(context.relative(r'C:\root\a\b.txt'), r'..\a\b.txt'); |
414 expect(builder.relative(r'C:/a/b'), r'..\..\a\b'); | 406 expect(context.relative(r'C:/a/b'), r'..\..\a\b'); |
415 expect(builder.relative(r'C:/root/path/a'), 'a'); | 407 expect(context.relative(r'C:/root/path/a'), 'a'); |
416 expect(builder.relative(r'c:\a\b'), r'..\..\a\b'); | 408 expect(context.relative(r'c:\a\b'), r'..\..\a\b'); |
417 expect(builder.relative(r'c:\root\path\a'), 'a'); | 409 expect(context.relative(r'c:\root\path\a'), 'a'); |
418 }); | 410 }); |
419 | 411 |
420 test('given absolute path on different drive', () { | 412 test('given absolute path on different drive', () { |
421 expect(builder.relative(r'D:\a\b'), r'D:\a\b'); | 413 expect(context.relative(r'D:\a\b'), r'D:\a\b'); |
422 }); | 414 }); |
423 | 415 |
424 test('given relative path', () { | 416 test('given relative path', () { |
425 // The path is considered relative to the root, so it basically just | 417 // The path is considered relative to the root, so it basically just |
426 // normalizes. | 418 // normalizes. |
427 expect(builder.relative(''), '.'); | 419 expect(context.relative(''), '.'); |
428 expect(builder.relative('.'), '.'); | 420 expect(context.relative('.'), '.'); |
429 expect(builder.relative('a'), 'a'); | 421 expect(context.relative('a'), 'a'); |
430 expect(builder.relative(r'a\b.txt'), r'a\b.txt'); | 422 expect(context.relative(r'a\b.txt'), r'a\b.txt'); |
431 expect(builder.relative(r'..\a\b.txt'), r'..\a\b.txt'); | 423 expect(context.relative(r'..\a\b.txt'), r'..\a\b.txt'); |
432 expect(builder.relative(r'a\.\b\..\c.txt'), r'a\c.txt'); | 424 expect(context.relative(r'a\.\b\..\c.txt'), r'a\c.txt'); |
433 }); | 425 }); |
434 | 426 |
435 // Regression | 427 // Regression |
436 test('from root-only path', () { | 428 test('from root-only path', () { |
437 expect(builder.relative(r'C:\', from: r'C:\'), '.'); | 429 expect(context.relative(r'C:\', from: r'C:\'), '.'); |
438 expect(builder.relative(r'C:\root\path', from: r'C:\'), r'root\path'); | 430 expect(context.relative(r'C:\root\path', from: r'C:\'), r'root\path'); |
439 }); | 431 }); |
440 }); | 432 }); |
441 | 433 |
442 group('from relative root', () { | 434 group('from relative root', () { |
443 var r = new path.Builder(style: path.Style.windows, root: r'foo\bar'); | 435 var r = new path.Context(style: path.Style.windows, current: r'foo\bar'); |
444 | 436 |
445 test('given absolute path', () { | 437 test('given absolute path', () { |
446 expect(r.relative(r'C:\'), equals(r'C:\')); | 438 expect(r.relative(r'C:\'), equals(r'C:\')); |
447 expect(r.relative(r'C:\a\b'), equals(r'C:\a\b')); | 439 expect(r.relative(r'C:\a\b'), equals(r'C:\a\b')); |
448 expect(r.relative(r'\'), equals(r'\')); | 440 expect(r.relative(r'\'), equals(r'\')); |
449 expect(r.relative(r'\a\b'), equals(r'\a\b')); | 441 expect(r.relative(r'\a\b'), equals(r'\a\b')); |
450 }); | 442 }); |
451 | 443 |
452 test('given relative path', () { | 444 test('given relative path', () { |
453 // The path is considered relative to the root, so it basically just | 445 // The path is considered relative to the root, so it basically just |
454 // normalizes. | 446 // normalizes. |
455 expect(r.relative(''), '.'); | 447 expect(r.relative(''), '.'); |
456 expect(r.relative('.'), '.'); | 448 expect(r.relative('.'), '.'); |
457 expect(r.relative('..'), '..'); | 449 expect(r.relative('..'), '..'); |
458 expect(r.relative('a'), 'a'); | 450 expect(r.relative('a'), 'a'); |
459 expect(r.relative(r'a\b.txt'), r'a\b.txt'); | 451 expect(r.relative(r'a\b.txt'), r'a\b.txt'); |
460 expect(r.relative(r'..\a/b.txt'), r'..\a\b.txt'); | 452 expect(r.relative(r'..\a/b.txt'), r'..\a\b.txt'); |
461 expect(r.relative(r'a\./b\../c.txt'), r'a\c.txt'); | 453 expect(r.relative(r'a\./b\../c.txt'), r'a\c.txt'); |
462 }); | 454 }); |
463 }); | 455 }); |
464 | 456 |
465 group('from root-relative root', () { | 457 group('from root-relative root', () { |
466 var r = new path.Builder(style: path.Style.windows, root: r'\foo\bar'); | 458 var r = new path.Context(style: path.Style.windows, current: r'\foo\bar'); |
467 | 459 |
468 test('given absolute path', () { | 460 test('given absolute path', () { |
469 expect(r.relative(r'C:\'), equals(r'C:\')); | 461 expect(r.relative(r'C:\'), equals(r'C:\')); |
470 expect(r.relative(r'C:\a\b'), equals(r'C:\a\b')); | 462 expect(r.relative(r'C:\a\b'), equals(r'C:\a\b')); |
471 expect(r.relative(r'\'), equals(r'..\..')); | 463 expect(r.relative(r'\'), equals(r'..\..')); |
472 expect(r.relative(r'\a\b'), equals(r'..\..\a\b')); | 464 expect(r.relative(r'\a\b'), equals(r'..\..\a\b')); |
473 expect(r.relative('/'), equals(r'..\..')); | 465 expect(r.relative('/'), equals(r'..\..')); |
474 expect(r.relative('/a/b'), equals(r'..\..\a\b')); | 466 expect(r.relative('/a/b'), equals(r'..\..\a\b')); |
475 }); | 467 }); |
476 | 468 |
477 test('given relative path', () { | 469 test('given relative path', () { |
478 // The path is considered relative to the root, so it basically just | 470 // The path is considered relative to the root, so it basically just |
479 // normalizes. | 471 // normalizes. |
480 expect(r.relative(''), '.'); | 472 expect(r.relative(''), '.'); |
481 expect(r.relative('.'), '.'); | 473 expect(r.relative('.'), '.'); |
482 expect(r.relative('..'), '..'); | 474 expect(r.relative('..'), '..'); |
483 expect(r.relative('a'), 'a'); | 475 expect(r.relative('a'), 'a'); |
484 expect(r.relative(r'a\b.txt'), r'a\b.txt'); | 476 expect(r.relative(r'a\b.txt'), r'a\b.txt'); |
485 expect(r.relative(r'..\a/b.txt'), r'..\a\b.txt'); | 477 expect(r.relative(r'..\a/b.txt'), r'..\a\b.txt'); |
486 expect(r.relative(r'a\./b\../c.txt'), r'a\c.txt'); | 478 expect(r.relative(r'a\./b\../c.txt'), r'a\c.txt'); |
487 }); | 479 }); |
488 }); | 480 }); |
489 | 481 |
490 test('from a root with extension', () { | 482 test('from a root with extension', () { |
491 var r = new path.Builder(style: path.Style.windows, root: r'C:\dir.ext'); | 483 var r = new path.Context( |
| 484 style: path.Style.windows, current: r'C:\dir.ext'); |
492 expect(r.relative(r'C:\dir.ext\file'), 'file'); | 485 expect(r.relative(r'C:\dir.ext\file'), 'file'); |
493 }); | 486 }); |
494 | 487 |
495 test('with a root parameter', () { | 488 test('with a root parameter', () { |
496 expect(builder.relative(r'C:\foo\bar\baz', from: r'C:\foo\bar'), | 489 expect(context.relative(r'C:\foo\bar\baz', from: r'C:\foo\bar'), |
497 equals('baz')); | 490 equals('baz')); |
498 expect(builder.relative('..', from: r'C:\foo\bar'), | 491 expect(context.relative('..', from: r'C:\foo\bar'), |
499 equals(r'..\..\root')); | 492 equals(r'..\..\root')); |
500 expect(builder.relative('..', from: r'D:\foo\bar'), equals(r'C:\root')); | 493 expect(context.relative('..', from: r'D:\foo\bar'), equals(r'C:\root')); |
501 expect(builder.relative(r'C:\foo\bar\baz', from: r'foo\bar'), | 494 expect(context.relative(r'C:\foo\bar\baz', from: r'foo\bar'), |
502 equals(r'..\..\..\..\foo\bar\baz')); | 495 equals(r'..\..\..\..\foo\bar\baz')); |
503 expect(builder.relative('..', from: r'foo\bar'), equals(r'..\..\..')); | 496 expect(context.relative('..', from: r'foo\bar'), equals(r'..\..\..')); |
504 }); | 497 }); |
505 | 498 |
506 test('with a root parameter and a relative root', () { | 499 test('with a root parameter and a relative root', () { |
507 var r = new path.Builder(style: path.Style.windows, root: r'relative\root'
); | 500 var r = new path.Context( |
| 501 style: path.Style.windows, current: r'relative\root'); |
508 expect(r.relative(r'C:\foo\bar\baz', from: r'C:\foo\bar'), equals('baz')); | 502 expect(r.relative(r'C:\foo\bar\baz', from: r'C:\foo\bar'), equals('baz')); |
509 expect(() => r.relative('..', from: r'C:\foo\bar'), throwsPathException); | 503 expect(() => r.relative('..', from: r'C:\foo\bar'), throwsPathException); |
510 expect(r.relative(r'C:\foo\bar\baz', from: r'foo\bar'), | 504 expect(r.relative(r'C:\foo\bar\baz', from: r'foo\bar'), |
511 equals(r'C:\foo\bar\baz')); | 505 equals(r'C:\foo\bar\baz')); |
512 expect(r.relative('..', from: r'foo\bar'), equals(r'..\..\..')); | 506 expect(r.relative('..', from: r'foo\bar'), equals(r'..\..\..')); |
513 }); | 507 }); |
514 | 508 |
515 test('given absolute with different root prefix', () { | 509 test('given absolute with different root prefix', () { |
516 expect(builder.relative(r'D:\a\b'), r'D:\a\b'); | 510 expect(context.relative(r'D:\a\b'), r'D:\a\b'); |
517 expect(builder.relative(r'\\server\share\a\b'), r'\\server\share\a\b'); | 511 expect(context.relative(r'\\server\share\a\b'), r'\\server\share\a\b'); |
518 }); | 512 }); |
519 | 513 |
520 test('from a . root', () { | 514 test('from a . root', () { |
521 var r = new path.Builder(style: path.Style.windows, root: '.'); | 515 var r = new path.Context(style: path.Style.windows, current: '.'); |
522 expect(r.relative(r'C:\foo\bar\baz'), equals(r'C:\foo\bar\baz')); | 516 expect(r.relative(r'C:\foo\bar\baz'), equals(r'C:\foo\bar\baz')); |
523 expect(r.relative(r'foo\bar\baz'), equals(r'foo\bar\baz')); | 517 expect(r.relative(r'foo\bar\baz'), equals(r'foo\bar\baz')); |
524 expect(r.relative(r'\foo\bar\baz'), equals(r'\foo\bar\baz')); | 518 expect(r.relative(r'\foo\bar\baz'), equals(r'\foo\bar\baz')); |
525 }); | 519 }); |
526 }); | 520 }); |
527 | 521 |
528 group('isWithin', () { | 522 group('isWithin', () { |
529 test('simple cases', () { | 523 test('simple cases', () { |
530 expect(builder.isWithin(r'foo\bar', r'foo\bar'), isFalse); | 524 expect(context.isWithin(r'foo\bar', r'foo\bar'), isFalse); |
531 expect(builder.isWithin(r'foo\bar', r'foo\bar\baz'), isTrue); | 525 expect(context.isWithin(r'foo\bar', r'foo\bar\baz'), isTrue); |
532 expect(builder.isWithin(r'foo\bar', r'foo\baz'), isFalse); | 526 expect(context.isWithin(r'foo\bar', r'foo\baz'), isFalse); |
533 expect(builder.isWithin(r'foo\bar', r'..\path\foo\bar\baz'), isTrue); | 527 expect(context.isWithin(r'foo\bar', r'..\path\foo\bar\baz'), isTrue); |
534 expect(builder.isWithin(r'C:\', r'C:\foo\bar'), isTrue); | 528 expect(context.isWithin(r'C:\', r'C:\foo\bar'), isTrue); |
535 expect(builder.isWithin(r'C:\', r'D:\foo\bar'), isFalse); | 529 expect(context.isWithin(r'C:\', r'D:\foo\bar'), isFalse); |
536 expect(builder.isWithin(r'C:\', r'\foo\bar'), isTrue); | 530 expect(context.isWithin(r'C:\', r'\foo\bar'), isTrue); |
537 expect(builder.isWithin(r'C:\foo', r'\foo\bar'), isTrue); | 531 expect(context.isWithin(r'C:\foo', r'\foo\bar'), isTrue); |
538 expect(builder.isWithin(r'C:\foo', r'\bar\baz'), isFalse); | 532 expect(context.isWithin(r'C:\foo', r'\bar\baz'), isFalse); |
539 expect(builder.isWithin(r'baz', r'C:\root\path\baz\bang'), isTrue); | 533 expect(context.isWithin(r'baz', r'C:\root\path\baz\bang'), isTrue); |
540 expect(builder.isWithin(r'baz', r'C:\root\path\bang\baz'), isFalse); | 534 expect(context.isWithin(r'baz', r'C:\root\path\bang\baz'), isFalse); |
541 }); | 535 }); |
542 | 536 |
543 test('from a relative root', () { | 537 test('from a relative root', () { |
544 var r = new path.Builder(style: path.Style.windows, root: r'foo\bar'); | 538 var r = new path.Context(style: path.Style.windows, current: r'foo\bar'); |
545 expect(builder.isWithin('.', r'a\b\c'), isTrue); | 539 expect(context.isWithin('.', r'a\b\c'), isTrue); |
546 expect(builder.isWithin('.', r'..\a\b\c'), isFalse); | 540 expect(context.isWithin('.', r'..\a\b\c'), isFalse); |
547 expect(builder.isWithin('.', r'..\..\a\foo\b\c'), isFalse); | 541 expect(context.isWithin('.', r'..\..\a\foo\b\c'), isFalse); |
548 expect(builder.isWithin(r'C:\', r'C:\baz\bang'), isTrue); | 542 expect(context.isWithin(r'C:\', r'C:\baz\bang'), isTrue); |
549 expect(builder.isWithin('.', r'C:\baz\bang'), isFalse); | 543 expect(context.isWithin('.', r'C:\baz\bang'), isFalse); |
550 }); | 544 }); |
551 }); | 545 }); |
552 | 546 |
553 group('resolve', () { | 547 group('absolute', () { |
554 test('allows up to seven parts', () { | 548 test('allows up to seven parts', () { |
555 expect(builder.resolve('a'), r'C:\root\path\a'); | 549 expect(context.absolute('a'), r'C:\root\path\a'); |
556 expect(builder.resolve('a', 'b'), r'C:\root\path\a\b'); | 550 expect(context.absolute('a', 'b'), r'C:\root\path\a\b'); |
557 expect(builder.resolve('a', 'b', 'c'), r'C:\root\path\a\b\c'); | 551 expect(context.absolute('a', 'b', 'c'), r'C:\root\path\a\b\c'); |
558 expect(builder.resolve('a', 'b', 'c', 'd'), r'C:\root\path\a\b\c\d'); | 552 expect(context.absolute('a', 'b', 'c', 'd'), r'C:\root\path\a\b\c\d'); |
559 expect(builder.resolve('a', 'b', 'c', 'd', 'e'), | 553 expect(context.absolute('a', 'b', 'c', 'd', 'e'), |
560 r'C:\root\path\a\b\c\d\e'); | 554 r'C:\root\path\a\b\c\d\e'); |
561 expect(builder.resolve('a', 'b', 'c', 'd', 'e', 'f'), | 555 expect(context.absolute('a', 'b', 'c', 'd', 'e', 'f'), |
562 r'C:\root\path\a\b\c\d\e\f'); | 556 r'C:\root\path\a\b\c\d\e\f'); |
563 expect(builder.resolve('a', 'b', 'c', 'd', 'e', 'f', 'g'), | 557 expect(context.absolute('a', 'b', 'c', 'd', 'e', 'f', 'g'), |
564 r'C:\root\path\a\b\c\d\e\f\g'); | 558 r'C:\root\path\a\b\c\d\e\f\g'); |
565 }); | 559 }); |
566 | 560 |
567 test('does not add separator if a part ends in one', () { | 561 test('does not add separator if a part ends in one', () { |
568 expect(builder.resolve(r'a\', 'b', r'c\', 'd'), r'C:\root\path\a\b\c\d'); | 562 expect(context.absolute(r'a\', 'b', r'c\', 'd'), r'C:\root\path\a\b\c\d'); |
569 expect(builder.resolve('a/', 'b'), r'C:\root\path\a/b'); | 563 expect(context.absolute('a/', 'b'), r'C:\root\path\a/b'); |
570 }); | 564 }); |
571 | 565 |
572 test('ignores parts before an absolute path', () { | 566 test('ignores parts before an absolute path', () { |
573 expect(builder.resolve('a', '/b', '/c', 'd'), r'C:\c\d'); | 567 expect(context.absolute('a', '/b', '/c', 'd'), r'C:\c\d'); |
574 expect(builder.resolve('a', r'\b', r'\c', 'd'), r'C:\c\d'); | 568 expect(context.absolute('a', r'\b', r'\c', 'd'), r'C:\c\d'); |
575 expect(builder.resolve('a', r'c:\b', 'c', 'd'), r'c:\b\c\d'); | 569 expect(context.absolute('a', r'c:\b', 'c', 'd'), r'c:\b\c\d'); |
576 expect(builder.resolve('a', r'\\b\c', r'\\d\e', 'f'), r'\\d\e\f'); | 570 expect(context.absolute('a', r'\\b\c', r'\\d\e', 'f'), r'\\d\e\f'); |
577 }); | 571 }); |
578 }); | 572 }); |
579 | 573 |
580 test('withoutExtension', () { | 574 test('withoutExtension', () { |
581 expect(builder.withoutExtension(''), ''); | 575 expect(context.withoutExtension(''), ''); |
582 expect(builder.withoutExtension('a'), 'a'); | 576 expect(context.withoutExtension('a'), 'a'); |
583 expect(builder.withoutExtension('.a'), '.a'); | 577 expect(context.withoutExtension('.a'), '.a'); |
584 expect(builder.withoutExtension('a.b'), 'a'); | 578 expect(context.withoutExtension('a.b'), 'a'); |
585 expect(builder.withoutExtension(r'a\b.c'), r'a\b'); | 579 expect(context.withoutExtension(r'a\b.c'), r'a\b'); |
586 expect(builder.withoutExtension(r'a\b.c.d'), r'a\b.c'); | 580 expect(context.withoutExtension(r'a\b.c.d'), r'a\b.c'); |
587 expect(builder.withoutExtension(r'a\'), r'a\'); | 581 expect(context.withoutExtension(r'a\'), r'a\'); |
588 expect(builder.withoutExtension(r'a\b\'), r'a\b\'); | 582 expect(context.withoutExtension(r'a\b\'), r'a\b\'); |
589 expect(builder.withoutExtension(r'a\.'), r'a\.'); | 583 expect(context.withoutExtension(r'a\.'), r'a\.'); |
590 expect(builder.withoutExtension(r'a\.b'), r'a\.b'); | 584 expect(context.withoutExtension(r'a\.b'), r'a\.b'); |
591 expect(builder.withoutExtension(r'a.b\c'), r'a.b\c'); | 585 expect(context.withoutExtension(r'a.b\c'), r'a.b\c'); |
592 expect(builder.withoutExtension(r'a/b.c/d'), r'a/b.c/d'); | 586 expect(context.withoutExtension(r'a/b.c/d'), r'a/b.c/d'); |
593 expect(builder.withoutExtension(r'a\b/c'), r'a\b/c'); | 587 expect(context.withoutExtension(r'a\b/c'), r'a\b/c'); |
594 expect(builder.withoutExtension(r'a\b/c.d'), r'a\b/c'); | 588 expect(context.withoutExtension(r'a\b/c.d'), r'a\b/c'); |
595 expect(builder.withoutExtension(r'a.b/c'), r'a.b/c'); | 589 expect(context.withoutExtension(r'a.b/c'), r'a.b/c'); |
596 expect(builder.withoutExtension(r'a\b.c\'), r'a\b\'); | 590 expect(context.withoutExtension(r'a\b.c\'), r'a\b\'); |
597 }); | 591 }); |
598 | 592 |
599 test('fromUri', () { | 593 test('fromUri', () { |
600 expect(builder.fromUri(Uri.parse('file:///C:/path/to/foo')), | 594 expect(context.fromUri(Uri.parse('file:///C:/path/to/foo')), |
601 r'C:\path\to\foo'); | 595 r'C:\path\to\foo'); |
602 expect(builder.fromUri(Uri.parse('file://server/share/path/to/foo')), | 596 expect(context.fromUri(Uri.parse('file://server/share/path/to/foo')), |
603 r'\\server\share\path\to\foo'); | 597 r'\\server\share\path\to\foo'); |
604 expect(builder.fromUri(Uri.parse('file:///C:/')), r'C:\'); | 598 expect(context.fromUri(Uri.parse('file:///C:/')), r'C:\'); |
605 expect(builder.fromUri(Uri.parse('file://server/share')), | 599 expect(context.fromUri(Uri.parse('file://server/share')), |
606 r'\\server\share'); | 600 r'\\server\share'); |
607 expect(builder.fromUri(Uri.parse('foo/bar')), r'foo\bar'); | 601 expect(context.fromUri(Uri.parse('foo/bar')), r'foo\bar'); |
608 expect(builder.fromUri(Uri.parse('/C:/path/to/foo')), r'C:\path\to\foo'); | 602 expect(context.fromUri(Uri.parse('/C:/path/to/foo')), r'C:\path\to\foo'); |
609 expect(builder.fromUri(Uri.parse('///C:/path/to/foo')), r'C:\path\to\foo'); | 603 expect(context.fromUri(Uri.parse('///C:/path/to/foo')), r'C:\path\to\foo'); |
610 expect(builder.fromUri(Uri.parse('//server/share/path/to/foo')), | 604 expect(context.fromUri(Uri.parse('//server/share/path/to/foo')), |
611 r'\\server\share\path\to\foo'); | 605 r'\\server\share\path\to\foo'); |
612 expect(builder.fromUri(Uri.parse('file:///C:/path/to/foo%23bar')), | 606 expect(context.fromUri(Uri.parse('file:///C:/path/to/foo%23bar')), |
613 r'C:\path\to\foo#bar'); | 607 r'C:\path\to\foo#bar'); |
614 expect(builder.fromUri(Uri.parse('file://server/share/path/to/foo%23bar')), | 608 expect(context.fromUri(Uri.parse('file://server/share/path/to/foo%23bar')), |
615 r'\\server\share\path\to\foo#bar'); | 609 r'\\server\share\path\to\foo#bar'); |
616 expect(builder.fromUri(Uri.parse('_%7B_%7D_%60_%5E_%20_%22_%25_')), | 610 expect(context.fromUri(Uri.parse('_%7B_%7D_%60_%5E_%20_%22_%25_')), |
617 r'_{_}_`_^_ _"_%_'); | 611 r'_{_}_`_^_ _"_%_'); |
618 expect(() => builder.fromUri(Uri.parse('http://dartlang.org')), | 612 expect(() => context.fromUri(Uri.parse('http://dartlang.org')), |
619 throwsArgumentError); | 613 throwsArgumentError); |
620 }); | 614 }); |
621 | 615 |
622 test('toUri', () { | 616 test('toUri', () { |
623 expect(builder.toUri(r'C:\path\to\foo'), | 617 expect(context.toUri(r'C:\path\to\foo'), |
624 Uri.parse('file:///C:/path/to/foo')); | 618 Uri.parse('file:///C:/path/to/foo')); |
625 expect(builder.toUri(r'C:\path\to\foo\'), | 619 expect(context.toUri(r'C:\path\to\foo\'), |
626 Uri.parse('file:///C:/path/to/foo/')); | 620 Uri.parse('file:///C:/path/to/foo/')); |
627 expect(builder.toUri(r'C:\'), Uri.parse('file:///C:/')); | 621 expect(context.toUri(r'C:\'), Uri.parse('file:///C:/')); |
628 expect(builder.toUri(r'\\server\share'), Uri.parse('file://server/share')); | 622 expect(context.toUri(r'\\server\share'), Uri.parse('file://server/share')); |
629 expect(builder.toUri(r'\\server\share\'), | 623 expect(context.toUri(r'\\server\share\'), |
630 Uri.parse('file://server/share/')); | 624 Uri.parse('file://server/share/')); |
631 expect(builder.toUri(r'foo\bar'), Uri.parse('foo/bar')); | 625 expect(context.toUri(r'foo\bar'), Uri.parse('foo/bar')); |
632 expect(builder.toUri(r'C:\path\to\foo#bar'), | 626 expect(context.toUri(r'C:\path\to\foo#bar'), |
633 Uri.parse('file:///C:/path/to/foo%23bar')); | 627 Uri.parse('file:///C:/path/to/foo%23bar')); |
634 expect(builder.toUri(r'\\server\share\path\to\foo#bar'), | 628 expect(context.toUri(r'\\server\share\path\to\foo#bar'), |
635 Uri.parse('file://server/share/path/to/foo%23bar')); | 629 Uri.parse('file://server/share/path/to/foo%23bar')); |
636 expect(builder.toUri(r'C:\_{_}_`_^_ _"_%_'), | 630 expect(context.toUri(r'C:\_{_}_`_^_ _"_%_'), |
637 Uri.parse('file:///C:/_%7B_%7D_%60_%5E_%20_%22_%25_')); | 631 Uri.parse('file:///C:/_%7B_%7D_%60_%5E_%20_%22_%25_')); |
638 expect(builder.toUri(r'_{_}_`_^_ _"_%_'), | 632 expect(context.toUri(r'_{_}_`_^_ _"_%_'), |
639 Uri.parse('_%7B_%7D_%60_%5E_%20_%22_%25_')); | 633 Uri.parse('_%7B_%7D_%60_%5E_%20_%22_%25_')); |
640 }); | 634 }); |
641 } | 635 } |
OLD | NEW |