1 /*
2     __ _____ _____ _____
3  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
4 |  |  |__   |  |  | | | |  version 3.9.1
5 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
6 
7 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
8 SPDX-License-Identifier: MIT
9 Copyright (c) 2013-2019 Niels Lohmann <http://nlohmann.me>.
10 
11 Permission is hereby  granted, free of charge, to any  person obtaining a copy
12 of this software and associated  documentation files (the "Software"), to deal
13 in the Software  without restriction, including without  limitation the rights
14 to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell
15 copies  of  the Software,  and  to  permit persons  to  whom  the Software  is
16 furnished to do so, subject to the following conditions:
17 
18 The above copyright notice and this permission notice shall be included in all
19 copies or substantial portions of the Software.
20 
21 THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR
22 IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,
23 FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE
24 AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER
25 LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,
26 OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE
27 SOFTWARE.
28 */
29 
30 #include "doctest_compatibility.h"
31 
32 #include <nlohmann/json.hpp>
33 using nlohmann::json;
34 
35 #if (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
36     #define JSON_HAS_CPP_17
37     #define JSON_HAS_CPP_14
38 #elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
39     #define JSON_HAS_CPP_14
40 #endif
41 
42 TEST_CASE("iterator_wrapper")
43 {
44     SECTION("object")
45     {
46         SECTION("value")
47         {
48             json j = { {"A", 1}, {"B", 2} };
49             int counter = 1;
50 
51             for (auto i : json::iterator_wrapper(j))
52             {
53                 switch (counter++)
54                 {
55                     case 1:
56                     {
57                         CHECK(i.key() == "A");
58                         CHECK(i.value() == json(1));
59                         break;
60                     }
61 
62                     case 2:
63                     {
64                         CHECK(i.key() == "B");
65                         CHECK(i.value() == json(2));
66                         break;
67                     }
68 
69                     default:
70                     {
71                         break;
72                     }
73                 }
74             }
75 
76             CHECK(counter == 3);
77         }
78 
79         SECTION("reference")
80         {
81             json j = { {"A", 1}, {"B", 2} };
82             int counter = 1;
83 
84             for (auto& i : json::iterator_wrapper(j))
85             {
86                 switch (counter++)
87                 {
88                     case 1:
89                     {
90                         CHECK(i.key() == "A");
91                         CHECK(i.value() == json(1));
92 
93                         // change the value
94                         i.value() = json(11);
95                         CHECK(i.value() == json(11));
96                         break;
97                     }
98 
99                     case 2:
100                     {
101                         CHECK(i.key() == "B");
102                         CHECK(i.value() == json(2));
103 
104                         // change the value
105                         i.value() = json(22);
106                         CHECK(i.value() == json(22));
107                         break;
108                     }
109 
110                     default:
111                     {
112                         break;
113                     }
114                 }
115             }
116 
117             CHECK(counter == 3);
118 
119             // check if values where changed
120             CHECK(j == json({ {"A", 11}, {"B", 22} }));
121         }
122 
123         SECTION("const value")
124         {
125             json j = { {"A", 1}, {"B", 2} };
126             int counter = 1;
127 
128             for (const auto i : json::iterator_wrapper(j))
129             {
130                 switch (counter++)
131                 {
132                     case 1:
133                     {
134                         CHECK(i.key() == "A");
135                         CHECK(i.value() == json(1));
136                         break;
137                     }
138 
139                     case 2:
140                     {
141                         CHECK(i.key() == "B");
142                         CHECK(i.value() == json(2));
143                         break;
144                     }
145 
146                     default:
147                     {
148                         break;
149                     }
150                 }
151             }
152 
153             CHECK(counter == 3);
154         }
155 
156         SECTION("const reference")
157         {
158             json j = { {"A", 1}, {"B", 2} };
159             int counter = 1;
160 
161             for (const auto& i : json::iterator_wrapper(j))
162             {
163                 switch (counter++)
164                 {
165                     case 1:
166                     {
167                         CHECK(i.key() == "A");
168                         CHECK(i.value() == json(1));
169                         break;
170                     }
171 
172                     case 2:
173                     {
174                         CHECK(i.key() == "B");
175                         CHECK(i.value() == json(2));
176                         break;
177                     }
178 
179                     default:
180                     {
181                         break;
182                     }
183                 }
184             }
185 
186             CHECK(counter == 3);
187         }
188     }
189 
190     SECTION("const object")
191     {
192         SECTION("value")
193         {
194             const json j = { {"A", 1}, {"B", 2} };
195             int counter = 1;
196 
197             for (auto i : json::iterator_wrapper(j))
198             {
199                 switch (counter++)
200                 {
201                     case 1:
202                     {
203                         CHECK(i.key() == "A");
204                         CHECK(i.value() == json(1));
205                         break;
206                     }
207 
208                     case 2:
209                     {
210                         CHECK(i.key() == "B");
211                         CHECK(i.value() == json(2));
212                         break;
213                     }
214 
215                     default:
216                     {
217                         break;
218                     }
219                 }
220             }
221 
222             CHECK(counter == 3);
223         }
224 
225         SECTION("reference")
226         {
227             const json j = { {"A", 1}, {"B", 2} };
228             int counter = 1;
229 
230             for (auto& i : json::iterator_wrapper(j))
231             {
232                 switch (counter++)
233                 {
234                     case 1:
235                     {
236                         CHECK(i.key() == "A");
237                         CHECK(i.value() == json(1));
238                         break;
239                     }
240 
241                     case 2:
242                     {
243                         CHECK(i.key() == "B");
244                         CHECK(i.value() == json(2));
245                         break;
246                     }
247 
248                     default:
249                     {
250                         break;
251                     }
252                 }
253             }
254 
255             CHECK(counter == 3);
256         }
257 
258         SECTION("const value")
259         {
260             const json j = { {"A", 1}, {"B", 2} };
261             int counter = 1;
262 
263             for (const auto i : json::iterator_wrapper(j))
264             {
265                 switch (counter++)
266                 {
267                     case 1:
268                     {
269                         CHECK(i.key() == "A");
270                         CHECK(i.value() == json(1));
271                         break;
272                     }
273 
274                     case 2:
275                     {
276                         CHECK(i.key() == "B");
277                         CHECK(i.value() == json(2));
278                         break;
279                     }
280 
281                     default:
282                     {
283                         break;
284                     }
285                 }
286             }
287 
288             CHECK(counter == 3);
289         }
290 
291         SECTION("const reference")
292         {
293             const json j = { {"A", 1}, {"B", 2} };
294             int counter = 1;
295 
296             for (const auto& i : json::iterator_wrapper(j))
297             {
298                 switch (counter++)
299                 {
300                     case 1:
301                     {
302                         CHECK(i.key() == "A");
303                         CHECK(i.value() == json(1));
304                         break;
305                     }
306 
307                     case 2:
308                     {
309                         CHECK(i.key() == "B");
310                         CHECK(i.value() == json(2));
311                         break;
312                     }
313 
314                     default:
315                     {
316                         break;
317                     }
318                 }
319             }
320 
321             CHECK(counter == 3);
322         }
323     }
324 
325     SECTION("array")
326     {
327         SECTION("value")
328         {
329             json j = { "A", "B" };
330             int counter = 1;
331 
332             for (auto i : json::iterator_wrapper(j))
333             {
334                 switch (counter++)
335                 {
336                     case 1:
337                     {
338                         CHECK(i.key() == "0");
339                         CHECK(i.value() == "A");
340                         break;
341                     }
342 
343                     case 2:
344                     {
345                         CHECK(i.key() == "1");
346                         CHECK(i.value() == "B");
347                         break;
348                     }
349 
350                     default:
351                     {
352                         break;
353                     }
354                 }
355             }
356 
357             CHECK(counter == 3);
358         }
359 
360         SECTION("reference")
361         {
362             json j = { "A", "B" };
363             int counter = 1;
364 
365             for (auto& i : json::iterator_wrapper(j))
366             {
367                 switch (counter++)
368                 {
369                     case 1:
370                     {
371                         CHECK(i.key() == "0");
372                         CHECK(i.value() == "A");
373 
374                         // change the value
375                         i.value() = "AA";
376                         CHECK(i.value() == "AA");
377                         break;
378                     }
379 
380                     case 2:
381                     {
382                         CHECK(i.key() == "1");
383                         CHECK(i.value() == "B");
384 
385                         // change the value
386                         i.value() = "BB";
387                         CHECK(i.value() == "BB");
388                         break;
389                     }
390 
391                     default:
392                     {
393                         break;
394                     }
395                 }
396             }
397 
398             CHECK(counter == 3);
399 
400             // check if values where changed
401             CHECK(j == json({ "AA", "BB" }));
402         }
403 
404         SECTION("const value")
405         {
406             json j = { "A", "B" };
407             int counter = 1;
408 
409             for (const auto i : json::iterator_wrapper(j))
410             {
411                 switch (counter++)
412                 {
413                     case 1:
414                     {
415                         CHECK(i.key() == "0");
416                         CHECK(i.value() == "A");
417                         break;
418                     }
419 
420                     case 2:
421                     {
422                         CHECK(i.key() == "1");
423                         CHECK(i.value() == "B");
424                         break;
425                     }
426 
427                     default:
428                     {
429                         break;
430                     }
431                 }
432             }
433 
434             CHECK(counter == 3);
435         }
436 
437         SECTION("const reference")
438         {
439             json j = { "A", "B" };
440             int counter = 1;
441 
442             for (const auto& i : json::iterator_wrapper(j))
443             {
444                 switch (counter++)
445                 {
446                     case 1:
447                     {
448                         CHECK(i.key() == "0");
449                         CHECK(i.value() == "A");
450                         break;
451                     }
452 
453                     case 2:
454                     {
455                         CHECK(i.key() == "1");
456                         CHECK(i.value() == "B");
457                         break;
458                     }
459 
460                     default:
461                     {
462                         break;
463                     }
464                 }
465             }
466 
467             CHECK(counter == 3);
468         }
469     }
470 
471     SECTION("const array")
472     {
473         SECTION("value")
474         {
475             const json j = { "A", "B" };
476             int counter = 1;
477 
478             for (auto i : json::iterator_wrapper(j))
479             {
480                 switch (counter++)
481                 {
482                     case 1:
483                     {
484                         CHECK(i.key() == "0");
485                         CHECK(i.value() == "A");
486                         break;
487                     }
488 
489                     case 2:
490                     {
491                         CHECK(i.key() == "1");
492                         CHECK(i.value() == "B");
493                         break;
494                     }
495 
496                     default:
497                     {
498                         break;
499                     }
500                 }
501             }
502 
503             CHECK(counter == 3);
504         }
505 
506         SECTION("reference")
507         {
508             const json j = { "A", "B" };
509             int counter = 1;
510 
511             for (auto& i : json::iterator_wrapper(j))
512             {
513                 switch (counter++)
514                 {
515                     case 1:
516                     {
517                         CHECK(i.key() == "0");
518                         CHECK(i.value() == "A");
519                         break;
520                     }
521 
522                     case 2:
523                     {
524                         CHECK(i.key() == "1");
525                         CHECK(i.value() == "B");
526                         break;
527                     }
528 
529                     default:
530                     {
531                         break;
532                     }
533                 }
534             }
535 
536             CHECK(counter == 3);
537         }
538 
539         SECTION("const value")
540         {
541             const json j = { "A", "B" };
542             int counter = 1;
543 
544             for (const auto i : json::iterator_wrapper(j))
545             {
546                 switch (counter++)
547                 {
548                     case 1:
549                     {
550                         CHECK(i.key() == "0");
551                         CHECK(i.value() == "A");
552                         break;
553                     }
554 
555                     case 2:
556                     {
557                         CHECK(i.key() == "1");
558                         CHECK(i.value() == "B");
559                         break;
560                     }
561 
562                     default:
563                     {
564                         break;
565                     }
566                 }
567             }
568 
569             CHECK(counter == 3);
570         }
571 
572         SECTION("const reference")
573         {
574             const json j = { "A", "B" };
575             int counter = 1;
576 
577             for (const auto& i : json::iterator_wrapper(j))
578             {
579                 switch (counter++)
580                 {
581                     case 1:
582                     {
583                         CHECK(i.key() == "0");
584                         CHECK(i.value() == "A");
585                         break;
586                     }
587 
588                     case 2:
589                     {
590                         CHECK(i.key() == "1");
591                         CHECK(i.value() == "B");
592                         break;
593                     }
594 
595                     default:
596                     {
597                         break;
598                     }
599                 }
600             }
601 
602             CHECK(counter == 3);
603         }
604     }
605 
606     SECTION("primitive")
607     {
608         SECTION("value")
609         {
610             json j = 1;
611             int counter = 1;
612 
613             for (auto i : json::iterator_wrapper(j))
614             {
615                 ++counter;
616                 CHECK(i.key() == "");
617                 CHECK(i.value() == json(1));
618             }
619 
620             CHECK(counter == 2);
621         }
622 
623         SECTION("reference")
624         {
625             json j = 1;
626             int counter = 1;
627 
628             for (auto& i : json::iterator_wrapper(j))
629             {
630                 ++counter;
631                 CHECK(i.key() == "");
632                 CHECK(i.value() == json(1));
633 
634                 // change value
635                 i.value() = json(2);
636             }
637 
638             CHECK(counter == 2);
639 
640             // check if value has changed
641             CHECK(j == json(2));
642         }
643 
644         SECTION("const value")
645         {
646             json j = 1;
647             int counter = 1;
648 
649             for (const auto i : json::iterator_wrapper(j))
650             {
651                 ++counter;
652                 CHECK(i.key() == "");
653                 CHECK(i.value() == json(1));
654             }
655 
656             CHECK(counter == 2);
657         }
658 
659         SECTION("const reference")
660         {
661             json j = 1;
662             int counter = 1;
663 
664             for (const auto& i : json::iterator_wrapper(j))
665             {
666                 ++counter;
667                 CHECK(i.key() == "");
668                 CHECK(i.value() == json(1));
669             }
670 
671             CHECK(counter == 2);
672         }
673     }
674 
675     SECTION("const primitive")
676     {
677         SECTION("value")
678         {
679             const json j = 1;
680             int counter = 1;
681 
682             for (auto i : json::iterator_wrapper(j))
683             {
684                 ++counter;
685                 CHECK(i.key() == "");
686                 CHECK(i.value() == json(1));
687             }
688 
689             CHECK(counter == 2);
690         }
691 
692         SECTION("reference")
693         {
694             const json j = 1;
695             int counter = 1;
696 
697             for (auto& i : json::iterator_wrapper(j))
698             {
699                 ++counter;
700                 CHECK(i.key() == "");
701                 CHECK(i.value() == json(1));
702             }
703 
704             CHECK(counter == 2);
705         }
706 
707         SECTION("const value")
708         {
709             const json j = 1;
710             int counter = 1;
711 
712             for (const auto i : json::iterator_wrapper(j))
713             {
714                 ++counter;
715                 CHECK(i.key() == "");
716                 CHECK(i.value() == json(1));
717             }
718 
719             CHECK(counter == 2);
720         }
721 
722         SECTION("const reference")
723         {
724             const json j = 1;
725             int counter = 1;
726 
727             for (const auto& i : json::iterator_wrapper(j))
728             {
729                 ++counter;
730                 CHECK(i.key() == "");
731                 CHECK(i.value() == json(1));
732             }
733 
734             CHECK(counter == 2);
735         }
736     }
737 }
738 
739 TEST_CASE("items()")
740 {
741     SECTION("object")
742     {
743         SECTION("value")
744         {
745             json j = { {"A", 1}, {"B", 2} };
746             int counter = 1;
747 
748             for (auto i : j.items())
749             {
750                 switch (counter++)
751                 {
752                     case 1:
753                     {
754                         CHECK(i.key() == "A");
755                         CHECK(i.value() == json(1));
756                         break;
757                     }
758 
759                     case 2:
760                     {
761                         CHECK(i.key() == "B");
762                         CHECK(i.value() == json(2));
763                         break;
764                     }
765 
766                     default:
767                     {
768                         break;
769                     }
770                 }
771             }
772 
773             CHECK(counter == 3);
774         }
775 
776         SECTION("reference")
777         {
778             json j = { {"A", 1}, {"B", 2} };
779             int counter = 1;
780 
781             for (auto& i : j.items())
782             {
783                 switch (counter++)
784                 {
785                     case 1:
786                     {
787                         CHECK(i.key() == "A");
788                         CHECK(i.value() == json(1));
789 
790                         // change the value
791                         i.value() = json(11);
792                         CHECK(i.value() == json(11));
793                         break;
794                     }
795 
796                     case 2:
797                     {
798                         CHECK(i.key() == "B");
799                         CHECK(i.value() == json(2));
800 
801                         // change the value
802                         i.value() = json(22);
803                         CHECK(i.value() == json(22));
804                         break;
805                     }
806 
807                     default:
808                     {
809                         break;
810                     }
811                 }
812             }
813 
814             CHECK(counter == 3);
815 
816             // check if values where changed
817             CHECK(j == json({ {"A", 11}, {"B", 22} }));
818         }
819 
820         SECTION("const value")
821         {
822             json j = { {"A", 1}, {"B", 2} };
823             int counter = 1;
824 
825             for (const auto i : j.items())
826             {
827                 switch (counter++)
828                 {
829                     case 1:
830                     {
831                         CHECK(i.key() == "A");
832                         CHECK(i.value() == json(1));
833                         break;
834                     }
835 
836                     case 2:
837                     {
838                         CHECK(i.key() == "B");
839                         CHECK(i.value() == json(2));
840                         break;
841                     }
842 
843                     default:
844                     {
845                         break;
846                     }
847                 }
848             }
849 
850             CHECK(counter == 3);
851         }
852 
853         SECTION("const reference")
854         {
855             json j = { {"A", 1}, {"B", 2} };
856             int counter = 1;
857 
858             for (const auto& i : j.items())
859             {
860                 switch (counter++)
861                 {
862                     case 1:
863                     {
864                         CHECK(i.key() == "A");
865                         CHECK(i.value() == json(1));
866                         break;
867                     }
868 
869                     case 2:
870                     {
871                         CHECK(i.key() == "B");
872                         CHECK(i.value() == json(2));
873                         break;
874                     }
875 
876                     default:
877                     {
878                         break;
879                     }
880                 }
881             }
882 
883             CHECK(counter == 3);
884         }
885 
886 #ifdef JSON_HAS_CPP_17
887         SECTION("structured bindings")
888         {
889             json j = { {"A", 1}, {"B", 2} };
890 
891             std::map<std::string, int> m;
892 
893             for (auto const&[key, value] : j.items())
894             {
895                 m.emplace(key, value);
896             }
897 
898             CHECK(j.get<decltype(m)>() == m);
899         }
900 #endif
901     }
902 
903     SECTION("const object")
904     {
905         SECTION("value")
906         {
907             const json j = { {"A", 1}, {"B", 2} };
908             int counter = 1;
909 
910             for (auto i : j.items())
911             {
912                 switch (counter++)
913                 {
914                     case 1:
915                     {
916                         CHECK(i.key() == "A");
917                         CHECK(i.value() == json(1));
918                         break;
919                     }
920 
921                     case 2:
922                     {
923                         CHECK(i.key() == "B");
924                         CHECK(i.value() == json(2));
925                         break;
926                     }
927 
928                     default:
929                     {
930                         break;
931                     }
932                 }
933             }
934 
935             CHECK(counter == 3);
936         }
937 
938         SECTION("reference")
939         {
940             const json j = { {"A", 1}, {"B", 2} };
941             int counter = 1;
942 
943             for (auto& i : j.items())
944             {
945                 switch (counter++)
946                 {
947                     case 1:
948                     {
949                         CHECK(i.key() == "A");
950                         CHECK(i.value() == json(1));
951                         break;
952                     }
953 
954                     case 2:
955                     {
956                         CHECK(i.key() == "B");
957                         CHECK(i.value() == json(2));
958                         break;
959                     }
960 
961                     default:
962                     {
963                         break;
964                     }
965                 }
966             }
967 
968             CHECK(counter == 3);
969         }
970 
971         SECTION("const value")
972         {
973             const json j = { {"A", 1}, {"B", 2} };
974             int counter = 1;
975 
976             for (const auto i : j.items())
977             {
978                 switch (counter++)
979                 {
980                     case 1:
981                     {
982                         CHECK(i.key() == "A");
983                         CHECK(i.value() == json(1));
984                         break;
985                     }
986 
987                     case 2:
988                     {
989                         CHECK(i.key() == "B");
990                         CHECK(i.value() == json(2));
991                         break;
992                     }
993 
994                     default:
995                     {
996                         break;
997                     }
998                 }
999             }
1000 
1001             CHECK(counter == 3);
1002         }
1003 
1004         SECTION("const reference")
1005         {
1006             const json j = { {"A", 1}, {"B", 2} };
1007             int counter = 1;
1008 
1009             for (const auto& i : j.items())
1010             {
1011                 switch (counter++)
1012                 {
1013                     case 1:
1014                     {
1015                         CHECK(i.key() == "A");
1016                         CHECK(i.value() == json(1));
1017                         break;
1018                     }
1019 
1020                     case 2:
1021                     {
1022                         CHECK(i.key() == "B");
1023                         CHECK(i.value() == json(2));
1024                         break;
1025                     }
1026 
1027                     default:
1028                     {
1029                         break;
1030                     }
1031                 }
1032             }
1033 
1034             CHECK(counter == 3);
1035         }
1036     }
1037 
1038     SECTION("array")
1039     {
1040         SECTION("value")
1041         {
1042             json j = { "A", "B" };
1043             int counter = 1;
1044 
1045             for (auto i : j.items())
1046             {
1047                 switch (counter++)
1048                 {
1049                     case 1:
1050                     {
1051                         CHECK(i.key() == "0");
1052                         CHECK(i.value() == "A");
1053                         break;
1054                     }
1055 
1056                     case 2:
1057                     {
1058                         CHECK(i.key() == "1");
1059                         CHECK(i.value() == "B");
1060                         break;
1061                     }
1062 
1063                     default:
1064                     {
1065                         break;
1066                     }
1067                 }
1068             }
1069 
1070             CHECK(counter == 3);
1071         }
1072 
1073         SECTION("reference")
1074         {
1075             json j = { "A", "B" };
1076             int counter = 1;
1077 
1078             for (auto& i : j.items())
1079             {
1080                 switch (counter++)
1081                 {
1082                     case 1:
1083                     {
1084                         CHECK(i.key() == "0");
1085                         CHECK(i.value() == "A");
1086 
1087                         // change the value
1088                         i.value() = "AA";
1089                         CHECK(i.value() == "AA");
1090                         break;
1091                     }
1092 
1093                     case 2:
1094                     {
1095                         CHECK(i.key() == "1");
1096                         CHECK(i.value() == "B");
1097 
1098                         // change the value
1099                         i.value() = "BB";
1100                         CHECK(i.value() == "BB");
1101                         break;
1102                     }
1103 
1104                     default:
1105                     {
1106                         break;
1107                     }
1108                 }
1109             }
1110 
1111             CHECK(counter == 3);
1112 
1113             // check if values where changed
1114             CHECK(j == json({ "AA", "BB" }));
1115         }
1116 
1117         SECTION("const value")
1118         {
1119             json j = { "A", "B" };
1120             int counter = 1;
1121 
1122             for (const auto i : j.items())
1123             {
1124                 switch (counter++)
1125                 {
1126                     case 1:
1127                     {
1128                         CHECK(i.key() == "0");
1129                         CHECK(i.value() == "A");
1130                         break;
1131                     }
1132 
1133                     case 2:
1134                     {
1135                         CHECK(i.key() == "1");
1136                         CHECK(i.value() == "B");
1137                         break;
1138                     }
1139 
1140                     default:
1141                     {
1142                         break;
1143                     }
1144                 }
1145             }
1146 
1147             CHECK(counter == 3);
1148         }
1149 
1150         SECTION("const reference")
1151         {
1152             json j = { "A", "B" };
1153             int counter = 1;
1154 
1155             for (const auto& i : j.items())
1156             {
1157                 switch (counter++)
1158                 {
1159                     case 1:
1160                     {
1161                         CHECK(i.key() == "0");
1162                         CHECK(i.value() == "A");
1163                         break;
1164                     }
1165 
1166                     case 2:
1167                     {
1168                         CHECK(i.key() == "1");
1169                         CHECK(i.value() == "B");
1170                         break;
1171                     }
1172 
1173                     default:
1174                     {
1175                         break;
1176                     }
1177                 }
1178             }
1179 
1180             CHECK(counter == 3);
1181         }
1182     }
1183 
1184     SECTION("const array")
1185     {
1186         SECTION("value")
1187         {
1188             const json j = { "A", "B" };
1189             int counter = 1;
1190 
1191             for (auto i : j.items())
1192             {
1193                 switch (counter++)
1194                 {
1195                     case 1:
1196                     {
1197                         CHECK(i.key() == "0");
1198                         CHECK(i.value() == "A");
1199                         break;
1200                     }
1201 
1202                     case 2:
1203                     {
1204                         CHECK(i.key() == "1");
1205                         CHECK(i.value() == "B");
1206                         break;
1207                     }
1208 
1209                     default:
1210                     {
1211                         break;
1212                     }
1213                 }
1214             }
1215 
1216             CHECK(counter == 3);
1217         }
1218 
1219         SECTION("reference")
1220         {
1221             const json j = { "A", "B" };
1222             int counter = 1;
1223 
1224             for (auto& i : j.items())
1225             {
1226                 switch (counter++)
1227                 {
1228                     case 1:
1229                     {
1230                         CHECK(i.key() == "0");
1231                         CHECK(i.value() == "A");
1232                         break;
1233                     }
1234 
1235                     case 2:
1236                     {
1237                         CHECK(i.key() == "1");
1238                         CHECK(i.value() == "B");
1239                         break;
1240                     }
1241 
1242                     default:
1243                     {
1244                         break;
1245                     }
1246                 }
1247             }
1248 
1249             CHECK(counter == 3);
1250         }
1251 
1252         SECTION("const value")
1253         {
1254             const json j = { "A", "B" };
1255             int counter = 1;
1256 
1257             for (const auto i : j.items())
1258             {
1259                 switch (counter++)
1260                 {
1261                     case 1:
1262                     {
1263                         CHECK(i.key() == "0");
1264                         CHECK(i.value() == "A");
1265                         break;
1266                     }
1267 
1268                     case 2:
1269                     {
1270                         CHECK(i.key() == "1");
1271                         CHECK(i.value() == "B");
1272                         break;
1273                     }
1274 
1275                     default:
1276                     {
1277                         break;
1278                     }
1279                 }
1280             }
1281 
1282             CHECK(counter == 3);
1283         }
1284 
1285         SECTION("const reference")
1286         {
1287             const json j = { "A", "B" };
1288             int counter = 1;
1289 
1290             for (const auto& i : j.items())
1291             {
1292                 switch (counter++)
1293                 {
1294                     case 1:
1295                     {
1296                         CHECK(i.key() == "0");
1297                         CHECK(i.value() == "A");
1298                         break;
1299                     }
1300 
1301                     case 2:
1302                     {
1303                         CHECK(i.key() == "1");
1304                         CHECK(i.value() == "B");
1305                         break;
1306                     }
1307 
1308                     default:
1309                     {
1310                         break;
1311                     }
1312                 }
1313             }
1314 
1315             CHECK(counter == 3);
1316         }
1317     }
1318 
1319     SECTION("primitive")
1320     {
1321         SECTION("value")
1322         {
1323             json j = 1;
1324             int counter = 1;
1325 
1326             for (auto i : j.items())
1327             {
1328                 ++counter;
1329                 CHECK(i.key() == "");
1330                 CHECK(i.value() == json(1));
1331             }
1332 
1333             CHECK(counter == 2);
1334         }
1335 
1336         SECTION("reference")
1337         {
1338             json j = 1;
1339             int counter = 1;
1340 
1341             for (auto& i : j.items())
1342             {
1343                 ++counter;
1344                 CHECK(i.key() == "");
1345                 CHECK(i.value() == json(1));
1346 
1347                 // change value
1348                 i.value() = json(2);
1349             }
1350 
1351             CHECK(counter == 2);
1352 
1353             // check if value has changed
1354             CHECK(j == json(2));
1355         }
1356 
1357         SECTION("const value")
1358         {
1359             json j = 1;
1360             int counter = 1;
1361 
1362             for (const auto i : j.items())
1363             {
1364                 ++counter;
1365                 CHECK(i.key() == "");
1366                 CHECK(i.value() == json(1));
1367             }
1368 
1369             CHECK(counter == 2);
1370         }
1371 
1372         SECTION("const reference")
1373         {
1374             json j = 1;
1375             int counter = 1;
1376 
1377             for (const auto& i : j.items())
1378             {
1379                 ++counter;
1380                 CHECK(i.key() == "");
1381                 CHECK(i.value() == json(1));
1382             }
1383 
1384             CHECK(counter == 2);
1385         }
1386     }
1387 
1388     SECTION("const primitive")
1389     {
1390         SECTION("value")
1391         {
1392             const json j = 1;
1393             int counter = 1;
1394 
1395             for (auto i : j.items())
1396             {
1397                 ++counter;
1398                 CHECK(i.key() == "");
1399                 CHECK(i.value() == json(1));
1400             }
1401 
1402             CHECK(counter == 2);
1403         }
1404 
1405         SECTION("reference")
1406         {
1407             const json j = 1;
1408             int counter = 1;
1409 
1410             for (auto& i : j.items())
1411             {
1412                 ++counter;
1413                 CHECK(i.key() == "");
1414                 CHECK(i.value() == json(1));
1415             }
1416 
1417             CHECK(counter == 2);
1418         }
1419 
1420         SECTION("const value")
1421         {
1422             const json j = 1;
1423             int counter = 1;
1424 
1425             for (const auto i : j.items())
1426             {
1427                 ++counter;
1428                 CHECK(i.key() == "");
1429                 CHECK(i.value() == json(1));
1430             }
1431 
1432             CHECK(counter == 2);
1433         }
1434 
1435         SECTION("const reference")
1436         {
1437             const json j = 1;
1438             int counter = 1;
1439 
1440             for (const auto& i : j.items())
1441             {
1442                 ++counter;
1443                 CHECK(i.key() == "");
1444                 CHECK(i.value() == json(1));
1445             }
1446 
1447             CHECK(counter == 2);
1448         }
1449     }
1450 }
1451