PierMesh
/
direwolf
mirror of https://github.com/wb2osz/direwolf.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
direwolf/test/CMakeLists.txt

740 lines
18 KiB
CMake
Raw Normal View History

FX.25
2020-01-06 01:08:22 +00:00
# This is a trick to avoid more complication
# because configure_file() is done at configuration time
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
set(CUSTOM_TEST_BINARY_DIR "${CMAKE_BINARY_DIR}/test")
set(GEN_PACKETS_BIN "${CMAKE_BINARY_DIR}/src/gen_packets${CMAKE_EXECUTABLE_SUFFIX}")
set(ATEST_BIN "${CMAKE_BINARY_DIR}/src/atest${CMAKE_EXECUTABLE_SUFFIX}")
FX.25
2020-01-06 01:08:22 +00:00
set(FXSEND_BIN "${CMAKE_BINARY_DIR}/test/fxsend${CMAKE_EXECUTABLE_SUFFIX}")
set(FXREC_BIN "${CMAKE_BINARY_DIR}/test/fxrec${CMAKE_EXECUTABLE_SUFFIX}")
Add IL2P.
2021-10-22 21:29:20 +00:00
set(IL2P_TEST_BIN "${CMAKE_BINARY_DIR}/test/il2p_test${CMAKE_EXECUTABLE_SUFFIX}")
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
if(WIN32)
set(CUSTOM_SCRIPT_SUFFIX ".bat")
else()
set(CUSTOM_SCRIPT_SUFFIX "")
endif()
FX.25
2020-01-06 01:08:22 +00:00
set(TEST_CHECK-FX25_FILE "check-fx25")
Add IL2P.
2021-10-22 21:29:20 +00:00
set(TEST_CHECK-IL2P_FILE "check-il2p")
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
set(TEST_CHECK-MODEM1200_FILE "check-modem1200")
Add IL2P.
2021-10-22 21:29:20 +00:00
set(TEST_CHECK-MODEM1200_IL2P_FILE "check-modem1200-i")
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
set(TEST_CHECK-MODEM300_FILE "check-modem300")
set(TEST_CHECK-MODEM9600_FILE "check-modem9600")
Fix IL2P for 9600 bps.
2021-11-23 02:10:31 +00:00
set(TEST_CHECK-MODEM9600_IL2P_FILE "check-modem9600-i")
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
set(TEST_CHECK-MODEM19200_FILE "check-modem19200")
set(TEST_CHECK-MODEM2400-a_FILE "check-modem2400-a")
set(TEST_CHECK-MODEM2400-b_FILE "check-modem2400-b")
set(TEST_CHECK-MODEM2400-g_FILE "check-modem2400-g")
set(TEST_CHECK-MODEM4800_FILE "check-modem4800")
# generate the scripts that run the tests
FX.25
2020-01-06 01:08:22 +00:00
configure_file(
"${CUSTOM_TEST_SCRIPTS_DIR}/${TEST_CHECK-FX25_FILE}"
"${CUSTOM_TEST_BINARY_DIR}/${TEST_CHECK-FX25_FILE}${CUSTOM_SCRIPT_SUFFIX}"
@ONLY
)
Add IL2P.
2021-10-22 21:29:20 +00:00
configure_file(
"${CUSTOM_TEST_SCRIPTS_DIR}/${TEST_CHECK-IL2P_FILE}"
"${CUSTOM_TEST_BINARY_DIR}/${TEST_CHECK-IL2P_FILE}${CUSTOM_SCRIPT_SUFFIX}"
@ONLY
)
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
configure_file(
"${CUSTOM_TEST_SCRIPTS_DIR}/${TEST_CHECK-MODEM1200_FILE}"
"${CUSTOM_TEST_BINARY_DIR}/${TEST_CHECK-MODEM1200_FILE}${CUSTOM_SCRIPT_SUFFIX}"
@ONLY
)
Add IL2P.
2021-10-22 21:29:20 +00:00
configure_file(
"${CUSTOM_TEST_SCRIPTS_DIR}/${TEST_CHECK-MODEM1200_IL2P_FILE}"
"${CUSTOM_TEST_BINARY_DIR}/${TEST_CHECK-MODEM1200_IL2P_FILE}${CUSTOM_SCRIPT_SUFFIX}"
@ONLY
)
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
configure_file(
"${CUSTOM_TEST_SCRIPTS_DIR}/${TEST_CHECK-MODEM300_FILE}"
"${CUSTOM_TEST_BINARY_DIR}${CUSTOM_SCRIPT_SUFFIX}"
@ONLY
)
configure_file(
"${CUSTOM_TEST_SCRIPTS_DIR}/${TEST_CHECK-MODEM9600_FILE}"
"${CUSTOM_TEST_BINARY_DIR}/${TEST_CHECK-MODEM9600_FILE}${CUSTOM_SCRIPT_SUFFIX}"
@ONLY
)
Fix IL2P for 9600 bps.
2021-11-23 02:10:31 +00:00
configure_file(
"${CUSTOM_TEST_SCRIPTS_DIR}/${TEST_CHECK-MODEM9600_IL2P_FILE}"
"${CUSTOM_TEST_BINARY_DIR}/${TEST_CHECK-MODEM9600_IL2P_FILE}${CUSTOM_SCRIPT_SUFFIX}"
@ONLY
)
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
configure_file(
"${CUSTOM_TEST_SCRIPTS_DIR}/${TEST_CHECK-MODEM19200_FILE}"
"${CUSTOM_TEST_BINARY_DIR}/${TEST_CHECK-MODEM19200_FILE}${CUSTOM_SCRIPT_SUFFIX}"
@ONLY
)
configure_file(
"${CUSTOM_TEST_SCRIPTS_DIR}/${TEST_CHECK-MODEM2400-a_FILE}"
"${CUSTOM_TEST_BINARY_DIR}/${TEST_CHECK-MODEM2400-a_FILE}${CUSTOM_SCRIPT_SUFFIX}"
@ONLY
)
configure_file(
"${CUSTOM_TEST_SCRIPTS_DIR}/${TEST_CHECK-MODEM2400-b_FILE}"
"${CUSTOM_TEST_BINARY_DIR}/${TEST_CHECK-MODEM2400-b_FILE}${CUSTOM_SCRIPT_SUFFIX}"
@ONLY
)
configure_file(
"${CUSTOM_TEST_SCRIPTS_DIR}/${TEST_CHECK-MODEM2400-g_FILE}"
"${CUSTOM_TEST_BINARY_DIR}/${TEST_CHECK-MODEM2400-g_FILE}${CUSTOM_SCRIPT_SUFFIX}"
@ONLY
)
configure_file(
"${CUSTOM_TEST_SCRIPTS_DIR}/${TEST_CHECK-MODEM4800_FILE}"
"${CUSTOM_TEST_BINARY_DIR}/${TEST_CHECK-MODEM4800_FILE}${CUSTOM_SCRIPT_SUFFIX}"
@ONLY
)
# global includes
# not ideal but not so slow
# otherwise use target_include_directories
include_directories(
${CUSTOM_SRC_DIR}
${GPSD_INCLUDE_DIRS}
${HAMLIB_INCLUDE_DIRS}
${ALSA_INCLUDE_DIRS}
${UDEV_INCLUDE_DIRS}
${PORTAUDIO_INCLUDE_DIRS}
${CUSTOM_GEOTRANZ_DIR}
${CMAKE_BINARY_DIR}/src
)
cmake: windows build fixes works with cygwin and x86_64-w64-mingw32-gcc/x86_64-w64-mingw32-g++ from the package installer of cygwin. To use that add the following lines to .bash_profile export CC=x86_64-w64-mingw32-gcc export CXX=x86_64-w64-mingw32-g++ you also need cmake from cygwin
2019-09-02 09:40:16 +00:00
if(WIN32 OR CYGWIN)
include_directories(
${CUSTOM_REGEX_DIR}
)
endif()
if(WIN32 OR CYGWIN)
list(REMOVE_ITEM atest9_SOURCES
${CUSTOM_SRC_DIR}/dwgpsd.c
)
endif()
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
# Unit test for inner digipeater algorithm
list(APPEND dtest_SOURCES
${CUSTOM_SRC_DIR}/digipeater.c
AIS reception.
2020-04-19 04:50:18 +00:00
${CUSTOM_SRC_DIR}/ais.c
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
${CUSTOM_SRC_DIR}/dedupe.c
${CUSTOM_SRC_DIR}/pfilter.c
${CUSTOM_SRC_DIR}/ax25_pad.c
${CUSTOM_SRC_DIR}/fcs_calc.c
${CUSTOM_SRC_DIR}/tq.c
${CUSTOM_SRC_DIR}/textcolor.c
${CUSTOM_SRC_DIR}/decode_aprs.c
${CUSTOM_SRC_DIR}/dwgpsnmea.c
${CUSTOM_SRC_DIR}/dwgps.c
${CUSTOM_SRC_DIR}/dwgpsd.c
${CUSTOM_SRC_DIR}/serial_port.c
${CUSTOM_SRC_DIR}/latlong.c
${CUSTOM_SRC_DIR}/telemetry.c
${CUSTOM_SRC_DIR}/symbols.c
${CUSTOM_SRC_DIR}/tt_text.c
)
cmake: windows build fixes works with cygwin and x86_64-w64-mingw32-gcc/x86_64-w64-mingw32-g++ from the package installer of cygwin. To use that add the following lines to .bash_profile export CC=x86_64-w64-mingw32-gcc export CXX=x86_64-w64-mingw32-g++ you also need cmake from cygwin
2019-09-02 09:40:16 +00:00
if(WIN32 OR CYGWIN)
list(REMOVE_ITEM dtest_SOURCES
${CUSTOM_SRC_DIR}/dwgpsd.c
)
endif()
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
add_executable(dtest
${dtest_SOURCES}
)
set_target_properties(dtest
cmake: windows build fixes works with cygwin and x86_64-w64-mingw32-gcc/x86_64-w64-mingw32-g++ from the package installer of cygwin. To use that add the following lines to .bash_profile export CC=x86_64-w64-mingw32-gcc export CXX=x86_64-w64-mingw32-g++ you also need cmake from cygwin
2019-09-02 09:40:16 +00:00
PROPERTIES COMPILE_FLAGS "-DDIGITEST -DUSE_REGEX_STATIC"
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
)
target_link_libraries(dtest
${MISC_LIBRARIES}
${REGEX_LIBRARIES}
${GPSD_LIBRARIES}
Threads::Threads
)
cmake: windows build fixes works with cygwin and x86_64-w64-mingw32-gcc/x86_64-w64-mingw32-g++ from the package installer of cygwin. To use that add the following lines to .bash_profile export CC=x86_64-w64-mingw32-gcc export CXX=x86_64-w64-mingw32-g++ you also need cmake from cygwin
2019-09-02 09:40:16 +00:00
if(WIN32 OR CYGWIN)
target_link_libraries(dtest ws2_32)
endif()
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
Fix errors in comments Errors found with codespell.
2021-09-19 18:51:18 +00:00
# Unit test for APRStt tone sequence parsing.
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
list(APPEND ttest_SOURCES
${CUSTOM_SRC_DIR}/aprs_tt.c
${CUSTOM_SRC_DIR}/tt_text.c
${CUSTOM_SRC_DIR}/latlong.c
${CUSTOM_SRC_DIR}/textcolor.c
)
add_executable(ttest
${ttest_SOURCES}
)
set_target_properties(ttest
PROPERTIES COMPILE_FLAGS "-DTT_MAIN"
)
target_link_libraries(ttest
${MISC_LIBRARIES}
${GEOTRANZ_LIBRARIES}
)
# Unit test for APRStt tone sequence / text conversions.
list(APPEND tttexttest_SOURCES
${CUSTOM_SRC_DIR}/tt_text.c
${CUSTOM_SRC_DIR}/textcolor.c
)
add_executable(tttexttest
${tttexttest_SOURCES}
)
set_target_properties(tttexttest
PROPERTIES COMPILE_FLAGS "-DTTT_TEST"
)
target_link_libraries(tttexttest
${MISC_LIBRARIES}
)
# Unit test for Packet Filtering.
list(APPEND pftest_SOURCES
${CUSTOM_SRC_DIR}/pfilter.c
AIS reception.
2020-04-19 04:50:18 +00:00
${CUSTOM_SRC_DIR}/ais.c
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
${CUSTOM_SRC_DIR}/ax25_pad.c
${CUSTOM_SRC_DIR}/textcolor.c
${CUSTOM_SRC_DIR}/fcs_calc.c
${CUSTOM_SRC_DIR}/decode_aprs.c
${CUSTOM_SRC_DIR}/dwgpsnmea.c
${CUSTOM_SRC_DIR}/dwgps.c
${CUSTOM_SRC_DIR}/dwgpsd.c
${CUSTOM_SRC_DIR}/serial_port.c
${CUSTOM_SRC_DIR}/latlong.c
${CUSTOM_SRC_DIR}/symbols.c
${CUSTOM_SRC_DIR}/telemetry.c
${CUSTOM_SRC_DIR}/tt_text.c
)
cmake: windows build fixes works with cygwin and x86_64-w64-mingw32-gcc/x86_64-w64-mingw32-g++ from the package installer of cygwin. To use that add the following lines to .bash_profile export CC=x86_64-w64-mingw32-gcc export CXX=x86_64-w64-mingw32-g++ you also need cmake from cygwin
2019-09-02 09:40:16 +00:00
if(WIN32 OR CYGWIN)
list(REMOVE_ITEM pftest_SOURCES
${CUSTOM_SRC_DIR}/dwgpsd.c
)
endif()
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
add_executable(pftest
${pftest_SOURCES}
)
set_target_properties(pftest
cmake: windows build fixes works with cygwin and x86_64-w64-mingw32-gcc/x86_64-w64-mingw32-g++ from the package installer of cygwin. To use that add the following lines to .bash_profile export CC=x86_64-w64-mingw32-gcc export CXX=x86_64-w64-mingw32-g++ you also need cmake from cygwin
2019-09-02 09:40:16 +00:00
PROPERTIES COMPILE_FLAGS "-DPFTEST -DUSE_REGEX_STATIC"
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
)
target_link_libraries(pftest
${MISC_LIBRARIES}
${REGEX_LIBRARIES}
${GPSD_LIBRARIES}
Threads::Threads
)
cmake: windows build fixes works with cygwin and x86_64-w64-mingw32-gcc/x86_64-w64-mingw32-g++ from the package installer of cygwin. To use that add the following lines to .bash_profile export CC=x86_64-w64-mingw32-gcc export CXX=x86_64-w64-mingw32-g++ you also need cmake from cygwin
2019-09-02 09:40:16 +00:00
if(WIN32 OR CYGWIN)
target_link_libraries(pftest ws2_32)
endif()
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
# Unit test for telemetry decoding.
list(APPEND tlmtest_SOURCES
${CUSTOM_SRC_DIR}/telemetry.c
${CUSTOM_SRC_DIR}/ax25_pad.c
${CUSTOM_SRC_DIR}/fcs_calc.c
${CUSTOM_SRC_DIR}/textcolor.c
)
cmake: windows build fixes works with cygwin and x86_64-w64-mingw32-gcc/x86_64-w64-mingw32-g++ from the package installer of cygwin. To use that add the following lines to .bash_profile export CC=x86_64-w64-mingw32-gcc export CXX=x86_64-w64-mingw32-g++ you also need cmake from cygwin
2019-09-02 09:40:16 +00:00
if(WIN32 OR CYGWIN)
list(REMOVE_ITEM tlmtest_SOURCES
${CUSTOM_SRC_DIR}/dwgpsd.c
)
endif()
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
add_executable(tlmtest
${tlmtest_SOURCES}
)
set_target_properties(tlmtest
cmake: windows build fixes works with cygwin and x86_64-w64-mingw32-gcc/x86_64-w64-mingw32-g++ from the package installer of cygwin. To use that add the following lines to .bash_profile export CC=x86_64-w64-mingw32-gcc export CXX=x86_64-w64-mingw32-g++ you also need cmake from cygwin
2019-09-02 09:40:16 +00:00
PROPERTIES COMPILE_FLAGS "-DTEST -DUSE_REGEX_STATIC"
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
)
target_link_libraries(tlmtest
${MISC_LIBRARIES}
${REGEX_LIBRARIES}
)
cmake: windows build fixes works with cygwin and x86_64-w64-mingw32-gcc/x86_64-w64-mingw32-g++ from the package installer of cygwin. To use that add the following lines to .bash_profile export CC=x86_64-w64-mingw32-gcc export CXX=x86_64-w64-mingw32-g++ you also need cmake from cygwin
2019-09-02 09:40:16 +00:00
if(WIN32 OR CYGWIN)
target_link_libraries(tlmtest ws2_32)
endif()
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
# Unit test for location coordinate conversion.
list(APPEND lltest_SOURCES
${CUSTOM_SRC_DIR}/latlong.c
${CUSTOM_SRC_DIR}/textcolor.c
)
add_executable(lltest
${lltest_SOURCES}
)
set_target_properties(lltest
PROPERTIES COMPILE_FLAGS "-DLLTEST"
)
target_link_libraries(lltest
${MISC_LIBRARIES}
)
# Unit test for encoding position & object report.
list(APPEND enctest_SOURCES
${CUSTOM_SRC_DIR}/encode_aprs.c
${CUSTOM_SRC_DIR}/latlong.c
${CUSTOM_SRC_DIR}/textcolor.c
)
add_executable(enctest
${enctest_SOURCES}
)
set_target_properties(enctest
PROPERTIES COMPILE_FLAGS "-DEN_MAIN"
)
target_link_libraries(enctest
${MISC_LIBRARIES}
)
# Unit test for KISS encapsulation.
list(APPEND kisstest_SOURCES
${CUSTOM_SRC_DIR}/kiss_frame.c
)
add_executable(kisstest
${kisstest_SOURCES}
)
set_target_properties(kisstest
PROPERTIES COMPILE_FLAGS "-DKISSTEST"
)
# Unit test for constructing frames besides UI.
list(APPEND pad2test_SOURCES
${CUSTOM_SRC_DIR}/ax25_pad2.c
${CUSTOM_SRC_DIR}/ax25_pad.c
${CUSTOM_SRC_DIR}/fcs_calc.c
${CUSTOM_SRC_DIR}/textcolor.c
)
add_executable(pad2test
${pad2test_SOURCES}
)
set_target_properties(pad2test
cmake: windows build fixes works with cygwin and x86_64-w64-mingw32-gcc/x86_64-w64-mingw32-g++ from the package installer of cygwin. To use that add the following lines to .bash_profile export CC=x86_64-w64-mingw32-gcc export CXX=x86_64-w64-mingw32-g++ you also need cmake from cygwin
2019-09-02 09:40:16 +00:00
PROPERTIES COMPILE_FLAGS "-DPAD2TEST -DUSE_REGEX_STATIC"
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
)
target_link_libraries(pad2test
${MISC_LIBRARIES}
${REGEX_LIBRARIES}
)
cmake: windows build fixes works with cygwin and x86_64-w64-mingw32-gcc/x86_64-w64-mingw32-g++ from the package installer of cygwin. To use that add the following lines to .bash_profile export CC=x86_64-w64-mingw32-gcc export CXX=x86_64-w64-mingw32-g++ you also need cmake from cygwin
2019-09-02 09:40:16 +00:00
if(WIN32 OR CYGWIN)
target_link_libraries(pad2test ws2_32)
endif()
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
# Unit Test for XID frame encode/decode.
list(APPEND xidtest_SOURCES
${CUSTOM_SRC_DIR}/xid.c
${CUSTOM_SRC_DIR}/textcolor.c
)
add_executable(xidtest
${xidtest_SOURCES}
)
set_target_properties(xidtest
PROPERTIES COMPILE_FLAGS "-DXIDTEST"
)
target_link_libraries(xidtest
${MISC_LIBRARIES}
)
# Unit Test for DTMF encode/decode.
list(APPEND dtmftest_SOURCES
${CUSTOM_SRC_DIR}/dtmf.c
${CUSTOM_SRC_DIR}/textcolor.c
)
add_executable(dtmftest
${dtmftest_SOURCES}
)
set_target_properties(dtmftest
PROPERTIES COMPILE_FLAGS "-DDTMF_TEST"
)
FX.25
2020-01-06 01:08:22 +00:00
# Unit Test FX.25 algorithm.
list(APPEND fxsend_SOURCES
${CUSTOM_SRC_DIR}/fx25_send.c
${CUSTOM_SRC_DIR}/fx25_encode.c
${CUSTOM_SRC_DIR}/fx25_init.c
${CUSTOM_SRC_DIR}/fcs_calc.c
${CUSTOM_SRC_DIR}/textcolor.c
)
add_executable(fxsend
${fxsend_SOURCES}
)
set_target_properties(fxsend
PROPERTIES COMPILE_FLAGS "-DFXTEST"
)
list(APPEND fxrec_SOURCES
${CUSTOM_SRC_DIR}/fx25_rec.c
${CUSTOM_SRC_DIR}/fx25_extract.c
${CUSTOM_SRC_DIR}/fx25_init.c
${CUSTOM_SRC_DIR}/fcs_calc.c
${CUSTOM_SRC_DIR}/textcolor.c
)
add_executable(fxrec
${fxrec_SOURCES}
)
set_target_properties(fxrec
PROPERTIES COMPILE_FLAGS "-DFXTEST"
)
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
Add IL2P.
2021-10-22 21:29:20 +00:00
# Unit Test IL2P with out modems.
list(APPEND il2p_test_SOURCES
${CUSTOM_SRC_DIR}/il2p_test.c
${CUSTOM_SRC_DIR}/il2p_init.c
${CUSTOM_SRC_DIR}/il2p_rec.c
${CUSTOM_SRC_DIR}/il2p_send.c
${CUSTOM_SRC_DIR}/il2p_codec.c
${CUSTOM_SRC_DIR}/il2p_payload.c
${CUSTOM_SRC_DIR}/il2p_header.c
${CUSTOM_SRC_DIR}/il2p_scramble.c
${CUSTOM_SRC_DIR}/ax25_pad.c
${CUSTOM_SRC_DIR}/ax25_pad2.c
${CUSTOM_SRC_DIR}/fx25_encode.c
${CUSTOM_SRC_DIR}/fx25_extract.c
${CUSTOM_SRC_DIR}/fx25_init.c
${CUSTOM_SRC_DIR}/fcs_calc.c
${CUSTOM_SRC_DIR}/textcolor.c
)
add_executable(il2p_test
${il2p_test_SOURCES}
)
#FIXME - remove if not needed.
#set_target_properties(il2p_test
# PROPERTIES COMPILE_FLAGS "-DXXXXX"
# )
target_link_libraries(il2p_test
${MISC_LIBRARIES}
)
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
# doing ctest on previous programs
FX.25
2020-01-06 01:08:22 +00:00
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
add_test(dtest dtest)
add_test(ttest ttest)
add_test(tttexttest tttexttest)
add_test(pftest pftest)
add_test(tlmtest tlmtest)
add_test(lltest lltest)
add_test(enctest enctest)
add_test(kisstest kisstest)
add_test(pad2test pad2test)
add_test(xidtest xidtest)
add_test(dtmftest dtmftest)
FX.25
2020-01-06 01:08:22 +00:00
add_test(check-fx25 "${CUSTOM_TEST_BINARY_DIR}/${TEST_CHECK-FX25_FILE}${CUSTOM_SCRIPT_SUFFIX}")
Add IL2P.
2021-10-22 21:29:20 +00:00
add_test(check-il2p "${CUSTOM_TEST_BINARY_DIR}/${TEST_CHECK-IL2P_FILE}${CUSTOM_SCRIPT_SUFFIX}")
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
add_test(check-modem1200 "${CUSTOM_TEST_BINARY_DIR}/${TEST_CHECK-MODEM1200_FILE}${CUSTOM_SCRIPT_SUFFIX}")
Add IL2P.
2021-10-22 21:29:20 +00:00
add_test(check-modem1200-i "${CUSTOM_TEST_BINARY_DIR}/${TEST_CHECK-MODEM1200_IL2P_FILE}${CUSTOM_SCRIPT_SUFFIX}")
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
add_test(check-modem300 "${CUSTOM_TEST_BINARY_DIR}/${TEST_CHECK-MODEM300_FILE}${CUSTOM_SCRIPT_SUFFIX}")
add_test(check-modem9600 "${CUSTOM_TEST_BINARY_DIR}/${TEST_CHECK-MODEM9600_FILE}${CUSTOM_SCRIPT_SUFFIX}")
Fix IL2P for 9600 bps.
2021-11-23 02:10:31 +00:00
add_test(check-modem9600-i "${CUSTOM_TEST_BINARY_DIR}/${TEST_CHECK-MODEM9600_IL2P_FILE}${CUSTOM_SCRIPT_SUFFIX}")
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
add_test(check-modem19200 "${CUSTOM_TEST_BINARY_DIR}/${TEST_CHECK-MODEM19200_FILE}${CUSTOM_SCRIPT_SUFFIX}")
add_test(check-modem2400-a "${CUSTOM_TEST_BINARY_DIR}/${TEST_CHECK-MODEM2400-a_FILE}${CUSTOM_SCRIPT_SUFFIX}")
add_test(check-modem2400-b "${CUSTOM_TEST_BINARY_DIR}/${TEST_CHECK-MODEM2400-b_FILE}${CUSTOM_SCRIPT_SUFFIX}")
add_test(check-modem2400-g "${CUSTOM_TEST_BINARY_DIR}/${TEST_CHECK-MODEM2400-g_FILE}${CUSTOM_SCRIPT_SUFFIX}")
add_test(check-modem4800 "${CUSTOM_TEST_BINARY_DIR}/${TEST_CHECK-MODEM4800_FILE}${CUSTOM_SCRIPT_SUFFIX}")
# ----------------------------- Manual tests and experiments ---------------------------
if(OPTIONAL_TEST)
# Unit test for IGate
list(APPEND itest_SOURCES
${CUSTOM_SRC_DIR}/igate.c
AIS reception.
2020-04-19 04:50:18 +00:00
${CUSTOM_SRC_DIR}/ais.c
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
${CUSTOM_SRC_DIR}/ax25_pad.c
${CUSTOM_SRC_DIR}/fcs_calc.c
${CUSTOM_SRC_DIR}/mheard.c
${CUSTOM_SRC_DIR}/pfilter.c
${CUSTOM_SRC_DIR}/telemetry.c
${CUSTOM_SRC_DIR}/decode_aprs.c
${CUSTOM_SRC_DIR}/dwgpsnmea.c
${CUSTOM_SRC_DIR}/dwgps.c
${CUSTOM_SRC_DIR}/dwgpsd.c
${CUSTOM_SRC_DIR}/serial_port.c
${CUSTOM_SRC_DIR}/textcolor.c
${CUSTOM_SRC_DIR}/dtime_now.c
${CUSTOM_SRC_DIR}/latlong.c
${CUSTOM_SRC_DIR}/tt_text.c
${CUSTOM_SRC_DIR}/symbols.c
Fix compiling itest
2023-03-30 19:00:25 +00:00
${CUSTOM_SRC_DIR}/dlq.c
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
)
cmake: windows build fixes works with cygwin and x86_64-w64-mingw32-gcc/x86_64-w64-mingw32-g++ from the package installer of cygwin. To use that add the following lines to .bash_profile export CC=x86_64-w64-mingw32-gcc export CXX=x86_64-w64-mingw32-g++ you also need cmake from cygwin
2019-09-02 09:40:16 +00:00
if(WIN32 OR CYGWIN)
list(REMOVE_ITEM itest_SOURCES
${CUSTOM_SRC_DIR}/dwgpsd.c
)
endif()
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
add_executable(itest
${itest_SOURCES}
)
set_target_properties(itest
PROPERTIES COMPILE_FLAGS "-DITEST"
)
target_link_libraries(itest
${MISC_LIBRARIES}
${GPSD_LIBRARIES}
Threads::Threads
)
cmake: windows build fixes works with cygwin and x86_64-w64-mingw32-gcc/x86_64-w64-mingw32-g++ from the package installer of cygwin. To use that add the following lines to .bash_profile export CC=x86_64-w64-mingw32-gcc export CXX=x86_64-w64-mingw32-g++ you also need cmake from cygwin
2019-09-02 09:40:16 +00:00
if(WIN32 OR CYGWIN)
target_link_libraries(itest ws2_32)
endif()
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
# For demodulator tweaking experiments.
list(APPEND testagc_SOURCES
${CUSTOM_SRC_DIR}/atest.c
AIS reception.
2020-04-19 04:50:18 +00:00
${CUSTOM_SRC_DIR}/ais.c
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
${CUSTOM_SRC_DIR}/demod.c
${CUSTOM_SRC_DIR}/dsp.c
${CUSTOM_SRC_DIR}/demod_afsk.c
${CUSTOM_SRC_DIR}/demod_psk.c
${CUSTOM_SRC_DIR}/demod_9600.c
${CUSTOM_SRC_DIR}/hdlc_rec.c
${CUSTOM_SRC_DIR}/hdlc_rec2.c
${CUSTOM_SRC_DIR}/multi_modem.c
${CUSTOM_SRC_DIR}/rrbb.c
${CUSTOM_SRC_DIR}/fcs_calc.c
${CUSTOM_SRC_DIR}/ax25_pad.c
${CUSTOM_SRC_DIR}/decode_aprs.c
${CUSTOM_SRC_DIR}/dwgpsnmea.c
${CUSTOM_SRC_DIR}/dwgps.c
${CUSTOM_SRC_DIR}/dwgpsd.c
${CUSTOM_SRC_DIR}/serial_port.c
${CUSTOM_SRC_DIR}/telemetry.c
${CUSTOM_SRC_DIR}/dtime_now.c
${CUSTOM_SRC_DIR}/latlong.c
${CUSTOM_SRC_DIR}/tt_text.c
${CUSTOM_SRC_DIR}/symbols.c
${CUSTOM_SRC_DIR}/textcolor.c
Fix compiling testagc
2023-03-30 19:00:36 +00:00
${CUSTOM_SRC_DIR}/ax25_pad2.c
${CUSTOM_SRC_DIR}/fx25_init.c
${CUSTOM_SRC_DIR}/fx25_encode.c
${CUSTOM_SRC_DIR}/fx25_extract.c
${CUSTOM_SRC_DIR}/fx25_rec.c
${CUSTOM_SRC_DIR}/il2p_header.c
${CUSTOM_SRC_DIR}/il2p_init.c
${CUSTOM_SRC_DIR}/il2p_codec.c
${CUSTOM_SRC_DIR}/il2p_payload.c
${CUSTOM_SRC_DIR}/il2p_rec.c
${CUSTOM_SRC_DIR}/il2p_scramble.c
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
)
cmake: windows build fixes works with cygwin and x86_64-w64-mingw32-gcc/x86_64-w64-mingw32-g++ from the package installer of cygwin. To use that add the following lines to .bash_profile export CC=x86_64-w64-mingw32-gcc export CXX=x86_64-w64-mingw32-g++ you also need cmake from cygwin
2019-09-02 09:40:16 +00:00
if(WIN32 OR CYGWIN)
list(REMOVE_ITEM testagc_SOURCES
${CUSTOM_SRC_DIR}/dwgpsd.c
)
endif()
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
add_executable(testagc
${testagc_SOURCES}
)
target_link_libraries(testagc
${MISC_LIBRARIES}
${GPSD_LIBRARIES}
Threads::Threads
)
cmake: windows build fixes works with cygwin and x86_64-w64-mingw32-gcc/x86_64-w64-mingw32-g++ from the package installer of cygwin. To use that add the following lines to .bash_profile export CC=x86_64-w64-mingw32-gcc export CXX=x86_64-w64-mingw32-g++ you also need cmake from cygwin
2019-09-02 09:40:16 +00:00
if(WIN32 OR CYGWIN)
target_link_libraries(testagc ws2_32)
endif()
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
# Send GPS location to KISS TNC each second.
list(APPEND walk96_SOURCES
${CUSTOM_SRC_DIR}/walk96.c
AIS reception.
2020-04-19 04:50:18 +00:00
${CUSTOM_SRC_DIR}/ais.c
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
${CUSTOM_SRC_DIR}/dwgps.c
${CUSTOM_SRC_DIR}/dwgpsnmea.c
${CUSTOM_SRC_DIR}/dwgpsd.c
${CUSTOM_SRC_DIR}/kiss_frame.c
${CUSTOM_SRC_DIR}/latlong.c
${CUSTOM_SRC_DIR}/encode_aprs.c
${CUSTOM_SRC_DIR}/serial_port.c
${CUSTOM_SRC_DIR}/textcolor.c
${CUSTOM_SRC_DIR}/ax25_pad.c
${CUSTOM_SRC_DIR}/fcs_calc.c
${CUSTOM_SRC_DIR}/xmit.c
${CUSTOM_SRC_DIR}/xid.c
${CUSTOM_SRC_DIR}/hdlc_send.c
${CUSTOM_SRC_DIR}/gen_tone.c
${CUSTOM_SRC_DIR}/ptt.c
${CUSTOM_SRC_DIR}/tq.c
${CUSTOM_SRC_DIR}/hdlc_rec.c
${CUSTOM_SRC_DIR}/hdlc_rec2.c
${CUSTOM_SRC_DIR}/rrbb.c
${CUSTOM_SRC_DIR}/dsp.c
${CUSTOM_SRC_DIR}/multi_modem.c
${CUSTOM_SRC_DIR}/demod.c
${CUSTOM_SRC_DIR}/demod_afsk.c
${CUSTOM_SRC_DIR}/demod_psk.c
${CUSTOM_SRC_DIR}/demod_9600.c
${CUSTOM_SRC_DIR}/server.c
${CUSTOM_SRC_DIR}/morse.c
${CUSTOM_SRC_DIR}/dtmf.c
${CUSTOM_SRC_DIR}/audio_stats.c
${CUSTOM_SRC_DIR}/dtime_now.c
${CUSTOM_SRC_DIR}/dlq.c
Fix compiling walk96
2023-03-30 19:23:21 +00:00
${CUSTOM_SRC_DIR}/ax25_pad2.c
${CUSTOM_SRC_DIR}/decode_aprs.c
${CUSTOM_SRC_DIR}/fx25_encode.c
${CUSTOM_SRC_DIR}/fx25_extract.c
${CUSTOM_SRC_DIR}/fx25_init.c
${CUSTOM_SRC_DIR}/fx25_rec.c
${CUSTOM_SRC_DIR}/fx25_send.c
${CUSTOM_SRC_DIR}/gen_tone.c
${CUSTOM_SRC_DIR}/igate.c
${CUSTOM_SRC_DIR}/il2p_codec.c
${CUSTOM_SRC_DIR}/il2p_header.c
${CUSTOM_SRC_DIR}/il2p_init.c
${CUSTOM_SRC_DIR}/il2p_payload.c
${CUSTOM_SRC_DIR}/il2p_rec.c
${CUSTOM_SRC_DIR}/il2p_scramble.c
${CUSTOM_SRC_DIR}/il2p_send.c
${CUSTOM_SRC_DIR}/mheard.c
${CUSTOM_SRC_DIR}/pfilter.c
${CUSTOM_SRC_DIR}/symbols.c
${CUSTOM_SRC_DIR}/telemetry.c
${CUSTOM_SRC_DIR}/tt_text.c
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
)
if(LINUX)
list(APPEND walk96_SOURCES
${CUSTOM_SRC_DIR}/audio.c
)
if(UDEV_FOUND)
list(APPEND walk96_SOURCES
${CUSTOM_SRC_DIR}/cm108.c
)
endif()
cmake: windows build fixes works with cygwin and x86_64-w64-mingw32-gcc/x86_64-w64-mingw32-g++ from the package installer of cygwin. To use that add the following lines to .bash_profile export CC=x86_64-w64-mingw32-gcc export CXX=x86_64-w64-mingw32-g++ you also need cmake from cygwin
2019-09-02 09:40:16 +00:00
elseif(WIN32 OR CYGWIN) # windows
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
list(APPEND walk96_SOURCES
${CUSTOM_SRC_DIR}/audio_win.c
)
cmake: windows build fixes works with cygwin and x86_64-w64-mingw32-gcc/x86_64-w64-mingw32-g++ from the package installer of cygwin. To use that add the following lines to .bash_profile export CC=x86_64-w64-mingw32-gcc export CXX=x86_64-w64-mingw32-g++ you also need cmake from cygwin
2019-09-02 09:40:16 +00:00
list(REMOVE_ITEM walk96_SOURCES
${CUSTOM_SRC_DIR}/dwgpsd.c
)
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
else() # macOS freebsd openbsd
list(APPEND walk96_SOURCES
${CUSTOM_SRC_DIR}/audio_portaudio.c
)
endif()
add_executable(walk96
${walk96_SOURCES}
)
set_target_properties(walk96
cmake: windows build fixes works with cygwin and x86_64-w64-mingw32-gcc/x86_64-w64-mingw32-g++ from the package installer of cygwin. To use that add the following lines to .bash_profile export CC=x86_64-w64-mingw32-gcc export CXX=x86_64-w64-mingw32-g++ you also need cmake from cygwin
2019-09-02 09:40:16 +00:00
PROPERTIES COMPILE_FLAGS "-DWALK96 -DUSE_REGEX_STATIC"
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
)
target_link_libraries(walk96
${MISC_LIBRARIES}
${REGEX_LIBRARIES}
${GPSD_LIBRARIES}
${HAMLIB_LIBRARIES}
${ALSA_LIBRARIES}
${PORTAUDIO_LIBRARIES}
${UDEV_LIBRARIES}
Threads::Threads
)
cmake: windows build fixes works with cygwin and x86_64-w64-mingw32-gcc/x86_64-w64-mingw32-g++ from the package installer of cygwin. To use that add the following lines to .bash_profile export CC=x86_64-w64-mingw32-gcc export CXX=x86_64-w64-mingw32-g++ you also need cmake from cygwin
2019-09-02 09:40:16 +00:00
if(WIN32 OR CYGWIN)
target_link_libraries(walk96 ws2_32)
endif()
cmake: implements tests using CTest suite the new tests are implemented with CTest suite of CMake. To enable the tests you need to run cmake with -DBUILD_TESTING=ON There are optional tests (that might not work) that can be enabled with -DOPTIONAL_TEST=ON So, to enable all tests and run it use the following command mkdir build cmake -DBUILD_TESTING=ON -DOPTIONA_TEST=ON .. make ctest to debug the errors use ctest --debug You can always find all tests binary on build/test/ Implementation: - check-modem* tests are implemented with shell script because it requires to execute many commands and therefore will be easy to manage. The file is configured at configuration time. - for single binary we verify the exit status (default = 0) so you only need to build the binary and add it to add_test()
2019-08-30 10:22:26 +00:00
# TODO miss the audio file
# testagc
# ./atest -P H+ -F 0 ../01_Track_1.wav ../02_Track_2.wav | grep "packets decoded in" >atest.out
# testagc3
# ./gen_packets -B 300 -n 100 -o noisy3.wav
# ./atest3 -B 300 -P D -D 3 noisy3.wav | grep "packets decoded in" >atest.out
# testagc96
# ./gen_packets -B 9600 -n 100 -o noisy96.wav
# ./atest96 -B 9600 ../walkabout9600c.wav noisy96.wav zzz16.wav zzz16.wav zzz16.wav zzz8.wav zzz8.wav zzz8.wav | grep "packets decoded in" >atest.out
# testagc24
# ./atest24 -B 2400 test2400.wav | grep "packets decoded in" >atest.out
# testagc24mfj
# ./atest24mfj -F 1 -B 2400 ../ref-doc/MFJ-2400-PSK/2k4_short.wav
# testagc48
# ./atest48 -B 4800 test4800.wav | grep "packets decoded in" >atest.out
endif() # OPTIONAL_TEST