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