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