1 ///////////////////////////////////////////////////////////////////////////////
3 /// \file test_block_header.c
4 /// \brief Tests Block Header coders
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 uint8_t buffer[4096];
24 static lzma_stream strm = LZMA_STREAM_INIT;
25 static lzma_options_block known_options;
26 static lzma_options_block decoded_options;
28 // We want to test zero, one, and two filters in the chain.
30 static const lzma_options_filter filters_none[1] = {
32 .id = LZMA_VLI_VALUE_UNKNOWN,
37 static const lzma_options_filter filters_powerpc[2] = {
39 .id = LZMA_FILTER_POWERPC,
42 .id = LZMA_VLI_VALUE_UNKNOWN,
47 static const lzma_options_delta options_delta = {
51 static const lzma_options_filter filters_delta[3] = {
53 .id = LZMA_FILTER_DELTA,
54 .options = (void *)(&options_delta),
56 .id = LZMA_FILTER_COPY,
59 .id = LZMA_VLI_VALUE_UNKNOWN,
66 encode(uint32_t header_size)
68 memcrap(buffer, sizeof(buffer));
70 if (lzma_block_header_size(&known_options) != LZMA_OK)
73 if (known_options.header_size != header_size)
76 if (lzma_block_header_encode(buffer, &known_options) != LZMA_OK)
84 decode_ret(uint32_t header_size, lzma_ret ret_ok)
86 memcrap(&decoded_options, sizeof(decoded_options));
87 decoded_options.has_crc32 = known_options.has_crc32;
89 expect(lzma_block_header_decoder(&strm, &decoded_options) == LZMA_OK);
91 return decoder_loop_ret(&strm, buffer, header_size, ret_ok);
96 decode(uint32_t header_size)
98 memcrap(&decoded_options, sizeof(decoded_options));
99 decoded_options.has_crc32 = known_options.has_crc32;
101 expect(lzma_block_header_decoder(&strm, &decoded_options) == LZMA_OK);
103 if (decoder_loop(&strm, buffer, header_size))
106 if (known_options.has_eopm != decoded_options.has_eopm)
109 if (known_options.is_metadata != decoded_options.is_metadata)
112 if (known_options.compressed_size == LZMA_VLI_VALUE_UNKNOWN
113 && known_options.compressed_reserve != 0) {
114 if (decoded_options.compressed_size != 0)
116 } else if (known_options.compressed_size
117 != decoded_options.compressed_size) {
121 if (known_options.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN
122 && known_options.uncompressed_reserve != 0) {
123 if (decoded_options.uncompressed_size != 0)
125 } else if (known_options.uncompressed_size
126 != decoded_options.uncompressed_size) {
130 if (known_options.compressed_reserve != 0
131 && known_options.compressed_reserve
132 != decoded_options.compressed_reserve)
135 if (known_options.uncompressed_reserve != 0
136 && known_options.uncompressed_reserve
137 != decoded_options.uncompressed_reserve)
140 if (known_options.padding != decoded_options.padding)
148 code(uint32_t header_size)
150 return encode(header_size) || decode(header_size);
155 helper_loop(uint32_t unpadded_size, uint32_t multiple)
157 for (int i = 0; i <= LZMA_BLOCK_HEADER_PADDING_MAX; ++i) {
158 known_options.padding = i;
159 if (code(unpadded_size + i))
163 for (int i = 0 - LZMA_BLOCK_HEADER_PADDING_MAX - 1;
164 i <= LZMA_BLOCK_HEADER_PADDING_MAX + 1; ++i) {
165 known_options.alignment = i;
167 uint32_t size = unpadded_size;
168 while ((size + known_options.alignment) % multiple)
171 known_options.padding = LZMA_BLOCK_HEADER_PADDING_AUTO;
175 } while (++known_options.alignment
176 <= LZMA_BLOCK_HEADER_PADDING_MAX + 1);
183 helper(uint32_t unpadded_size, uint32_t multiple)
185 known_options.has_crc32 = false;
186 known_options.is_metadata = false;
187 if (helper_loop(unpadded_size, multiple))
190 known_options.has_crc32 = false;
191 known_options.is_metadata = true;
192 if (helper_loop(unpadded_size, multiple))
195 known_options.has_crc32 = true;
196 known_options.is_metadata = false;
197 if (helper_loop(unpadded_size + 4, multiple))
200 known_options.has_crc32 = true;
201 known_options.is_metadata = true;
202 if (helper_loop(unpadded_size + 4, multiple))
212 known_options = (lzma_options_block){
214 .compressed_size = LZMA_VLI_VALUE_UNKNOWN,
215 .uncompressed_size = LZMA_VLI_VALUE_UNKNOWN,
216 .compressed_reserve = 0,
217 .uncompressed_reserve = 0,
219 memcpy(known_options.filters, filters_none, sizeof(filters_none));
220 expect(!helper(2, 1));
222 memcpy(known_options.filters, filters_powerpc,
223 sizeof(filters_powerpc));
224 expect(!helper(3, 4));
226 memcpy(known_options.filters, filters_delta, sizeof(filters_delta));
227 expect(!helper(5, 1));
229 known_options.padding = LZMA_BLOCK_HEADER_PADDING_MAX + 1;
230 expect(lzma_block_header_size(&known_options) == LZMA_PROG_ERROR);
235 test2_helper(uint32_t unpadded_size, uint32_t multiple)
237 known_options.has_eopm = true;
238 known_options.compressed_size = LZMA_VLI_VALUE_UNKNOWN;
239 known_options.uncompressed_size = LZMA_VLI_VALUE_UNKNOWN;
240 known_options.compressed_reserve = 1;
241 known_options.uncompressed_reserve = 1;
242 expect(!helper(unpadded_size + 2, multiple));
244 known_options.compressed_reserve = LZMA_VLI_BYTES_MAX;
245 known_options.uncompressed_reserve = LZMA_VLI_BYTES_MAX;
246 expect(!helper(unpadded_size + 18, multiple));
248 known_options.compressed_size = 1234;
249 known_options.uncompressed_size = 2345;
250 expect(!helper(unpadded_size + 18, multiple));
252 known_options.compressed_reserve = 1;
253 known_options.uncompressed_reserve = 1;
254 expect(lzma_block_header_size(&known_options) == LZMA_PROG_ERROR);
261 memcpy(known_options.filters, filters_none, sizeof(filters_none));
264 memcpy(known_options.filters, filters_powerpc,
265 sizeof(filters_powerpc));
268 memcpy(known_options.filters, filters_delta,
269 sizeof(filters_delta));
277 known_options = (lzma_options_block){
280 .is_metadata = false,
281 .compressed_size = LZMA_VLI_VALUE_UNKNOWN,
282 .uncompressed_size = LZMA_VLI_VALUE_UNKNOWN,
283 .compressed_reserve = 1,
284 .uncompressed_reserve = 1,
286 memcpy(known_options.filters, filters_none, sizeof(filters_none));
288 known_options.header_size = 3;
289 expect(lzma_block_header_encode(buffer, &known_options)
292 known_options.header_size = 4;
293 expect(lzma_block_header_encode(buffer, &known_options) == LZMA_OK);
295 known_options.header_size = 5;
296 expect(lzma_block_header_encode(buffer, &known_options)
299 // NOTE: This assumes that Filter ID 0x1F is not supported. Update
300 // this test to use some other ID if 0x1F becomes supported.
301 known_options.filters[0].id = 0x1F;
302 known_options.header_size = 5;
303 expect(lzma_block_header_encode(buffer, &known_options)
304 == LZMA_HEADER_ERROR);
311 known_options = (lzma_options_block){
314 .is_metadata = false,
315 .compressed_size = 0,
316 .uncompressed_size = 0,
317 .compressed_reserve = LZMA_VLI_BYTES_MAX,
318 .uncompressed_reserve = LZMA_VLI_BYTES_MAX,
321 memcpy(known_options.filters, filters_powerpc,
322 sizeof(filters_powerpc));
327 expect(!decode_ret(1, LZMA_HEADER_ERROR));
331 expect(decode_ret(21, LZMA_HEADER_ERROR));