tests/test_filter_str.c

   1 ///////////////////////////////////////////////////////////////////////////////
   2 //
   3 /// \file       test_filter_str.c
   4 /// \brief      Tests Filter string functions
   5 //
   6 //  Author:    Jia Tan
   7 //
   8 //  This file has been put into the public domain.
   9 //  You can do whatever you want with this file.
  10 //
  11 ///////////////////////////////////////////////////////////////////////////////
  12
  13 #include "tests.h"
  14
  15
  16 static void
  17 test_lzma_str_to_filters(void)
  18 {
  19         lzma_filter filters[LZMA_FILTERS_MAX + 1];
  20         int error_pos;
  21
  22         // Test with NULL string.
  23         assert_true(lzma_str_to_filters(NULL, &error_pos, filters, 0,
  24                         NULL) != NULL);
  25
  26         // Test with NULL filter array.
  27         assert_true(lzma_str_to_filters("lzma2", &error_pos, NULL, 0,
  28                         NULL) != NULL);
  29
  30         // Test with unsupported flags.
  31         assert_true(lzma_str_to_filters("lzma2", &error_pos, filters,
  32                         UINT32_MAX, NULL) != NULL);
  33
  34         assert_true(lzma_str_to_filters("lzma2", &error_pos, filters,
  35                         LZMA_STR_NO_SPACES << 1, NULL) != NULL);
  36
  37         assert_true(lzma_str_to_filters("lzma2", &error_pos, filters,
  38                         LZMA_STR_NO_SPACES, NULL) != NULL);
  39
  40         // Test with empty string.
  41         assert_true(lzma_str_to_filters("", &error_pos,
  42                         filters, 0, NULL) != NULL);
  43         assert_int_eq(error_pos, 0);
  44
  45         // Test with invalid filter name and missing filter name.
  46         assert_true(lzma_str_to_filters("lzma2 abcd", &error_pos,
  47                         filters, 0, NULL) != NULL);
  48         assert_int_eq(error_pos, 6);
  49
  50         assert_true(lzma_str_to_filters("lzma2--abcd", &error_pos,
  51                         filters, 0, NULL) != NULL);
  52         assert_int_eq(error_pos, 7);
  53
  54         assert_true(lzma_str_to_filters("lzma2--", &error_pos,
  55                         filters, 0, NULL) != NULL);
  56         assert_int_eq(error_pos, 7);
  57
  58         // Test LZMA_STR_ALL_FILTERS flag (should work with LZMA1 if built).
  59 #if defined(HAVE_ENCODER_LZMA1) || defined(HAVE_DECODER_LZMA1)
  60         // Using LZMA1 as a Filter should fail without LZMA_STR_ALL_FILTERS.
  61         assert_true(lzma_str_to_filters("lzma1", &error_pos, filters,
  62                         0, NULL) != NULL);
  63         assert_int_eq(error_pos, 0);
  64
  65         assert_true(lzma_str_to_filters("lzma1", &error_pos, filters,
  66                         LZMA_STR_ALL_FILTERS, NULL) == NULL);
  67
  68         // Verify Filters array IDs are correct. The array should contain
  69         // only two elements:
  70         // 1. LZMA1 Filter
  71         // 2. LZMA_VLI_UNKNOWN filter array terminator
  72         assert_uint_eq(filters[0].id, LZMA_FILTER_LZMA1);
  73         assert_uint_eq(filters[1].id, LZMA_VLI_UNKNOWN);
  74
  75         lzma_filters_free(filters, NULL);
  76 #endif
  77
  78         // Test LZMA_STR_NO_VALIDATION flag. This should allow having the
  79         // same Filter multiple times in the chain and having a non-last
  80         // Filter like lzma2 appear before another Filter.
  81         // Without the flag, "lzma2 lzma2" must fail.
  82         assert_true(lzma_str_to_filters("lzma2 lzma2", &error_pos, filters,
  83                         0, NULL) != NULL);
  84
  85         assert_true(lzma_str_to_filters("lzma2 lzma2", &error_pos, filters,
  86                         LZMA_STR_NO_VALIDATION, NULL) == NULL);
  87
  88         assert_uint_eq(filters[0].id, LZMA_FILTER_LZMA2);
  89         assert_uint_eq(filters[1].id, LZMA_FILTER_LZMA2);
  90         assert_uint_eq(filters[2].id, LZMA_VLI_UNKNOWN);
  91
  92         lzma_filters_free(filters, NULL);
  93
  94         // Should fail with invalid Filter options (lc + lp must be <= 4).
  95         assert_true(lzma_str_to_filters("lzma2:lc=3,lp=3", &error_pos, filters,
  96                         LZMA_STR_NO_VALIDATION, NULL) != NULL);
  97
  98         // Test invalid option name.
  99         assert_true(lzma_str_to_filters("lzma2:foo=1,bar=2", &error_pos,
 100                         filters, 0, NULL) != NULL);
 101         assert_int_eq(error_pos, 6);
 102
 103         // Test missing option value.
 104         assert_true(lzma_str_to_filters("lzma2:lc=", &error_pos,
 105                         filters, 0, NULL) != NULL);
 106         assert_int_eq(error_pos, 9);
 107
 108         assert_true(lzma_str_to_filters("lzma2:=,pb=1", &error_pos,
 109                         filters, 0, NULL) != NULL);
 110         assert_int_eq(error_pos, 6);
 111
 112         // Test unsupported preset value.
 113         assert_true(lzma_str_to_filters("-10", &error_pos,
 114                         filters, 0, NULL) != NULL);
 115         assert_int_eq(error_pos, 2);
 116
 117         assert_true(lzma_str_to_filters("-5f", &error_pos,
 118                         filters, 0, NULL) != NULL);
 119         assert_int_eq(error_pos, 2);
 120
 121         // Test filter chain too long.
 122         assert_true(lzma_str_to_filters("lzma2 lzma2 lzma2 lzma2 lzma2",
 123                         &error_pos, filters, LZMA_STR_NO_VALIDATION,
 124                         NULL) != NULL);
 125         assert_int_eq(error_pos, 24);
 126
 127 #if defined(HAVE_ENCODER_LZMA1) || defined(HAVE_DECODER_LZMA1)
 128         // Should fail with a Filter not supported in the .xz format (lzma1).
 129         assert_true(lzma_str_to_filters("lzma1", &error_pos, filters,
 130                         LZMA_STR_NO_VALIDATION, NULL) != NULL);
 131 #endif
 132
 133         // Test setting options with the "=" format.
 134         assert_true(lzma_str_to_filters("lzma2=dict=4096,lc=2,lp=2,pb=1,"
 135                         "mode=fast,nice=3,mf=hc3,depth=10", &error_pos,
 136                         filters, 0, NULL) == NULL);
 137         assert_uint_eq(filters[0].id, LZMA_FILTER_LZMA2);
 138         assert_uint_eq(filters[1].id, LZMA_VLI_UNKNOWN);
 139
 140         lzma_options_lzma *opts = filters[0].options;
 141         assert_uint_eq(opts->dict_size, 4096);
 142         assert_uint_eq(opts->lc, 2);
 143         assert_uint_eq(opts->lp, 2);
 144         assert_uint_eq(opts->pb, 1);
 145         assert_uint_eq(opts->mode, LZMA_MODE_FAST);
 146         assert_uint_eq(opts->nice_len, 3);
 147         assert_uint_eq(opts->mf, LZMA_MF_HC3);
 148         assert_uint_eq(opts->depth, 10);
 149
 150         lzma_filters_free(filters, NULL);
 151
 152 #if defined(HAVE_ENCODER_X86) || defined(HAVE_DECODER_X86)
 153         // Test BCJ Filter options.
 154         assert_true(lzma_str_to_filters("x86:start=16", &error_pos, filters,
 155                         LZMA_STR_NO_VALIDATION, NULL) == NULL);
 156
 157         assert_uint_eq(filters[0].id, LZMA_FILTER_X86);
 158         assert_uint_eq(filters[1].id, LZMA_VLI_UNKNOWN);
 159
 160         lzma_options_bcj *bcj_opts = filters[0].options;
 161         assert_uint_eq(bcj_opts->start_offset, 16);
 162
 163         lzma_filters_free(filters, NULL);
 164 #endif
 165
 166 #if defined(HAVE_ENCODER_DELTA) || defined(HAVE_DECODER_DELTA)
 167         // Test Delta Filter options.
 168         assert_true(lzma_str_to_filters("delta:dist=20", &error_pos, filters,
 169                         LZMA_STR_NO_VALIDATION, NULL) == NULL);
 170
 171         assert_uint_eq(filters[0].id, LZMA_FILTER_DELTA);
 172         assert_uint_eq(filters[1].id, LZMA_VLI_UNKNOWN);
 173
 174         lzma_options_delta *delta_opts = filters[0].options;
 175         assert_uint_eq(delta_opts->dist, 20);
 176
 177         lzma_filters_free(filters, NULL);
 178 #endif
 179
 180         // Test skipping leading spaces.
 181         assert_true(lzma_str_to_filters("    lzma2", &error_pos, filters,
 182                         0, NULL) == NULL);
 183
 184         assert_uint_eq(filters[0].id, LZMA_FILTER_LZMA2);
 185         assert_uint_eq(filters[1].id, LZMA_VLI_UNKNOWN);
 186
 187         lzma_filters_free(filters, NULL);
 188
 189         // Test skipping trailing spaces.
 190         assert_true(lzma_str_to_filters("lzma2    ", &error_pos, filters,
 191                         0, NULL) == NULL);
 192
 193         assert_uint_eq(filters[0].id, LZMA_FILTER_LZMA2);
 194         assert_uint_eq(filters[1].id, LZMA_VLI_UNKNOWN);
 195
 196         lzma_filters_free(filters, NULL);
 197
 198         // Test with "--" instead of space separating.
 199         assert_true(lzma_str_to_filters("lzma2--lzma2", &error_pos, filters,
 200                         LZMA_STR_NO_VALIDATION, NULL) == NULL);
 201
 202         assert_uint_eq(filters[0].id, LZMA_FILTER_LZMA2);
 203         assert_uint_eq(filters[1].id, LZMA_FILTER_LZMA2);
 204         assert_uint_eq(filters[2].id, LZMA_VLI_UNKNOWN);
 205
 206         lzma_filters_free(filters, NULL);
 207
 208         // Test preset with and without leading "-", and with "e".
 209         assert_true(lzma_str_to_filters("-3", &error_pos, filters,
 210                         0, NULL) == NULL);
 211
 212         assert_uint_eq(filters[0].id, LZMA_FILTER_LZMA2);
 213         assert_uint_eq(filters[1].id, LZMA_VLI_UNKNOWN);
 214
 215         lzma_filters_free(filters, NULL);
 216
 217         assert_true(lzma_str_to_filters("4", &error_pos, filters,
 218                         0, NULL) == NULL);
 219
 220         assert_uint_eq(filters[0].id, LZMA_FILTER_LZMA2);
 221         assert_uint_eq(filters[1].id, LZMA_VLI_UNKNOWN);
 222
 223         lzma_filters_free(filters, NULL);
 224
 225         assert_true(lzma_str_to_filters("9e", &error_pos, filters,
 226                         0, NULL) == NULL);
 227
 228         assert_uint_eq(filters[0].id, LZMA_FILTER_LZMA2);
 229         assert_uint_eq(filters[1].id, LZMA_VLI_UNKNOWN);
 230
 231         lzma_filters_free(filters, NULL);
 232
 233         // Test using a preset as an lzma2 option.
 234         assert_true(lzma_str_to_filters("lzma2:preset=9e", &error_pos, filters,
 235                         0, NULL) == NULL);
 236
 237         assert_uint_eq(filters[0].id, LZMA_FILTER_LZMA2);
 238         assert_uint_eq(filters[1].id, LZMA_VLI_UNKNOWN);
 239
 240         lzma_filters_free(filters, NULL);
 241
 242         // Test setting dictionary size with invalid modifier suffix.
 243         assert_true(lzma_str_to_filters("lzma2:dict=4096ZiB", &error_pos, filters,
 244                         0, NULL) != NULL);
 245
 246         assert_true(lzma_str_to_filters("lzma2:dict=4096KiBs", &error_pos, filters,
 247                         0, NULL) != NULL);
 248
 249         // Test option that cannot have multiplier modifier.
 250         assert_true(lzma_str_to_filters("lzma2:pb=1k", &error_pos, filters,
 251                         0, NULL) != NULL);
 252
 253         // Test option value too large.
 254         assert_true(lzma_str_to_filters("lzma2:dict=4096GiB", &error_pos, filters,
 255                         0, NULL) != NULL);
 256
 257         // Test valid uses of multiplier modifiers (k,m,g).
 258         assert_true(lzma_str_to_filters("lzma2:dict=4096KiB", &error_pos, filters,
 259                         0, NULL) == NULL);
 260
 261         assert_uint_eq(filters[0].id, LZMA_FILTER_LZMA2);
 262         assert_uint_eq(filters[1].id, LZMA_VLI_UNKNOWN);
 263
 264         opts = filters[0].options;
 265         assert_uint_eq(opts->dict_size, 4096 << 10);
 266
 267         lzma_filters_free(filters, NULL);
 268
 269         assert_true(lzma_str_to_filters("lzma2:dict=40Mi", &error_pos, filters,
 270                         0, NULL) == NULL);
 271
 272         assert_uint_eq(filters[0].id, LZMA_FILTER_LZMA2);
 273         assert_uint_eq(filters[1].id, LZMA_VLI_UNKNOWN);
 274
 275         opts = filters[0].options;
 276         assert_uint_eq(opts->dict_size, 40 << 20);
 277
 278         lzma_filters_free(filters, NULL);
 279
 280         assert_true(lzma_str_to_filters("lzma2:dict=1g", &error_pos, filters,
 281                         0, NULL) == NULL);
 282
 283         assert_uint_eq(filters[0].id, LZMA_FILTER_LZMA2);
 284         assert_uint_eq(filters[1].id, LZMA_VLI_UNKNOWN);
 285
 286         opts = filters[0].options;
 287         assert_uint_eq(opts->dict_size, 1 << 30);
 288
 289         lzma_filters_free(filters, NULL);
 290 }
 291
 292
 293 static void
 294 test_lzma_str_from_filters(void)
 295 {
 296         lzma_filter filters[LZMA_FILTERS_MAX];
 297         filters[0].id = LZMA_VLI_UNKNOWN;
 298
 299         char *output_str = NULL;
 300
 301         // Test basic NULL inputs.
 302         assert_lzma_ret(lzma_str_from_filters(NULL, filters, 0, NULL),
 303                         LZMA_PROG_ERROR);
 304
 305         assert_lzma_ret(lzma_str_from_filters(&output_str, NULL, 0, NULL),
 306                         LZMA_PROG_ERROR);
 307
 308         // Test with empty filters array.
 309         assert_lzma_ret(lzma_str_from_filters(&output_str, filters, 0, NULL),
 310                         LZMA_OPTIONS_ERROR);
 311
 312         // Create a simple filter array only containing an LZMA2 Filter.
 313         assert_true(lzma_str_to_filters("lzma2", NULL, filters, 0, NULL)
 314                         == NULL);
 315
 316         // Test with bad flags.
 317         assert_lzma_ret(lzma_str_from_filters(&output_str, filters,
 318                         LZMA_STR_ALL_FILTERS, NULL), LZMA_OPTIONS_ERROR);
 319
 320         assert_lzma_ret(lzma_str_from_filters(&output_str, filters,
 321                         LZMA_STR_NO_VALIDATION, NULL), LZMA_OPTIONS_ERROR);
 322
 323         // Test with no flags.
 324         assert_lzma_ret(lzma_str_from_filters(&output_str, filters, 0, NULL),
 325                         LZMA_OK);
 326
 327         assert_str_eq(output_str, "lzma2");
 328         free(output_str);
 329
 330         // Test LZMA_STR_ENCODER flag.
 331         // Only the the return value is checked since the actual string
 332         // may change in the future (even though it is unlikely).
 333         // The order of options or the inclusion of new options could
 334         // cause a change in output, so we will avoid hardcoding an
 335         // expected result.
 336         assert_lzma_ret(lzma_str_from_filters(&output_str, filters,
 337                         LZMA_STR_ENCODER, NULL), LZMA_OK);
 338         free(output_str);
 339
 340         // Test LZMA_STR_DECODER flag.
 341         assert_lzma_ret(lzma_str_from_filters(&output_str, filters,
 342                         LZMA_STR_DECODER, NULL), LZMA_OK);
 343         free(output_str);
 344
 345         // Test LZMA_STR_GETOPT_LONG flag.
 346         assert_lzma_ret(lzma_str_from_filters(&output_str, filters,
 347                         LZMA_STR_GETOPT_LONG, NULL), LZMA_OK);
 348         free(output_str);
 349
 350         // Test LZMA_STR_NO_SPACES flag.
 351         assert_lzma_ret(lzma_str_from_filters(&output_str, filters,
 352                         LZMA_STR_NO_SPACES, NULL), LZMA_OK);
 353
 354         // Check to be sure there are no spaces.
 355         assert_true(strchr(output_str, ' ') == NULL);
 356
 357         free(output_str);
 358
 359         lzma_filters_free(filters, NULL);
 360
 361 #if defined(HAVE_ENCODER_X86) || defined(HAVE_DECODER_X86)
 362         assert_true(lzma_str_to_filters("x86 lzma2", NULL, filters, 0, NULL)
 363                         == NULL);
 364
 365         assert_lzma_ret(lzma_str_from_filters(&output_str, filters, 0, NULL),
 366                         LZMA_OK);
 367
 368         assert_str_eq(output_str, "x86 lzma2");
 369
 370         free(output_str);
 371
 372         // Test setting BCJ option to NULL.
 373         assert_false(filters[0].options == NULL);
 374         free(filters[0].options);
 375
 376         filters[0].options = NULL;
 377
 378         assert_lzma_ret(lzma_str_from_filters(&output_str, filters, 0, NULL),
 379                         LZMA_OK);
 380
 381         assert_str_eq(output_str, "x86 lzma2");
 382
 383         lzma_filters_free(filters, NULL);
 384         free(output_str);
 385 #endif
 386
 387         lzma_options_lzma opts;
 388         assert_false(lzma_lzma_preset(&opts, LZMA_PRESET_DEFAULT));
 389         // Test with too many Filters (array terminated after 4+ filters).
 390         lzma_filter oversized_filters[LZMA_FILTERS_MAX + 2];
 391
 392         for (uint32_t i = 0; i < ARRAY_SIZE(oversized_filters) - 1; i++) {
 393                 oversized_filters[i].id = LZMA_FILTER_LZMA2;
 394                 oversized_filters[i].options = &opts;
 395         }
 396
 397         oversized_filters[LZMA_FILTERS_MAX + 1].id = LZMA_VLI_UNKNOWN;
 398         oversized_filters[LZMA_FILTERS_MAX + 1].options = NULL;
 399
 400         assert_lzma_ret(lzma_str_from_filters(&output_str, oversized_filters,
 401                         0, NULL), LZMA_OPTIONS_ERROR);
 402
 403         // Test with NULL filter options (when they cannot be NULL).
 404         filters[0].id = LZMA_FILTER_LZMA2;
 405         filters[0].options = NULL;
 406         filters[1].id = LZMA_VLI_UNKNOWN;
 407
 408         assert_lzma_ret(lzma_str_from_filters(&output_str, filters,
 409                         LZMA_STR_ENCODER, NULL), LZMA_OPTIONS_ERROR);
 410
 411         // Test with bad Filter ID.
 412         filters[0].id = LZMA_VLI_UNKNOWN - 1;
 413         assert_lzma_ret(lzma_str_from_filters(&output_str, filters,
 414                         LZMA_STR_ENCODER, NULL), LZMA_OPTIONS_ERROR);
 415 }
 416
 417
 418 static const char supported_encoders[][9] = {
 419         "lzma2",
 420 #ifdef HAVE_ENCODER_X86
 421         "x86",
 422 #endif
 423 #ifdef HAVE_ENCODER_POWERPC
 424         "powerpc",
 425 #endif
 426 #ifdef HAVE_ENCODER_IA64
 427         "ia64",
 428 #endif
 429 #ifdef HAVE_ENCODER_ARM
 430         "arm",
 431 #endif
 432 #ifdef HAVE_ENCODER_ARMTHUMB
 433         "armthumb",
 434 #endif
 435 #ifdef HAVE_ENCODER_SPARC
 436         "sparc",
 437 #endif
 438 #ifdef HAVE_ENCODER_ARM64
 439         "arm64",
 440 #endif
 441 #ifdef HAVE_ENCODER_DELTA
 442         "delta",
 443 #endif
 444 };
 445
 446 static const char supported_decoders[][9] = {
 447         "lzma2",
 448 #ifdef HAVE_DECODER_X86
 449         "x86",
 450 #endif
 451 #ifdef HAVE_DECODER_POWERPC
 452         "powerpc",
 453 #endif
 454 #ifdef HAVE_DECODER_IA64
 455         "ia64",
 456 #endif
 457 #ifdef HAVE_DECODER_ARM
 458         "arm",
 459 #endif
 460 #ifdef HAVE_DECODER_ARMTHUMB
 461         "armthumb",
 462 #endif
 463 #ifdef HAVE_DECODER_SPARC
 464         "sparc",
 465 #endif
 466 #ifdef HAVE_DECODER_ARM64
 467         "arm64",
 468 #endif
 469 #ifdef HAVE_DECODER_DELTA
 470         "delta",
 471 #endif
 472 };
 473
 474 static const char supported_filters[][9] = {
 475         "lzma2",
 476 #if defined(HAVE_ENCODER_X86) || defined(HAVE_DECODER_X86)
 477         "x86",
 478 #endif
 479 #if defined(HAVE_ENCODER_POWERPC) || defined(HAVE_DECODER_POWERPC)
 480         "powerpc",
 481 #endif
 482 #if defined(HAVE_ENCODER_IA64) || defined(HAVE_DECODER_IA64)
 483         "ia64",
 484 #endif
 485 #if defined(HAVE_ENCODER_ARM) || defined(HAVE_DECODER_ARM)
 486         "arm",
 487 #endif
 488 #if defined(HAVE_ENCODER_ARMTHUMB) || defined(HAVE_DECODER_ARMTHUMB)
 489         "armthumb",
 490 #endif
 491 #if defined(HAVE_ENCODER_SPARC) || defined(HAVE_DECODER_SPARC)
 492         "sparc",
 493 #endif
 494 #if defined(HAVE_ENCODER_ARM64) || defined(HAVE_DECODER_ARM64)
 495         "arm64",
 496 #endif
 497 #if defined(HAVE_ENCODER_DELTA) || defined(HAVE_DECODER_DELTA)
 498         "delta",
 499 #endif
 500 };
 501
 502
 503 static void
 504 test_lzma_str_list_filters(void)
 505 {
 506         // Test with basic NULL inputs.
 507         assert_lzma_ret(lzma_str_list_filters(NULL, LZMA_VLI_UNKNOWN, 0,
 508                         NULL), LZMA_PROG_ERROR);
 509
 510         char *str = NULL;
 511
 512         // Test with bad flags.
 513         assert_lzma_ret(lzma_str_list_filters(&str, LZMA_VLI_UNKNOWN,
 514                         LZMA_STR_NO_VALIDATION , NULL), LZMA_OPTIONS_ERROR);
 515
 516         assert_lzma_ret(lzma_str_list_filters(&str, LZMA_VLI_UNKNOWN,
 517                         LZMA_STR_NO_SPACES, NULL), LZMA_OPTIONS_ERROR);
 518
 519         // Test with bad Filter ID.
 520         assert_lzma_ret(lzma_str_list_filters(&str, LZMA_VLI_UNKNOWN - 1,
 521                         0, NULL), LZMA_OPTIONS_ERROR);
 522
 523         // Test LZMA_STR_ENCODER flag.
 524         assert_lzma_ret(lzma_str_list_filters(&str, LZMA_VLI_UNKNOWN,
 525                         LZMA_STR_ENCODER, NULL), LZMA_OK);
 526
 527         for (uint32_t i = 0; i < ARRAY_SIZE(supported_encoders); i++)
 528                 assert_str_contains(str, supported_encoders[i]);
 529
 530         free(str);
 531
 532         // Test LZMA_STR_DECODER flag.
 533         assert_lzma_ret(lzma_str_list_filters(&str, LZMA_VLI_UNKNOWN,
 534                         LZMA_STR_DECODER, NULL), LZMA_OK);
 535
 536         for (uint32_t i = 0; i < ARRAY_SIZE(supported_decoders); i++)
 537                 assert_str_contains(str, supported_decoders[i]);
 538
 539         free(str);
 540
 541         // Test LZMA_STR_GETOPT_LONG flag.
 542         assert_lzma_ret(lzma_str_list_filters(&str, LZMA_VLI_UNKNOWN,
 543                         LZMA_STR_GETOPT_LONG, NULL), LZMA_OK);
 544
 545         free(str);
 546
 547         // Test LZMA_STR_ALL_FILTERS flag.
 548         assert_lzma_ret(lzma_str_list_filters(&str, LZMA_VLI_UNKNOWN,
 549                         LZMA_STR_ALL_FILTERS, NULL), LZMA_OK);
 550 #if defined(HAVE_ENCODER_LZMA1) || defined(HAVE_DECODER_LZMA1)
 551         // With the flag, the string should contain the LZMA1 Filter.
 552         assert_str_contains(str, "lzma1");
 553
 554         free(str);
 555
 556         // If a non .xz filter is specified, it should still list the Filter.
 557         assert_lzma_ret(lzma_str_list_filters(&str, LZMA_FILTER_LZMA1,
 558                         0, NULL), LZMA_OK);
 559         assert_str_eq(str, "lzma1");
 560 #endif
 561         free(str);
 562
 563         // Test with no flags.
 564         assert_lzma_ret(lzma_str_list_filters(&str, LZMA_VLI_UNKNOWN,
 565                         0, NULL), LZMA_OK);
 566
 567         for (uint32_t i = 0; i < ARRAY_SIZE(supported_filters); i++)
 568                 assert_str_contains(str, supported_filters[i]);
 569
 570         assert_str_doesnt_contain(str, "lzma1");
 571
 572         free(str);
 573
 574         // Test providing a Filter ID.
 575         assert_lzma_ret(lzma_str_list_filters(&str, LZMA_FILTER_LZMA2,
 576                         LZMA_STR_ALL_FILTERS, NULL), LZMA_OK);
 577         assert_str_eq(str, "lzma2");
 578
 579         free(str);
 580 }
 581
 582
 583 extern int
 584 main(int argc, char **argv)
 585 {
 586         tuktest_start(argc, argv);
 587
 588         tuktest_run(test_lzma_str_to_filters);
 589         tuktest_run(test_lzma_str_from_filters);
 590         tuktest_run(test_lzma_str_list_filters);
 591
 592         return tuktest_end();
 593 }