Debian Codegraph @

LspCpp/third_party/uri/test/uri_parse_test.cpp

raw
1 // Copyright 2016-2017 Glyn Matthews.
2 // Distributed under the Boost Software License, Version 1.0.
3 // (See accompanying file LICENSE_1_0.txt of copy at
4 // http://www.boost.org/LICENSE_1_0.txt)
5
6 #include <fstream>
7 #include <gtest/gtest.h>
8 #include "test_uri.hpp"
9 #include "string_utility.hpp"
10
11 TEST(uri_parse_test, test_empty_uri) {
12 test::uri uri("");
13 EXPECT_FALSE(uri.parse_uri());
14 EXPECT_TRUE(uri.parsed_till().empty());
15 }
16
17 TEST(uri_parse_test, test_hierarchical_part_valid_user_info) {
18 test::uri uri("http://[email protected]:80/path?query#fragment");
19 EXPECT_TRUE(uri.parse_uri());
20 ASSERT_TRUE(uri.has_user_info());
21 EXPECT_EQ("user", uri.user_info());
22 }
23
24 TEST(uri_parse_test, test_hierarchical_part_empty_user_info) {
25 test::uri uri("http://@www.example.com:80/path?query#fragment");
26 EXPECT_FALSE(uri.parse_uri());
27 ASSERT_FALSE(uri.has_user_info());
28 }
29
30 TEST(uri_parse_test, test_hierarchical_part_unset_user_info) {
31 test::uri uri("http://www.example.com:80/path?query#fragment");
32 EXPECT_TRUE(uri.parse_uri());
33 ASSERT_FALSE(uri.has_user_info());
34 ASSERT_TRUE(uri.has_host());
35 EXPECT_EQ("www.example.com", uri.host());
36 }
37
38 TEST(uri_parse_test, test_hierarchical_part_unset_user_info_and_host) {
39 test::uri uri("http://:80/path?query#fragment");
40 EXPECT_FALSE(uri.parse_uri());
41 ASSERT_FALSE(uri.has_user_info());
42 ASSERT_FALSE(uri.has_host());
43 }
44
45 TEST(uri_parse_test, test_hierarchical_part_valid_user_info_and_host) {
46 test::uri uri("http://[email protected]:80/path?query#fragment");
47 EXPECT_TRUE(uri.parse_uri());
48 ASSERT_TRUE(uri.has_user_info());
49 EXPECT_EQ("user", uri.user_info());
50 ASSERT_TRUE(uri.has_host());
51 EXPECT_EQ("www.example.com", uri.host());
52 }
53
54 TEST(uri_parse_test, test_hierarchical_part_valid_user_info_unset_host) {
55 test::uri uri("http://user@:80/path?query#fragment");
56 EXPECT_FALSE(uri.parse_uri());
57 ASSERT_FALSE(uri.has_host());
58 }
59
60 TEST(uri_parse_test, test_hierarchical_part_valid_user_info_host_and_port) {
61 test::uri uri("http://[email protected]:80/path?query#fragment");
62 EXPECT_TRUE(uri.parse_uri());
63 ASSERT_TRUE(uri.has_user_info());
64 EXPECT_EQ("user", uri.user_info());
65 ASSERT_TRUE(uri.has_host());
66 EXPECT_EQ("www.example.com", uri.host());
67 ASSERT_TRUE(uri.has_port());
68 EXPECT_EQ("80", uri.port());
69 }
70
71 TEST(uri_parse_test, test_hierarchical_part_empty_user_info_valid_host_and_port) {
72 test::uri uri("http://www.example.com:80/path?query#fragment");
73 EXPECT_TRUE(uri.parse_uri());
74 ASSERT_FALSE(uri.has_user_info());
75 ASSERT_TRUE(uri.has_host());
76 EXPECT_EQ("www.example.com", uri.host());
77 ASSERT_TRUE(uri.has_port());
78 EXPECT_EQ("80", uri.port());
79 }
80
81 TEST(uri_parse_test, test_hierarchical_part_empty_user_info_valid_host_empty_port) {
82 test::uri uri("http://www.example.com/path?query#fragment");
83 EXPECT_TRUE(uri.parse_uri());
84 ASSERT_FALSE(uri.has_user_info());
85 ASSERT_TRUE(uri.has_host());
86 EXPECT_EQ("www.example.com", uri.host());
87 ASSERT_FALSE(uri.has_port());
88 }
89
90 TEST(uri_parse_test, test_hierarchical_part_valid_user_info_and_host_empty_port) {
91 test::uri uri("http://[email protected]/path?query#fragment");
92 EXPECT_TRUE(uri.parse_uri());
93 ASSERT_TRUE(uri.has_user_info());
94 EXPECT_EQ("user", uri.user_info());
95 ASSERT_TRUE(uri.has_host());
96 EXPECT_EQ("www.example.com", uri.host());
97 ASSERT_FALSE(uri.has_port());
98 }
99
100 TEST(uri_parse_test, test_hierarchical_part_valid_user_info_empty_host_valid_port) {
101 test::uri uri("http://user@:80/path?query#fragment");
102 EXPECT_FALSE(uri.parse_uri());
103 }
104
105 TEST(uri_parse_test, test_hierarchical_part_valid_host_empty_port_empty_path) {
106 test::uri uri("http://www.example.com");
107 EXPECT_TRUE(uri.parse_uri());
108 ASSERT_FALSE(uri.has_user_info());
109 ASSERT_TRUE(uri.has_host());
110 EXPECT_EQ("www.example.com", uri.host());
111 ASSERT_FALSE(uri.has_port());
112 ASSERT_TRUE(uri.has_path());
113 ASSERT_TRUE(uri.path().empty());
114 }
115
116 TEST(uri_parse_test, test_hierarchical_part_valid_host_valid_port_empty_path) {
117 test::uri uri("http://www.example.com:80");
118 EXPECT_TRUE(uri.parse_uri());
119 ASSERT_FALSE(uri.has_user_info());
120 ASSERT_TRUE(uri.has_host());
121 EXPECT_EQ("www.example.com", uri.host());
122 ASSERT_TRUE(uri.has_port());
123 EXPECT_EQ("80", uri.port());
124 ASSERT_TRUE(uri.has_path());
125 ASSERT_TRUE(uri.path().empty());
126 }
127
128 TEST(uri_parse_test, test_hierarchical_part_valid_user_odd_digits_port) {
129 test::uri uri("http://[email protected]:12345/foo");
130 EXPECT_TRUE(uri.parse_uri());
131 ASSERT_TRUE(uri.has_port());
132 EXPECT_EQ("12345", uri.port());
133 }
134
135 TEST(uri_parse_test, test_hierarchical_part_valid_host_port_path) {
136 test::uri uri("http://www.example.com:80/path");
137 EXPECT_TRUE(uri.parse_uri());
138 ASSERT_FALSE(uri.has_user_info());
139 ASSERT_TRUE(uri.has_host());
140 EXPECT_EQ("www.example.com", uri.host());
141 ASSERT_TRUE(uri.has_port());
142 EXPECT_EQ("80", uri.port());
143 ASSERT_TRUE(uri.has_path());
144 EXPECT_EQ("/path", uri.path());
145 }
146
147 TEST(uri_parse_test, test_hierarchical_part_valid_host_path) {
148 test::uri uri("http://www.example.com/path");
149 EXPECT_TRUE(uri.parse_uri());
150 ASSERT_FALSE(uri.has_user_info());
151 ASSERT_TRUE(uri.has_host());
152 EXPECT_EQ("www.example.com", uri.host());
153 ASSERT_FALSE(uri.has_port());
154 ASSERT_TRUE(uri.has_path());
155 EXPECT_EQ("/path", uri.path());
156 }
157
158 TEST(uri_parse_test, test_hierarchical_part_with_opaque_uri) {
159 test::uri uri("mailto:[email protected]");
160 EXPECT_TRUE(uri.parse_uri());
161 ASSERT_TRUE(uri.has_scheme());
162 EXPECT_EQ("mailto", uri.scheme());
163 ASSERT_FALSE(uri.has_user_info());
164 ASSERT_FALSE(uri.has_host());
165 ASSERT_FALSE(uri.has_port());
166 ASSERT_TRUE(uri.has_path());
167 EXPECT_EQ("[email protected]", uri.path());
168 }
169
170 TEST(uri_parse_test, test_hierarchical_part_valid_host_path_and_query) {
171 test::uri uri("http://www.example.com/path?query");
172 EXPECT_TRUE(uri.parse_uri());
173 ASSERT_FALSE(uri.has_user_info());
174 ASSERT_TRUE(uri.has_host());
175 EXPECT_EQ("www.example.com", uri.host());
176 ASSERT_FALSE(uri.has_port());
177 ASSERT_TRUE(uri.has_path());
178 EXPECT_EQ("/path", uri.path());
179 ASSERT_TRUE(uri.has_query());
180 EXPECT_EQ("query", uri.query());
181 ASSERT_FALSE(uri.has_fragment());
182 }
183
184 TEST(uri_parse_test, test_hierarchical_part_valid_host_path_query_and_fragment) {
185 test::uri uri("http://www.example.com/path?query#fragment");
186 EXPECT_TRUE(uri.parse_uri());
187 ASSERT_FALSE(uri.has_user_info());
188 ASSERT_TRUE(uri.has_host());
189 EXPECT_EQ("www.example.com", uri.host());
190 ASSERT_FALSE(uri.has_port());
191 ASSERT_TRUE(uri.has_path());
192 EXPECT_EQ("/path", uri.path());
193 ASSERT_TRUE(uri.has_query());
194 EXPECT_EQ("query", uri.query());
195 ASSERT_TRUE(uri.has_fragment());
196 EXPECT_EQ("fragment", uri.fragment());
197 }
198
199 TEST(uri_parse_test, test_hierarchical_part_valid_host_path_and_fragment) {
200 test::uri uri("http://www.example.com/path#fragment");
201 EXPECT_TRUE(uri.parse_uri());
202 ASSERT_FALSE(uri.has_user_info());
203 ASSERT_TRUE(uri.has_host());
204 EXPECT_EQ("www.example.com", uri.host());
205 ASSERT_FALSE(uri.has_port());
206 ASSERT_TRUE(uri.has_path());
207 EXPECT_EQ("/path", uri.path());
208 ASSERT_FALSE(uri.has_query());
209 ASSERT_TRUE(uri.has_fragment());
210 EXPECT_EQ("fragment", uri.fragment());
211 }
212
213 TEST(uri_parse_test, test_invalid_fragment) {
214 test::uri uri("http://www.example.com/path#%fragment");
215 EXPECT_FALSE(uri.parse_uri());
216 }
217
218 TEST(uri_parse_test, test_valid_fragment_with_pct_encoded_char) {
219 test::uri uri("http://www.example.com/path#%ffragment");
220 EXPECT_TRUE(uri.parse_uri());
221 ASSERT_TRUE(uri.has_fragment());
222 EXPECT_EQ("%ffragment", uri.fragment());
223 }
224
225 TEST(uri_parse_test, test_valid_fragment_with_unreserved_char) {
226 test::uri uri("http://www.example.com/path#fragment-");
227 EXPECT_TRUE(uri.parse_uri());
228 ASSERT_FALSE(uri.has_query());
229 ASSERT_TRUE(uri.has_fragment());
230 EXPECT_EQ("fragment-", uri.fragment());
231 }
232
233 TEST(uri_parse_test, test_invalid_fragment_with_gen_delim) {
234 test::uri uri("http://www.example.com/path#frag#ment");
235 EXPECT_FALSE(uri.parse_uri());
236 }
237
238 TEST(uri_parse_test, test_valid_fragment_with_sub_delim) {
239 test::uri uri("http://www.example.com/path#frag$ment");
240 EXPECT_TRUE(uri.parse_uri());
241 ASSERT_FALSE(uri.has_query());
242 ASSERT_TRUE(uri.has_fragment());
243 EXPECT_EQ("frag$ment", uri.fragment());
244 }
245
246 TEST(uri_parse_test, test_valid_fragment_with_forward_slash_and_question_mark) {
247 test::uri uri("http://www.example.com/path#frag/ment?");
248 EXPECT_TRUE(uri.parse_uri());
249 ASSERT_FALSE(uri.has_query());
250 ASSERT_TRUE(uri.has_fragment());
251 EXPECT_EQ("frag/ment?", uri.fragment());
252 }
253
254 TEST(uri_parse_test, test_invalid_query) {
255 test::uri uri("http://www.example.com/path?%query");
256 EXPECT_FALSE(uri.parse_uri());
257 }
258
259 TEST(uri_parse_test, test_valid_query_with_pct_encoded_char) {
260 test::uri uri("http://www.example.com/path?%00query");
261 EXPECT_TRUE(uri.parse_uri());
262 ASSERT_TRUE(uri.has_query());
263 EXPECT_EQ("%00query", uri.query());
264 ASSERT_FALSE(uri.has_fragment());
265 }
266
267 TEST(uri_parse_test, test_valid_query_with_unreserved_char) {
268 test::uri uri("http://www.example.com/path?query-");
269 EXPECT_TRUE(uri.parse_uri());
270 ASSERT_TRUE(uri.has_query());
271 EXPECT_EQ("query-", uri.query());
272 ASSERT_FALSE(uri.has_fragment());
273 }
274
275 TEST(uri_parse_test, test_valid_query_with_sub_delim) {
276 test::uri uri("http://www.example.com/path?qu$ery");
277 EXPECT_TRUE(uri.parse_uri());
278 ASSERT_TRUE(uri.has_query());
279 EXPECT_EQ("qu$ery", uri.query());
280 ASSERT_FALSE(uri.has_fragment());
281 }
282
283 TEST(uri_parse_test, test_invalid_port_with_path) {
284 test::uri uri("http://123.34.23.56:6662626/");
285 EXPECT_FALSE(uri.parse_uri());
286 }
287
288 TEST(uri_parse_test, test_invalid_port) {
289 test::uri uri("http://123.34.23.56:6662626");
290 EXPECT_FALSE(uri.parse_uri());
291 }
292
293 TEST(uri_parse_test, test_empty_port_with_path) {
294 test::uri uri("http://123.34.23.56:/");
295 EXPECT_TRUE(uri.parse_uri());
296 ASSERT_TRUE(uri.has_port());
297 ASSERT_EQ("", uri.port());
298 }
299
300 TEST(uri_parse_test, test_empty_port) {
301 test::uri uri("http://123.34.23.56:");
302 EXPECT_TRUE(uri.parse_uri());
303 ASSERT_TRUE(uri.has_port());
304 ASSERT_EQ("", uri.port());
305 }
306
307 TEST(uri_parse_test, test_ipv6_address) {
308 test::uri uri("http://[1080:0:0:0:8:800:200C:417A]");
309 EXPECT_TRUE(uri.parse_uri());
310 ASSERT_TRUE(uri.has_host());
311 EXPECT_EQ("[1080:0:0:0:8:800:200C:417A]", uri.host());
312 }
313
314 TEST(uri_parse_test, test_ipv6_address_with_path) {
315 test::uri uri("http://[1080:0:0:0:8:800:200C:417A]/");
316 EXPECT_TRUE(uri.parse_uri());
317 ASSERT_TRUE(uri.has_host());
318 EXPECT_EQ("[1080:0:0:0:8:800:200C:417A]", uri.host());
319 ASSERT_TRUE(uri.has_path());
320 EXPECT_EQ("/", uri.path());
321 }
322
323 TEST(uri_parse_test, test_invalid_ipv6_address) {
324 test::uri uri("http://[1080:0:0:0:8:800:200C:417A");
325 EXPECT_FALSE(!uri.parse_uri());
326 }
327
328 TEST(uri_parse_test, test_invalid_ipv6_address_with_path) {
329 test::uri uri("http://[1080:0:0:0:8:800:200C:417A/");
330 EXPECT_FALSE(!uri.parse_uri());
331 }
332
333 TEST(uri_parse_test, test_opaque_uri_with_one_slash) {
334 test::uri uri("scheme:/path/");
335 EXPECT_TRUE(uri.parse_uri());
336 ASSERT_TRUE(uri.has_scheme());
337 EXPECT_EQ("scheme", uri.scheme());
338 ASSERT_TRUE(uri.has_path());
339 EXPECT_EQ("/path/", uri.path());
340 }
341
342 TEST(uri_parse_test, test_empty_query) {
343 test::uri uri("http://www.example.com/?");
344 EXPECT_TRUE(uri.parse_uri());
345 ASSERT_TRUE(uri.has_query());
346 EXPECT_EQ("", uri.query());
347 }
348
349 TEST(uri_parse_test, test_query_with_empty_path) {
350 test::uri uri("http://www.example.com?query");
351 EXPECT_TRUE(uri.parse_uri());
352 ASSERT_TRUE(uri.has_scheme());
353 EXPECT_EQ("http", uri.scheme());
354 ASSERT_FALSE(uri.has_user_info());
355 ASSERT_TRUE(uri.has_host());
356 EXPECT_EQ("www.example.com", uri.host());
357 ASSERT_FALSE(uri.has_port());
358 ASSERT_TRUE(uri.has_path());
359 EXPECT_EQ("", uri.path());
360 ASSERT_TRUE(uri.has_query());
361 EXPECT_EQ("query", uri.query());
362 ASSERT_FALSE(uri.has_fragment());
363 }
364
365 TEST(uri_parse_test, test_query_with_user_info_and_empty_path) {
366 test::uri uri("http://[email protected]?query");
367 EXPECT_TRUE(uri.parse_uri());
368 ASSERT_TRUE(uri.has_scheme());
369 EXPECT_EQ("http", uri.scheme());
370 ASSERT_TRUE(uri.has_user_info());
371 EXPECT_EQ("user", uri.user_info());
372 ASSERT_TRUE(uri.has_host());
373 EXPECT_EQ("www.example.com", uri.host());
374 ASSERT_FALSE(uri.has_port());
375 ASSERT_TRUE(uri.has_path());
376 EXPECT_EQ("", uri.path());
377 ASSERT_TRUE(uri.has_query());
378 EXPECT_EQ("query", uri.query());
379 ASSERT_FALSE(uri.has_fragment());
380 }
381
382 TEST(uri_parse_test, test_fragment_with_empty_path) {
383 test::uri uri("http://www.example.com#fragment");
384 EXPECT_TRUE(uri.parse_uri());
385 ASSERT_TRUE(uri.has_scheme());
386 EXPECT_EQ("http", uri.scheme());
387 ASSERT_FALSE(uri.has_user_info());
388 ASSERT_TRUE(uri.has_host());
389 EXPECT_EQ("www.example.com", uri.host());
390 ASSERT_FALSE(uri.has_port());
391 ASSERT_TRUE(uri.has_path());
392 EXPECT_EQ("", uri.path());
393 ASSERT_FALSE(uri.has_query());
394 ASSERT_TRUE(uri.has_fragment());
395 EXPECT_EQ("fragment", uri.fragment());
396 }
397
398 TEST(uri_parse_test, test_fragment_with_user_info_and_empty_path) {
399 test::uri uri("http://[email protected]#fragment");
400 EXPECT_TRUE(uri.parse_uri());
401 ASSERT_TRUE(uri.has_scheme());
402 EXPECT_EQ("http", uri.scheme());
403 ASSERT_TRUE(uri.has_user_info());
404 EXPECT_EQ("user", uri.user_info());
405 ASSERT_TRUE(uri.has_host());
406 EXPECT_EQ("www.example.com", uri.host());
407 ASSERT_FALSE(uri.has_port());
408 ASSERT_TRUE(uri.has_path());
409 EXPECT_EQ("", uri.path());
410 ASSERT_FALSE(uri.has_query());
411 ASSERT_TRUE(uri.has_fragment());
412 EXPECT_EQ("fragment", uri.fragment());
413 }
414
415 TEST(uri_parse_test, test_query_with_empty_path_and_ipv6_address) {
416 test::uri uri("http://[1080:0:0:0:8:800:200C:417A]?query");
417 EXPECT_TRUE(uri.parse_uri());
418 ASSERT_TRUE(uri.has_scheme());
419 EXPECT_EQ("http", uri.scheme());
420 ASSERT_FALSE(uri.has_user_info());
421 ASSERT_TRUE(uri.has_host());
422 EXPECT_EQ("[1080:0:0:0:8:800:200C:417A]", uri.host());
423 ASSERT_FALSE(uri.has_port());
424 ASSERT_TRUE(uri.has_path());
425 EXPECT_EQ("", uri.path());
426 ASSERT_TRUE(uri.has_query());
427 EXPECT_EQ("query", uri.query());
428 ASSERT_FALSE(uri.has_fragment());
429 }
430
431 TEST(uri_parse_test, test_query_with_user_info_empty_path_and_ipv6_address) {
432 test::uri uri("http://user@[1080:0:0:0:8:800:200C:417A]?query");
433 EXPECT_TRUE(uri.parse_uri());
434 EXPECT_EQ("http://user@[1080:0:0:0:8:800:200C:417A]?query", uri.parsed_till());
435 ASSERT_TRUE(uri.has_scheme());
436 EXPECT_EQ("http", uri.scheme());
437 ASSERT_TRUE(uri.has_user_info());
438 EXPECT_EQ("user", uri.user_info());
439 ASSERT_TRUE(uri.has_host());
440 EXPECT_EQ("[1080:0:0:0:8:800:200C:417A]", uri.host());
441 ASSERT_FALSE(uri.has_port());
442 ASSERT_TRUE(uri.has_path());
443 EXPECT_EQ("", uri.path());
444 ASSERT_TRUE(uri.has_query());
445 EXPECT_EQ("query", uri.query());
446 ASSERT_FALSE(uri.has_fragment());
447 }
448
449 TEST(uri_parse_test, test_fragment_with_empty_path_and_ipv6_address) {
450 test::uri uri("http://[1080:0:0:0:8:800:200C:417A]#fragment");
451 EXPECT_TRUE(uri.parse_uri());
452 ASSERT_TRUE(uri.has_scheme());
453 EXPECT_EQ("http", uri.scheme());
454 ASSERT_FALSE(uri.has_user_info());
455 ASSERT_TRUE(uri.has_host());
456 EXPECT_EQ("[1080:0:0:0:8:800:200C:417A]", uri.host());
457 ASSERT_FALSE(uri.has_port());
458 ASSERT_TRUE(uri.has_path());
459 EXPECT_EQ("", uri.path());
460 ASSERT_FALSE(uri.has_query());
461 ASSERT_TRUE(uri.has_fragment());
462 EXPECT_EQ("fragment", uri.fragment());
463 }
464
465 TEST(uri_parse_test, test_fragment_with_user_info_empty_path_and_ipv6_address) {
466 test::uri uri("http://user@[1080:0:0:0:8:800:200C:417A]#fragment");
467 EXPECT_TRUE(uri.parse_uri());
468 ASSERT_TRUE(uri.has_scheme());
469 EXPECT_EQ("http", uri.scheme());
470 ASSERT_TRUE(uri.has_user_info());
471 EXPECT_EQ("user", uri.user_info());
472 ASSERT_TRUE(uri.has_host());
473 EXPECT_EQ("[1080:0:0:0:8:800:200C:417A]", uri.host());
474 ASSERT_FALSE(uri.has_port());
475 ASSERT_TRUE(uri.has_path());
476 EXPECT_EQ("", uri.path());
477 ASSERT_FALSE(uri.has_query());
478 ASSERT_TRUE(uri.has_fragment());
479 EXPECT_EQ("fragment", uri.fragment());
480 }
481
482 TEST(uri_parse_test, test_pct_encoded_user_info) {
483 test::uri uri("http://user%[email protected]/");
484 EXPECT_TRUE(uri.parse_uri());
485 ASSERT_TRUE(uri.has_scheme());
486 EXPECT_EQ("http", uri.scheme());
487 ASSERT_TRUE(uri.has_user_info());
488 EXPECT_EQ("user%3f", uri.user_info());
489 ASSERT_TRUE(uri.has_host());
490 EXPECT_EQ("www.example.com", uri.host());
491 ASSERT_TRUE(uri.has_path());
492 EXPECT_EQ("/", uri.path());
493 }
494
495 TEST(uri_parse_test, test_file_uri_bug_98) {
496 test::uri uri("file:///bin/bash");
497 EXPECT_TRUE(uri.parse_uri());
498 ASSERT_FALSE(uri.has_user_info());
499 ASSERT_TRUE(uri.has_host());
500 EXPECT_EQ("", uri.host());
501 ASSERT_TRUE(uri.has_path());
502 EXPECT_EQ("/bin/bash", uri.path());
503 }
504
505 TEST(uri_parse_test, test_file_uri_bug_98_2) {
506 test::uri uri("file://localhost/bin");
507 EXPECT_TRUE(uri.parse_uri());
508 ASSERT_FALSE(uri.has_user_info());
509 ASSERT_TRUE(uri.has_host());
510 EXPECT_EQ("localhost", uri.host());
511 ASSERT_TRUE(uri.has_path());
512 EXPECT_EQ("/bin", uri.path());
513 }
514
515 TEST(uri_parse_test, test_file_uri_bug_98_3) {
516 test::uri uri("file://localhost/bin/bash");
517 EXPECT_TRUE(uri.parse_uri());
518 ASSERT_FALSE(uri.has_user_info());
519 ASSERT_TRUE(uri.has_host());
520 EXPECT_EQ("localhost", uri.host());
521 ASSERT_TRUE(uri.has_path());
522 EXPECT_EQ("/bin/bash", uri.path());
523 }
524
525 TEST(uri_parse_test, test_file_uri_bug_98_4) {
526 test::uri uri("file:///bin");
527 EXPECT_TRUE(uri.parse_uri());
528 ASSERT_FALSE(uri.has_user_info());
529 ASSERT_TRUE(uri.has_host());
530 EXPECT_EQ("", uri.host());
531 ASSERT_TRUE(uri.has_path());
532 EXPECT_EQ("/bin", uri.path());
533 }
534
535 TEST(uri_parse_test, test_has_host_bug_88) {
536 test::uri uri("http://user@host");
537 EXPECT_TRUE(uri.parse_uri());
538 }
539
540 // http://formvalidation.io/validators/uri/
541
542 std::vector<std::string> create_urls(const std::string &filename) {
543 std::vector<std::string> urls;
544 std::ifstream ifs(filename);
545 if (!ifs) {
546 throw std::runtime_error("Unable to open file: " + filename);
547 }
548 for (std::string url; std::getline(ifs, url);) {
549 if (url.front() != '#') {
550 urls.push_back(url);
551 }
552 }
553 return urls;
554 }
555
556 // All valid URLs in the list should pass
557 class test_valid_urls : public ::testing::TestWithParam<std::string> {};
558
559 INSTANTIATE_TEST_CASE_P(uri_parse_test, test_valid_urls,
560 testing::ValuesIn(create_urls("valid_urls.txt")));
561
562 TEST_P(test_valid_urls, urls_are_valid) {
563 test::uri uri(GetParam());
564 EXPECT_TRUE(uri.parse_uri());
565 }