OLD | NEW |
| (Empty) |
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 | |
3 // BSD-style license that can be found in the LICENSE file. | |
4 | |
5 library pathos_windows_test; | |
6 | |
7 import 'package:unittest/unittest.dart'; | |
8 import 'package:pathos/path.dart' as path; | |
9 | |
10 main() { | |
11 var builder = new path.Builder(style: path.Style.windows, | |
12 root: r'C:\root\path'); | |
13 | |
14 if (new path.Builder().style == path.Style.windows) { | |
15 group('absolute', () { | |
16 expect(path.absolute(r'a\b.txt'), path.join(path.current, r'a\b.txt')); | |
17 expect(path.absolute(r'C:\a\b.txt'), r'C:\a\b.txt'); | |
18 expect(path.absolute(r'\\a\b.txt'), r'\\a\b.txt'); | |
19 }); | |
20 } | |
21 | |
22 group('separator', () { | |
23 expect(builder.separator, '\\'); | |
24 }); | |
25 | |
26 test('extension', () { | |
27 expect(builder.extension(''), ''); | |
28 expect(builder.extension('foo.dart'), '.dart'); | |
29 expect(builder.extension('foo.dart.js'), '.js'); | |
30 expect(builder.extension(r'a.b\c'), ''); | |
31 expect(builder.extension('a.b/c.d'), '.d'); | |
32 expect(builder.extension(r'~\.bashrc'), ''); | |
33 expect(builder.extension(r'a.b/c'), r''); | |
34 }); | |
35 | |
36 test('rootPrefix', () { | |
37 expect(builder.rootPrefix(''), ''); | |
38 expect(builder.rootPrefix('a'), ''); | |
39 expect(builder.rootPrefix(r'a\b'), ''); | |
40 expect(builder.rootPrefix(r'C:\a\c'), r'C:\'); | |
41 expect(builder.rootPrefix('C:\\'), r'C:\'); | |
42 expect(builder.rootPrefix('C:/'), 'C:/'); | |
43 | |
44 // TODO(nweiz): enable this once issue 7323 is fixed. | |
45 // expect(builder.rootPrefix(r'\\server\a\b'), r'\\server\'); | |
46 }); | |
47 | |
48 test('dirname', () { | |
49 expect(builder.dirname(r''), '.'); | |
50 expect(builder.dirname(r'a'), '.'); | |
51 expect(builder.dirname(r'a\b'), 'a'); | |
52 expect(builder.dirname(r'a\b\c'), r'a\b'); | |
53 expect(builder.dirname(r'a\b.c'), 'a'); | |
54 expect(builder.dirname(r'a\'), '.'); | |
55 expect(builder.dirname('a/'), '.'); | |
56 expect(builder.dirname(r'a\.'), 'a'); | |
57 expect(builder.dirname(r'a\b/c'), r'a\b'); | |
58 expect(builder.dirname(r'C:\a'), r'C:\'); | |
59 expect(builder.dirname(r'C:\\\a'), r'C:\'); | |
60 expect(builder.dirname(r'C:\'), r'C:\'); | |
61 expect(builder.dirname(r'C:\\\'), r'C:\'); | |
62 expect(builder.dirname(r'a\b\'), r'a'); | |
63 expect(builder.dirname(r'a/b\c'), 'a/b'); | |
64 expect(builder.dirname(r'a\\'), r'.'); | |
65 expect(builder.dirname(r'a\b\\'), 'a'); | |
66 expect(builder.dirname(r'a\\b'), 'a'); | |
67 }); | |
68 | |
69 test('basename', () { | |
70 expect(builder.basename(r''), ''); | |
71 expect(builder.basename(r'a'), 'a'); | |
72 expect(builder.basename(r'a\b'), 'b'); | |
73 expect(builder.basename(r'a\b\c'), 'c'); | |
74 expect(builder.basename(r'a\b.c'), 'b.c'); | |
75 expect(builder.basename(r'a\'), 'a'); | |
76 expect(builder.basename(r'a/'), 'a'); | |
77 expect(builder.basename(r'a\.'), '.'); | |
78 expect(builder.basename(r'a\b/c'), r'c'); | |
79 expect(builder.basename(r'C:\a'), 'a'); | |
80 expect(builder.basename(r'C:\'), r'C:\'); | |
81 expect(builder.basename(r'a\b\'), 'b'); | |
82 expect(builder.basename(r'a/b\c'), 'c'); | |
83 expect(builder.basename(r'a\\'), 'a'); | |
84 expect(builder.basename(r'a\b\\'), 'b'); | |
85 expect(builder.basename(r'a\\b'), 'b'); | |
86 }); | |
87 | |
88 test('basenameWithoutExtension', () { | |
89 expect(builder.basenameWithoutExtension(''), ''); | |
90 expect(builder.basenameWithoutExtension('a'), 'a'); | |
91 expect(builder.basenameWithoutExtension(r'a\b'), 'b'); | |
92 expect(builder.basenameWithoutExtension(r'a\b\c'), 'c'); | |
93 expect(builder.basenameWithoutExtension(r'a\b.c'), 'b'); | |
94 expect(builder.basenameWithoutExtension(r'a\'), 'a'); | |
95 expect(builder.basenameWithoutExtension(r'a\.'), '.'); | |
96 expect(builder.basenameWithoutExtension(r'a\b/c'), r'c'); | |
97 expect(builder.basenameWithoutExtension(r'a\.bashrc'), '.bashrc'); | |
98 expect(builder.basenameWithoutExtension(r'a\b\c.d.e'), 'c.d'); | |
99 expect(builder.basenameWithoutExtension(r'a\\'), 'a'); | |
100 expect(builder.basenameWithoutExtension(r'a\b\\'), 'b'); | |
101 expect(builder.basenameWithoutExtension(r'a\\b'), 'b'); | |
102 expect(builder.basenameWithoutExtension(r'a\b.c\'), 'b'); | |
103 expect(builder.basenameWithoutExtension(r'a\b.c\\'), 'b'); | |
104 }); | |
105 | |
106 test('isAbsolute', () { | |
107 expect(builder.isAbsolute(''), false); | |
108 expect(builder.isAbsolute('a'), false); | |
109 expect(builder.isAbsolute(r'a\b'), false); | |
110 expect(builder.isAbsolute(r'\a'), false); | |
111 expect(builder.isAbsolute(r'\a\b'), false); | |
112 expect(builder.isAbsolute('~'), false); | |
113 expect(builder.isAbsolute('.'), false); | |
114 expect(builder.isAbsolute(r'..\a'), false); | |
115 expect(builder.isAbsolute(r'a:/a\b'), true); | |
116 expect(builder.isAbsolute(r'D:/a/b'), true); | |
117 expect(builder.isAbsolute(r'c:\'), true); | |
118 expect(builder.isAbsolute(r'B:\'), true); | |
119 expect(builder.isAbsolute(r'c:\a'), true); | |
120 expect(builder.isAbsolute(r'C:\a'), true); | |
121 expect(builder.isAbsolute(r'\\a'), true); | |
122 expect(builder.isAbsolute(r'\\'), true); | |
123 }); | |
124 | |
125 test('isRelative', () { | |
126 expect(builder.isRelative(''), true); | |
127 expect(builder.isRelative('a'), true); | |
128 expect(builder.isRelative(r'a\b'), true); | |
129 expect(builder.isRelative(r'\a'), true); | |
130 expect(builder.isRelative(r'\a\b'), true); | |
131 expect(builder.isRelative('~'), true); | |
132 expect(builder.isRelative('.'), true); | |
133 expect(builder.isRelative(r'..\a'), true); | |
134 expect(builder.isRelative(r'a:/a\b'), false); | |
135 expect(builder.isRelative(r'D:/a/b'), false); | |
136 expect(builder.isRelative(r'c:\'), false); | |
137 expect(builder.isRelative(r'B:\'), false); | |
138 expect(builder.isRelative(r'c:\a'), false); | |
139 expect(builder.isRelative(r'C:\a'), false); | |
140 expect(builder.isRelative(r'\\a'), false); | |
141 expect(builder.isRelative(r'\\'), false); | |
142 }); | |
143 | |
144 group('join', () { | |
145 test('allows up to eight parts', () { | |
146 expect(builder.join('a'), 'a'); | |
147 expect(builder.join('a', 'b'), r'a\b'); | |
148 expect(builder.join('a', 'b', 'c'), r'a\b\c'); | |
149 expect(builder.join('a', 'b', 'c', 'd'), r'a\b\c\d'); | |
150 expect(builder.join('a', 'b', 'c', 'd', 'e'), r'a\b\c\d\e'); | |
151 expect(builder.join('a', 'b', 'c', 'd', 'e', 'f'), r'a\b\c\d\e\f'); | |
152 expect(builder.join('a', 'b', 'c', 'd', 'e', 'f', 'g'), r'a\b\c\d\e\f\g'); | |
153 expect(builder.join('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'), | |
154 r'a\b\c\d\e\f\g\h'); | |
155 }); | |
156 | |
157 test('does not add separator if a part ends or begins in one', () { | |
158 expect(builder.join(r'a\', 'b', r'c\', 'd'), r'a\b\c\d'); | |
159 expect(builder.join('a/', 'b'), r'a/b'); | |
160 expect(builder.join('a', '/b'), 'a/b'); | |
161 expect(builder.join('a', r'\b'), r'a\b'); | |
162 }); | |
163 | |
164 test('ignores parts before an absolute path', () { | |
165 expect(builder.join('a', '/b', '/c', 'd'), r'a/b/c\d'); | |
166 expect(builder.join('a', r'c:\b', 'c', 'd'), r'c:\b\c\d'); | |
167 expect(builder.join('a', r'\\b', r'\\c', 'd'), r'\\c\d'); | |
168 }); | |
169 | |
170 test('ignores trailing nulls', () { | |
171 expect(builder.join('a', null), equals('a')); | |
172 expect(builder.join('a', 'b', 'c', null, null), equals(r'a\b\c')); | |
173 }); | |
174 | |
175 test('disallows intermediate nulls', () { | |
176 expect(() => builder.join('a', null, 'b'), throwsArgumentError); | |
177 expect(() => builder.join(null, 'a'), throwsArgumentError); | |
178 }); | |
179 }); | |
180 | |
181 group('joinAll', () { | |
182 test('allows more than eight parts', () { | |
183 expect(builder.joinAll(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']), | |
184 r'a\b\c\d\e\f\g\h\i'); | |
185 }); | |
186 | |
187 test('does not add separator if a part ends or begins in one', () { | |
188 expect(builder.joinAll([r'a\', 'b', r'c\', 'd']), r'a\b\c\d'); | |
189 expect(builder.joinAll(['a/', 'b']), r'a/b'); | |
190 expect(builder.joinAll(['a', '/b']), 'a/b'); | |
191 expect(builder.joinAll(['a', r'\b']), r'a\b'); | |
192 }); | |
193 | |
194 test('ignores parts before an absolute path', () { | |
195 expect(builder.joinAll(['a', '/b', '/c', 'd']), r'a/b/c\d'); | |
196 expect(builder.joinAll(['a', r'c:\b', 'c', 'd']), r'c:\b\c\d'); | |
197 expect(builder.joinAll(['a', r'\\b', r'\\c', 'd']), r'\\c\d'); | |
198 }); | |
199 }); | |
200 | |
201 group('split', () { | |
202 test('simple cases', () { | |
203 expect(builder.split(''), []); | |
204 expect(builder.split('.'), ['.']); | |
205 expect(builder.split('..'), ['..']); | |
206 expect(builder.split('foo'), equals(['foo'])); | |
207 expect(builder.split(r'foo\bar.txt'), equals(['foo', 'bar.txt'])); | |
208 expect(builder.split(r'foo\bar/baz'), equals(['foo', 'bar', 'baz'])); | |
209 expect(builder.split(r'foo\..\bar\.\baz'), | |
210 equals(['foo', '..', 'bar', '.', 'baz'])); | |
211 expect(builder.split(r'foo\\bar\\\baz'), equals(['foo', 'bar', 'baz'])); | |
212 expect(builder.split(r'foo\/\baz'), equals(['foo', 'baz'])); | |
213 expect(builder.split('.'), equals(['.'])); | |
214 expect(builder.split(''), equals([])); | |
215 expect(builder.split('foo/'), equals(['foo'])); | |
216 expect(builder.split(r'C:\'), equals([r'C:\'])); | |
217 }); | |
218 | |
219 test('includes the root for absolute paths', () { | |
220 expect(builder.split(r'C:\foo\bar\baz'), | |
221 equals([r'C:\', 'foo', 'bar', 'baz'])); | |
222 expect(builder.split(r'C:\\'), equals([r'C:\'])); | |
223 | |
224 // TODO(nweiz): enable these once issue 7323 is fixed. | |
225 // expect(builder.split(r'\\server\foo\bar\baz'), | |
226 // equals([r'\\server\', 'foo', 'bar', 'baz'])); | |
227 // expect(builder.split(r'\\server\'), equals([r'\\server\'])); | |
228 }); | |
229 }); | |
230 | |
231 group('normalize', () { | |
232 test('simple cases', () { | |
233 expect(builder.normalize(''), ''); | |
234 expect(builder.normalize('.'), '.'); | |
235 expect(builder.normalize('..'), '..'); | |
236 expect(builder.normalize('a'), 'a'); | |
237 expect(builder.normalize('C:/'), r'C:\'); | |
238 expect(builder.normalize(r'C:\'), r'C:\'); | |
239 expect(builder.normalize(r'\\'), r'\\'); | |
240 }); | |
241 | |
242 test('collapses redundant separators', () { | |
243 expect(builder.normalize(r'a\b\c'), r'a\b\c'); | |
244 expect(builder.normalize(r'a\\b\\\c\\\\d'), r'a\b\c\d'); | |
245 }); | |
246 | |
247 test('eliminates "." parts', () { | |
248 expect(builder.normalize(r'.\'), '.'); | |
249 expect(builder.normalize(r'c:\.'), r'c:\'); | |
250 expect(builder.normalize(r'B:\.\'), r'B:\'); | |
251 expect(builder.normalize(r'\\.'), r'\\'); | |
252 expect(builder.normalize(r'\\.\'), r'\\'); | |
253 expect(builder.normalize(r'.\.'), '.'); | |
254 expect(builder.normalize(r'a\.\b'), r'a\b'); | |
255 expect(builder.normalize(r'a\.b\c'), r'a\.b\c'); | |
256 expect(builder.normalize(r'a\./.\b\.\c'), r'a\b\c'); | |
257 expect(builder.normalize(r'.\./a'), 'a'); | |
258 expect(builder.normalize(r'a/.\.'), 'a'); | |
259 }); | |
260 | |
261 test('eliminates ".." parts', () { | |
262 expect(builder.normalize('..'), '..'); | |
263 expect(builder.normalize(r'..\'), '..'); | |
264 expect(builder.normalize(r'..\..\..'), r'..\..\..'); | |
265 expect(builder.normalize(r'../..\..\'), r'..\..\..'); | |
266 // TODO(rnystrom): Is this how Python handles absolute paths on Windows? | |
267 expect(builder.normalize(r'\\..'), r'\\'); | |
268 expect(builder.normalize(r'\\..\..\..'), r'\\'); | |
269 expect(builder.normalize(r'\\..\../..\a'), r'\\a'); | |
270 expect(builder.normalize(r'c:\..'), r'c:\'); | |
271 expect(builder.normalize(r'A:/..\..\..'), r'A:\'); | |
272 expect(builder.normalize(r'b:\..\..\..\a'), r'b:\a'); | |
273 expect(builder.normalize(r'a\..'), '.'); | |
274 expect(builder.normalize(r'a\b\..'), 'a'); | |
275 expect(builder.normalize(r'a\..\b'), 'b'); | |
276 expect(builder.normalize(r'a\.\..\b'), 'b'); | |
277 expect(builder.normalize(r'a\b\c\..\..\d\e\..'), r'a\d'); | |
278 expect(builder.normalize(r'a\b\..\..\..\..\c'), r'..\..\c'); | |
279 }); | |
280 | |
281 test('removes trailing separators', () { | |
282 expect(builder.normalize(r'.\'), '.'); | |
283 expect(builder.normalize(r'.\\'), '.'); | |
284 expect(builder.normalize(r'a/'), 'a'); | |
285 expect(builder.normalize(r'a\b\'), r'a\b'); | |
286 expect(builder.normalize(r'a\b\\\'), r'a\b'); | |
287 }); | |
288 | |
289 test('normalizes separators', () { | |
290 expect(builder.normalize(r'a/b\c'), r'a\b\c'); | |
291 }); | |
292 }); | |
293 | |
294 group('relative', () { | |
295 group('from absolute root', () { | |
296 test('given absolute path in root', () { | |
297 expect(builder.relative(r'C:\'), r'..\..'); | |
298 expect(builder.relative(r'C:\root'), '..'); | |
299 expect(builder.relative(r'C:\root\path'), '.'); | |
300 expect(builder.relative(r'C:\root\path\a'), 'a'); | |
301 expect(builder.relative(r'C:\root\path\a\b.txt'), r'a\b.txt'); | |
302 expect(builder.relative(r'C:\root\a\b.txt'), r'..\a\b.txt'); | |
303 expect(builder.relative(r'C:/'), r'..\..'); | |
304 expect(builder.relative(r'C:/root'), '..'); | |
305 expect(builder.relative(r'c:\'), r'..\..'); | |
306 expect(builder.relative(r'c:\root'), '..'); | |
307 }); | |
308 | |
309 test('given absolute path outside of root', () { | |
310 expect(builder.relative(r'C:\a\b'), r'..\..\a\b'); | |
311 expect(builder.relative(r'C:\root\path\a'), 'a'); | |
312 expect(builder.relative(r'C:\root\path\a\b.txt'), r'a\b.txt'); | |
313 expect(builder.relative(r'C:\root\a\b.txt'), r'..\a\b.txt'); | |
314 expect(builder.relative(r'C:/a/b'), r'..\..\a\b'); | |
315 expect(builder.relative(r'C:/root/path/a'), 'a'); | |
316 expect(builder.relative(r'c:\a\b'), r'..\..\a\b'); | |
317 expect(builder.relative(r'c:\root\path\a'), 'a'); | |
318 }); | |
319 | |
320 test('given absolute path on different drive', () { | |
321 expect(builder.relative(r'D:\a\b'), r'D:\a\b'); | |
322 }); | |
323 | |
324 test('given relative path', () { | |
325 // The path is considered relative to the root, so it basically just | |
326 // normalizes. | |
327 expect(builder.relative(''), '.'); | |
328 expect(builder.relative('.'), '.'); | |
329 expect(builder.relative('a'), 'a'); | |
330 expect(builder.relative(r'a\b.txt'), r'a\b.txt'); | |
331 expect(builder.relative(r'..\a\b.txt'), r'..\a\b.txt'); | |
332 expect(builder.relative(r'a\.\b\..\c.txt'), r'a\c.txt'); | |
333 }); | |
334 | |
335 // Regression | |
336 test('from root-only path', () { | |
337 expect(builder.relative(r'C:\', from: r'C:\'), '.'); | |
338 expect(builder.relative(r'C:\root\path', from: r'C:\'), r'root\path'); | |
339 }); | |
340 }); | |
341 | |
342 group('from relative root', () { | |
343 var r = new path.Builder(style: path.Style.windows, root: r'foo\bar'); | |
344 | |
345 test('given absolute path', () { | |
346 expect(r.relative(r'C:\'), equals(r'C:\')); | |
347 expect(r.relative(r'C:\a\b'), equals(r'C:\a\b')); | |
348 }); | |
349 | |
350 test('given relative path', () { | |
351 // The path is considered relative to the root, so it basically just | |
352 // normalizes. | |
353 expect(r.relative(''), '.'); | |
354 expect(r.relative('.'), '.'); | |
355 expect(r.relative('..'), '..'); | |
356 expect(r.relative('a'), 'a'); | |
357 expect(r.relative(r'a\b.txt'), r'a\b.txt'); | |
358 expect(r.relative(r'..\a/b.txt'), r'..\a\b.txt'); | |
359 expect(r.relative(r'a\./b\../c.txt'), r'a\c.txt'); | |
360 }); | |
361 }); | |
362 | |
363 test('from a root with extension', () { | |
364 var r = new path.Builder(style: path.Style.windows, root: r'C:\dir.ext'); | |
365 expect(r.relative(r'C:\dir.ext\file'), 'file'); | |
366 }); | |
367 | |
368 test('with a root parameter', () { | |
369 expect(builder.relative(r'C:\foo\bar\baz', from: r'C:\foo\bar'), | |
370 equals('baz')); | |
371 expect(builder.relative('..', from: r'C:\foo\bar'), | |
372 equals(r'..\..\root')); | |
373 expect(builder.relative('..', from: r'D:\foo\bar'), equals(r'C:\root')); | |
374 expect(builder.relative(r'C:\foo\bar\baz', from: r'foo\bar'), | |
375 equals(r'..\..\..\..\foo\bar\baz')); | |
376 expect(builder.relative('..', from: r'foo\bar'), equals(r'..\..\..')); | |
377 }); | |
378 | |
379 test('with a root parameter and a relative root', () { | |
380 var r = new path.Builder(style: path.Style.windows, root: r'relative\root'
); | |
381 expect(r.relative(r'C:\foo\bar\baz', from: r'C:\foo\bar'), equals('baz')); | |
382 expect(() => r.relative('..', from: r'C:\foo\bar'), throwsArgumentError); | |
383 expect(r.relative(r'C:\foo\bar\baz', from: r'foo\bar'), | |
384 equals(r'C:\foo\bar\baz')); | |
385 expect(r.relative('..', from: r'foo\bar'), equals(r'..\..\..')); | |
386 }); | |
387 | |
388 test('given absolute with different root prefix', () { | |
389 expect(builder.relative(r'D:\a\b'), r'D:\a\b'); | |
390 expect(builder.relative(r'\\a\b'), r'\\a\b'); | |
391 }); | |
392 | |
393 test('from a . root', () { | |
394 var r = new path.Builder(style: path.Style.windows, root: '.'); | |
395 expect(r.relative(r'C:\foo\bar\baz'), equals(r'C:\foo\bar\baz')); | |
396 expect(r.relative(r'foo\bar\baz'), equals(r'foo\bar\baz')); | |
397 }); | |
398 }); | |
399 | |
400 group('resolve', () { | |
401 test('allows up to seven parts', () { | |
402 expect(builder.resolve('a'), r'C:\root\path\a'); | |
403 expect(builder.resolve('a', 'b'), r'C:\root\path\a\b'); | |
404 expect(builder.resolve('a', 'b', 'c'), r'C:\root\path\a\b\c'); | |
405 expect(builder.resolve('a', 'b', 'c', 'd'), r'C:\root\path\a\b\c\d'); | |
406 expect(builder.resolve('a', 'b', 'c', 'd', 'e'), | |
407 r'C:\root\path\a\b\c\d\e'); | |
408 expect(builder.resolve('a', 'b', 'c', 'd', 'e', 'f'), | |
409 r'C:\root\path\a\b\c\d\e\f'); | |
410 expect(builder.resolve('a', 'b', 'c', 'd', 'e', 'f', 'g'), | |
411 r'C:\root\path\a\b\c\d\e\f\g'); | |
412 }); | |
413 | |
414 test('does not add separator if a part ends in one', () { | |
415 expect(builder.resolve(r'a\', 'b', r'c\', 'd'), r'C:\root\path\a\b\c\d'); | |
416 expect(builder.resolve('a/', 'b'), r'C:\root\path\a/b'); | |
417 }); | |
418 | |
419 test('ignores parts before an absolute path', () { | |
420 expect(builder.resolve('a', '/b', '/c', 'd'), r'C:\root\path\a/b/c\d'); | |
421 expect(builder.resolve('a', r'c:\b', 'c', 'd'), r'c:\b\c\d'); | |
422 expect(builder.resolve('a', r'\\b', r'\\c', 'd'), r'\\c\d'); | |
423 }); | |
424 }); | |
425 | |
426 test('withoutExtension', () { | |
427 expect(builder.withoutExtension(''), ''); | |
428 expect(builder.withoutExtension('a'), 'a'); | |
429 expect(builder.withoutExtension('.a'), '.a'); | |
430 expect(builder.withoutExtension('a.b'), 'a'); | |
431 expect(builder.withoutExtension(r'a\b.c'), r'a\b'); | |
432 expect(builder.withoutExtension(r'a\b.c.d'), r'a\b.c'); | |
433 expect(builder.withoutExtension(r'a\'), r'a\'); | |
434 expect(builder.withoutExtension(r'a\b\'), r'a\b\'); | |
435 expect(builder.withoutExtension(r'a\.'), r'a\.'); | |
436 expect(builder.withoutExtension(r'a\.b'), r'a\.b'); | |
437 expect(builder.withoutExtension(r'a.b\c'), r'a.b\c'); | |
438 expect(builder.withoutExtension(r'a/b.c/d'), r'a/b.c/d'); | |
439 expect(builder.withoutExtension(r'a\b/c'), r'a\b/c'); | |
440 expect(builder.withoutExtension(r'a\b/c.d'), r'a\b/c'); | |
441 expect(builder.withoutExtension(r'a.b/c'), r'a.b/c'); | |
442 expect(builder.withoutExtension(r'a\b.c\'), r'a\b\'); | |
443 }); | |
444 | |
445 test('fromUri', () { | |
446 expect(builder.fromUri(Uri.parse('file:///C:/path/to/foo')), | |
447 r'C:\path\to\foo'); | |
448 expect(builder.fromUri(Uri.parse('file://hostname/path/to/foo')), | |
449 r'\\hostname\path\to\foo'); | |
450 expect(builder.fromUri(Uri.parse('file:///C:/')), r'C:\'); | |
451 expect(builder.fromUri(Uri.parse('file://hostname/')), r'\\hostname\'); | |
452 expect(builder.fromUri(Uri.parse('foo/bar')), r'foo\bar'); | |
453 expect(builder.fromUri(Uri.parse('/C:/path/to/foo')), r'C:\path\to\foo'); | |
454 expect(builder.fromUri(Uri.parse('///C:/path/to/foo')), r'C:\path\to\foo'); | |
455 expect(builder.fromUri(Uri.parse('//hostname/path/to/foo')), | |
456 r'\\hostname\path\to\foo'); | |
457 expect(builder.fromUri(Uri.parse('file:///C:/path/to/foo%23bar')), | |
458 r'C:\path\to\foo#bar'); | |
459 expect(builder.fromUri(Uri.parse('file://hostname/path/to/foo%23bar')), | |
460 r'\\hostname\path\to\foo#bar'); | |
461 expect(() => builder.fromUri(Uri.parse('http://dartlang.org')), | |
462 throwsArgumentError); | |
463 }); | |
464 | |
465 test('toUri', () { | |
466 expect(builder.toUri(r'C:\path\to\foo'), | |
467 Uri.parse('file:///C:/path/to/foo')); | |
468 expect(builder.toUri(r'C:\path\to\foo\'), | |
469 Uri.parse('file:///C:/path/to/foo/')); | |
470 expect(builder.toUri(r'C:\'), Uri.parse('file:///C:/')); | |
471 expect(builder.toUri(r'\\hostname\'), Uri.parse('file://hostname/')); | |
472 expect(builder.toUri(r'foo\bar'), Uri.parse('foo/bar')); | |
473 expect(builder.toUri(r'C:\path\to\foo#bar'), | |
474 Uri.parse('file:///C:/path/to/foo%23bar')); | |
475 expect(builder.toUri(r'\\hostname\path\to\foo#bar'), | |
476 Uri.parse('file://hostname/path/to/foo%23bar')); | |
477 }); | |
478 } | |
OLD | NEW |