/*
 * Copyright 2014 (c) Anna Schumaker.
 */

#include <iostream>
#include <stdlib.h>
#include <glib.h>

namespace test
{


	static unsigned int test_num;
	static unsigned int failed;

	void new_test(const std::string &name)
	{
		std::cout << name << std::endl;
		test_num = 0;
		failed = 0;
	}

	void begin()
	{
		std::cout << "	" << test_num << ": ";
		test_num++;
	}

	void end()
	{
		std::cout << std::endl;
		if (failed > 0) {
			std::cout << failed << " tests failed =(" << std::endl;
			std::cout << std::endl;
			exit(failed);
		}
	}

	void success()
	{
		std::cout << "Success!" << std::endl;
	}

	template <class T>
	void failure(const T &lhs, const T &rhs, unsigned int line)
	{
		std::cout << "Failed at line " << line << ":" << std::endl;
		std::cout << "		  Actual: " << lhs << std::endl;
		std::cout << "		Expected: " << rhs << std::endl;
		failed++;
	}

	template <class T>
	void check_equal(const T &lhs, const T &rhs, unsigned int line)
	{
		if (lhs == rhs)
			success();
		else
			failure(lhs, rhs, line);
	}

	template <class T>
	void check_not_equal(const T &lhs, const T &rhs, unsigned int line)
	{
		if (lhs != rhs)
			success();
		else
			failure(lhs, rhs, line);
	}

	template <class T>
	void equal(const T &lhs, const T &rhs, unsigned int line = 0)
	{
		begin();
		check_equal(lhs, rhs, line);
	}

	template <class T>
	void not_equal(const T &lhs, const T &rhs, unsigned int line)
	{
		begin();
		check_not_equal(lhs, rhs, line);
	}

	std::string data_dir()
	{
		std::string res = g_get_user_data_dir();
		res += "/ocarina-test";
		return res;
	}

	std::string data_file(const std::string &name)
	{
		return data_dir() + "/" + name;
	}

	bool data_dir_exists()
	{
		return g_file_test(data_dir().c_str(), G_FILE_TEST_IS_DIR);
	}

	bool data_file_exists(const std::string &name)
	{
		return g_file_test(data_file(name).c_str(), G_FILE_TEST_EXISTS);
	}

	void rm_data_dir()
	{
		std::string cmd = "rm -r " + data_dir() + " 2>/dev/null";
		if (data_dir_exists())
			system(cmd.c_str());
	}
}

#define run_test(name, func, ...)	\
	do {				\
		test :: new_test(name);	\
		func( __VA_ARGS__ );	\
		test :: end();		\
	} while (0)

#define test_equal(lhs, rhs)				\
	do {						\
		test :: equal(lhs, rhs, __LINE__);	\
	} while (0)

#define test_not_equal(lhs, rhs)			\
	do {						\
		test :: not_equal(lhs, rhs, __LINE__);	\
	} while (0)

#define check_equal(lhs, rhs)					\
	do {							\
		if (lhs != rhs)					\
			test :: failure(lhs, rhs, __LINE__);	\
	} while (0)

#define check_not_equal(lhs, rhs)				\
	do {							\
		if (lhs == rhs)					\
			test :: failure(lhs, rhs, __LINE__);	\
	} while (0)