diff --git a/Makefile b/Makefile index a2907580a..e1a1d2b75 100644 --- a/Makefile +++ b/Makefile @@ -1,4 +1,4 @@ -.PHONY: pretty clean ChangeLog.md release +.PHONY: pretty clean ChangeLog.md release update_hedley update_hedley_undef ########################################################################## # configuration @@ -41,6 +41,8 @@ all: @echo "fuzz_testing_ubjson - prepare fuzz testing of the UBJSON parser" @echo "pretty - beautify code with Artistic Style" @echo "run_benchmarks - build and run benchmarks" + @echo "update_hedley - download Hedley and regenerate hedley.hpp / hedley_undef.hpp" + @echo "update_hedley_undef - rebuild hedley_undef.hpp from the JSON_HEDLEY_* #define names in hedley.hpp" ########################################################################## @@ -241,11 +243,24 @@ update_hedley: rm -f include/nlohmann/thirdparty/hedley/hedley.hpp include/nlohmann/thirdparty/hedley/hedley_undef.hpp curl https://raw.githubusercontent.com/nemequ/hedley/master/hedley.h -o include/nlohmann/thirdparty/hedley/hedley.hpp $(SED) -i 's/HEDLEY_/JSON_HEDLEY_/g' include/nlohmann/thirdparty/hedley/hedley.hpp - grep -oE "#[[:blank:]]*define[[:blank:]]+JSON_HEDLEY_[A-Za-z0-9_]+" include/nlohmann/thirdparty/hedley/hedley.hpp | awk '{print $$NF}' | grep -v "__" | sort -u | $(SED) 's/^/#undef /' > include/nlohmann/thirdparty/hedley/hedley_undef.hpp $(SED) -i '1s/^/#pragma once\n\n/' include/nlohmann/thirdparty/hedley/hedley.hpp - $(SED) -i '1s/^/#pragma once\n\n/' include/nlohmann/thirdparty/hedley/hedley_undef.hpp + $(MAKE) update_hedley_undef $(MAKE) amalgamate +# Rebuild hedley_undef.hpp from every JSON_HEDLEY_* name that hedley.hpp +# #defines. Hedley does not #undef all of its public macros internally (see +# #5408), so grepping those #undef lines misses names such as +# JSON_HEDLEY_PRAGMA. cmake/scripts/gen_hedley_undef_check.cmake is the +# single source of truth for this extraction (tests/CMakeLists.txt uses the +# same script, in MODE=checks, to generate the matching leak-check test), so +# the vendored header, the generated #undef list, and the regression test +# cannot drift apart. +update_hedley_undef: + cmake -DHEDLEY_HPP=include/nlohmann/thirdparty/hedley/hedley.hpp \ + -DOUTPUT=include/nlohmann/thirdparty/hedley/hedley_undef.hpp \ + -DMODE=undef \ + -P cmake/scripts/gen_hedley_undef_check.cmake + ########################################################################## # serve_header.py ########################################################################## diff --git a/cmake/scripts/gen_hedley_undef_check.cmake b/cmake/scripts/gen_hedley_undef_check.cmake new file mode 100644 index 000000000..225f311f6 --- /dev/null +++ b/cmake/scripts/gen_hedley_undef_check.cmake @@ -0,0 +1,105 @@ +# Shared extractor for the JSON_HEDLEY_* macro names defined in hedley.hpp. +# +# Every macro that hedley.hpp #defines must be #undef-ed again once json.hpp +# has been fully processed (see include/nlohmann/detail/macro_unscope.hpp +# and https://github.com/nlohmann/json/issues/5408). Deriving the macro list +# straight from hedley.hpp here -- instead of hand-maintaining it in two +# places -- means hedley_undef.hpp and the regression test that checks for +# leaked macros can never drift apart, even after a future `make +# update_hedley` pulls in new macros from upstream Hedley. +# +# MODE=undef (default): write hedley_undef.hpp (SPDX header, #pragma once, +# one #undef per macro name) -- used by `make update_hedley_undef` +# MODE=checks: write one #ifdef/FAIL_CHECK/#endif per macro name, +# meant to be #include-d inside a TEST_CASE -- used by +# tests/CMakeLists.txt to (re)generate the include for +# tests/src/unit-no-macro-leak.cpp +# +# Required variables: +# HEDLEY_HPP path to include/nlohmann/thirdparty/hedley/hedley.hpp +# OUTPUT path of the file to (over)write +# Optional: +# MODE "undef" (default) or "checks" + +if(NOT DEFINED HEDLEY_HPP OR NOT DEFINED OUTPUT) + message(FATAL_ERROR "HEDLEY_HPP and OUTPUT must be set") +endif() + +if(NOT EXISTS "${HEDLEY_HPP}") + message(FATAL_ERROR "Hedley header not found: ${HEDLEY_HPP}") +endif() + +if(NOT DEFINED MODE) + set(MODE undef) +endif() + +if(NOT MODE STREQUAL "undef" AND NOT MODE STREQUAL "checks") + message(FATAL_ERROR "MODE must be undef or checks, got: ${MODE}") +endif() + +# Line-anchored, like `grep -oE "^[[:blank:]]*#[[:blank:]]*define[[:blank:]]+JSON_HEDLEY_[A-Za-z0-9_]+"`. +# Unanchored matching would also pick up JSON_HEDLEY_* mentions inside +# comments or string literals elsewhere in the file, which must not turn +# into #undef lines. +file(STRINGS "${HEDLEY_HPP}" hedley_lines) +set(macro_names) +foreach(line IN LISTS hedley_lines) + if("${line}" MATCHES "^[ \t]*#[ \t]*define[ \t]+(JSON_HEDLEY_[A-Za-z0-9_]+)") + list(APPEND macro_names "${CMAKE_MATCH_1}") + endif() +endforeach() + +if(NOT macro_names) + message(FATAL_ERROR "No JSON_HEDLEY_* macros found in ${HEDLEY_HPP}") +endif() + +list(REMOVE_DUPLICATES macro_names) +# Lexicographic, locale-independent (ASCII-only names) -- matches `LC_ALL=C sort`. +list(SORT macro_names COMPARE STRING) +list(LENGTH macro_names macro_count) + +set(generated "") +if(MODE STREQUAL "undef") + # Same banner `make update_hedley_undef` would stamp by hand, so the + # recipe is self-contained and its output is byte-stable across reruns. + string(APPEND generated "// __ _____ _____ _____\n") + string(APPEND generated "// __| | __| | | | JSON for Modern C++\n") + string(APPEND generated "// | | |__ | | | | | | version 3.12.0\n") + string(APPEND generated "// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n") + string(APPEND generated "//\n") + string(APPEND generated "// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann \n") + string(APPEND generated "// SPDX-License-Identifier: MIT\n") + string(APPEND generated "\n") + string(APPEND generated "#pragma once\n") + string(APPEND generated "\n") + foreach(name IN LISTS macro_names) + string(APPEND generated "#undef ${name}\n") + endforeach() +else() + string(APPEND generated "// This file is generated by cmake/scripts/gen_hedley_undef_check.cmake\n") + string(APPEND generated "// from include/nlohmann/thirdparty/hedley/hedley.hpp. Do not edit it by\n") + string(APPEND generated "// hand -- it is regenerated on every build. ${macro_count} macros checked.\n\n") + foreach(name IN LISTS macro_names) + string(APPEND generated "#ifdef ${name}\n") + string(APPEND generated " FAIL_CHECK(\"${name} leaked after including nlohmann/json.hpp\");\n") + string(APPEND generated "#endif\n") + endforeach() +endif() + +get_filename_component(output_dir "${OUTPUT}" DIRECTORY) +if(output_dir) + file(MAKE_DIRECTORY "${output_dir}") +endif() + +# Avoid rewriting the file (and busting downstream incremental rebuilds) +# when the content has not actually changed. +set(write_output TRUE) +if(EXISTS "${OUTPUT}") + file(READ "${OUTPUT}" existing_content) + if(existing_content STREQUAL generated) + set(write_output FALSE) + endif() +endif() +if(write_output) + file(WRITE "${OUTPUT}" "${generated}") +endif() diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 4383b582c..2d0aaaf70 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -125,6 +125,51 @@ json_test_set_test_options(test-unicode4 TEST_PROPERTIES TIMEOUT 3000) # add unit tests ############################################################################# +# Generate the leak checks for every JSON_HEDLEY_* macro defined in +# hedley.hpp; tests/src/unit-no-macro-leak.cpp #include-s the result after +# nlohmann/json.hpp (see issue #5408). Using the shared +# cmake/scripts/gen_hedley_undef_check.cmake script (also used by `make +# update_hedley_undef`) instead of a hand-maintained list of macro names +# means this test can never go stale after a future `make update_hedley`. +set(hedley_hpp "${PROJECT_SOURCE_DIR}/include/nlohmann/thirdparty/hedley/hedley.hpp") +set(hedley_undef_check_script "${PROJECT_SOURCE_DIR}/cmake/scripts/gen_hedley_undef_check.cmake") +set(hedley_undef_checks "${PROJECT_BINARY_DIR}/include/hedley_undef_checks.inc") + +# Reconfigure whenever the vendored header or the generator script changes, +# so a `cmake --build` after `make update_hedley` does not silently keep a +# stale generated file around. +set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS + "${hedley_hpp}" + "${hedley_undef_check_script}") + +# Generate once at configure time, so the very first build (before any +# custom-command build step has run) already has an up-to-date file. +execute_process( + COMMAND ${CMAKE_COMMAND} + "-DHEDLEY_HPP=${hedley_hpp}" + "-DOUTPUT=${hedley_undef_checks}" + -DMODE=checks + -P "${hedley_undef_check_script}" + RESULT_VARIABLE hedley_undef_check_result +) +if(NOT hedley_undef_check_result EQUAL 0) + message(FATAL_ERROR "Failed to generate ${hedley_undef_checks}") +endif() + +# Also (re)generate as a build step, so an incremental build after editing +# hedley.hpp without a full reconfigure still picks up the change. +add_custom_command( + OUTPUT "${hedley_undef_checks}" + COMMAND ${CMAKE_COMMAND} + "-DHEDLEY_HPP=${hedley_hpp}" + "-DOUTPUT=${hedley_undef_checks}" + -DMODE=checks + -P "${hedley_undef_check_script}" + DEPENDS "${hedley_hpp}" "${hedley_undef_check_script}" + COMMENT "Generating Hedley undef leak checks" + VERBATIM) +add_custom_target(generate_hedley_undef_checks DEPENDS "${hedley_undef_checks}") + if("${JSON_TestStandards}" STREQUAL "") set(test_cxx_standards 11 14 17 20 23) unset(test_force) @@ -163,6 +208,14 @@ foreach(file ${files}) json_test_add_test_for(${file} MAIN test_main CXX_STANDARDS ${test_cxx_standards} ${test_force}) endforeach() +# tests/src/unit-no-macro-leak.cpp #include-s the generated leak-check file, +# so its test targets must be built after generate_hedley_undef_checks. +foreach(cxx_standard ${test_cxx_standards}) + if(TARGET test-no-macro-leak_cpp${cxx_standard}) + add_dependencies(test-no-macro-leak_cpp${cxx_standard} generate_hedley_undef_checks) + endif() +endforeach() + if(json_32bit_test_only) # Skip all other tests in this file return() diff --git a/tests/src/unit-no-macro-leak.cpp b/tests/src/unit-no-macro-leak.cpp index 5e27abb03..c5184c52f 100644 --- a/tests/src/unit-no-macro-leak.cpp +++ b/tests/src/unit-no-macro-leak.cpp @@ -16,471 +16,19 @@ // and JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE escaped this cleanup because // hedley_undef.hpp had no matching #undef for them. // -// The #ifdef/#error checks below are mechanically derived from the full list -// of macro names in hedley_undef.hpp, so every JSON_HEDLEY_* macro is covered -// -- not just the four that leaked historically. +// hedley_undef_checks.inc (included below) is generated at CMake configure/ +// build time by cmake/scripts/gen_hedley_undef_check.cmake, which derives the +// full list of JSON_HEDLEY_* macro names directly from hedley.hpp. That way +// this test covers every macro Hedley actually defines -- not a hardcoded +// snapshot that would silently go stale the next time `make update_hedley` +// runs -- and can never drift from the vendored header. #include "doctest_compatibility.h" #include -#ifdef JSON_HEDLEY_ALWAYS_INLINE - #error "JSON_HEDLEY_ALWAYS_INLINE must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_ARM_VERSION - #error "JSON_HEDLEY_ARM_VERSION must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_ARM_VERSION_CHECK - #error "JSON_HEDLEY_ARM_VERSION_CHECK must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_ARRAY_PARAM - #error "JSON_HEDLEY_ARRAY_PARAM must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_ASSUME - #error "JSON_HEDLEY_ASSUME must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_BEGIN_C_DECLS - #error "JSON_HEDLEY_BEGIN_C_DECLS must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE - #error "JSON_HEDLEY_CLANG_HAS_ATTRIBUTE must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_CLANG_HAS_BUILTIN - #error "JSON_HEDLEY_CLANG_HAS_BUILTIN must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE - #error "JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE - #error "JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_CLANG_HAS_EXTENSION - #error "JSON_HEDLEY_CLANG_HAS_EXTENSION must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_CLANG_HAS_FEATURE - #error "JSON_HEDLEY_CLANG_HAS_FEATURE must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_CLANG_HAS_WARNING - #error "JSON_HEDLEY_CLANG_HAS_WARNING must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_COMPCERT_VERSION - #error "JSON_HEDLEY_COMPCERT_VERSION must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_COMPCERT_VERSION_CHECK - #error "JSON_HEDLEY_COMPCERT_VERSION_CHECK must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_CONCAT - #error "JSON_HEDLEY_CONCAT must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_CONCAT3 - #error "JSON_HEDLEY_CONCAT3 must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_CONCAT3_EX - #error "JSON_HEDLEY_CONCAT3_EX must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_CONCAT_EX - #error "JSON_HEDLEY_CONCAT_EX must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_CONST - #error "JSON_HEDLEY_CONST must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_CONSTEXPR - #error "JSON_HEDLEY_CONSTEXPR must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_CONST_CAST - #error "JSON_HEDLEY_CONST_CAST must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_CPP_CAST - #error "JSON_HEDLEY_CPP_CAST must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_CRAY_VERSION - #error "JSON_HEDLEY_CRAY_VERSION must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_CRAY_VERSION_CHECK - #error "JSON_HEDLEY_CRAY_VERSION_CHECK must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_C_DECL - #error "JSON_HEDLEY_C_DECL must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_DEPRECATED - #error "JSON_HEDLEY_DEPRECATED must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_DEPRECATED_FOR - #error "JSON_HEDLEY_DEPRECATED_FOR must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL - #error "JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ - #error "JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED - #error "JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES - #error "JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS - #error "JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION - #error "JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_DIAGNOSTIC_POP - #error "JSON_HEDLEY_DIAGNOSTIC_POP must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_DIAGNOSTIC_PUSH - #error "JSON_HEDLEY_DIAGNOSTIC_PUSH must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_DMC_VERSION - #error "JSON_HEDLEY_DMC_VERSION must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_DMC_VERSION_CHECK - #error "JSON_HEDLEY_DMC_VERSION_CHECK must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_EMPTY_BASES - #error "JSON_HEDLEY_EMPTY_BASES must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_EMSCRIPTEN_VERSION - #error "JSON_HEDLEY_EMSCRIPTEN_VERSION must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK - #error "JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_END_C_DECLS - #error "JSON_HEDLEY_END_C_DECLS must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_FALL_THROUGH - #error "JSON_HEDLEY_FALL_THROUGH must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_FLAGS - #error "JSON_HEDLEY_FLAGS must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_FLAGS_CAST - #error "JSON_HEDLEY_FLAGS_CAST must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_GCC_HAS_ATTRIBUTE - #error "JSON_HEDLEY_GCC_HAS_ATTRIBUTE must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_GCC_HAS_BUILTIN - #error "JSON_HEDLEY_GCC_HAS_BUILTIN must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE - #error "JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE - #error "JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_GCC_HAS_EXTENSION - #error "JSON_HEDLEY_GCC_HAS_EXTENSION must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_GCC_HAS_FEATURE - #error "JSON_HEDLEY_GCC_HAS_FEATURE must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_GCC_HAS_WARNING - #error "JSON_HEDLEY_GCC_HAS_WARNING must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK - #error "JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_GCC_VERSION - #error "JSON_HEDLEY_GCC_VERSION must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_GCC_VERSION_CHECK - #error "JSON_HEDLEY_GCC_VERSION_CHECK must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE - #error "JSON_HEDLEY_GNUC_HAS_ATTRIBUTE must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_GNUC_HAS_BUILTIN - #error "JSON_HEDLEY_GNUC_HAS_BUILTIN must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE - #error "JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE - #error "JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_GNUC_HAS_EXTENSION - #error "JSON_HEDLEY_GNUC_HAS_EXTENSION must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_GNUC_HAS_FEATURE - #error "JSON_HEDLEY_GNUC_HAS_FEATURE must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_GNUC_HAS_WARNING - #error "JSON_HEDLEY_GNUC_HAS_WARNING must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_GNUC_VERSION - #error "JSON_HEDLEY_GNUC_VERSION must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_GNUC_VERSION_CHECK - #error "JSON_HEDLEY_GNUC_VERSION_CHECK must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_HAS_ATTRIBUTE - #error "JSON_HEDLEY_HAS_ATTRIBUTE must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_HAS_BUILTIN - #error "JSON_HEDLEY_HAS_BUILTIN must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_HAS_CPP_ATTRIBUTE - #error "JSON_HEDLEY_HAS_CPP_ATTRIBUTE must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS - #error "JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE - #error "JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_HAS_EXTENSION - #error "JSON_HEDLEY_HAS_EXTENSION must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_HAS_FEATURE - #error "JSON_HEDLEY_HAS_FEATURE must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_HAS_WARNING - #error "JSON_HEDLEY_HAS_WARNING must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_IAR_VERSION - #error "JSON_HEDLEY_IAR_VERSION must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_IAR_VERSION_CHECK - #error "JSON_HEDLEY_IAR_VERSION_CHECK must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_IBM_VERSION - #error "JSON_HEDLEY_IBM_VERSION must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_IBM_VERSION_CHECK - #error "JSON_HEDLEY_IBM_VERSION_CHECK must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_IMPORT - #error "JSON_HEDLEY_IMPORT must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_INLINE - #error "JSON_HEDLEY_INLINE must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_INTEL_CL_VERSION - #error "JSON_HEDLEY_INTEL_CL_VERSION must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_INTEL_CL_VERSION_CHECK - #error "JSON_HEDLEY_INTEL_CL_VERSION_CHECK must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_INTEL_VERSION - #error "JSON_HEDLEY_INTEL_VERSION must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_INTEL_VERSION_CHECK - #error "JSON_HEDLEY_INTEL_VERSION_CHECK must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_IS_CONSTANT - #error "JSON_HEDLEY_IS_CONSTANT must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_IS_CONSTEXPR_ - #error "JSON_HEDLEY_IS_CONSTEXPR_ must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_LIKELY - #error "JSON_HEDLEY_LIKELY must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_MALLOC - #error "JSON_HEDLEY_MALLOC must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_MCST_LCC_VERSION - #error "JSON_HEDLEY_MCST_LCC_VERSION must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_MCST_LCC_VERSION_CHECK - #error "JSON_HEDLEY_MCST_LCC_VERSION_CHECK must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_MESSAGE - #error "JSON_HEDLEY_MESSAGE must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_MSVC_VERSION - #error "JSON_HEDLEY_MSVC_VERSION must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_MSVC_VERSION_CHECK - #error "JSON_HEDLEY_MSVC_VERSION_CHECK must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_NEVER_INLINE - #error "JSON_HEDLEY_NEVER_INLINE must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_NON_NULL - #error "JSON_HEDLEY_NON_NULL must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_NO_ESCAPE - #error "JSON_HEDLEY_NO_ESCAPE must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_NO_RETURN - #error "JSON_HEDLEY_NO_RETURN must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_NO_THROW - #error "JSON_HEDLEY_NO_THROW must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_NULL - #error "JSON_HEDLEY_NULL must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_PELLES_VERSION - #error "JSON_HEDLEY_PELLES_VERSION must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_PELLES_VERSION_CHECK - #error "JSON_HEDLEY_PELLES_VERSION_CHECK must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_PGI_VERSION - #error "JSON_HEDLEY_PGI_VERSION must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_PGI_VERSION_CHECK - #error "JSON_HEDLEY_PGI_VERSION_CHECK must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_PRAGMA - #error "JSON_HEDLEY_PRAGMA must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_PREDICT - #error "JSON_HEDLEY_PREDICT must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_PREDICT_FALSE - #error "JSON_HEDLEY_PREDICT_FALSE must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_PREDICT_TRUE - #error "JSON_HEDLEY_PREDICT_TRUE must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_PRINTF_FORMAT - #error "JSON_HEDLEY_PRINTF_FORMAT must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_PRIVATE - #error "JSON_HEDLEY_PRIVATE must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_PUBLIC - #error "JSON_HEDLEY_PUBLIC must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_PURE - #error "JSON_HEDLEY_PURE must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_REINTERPRET_CAST - #error "JSON_HEDLEY_REINTERPRET_CAST must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_REQUIRE - #error "JSON_HEDLEY_REQUIRE must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_REQUIRE_CONSTEXPR - #error "JSON_HEDLEY_REQUIRE_CONSTEXPR must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_REQUIRE_MSG - #error "JSON_HEDLEY_REQUIRE_MSG must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_RESTRICT - #error "JSON_HEDLEY_RESTRICT must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_RETURNS_NON_NULL - #error "JSON_HEDLEY_RETURNS_NON_NULL must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_SENTINEL - #error "JSON_HEDLEY_SENTINEL must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_STATIC_ASSERT - #error "JSON_HEDLEY_STATIC_ASSERT must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_STATIC_CAST - #error "JSON_HEDLEY_STATIC_CAST must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_STRINGIFY - #error "JSON_HEDLEY_STRINGIFY must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_STRINGIFY_EX - #error "JSON_HEDLEY_STRINGIFY_EX must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_SUNPRO_VERSION - #error "JSON_HEDLEY_SUNPRO_VERSION must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_SUNPRO_VERSION_CHECK - #error "JSON_HEDLEY_SUNPRO_VERSION_CHECK must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_TINYC_VERSION - #error "JSON_HEDLEY_TINYC_VERSION must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_TINYC_VERSION_CHECK - #error "JSON_HEDLEY_TINYC_VERSION_CHECK must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_TI_ARMCL_VERSION - #error "JSON_HEDLEY_TI_ARMCL_VERSION must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK - #error "JSON_HEDLEY_TI_ARMCL_VERSION_CHECK must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_TI_CL2000_VERSION - #error "JSON_HEDLEY_TI_CL2000_VERSION must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_TI_CL2000_VERSION_CHECK - #error "JSON_HEDLEY_TI_CL2000_VERSION_CHECK must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_TI_CL430_VERSION - #error "JSON_HEDLEY_TI_CL430_VERSION must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_TI_CL430_VERSION_CHECK - #error "JSON_HEDLEY_TI_CL430_VERSION_CHECK must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_TI_CL6X_VERSION - #error "JSON_HEDLEY_TI_CL6X_VERSION must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_TI_CL6X_VERSION_CHECK - #error "JSON_HEDLEY_TI_CL6X_VERSION_CHECK must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_TI_CL7X_VERSION - #error "JSON_HEDLEY_TI_CL7X_VERSION must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_TI_CL7X_VERSION_CHECK - #error "JSON_HEDLEY_TI_CL7X_VERSION_CHECK must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_TI_CLPRU_VERSION - #error "JSON_HEDLEY_TI_CLPRU_VERSION must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK - #error "JSON_HEDLEY_TI_CLPRU_VERSION_CHECK must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_TI_VERSION - #error "JSON_HEDLEY_TI_VERSION must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_TI_VERSION_CHECK - #error "JSON_HEDLEY_TI_VERSION_CHECK must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_UNAVAILABLE - #error "JSON_HEDLEY_UNAVAILABLE must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_UNLIKELY - #error "JSON_HEDLEY_UNLIKELY must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_UNPREDICTABLE - #error "JSON_HEDLEY_UNPREDICTABLE must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_UNREACHABLE - #error "JSON_HEDLEY_UNREACHABLE must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_UNREACHABLE_RETURN - #error "JSON_HEDLEY_UNREACHABLE_RETURN must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_VERSION - #error "JSON_HEDLEY_VERSION must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_VERSION_DECODE_MAJOR - #error "JSON_HEDLEY_VERSION_DECODE_MAJOR must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_VERSION_DECODE_MINOR - #error "JSON_HEDLEY_VERSION_DECODE_MINOR must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_VERSION_DECODE_REVISION - #error "JSON_HEDLEY_VERSION_DECODE_REVISION must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_VERSION_ENCODE - #error "JSON_HEDLEY_VERSION_ENCODE must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_WARNING - #error "JSON_HEDLEY_WARNING must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_WARN_UNUSED_RESULT - #error "JSON_HEDLEY_WARN_UNUSED_RESULT must not remain defined after including json.hpp" -#endif -#ifdef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG - #error "JSON_HEDLEY_WARN_UNUSED_RESULT_MSG must not remain defined after including json.hpp" -#endif - -TEST_CASE("no JSON_HEDLEY_* macro leaks after including json.hpp") +TEST_CASE("JSON_HEDLEY macros do not leak after including json.hpp") { - // if this test compiles at all, none of the JSON_HEDLEY_* macros checked - // above remained defined after including - CHECK(true); +#include "hedley_undef_checks.inc" + CHECK(true); // keep an assertion when nothing leaked }