← Back to branch summary

~sergei.glushchenko/+junk/page-scan-hack

« back to all changes in this revision

Viewing changes to src/libarchive/libarchive/test/test_write_compress_bzip2.c

merge parallel compression branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/libarchive/libarchive/test/test_write_compress_bzip2.c
 
1
/*-
 
2
 * Copyright (c) 2007 Tim Kientzle
 
3
 * All rights reserved.
 
4
 *
 
5
 * Redistribution and use in source and binary forms, with or without
 
6
 * modification, are permitted provided that the following conditions
 
7
 * are met:
 
8
 * 1. Redistributions of source code must retain the above copyright
 
9
 *    notice, this list of conditions and the following disclaimer
 
10
 *    in this position and unchanged.
 
11
 * 2. Redistributions in binary form must reproduce the above copyright
 
12
 *    notice, this list of conditions and the following disclaimer in the
 
13
 *    documentation and/or other materials provided with the distribution.
 
14
 *
 
15
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 
16
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 
17
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 
18
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 
19
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 
20
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 
21
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 
22
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
23
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 
24
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
25
 */
 
26
 
 
27
#include "test.h"
 
28
__FBSDID("$FreeBSD: head/lib/libarchive/test/test_write_compress_bzip2.c 191183 2009-04-17 01:06:31Z kientzle $");
 
29
 
 
30
/*
 
31
 * A basic exercise of bzip2 reading and writing.
 
32
 *
 
33
 * TODO: Add a reference file and make sure we can decompress that.
 
34
 */
 
35
 
 
36
DEFINE_TEST(test_write_compress_bzip2)
 
37
{
 
38
        struct archive_entry *ae;
 
39
        struct archive* a;
 
40
        char *buff, *data;
 
41
        size_t buffsize, datasize;
 
42
        char path[16];
 
43
        size_t used1, used2;
 
44
        int i, r;
 
45
 
 
46
        buffsize = 2000000;
 
47
        assert(NULL != (buff = (char *)malloc(buffsize)));
 
48
 
 
49
        datasize = 10000;
 
50
        assert(NULL != (data = (char *)malloc(datasize)));
 
51
        memset(data, 0, datasize);
 
52
 
 
53
        /*
 
54
         * Write a 100 files and read them all back.
 
55
         */
 
56
        assert((a = archive_write_new()) != NULL);
 
57
        assertA(0 == archive_write_set_format_ustar(a));
 
58
        r = archive_write_set_compression_bzip2(a);
 
59
        if (r == ARCHIVE_FATAL) {
 
60
                skipping("bzip2 writing not supported on this platform");
 
61
                assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
 
62
                return;
 
63
        }
 
64
        assertEqualIntA(a, ARCHIVE_OK,
 
65
            archive_write_set_bytes_per_block(a, 10));
 
66
        assertEqualInt(ARCHIVE_COMPRESSION_BZIP2, archive_compression(a));
 
67
        assertEqualString("bzip2", archive_compression_name(a));
 
68
        assertA(0 == archive_write_open_memory(a, buff, buffsize, &used1));
 
69
        assertEqualInt(ARCHIVE_COMPRESSION_BZIP2, archive_compression(a));
 
70
        assertEqualString("bzip2", archive_compression_name(a));
 
71
        assert((ae = archive_entry_new()) != NULL);
 
72
        archive_entry_set_filetype(ae, AE_IFREG);
 
73
        archive_entry_set_size(ae, datasize);
 
74
        for (i = 0; i < 999; i++) {
 
75
                sprintf(path, "file%03d", i);
 
76
                archive_entry_copy_pathname(ae, path);
 
77
                assertA(0 == archive_write_header(a, ae));
 
78
                assertA(datasize
 
79
                    == (size_t)archive_write_data(a, data, datasize));
 
80
        }
 
81
        archive_entry_free(ae);
 
82
        archive_write_close(a);
 
83
        assert(0 == archive_write_finish(a));
 
84
 
 
85
        assert((a = archive_read_new()) != NULL);
 
86
        assertA(0 == archive_read_support_format_all(a));
 
87
        assertA(0 == archive_read_support_compression_all(a));
 
88
        assertA(0 == archive_read_open_memory(a, buff, used1));
 
89
        for (i = 0; i < 999; i++) {
 
90
                sprintf(path, "file%03d", i);
 
91
                if (!assertEqualInt(0, archive_read_next_header(a, &ae)))
 
92
                        break;
 
93
                assertEqualString(path, archive_entry_pathname(ae));
 
94
                assertEqualInt((int)datasize, archive_entry_size(ae));
 
95
        }
 
96
        assert(0 == archive_read_close(a));
 
97
        assert(0 == archive_read_finish(a));
 
98
 
 
99
        /*
 
100
         * Repeat the cycle again, this time setting some compression
 
101
         * options.
 
102
         */
 
103
        assert((a = archive_write_new()) != NULL);
 
104
        assertA(0 == archive_write_set_format_ustar(a));
 
105
        assertEqualIntA(a, ARCHIVE_OK,
 
106
            archive_write_set_bytes_per_block(a, 10));
 
107
        assertA(0 == archive_write_set_compression_bzip2(a));
 
108
        assertEqualIntA(a, ARCHIVE_WARN,
 
109
            archive_write_set_compressor_options(a, "nonexistent-option=0"));
 
110
        assertEqualIntA(a, ARCHIVE_WARN,
 
111
            archive_write_set_compressor_options(a, "compression-level=abc"));
 
112
        assertEqualIntA(a, ARCHIVE_WARN,
 
113
            archive_write_set_compressor_options(a, "compression-level=99"));
 
114
        assertEqualIntA(a, ARCHIVE_OK,
 
115
            archive_write_set_compressor_options(a, "compression-level=9"));
 
116
        assertA(0 == archive_write_open_memory(a, buff, buffsize, &used2));
 
117
        for (i = 0; i < 999; i++) {
 
118
                sprintf(path, "file%03d", i);
 
119
                assert((ae = archive_entry_new()) != NULL);
 
120
                archive_entry_copy_pathname(ae, path);
 
121
                archive_entry_set_size(ae, datasize);
 
122
                archive_entry_set_filetype(ae, AE_IFREG);
 
123
                assertA(0 == archive_write_header(a, ae));
 
124
                assertA(datasize == (size_t)archive_write_data(a, data, datasize));
 
125
                archive_entry_free(ae);
 
126
        }
 
127
        archive_write_close(a);
 
128
        assert(0 == archive_write_finish(a));
 
129
 
 
130
        /* Curiously, this test fails; the test data above compresses
 
131
         * better at default compression than at level 9. */
 
132
        /*
 
133
        failure("compression-level=9 wrote %d bytes, default wrote %d bytes",
 
134
            (int)used2, (int)used1);
 
135
        assert(used2 < used1);
 
136
        */
 
137
 
 
138
        assert((a = archive_read_new()) != NULL);
 
139
        assertA(0 == archive_read_support_format_all(a));
 
140
        assertA(0 == archive_read_support_compression_all(a));
 
141
        assertA(0 == archive_read_open_memory(a, buff, used2));
 
142
        for (i = 0; i < 999; i++) {
 
143
                sprintf(path, "file%03d", i);
 
144
                if (!assertEqualInt(0, archive_read_next_header(a, &ae)))
 
145
                        break;
 
146
                assertEqualString(path, archive_entry_pathname(ae));
 
147
                assertEqualInt((int)datasize, archive_entry_size(ae));
 
148
        }
 
149
        assert(0 == archive_read_close(a));
 
150
        assert(0 == archive_read_finish(a));
 
151
 
 
152
        /*
 
153
         * Repeat again, with much lower compression.
 
154
         */
 
155
        assert((a = archive_write_new()) != NULL);
 
156
        assertA(0 == archive_write_set_format_ustar(a));
 
157
        assertEqualIntA(a, ARCHIVE_OK,
 
158
            archive_write_set_bytes_per_block(a, 10));
 
159
        assertA(0 == archive_write_set_compression_bzip2(a));
 
160
        assertEqualIntA(a, ARCHIVE_OK,
 
161
            archive_write_set_compressor_options(a, "compression-level=1"));
 
162
        assertA(0 == archive_write_open_memory(a, buff, buffsize, &used2));
 
163
        for (i = 0; i < 999; i++) {
 
164
                sprintf(path, "file%03d", i);
 
165
                assert((ae = archive_entry_new()) != NULL);
 
166
                archive_entry_copy_pathname(ae, path);
 
167
                archive_entry_set_size(ae, datasize);
 
168
                archive_entry_set_filetype(ae, AE_IFREG);
 
169
                assertA(0 == archive_write_header(a, ae));
 
170
                failure("Writing file %s", path);
 
171
                assertEqualIntA(a, datasize,
 
172
                    (size_t)archive_write_data(a, data, datasize));
 
173
                archive_entry_free(ae);
 
174
        }
 
175
        archive_write_close(a);
 
176
        assert(0 == archive_write_finish(a));
 
177
 
 
178
        /* Level 0 really does result in larger data. */
 
179
        failure("Compression-level=0 wrote %d bytes; default wrote %d bytes",
 
180
            (int)used2, (int)used1);
 
181
        assert(used2 > used1);
 
182
 
 
183
        assert((a = archive_read_new()) != NULL);
 
184
        assertA(0 == archive_read_support_format_all(a));
 
185
        assertA(0 == archive_read_support_compression_all(a));
 
186
        assertA(0 == archive_read_open_memory(a, buff, used2));
 
187
        for (i = 0; i < 999; i++) {
 
188
                sprintf(path, "file%03d", i);
 
189
                if (!assertEqualInt(0, archive_read_next_header(a, &ae)))
 
190
                        break;
 
191
                assertEqualString(path, archive_entry_pathname(ae));
 
192
                assertEqualInt((int)datasize, archive_entry_size(ae));
 
193
        }
 
194
        assert(0 == archive_read_close(a));
 
195
        assert(0 == archive_read_finish(a));
 
196
 
 
197
        /*
 
198
         * Test various premature shutdown scenarios to make sure we
 
199
         * don't crash or leak memory.
 
200
         */
 
201
        assert((a = archive_write_new()) != NULL);
 
202
        assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_bzip2(a));
 
203
        assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
 
204
 
 
205
        assert((a = archive_write_new()) != NULL);
 
206
        assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_bzip2(a));
 
207
        assertEqualInt(ARCHIVE_OK, archive_write_close(a));
 
208
        assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
 
209
 
 
210
        assert((a = archive_write_new()) != NULL);
 
211
        assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
 
212
        assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_bzip2(a));
 
213
        assertEqualInt(ARCHIVE_OK, archive_write_close(a));
 
214
        assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
 
215
 
 
216
        assert((a = archive_write_new()) != NULL);
 
217
        assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
 
218
        assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_bzip2(a));
 
219
        assertA(0 == archive_write_open_memory(a, buff, buffsize, &used2));
 
220
        assertEqualInt(ARCHIVE_OK, archive_write_close(a));
 
221
        assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
 
222
 
 
223
        /*
 
224
         * Clean up.
 
225
         */
 
226
        free(data);
 
227
        free(buff);
 
228
}