tests/conformance/CMakeLists.txt

   1 # CONFORMANCE TESTS AND NON-REGRESSION ON THIS DATASET
   2
   3 file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/Temporary)
   4
   5 set(TEMP ${CMAKE_CURRENT_BINARY_DIR}/Temporary)
   6 set(BASELINE_CONF ${OPJ_DATA_ROOT}/baseline/conformance)
   7 set(BASELINE_NR ${OPJ_DATA_ROOT}/baseline/nonregression)
   8 set(INPUT_CONF ${OPJ_DATA_ROOT}/input/conformance)
   9
  10
  11 # List of components by file (normaly p0_13.j2k have 257 components but for this
  12 #set of test we consider only 4)
  13 set( CP0_nbC_list "not_used;1;1;1;3;4;4;3;3;1;3;1;1;4;3;1;1")
  14 set( CP1_nbC_list "not_used;1;3;4;1;3;3;2")
  15
  16 set(COMMENTCODEVAR FALSE)
  17
  18
  19 #--------------------------------------------------------------------------
  20 # Tests about class 0 profile 0
  21 # try to decode
  22 # compare to ref file provided by the Executable Test Suite
  23 # non regression comparison
  24
  25 # Parameters and tolerances given by Table C.1
  26 set( C0P0_ResFactor_list "not_used;0;0;0;3;3;3;0;5;2;0;0;0;0;2;0;0")
  27 set( C0P0_PEAK_list "not_used;0;0;0;33;54;109;10;7;4;10;0;0;0;0;0;0")
  28 set( C0P0_MSE_list "not_used;0;0;0;55.8;68;743;0.34;6.72;1.47;2.84;0;0;0;0;0;0")
  29
  30 foreach(numFileC0P0 RANGE 1 16)
  31
  32   # Build filenames
  33   if(${numFileC0P0} LESS 10)
  34     set( filenameInput p0_0${numFileC0P0}.j2k )
  35     set( filenameRef   c0p0_0${numFileC0P0}.pgx )
  36   else()
  37     set( filenameInput p0_${numFileC0P0}.j2k )
  38     set( filenameRef   c0p0_${numFileC0P0}.pgx )
  39   endif()
  40
  41   # Get corresponding tests parameters
  42   list(GET C0P0_ResFactor_list ${numFileC0P0}  ResFactor)
  43   #For Class-0 testing, we always focus on the first component only
  44   #list(GET CP0_nbC_list ${numFileC0P0}  nbComponents)
  45   set( nbComponents "1")
  46   list(GET C0P0_PEAK_list ${numFileC0P0}  PEAK_limit)
  47   list(GET C0P0_MSE_list ${numFileC0P0}  MSE_limit)
  48
  49   # Manage cases which need to try different resolution reduction
  50   if (numFileC0P0 EQUAL 3 OR numFileC0P0 EQUAL 15)
  51     get_filename_component(filenameRefSub ${filenameRef} NAME_WE)
  52     #r = 0
  53
  54     add_test(ETS-C0P0-${filenameInput}-r0-decode
  55         ${EXECUTABLE_OUTPUT_PATH}/opj_decompress
  56         -i ${INPUT_CONF}/${filenameInput}
  57         -o ${TEMP}/c0${filenameInput}-r0.pgx
  58         -r 0
  59         )
  60
  61     add_test(ETS-C0P0-${filenameInput}-r0-compare2ref
  62         ${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
  63         -b ${BASELINE_CONF}/${filenameRefSub}r0.pgx
  64         -t ${TEMP}/c0${filenameInput}-r0.pgx
  65         -n ${nbComponents}
  66         -p ${PEAK_limit}
  67         -m ${MSE_limit}
  68         -s t_
  69         )
  70
  71     set_tests_properties(ETS-C0P0-${filenameInput}-r0-compare2ref
  72                          PROPERTIES DEPENDS
  73                          ETS-C0P0-${filenameInput}-r0-decode)
  74
  75     add_test(NR-C0P0-${filenameInput}-r0-compare2base
  76         ${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
  77         -b ${BASELINE_NR}/opj_${filenameRefSub}-r0.pgx
  78         -t ${TEMP}/c0${filenameInput}-r0.pgx
  79         -n ${nbComponents}
  80         -d
  81         -s b_t_
  82         )
  83
  84     set_tests_properties(NR-C0P0-${filenameInput}-r0-compare2base
  85                          PROPERTIES DEPENDS
  86                          ETS-C0P0-${filenameInput}-r0-decode)
  87
  88     #r = 1
  89     add_test(ETS-C0P0-${filenameInput}-r1-decode
  90         ${EXECUTABLE_OUTPUT_PATH}/opj_decompress
  91         -i ${INPUT_CONF}/${filenameInput}
  92         -o ${TEMP}/c0${filenameInput}-r1.pgx
  93         -r 1
  94         )
  95
  96     add_test(ETS-C0P0-${filenameInput}-r1-compare2ref
  97         ${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
  98         -b ${BASELINE_CONF}/${filenameRefSub}r1.pgx
  99         -t ${TEMP}/c0${filenameInput}-r1.pgx
 100         -n ${nbComponents}
 101         -p ${PEAK_limit}
 102         -m ${MSE_limit}
 103         -s t_
 104         )
 105
 106     set_tests_properties(ETS-C0P0-${filenameInput}-r1-compare2ref
 107                          PROPERTIES DEPENDS
 108                          ETS-C0P0-${filenameInput}-r1-decode)
 109
 110     add_test(NR-C0P0-${filenameInput}-r1-compare2base
 111         ${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
 112         -b ${BASELINE_NR}/opj_${filenameRefSub}-r1.pgx
 113         -t ${TEMP}/c0${filenameInput}-r1.pgx
 114         -n ${nbComponents}
 115         -d
 116         -s b_t_
 117         )
 118
 119     set_tests_properties(NR-C0P0-${filenameInput}-r1-compare2base
 120                          PROPERTIES DEPENDS
 121                          ETS-C0P0-${filenameInput}-r1-decode)
 122
 123   else()
 124
 125     add_test(ETS-C0P0-${filenameInput}-decode
 126         ${EXECUTABLE_OUTPUT_PATH}/opj_decompress
 127         -i ${INPUT_CONF}/${filenameInput}
 128         -o ${TEMP}/c0${filenameInput}.pgx
 129         -r ${ResFactor}
 130         )
 131
 132     add_test(ETS-C0P0-${filenameInput}-compare2ref
 133         ${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
 134         -b ${BASELINE_CONF}/${filenameRef}
 135         -t ${TEMP}/c0${filenameInput}.pgx
 136         -n ${nbComponents}
 137         -p ${PEAK_limit}
 138         -m ${MSE_limit}
 139         -s t_
 140         )
 141
 142     set_tests_properties(ETS-C0P0-${filenameInput}-compare2ref
 143                          PROPERTIES DEPENDS
 144                          ETS-C0P0-${filenameInput}-decode)
 145
 146     add_test(NR-C0P0-${filenameInput}-compare2base
 147         ${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
 148         -b ${BASELINE_NR}/opj_${filenameRef}
 149         -t ${TEMP}/c0${filenameInput}.pgx
 150         -n ${nbComponents}
 151         -d
 152         -s b_t_
 153         )
 154
 155     set_tests_properties(NR-C0P0-${filenameInput}-compare2base
 156                          PROPERTIES DEPENDS
 157                          ETS-C0P0-${filenameInput}-decode)
 158
 159   endif()
 160
 161 endforeach()
 162
 163 #--------------------------------------------------------------------------
 164 # Tests about class 0 profile 1
 165 # try to decode
 166 # compare to ref file
 167 # non regression comparison
 168
 169 # Parameters and tolerances given by Table C.4
 170 set( C0P1_ResFactor_list "not_used;0;3;3;0;4;1;0")
 171 set( C0P1_PEAK_list "not_used;0;35;28;2;128;128;0")
 172 set( C0P1_MSE_list "not_used;0;74;18.8;0.550;16384;16384;0")
 173
 174 foreach(numFileC0P1 RANGE 1 7)
 175
 176   # Build filenames
 177   set( filenameInput p1_0${numFileC0P1}.j2k )
 178   set( filenameRef   c0p1_0${numFileC0P1}.pgx )
 179
 180   # Get corresponding tests parameters
 181   list(GET C0P1_ResFactor_list ${numFileC0P1}  ResFactor)
 182   #For Class-0 testing, we always focus on the first component only
 183   #list(GET CP0_nbC_list ${numFileC0P0}  nbComponents)
 184   set( nbComponents "1")
 185   list(GET C0P1_PEAK_list ${numFileC0P1}  PEAK_limit)
 186   list(GET C0P1_MSE_list ${numFileC0P1}  MSE_limit)
 187
 188   # Manage cases which need to try different resolution reduction
 189   if (numFileC0P1 EQUAL 4 )
 190     get_filename_component(filenameRefSub ${filenameRef} NAME_WE)
 191
 192     #r = 0
 193     add_test(ETS-C0P1-${filenameInput}-r0-decode
 194         ${EXECUTABLE_OUTPUT_PATH}/opj_decompress
 195         -i ${INPUT_CONF}/${filenameInput}
 196         -o ${TEMP}/c0${filenameInput}-r0.pgx
 197         -r 0
 198         )
 199
 200     add_test(ETS-C0P1-${filenameInput}-r0-compare2ref
 201         ${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
 202         -b ${BASELINE_CONF}/${filenameRefSub}r0.pgx
 203         -t ${TEMP}/c0${filenameInput}-r0.pgx
 204         -n ${nbComponents}
 205         -p ${PEAK_limit}
 206         -m ${MSE_limit}
 207         -s t_
 208         )
 209
 210     set_tests_properties(ETS-C0P1-${filenameInput}-r0-compare2ref
 211                          PROPERTIES DEPENDS
 212                          ETS-C0P1-${filenameInput}-r0-decode)
 213
 214     add_test(NR-C0P1-${filenameInput}-r0-compare2base
 215         ${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
 216         -b ${BASELINE_NR}/opj_${filenameRefSub}-r0.pgx
 217         -t ${TEMP}/c0${filenameInput}-r0.pgx
 218         -n ${nbComponents}
 219         -d
 220         -s b_t_
 221         )
 222
 223     set_tests_properties(NR-C0P1-${filenameInput}-r0-compare2base
 224                          PROPERTIES DEPENDS
 225                          ETS-C0P1-${filenameInput}-r0-decode)
 226
 227     #r = 3
 228     add_test(ETS-C0P1-${filenameInput}-r3-decode
 229         ${EXECUTABLE_OUTPUT_PATH}/opj_decompress
 230         -i ${INPUT_CONF}/${filenameInput}
 231         -o ${TEMP}/c0${filenameInput}-r3.pgx
 232         -r 3
 233         )
 234
 235     add_test(ETS-C0P1-${filenameInput}-r3-compare2ref
 236         ${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
 237         -b ${BASELINE_CONF}/${filenameRefSub}r3.pgx
 238         -t ${TEMP}/c0${filenameInput}-r3.pgx
 239         -n ${nbComponents}
 240         -p ${PEAK_limit}
 241         -m ${MSE_limit}
 242         -s t_
 243         )
 244
 245     set_tests_properties(ETS-C0P1-${filenameInput}-r3-compare2ref
 246                          PROPERTIES DEPENDS
 247                          ETS-C0P1-${filenameInput}-r3-decode)
 248
 249     add_test(NR-C0P1-${filenameInput}-r3-compare2base
 250         ${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
 251         -b ${BASELINE_NR}/opj_${filenameRefSub}-r3.pgx
 252         -t ${TEMP}/c0${filenameInput}-r3.pgx
 253         -n ${nbComponents}
 254         -d
 255         -s b_t_
 256         )
 257
 258     set_tests_properties(NR-C0P1-${filenameInput}-r3-compare2base
 259                          PROPERTIES DEPENDS
 260                          ETS-C0P1-${filenameInput}-r3-decode)
 261
 262   else()
 263
 264     add_test(ETS-C0P1-${filenameInput}-decode
 265         ${EXECUTABLE_OUTPUT_PATH}/opj_decompress
 266         -i ${INPUT_CONF}/${filenameInput}
 267         -o ${TEMP}/c0${filenameInput}.pgx
 268         -r ${ResFactor}
 269         )
 270
 271     add_test(ETS-C0P1-${filenameInput}-compare2ref
 272         ${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
 273         -b ${BASELINE_CONF}/${filenameRef}
 274         -t ${TEMP}/c0${filenameInput}.pgx
 275         -n ${nbComponents}
 276         -p ${PEAK_limit}
 277         -m ${MSE_limit}
 278         -s t_
 279         )
 280
 281     set_tests_properties(ETS-C0P1-${filenameInput}-compare2ref
 282                          PROPERTIES DEPENDS
 283                          ETS-C0P1-${filenameInput}-decode)
 284
 285     add_test(NR-C0P1-${filenameInput}-compare2base
 286         ${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
 287         -b ${BASELINE_NR}/opj_${filenameRef}
 288         -t ${TEMP}/c0${filenameInput}.pgx
 289         -n ${nbComponents}
 290         -d
 291         -s b_t_
 292         )
 293
 294     set_tests_properties(NR-C0P1-${filenameInput}-compare2base
 295                          PROPERTIES DEPENDS
 296                          ETS-C0P1-${filenameInput}-decode)
 297
 298   endif()
 299
 300 endforeach()
 301
 302 #--------------------------------------------------------------------------
 303 # Tests about class 1 profile 0
 304 # try to decode
 305 # compare to ref file
 306 # non regression comparison
 307
 308 # Parameters and tolerances given by Table C.6
 309 set( C1P0_ResFactor_list "not_used;0;0;0;0;0;0;0;1;0;0;0;0;0;0;0;0")
 310 set( C1P0_PEAK_list "not_used;0;0;0;5:4:6;2:2:2:0;635:403:378:0;0:0:0;0:0:0;0;0:0:0;0;0;0:0:0:0;0:0:0;0;0")
 311 set( C1P0_MSE_list  "not_used;0;0;0;0.776:0.626:1.070;0.302:0.307:0.269:0;11287:6124:3968:0;0:0:0;0:0:0;0;0:0:0;0;0;0:0:0:0;0:0:0;0;0")
 312
 313 foreach(numFileC1P0 RANGE 1 16)
 314
 315   # Build filenames
 316   if(${numFileC1P0} LESS 10)
 317     set( filenameInput p0_0${numFileC1P0}.j2k )
 318     set( filenameRef   c1p0_0${numFileC1P0}.pgx )
 319   else()
 320     set( filenameInput p0_${numFileC1P0}.j2k )
 321     set( filenameRef   c1p0_${numFileC1P0}.pgx )
 322   endif()
 323
 324   # Get corresponding tests parameters
 325   list(GET CP0_nbC_list ${numFileC1P0}  nbComponents)
 326   list(GET C1P0_ResFactor_list ${numFileC1P0}  ResFactor)
 327   list(GET C1P0_PEAK_list ${numFileC1P0}  PEAK_limit)
 328   list(GET C1P0_MSE_list ${numFileC1P0}  MSE_limit)
 329
 330   add_test(ETS-C1P0-${filenameInput}-decode
 331       ${EXECUTABLE_OUTPUT_PATH}/opj_decompress
 332       -i ${INPUT_CONF}/${filenameInput}
 333       -o ${TEMP}/c1${filenameInput}.pgx
 334       -r ${ResFactor}
 335       )
 336
 337   add_test(ETS-C1P0-${filenameInput}-compare2ref
 338       ${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
 339      -b ${BASELINE_CONF}/${filenameRef}
 340      -t ${TEMP}/c1${filenameInput}.pgx
 341      -n ${nbComponents}
 342      -p ${PEAK_limit}
 343      -m ${MSE_limit}
 344      -s b_t_
 345      )
 346
 347   set_tests_properties(ETS-C1P0-${filenameInput}-compare2ref
 348                        PROPERTIES DEPENDS
 349                        ETS-C1P0-${filenameInput}-decode)
 350
 351   add_test(NR-C1P0-${filenameInput}-compare2base
 352       ${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
 353      -b ${BASELINE_NR}/opj_${filenameRef}
 354      -t ${TEMP}/c1${filenameInput}.pgx
 355      -n ${nbComponents}
 356      -d
 357      -s b_t_
 358      )
 359
 360   set_tests_properties(NR-C1P0-${filenameInput}-compare2base
 361                        PROPERTIES DEPENDS
 362                        ETS-C1P0-${filenameInput}-decode)
 363
 364 endforeach()
 365
 366 #--------------------------------------------------------------------------
 367 # Tests about class 1 profile 1
 368 # try to decode
 369 # compare to ref file
 370 # non regression comparison
 371
 372 # Parameters and tolerances given by Table C.7
 373 set( C1P1_PEAK_list "not_used;0;5:4:6;2:2:1:0;624;40:40:40;2:2:2;0:0")
 374 set( C1P1_MSE_list  "not_used;0;0.765:0.616:1.051;0.3:0.210:0.200:0;3080;8.458:9.816:10.154;0.6:0.6:0.6;0:0")
 375
 376 foreach(numFileC1P1 RANGE 1 7)
 377
 378   # Build filenames
 379   set( filenameInput p1_0${numFileC1P1}.j2k )
 380   set( filenameRef   c1p1_0${numFileC1P1}.pgx )
 381
 382   # Get corresponding tests parameters
 383   list(GET CP1_nbC_list ${numFileC1P1}  nbComponents)
 384   list(GET C1P1_PEAK_list ${numFileC1P1}  PEAK_limit)
 385   list(GET C1P1_MSE_list ${numFileC1P1}  MSE_limit)
 386
 387   add_test(ETS-C1P1-${filenameInput}-decode
 388       ${EXECUTABLE_OUTPUT_PATH}/opj_decompress
 389       -i ${INPUT_CONF}/${filenameInput}
 390       -o ${TEMP}/c1${filenameInput}.pgx
 391       -r 0
 392       )
 393
 394   add_test(ETS-C1P1-${filenameInput}-compare2ref
 395       ${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
 396      -b ${BASELINE_CONF}/${filenameRef}
 397      -t ${TEMP}/c1${filenameInput}.pgx
 398      -n ${nbComponents}
 399      -p ${PEAK_limit}
 400      -m ${MSE_limit}
 401      -s b_t_
 402      )
 403
 404   set_tests_properties(ETS-C1P1-${filenameInput}-compare2ref
 405                        PROPERTIES DEPENDS
 406                        ETS-C1P1-${filenameInput}-decode)
 407
 408   add_test(NR-C1P1-${filenameInput}-compare2base
 409       ${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
 410      -b ${BASELINE_NR}/opj_${filenameRef}
 411      -t ${TEMP}/c1${filenameInput}.pgx
 412      -n ${nbComponents}
 413      -d
 414      -s b_t_
 415      )
 416
 417   set_tests_properties(NR-C1P1-${filenameInput}-compare2base
 418                        PROPERTIES DEPENDS
 419                        ETS-C1P1-${filenameInput}-decode)
 420
 421 endforeach()
 422
 423 #--------------------------------------------------------------------------
 424 # Tests about JP2 file
 425 # try to decode
 426 # compare to ref file
 427 # non regression comparison
 428
 429 # Tolerances given by Table G.1
 430
 431 foreach(numFileJP2 RANGE 1 9)
 432
 433   # Build filenames
 434   set( filenameInput "file${numFileJP2}.jp2" )
 435   set( filenameRef   jp2_${numFileJP2}.tif )
 436
 437   # Get corresponding tests parameters
 438   list(GET JP2_PEAK_list ${numFileJP2}  PEAK_limit)
 439
 440   add_test(ETS-JP2-${filenameInput}-decode
 441       ${EXECUTABLE_OUTPUT_PATH}/opj_decompress
 442       -i ${INPUT_CONF}/${filenameInput}
 443       -o ${TEMP}/${filenameInput}.tif
 444       )
 445 #
 446 # FIXME: Need to implement a compare tif images function
 447 #
 448 #  add_test(ETS-JP2-${filenameInput}-compare2ref
 449 #      ${EXECUTABLE_OUTPUT_PATH}/compareTIFimages
 450 #     -b ${BASELINE_CONF}/${filenameRef_tif}
 451 #     -t ${TEMP}/${filenameInput}.pgx
 452 #     -p 4
 453 #     )
 454 #
 455 #  set_tests_properties(ETS-JP2-${filenameInput}-compare2ref
 456 #                       PROPERTIES DEPENDS
 457 #                       ETS-JP2-${filenameInput}-decode)
 458 #
 459 #  add_test(NR-JP2-${filenameInput}-compare2base
 460 #      ${EXECUTABLE_OUTPUT_PATH}/compareTIFimages
 461 #     -b ${BASELINE_NR}/opj_${filenameRef}
 462 #     -t ${TEMP}/${filenameInput}.tif
 463 #     -d
 464 #     )
 465 #
 466 #  set_tests_properties(NR-JP2-${filenameInput}-compare2base
 467 #                       PROPERTIES DEPENDS
 468 #                       ETS-JP2-${filenameInput}-decode)
 469
 470 endforeach()
 471
 472 #--------------------------------------------------------------------------#
 473 #--------------------------------------------------------------------------#
 474 #--------------------------------------------------------------------------#
 475
 476 #--------------------------------------------------------------------------
 477 # Tests about dump of profile 0 file
 478 # try to dump image and codestream informations into a file
 479 # non regression comparison this file to the baseline
 480
 481 foreach(numFileP0 RANGE 1 16)
 482
 483   # Build filenames
 484   if(${numFileP0} LESS 10)
 485     set( filenameInput p0_0${numFileP0}.j2k )
 486   else()
 487     set( filenameInput p0_${numFileP0}.j2k )
 488   endif()
 489   get_filename_component(filenameRefSub ${filenameInput} NAME_WE)
 490
 491
 492   add_test(NR-${filenameInput}-dump
 493       ${EXECUTABLE_OUTPUT_PATH}/opj_dump
 494      -i ${INPUT_CONF}/${filenameInput}
 495      -o ${TEMP}/${filenameInput}.txt
 496      )
 497
 498   add_test(NR-${filenameInput}-compare_dump2base
 499       ${EXECUTABLE_OUTPUT_PATH}/compare_dump_files
 500      -b ${BASELINE_NR}/opj_v2_${filenameRefSub}.txt
 501      -t ${TEMP}/${filenameInput}.txt
 502      )
 503
 504   set_tests_properties(NR-${filenameInput}-compare_dump2base
 505                        PROPERTIES DEPENDS
 506                        NR-${filenameInput}-dump)
 507
 508 endforeach()
 509
 510 #--------------------------------------------------------------------------
 511 # Tests about dump of profile 1 file
 512 # try to dump image and codestream informations into a file
 513 # non regression comparison this file to the baseline
 514
 515 foreach(numFileP1 RANGE 1 7)
 516
 517   # Build filenames
 518   set( filenameInput p1_0${numFileP1}.j2k )
 519   get_filename_component(filenameInputSub ${filenameInput} NAME_WE)
 520
 521   add_test(NR-${filenameInput}-dump
 522       ${EXECUTABLE_OUTPUT_PATH}/opj_dump
 523      -i ${INPUT_CONF}/${filenameInput}
 524      -o ${TEMP}/${filenameInput}.txt
 525      )
 526
 527   add_test(NR-${filenameInput}-compare_dump2base
 528       ${EXECUTABLE_OUTPUT_PATH}/compare_dump_files
 529      -b ${BASELINE_NR}/opj_v2_${filenameInputSub}.txt
 530      -t ${TEMP}/${filenameInput}.txt
 531      )
 532
 533   set_tests_properties(NR-${filenameInput}-compare_dump2base
 534                        PROPERTIES DEPENDS
 535                        NR-${filenameInput}-dump)
 536
 537 endforeach()
 538
 539 #--------------------------------------------------------------------------
 540 # Tests about dump of JP2 file
 541 # try to dump image and codestream informations into a file
 542 # non regression comparison this file to the baseline
 543
 544 foreach(numFileJP2 RANGE 1 9)
 545
 546   # Build filenames
 547   set( filenameInput "file${numFileJP2}.jp2" )
 548   get_filename_component(filenameInputSub ${filenameInput} NAME_WE)
 549
 550   add_test(NR-${filenameInput}-dump
 551       ${EXECUTABLE_OUTPUT_PATH}/opj_dump
 552      -i ${INPUT_CONF}/${filenameInput}
 553      -o ${TEMP}/${filenameInput}.txt
 554      )
 555
 556   add_test(NR-${filenameInput}-compare_dump2base
 557       ${EXECUTABLE_OUTPUT_PATH}/compare_dump_files
 558      -b ${BASELINE_NR}/opj_v2_${filenameInputSub}.txt
 559      -t ${TEMP}/${filenameInput}.txt
 560      )
 561
 562   set_tests_properties(NR-${filenameInput}-compare_dump2base
 563                        PROPERTIES DEPENDS
 564                        NR-${filenameInput}-dump)
 565
 566 endforeach()