]> git.sur5r.net Git - u-boot/blob - test/compression.c
Merge git://git.denx.de/u-boot-fsl-qoriq
[u-boot] / test / compression.c
1 /*
2  * Copyright (c) 2013, The Chromium Authors
3  *
4  * SPDX-License-Identifier:     GPL-2.0+
5  */
6
7 #include <common.h>
8 #include <bootm.h>
9 #include <command.h>
10 #include <malloc.h>
11 #include <mapmem.h>
12 #include <asm/io.h>
13
14 #include <u-boot/zlib.h>
15 #include <bzlib.h>
16
17 #include <lzma/LzmaTypes.h>
18 #include <lzma/LzmaDec.h>
19 #include <lzma/LzmaTools.h>
20
21 #include <linux/lzo.h>
22 #include <test/compression.h>
23 #include <test/suites.h>
24 #include <test/ut.h>
25
26 static const char plain[] =
27         "I am a highly compressable bit of text.\n"
28         "I am a highly compressable bit of text.\n"
29         "I am a highly compressable bit of text.\n"
30         "There are many like me, but this one is mine.\n"
31         "If I were any shorter, there wouldn't be much sense in\n"
32         "compressing me in the first place. At least with lzo, anyway,\n"
33         "which appears to behave poorly in the face of short text\n"
34         "messages.\n";
35
36 /* bzip2 -c /tmp/plain.txt > /tmp/plain.bz2 */
37 static const char bzip2_compressed[] =
38         "\x42\x5a\x68\x39\x31\x41\x59\x26\x53\x59\xe5\x63\xdd\x09\x00\x00"
39         "\x28\x57\x80\x00\x10\x40\x85\x20\x20\x04\x00\x3f\xef\xdf\xf0\x30"
40         "\x00\xd6\xd0\x34\x91\x89\xa6\xf5\x4d\x19\x1a\x19\x0d\x02\x34\xd4"
41         "\xc9\x00\x34\x34\x00\x02\x48\x41\x35\x4f\xd4\xc6\x88\xd3\x50\x3d"
42         "\x4f\x51\x82\x4f\x88\xc3\x0d\x05\x62\x4f\x91\xa3\x52\x1b\xd0\x52"
43         "\x41\x4a\xa3\x98\xc2\x6b\xca\xa3\x82\xa5\xac\x8b\x15\x99\x68\xad"
44         "\xdf\x29\xd6\xf1\xf7\x5a\x10\xcd\x8c\x26\x61\x94\x95\xfe\x9e\x16"
45         "\x18\x28\x69\xd4\x23\x64\xcc\x2b\xe5\xe8\x5f\x00\xa4\x70\x26\x2c"
46         "\xee\xbd\x59\x6d\x6a\xec\xfc\x31\xda\x59\x0a\x14\x2a\x60\x1c\xf0"
47         "\x04\x86\x73\x9a\xc5\x5b\x87\x3f\x5b\x4c\x93\xe6\xb5\x35\x0d\xa6"
48         "\xb1\x2e\x62\x7b\xab\x67\xe7\x99\x2a\x14\x5e\x9f\x64\xcb\x96\xf4"
49         "\x0d\x65\xd4\x39\xe6\x8b\x7e\xea\x1c\x03\x69\x97\x83\x58\x91\x96"
50         "\xe1\xf0\x9d\xa4\x15\x8b\xb8\xc6\x93\xdc\x3d\xd9\x3c\x22\x55\xef"
51         "\xfb\xbb\x2a\xd3\x87\xa2\x8b\x04\xd9\x19\xf8\xe2\xfd\x4f\xdb\x1a"
52         "\x07\xc8\x60\xa3\x3f\xf8\xbb\x92\x29\xc2\x84\x87\x2b\x1e\xe8\x48";
53 static const unsigned long bzip2_compressed_size = 240;
54
55 /* lzma -z -c /tmp/plain.txt > /tmp/plain.lzma */
56 static const char lzma_compressed[] =
57         "\x5d\x00\x00\x80\x00\xff\xff\xff\xff\xff\xff\xff\xff\x00\x24\x88"
58         "\x08\x26\xd8\x41\xff\x99\xc8\xcf\x66\x3d\x80\xac\xba\x17\xf1\xc8"
59         "\xb9\xdf\x49\x37\xb1\x68\xa0\x2a\xdd\x63\xd1\xa7\xa3\x66\xf8\x15"
60         "\xef\xa6\x67\x8a\x14\x18\x80\xcb\xc7\xb1\xcb\x84\x6a\xb2\x51\x16"
61         "\xa1\x45\xa0\xd6\x3e\x55\x44\x8a\x5c\xa0\x7c\xe5\xa8\xbd\x04\x57"
62         "\x8f\x24\xfd\xb9\x34\x50\x83\x2f\xf3\x46\x3e\xb9\xb0\x00\x1a\xf5"
63         "\xd3\x86\x7e\x8f\x77\xd1\x5d\x0e\x7c\xe1\xac\xde\xf8\x65\x1f\x4d"
64         "\xce\x7f\xa7\x3d\xaa\xcf\x26\xa7\x58\x69\x1e\x4c\xea\x68\x8a\xe5"
65         "\x89\xd1\xdc\x4d\xc7\xe0\x07\x42\xbf\x0c\x9d\x06\xd7\x51\xa2\x0b"
66         "\x7c\x83\x35\xe1\x85\xdf\xee\xfb\xa3\xee\x2f\x47\x5f\x8b\x70\x2b"
67         "\xe1\x37\xf3\x16\xf6\x27\x54\x8a\x33\x72\x49\xea\x53\x7d\x60\x0b"
68         "\x21\x90\x66\xe7\x9e\x56\x61\x5d\xd8\xdc\x59\xf0\xac\x2f\xd6\x49"
69         "\x6b\x85\x40\x08\x1f\xdf\x26\x25\x3b\x72\x44\xb0\xb8\x21\x2f\xb3"
70         "\xd7\x9b\x24\x30\x78\x26\x44\x07\xc3\x33\xd1\x4d\x03\x1b\xe1\xff"
71         "\xfd\xf5\x50\x8d\xca";
72 static const unsigned long lzma_compressed_size = 229;
73
74 /* lzop -c /tmp/plain.txt > /tmp/plain.lzo */
75 static const char lzo_compressed[] =
76         "\x89\x4c\x5a\x4f\x00\x0d\x0a\x1a\x0a\x10\x30\x20\x60\x09\x40\x01"
77         "\x05\x03\x00\x00\x09\x00\x00\x81\xb4\x52\x09\x54\xf1\x00\x00\x00"
78         "\x00\x09\x70\x6c\x61\x69\x6e\x2e\x74\x78\x74\x65\xb1\x07\x9c\x00"
79         "\x00\x01\x5e\x00\x00\x01\x0f\xc3\xc7\x7a\xe0\x00\x16\x49\x20\x61"
80         "\x6d\x20\x61\x20\x68\x69\x67\x68\x6c\x79\x20\x63\x6f\x6d\x70\x72"
81         "\x65\x73\x73\x61\x62\x6c\x65\x20\x62\x69\x74\x20\x6f\x66\x20\x74"
82         "\x65\x78\x74\x2e\x0a\x20\x2f\x9c\x00\x00\x22\x54\x68\x65\x72\x65"
83         "\x20\x61\x72\x65\x20\x6d\x61\x6e\x79\x20\x6c\x69\x6b\x65\x20\x6d"
84         "\x65\x2c\x20\x62\x75\x74\x20\x74\x68\x69\x73\x20\x6f\x6e\x65\x20"
85         "\x69\x73\x20\x6d\x69\x6e\x65\x2e\x0a\x49\x66\x20\x49\x20\x77\x84"
86         "\x06\x0a\x6e\x79\x20\x73\x68\x6f\x72\x74\x65\x72\x2c\x20\x74\x90"
87         "\x08\x00\x08\x77\x6f\x75\x6c\x64\x6e\x27\x74\x20\x62\x65\x20\x6d"
88         "\x75\x63\x68\x20\x73\x65\x6e\x73\x65\x20\x69\x6e\x0a\xf8\x19\x02"
89         "\x69\x6e\x67\x20\x6d\x64\x02\x64\x06\x00\x5a\x20\x66\x69\x72\x73"
90         "\x74\x20\x70\x6c\x61\x63\x65\x2e\x20\x41\x74\x20\x6c\x65\x61\x73"
91         "\x74\x20\x77\x69\x74\x68\x20\x6c\x7a\x6f\x2c\x20\x61\x6e\x79\x77"
92         "\x61\x79\x2c\x0a\x77\x68\x69\x63\x68\x20\x61\x70\x70\x65\x61\x72"
93         "\x73\x20\x74\x6f\x20\x62\x65\x68\x61\x76\x65\x20\x70\x6f\x6f\x72"
94         "\x6c\x79\x20\x69\x6e\x20\x74\x68\x65\x20\x66\x61\x63\x65\x20\x6f"
95         "\x66\x20\x73\x68\x6f\x72\x74\x20\x74\x65\x78\x74\x0a\x6d\x65\x73"
96         "\x73\x61\x67\x65\x73\x2e\x0a\x11\x00\x00\x00\x00\x00\x00";
97 static const unsigned long lzo_compressed_size = 334;
98
99 /* lz4 -z /tmp/plain.txt > /tmp/plain.lz4 */
100 static const char lz4_compressed[] =
101         "\x04\x22\x4d\x18\x64\x70\xb9\x01\x01\x00\x00\xff\x19\x49\x20\x61"
102         "\x6d\x20\x61\x20\x68\x69\x67\x68\x6c\x79\x20\x63\x6f\x6d\x70\x72"
103         "\x65\x73\x73\x61\x62\x6c\x65\x20\x62\x69\x74\x20\x6f\x66\x20\x74"
104         "\x65\x78\x74\x2e\x0a\x28\x00\x3d\xf1\x25\x54\x68\x65\x72\x65\x20"
105         "\x61\x72\x65\x20\x6d\x61\x6e\x79\x20\x6c\x69\x6b\x65\x20\x6d\x65"
106         "\x2c\x20\x62\x75\x74\x20\x74\x68\x69\x73\x20\x6f\x6e\x65\x20\x69"
107         "\x73\x20\x6d\x69\x6e\x65\x2e\x0a\x49\x66\x20\x49\x20\x77\x32\x00"
108         "\xd1\x6e\x79\x20\x73\x68\x6f\x72\x74\x65\x72\x2c\x20\x74\x45\x00"
109         "\xf4\x0b\x77\x6f\x75\x6c\x64\x6e\x27\x74\x20\x62\x65\x20\x6d\x75"
110         "\x63\x68\x20\x73\x65\x6e\x73\x65\x20\x69\x6e\x0a\xcf\x00\x50\x69"
111         "\x6e\x67\x20\x6d\x12\x00\x00\x32\x00\xf0\x11\x20\x66\x69\x72\x73"
112         "\x74\x20\x70\x6c\x61\x63\x65\x2e\x20\x41\x74\x20\x6c\x65\x61\x73"
113         "\x74\x20\x77\x69\x74\x68\x20\x6c\x7a\x6f\x2c\x63\x00\xf5\x14\x77"
114         "\x61\x79\x2c\x0a\x77\x68\x69\x63\x68\x20\x61\x70\x70\x65\x61\x72"
115         "\x73\x20\x74\x6f\x20\x62\x65\x68\x61\x76\x65\x20\x70\x6f\x6f\x72"
116         "\x6c\x79\x4e\x00\x30\x61\x63\x65\x27\x01\x01\x95\x00\x01\x2d\x01"
117         "\xb0\x0a\x6d\x65\x73\x73\x61\x67\x65\x73\x2e\x0a\x00\x00\x00\x00"
118         "\x9d\x12\x8c\x9d";
119 static const unsigned long lz4_compressed_size = 276;
120
121
122 #define TEST_BUFFER_SIZE        512
123
124 typedef int (*mutate_func)(struct unit_test_state *uts, void *, unsigned long,
125                            void *, unsigned long, unsigned long *);
126
127 static int compress_using_gzip(struct unit_test_state *uts,
128                                void *in, unsigned long in_size,
129                                void *out, unsigned long out_max,
130                                unsigned long *out_size)
131 {
132         int ret;
133         unsigned long inout_size = out_max;
134
135         ret = gzip(out, &inout_size, in, in_size);
136         if (out_size)
137                 *out_size = inout_size;
138
139         return ret;
140 }
141
142 static int uncompress_using_gzip(struct unit_test_state *uts,
143                                  void *in, unsigned long in_size,
144                                  void *out, unsigned long out_max,
145                                  unsigned long *out_size)
146 {
147         int ret;
148         unsigned long inout_size = in_size;
149
150         ret = gunzip(out, out_max, in, &inout_size);
151         if (out_size)
152                 *out_size = inout_size;
153
154         return ret;
155 }
156
157 static int compress_using_bzip2(struct unit_test_state *uts,
158                                 void *in, unsigned long in_size,
159                                 void *out, unsigned long out_max,
160                                 unsigned long *out_size)
161 {
162         /* There is no bzip2 compression in u-boot, so fake it. */
163         ut_asserteq(in_size, strlen(plain));
164         ut_asserteq(0, memcmp(plain, in, in_size));
165
166         if (bzip2_compressed_size > out_max)
167                 return -1;
168
169         memcpy(out, bzip2_compressed, bzip2_compressed_size);
170         if (out_size)
171                 *out_size = bzip2_compressed_size;
172
173         return 0;
174 }
175
176 static int uncompress_using_bzip2(struct unit_test_state *uts,
177                                   void *in, unsigned long in_size,
178                                   void *out, unsigned long out_max,
179                                   unsigned long *out_size)
180 {
181         int ret;
182         unsigned int inout_size = out_max;
183
184         ret = BZ2_bzBuffToBuffDecompress(out, &inout_size, in, in_size,
185                         CONFIG_SYS_MALLOC_LEN < (4096 * 1024), 0);
186         if (out_size)
187                 *out_size = inout_size;
188
189         return (ret != BZ_OK);
190 }
191
192 static int compress_using_lzma(struct unit_test_state *uts,
193                                void *in, unsigned long in_size,
194                                void *out, unsigned long out_max,
195                                unsigned long *out_size)
196 {
197         /* There is no lzma compression in u-boot, so fake it. */
198         ut_asserteq(in_size,  strlen(plain));
199         ut_asserteq(0, memcmp(plain, in, in_size));
200
201         if (lzma_compressed_size > out_max)
202                 return -1;
203
204         memcpy(out, lzma_compressed, lzma_compressed_size);
205         if (out_size)
206                 *out_size = lzma_compressed_size;
207
208         return 0;
209 }
210
211 static int uncompress_using_lzma(struct unit_test_state *uts,
212                                  void *in, unsigned long in_size,
213                                  void *out, unsigned long out_max,
214                                  unsigned long *out_size)
215 {
216         int ret;
217         SizeT inout_size = out_max;
218
219         ret = lzmaBuffToBuffDecompress(out, &inout_size, in, in_size);
220         if (out_size)
221                 *out_size = inout_size;
222
223         return (ret != SZ_OK);
224 }
225
226 static int compress_using_lzo(struct unit_test_state *uts,
227                               void *in, unsigned long in_size,
228                               void *out, unsigned long out_max,
229                               unsigned long *out_size)
230 {
231         /* There is no lzo compression in u-boot, so fake it. */
232         ut_asserteq(in_size,  strlen(plain));
233         ut_asserteq(0, memcmp(plain, in, in_size));
234
235         if (lzo_compressed_size > out_max)
236                 return -1;
237
238         memcpy(out, lzo_compressed, lzo_compressed_size);
239         if (out_size)
240                 *out_size = lzo_compressed_size;
241
242         return 0;
243 }
244
245 static int uncompress_using_lzo(struct unit_test_state *uts,
246                                 void *in, unsigned long in_size,
247                                 void *out, unsigned long out_max,
248                                 unsigned long *out_size)
249 {
250         int ret;
251         size_t input_size = in_size;
252         size_t output_size = out_max;
253
254         ret = lzop_decompress(in, input_size, out, &output_size);
255         if (out_size)
256                 *out_size = output_size;
257
258         return (ret != LZO_E_OK);
259 }
260
261 static int compress_using_lz4(struct unit_test_state *uts,
262                               void *in, unsigned long in_size,
263                               void *out, unsigned long out_max,
264                               unsigned long *out_size)
265 {
266         /* There is no lz4 compression in u-boot, so fake it. */
267         ut_asserteq(in_size,  strlen(plain));
268         ut_asserteq(0, memcmp(plain, in, in_size));
269
270         if (lz4_compressed_size > out_max)
271                 return -1;
272
273         memcpy(out, lz4_compressed, lz4_compressed_size);
274         if (out_size)
275                 *out_size = lz4_compressed_size;
276
277         return 0;
278 }
279
280 static int uncompress_using_lz4(struct unit_test_state *uts,
281                                 void *in, unsigned long in_size,
282                                 void *out, unsigned long out_max,
283                                 unsigned long *out_size)
284 {
285         int ret;
286         size_t input_size = in_size;
287         size_t output_size = out_max;
288
289         ret = ulz4fn(in, input_size, out, &output_size);
290         if (out_size)
291                 *out_size = output_size;
292
293         return (ret != 0);
294 }
295
296 #define errcheck(statement) if (!(statement)) { \
297         fprintf(stderr, "\tFailed: %s\n", #statement); \
298         ret = 1; \
299         goto out; \
300 }
301
302 struct buf_state {
303         ulong orig_size;
304         ulong compressed_size;
305         ulong uncompressed_size;
306         void *orig_buf;
307         void *compressed_buf;
308         void *uncompressed_buf;
309         void *compare_buf;
310 };
311
312 static int run_test_internal(struct unit_test_state *uts, char *name,
313                              mutate_func compress, mutate_func uncompress,
314                              struct buf_state *buf)
315 {
316         int ret;
317
318         /* Compress works as expected. */
319         printf("\torig_size:%lu\n", buf->orig_size);
320         memset(buf->compressed_buf, 'A', TEST_BUFFER_SIZE);
321         errcheck(compress(uts, buf->orig_buf, buf->orig_size,
322                           buf->compressed_buf, buf->compressed_size,
323                           &buf->compressed_size) == 0);
324         printf("\tcompressed_size:%lu\n", buf->compressed_size);
325         errcheck(buf->compressed_size > 0);
326         errcheck(buf->compressed_size < buf->orig_size);
327         errcheck(((char *)buf->compressed_buf)[buf->compressed_size - 1] !=
328                         'A');
329         errcheck(((char *)buf->compressed_buf)[buf->compressed_size] == 'A');
330
331         /* Uncompresses with space remaining. */
332         errcheck(uncompress(uts, buf->compressed_buf, buf->compressed_size,
333                             buf->uncompressed_buf, buf->uncompressed_size,
334                             &buf->uncompressed_size) == 0);
335         printf("\tuncompressed_size:%lu\n", buf->uncompressed_size);
336         errcheck(buf->uncompressed_size == buf->orig_size);
337         errcheck(memcmp(buf->orig_buf, buf->uncompressed_buf,
338                         buf->orig_size) == 0);
339
340         /* Uncompresses with exactly the right size output buffer. */
341         memset(buf->uncompressed_buf, 'A', TEST_BUFFER_SIZE);
342         errcheck(uncompress(uts, buf->compressed_buf, buf->compressed_size,
343                             buf->uncompressed_buf, buf->orig_size,
344                             &buf->uncompressed_size) == 0);
345         errcheck(buf->uncompressed_size == buf->orig_size);
346         errcheck(memcmp(buf->orig_buf, buf->uncompressed_buf,
347                         buf->orig_size) == 0);
348         errcheck(((char *)buf->uncompressed_buf)[buf->orig_size] == 'A');
349
350         /* Make sure compression does not over-run. */
351         memset(buf->compare_buf, 'A', TEST_BUFFER_SIZE);
352         ret = compress(uts, buf->orig_buf, buf->orig_size,
353                        buf->compare_buf, buf->compressed_size - 1,
354                        NULL);
355         errcheck(((char *)buf->compare_buf)[buf->compressed_size] == 'A');
356         errcheck(ret != 0);
357         printf("\tcompress does not overrun\n");
358
359         /* Make sure decompression does not over-run. */
360         memset(buf->compare_buf, 'A', TEST_BUFFER_SIZE);
361         ret = uncompress(uts, buf->compressed_buf, buf->compressed_size,
362                          buf->compare_buf, buf->uncompressed_size - 1,
363                          NULL);
364         errcheck(((char *)buf->compare_buf)[buf->uncompressed_size - 1] == 'A');
365         errcheck(ret != 0);
366         printf("\tuncompress does not overrun\n");
367
368         /* Got here, everything is fine. */
369         ret = 0;
370
371 out:
372         return ret;
373 }
374
375 static int run_test(struct unit_test_state *uts, char *name,
376                     mutate_func compress, mutate_func uncompress)
377 {
378         struct buf_state sbuf, *buf = &sbuf;
379         int ret;
380
381         printf(" testing %s ...\n", name);
382
383         buf->orig_buf = (void *)plain;
384         buf->orig_size = strlen(buf->orig_buf); /* Trailing NUL not included */
385         errcheck(buf->orig_size > 0);
386
387         buf->compressed_size = TEST_BUFFER_SIZE;
388         buf->uncompressed_size = TEST_BUFFER_SIZE;
389         buf->compressed_buf = malloc(buf->compressed_size);
390         errcheck(buf->compressed_buf);
391         buf->uncompressed_buf = malloc(buf->uncompressed_size);
392         errcheck(buf->uncompressed_buf);
393         buf->compare_buf = malloc(buf->uncompressed_size);
394         errcheck(buf->compare_buf);
395
396         ret = run_test_internal(uts, name, compress, uncompress, buf);
397 out:
398         printf(" %s: %s\n", name, ret == 0 ? "ok" : "FAILED");
399
400         free(buf->compare_buf);
401         free(buf->uncompressed_buf);
402         free(buf->compressed_buf);
403
404         return ret;
405 }
406
407 static int compression_test_gzip(struct unit_test_state *uts)
408 {
409         return run_test(uts, "gzip", compress_using_gzip,
410                         uncompress_using_gzip);
411 }
412 COMPRESSION_TEST(compression_test_gzip, 0);
413
414 static int compression_test_bzip2(struct unit_test_state *uts)
415 {
416         return run_test(uts, "bzip2", compress_using_bzip2,
417                         uncompress_using_bzip2);
418 }
419 COMPRESSION_TEST(compression_test_bzip2, 0);
420
421 static int compression_test_lzma(struct unit_test_state *uts)
422 {
423         return run_test(uts, "lzma", compress_using_lzma,
424                         uncompress_using_lzma);
425 }
426 COMPRESSION_TEST(compression_test_lzma, 0);
427
428 static int compression_test_lzo(struct unit_test_state *uts)
429 {
430         return run_test(uts, "lzo", compress_using_lzo, uncompress_using_lzo);
431 }
432 COMPRESSION_TEST(compression_test_lzo, 0);
433
434 static int compression_test_lz4(struct unit_test_state *uts)
435 {
436         return run_test(uts, "lz4", compress_using_lz4, uncompress_using_lz4);
437 }
438 COMPRESSION_TEST(compression_test_lz4, 0);
439
440 static int compress_using_none(struct unit_test_state *uts,
441                                void *in, unsigned long in_size,
442                                void *out, unsigned long out_max,
443                                unsigned long *out_size)
444 {
445         /* Here we just copy */
446         memcpy(out, in, in_size);
447         *out_size = in_size;
448
449         return 0;
450 }
451
452 /**
453  * run_bootm_test() - Run tests on the bootm decopmression function
454  *
455  * @comp_type:  Compression type to test
456  * @compress:   Our function to compress data
457  * @return 0 if OK, non-zero on failure
458  */
459 static int run_bootm_test(struct unit_test_state *uts, int comp_type,
460                           mutate_func compress)
461 {
462         ulong compress_size = 1024;
463         void *compress_buff;
464         int unc_len;
465         int err = 0;
466         const ulong image_start = 0;
467         const ulong load_addr = 0x1000;
468         ulong load_end;
469
470         printf("Testing: %s\n", genimg_get_comp_name(comp_type));
471         compress_buff = map_sysmem(image_start, 0);
472         unc_len = strlen(plain);
473         compress(uts, (void *)plain, unc_len, compress_buff, compress_size,
474                  &compress_size);
475         err = bootm_decomp_image(comp_type, load_addr, image_start,
476                                  IH_TYPE_KERNEL, map_sysmem(load_addr, 0),
477                                  compress_buff, compress_size, unc_len,
478                                  &load_end);
479         ut_assertok(err);
480         err = bootm_decomp_image(comp_type, load_addr, image_start,
481                                  IH_TYPE_KERNEL, map_sysmem(load_addr, 0),
482                                  compress_buff, compress_size, unc_len - 1,
483                                  &load_end);
484         ut_assert(err);
485
486         /* We can't detect corruption when not decompressing */
487         if (comp_type == IH_COMP_NONE)
488                 return 0;
489         memset(compress_buff + compress_size / 2, '\x49',
490                compress_size / 2);
491         err = bootm_decomp_image(comp_type, load_addr, image_start,
492                                  IH_TYPE_KERNEL, map_sysmem(load_addr, 0),
493                                  compress_buff, compress_size, 0x10000,
494                                  &load_end);
495         ut_assert(err);
496
497         return 0;
498 }
499
500 static int compression_test_bootm_gzip(struct unit_test_state *uts)
501 {
502         return run_bootm_test(uts, IH_COMP_GZIP, compress_using_gzip);
503 }
504 COMPRESSION_TEST(compression_test_bootm_gzip, 0);
505
506 static int compression_test_bootm_bzip2(struct unit_test_state *uts)
507 {
508         return run_bootm_test(uts, IH_COMP_BZIP2, compress_using_bzip2);
509 }
510 COMPRESSION_TEST(compression_test_bootm_bzip2, 0);
511
512 static int compression_test_bootm_lzma(struct unit_test_state *uts)
513 {
514         return run_bootm_test(uts, IH_COMP_LZMA, compress_using_lzma);
515 }
516 COMPRESSION_TEST(compression_test_bootm_lzma, 0);
517
518 static int compression_test_bootm_lzo(struct unit_test_state *uts)
519 {
520         return run_bootm_test(uts, IH_COMP_LZO, compress_using_lzo);
521 }
522 COMPRESSION_TEST(compression_test_bootm_lzo, 0);
523
524 static int compression_test_bootm_lz4(struct unit_test_state *uts)
525 {
526         return run_bootm_test(uts, IH_COMP_LZ4, compress_using_lz4);
527 }
528 COMPRESSION_TEST(compression_test_bootm_lz4, 0);
529
530 static int compression_test_bootm_none(struct unit_test_state *uts)
531 {
532         return run_bootm_test(uts, IH_COMP_NONE, compress_using_none);
533 }
534 COMPRESSION_TEST(compression_test_bootm_none, 0);
535
536 int do_ut_compression(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
537 {
538         struct unit_test *tests = ll_entry_start(struct unit_test,
539                                                  compression_test);
540         const int n_ents = ll_entry_count(struct unit_test, compression_test);
541
542         return cmd_ut_category("compression", tests, n_ents, argc, argv);
543 }