← Back to branch summary

~ubuntu-branches/ubuntu/quantal/libarchive/quantal

« back to all changes in this revision

Viewing changes to libarchive/test/test_write_compress_lzma.c

  • Committer: Package Import Robot
  • Author(s): Andres Mejia
  • Date: 2012-02-23 19:29:24 UTC
  • mfrom: (8.1.10 sid)
  • Revision ID: package-import@ubuntu.com-20120223192924-73n4iedok5fwgsyr
Tags: 3.0.3-5
* Detect if locales or locales-all is installed for use with test suite.
* Bump Standards-Version to 3.9.3.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libarchive/test/test_write_compress_lzma.c
53
53
         * Write a 100 files and read them all back.
54
54
         */
55
55
        assert((a = archive_write_new()) != NULL);
56
 
        assertA(0 == archive_write_set_format_ustar(a));
 
56
        assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
57
57
        r = archive_write_set_compression_lzma(a);
58
58
        if (r == ARCHIVE_FATAL) {
59
59
                skipping("lzma writing not supported on this platform");
60
 
                assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
 
60
                assertEqualInt(ARCHIVE_OK, archive_write_free(a));
61
61
                return;
62
62
        }
63
63
        assertEqualIntA(a, ARCHIVE_OK,
64
64
            archive_write_set_bytes_per_block(a, 10));
65
65
        assertEqualInt(ARCHIVE_COMPRESSION_LZMA, archive_compression(a));
66
66
        assertEqualString("lzma", archive_compression_name(a));
67
 
        assertA(0 == archive_write_open_memory(a, buff, buffsize, &used1));
 
67
        assertEqualIntA(a, ARCHIVE_OK,
 
68
            archive_write_open_memory(a, buff, buffsize, &used1));
68
69
        assertEqualInt(ARCHIVE_COMPRESSION_LZMA, archive_compression(a));
69
70
        assertEqualString("lzma", archive_compression_name(a));
70
71
        assert((ae = archive_entry_new()) != NULL);
73
74
        for (i = 0; i < 100; i++) {
74
75
                sprintf(path, "file%03d", i);
75
76
                archive_entry_copy_pathname(ae, path);
76
 
                assertA(0 == archive_write_header(a, ae));
 
77
                assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
77
78
                assertA(datasize
78
79
                    == (size_t)archive_write_data(a, data, datasize));
79
80
        }
80
81
        archive_entry_free(ae);
81
 
        archive_write_close(a);
82
 
        assert(0 == archive_write_finish(a));
 
82
        assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
 
83
        assertEqualInt(ARCHIVE_OK, archive_write_free(a));
83
84
 
84
85
        assert((a = archive_read_new()) != NULL);
85
 
        assertA(0 == archive_read_support_format_all(a));
86
 
        r = archive_read_support_compression_lzma(a);
 
86
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 
87
        r = archive_read_support_filter_lzma(a);
87
88
        if (r == ARCHIVE_WARN) {
88
89
                skipping("Can't verify lzma writing by reading back;"
89
90
                    " lzma reading not fully supported on this platform");
90
91
        } else {
91
92
                assertEqualIntA(a, ARCHIVE_OK,
92
 
                    archive_read_support_compression_all(a));
 
93
                    archive_read_support_filter_all(a));
93
94
                assertEqualIntA(a, ARCHIVE_OK,
94
95
                    archive_read_open_memory(a, buff, used1));
95
96
                for (i = 0; i < 100; i++) {
102
103
                }
103
104
                assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
104
105
        }
105
 
        assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
 
106
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
106
107
 
107
108
        /*
108
109
         * Repeat the cycle again, this time setting some compression
109
110
         * options.
110
111
         */
111
112
        assert((a = archive_write_new()) != NULL);
112
 
        assertA(0 == archive_write_set_format_ustar(a));
 
113
        assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
113
114
        assertEqualIntA(a, ARCHIVE_OK,
114
115
            archive_write_set_bytes_per_block(a, 10));
115
 
        assertA(0 == archive_write_set_compression_lzma(a));
116
 
        assertEqualIntA(a, ARCHIVE_WARN,
117
 
            archive_write_set_compressor_options(a, "nonexistent-option=0"));
118
 
        assertEqualIntA(a, ARCHIVE_WARN,
119
 
            archive_write_set_compressor_options(a, "compression-level=abc"));
120
 
        assertEqualIntA(a, ARCHIVE_WARN,
121
 
            archive_write_set_compressor_options(a, "compression-level=99"));
 
116
        assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_lzma(a));
 
117
        assertEqualIntA(a, ARCHIVE_FAILED,
 
118
            archive_write_set_filter_option(a, NULL, "nonexistent-option", "0"));
 
119
        assertEqualIntA(a, ARCHIVE_FAILED,
 
120
            archive_write_set_filter_option(a, NULL, "compression-level", "abc"));
 
121
        assertEqualIntA(a, ARCHIVE_FAILED,
 
122
            archive_write_set_filter_option(a, NULL, "compression-level", "99"));
122
123
        assertEqualIntA(a, ARCHIVE_OK,
123
 
            archive_write_set_compressor_options(a, "compression-level=9"));
124
 
        assertA(0 == archive_write_open_memory(a, buff, buffsize, &used2));
 
124
            archive_write_set_filter_option(a, NULL, "compression-level", "9"));
 
125
        assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, buffsize, &used2));
125
126
        for (i = 0; i < 100; i++) {
126
127
                sprintf(path, "file%03d", i);
127
128
                assert((ae = archive_entry_new()) != NULL);
128
129
                archive_entry_copy_pathname(ae, path);
129
130
                archive_entry_set_size(ae, datasize);
130
131
                archive_entry_set_filetype(ae, AE_IFREG);
131
 
                assertA(0 == archive_write_header(a, ae));
 
132
                assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
132
133
                assertA(datasize == (size_t)archive_write_data(a, data, datasize));
133
134
                archive_entry_free(ae);
134
135
        }
135
 
        archive_write_close(a);
136
 
        assert(0 == archive_write_finish(a));
 
136
        assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
 
137
        assertEqualInt(ARCHIVE_OK, archive_write_free(a));
137
138
 
138
139
 
139
140
        assert((a = archive_read_new()) != NULL);
140
141
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
141
 
        r = archive_read_support_compression_lzma(a);
 
142
        r = archive_read_support_filter_lzma(a);
142
143
        if (r == ARCHIVE_WARN) {
143
144
                skipping("lzma reading not fully supported on this platform");
144
145
        } else {
145
146
                assertEqualIntA(a, ARCHIVE_OK,
146
 
                    archive_read_support_compression_all(a));
 
147
                    archive_read_support_filter_all(a));
147
148
                assertEqualIntA(a, ARCHIVE_OK,
148
149
                    archive_read_open_memory(a, buff, used2));
149
150
                for (i = 0; i < 100; i++) {
157
158
                }
158
159
                assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
159
160
        }
160
 
        assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
 
161
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
161
162
 
162
163
        /*
163
164
         * Repeat again, with much lower compression.
164
165
         */
165
166
        assert((a = archive_write_new()) != NULL);
166
 
        assertA(0 == archive_write_set_format_ustar(a));
 
167
        assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
167
168
        assertEqualIntA(a, ARCHIVE_OK,
168
169
            archive_write_set_bytes_per_block(a, 10));
169
 
        assertA(0 == archive_write_set_compression_lzma(a));
 
170
        assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_lzma(a));
170
171
        assertEqualIntA(a, ARCHIVE_OK,
171
 
            archive_write_set_compressor_options(a, "compression-level=0"));
172
 
        assertA(0 == archive_write_open_memory(a, buff, buffsize, &used2));
 
172
            archive_write_set_filter_option(a, NULL, "compression-level", "0"));
 
173
        assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, buffsize, &used2));
173
174
        for (i = 0; i < 100; i++) {
174
175
                sprintf(path, "file%03d", i);
175
176
                assert((ae = archive_entry_new()) != NULL);
176
177
                archive_entry_copy_pathname(ae, path);
177
178
                archive_entry_set_size(ae, datasize);
178
179
                archive_entry_set_filetype(ae, AE_IFREG);
179
 
                assertA(0 == archive_write_header(a, ae));
 
180
                assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
180
181
                failure("Writing file %s", path);
181
182
                assertEqualIntA(a, datasize,
182
183
                    (size_t)archive_write_data(a, data, datasize));
183
184
                archive_entry_free(ae);
184
185
        }
185
 
        archive_write_close(a);
186
 
        assert(0 == archive_write_finish(a));
 
186
        assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
 
187
        assertEqualInt(ARCHIVE_OK, archive_write_free(a));
187
188
 
188
189
        /* It would be nice to assert that compression-level=0 produced
189
190
         * consistently larger/smaller results than the default compression,
196
197
        */
197
198
 
198
199
        assert((a = archive_read_new()) != NULL);
199
 
        assertA(0 == archive_read_support_format_all(a));
200
 
        assertA(0 == archive_read_support_compression_all(a));
201
 
        r = archive_read_support_compression_lzma(a);
 
200
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 
201
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 
202
        r = archive_read_support_filter_lzma(a);
202
203
        if (r == ARCHIVE_WARN) {
203
204
                skipping("lzma reading not fully supported on this platform");
204
205
        } else {
214
215
                }
215
216
                assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
216
217
        }
217
 
        assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
 
218
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
218
219
 
219
220
        /*
220
221
         * Test various premature shutdown scenarios to make sure we
222
223
         */
223
224
        assert((a = archive_write_new()) != NULL);
224
225
        assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_lzma(a));
225
 
        assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
226
 
 
227
 
        assert((a = archive_write_new()) != NULL);
228
 
        assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_lzma(a));
229
 
        assertEqualInt(ARCHIVE_OK, archive_write_close(a));
230
 
        assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
231
 
 
232
 
        assert((a = archive_write_new()) != NULL);
233
 
        assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
234
 
        assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_lzma(a));
235
 
        assertEqualInt(ARCHIVE_OK, archive_write_close(a));
236
 
        assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
237
 
 
238
 
        assert((a = archive_write_new()) != NULL);
239
 
        assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
240
 
        assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_lzma(a));
241
 
        assertA(0 == archive_write_open_memory(a, buff, buffsize, &used2));
242
 
        assertEqualInt(ARCHIVE_OK, archive_write_close(a));
243
 
        assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
 
226
        assertEqualInt(ARCHIVE_OK, archive_write_free(a));
 
227
 
 
228
        assert((a = archive_write_new()) != NULL);
 
229
        assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_lzma(a));
 
230
        assertEqualInt(ARCHIVE_OK, archive_write_close(a));
 
231
        assertEqualInt(ARCHIVE_OK, archive_write_free(a));
 
232
 
 
233
        assert((a = archive_write_new()) != NULL);
 
234
        assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
 
235
        assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_lzma(a));
 
236
        assertEqualInt(ARCHIVE_OK, archive_write_close(a));
 
237
        assertEqualInt(ARCHIVE_OK, archive_write_free(a));
 
238
 
 
239
        assert((a = archive_write_new()) != NULL);
 
240
        assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
 
241
        assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_lzma(a));
 
242
        assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, buffsize, &used2));
 
243
        assertEqualInt(ARCHIVE_OK, archive_write_close(a));
 
244
        assertEqualInt(ARCHIVE_OK, archive_write_free(a));
244
245
 
245
246
        /*
246
247
         * Clean up.