1 ///////////////////////////////////////////////////////////////////////////////
4 /// \brief Tests functions handling the lzma_info structure
6 // Copyright (C) 2007 Lasse Collin
8 // This library is free software; you can redistribute it and/or
9 // modify it under the terms of the GNU Lesser General Public
10 // License as published by the Free Software Foundation; either
11 // version 2.1 of the License, or (at your option) any later version.
13 // This library is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 // Lesser General Public License for more details.
18 ///////////////////////////////////////////////////////////////////////////////
23 static lzma_info *info = NULL;
24 static lzma_info_iter iter;
26 static lzma_vli stream_start = 0;
27 static lzma_vli header_metadata_size = LZMA_VLI_VALUE_UNKNOWN;
28 static lzma_vli total_size = LZMA_VLI_VALUE_UNKNOWN;
29 static lzma_vli uncompressed_size = LZMA_VLI_VALUE_UNKNOWN;
30 static lzma_vli footer_metadata_size = LZMA_VLI_VALUE_UNKNOWN;
32 static lzma_index my_index[3] = {
33 { 22, 33, my_index + 1 },
34 { 44, 55, my_index + 2 },
38 static lzma_metadata my_metadata = {
39 .header_metadata_size = 11,
40 .total_size = 22 + 44 + 66,
41 .uncompressed_size = 33 + 55 + 77,
50 expect(lzma_info_init(info, NULL) == info);
52 header_metadata_size = LZMA_VLI_VALUE_UNKNOWN;
53 total_size = LZMA_VLI_VALUE_UNKNOWN;
54 uncompressed_size = LZMA_VLI_VALUE_UNKNOWN;
55 footer_metadata_size = LZMA_VLI_VALUE_UNKNOWN;
62 expect(lzma_info_size_get(info, LZMA_INFO_STREAM_START)
64 expect(lzma_info_size_get(info, LZMA_INFO_HEADER_METADATA)
65 == header_metadata_size);
66 expect(lzma_info_size_get(info, LZMA_INFO_TOTAL) == total_size);
67 expect(lzma_info_size_get(info, LZMA_INFO_UNCOMPRESSED)
68 == uncompressed_size);
69 expect(lzma_info_size_get(info, LZMA_INFO_FOOTER_METADATA)
70 == footer_metadata_size);
78 expect(lzma_info_size_set(info, LZMA_INFO_STREAM_START,
79 stream_start = 1234) == LZMA_OK);
81 expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA,
82 header_metadata_size = 2345) == LZMA_OK);
84 expect(lzma_info_size_set(info, LZMA_INFO_TOTAL, total_size = 3456)
87 expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED,
88 uncompressed_size = 4567) == LZMA_OK);
90 expect(lzma_info_size_set(info, LZMA_INFO_FOOTER_METADATA,
91 footer_metadata_size = 5432) == LZMA_OK);
94 // Not everything allow zero size
96 expect(lzma_info_size_set(info, LZMA_INFO_STREAM_START,
97 stream_start = 0) == LZMA_OK);
98 expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA,
99 header_metadata_size = 0) == LZMA_OK);
100 expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED,
101 uncompressed_size = 0) == LZMA_OK);
105 expect(lzma_info_size_set(info, LZMA_INFO_TOTAL, 0)
109 expect(lzma_info_size_set(info, LZMA_INFO_FOOTER_METADATA, 0)
114 expect(lzma_info_size_set(info, LZMA_INFO_STREAM_START,
115 LZMA_VLI_VALUE_MAX + 1) == LZMA_PROG_ERROR);
117 expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA,
118 LZMA_VLI_VALUE_MAX + 1) == LZMA_PROG_ERROR);
120 expect(lzma_info_size_set(info, LZMA_INFO_TOTAL,
121 LZMA_VLI_VALUE_MAX + 1) == LZMA_PROG_ERROR);
123 expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED,
124 LZMA_VLI_VALUE_MAX + 1) == LZMA_PROG_ERROR);
126 expect(lzma_info_size_set(info, LZMA_INFO_FOOTER_METADATA,
127 LZMA_VLI_VALUE_MAX + 1) == LZMA_PROG_ERROR);
134 test2_helper(lzma_vli *num, lzma_info_size type)
136 expect(lzma_info_size_set(info, type, *num = 1234) == LZMA_OK);
138 const bool ret = lzma_info_size_set(info, type, 4321) != LZMA_OK;
147 // Excluding start offset of Stream, once a size has been set,
148 // trying to set some other known value fails.
149 expect(!test2_helper(&stream_start, LZMA_INFO_STREAM_START));
150 expect(test2_helper(&header_metadata_size, LZMA_INFO_HEADER_METADATA));
151 expect(test2_helper(&total_size, LZMA_INFO_TOTAL));
152 expect(test2_helper(&uncompressed_size, LZMA_INFO_UNCOMPRESSED));
153 expect(test2_helper(&footer_metadata_size, LZMA_INFO_FOOTER_METADATA));
161 lzma_info_iter_begin(info, &iter);
162 expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
169 // Setting the same sizes multiple times for the same Index Record
170 // is OK, but the values must always be the same.
172 expect(lzma_info_index_count_get(info) == 1);
173 expect(lzma_info_iter_set(&iter, 1234, 2345) == LZMA_OK);
174 expect(lzma_info_index_count_get(info) == 1);
175 expect(lzma_info_iter_set(&iter, 1234, 2345) == LZMA_OK);
176 expect(lzma_info_index_count_get(info) == 1);
177 expect(lzma_info_iter_set(&iter, 1111, 2345) == LZMA_DATA_ERROR);
179 // Cannot finish an empty Index.
181 expect(lzma_info_index_finish(info) == LZMA_DATA_ERROR);
184 expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
185 expect(lzma_info_index_count_get(info) == 2);
186 expect(lzma_info_iter_set(&iter, 1234, 2345) == LZMA_OK);
187 expect(lzma_info_index_count_get(info) == 2);
188 expect(lzma_info_index_finish(info) == LZMA_DATA_ERROR);
191 expect(lzma_info_iter_set(&iter, 1234, 2345) == LZMA_OK);
192 expect(lzma_info_index_count_get(info) == 1);
193 expect(lzma_info_index_finish(info) == LZMA_OK);
194 expect(lzma_info_size_set(info, LZMA_INFO_TOTAL, 1234) == LZMA_OK);
195 expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED, 2345)
197 expect(lzma_info_size_set(info, LZMA_INFO_TOTAL, 1111)
201 expect(lzma_info_iter_set(&iter, 1234, 2345) == LZMA_OK);
202 expect(lzma_info_index_count_get(info) == 1);
203 expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
204 expect(lzma_info_index_count_get(info) == 2);
205 expect(lzma_info_iter_set(&iter, 4321, 5432) == LZMA_OK);
206 expect(lzma_info_index_count_get(info) == 2);
207 expect(lzma_info_index_finish(info) == LZMA_OK);
208 expect(lzma_info_size_set(info, LZMA_INFO_TOTAL, 1234 + 4321)
210 expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED, 2345 + 5432)
212 expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED, 1111)
216 expect(lzma_info_size_set(info, LZMA_INFO_TOTAL, 1234 + 4321)
218 expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED, 2345 + 5432)
220 expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED, 1111)
222 expect(lzma_info_iter_set(&iter, 1234, 2345) == LZMA_OK);
223 expect(lzma_info_index_count_get(info) == 1);
224 expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
225 expect(lzma_info_index_count_get(info) == 2);
226 expect(lzma_info_iter_set(&iter, 4321, 5432) == LZMA_OK);
227 expect(lzma_info_index_count_get(info) == 2);
228 expect(lzma_info_index_finish(info) == LZMA_OK);
231 expect(lzma_info_size_set(info, LZMA_INFO_TOTAL, 1000) == LZMA_OK);
232 expect(lzma_info_iter_set(&iter, 1001, 2001) == LZMA_DATA_ERROR);
235 expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED, 2000)
237 expect(lzma_info_iter_set(&iter, 1001, 2001) == LZMA_DATA_ERROR);
247 lzma_info_iter_begin(info, &iter);
248 expect(lzma_info_index_count_get(info) == 0);
250 expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
251 expect(iter.total_size == LZMA_VLI_VALUE_UNKNOWN);
252 expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
253 expect(iter.stream_offset == LZMA_VLI_VALUE_UNKNOWN);
254 expect(iter.uncompressed_offset == 0);
255 expect(lzma_info_index_count_get(info) == 1);
257 expect(lzma_info_iter_set(&iter, 22, 33) == LZMA_OK);
258 expect(iter.total_size == 22);
259 expect(iter.uncompressed_size == 33);
260 expect(iter.stream_offset == LZMA_VLI_VALUE_UNKNOWN);
261 expect(iter.uncompressed_offset == 0);
262 expect(lzma_info_index_count_get(info) == 1);
264 expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
265 expect(iter.total_size == LZMA_VLI_VALUE_UNKNOWN);
266 expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
267 expect(iter.stream_offset == LZMA_VLI_VALUE_UNKNOWN);
268 expect(iter.uncompressed_offset == 33);
272 lzma_info_iter_begin(info, &iter);
273 expect(lzma_info_index_count_get(info) == 0);
274 expect(lzma_info_size_set(info, LZMA_INFO_STREAM_START, 5) == LZMA_OK);
275 expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA, 11)
278 expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
279 expect(iter.total_size == LZMA_VLI_VALUE_UNKNOWN);
280 expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
281 expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11);
282 expect(iter.uncompressed_offset == 0);
283 expect(lzma_info_index_count_get(info) == 1);
285 expect(lzma_info_iter_set(&iter, 22, 33) == LZMA_OK);
286 expect(iter.total_size == 22);
287 expect(iter.uncompressed_size == 33);
288 expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11);
289 expect(iter.uncompressed_offset == 0);
290 expect(lzma_info_index_count_get(info) == 1);
292 expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
293 expect(iter.total_size == LZMA_VLI_VALUE_UNKNOWN);
294 expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
295 expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11 + 22);
296 expect(iter.uncompressed_offset == 33);
297 expect(lzma_info_index_count_get(info) == 2);
299 expect(lzma_info_iter_set(&iter, 44, 55) == LZMA_OK);
300 expect(iter.total_size == 44);
301 expect(iter.uncompressed_size == 55);
302 expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11 + 22);
303 expect(iter.uncompressed_offset == 33);
304 expect(lzma_info_index_count_get(info) == 2);
306 expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
307 expect(iter.total_size == LZMA_VLI_VALUE_UNKNOWN);
308 expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
309 expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
311 expect(iter.uncompressed_offset == 33 + 55);
312 expect(lzma_info_index_count_get(info) == 3);
314 expect(lzma_info_iter_set(&iter, 66, 77) == LZMA_OK);
315 expect(iter.total_size == 66);
316 expect(iter.uncompressed_size == 77);
317 expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
319 expect(iter.uncompressed_offset == 33 + 55);
320 expect(lzma_info_index_count_get(info) == 3);
322 expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
323 expect(iter.total_size == LZMA_VLI_VALUE_UNKNOWN);
324 expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
325 expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
326 + 11 + 22 + 44 + 66);
327 expect(iter.uncompressed_offset == 33 + 55 + 77);
328 expect(lzma_info_index_count_get(info) == 4);
330 expect(lzma_info_iter_set(&iter, 88, 99) == LZMA_OK);
331 expect(iter.total_size == 88);
332 expect(iter.uncompressed_size == 99);
333 expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
334 + 11 + 22 + 44 + 66);
335 expect(iter.uncompressed_offset == 33 + 55 + 77);
336 expect(lzma_info_index_count_get(info) == 4);
338 // 4c (continues from 4b)
339 lzma_info_iter_begin(info, &iter);
340 expect(lzma_info_index_count_get(info) == 4);
342 expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
343 expect(iter.total_size == 22);
344 expect(iter.uncompressed_size == 33);
345 expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11);
346 expect(iter.uncompressed_offset == 0);
347 expect(lzma_info_index_count_get(info) == 4);
349 expect(lzma_info_iter_set(&iter, 22, LZMA_VLI_VALUE_UNKNOWN)
351 expect(iter.total_size == 22);
352 expect(iter.uncompressed_size == 33);
353 expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11);
354 expect(iter.uncompressed_offset == 0);
355 expect(lzma_info_index_count_get(info) == 4);
357 expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
358 expect(iter.total_size == 44);
359 expect(iter.uncompressed_size == 55);
360 expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11 + 22);
361 expect(iter.uncompressed_offset == 33);
362 expect(lzma_info_index_count_get(info) == 4);
364 expect(lzma_info_iter_set(&iter, LZMA_VLI_VALUE_UNKNOWN, 55)
366 expect(iter.total_size == 44);
367 expect(iter.uncompressed_size == 55);
368 expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11 + 22);
369 expect(iter.uncompressed_offset == 33);
370 expect(lzma_info_index_count_get(info) == 4);
372 expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
373 expect(iter.total_size == 66);
374 expect(iter.uncompressed_size == 77);
375 expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
377 expect(iter.uncompressed_offset == 33 + 55);
378 expect(lzma_info_index_count_get(info) == 4);
380 expect(lzma_info_iter_set(&iter, LZMA_VLI_VALUE_UNKNOWN,
381 LZMA_VLI_VALUE_UNKNOWN) == LZMA_OK);
382 expect(iter.total_size == 66);
383 expect(iter.uncompressed_size == 77);
384 expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
386 expect(iter.uncompressed_offset == 33 + 55);
387 expect(lzma_info_index_count_get(info) == 4);
389 expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
390 expect(iter.total_size == 88);
391 expect(iter.uncompressed_size == 99);
392 expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
393 + 11 + 22 + 44 + 66);
394 expect(iter.uncompressed_offset == 33 + 55 + 77);
395 expect(lzma_info_index_count_get(info) == 4);
397 expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
398 expect(iter.total_size == LZMA_VLI_VALUE_UNKNOWN);
399 expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
400 expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
401 + 11 + 22 + 44 + 66 + 88);
402 expect(iter.uncompressed_offset == 33 + 55 + 77 + 99);
403 expect(lzma_info_index_count_get(info) == 5);
405 expect(lzma_info_iter_set(&iter, 1234, LZMA_VLI_VALUE_UNKNOWN)
407 expect(iter.total_size == 1234);
408 expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
409 expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
410 + 11 + 22 + 44 + 66 + 88);
411 expect(iter.uncompressed_offset == 33 + 55 + 77 + 99);
412 expect(lzma_info_index_count_get(info) == 5);
414 // Test 4d (continues from 4c)
415 lzma_info_iter_begin(info, &iter);
416 for (size_t i = 0; i < 4; ++i)
417 expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
418 expect(lzma_info_iter_set(&iter, 88, 99) == LZMA_OK);
419 expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
420 expect(iter.total_size == 1234);
421 expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
422 expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
423 + 11 + 22 + 44 + 66 + 88);
424 expect(iter.uncompressed_offset == 33 + 55 + 77 + 99);
425 expect(lzma_info_index_count_get(info) == 5);
427 expect(lzma_info_iter_set(&iter, LZMA_VLI_VALUE_UNKNOWN, 4321)
429 expect(iter.total_size == 1234);
430 expect(iter.uncompressed_size == 4321);
431 expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
432 + 11 + 22 + 44 + 66 + 88);
433 expect(iter.uncompressed_offset == 33 + 55 + 77 + 99);
434 expect(lzma_info_index_count_get(info) == 5);
436 expect(lzma_info_index_finish(info) == LZMA_OK);
437 expect(lzma_info_index_count_get(info) == 5);
439 // Test 4e (continues from 4d)
440 lzma_info_iter_begin(info, &iter);
441 for (size_t i = 0; i < 5; ++i)
442 expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
443 expect(lzma_info_iter_set(&iter, 1234, 4321) == LZMA_OK);
444 expect(lzma_info_iter_next(&iter, NULL) == LZMA_DATA_ERROR);
455 expect(lzma_info_index_set(info, NULL, NULL, true)
459 expect(lzma_info_index_set(info, NULL, my_index, false) == LZMA_OK);
460 i = lzma_index_dup(my_index, NULL);
462 i->next->uncompressed_size = 99;
463 expect(lzma_info_index_set(info, NULL, i, true) == LZMA_DATA_ERROR);
466 expect(lzma_info_index_set(info, NULL, my_index, false) == LZMA_OK);
467 i = lzma_index_dup(my_index, NULL);
469 lzma_index_free(i->next->next, NULL);
470 i->next->next = NULL;
471 expect(lzma_info_index_set(info, NULL, i, true) == LZMA_DATA_ERROR);
474 expect(lzma_info_index_set(info, NULL, my_index, false) == LZMA_OK);
475 i = lzma_index_dup(my_index, NULL);
477 lzma_index_free(i->next->next, NULL);
478 i->next->next = lzma_index_dup(my_index, NULL);
479 expect(i->next->next != NULL);
480 expect(lzma_info_index_set(info, NULL, i, true) == LZMA_DATA_ERROR);
483 expect(lzma_info_size_set(info, LZMA_INFO_TOTAL,
484 total_size = 22 + 44 + 66) == LZMA_OK);
485 expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED,
486 uncompressed_size = 33 + 55 + 77) == LZMA_OK);
488 expect(lzma_info_index_set(info, NULL, my_index, false) == LZMA_OK);
492 expect(lzma_info_size_set(info, LZMA_INFO_TOTAL, total_size = 77)
494 expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED,
495 uncompressed_size = 33 + 55 + 77) == LZMA_OK);
497 expect(lzma_info_index_set(info, NULL, my_index, false)
501 expect(lzma_info_size_set(info, LZMA_INFO_TOTAL,
502 total_size = 22 + 44 + 66) == LZMA_OK);
503 expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED,
504 uncompressed_size = 777777) == LZMA_OK);
506 expect(lzma_info_index_set(info, NULL, my_index, false)
516 lzma_metadata metadata;
518 // Same complete Metadata in both Header and Footer
519 expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA,
520 my_metadata.header_metadata_size) == LZMA_OK);
521 expect(lzma_info_metadata_set(info, NULL, &my_metadata, true, false)
523 expect(lzma_info_metadata_set(info, NULL, &my_metadata, false, false)
526 // Header Metadata is not present but Size of Header Metadata is
527 // still present in Footer.
529 metadata = my_metadata;
530 metadata.header_metadata_size = 0;
531 expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA, 0)
533 expect(lzma_info_metadata_set(info, NULL, &metadata, true, false)
535 expect(lzma_info_metadata_set(info, NULL, &my_metadata, false, false)
538 // Header Metadata is present but Size of Header Metadata is missing
541 metadata = my_metadata;
542 metadata.header_metadata_size = 0;
543 expect(lzma_info_metadata_set(info, NULL, &my_metadata, true, false)
545 expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA,
546 my_metadata.header_metadata_size) == LZMA_OK);
547 expect(lzma_info_metadata_set(info, NULL, &metadata, false, false)
552 metadata = my_metadata;
553 metadata.index = NULL;
554 expect(lzma_info_metadata_set(info, NULL, &metadata, true, false)
556 expect(lzma_info_metadata_set(info, NULL, &metadata, false, false)
559 // Index in Header Metadata but not in Footer Metadata
561 expect(lzma_info_metadata_set(info, NULL, &my_metadata, true, false)
563 expect(lzma_info_metadata_set(info, NULL, &metadata, false, false)
566 // Index in Header Metadata but not in Footer Metadata but
567 // Total Size is missing from Footer.
569 metadata.total_size = LZMA_VLI_VALUE_UNKNOWN;
570 expect(lzma_info_metadata_set(info, NULL, &my_metadata, true, false)
572 expect(lzma_info_metadata_set(info, NULL, &metadata, false, false)
575 // Total Size doesn't match the Index
577 metadata = my_metadata;
578 metadata.total_size = 9999;
579 expect(lzma_info_metadata_set(info, NULL, &metadata, true, false)
582 // Uncompressed Size doesn't match the Index
584 metadata = my_metadata;
585 metadata.uncompressed_size = 9999;
586 expect(lzma_info_metadata_set(info, NULL, &metadata, true, false)
596 // No info yet, so we cannot locate anything.
597 expect(lzma_info_metadata_locate(info, true)
598 == LZMA_VLI_VALUE_UNKNOWN);
599 expect(lzma_info_metadata_locate(info, false)
600 == LZMA_VLI_VALUE_UNKNOWN);
602 // Setting the Stream start offset doesn't change this situation.
603 expect(lzma_info_size_set(info, LZMA_INFO_STREAM_START, 5) == LZMA_OK);
604 expect(lzma_info_metadata_locate(info, true)
605 == LZMA_VLI_VALUE_UNKNOWN);
606 expect(lzma_info_metadata_locate(info, false)
607 == LZMA_VLI_VALUE_UNKNOWN);
609 // Setting the Size of Header Metadata known allows us to locate
610 // the Header Metadata Block.
611 expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA, 11)
613 expect(lzma_info_metadata_locate(info, true)
614 == 5 + LZMA_STREAM_HEADER_SIZE);
615 expect(lzma_info_metadata_locate(info, false)
616 == LZMA_VLI_VALUE_UNKNOWN);
618 // Adding a Data Block. As long as Index is not Finished, we cannot
619 // locate Footer Metadata Block.
620 lzma_info_iter_begin(info, &iter);
621 expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
622 expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11);
623 expect(iter.uncompressed_offset == 0);
624 expect(lzma_info_iter_set(&iter, 22, 33) == LZMA_OK);
625 expect(lzma_info_metadata_locate(info, true)
626 == 5 + LZMA_STREAM_HEADER_SIZE);
627 expect(lzma_info_metadata_locate(info, false)
628 == LZMA_VLI_VALUE_UNKNOWN);
630 // Once the Index is finished, we can locate Footer Metadata Block too.
631 expect(lzma_info_index_finish(info) == LZMA_OK);
632 expect(lzma_info_metadata_locate(info, true)
633 == 5 + LZMA_STREAM_HEADER_SIZE);
634 expect(lzma_info_metadata_locate(info, false)
635 == 5 + LZMA_STREAM_HEADER_SIZE + 11 + 22);
637 // A retry of most of the above but now with unknown Size of Header
638 // Metadata Block, which makes locating Footer Metadata Block
641 expect(lzma_info_size_set(info, LZMA_INFO_STREAM_START, 5) == LZMA_OK);
642 expect(lzma_info_metadata_locate(info, true)
643 == LZMA_VLI_VALUE_UNKNOWN);
644 expect(lzma_info_metadata_locate(info, false)
645 == LZMA_VLI_VALUE_UNKNOWN);
647 expect(lzma_info_index_set(info, NULL, my_index, false) == LZMA_OK);
648 expect(lzma_info_metadata_locate(info, true)
649 == LZMA_VLI_VALUE_UNKNOWN);
650 expect(lzma_info_metadata_locate(info, false)
651 == LZMA_VLI_VALUE_UNKNOWN);
653 expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA, 11)
655 expect(lzma_info_metadata_locate(info, true)
656 == 5 + LZMA_STREAM_HEADER_SIZE);
657 expect(lzma_info_metadata_locate(info, false)
658 == LZMA_STREAM_HEADER_SIZE + 5 + 11 + 22 + 44 + 66);
667 expect(lzma_info_size_set(info, LZMA_INFO_STREAM_START, 5) == LZMA_OK);
668 expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA, 11)
671 lzma_info_iter_begin(info, &iter);
672 expect(lzma_info_iter_locate(&iter, NULL, 0, false)
674 expect(lzma_info_index_count_get(info) == 0);
676 lzma_info_iter_begin(info, &iter);
677 expect(lzma_info_iter_locate(&iter, NULL, 0, true) == LZMA_OK);
678 expect(lzma_info_index_count_get(info) == 1);
679 expect(lzma_info_iter_locate(&iter, NULL, 0, false) == LZMA_OK);
680 expect(lzma_info_index_count_get(info) == 1);
690 // TODO Various integer overflow checks
700 info = lzma_info_init(NULL, NULL);
715 lzma_info_free(info, NULL);