tests/test_filter_str.c

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