]> git.proxmox.com Git - ceph.git/blob - ceph/src/boost/libs/json/test/value.cpp
projects / ceph.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
import quincy beta 17.1.0
[ceph.git] / ceph / src / boost / libs / json / test / value.cpp
1 //
2 // Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com)
3 //
4 // Distributed under the Boost Software License, Version 1.0. (See accompanying
5 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6 //
7 // Official repository: https://github.com/boostorg/json
8 //
9
10 // Test that header file is self-contained.
11 #include <boost/json/value.hpp>
12
13 #include <boost/json/monotonic_resource.hpp>
14
15 #include <memory>
16 #include <string>
17 #include <vector>
18
19 #include "test.hpp"
20 #include "test_suite.hpp"
21
22 BOOST_JSON_NS_BEGIN
23
24 BOOST_STATIC_ASSERT( std::is_nothrow_destructible<value>::value );
25 BOOST_STATIC_ASSERT( std::is_nothrow_move_constructible<value>::value );
26
27 namespace {
28
29 template<class T>
30 static
31 T max_of()
32 {
33 return (std::numeric_limits<T>::max)();
34 }
35
36 template<class T>
37 static
38 T min_of()
39 {
40 return (std::numeric_limits<T>::min)();
41 }
42
43 } // (anon)
44
45 class value_test
46 {
47 public:
48 //BOOST_STATIC_ASSERT(has_value_from<short>::value);
49
50 string_view const str_;
51
52 value_test()
53 : str_(
54 "abcdefghijklmnopqrstuvwxyz")
55 {
56 // ensure this string does
57 // not fit in the SBO area.
58 BOOST_ASSERT(str_.size() >
59 string().capacity());
60 }
61
62 //------------------------------------------------------
63
64 void
65 testSpecial()
66 {
67 auto dsp = storage_ptr{};
68 auto sp = make_shared_resource<unique_resource>();
69
70 // ~value()
71 {
72 value(object{});
73 value(array{});
74 value(string{});
75 value(std::int64_t(0));
76 value(std::uint64_t(0));
77 value(double(0));
78 value(true);
79 value(nullptr);
80 }
81
82 // value()
83 {
84 value jv;
85 BOOST_TEST(*jv.storage() == *dsp);
86 }
87
88 // value(storage_ptr)
89 {
90 value jv(sp);
91 BOOST_TEST(*jv.storage() == *sp);
92 }
93
94 // value(pilfered<value>)
95 {
96 {
97 value jv1(object{});
98 value jv2(pilfer(jv1));
99 BOOST_TEST(jv2.is_object());
100 }
101 {
102 value jv1(array{});
103 value jv2(pilfer(jv1));
104 BOOST_TEST(jv2.is_array());
105 }
106 {
107 value jv1(string{});
108 value jv2(pilfer(jv1));
109 BOOST_TEST(jv2.is_string());
110 }
111 {
112 value jv1(std::int64_t{});
113 value jv2(pilfer(jv1));
114 BOOST_TEST(jv2.is_int64());
115 }
116 {
117 value jv1(std::uint64_t{});
118 value jv2(pilfer(jv1));
119 BOOST_TEST(jv2.is_uint64());
120 }
121 {
122 value jv1(double{});
123 value jv2(pilfer(jv1));
124 BOOST_TEST(jv2.is_double());
125 }
126 {
127 value jv1(true);
128 value jv2(pilfer(jv1));
129 BOOST_TEST(jv2.is_bool());
130 }
131 {
132 value jv1(nullptr);
133 value jv2(pilfer(jv1));
134 BOOST_TEST(jv2.is_null());
135 }
136
137 // ensure pilfered-from objects
138 // are trivially destructible
139 {
140 value v1(make_shared_resource<
141 monotonic_resource>());
142 value v2(pilfer(v1));
143 BOOST_TEST(v1.storage().get() ==
144 storage_ptr().get());
145 }
146 }
147
148 // value(value const&)
149 {
150 {
151 value jv1(object{});
152 value jv2(jv1);
153 BOOST_TEST(jv2.is_object());
154 }
155 {
156 value jv1(array{});
157 value jv2(jv1);
158 BOOST_TEST(jv2.is_array());
159 }
160 {
161 value jv1(string{});
162 value jv2(jv1);
163 BOOST_TEST(jv2.is_string());
164 }
165 {
166 value jv1(std::int64_t{});
167 value jv2(jv1);
168 BOOST_TEST(jv2.is_int64());
169 }
170 {
171 value jv1(std::uint64_t{});
172 value jv2(jv1);
173 BOOST_TEST(jv2.is_uint64());
174 }
175 {
176 value jv1(double{});
177 value jv2(jv1);
178 BOOST_TEST(jv2.is_double());
179 }
180 {
181 value jv1(true);
182 value jv2(jv1);
183 BOOST_TEST(jv2.is_bool());
184 }
185 {
186 value jv1(nullptr);
187 value jv2(jv1);
188 BOOST_TEST(jv2.is_null());
189 }
190 }
191
192 // value(value const&, storage_ptr)
193 {
194 {
195 value jv1(object{});
196 value jv2(jv1, sp);
197 BOOST_TEST(jv2.is_object());
198 BOOST_TEST(*jv2.storage() == *sp);
199 }
200 {
201 value jv1(array{});
202 value jv2(jv1, sp);
203 BOOST_TEST(jv2.is_array());
204 BOOST_TEST(*jv2.storage() == *sp);
205 }
206 {
207 value jv1(string{});
208 value jv2(jv1, sp);
209 BOOST_TEST(jv2.is_string());
210 BOOST_TEST(*jv2.storage() == *sp);
211 }
212 {
213 value jv1(std::int64_t{});
214 value jv2(jv1, sp);
215 BOOST_TEST(jv2.is_int64());
216 BOOST_TEST(*jv2.storage() == *sp);
217 }
218 {
219 value jv1(std::uint64_t{});
220 value jv2(jv1, sp);
221 BOOST_TEST(jv2.is_uint64());
222 BOOST_TEST(*jv2.storage() == *sp);
223 }
224 {
225 value jv1(double{});
226 value jv2(jv1, sp);
227 BOOST_TEST(jv2.is_double());
228 BOOST_TEST(*jv2.storage() == *sp);
229 }
230 {
231 value jv1(true);
232 value jv2(jv1, sp);
233 BOOST_TEST(jv2.is_bool());
234 BOOST_TEST(*jv2.storage() == *sp);
235 }
236 {
237 value jv1(nullptr);
238 value jv2(jv1, sp);
239 BOOST_TEST(jv2.is_null());
240 BOOST_TEST(*jv2.storage() == *sp);
241 }
242 }
243
244 // value(value&&)
245 {
246 {
247 value jv1(object{});
248 value jv2(std::move(jv1));
249 BOOST_TEST(jv2.is_object());
250 }
251 {
252 value jv1(array{});
253 value jv2(std::move(jv1));
254 BOOST_TEST(jv2.is_array());
255 }
256 {
257 value jv1(string{});
258 value jv2(std::move(jv1));
259 BOOST_TEST(jv2.is_string());
260 }
261 {
262 value jv1(std::int64_t{});
263 value jv2(std::move(jv1));
264 BOOST_TEST(jv2.is_int64());
265 }
266 {
267 value jv1(std::uint64_t{});
268 value jv2(std::move(jv1));
269 BOOST_TEST(jv2.is_uint64());
270 }
271 {
272 value jv1(double{});
273 value jv2(std::move(jv1));
274 BOOST_TEST(jv2.is_double());
275 }
276 {
277 value jv1(true);
278 value jv2(std::move(jv1));
279 BOOST_TEST(jv2.is_bool());
280 }
281 {
282 value jv1(nullptr);
283 value jv2(std::move(jv1));
284 BOOST_TEST(jv2.is_null());
285 }
286 }
287
288 // value(value&&, storage_ptr)
289 {
290 {
291 value jv1(object{});
292 value jv2(std::move(jv1), sp);
293 BOOST_TEST(jv2.is_object());
294 }
295 {
296 value jv1(array{});
297 value jv2(std::move(jv1), sp);
298 BOOST_TEST(jv2.is_array());
299 }
300 {
301 value jv1(string{});
302 value jv2(std::move(jv1), sp);
303 BOOST_TEST(jv2.is_string());
304 }
305 {
306 value jv1(std::int64_t{});
307 value jv2(std::move(jv1), sp);
308 BOOST_TEST(jv2.is_int64());
309 }
310 {
311 value jv1(std::uint64_t{});
312 value jv2(std::move(jv1), sp);
313 BOOST_TEST(jv2.is_uint64());
314 }
315 {
316 value jv1(double{});
317 value jv2(std::move(jv1), sp);
318 BOOST_TEST(jv2.is_double());
319 }
320 {
321 value jv1(true);
322 value jv2(std::move(jv1), sp);
323 BOOST_TEST(jv2.is_bool());
324 }
325 {
326 value jv1(nullptr);
327 value jv2(std::move(jv1), sp);
328 BOOST_TEST(jv2.is_null());
329 }
330 }
331 }
332
333 void
334 testConversion()
335 {
336 auto dsp = storage_ptr{};
337 auto sp = make_shared_resource<unique_resource>();
338
339 // value(object)
340 // value(object, storage_ptr)
341 // value(object_kind, storage_ptr)
342 {
343 {
344 auto jv = value(object());
345 BOOST_TEST(jv.is_object());
346 BOOST_TEST(*jv.storage() == *dsp);
347 }
348 {
349 auto jv = value(object(sp));
350 BOOST_TEST(jv.is_object());
351 BOOST_TEST(*jv.storage() == *sp);
352 }
353 {
354 auto jv = value(object(), sp);
355 BOOST_TEST(jv.is_object());
356 BOOST_TEST(*jv.storage() == *sp);
357 }
358 {
359 auto jv = value(object_kind);
360 BOOST_TEST(jv.is_object());
361 BOOST_TEST(*jv.storage() == *dsp);
362 }
363 {
364 auto jv = value(object_kind, sp);
365 BOOST_TEST(jv.is_object());
366 BOOST_TEST(*jv.storage() == *sp);
367 }
368 {
369 // verify moved from
370 object obj{{"a", 1}, {"b", 2}};
371 BOOST_TEST(obj.capacity() > 0);
372 value jv(std::move(obj), {});
373 BOOST_TEST(obj.capacity() == 0);
374 }
375 }
376
377 // value(array)
378 // value(array, storage_ptr)
379 // value(object_kind, storage_ptr)
380 {
381 {
382 auto jv = value(array());
383 BOOST_TEST(jv.is_array());
384 BOOST_TEST(*jv.storage() == *dsp);
385 }
386 {
387 auto jv = value(array(sp));
388 BOOST_TEST(jv.is_array());
389 BOOST_TEST(*jv.storage() == *sp);
390 }
391 {
392 auto jv = value(array(), sp);
393 BOOST_TEST(jv.is_array());
394 BOOST_TEST(*jv.storage() == *sp);
395 }
396 {
397 auto jv = value(array_kind);
398 BOOST_TEST(jv.is_array());
399 BOOST_TEST(*jv.storage() == *dsp);
400 }
401 {
402 auto jv = value(array_kind, sp);
403 BOOST_TEST(jv.is_array());
404 BOOST_TEST(*jv.storage() == *sp);
405 }
406 }
407
408 // value(string)
409 // value(string, storage_ptr)
410 {
411 {
412 auto jv = value(string());
413 BOOST_TEST(jv.is_string());
414 BOOST_TEST(*jv.storage() == *dsp);
415 }
416 {
417 auto jv = value(string(sp));
418 BOOST_TEST(jv.is_string());
419 BOOST_TEST(*jv.storage() == *sp);
420 }
421 {
422 auto jv = value(string(), sp);
423 BOOST_TEST(jv.is_string());
424 BOOST_TEST(*jv.storage() == *sp);
425 }
426 }
427
428 // value(int64)
429 // value(int64, storage_ptr)
430 {
431 {
432 auto jv = value(std::int64_t{-65536});
433 BOOST_TEST(jv.is_int64());
434 BOOST_TEST(*jv.storage() == *dsp);
435 }
436 {
437 auto jv = value(std::int64_t{-65536}, sp);
438 BOOST_TEST(jv.is_int64());
439 BOOST_TEST(*jv.storage() == *sp);
440 }
441 }
442
443 // value(uint64)
444 // value(uint64, storage_ptr)
445 {
446 {
447 auto jv = value(std::uint64_t{65536});
448 BOOST_TEST(jv.is_uint64());
449 BOOST_TEST(*jv.storage() == *dsp);
450 }
451 {
452 auto jv = value(std::uint64_t{65536}, sp);
453 BOOST_TEST(jv.is_uint64());
454 BOOST_TEST(*jv.storage() == *sp);
455 }
456 }
457
458 // value(double)
459 // value(double, storage_ptr)
460 {
461 {
462 auto jv = value(double{3.141});
463 BOOST_TEST(jv.is_double());
464 BOOST_TEST(*jv.storage() == *dsp);
465 }
466 {
467 auto jv = value(double{3.141}, sp);
468 BOOST_TEST(jv.is_double());
469 BOOST_TEST(*jv.storage() == *sp);
470 }
471 }
472
473 // value(bool)
474 // value(bool, storage_ptr)
475 {
476 {
477 auto jv = value(true);
478 BOOST_TEST(jv.is_bool());
479 BOOST_TEST(*jv.storage() == *dsp);
480 }
481 {
482 auto jv = value(true, sp);
483 BOOST_TEST(jv.is_bool());
484 BOOST_TEST(*jv.storage() == *sp);
485 }
486 }
487
488 // value(nullptr_t)
489 // value(nullptr_t, storage_ptr)
490 {
491 {
492 auto jv = value(nullptr);
493 BOOST_TEST(jv.is_null());
494 BOOST_TEST(*jv.storage() == *dsp);
495 }
496 {
497 auto jv = value(nullptr, sp);
498 BOOST_TEST(jv.is_null());
499 BOOST_TEST(*jv.storage() == *sp);
500 }
501 }
502
503 // value(initializer_list)
504 // value(initializer_list, storage_ptr)
505 {
506 {
507 value jv({1, 2, 3});
508 BOOST_TEST(jv.is_array());
509 BOOST_TEST(*jv.storage() == *dsp);
510 }
511 {
512 value jv({1, 2, 3}, sp);
513 BOOST_TEST(jv.is_array());
514 BOOST_TEST(*jv.storage() == *sp);
515 }
516 {
517 value jv({{"a",1},{"b",2},{"c",3}});
518 BOOST_TEST(jv.is_object());
519 BOOST_TEST(*jv.storage() == *dsp);
520 }
521 {
522 value jv({{"a",1},{"b",2},{"c",3}}, sp);
523 BOOST_TEST(jv.is_object());
524 BOOST_TEST(*jv.storage() == *sp);
525 }
526 }
527 }
528
529 void
530 testAssignment()
531 {
532 auto dsp = storage_ptr{};
533 auto sp = make_shared_resource<unique_resource>();
534
535 // operator=(value const&)
536 {
537 {
538 value jv1(object{});
539 value jv2;
540 jv2 = jv1;
541 BOOST_TEST(jv2.is_object());
542 }
543 {
544 value jv1(array{});
545 value jv2;
546 jv2 = jv1;
547 BOOST_TEST(jv2.is_array());
548 }
549 {
550 value jv1(string{});
551 value jv2;
552 jv2 = jv1;
553 BOOST_TEST(jv2.is_string());
554 }
555 {
556 value jv1(std::int64_t{});
557 value jv2;
558 jv2 = jv1;
559 BOOST_TEST(jv2.is_int64());
560 }
561 {
562 value jv1(std::uint64_t{});
563 value jv2;
564 jv2 = jv1;
565 BOOST_TEST(jv2.is_uint64());
566 }
567 {
568 value jv1(double{});
569 value jv2;
570 jv2 = jv1;
571 BOOST_TEST(jv2.is_double());
572 }
573 {
574 value jv1(true);
575 value jv2;
576 jv2 = jv1;
577 BOOST_TEST(jv2.is_bool());
578 }
579 {
580 value jv1(nullptr);
581 value jv2;
582 jv2 = jv1;
583 BOOST_TEST(jv2.is_null());
584 }
585
586 fail_loop([&](storage_ptr const sp)
587 {
588 value jv1({1, 2, 3, 4, 5});
589 value jv2(sp);
590 jv2 = jv1;
591 BOOST_TEST(jv2.as_array().size() == 5);
592 });
593
594 fail_loop([&](storage_ptr const sp)
595 {
596 value jv1({
597 {"a",1},{"b",2},{"c",3}});
598 value jv2(sp);
599 jv2 = jv1;
600 BOOST_TEST(jv2.as_object().size() == 3);
601 });
602
603 fail_loop([&](storage_ptr const sp)
604 {
605 value jv1(str_);
606 value jv2(sp);
607 jv2 = jv1;
608 BOOST_TEST(jv2.as_string() == str_);
609 });
610
611 // self-assign
612 {
613 value jv = { 1, 2, 3 };
614 jv = static_cast<value const&>(jv);
615 BOOST_TEST(jv == value({1, 2, 3}));
616 }
617
618 // copy from child
619 {
620 value jv = { 1, 2, 3 };
621 jv = jv.at(1);
622 BOOST_TEST(
623 *jv.if_int64() == 2);
624 }
625 }
626
627 // operator=(value&&)
628 {
629 {
630 value jv;
631 jv = value(object{});
632 BOOST_TEST(jv.is_object());
633 }
634 {
635 value jv;
636 jv = value(array{});
637 BOOST_TEST(jv.is_array());
638 }
639 {
640 value jv;
641 jv = value(string{});
642 BOOST_TEST(jv.is_string());
643 }
644 {
645 value jv;
646 jv = value(std::int64_t{});
647 BOOST_TEST(jv.is_int64());
648 }
649 {
650 value jv;
651 jv = value(std::uint64_t{});
652 BOOST_TEST(jv.is_uint64());
653 }
654 {
655 value jv;
656 jv = value(double{});
657 BOOST_TEST(jv.is_double());
658 }
659 {
660 value jv;
661 jv = value(true);
662 BOOST_TEST(jv.is_bool());
663 }
664 {
665 value jv;
666 jv = value(nullptr);
667 BOOST_TEST(jv.is_null());
668 }
669
670 fail_loop([&](storage_ptr const sp)
671 {
672 value jv(sp);
673 jv = value({
674 { {"a",1}, {"b",2u} },
675 { 1, 2 },
676 "hello",
677 1,
678 2u,
679 3.,
680 true,
681 nullptr
682 });
683 BOOST_TEST(jv.as_array().size() == 8);
684 });
685
686 fail_loop([&](storage_ptr const sp)
687 {
688 value jv(sp);
689 jv = value({
690 { "aa", { {"a",1}, {"b",2u} } },
691 { "bb", { 1, 2 } },
692 { "cc", "hello" },
693 { "dd", 1 },
694 { "ee", 2u },
695 { "ff", 3. },
696 { "gg", true },
697 { "hh", nullptr },
698 });
699 BOOST_TEST(jv.as_object().size() == 8);
700 });
701
702 fail_loop([&](storage_ptr const sp)
703 {
704 value jv(sp);
705 jv = value(str_);
706 BOOST_TEST(jv.as_string() == str_);
707 });
708
709 // self-move
710 {
711 value jv = { 1, 2, 3 };
712 value* p = &jv;
713 jv = std::move(*p);
714 BOOST_TEST(jv == value({1, 2, 3}));
715 }
716
717 // move from child
718 {
719 value jv = { 1, 2, 3 };
720 jv = std::move(jv.at(1));
721 BOOST_TEST(
722 *jv.if_int64() == 2);
723 }
724 }
725
726 // operator=(initializer_list)
727 {
728 value jv;
729 jv = {1, 2, 3};
730 BOOST_TEST(jv.is_array());
731 BOOST_TEST(*jv.storage() == *dsp);
732 BOOST_TEST(jv.at(0).as_int64() == 1);
733 BOOST_TEST(jv.at(1).as_int64() == 2);
734 BOOST_TEST(jv.at(2).as_int64() == 3);
735 }
736
737 // operator=(nullptr_t)
738 {
739 {
740 value jv = 1;
741 BOOST_TEST(! jv.is_null());
742 jv = nullptr;
743 BOOST_TEST(jv.is_null());
744 }
745 {
746 value jv = "string";
747 BOOST_TEST(! jv.is_null());
748 jv = nullptr;
749 BOOST_TEST(jv.is_null());
750 }
751 }
752
753 // operator=(bool)
754 {
755 {
756 value jv = 1;
757 BOOST_TEST(! jv.is_bool());
758 jv = true;
759 BOOST_TEST(jv.is_bool());
760 }
761 {
762 value jv = "string";
763 BOOST_TEST(! jv.is_bool());
764 jv = true;
765 BOOST_TEST(jv.is_bool());
766 }
767 }
768
769 // operator=(int64)
770 {
771 {
772 value jv = false;
773 BOOST_TEST(! jv.is_int64());
774 jv = std::int64_t{-65536};
775 BOOST_TEST(jv.is_int64());
776 }
777 {
778 value jv = "string";
779 BOOST_TEST(! jv.is_int64());
780 jv = std::int64_t{-65536};
781 BOOST_TEST(jv.is_int64());
782 }
783 }
784
785 // operator=(uint64)
786 {
787 {
788 value jv = false;
789 BOOST_TEST(! jv.is_uint64());
790 jv = std::uint64_t{65536};
791 BOOST_TEST(jv.is_uint64());
792 }
793 {
794 value jv = "string";
795 BOOST_TEST(! jv.is_uint64());
796 jv = std::uint64_t{65536};
797 BOOST_TEST(jv.is_uint64());
798 }
799 }
800
801 // operator=(double)
802 {
803 {
804 value jv = false;
805 BOOST_TEST(! jv.is_double());
806 jv = double{3.141};
807 BOOST_TEST(jv.is_double());
808 }
809 {
810 value jv = "string";
811 BOOST_TEST(! jv.is_double());
812 jv = double{3.141};
813 BOOST_TEST(jv.is_double());
814 }
815 }
816
817 // operator=(string)
818 {
819 {
820 value jv;
821 jv = string();
822 BOOST_TEST(jv.is_string());
823 BOOST_TEST(*jv.storage() == *dsp);
824 }
825 {
826 value jv(sp);
827 jv = string();
828 BOOST_TEST(jv.is_string());
829 BOOST_TEST(*jv.storage() == *sp);
830 }
831 }
832
833 // operator=(array)
834 {
835 {
836 value jv;
837 jv = array();
838 BOOST_TEST(jv.is_array());
839 BOOST_TEST(*jv.storage() == *dsp);
840 }
841 {
842 value jv(sp);
843 jv = array();
844 BOOST_TEST(jv.is_array());
845 BOOST_TEST(*jv.storage() == *sp);
846 }
847 }
848
849 // operator=(object)
850 {
851 {
852 value jv;
853 jv = object();
854 BOOST_TEST(*jv.storage() == *dsp);
855 BOOST_TEST(jv.is_object());
856 }
857 {
858 value jv(sp);
859 jv = object();
860 BOOST_TEST(jv.is_object());
861 BOOST_TEST(*jv.storage() == *sp);
862 }
863 }
864 }
865
866 void
867 testModifiers()
868 {
869 // emplace
870 {
871 BOOST_TEST(value().emplace_object().empty());
872 BOOST_TEST(value().emplace_array().empty());
873 BOOST_TEST(value().emplace_string().empty());
874 BOOST_TEST(value().emplace_int64() == 0);
875 BOOST_TEST(value().emplace_uint64() == 0);
876 BOOST_TEST(value().emplace_double() == 0);
877 BOOST_TEST(value().emplace_bool() = true);
878 {
879 value jv(object_kind);
880 jv.emplace_null();
881 BOOST_TEST(jv.is_null());
882 }
883 {
884 value jv(array_kind);
885 jv.emplace_null();
886 BOOST_TEST(jv.is_null());
887 }
888 {
889 value jv(string_kind);
890 jv.emplace_null();
891 BOOST_TEST(jv.is_null());
892 }
893 {
894 value jv(-1);
895 jv.emplace_null();
896 BOOST_TEST(jv.is_null());
897 }
898 {
899 value jv(1U);
900 jv.emplace_null();
901 BOOST_TEST(jv.is_null());
902 }
903 {
904 value jv(1.0);
905 jv.emplace_null();
906 BOOST_TEST(jv.is_null());
907 }
908 {
909 value jv(false);
910 jv.emplace_null();
911 BOOST_TEST(jv.is_null());
912 }
913 {
914 value jv;
915 jv.emplace_null();
916 BOOST_TEST(jv.is_null());
917 }
918 }
919
920 // swap
921 {
922 {
923 // self-swap
924 value jv;
925 swap(jv, jv);
926 }
927 {
928 value jv1(1);
929 value jv2("abc");
930 BOOST_TEST(
931 *jv1.storage() == *jv2.storage());
932 swap(jv1, jv2);
933 BOOST_TEST(jv1.as_string() == "abc");
934 BOOST_TEST(jv2.as_int64() == 1);
935 }
936
937 // different storage
938 fail_loop([&](storage_ptr const& sp)
939 {
940 value jv1(1);
941 value jv2("abc", sp);
942 BOOST_TEST(
943 *jv1.storage() != *jv2.storage());
944 swap(jv1, jv2);
945 BOOST_TEST(jv1.as_string() == "abc");
946 BOOST_TEST(jv2.as_int64() == 1);
947 });
948 }
949 }
950
951 template<typename T>
952 using tt = T;
953
954 void
955 testExchange()
956 {
957 // string{}
958 {
959 BOOST_TEST(value("abc").is_string());
960 BOOST_TEST(value(std::string()).is_string());
961 BOOST_TEST(value(string_view()).is_string());
962
963 { value jv; BOOST_TEST((jv = "abc").is_string()); }
964 { value jv; BOOST_TEST((jv = std::string()).is_string()); }
965 { value jv; BOOST_TEST((jv = string_view()).is_string()); }
966 }
967
968 // numbers
969 {
970 BOOST_TEST(value(tt<signed char>{}).is_int64());
971 BOOST_TEST(value(tt<short>{}).is_int64());
972 BOOST_TEST(value(tt<int>{}).is_int64());
973 BOOST_TEST(value(tt<long>{}).is_int64());
974 BOOST_TEST(value(tt<long long>{}).is_int64());
975 BOOST_TEST(value(tt<unsigned char>{}).is_uint64());
976 BOOST_TEST(value(tt<unsigned short>{}).is_uint64());
977 BOOST_TEST(value(tt<unsigned int>{}).is_uint64());
978 BOOST_TEST(value(tt<unsigned long>{}).is_uint64());
979 BOOST_TEST(value(tt<unsigned long long>{}).is_uint64());
980 BOOST_TEST(value(tt<float>{}).is_double());
981 BOOST_TEST(value(tt<double>{}).is_double());
982
983 { value jv; BOOST_TEST((jv = tt<signed char>{}).is_int64()); }
984 { value jv; BOOST_TEST((jv = tt<short>{}).is_int64()); }
985 { value jv; BOOST_TEST((jv = tt<int>{}).is_int64()); }
986 { value jv; BOOST_TEST((jv = tt<long>{}).is_int64()); }
987 { value jv; BOOST_TEST((jv = tt<long long>{}).is_int64()); }
988 { value jv; BOOST_TEST((jv = tt<unsigned char>{}).is_uint64()); }
989 { value jv; BOOST_TEST((jv = tt<unsigned short>{}).is_uint64()); }
990 { value jv; BOOST_TEST((jv = tt<unsigned int>{}).is_uint64()); }
991 { value jv; BOOST_TEST((jv = tt<unsigned long>{}).is_uint64()); }
992 { value jv; BOOST_TEST((jv = tt<unsigned long long>{}).is_uint64()); }
993 { value jv; BOOST_TEST((jv = tt<float>{}).is_double()); }
994 { value jv; BOOST_TEST((jv = tt<double>{}).is_double()); }
995 }
996
997 // bool
998 {
999 BOOST_TEST(value(true).is_bool());
1000 BOOST_TEST(value(false).is_bool());
1001
1002 { value jv; BOOST_TEST((jv = true).is_bool()); }
1003 { value jv; BOOST_TEST((jv = false).is_bool()); }
1004 }
1005
1006 // nullptr
1007 {
1008 BOOST_TEST(value(nullptr).is_null());
1009
1010 { value jv("x"); BOOST_TEST((jv = nullptr).is_null()); }
1011 }
1012
1013 // VFALCO TODO store()
1014 }
1015
1016 void
1017 testObservers()
1018 {
1019 value const obj(object{});
1020 value const arr(array{});
1021 value const str(string{});
1022 value const i64(std::int64_t{});
1023 value const u64(std::uint64_t{});
1024 value const dub(double{});
1025 value const boo(true);
1026 value const nul(nullptr);
1027
1028 // kind()
1029 {
1030 BOOST_TEST(obj.kind() == kind::object);
1031 BOOST_TEST(arr.kind() == kind::array);
1032 BOOST_TEST(str.kind() == kind::string);
1033 BOOST_TEST(i64.kind() == kind::int64);
1034 BOOST_TEST(u64.kind() == kind::uint64);
1035 BOOST_TEST(dub.kind() == kind::double_);
1036 BOOST_TEST(boo.kind() == kind::bool_);
1037 BOOST_TEST(nul.kind() == kind::null);
1038 }
1039
1040 // is_object()
1041 {
1042 BOOST_TEST( obj.is_object());
1043 BOOST_TEST(! arr.is_object());
1044 BOOST_TEST(! str.is_object());
1045 BOOST_TEST(! i64.is_object());
1046 BOOST_TEST(! u64.is_object());
1047 BOOST_TEST(! dub.is_object());
1048 BOOST_TEST(! boo.is_object());
1049 BOOST_TEST(! nul.is_object());
1050 }
1051
1052 // is_array()
1053 {
1054 BOOST_TEST(! obj.is_array());
1055 BOOST_TEST( arr.is_array());
1056 BOOST_TEST(! str.is_array());
1057 BOOST_TEST(! i64.is_array());
1058 BOOST_TEST(! u64.is_array());
1059 BOOST_TEST(! dub.is_array());
1060 BOOST_TEST(! boo.is_array());
1061 BOOST_TEST(! nul.is_array());
1062 }
1063
1064 // is_string()
1065 {
1066 BOOST_TEST(! obj.is_string());
1067 BOOST_TEST(! arr.is_string());
1068 BOOST_TEST( str.is_string());
1069 BOOST_TEST(! i64.is_string());
1070 BOOST_TEST(! u64.is_string());
1071 BOOST_TEST(! dub.is_string());
1072 BOOST_TEST(! boo.is_string());
1073 BOOST_TEST(! nul.is_string());
1074 }
1075
1076 // is_int64()
1077 {
1078 BOOST_TEST(! obj.is_int64());
1079 BOOST_TEST(! arr.is_int64());
1080 BOOST_TEST(! str.is_int64());
1081 BOOST_TEST( i64.is_int64());
1082 BOOST_TEST(! u64.is_int64());
1083 BOOST_TEST(! dub.is_int64());
1084 BOOST_TEST(! boo.is_int64());
1085 BOOST_TEST(! nul.is_int64());
1086 }
1087
1088 // is_uint64()
1089 {
1090 BOOST_TEST(! obj.is_uint64());
1091 BOOST_TEST(! arr.is_uint64());
1092 BOOST_TEST(! str.is_uint64());
1093 BOOST_TEST(! i64.is_uint64());
1094 BOOST_TEST( u64.is_uint64());
1095 BOOST_TEST(! dub.is_uint64());
1096 BOOST_TEST(! boo.is_uint64());
1097 BOOST_TEST(! nul.is_uint64());
1098 }
1099
1100 // is_double()
1101 {
1102 BOOST_TEST(! obj.is_double());
1103 BOOST_TEST(! arr.is_double());
1104 BOOST_TEST(! str.is_double());
1105 BOOST_TEST(! i64.is_double());
1106 BOOST_TEST(! u64.is_double());
1107 BOOST_TEST( dub.is_double());
1108 BOOST_TEST(! boo.is_double());
1109 BOOST_TEST(! nul.is_double());
1110 }
1111
1112 // is_bool()
1113 {
1114 BOOST_TEST(! obj.is_bool());
1115 BOOST_TEST(! arr.is_bool());
1116 BOOST_TEST(! str.is_bool());
1117 BOOST_TEST(! i64.is_bool());
1118 BOOST_TEST(! u64.is_bool());
1119 BOOST_TEST(! dub.is_bool());
1120 BOOST_TEST( boo.is_bool());
1121 BOOST_TEST(! nul.is_bool());
1122 }
1123
1124 // is_null()
1125 {
1126 BOOST_TEST(! obj.is_null());
1127 BOOST_TEST(! arr.is_null());
1128 BOOST_TEST(! str.is_null());
1129 BOOST_TEST(! i64.is_null());
1130 BOOST_TEST(! u64.is_null());
1131 BOOST_TEST(! dub.is_null());
1132 BOOST_TEST(! boo.is_null());
1133 BOOST_TEST( nul.is_null());
1134 }
1135
1136 // is_number()
1137 {
1138 BOOST_TEST(! obj.is_number());
1139 BOOST_TEST(! arr.is_number());
1140 BOOST_TEST(! str.is_number());
1141 BOOST_TEST( i64.is_number());
1142 BOOST_TEST( u64.is_number());
1143 BOOST_TEST( dub.is_number());
1144 BOOST_TEST(! boo.is_number());
1145 BOOST_TEST(! nul.is_number());
1146 }
1147
1148 // is_primitive()
1149 {
1150 BOOST_TEST(! obj.is_primitive());
1151 BOOST_TEST(! arr.is_primitive());
1152 BOOST_TEST( str.is_primitive());
1153 BOOST_TEST( i64.is_primitive());
1154 BOOST_TEST( u64.is_primitive());
1155 BOOST_TEST( dub.is_primitive());
1156 BOOST_TEST( boo.is_primitive());
1157 BOOST_TEST( nul.is_primitive());
1158 }
1159
1160 // is_structured()
1161 {
1162 BOOST_TEST( obj.is_structured());
1163 BOOST_TEST( arr.is_structured());
1164 BOOST_TEST(! str.is_structured());
1165 BOOST_TEST(! i64.is_structured());
1166 BOOST_TEST(! u64.is_structured());
1167 BOOST_TEST(! dub.is_structured());
1168 BOOST_TEST(! boo.is_structured());
1169 BOOST_TEST(! nul.is_structured());
1170 }
1171 }
1172
1173 //------------------------------------------------------
1174 //
1175 // Accessors
1176 //
1177 //------------------------------------------------------
1178
1179 void
1180 testGetStorage()
1181 {
1182 auto const sp =
1183 make_shared_resource<unique_resource>();
1184
1185 value obj(object{}, sp);
1186 value arr(array{}, sp);
1187 value str(string{}, sp);
1188 value i64(std::int64_t{}, sp);
1189 value u64(std::uint64_t{}, sp);
1190 value dub(double{}, sp);
1191 value boo(true, sp);
1192 value nul(nullptr, sp);
1193
1194 // storage()
1195 {
1196 BOOST_TEST(*obj.storage() == *sp);
1197 BOOST_TEST(*arr.storage() == *sp);
1198 BOOST_TEST(*str.storage() == *sp);
1199 BOOST_TEST(*i64.storage() == *sp);
1200 BOOST_TEST(*u64.storage() == *sp);
1201 BOOST_TEST(*dub.storage() == *sp);
1202 BOOST_TEST(*boo.storage() == *sp);
1203 BOOST_TEST(*nul.storage() == *sp);
1204 }
1205 }
1206
1207 void
1208 testIf()
1209 {
1210 value obj(object{});
1211 value arr(array{});
1212 value str(string{});
1213 value i64(std::int64_t{});
1214 value u64(std::uint64_t{});
1215 value dub(double{});
1216 value boo(true);
1217 value nul(nullptr);
1218
1219 auto const& cobj(obj);
1220 auto const& carr(arr);
1221 auto const& cstr(str);
1222 auto const& ci64(i64);
1223 auto const& cu64(u64);
1224 auto const& cdub(dub);
1225 auto const& cboo(boo);
1226 auto const& cnul(nul);
1227
1228 // if_object()
1229 {
1230 BOOST_TEST(obj.if_object() != nullptr);
1231 BOOST_TEST(arr.if_object() == nullptr);
1232 BOOST_TEST(str.if_object() == nullptr);
1233 BOOST_TEST(i64.if_object() == nullptr);
1234 BOOST_TEST(u64.if_object() == nullptr);
1235 BOOST_TEST(dub.if_object() == nullptr);
1236 BOOST_TEST(boo.if_object() == nullptr);
1237 BOOST_TEST(nul.if_object() == nullptr);
1238 }
1239
1240 // if_object() const
1241 {
1242 BOOST_TEST(cobj.if_object() != nullptr);
1243 BOOST_TEST(carr.if_object() == nullptr);
1244 BOOST_TEST(cstr.if_object() == nullptr);
1245 BOOST_TEST(ci64.if_object() == nullptr);
1246 BOOST_TEST(cu64.if_object() == nullptr);
1247 BOOST_TEST(cdub.if_object() == nullptr);
1248 BOOST_TEST(cboo.if_object() == nullptr);
1249 BOOST_TEST(cnul.if_object() == nullptr);
1250 }
1251
1252 // if_array()
1253 {
1254 BOOST_TEST(obj.if_array() == nullptr);
1255 BOOST_TEST(arr.if_array() != nullptr);
1256 BOOST_TEST(str.if_array() == nullptr);
1257 BOOST_TEST(i64.if_array() == nullptr);
1258 BOOST_TEST(u64.if_array() == nullptr);
1259 BOOST_TEST(dub.if_array() == nullptr);
1260 BOOST_TEST(boo.if_array() == nullptr);
1261 BOOST_TEST(nul.if_array() == nullptr);
1262 }
1263
1264 // if_array() const
1265 {
1266 BOOST_TEST(cobj.if_array() == nullptr);
1267 BOOST_TEST(carr.if_array() != nullptr);
1268 BOOST_TEST(cstr.if_array() == nullptr);
1269 BOOST_TEST(ci64.if_array() == nullptr);
1270 BOOST_TEST(cu64.if_array() == nullptr);
1271 BOOST_TEST(cdub.if_array() == nullptr);
1272 BOOST_TEST(cboo.if_array() == nullptr);
1273 BOOST_TEST(cnul.if_array() == nullptr);
1274 }
1275
1276 // if_string()
1277 {
1278 BOOST_TEST(obj.if_string() == nullptr);
1279 BOOST_TEST(arr.if_string() == nullptr);
1280 BOOST_TEST(str.if_string() != nullptr);
1281 BOOST_TEST(i64.if_string() == nullptr);
1282 BOOST_TEST(u64.if_string() == nullptr);
1283 BOOST_TEST(dub.if_string() == nullptr);
1284 BOOST_TEST(boo.if_string() == nullptr);
1285 BOOST_TEST(nul.if_string() == nullptr);
1286 }
1287
1288 // if_string() const
1289 {
1290 BOOST_TEST(cobj.if_string() == nullptr);
1291 BOOST_TEST(carr.if_string() == nullptr);
1292 BOOST_TEST(cstr.if_string() != nullptr);
1293 BOOST_TEST(ci64.if_string() == nullptr);
1294 BOOST_TEST(cu64.if_string() == nullptr);
1295 BOOST_TEST(cdub.if_string() == nullptr);
1296 BOOST_TEST(cboo.if_string() == nullptr);
1297 BOOST_TEST(cnul.if_string() == nullptr);
1298 }
1299
1300 // if_int64()
1301 {
1302 BOOST_TEST(obj.if_int64() == nullptr);
1303 BOOST_TEST(arr.if_int64() == nullptr);
1304 BOOST_TEST(str.if_int64() == nullptr);
1305 BOOST_TEST(i64.if_int64() != nullptr);
1306 BOOST_TEST(u64.if_int64() == nullptr);
1307 BOOST_TEST(dub.if_int64() == nullptr);
1308 BOOST_TEST(boo.if_int64() == nullptr);
1309 BOOST_TEST(nul.if_int64() == nullptr);
1310 }
1311
1312 // if_int64() const
1313 {
1314 BOOST_TEST(cobj.if_int64() == nullptr);
1315 BOOST_TEST(carr.if_int64() == nullptr);
1316 BOOST_TEST(cstr.if_int64() == nullptr);
1317 BOOST_TEST(ci64.if_int64() != nullptr);
1318 BOOST_TEST(cu64.if_int64() == nullptr);
1319 BOOST_TEST(cdub.if_int64() == nullptr);
1320 BOOST_TEST(cboo.if_int64() == nullptr);
1321 BOOST_TEST(cnul.if_int64() == nullptr);
1322 }
1323
1324 // if_uint64()
1325 {
1326 BOOST_TEST(obj.if_uint64() == nullptr);
1327 BOOST_TEST(arr.if_uint64() == nullptr);
1328 BOOST_TEST(str.if_uint64() == nullptr);
1329 BOOST_TEST(i64.if_uint64() == nullptr);
1330 BOOST_TEST(u64.if_uint64() != nullptr);
1331 BOOST_TEST(dub.if_uint64() == nullptr);
1332 BOOST_TEST(boo.if_uint64() == nullptr);
1333 BOOST_TEST(nul.if_uint64() == nullptr);
1334 }
1335
1336 // if_uint64() const
1337 {
1338 BOOST_TEST(cobj.if_uint64() == nullptr);
1339 BOOST_TEST(carr.if_uint64() == nullptr);
1340 BOOST_TEST(cstr.if_uint64() == nullptr);
1341 BOOST_TEST(ci64.if_uint64() == nullptr);
1342 BOOST_TEST(cu64.if_uint64() != nullptr);
1343 BOOST_TEST(cdub.if_uint64() == nullptr);
1344 BOOST_TEST(cboo.if_uint64() == nullptr);
1345 BOOST_TEST(cnul.if_uint64() == nullptr);
1346 }
1347
1348 // if_double()
1349 {
1350 BOOST_TEST(obj.if_double() == nullptr);
1351 BOOST_TEST(arr.if_double() == nullptr);
1352 BOOST_TEST(str.if_double() == nullptr);
1353 BOOST_TEST(i64.if_double() == nullptr);
1354 BOOST_TEST(u64.if_double() == nullptr);
1355 BOOST_TEST(dub.if_double() != nullptr);
1356 BOOST_TEST(boo.if_double() == nullptr);
1357 BOOST_TEST(nul.if_double() == nullptr);
1358 }
1359
1360 // if_double() const
1361 {
1362 BOOST_TEST(cobj.if_double() == nullptr);
1363 BOOST_TEST(carr.if_double() == nullptr);
1364 BOOST_TEST(cstr.if_double() == nullptr);
1365 BOOST_TEST(ci64.if_double() == nullptr);
1366 BOOST_TEST(cu64.if_double() == nullptr);
1367 BOOST_TEST(cdub.if_double() != nullptr);
1368 BOOST_TEST(cboo.if_double() == nullptr);
1369 BOOST_TEST(cnul.if_double() == nullptr);
1370 }
1371
1372 // if_bool()
1373 {
1374 BOOST_TEST(obj.if_bool() == nullptr);
1375 BOOST_TEST(arr.if_bool() == nullptr);
1376 BOOST_TEST(str.if_bool() == nullptr);
1377 BOOST_TEST(i64.if_bool() == nullptr);
1378 BOOST_TEST(u64.if_bool() == nullptr);
1379 BOOST_TEST(dub.if_bool() == nullptr);
1380 BOOST_TEST(boo.if_bool() != nullptr);
1381 BOOST_TEST(nul.if_bool() == nullptr);
1382 }
1383
1384 // if_bool() const
1385 {
1386 BOOST_TEST(cobj.if_bool() == nullptr);
1387 BOOST_TEST(carr.if_bool() == nullptr);
1388 BOOST_TEST(cstr.if_bool() == nullptr);
1389 BOOST_TEST(ci64.if_bool() == nullptr);
1390 BOOST_TEST(cu64.if_bool() == nullptr);
1391 BOOST_TEST(cdub.if_bool() == nullptr);
1392 BOOST_TEST(cboo.if_bool() != nullptr);
1393 BOOST_TEST(cnul.if_bool() == nullptr);
1394 }
1395 }
1396
1397 void
1398 testToNumber()
1399 {
1400 #define EQAL(T) BOOST_TEST(jv.to_number<T>() == V)
1401 #define EQUS(T) BOOST_TEST((V >= 0) && jv.to_number<T>() == static_cast<std::uint64_t>(V))
1402 #define EQUF(T) BOOST_TEST(static_cast<float>(V) == static_cast<float>(jv.to_number<T>()))
1403 #define THRO(T) BOOST_TEST_THROWS(jv.to_number<T>(), system_error)
1404
1405 BOOST_TEST_THROWS(value(nullptr).to_number<int>(), system_error);
1406 BOOST_TEST_THROWS(value(false).to_number<int>(), system_error);
1407 BOOST_TEST_THROWS(value(string_kind).to_number<int>(), system_error);
1408 BOOST_TEST_THROWS(value(array_kind).to_number<int>(), system_error);
1409 BOOST_TEST_THROWS(value(object_kind).to_number<int>(), system_error);
1410
1411 BOOST_TEST_THROWS(value(nullptr).to_number<unsigned>(), system_error);
1412 BOOST_TEST_THROWS(value(false).to_number<unsigned>(), system_error);
1413 BOOST_TEST_THROWS(value(string_kind).to_number<unsigned>(), system_error);
1414 BOOST_TEST_THROWS(value(array_kind).to_number<unsigned>(), system_error);
1415 BOOST_TEST_THROWS(value(object_kind).to_number<unsigned>(), system_error);
1416
1417 BOOST_TEST_THROWS(value(nullptr).to_number<double>(), system_error);
1418 BOOST_TEST_THROWS(value(false).to_number<double>(), system_error);
1419 BOOST_TEST_THROWS(value(string_kind).to_number<double>(), system_error);
1420 BOOST_TEST_THROWS(value(array_kind).to_number<double>(), system_error);
1421 BOOST_TEST_THROWS(value(object_kind).to_number<double>(), system_error);
1422
1423 {
1424 unsigned char V = 0;
1425 value const jv(V);
1426 EQAL(std::int8_t);
1427 EQAL(std::int16_t);
1428 EQAL(std::int32_t);
1429 EQAL(std::int64_t);
1430 EQAL(std::uint8_t);
1431 EQAL(std::uint16_t);
1432 EQAL(std::uint32_t);
1433 EQAL(std::uint64_t);
1434 EQAL(float);
1435 EQAL(double);
1436 }
1437 {
1438 auto V = max_of<std::int8_t>();
1439 value const jv(V);
1440 EQAL(std::int8_t);
1441 EQAL(std::int16_t);
1442 EQAL(std::int32_t);
1443 EQAL(std::int64_t);
1444 EQAL(std::uint8_t);
1445 EQAL(std::uint16_t);
1446 EQUS(std::uint32_t);
1447 EQUS(std::uint64_t);
1448 EQAL(float);
1449 EQAL(double);
1450 }
1451 {
1452 auto V = max_of<std::int16_t>();
1453 value const jv(V);
1454 THRO(std::int8_t);
1455 EQAL(std::int16_t);
1456 EQAL(std::int32_t);
1457 EQAL(std::int64_t);
1458 THRO(std::uint8_t);
1459 EQAL(std::uint16_t);
1460 EQUS(std::uint32_t);
1461 EQUS(std::uint64_t);
1462 EQAL(float);
1463 EQAL(double);
1464 }
1465 {
1466 auto V = max_of<std::int32_t>();
1467 value const jv(V);
1468 THRO(std::int8_t);
1469 THRO(std::int16_t);
1470 EQAL(std::int32_t);
1471 EQAL(std::int64_t);
1472 THRO(std::uint8_t);
1473 THRO(std::uint16_t);
1474 EQUS(std::uint32_t);
1475 EQUS(std::uint64_t);
1476 EQUF(float);
1477 EQAL(double);
1478 }
1479 {
1480 auto V = max_of<std::int64_t>();
1481 value const jv(V);
1482 THRO(std::int8_t);
1483 THRO(std::int16_t);
1484 THRO(std::int32_t);
1485 EQAL(std::int64_t);
1486 THRO(std::uint8_t);
1487 THRO(std::uint16_t);
1488 THRO(std::uint32_t);
1489 EQUS(std::uint64_t);
1490 EQUF(float);
1491 EQUF(double);
1492 }
1493 //---
1494 {
1495 auto V = max_of<std::uint8_t>();
1496 value const jv(V);
1497 THRO(std::int8_t);
1498 EQAL(std::int16_t);
1499 EQAL(std::int32_t);
1500 EQAL(std::int64_t);
1501 EQAL(std::uint8_t);
1502 EQAL(std::uint16_t);
1503 EQAL(std::uint32_t);
1504 EQAL(std::uint64_t);
1505 EQAL(float);
1506 EQAL(double);
1507 }
1508 {
1509 auto V = max_of<std::uint16_t>();
1510 value const jv(V);
1511 THRO(std::int8_t);
1512 THRO(std::int16_t);
1513 EQAL(std::int32_t);
1514 EQAL(std::int64_t);
1515 THRO(std::uint8_t);
1516 EQAL(std::uint16_t);
1517 EQAL(std::uint32_t);
1518 EQAL(std::uint64_t);
1519 EQAL(float);
1520 EQAL(double);
1521 }
1522 {
1523 auto V = max_of<std::uint32_t>();
1524 value const jv(V);
1525 THRO(std::int8_t);
1526 THRO(std::int16_t);
1527 THRO(std::int32_t);
1528 EQAL(std::int64_t);
1529 THRO(std::uint8_t);
1530 THRO(std::uint16_t);
1531 EQAL(std::uint32_t);
1532 EQAL(std::uint64_t);
1533 EQUF(float);
1534 EQAL(double);
1535 }
1536 {
1537 auto V = max_of<std::uint64_t>();
1538 value const jv(V);
1539 THRO(std::int8_t);
1540 THRO(std::int16_t);
1541 THRO(std::int32_t);
1542 THRO(std::int64_t);
1543 THRO(std::uint8_t);
1544 THRO(std::uint16_t);
1545 THRO(std::uint32_t);
1546 EQAL(std::uint64_t);
1547 EQUF(float);
1548 EQUF(double);
1549 }
1550 //---
1551 {
1552 auto V = min_of<std::int8_t>();
1553 value const jv(V);
1554 EQAL(std::int8_t);
1555 EQAL(std::int16_t);
1556 EQAL(std::int32_t);
1557 EQAL(std::int64_t);
1558 THRO(std::uint8_t);
1559 THRO(std::uint16_t);
1560 THRO(std::uint32_t);
1561 THRO(std::uint64_t);
1562 EQAL(float);
1563 EQAL(double);
1564 }
1565 {
1566 auto V = min_of<std::int16_t>();
1567 value const jv(V);
1568 THRO(std::int8_t);
1569 EQAL(std::int16_t);
1570 EQAL(std::int32_t);
1571 EQAL(std::int64_t);
1572 THRO(std::uint8_t);
1573 THRO(std::uint16_t);
1574 THRO(std::uint32_t);
1575 THRO(std::uint64_t);
1576 EQAL(float);
1577 EQAL(double);
1578 }
1579 {
1580 auto V = min_of<std::int32_t>();
1581 value const jv(V);
1582 THRO(std::int8_t);
1583 THRO(std::int16_t);
1584 EQAL(std::int32_t);
1585 EQAL(std::int64_t);
1586 THRO(std::uint8_t);
1587 THRO(std::uint16_t);
1588 THRO(std::uint32_t);
1589 THRO(std::uint64_t);
1590 EQUF(float);
1591 EQAL(double);
1592 }
1593 {
1594 auto V = min_of<std::int64_t>();
1595 value const jv(V);
1596 THRO(std::int8_t);
1597 THRO(std::int16_t);
1598 THRO(std::int32_t);
1599 EQAL(std::int64_t);
1600 THRO(std::uint8_t);
1601 THRO(std::uint16_t);
1602 THRO(std::uint32_t);
1603 THRO(std::uint64_t);
1604 EQUF(float);
1605 EQUF(double);
1606 }
1607 //---
1608 {
1609 auto V = double(1.5);
1610 value const jv(V);
1611 THRO(std::int8_t);
1612 THRO(std::int16_t);
1613 THRO(std::int32_t);
1614 THRO(std::int64_t);
1615 THRO(std::uint8_t);
1616 THRO(std::uint16_t);
1617 THRO(std::uint32_t);
1618 THRO(std::uint64_t);
1619 EQAL(float);
1620 EQAL(double);
1621 }
1622 {
1623 auto V = double(2.0);
1624 value const jv(V);
1625 EQAL(std::int8_t);
1626 EQAL(std::int16_t);
1627 EQAL(std::int32_t);
1628 EQAL(std::int64_t);
1629 EQAL(std::uint8_t);
1630 EQAL(std::uint16_t);
1631 EQAL(std::uint32_t);
1632 EQAL(std::uint64_t);
1633 EQAL(float);
1634 EQAL(double);
1635 }
1636 {
1637 auto V = double(-4.0);
1638 value const jv(V);
1639 EQAL(std::int8_t);
1640 EQAL(std::int16_t);
1641 EQAL(std::int32_t);
1642 EQAL(std::int64_t);
1643 THRO(std::uint8_t);
1644 THRO(std::uint16_t);
1645 THRO(std::uint32_t);
1646 THRO(std::uint64_t);
1647 EQAL(float);
1648 EQAL(double);
1649 }
1650 }
1651
1652 void
1653 testAs()
1654 {
1655 value obj(object{});
1656 value arr(array{});
1657 value str(string{});
1658 value i64(std::int64_t{});
1659 value u64(std::uint64_t{});
1660 value dub(double{});
1661 value boo(true);
1662 value nul(nullptr);
1663
1664 auto const& cobj(obj);
1665 auto const& carr(arr);
1666 auto const& cstr(str);
1667 auto const& ci64(i64);
1668 auto const& cu64(u64);
1669 auto const& cdub(dub);
1670 auto const& cboo(boo);
1671 auto const& cnul(nul);
1672
1673 // as_object()
1674 {
1675 object& x = obj.as_object();
1676 BOOST_TEST_THROWS(arr.as_object(), std::invalid_argument);
1677 BOOST_TEST_THROWS(str.as_object(), std::invalid_argument);
1678 BOOST_TEST_THROWS(i64.as_object(), std::invalid_argument);
1679 BOOST_TEST_THROWS(u64.as_object(), std::invalid_argument);
1680 BOOST_TEST_THROWS(dub.as_object(), std::invalid_argument);
1681 BOOST_TEST_THROWS(boo.as_object(), std::invalid_argument);
1682 BOOST_TEST_THROWS(nul.as_object(), std::invalid_argument);
1683 (void)x;
1684 }
1685
1686 // as_object() const
1687 {
1688 object const& x = cobj.as_object();
1689 BOOST_TEST_THROWS(carr.as_object(), std::invalid_argument);
1690 BOOST_TEST_THROWS(cstr.as_object(), std::invalid_argument);
1691 BOOST_TEST_THROWS(ci64.as_object(), std::invalid_argument);
1692 BOOST_TEST_THROWS(cu64.as_object(), std::invalid_argument);
1693 BOOST_TEST_THROWS(cdub.as_object(), std::invalid_argument);
1694 BOOST_TEST_THROWS(cboo.as_object(), std::invalid_argument);
1695 BOOST_TEST_THROWS(cnul.as_object(), std::invalid_argument);
1696 (void)x;
1697 }
1698
1699 // as_array()
1700 {
1701 BOOST_TEST_THROWS(obj.as_array(), std::invalid_argument);
1702 array& x = arr.as_array();
1703 BOOST_TEST_THROWS(str.as_array(), std::invalid_argument);
1704 BOOST_TEST_THROWS(i64.as_array(), std::invalid_argument);
1705 BOOST_TEST_THROWS(u64.as_array(), std::invalid_argument);
1706 BOOST_TEST_THROWS(dub.as_array(), std::invalid_argument);
1707 BOOST_TEST_THROWS(boo.as_array(), std::invalid_argument);
1708 BOOST_TEST_THROWS(nul.as_array(), std::invalid_argument);
1709 (void)x;
1710 }
1711
1712 // as_array() const
1713 {
1714 BOOST_TEST_THROWS(cobj.as_array(), std::invalid_argument);
1715 array const& x = carr.as_array();
1716 BOOST_TEST_THROWS(cstr.as_array(), std::invalid_argument);
1717 BOOST_TEST_THROWS(ci64.as_array(), std::invalid_argument);
1718 BOOST_TEST_THROWS(cu64.as_array(), std::invalid_argument);
1719 BOOST_TEST_THROWS(cdub.as_array(), std::invalid_argument);
1720 BOOST_TEST_THROWS(cboo.as_array(), std::invalid_argument);
1721 BOOST_TEST_THROWS(cnul.as_array(), std::invalid_argument);
1722 (void)x;
1723 }
1724
1725 // as_string()
1726 {
1727 BOOST_TEST_THROWS(obj.as_string(), std::invalid_argument);
1728 BOOST_TEST_THROWS(arr.as_string(), std::invalid_argument);
1729 string& x = str.as_string();
1730 BOOST_TEST_THROWS(i64.as_string(), std::invalid_argument);
1731 BOOST_TEST_THROWS(u64.as_string(), std::invalid_argument);
1732 BOOST_TEST_THROWS(dub.as_string(), std::invalid_argument);
1733 BOOST_TEST_THROWS(boo.as_string(), std::invalid_argument);
1734 BOOST_TEST_THROWS(nul.as_string(), std::invalid_argument);
1735 (void)x;
1736 }
1737
1738 // as_string() const
1739 {
1740 BOOST_TEST_THROWS(cobj.as_string(), std::invalid_argument);
1741 BOOST_TEST_THROWS(carr.as_string(), std::invalid_argument);
1742 string const& x = cstr.as_string();
1743 BOOST_TEST_THROWS(ci64.as_string(), std::invalid_argument);
1744 BOOST_TEST_THROWS(cu64.as_string(), std::invalid_argument);
1745 BOOST_TEST_THROWS(cdub.as_string(), std::invalid_argument);
1746 BOOST_TEST_THROWS(cboo.as_string(), std::invalid_argument);
1747 BOOST_TEST_THROWS(cnul.as_string(), std::invalid_argument);
1748 (void)x;
1749 }
1750
1751 // as_int64()
1752 {
1753 BOOST_TEST_THROWS(obj.as_int64(), std::invalid_argument);
1754 BOOST_TEST_THROWS(arr.as_int64(), std::invalid_argument);
1755 BOOST_TEST_THROWS(str.as_int64(), std::invalid_argument);
1756 std::int64_t& x = i64.as_int64();
1757 BOOST_TEST_THROWS(u64.as_int64(), std::invalid_argument);
1758 BOOST_TEST_THROWS(dub.as_int64(), std::invalid_argument);
1759 BOOST_TEST_THROWS(boo.as_int64(), std::invalid_argument);
1760 BOOST_TEST_THROWS(nul.as_int64(), std::invalid_argument);
1761 (void)x;
1762 }
1763
1764 // as_int64() const
1765 {
1766 BOOST_TEST_THROWS(cobj.as_int64(), std::invalid_argument);
1767 BOOST_TEST_THROWS(carr.as_int64(), std::invalid_argument);
1768 BOOST_TEST_THROWS(cstr.as_int64(), std::invalid_argument);
1769 std::int64_t const& x = ci64.as_int64();
1770 BOOST_TEST_THROWS(cu64.as_int64(), std::invalid_argument);
1771 BOOST_TEST_THROWS(cdub.as_int64(), std::invalid_argument);
1772 BOOST_TEST_THROWS(cboo.as_int64(), std::invalid_argument);
1773 BOOST_TEST_THROWS(cnul.as_int64(), std::invalid_argument);
1774 (void)x;
1775 }
1776
1777 // as_uint64()
1778 {
1779 BOOST_TEST_THROWS(obj.as_uint64(), std::invalid_argument);
1780 BOOST_TEST_THROWS(arr.as_uint64(), std::invalid_argument);
1781 BOOST_TEST_THROWS(str.as_uint64(), std::invalid_argument);
1782 BOOST_TEST_THROWS(i64.as_uint64(), std::invalid_argument);
1783 std::uint64_t& x = u64.as_uint64();
1784 BOOST_TEST_THROWS(dub.as_uint64(), std::invalid_argument);
1785 BOOST_TEST_THROWS(boo.as_uint64(), std::invalid_argument);
1786 BOOST_TEST_THROWS(nul.as_uint64(), std::invalid_argument);
1787 (void)x;
1788 }
1789
1790 // as_uint64() const
1791 {
1792 BOOST_TEST_THROWS(cobj.as_uint64(), std::invalid_argument);
1793 BOOST_TEST_THROWS(carr.as_uint64(), std::invalid_argument);
1794 BOOST_TEST_THROWS(cstr.as_uint64(), std::invalid_argument);
1795 BOOST_TEST_THROWS(ci64.as_uint64(), std::invalid_argument);
1796 std::uint64_t const& x = cu64.as_uint64();
1797 BOOST_TEST_THROWS(cdub.as_uint64(), std::invalid_argument);
1798 BOOST_TEST_THROWS(cboo.as_uint64(), std::invalid_argument);
1799 BOOST_TEST_THROWS(cnul.as_uint64(), std::invalid_argument);
1800 (void)x;
1801 }
1802
1803 // as_double()
1804 {
1805 BOOST_TEST_THROWS(obj.as_double(), std::invalid_argument);
1806 BOOST_TEST_THROWS(arr.as_double(), std::invalid_argument);
1807 BOOST_TEST_THROWS(str.as_double(), std::invalid_argument);
1808 BOOST_TEST_THROWS(i64.as_double(), std::invalid_argument);
1809 BOOST_TEST_THROWS(u64.as_double(), std::invalid_argument);
1810 double& x = dub.as_double();
1811 BOOST_TEST_THROWS(boo.as_double(), std::invalid_argument);
1812 BOOST_TEST_THROWS(nul.as_double(), std::invalid_argument);
1813 (void)x;
1814 }
1815
1816 // as_double() const
1817 {
1818 BOOST_TEST_THROWS(cobj.as_double(), std::invalid_argument);
1819 BOOST_TEST_THROWS(carr.as_double(), std::invalid_argument);
1820 BOOST_TEST_THROWS(cstr.as_double(), std::invalid_argument);
1821 BOOST_TEST_THROWS(ci64.as_double(), std::invalid_argument);
1822 BOOST_TEST_THROWS(cu64.as_double(), std::invalid_argument);
1823 double const& x = cdub.as_double();
1824 BOOST_TEST_THROWS(cboo.as_double(), std::invalid_argument);
1825 BOOST_TEST_THROWS(cnul.as_double(), std::invalid_argument);
1826 (void)x;
1827 }
1828
1829 // as_bool()
1830 {
1831 BOOST_TEST_THROWS(obj.as_bool(), std::invalid_argument);
1832 BOOST_TEST_THROWS(arr.as_bool(), std::invalid_argument);
1833 BOOST_TEST_THROWS(str.as_bool(), std::invalid_argument);
1834 BOOST_TEST_THROWS(i64.as_bool(), std::invalid_argument);
1835 BOOST_TEST_THROWS(u64.as_bool(), std::invalid_argument);
1836 BOOST_TEST_THROWS(dub.as_bool(), std::invalid_argument);
1837 bool& x = boo.as_bool();
1838 BOOST_TEST_THROWS(nul.as_bool(), std::invalid_argument);
1839 (void)x;
1840 }
1841
1842 // as_bool() const
1843 {
1844 BOOST_TEST_THROWS(cobj.as_bool(), std::invalid_argument);
1845 BOOST_TEST_THROWS(carr.as_bool(), std::invalid_argument);
1846 BOOST_TEST_THROWS(cstr.as_bool(), std::invalid_argument);
1847 BOOST_TEST_THROWS(ci64.as_bool(), std::invalid_argument);
1848 BOOST_TEST_THROWS(cu64.as_bool(), std::invalid_argument);
1849 BOOST_TEST_THROWS(cdub.as_bool(), std::invalid_argument);
1850 bool const&x = cboo.as_bool();
1851 BOOST_TEST_THROWS(cnul.as_bool(), std::invalid_argument);
1852 (void)x;
1853 }
1854 }
1855
1856 void
1857 testGet()
1858 {
1859 value obj(object{});
1860 value arr(array{});
1861 value str(string{});
1862 value i64(std::int64_t{});
1863 value u64(std::uint64_t{});
1864 value dub(double{});
1865 value boo(true);
1866
1867 auto const& cobj(obj);
1868 auto const& carr(arr);
1869 auto const& cstr(str);
1870 auto const& ci64(i64);
1871 auto const& cu64(u64);
1872 auto const& cdub(dub);
1873 auto const& cboo(boo);
1874
1875 // get_object()
1876 // get_array()
1877 // get_string()
1878 // get_int64()
1879 // get_uint64()
1880 // get_double()
1881 // get_bool()
1882 {
1883 object& xobj = obj.get_object();
1884 array& xarr = arr.get_array();
1885 string& xstr = str.get_string();
1886 std::int64_t& xi64 = i64.get_int64();
1887 std::uint64_t& xu64 = u64.get_uint64();
1888 double& xdub = dub.get_double();
1889 bool& xboo = boo.get_bool();
1890
1891 (void)(xobj);
1892 (void)(xarr);
1893 (void)(xstr);
1894 (void)(xi64);
1895 (void)(xu64);
1896 (void)(xdub);
1897 (void)(xboo);
1898 }
1899
1900 // get_object() const
1901 // get_array() const
1902 // get_string() const
1903 // get_int64() const
1904 // get_uint64() const
1905 // get_double() const
1906 // get_bool() const
1907 {
1908 object const& xobj = cobj.get_object();
1909 array const& xarr = carr.get_array();
1910 string const& xstr = cstr.get_string();
1911 std::int64_t
1912 const& xi64 = ci64.get_int64();
1913 std::uint64_t
1914 const& xu64 = cu64.get_uint64();
1915 double const& xdub = cdub.get_double();
1916 bool const& xboo = cboo.get_bool();
1917
1918 (void)(xobj);
1919 (void)(xarr);
1920 (void)(xstr);
1921 (void)(xi64);
1922 (void)(xu64);
1923 (void)(xdub);
1924 (void)(xboo);
1925 }
1926 }
1927
1928 void
1929 testAt()
1930 {
1931 // object
1932 BOOST_TEST(value(
1933 {{"k1", "value"}, {"k2", nullptr}}
1934 ).at("k1").as_string() == "value");
1935 BOOST_TEST_THROWS(value(
1936 {{"k1", "value"}, {"k2", nullptr}}
1937 ).at("null"),
1938 std::out_of_range);
1939
1940 // array
1941 BOOST_TEST(
1942 value({true,2,"3"}).at(1).as_int64() == 2);
1943
1944 BOOST_TEST_THROWS( value({false,2,false}).at(4), std::out_of_range );
1945 BOOST_TEST_THROWS( value({false,2,"3"}).at(4), std::out_of_range );
1946 BOOST_TEST_THROWS( value({false,false}).at(4), std::out_of_range );
1947 BOOST_TEST_THROWS( value({false,2}).at(4), std::out_of_range );
1948 BOOST_TEST_THROWS( value({false,2,"3",nullptr}).at(4), std::out_of_range );
1949 BOOST_TEST_THROWS( value({2,false,"3"}).at(4), std::out_of_range );
1950 BOOST_TEST_THROWS( value({true,2,"3"}).at(4), std::out_of_range );
1951 }
1952
1953 //------------------------------------------------------
1954
1955 void
1956 testKeyValuePair()
1957 {
1958 using kvp = key_value_pair;
1959
1960 kvp v1("key", "value");
1961 kvp v2(v1);
1962 BOOST_TEST(v2.key() == "key");
1963 BOOST_TEST(
1964 v2.value().get_string() == "value");
1965 kvp v3(std::move(v2));
1966 BOOST_TEST(v3.key() == "key");
1967 BOOST_TEST(
1968 v3.value().get_string() == "value");
1969 BOOST_TEST(std::memcmp(
1970 v3.key_c_str(), "key\0", 4) == 0);
1971
1972 BOOST_STATIC_ASSERT(std::tuple_size<key_value_pair>::value == 2);
1973 BOOST_TEST(get<0>(v3) == "key");
1974 BOOST_TEST(
1975 get<1>(v3).get_string() == "value");
1976
1977 BOOST_STATIC_ASSERT(std::is_same<
1978 decltype(get<1>(std::declval<kvp>())), json::value&&>::value);
1979
1980 #if __cplusplus >= 201703L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
1981 auto const [kc, vc] = v1;
1982 static_assert(std::is_same<decltype(kc), string_view const>::value);
1983 static_assert(std::is_same<decltype(vc), value const&>::value);
1984 BOOST_TEST(kc == "key");
1985 BOOST_TEST(&vc != &v1.value());
1986
1987 auto& [kr, vr] = v1;
1988 static_assert(std::is_same<decltype(kr), string_view const>::value);
1989 static_assert(std::is_same<decltype(vr), value&>::value);
1990 BOOST_TEST(kr == "key");
1991 BOOST_TEST(&vr == &v1.value());
1992
1993 auto const& [kcr, vcr] = v1;
1994 static_assert(std::is_same<decltype(kcr), string_view const>::value);
1995 static_assert(std::is_same<decltype(vcr), value const&>::value);
1996 BOOST_TEST(kcr == "key");
1997 BOOST_TEST(&vcr == &v1.value());
1998
1999 const kvp v4("const key", "const value");
2000 auto& [ckr, cvr] = v4;
2001 static_assert(std::is_same<decltype(ckr), string_view const>::value);
2002 static_assert(std::is_same<decltype(cvr), value const&>::value);
2003 BOOST_TEST(ckr == "const key");
2004 BOOST_TEST(&cvr == &v4.value());
2005 #endif
2006 }
2007
2008 //------------------------------------------------------
2009
2010 void
2011 testStdConstruction()
2012 {
2013 {
2014 value jv(std::string("test"));
2015 }
2016 }
2017
2018 void
2019 testInitList()
2020 {
2021 check_array(value{0,0,0}, 0, 0, 0);
2022 check_array(value{false,false,false}, false, false, false);
2023 check_array(value{false,2,false}, false, 2, false);
2024 check_array(value{false,2,"3"}, false, 2, "3");
2025 check_array(value{false,false}, false, false);
2026 check_array(value{false,2}, false, 2);
2027 check_array(value{false,2,"3",nullptr}, false, 2, "3", nullptr);
2028 check_array(value{2,false,"3"}, 2, false, "3");
2029 check_array(value{true,2,"3"}, true, 2, "3");
2030 }
2031
2032 //------------------------------------------------------
2033
2034 void
2035 testEquality()
2036 {
2037 BOOST_TEST(value(nullptr) == value(nullptr));
2038 BOOST_TEST(value(nullptr) != value(true));
2039
2040 BOOST_TEST(value(false) == value(false));
2041 BOOST_TEST(value(true) != value(false));
2042 BOOST_TEST(value(true) != value(nullptr));
2043
2044 BOOST_TEST(value( 1) == value( 1));
2045 BOOST_TEST(value( 1) != value( 2));
2046 BOOST_TEST(value(-1) == value(-1));
2047 BOOST_TEST(value(-1) != value(-2));
2048 BOOST_TEST(value(-1) != value( 2));
2049 BOOST_TEST(value( 1) == value( 1UL));
2050 BOOST_TEST(value( 1) != value( 2UL));
2051 BOOST_TEST(value(-1) != value( 1UL));
2052 BOOST_TEST(value(-1) != value(nullptr));
2053
2054 BOOST_TEST(value(1UL) == value( 1UL));
2055 BOOST_TEST(value(1UL) != value( 2UL));
2056 BOOST_TEST(value(1UL) == value( 1));
2057 BOOST_TEST(value(1UL) != value(-1));
2058 BOOST_TEST(value(1UL) != value(nullptr));
2059
2060 BOOST_TEST(value(1.5) == value(1.5));
2061 BOOST_TEST(value(1.5) != value(2.5));
2062 BOOST_TEST(value(1.5) != value(false));
2063 BOOST_TEST(value(2.0) != value(2));
2064
2065 BOOST_TEST(value("abc") == value("abc"));
2066 BOOST_TEST(value("abc") != value("xyz"));
2067 BOOST_TEST(value("abc") != value("x"));
2068 BOOST_TEST(value("abc") != value(nullptr));
2069
2070 BOOST_TEST(value({1,2,3}) == value({1,2,3}));
2071 BOOST_TEST(value({1,2,3}) != value({2,3,1}));
2072 BOOST_TEST(value({1,2,3}) != value({2,3,4}));
2073 BOOST_TEST(value({1,2,3}) != value(nullptr));
2074 BOOST_TEST(value({
2075 {"a",1}, {"b",2}, {"c",3} }) == value({
2076 {"a",1}, {"b",2}, {"c",3} }));
2077 BOOST_TEST(value({
2078 {"a",1}, {"b",2}, {"c",3} }) == value({
2079 {"c",3}, {"a",1}, {"b",2} }));
2080 BOOST_TEST(value({
2081 {"a",1}, {"b",2}, {"c",3} }) != value({
2082 {"b",1}, {"c",2}, {"d",3} }));
2083 BOOST_TEST(value({
2084 {"a",1}, {"b",2}, {"c",3} }) != value({
2085 {"a",2}, {"b",3}, {"c",4} }));
2086 BOOST_TEST(value({
2087 {"a",1}, {"b",2}, {"c",3} }) != value(nullptr));
2088 }
2089
2090 //------------------------------------------------------
2091
2092 void
2093 run()
2094 {
2095 testSpecial();
2096 testConversion();
2097 testAssignment();
2098 testModifiers();
2099 testExchange();
2100 testObservers();
2101 testGetStorage();
2102 testIf();
2103 testToNumber();
2104 testAs();
2105 testGet();
2106 testAt();
2107 testKeyValuePair();
2108 testStdConstruction();
2109 testInitList();
2110 testEquality();
2111 }
2112 };
2113
2114 TEST_SUITE(value_test, "boost.json.value");
2115
2116 BOOST_JSON_NS_END
Ceph