tests/test_block_header.c

   1 ///////////////////////////////////////////////////////////////////////////////
   2 //
   3 /// \file       test_block_header.c
   4 /// \brief      Tests Block Header coders
   5 //
   6 //  Authors:    Lasse Collin
   7 //              Jia Tan
   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
  17 static lzma_options_lzma opt_lzma;
  18
  19
  20 // Used in test_lzma_block_header_decode() between tests to ensure
  21 // no artifacts are leftover in the block struct that could influence
  22 // later tests.
  23 #define RESET_BLOCK(block, buf) \
  24 do { \
  25         lzma_filter *filters_ = (block).filters; \
  26         lzma_filters_free(filters_, NULL); \
  27         memzero((buf), sizeof((buf))); \
  28         memzero(&(block), sizeof(lzma_block)); \
  29         (block).filters = filters_; \
  30         (block).check = LZMA_CHECK_CRC32; \
  31 } while (0);
  32
  33
  34 #ifdef HAVE_ENCODERS
  35 static lzma_filter filters_none[1] = {
  36         {
  37                 .id = LZMA_VLI_UNKNOWN,
  38         },
  39 };
  40
  41
  42 static lzma_filter filters_one[2] = {
  43         {
  44                 .id = LZMA_FILTER_LZMA2,
  45                 .options = &opt_lzma,
  46         }, {
  47                 .id = LZMA_VLI_UNKNOWN,
  48         }
  49 };
  50
  51
  52 // These filters are only used in test_lzma_block_header_decode()
  53 // which only runs if encoders and decoders are configured.
  54 #ifdef HAVE_DECODERS
  55 static lzma_filter filters_four[5] = {
  56         {
  57                 .id = LZMA_FILTER_X86,
  58                 .options = NULL,
  59         }, {
  60                 .id = LZMA_FILTER_X86,
  61                 .options = NULL,
  62         }, {
  63                 .id = LZMA_FILTER_X86,
  64                 .options = NULL,
  65         }, {
  66                 .id = LZMA_FILTER_LZMA2,
  67                 .options = &opt_lzma,
  68         }, {
  69                 .id = LZMA_VLI_UNKNOWN,
  70         }
  71 };
  72 #endif
  73
  74
  75 static lzma_filter filters_five[6] = {
  76         {
  77                 .id = LZMA_FILTER_X86,
  78                 .options = NULL,
  79         }, {
  80                 .id = LZMA_FILTER_X86,
  81                 .options = NULL,
  82         }, {
  83                 .id = LZMA_FILTER_X86,
  84                 .options = NULL,
  85         }, {
  86                 .id = LZMA_FILTER_X86,
  87                 .options = NULL,
  88         }, {
  89                 .id = LZMA_FILTER_LZMA2,
  90                 .options = &opt_lzma,
  91         }, {
  92                 .id = LZMA_VLI_UNKNOWN,
  93         }
  94 };
  95 #endif
  96
  97
  98 static void
  99 test_lzma_block_header_size(void)
 100 {
 101 #ifndef HAVE_ENCODERS
 102         assert_skip("Encoder support disabled");
 103 #else
 104         if (!lzma_filter_encoder_is_supported(LZMA_FILTER_X86))
 105                 assert_skip("x86 BCJ encoder is disabled");
 106
 107         lzma_block block = {
 108                 .version = 0,
 109                 .filters = filters_one,
 110                 .compressed_size = LZMA_VLI_UNKNOWN,
 111                 .uncompressed_size = LZMA_VLI_UNKNOWN,
 112                 .check = LZMA_CHECK_CRC32
 113         };
 114
 115         // Test that all initial options are valid
 116         assert_lzma_ret(lzma_block_header_size(&block), LZMA_OK);
 117         assert_uint(block.header_size, >=, LZMA_BLOCK_HEADER_SIZE_MIN);
 118         assert_uint(block.header_size, <=, LZMA_BLOCK_HEADER_SIZE_MAX);
 119         assert_uint_eq(block.header_size % 4, 0);
 120
 121         // Test invalid version number
 122         for (uint32_t i = 2; i < 20; i++) {
 123                 block.version = i;
 124                 assert_lzma_ret(lzma_block_header_size(&block),
 125                                 LZMA_OPTIONS_ERROR);
 126         }
 127
 128         block.version = 1;
 129
 130         // Test invalid compressed size
 131         block.compressed_size = 0;
 132         assert_lzma_ret(lzma_block_header_size(&block), LZMA_PROG_ERROR);
 133
 134         block.compressed_size = LZMA_VLI_MAX + 1;
 135         assert_lzma_ret(lzma_block_header_size(&block), LZMA_PROG_ERROR);
 136         block.compressed_size = LZMA_VLI_UNKNOWN;
 137
 138         // Test invalid uncompressed size
 139         block.uncompressed_size = LZMA_VLI_MAX + 1;
 140         assert_lzma_ret(lzma_block_header_size(&block), LZMA_PROG_ERROR);
 141         block.uncompressed_size = LZMA_VLI_MAX;
 142
 143         // Test invalid filters
 144         block.filters = NULL;
 145         assert_lzma_ret(lzma_block_header_size(&block), LZMA_PROG_ERROR);
 146
 147         block.filters = filters_none;
 148         assert_lzma_ret(lzma_block_header_size(&block), LZMA_PROG_ERROR);
 149
 150         block.filters = filters_five;
 151         assert_lzma_ret(lzma_block_header_size(&block), LZMA_PROG_ERROR);
 152
 153         block.filters = filters_one;
 154
 155         // Test setting compressed_size to something valid
 156         block.compressed_size = 4096;
 157         assert_lzma_ret(lzma_block_header_size(&block), LZMA_OK);
 158         assert_uint(block.header_size, >=, LZMA_BLOCK_HEADER_SIZE_MIN);
 159         assert_uint(block.header_size, <=, LZMA_BLOCK_HEADER_SIZE_MAX);
 160         assert_uint_eq(block.header_size % 4, 0);
 161
 162         // Test setting uncompressed_size to something valid
 163         block.uncompressed_size = 4096;
 164         assert_lzma_ret(lzma_block_header_size(&block), LZMA_OK);
 165         assert_uint(block.header_size, >=, LZMA_BLOCK_HEADER_SIZE_MIN);
 166         assert_uint(block.header_size, <=, LZMA_BLOCK_HEADER_SIZE_MAX);
 167         assert_uint_eq(block.header_size % 4, 0);
 168
 169         // This should pass, but header_size will be an invalid value
 170         // because the total block size will not be able to fit in a valid
 171         // lzma_vli. This way a temporary value can be used to reserve
 172         // space for the header and later the actual value can be set.
 173         block.compressed_size = LZMA_VLI_MAX;
 174         assert_lzma_ret(lzma_block_header_size(&block), LZMA_OK);
 175         assert_uint(block.header_size, >=, LZMA_BLOCK_HEADER_SIZE_MIN);
 176         assert_uint(block.header_size, <=, LZMA_BLOCK_HEADER_SIZE_MAX);
 177         assert_uint_eq(block.header_size % 4, 0);
 178
 179         // Use an invalid value for a filter option. This should still pass
 180         // because the size of the LZMA2 properties is known by liblzma
 181         // without reading any of the options so it doesn't validate them.
 182         lzma_options_lzma bad_ops;
 183         assert_false(lzma_lzma_preset(&bad_ops, 1));
 184         bad_ops.pb = 0x1000;
 185
 186         lzma_filter bad_filters[2] = {
 187                 {
 188                         .id = LZMA_FILTER_LZMA2,
 189                         .options = &bad_ops
 190                 },
 191                 {
 192                         .id = LZMA_VLI_UNKNOWN,
 193                         .options = NULL
 194                 }
 195         };
 196
 197         block.filters = bad_filters;
 198
 199         assert_lzma_ret(lzma_block_header_size(&block), LZMA_OK);
 200         assert_uint(block.header_size, >=, LZMA_BLOCK_HEADER_SIZE_MIN);
 201         assert_uint(block.header_size, <=, LZMA_BLOCK_HEADER_SIZE_MAX);
 202         assert_uint_eq(block.header_size % 4, 0);
 203
 204         // Use an invalid block option. The check type isn't stored in
 205         // the Block Header and so _header_size ignores it.
 206         block.check = INVALID_LZMA_CHECK_ID;
 207         block.ignore_check = false;
 208
 209         assert_lzma_ret(lzma_block_header_size(&block), LZMA_OK);
 210         assert_uint(block.header_size, >=, LZMA_BLOCK_HEADER_SIZE_MIN);
 211         assert_uint(block.header_size, <=, LZMA_BLOCK_HEADER_SIZE_MAX);
 212         assert_uint_eq(block.header_size % 4, 0);
 213 #endif
 214 }
 215
 216
 217 static void
 218 test_lzma_block_header_encode(void)
 219 {
 220 #if !defined(HAVE_ENCODERS) || !defined(HAVE_DECODERS)
 221         assert_skip("Encoder or decoder support disabled");
 222 #else
 223
 224         if (!lzma_filter_encoder_is_supported(LZMA_FILTER_X86)
 225                         || !lzma_filter_decoder_is_supported(LZMA_FILTER_X86))
 226                 assert_skip("x86 BCJ encoder and/or decoder "
 227                                 "is disabled");
 228
 229         lzma_block block = {
 230                 .version = 1,
 231                 .filters = filters_one,
 232                 .compressed_size = LZMA_VLI_UNKNOWN,
 233                 .uncompressed_size = LZMA_VLI_UNKNOWN,
 234                 .check = LZMA_CHECK_CRC32,
 235         };
 236
 237         // Ensure all block options are valid before changes are tested
 238         assert_lzma_ret(lzma_block_header_size(&block), LZMA_OK);
 239
 240         uint8_t out[LZMA_BLOCK_HEADER_SIZE_MAX];
 241
 242         // Test invalid block version
 243         for (uint32_t i = 2; i < 20; i++) {
 244                 block.version = i;
 245                 assert_lzma_ret(lzma_block_header_encode(&block, out),
 246                                 LZMA_PROG_ERROR);
 247         }
 248
 249         block.version = 1;
 250
 251         // Test invalid header size (< min, > max, % 4 != 0)
 252         block.header_size = LZMA_BLOCK_HEADER_SIZE_MIN - 4;
 253         assert_lzma_ret(lzma_block_header_encode(&block, out),
 254                         LZMA_PROG_ERROR);
 255         block.header_size = LZMA_BLOCK_HEADER_SIZE_MIN + 2;
 256         assert_lzma_ret(lzma_block_header_encode(&block, out),
 257                         LZMA_PROG_ERROR);
 258         block.header_size = LZMA_BLOCK_HEADER_SIZE_MAX + 4;
 259         assert_lzma_ret(lzma_block_header_encode(&block, out),
 260                         LZMA_PROG_ERROR);
 261         assert_lzma_ret(lzma_block_header_size(&block), LZMA_OK);
 262
 263         // Test invalid compressed_size
 264         block.compressed_size = 0;
 265         assert_lzma_ret(lzma_block_header_encode(&block, out),
 266                         LZMA_PROG_ERROR);
 267         block.compressed_size = LZMA_VLI_MAX + 1;
 268         assert_lzma_ret(lzma_block_header_encode(&block, out),
 269                         LZMA_PROG_ERROR);
 270
 271         // This test passes test_lzma_block_header_size, but should
 272         // fail here because there is not enough space to encode the
 273         // proper block size because the total size is too big to fit
 274         // in an lzma_vli
 275         block.compressed_size = LZMA_VLI_MAX;
 276         assert_lzma_ret(lzma_block_header_encode(&block, out),
 277                         LZMA_PROG_ERROR);
 278         block.compressed_size = LZMA_VLI_UNKNOWN;
 279
 280         // Test invalid uncompressed size
 281         block.uncompressed_size = LZMA_VLI_MAX + 1;
 282         assert_lzma_ret(lzma_block_header_encode(&block, out),
 283                         LZMA_PROG_ERROR);
 284         block.uncompressed_size = LZMA_VLI_UNKNOWN;
 285
 286         // Test invalid block check
 287         block.check = INVALID_LZMA_CHECK_ID;
 288         block.ignore_check = false;
 289         assert_lzma_ret(lzma_block_header_encode(&block, out),
 290                         LZMA_PROG_ERROR);
 291         block.check = LZMA_CHECK_CRC32;
 292
 293         // Test invalid filters
 294         block.filters = NULL;
 295         assert_lzma_ret(lzma_block_header_encode(&block, out),
 296                         LZMA_PROG_ERROR);
 297
 298         block.filters = filters_none;
 299         assert_lzma_ret(lzma_block_header_encode(&block, out),
 300                         LZMA_PROG_ERROR);
 301
 302         block.filters = filters_five;
 303         block.header_size = LZMA_BLOCK_HEADER_SIZE_MAX - 4;
 304         assert_lzma_ret(lzma_block_header_encode(&block, out),
 305                         LZMA_PROG_ERROR);
 306
 307         // Test valid encoding and verify bytes of block header.
 308         // More complicated tests for encoding headers are included
 309         // in test_lzma_block_header_decode.
 310         block.filters = filters_one;
 311         assert_lzma_ret(lzma_block_header_size(&block), LZMA_OK);
 312         assert_lzma_ret(lzma_block_header_encode(&block, out), LZMA_OK);
 313
 314         // First read block header size from out and verify
 315         // that it == (encoded size + 1) * 4
 316         uint32_t header_size = (out[0] + 1U) * 4;
 317         assert_uint_eq(header_size, block.header_size);
 318
 319         // Next read block flags
 320         uint8_t flags = out[1];
 321
 322         // Should have number of filters = 1
 323         assert_uint_eq((flags & 0x3) + 1, 1);
 324
 325         // Bits 2-7 must be empty not set
 326         assert_uint_eq(flags & (0xFF - 0x3), 0);
 327
 328         // Verify filter flags
 329         // Decode Filter ID
 330         lzma_vli filter_id = 0;
 331         size_t pos = 2;
 332         assert_lzma_ret(lzma_vli_decode(&filter_id, NULL, out,
 333                         &pos, header_size), LZMA_OK);
 334         assert_uint_eq(filter_id, filters_one[0].id);
 335
 336         // Decode Size of Properties
 337         lzma_vli prop_size = 0;
 338         assert_lzma_ret(lzma_vli_decode(&prop_size, NULL, out,
 339                         &pos, header_size), LZMA_OK);
 340
 341         // LZMA2 has 1 byte prop size
 342         assert_uint_eq(prop_size, 1);
 343         uint8_t expected_filter_props = 0;
 344         assert_lzma_ret(lzma_properties_encode(filters_one,
 345                         &expected_filter_props), LZMA_OK);
 346         assert_uint_eq(out[pos], expected_filter_props);
 347         pos++;
 348
 349         // Check null-padding
 350         for (size_t i = pos; i < header_size - 4; i++)
 351                 assert_uint_eq(out[i], 0);
 352
 353         // Check CRC32
 354         assert_uint_eq(read32le(&out[header_size - 4]), lzma_crc32(out,
 355                         header_size - 4, 0));
 356 #endif
 357 }
 358
 359
 360 #if defined(HAVE_ENCODERS) && defined(HAVE_DECODERS)
 361 // Helper function to compare two lzma_block structures field by field
 362 static void
 363 compare_blocks(lzma_block *block_expected, lzma_block *block_actual)
 364 {
 365         assert_uint_eq(block_actual->version, block_expected->version);
 366         assert_uint_eq(block_actual->compressed_size,
 367                         block_expected->compressed_size);
 368         assert_uint_eq(block_actual->uncompressed_size,
 369                         block_expected->uncompressed_size);
 370         assert_uint_eq(block_actual->check, block_expected->check);
 371         assert_uint_eq(block_actual->header_size, block_expected->header_size);
 372
 373         // Compare filter IDs
 374         assert_true(block_expected->filters && block_actual->filters);
 375         lzma_filter expected_filter = block_expected->filters[0];
 376         uint32_t filter_count = 0;
 377         while (expected_filter.id != LZMA_VLI_UNKNOWN) {
 378                 assert_uint_eq(block_actual->filters[filter_count].id,
 379                                 expected_filter.id);
 380                 expected_filter = block_expected->filters[++filter_count];
 381         }
 382
 383         assert_uint_eq(block_actual->filters[filter_count].id,
 384                         LZMA_VLI_UNKNOWN);
 385 }
 386 #endif
 387
 388
 389 static void
 390 test_lzma_block_header_decode(void)
 391 {
 392 #if !defined(HAVE_ENCODERS) || !defined(HAVE_DECODERS)
 393         assert_skip("Encoder or decoder support disabled");
 394 #else
 395         if (!lzma_filter_encoder_is_supported(LZMA_FILTER_X86)
 396                         || !lzma_filter_decoder_is_supported(LZMA_FILTER_X86))
 397                 assert_skip("x86 BCJ encoder and/or decoder "
 398                                 "is disabled");
 399
 400         lzma_block block = {
 401                 .filters = filters_one,
 402                 .compressed_size = LZMA_VLI_UNKNOWN,
 403                 .uncompressed_size = LZMA_VLI_UNKNOWN,
 404                 .check = LZMA_CHECK_CRC32,
 405                 .version = 0
 406         };
 407
 408         assert_lzma_ret(lzma_block_header_size(&block), LZMA_OK);
 409
 410         // Encode block header with simple options
 411         uint8_t out[LZMA_BLOCK_HEADER_SIZE_MAX];
 412         assert_lzma_ret(lzma_block_header_encode(&block, out), LZMA_OK);
 413
 414         // Decode block header and check that the options match
 415         lzma_filter decoded_filters[LZMA_FILTERS_MAX + 1];
 416         lzma_block decoded_block = {
 417                 .version = 0,
 418                 .filters = decoded_filters,
 419                 .check = LZMA_CHECK_CRC32
 420         };
 421         decoded_block.header_size = lzma_block_header_size_decode(out[0]);
 422
 423         assert_lzma_ret(lzma_block_header_decode(&decoded_block, NULL, out),
 424                         LZMA_OK);
 425         compare_blocks(&block, &decoded_block);
 426
 427         // Reset output buffer and decoded_block
 428         RESET_BLOCK(decoded_block, out);
 429
 430         // Test with compressed size set
 431         block.compressed_size = 4096;
 432         assert_lzma_ret(lzma_block_header_size(&block), LZMA_OK);
 433         assert_lzma_ret(lzma_block_header_encode(&block, out), LZMA_OK);
 434         decoded_block.header_size = lzma_block_header_size_decode(out[0]);
 435         assert_lzma_ret(lzma_block_header_decode(&decoded_block, NULL, out),
 436                         LZMA_OK);
 437         compare_blocks(&block, &decoded_block);
 438
 439         RESET_BLOCK(decoded_block, out);
 440
 441         // Test with uncompressed size set
 442         block.uncompressed_size = 4096;
 443         assert_lzma_ret(lzma_block_header_size(&block), LZMA_OK);
 444         assert_lzma_ret(lzma_block_header_encode(&block, out), LZMA_OK);
 445         decoded_block.header_size = lzma_block_header_size_decode(out[0]);
 446         assert_lzma_ret(lzma_block_header_decode(&decoded_block, NULL, out),
 447                         LZMA_OK);
 448         compare_blocks(&block, &decoded_block);
 449
 450         RESET_BLOCK(decoded_block, out);
 451
 452         // Test with multiple filters
 453         block.filters = filters_four;
 454         assert_lzma_ret(lzma_block_header_size(&block), LZMA_OK);
 455         assert_lzma_ret(lzma_block_header_encode(&block, out), LZMA_OK);
 456         decoded_block.header_size = lzma_block_header_size_decode(out[0]);
 457         assert_lzma_ret(lzma_block_header_decode(&decoded_block, NULL, out),
 458                         LZMA_OK);
 459         compare_blocks(&block, &decoded_block);
 460
 461         lzma_filters_free(decoded_filters, NULL);
 462
 463         // Test with too high version. The decoder will set it to a version
 464         // that it supports.
 465         decoded_block.version = 2;
 466         assert_lzma_ret(lzma_block_header_decode(&decoded_block, NULL, out),
 467                         LZMA_OK);
 468         assert_uint_eq(decoded_block.version, 1);
 469
 470         // Free the filters for the last time since all other cases should
 471         // result in an error.
 472         lzma_filters_free(decoded_filters, NULL);
 473
 474         // Test bad check type
 475         decoded_block.check = INVALID_LZMA_CHECK_ID;
 476         assert_lzma_ret(lzma_block_header_decode(&decoded_block, NULL, out),
 477                         LZMA_PROG_ERROR);
 478         decoded_block.check = LZMA_CHECK_CRC32;
 479
 480         // Test bad check value
 481         out[decoded_block.header_size - 1] -= 10;
 482         assert_lzma_ret(lzma_block_header_decode(&decoded_block, NULL, out),
 483                         LZMA_DATA_ERROR);
 484         out[decoded_block.header_size - 1] += 10;
 485
 486         // Test non-NULL padding
 487         out[decoded_block.header_size - 5] = 1;
 488
 489         // Recompute CRC32
 490         write32le(&out[decoded_block.header_size - 4], lzma_crc32(out,
 491                         decoded_block.header_size - 4, 0));
 492         assert_lzma_ret(lzma_block_header_decode(&decoded_block, NULL, out),
 493                         LZMA_OPTIONS_ERROR);
 494
 495         // Test unsupported flags
 496         out[1] = 0xFF;
 497
 498         // Recompute CRC32
 499         write32le(&out[decoded_block.header_size - 4], lzma_crc32(out,
 500                         decoded_block.header_size - 4, 0));
 501         assert_lzma_ret(lzma_block_header_decode(&decoded_block, NULL, out),
 502                         LZMA_OPTIONS_ERROR);
 503 #endif
 504 }
 505
 506
 507 extern int
 508 main(int argc, char **argv)
 509 {
 510         tuktest_start(argc, argv);
 511
 512         if (lzma_lzma_preset(&opt_lzma, 1))
 513                 tuktest_error("lzma_lzma_preset() failed");
 514
 515         tuktest_run(test_lzma_block_header_size);
 516         tuktest_run(test_lzma_block_header_encode);
 517         tuktest_run(test_lzma_block_header_decode);
 518
 519         return tuktest_end();
 520 }