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 }