/*
   ctdb_io tests

   Copyright (C) Christof Schmitt 2019

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, see <http://www.gnu.org/licenses/>.
*/

#include "replace.h"
#include "system/filesys.h"

#include <assert.h>

#include "common/ctdb_io.c"

void ctdb_set_error(struct ctdb_context *ctdb, const char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	vprintf(fmt, ap);
	assert(false);
}

static void test_setup(ctdb_queue_cb_fn_t cb,
		       int *pfd,
		       struct ctdb_context **pctdb)
{
	int pipefd[2], ret;
	struct ctdb_context *ctdb;
	struct ctdb_queue *queue;

	ret = pipe(pipefd);
	assert(ret == 0);

	ctdb = talloc_zero(NULL, struct ctdb_context);
	assert(ctdb != NULL);

	ctdb->ev = tevent_context_init(NULL);

	queue = ctdb_queue_setup(ctdb, ctdb, pipefd[0], 0, cb,
				 NULL, "test queue");
	assert(queue != NULL);

	*pctdb = ctdb;
	*pfd = pipefd[1];
}

static const size_t test1_req_len = 8;
static const char *test1_req = "abcdefgh";

static void test1_callback(uint8_t *data, size_t length, void *private_data)
{
	uint32_t len;

	len = *(uint32_t *)data;
	assert(len == sizeof(uint32_t) + test1_req_len);

	assert(length == sizeof(uint32_t) + test1_req_len);
	assert(memcmp(data  + sizeof(len), test1_req, test1_req_len) == 0);
}

static void test1(void)
{
	struct ctdb_context *ctdb;
	int fd, ret;
	uint32_t pkt_size;

	test_setup(test1_callback, &fd, &ctdb);

	pkt_size = sizeof(uint32_t) + test1_req_len;
	ret = write(fd, &pkt_size, sizeof(pkt_size));
	assert(ret == sizeof(pkt_size));

	ret = write(fd, test1_req, test1_req_len);
	assert(ret == test1_req_len);

	tevent_loop_once(ctdb->ev);

	TALLOC_FREE(ctdb);
}

static const size_t test2_req_len[] = { 900, 24, 600 };

static int test2_cb_num = 0;

static void test2_callback(uint8_t *data, size_t length, void *private_data)
{
	uint32_t len;

	len = *(uint32_t *)data;
	assert(len == sizeof(uint32_t) + test2_req_len[test2_cb_num]);
	assert(length == sizeof(uint32_t) + test2_req_len[test2_cb_num]);

	test2_cb_num++;
}

static void test2(void)
{
	struct ctdb_context *ctdb;
	int fd, ret, i;
	uint32_t pkt_size;
	char req[1024] = { 0 };

	for (i = 0; i < sizeof(req); i++) {
		req[i] = i % CHAR_MAX;
	}

	test_setup(test2_callback, &fd, &ctdb);

	/*
	 * request 0
	 */

	pkt_size = sizeof(uint32_t) + test2_req_len[0];
	ret = write(fd, &pkt_size, sizeof(pkt_size));
	assert(ret == sizeof(pkt_size));

	ret = write(fd, req, test2_req_len[0]);
	assert(ret == test2_req_len[0]);

	/*
	 * request 1
	 */
	pkt_size = sizeof(uint32_t) + test2_req_len[1];
	ret = write(fd, &pkt_size, sizeof(pkt_size));
	assert(ret == sizeof(pkt_size));

	/*
	 * Omit the last byte to avoid buffer processing.
	 */
	ret = write(fd, req, test2_req_len[1] - 1);
	assert(ret == test2_req_len[1] - 1);

	tevent_loop_once(ctdb->ev);

	/*
	 * Write the missing byte now.
	 */
	ret = write(fd, &req[test2_req_len[1] - 1], 1);
	assert(ret == 1);

	/*
	 * request 2
	 */
	pkt_size = sizeof(uint32_t) + test2_req_len[2];
	ret = write(fd, &pkt_size, sizeof(pkt_size));
	assert(ret == sizeof(pkt_size));

	ret = write(fd, req, test2_req_len[2]);
	assert(ret == test2_req_len[2]);

	tevent_loop_once(ctdb->ev);
	tevent_loop_once(ctdb->ev);

	assert(test2_cb_num == 2);

	TALLOC_FREE(ctdb);
}

int main(int argc, const char **argv)
{
	int num;

	if (argc != 2) {
		fprintf(stderr, "%s <testnum>\n", argv[0]);
		exit(1);
	}


	num = atoi(argv[1]);
	switch (num) {
	case 1:
		test1();
		break;

	case 2:
		test2();
		break;

	default:
		fprintf(stderr, "Unknown test number %s\n", argv[1]);
	}

	return 0;
}
