revi-archive/xz-archive
1
0
Fork 0
mirror of https://git.tukaani.org/xz.git synced 2024-04-04 12:36:23 +02:00
Code Activity
xz-archive/tests/test_info.c
Lasse Collin 99e12af4e2 Fix Size of Header Metadata Block handling. Now 
lzma_metadata.header_metadata_size == LZMA_VLI_VALUE_UNKNOWN
is not allowed at all. To indicate missing Header Metadata
Block, header_metadata_size must be set to zero. This is
what Metadata decoder does after this patch too.

Note that other missing fields in lzma_metadata are still
indicated with LZMA_VLI_VALUE_UNKNOWN. This isn't as
illogical as it sounds at first, because missing Size of
Header Metadata Block means that Header Metadata Block is
not present in the Stream. With other Metadata fields,
a missing field means only that the value is unknown.
2008-01-23 13:36:07 +02:00

717 lines
23 KiB
C
Raw Blame History

///////////////////////////////////////////////////////////////////////////////
//
/// \file test_info.c
/// \brief Tests functions handling the lzma_info structure
//
// Copyright (C) 2007 Lasse Collin
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
///////////////////////////////////////////////////////////////////////////////
#include "tests.h"
static lzma_info *info = NULL;
static lzma_info_iter iter;
static lzma_vli stream_start = 0;
static lzma_vli header_metadata_size = LZMA_VLI_VALUE_UNKNOWN;
static lzma_vli total_size = LZMA_VLI_VALUE_UNKNOWN;
static lzma_vli uncompressed_size = LZMA_VLI_VALUE_UNKNOWN;
static lzma_vli footer_metadata_size = LZMA_VLI_VALUE_UNKNOWN;
static lzma_index my_index[3] = {
{ 22, 33, my_index + 1 },
{ 44, 55, my_index + 2 },
{ 66, 77, NULL },
};
static lzma_metadata my_metadata = {
.header_metadata_size = 11,
.total_size = 22 + 44 + 66,
.uncompressed_size = 33 + 55 + 77,
.index = my_index,
.extra = NULL,
};
static void
reset(void)
{
expect(lzma_info_init(info, NULL) == info);
stream_start = 0;
header_metadata_size = LZMA_VLI_VALUE_UNKNOWN;
total_size = LZMA_VLI_VALUE_UNKNOWN;
uncompressed_size = LZMA_VLI_VALUE_UNKNOWN;
footer_metadata_size = LZMA_VLI_VALUE_UNKNOWN;
}
static void
validate(void)
{
expect(lzma_info_size_get(info, LZMA_INFO_STREAM_START)
== stream_start);
expect(lzma_info_size_get(info, LZMA_INFO_HEADER_METADATA)
== header_metadata_size);
expect(lzma_info_size_get(info, LZMA_INFO_TOTAL) == total_size);
expect(lzma_info_size_get(info, LZMA_INFO_UNCOMPRESSED)
== uncompressed_size);
expect(lzma_info_size_get(info, LZMA_INFO_FOOTER_METADATA)
== footer_metadata_size);
}
static void
test1(void)
{
// Basics
expect(lzma_info_size_set(info, LZMA_INFO_STREAM_START,
stream_start = 1234) == LZMA_OK);
validate();
expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA,
header_metadata_size = 2345) == LZMA_OK);
validate();
expect(lzma_info_size_set(info, LZMA_INFO_TOTAL, total_size = 3456)
== LZMA_OK);
validate();
expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED,
uncompressed_size = 4567) == LZMA_OK);
validate();
expect(lzma_info_size_set(info, LZMA_INFO_FOOTER_METADATA,
footer_metadata_size = 5432) == LZMA_OK);
validate();
// Not everything allow zero size
reset();
expect(lzma_info_size_set(info, LZMA_INFO_STREAM_START,
stream_start = 0) == LZMA_OK);
expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA,
header_metadata_size = 0) == LZMA_OK);
expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED,
uncompressed_size = 0) == LZMA_OK);
validate();
reset();
expect(lzma_info_size_set(info, LZMA_INFO_TOTAL, 0)
== LZMA_PROG_ERROR);
reset();
expect(lzma_info_size_set(info, LZMA_INFO_FOOTER_METADATA, 0)
== LZMA_PROG_ERROR);
// Invalid sizes
reset();
expect(lzma_info_size_set(info, LZMA_INFO_STREAM_START,
LZMA_VLI_VALUE_MAX + 1) == LZMA_PROG_ERROR);
reset();
expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA,
LZMA_VLI_VALUE_MAX + 1) == LZMA_PROG_ERROR);
reset();
expect(lzma_info_size_set(info, LZMA_INFO_TOTAL,
LZMA_VLI_VALUE_MAX + 1) == LZMA_PROG_ERROR);
reset();
expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED,
LZMA_VLI_VALUE_MAX + 1) == LZMA_PROG_ERROR);
reset();
expect(lzma_info_size_set(info, LZMA_INFO_FOOTER_METADATA,
LZMA_VLI_VALUE_MAX + 1) == LZMA_PROG_ERROR);
reset();
}
static bool
test2_helper(lzma_vli *num, lzma_info_size type)
{
expect(lzma_info_size_set(info, type, *num = 1234) == LZMA_OK);
validate();
const bool ret = lzma_info_size_set(info, type, 4321) != LZMA_OK;
reset();
return ret;
}
static void
test2(void)
{
// Excluding start offset of Stream, once a size has been set,
// trying to set some other known value fails.
expect(!test2_helper(&stream_start, LZMA_INFO_STREAM_START));
expect(test2_helper(&header_metadata_size, LZMA_INFO_HEADER_METADATA));
expect(test2_helper(&total_size, LZMA_INFO_TOTAL));
expect(test2_helper(&uncompressed_size, LZMA_INFO_UNCOMPRESSED));
expect(test2_helper(&footer_metadata_size, LZMA_INFO_FOOTER_METADATA));
}
static void
test3_init(void)
{
reset();
lzma_info_iter_begin(info, &iter);
expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
}
static void
test3(void)
{
// Setting the same sizes multiple times for the same Index Record
// is OK, but the values must always be the same.
test3_init();
expect(lzma_info_index_count_get(info) == 1);
expect(lzma_info_iter_set(&iter, 1234, 2345) == LZMA_OK);
expect(lzma_info_index_count_get(info) == 1);
expect(lzma_info_iter_set(&iter, 1234, 2345) == LZMA_OK);
expect(lzma_info_index_count_get(info) == 1);
expect(lzma_info_iter_set(&iter, 1111, 2345) == LZMA_DATA_ERROR);
// Cannot finish an empty Index.
test3_init();
expect(lzma_info_index_finish(info) == LZMA_DATA_ERROR);
test3_init();
expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
expect(lzma_info_index_count_get(info) == 2);
expect(lzma_info_iter_set(&iter, 1234, 2345) == LZMA_OK);
expect(lzma_info_index_count_get(info) == 2);
expect(lzma_info_index_finish(info) == LZMA_DATA_ERROR);
test3_init();
expect(lzma_info_iter_set(&iter, 1234, 2345) == LZMA_OK);
expect(lzma_info_index_count_get(info) == 1);
expect(lzma_info_index_finish(info) == LZMA_OK);
expect(lzma_info_size_set(info, LZMA_INFO_TOTAL, 1234) == LZMA_OK);
expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED, 2345)
== LZMA_OK);
expect(lzma_info_size_set(info, LZMA_INFO_TOTAL, 1111)
== LZMA_DATA_ERROR);
test3_init();
expect(lzma_info_iter_set(&iter, 1234, 2345) == LZMA_OK);
expect(lzma_info_index_count_get(info) == 1);
expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
expect(lzma_info_index_count_get(info) == 2);
expect(lzma_info_iter_set(&iter, 4321, 5432) == LZMA_OK);
expect(lzma_info_index_count_get(info) == 2);
expect(lzma_info_index_finish(info) == LZMA_OK);
expect(lzma_info_size_set(info, LZMA_INFO_TOTAL, 1234 + 4321)
== LZMA_OK);
expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED, 2345 + 5432)
== LZMA_OK);
expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED, 1111)
== LZMA_DATA_ERROR);
test3_init();
expect(lzma_info_size_set(info, LZMA_INFO_TOTAL, 1234 + 4321)
== LZMA_OK);
expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED, 2345 + 5432)
== LZMA_OK);
expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED, 1111)
== LZMA_DATA_ERROR);
expect(lzma_info_iter_set(&iter, 1234, 2345) == LZMA_OK);
expect(lzma_info_index_count_get(info) == 1);
expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
expect(lzma_info_index_count_get(info) == 2);
expect(lzma_info_iter_set(&iter, 4321, 5432) == LZMA_OK);
expect(lzma_info_index_count_get(info) == 2);
expect(lzma_info_index_finish(info) == LZMA_OK);
test3_init();
expect(lzma_info_size_set(info, LZMA_INFO_TOTAL, 1000) == LZMA_OK);
expect(lzma_info_iter_set(&iter, 1001, 2001) == LZMA_DATA_ERROR);
test3_init();
expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED, 2000)
== LZMA_OK);
expect(lzma_info_iter_set(&iter, 1001, 2001) == LZMA_DATA_ERROR);
reset();
}
static void
test4(void)
{
// 4a
lzma_info_iter_begin(info, &iter);
expect(lzma_info_index_count_get(info) == 0);
expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
expect(iter.total_size == LZMA_VLI_VALUE_UNKNOWN);
expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
expect(iter.stream_offset == LZMA_VLI_VALUE_UNKNOWN);
expect(iter.uncompressed_offset == 0);
expect(lzma_info_index_count_get(info) == 1);
expect(lzma_info_iter_set(&iter, 22, 33) == LZMA_OK);
expect(iter.total_size == 22);
expect(iter.uncompressed_size == 33);
expect(iter.stream_offset == LZMA_VLI_VALUE_UNKNOWN);
expect(iter.uncompressed_offset == 0);
expect(lzma_info_index_count_get(info) == 1);
expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
expect(iter.total_size == LZMA_VLI_VALUE_UNKNOWN);
expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
expect(iter.stream_offset == LZMA_VLI_VALUE_UNKNOWN);
expect(iter.uncompressed_offset == 33);
// 4b
reset();
lzma_info_iter_begin(info, &iter);
expect(lzma_info_index_count_get(info) == 0);
expect(lzma_info_size_set(info, LZMA_INFO_STREAM_START, 5) == LZMA_OK);
expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA, 11)
== LZMA_OK);
expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
expect(iter.total_size == LZMA_VLI_VALUE_UNKNOWN);
expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11);
expect(iter.uncompressed_offset == 0);
expect(lzma_info_index_count_get(info) == 1);
expect(lzma_info_iter_set(&iter, 22, 33) == LZMA_OK);
expect(iter.total_size == 22);
expect(iter.uncompressed_size == 33);
expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11);
expect(iter.uncompressed_offset == 0);
expect(lzma_info_index_count_get(info) == 1);
expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
expect(iter.total_size == LZMA_VLI_VALUE_UNKNOWN);
expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11 + 22);
expect(iter.uncompressed_offset == 33);
expect(lzma_info_index_count_get(info) == 2);
expect(lzma_info_iter_set(&iter, 44, 55) == LZMA_OK);
expect(iter.total_size == 44);
expect(iter.uncompressed_size == 55);
expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11 + 22);
expect(iter.uncompressed_offset == 33);
expect(lzma_info_index_count_get(info) == 2);
expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
expect(iter.total_size == LZMA_VLI_VALUE_UNKNOWN);
expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
+ 11 + 22 + 44);
expect(iter.uncompressed_offset == 33 + 55);
expect(lzma_info_index_count_get(info) == 3);
expect(lzma_info_iter_set(&iter, 66, 77) == LZMA_OK);
expect(iter.total_size == 66);
expect(iter.uncompressed_size == 77);
expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
+ 11 + 22 + 44);
expect(iter.uncompressed_offset == 33 + 55);
expect(lzma_info_index_count_get(info) == 3);
expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
expect(iter.total_size == LZMA_VLI_VALUE_UNKNOWN);
expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
+ 11 + 22 + 44 + 66);
expect(iter.uncompressed_offset == 33 + 55 + 77);
expect(lzma_info_index_count_get(info) == 4);
expect(lzma_info_iter_set(&iter, 88, 99) == LZMA_OK);
expect(iter.total_size == 88);
expect(iter.uncompressed_size == 99);
expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
+ 11 + 22 + 44 + 66);
expect(iter.uncompressed_offset == 33 + 55 + 77);
expect(lzma_info_index_count_get(info) == 4);
// 4c (continues from 4b)
lzma_info_iter_begin(info, &iter);
expect(lzma_info_index_count_get(info) == 4);
expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
expect(iter.total_size == 22);
expect(iter.uncompressed_size == 33);
expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11);
expect(iter.uncompressed_offset == 0);
expect(lzma_info_index_count_get(info) == 4);
expect(lzma_info_iter_set(&iter, 22, LZMA_VLI_VALUE_UNKNOWN)
== LZMA_OK);
expect(iter.total_size == 22);
expect(iter.uncompressed_size == 33);
expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11);
expect(iter.uncompressed_offset == 0);
expect(lzma_info_index_count_get(info) == 4);
expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
expect(iter.total_size == 44);
expect(iter.uncompressed_size == 55);
expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11 + 22);
expect(iter.uncompressed_offset == 33);
expect(lzma_info_index_count_get(info) == 4);
expect(lzma_info_iter_set(&iter, LZMA_VLI_VALUE_UNKNOWN, 55)
== LZMA_OK);
expect(iter.total_size == 44);
expect(iter.uncompressed_size == 55);
expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11 + 22);
expect(iter.uncompressed_offset == 33);
expect(lzma_info_index_count_get(info) == 4);
expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
expect(iter.total_size == 66);
expect(iter.uncompressed_size == 77);
expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
+ 11 + 22 + 44);
expect(iter.uncompressed_offset == 33 + 55);
expect(lzma_info_index_count_get(info) == 4);
expect(lzma_info_iter_set(&iter, LZMA_VLI_VALUE_UNKNOWN,
LZMA_VLI_VALUE_UNKNOWN) == LZMA_OK);
expect(iter.total_size == 66);
expect(iter.uncompressed_size == 77);
expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
+ 11 + 22 + 44);
expect(iter.uncompressed_offset == 33 + 55);
expect(lzma_info_index_count_get(info) == 4);
expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
expect(iter.total_size == 88);
expect(iter.uncompressed_size == 99);
expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
+ 11 + 22 + 44 + 66);
expect(iter.uncompressed_offset == 33 + 55 + 77);
expect(lzma_info_index_count_get(info) == 4);
expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
expect(iter.total_size == LZMA_VLI_VALUE_UNKNOWN);
expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
+ 11 + 22 + 44 + 66 + 88);
expect(iter.uncompressed_offset == 33 + 55 + 77 + 99);
expect(lzma_info_index_count_get(info) == 5);
expect(lzma_info_iter_set(&iter, 1234, LZMA_VLI_VALUE_UNKNOWN)
== LZMA_OK);
expect(iter.total_size == 1234);
expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
+ 11 + 22 + 44 + 66 + 88);
expect(iter.uncompressed_offset == 33 + 55 + 77 + 99);
expect(lzma_info_index_count_get(info) == 5);
// Test 4d (continues from 4c)
lzma_info_iter_begin(info, &iter);
for (size_t i = 0; i < 4; ++i)
expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
expect(lzma_info_iter_set(&iter, 88, 99) == LZMA_OK);
expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
expect(iter.total_size == 1234);
expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
+ 11 + 22 + 44 + 66 + 88);
expect(iter.uncompressed_offset == 33 + 55 + 77 + 99);
expect(lzma_info_index_count_get(info) == 5);
expect(lzma_info_iter_set(&iter, LZMA_VLI_VALUE_UNKNOWN, 4321)
== LZMA_OK);
expect(iter.total_size == 1234);
expect(iter.uncompressed_size == 4321);
expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
+ 11 + 22 + 44 + 66 + 88);
expect(iter.uncompressed_offset == 33 + 55 + 77 + 99);
expect(lzma_info_index_count_get(info) == 5);
expect(lzma_info_index_finish(info) == LZMA_OK);
expect(lzma_info_index_count_get(info) == 5);
// Test 4e (continues from 4d)
lzma_info_iter_begin(info, &iter);
for (size_t i = 0; i < 5; ++i)
expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
expect(lzma_info_iter_set(&iter, 1234, 4321) == LZMA_OK);
expect(lzma_info_iter_next(&iter, NULL) == LZMA_DATA_ERROR);
reset();
}
static void
test5(void)
{
lzma_index *i;
expect(lzma_info_index_set(info, NULL, NULL, true)
== LZMA_PROG_ERROR);
reset();
expect(lzma_info_index_set(info, NULL, my_index, false) == LZMA_OK);
i = lzma_index_dup(my_index, NULL);
expect(i != NULL);
i->next->uncompressed_size = 99;
expect(lzma_info_index_set(info, NULL, i, true) == LZMA_DATA_ERROR);
reset();
expect(lzma_info_index_set(info, NULL, my_index, false) == LZMA_OK);
i = lzma_index_dup(my_index, NULL);
expect(i != NULL);
lzma_index_free(i->next->next, NULL);
i->next->next = NULL;
expect(lzma_info_index_set(info, NULL, i, true) == LZMA_DATA_ERROR);
reset();
expect(lzma_info_index_set(info, NULL, my_index, false) == LZMA_OK);
i = lzma_index_dup(my_index, NULL);
expect(i != NULL);
lzma_index_free(i->next->next, NULL);
i->next->next = lzma_index_dup(my_index, NULL);
expect(i->next->next != NULL);
expect(lzma_info_index_set(info, NULL, i, true) == LZMA_DATA_ERROR);
reset();
expect(lzma_info_size_set(info, LZMA_INFO_TOTAL,
total_size = 22 + 44 + 66) == LZMA_OK);
expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED,
uncompressed_size = 33 + 55 + 77) == LZMA_OK);
validate();
expect(lzma_info_index_set(info, NULL, my_index, false) == LZMA_OK);
validate();
reset();
expect(lzma_info_size_set(info, LZMA_INFO_TOTAL, total_size = 77)
== LZMA_OK);
expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED,
uncompressed_size = 33 + 55 + 77) == LZMA_OK);
validate();
expect(lzma_info_index_set(info, NULL, my_index, false)
== LZMA_DATA_ERROR);
reset();
expect(lzma_info_size_set(info, LZMA_INFO_TOTAL,
total_size = 22 + 44 + 66) == LZMA_OK);
expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED,
uncompressed_size = 777777) == LZMA_OK);
validate();
expect(lzma_info_index_set(info, NULL, my_index, false)
== LZMA_DATA_ERROR);
reset();
}
static void
test6(void)
{
lzma_metadata metadata;
// Same complete Metadata in both Header and Footer
expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA,
my_metadata.header_metadata_size) == LZMA_OK);
expect(lzma_info_metadata_set(info, NULL, &my_metadata, true, false)
== LZMA_OK);
expect(lzma_info_metadata_set(info, NULL, &my_metadata, false, false)
== LZMA_OK);
// Header Metadata is not present but Size of Header Metadata is
// still present in Footer.
reset();
metadata = my_metadata;
metadata.header_metadata_size = 0;
expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA, 0)
== LZMA_OK);
expect(lzma_info_metadata_set(info, NULL, &metadata, true, false)
== LZMA_OK);
expect(lzma_info_metadata_set(info, NULL, &my_metadata, false, false)
== LZMA_DATA_ERROR);
// Header Metadata is present but Size of Header Metadata is missing
// from Footer.
reset();
metadata = my_metadata;
metadata.header_metadata_size = 0;
expect(lzma_info_metadata_set(info, NULL, &my_metadata, true, false)
== LZMA_OK);
expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA,
my_metadata.header_metadata_size) == LZMA_OK);
expect(lzma_info_metadata_set(info, NULL, &metadata, false, false)
== LZMA_DATA_ERROR);
// Index missing
reset();
metadata = my_metadata;
metadata.index = NULL;
expect(lzma_info_metadata_set(info, NULL, &metadata, true, false)
== LZMA_OK);
expect(lzma_info_metadata_set(info, NULL, &metadata, false, false)
== LZMA_DATA_ERROR);
// Index in Header Metadata but not in Footer Metadata
reset();
expect(lzma_info_metadata_set(info, NULL, &my_metadata, true, false)
== LZMA_OK);
expect(lzma_info_metadata_set(info, NULL, &metadata, false, false)
== LZMA_OK);
// Index in Header Metadata but not in Footer Metadata but
// Total Size is missing from Footer.
reset();
metadata.total_size = LZMA_VLI_VALUE_UNKNOWN;
expect(lzma_info_metadata_set(info, NULL, &my_metadata, true, false)
== LZMA_OK);
expect(lzma_info_metadata_set(info, NULL, &metadata, false, false)
== LZMA_DATA_ERROR);
// Total Size doesn't match the Index
reset();
metadata = my_metadata;
metadata.total_size = 9999;
expect(lzma_info_metadata_set(info, NULL, &metadata, true, false)
== LZMA_DATA_ERROR);
// Uncompressed Size doesn't match the Index
reset();
metadata = my_metadata;
metadata.uncompressed_size = 9999;
expect(lzma_info_metadata_set(info, NULL, &metadata, true, false)
== LZMA_DATA_ERROR);
reset();
}
static void
test7(void)
{
// No info yet, so we cannot locate anything.
expect(lzma_info_metadata_locate(info, true)
== LZMA_VLI_VALUE_UNKNOWN);
expect(lzma_info_metadata_locate(info, false)
== LZMA_VLI_VALUE_UNKNOWN);
// Setting the Stream start offset doesn't change this situation.
expect(lzma_info_size_set(info, LZMA_INFO_STREAM_START, 5) == LZMA_OK);
expect(lzma_info_metadata_locate(info, true)
== LZMA_VLI_VALUE_UNKNOWN);
expect(lzma_info_metadata_locate(info, false)
== LZMA_VLI_VALUE_UNKNOWN);
// Setting the Size of Header Metadata known allows us to locate
// the Header Metadata Block.
expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA, 11)
== LZMA_OK);
expect(lzma_info_metadata_locate(info, true)
== 5 + LZMA_STREAM_HEADER_SIZE);
expect(lzma_info_metadata_locate(info, false)
== LZMA_VLI_VALUE_UNKNOWN);
// Adding a Data Block. As long as Index is not Finished, we cannot
// locate Footer Metadata Block.
lzma_info_iter_begin(info, &iter);
expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11);
expect(iter.uncompressed_offset == 0);
expect(lzma_info_iter_set(&iter, 22, 33) == LZMA_OK);
expect(lzma_info_metadata_locate(info, true)
== 5 + LZMA_STREAM_HEADER_SIZE);
expect(lzma_info_metadata_locate(info, false)
== LZMA_VLI_VALUE_UNKNOWN);
// Once the Index is finished, we can locate Footer Metadata Block too.
expect(lzma_info_index_finish(info) == LZMA_OK);
expect(lzma_info_metadata_locate(info, true)
== 5 + LZMA_STREAM_HEADER_SIZE);
expect(lzma_info_metadata_locate(info, false)
== 5 + LZMA_STREAM_HEADER_SIZE + 11 + 22);
// A retry of most of the above but now with unknown Size of Header
// Metadata Block, which makes locating Footer Metadata Block
// impossible.
reset();
expect(lzma_info_size_set(info, LZMA_INFO_STREAM_START, 5) == LZMA_OK);
expect(lzma_info_metadata_locate(info, true)
== LZMA_VLI_VALUE_UNKNOWN);
expect(lzma_info_metadata_locate(info, false)
== LZMA_VLI_VALUE_UNKNOWN);
expect(lzma_info_index_set(info, NULL, my_index, false) == LZMA_OK);
expect(lzma_info_metadata_locate(info, true)
== LZMA_VLI_VALUE_UNKNOWN);
expect(lzma_info_metadata_locate(info, false)
== LZMA_VLI_VALUE_UNKNOWN);
expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA, 11)
== LZMA_OK);
expect(lzma_info_metadata_locate(info, true)
== 5 + LZMA_STREAM_HEADER_SIZE);
expect(lzma_info_metadata_locate(info, false)
== LZMA_STREAM_HEADER_SIZE + 5 + 11 + 22 + 44 + 66);
reset();
}
static void
test8(void)
{
expect(lzma_info_size_set(info, LZMA_INFO_STREAM_START, 5) == LZMA_OK);
expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA, 11)
== LZMA_OK);
lzma_info_iter_begin(info, &iter);
expect(lzma_info_iter_locate(&iter, NULL, 0, false)
== LZMA_DATA_ERROR);
expect(lzma_info_index_count_get(info) == 0);
lzma_info_iter_begin(info, &iter);
expect(lzma_info_iter_locate(&iter, NULL, 0, true) == LZMA_OK);
expect(lzma_info_index_count_get(info) == 1);
expect(lzma_info_iter_locate(&iter, NULL, 0, false) == LZMA_OK);
expect(lzma_info_index_count_get(info) == 1);
// TODO
}
/*
static void
test9(void)
{
// TODO Various integer overflow checks
}
*/
int
main(void)
{
lzma_init();
info = lzma_info_init(NULL, NULL);
if (info == NULL)
return 1;
validate();
test1();
test2();
test3();
test4();
test5();
test6();
test7();
test8();
lzma_info_free(info, NULL);
return 0;
}
View git blame Copy permalink