system: Linux mars.sprixweb.com 3.10.0-1160.119.1.el7.x86_64 #1 SMP Tue Jun 4 14:43:51 UTC 2024 x86_64
# Copyright 2022 Joe Drago. All rights reserved.
# SPDX-License-Identifier: BSD-2-Clause
# With testing enabled, all targets referenced by add_test() can be run
# at once with CMake's ctest command line tool from the build folder.
enable_testing()
################################################################################
# C tests and tools
add_executable(aviftest aviftest.c)
if(AVIF_LOCAL_LIBGAV1)
set_target_properties(aviftest PROPERTIES LINKER_LANGUAGE "CXX")
endif()
target_link_libraries(aviftest avif ${AVIF_PLATFORM_LIBRARIES})
add_test(NAME aviftest COMMAND aviftest ${CMAKE_CURRENT_SOURCE_DIR}/data)
if(AVIF_ENABLE_COVERAGE)
add_custom_target(
avif_coverage
COMMAND ${CMAKE_COMMAND} -E env "LLVM_PROFILE_FILE=${CMAKE_CURRENT_BINARY_DIR}/aviftest.profraw" $<TARGET_FILE:aviftest>
${CMAKE_CURRENT_SOURCE_DIR}/data
COMMAND ${XCRUN} llvm-profdata merge -sparse ${CMAKE_CURRENT_BINARY_DIR}/aviftest.profraw -o
${CMAKE_CURRENT_BINARY_DIR}/aviftest.profdata
COMMAND cmake -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/coverage
COMMAND ${XCRUN} llvm-cov show $<TARGET_FILE:aviftest> -instr-profile=${CMAKE_CURRENT_BINARY_DIR}/aviftest.profdata
-project-title=libavif --format html -output-dir=${CMAKE_CURRENT_BINARY_DIR}/coverage
COMMAND echo Coverage report here: ${CMAKE_CURRENT_BINARY_DIR}/coverage/index.html
DEPENDS aviftest
)
endif()
add_executable(avifyuv avifyuv.c)
if(AVIF_LOCAL_LIBGAV1)
set_target_properties(avifyuv PROPERTIES LINKER_LANGUAGE "CXX")
endif()
target_link_libraries(avifyuv avif ${AVIF_PLATFORM_LIBRARIES})
foreach(AVIFYUV_MODE limited rgb) # Modes drift and premultiply take more than 2 minutes each so they are disabled.
add_test(NAME avifyuv_${AVIFYUV_MODE} COMMAND avifyuv -m ${AVIFYUV_MODE})
endforeach()
if(AVIF_ENABLE_GTEST OR AVIF_BUILD_APPS)
enable_language(CXX)
set(CMAKE_CXX_STANDARD 14)
add_library(aviftest_helpers OBJECT gtest/aviftest_helpers.cc)
target_link_libraries(aviftest_helpers avif_apps)
target_link_libraries(aviftest_helpers avif_internal)
endif()
# Fuzz target without any fuzzing engine dependency. For easy reproduction of oss-fuzz issues.
add_executable(repro_avif_decode_fuzzer oss-fuzz/avif_decode_fuzzer.cc oss-fuzz/repro_fuzz.cc)
if(AVIF_LOCAL_LIBGAV1)
set_target_properties(repro_avif_decode_fuzzer PROPERTIES LINKER_LANGUAGE "CXX")
endif()
target_link_libraries(repro_avif_decode_fuzzer avif ${AVIF_PLATFORM_LIBRARIES})
# The test below exists for coverage and as a usage example: repro_avif_decode_fuzzer [reproducer file path]
add_test(NAME repro_avif_decode_fuzzer COMMAND repro_avif_decode_fuzzer
${CMAKE_CURRENT_SOURCE_DIR}/data/color_grid_alpha_nogrid.avif
)
################################################################################
# GoogleTest
if(AVIF_ENABLE_GTEST)
if(AVIF_LOCAL_GTEST)
set(GTEST_INCLUDE_DIRS ${CMAKE_SOURCE_DIR}/ext/googletest/googletest/include)
set(GTEST_LIBRARIES ${CMAKE_SOURCE_DIR}/ext/googletest/build/lib/${AVIF_LIBRARY_PREFIX}gtest${AVIF_LIBRARY_SUFFIX})
set(GTEST_MAIN_LIBRARIES
${CMAKE_SOURCE_DIR}/ext/googletest/build/lib/${AVIF_LIBRARY_PREFIX}gtest_main${AVIF_LIBRARY_SUFFIX}
)
set(GTEST_BOTH_LIBRARIES ${GTEST_LIBRARIES} ${GTEST_MAIN_LIBRARIES})
if(NOT EXISTS ${GTEST_INCLUDE_DIRS}/gtest/gtest.h)
message(FATAL_ERROR "googletest(AVIF_LOCAL_GTEST): ${GTEST_INCLUDE_DIRS}/gtest/gtest.h is missing, bailing out")
elseif(NOT EXISTS ${GTEST_LIBRARIES})
message(FATAL_ERROR "googletest(AVIF_LOCAL_GTEST): ${GTEST_LIBRARIES} is missing, bailing out")
elseif(NOT EXISTS ${GTEST_MAIN_LIBRARIES})
message(FATAL_ERROR "googletest(AVIF_LOCAL_GTEST): ${GTEST_MAIN_LIBRARIES} is missing, bailing out")
else()
message(STATUS "Found local ext/googletest")
endif()
else()
find_package(GTest REQUIRED)
endif()
add_executable(avifallocationtest gtest/avifallocationtest.cc)
target_link_libraries(avifallocationtest aviftest_helpers ${GTEST_BOTH_LIBRARIES})
target_include_directories(avifallocationtest PRIVATE ${GTEST_INCLUDE_DIRS})
add_test(NAME avifallocationtest COMMAND avifallocationtest)
add_executable(avifalphapremtest gtest/avifalphapremtest.cc)
target_link_libraries(avifalphapremtest aviftest_helpers ${GTEST_BOTH_LIBRARIES})
target_include_directories(avifalphapremtest PRIVATE ${GTEST_INCLUDE_DIRS})
add_test(NAME avifalphapremtest COMMAND avifalphapremtest)
add_executable(avifbasictest gtest/avifbasictest.cc)
target_link_libraries(avifbasictest aviftest_helpers ${GTEST_BOTH_LIBRARIES})
target_include_directories(avifbasictest PRIVATE ${GTEST_INCLUDE_DIRS})
add_test(NAME avifbasictest COMMAND avifbasictest)
add_executable(avifchangesettingtest gtest/avifchangesettingtest.cc)
target_link_libraries(avifchangesettingtest aviftest_helpers ${GTEST_BOTH_LIBRARIES})
target_include_directories(avifchangesettingtest PRIVATE ${GTEST_INCLUDE_DIRS})
add_test(NAME avifchangesettingtest COMMAND avifchangesettingtest)
add_executable(avifclaptest gtest/avifclaptest.cc)
target_link_libraries(avifclaptest avif ${GTEST_BOTH_LIBRARIES})
target_include_directories(avifclaptest PRIVATE ${GTEST_INCLUDE_DIRS})
add_test(NAME avifclaptest COMMAND avifclaptest)
add_executable(avifcllitest gtest/avifcllitest.cc)
target_link_libraries(avifcllitest aviftest_helpers ${GTEST_BOTH_LIBRARIES})
target_include_directories(avifcllitest PRIVATE ${GTEST_INCLUDE_DIRS})
add_test(NAME avifcllitest COMMAND avifcllitest)
add_executable(avifcodectest gtest/avifcodectest.cc)
target_link_libraries(avifcodectest aviftest_helpers ${GTEST_BOTH_LIBRARIES})
target_include_directories(avifcodectest PRIVATE ${GTEST_INCLUDE_DIRS})
add_test(NAME avifcodectest COMMAND avifcodectest)
if(AVIF_ENABLE_EXPERIMENTAL_AVIR)
add_executable(avifconitest gtest/avifconitest.cc)
target_link_libraries(avifconitest aviftest_helpers ${GTEST_BOTH_LIBRARIES})
target_include_directories(avifconitest PRIVATE ${GTEST_INCLUDE_DIRS})
add_test(NAME avifconitest COMMAND avifconitest)
endif()
add_executable(avifdecodetest gtest/avifdecodetest.cc)
target_link_libraries(avifdecodetest aviftest_helpers ${GTEST_LIBRARIES})
target_include_directories(avifdecodetest PRIVATE ${GTEST_INCLUDE_DIRS})
add_test(NAME avifdecodetest COMMAND avifdecodetest ${CMAKE_CURRENT_SOURCE_DIR}/data/)
if(AVIF_ENABLE_EXPERIMENTAL_GAIN_MAP)
add_executable(avifgainmaptest gtest/avifgainmaptest.cc)
target_link_libraries(avifgainmaptest aviftest_helpers ${GTEST_BOTH_LIBRARIES})
target_include_directories(avifgainmaptest PRIVATE ${GTEST_INCLUDE_DIRS})
add_test(NAME avifgainmaptest COMMAND avifgainmaptest)
endif()
add_executable(avifgridapitest gtest/avifgridapitest.cc)
target_link_libraries(avifgridapitest avif_internal aviftest_helpers ${GTEST_BOTH_LIBRARIES})
target_include_directories(avifgridapitest PRIVATE ${GTEST_INCLUDE_DIRS})
add_test(NAME avifgridapitest COMMAND avifgridapitest)
add_executable(avifimagetest gtest/avifimagetest.cc)
target_link_libraries(avifimagetest aviftest_helpers ${GTEST_BOTH_LIBRARIES})
target_include_directories(avifimagetest PRIVATE ${GTEST_INCLUDE_DIRS})
add_test(NAME avifimagetest COMMAND avifimagetest)
add_library(avifincrtest_helpers OBJECT gtest/avifincrtest_helpers.cc)
target_link_libraries(avifincrtest_helpers avif ${AVIF_PLATFORM_LIBRARIES} ${GTEST_LIBRARIES})
target_include_directories(avifincrtest_helpers PUBLIC ${GTEST_INCLUDE_DIRS})
add_executable(avifincrtest gtest/avifincrtest.cc)
target_link_libraries(avifincrtest aviftest_helpers avifincrtest_helpers)
add_test(NAME avifincrtest COMMAND avifincrtest ${CMAKE_CURRENT_SOURCE_DIR}/data/)
add_executable(avifiostatstest gtest/avifiostatstest.cc)
target_link_libraries(avifiostatstest avif_internal aviftest_helpers ${GTEST_LIBRARIES})
target_include_directories(avifiostatstest PRIVATE ${GTEST_INCLUDE_DIRS})
add_test(NAME avifiostatstest COMMAND avifiostatstest ${CMAKE_CURRENT_SOURCE_DIR}/data/)
add_executable(aviflosslesstest gtest/aviflosslesstest.cc)
target_link_libraries(aviflosslesstest aviftest_helpers ${GTEST_BOTH_LIBRARIES})
target_include_directories(aviflosslesstest PRIVATE ${GTEST_INCLUDE_DIRS})
add_test(NAME aviflosslesstest COMMAND aviflosslesstest ${CMAKE_CURRENT_SOURCE_DIR}/data/)
add_executable(avifmetadatatest gtest/avifmetadatatest.cc)
target_link_libraries(avifmetadatatest aviftest_helpers ${GTEST_LIBRARIES})
target_include_directories(avifmetadatatest PRIVATE ${GTEST_INCLUDE_DIRS})
add_test(NAME avifmetadatatest COMMAND avifmetadatatest ${CMAKE_CURRENT_SOURCE_DIR}/data/)
add_executable(avifopaquetest gtest/avifopaquetest.cc)
target_link_libraries(avifopaquetest aviftest_helpers ${GTEST_BOTH_LIBRARIES})
target_include_directories(avifopaquetest PRIVATE ${GTEST_INCLUDE_DIRS})
add_test(NAME avifopaquetest COMMAND avifopaquetest)
add_executable(avifpng16bittest gtest/avifpng16bittest.cc)
target_link_libraries(avifpng16bittest aviftest_helpers ${GTEST_LIBRARIES})
target_include_directories(avifpng16bittest PRIVATE ${GTEST_INCLUDE_DIRS})
add_test(NAME avifpng16bittest COMMAND avifpng16bittest ${CMAKE_CURRENT_SOURCE_DIR}/data/)
add_executable(avifprogressivetest gtest/avifprogressivetest.cc)
target_link_libraries(avifprogressivetest aviftest_helpers ${GTEST_BOTH_LIBRARIES})
target_include_directories(avifprogressivetest PRIVATE ${GTEST_INCLUDE_DIRS})
add_test(NAME avifprogressivetest COMMAND avifprogressivetest)
add_executable(avifreadimagetest gtest/avifreadimagetest.cc)
target_link_libraries(avifreadimagetest aviftest_helpers ${GTEST_LIBRARIES})
target_include_directories(avifreadimagetest PRIVATE ${GTEST_INCLUDE_DIRS})
add_test(NAME avifreadimagetest COMMAND avifreadimagetest ${CMAKE_CURRENT_SOURCE_DIR}/data/)
add_executable(avifrgbtoyuvtest gtest/avifrgbtoyuvtest.cc)
target_link_libraries(avifrgbtoyuvtest aviftest_helpers ${GTEST_BOTH_LIBRARIES})
target_include_directories(avifrgbtoyuvtest PRIVATE ${GTEST_INCLUDE_DIRS})
add_test(NAME avifrgbtoyuvtest COMMAND avifrgbtoyuvtest)
add_executable(avifscaletest gtest/avifscaletest.cc)
target_link_libraries(avifscaletest avif_internal aviftest_helpers ${GTEST_LIBRARIES})
target_include_directories(avifscaletest PRIVATE ${GTEST_INCLUDE_DIRS})
add_test(NAME avifscaletest COMMAND avifscaletest ${CMAKE_CURRENT_SOURCE_DIR}/data/)
add_executable(avifstreamtest gtest/avifstreamtest.cc)
target_link_libraries(avifstreamtest avif_internal aviftest_helpers ${GTEST_BOTH_LIBRARIES})
target_include_directories(avifstreamtest PRIVATE ${GTEST_INCLUDE_DIRS})
add_test(NAME avifstreamtest COMMAND avifstreamtest ${CMAKE_CURRENT_SOURCE_DIR}/data/)
add_executable(aviftilingtest gtest/aviftilingtest.cc)
target_link_libraries(aviftilingtest avif_internal ${GTEST_BOTH_LIBRARIES})
target_include_directories(aviftilingtest PRIVATE ${GTEST_INCLUDE_DIRS})
add_test(NAME aviftilingtest COMMAND aviftilingtest)
add_executable(avify4mtest gtest/avify4mtest.cc)
target_link_libraries(avify4mtest aviftest_helpers ${GTEST_BOTH_LIBRARIES})
target_include_directories(avify4mtest PRIVATE ${GTEST_INCLUDE_DIRS})
add_test(NAME avify4mtest COMMAND avify4mtest)
if(NOT AVIF_CODEC_AOM OR NOT AVIF_CODEC_AOM_ENCODE OR NOT AVIF_CODEC_AOM_DECODE)
# These tests are supported with aom being the encoder and decoder. If aom is unavailable,
# these tests are disabled because other codecs may not implement all the necessary features.
# For example, SVT-AV1 requires 4:2:0 images with even dimensions of at least 64x64 px.
set_tests_properties(
avifallocationtest avifgridapitest avifincrtest aviflosslesstest avifmetadatatest PROPERTIES DISABLED True
)
message(STATUS "Some tests are disabled because aom is unavailable for encoding or decoding.")
endif()
if(NOT libsharpyuv_FOUND)
message(STATUS "Some tests are skipped because libsharpyuv is unavailable.")
endif()
else()
message(STATUS "Most tests are disabled because AVIF_ENABLE_GTEST is OFF.")
endif()
################################################################################
# Bash tests
if(AVIF_BUILD_APPS)
# When building apps, test the avifenc/avifdec.
# 'are_images_equal' is used to make sure inputs/outputs are unchanged.
add_executable(are_images_equal gtest/are_images_equal.cc)
target_link_libraries(are_images_equal aviftest_helpers)
add_test(NAME test_cmd COMMAND bash ${CMAKE_CURRENT_SOURCE_DIR}/test_cmd.sh ${CMAKE_BINARY_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/data
)
add_test(NAME test_cmd_animation COMMAND bash ${CMAKE_CURRENT_SOURCE_DIR}/test_cmd_animation.sh ${CMAKE_BINARY_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/data
)
add_test(NAME test_cmd_grid COMMAND bash ${CMAKE_CURRENT_SOURCE_DIR}/test_cmd_grid.sh ${CMAKE_BINARY_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/data
)
add_test(NAME test_cmd_icc_profile COMMAND bash ${CMAKE_CURRENT_SOURCE_DIR}/test_cmd_icc_profile.sh ${CMAKE_BINARY_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/data
)
add_test(NAME test_cmd_lossless COMMAND bash ${CMAKE_CURRENT_SOURCE_DIR}/test_cmd_lossless.sh ${CMAKE_BINARY_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/data
)
add_test(NAME test_cmd_metadata COMMAND bash ${CMAKE_CURRENT_SOURCE_DIR}/test_cmd_metadata.sh ${CMAKE_BINARY_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/data
)
add_test(NAME test_cmd_progressive COMMAND bash ${CMAKE_CURRENT_SOURCE_DIR}/test_cmd_progressive.sh ${CMAKE_BINARY_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/data
)
add_test(NAME test_cmd_targetsize COMMAND bash ${CMAKE_CURRENT_SOURCE_DIR}/test_cmd_targetsize.sh ${CMAKE_BINARY_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/data
)
if(NOT AVIF_CODEC_AOM OR NOT AVIF_CODEC_AOM_ENCODE)
# Only aom encoder supports AV1 lossless encoding.
set_property(TEST test_cmd_animation PROPERTY DISABLED True)
set_property(TEST test_cmd_icc_profile PROPERTY DISABLED True)
set_property(TEST test_cmd_lossless PROPERTY DISABLED True)
# SVT-AV1 does not support the images with odd dimensions that are used in this test.
if(NOT AVIF_CODEC_RAV1E)
set_property(TEST test_cmd_metadata PROPERTY DISABLED True)
endif()
# Only aom encoder supports encoding AV1 spatial layers (used to implement
# AVIF layered images that can be progressively decoded).
set_property(TEST test_cmd_progressive PROPERTY DISABLED True)
message(STATUS "Some tests are disabled because aom is unavailable for encoding.")
endif()
endif()
################################################################################
# AV2 tests
if(AVIF_CODEC_AVM)
if(AVIF_ENABLE_GTEST)
add_executable(avifavmtest gtest/avifavmtest.cc)
target_link_libraries(avifavmtest aviftest_helpers ${GTEST_BOTH_LIBRARIES})
target_include_directories(avifavmtest PRIVATE ${GTEST_INCLUDE_DIRS})
add_test(NAME avifavmtest COMMAND avifavmtest)
endif()
if(AVIF_BUILD_APPS)
add_test(NAME test_cmd_avm COMMAND bash ${CMAKE_CURRENT_SOURCE_DIR}/test_cmd_avm.sh ${CMAKE_BINARY_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/data
)
add_test(NAME test_cmd_avm_lossless COMMAND bash ${CMAKE_CURRENT_SOURCE_DIR}/test_cmd_avm_lossless.sh ${CMAKE_BINARY_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/data
)
endif()
# AV2 support is experimental and only available when avm is explicitly specified as the encoder.
# This may lead to test failures when there is no available AV1 codec.
if(((NOT AVIF_CODEC_AOM OR NOT AVIF_CODEC_AOM_ENCODE) AND NOT AVIF_CODEC_RAV1E AND NOT AVIF_CODEC_SVT)
OR ((NOT AVIF_CODEC_AOM OR NOT AVIF_CODEC_AOM_DECODE) AND NOT AVIF_CODEC_DAV1D AND NOT AVIF_CODEC_LIBGAV1)
)
# Disable all tests that use avifEncoder without explicitly setting the codec to avm.
set_tests_properties(aviftest PROPERTIES DISABLED True)
if(AVIF_ENABLE_GTEST)
set_tests_properties(
avifallocationtest avifbasictest avifchangesettingtest avifcllitest avifgridapitest avifincrtest avifiostatstest
avifmetadatatest avifprogressivetest avify4mtest PROPERTIES DISABLED True
)
if(AVIF_ENABLE_EXPERIMENTAL_AVIR)
set_tests_properties(avifconitest PROPERTIES DISABLED True)
endif()
if(AVIF_ENABLE_EXPERIMENTAL_GAIN_MAP)
set_tests_properties(avifgainmaptest PROPERTIES DISABLED True)
endif()
endif()
if(AVIF_BUILD_APPS)
# Disable all tests that use avifenc without explicitly setting --codec=avm.
set_tests_properties(test_cmd test_cmd_animation test_cmd_grid test_cmd_targetsize PROPERTIES DISABLED True)
endif()
endif()
endif()