#include "clar_libgit2.h"

#include "buffer.h"

#include "zstream.h"

static const char *data = "This is a test test test of This is a test";

#define INFLATE_EXTRA 2

static void assert_zlib_equal_(

	const void *expected, size_t e_len,

	const void *compressed, size_t c_len,

	const char *msg, const char *file, int line)

{

	z_stream stream;

	char *expanded = git__calloc(1, e_len + INFLATE_EXTRA);

	cl_assert(expanded);

	memset(&stream, 0, sizeof(stream));

	stream.next_out  = (Bytef *)expanded;

	stream.avail_out = (uInt)(e_len + INFLATE_EXTRA);

	stream.next_in   = (Bytef *)compressed;

	stream.avail_in  = (uInt)c_len;

	cl_assert(inflateInit(&stream) == Z_OK);

	cl_assert(inflate(&stream, Z_FINISH));

	inflateEnd(&stream);

	clar__assert_equal(

		file, line, msg, 1,

		"%d", (int)stream.total_out, (int)e_len);

	clar__assert_equal(

		file, line, "Buffer len was not exact match", 1,

		"%d", (int)stream.avail_out, (int)INFLATE_EXTRA);

	clar__assert(

		memcmp(expanded, expected, e_len) == 0,

		file, line, "uncompressed data did not match", NULL, 1);

	git__free(expanded);

}

#define assert_zlib_equal(E,EL,C,CL) \

	assert_zlib_equal_(E, EL, C, CL, #EL " != " #CL, __FILE__, (int)__LINE__)

void test_core_zstream__basic(void)

{

	git_zstream z = GIT_ZSTREAM_INIT;

	char out[128];

	size_t outlen = sizeof(out);

	cl_git_pass(git_zstream_init(&z, GIT_ZSTREAM_DEFLATE));

	cl_git_pass(git_zstream_set_input(&z, data, strlen(data) + 1));

	cl_git_pass(git_zstream_get_output(out, &outlen, &z);;

	cl_assert(git_zstream_done(&z);;

	cl_assert(outlen > 0);

	git_zstream_free(&z);

	assert_zlib_equal(data, strlen(data) + 1, out, outlen);

}

void test_core_zstream__fails_on_trailing_garbage(void)

{

	git_buf deflated = GIT_BUF_INIT, inflated = GIT_BUF_INIT;

	size_t i = 0;

	/* compress a simple string */

	git_zstream_deflatebuf(&deflated, "foobar!!", 8);

	/* append some garbage */

	for (i = 0; i < 10; i++) {

		git_buf_putc(&deflated, i);

	}

	cl_git_fail(git_zstream_inflatebuf(&inflated, deflated.ptr, deflated.size));

	git_buf_free(&deflated);

	git_buf_free(&inflated);

}

void test_core_zstream__buffer(void)

{

	git_buf out = GIT_BUF_INIT;

	cl_git_pass(git_zstream_deflatebuf(&out, data, strlen(data) + 1));

	assert_zlib_equal(data, strlen(data) + 1, out.ptr, out.size);

	git_buf_free(&out;;

}

#define BIG_STRING_PART "Big Data IS Big - Long Data IS Long - We need a buffer larger than 1024 x 1024 to make sure we trigger chunked compression - Big Big Data IS Bigger than Big - Long Long Data IS Longer than Long"

static void compress_and_decompress_input_various_ways(git_buf *input)

{

	git_buf out1 = GIT_BUF_INIT, out2 = GIT_BUF_INIT;

	git_buf inflated = GIT_BUF_INIT;

	size_t i, fixed_size = max(input->size / 2, 256);

	char *fixed = git__malloc(fixed_size);

	cl_assert(fixed);

	/* compress with deflatebuf */

	cl_git_pass(git_zstream_deflatebuf(&out1, input->ptr, input->size));

	assert_zlib_equal(input->ptr, input->size, out1.ptr, out1.size);

	/* compress with various fixed size buffer (accumulating the output) */

	for (i = 0; i < 3; ++i) {

		git_zstream zs = GIT_ZSTREAM_INIT;

		size_t use_fixed_size;

		switch (i) {

		case 0: use_fixed_size = 256; break;

		case 1: use_fixed_size = fixed_size / 2; break;

		case 2: use_fixed_size = fixed_size; break;

		}

		cl_assert(use_fixed_size <= fixed_size);

		cl_git_pass(git_zstream_init(&zs, GIT_ZSTREAM_DEFLATE));

		cl_git_pass(git_zstream_set_input(&zs, input->ptr, input->size));

		while (!git_zstream_done(&zs)) {

			size_t written = use_fixed_size;

			cl_git_pass(git_zstream_get_output(fixed, &written, &zs);;

			cl_git_pass(git_buf_put(&out2, fixed, written));

		}

		git_zstream_free(&zs);

		assert_zlib_equal(input->ptr, input->size, out2.ptr, out2.size);

		/* did both approaches give the same data? */

		cl_assert_equal_sz(out1.size, out2.size);

		cl_assert(!memcmp(out1.ptr, out2.ptr, out1.size));

		git_buf_free(&out2);

	}

	cl_git_pass(git_zstream_inflatebuf(&inflated, out1.ptr, out1.size));

	cl_assert_equal_i(input->size, inflated.size);

	cl_assert(memcmp(input->ptr, inflated.ptr, inflated.size) == 0);

	git_buf_free(&out1);

	git_buf_free(&inflated);

	git__free(fixed);

}

void test_core_zstream__big_data(void)

{

	git_buf in = GIT_BUF_INIT;

	size_t scan, target;

	for (target = 1024; target <= 1024 * 1024 * 4; target *= 8) {

		/* make a big string that's easy to compress */

		git_buf_clear(&in);

		while (in.size < target)

			cl_git_pass(

				git_buf_put(&in, BIG_STRING_PART, strlen(BIG_STRING_PART)));

		compress_and_decompress_input_various_ways(&in);

		/* make a big string that's hard to compress */

		srand(0xabad1dea);

		for (scan = 0; scan < in.size; ++scan)

			in.ptr[scan] = (char)rand();

		compress_and_decompress_input_various_ways(&in);

	}

	git_buf_free(&in);

}