Flutter Engine
The Flutter Engine
Loading...
Searching...
No Matches
uri_test.cc
Go to the documentation of this file.
1// Copyright (c) 2016, 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#include "vm/uri.h"
6#include "vm/unit_test.h"
7
8namespace dart {
9
10TEST_CASE(ParseUri_WithScheme_NoQueryNoUser) {
11 ParsedUri uri;
12 EXPECT(ParseUri("foo://example.com:8042/over/there", &uri));
13 EXPECT_STREQ("foo", uri.scheme);
14 EXPECT(uri.userinfo == nullptr);
15 EXPECT_STREQ("example.com", uri.host);
16 EXPECT_STREQ("8042", uri.port);
17 EXPECT_STREQ("/over/there", uri.path);
18 EXPECT(uri.query == nullptr);
19 EXPECT(uri.fragment == nullptr);
20}
21
22TEST_CASE(ParseUri_WithScheme_WithQuery) {
23 ParsedUri uri;
24 EXPECT(ParseUri("foo://example.com:8042/over/there?name=ferret", &uri));
25 EXPECT_STREQ("foo", uri.scheme);
26 EXPECT(uri.userinfo == nullptr);
27 EXPECT_STREQ("example.com", uri.host);
28 EXPECT_STREQ("8042", uri.port);
29 EXPECT_STREQ("/over/there", uri.path);
30 EXPECT_STREQ("name=ferret", uri.query);
31 EXPECT(uri.fragment == nullptr);
32}
33
34TEST_CASE(ParseUri_WithScheme_WithFragment) {
35 ParsedUri uri;
36 EXPECT(ParseUri("foo://example.com:8042/over/there#fragment", &uri));
37 EXPECT_STREQ("foo", uri.scheme);
38 EXPECT(uri.userinfo == nullptr);
39 EXPECT_STREQ("example.com", uri.host);
40 EXPECT_STREQ("8042", uri.port);
41 EXPECT_STREQ("/over/there", uri.path);
42 EXPECT(uri.query == nullptr);
43 EXPECT_STREQ("fragment", uri.fragment);
44}
45
46TEST_CASE(ParseUri_WithScheme_WithQueryWithFragment) {
47 ParsedUri uri;
48 EXPECT(
49 ParseUri("foo://example.com:8042/over/there?name=ferret#fragment", &uri));
50 EXPECT_STREQ("foo", uri.scheme);
51 EXPECT(uri.userinfo == nullptr);
52 EXPECT_STREQ("example.com", uri.host);
53 EXPECT_STREQ("8042", uri.port);
54 EXPECT_STREQ("/over/there", uri.path);
55 EXPECT_STREQ("name=ferret", uri.query);
56 EXPECT_STREQ("fragment", uri.fragment);
57}
58
59TEST_CASE(ParseUri_WithScheme_WithUser) {
60 ParsedUri uri;
61 EXPECT(ParseUri("foo://user@example.com:8042/over/there", &uri));
62 EXPECT_STREQ("foo", uri.scheme);
63 EXPECT_STREQ("user", uri.userinfo);
64 EXPECT_STREQ("example.com", uri.host);
65 EXPECT_STREQ("8042", uri.port);
66 EXPECT_STREQ("/over/there", uri.path);
67 EXPECT(uri.query == nullptr);
68 EXPECT(uri.fragment == nullptr);
69}
70
71TEST_CASE(ParseUri_WithScheme_ShortPath) {
72 ParsedUri uri;
73 EXPECT(ParseUri("foo://example.com:8042/", &uri));
74 EXPECT_STREQ("foo", uri.scheme);
75 EXPECT(uri.userinfo == nullptr);
76 EXPECT_STREQ("example.com", uri.host);
77 EXPECT_STREQ("8042", uri.port);
78 EXPECT_STREQ("/", uri.path);
79 EXPECT(uri.query == nullptr);
80 EXPECT(uri.fragment == nullptr);
81}
82
83TEST_CASE(ParseUri_WithScheme_EmptyPath) {
84 ParsedUri uri;
85 EXPECT(ParseUri("foo://example.com:8042", &uri));
86 EXPECT_STREQ("foo", uri.scheme);
87 EXPECT(uri.userinfo == nullptr);
88 EXPECT_STREQ("example.com", uri.host);
89 EXPECT_STREQ("8042", uri.port);
90 EXPECT_STREQ("", uri.path);
91 EXPECT(uri.query == nullptr);
92 EXPECT(uri.fragment == nullptr);
93}
94
95TEST_CASE(ParseUri_WithScheme_Rootless1) {
96 ParsedUri uri;
97 EXPECT(ParseUri("foo:here", &uri));
98 EXPECT_STREQ("foo", uri.scheme);
99 EXPECT(uri.userinfo == nullptr);
100 EXPECT(uri.host == nullptr);
101 EXPECT(uri.port == nullptr);
102 EXPECT_STREQ("here", uri.path);
103 EXPECT(uri.query == nullptr);
104 EXPECT(uri.fragment == nullptr);
105}
106
107TEST_CASE(ParseUri_WithScheme_Rootless2) {
108 ParsedUri uri;
109 EXPECT(ParseUri("foo:or/here", &uri));
110 EXPECT_STREQ("foo", uri.scheme);
111 EXPECT(uri.userinfo == nullptr);
112 EXPECT(uri.host == nullptr);
113 EXPECT(uri.port == nullptr);
114 EXPECT_STREQ("or/here", uri.path);
115 EXPECT(uri.query == nullptr);
116 EXPECT(uri.fragment == nullptr);
117}
118
119TEST_CASE(ParseUri_NoScheme_AbsPath_WithAuthority) {
120 ParsedUri uri;
121 EXPECT(ParseUri("//example.com:8042/over/there", &uri));
122 EXPECT(uri.scheme == nullptr);
123 EXPECT(uri.userinfo == nullptr);
124 EXPECT_STREQ("example.com", uri.host);
125 EXPECT_STREQ("8042", uri.port);
126 EXPECT_STREQ("/over/there", uri.path);
127 EXPECT(uri.query == nullptr);
128 EXPECT(uri.fragment == nullptr);
129}
130
131TEST_CASE(ParseUri_NoScheme_AbsPath_NoAuthority) {
132 ParsedUri uri;
133 EXPECT(ParseUri("/over/there", &uri));
134 EXPECT(uri.scheme == nullptr);
135 EXPECT(uri.userinfo == nullptr);
136 EXPECT(uri.host == nullptr);
137 EXPECT(uri.port == nullptr);
138 EXPECT_STREQ("/over/there", uri.path);
139 EXPECT(uri.query == nullptr);
140 EXPECT(uri.fragment == nullptr);
141}
142
143// Colons are permitted in path segments, in many cases.
144TEST_CASE(ParseUri_NoScheme_AbsPath_StrayColon) {
145 ParsedUri uri;
146 EXPECT(ParseUri("/ov:er/there", &uri));
147 EXPECT(uri.scheme == nullptr);
148 EXPECT(uri.userinfo == nullptr);
149 EXPECT(uri.host == nullptr);
150 EXPECT(uri.port == nullptr);
151 EXPECT_STREQ("/ov:er/there", uri.path);
152 EXPECT(uri.query == nullptr);
153}
154
155TEST_CASE(ParseUri_NoScheme_Rootless1) {
156 ParsedUri uri;
157 EXPECT(ParseUri("here", &uri));
158 EXPECT(uri.scheme == nullptr);
159 EXPECT(uri.userinfo == nullptr);
160 EXPECT(uri.host == nullptr);
161 EXPECT(uri.port == nullptr);
162 EXPECT_STREQ("here", uri.path);
163 EXPECT(uri.query == nullptr);
164 EXPECT(uri.fragment == nullptr);
165}
166
167TEST_CASE(ParseUri_NoScheme_Rootless2) {
168 ParsedUri uri;
169 EXPECT(ParseUri("or/here", &uri));
170 EXPECT(uri.scheme == nullptr);
171 EXPECT(uri.userinfo == nullptr);
172 EXPECT(uri.host == nullptr);
173 EXPECT(uri.port == nullptr);
174 EXPECT_STREQ("or/here", uri.path);
175 EXPECT(uri.query == nullptr);
176 EXPECT(uri.fragment == nullptr);
177}
178
179TEST_CASE(ParseUri_NoScheme_Empty) {
180 ParsedUri uri;
181 EXPECT(ParseUri("", &uri));
182 EXPECT(uri.scheme == nullptr);
183 EXPECT(uri.userinfo == nullptr);
184 EXPECT(uri.host == nullptr);
185 EXPECT(uri.port == nullptr);
186 EXPECT_STREQ("", uri.path);
187 EXPECT(uri.query == nullptr);
188 EXPECT(uri.fragment == nullptr);
189}
190
191TEST_CASE(ParseUri_NoScheme_QueryOnly) {
192 ParsedUri uri;
193 EXPECT(ParseUri("?name=ferret", &uri));
194 EXPECT(uri.scheme == nullptr);
195 EXPECT(uri.userinfo == nullptr);
196 EXPECT(uri.host == nullptr);
197 EXPECT(uri.port == nullptr);
198 EXPECT_STREQ("", uri.path);
199 EXPECT_STREQ("name=ferret", uri.query);
200 EXPECT(uri.fragment == nullptr);
201}
202
203TEST_CASE(ParseUri_NoScheme_FragmentOnly) {
204 ParsedUri uri;
205 EXPECT(ParseUri("#fragment", &uri));
206 EXPECT(uri.scheme == nullptr);
207 EXPECT(uri.userinfo == nullptr);
208 EXPECT(uri.host == nullptr);
209 EXPECT(uri.port == nullptr);
210 EXPECT_STREQ("", uri.path);
211 EXPECT(uri.query == nullptr);
212 EXPECT_STREQ("fragment", uri.fragment);
213}
214
215TEST_CASE(ParseUri_LowerCaseScheme) {
216 ParsedUri uri;
217 EXPECT(ParseUri("ScHeMe:path", &uri));
218 EXPECT_STREQ("scheme", uri.scheme);
219 EXPECT(uri.userinfo == nullptr);
220 EXPECT(uri.host == nullptr);
221 EXPECT(uri.port == nullptr);
222 EXPECT_STREQ("path", uri.path);
223 EXPECT(uri.query == nullptr);
224 EXPECT(uri.fragment == nullptr);
225}
226
227TEST_CASE(ParseUri_NormalizeEscapes_PathQueryFragment) {
228 ParsedUri uri;
229 EXPECT(ParseUri("scheme:/This%09Is A P%61th?This%09Is A Qu%65ry#A Fr%61gment",
230 &uri));
231 EXPECT_STREQ("scheme", uri.scheme);
232 EXPECT(uri.userinfo == nullptr);
233 EXPECT(uri.host == nullptr);
234 EXPECT(uri.port == nullptr);
235 EXPECT_STREQ("/This%09Is%20A%20Path", uri.path);
236 EXPECT_STREQ("This%09Is%20A%20Query", uri.query);
237 EXPECT_STREQ("A%20Fragment", uri.fragment);
238}
239
240TEST_CASE(ParseUri_NormalizeEscapes_UppercaseEscapesPreferred) {
241 ParsedUri uri;
242 EXPECT(ParseUri("scheme:/%1b%1B", &uri));
243 EXPECT_STREQ("scheme", uri.scheme);
244 EXPECT(uri.userinfo == nullptr);
245 EXPECT(uri.host == nullptr);
246 EXPECT(uri.port == nullptr);
247 EXPECT_STREQ("/%1B%1B", uri.path);
248 EXPECT(uri.query == nullptr);
249 EXPECT(uri.fragment == nullptr);
250}
251
252TEST_CASE(ParseUri_NormalizeEscapes_Authority) {
253 ParsedUri uri;
254 EXPECT(ParseUri("scheme://UsEr N%61%4de@h%4FsT.c%6fm:80/", &uri));
255 EXPECT_STREQ("scheme", uri.scheme);
256 EXPECT_STREQ("UsEr%20NaMe", uri.userinfo); // Normalized, case preserved.
257 EXPECT_STREQ("host.com", uri.host); // Normalized, lower-cased.
258 EXPECT_STREQ("80", uri.port);
259 EXPECT_STREQ("/", uri.path);
260 EXPECT(uri.query == nullptr);
261 EXPECT(uri.fragment == nullptr);
262}
263
264TEST_CASE(ParseUri_NormalizeEscapes_UppercaseEscapeInHost) {
265 ParsedUri uri;
266 EXPECT(ParseUri("scheme://tEst%1b/", &uri));
267 EXPECT_STREQ("scheme", uri.scheme);
268 EXPECT(uri.userinfo == nullptr);
269 EXPECT_STREQ("test%1B", uri.host); // Notice that %1B is upper-cased.
270 EXPECT(uri.port == nullptr);
271 EXPECT_STREQ("/", uri.path);
272 EXPECT(uri.query == nullptr);
273 EXPECT(uri.fragment == nullptr);
274}
275
276TEST_CASE(ParseUri_BrokenEscapeSequence) {
277 ParsedUri uri;
278 EXPECT(ParseUri("scheme:/%1g", &uri));
279 EXPECT_STREQ("scheme", uri.scheme);
280 EXPECT(uri.userinfo == nullptr);
281 EXPECT(uri.host == nullptr);
282 EXPECT(uri.port == nullptr);
283 EXPECT_STREQ("/%1g", uri.path); // Broken sequence is unchanged.
284 EXPECT(uri.query == nullptr);
285 EXPECT(uri.fragment == nullptr);
286}
287
288TEST_CASE(ResolveUri_WithScheme_NoAuthorityNoQuery) {
289 const char* target_uri;
290 EXPECT(ResolveUri("rscheme:/ref/path",
291 "bscheme://buser@bhost:11/base/path?baseQuery",
292 &target_uri));
293 EXPECT_STREQ("rscheme:/ref/path", target_uri);
294}
295
296TEST_CASE(ResolveUri_WithScheme_WithAuthorityWithQuery) {
297 const char* target_uri;
298 EXPECT(ResolveUri("rscheme://ruser@rhost:22/ref/path?refQuery",
299 "bscheme://buser@bhost:11/base/path?baseQuery",
300 &target_uri));
301 EXPECT_STREQ("rscheme://ruser@rhost:22/ref/path?refQuery", target_uri);
302}
303
304TEST_CASE(ResolveUri_NoScheme_WithAuthority) {
305 const char* target_uri;
306 EXPECT(ResolveUri("//ruser@rhost:22/ref/path",
307 "bscheme://buser@bhost:11/base/path?baseQuery",
308 &target_uri));
309 EXPECT_STREQ("bscheme://ruser@rhost:22/ref/path", target_uri);
310}
311
312TEST_CASE(ResolveUri_NoSchemeNoAuthority_AbsolutePath) {
313 const char* target_uri;
314 EXPECT(ResolveUri("/ref/path", "bscheme://buser@bhost:11/base/path?baseQuery",
315 &target_uri));
316 EXPECT_STREQ("bscheme://buser@bhost:11/ref/path", target_uri);
317}
318
319TEST_CASE(ResolveUri_NoSchemeNoAuthority_RelativePath) {
320 const char* target_uri;
321 EXPECT(ResolveUri("ref/path", "bscheme://buser@bhost:11/base/path?baseQuery",
322 &target_uri));
323 EXPECT_STREQ("bscheme://buser@bhost:11/base/ref/path", target_uri);
324}
325
326TEST_CASE(ResolveUri_NoSchemeNoAuthority_RelativePathEmptyBasePath) {
327 const char* target_uri;
328 EXPECT(ResolveUri("ref/path", "bscheme://buser@bhost:11", &target_uri));
329 EXPECT_STREQ("bscheme://buser@bhost:11/ref/path", target_uri);
330}
331
332TEST_CASE(ResolveUri_NoSchemeNoAuthority_RelativePathWeirdBasePath) {
333 const char* target_uri;
334 EXPECT(ResolveUri("ref/path", "bscheme:base", &target_uri));
335 EXPECT_STREQ("bscheme:ref/path", target_uri);
336}
337
338TEST_CASE(ResolveUri_NoSchemeNoAuthority_EmptyPath) {
339 const char* target_uri;
340 EXPECT(ResolveUri("",
341 "bscheme://buser@bhost:11/base/path?baseQuery#bfragment",
342 &target_uri));
343 // Note that we drop the base fragment from the resolved uri.
344 EXPECT_STREQ("bscheme://buser@bhost:11/base/path?baseQuery", target_uri);
345}
346
347TEST_CASE(ResolveUri_NoSchemeNoAuthority_EmptyPathWithQuery) {
348 const char* target_uri;
349 EXPECT(ResolveUri("?refQuery",
350 "bscheme://buser@bhost:11/base/path?baseQuery#bfragment",
351 &target_uri));
352 EXPECT_STREQ("bscheme://buser@bhost:11/base/path?refQuery", target_uri);
353}
354
355TEST_CASE(ResolveUri_NoSchemeNoAuthority_EmptyPathWithFragment) {
356 const char* target_uri;
357 EXPECT(ResolveUri("#rfragment",
358 "bscheme://buser@bhost:11/base/path?baseQuery#bfragment",
359 &target_uri));
360 EXPECT_STREQ("bscheme://buser@bhost:11/base/path?baseQuery#rfragment",
361 target_uri);
362}
363
364TEST_CASE(ResolveUri_RemoveDots_RemoveOneDotSegment) {
365 const char* target_uri;
366 EXPECT(ResolveUri("./refpath", "scheme://auth/a/b/c/d", &target_uri));
367 EXPECT_STREQ("scheme://auth/a/b/c/refpath", target_uri);
368}
369
370TEST_CASE(ResolveUri_RemoveDots_RemoveTwoDotSegments) {
371 const char* target_uri;
372 EXPECT(ResolveUri("././refpath", "scheme://auth/a/b/c/d", &target_uri));
373 EXPECT_STREQ("scheme://auth/a/b/c/refpath", target_uri);
374}
375
376TEST_CASE(ResolveUri_RemoveDots_RemoveOneDotDotSegment) {
377 const char* target_uri;
378 EXPECT(ResolveUri("../refpath", "scheme://auth/a/b/c/d", &target_uri));
379 EXPECT_STREQ("scheme://auth/a/b/refpath", target_uri);
380}
381
382TEST_CASE(ResolveUri_RemoveDots_RemoveTwoDotDotSegments) {
383 const char* target_uri;
384 EXPECT(ResolveUri("../../refpath", "scheme://auth/a/b/c/d", &target_uri));
385 EXPECT_STREQ("scheme://auth/a/refpath", target_uri);
386}
387
388TEST_CASE(ResolveUri_RemoveDots_RemoveTooManyDotDotSegments) {
389 const char* target_uri;
390 EXPECT(ResolveUri("../../../../../../../../../refpath",
391 "scheme://auth/a/b/c/d", &target_uri));
392 EXPECT_STREQ("scheme://auth/refpath", target_uri);
393}
394
395TEST_CASE(ResolveUri_RemoveDots_RemoveDotSegmentsNothingLeft1) {
396 const char* target_uri;
397 EXPECT(ResolveUri("../../../../..", "scheme://auth/a/b/c/d", &target_uri));
398 EXPECT_STREQ("scheme://auth/", target_uri);
399}
400
401TEST_CASE(ResolveUri_RemoveDots_RemoveDotSegmentsNothingLeft2) {
402 const char* target_uri;
403 EXPECT(ResolveUri(".", "scheme://auth/", &target_uri));
404 EXPECT_STREQ("scheme://auth/", target_uri);
405}
406
407TEST_CASE(ResolveUri_RemoveDots_RemoveDotSegmentsInitialPrefix) {
408 const char* target_uri;
409 EXPECT(ResolveUri("../../../../refpath", "scheme://auth", &target_uri));
410 EXPECT_STREQ("scheme://auth/refpath", target_uri);
411}
412
413TEST_CASE(ResolveUri_RemoveDots_RemoveDotSegmentsMixed) {
414 const char* target_uri;
415 EXPECT(ResolveUri("../../1/./2/../3/4/../5/././6/../7",
416 "scheme://auth/a/b/c/d/e", &target_uri));
417 EXPECT_STREQ("scheme://auth/a/b/1/3/5/7", target_uri);
418}
419
420TEST_CASE(ResolveUri_NormalizeEscapes_PathQueryFragment) {
421 const char* target_uri;
422 EXPECT(ResolveUri("#A Fr%61gment",
423 "scheme:/This%09Is A P%61th?This%09Is A Qu%65ry",
424 &target_uri));
425 EXPECT_STREQ(
426 "scheme:/This%09Is%20A%20Path?This%09Is%20A%20Query#A%20Fragment",
427 target_uri);
428}
429
430TEST_CASE(ResolveUri_NormalizeEscapes_UppercaseHexPreferred) {
431 const char* target_uri;
432 EXPECT(ResolveUri("", "scheme:/%1b%1B", &target_uri));
433 EXPECT_STREQ("scheme:/%1B%1B", target_uri);
434}
435
436TEST_CASE(ResolveUri_NormalizeEscapes_Authority) {
437 const char* target_uri;
438 EXPECT(
439 ResolveUri("", "scheme://UsEr N%61%4de@h%4FsT.c%6fm:80/", &target_uri));
440 // userinfo is normalized and case is preserved. host is normalized
441 // and lower-cased.
442 EXPECT_STREQ("scheme://UsEr%20NaMe@host.com:80/", target_uri);
443}
444
445TEST_CASE(ResolveUri_NormalizeEscapes_BrokenEscapeSequence) {
446 const char* target_uri;
447 EXPECT(ResolveUri("", "scheme:/%1g", &target_uri));
448 // We don't change broken escape sequences.
449 EXPECT_STREQ("scheme:/%1g", target_uri);
450}
451
452TEST_CASE(ResolveUri_DataUri) {
453 const char* data_uri =
454 "data:application/"
455 "dart;charset=utf-8,%20%20%20%20%20%20%20%20import%20%22dart:isolate%22;%"
456 "0A%0A%20%20%20%20%20%20%20%20import%20%22package:stream_channel/"
457 "stream_channel.dart%22;%0A%0A%20%20%20%20%20%20%20%20import%20%"
458 "22package:test/src/runner/plugin/"
459 "remote_platform_helpers.dart%22;%0A%20%20%20%20%20%20%20%20import%20%"
460 "22package:test/src/runner/vm/"
461 "catch_isolate_errors.dart%22;%0A%0A%20%20%20%20%20%20%20%20import%20%"
462 "22file:///home/sra/xxxx/dev_compiler/test/"
463 "all_tests.dart%22%20as%20test;%0A%0A%20%20%20%20%20%20%20%20void%20main("
464 "_,%20SendPort%20message)%20%7B%0A%20%20%20%20%20%20%20%20%20%20var%"
465 "20channel%20=%20serializeSuite(()%20%7B%0A%20%20%20%20%20%20%20%20%20%"
466 "20%20%20catchIsolateErrors();%0A%20%20%20%20%20%20%20%20%20%20%20%"
467 "20return%20test.main;%0A%20%20%20%20%20%20%20%20%20%20%7D);%0A%20%20%20%"
468 "20%20%20%20%20%20%20new%20IsolateChannel.connectSend(message).pipe("
469 "channel);%0A%20%20%20%20%20%20%20%20%7D%0A%20%20%20%20%20%20";
470
471 const char* target_uri;
472 EXPECT(ResolveUri(data_uri,
473 "bscheme://buser@bhost:11/base/path?baseQuery#bfragment",
474 &target_uri));
475 EXPECT_STREQ(data_uri, target_uri);
476}
477
478// dart:core Uri allows for the base url to be relative (no scheme, no
479// authority, relative path) but this behavior is not in RFC 3986. We
480// do not implement this.
481TEST_CASE(ResolveUri_RelativeBase_NotImplemented) {
482 const char* target_uri;
483 EXPECT(!ResolveUri("../r1", "b1/b2", &target_uri));
484 EXPECT(target_uri == nullptr);
485
486 EXPECT(!ResolveUri("..", "b1/b2", &target_uri));
487 EXPECT(target_uri == nullptr);
488
489 EXPECT(!ResolveUri("../..", "b1/b2", &target_uri));
490 EXPECT(target_uri == nullptr);
491
492 EXPECT(!ResolveUri("../../..", "b1/b2", &target_uri));
493 EXPECT(target_uri == nullptr);
494
495 EXPECT(!ResolveUri("../../../r1", "b1/b2", &target_uri));
496 EXPECT(target_uri == nullptr);
497
498 EXPECT(!ResolveUri("../r1", "../../b1/b2/b3", &target_uri));
499 EXPECT(target_uri == nullptr);
500
501 EXPECT(!ResolveUri("../../../r1", "../../b1/b2/b3", &target_uri));
502 EXPECT(target_uri == nullptr);
503}
504
505static const char* TestResolve(const char* base_uri, const char* uri) {
506 const char* target_uri;
507 EXPECT(ResolveUri(uri, base_uri, &target_uri));
508 return target_uri;
509}
510
511// This test is ported from sdk/tests/corelib/uri_test.dart (testUriPerRFCs).
512TEST_CASE(ResolveUri_TestUriPerRFCs) {
513 const char* base = "http://a/b/c/d;p?q";
514
515 // From RFC 3986
516 EXPECT_STREQ("g:h", TestResolve(base, "g:h"));
517 EXPECT_STREQ("http://a/b/c/g", TestResolve(base, "g"));
518 EXPECT_STREQ("http://a/b/c/g", TestResolve(base, "./g"));
519 EXPECT_STREQ("http://a/b/c/g/", TestResolve(base, "g/"));
520 EXPECT_STREQ("http://a/g", TestResolve(base, "/g"));
521 EXPECT_STREQ("http://g", TestResolve(base, "//g"));
522 EXPECT_STREQ("http://a/b/c/d;p?y", TestResolve(base, "?y"));
523 EXPECT_STREQ("http://a/b/c/g?y", TestResolve(base, "g?y"));
524 EXPECT_STREQ("http://a/b/c/d;p?q#s", TestResolve(base, "#s"));
525 EXPECT_STREQ("http://a/b/c/g#s", TestResolve(base, "g#s"));
526 EXPECT_STREQ("http://a/b/c/g?y#s", TestResolve(base, "g?y#s"));
527 EXPECT_STREQ("http://a/b/c/;x", TestResolve(base, ";x"));
528 EXPECT_STREQ("http://a/b/c/g;x", TestResolve(base, "g;x"));
529 EXPECT_STREQ("http://a/b/c/g;x?y#s", TestResolve(base, "g;x?y#s"));
530 EXPECT_STREQ("http://a/b/c/d;p?q", TestResolve(base, ""));
531 EXPECT_STREQ("http://a/b/c/", TestResolve(base, "."));
532 EXPECT_STREQ("http://a/b/c/", TestResolve(base, "./"));
533 EXPECT_STREQ("http://a/b/", TestResolve(base, ".."));
534 EXPECT_STREQ("http://a/b/", TestResolve(base, "../"));
535 EXPECT_STREQ("http://a/b/g", TestResolve(base, "../g"));
536 EXPECT_STREQ("http://a/", TestResolve(base, "../.."));
537 EXPECT_STREQ("http://a/", TestResolve(base, "../../"));
538 EXPECT_STREQ("http://a/g", TestResolve(base, "../../g"));
539 EXPECT_STREQ("http://a/g", TestResolve(base, "../../../g"));
540 EXPECT_STREQ("http://a/g", TestResolve(base, "../../../../g"));
541 EXPECT_STREQ("http://a/g", TestResolve(base, "/./g"));
542 EXPECT_STREQ("http://a/g", TestResolve(base, "/../g"));
543 EXPECT_STREQ("http://a/b/c/g.", TestResolve(base, "g."));
544 EXPECT_STREQ("http://a/b/c/.g", TestResolve(base, ".g"));
545 EXPECT_STREQ("http://a/b/c/g..", TestResolve(base, "g.."));
546 EXPECT_STREQ("http://a/b/c/..g", TestResolve(base, "..g"));
547 EXPECT_STREQ("http://a/b/g", TestResolve(base, "./../g"));
548 EXPECT_STREQ("http://a/b/c/g/", TestResolve(base, "./g/."));
549 EXPECT_STREQ("http://a/b/c/g/h", TestResolve(base, "g/./h"));
550 EXPECT_STREQ("http://a/b/c/h", TestResolve(base, "g/../h"));
551 EXPECT_STREQ("http://a/b/c/g;x=1/y", TestResolve(base, "g;x=1/./y"));
552 EXPECT_STREQ("http://a/b/c/y", TestResolve(base, "g;x=1/../y"));
553 EXPECT_STREQ("http://a/b/c/g?y/./x", TestResolve(base, "g?y/./x"));
554 EXPECT_STREQ("http://a/b/c/g?y/../x", TestResolve(base, "g?y/../x"));
555 EXPECT_STREQ("http://a/b/c/g#s/./x", TestResolve(base, "g#s/./x"));
556 EXPECT_STREQ("http://a/b/c/g#s/../x", TestResolve(base, "g#s/../x"));
557 EXPECT_STREQ("http:g", TestResolve(base, "http:g"));
558
559 // Additional tests (not from RFC 3986).
560 EXPECT_STREQ("http://a/b/g;p/h;s", TestResolve(base, "../g;p/h;s"));
561
562 base = "s:a/b";
563 EXPECT_STREQ("s:/c", TestResolve(base, "../c"));
564}
565
566// This test is ported from sdk/tests/corelib/uri_test.dart (testResolvePath).
567TEST_CASE(ResolveUri_MoreDotSegmentTests) {
568 const char* base = "/";
569 EXPECT_STREQ("/a/g", TestResolve(base, "/a/b/c/./../../g"));
570 EXPECT_STREQ("/a/g", TestResolve(base, "/a/b/c/./../../g"));
571 EXPECT_STREQ("/mid/6", TestResolve(base, "mid/content=5/../6"));
572 EXPECT_STREQ("/a/b/e", TestResolve(base, "a/b/c/d/../../e"));
573 EXPECT_STREQ("/a/b/e", TestResolve(base, "../a/b/c/d/../../e"));
574 EXPECT_STREQ("/a/b/e", TestResolve(base, "./a/b/c/d/../../e"));
575 EXPECT_STREQ("/a/b/e", TestResolve(base, "../a/b/./c/d/../../e"));
576 EXPECT_STREQ("/a/b/e", TestResolve(base, "./a/b/./c/d/../../e"));
577 EXPECT_STREQ("/a/b/e/", TestResolve(base, "./a/b/./c/d/../../e/."));
578 EXPECT_STREQ("/a/b/e/", TestResolve(base, "./a/b/./c/d/../../e/./."));
579 EXPECT_STREQ("/a/b/e/", TestResolve(base, "./a/b/./c/d/../../e/././."));
580
581#define LH "http://localhost"
582 base = LH;
583 EXPECT_STREQ(LH "/a/g", TestResolve(base, "/a/b/c/./../../g"));
584 EXPECT_STREQ(LH "/a/g", TestResolve(base, "/a/b/c/./../../g"));
585 EXPECT_STREQ(LH "/mid/6", TestResolve(base, "mid/content=5/../6"));
586 EXPECT_STREQ(LH "/a/b/e", TestResolve(base, "a/b/c/d/../../e"));
587 EXPECT_STREQ(LH "/a/b/e", TestResolve(base, "../a/b/c/d/../../e"));
588 EXPECT_STREQ(LH "/a/b/e", TestResolve(base, "./a/b/c/d/../../e"));
589 EXPECT_STREQ(LH "/a/b/e", TestResolve(base, "../a/b/./c/d/../../e"));
590 EXPECT_STREQ(LH "/a/b/e", TestResolve(base, "./a/b/./c/d/../../e"));
591 EXPECT_STREQ(LH "/a/b/e/", TestResolve(base, "./a/b/./c/d/../../e/."));
592 EXPECT_STREQ(LH "/a/b/e/", TestResolve(base, "./a/b/./c/d/../../e/./."));
593 EXPECT_STREQ(LH "/a/b/e/", TestResolve(base, "./a/b/./c/d/../../e/././."));
594#undef LH
595}
596
597TEST_CASE(ResolveUri_WindowsPaths_Forwardslash_NoScheme) {
598 EXPECT_STREQ(
599 "c:/Users/USERNA~1/AppData/Local/Temp/a/b.dll",
600 TestResolve("C:/Users/USERNA~1/AppData/Local/Temp/a/out.dill", "b.dll"));
601}
602
603// > Here are some examples which may be accepted by some applications on
604// > Windows systems
605// https://en.wikipedia.org/wiki/File_URI_scheme
606// "file:///C:/"
607TEST_CASE(ResolveUri_WindowsPaths_Forwardslash_FileScheme) {
608 EXPECT_STREQ(
609 "file:///"
610 "C:/Users/USERNA~1/AppData/Local/Temp/a/b.dll",
611 TestResolve("file:///C:/Users/USERNA~1/AppData/Local/Temp/a/out.dill",
612 "b.dll"));
613}
614
615TEST_CASE(ResolveUri_WindowsPaths_Backslash) {
616 EXPECT_STREQ(
617 "file:///b.dll",
618 TestResolve(
619 "file:///C:\\Users\\USERNA~1\\AppData\\Local\\Temp\\a\\out.dill",
620 "b.dll"));
621}
622
623} // namespace dart
EXPECT
#define EXPECT(type, expectedAlignment, expectedSize)
Definition UniformOffsetCalculatorTest.cpp:33
dart::ResolveUri
bool ResolveUri(const char *ref_uri, const char *base_uri, const char **target_uri)
Definition uri.cc:424
dart::ParseUri
bool ParseUri(const char *uri, ParsedUri *parsed_uri)
Definition uri.cc:193
dart::TestResolve
static const char * TestResolve(const char *base_uri, const char *uri)
Definition uri_test.cc:505
dart::ParsedUri::query
const char * query
Definition uri.h:19
dart::ParsedUri::path
const char * path
Definition uri.h:18
dart::ParsedUri::userinfo
const char * userinfo
Definition uri.h:15
dart::ParsedUri::scheme
const char * scheme
Definition uri.h:14
dart::ParsedUri::host
const char * host
Definition uri.h:16
dart::ParsedUri::port
const char * port
Definition uri.h:17
dart::ParsedUri::fragment
const char * fragment
Definition uri.h:20
unit_test.h
TEST_CASE
#define TEST_CASE(name)
Definition unit_test.h:85
Generated on Fri Apr 26 2024 06:15:21 for Flutter Engine by doxygen 1.9.8