2 * Copyright (c) Meta Platforms, Inc. and affiliates.
5 * This source code is licensed under both the BSD-style license (found in the
6 * LICENSE file in the root directory of this source tree) and the GPLv2 (found
7 * in the COPYING file in the root directory of this source tree).
8 * You may select, at your option, one of the above-listed licenses.
15 #include <linux/zstd.h>
20 fprintf(stderr, "%s:%u: %s failed!\n", __FUNCTION__, __LINE__, #x); \
33 static test_data_t create_test_data(void) {
35 data.dataSize = 128 * 1024;
36 data.data = (char*)malloc(data.dataSize);
37 CONTROL(data.data != NULL);
38 data.data2 = (char*)malloc(data.dataSize);
39 CONTROL(data.data2 != NULL);
40 data.compSize = zstd_compress_bound(data.dataSize);
41 data.comp = (char*)malloc(data.compSize);
42 CONTROL(data.comp != NULL);
43 memset(data.data, 0, data.dataSize);
47 static void free_test_data(test_data_t const *data) {
53 #define MIN(a, b) ((a) < (b) ? (a) : (b))
54 #define MAX(a, b) ((a) > (b) ? (a) : (b))
56 static void test_btrfs(test_data_t const *data) {
57 size_t const size = MIN(data->dataSize, 128 * 1024);
58 fprintf(stderr, "testing btrfs use cases... ");
59 for (int level = -1; level < 16; ++level) {
60 zstd_parameters params = zstd_get_params(level, size);
61 size_t const workspaceSize =
62 MAX(zstd_cstream_workspace_bound(¶ms.cParams),
63 zstd_dstream_workspace_bound(size));
64 void *workspace = malloc(workspaceSize);
66 char const *ip = data->data;
67 char const *iend = ip + size;
68 char *op = data->comp;
69 char *oend = op + data->compSize;
71 CONTROL(params.cParams.windowLog <= 17);
72 CONTROL(workspace != NULL);
74 zstd_cstream *cctx = zstd_init_cstream(¶ms, size, workspace, workspaceSize);
75 zstd_out_buffer out = {NULL, 0, 0};
76 zstd_in_buffer in = {NULL, 0, 0};
77 CONTROL(cctx != NULL);
79 if (in.pos == in.size) {
81 in.size = MIN(4096, iend - ip);
86 if (out.pos == out.size) {
88 out.size = MIN(4096, oend - op);
93 if (ip != iend || in.pos < in.size) {
94 CONTROL(!zstd_is_error(zstd_compress_stream(cctx, &out, &in)));
96 size_t const ret = zstd_end_stream(cctx, &out);
97 CONTROL(!zstd_is_error(ret));
111 zstd_dstream *dctx = zstd_init_dstream(1ULL << params.cParams.windowLog, workspace, workspaceSize);
112 zstd_out_buffer out = {NULL, 0, 0};
113 zstd_in_buffer in = {NULL, 0, 0};
114 CONTROL(dctx != NULL);
116 if (in.pos == in.size) {
118 in.size = MIN(4096, iend - ip);
123 if (out.pos == out.size) {
125 out.size = MIN(4096, oend - op);
130 size_t const ret = zstd_decompress_stream(dctx, &out, &in);
131 CONTROL(!zstd_is_error(ret));
138 CONTROL((size_t)(op - data->data2) == data->dataSize);
139 CONTROL(!memcmp(data->data, data->data2, data->dataSize));
142 fprintf(stderr, "Ok\n");
145 static void test_decompress_unzstd(test_data_t const *data) {
147 fprintf(stderr, "Testing decompress unzstd... ");
149 zstd_parameters params = zstd_get_params(19, 0);
150 size_t const wkspSize = zstd_cctx_workspace_bound(¶ms.cParams);
151 void* wksp = malloc(wkspSize);
152 zstd_cctx* cctx = zstd_init_cctx(wksp, wkspSize);
153 CONTROL(wksp != NULL);
154 CONTROL(cctx != NULL);
155 cSize = zstd_compress_cctx(cctx, data->comp, data->compSize, data->data, data->dataSize, ¶ms);
156 CONTROL(!zstd_is_error(cSize));
160 size_t const wkspSize = zstd_dctx_workspace_bound();
161 void* wksp = malloc(wkspSize);
162 zstd_dctx* dctx = zstd_init_dctx(wksp, wkspSize);
163 CONTROL(wksp != NULL);
164 CONTROL(dctx != NULL);
166 size_t const dSize = zstd_decompress_dctx(dctx, data->data2, data->dataSize, data->comp, cSize);
167 CONTROL(!zstd_is_error(dSize));
168 CONTROL(dSize == data->dataSize);
170 CONTROL(!memcmp(data->data, data->data2, data->dataSize));
173 fprintf(stderr, "Ok\n");
176 static void test_f2fs(void) {
177 fprintf(stderr, "testing f2fs uses... ");
178 CONTROL(zstd_min_clevel() < 0);
179 CONTROL(zstd_max_clevel() == 22);
180 fprintf(stderr, "Ok\n");
183 static char *g_stack = NULL;
185 static void __attribute__((noinline)) use(void *x) {
186 asm volatile("" : "+r"(x));
189 static void __attribute__((noinline)) fill_stack(void) {
190 memset(g_stack, 0x33, 8192);
193 static void __attribute__((noinline)) set_stack(void) {
200 static void __attribute__((noinline)) check_stack(void) {
201 size_t cleanStack = 0;
202 while (cleanStack < 8192 && g_stack[cleanStack] == 0x33) {
206 size_t const stackSize = 8192 - cleanStack;
207 fprintf(stderr, "Maximum stack size: %zu\n", stackSize);
208 CONTROL(stackSize <= 2048 + 512);
212 static void test_stack_usage(test_data_t const *data) {
217 test_decompress_unzstd(data);
222 test_data_t data = create_test_data();
225 test_decompress_unzstd(&data);
226 test_stack_usage(&data);
227 free_test_data(&data);