#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include "checksum_test_ref.h"
#include "igzip_lib.h"
#include "igzip_wrapper.h"

#ifndef TEST_SEED
# define TEST_SEED 0x1234
#endif
#ifndef RANDOMS
# define RANDOMS 0x4000
#endif

#define EXTRA_SIZE_MAX 256
#define NAME_SIZE_MAX 256
#define COMMENT_SIZE_MAX 1024

#define EXTRA_SIZE 10
#define NAME_SIZE 25
#define COMMENT_SIZE 192

enum {
	INVALID_WRAPPER = ISAL_INVALID_WRAPPER,
	UNSUPPORTED_METHOD = ISAL_UNSUPPORTED_METHOD,
	INCORRECT_CHECKSUM = ISAL_INCORRECT_CHECKSUM,
	NO_ERROR = ISAL_DECOMP_OK,
	END_INPUT = ISAL_END_INPUT,
	NAME_OVERFLOW = ISAL_NAME_OVERFLOW,
	COMMENT_OVERFLOW = ISAL_COMMENT_OVERFLOW,
	EXTRA_OVERFLOW = ISAL_EXTRA_OVERFLOW,
	INCORRECT_TEXT_FLAG,
	INCORRECT_TIME,
	INCORRECT_XFLAGS,
	INCORRECT_OS,
	INCORRECT_EXTRA_LEN,
	INCORRECT_EXTRA_BUF,
	INCORRECT_NAME,
	INCORRECT_COMMENT,
	INCORRECT_INFO,
	INCORRECT_LEVEL,
	INCORRECT_DICT_FLAG,
	INCORRECT_DICT_ID,
	INCORRECT_HDR_LEN,
	INSUFFICIENT_BUFFER_SIZE,
	INCORRECT_WRITE_RETURN,
	MALLOC_FAILED
};

void print_error(int32_t error)
{
	printf("Error Code %d: ", error);
	switch (error) {
	case END_INPUT:
		printf("End of input reached before header decompressed\n");
		break;
	case INVALID_WRAPPER:
		printf("Invalid gzip wrapper found\n");
		break;
	case UNSUPPORTED_METHOD:
		printf("Unsupported decompression method found\n");
		break;
	case INCORRECT_CHECKSUM:
		printf("Incorrect header checksum found\n");
		break;
	case NAME_OVERFLOW:
		printf("Name buffer overflow while decompression\n");
		break;
	case COMMENT_OVERFLOW:
		printf("Comment buffer overflow while decompressing\n");
	case EXTRA_OVERFLOW:
		printf("Extra buffer overflow while decomrpessiong\n");
		break;
	case INCORRECT_TEXT_FLAG:
		printf("Incorrect text field found\n");
		break;
	case INCORRECT_TIME:
		printf("Incorrect time filed found\n");
		break;
	case INCORRECT_XFLAGS:
		printf("Incorrect xflags field found\n");
		break;
	case INCORRECT_OS:
		printf("Incorrect os field found\n");
		break;
	case INCORRECT_EXTRA_LEN:
		printf("Incorect extra_len field found\n");
		break;
	case INCORRECT_EXTRA_BUF:
		printf("Incorrect extra buffer found\n");
		break;
	case INCORRECT_NAME:
		printf("Incorrect name found\n");
		break;
	case INCORRECT_COMMENT:
		printf("Incorrect comment found\n");
		break;
	case INCORRECT_INFO:
		printf("Incorrect info found\n");
		break;
	case INCORRECT_LEVEL:
		printf("Incorrect level found\n");
		break;
	case INCORRECT_DICT_FLAG:
		printf("Incorrect dictionary flag found\n");
		break;
	case INCORRECT_DICT_ID:
		printf("Incorrect dictionary id found\n");
		break;
	case INCORRECT_HDR_LEN:
		printf("Incorrect header length found\n");
		break;
	case INSUFFICIENT_BUFFER_SIZE:
		printf("Insufficient buffer size to write header\n");
		break;
	case INCORRECT_WRITE_RETURN:
		printf("Header write returned an incorrect value\n");
		break;
	case MALLOC_FAILED:
		printf("Failed to allocate buffers\n");
		break;
	case NO_ERROR:
		printf("No error found\n");
	}
}

void print_uint8_t(uint8_t * array, uint64_t length, char *prepend)
{
	const int line_size = 16;
	int i;

	if (array == NULL)
		printf("%s(NULL)", prepend);
	else if (length == 0)
		printf("%s(Empty)", prepend);

	for (i = 0; i < length; i++) {
		if (i == 0)
			printf("%s0x%04x\t", prepend, i);
		else if ((i % line_size) == 0)
			printf("\n%s0x%04x\t", prepend, i);
		else
			printf(" ");
		printf("0x%02x,", array[i]);
	}
	printf("\n");
}

void print_string(char *str, uint32_t str_max_len, char *prepend)
{
	const int line_size = 64;
	uint32_t i = 0;

	while (str[i] != 0 && i < str_max_len) {
		if (i == 0)
			printf("%s0x%04x\t", prepend, i);
		else if ((i % line_size) == 0)
			printf("\n%s0x%04x\t", prepend, i);

		printf("%c", str[i]);
		i++;
	}
	printf("\n");
}

void print_gzip_header(struct isal_gzip_header *gz_hdr, char *prepend1, char *prepend2)
{
	printf("%sText: %d, Time: 0x%08x, Xflags: 0x%x, OS: 0x%x\n", prepend1,
	       gz_hdr->text, gz_hdr->time, gz_hdr->xflags, gz_hdr->os);

	printf("%sExtra:  Extra_len = 0x%x\n", prepend1, gz_hdr->extra_len);
	if (gz_hdr->extra_len < EXTRA_SIZE_MAX)
		print_uint8_t(gz_hdr->extra, gz_hdr->extra_len, prepend2);
	else
		printf("%sExtra field larger than EXTRA_SIZE_MAX\n", prepend2);

	printf("%sName:\n", prepend1);
	if (gz_hdr->name_buf_len < NAME_SIZE_MAX)
		print_string(gz_hdr->name, gz_hdr->name_buf_len, prepend2);
	else
		printf("%sName field larger than NAME_SIZE_MAX\n", prepend2);

	printf("%sComment:\n", prepend1);
	if (gz_hdr->comment_buf_len < COMMENT_SIZE_MAX)
		print_string(gz_hdr->comment, gz_hdr->comment_buf_len, prepend2);
	else
		printf("%sComment field larger than COMMENT_SIZE_MAX\n", prepend2);
}

void print_zlib_header(struct isal_zlib_header *z_hdr, char *prepend)
{
	printf("%sInfo: 0x%x\n", prepend, z_hdr->info);
	printf("%sLevel: 0x%x\n", prepend, z_hdr->level);
	printf("%sDictionary: Flag = 0x%x, Id =0x%x\n", prepend, z_hdr->dict_flag,
	       z_hdr->dict_id);
}

void print_gzip_final_verbose(uint8_t * hdr_buf, uint32_t hdr_buf_len,
			      struct isal_gzip_header *gz_hdr_orig,
			      struct isal_gzip_header *gz_hdr)
{
#ifdef VERBOSE
	printf("\n");
	if (gz_hdr_orig != NULL) {
		printf("Original Gzip Header Struct:\n");
		print_gzip_header(gz_hdr_orig, "\t", "\t\t");
		printf("\n");
	}

	if (gz_hdr != NULL) {
		printf("Parsed Gzip Header Struct:\n");
		print_gzip_header(gz_hdr, "\t", "\t\t");
		printf("\n");
	}

	if (hdr_buf != NULL) {
		printf("Serialized Gzip Header:\n");
		print_uint8_t(hdr_buf, hdr_buf_len, "\t");
		printf("\n");
	}
#endif
	return;
}

void print_zlib_final_verbose(uint8_t * hdr_buf, uint32_t hdr_buf_len,
			      struct isal_zlib_header *z_hdr_orig,
			      struct isal_zlib_header *z_hdr)
{
#ifdef VERBOSE
	printf("\n");
	if (z_hdr_orig != NULL) {
		printf("Original Zlib Header Struct:\n");
		print_zlib_header(z_hdr_orig, "\t");
		printf("\n");
	}

	if (z_hdr != NULL) {
		printf("Parsed Zlib Header Struct:\n");
		print_zlib_header(z_hdr, "\t");
		printf("\n");
	}

	if (hdr_buf != NULL) {
		printf("Serialized Zlib Header:\n");
		print_uint8_t(hdr_buf, hdr_buf_len, "\t");
		printf("\n");
	}
#endif
	return;
}

int gzip_header_size(struct isal_gzip_header *gz_hdr)
{
	int hdr_size = 10;
	if (gz_hdr->extra != NULL) {
		hdr_size += 2 + gz_hdr->extra_len;
	}
	if (gz_hdr->name != NULL) {
		hdr_size += strnlen(gz_hdr->name, gz_hdr->name_buf_len) + 1;
	}
	if (gz_hdr->comment != NULL) {
		hdr_size += strnlen(gz_hdr->comment, gz_hdr->comment_buf_len) + 1;
	}

	if (gz_hdr->hcrc) {
		hdr_size += 2;
	}

	return hdr_size;
}

int zlib_header_size(struct isal_zlib_header *z_hdr)
{
	if (z_hdr->dict_flag)
		return 6;
	else
		return 2;
}

void rand_string(char *string, uint32_t str_len)
{
	int i;

	if (str_len == 0 || string == NULL)
		return;
	for (i = 0; i < str_len - 1; i++) {
		string[i] = rand() % 26 + 65;
	}
	string[str_len - 1] = 0;
}

void rand_buf(uint8_t * buf, uint32_t buf_len)
{
	int i;

	if (buf_len == 0 || buf == NULL)
		return;

	for (i = 0; i < buf_len; i++) {
		buf[i] = rand();
	}
}

int malloc_gzip_header(struct isal_gzip_header *gz_hdr)
{
	gz_hdr->extra = NULL;
	if (gz_hdr->extra_buf_len) {
		gz_hdr->extra = malloc(gz_hdr->extra_buf_len);
		if (gz_hdr->extra == NULL)
			return MALLOC_FAILED;
	}

	gz_hdr->name = NULL;
	if (gz_hdr->name_buf_len) {
		gz_hdr->name = malloc(gz_hdr->name_buf_len);
		if (gz_hdr->name == NULL)
			return MALLOC_FAILED;
	}

	gz_hdr->comment = NULL;
	if (gz_hdr->comment_buf_len) {
		gz_hdr->comment = malloc(gz_hdr->comment_buf_len);
		if (gz_hdr->comment == NULL)
			return MALLOC_FAILED;
	}

	return 0;
}

void free_gzip_header(struct isal_gzip_header *gz_hdr)
{
	if (gz_hdr->extra != NULL) {
		free(gz_hdr->extra);
		gz_hdr->extra = NULL;
	}

	if (gz_hdr->name != NULL) {
		free(gz_hdr->name);
		gz_hdr->name = NULL;
	}

	if (gz_hdr->comment != NULL) {
		free(gz_hdr->comment);
		gz_hdr->comment = NULL;
	}

}

int gen_rand_gzip_header(struct isal_gzip_header *gz_hdr)
{
	int ret = 0;
	int field_set_space = 8;

	isal_gzip_header_init(gz_hdr);

	if (rand() % field_set_space != 0)
		gz_hdr->text = rand() % 2;
	if (rand() % field_set_space != 0)
		gz_hdr->time = rand();
	if (rand() % field_set_space != 0)
		gz_hdr->xflags = rand() % 256;
	if (rand() % field_set_space != 0)
		gz_hdr->os = rand() % 256;

	if (rand() % field_set_space != 0) {
		gz_hdr->extra_buf_len = rand() % EXTRA_SIZE_MAX;
		gz_hdr->extra_len = gz_hdr->extra_buf_len;
	}

	if (rand() % field_set_space != 0)
		gz_hdr->name_buf_len = rand() % NAME_SIZE_MAX;

	if (rand() % field_set_space != 0)
		gz_hdr->comment_buf_len = rand() % COMMENT_SIZE_MAX;

	gz_hdr->hcrc = rand() % 2;

	ret = malloc_gzip_header(gz_hdr);
	if (ret)
		return ret;

	rand_buf(gz_hdr->extra, gz_hdr->extra_len);
	rand_string(gz_hdr->name, gz_hdr->name_buf_len);
	rand_string(gz_hdr->comment, gz_hdr->comment_buf_len);

	return ret;
}

void gen_rand_zlib_header(struct isal_zlib_header *z_hdr)
{
	z_hdr->info = rand() % 16;
	z_hdr->level = rand() % 4;
	z_hdr->dict_flag = rand() % 2;
	z_hdr->dict_id = rand();
}

int write_gzip_header(uint8_t * hdr_buf, uint32_t hdr_buf_len, struct isal_gzip_header *gz_hdr)
{

	struct isal_zstream stream;
	uint32_t hdr_len = gzip_header_size(gz_hdr);
	uint32_t len;

	isal_deflate_init(&stream);
	stream.next_out = hdr_buf;
	stream.avail_out = rand() % hdr_len;
	len = isal_write_gzip_header(&stream, gz_hdr);

	if (len != hdr_len) {
		printf("len = %d, hdr_buf_len = %d\n", len, hdr_len);
		print_gzip_final_verbose(hdr_buf, hdr_buf_len, gz_hdr, NULL);
		print_error(INCORRECT_HDR_LEN);
		return INCORRECT_HDR_LEN;
	}

	if (hdr_buf_len < hdr_len) {
		print_gzip_final_verbose(NULL, 0, gz_hdr, NULL);
		print_error(INSUFFICIENT_BUFFER_SIZE);
		return INSUFFICIENT_BUFFER_SIZE;
	}

	stream.avail_out = hdr_buf_len;

	len = isal_write_gzip_header(&stream, gz_hdr);

	if (len) {
		print_gzip_final_verbose(hdr_buf, hdr_buf_len, gz_hdr, NULL);
		print_error(INCORRECT_WRITE_RETURN);
		return INCORRECT_WRITE_RETURN;;
	}

	return 0;
}

int write_zlib_header(uint8_t * hdr_buf, uint32_t hdr_buf_len, struct isal_zlib_header *z_hdr)
{
	struct isal_zstream stream;
	uint32_t hdr_len = zlib_header_size(z_hdr);
	uint32_t len;

	isal_deflate_init(&stream);
	stream.next_out = hdr_buf;
	stream.avail_out = rand() % hdr_len;
	len = isal_write_zlib_header(&stream, z_hdr);

	if (len != hdr_len) {
		print_zlib_final_verbose(hdr_buf, hdr_buf_len, z_hdr, NULL);
		print_error(INCORRECT_HDR_LEN);
		return INCORRECT_HDR_LEN;
	}

	if (hdr_buf_len < hdr_len) {
		print_zlib_final_verbose(NULL, 0, z_hdr, NULL);
		print_error(INSUFFICIENT_BUFFER_SIZE);
		return INSUFFICIENT_BUFFER_SIZE;
	}

	stream.avail_out = hdr_buf_len;

	len = isal_write_zlib_header(&stream, z_hdr);

	if (len) {
		print_zlib_final_verbose(hdr_buf, hdr_buf_len, z_hdr, NULL);
		print_error(INCORRECT_WRITE_RETURN);
		return INCORRECT_WRITE_RETURN;;
	}

	return 0;
}

int compare_gzip_headers(struct isal_gzip_header *gz_hdr1, struct isal_gzip_header *gz_hdr2)
{
	int ret = 0;
	uint32_t max_len;

	if (gz_hdr1->text != gz_hdr2->text)
		return INCORRECT_TEXT_FLAG;

	if (gz_hdr1->time != gz_hdr2->time)
		return INCORRECT_TIME;

	if (gz_hdr1->xflags != gz_hdr2->xflags)
		return INCORRECT_XFLAGS;

	if (gz_hdr1->os != gz_hdr2->os)
		return INCORRECT_OS;

	if (gz_hdr1->extra_len != gz_hdr2->extra_len)
		return INCORRECT_EXTRA_LEN;

	if (gz_hdr1->extra != NULL && gz_hdr2->extra != NULL) {
		ret = memcmp(gz_hdr1->extra, gz_hdr2->extra, gz_hdr1->extra_len);
		if (ret)
			return INCORRECT_EXTRA_BUF;
	}

	if (gz_hdr1->name != NULL && gz_hdr2->name != NULL) {
		max_len = gz_hdr1->name_buf_len;
		if (gz_hdr1->name_buf_len < gz_hdr2->name_buf_len)
			max_len = gz_hdr2->name_buf_len;

		ret = strncmp(gz_hdr1->name, gz_hdr2->name, max_len);
		if (ret)
			return INCORRECT_NAME;
	}

	if (gz_hdr1->comment != NULL && gz_hdr2->comment != NULL) {
		max_len = gz_hdr1->comment_buf_len;
		if (gz_hdr1->comment_buf_len < gz_hdr2->comment_buf_len)
			max_len = gz_hdr2->comment_buf_len;

		ret = strncmp(gz_hdr1->comment, gz_hdr2->comment, max_len);
		if (ret)
			return INCORRECT_COMMENT;
	}
	return ret;
}

int compare_zlib_headers(struct isal_zlib_header *z_hdr1, struct isal_zlib_header *z_hdr2)
{
	if (z_hdr1->info != z_hdr2->info)
		return INCORRECT_INFO;

	if (z_hdr1->level != z_hdr2->level)
		return INCORRECT_LEVEL;

	if (z_hdr1->dict_flag != z_hdr2->dict_flag)
		return INCORRECT_DICT_FLAG;

	if (z_hdr1->dict_flag && z_hdr1->dict_id != z_hdr2->dict_id)
		return INCORRECT_DICT_ID;

	return 0;
}

int read_gzip_header_simple(uint8_t * hdr_buf, uint32_t hdr_buf_len,
			    struct isal_gzip_header *gz_hdr_orig)
{

	int ret = 0;
	struct inflate_state state;
	struct isal_gzip_header gz_hdr;

	rand_buf((uint8_t *) & gz_hdr, sizeof(gz_hdr));
	gz_hdr.extra_buf_len = gz_hdr_orig->extra_buf_len;
	gz_hdr.name_buf_len = gz_hdr_orig->name_buf_len;
	gz_hdr.comment_buf_len = gz_hdr_orig->comment_buf_len;

	ret = malloc_gzip_header(&gz_hdr);
	if (ret) {
		print_gzip_final_verbose(hdr_buf, hdr_buf_len, gz_hdr_orig, NULL);
		print_error(ret);
		free_gzip_header(&gz_hdr);
		return ret;
	}

	isal_inflate_init(&state);
	state.next_in = hdr_buf;
	state.avail_in = hdr_buf_len;
	ret = isal_read_gzip_header(&state, &gz_hdr);

	if (ret) {
		print_gzip_final_verbose(hdr_buf, hdr_buf_len, gz_hdr_orig, &gz_hdr);
		print_error(ret);
		free_gzip_header(&gz_hdr);
		return ret;
	}

	ret = compare_gzip_headers(gz_hdr_orig, &gz_hdr);

	if (ret) {
		print_gzip_final_verbose(hdr_buf, hdr_buf_len, gz_hdr_orig, &gz_hdr);
		print_error(ret);
	}

	free_gzip_header(&gz_hdr);
	return ret;
}

int read_zlib_header_simple(uint8_t * hdr_buf, uint32_t hdr_buf_len,
			    struct isal_zlib_header *z_hdr_orig)
{

	int ret = 0;
	struct inflate_state state;
	struct isal_zlib_header z_hdr;

	rand_buf((uint8_t *) & z_hdr, sizeof(z_hdr));

	if (ret) {
		print_zlib_final_verbose(hdr_buf, hdr_buf_len, z_hdr_orig, NULL);
		print_error(ret);
		return ret;
	}

	isal_inflate_init(&state);
	state.next_in = hdr_buf;
	state.avail_in = hdr_buf_len;
	ret = isal_read_zlib_header(&state, &z_hdr);

	if (ret) {
		print_zlib_final_verbose(hdr_buf, hdr_buf_len, z_hdr_orig, &z_hdr);
		print_error(ret);
		return ret;
	}

	ret = compare_zlib_headers(z_hdr_orig, &z_hdr);

	if (ret) {
		print_zlib_final_verbose(hdr_buf, hdr_buf_len, z_hdr_orig, &z_hdr);
		print_error(ret);
	}

	return ret;
}

int read_gzip_header_streaming(uint8_t * hdr_buf, uint32_t hdr_buf_len,
			       struct isal_gzip_header *gz_hdr_orig)
{
	int ret = 0;
	uint32_t max_dec_size, dec_size, max_extra_len, extra_len;
	uint32_t max_name_len, name_len, max_comment_len, comment_len;
	struct inflate_state state;
	struct isal_gzip_header gz_hdr;
	void *tmp_ptr;

	rand_buf((uint8_t *) & gz_hdr, sizeof(gz_hdr));

	max_dec_size = (rand() % hdr_buf_len) + 2;

	max_extra_len = 2;
	max_name_len = 2;
	max_comment_len = 2;
	if (gz_hdr_orig->extra_buf_len)
		max_extra_len = (rand() % gz_hdr_orig->extra_buf_len) + 2;
	if (gz_hdr_orig->name_buf_len)
		max_name_len = (rand() % gz_hdr_orig->name_buf_len) + 2;
	if (gz_hdr_orig->comment_buf_len)
		max_comment_len = (rand() % gz_hdr_orig->comment_buf_len) + 2;

	extra_len = rand() % max_extra_len;
	name_len = rand() % max_name_len;
	comment_len = rand() % max_comment_len;

	if (extra_len == 0)
		extra_len = 1;
	if (name_len == 0)
		name_len = 1;
	if (comment_len == 0)
		comment_len = 1;

	gz_hdr.extra_buf_len = extra_len;
	gz_hdr.name_buf_len = name_len;
	gz_hdr.comment_buf_len = comment_len;

	ret = malloc_gzip_header(&gz_hdr);

	if (ret) {
		print_gzip_final_verbose(hdr_buf, hdr_buf_len, gz_hdr_orig, NULL);
		print_error(ret);
		free_gzip_header(&gz_hdr);
		return (ret == 0);
	}

	isal_inflate_init(&state);

	state.next_in = hdr_buf;
	dec_size = rand() % max_dec_size;
	if (dec_size > hdr_buf_len)
		dec_size = hdr_buf_len;

	state.avail_in = dec_size;
	hdr_buf_len -= dec_size;

	while (1) {
		ret = isal_read_gzip_header(&state, &gz_hdr);

		switch (ret) {
		case ISAL_NAME_OVERFLOW:
			if (name_len >= NAME_SIZE_MAX)
				break;

			name_len += rand() % max_name_len;
			tmp_ptr = realloc(gz_hdr.name, name_len);
			if (tmp_ptr == NULL) {
				ret = MALLOC_FAILED;
				break;
			}
			gz_hdr.name = tmp_ptr;
			gz_hdr.name_buf_len = name_len;
			continue;
		case ISAL_COMMENT_OVERFLOW:
			if (comment_len >= COMMENT_SIZE_MAX)
				break;

			comment_len += rand() % max_comment_len;
			tmp_ptr = realloc(gz_hdr.comment, comment_len);
			if (tmp_ptr == NULL) {
				ret = MALLOC_FAILED;
				break;
			}
			gz_hdr.comment = tmp_ptr;
			gz_hdr.comment_buf_len = comment_len;
			continue;
		case ISAL_EXTRA_OVERFLOW:
			if (extra_len >= EXTRA_SIZE_MAX)
				break;

			extra_len += rand() % max_extra_len;
			tmp_ptr = realloc(gz_hdr.extra, extra_len);
			if (tmp_ptr == NULL) {
				ret = MALLOC_FAILED;
				break;
			}
			gz_hdr.extra = tmp_ptr;
			gz_hdr.extra_buf_len = extra_len;
			continue;
		case ISAL_END_INPUT:
			if (hdr_buf_len == 0)
				break;

			dec_size = rand() % max_dec_size;
			if (dec_size > hdr_buf_len)
				dec_size = hdr_buf_len;

			state.avail_in = dec_size;
			hdr_buf_len -= dec_size;
			continue;
		}

		break;
	}

	if (ret) {
		print_gzip_final_verbose(hdr_buf, hdr_buf_len, gz_hdr_orig, &gz_hdr);
		print_error(ret);
		free_gzip_header(&gz_hdr);
		return ret;
	}

	ret = compare_gzip_headers(gz_hdr_orig, &gz_hdr);

	if (ret) {
		print_gzip_final_verbose(hdr_buf, hdr_buf_len, gz_hdr_orig, &gz_hdr);
		print_error(ret);
	}

	free_gzip_header(&gz_hdr);
	return ret;
}

int read_zlib_header_streaming(uint8_t * hdr_buf, uint32_t hdr_buf_len,
			       struct isal_zlib_header *z_hdr_orig)
{
	int ret = ISAL_END_INPUT;
	uint32_t max_dec_size, dec_size;
	struct inflate_state state;
	struct isal_zlib_header z_hdr;

	rand_buf((uint8_t *) & z_hdr, sizeof(z_hdr));

	max_dec_size = (rand() % hdr_buf_len) + 2;

	isal_inflate_init(&state);

	state.next_in = hdr_buf;
	while (ret == ISAL_END_INPUT && hdr_buf_len > 0) {
		dec_size = rand() % max_dec_size;
		if (dec_size > hdr_buf_len)
			dec_size = hdr_buf_len;

		state.avail_in = dec_size;
		hdr_buf_len -= dec_size;

		ret = isal_read_zlib_header(&state, &z_hdr);
	}

	if (ret) {
		print_zlib_final_verbose(hdr_buf, hdr_buf_len, z_hdr_orig, &z_hdr);
		print_error(ret);
		return ret;
	}

	ret = compare_zlib_headers(z_hdr_orig, &z_hdr);

	if (ret) {
		print_zlib_final_verbose(hdr_buf, hdr_buf_len, z_hdr_orig, &z_hdr);
		print_error(ret);
	}

	return ret;
}

int main(int argc, char *argv[])
{
	uint8_t *hdr_buf;
	uint32_t hdr_buf_len;
	int ret = 0, fin_ret = 0;
	struct isal_gzip_header gz_hdr_orig;
	struct isal_zlib_header z_hdr_orig;
	int i;

#ifndef VERBOSE
	setbuf(stdout, NULL);
#endif
	printf("Test Seed  : %d\n", TEST_SEED);
	printf("Randoms    : %d\n", RANDOMS);
	srand(TEST_SEED);

	printf("gzip wrapper test: ");
	for (i = 0; i < RANDOMS; i++) {
		rand_buf((uint8_t *) & gz_hdr_orig, sizeof(gz_hdr_orig));

		ret = gen_rand_gzip_header(&gz_hdr_orig);
		if (ret) {
			print_error(ret);
			return (ret == 0);
		}

		hdr_buf_len = gzip_header_size(&gz_hdr_orig);
		hdr_buf = malloc(hdr_buf_len);

		ret = write_gzip_header(hdr_buf, hdr_buf_len, &gz_hdr_orig);

		fin_ret |= ret;
		if (ret)
			return (ret == 0);

		ret = read_gzip_header_simple(hdr_buf, hdr_buf_len, &gz_hdr_orig);

		fin_ret |= ret;
		if (ret)
			return (ret == 0);

		ret = read_gzip_header_streaming(hdr_buf, hdr_buf_len, &gz_hdr_orig);

		fin_ret |= ret;
		if (ret)
			return (ret == 0);

		free_gzip_header(&gz_hdr_orig);
		if (hdr_buf != NULL)
			free(hdr_buf);

		if (i % (RANDOMS / 16) == 0)
			printf(".");
	}
	printf("Pass \n");

	printf("zlib wrapper test: ");
	for (i = 0; i < RANDOMS; i++) {
		memset(&z_hdr_orig, 0, sizeof(z_hdr_orig));

		gen_rand_zlib_header(&z_hdr_orig);

		hdr_buf_len = zlib_header_size(&z_hdr_orig);
		hdr_buf = malloc(hdr_buf_len);

		ret = write_zlib_header(hdr_buf, hdr_buf_len, &z_hdr_orig);

		fin_ret |= ret;
		if (ret)
			return (ret == 0);

		ret = read_zlib_header_simple(hdr_buf, hdr_buf_len, &z_hdr_orig);

		fin_ret |= ret;
		if (ret)
			return (ret == 0);

		ret = read_zlib_header_streaming(hdr_buf, hdr_buf_len, &z_hdr_orig);

		fin_ret |= ret;
		if (ret)
			return (ret == 0);

		if (hdr_buf != NULL)
			free(hdr_buf);

		if (i % (RANDOMS / 16) == 0)
			printf(".");
	}
	printf("Pass \n");

	printf("igzip wrapper_hdr test finished:%s \n",
	       fin_ret ? " Some tests failed " : " All tests passed");

	return 0;
}