# tests/ — mstring's own tests. Each one is a plain add_test() driven by
# run_and_diff.cmake (no GTest): the generated code is compiled with
# -Wall -Wextra -Werror and run, and the diagnostics of broken inputs are
# checked. A change to the generator is only proven by code that compiles.

set(RUN_AND_DIFF ${PROJECT_SOURCE_DIR}/cmake/run_and_diff.cmake)
set(MSTRING_TEST_WARNINGS -Wall -Wextra -Wpedantic -Werror)

# The features test: every generator feature, compiled and run.
# Deliberately incomplete translations: -w keeps the build log clean (the
# warnings have their own tests below).
mstring_generate(FEATURES_GENERATED ${CMAKE_CURRENT_SOURCE_DIR}/features/features.msg
                 OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/features
                 OPTIONS -w)
# Reporter (user.hh) has no user.cpp: its members are the generated MEMBER OF functions.
add_executable(mstring-test-features features/main.cpp ${FEATURES_GENERATED})
target_include_directories(mstring-test-features PRIVATE
    ${CMAKE_CURRENT_BINARY_DIR}/features ${CMAKE_CURRENT_SOURCE_DIR}/features)
target_compile_options(mstring-test-features PRIVATE ${MSTRING_TEST_WARNINGS})
add_test(NAME features
         COMMAND ${CMAKE_COMMAND}
                 -DEXE=$<TARGET_FILE:mstring-test-features>
                 -DEXPECTED=${CMAKE_CURRENT_SOURCE_DIR}/features/expected.txt
                 -P ${RUN_AND_DIFF})

# `$MESSAGE Just : STRING` generated the string function and nothing else.
add_test(NAME features.per-message-artefacts
         COMMAND ${CMAKE_COMMAND} -E cat ${CMAKE_CURRENT_BINARY_DIR}/features/features.hh)
set_tests_properties(features.per-message-artefacts PROPERTIES
    DEPENDS features
    PASS_REGULAR_EXPRESSION "std::string JustStr\\("
    FAIL_REGULAR_EXPRESSION "ThrowJust|JustException|JustStreamable")

# NOHEADER: the source carries the declarations and compiles on its own.
mstring_generate(SINGLE_GENERATED ${CMAKE_CURRENT_SOURCE_DIR}/single-file/single.msg
                 OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/single-file
                 NOHEADER)
add_executable(mstring-test-single single-file/main.cpp ${SINGLE_GENERATED})
target_compile_options(mstring-test-single PRIVATE ${MSTRING_TEST_WARNINGS})
add_test(NAME single-file
         COMMAND ${CMAKE_COMMAND}
                 -DEXE=$<TARGET_FILE:mstring-test-single>
                 -DEXPECTED=${CMAKE_CURRENT_SOURCE_DIR}/single-file/expected.txt
                 -P ${RUN_AND_DIFF})

# INLINE: header-only modules, two of them in one translation unit and in two
# translation units, next to an ordinary module.
foreach(module alpha beta)
    mstring_generate(INLINE_GENERATED ${CMAKE_CURRENT_SOURCE_DIR}/inline/${module}.msg
                     OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/inline
                     INLINE)
endforeach()
mstring_generate(INLINE_GENERATED ${CMAKE_CURRENT_SOURCE_DIR}/inline/gamma.msg
                 OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/inline)
add_executable(mstring-test-inline inline/main.cpp inline/other.cpp ${INLINE_GENERATED})
target_include_directories(mstring-test-inline PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/inline)
target_compile_options(mstring-test-inline PRIVATE ${MSTRING_TEST_WARNINGS})
add_test(NAME inline
         COMMAND ${CMAKE_COMMAND}
                 -DEXE=$<TARGET_FILE:mstring-test-inline>
                 -DEXPECTED=${CMAKE_CURRENT_SOURCE_DIR}/inline/expected.txt
                 -P ${RUN_AND_DIFF})

# $EXPORT + $EXCEPTION OVERRIDE (plugin's dsold shape): a shared library
# built with hidden visibility, used from a program.
mstring_generate(EXPORT_GENERATED ${CMAKE_CURRENT_SOURCE_DIR}/export/lib.msg
                 OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/export)
add_library(mstring-test-export-lib SHARED ${EXPORT_GENERATED})
target_include_directories(mstring-test-export-lib PUBLIC
    ${CMAKE_CURRENT_BINARY_DIR}/export ${CMAKE_CURRENT_SOURCE_DIR}/export)
set_target_properties(mstring-test-export-lib PROPERTIES
    CXX_VISIBILITY_PRESET hidden VISIBILITY_INLINES_HIDDEN ON)
target_compile_options(mstring-test-export-lib PRIVATE ${MSTRING_TEST_WARNINGS})
add_executable(mstring-test-export export/main.cpp)
target_link_libraries(mstring-test-export PRIVATE mstring-test-export-lib)
target_compile_options(mstring-test-export PRIVATE ${MSTRING_TEST_WARNINGS})
add_test(NAME export-override
         COMMAND ${CMAKE_COMMAND}
                 -DEXE=$<TARGET_FILE:mstring-test-export>
                 -DEXPECTED=${CMAKE_CURRENT_SOURCE_DIR}/export/expected.txt
                 -P ${RUN_AND_DIFF})

# $IMPORT: next to the importing file, then -I; settings carry over.
mstring_generate(IMPORT_GENERATED ${CMAKE_CURRENT_SOURCE_DIR}/import/main.msg
                 MODULE imported
                 OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/import
                 IMPORT_DIRECTORIES ${CMAKE_CURRENT_SOURCE_DIR}/import/lib
                 DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/import/shared/settings.msg
                         ${CMAKE_CURRENT_SOURCE_DIR}/import/lib/common.msg)
add_executable(mstring-test-import import/main.cpp ${IMPORT_GENERATED})
target_include_directories(mstring-test-import PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/import)
target_compile_options(mstring-test-import PRIVATE ${MSTRING_TEST_WARNINGS})
add_test(NAME import
         COMMAND ${CMAKE_COMMAND}
                 -DEXE=$<TARGET_FILE:mstring-test-import>
                 -DEXPECTED=${CMAKE_CURRENT_SOURCE_DIR}/import/expected.txt
                 -P ${RUN_AND_DIFF})

# Standard input, and the command line.
file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/stdin)
add_test(NAME stdin
         COMMAND ${CMAKE_COMMAND}
                 -DEXE=$<TARGET_FILE:mstring>
                 "-DARGS=-t|-O|${CMAKE_CURRENT_BINARY_DIR}/stdin"
                 -DINPUT=${CMAKE_CURRENT_SOURCE_DIR}/stdin/stdin.msg
                 -DEXPECTED=${CMAKE_CURRENT_SOURCE_DIR}/stdin/expected.txt
                 -DMATCH=1 -DRC=0
                 -P ${RUN_AND_DIFF})
add_test(NAME stdin.output
         COMMAND ${CMAKE_COMMAND} -E cat ${CMAKE_CURRENT_BINARY_DIR}/stdin/piped.hh)
set_tests_properties(stdin.output PROPERTIES DEPENDS stdin PASS_REGULAR_EXPRESSION "std::string HelloStr\\(")
# An empty input is valid (and writes an empty module).
add_test(NAME stdin.empty
         COMMAND ${CMAKE_COMMAND}
                 -DEXE=$<TARGET_FILE:mstring>
                 "-DARGS=-O|${CMAKE_CURRENT_BINARY_DIR}/stdin|-m|empty"
                 -DINPUT=${CMAKE_CURRENT_SOURCE_DIR}/stdin/empty.msg
                 -DEXPECTED=${CMAKE_CURRENT_SOURCE_DIR}/stdin/empty.expected
                 -DRC=0
                 -P ${RUN_AND_DIFF})
add_test(NAME version
         COMMAND ${CMAKE_COMMAND}
                 -DEXE=$<TARGET_FILE:mstring> -DARG=-v
                 -DEXPECTED=${CMAKE_CURRENT_BINARY_DIR}/version.expected
                 -P ${RUN_AND_DIFF})
file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/version.expected
     "mstring ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}\n")
add_test(NAME unknown-option
         COMMAND ${CMAKE_COMMAND}
                 -DEXE=$<TARGET_FILE:mstring> -DARG=-q
                 -DEXPECTED=${CMAKE_CURRENT_SOURCE_DIR}/cli/unknown-option.expected
                 -DMATCH=1 -DRC=1
                 -P ${RUN_AND_DIFF})

# Warnings: warnings/<name>.msg must succeed (exit code 0) and print the text
# in warnings/<name>.expected.
file(GLOB WARNING_INPUTS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/warnings
     ${CMAKE_CURRENT_SOURCE_DIR}/warnings/*.msg)
file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/warnings)

foreach(input IN LISTS WARNING_INPUTS)
    get_filename_component(name ${input} NAME_WE)
    add_test(NAME warning.${name}
             COMMAND ${CMAKE_COMMAND}
                     -DEXE=$<TARGET_FILE:mstring>
                     "-DARGS=-O|${CMAKE_CURRENT_BINARY_DIR}/warnings|${input}"
                     -DEXPECTED=${CMAKE_CURRENT_SOURCE_DIR}/warnings/${name}.expected
                     -DMATCH=1 -DRC=0
                     -P ${RUN_AND_DIFF}
             WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/warnings)
endforeach()

# -w silences them: no output at all.
add_test(NAME warning.silenced
         COMMAND ${CMAKE_COMMAND}
                 -DEXE=$<TARGET_FILE:mstring>
                 "-DARGS=-w|-O|${CMAKE_CURRENT_BINARY_DIR}/warnings|missing-translation.msg"
                 -DEXPECTED=${CMAKE_CURRENT_SOURCE_DIR}/cli/empty.expected
                 -DRC=0
                 -P ${RUN_AND_DIFF}
         WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/warnings)

# Diagnostics: diagnostics/<name>.msg must fail (exit code 1) with the text
# in diagnostics/<name>.expected. The file name is given relative to the
# folder, so the expected text carries no machine-specific path.
file(GLOB DIAGNOSTIC_INPUTS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/diagnostics
     ${CMAKE_CURRENT_SOURCE_DIR}/diagnostics/*.msg)
# recursive-b.msg is only imported by recursive.msg.
list(REMOVE_ITEM DIAGNOSTIC_INPUTS recursive-b.msg)
file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/diagnostics)

foreach(input IN LISTS DIAGNOSTIC_INPUTS)
    get_filename_component(name ${input} NAME_WE)
    add_test(NAME diagnostic.${name}
             COMMAND ${CMAKE_COMMAND}
                     -DEXE=$<TARGET_FILE:mstring>
                     "-DARGS=-O|${CMAKE_CURRENT_BINARY_DIR}/diagnostics|${input}"
                     -DEXPECTED=${CMAKE_CURRENT_SOURCE_DIR}/diagnostics/${name}.expected
                     -DMATCH=1 -DRC=1
                     -P ${RUN_AND_DIFF}
             WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/diagnostics)
endforeach()