tests/test_filter_flags.c

   1 ///////////////////////////////////////////////////////////////////////////////
   2 //
   3 /// \file       test_filter_flags.c
   4 /// \brief      Tests Filter Flags coders
   5 //
   6 //  Authors:    Jia Tan
   7 //              Lasse Collin
   8 //
   9 //  This file has been put into the public domain.
  10 //  You can do whatever you want with this file.
  11 //
  12 ///////////////////////////////////////////////////////////////////////////////
  13
  14 #include "tests.h"
  15
  16 // FIXME: This is from src/liblzma/common/common.h but it cannot be
  17 // included here. This constant is needed in only a few files, perhaps
  18 // move it to some other internal header or create a new one?
  19 #define LZMA_FILTER_RESERVED_START (LZMA_VLI_C(1) << 62)
  20
  21
  22 #if defined(HAVE_ENCODERS)
  23 // No tests are run without encoders, so init the global filters
  24 // only when the encoders are enabled.
  25 static lzma_filter lzma1_filter = { LZMA_FILTER_LZMA1, NULL };
  26 static lzma_filter lzma2_filter = { LZMA_FILTER_LZMA2, NULL };
  27 static lzma_filter delta_filter = { LZMA_FILTER_DELTA, NULL };
  28
  29 static lzma_filter bcj_filters_encoders[] = {
  30 #ifdef HAVE_ENCODER_X86
  31         { LZMA_FILTER_X86, NULL },
  32 #endif
  33 #ifdef HAVE_ENCODER_POWERPC
  34         { LZMA_FILTER_POWERPC, NULL },
  35 #endif
  36 #ifdef HAVE_ENCODER_IA64
  37         { LZMA_FILTER_IA64, NULL },
  38 #endif
  39 #ifdef HAVE_ENCODER_ARM
  40         { LZMA_FILTER_ARM, NULL },
  41 #endif
  42 #ifdef HAVE_ENCODER_ARM64
  43         { LZMA_FILTER_ARM64, NULL },
  44 #endif
  45 #ifdef HAVE_ENCODER_ARMTHUMB
  46         { LZMA_FILTER_ARMTHUMB, NULL },
  47 #endif
  48 #ifdef HAVE_ENCODER_SPARC
  49         { LZMA_FILTER_SPARC, NULL },
  50 #endif
  51 };
  52
  53 // HAVE_ENCODERS ifdef not termianted here because decoders are
  54 // only used if encoders are, but encoders can still be used
  55 // even if decoders are not.
  56
  57 #ifdef HAVE_DECODERS
  58 static lzma_filter bcj_filters_decoders[] = {
  59 #ifdef HAVE_DECODER_X86
  60         { LZMA_FILTER_X86, NULL },
  61 #endif
  62 #ifdef HAVE_DECODER_POWERPC
  63         { LZMA_FILTER_POWERPC, NULL },
  64 #endif
  65 #ifdef HAVE_DECODER_IA64
  66         { LZMA_FILTER_IA64, NULL },
  67 #endif
  68 #ifdef HAVE_DECODER_ARM
  69         { LZMA_FILTER_ARM, NULL },
  70 #endif
  71 #ifdef HAVE_DECODER_ARM64
  72         { LZMA_FILTER_ARM64, NULL },
  73 #endif
  74 #ifdef HAVE_DECODER_ARMTHUMB
  75         { LZMA_FILTER_ARMTHUMB, NULL },
  76 #endif
  77 #ifdef HAVE_DECODER_SPARC
  78         { LZMA_FILTER_SPARC, NULL },
  79 #endif
  80 };
  81 #endif
  82 #endif
  83
  84
  85 static void
  86 test_lzma_filter_flags_size(void)
  87 {
  88 #ifndef HAVE_ENCODERS
  89         assert_skip("Encoder support disabled");
  90 #else
  91         // For each supported filter, test that the size can be calculated
  92         // and that the size calculated is reasonable. A reasonable size
  93         // must be greater than 0, but less than the maximum size for the
  94         // block header.
  95         uint32_t size = 0;
  96         if (lzma_filter_encoder_is_supported(LZMA_FILTER_LZMA1)) {
  97                 assert_lzma_ret(lzma_filter_flags_size(&size,
  98                                 &lzma1_filter), LZMA_PROG_ERROR);
  99         }
 100
 101         if (lzma_filter_encoder_is_supported(LZMA_FILTER_LZMA2)) {
 102                 assert_lzma_ret(lzma_filter_flags_size(&size,
 103                                 &lzma2_filter), LZMA_OK);
 104                 assert_true(size != 0 && size < LZMA_BLOCK_HEADER_SIZE_MAX);
 105         }
 106
 107         // Do not use macro ARRAY_SIZE() in the for loop condition directly.
 108         // If the BCJ filters are not configured and built, then ARRAY_SIZE()
 109         // will return 0 and cause a warning because the for loop will never
 110         // execute since any unsigned number cannot be < 0 (-Werror=type-limits).
 111         const uint32_t bcj_array_size = ARRAY_SIZE(bcj_filters_encoders);
 112         for (uint32_t i = 0; i < bcj_array_size; i++) {
 113                 assert_lzma_ret(lzma_filter_flags_size(&size,
 114                                 &bcj_filters_encoders[i]), LZMA_OK);
 115                 assert_true(size != 0 && size < LZMA_BLOCK_HEADER_SIZE_MAX);
 116         }
 117
 118         if (lzma_filter_encoder_is_supported(LZMA_FILTER_DELTA)) {
 119                 assert_lzma_ret(lzma_filter_flags_size(&size,
 120                                 &delta_filter), LZMA_OK);
 121                 assert_true(size != 0 && size < LZMA_BLOCK_HEADER_SIZE_MAX);
 122         }
 123
 124         // Test invalid Filter IDs
 125         lzma_filter bad_filter = { 2, NULL };
 126
 127         assert_lzma_ret(lzma_filter_flags_size(&size, &bad_filter),
 128                         LZMA_OPTIONS_ERROR);
 129         bad_filter.id = LZMA_VLI_MAX;
 130         assert_lzma_ret(lzma_filter_flags_size(&size, &bad_filter),
 131                         LZMA_PROG_ERROR);
 132         bad_filter.id = LZMA_FILTER_RESERVED_START;
 133         assert_lzma_ret(lzma_filter_flags_size(&size, &bad_filter),
 134                         LZMA_PROG_ERROR);
 135 #endif
 136 }
 137
 138
 139 // Helper function for test_lzma_filter_flags_encode.
 140 // The should_encode parameter represents if the encoding operation
 141 // is expected to fail.
 142 // Avoid data -> encode -> decode -> compare to data.
 143 // Instead create expected encoding and compare to result from
 144 // lzma_filter_flags_encode.
 145 // Filter Flags in .xz are encoded as:
 146 // |Filter ID (VLI)|Size of Properties (VLI)|Filter Properties|
 147 #if defined(HAVE_ENCODERS) && defined(HAVE_DECODERS)
 148 static void
 149 verify_filter_flags_encode(lzma_filter *filter, bool should_encode)
 150 {
 151         uint32_t size = 0;
 152
 153         // First calculate the size of Filter Flags to know how much
 154         // memory to allocate to hold the encoded Filter Flags
 155         assert_lzma_ret(lzma_filter_flags_size(&size, filter), LZMA_OK);
 156         uint8_t *encoded_out = tuktest_malloc(size * sizeof(uint8_t));
 157         size_t out_pos = 0;
 158         if (!should_encode) {
 159                 assert_false(lzma_filter_flags_encode(filter, encoded_out,
 160                                 &out_pos, size) == LZMA_OK);
 161                 return;
 162         }
 163
 164         // Next encode the Filter Flags for the provided filter
 165         assert_lzma_ret(lzma_filter_flags_encode(filter, encoded_out,
 166                         &out_pos, size), LZMA_OK);
 167         assert_uint_eq(size, out_pos);
 168
 169         // Next decode the VLI for the Filter ID and verify it matches
 170         // the expected Filter ID
 171         size_t filter_id_vli_size = 0;
 172         lzma_vli filter_id = 0;
 173         assert_lzma_ret(lzma_vli_decode(&filter_id, NULL, encoded_out,
 174                         &filter_id_vli_size, size), LZMA_OK);
 175         assert_uint_eq(filter->id, filter_id);
 176
 177         // Next decode the Size of Properites and ensure it equals
 178         // the expected size.
 179         // Expected size should be:
 180         // total filter flag length - size of filter id VLI + size of
 181         //                            property size VLI
 182         // Not verifying the contents of Filter Properties since
 183         // that belongs in a different test
 184         size_t size_of_properties_vli_size = 0;
 185         lzma_vli size_of_properties = 0;
 186         assert_lzma_ret(lzma_vli_decode(&size_of_properties, NULL,
 187                         encoded_out + filter_id_vli_size,
 188                         &size_of_properties_vli_size, size), LZMA_OK);
 189         assert_uint_eq(size - (size_of_properties_vli_size +
 190                         filter_id_vli_size), size_of_properties);
 191 }
 192 #endif
 193
 194
 195 static void
 196 test_lzma_filter_flags_encode(void)
 197 {
 198 #if !defined(HAVE_ENCODERS) || !defined(HAVE_DECODERS)
 199         assert_skip("Encoder or decoder support disabled");
 200 #else
 201         // No test for LZMA1 since the .xz format does not support LZMA1
 202         // and so the flags cannot be encoded for that filter
 203         if (lzma_filter_encoder_is_supported(LZMA_FILTER_LZMA2)) {
 204                 // Test with NULL options that should fail
 205                 lzma_options_lzma *options = lzma2_filter.options;
 206                 lzma2_filter.options = NULL;
 207                 verify_filter_flags_encode(&lzma2_filter, false);
 208
 209                 // Place options back in the filter, and test should pass
 210                 lzma2_filter.options = options;
 211                 verify_filter_flags_encode(&lzma2_filter, true);
 212         }
 213
 214         // NOTE: Many BCJ filters require that start_offset is a multiple
 215         // of some power of two. The Filter Flags encoder and decoder don't
 216         // completely validate the options and thus 257 passes the tests
 217         // with all BCJ filters. It would be caught when initializing
 218         // a filter chain encoder or decoder.
 219         lzma_options_bcj bcj_options = {
 220                 .start_offset = 257
 221         };
 222
 223         const uint32_t bcj_array_size = ARRAY_SIZE(bcj_filters_encoders);
 224         for (uint32_t i = 0; i < bcj_array_size; i++) {
 225                 // NULL options should pass for bcj filters
 226                 verify_filter_flags_encode(&bcj_filters_encoders[i], true);
 227                 lzma_filter bcj_with_options = {
 228                                 bcj_filters_encoders[i].id, &bcj_options };
 229                 verify_filter_flags_encode(&bcj_with_options, true);
 230         }
 231
 232         if (lzma_filter_encoder_is_supported(LZMA_FILTER_DELTA)) {
 233                 lzma_options_delta delta_opts_below_min = {
 234                         .type = LZMA_DELTA_TYPE_BYTE,
 235                         .dist = LZMA_DELTA_DIST_MIN - 1
 236                 };
 237
 238                 lzma_options_delta delta_opts_above_max = {
 239                         .type = LZMA_DELTA_TYPE_BYTE,
 240                         .dist = LZMA_DELTA_DIST_MAX + 1
 241                 };
 242
 243                 verify_filter_flags_encode(&delta_filter, true);
 244
 245                 lzma_filter delta_filter_bad_options = {
 246                                 LZMA_FILTER_DELTA, &delta_opts_below_min };
 247
 248                 // Next test error case using minimum - 1 delta distance
 249                 verify_filter_flags_encode(&delta_filter_bad_options, false);
 250
 251                 // Next test error case using maximum + 1 delta distance
 252                 delta_filter_bad_options.options = &delta_opts_above_max;
 253                 verify_filter_flags_encode(&delta_filter_bad_options, false);
 254
 255                 // Next test NULL case
 256                 delta_filter_bad_options.options = NULL;
 257                 verify_filter_flags_encode(&delta_filter_bad_options, false);
 258         }
 259
 260         // Test expected failing cases
 261         lzma_filter bad_filter = { LZMA_FILTER_RESERVED_START, NULL };
 262         size_t out_pos = 0;
 263         size_t out_size = LZMA_BLOCK_HEADER_SIZE_MAX;
 264         uint8_t out[LZMA_BLOCK_HEADER_SIZE_MAX];
 265
 266
 267         // Filter ID outside of valid range
 268         assert_lzma_ret(lzma_filter_flags_encode(&bad_filter, out, &out_pos,
 269                         out_size), LZMA_PROG_ERROR);
 270         out_pos = 0;
 271         bad_filter.id = LZMA_VLI_MAX + 1;
 272         assert_lzma_ret(lzma_filter_flags_encode(&bad_filter, out, &out_pos,
 273                         out_size), LZMA_PROG_ERROR);
 274         out_pos = 0;
 275
 276         // Invalid Filter ID
 277         bad_filter.id = 2;
 278         assert_lzma_ret(lzma_filter_flags_encode(&bad_filter, out, &out_pos,
 279                         out_size), LZMA_OPTIONS_ERROR);
 280         out_pos = 0;
 281
 282         // Out size too small
 283         if (lzma_filter_encoder_is_supported(LZMA_FILTER_LZMA2)) {
 284                 uint32_t bad_size = 0;
 285
 286                 // First test with 0 output size
 287                 assert_lzma_ret(lzma_filter_flags_encode(
 288                                 &lzma2_filter, out, &out_pos, 0),
 289                                 LZMA_PROG_ERROR);
 290
 291                 // Next calculate the size needed to encode and
 292                 // use less than that
 293                 assert_lzma_ret(lzma_filter_flags_size(&bad_size,
 294                                 &lzma2_filter), LZMA_OK);
 295
 296                 assert_lzma_ret(lzma_filter_flags_encode(
 297                                 &lzma2_filter, out, &out_pos,
 298                                 bad_size - 1), LZMA_PROG_ERROR);
 299                 out_pos = 0;
 300         }
 301
 302         // Invalid options
 303         if (lzma_filter_encoder_is_supported(LZMA_FILTER_DELTA)) {
 304                 bad_filter.id = LZMA_FILTER_DELTA;
 305
 306                 // First test with NULL options
 307                 assert_lzma_ret(lzma_filter_flags_encode(&bad_filter, out,
 308                                 &out_pos, out_size), LZMA_PROG_ERROR);
 309                 out_pos = 0;
 310
 311                 // Next test with invalid options
 312                 lzma_options_delta bad_options = {
 313                         .dist = LZMA_DELTA_DIST_MAX + 1,
 314                         .type = LZMA_DELTA_TYPE_BYTE
 315                 };
 316                 bad_filter.options = &bad_options;
 317
 318                 assert_lzma_ret(lzma_filter_flags_encode(&bad_filter, out,
 319                                 &out_pos, out_size), LZMA_PROG_ERROR);
 320         }
 321 #endif
 322 }
 323
 324
 325 // Helper function for test_lzma_filter_flags_decode.
 326 // Encodes the filter_in without using lzma_filter_flags_encode.
 327 // Leaves the specific assertions of filter_out options to the caller
 328 // because it is agnostic to the type of options used in the call
 329 #if defined(HAVE_ENCODERS) && defined(HAVE_DECODERS)
 330 static void
 331 verify_filter_flags_decode(lzma_filter *filter_in, lzma_filter *filter_out)
 332 {
 333         uint32_t total_size = 0;
 334
 335         assert_lzma_ret(lzma_filter_flags_size(&total_size, filter_in),
 336                         LZMA_OK);
 337         assert_uint(total_size, >, 0);
 338         uint8_t *filter_flag_buffer = tuktest_malloc(total_size);
 339
 340         uint32_t properties_size = 0;
 341         size_t out_pos = 0;
 342         size_t in_pos = 0;
 343         assert_lzma_ret(lzma_properties_size(&properties_size, filter_in),
 344                         LZMA_OK);
 345         assert_lzma_ret(lzma_vli_encode(filter_in->id, NULL,
 346                         filter_flag_buffer, &out_pos, total_size), LZMA_OK);
 347         assert_lzma_ret(lzma_vli_encode(properties_size, NULL,
 348                         filter_flag_buffer, &out_pos, total_size),
 349                         LZMA_OK);
 350         assert_lzma_ret(lzma_properties_encode(filter_in,
 351                         filter_flag_buffer + out_pos), LZMA_OK);
 352         assert_lzma_ret(lzma_filter_flags_decode(filter_out, NULL,
 353                         filter_flag_buffer, &in_pos, total_size),
 354                         LZMA_OK);
 355         assert_uint_eq(filter_in->id, filter_out->id);
 356 }
 357 #endif
 358
 359
 360 static void
 361 test_lzma_filter_flags_decode(void)
 362 {
 363 #if !defined(HAVE_ENCODERS) || !defined(HAVE_DECODERS)
 364         assert_skip("Encoder or decoder support disabled");
 365 #else
 366         // For each filter, only run the decoder test if both the encoder
 367         // and decoder are enabled. This is because verify_filter_flags_decode
 368         // uses lzma_filter_flags_size which requires the encoder.
 369         if (lzma_filter_decoder_is_supported(LZMA_FILTER_LZMA2) &&
 370                         lzma_filter_encoder_is_supported(LZMA_FILTER_LZMA2)) {
 371                 lzma_filter lzma2_decoded = { LZMA_FILTER_LZMA2, NULL };
 372
 373                 verify_filter_flags_decode(&lzma2_filter, &lzma2_decoded);
 374
 375                 lzma_options_lzma *expected = lzma2_filter.options;
 376                 lzma_options_lzma *decoded = lzma2_decoded.options;
 377
 378                 // Only the dictionary size is encoded and decoded
 379                 // so only compare those
 380                 assert_uint_eq(decoded->dict_size, expected->dict_size);
 381
 382                 // The decoded options must be freed by the caller
 383                 free(decoded);
 384         }
 385
 386         const uint32_t bcj_array_size = ARRAY_SIZE(bcj_filters_decoders);
 387         for (uint32_t i = 0; i < bcj_array_size; i++) {
 388                 if (lzma_filter_encoder_is_supported(
 389                                 bcj_filters_decoders[i].id)) {
 390                         lzma_filter bcj_decoded = {
 391                                         bcj_filters_decoders[i].id, NULL };
 392
 393                         lzma_filter bcj_encoded = {
 394                                         bcj_filters_decoders[i].id, NULL };
 395
 396                         // First test without options
 397                         verify_filter_flags_decode(&bcj_encoded,
 398                                         &bcj_decoded);
 399                         assert_true(bcj_decoded.options == NULL);
 400
 401                         // Next test with offset
 402                         lzma_options_bcj options = {
 403                                 .start_offset = 257
 404                         };
 405
 406                         bcj_encoded.options = &options;
 407                         verify_filter_flags_decode(&bcj_encoded,
 408                                         &bcj_decoded);
 409                         lzma_options_bcj *decoded_opts = bcj_decoded.options;
 410                         assert_uint_eq(decoded_opts->start_offset,
 411                                         options.start_offset);
 412                         free(decoded_opts);
 413                 }
 414         }
 415
 416         if (lzma_filter_decoder_is_supported(LZMA_FILTER_DELTA) &&
 417                         lzma_filter_encoder_is_supported(LZMA_FILTER_DELTA)) {
 418                 lzma_filter delta_decoded = { LZMA_FILTER_DELTA, NULL };
 419
 420                 verify_filter_flags_decode(&delta_filter, &delta_decoded);
 421                 lzma_options_delta *expected = delta_filter.options;
 422                 lzma_options_delta *decoded = delta_decoded.options;
 423                 assert_uint_eq(expected->dist, decoded->dist);
 424                 assert_uint_eq(expected->type, decoded->type);
 425
 426                 free(decoded);
 427         }
 428
 429         // Test expected failing cases
 430         uint8_t bad_encoded_filter[LZMA_BLOCK_HEADER_SIZE_MAX];
 431         lzma_filter bad_filter;
 432
 433         // Filter ID outside of valid range
 434         lzma_vli bad_filter_id = LZMA_FILTER_RESERVED_START;
 435         size_t bad_encoded_out_pos = 0;
 436         size_t in_pos = 0;
 437
 438         assert_lzma_ret(lzma_vli_encode(bad_filter_id, NULL,
 439                         bad_encoded_filter, &bad_encoded_out_pos,
 440                         LZMA_BLOCK_HEADER_SIZE_MAX), LZMA_OK);
 441
 442         assert_lzma_ret(lzma_filter_flags_decode(&bad_filter, NULL,
 443                         bad_encoded_filter, &in_pos,
 444                         LZMA_BLOCK_HEADER_SIZE_MAX), LZMA_DATA_ERROR);
 445
 446         bad_encoded_out_pos = 0;
 447         in_pos = 0;
 448
 449         // Invalid Filter ID
 450         bad_filter_id = 2;
 451         bad_encoded_out_pos = 0;
 452         in_pos = 0;
 453
 454         assert_lzma_ret(lzma_vli_encode(bad_filter_id, NULL,
 455                         bad_encoded_filter, &bad_encoded_out_pos,
 456                         LZMA_BLOCK_HEADER_SIZE_MAX), LZMA_OK);
 457
 458         // Next encode Size of Properties with the value of 0
 459         assert_lzma_ret(lzma_vli_encode(0, NULL,
 460                         bad_encoded_filter, &bad_encoded_out_pos,
 461                         LZMA_BLOCK_HEADER_SIZE_MAX), LZMA_OK);
 462
 463         // Decode should fail on bad Filter ID
 464         assert_lzma_ret(lzma_filter_flags_decode(&bad_filter, NULL,
 465                         bad_encoded_filter, &in_pos,
 466                         LZMA_BLOCK_HEADER_SIZE_MAX), LZMA_OPTIONS_ERROR);
 467         bad_encoded_out_pos = 0;
 468         in_pos = 0;
 469
 470         // Outsize too small
 471         // Encode the LZMA2 filter normally, but then set
 472         // the out size when decoding as too small
 473         if (lzma_filter_encoder_is_supported(LZMA_FILTER_LZMA2) &&
 474                         lzma_filter_decoder_is_supported(LZMA_FILTER_LZMA2)) {
 475                 uint32_t filter_flag_size = 0;
 476                 assert_lzma_ret(lzma_filter_flags_size(&filter_flag_size,
 477                                 &lzma2_filter), LZMA_OK);
 478
 479                 assert_lzma_ret(lzma_filter_flags_encode(&lzma2_filter,
 480                                 bad_encoded_filter, &bad_encoded_out_pos,
 481                                 LZMA_BLOCK_HEADER_SIZE_MAX), LZMA_OK);
 482
 483                 assert_lzma_ret(lzma_filter_flags_decode(&bad_filter, NULL,
 484                                 bad_encoded_filter, &in_pos,
 485                                 filter_flag_size - 1), LZMA_DATA_ERROR);
 486         }
 487 #endif
 488 }
 489
 490
 491 extern int
 492 main(int argc, char **argv)
 493 {
 494         tuktest_start(argc, argv);
 495
 496 #ifdef HAVE_ENCODERS
 497         // Only init filter options if encoder is supported because decoder
 498         // tests requires encoder support, so the decoder tests will only
 499         // run if for a given filter both the encoder and decoder are enabled.
 500         if (lzma_filter_encoder_is_supported(LZMA_FILTER_LZMA1)) {
 501                 lzma_options_lzma *options = tuktest_malloc(
 502                                 sizeof(lzma_options_lzma));
 503                 lzma_lzma_preset(options, LZMA_PRESET_DEFAULT);
 504                 lzma1_filter.options = options;
 505         }
 506
 507         if (lzma_filter_encoder_is_supported(LZMA_FILTER_LZMA2)) {
 508                 lzma_options_lzma *options = tuktest_malloc(
 509                                 sizeof(lzma_options_lzma));
 510                 lzma_lzma_preset(options, LZMA_PRESET_DEFAULT);
 511                 lzma2_filter.options = options;
 512         }
 513
 514         if (lzma_filter_encoder_is_supported(LZMA_FILTER_DELTA)) {
 515                 lzma_options_delta *options = tuktest_malloc(
 516                                 sizeof(lzma_options_delta));
 517                 options->dist = LZMA_DELTA_DIST_MIN;
 518                 options->type = LZMA_DELTA_TYPE_BYTE;
 519                 delta_filter.options = options;
 520         }
 521 #endif
 522
 523         tuktest_run(test_lzma_filter_flags_size);
 524         tuktest_run(test_lzma_filter_flags_encode);
 525         tuktest_run(test_lzma_filter_flags_decode);
 526         return tuktest_end();
 527 }