Debian Codegraph @

LspCpp/third_party/uri/test/uri_test.cpp

raw
1 // Copyright 2010 Jeroen Habraken.
2 // Copyright 2009-2017 Dean Michael Berris, Glyn Matthews.
3 // Copyright 2012 Google, Inc.
4 // Distributed under the Boost Software License, Version 1.0.
5 // (See accompanying file LICENSE_1_0.txt of copy at
6 // http://www.boost.org/LICENSE_1_0.txt)
7
8 #include <gtest/gtest.h>
9 #include <network/uri.hpp>
10 #include <algorithm>
11 #include <memory>
12 #include <map>
13 #include <set>
14 #include <unordered_set>
15 #include "string_utility.hpp"
16
17 TEST(uri_test, construct_invalid_uri) {
18 EXPECT_THROW(network::uri("I am not a valid URI."), network::uri_syntax_error);
19 }
20
21 TEST(uri_test, make_invalid_uri) {
22 std::error_code ec;
23 network::uri uri = network::make_uri("I am not a valid URI.", ec);
24 EXPECT_TRUE(static_cast<bool>(ec));
25 }
26
27 TEST(uri_test, construct_uri_from_char_array) {
28 EXPECT_NO_THROW(network::uri("http://www.example.com/"));
29 }
30
31 TEST(uri_test, construct_uri_starting_with_ipv4_like) {
32 EXPECT_NO_THROW(network::uri("http://198.51.100.0.example.com/"));
33 }
34
35 TEST(uri_test, construct_uri_starting_with_ipv4_like_glued) {
36 ASSERT_NO_THROW(network::uri("http://198.51.100.0example.com/"));
37 }
38
39 TEST(uri_test, construct_uri_like_short_ipv4) {
40 EXPECT_NO_THROW(network::uri("http://198.51.100/"));
41 }
42
43 TEST(uri_test, construct_uri_like_long_ipv4) {
44 EXPECT_NO_THROW(network::uri("http://198.51.100.0.255/"));
45 }
46
47 TEST(uri_test, make_uri_from_char_array) {
48 std::error_code ec;
49 network::uri uri = network::make_uri("http://www.example.com/", ec);
50 EXPECT_FALSE(ec);
51 }
52
53 TEST(uri_test, construct_uri_from_wchar_t_array) {
54 EXPECT_NO_THROW(network::uri(L"http://www.example.com/"));
55 }
56
57 TEST(uri_test, make_uri_from_wchar_t_array) {
58 std::error_code ec;
59 network::uri uri = network::make_uri(L"http://www.example.com/", ec);
60 EXPECT_FALSE(ec);
61 }
62
63 TEST(uri_test, construct_uri_from_string) {
64 EXPECT_NO_THROW(network::uri(std::string("http://www.example.com/")));
65 }
66
67 TEST(uri_test, make_uri_from_string) {
68 std::error_code ec;
69 network::uri uri = network::make_uri(std::string("http://www.example.com/"), ec);
70 EXPECT_FALSE(ec);
71 }
72
73 TEST(uri_test, construct_uri_from_wstring) {
74 EXPECT_NO_THROW(network::uri(std::wstring(L"http://www.example.com/")));
75 }
76
77 TEST(uri_test, make_uri_from_wstring) {
78 std::error_code ec;
79 network::uri uri = network::make_uri(std::wstring(L"http://www.example.com/"), ec);
80 EXPECT_FALSE(ec);
81 }
82
83 TEST(uri_test, basic_uri_scheme_test) {
84 network::uri instance("http://www.example.com/");
85 ASSERT_TRUE(instance.has_scheme());
86 EXPECT_EQ("http", instance.scheme());
87 }
88
89 TEST(uri_test, basic_uri_user_info_test) {
90 network::uri instance("http://www.example.com/");
91 EXPECT_FALSE(instance.has_user_info());
92 }
93
94 TEST(uri_test, basic_uri_host_test) {
95 network::uri instance("http://www.example.com/");
96 ASSERT_TRUE(instance.has_host());
97 EXPECT_EQ("www.example.com", instance.host());
98 }
99
100 TEST(uri_test, basic_uri_port_test) {
101 network::uri instance("http://www.example.com/");
102 EXPECT_FALSE(instance.has_port());
103 }
104
105 TEST(uri_test, basic_uri_path_test) {
106 network::uri instance("http://www.example.com/");
107 ASSERT_TRUE(instance.has_path());
108 EXPECT_EQ("/", instance.path());
109 }
110
111 TEST(uri_test, basic_uri_query_test) {
112 network::uri instance("http://www.example.com/");
113 EXPECT_FALSE(instance.has_query());
114 }
115
116 TEST(uri_test, basic_uri_fragment_test) {
117 network::uri instance("http://www.example.com/");
118 EXPECT_FALSE(instance.has_fragment());
119 }
120
121 TEST(uri_test, basic_uri_value_semantics_test) {
122 network::uri original;
123 network::uri assigned;
124 assigned = original;
125 EXPECT_EQ(original, assigned);
126 assigned = network::uri("http://www.example.com/");
127 EXPECT_NE(original, assigned);
128 network::uri copy(assigned);
129 EXPECT_EQ(copy, assigned);
130 }
131
132 TEST(uri_test, full_uri_scheme_test) {
133 network::uri instance("http://[email protected]:80/path?query#fragment");
134 EXPECT_EQ("http", instance.scheme());
135 }
136
137 TEST(uri_test, full_uri_user_info_test) {
138 network::uri instance("http://[email protected]:80/path?query#fragment");
139 EXPECT_EQ("user", instance.user_info());
140 }
141
142 TEST(uri_test, full_uri_host_test) {
143 network::uri instance("http://[email protected]:80/path?query#fragment");
144 EXPECT_EQ("www.example.com", instance.host());
145 }
146
147 TEST(uri_test, full_uri_port_test) {
148 network::uri instance("http://[email protected]:80/path?query#fragment");
149 EXPECT_EQ("80", instance.port());
150 }
151
152 TEST(uri_test, full_uri_port_as_int_test) {
153 network::uri instance("http://[email protected]:80/path?query#fragment");
154 EXPECT_EQ(80, instance.port<int>());
155 }
156
157 TEST(uri_test, full_uri_path_test) {
158 network::uri instance("http://[email protected]:80/path?query#fragment");
159 EXPECT_EQ("/path", instance.path());
160 }
161
162 TEST(uri_test, full_uri_query_test) {
163 network::uri instance("http://[email protected]:80/path?query#fragment");
164 EXPECT_EQ("query", instance.query());
165 }
166
167 TEST(uri_test, full_uri_fragment_test) {
168 network::uri instance("http://[email protected]:80/path?query#fragment");
169 EXPECT_EQ("fragment", instance.fragment());
170 }
171
172 TEST(uri_test, full_uri_range_scheme_test) {
173 network::uri instance("http://[email protected]:80/path?query#fragment");
174 ASSERT_TRUE(instance.has_scheme());
175 EXPECT_EQ("http", instance.scheme());
176 }
177
178 TEST(uri_test, full_uri_range_user_info_test) {
179 network::uri instance("http://[email protected]:80/path?query#fragment");
180 ASSERT_TRUE(instance.has_user_info());
181 EXPECT_EQ("user", instance.user_info());
182 }
183
184 TEST(uri_test, full_uri_range_host_test) {
185 network::uri instance("http://[email protected]:80/path?query#fragment");
186 ASSERT_TRUE(instance.has_host());
187 EXPECT_EQ("www.example.com", instance.host());
188 }
189
190 TEST(uri_test, full_uri_range_port_test) {
191 network::uri instance("http://[email protected]:80/path?query#fragment");
192 ASSERT_TRUE(instance.has_port());
193 EXPECT_EQ("80", instance.port());
194 }
195
196 TEST(uri_test, full_uri_range_path_test) {
197 network::uri instance("http://[email protected]:80/path?query#fragment");
198 ASSERT_TRUE(instance.has_path());
199 EXPECT_EQ("/path", instance.path());
200 }
201
202 TEST(uri_test, full_uri_range_query_test) {
203 network::uri instance("http://[email protected]:80/path?query#fragment");
204 ASSERT_TRUE(instance.has_query());
205 EXPECT_EQ("query", instance.query());
206 }
207
208 TEST(uri_test, full_uri_range_fragment_test) {
209 network::uri instance("http://[email protected]:80/path?query#fragment");
210 ASSERT_TRUE(instance.has_fragment());
211 EXPECT_EQ("fragment", instance.fragment());
212 }
213
214 TEST(uri_test, uri_with_empty_query) {
215 network::uri instance("http://example.com/?");
216 ASSERT_TRUE(instance.has_query());
217 EXPECT_EQ("", instance.query());
218 }
219
220 TEST(uri_test, mailto_test) {
221 network::uri instance("mailto:[email protected]");
222 EXPECT_EQ("mailto", instance.scheme());
223 EXPECT_EQ("[email protected]", instance.path());
224 }
225
226 TEST(uri_test, file_test) {
227 network::uri instance("file:///bin/bash");
228 EXPECT_EQ("file", instance.scheme());
229 EXPECT_EQ("/bin/bash", instance.path());
230 }
231
232 TEST(uri_test, file_path_has_host_bug_98) {
233 network::uri instance("file:///bin/bash");
234 EXPECT_TRUE(instance.has_scheme());
235 EXPECT_FALSE(instance.has_user_info());
236 EXPECT_TRUE(instance.has_host());
237 EXPECT_FALSE(instance.has_port());
238 EXPECT_TRUE(instance.has_path());
239 EXPECT_FALSE(instance.has_query());
240 EXPECT_FALSE(instance.has_fragment());
241 }
242
243 TEST(uri_test, xmpp_test) {
244 network::uri instance("xmpp:[email protected]?message;subject=Hello%20World");
245 EXPECT_EQ("xmpp", instance.scheme());
246 EXPECT_EQ("[email protected]", instance.path());
247 EXPECT_EQ("message;subject=Hello%20World", instance.query());
248 }
249
250 TEST(uri_test, ipv4_address_test) {
251 network::uri instance("http://129.79.245.252/");
252 EXPECT_EQ("http", instance.scheme());
253 EXPECT_EQ("129.79.245.252", instance.host());
254 EXPECT_EQ("/", instance.path());
255 }
256
257 TEST(uri_test, ipv4_loopback_test) {
258 network::uri instance("http://127.0.0.1/");
259 EXPECT_EQ("http", instance.scheme());
260 EXPECT_EQ("127.0.0.1", instance.host());
261 EXPECT_EQ("/", instance.path());
262 }
263
264 TEST(uri_test, ipv6_address_test_1) {
265 network::uri instance("http://[1080:0:0:0:8:800:200C:417A]/");
266 EXPECT_EQ("http", instance.scheme());
267 EXPECT_EQ("[1080:0:0:0:8:800:200C:417A]", instance.host());
268 EXPECT_EQ("/", instance.path());
269 }
270
271 TEST(uri_test, ipv6_address_test_2) {
272 network::uri instance("http://[2001:db8:85a3:8d3:1319:8a2e:370:7348]/");
273 EXPECT_EQ("http", instance.scheme());
274 EXPECT_EQ("[2001:db8:85a3:8d3:1319:8a2e:370:7348]", instance.host());
275 EXPECT_EQ("/", instance.path());
276 }
277
278 TEST(uri_test, ipv6_address_test_3) {
279 network::uri instance("http://[2001:db8:85a3:0:0:8a2e:370:7334]/");
280 EXPECT_EQ("http", instance.scheme());
281 EXPECT_EQ("[2001:db8:85a3:0:0:8a2e:370:7334]", instance.host());
282 EXPECT_EQ("/", instance.path());
283 }
284
285 TEST(uri_test, ipv6_address_test_4) {
286 network::uri instance("http://[2001:db8:85a3::8a2e:370:7334]/");
287 EXPECT_EQ("http", instance.scheme());
288 EXPECT_EQ("[2001:db8:85a3::8a2e:370:7334]", instance.host());
289 EXPECT_EQ("/", instance.path());
290 }
291
292 TEST(uri_test, ipv6_address_test_5) {
293 network::uri instance("http://[2001:0db8:0000:0000:0000:0000:1428:57ab]/");
294 EXPECT_EQ("http", instance.scheme());
295 EXPECT_EQ("[2001:0db8:0000:0000:0000:0000:1428:57ab]", instance.host());
296 EXPECT_EQ("/", instance.path());
297 }
298
299 TEST(uri_test, ipv6_address_test_6) {
300 network::uri instance("http://[2001:0db8:0000:0000:0000::1428:57ab]/");
301 EXPECT_EQ("http", instance.scheme());
302 EXPECT_EQ("[2001:0db8:0000:0000:0000::1428:57ab]", instance.host());
303 EXPECT_EQ("/", instance.path());
304 }
305
306 TEST(uri_test, ipv6_address_test_7) {
307 network::uri instance("http://[2001:0db8:0:0:0:0:1428:57ab]/");
308 EXPECT_EQ("http", instance.scheme());
309 EXPECT_EQ("[2001:0db8:0:0:0:0:1428:57ab]", instance.host());
310 EXPECT_EQ("/", instance.path());
311 }
312
313 TEST(uri_test, ipv6_address_test_8) {
314 network::uri instance("http://[2001:0db8:0:0::1428:57ab]/");
315 EXPECT_EQ("http", instance.scheme());
316 EXPECT_EQ("[2001:0db8:0:0::1428:57ab]", instance.host());
317 EXPECT_EQ("/", instance.path());
318 }
319
320 TEST(uri_test, ipv6_address_test_9) {
321 network::uri instance("http://[2001:0db8::1428:57ab]/");
322 EXPECT_EQ("http", instance.scheme());
323 EXPECT_EQ("[2001:0db8::1428:57ab]", instance.host());
324 EXPECT_EQ("/", instance.path());
325 }
326
327 TEST(uri_test, ipv6_address_test_10) {
328 network::uri instance("http://[2001:db8::1428:57ab]/");
329 EXPECT_EQ("http", instance.scheme());
330 EXPECT_EQ("[2001:db8::1428:57ab]", instance.host());
331 EXPECT_EQ("/", instance.path());
332 }
333
334 TEST(uri_test, ipv6_address_test_11) {
335 network::uri instance("http://[::ffff:0c22:384e]/");
336 EXPECT_EQ("http", instance.scheme());
337 EXPECT_EQ("[::ffff:0c22:384e]", instance.host());
338 EXPECT_EQ("/", instance.path());
339 }
340
341 TEST(uri_test, ipv6_address_test_12) {
342 network::uri instance("http://[fe80::]/");
343 EXPECT_EQ("http", instance.scheme());
344 EXPECT_EQ("[fe80::]", instance.host());
345 EXPECT_EQ("/", instance.path());
346 }
347
348 TEST(uri_test, ipv6_address_test_13) {
349 network::uri instance("http://[::ffff:c000:280]/");
350 EXPECT_EQ("http", instance.scheme());
351 EXPECT_EQ("[::ffff:c000:280]", instance.host());
352 EXPECT_EQ("/", instance.path());
353 }
354
355 TEST(uri_test, ipv6_loopback_test) {
356 network::uri instance("http://[::1]/");
357 EXPECT_EQ("http", instance.scheme());
358 EXPECT_EQ("[::1]", instance.host());
359 EXPECT_EQ("/", instance.path());
360 }
361
362 TEST(uri_test, ipv6_loopback_test_1) {
363 network::uri instance("http://[0000:0000:0000:0000:0000:0000:0000:0001]/");
364 EXPECT_EQ("http", instance.scheme());
365 EXPECT_EQ("[0000:0000:0000:0000:0000:0000:0000:0001]", instance.host());
366 EXPECT_EQ("/", instance.path());
367 }
368
369 TEST(uri_test, ipv6_v4inv6_test_1) {
370 network::uri instance("http://[::ffff:12.34.56.78]/");
371 EXPECT_EQ("http", instance.scheme());
372 EXPECT_EQ("[::ffff:12.34.56.78]", instance.host());
373 EXPECT_EQ("/", instance.path());
374 }
375
376 TEST(uri_test, ipv6_v4inv6_test_2) {
377 network::uri instance("http://[::ffff:192.0.2.128]/");
378 EXPECT_EQ("http", instance.scheme());
379 EXPECT_EQ("[::ffff:192.0.2.128]", instance.host());
380 EXPECT_EQ("/", instance.path());
381 }
382
383 TEST(uri_test, ftp_test) {
384 network::uri instance("ftp://[email protected]/");
385 EXPECT_EQ("ftp", instance.scheme());
386 EXPECT_EQ("john.doe", instance.user_info());
387 EXPECT_EQ("ftp.example.com", instance.host());
388 EXPECT_EQ("/", instance.path());
389 }
390
391 TEST(uri_test, news_test) {
392 network::uri instance("news:comp.infosystems.www.servers.unix");
393 EXPECT_EQ("news", instance.scheme());
394 EXPECT_EQ("comp.infosystems.www.servers.unix", instance.path());
395 }
396
397 TEST(uri_test, tel_test) {
398 network::uri instance("tel:+1-816-555-1212");
399 EXPECT_EQ("tel", instance.scheme());
400 EXPECT_EQ("+1-816-555-1212", instance.path());
401 }
402
403 TEST(uri_test, ldap_test) {
404 network::uri instance("ldap://[2001:db8::7]/c=GB?objectClass?one");
405 EXPECT_EQ("ldap", instance.scheme());
406 EXPECT_EQ("[2001:db8::7]", instance.host());
407 EXPECT_EQ("/c=GB", instance.path());
408 EXPECT_EQ("objectClass?one", instance.query());
409 }
410
411 TEST(uri_test, urn_test) {
412 network::uri instance("urn:oasis:names:specification:docbook:dtd:xml:4.1.2");
413 EXPECT_EQ("urn", instance.scheme());
414 EXPECT_EQ("oasis:names:specification:docbook:dtd:xml:4.1.2", instance.path());
415 }
416
417 TEST(uri_test, svn_ssh_test) {
418 network::uri instance("svn+ssh://example.com/");
419 EXPECT_EQ("svn+ssh", instance.scheme());
420 EXPECT_EQ("example.com", instance.host());
421 EXPECT_EQ("/", instance.path());
422 }
423
424 TEST(uri_test, copy_constructor_test) {
425 network::uri instance("http://www.example.com/");
426 network::uri copy = instance;
427 EXPECT_EQ(instance, copy);
428 }
429
430 TEST(uri_test, assignment_test) {
431 network::uri instance("http://www.example.com/");
432 network::uri copy;
433 copy = instance;
434 EXPECT_EQ(instance, copy);
435 }
436
437 TEST(uri_test, swap_test) {
438 network::uri original("http://example.com/path/to/file.txt");
439 network::uri instance("file:///something/different/");
440 original.swap(instance);
441
442 ASSERT_TRUE(original.has_scheme());
443 ASSERT_TRUE(original.has_host());
444 ASSERT_TRUE(original.has_path());
445 EXPECT_EQ("file", original.scheme());
446 EXPECT_EQ("", original.host());
447 EXPECT_EQ("/something/different/", original.path());
448
449 ASSERT_TRUE(instance.has_scheme());
450 ASSERT_TRUE(instance.has_host());
451 ASSERT_TRUE(instance.has_path());
452 EXPECT_EQ("http", instance.scheme());
453 EXPECT_EQ("example.com", instance.host());
454 EXPECT_EQ("/path/to/file.txt", instance.path());
455 }
456
457 TEST(uri_test, authority_test) {
458 network::uri instance("http://[email protected]:80/path?query#fragment");
459 ASSERT_TRUE(instance.has_authority());
460 EXPECT_EQ("[email protected]:80", instance.authority());
461 }
462
463 TEST(uri_test, partial_authority_test) {
464 network::uri instance("http://www.example.com/path?query#fragment");
465 ASSERT_TRUE(instance.has_authority());
466 EXPECT_EQ("www.example.com", instance.authority());
467 }
468
469 TEST(uri_test, range_test) {
470 const std::string url("http://www.example.com/");
471 network::uri instance(url);
472 EXPECT_TRUE(std::equal(std::begin(instance), std::end(instance),
473 std::begin(url)));
474 }
475
476 TEST(uri_test, issue_104_test) {
477 // https://github.com/cpp-netlib/cpp-netlib/issues/104
478 std::unique_ptr<network::uri> instance(new network::uri("http://www.example.com/"));
479 network::uri copy = *instance;
480 instance.reset();
481 EXPECT_EQ("http", copy.scheme());
482 }
483
484 TEST(uri_test, uri_set_test) {
485 std::set<network::uri> uri_set;
486 uri_set.insert(network::uri("http://www.example.com/"));
487 EXPECT_FALSE(uri_set.empty());
488 EXPECT_EQ(network::uri("http://www.example.com/"), (*std::begin(uri_set)));
489 }
490
491 TEST(uri_test, uri_unordered_set_test) {
492 std::unordered_set<network::uri> uri_set;
493 uri_set.insert(network::uri("http://www.example.com/"));
494 EXPECT_FALSE(uri_set.empty());
495 EXPECT_EQ(network::uri("http://www.example.com/"), (*std::begin(uri_set)));
496 }
497
498 TEST(uri_test, empty_uri) {
499 network::uri instance;
500 EXPECT_TRUE(instance.empty());
501 }
502
503 TEST(uri_test, empty_uri_has_no_scheme) {
504 network::uri instance;
505 EXPECT_FALSE(instance.has_scheme());
506 }
507
508 TEST(uri_test, empty_uri_has_no_user_info) {
509 network::uri instance;
510 EXPECT_FALSE(instance.has_user_info());
511 }
512
513 TEST(uri_test, empty_uri_has_no_host) {
514 network::uri instance;
515 EXPECT_FALSE(instance.has_host());
516 }
517
518 TEST(uri_test, empty_uri_has_no_port) {
519 network::uri instance;
520 EXPECT_FALSE(instance.has_port());
521 }
522
523 TEST(uri_test, empty_uri_has_no_path) {
524 network::uri instance;
525 EXPECT_FALSE(instance.has_path());
526 }
527
528 TEST(uri_test, empty_uri_has_no_query) {
529 network::uri instance;
530 EXPECT_FALSE(instance.has_query());
531 }
532
533 TEST(uri_test, empty_uri_has_no_fragment) {
534 network::uri instance;
535 EXPECT_FALSE(instance.has_fragment());
536 }
537
538 TEST(uri_test, http_is_absolute) {
539 network::uri instance("http://www.example.com/");
540 EXPECT_TRUE(instance.is_absolute());
541 }
542
543 TEST(uri_test, mailto_has_no_user_info) {
544 network::uri instance("mailto:[email protected]");
545 EXPECT_FALSE(instance.has_user_info());
546 }
547
548 TEST(uri_test, mailto_has_no_host) {
549 network::uri instance("mailto:[email protected]");
550 EXPECT_FALSE(instance.has_host());
551 }
552
553 TEST(uri_test, mailto_has_no_port) {
554 network::uri instance("mailto:[email protected]");
555 EXPECT_FALSE(instance.has_port());
556 }
557
558 TEST(uri_test, mailto_has_no_authority) {
559 network::uri instance("mailto:[email protected]");
560 EXPECT_FALSE(instance.has_authority());
561 }
562
563 TEST(uri_test, http_is_not_opaque) {
564 network::uri instance("http://www.example.com/");
565 EXPECT_FALSE(instance.is_opaque());
566 }
567
568 TEST(uri_test, file_is_not_opaque) {
569 network::uri instance("file:///bin/bash");
570 EXPECT_FALSE(instance.is_opaque());
571 }
572
573 TEST(uri_test, mailto_is_absolute) {
574 network::uri instance("mailto:[email protected]");
575 EXPECT_TRUE(instance.is_absolute());
576 }
577
578 TEST(uri_test, mailto_is_opaque) {
579 network::uri instance("mailto:[email protected]");
580 EXPECT_TRUE(instance.is_opaque());
581 }
582
583 TEST(uri_test, whitespace_no_throw) {
584 EXPECT_NO_THROW(network::uri(" http://www.example.com/ "));
585 }
586
587 TEST(uri_test, whitespace_is_trimmed) {
588 network::uri instance(" http://www.example.com/ ");
589 EXPECT_EQ("http://www.example.com/", instance);
590 }
591
592 TEST(uri_test, unnormalized_invalid_path_doesnt_throw) {
593 EXPECT_NO_THROW(network::uri("http://www.example.com/.."));
594 }
595
596 TEST(uri_test, unnormalized_invalid_path_is_valid) {
597 network::uri instance("http://www.example.com/..");
598 EXPECT_TRUE(instance.has_path());
599 }
600
601 TEST(uri_test, unnormalized_invalid_path_value) {
602 network::uri instance("http://www.example.com/..");
603 EXPECT_EQ("/..", instance.path());
604 }
605
606 TEST(uri_test, git) {
607 network::uri instance("git://github.com/cpp-netlib/cpp-netlib.git");
608 EXPECT_EQ("git", instance.scheme());
609 EXPECT_EQ("github.com", instance.host());
610 EXPECT_EQ("/cpp-netlib/cpp-netlib.git", instance.path());
611 }
612
613 TEST(uri_test, invalid_port_test) {
614 EXPECT_THROW(network::uri("http://123.34.23.56:6662626/"), network::uri_syntax_error);
615 }
616
617 TEST(uri_test, valid_empty_port_test) {
618 EXPECT_NO_THROW(network::uri("http://123.34.23.56:/"));
619 }
620
621 TEST(uri_test, empty_port_test) {
622 network::uri instance("http://123.34.23.56:/");
623 ASSERT_TRUE(instance.has_port());
624 EXPECT_EQ("", instance.port());
625 }
626
627 TEST(uri_test, full_copy_uri_scheme_test) {
628 network::uri origin("http://[email protected]:80/path?query#fragment");
629 network::uri instance = origin;
630 EXPECT_EQ("http", instance.scheme());
631 }
632
633 TEST(uri_test, full_copy_uri_user_info_test) {
634 network::uri origin("http://[email protected]:80/path?query#fragment");
635 network::uri instance = origin;
636 EXPECT_EQ("user", instance.user_info());
637 }
638
639 TEST(uri_test, full_copy_uri_host_test) {
640 network::uri origin("http://[email protected]:80/path?query#fragment");
641 network::uri instance = origin;
642 EXPECT_EQ("www.example.com", instance.host());
643 }
644
645 TEST(uri_test, full_copy_uri_port_test) {
646 network::uri origin("http://[email protected]:80/path?query#fragment");
647 network::uri instance = origin;
648 EXPECT_EQ("80", instance.port());
649 }
650
651 TEST(uri_test, full_copy_uri_path_test) {
652 network::uri origin("http://[email protected]:80/path?query#fragment");
653 network::uri instance = origin;
654 EXPECT_EQ("/path", instance.path());
655 }
656
657 TEST(uri_test, full_copy_uri_query_test) {
658 network::uri origin("http://[email protected]:80/path?query#fragment");
659 network::uri instance = origin;
660 EXPECT_EQ("query", instance.query());
661 }
662
663 TEST(uri_test, full_copy_uri_fragment_test) {
664 network::uri origin("http://[email protected]:80/path?query#fragment");
665 network::uri instance = origin;
666 EXPECT_EQ("fragment", instance.fragment());
667 }
668
669 TEST(uri_test, full_move_uri_scheme_test) {
670 network::uri origin("http://[email protected]:80/path?query#fragment");
671 network::uri instance = std::move(origin);
672 EXPECT_EQ("http", instance.scheme());
673 }
674
675 TEST(uri_test, full_move_uri_user_info_test) {
676 network::uri origin("http://[email protected]:80/path?query#fragment");
677 network::uri instance = std::move(origin);
678 EXPECT_EQ("user", instance.user_info());
679 }
680
681 TEST(uri_test, full_move_uri_host_test) {
682 network::uri origin("http://[email protected]:80/path?query#fragment");
683 network::uri instance = std::move(origin);
684 EXPECT_EQ("www.example.com", instance.host());
685 }
686
687 TEST(uri_test, full_move_uri_port_test) {
688 network::uri origin("http://[email protected]:80/path?query#fragment");
689 network::uri instance = std::move(origin);
690 EXPECT_EQ("80", instance.port());
691 }
692
693 TEST(uri_test, full_move_uri_path_test) {
694 network::uri origin("http://[email protected]:80/path?query#fragment");
695 network::uri instance = std::move(origin);
696 EXPECT_EQ("/path", instance.path());
697 }
698
699 TEST(uri_test, full_move_uri_query_test) {
700 network::uri origin("http://[email protected]:80/path?query#fragment");
701 network::uri instance = std::move(origin);
702 EXPECT_EQ("query", instance.query());
703 }
704
705 TEST(uri_test, full_move_uri_fragment_test) {
706 network::uri origin("http://[email protected]:80/path?query#fragment");
707 network::uri instance = std::move(origin);
708 EXPECT_EQ("fragment", instance.fragment());
709 }
710
711 TEST(uri_test, mailto_uri_path) {
712 network::uri origin("mailto:[email protected]?query#fragment");
713 network::uri instance = origin;
714 EXPECT_EQ("[email protected]", instance.path());
715 }
716
717 TEST(uri_test, mailto_uri_query) {
718 network::uri origin("mailto:[email protected]?query#fragment");
719 network::uri instance = origin;
720 EXPECT_EQ("query", instance.query());
721 }
722
723 TEST(uri_test, mailto_uri_fragment) {
724 network::uri origin("mailto:[email protected]?query#fragment");
725 network::uri instance = origin;
726 EXPECT_EQ("fragment", instance.fragment());
727 }
728
729 TEST(uri_test, opaque_uri_with_one_slash) {
730 network::uri instance("scheme:/path/");
731 EXPECT_TRUE(instance.is_opaque());
732 }
733
734 TEST(uri_test, opaque_uri_with_one_slash_scheme) {
735 network::uri instance("scheme:/path/");
736 EXPECT_EQ("scheme", instance.scheme());
737 }
738
739 TEST(uri_test, opaque_uri_with_one_slash_path) {
740 network::uri instance("scheme:/path/");
741 EXPECT_EQ("/path/", instance.path());
742 }
743
744 TEST(uri_test, opaque_uri_with_one_slash_query) {
745 network::uri instance("scheme:/path/?query#fragment");
746 EXPECT_EQ("query", instance.query());
747 }
748
749 TEST(uri_test, opaque_uri_with_one_slash_fragment) {
750 network::uri instance("scheme:/path/?query#fragment");
751 EXPECT_EQ("fragment", instance.fragment());
752 }
753
754 TEST(uri_test, opaque_uri_with_one_slash_copy) {
755 network::uri origin("scheme:/path/");
756 network::uri instance = origin;
757 EXPECT_TRUE(instance.is_opaque());
758 }
759
760 TEST(uri_test, opaque_uri_with_one_slash_copy_query) {
761 network::uri origin("scheme:/path/?query#fragment");
762 network::uri instance = origin;
763 EXPECT_EQ("query", instance.query());
764 }
765
766 TEST(uri_test, opaque_uri_with_one_slash_copy_fragment) {
767 network::uri origin("scheme:/path/?query#fragment");
768 network::uri instance = origin;
769 EXPECT_EQ("fragment", instance.fragment());
770 }
771
772 TEST(uri_test, move_empty_uri_check_scheme) {
773 network::uri origin("http://[email protected]:80/path?query#fragment");
774 network::uri instance = std::move(origin);
775 EXPECT_FALSE(origin.has_scheme());
776 }
777
778 TEST(uri_test, move_empty_uri_check_user_info) {
779 network::uri origin("http://[email protected]:80/path?query#fragment");
780 network::uri instance = std::move(origin);
781 EXPECT_FALSE(origin.has_user_info());
782 }
783
784 TEST(uri_test, move_empty_uri_check_host) {
785 network::uri origin("http://[email protected]:80/path?query#fragment");
786 network::uri instance = std::move(origin);
787 EXPECT_FALSE(origin.has_host());
788 }
789
790 TEST(uri_test, move_empty_uri_check_port) {
791 network::uri origin("http://[email protected]:80/path?query#fragment");
792 network::uri instance = std::move(origin);
793 EXPECT_FALSE(origin.has_port());
794 }
795
796 TEST(uri_test, move_empty_uri_check_path) {
797 network::uri origin("http://[email protected]:80/path?query#fragment");
798 network::uri instance = std::move(origin);
799 EXPECT_FALSE(origin.has_path());
800 }
801
802 TEST(uri_test, move_empty_uri_check_query) {
803 network::uri origin("http://[email protected]:80/path?query#fragment");
804 network::uri instance = std::move(origin);
805 EXPECT_FALSE(origin.has_query());
806 }
807
808 TEST(uri_test, move_empty_uri_check_fragment) {
809 network::uri origin("http://[email protected]:80/path?query#fragment");
810 network::uri instance = std::move(origin);
811 EXPECT_FALSE(origin.has_fragment());
812 }
813
814 TEST(uri_test, DISABLED_empty_username_in_user_info) {
815 network::uri instance("ftp://:@localhost");
816 ASSERT_TRUE(instance.has_user_info());
817 EXPECT_EQ(":", instance.user_info());
818 EXPECT_EQ("localhost", instance.host());
819 }
820
821 TEST(uri_test, uri_begins_with_a_colon) {
822 EXPECT_THROW(network::uri("://example.com"), network::uri_syntax_error);
823 }
824
825 TEST(uri_test, uri_begins_with_a_number) {
826 EXPECT_THROW(network::uri("3http://example.com"), network::uri_syntax_error);
827 }
828
829 TEST(uri_test, uri_scheme_contains_an_invalid_character) {
830 EXPECT_THROW(network::uri("ht%tp://example.com"), network::uri_syntax_error);
831 }
832
833 TEST(uri_test, default_constructed_assignment_test) {
834 network::uri instance("http://www.example.com/");
835 instance = network::uri(); // <-- CRASHES HERE
836 EXPECT_TRUE(instance.empty());
837 }
838
839 TEST(uri_test, opaque_path_no_double_slash) {
840 network::uri instance("file:/path/to/something/");
841 ASSERT_TRUE(instance.has_path());
842 EXPECT_EQ("/path/to/something/", instance.path());
843 EXPECT_TRUE(instance.is_opaque());
844 }
845
846 TEST(uri_test, non_opaque_path_has_double_slash) {
847 network::uri instance("file:///path/to/something/");
848 ASSERT_TRUE(instance.has_path());
849 EXPECT_EQ("/path/to/something/", instance.path());
850 EXPECT_FALSE(instance.is_opaque());
851 }
852
853 TEST(uri_test, query_iterator_with_no_query) {
854 network::uri instance("http://example.com/");
855 ASSERT_FALSE(instance.has_query());
856 ASSERT_EQ(instance.query_begin(), instance.query_end());
857 }
858
859 TEST(uri_test, query_iterator_with_empty_query) {
860 network::uri instance("http://example.com/?");
861 ASSERT_TRUE(instance.has_query());
862 EXPECT_EQ("", instance.query());
863 EXPECT_EQ(instance.query_begin(), instance.query_end());
864 }
865
866 TEST(uri_test, query_iterator_with_single_kvp) {
867 network::uri instance("http://example.com/?a=b");
868 ASSERT_TRUE(instance.has_query());
869 auto query_it = instance.query_begin();
870 ASSERT_NE(query_it, instance.query_end());
871 EXPECT_EQ("a", query_it->first);
872 EXPECT_EQ("b", query_it->second);
873 ++query_it;
874 EXPECT_EQ(query_it, instance.query_end());
875 }
876
877 TEST(uri_test, query_iterator_with_two_kvps) {
878 network::uri instance("http://example.com/?a=b&c=d");
879
880 ASSERT_TRUE(instance.has_query());
881 auto query_it = instance.query_begin();
882 ASSERT_NE(query_it, instance.query_end());
883 EXPECT_EQ("a", query_it->first);
884 EXPECT_EQ("b", query_it->second);
885 ++query_it;
886 ASSERT_NE(query_it, instance.query_end());
887 EXPECT_EQ("c", query_it->first);
888 EXPECT_EQ("d", query_it->second);
889 ++query_it;
890 EXPECT_EQ(query_it, instance.query_end());
891 }
892
893 TEST(uri_test, query_iterator_with_two_kvps_using_semicolon_separator) {
894 network::uri instance("http://example.com/?a=b;c=d");
895
896 ASSERT_TRUE(instance.has_query());
897 auto query_it = instance.query_begin();
898 ASSERT_NE(query_it, instance.query_end());
899 EXPECT_EQ("a", query_it->first);
900 EXPECT_EQ("b", query_it->second);
901 ++query_it;
902 ASSERT_NE(query_it, instance.query_end());
903 EXPECT_EQ("c", query_it->first);
904 EXPECT_EQ("d", query_it->second);
905 ++query_it;
906 EXPECT_EQ(query_it, instance.query_end());
907 }
908
909 TEST(uri_test, query_iterator_with_key_and_no_value) {
910 network::uri instance("http://example.com/?query");
911 ASSERT_TRUE(instance.has_query());
912 auto query_it = instance.query_begin();
913 EXPECT_EQ("query", query_it->first);
914 EXPECT_EQ("", query_it->second);
915 ++query_it;
916 EXPECT_EQ(query_it, instance.query_end());
917 }
918
919 TEST(uri_test, query_iterator_with_fragment) {
920 network::uri instance("http://example.com/?a=b;c=d#fragment");
921 ASSERT_TRUE(instance.has_query());
922 ASSERT_NE(instance.query_begin(), instance.query_end());
923 auto query_it = instance.query_begin();
924 EXPECT_EQ("a", query_it->first);
925 EXPECT_EQ("b", query_it->second);
926 ++query_it;
927 EXPECT_EQ("c", query_it->first);
928 EXPECT_EQ("d", query_it->second);
929 ++query_it;
930 EXPECT_EQ(query_it, instance.query_end());
931 }
932
933 TEST(uri_test, copy_assignment_bug_98) {
934 network::uri original("file:///path/to/file.txt");
935
936 ASSERT_TRUE(original.has_scheme());
937 ASSERT_FALSE(original.is_opaque());
938 ASSERT_TRUE(original.has_host());
939 ASSERT_TRUE(original.has_path());
940
941 network::uri instance;
942 instance = original;
943
944 ASSERT_TRUE(instance.has_scheme());
945 ASSERT_TRUE(instance.has_host());
946 ASSERT_TRUE(instance.has_path());
947 EXPECT_EQ("file", instance.scheme());
948 EXPECT_EQ("", instance.host());
949 EXPECT_EQ("/path/to/file.txt", instance.path());
950 }
951
952 TEST(uri_test, copy_assignment_bug_98_2) {
953 network::uri original("file:///path/to/file.txt?query=value#foo");
954
955 network::uri instance;
956 instance = original;
957
958 ASSERT_TRUE(instance.has_scheme());
959 ASSERT_TRUE(instance.has_path());
960 ASSERT_TRUE(instance.has_query());
961 ASSERT_TRUE(instance.has_fragment());
962 EXPECT_EQ("file", instance.scheme());
963 EXPECT_EQ("/path/to/file.txt", instance.path());
964 EXPECT_EQ("query=value", instance.query());
965 EXPECT_EQ("foo", instance.fragment());
966 }
967
968 TEST(uri_test, copy_constructor_bug_98) {
969 network::uri original("file:///path/to/file.txt?query=value#foo");
970
971 network::uri instance(original);
972
973 ASSERT_TRUE(instance.has_scheme());
974 ASSERT_TRUE(instance.has_path());
975 ASSERT_TRUE(instance.has_query());
976 ASSERT_TRUE(instance.has_fragment());
977 EXPECT_EQ("file", instance.scheme());
978 EXPECT_EQ("/path/to/file.txt", instance.path());
979 EXPECT_EQ("query=value", instance.query());
980 EXPECT_EQ("foo", instance.fragment());
981 }
982
983 TEST(uri_test, move_assignment_bug_98) {
984 network::uri original("file:///path/to/file.txt?query=value#foo");
985
986 network::uri instance;
987 instance = std::move(original);
988
989 ASSERT_TRUE(instance.has_scheme());
990 ASSERT_TRUE(instance.has_path());
991 ASSERT_TRUE(instance.has_query());
992 ASSERT_TRUE(instance.has_fragment());
993 EXPECT_EQ("file", instance.scheme());
994 EXPECT_EQ("/path/to/file.txt", instance.path());
995 EXPECT_EQ("query=value", instance.query());
996 EXPECT_EQ("foo", instance.fragment());
997 }
998
999 TEST(uri_test, move_constructor_bug_98) {
1000 network::uri original("file:///path/to/file.txt?query=value#foo");
1001
1002 network::uri instance(std::move(original));
1003
1004 ASSERT_TRUE(instance.has_scheme());
1005 ASSERT_TRUE(instance.has_path());
1006 ASSERT_TRUE(instance.has_query());
1007 ASSERT_TRUE(instance.has_fragment());
1008 EXPECT_EQ("file", instance.scheme());
1009 EXPECT_EQ("/path/to/file.txt", instance.path());
1010 EXPECT_EQ("query=value", instance.query());
1011 EXPECT_EQ("foo", instance.fragment());
1012 }
1013
1014 TEST(uri_test, http_copy_assignment_bug_98) {
1015 network::uri original("http://example.com/path/to/file.txt");
1016
1017 network::uri instance;
1018 instance = original;
1019
1020 ASSERT_TRUE(instance.has_scheme());
1021 ASSERT_TRUE(instance.has_path());
1022 EXPECT_EQ("http", instance.scheme());
1023 EXPECT_EQ("/path/to/file.txt", instance.path());
1024 }
1025
1026 TEST(uri_test, uri_has_host_bug_87) {
1027 EXPECT_THROW(network::uri("http://"), network::uri_syntax_error);
1028 }
1029
1030 TEST(uri_test, uri_has_host_bug_87_2) {
1031 EXPECT_THROW(network::uri("http://user@"), network::uri_syntax_error);
1032 }
1033
1034 TEST(uri_test, uri_has_host_bug_88) {
1035 network::uri instance("http://user@host");
1036
1037 ASSERT_TRUE(instance.has_scheme());
1038 ASSERT_TRUE(instance.has_user_info());
1039 ASSERT_TRUE(instance.has_host());
1040 ASSERT_FALSE(instance.has_port());
1041 ASSERT_TRUE(instance.has_path());
1042 ASSERT_FALSE(instance.has_query());
1043 ASSERT_FALSE(instance.has_fragment());
1044
1045 EXPECT_EQ("host", instance.host().to_string());
1046 }
1047
1048 TEST(uri_test, uri_has_host_bug_88_2) {
1049 network::uri instance("http://[email protected]");
1050
1051 ASSERT_TRUE(instance.has_scheme());
1052 ASSERT_TRUE(instance.has_user_info());
1053 ASSERT_TRUE(instance.has_host());
1054 ASSERT_FALSE(instance.has_port());
1055 ASSERT_TRUE(instance.has_path());
1056 ASSERT_FALSE(instance.has_query());
1057 ASSERT_FALSE(instance.has_fragment());
1058
1059 EXPECT_EQ("example.com", instance.host().to_string());
1060 }
1061
1062 TEST(uri_test, assignment_operator_bug_116) {
1063 network::uri a("http://a.com:1234");
1064 ASSERT_TRUE(a.has_port());
1065
1066 const network::uri b("http://b.com");
1067 ASSERT_FALSE(b.has_port());
1068
1069 a = b;
1070 ASSERT_FALSE(a.has_port()) << a.string() << ", " << a.port();
1071 }