Debian Codegraph @

LspCpp/third_party/uri/test/uri_builder_test.cpp

raw
1 // Copyright (c) Glyn Matthews 2012-2016.
2 // Copyright 2012 Google, Inc.
3 // Distributed under the Boost Software License, Version 1.0.
4 // (See accompanying file LICENSE_1_0.txt or copy at
5 // http://www.boost.org/LICENSE_1_0.txt)
6
7 #include <gtest/gtest.h>
8 #include <network/uri.hpp>
9 #include "string_utility.hpp"
10
11 TEST(builder_test, empty_uri_doesnt_throw) {
12 network::uri_builder builder;
13 ASSERT_NO_THROW(builder.uri());
14 }
15
16 TEST(builder_test, empty_uri) {
17 network::uri_builder builder;
18 network::uri instance(builder);
19 ASSERT_TRUE(instance.empty());
20 }
21
22 TEST(builder_test, simple_uri_doesnt_throw) {
23 network::uri_builder builder;
24 builder
25 .scheme("http")
26 .host("www.example.com")
27 .path("/")
28 ;
29 ASSERT_NO_THROW(builder.uri());
30 }
31
32 TEST(builder_test, simple_uri) {
33 network::uri_builder builder;
34 builder
35 .scheme("http")
36 .host("www.example.com")
37 .path("/")
38 ;
39 ASSERT_EQ("http://www.example.com/", builder.uri().string());
40 }
41
42 TEST(builder_test, simple_uri_has_scheme) {
43 network::uri_builder builder;
44 builder
45 .scheme("http")
46 .host("www.example.com")
47 .path("/")
48 ;
49 ASSERT_TRUE(builder.uri().has_scheme());
50 }
51
52 TEST(builder_test, simple_uri_scheme_value) {
53 network::uri_builder builder;
54 builder
55 .scheme("http")
56 .host("www.example.com")
57 .path("/")
58 ;
59 ASSERT_EQ("http", builder.uri().scheme());
60 }
61
62 TEST(builder_test, simple_uri_has_no_user_info) {
63 network::uri_builder builder;
64 builder
65 .scheme("http")
66 .host("www.example.com")
67 .path("/")
68 ;
69 ASSERT_FALSE(builder.uri().has_user_info());
70 }
71
72 TEST(builder_test, simple_uri_has_host) {
73 network::uri_builder builder;
74 builder
75 .scheme("http")
76 .host("www.example.com")
77 .path("/")
78 ;
79 ASSERT_TRUE(builder.uri().has_host());
80 }
81
82 TEST(builder_test, simple_uri_host_value) {
83 network::uri_builder builder;
84 builder
85 .scheme("http")
86 .host("www.example.com")
87 .path("/")
88 ;
89 ASSERT_EQ("www.example.com", builder.uri().host());
90 }
91
92 TEST(builder_test, simple_uri_has_no_port) {
93 network::uri_builder builder;
94 builder
95 .scheme("http")
96 .host("www.example.com")
97 .path("/")
98 ;
99 ASSERT_FALSE(builder.uri().has_port());
100 }
101
102 TEST(builder_test, simple_uri_has_path) {
103 network::uri_builder builder;
104 builder
105 .scheme("http")
106 .host("www.example.com")
107 .path("/")
108 ;
109 ASSERT_TRUE(builder.uri().has_path());
110 }
111
112 TEST(builder_test, simple_uri_path_value) {
113 network::uri_builder builder;
114 builder
115 .scheme("http")
116 .host("www.example.com")
117 .path("/")
118 ;
119 ASSERT_EQ("/", builder.uri().path());
120 }
121
122 TEST(builder_test, simple_uri_has_no_query) {
123 network::uri_builder builder;
124 builder
125 .scheme("http")
126 .host("www.example.com")
127 .path("/")
128 ;
129 ASSERT_FALSE(builder.uri().has_query());
130 }
131
132 TEST(builder_test, simple_uri_has_no_fragment) {
133 network::uri_builder builder;
134 builder
135 .scheme("http")
136 .host("www.example.com")
137 .path("/")
138 ;
139 ASSERT_FALSE(builder.uri().has_fragment());
140 }
141
142 TEST(builder_test, simple_opaque_uri_doesnt_throw) {
143 network::uri_builder builder;
144 builder
145 .scheme("mailto")
146 .path("[email protected]")
147 ;
148 ASSERT_NO_THROW(builder.uri());
149 }
150
151 TEST(builder_test, simple_opaque_uri) {
152 network::uri_builder builder;
153 builder
154 .scheme("mailto")
155 .path("[email protected]")
156 ;
157 ASSERT_EQ("mailto:[email protected]", builder.uri().string());
158 }
159
160 TEST(builder_test, simple_opaque_uri_has_scheme) {
161 network::uri_builder builder;
162 builder
163 .scheme("mailto")
164 .path("[email protected]")
165 ;
166 ASSERT_TRUE(builder.uri().has_scheme());
167 }
168
169 TEST(builder_test, simple_opaque_uri_scheme_value) {
170 network::uri_builder builder;
171 builder
172 .scheme("mailto")
173 .path("[email protected]")
174 ;
175 ASSERT_EQ("mailto", builder.uri().scheme());
176 }
177
178 TEST(builder_test, relative_hierarchical_uri_doesnt_throw) {
179 network::uri_builder builder;
180 builder
181 .host("www.example.com")
182 .path("/")
183 ;
184 ASSERT_NO_THROW(builder.uri());
185 }
186
187 TEST(builder_test, relative_hierarchical_uri) {
188 network::uri_builder builder;
189 builder
190 .host("www.example.com")
191 .path("/")
192 ;
193 ASSERT_EQ("www.example.com/", builder.uri().string());
194 }
195
196 TEST(builder_test, relative_opaque_uri_doesnt_throw) {
197 network::uri_builder builder;
198 builder
199 .path("[email protected]")
200 ;
201 ASSERT_NO_THROW(builder.uri());
202 }
203
204 TEST(builder_test, relative_opaque_uri) {
205 network::uri_builder builder;
206 builder
207 .path("[email protected]")
208 ;
209 ASSERT_EQ("[email protected]", builder.uri().string());
210 }
211
212 TEST(builder_test, full_uri_doesnt_throw) {
213 network::uri_builder builder;
214 builder
215 .scheme("http")
216 .user_info("user")
217 .host("www.example.com")
218 .port("80")
219 .path("/path")
220 .append_query_key_value_pair("query", "value")
221 .fragment("fragment")
222 ;
223 ASSERT_NO_THROW(builder.uri());
224 }
225
226 TEST(builder_test, full_uri) {
227 network::uri_builder builder;
228 builder
229 .scheme("http")
230 .user_info("user")
231 .host("www.example.com")
232 .port("80")
233 .path("/path")
234 .append_query_key_value_pair("query", "value")
235 .fragment("fragment")
236 ;
237 ASSERT_EQ("http://[email protected]:80/path?query=value#fragment", builder.uri().string());
238 }
239
240 TEST(builder_test, full_uri_has_scheme) {
241 network::uri_builder builder;
242 builder
243 .scheme("http")
244 .user_info("user")
245 .host("www.example.com")
246 .port("80")
247 .path("/path")
248 .append_query_key_value_pair("query", "value")
249 .fragment("fragment")
250 ;
251 ASSERT_TRUE(builder.uri().has_scheme());
252 }
253
254 TEST(builder_test, full_uri_scheme_value) {
255 network::uri_builder builder;
256 builder
257 .scheme("http")
258 .user_info("user")
259 .host("www.example.com")
260 .port("80")
261 .path("/path")
262 .append_query_key_value_pair("query", "value")
263 .fragment("fragment")
264 ;
265 ASSERT_EQ("http", builder.uri().scheme());
266 }
267
268 TEST(builder_test, full_uri_has_user_info) {
269 network::uri_builder builder;
270 builder
271 .scheme("http")
272 .user_info("user")
273 .host("www.example.com")
274 .port("80")
275 .path("/path")
276 .append_query_key_value_pair("query", "value")
277 .fragment("fragment")
278 ;
279 ASSERT_TRUE(builder.uri().has_user_info());
280 }
281
282 TEST(builder_test, full_uri_user_info_value) {
283 network::uri_builder builder;
284 builder
285 .scheme("http")
286 .user_info("user")
287 .host("www.example.com")
288 .port("80")
289 .path("/path")
290 .append_query_key_value_pair("query", "value")
291 .fragment("fragment")
292 ;
293 ASSERT_EQ("user", builder.uri().user_info());
294 }
295
296 TEST(builder_test, full_uri_has_host) {
297 network::uri_builder builder;
298 builder
299 .scheme("http")
300 .user_info("user")
301 .host("www.example.com")
302 .port("80")
303 .path("/path")
304 .append_query_key_value_pair("query", "value")
305 .fragment("fragment")
306 ;
307 ASSERT_TRUE(builder.uri().has_host());
308 }
309
310 TEST(builder_test, full_uri_host_value) {
311 network::uri_builder builder;
312 builder
313 .scheme("http")
314 .user_info("user")
315 .host("www.example.com")
316 .port("80")
317 .path("/path")
318 .append_query_key_value_pair("query", "value")
319 .fragment("fragment")
320 ;
321 ASSERT_EQ("www.example.com", builder.uri().host());
322 }
323
324 TEST(builder_test, full_uri_has_port) {
325 network::uri_builder builder;
326 builder
327 .scheme("http")
328 .user_info("user")
329 .host("www.example.com")
330 .port("80")
331 .path("/path")
332 .append_query_key_value_pair("query", "value")
333 .fragment("fragment")
334 ;
335 ASSERT_TRUE(builder.uri().has_port());
336 }
337
338 TEST(builder_test, full_uri_has_path) {
339 network::uri_builder builder;
340 builder
341 .scheme("http")
342 .user_info("user")
343 .host("www.example.com")
344 .port("80")
345 .path("/path")
346 .append_query_key_value_pair("query", "value")
347 .fragment("fragment")
348 ;
349 ASSERT_TRUE(builder.uri().has_path());
350 }
351
352 TEST(builder_test, full_uri_path_value) {
353 network::uri_builder builder;
354 builder
355 .scheme("http")
356 .user_info("user")
357 .host("www.example.com")
358 .port("80")
359 .path("/path")
360 .append_query_key_value_pair("query", "value")
361 .fragment("fragment")
362 ;
363 ASSERT_EQ("/path", builder.uri().path());
364 }
365
366 TEST(builder_test, full_uri_has_query) {
367 network::uri_builder builder;
368 builder
369 .scheme("http")
370 .user_info("user")
371 .host("www.example.com")
372 .port("80")
373 .path("/path")
374 .append_query_key_value_pair("query", "value")
375 .fragment("fragment")
376 ;
377 ASSERT_TRUE(builder.uri().has_query());
378 }
379
380 TEST(builder_test, full_uri_query_value) {
381 network::uri_builder builder;
382 builder
383 .scheme("http")
384 .user_info("user")
385 .host("www.example.com")
386 .port("80")
387 .path("/path")
388 .append_query_key_value_pair("query", "value")
389 .fragment("fragment")
390 ;
391 ASSERT_EQ("query=value", builder.uri().query());
392 }
393
394 TEST(builder_test, full_uri_has_fragment) {
395 network::uri_builder builder;
396 builder
397 .scheme("http")
398 .user_info("user")
399 .host("www.example.com")
400 .port("80")
401 .path("/path")
402 .append_query_key_value_pair("query", "value")
403 .fragment("fragment")
404 ;
405 ASSERT_TRUE(builder.uri().has_fragment());
406 }
407
408 TEST(builder_test, full_uri_fragment_value) {
409 network::uri_builder builder;
410 builder
411 .scheme("http")
412 .user_info("user")
413 .host("www.example.com")
414 .port("80")
415 .path("/path")
416 .append_query_key_value_pair("query", "value")
417 .fragment("fragment")
418 ;
419 ASSERT_EQ("fragment", builder.uri().fragment());
420 }
421
422 TEST(builder_test, relative_uri) {
423 network::uri_builder builder;
424 builder
425 .host("www.example.com")
426 .path("/")
427 ;
428 ASSERT_EQ("www.example.com/", builder.uri().string());
429 }
430
431 TEST(builder_test, relative_uri_scheme) {
432 network::uri_builder builder;
433 builder
434 .host("www.example.com")
435 .path("/")
436 ;
437 ASSERT_FALSE(builder.uri().has_scheme());
438 }
439
440 TEST(builder_test, authority) {
441 network::uri_builder builder;
442 builder
443 .scheme("http")
444 .authority("www.example.com:8080")
445 .path("/")
446 ;
447 ASSERT_EQ("http://www.example.com:8080/", builder.uri().string());
448 ASSERT_EQ("www.example.com", builder.uri().host());
449 ASSERT_EQ("8080", builder.uri().port());
450 }
451
452 TEST(builder_test, relative_uri_has_host) {
453 network::uri_builder builder;
454 builder
455 .host("www.example.com")
456 .path("/")
457 ;
458 ASSERT_TRUE(builder.uri().has_host());
459 }
460
461 TEST(builder_test, relative_uri_host_value) {
462 network::uri_builder builder;
463 builder
464 .host("www.example.com")
465 .path("/")
466 ;
467 ASSERT_EQ("www.example.com", builder.uri().host());
468 }
469
470 TEST(builder_test, relative_uri_has_path) {
471 network::uri_builder builder;
472 builder
473 .host("www.example.com")
474 .path("/")
475 ;
476 ASSERT_TRUE(builder.uri().has_path());
477 }
478
479 TEST(builder_test, relative_uri_path_value) {
480 network::uri_builder builder;
481 builder
482 .host("www.example.com")
483 .path("/")
484 ;
485 ASSERT_EQ("/", builder.uri().path());
486 }
487
488 TEST(builder_test, build_relative_uri_with_path_query_and_fragment) {
489 network::uri_builder builder;
490 builder
491 .path("/path/")
492 .append_query_key_value_pair("key", "value")
493 .fragment("fragment")
494 ;
495 ASSERT_EQ("/path/", builder.uri().path());
496 ASSERT_EQ("key=value", builder.uri().query());
497 ASSERT_EQ("fragment", builder.uri().fragment());
498 }
499
500 TEST(builder_test, build_uri_with_capital_scheme) {
501 network::uri_builder builder;
502 builder
503 .scheme("HTTP")
504 .host("www.example.com")
505 .path("/")
506 ;
507 ASSERT_EQ("http://www.example.com/", builder.uri().string());
508 }
509
510 TEST(builder_test, build_uri_with_capital_host) {
511 network::uri_builder builder;
512 builder
513 .scheme("http")
514 .host("WWW.EXAMPLE.COM")
515 .path("/")
516 ;
517 ASSERT_EQ("http://www.example.com/", builder.uri().string());
518 }
519
520 TEST(builder_test, build_uri_with_unencoded_path) {
521 network::uri_builder builder;
522 builder
523 .scheme("http")
524 .host("www.example.com")
525 .path("/A path with spaces")
526 ;
527 ASSERT_EQ("http://www.example.com/A%20path%20with%20spaces", builder.uri().string());
528 }
529
530 TEST(builder_test, DISABLED_builder_uri_and_remove_dot_segments_from_path) {
531 network::uri_builder builder;
532 builder
533 .scheme("http")
534 .host("www.example.com")
535 .path("/A/./path/")
536 ;
537 ASSERT_EQ("http://www.example.com/A/path/", builder.uri().string());
538 }
539
540 TEST(builder_test, build_uri_with_qmark_in_path) {
541 network::uri_builder builder;
542 builder
543 .scheme("http")
544 .host("www.example.com")
545 .path("/?/")
546 ;
547 ASSERT_EQ("http://www.example.com/%3F/", builder.uri().string());
548 }
549
550 TEST(builder_test, build_uri_with_hash_in_path) {
551 network::uri_builder builder;
552 builder
553 .scheme("http")
554 .host("www.example.com")
555 .path("/#/")
556 ;
557 ASSERT_EQ("http://www.example.com/%23/", builder.uri().string());
558 }
559
560 TEST(builder_test, simple_port) {
561 network::uri_builder builder;
562 builder
563 .scheme("http")
564 .host("www.example.com")
565 .port(8000)
566 .path("/")
567 ;
568 ASSERT_EQ("http://www.example.com:8000/", builder.uri().string());
569 }
570
571 TEST(builder_test, build_uri_with_query_item) {
572 network::uri_builder builder;
573 builder
574 .scheme("http")
575 .host("www.example.com")
576 .append_query_key_value_pair("a", "1")
577 .path("/")
578 ;
579 ASSERT_EQ("http://www.example.com/?a=1", builder.uri().string());
580 }
581
582 TEST(builder_test, build_uri_with_multiple_query_items) {
583 network::uri_builder builder;
584 builder
585 .scheme("http")
586 .host("www.example.com")
587 .append_query_key_value_pair("a", "1")
588 .append_query_key_value_pair("b", "2")
589 .path("/")
590 ;
591 ASSERT_EQ("http://www.example.com/?a=1&b=2", builder.uri().string());
592 }
593
594 TEST(builder_test, build_uri_with_query_item_with_encoded_chars)
595 {
596 network::uri_builder builder;
597 builder
598 .scheme("http")
599 .host("www.example.com")
600 .append_query_key_value_pair("a", "parameter with encoded chars!")
601 .path("/")
602 ;
603 ASSERT_EQ("http://www.example.com/?a=parameter%20with%20encoded%20chars%21", builder.uri().string());
604 }
605
606 TEST(builder_test, build_uri_with_multiple_query_items_with_encoded_chars) {
607 network::uri_builder builder;
608 builder
609 .scheme("http")
610 .host("www.example.com")
611 .append_query_key_value_pair("a", "first parameter with encoded chars!")
612 .append_query_key_value_pair("b", "second parameter with encoded chars!")
613 .path("/")
614 ;
615 ASSERT_EQ("http://www.example.com/?a=first%20parameter%20with%20encoded%20chars%21&b=second%20parameter%20with%20encoded%20chars%21", builder.uri().string());
616 }
617
618 TEST(builder_test, construct_from_existing_uri) {
619 network::uri instance("http://www.example.com/");
620 network::uri_builder builder(instance);
621 ASSERT_EQ("http://www.example.com/", builder.uri().string());
622 }
623
624 TEST(builder_test, build_from_existing_uri) {
625 network::uri instance("http://www.example.com/");
626 network::uri_builder builder(instance);
627 builder.append_query_key_value_pair("a", "1").append_query_key_value_pair("b", "2").fragment("fragment");
628 ASSERT_EQ("http://www.example.com/?a=1&b=2#fragment", builder.uri().string());
629 }
630
631 TEST(builder_test, authority_without_port_test) {
632 network::uri_builder builder;
633 builder
634 .scheme("https")
635 .authority("www.example.com")
636 ;
637 ASSERT_EQ("www.example.com", builder.uri().authority());
638 }
639
640 TEST(builder_test, authority_with_port_test) {
641 network::uri_builder builder;
642 builder
643 .scheme("https")
644 .authority("www.example.com:")
645 ;
646 ASSERT_EQ("www.example.com:", builder.uri().authority());
647 }
648
649 TEST(builder_test, DISABLED_authority_without_host_test) {
650 network::uri_builder builder;
651 builder
652 .scheme("https")
653 .authority(":1234")
654 ;
655 ASSERT_EQ(":1234", builder.uri().authority());
656 }
657
658 TEST(builder_test, clear_user_info_test) {
659 network::uri instance("http://[email protected]:80/path?query#fragment");
660 network::uri_builder builder(instance);
661 builder.clear_user_info();
662 ASSERT_EQ("http://www.example.com:80/path?query#fragment", builder.uri().string());
663 }
664
665 TEST(builder_test, clear_port_test) {
666 network::uri instance("http://[email protected]:80/path?query#fragment");
667 network::uri_builder builder(instance);
668 builder.clear_port();
669 ASSERT_EQ("http://[email protected]/path?query#fragment", builder.uri().string());
670 }
671
672 TEST(builder_test, clear_path_test) {
673 network::uri instance("http://[email protected]:80/path?query#fragment");
674 network::uri_builder builder(instance);
675 builder.clear_path();
676 ASSERT_EQ("http://[email protected]:80?query#fragment", builder.uri().string());
677 }
678
679 TEST(builder_test, clear_query_test) {
680 network::uri instance("http://[email protected]:80/path?query#fragment");
681 network::uri_builder builder(instance);
682 builder.clear_query();
683 ASSERT_EQ("http://[email protected]:80/path#fragment", builder.uri().string());
684 }
685
686 TEST(uri_test, clear_query_params_with_no_query) {
687 network::uri original("http://example.com/path");
688 network::uri_builder builder(original);
689 builder.clear_query();
690 }
691
692 TEST(builder_test, clear_fragment_test) {
693 network::uri instance("http://[email protected]:80/path?query#fragment");
694 network::uri_builder builder(instance);
695 builder.clear_fragment();
696 ASSERT_EQ("http://[email protected]:80/path?query", builder.uri().string());
697 }
698
699 TEST(builder_test, empty_username) {
700 std::string user_info(":");
701 network::uri_builder builder;
702 builder.scheme("ftp").host("127.0.0.1").user_info(user_info);
703 ASSERT_EQ("ftp://:@127.0.0.1", builder.uri().string());
704 }
705
706 TEST(builder_test, path_should_be_prefixed_with_slash) {
707 std::string path("relative");
708 network::uri_builder builder;
709 builder.scheme("ftp").host("127.0.0.1").path(path);
710 ASSERT_EQ("ftp://127.0.0.1/relative", builder.uri().string());
711 }
712
713 TEST(builder_test, path_should_be_prefixed_with_slash_2) {
714 network::uri_builder builder;
715 builder
716 .scheme("ftp").host("127.0.0.1").path("noleadingslash/foo.txt");
717 ASSERT_EQ("/noleadingslash/foo.txt", builder.uri().path());
718 }
719
720 TEST(builder_test, set_multiple_query_with_encoding) {
721 network::uri_builder builder;
722 builder
723 .scheme("http")
724 .host("example.com")
725 .append_query_key_value_pair("q1", "foo bar")
726 .append_query_key_value_pair("q2", "biz baz")
727 ;
728 ASSERT_EQ("http://example.com?q1=foo%20bar&q2=biz%20baz", builder.uri().string());
729 }
730
731 TEST(builder_test, non_array_string_literals_should_work) {
732 const char* p = "http";
733 const char* q = "foo";
734
735 network::uri_builder builder;
736 builder
737 .scheme(p)
738 .host("example.com")
739 .path(q)
740 ;
741 ASSERT_EQ("http://example.com/foo", builder.uri());
742 }
743
744 TEST(builder_test, non_const_non_array_string_literals_should_work) {
745 const char* p = "http";
746 const char* q = "foo";
747
748 network::uri_builder builder;
749 builder
750 .scheme(const_cast<char *>(p))
751 .host("example.com")
752 .path(const_cast<char *>(q))
753 ;
754 ASSERT_EQ("http://example.com/foo", builder.uri());
755 }
756
757 TEST(builder_test, scheme_and_absolute_path) {
758 network::uri_builder builder;
759 builder
760 .scheme("foo")
761 .path("/bar")
762 ;
763 ASSERT_EQ("foo:/bar", builder.uri());
764 ASSERT_EQ("foo", builder.uri().scheme());
765 ASSERT_EQ("/bar", builder.uri().path());
766 }
767
768 TEST(builder_test, assignment_operator_bug_116) {
769 // https://github.com/cpp-netlib/uri/issues/116
770 network::uri a("http://a.com:1234");
771 ASSERT_TRUE(a.has_port());
772
773 const network::uri b("http://b.com");
774 ASSERT_FALSE(b.has_port());
775
776 a = b;
777 ASSERT_FALSE(a.has_port()) << a.string();
778 }
779
780 TEST(builder_test, construct_from_uri_bug_116) {
781 // https://github.com/cpp-netlib/uri/issues/116
782 network::uri a("http://a.com:1234");
783 const network::uri b("http://b.com");
784 a = b;
785
786 network::uri_builder ub(a);
787 const network::uri c(ub.uri());
788 ASSERT_FALSE(c.has_port()) << c.string();
789 }
790
791 TEST(builder_test, append_query_value) {
792 network::uri_builder ub(network::uri("http://example.com"));
793 ASSERT_NO_THROW(ub.append_query_component("q"));
794 ASSERT_EQ(network::string_view("q"), ub.uri().query_begin()->first);
795 }
796
797 TEST(builder_test, append_query_value_encodes_equal_sign) {
798 network::uri_builder ub(network::uri("http://example.com"));
799 ASSERT_NO_THROW(ub.append_query_component("="));
800 ASSERT_EQ(network::string_view("%3D"), ub.uri().query_begin()->first);
801 }
802
803 TEST(builder_test, append_query_key_value_pair_encodes_equals_sign) {
804 network::uri_builder ub(network::uri("http://example.com"));
805 ASSERT_NO_THROW(ub.append_query_key_value_pair("q", "="));
806 ASSERT_EQ(network::string_view("q"), ub.uri().query_begin()->first);
807 ASSERT_EQ(network::string_view("%3D"), ub.uri().query_begin()->second);
808 }
809
810 TEST(builder_test, append_query_key_value_pair_encodes_number_sign) {
811 network::uri_builder ub(network::uri("http://example.com"));
812 ASSERT_NO_THROW(ub.append_query_key_value_pair("q", "#"));
813 ASSERT_EQ(network::string_view("%23"), ub.uri().query_begin()->second);
814 }
815
816 TEST(builder_test, append_query_key_value_pair_encodes_percent_sign) {
817 network::uri_builder ub(network::uri("http://example.com"));
818 ASSERT_NO_THROW(ub.append_query_key_value_pair("q", "%"));
819 ASSERT_EQ(network::string_view("%25"), ub.uri().query_begin()->second);
820 }
821
822 TEST(builder_test, append_query_key_value_pair_encodes_ampersand) {
823 network::uri_builder ub(network::uri("http://example.com"));
824 ASSERT_NO_THROW(ub.append_query_key_value_pair("q", "&"));
825 ASSERT_EQ(network::string_view("%26"), ub.uri().query_begin()->second);
826 }
827
828 TEST(builder_test, append_query_key_value_pair_does_not_encode_slash) {
829 // https://tools.ietf.org/html/rfc3986#section-3.4
830 network::uri_builder ub(network::uri("http://example.com"));
831 ASSERT_NO_THROW(ub.append_query_key_value_pair("q", "/"));
832 ASSERT_EQ(network::string_view("/"), ub.uri().query_begin()->second);
833 }
834
835 TEST(builder_test, append_query_key_value_pair_does_not_encode_qmark) {
836 // https://tools.ietf.org/html/rfc3986#section-3.4
837 network::uri_builder ub(network::uri("http://example.com"));
838 ASSERT_NO_THROW(ub.append_query_key_value_pair("q", "?"));
839 ASSERT_EQ(network::string_view("?"), ub.uri().query_begin()->second);
840 }
841
842 TEST(builder_test, build_from_uri_with_encoded_user_info) {
843 network::uri_builder ub(network::uri("http://%[email protected]"));
844 ASSERT_EQ(network::string_view("%40"), ub.uri().user_info());
845 }
846
847 TEST(builder_test, build_from_uri_with_encoded_query) {
848 network::uri_builder ub(network::uri("http://example.com?x=%40"));
849 ASSERT_EQ(network::string_view("x=%40"), ub.uri().query());
850 }
851
852 TEST(builder_test, build_from_uri_with_encoded_fragment) {
853 network::uri_builder ub(network::uri("http://example.com#%40"));
854 ASSERT_EQ(network::string_view("%40"), ub.uri().fragment());
855 }