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