tests/nonregression/CMakeLists.txt

   1 # NON-REGRESSION TESTS ON THIS DATASET LOCATED ${OPJ_DATA_ROOT}/input/nonregression
   2
   3 FILE(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/Temporary)
   4
   5 SET(TEMP ${CMAKE_CURRENT_BINARY_DIR}/Temporary)
   6 SET(BASELINE_NR ${OPJ_DATA_ROOT}/baseline/nonregression)
   7 SET(INPUT_NR ${OPJ_DATA_ROOT}/input/nonregression)
   8
   9 SET(INPUT_NR_PATH ${INPUT_NR})
  10 SET(TEMP_PATH ${TEMP})
  11
  12 # FIXME: should be corectly manage with a find kakadu
  13 IF (NOT WIN32)
  14 CONFIGURE_FILE("opj_ref_decode_cmd.sh.in"
  15                "${CMAKE_CURRENT_BINARY_DIR}/opj_ref_decode_cmd.sh"
  16                @ONLY)
  17 ENDIF (NOT WIN32)
  18
  19 STRING(COMPARE EQUAL ${REF_DECODER_BIN_PATH} "NOTFOUND" REF_DECODER_NOTFOUND)
  20 IF (REF_DECODER_NOTFOUND)
  21   MESSAGE(STATUS "REF_DECODER_BIN_PATH not found, if you want all the encoding tests suite please provide a regular path")
  22 ENDIF (REF_DECODER_NOTFOUND)
  23
  24 #########################################################################
  25 # GENERATION OF THE TEST SUITE
  26 # Read one and more input file(s) (located in ${OPJ_DATA_ROOT}/input/nonregression)
  27 # to know which files processed and with which options.
  28
  29 # Configure the test suite file:
  30 CONFIGURE_FILE("test_suite.ctest.in"
  31                "${CMAKE_CURRENT_BINARY_DIR}/test_suite.ctest"
  32                @ONLY)
  33
  34 # Read the file into a list
  35 FILE(STRINGS ${CMAKE_CURRENT_BINARY_DIR}/test_suite.ctest OPJ_TEST_CMD_LINE_LIST)
  36
  37 # Try to find and configure and read another test suite file
  38 FILE(GLOB TEST_SUITE_FILES *.ctest.in)
  39 IF (TEST_SUITE_FILES)
  40   FOREACH(TEST_SUITE_FILE ${TEST_SUITE_FILES})
  41
  42     # Avoid to process the official test suite
  43     SET(FILE_ALREADY_READ 0)
  44     STRING(REGEX MATCH "test_suite.ctest.in$" FILE_ALREADY_READ ${TEST_SUITE_FILE})
  45
  46     IF(NOT FILE_ALREADY_READ)
  47       # Configure the additional test suite file:
  48       GET_FILENAME_COMPONENT(TEST_SUITE_FILE_SUB ${TEST_SUITE_FILE} NAME_WE)
  49       CONFIGURE_FILE("${TEST_SUITE_FILE}"
  50                      "${CMAKE_CURRENT_BINARY_DIR}/${TEST_SUITE_FILE_SUB}.ctest"
  51                      @ONLY)
  52       # Read the additional file into a list
  53       FILE(STRINGS ${CMAKE_CURRENT_BINARY_DIR}/${TEST_SUITE_FILE_SUB}.ctest OPJ_TEST_CMD_LINE_LIST_TEMP)
  54       # Append the list of command
  55       SET(OPJ_TEST_CMD_LINE_LIST ${OPJ_TEST_CMD_LINE_LIST} ${OPJ_TEST_CMD_LINE_LIST_TEMP})
  56
  57     ENDIF(NOT FILE_ALREADY_READ)
  58
  59   ENDFOREACH(TEST_SUITE_FILE)
  60
  61 ELSE(TEST_SUITE_FILES)
  62
  63   MESSAGE(FATAL_ERROR "One test suite should be available (test_suite.ctest.in) !!!")
  64
  65 ENDIF(TEST_SUITE_FILES)
  66
  67
  68 # Parse the command line found in the file(s)
  69 SET(IT_TEST_ENC 0)
  70 SET(IT_TEST_DEC 0)
  71 FOREACH(OPJ_TEST_CMD_LINE ${OPJ_TEST_CMD_LINE_LIST})
  72
  73   SET(IGNORE_LINE_FOUND 0)
  74
  75   # Replace space by ; to generate a list
  76   STRING(REPLACE " " ";" CMD_ARG_LIST ${OPJ_TEST_CMD_LINE})
  77
  78   # Check if the first argument begin by the comment sign
  79   LIST(GET CMD_ARG_LIST 0 EXE_NAME)
  80   STRING(REGEX MATCH "^#" IGNORE_LINE_FOUND ${EXE_NAME})
  81
  82   IF(IGNORE_LINE_FOUND)
  83
  84     #MESSAGE( STATUS "Current line is ignored: ${OPJ_TEST_CMD_LINE}")
  85
  86   ELSE(IGNORE_LINE_FOUND)
  87
  88     # Check if the first argument begin by the failed sign
  89     SET(FAILED_TEST_FOUND 0)
  90     STRING(REGEX MATCH "^!" FAILED_TEST_FOUND ${EXE_NAME})
  91
  92     IF (FAILED_TEST_FOUND)
  93       # Manage the different cases with the failed sign to remove the first argument which must be image_to_j2k
  94       SET(FAILED_TEST_FOUND_1 0)
  95       STRING(REGEX MATCH "^!image_to_j2k$|^!j2k_to_image$" FAILED_TEST_FOUND_1 ${EXE_NAME})
  96
  97       IF (FAILED_TEST_FOUND_1)
  98
  99         LIST(REMOVE_AT CMD_ARG_LIST 0)
 100
 101       ELSE (FAILED_TEST_FOUND_1)
 102
 103         SET(FAILED_TEST_FOUND_2 0)
 104         LIST(GET CMD_ARG_LIST 1 EXE_NAME)
 105         STRING(REGEX MATCH "^image_to_j2k$|^j2k_to_image$" FAILED_TEST_FOUND_2 ${EXE_NAME})
 106
 107         IF (FAILED_TEST_FOUND_2)
 108
 109           LIST(REMOVE_AT CMD_ARG_LIST 0)
 110           LIST(REMOVE_AT CMD_ARG_LIST 0)
 111
 112         ELSE (FAILED_TEST_FOUND_2)
 113
 114           MESSAGE( FATAL_ERROR "${EXE_NAME} is not the right executable name to encode file (try to use image_to_j2k or j2k_to_image)")
 115
 116         ENDIF (FAILED_TEST_FOUND_2)
 117       ENDIF (FAILED_TEST_FOUND_1)
 118
 119     ELSE (FAILED_TEST_FOUND)
 120       # Check if the first argument is equal to image_to_j2k
 121       STRING(REGEX MATCH "^image_to_j2k$|^j2k_to_image$" EXE_NAME_FOUND ${EXE_NAME})
 122
 123       IF(EXE_NAME_FOUND)
 124
 125         STRING(REGEX MATCH "image_to_j2k" ENC_TEST_FOUND ${EXE_NAME})
 126
 127       ELSE(EXE_NAME_FOUND)
 128
 129         MESSAGE( FATAL_ERROR "${EXE_NAME} is not the right executable name to encode file (try to use image_to_j2k)")
 130
 131       ENDIF(EXE_NAME_FOUND)
 132
 133       LIST(REMOVE_AT CMD_ARG_LIST 0)
 134
 135     ENDIF (FAILED_TEST_FOUND)
 136
 137     # Parse the argument list to find the input filename and output filename
 138     SET(CMD_ARG_LIST_2 "")
 139     SET(ARG_POS 0)
 140     SET(INPUT_ARG_POS 0)
 141     SET(OUTPUT_ARG_POS 0)
 142
 143     FOREACH(CMD_ARG_ELT ${CMD_ARG_LIST})
 144
 145       math(EXPR ARG_POS "${ARG_POS}+1" )
 146
 147       STRING(COMPARE EQUAL ${CMD_ARG_ELT} "-i" INPUT_ARG_FOUND)
 148       IF(INPUT_ARG_FOUND)
 149         SET(INPUT_ARG_POS ${ARG_POS})
 150         SET(INPUT_ARG_FOUND 0)
 151       ENDIF(INPUT_ARG_FOUND)
 152
 153       STRING(COMPARE EQUAL ${CMD_ARG_ELT} "-o" OUTPUT_ARG_FOUND)
 154       IF(OUTPUT_ARG_FOUND)
 155         SET(OUTPUT_ARG_POS ${ARG_POS})
 156         SET(OUTPUT_ARG_FOUND 0)
 157       ENDIF(OUTPUT_ARG_FOUND)
 158
 159       LIST (APPEND CMD_ARG_LIST_2 ${CMD_ARG_ELT})
 160
 161     ENDFOREACH(CMD_ARG_ELT)
 162
 163     LIST(GET CMD_ARG_LIST_2 ${INPUT_ARG_POS} INPUT_FILENAME)
 164     GET_FILENAME_COMPONENT(INPUT_FILENAME_NAME ${INPUT_FILENAME} NAME)
 165     GET_FILENAME_COMPONENT(INPUT_FILENAME_NAME_WE ${INPUT_FILENAME_NAME} NAME_WE)
 166     LIST(GET CMD_ARG_LIST_2 ${OUTPUT_ARG_POS} OUTPUT_FILENAME)
 167     GET_FILENAME_COMPONENT(OUTPUT_FILENAME_NAME_WE ${OUTPUT_FILENAME} NAME_WE)
 168
 169     #-----
 170     # Now we can add the test suite corresponding to a line command in the file
 171     #-----
 172
 173     # ENCODER TEST SUITE
 174     IF(ENC_TEST_FOUND)
 175         math(EXPR IT_TEST_ENC "${IT_TEST_ENC}+1" )
 176
 177         # Encode an image into the jpeg2000 format
 178         ADD_TEST(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-encode
 179           ${EXECUTABLE_OUTPUT_PATH}/image_to_j2k
 180           ${CMD_ARG_LIST_2}
 181         )
 182
 183         IF(FAILED_TEST_FOUND)
 184             SET_TESTS_PROPERTIES(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-encode PROPERTIES WILL_FAIL TRUE)
 185         ELSE(FAILED_TEST_FOUND)
 186
 187           # Dump the encoding file
 188           ADD_TEST(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-dump
 189             ${EXECUTABLE_OUTPUT_PATH}/j2k_dump
 190             -i ${OUTPUT_FILENAME}
 191             -o ${OUTPUT_FILENAME}-ENC-${IT_TEST_ENC}.txt
 192           )
 193           SET_TESTS_PROPERTIES(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-dump
 194                                PROPERTIES DEPENDS
 195                                NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-encode)
 196
 197           # Compare the dump file with the baseline
 198           ADD_TEST(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-compare_dump2base
 199             ${EXECUTABLE_OUTPUT_PATH}/compare_dump_files
 200             -b ${BASELINE_NR}/opj_${OUTPUT_FILENAME_NAME_WE}-ENC-${IT_TEST_ENC}.txt
 201             -t ${OUTPUT_FILENAME}-ENC-${IT_TEST_ENC}.txt
 202           )
 203
 204           SET_TESTS_PROPERTIES(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-compare_dump2base
 205                                PROPERTIES DEPENDS
 206                                NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-dump)
 207
 208           # Decode the encoding file with kakadu expand command
 209           IF (NOT REF_DECODER_NOTFOUND)
 210             IF (NOT WIN32)
 211               # Need a bash script to export the path of the kakadu library into PATH
 212               ADD_TEST( NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-decode-ref
 213                 bash ${CMAKE_CURRENT_BINARY_DIR}/opj_ref_decode_cmd.sh
 214                 -i ${OUTPUT_FILENAME}
 215                 -o ${OUTPUT_FILENAME}.raw
 216               )
 217             ELSE (NOT WIN32)
 218               ADD_TEST(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-decode-ref
 219                 ${REF_DECODER_BIN_PATH}/kdu_expand
 220                 -i ${OUTPUT_FILENAME}
 221                 -o ${OUTPUT_FILENAME}.raw
 222               )
 223             ENDIF (NOT WIN32)
 224
 225             SET_TESTS_PROPERTIES(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-decode-ref
 226                                  PROPERTIES DEPENDS
 227                                  NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-encode)
 228
 229             # Compare the decoding file with baseline generated from the kdu_expand and baseline.j2k
 230             ADD_TEST(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-compare_dec-ref-out2base
 231               ${EXECUTABLE_OUTPUT_PATH}/compareRAWimages
 232               -b ${BASELINE_NR}/opj_${OUTPUT_FILENAME_NAME_WE}-ENC-${IT_TEST_ENC}.raw
 233               -t ${OUTPUT_FILENAME}.raw
 234             )
 235
 236             SET_TESTS_PROPERTIES(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-compare_dec-ref-out2base
 237                                  PROPERTIES DEPENDS
 238                                  NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-decode-ref)
 239
 240           ENDIF(NOT REF_DECODER_NOTFOUND)
 241       ENDIF(FAILED_TEST_FOUND)
 242
 243     # DECODER TEST SUITE
 244     ELSE(ENC_TEST_FOUND)
 245       math(EXPR IT_TEST_DEC "${IT_TEST_DEC}+1" )
 246
 247       # Decode the input image
 248       ADD_TEST(NR-DEC-${INPUT_FILENAME_NAME}-${IT_TEST_DEC}-decode
 249         ${EXECUTABLE_OUTPUT_PATH}/j2k_to_image
 250         ${CMD_ARG_LIST_2}
 251       )
 252
 253       IF(FAILED_TEST_FOUND)
 254
 255         SET_TESTS_PROPERTIES(NR-DEC-${INPUT_FILENAME_NAME}-${IT_TEST_DEC}-decode PROPERTIES WILL_FAIL TRUE)
 256
 257       ELSE(FAILED_TEST_FOUND)
 258
 259 # FIXME: add a compare2base function base on raw which
 260 # can output png diff files if necesary
 261 #  ADD_TEST(NR-${filename}-compare2base
 262 #      ${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
 263 #     -b ${BASELINE_NR}/opj_${filenameRef}
 264 #     -t ${TEMP}/${filename}.pgx
 265 #     -n ${nbComponents}
 266 #     -d
 267 #     -s b_t_
 268 #     )
 269 #
 270 #  SET_TESTS_PROPERTIES(NR-${filename}-compare2base
 271 #                       PROPERTIES DEPENDS
 272 #                       NR-${filename}-decode)
 273
 274         # Dump the input image
 275         ADD_TEST(NR-DEC-${INPUT_FILENAME_NAME}-${IT_TEST_DEC}-dump
 276           ${EXECUTABLE_OUTPUT_PATH}/j2k_dump
 277           -i ${INPUT_FILENAME}
 278           -o ${TEMP}/${INPUT_FILENAME_NAME}.txt
 279         )
 280
 281         # Compare the dump output with the baseline
 282         ADD_TEST(NR-DEC-${INPUT_FILENAME_NAME}-${IT_TEST_DEC}-compare_dump2base
 283           ${EXECUTABLE_OUTPUT_PATH}/compare_dump_files
 284          -b ${BASELINE_NR}/opj_${INPUT_FILENAME_NAME_WE}.txt
 285          -t ${TEMP}/${INPUT_FILENAME_NAME}.txt
 286         )
 287
 288         SET_TESTS_PROPERTIES(NR-DEC-${INPUT_FILENAME_NAME}-${IT_TEST_DEC}-compare_dump2base
 289                              PROPERTIES DEPENDS
 290                              NR-DEC-${INPUT_FILENAME_NAME}-${IT_TEST_DEC}-dump)
 291
 292
 293       ENDIF(FAILED_TEST_FOUND)
 294
 295     ENDIF(ENC_TEST_FOUND)
 296
 297   ENDIF(IGNORE_LINE_FOUND)
 298
 299 ENDFOREACH(OPJ_TEST_CMD_LINE)
 300