[pcsx_rearmed.git] / deps / libchdr / deps / zstd-1.5.5 / contrib / seekable_format / tests / seekable_tests.c

#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>  // malloc
#include <stdio.h>
#include <assert.h>
#include <string.h>

#include "../zstd_seekable.h"


/* ZSTD_seekable_customFile implementation that reads/seeks a buffer while keeping track of total bytes read */
typedef struct {
    const void *ptr;
    size_t size;
    size_t pos;
    size_t totalRead;
} buffWrapperWithTotal_t;

static int readBuffWithTotal(void* opaque, void* buffer, size_t n)
{
    buffWrapperWithTotal_t* const buff = (buffWrapperWithTotal_t*)opaque;
    assert(buff != NULL);
    if (buff->pos + n > buff->size) return -1;
    memcpy(buffer, (const char*)buff->ptr + buff->pos, n);
    buff->pos += n;
    buff->totalRead += n;
    return 0;
}

static int seekBuffWithTotal(void* opaque, long long offset, int origin)
{
    buffWrapperWithTotal_t* const buff = (buffWrapperWithTotal_t*) opaque;
    unsigned long long newOffset;
    assert(buff != NULL);
    switch (origin) {
    case SEEK_SET:
        assert(offset >= 0);
        newOffset = (unsigned long long)offset;
        break;
    case SEEK_CUR:
        newOffset = (unsigned long long)((long long)buff->pos + offset);
        break;
    case SEEK_END:
        newOffset = (unsigned long long)((long long)buff->size + offset);
        break;
    default:
        assert(0);  /* not possible */
    }
    if (newOffset > buff->size) {
        return -1;
    }
    buff->pos = newOffset;
    return 0;
}

/* Basic unit tests for zstd seekable format */
int main(int argc, const char** argv)
{
    unsigned testNb = 1;
    (void)argc; (void)argv;
    printf("Beginning zstd seekable format tests...\n");

    printf("Test %u - simple round trip: ", testNb++);
    {   size_t const inSize = 4000;
        void* const inBuffer = malloc(inSize);
        assert(inBuffer != NULL);

        size_t const seekCapacity = 5000;
        void* const seekBuffer = malloc(seekCapacity);
        assert(seekBuffer != NULL);
        size_t seekSize;

        size_t const outCapacity = inSize;
        void* const outBuffer = malloc(outCapacity);
        assert(outBuffer != NULL);

        ZSTD_seekable_CStream* const zscs = ZSTD_seekable_createCStream();
        assert(zscs != NULL);

        { size_t const initStatus = ZSTD_seekable_initCStream(zscs, 9, 0 /* checksumFlag */, (unsigned)inSize /* maxFrameSize */);
          assert(!ZSTD_isError(initStatus));
        }

        {   ZSTD_outBuffer outb = { .dst=seekBuffer, .pos=0, .size=seekCapacity };
            ZSTD_inBuffer inb = { .src=inBuffer, .pos=0, .size=inSize };

            size_t const cStatus = ZSTD_seekable_compressStream(zscs, &outb, &inb);
            assert(!ZSTD_isError(cStatus));
            assert(inb.pos == inb.size);

            size_t const endStatus = ZSTD_seekable_endStream(zscs, &outb);
            assert(!ZSTD_isError(endStatus));
            seekSize = outb.pos;
        }

        ZSTD_seekable* const stream = ZSTD_seekable_create();
        assert(stream != NULL);
        { size_t const initStatus = ZSTD_seekable_initBuff(stream, seekBuffer, seekSize);
          assert(!ZSTD_isError(initStatus)); }

        { size_t const decStatus = ZSTD_seekable_decompress(stream, outBuffer, outCapacity, 0);
          assert(decStatus == inSize); }

        /* unit test ZSTD_seekTable functions */
        ZSTD_seekTable* const zst = ZSTD_seekTable_create_fromSeekable(stream);
        assert(zst != NULL);

        unsigned const nbFrames = ZSTD_seekTable_getNumFrames(zst);
        assert(nbFrames > 0);

        unsigned long long const frame0Offset = ZSTD_seekTable_getFrameCompressedOffset(zst, 0);
        assert(frame0Offset == 0);

        unsigned long long const content0Offset = ZSTD_seekTable_getFrameDecompressedOffset(zst, 0);
        assert(content0Offset == 0);

        size_t const cSize = ZSTD_seekTable_getFrameCompressedSize(zst, 0);
        assert(!ZSTD_isError(cSize));
        assert(cSize <= seekCapacity);

        size_t const origSize = ZSTD_seekTable_getFrameDecompressedSize(zst, 0);
        assert(origSize == inSize);

        unsigned const fo1idx = ZSTD_seekTable_offsetToFrameIndex(zst, 1);
        assert(fo1idx == 0);

        free(inBuffer);
        free(seekBuffer);
        free(outBuffer);
        ZSTD_seekable_freeCStream(zscs);
        ZSTD_seekTable_free(zst);
        ZSTD_seekable_free(stream);
    }
    printf("Success!\n");


    printf("Test %u - check that seekable decompress does not hang: ", testNb++);
    {   /* Github issue #2335 */
        const size_t compressed_size = 17;
        const uint8_t compressed_data[17] = {
            '^',
            '*',
            'M',
            '\x18',
            '\t',
            '\x00',
            '\x00',
            '\x00',
            '\x00',
            '\x00',
            '\x00',
            '\x00',
            (uint8_t)('\x03'),
            (uint8_t)('\xb1'),
            (uint8_t)('\xea'),
            (uint8_t)('\x92'),
            (uint8_t)('\x8f'),
        };
        const size_t uncompressed_size = 32;
        uint8_t uncompressed_data[32];

        ZSTD_seekable* const stream = ZSTD_seekable_create();
        assert(stream != NULL);
        {   size_t const status = ZSTD_seekable_initBuff(stream, compressed_data, compressed_size);
            if (ZSTD_isError(status)) {
                ZSTD_seekable_free(stream);
                goto _test_error;
        }   }

        /* Should return an error, but not hang */
        {   const size_t offset = 2;
            size_t const status = ZSTD_seekable_decompress(stream, uncompressed_data, uncompressed_size, offset);
            if (!ZSTD_isError(status)) {
                ZSTD_seekable_free(stream);
                goto _test_error;
        }   }

        ZSTD_seekable_free(stream);
    }
    printf("Success!\n");

    printf("Test %u - check #2 that seekable decompress does not hang: ", testNb++);
    {   /* Github issue #FIXME */
        const size_t compressed_size = 27;
        const uint8_t compressed_data[27] = {
            (uint8_t)'\x28',
            (uint8_t)'\xb5',
            (uint8_t)'\x2f',
            (uint8_t)'\xfd',
            (uint8_t)'\x00',
            (uint8_t)'\x32',
            (uint8_t)'\x91',
            (uint8_t)'\x00',
            (uint8_t)'\x00',
            (uint8_t)'\x00',
            (uint8_t)'\x5e',
            (uint8_t)'\x2a',
            (uint8_t)'\x4d',
            (uint8_t)'\x18',
            (uint8_t)'\x09',
            (uint8_t)'\x00',
            (uint8_t)'\x00',
            (uint8_t)'\x00',
            (uint8_t)'\x00',
            (uint8_t)'\x00',
            (uint8_t)'\x00',
            (uint8_t)'\x00',
            (uint8_t)'\x00',
            (uint8_t)'\xb1',
            (uint8_t)'\xea',
            (uint8_t)'\x92',
            (uint8_t)'\x8f',
        };
        const size_t uncompressed_size = 400;
        uint8_t uncompressed_data[400];

        ZSTD_seekable* stream = ZSTD_seekable_create();
        size_t status = ZSTD_seekable_initBuff(stream, compressed_data, compressed_size);
        if (ZSTD_isError(status)) {
            ZSTD_seekable_free(stream);
            goto _test_error;
        }

        const size_t offset = 2;
        /* Should return an error, but not hang */
        status = ZSTD_seekable_decompress(stream, uncompressed_data, uncompressed_size, offset);
        if (!ZSTD_isError(status)) {
            ZSTD_seekable_free(stream);
            goto _test_error;
        }

        ZSTD_seekable_free(stream);
    }
    printf("Success!\n");


    printf("Test %u - check ZSTD magic in compressing empty string: ", testNb++);
    { // compressing empty string should return a zstd header
        size_t const capacity = 255;
        char* inBuffer = malloc(capacity);
        assert(inBuffer != NULL);
        inBuffer[0] = '\0';
        void* const outBuffer = malloc(capacity);
        assert(outBuffer != NULL);

        ZSTD_seekable_CStream *s = ZSTD_seekable_createCStream();
        ZSTD_seekable_initCStream(s, 1, 1, 255);

        ZSTD_inBuffer input = { .src=inBuffer, .pos=0, .size=0 };
        ZSTD_outBuffer output = { .dst=outBuffer, .pos=0, .size=capacity };

        ZSTD_seekable_compressStream(s, &output, &input);
        ZSTD_seekable_endStream(s, &output);

        if((((char*)output.dst)[0] != '\x28') | (((char*)output.dst)[1] != '\xb5') | (((char*)output.dst)[2] != '\x2f') | (((char*)output.dst)[3] != '\xfd')) {
            printf("%#02x %#02x %#02x %#02x\n", ((char*)output.dst)[0], ((char*)output.dst)[1] , ((char*)output.dst)[2] , ((char*)output.dst)[3] );

            free(inBuffer);
            free(outBuffer);
            ZSTD_seekable_freeCStream(s);
            goto _test_error;
        }

        free(inBuffer);
        free(outBuffer);
        ZSTD_seekable_freeCStream(s);
    }
    printf("Success!\n");


    printf("Test %u - multiple decompress calls: ", testNb++);
    {   char const inBuffer[] = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt";
        size_t const inSize = sizeof(inBuffer);

        size_t const seekCapacity = 5000;
        void* const seekBuffer = malloc(seekCapacity);
        assert(seekBuffer != NULL);
        size_t seekSize;

        size_t const outCapacity = inSize;
        char* const outBuffer = malloc(outCapacity);
        assert(outBuffer != NULL);

        ZSTD_seekable_CStream* const zscs = ZSTD_seekable_createCStream();
        assert(zscs != NULL);

        /* compress test data with a small frame size to ensure multiple frames in the output */
        unsigned const maxFrameSize = 40;
        { size_t const initStatus = ZSTD_seekable_initCStream(zscs, 9, 0 /* checksumFlag */, maxFrameSize);
          assert(!ZSTD_isError(initStatus));
        }

        {   ZSTD_outBuffer outb = { .dst=seekBuffer, .pos=0, .size=seekCapacity };
            ZSTD_inBuffer inb = { .src=inBuffer, .pos=0, .size=inSize };

            while (inb.pos < inb.size) {
                size_t const cStatus = ZSTD_seekable_compressStream(zscs, &outb, &inb);
                assert(!ZSTD_isError(cStatus));
            }

            size_t const endStatus = ZSTD_seekable_endStream(zscs, &outb);
            assert(!ZSTD_isError(endStatus));
            seekSize = outb.pos;
        }

        ZSTD_seekable* const stream = ZSTD_seekable_create();
        assert(stream != NULL);
        buffWrapperWithTotal_t buffWrapper = {seekBuffer, seekSize, 0, 0};
        { ZSTD_seekable_customFile srcFile = {&buffWrapper, &readBuffWithTotal, &seekBuffWithTotal};
          size_t const initStatus = ZSTD_seekable_initAdvanced(stream, srcFile);
          assert(!ZSTD_isError(initStatus)); }

        /* Perform a series of small reads and seeks (repeatedly read 1 byte and skip 1 byte)
           and check that we didn't reread input data unnecessarily */
        size_t pos;
        for (pos = 0; pos < inSize; pos += 2) {
            size_t const decStatus = ZSTD_seekable_decompress(stream, outBuffer, 1, pos);
            if (decStatus != 1 || outBuffer[0] != inBuffer[pos]) {
                goto _test_error;
            }
        }
        if (buffWrapper.totalRead > seekSize) {
            /* We read more than the compressed size, meaning there were some rereads.
               This is unneeded because we only seeked forward. */
            printf("Too much data read: %zu read, with compressed size %zu\n", buffWrapper.totalRead, seekSize);
            goto _test_error;
        }

        /* Perform some reads and seeks to ensure correctness */
        struct {
            size_t offset;
            size_t size;
        } const tests[] = {  /* Assume the frame size is 40 */
            {20, 40}, /* read partial data from two frames */
            {60, 10}, /* continue reading from the same offset */
            {50, 20}, /* seek backward within the same frame */
            {10, 10}, /* seek backward to a different frame */
            {25, 10}, /* seek forward within the same frame */
            {60, 10}, /* seek forward to a different frame */
        };
        size_t idx;
        for (idx = 0; idx < sizeof(tests) / sizeof(tests[0]); idx++) {
            size_t const decStatus = ZSTD_seekable_decompress(stream, outBuffer, tests[idx].size, tests[idx].offset);
            if (decStatus != tests[idx].size || memcmp(outBuffer, inBuffer + tests[idx].offset, tests[idx].size) != 0) {
                goto _test_error;
            }
        }

        free(seekBuffer);
        free(outBuffer);
        ZSTD_seekable_freeCStream(zscs);
        ZSTD_seekable_free(stream);
    }
    printf("Success!\n");

    /* TODO: Add more tests */
    printf("Finished tests\n");
    return 0;

_test_error:
    printf("test failed! Exiting..\n");
    return 1;
}
Commit	Line	Data
648db22b	1	#include <stddef.h>
	2	#include <stdint.h>
	3	#include <stdlib.h> // malloc
	4	#include <stdio.h>
	5	#include <assert.h>
	6	#include <string.h>
	7
	8	#include "../zstd_seekable.h"
	9
	10
	11	/* ZSTD_seekable_customFile implementation that reads/seeks a buffer while keeping track of total bytes read */
	12	typedef struct {
	13	const void *ptr;
	14	size_t size;
	15	size_t pos;
	16	size_t totalRead;
	17	} buffWrapperWithTotal_t;
	18
	19	static int readBuffWithTotal(void* opaque, void* buffer, size_t n)
	20	{
	21	buffWrapperWithTotal_t* const buff = (buffWrapperWithTotal_t*)opaque;
	22	assert(buff != NULL);
	23	if (buff->pos + n > buff->size) return -1;
	24	memcpy(buffer, (const char*)buff->ptr + buff->pos, n);
	25	buff->pos += n;
	26	buff->totalRead += n;
	27	return 0;
	28	}
	29
	30	static int seekBuffWithTotal(void* opaque, long long offset, int origin)
	31	{
	32	buffWrapperWithTotal_t* const buff = (buffWrapperWithTotal_t*) opaque;
	33	unsigned long long newOffset;
	34	assert(buff != NULL);
	35	switch (origin) {
	36	case SEEK_SET:
	37	assert(offset >= 0);
	38	newOffset = (unsigned long long)offset;
	39	break;
	40	case SEEK_CUR:
	41	newOffset = (unsigned long long)((long long)buff->pos + offset);
	42	break;
	43	case SEEK_END:
	44	newOffset = (unsigned long long)((long long)buff->size + offset);
	45	break;
	46	default:
	47	assert(0); /* not possible */
	48	}
	49	if (newOffset > buff->size) {
	50	return -1;
	51	}
	52	buff->pos = newOffset;
	53	return 0;
	54	}
	55
	56	/* Basic unit tests for zstd seekable format */
	57	int main(int argc, const char** argv)
	58	{
	59	unsigned testNb = 1;
	60	(void)argc; (void)argv;
	61	printf("Beginning zstd seekable format tests...\n");
	62
	63	printf("Test %u - simple round trip: ", testNb++);
	64	{ size_t const inSize = 4000;
65	void* const inBuffer = malloc(inSize);
66	assert(inBuffer != NULL);
67
68	size_t const seekCapacity = 5000;
69	void* const seekBuffer = malloc(seekCapacity);
70	assert(seekBuffer != NULL);
71	size_t seekSize;
72
73	size_t const outCapacity = inSize;
74	void* const outBuffer = malloc(outCapacity);
75	assert(outBuffer != NULL);
76
77	ZSTD_seekable_CStream* const zscs = ZSTD_seekable_createCStream();
78	assert(zscs != NULL);
79
80	{ size_t const initStatus = ZSTD_seekable_initCStream(zscs, 9, 0 /* checksumFlag /, (unsigned)inSize / maxFrameSize */);
81	assert(!ZSTD_isError(initStatus));
82	}
83
84	{ ZSTD_outBuffer outb = { .dst=seekBuffer, .pos=0, .size=seekCapacity };
85	ZSTD_inBuffer inb = { .src=inBuffer, .pos=0, .size=inSize };
86
87	size_t const cStatus = ZSTD_seekable_compressStream(zscs, &outb, &inb);
88	assert(!ZSTD_isError(cStatus));
89	assert(inb.pos == inb.size);
90
91	size_t const endStatus = ZSTD_seekable_endStream(zscs, &outb);
92	assert(!ZSTD_isError(endStatus));
93	seekSize = outb.pos;
94	}
95
96	ZSTD_seekable* const stream = ZSTD_seekable_create();
97	assert(stream != NULL);
98	{ size_t const initStatus = ZSTD_seekable_initBuff(stream, seekBuffer, seekSize);
99	assert(!ZSTD_isError(initStatus)); }
100
101	{ size_t const decStatus = ZSTD_seekable_decompress(stream, outBuffer, outCapacity, 0);
102	assert(decStatus == inSize); }
103
104	/* unit test ZSTD_seekTable functions */
105	ZSTD_seekTable* const zst = ZSTD_seekTable_create_fromSeekable(stream);
106	assert(zst != NULL);
107
108	unsigned const nbFrames = ZSTD_seekTable_getNumFrames(zst);
109	assert(nbFrames > 0);
110
111	unsigned long long const frame0Offset = ZSTD_seekTable_getFrameCompressedOffset(zst, 0);
112	assert(frame0Offset == 0);
113
114	unsigned long long const content0Offset = ZSTD_seekTable_getFrameDecompressedOffset(zst, 0);
115	assert(content0Offset == 0);
116
117	size_t const cSize = ZSTD_seekTable_getFrameCompressedSize(zst, 0);
118	assert(!ZSTD_isError(cSize));
119	assert(cSize <= seekCapacity);
120
121	size_t const origSize = ZSTD_seekTable_getFrameDecompressedSize(zst, 0);
122	assert(origSize == inSize);
123
124	unsigned const fo1idx = ZSTD_seekTable_offsetToFrameIndex(zst, 1);
125	assert(fo1idx == 0);
126
127	free(inBuffer);
128	free(seekBuffer);
129	free(outBuffer);
130	ZSTD_seekable_freeCStream(zscs);
131	ZSTD_seekTable_free(zst);
132	ZSTD_seekable_free(stream);
133	}
134	printf("Success!\n");
135
136
137	printf("Test %u - check that seekable decompress does not hang: ", testNb++);
138	{ /* Github issue #2335 */
139	const size_t compressed_size = 17;
140	const uint8_t compressed_data[17] = {
141	'^',
142	'*',
143	'M',
144	'\x18',
145	'\t',
146	'\x00',
147	'\x00',
148	'\x00',
149	'\x00',
150	'\x00',
151	'\x00',
152	'\x00',
153	(uint8_t)('\x03'),
154	(uint8_t)('\xb1'),
155	(uint8_t)('\xea'),
156	(uint8_t)('\x92'),
157	(uint8_t)('\x8f'),
158	};
159	const size_t uncompressed_size = 32;
160	uint8_t uncompressed_data[32];
161
162	ZSTD_seekable* const stream = ZSTD_seekable_create();
163	assert(stream != NULL);
164	{ size_t const status = ZSTD_seekable_initBuff(stream, compressed_data, compressed_size);
165	if (ZSTD_isError(status)) {
166	ZSTD_seekable_free(stream);
167	goto _test_error;
168	} }
169
170	/* Should return an error, but not hang */
171	{ const size_t offset = 2;
172	size_t const status = ZSTD_seekable_decompress(stream, uncompressed_data, uncompressed_size, offset);
173	if (!ZSTD_isError(status)) {
174	ZSTD_seekable_free(stream);
175	goto _test_error;
176	} }
177
178	ZSTD_seekable_free(stream);
179	}
180	printf("Success!\n");
181
182	printf("Test %u - check #2 that seekable decompress does not hang: ", testNb++);
183	{ /* Github issue #FIXME */
184	const size_t compressed_size = 27;
185	const uint8_t compressed_data[27] = {
186	(uint8_t)'\x28',
187	(uint8_t)'\xb5',
188	(uint8_t)'\x2f',
189	(uint8_t)'\xfd',
190	(uint8_t)'\x00',
191	(uint8_t)'\x32',
192	(uint8_t)'\x91',
193	(uint8_t)'\x00',
194	(uint8_t)'\x00',
195	(uint8_t)'\x00',
196	(uint8_t)'\x5e',
197	(uint8_t)'\x2a',
198	(uint8_t)'\x4d',
199	(uint8_t)'\x18',
200	(uint8_t)'\x09',
201	(uint8_t)'\x00',
202	(uint8_t)'\x00',
203	(uint8_t)'\x00',
204	(uint8_t)'\x00',
205	(uint8_t)'\x00',
206	(uint8_t)'\x00',
207	(uint8_t)'\x00',
208	(uint8_t)'\x00',
209	(uint8_t)'\xb1',
210	(uint8_t)'\xea',
211	(uint8_t)'\x92',
212	(uint8_t)'\x8f',
213	};
214	const size_t uncompressed_size = 400;
215	uint8_t uncompressed_data[400];
216
217	ZSTD_seekable* stream = ZSTD_seekable_create();
218	size_t status = ZSTD_seekable_initBuff(stream, compressed_data, compressed_size);
219	if (ZSTD_isError(status)) {
220	ZSTD_seekable_free(stream);
221	goto _test_error;
222	}
223
224	const size_t offset = 2;
225	/* Should return an error, but not hang */
226	status = ZSTD_seekable_decompress(stream, uncompressed_data, uncompressed_size, offset);
227	if (!ZSTD_isError(status)) {
228	ZSTD_seekable_free(stream);
229	goto _test_error;
230	}
231
232	ZSTD_seekable_free(stream);
233	}
234	printf("Success!\n");
235
236
237	printf("Test %u - check ZSTD magic in compressing empty string: ", testNb++);
238	{ // compressing empty string should return a zstd header
239	size_t const capacity = 255;
240	char* inBuffer = malloc(capacity);
241	assert(inBuffer != NULL);
242	inBuffer[0] = '\0';
243	void* const outBuffer = malloc(capacity);
244	assert(outBuffer != NULL);
245
246	ZSTD_seekable_CStream *s = ZSTD_seekable_createCStream();
247	ZSTD_seekable_initCStream(s, 1, 1, 255);
248
249	ZSTD_inBuffer input = { .src=inBuffer, .pos=0, .size=0 };
250	ZSTD_outBuffer output = { .dst=outBuffer, .pos=0, .size=capacity };
251
252	ZSTD_seekable_compressStream(s, &output, &input);
253	ZSTD_seekable_endStream(s, &output);
254
255	if((((char)output.dst)[0] != '\x28') \| (((char)output.dst)[1] != '\xb5') \| (((char)output.dst)[2] != '\x2f') \| (((char)output.dst)[3] != '\xfd')) {
256	printf("%#02x %#02x %#02x %#02x\n", ((char)output.dst)[0], ((char)output.dst)[1] , ((char)output.dst)[2] , ((char)output.dst)[3] );
257
258	free(inBuffer);
259	free(outBuffer);
260	ZSTD_seekable_freeCStream(s);
261	goto _test_error;
262	}
263
264	free(inBuffer);
265	free(outBuffer);
266	ZSTD_seekable_freeCStream(s);
267	}
268	printf("Success!\n");
269
270
271	printf("Test %u - multiple decompress calls: ", testNb++);
272	{ char const inBuffer[] = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt";
273	size_t const inSize = sizeof(inBuffer);
274
275	size_t const seekCapacity = 5000;
276	void* const seekBuffer = malloc(seekCapacity);
277	assert(seekBuffer != NULL);
278	size_t seekSize;
279
280	size_t const outCapacity = inSize;
281	char* const outBuffer = malloc(outCapacity);
282	assert(outBuffer != NULL);
283
284	ZSTD_seekable_CStream* const zscs = ZSTD_seekable_createCStream();
285	assert(zscs != NULL);
286
287	/* compress test data with a small frame size to ensure multiple frames in the output */
288	unsigned const maxFrameSize = 40;
289	{ size_t const initStatus = ZSTD_seekable_initCStream(zscs, 9, 0 /* checksumFlag */, maxFrameSize);
290	assert(!ZSTD_isError(initStatus));
291	}
292
293	{ ZSTD_outBuffer outb = { .dst=seekBuffer, .pos=0, .size=seekCapacity };
294	ZSTD_inBuffer inb = { .src=inBuffer, .pos=0, .size=inSize };
295
296	while (inb.pos < inb.size) {
297	size_t const cStatus = ZSTD_seekable_compressStream(zscs, &outb, &inb);
298	assert(!ZSTD_isError(cStatus));
299	}
300
301	size_t const endStatus = ZSTD_seekable_endStream(zscs, &outb);
302	assert(!ZSTD_isError(endStatus));
303	seekSize = outb.pos;
304	}
305
306	ZSTD_seekable* const stream = ZSTD_seekable_create();
307	assert(stream != NULL);
308	buffWrapperWithTotal_t buffWrapper = {seekBuffer, seekSize, 0, 0};
309	{ ZSTD_seekable_customFile srcFile = {&buffWrapper, &readBuffWithTotal, &seekBuffWithTotal};
310	size_t const initStatus = ZSTD_seekable_initAdvanced(stream, srcFile);
311	assert(!ZSTD_isError(initStatus)); }
312
313	/* Perform a series of small reads and seeks (repeatedly read 1 byte and skip 1 byte)
314	and check that we didn't reread input data unnecessarily */
315	size_t pos;
316	for (pos = 0; pos < inSize; pos += 2) {
317	size_t const decStatus = ZSTD_seekable_decompress(stream, outBuffer, 1, pos);
318	if (decStatus != 1 \|\| outBuffer[0] != inBuffer[pos]) {
319	goto _test_error;
320	}
321	}
322	if (buffWrapper.totalRead > seekSize) {
323	/* We read more than the compressed size, meaning there were some rereads.
324	This is unneeded because we only seeked forward. */
325	printf("Too much data read: %zu read, with compressed size %zu\n", buffWrapper.totalRead, seekSize);
326	goto _test_error;
327	}
328
329	/* Perform some reads and seeks to ensure correctness */
330	struct {
331	size_t offset;
332	size_t size;
333	} const tests[] = { /* Assume the frame size is 40 */
334	{20, 40}, /* read partial data from two frames */
335	{60, 10}, /* continue reading from the same offset */
336	{50, 20}, /* seek backward within the same frame */
337	{10, 10}, /* seek backward to a different frame */
338	{25, 10}, /* seek forward within the same frame */
339	{60, 10}, /* seek forward to a different frame */
340	};
341	size_t idx;
342	for (idx = 0; idx < sizeof(tests) / sizeof(tests[0]); idx++) {
343	size_t const decStatus = ZSTD_seekable_decompress(stream, outBuffer, tests[idx].size, tests[idx].offset);
344	if (decStatus != tests[idx].size \|\| memcmp(outBuffer, inBuffer + tests[idx].offset, tests[idx].size) != 0) {
345	goto _test_error;
346	}
347	}
348
349	free(seekBuffer);
350	free(outBuffer);
351	ZSTD_seekable_freeCStream(zscs);
352	ZSTD_seekable_free(stream);
353	}
354	printf("Success!\n");
355
356	/* TODO: Add more tests */
357	printf("Finished tests\n");
358	return 0;
359
360	_test_error:
361	printf("test failed! Exiting..\n");
362	return 1;
363	}