1 ///////////////////////////////////////////////////////////////////////////////
2 //
3 /// \file test_vli.c
4 /// \brief Tests liblzma vli 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 // Pre-encoded VLI values for testing
17 // VLI can have between 1 and 9 bytes when encoded
18 // They are encoded little endian where all but the last
19 // byte must have the leading 1 bit set
20 #if defined(HAVE_ENCODERS) || defined(HAVE_DECODERS)
21 static const uint8_t one_byte[1] = {0x25};
22 static const lzma_vli one_byte_value = 37;
23
24 static const uint8_t two_bytes[2] = {0x80, 0x56};
25 static const lzma_vli two_byte_value = 11008;
26
27 static const uint8_t three_bytes[3] = {0x99, 0x92, 0x20};
28 static const lzma_vli three_byte_value = 526617;
29
30 static const uint8_t four_bytes[4] = {0x97, 0x83, 0x94, 0x47};
31 static const lzma_vli four_byte_value = 149225879;
32
33 static const uint8_t five_bytes[5] = {0xA6, 0x92, 0x88, 0x89, 0x32};
34 static const lzma_vli five_byte_value = 13440780582;
35
36 static const uint8_t six_bytes[6] = {0xA9, 0x84, 0x99, 0x82, 0x94, 0x12};
37 static const lzma_vli six_byte_value = 623848604201;
38
39 static const uint8_t seven_bytes[7] = {0x90, 0x80, 0x90, 0x80, 0x90, 0x80,
40 0x79};
41 static const lzma_vli seven_byte_value = 532167923073040;
42
43 static const uint8_t eight_bytes[8] = {0x91, 0x87, 0xF2, 0xB2, 0xC2, 0xD2,
44 0x93, 0x63};
45 static const lzma_vli eight_byte_value = 55818443594433425;
46
47 static const uint8_t nine_bytes[9] = {0x81, 0x91, 0xA1, 0xB1, 0xC1, 0xD1,
48 0xE1, 0xF1, 0x1};
49 static const lzma_vli nine_byte_value = 136100349976529025;
50 #endif
51
52
53 static void
54 test_lzma_vli_size(void)
55 {
56 // First test invalid VLI values (should return 0)
57 // VLI UNKNOWN is an invalid VLI
58 assert_uint_eq(lzma_vli_size(LZMA_VLI_UNKNOWN), 0);
59 // Loop over a few VLI values just over the maximum
60 for (uint64_t i = LZMA_VLI_MAX + 1; i < LZMA_VLI_MAX + 10; i++)
61 assert_uint_eq(lzma_vli_size(i), 0);
62
63 // Number should increment every seven set bits
64 lzma_vli vli = 1;
65 for (uint32_t i = 1; i < LZMA_VLI_BYTES_MAX; i++, vli <<= 7) {
66 // Test the base value and a few others around it
67 assert_uint_eq(lzma_vli_size(vli), i);
68 assert_uint_eq(lzma_vli_size(vli * 2), i);
69 assert_uint_eq(lzma_vli_size(vli + 10), i);
70 assert_uint_eq(lzma_vli_size(vli * 3 + 39), i);
71 }
72 }
73
74
75 #ifdef HAVE_ENCODERS
76 // Helper function for test_lzma_vli_encode
77 // Encodes an input VLI and compares against a pre-computed value
78 static void
79 encode_single_call_mode(lzma_vli input, const uint8_t *expected,
80 uint32_t expected_len)
81 {
82 uint8_t out[LZMA_VLI_BYTES_MAX];
83 size_t out_pos = 0;
84 assert_lzma_ret(lzma_vli_encode(input, NULL, out, &out_pos,
85 expected_len), LZMA_OK);
86 assert_uint_eq(out_pos, expected_len);
87 assert_array_eq(out, expected, expected_len);
88 }
89
90
91 // Helper function for test_lzma_vli_encode
92 // Encodes an input VLI one byte at a time with the multi call
93 // method. Then compares against a pre-computed value
94 static void
95 encode_multi_call_mode(lzma_vli input, const uint8_t *expected,
96 uint32_t expected_len)
97 {
98 uint8_t out[LZMA_VLI_BYTES_MAX];
99 size_t out_pos = 0;
100 size_t vli_pos = 0;
101
102 for (uint32_t i = 1; i < expected_len; i++) {
103 assert_lzma_ret(lzma_vli_encode(input, &vli_pos, out,
104 &out_pos, i), LZMA_OK);
105 assert_uint_eq(out_pos, i);
106 assert_uint_eq(vli_pos, i);
107 }
108 assert_lzma_ret(lzma_vli_encode(input, &vli_pos, out, &out_pos,
109 expected_len), LZMA_STREAM_END);
110 assert_uint_eq(out_pos, expected_len);
111 assert_uint_eq(vli_pos, expected_len);
112 assert_array_eq(out, expected, expected_len);
113 }
114 #endif
115
116
117 static void
118 test_lzma_vli_encode(void)
119 {
120 #ifndef HAVE_ENCODERS
121 assert_skip("Encoder support disabled");
122 #else
123 size_t vli_pos = 0;
124 uint8_t out[LZMA_VLI_BYTES_MAX];
125 uint8_t zeros[LZMA_VLI_BYTES_MAX];
126 memzero(out, LZMA_VLI_BYTES_MAX);
127 memzero(zeros, LZMA_VLI_BYTES_MAX);
128 size_t out_pos = 0;
129
130 // First test invalid input parameters
131 // VLI invalid
132 assert_lzma_ret(lzma_vli_encode(LZMA_VLI_UNKNOWN, &vli_pos, out,
133 &out_pos, sizeof(out)), LZMA_PROG_ERROR);
134 // Failure should not change params
135 assert_uint_eq(vli_pos, 0);
136 assert_uint_eq(out_pos, 0);
137 assert_array_eq(out, zeros, LZMA_VLI_BYTES_MAX);
138
139 assert_lzma_ret(lzma_vli_encode(LZMA_VLI_MAX + 1, &vli_pos, out,
140 &out_pos, sizeof(out)), LZMA_PROG_ERROR);
141 assert_uint_eq(vli_pos, 0);
142 assert_uint_eq(out_pos, 0);
143 assert_array_eq(out, zeros, LZMA_VLI_BYTES_MAX);
144
145 // 0 output size
146 assert_lzma_ret(lzma_vli_encode(one_byte_value, &vli_pos, out,
147 &out_pos, 0), LZMA_BUF_ERROR);
148 assert_uint_eq(vli_pos, 0);
149 assert_uint_eq(out_pos, 0);
150 assert_array_eq(out, zeros, LZMA_VLI_BYTES_MAX);
151
152 // Size of VLI does not fit in buffer
153 size_t phony_out_pos = 3;
154 assert_lzma_ret(lzma_vli_encode(one_byte_value, NULL, out,
155 &phony_out_pos, 2), LZMA_PROG_ERROR);
156
157 assert_lzma_ret(lzma_vli_encode(LZMA_VLI_MAX / 2, NULL, out,
158 &out_pos, 2), LZMA_PROG_ERROR);
159
160 // Test single-call mode (using vli_pos as NULL)
161 encode_single_call_mode(one_byte_value, one_byte,
162 sizeof(one_byte));
163 encode_single_call_mode(two_byte_value, two_bytes,
164 sizeof(two_bytes));
165 encode_single_call_mode(three_byte_value, three_bytes,
166 sizeof(three_bytes));
167 encode_single_call_mode(four_byte_value, four_bytes,
168 sizeof(four_bytes));
169 encode_single_call_mode(five_byte_value, five_bytes,
170 sizeof(five_bytes));
171 encode_single_call_mode(six_byte_value, six_bytes,
172 sizeof(six_bytes));
173 encode_single_call_mode(seven_byte_value, seven_bytes,
174 sizeof(seven_bytes));
175 encode_single_call_mode(eight_byte_value, eight_bytes,
176 sizeof(eight_bytes));
177 encode_single_call_mode(nine_byte_value, nine_bytes,
178 sizeof(nine_bytes));
179
180 // Test multi-call mode
181 encode_multi_call_mode(one_byte_value, one_byte,
182 sizeof(one_byte));
183 encode_multi_call_mode(two_byte_value, two_bytes,
184 sizeof(two_bytes));
185 encode_multi_call_mode(three_byte_value, three_bytes,
186 sizeof(three_bytes));
187 encode_multi_call_mode(four_byte_value, four_bytes,
188 sizeof(four_bytes));
189 encode_multi_call_mode(five_byte_value, five_bytes,
190 sizeof(five_bytes));
191 encode_multi_call_mode(six_byte_value, six_bytes,
192 sizeof(six_bytes));
193 encode_multi_call_mode(seven_byte_value, seven_bytes,
194 sizeof(seven_bytes));
195 encode_multi_call_mode(eight_byte_value, eight_bytes,
196 sizeof(eight_bytes));
197 encode_multi_call_mode(nine_byte_value, nine_bytes,
198 sizeof(nine_bytes));
199 #endif
200 }
201
202
203 #ifdef HAVE_DECODERS
204 static void
205 decode_single_call_mode(const uint8_t *input, uint32_t input_len,
206 lzma_vli expected)
207 {
208 lzma_vli out = 0;
209 size_t in_pos = 0;
210
211 assert_lzma_ret(lzma_vli_decode(&out, NULL, input, &in_pos,
212 input_len), LZMA_OK);
213 assert_uint_eq(in_pos, input_len);
214 assert_uint_eq(out, expected);
215 }
216
217
218 static void
219 decode_multi_call_mode(const uint8_t *input, uint32_t input_len,
220 lzma_vli expected)
221 {
222 lzma_vli out = 0;
223 size_t in_pos = 0;
224 size_t vli_pos = 0;
225
226 for (uint32_t i = 1; i < input_len; i++) {
227 assert_lzma_ret(lzma_vli_decode(&out, &vli_pos, input,
228 &in_pos, i), LZMA_OK);
229 assert_uint_eq(in_pos, i);
230 assert_uint_eq(vli_pos, i);
231 }
232
233 assert_lzma_ret(lzma_vli_decode(&out, &vli_pos, input, &in_pos,
234 input_len), LZMA_STREAM_END);
235 assert_uint_eq(in_pos, input_len);
236 assert_uint_eq(vli_pos, input_len);
237 assert_uint_eq(out, expected);
238 }
239 #endif
240
241
242 static void
243 test_lzma_vli_decode(void)
244 {
245 #ifndef HAVE_DECODERS
246 assert_skip("Decoder support disabled");
247 #else
248 lzma_vli out = 0;
249 size_t in_pos = 0;
250
251 // First test invalid input params
252 // 0 in_size
253 assert_lzma_ret(lzma_vli_decode(&out, NULL, one_byte, &in_pos, 0),
254 LZMA_DATA_ERROR);
255 assert_uint_eq(out, 0);
256 assert_uint_eq(in_pos, 0);
257
258 // VLI encoded is invalid (last digit has leading 1 set)
259 uint8_t invalid_vli[3] = {0x80, 0x80, 0x80};
260 assert_lzma_ret(lzma_vli_decode(&out, NULL, invalid_vli, &in_pos,
261 sizeof(invalid_vli)), LZMA_DATA_ERROR);
262
263 // Bad vli_pos
264 size_t vli_pos = LZMA_VLI_BYTES_MAX;
265 assert_lzma_ret(lzma_vli_decode(&out, &vli_pos, invalid_vli, &in_pos,
266 sizeof(invalid_vli)), LZMA_PROG_ERROR);
267
268 // Bad in_pos
269 in_pos = sizeof(invalid_vli);
270 assert_lzma_ret(lzma_vli_decode(&out, &in_pos, invalid_vli, &in_pos,
271 sizeof(invalid_vli)), LZMA_BUF_ERROR);
272
273 // Test single call mode
274 decode_single_call_mode(one_byte, sizeof(one_byte),
275 one_byte_value);
276 decode_single_call_mode(two_bytes, sizeof(two_bytes),
277 two_byte_value);
278 decode_single_call_mode(three_bytes, sizeof(three_bytes),
279 three_byte_value);
280 decode_single_call_mode(four_bytes, sizeof(four_bytes),
281 four_byte_value);
282 decode_single_call_mode(five_bytes, sizeof(five_bytes),
283 five_byte_value);
284 decode_single_call_mode(six_bytes, sizeof(six_bytes),
285 six_byte_value);
286 decode_single_call_mode(seven_bytes, sizeof(seven_bytes),
287 seven_byte_value);
288 decode_single_call_mode(eight_bytes, sizeof(eight_bytes),
289 eight_byte_value);
290 decode_single_call_mode(nine_bytes, sizeof(nine_bytes),
291 nine_byte_value);
292
293 // Test multi call mode
294 decode_multi_call_mode(one_byte, sizeof(one_byte),
295 one_byte_value);
296 decode_multi_call_mode(two_bytes, sizeof(two_bytes),
297 two_byte_value);
298 decode_multi_call_mode(three_bytes, sizeof(three_bytes),
299 three_byte_value);
300 decode_multi_call_mode(four_bytes, sizeof(four_bytes),
301 four_byte_value);
302 decode_multi_call_mode(five_bytes, sizeof(five_bytes),
303 five_byte_value);
304 decode_multi_call_mode(six_bytes, sizeof(six_bytes),
305 six_byte_value);
306 decode_multi_call_mode(seven_bytes, sizeof(seven_bytes),
307 seven_byte_value);
308 decode_multi_call_mode(eight_bytes, sizeof(eight_bytes),
309 eight_byte_value);
310 decode_multi_call_mode(nine_bytes, sizeof(nine_bytes),
311 nine_byte_value);
312 #endif
313 }
314
315
316 extern int
317 main(int argc, char **argv)
318 {
319 tuktest_start(argc, argv);
320 tuktest_run(test_lzma_vli_size);
321 tuktest_run(test_lzma_vli_encode);
322 tuktest_run(test_lzma_vli_decode);
323 return tuktest_end();
324 }