/*

  Copyright (C) 2011 Markus Kauppila <markus.kauppila@gmail.com>

  This software is provided 'as-is', without any express or implied

  warranty.  In no event will the authors be held liable for any damages

  arising from the use of this software.

  Permission is granted to anyone to use this software for any purpose,

  including commercial applications, and to alter it and redistribute it

  freely, subject to the following restrictions:

  1. The origin of this software must not be misrepresented; you must not

     claim that you wrote the original software. If you use this software

     in a product, an acknowledgment in the product documentation would be

     appreciated but is not required.

  2. Altered source versions must be plainly marked as such, and must not be

     misrepresented as being the original software.

  3. This notice may not be removed or altered from any source distribution.

*/

#include "SDL/SDL.h"

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <string.h>

#include <dirent.h>

#include <sys/types.h>

#include <sys/stat.h>

#include "../../include/SDL_test.h"

#include "../../config.h"

#include "../libSDLtest/fuzzer/fuzzer.h"

#include "../libSDLtest/plain_logger.h"

#include "../libSDLtest/xml_logger.h"

#include "../libSDLtest/logger_helpers.h"

#include "logger.h"

#include "support.h"

//!< Function pointer to a test case function

typedef void (*TestCaseFp)(void *arg);

//!< Function pointer to a test case init function

typedef void (*InitTestInvironmentFp)(Uint64);

//!< Function pointer to a test case quit function

typedef int  (*QuitTestInvironmentFp)(void);

//!< Function pointer to a test case set up function

typedef void (*TestCaseSetUpFp)(void *arg);

//!< Function pointer to a test case tear down function

typedef void  (*TestCaseTearDownFp)(void *arg);

//!< Function pointer to a function which returns the failed assert count

typedef int (*CountFailedAssertsFp)(void);

//!< Flag for executing tests in-process

static int execute_inproc = 0;

//!< Flag for only printing out the test names

static int only_print_tests = 0;

//!< Flag for executing only test with selected name

static int only_selected_test  = 0;

//!< Flag for executing only the selected test suite

static int only_selected_suite = 0;

//!< Flag for executing only tests that contain certain string in their name

static int only_tests_with_string = 0;

//!< Flag for enabling XML logging

static int xml_enabled = 0;

//! Flag for enabling user-supplied style sheet for XML test report

static int custom_xsl_enabled = 0;

//! Flag for disabling xsl-style from xml report

static int xsl_enabled = 0;

//! Flag for enabling universal timeout for tests

static int universal_timeout_enabled = 0;

//! Flag for enabling verbose logging

static int enable_verbose_logger = 0;

//! Flag for using user supplied run seed

static int userRunSeed = 0;

//! Whether or not logger should log to stdout instead of file

static int log_stdout_enabled = 1;

//! Whether or not dummy suite should be included to the test run

static int include_dummy_suite = 0;

//!< Size of the test and suite name buffers

#define NAME_BUFFER_SIZE 1024

//!< Name of the selected test

char selected_test_name[NAME_BUFFER_SIZE];

//!< Name of the selected suite

char selected_suite_name[NAME_BUFFER_SIZE];

//!< substring of test case name

char testcase_name_substring[NAME_BUFFER_SIZE];

//! Name for user-supplied XSL style sheet name

char xsl_stylesheet_name[NAME_BUFFER_SIZE];

//! User-suppled timeout value for tests

int universal_timeout = -1;

//! Default directory of the test suites

#define DEFAULT_TEST_DIRECTORY "tests/"

//! Default directory for placing log files

#define DEFAULT_LOG_DIRECTORY "logs"

//! Default directory of the test suites

#define DEFAULT_LOG_FILENAME "testrun"

//! Defines directory separator

#define DIRECTORY_SEPARATOR '/'

#define DUMMY_TEST_NAME "libtestdummy"

//! Name of the default stylesheet

const char *defaultXSLStylesheet = "style.xsl";

//! Fuzzer seed for the harness

char *runSeed = NULL;

//! Execution key that user supplied via command options

Uint64 userExecKey = 0;

//! How man time a test will be invocated

int testInvocationCount = 1;

//! Stores the basename for log files

char log_basename[NAME_BUFFER_SIZE];

//! Stores directory name for placing the logs

char log_directory[NAME_BUFFER_SIZE];

// \todo add comments

int totalTestFailureCount = 0, totalTestPassCount = 0, totalTestSkipCount = 0;

int testFailureCount = 0, testPassCount = 0, testSkipCount = 0;

/*!

 * Holds information about test suite such as it's name

 * and pointer to dynamic library. Implemented as linked list.

 */

typedef struct TestSuiteReference {

	char *name; //!< test suite name

	char *directoryPath; //!< test suites path (eg. tests/libtestsuite)

	void *library; //!< pointer to shared/dynamic library implementing the suite

	struct TestSuiteReference *next; //!< Pointer to next item in the list

} TestSuiteReference;

/*!

 * Holds information about the tests that will be executed.

 *

 * Implemented as linked list.

 */

typedef struct TestCaseItem {

	char *testName;

	char *suiteName;

	char *description;

	long requirements;

	long timeout;

	InitTestInvironmentFp initTestEnvironment;

	TestCaseSetUpFp testSetUp;

	TestCaseFp testCase;

	TestCaseTearDownFp testTearDown;

 	QuitTestInvironmentFp quitTestEnvironment;

 	CountFailedAssertsFp countFailedAsserts;

	struct TestCaseItem *next;

} TestCase;

/*! Some function prototypes. Add the rest of functions and move to runner.h */

TestCaseFp LoadTestCaseFunction(void *suite, char *testName);

InitTestInvironmentFp LoadInitTestInvironmentFunction(void *suite);

QuitTestInvironmentFp LoadQuitTestInvironmentFunction(void *suite);

TestCaseReference **QueryTestCaseReferences(void *library);

TestCaseSetUpFp LoadTestSetUpFunction(void *suite);

TestCaseTearDownFp LoadTestTearDownFunction(void *suite);

CountFailedAssertsFp LoadCountFailedAssertsFunction(void *suite);

void KillHungTestInChildProcess(int signum);

void UnloadTestSuites(TestSuiteReference *suites);

int FilterTestCase(TestCaseReference *testReference);

int HandleChildProcessReturnValue(int stat_lock);

/*! Pointers to selected logger implementation */

RunStartedFp RunStarted = NULL;

RunEndedFp RunEnded = NULL;

SuiteStartedFp SuiteStarted = NULL;

SuiteEndedFp SuiteEnded = NULL;

TestStartedFp TestStarted = NULL;

TestEndedFp TestEnded = NULL;

AssertFp Assert = NULL;

AssertWithValuesFp AssertWithValues = NULL;

AssertSummaryFp AssertSummary = NULL;

LogFp Log = NULL;

/*!

 * Scans the tests/ directory and returns the names

 * of the dynamic libraries implementing the test suites.

 *

 * Note: currently function assumes that test suites names

 * are in following format: libtestsuite.dylib or libtestsuite.so.

 *

 * Note: if only_selected_suite flags is non-zero, only the selected

 * test will be loaded.

 *

 * \param directoryName Name of the directory which will be scanned

 * \param extension What file extension is used with dynamic objects

 *

 * \return Pointer to TestSuiteReference which holds all the info about suites

 * 		   or NULL on failure

 */

TestSuiteReference *

ScanForTestSuites(char *directoryName, char *extension)

{

	typedef struct dirent Entry;

	TestSuiteReference *suites = NULL;

	TestSuiteReference *reference = NULL;

	Entry *entry = NULL;

	DIR *directory = NULL;

	if(directoryName == NULL || extension == NULL ||

		SDL_strlen(directoryName) == 0 || SDL_strlen(extension) == 0) {

		return NULL;

	}

	directory = opendir(directoryName);

	if(!directory) {

		fprintf(stderr, "Failed to open test suite directory: %s\n", directoryName);

		perror("Error message");

		exit(2);

	}

	while( (entry = readdir(directory)) ) {

		 // discards . and .. and hidden files starting with dot and directories etc.

		if(strlen(entry->d_name) > 2 && entry->d_name[0] != '.' && entry->d_type == DT_REG) {

			const char *delimiters = ".";

			char *name = strtok(entry->d_name, delimiters);

			char *ext = strtok(NULL, delimiters);

			if(name == NULL || ext == NULL) {

				goto error;

			}

			int ok = 1; // on default, we want to include all tests

			// filter out all other suites but the selected test suite

			if(only_selected_suite) {

				ok = SDL_strncmp(selected_suite_name, name, NAME_BUFFER_SIZE) == 0;

			}

			if(SDL_strncmp(name, DUMMY_TEST_NAME, NAME_BUFFER_SIZE) == 0) {

				if(include_dummy_suite) {

					ok =  1;

				} else {

					ok = 0;

				}

			}

			if(ok && SDL_strncmp(ext, extension, SDL_strlen(extension))  == 0) {

				// create test suite reference

				reference = (TestSuiteReference *) SDL_malloc(sizeof(TestSuiteReference));

				if(reference == NULL) {

					goto error;

				}

				memset(reference, 0, sizeof(TestSuiteReference));

				const Uint32 dirSize = SDL_strlen(directoryName);

				const Uint32 extSize = SDL_strlen(ext);

				const Uint32 nameSize = SDL_strlen(name) + 1;

				// copy the name

				reference->name = SDL_malloc(nameSize * sizeof(char));

				if(reference->name == NULL) {

					goto error;

				}

				SDL_snprintf(reference->name, nameSize, "%s", name);

				// copy the directory path

				const Uint32 dpSize = dirSize + nameSize + 1 + extSize + 1;

				reference->directoryPath = SDL_malloc(dpSize * sizeof(char));

				if(reference->directoryPath == NULL) {

					goto error;

				}

				SDL_snprintf(reference->directoryPath, dpSize, "%s%s.%s",

						directoryName, name, ext);

				reference->next = suites;

				suites = reference;

			}

		}

	}

	goto finished;

	error:

	if(reference) {

		SDL_free(reference->name);

		SDL_free(reference->directoryPath);

		SDL_free(reference);

	}

	// Unload all the suites that are loaded thus far

	UnloadTestSuites(suites);

	suites = NULL;

	finished:

	if(directory) {

		closedir(directory);

	}

	return suites;

}

/*!

 * Loads test suite which is implemented as dynamic library.

 *

 * \param suite Reference to test suite that'll be loaded

 *

 * \return Pointer to loaded test suite, or NULL if library could not be loaded

 */

void *

LoadTestSuite(const TestSuiteReference *suite)

{

	void *library = SDL_LoadObject(suite->directoryPath);

	if(library == NULL) {

		fprintf(stderr, "Loading %s failed\n", suite->name);

		fprintf(stderr, "%s\n", SDL_GetError());

	}

	return library;

}

/*!

 * Goes through all the given TestSuiteReferences

 * and loads the dynamic libraries. Updates the suites

 * parameter on-the-fly and returns it.

 *

 * \param suites Suites that will be loaded

 *

 * \return Updated TestSuiteReferences with pointer to loaded libraries

 */

TestSuiteReference *

LoadTestSuites(TestSuiteReference *suites)

{

	TestSuiteReference *reference = NULL;

	for(reference = suites; reference; reference = reference->next) {

		reference->library = LoadTestSuite(reference);

	}

	return suites;

}

/*!

 * Unloads the given TestSuiteReferences. Frees all

 * the allocated resources including the dynamic libraries.

 *

 * \param suites TestSuiteReferences for deallocation process

 */

void

UnloadTestSuites(TestSuiteReference *suites)

{

	TestSuiteReference *ref = suites;

	while(ref) {

		if(ref->name)

			SDL_free(ref->name);

		if(ref->directoryPath)

			SDL_free(ref->directoryPath);

		if(ref->library)

			SDL_UnloadObject(ref->library);

		TestSuiteReference *temp = ref->next;

		SDL_free(ref);

		ref = temp;

	}

	suites = NULL;

}

/*!

 * Goes through the previously loaded test suites and

 * loads test cases from them. Test cases are filtered

 * during the process. Function will only return the

 * test cases which aren't filtered out.

 *

 * \param suites previously loaded test suites

 *

 * \return Test cases that survived filtering process.

 */

TestCase *

LoadTestCases(TestSuiteReference *suites)

{

	TestCase *testCases = NULL;

	TestSuiteReference *suiteReference = NULL;

	for(suiteReference = suites; suiteReference; suiteReference = suiteReference->next) {

		TestCaseReference **tests = QueryTestCaseReferences(suiteReference->library);

		TestCaseReference *testReference = NULL;

		int counter = 0;

 		for(testReference = tests[counter]; testReference; testReference = tests[++counter]) {

			//void *suite = suiteReference->library;

			// Load test case functions

			InitTestInvironmentFp initTestEnvironment = LoadInitTestInvironmentFunction(suiteReference->library);

			QuitTestInvironmentFp quitTestEnvironment = LoadQuitTestInvironmentFunction(suiteReference->library);

			TestCaseSetUpFp testSetUp = LoadTestSetUpFunction(suiteReference->library);

			TestCaseTearDownFp testTearDown = LoadTestTearDownFunction(suiteReference->library);

			TestCaseFp testCase = LoadTestCaseFunction(suiteReference->library, testReference->name);

			CountFailedAssertsFp countFailedAsserts = LoadCountFailedAssertsFunction(suiteReference->library);

			// Do the filtering

			if(FilterTestCase(testReference)) {

				TestCase *item = SDL_malloc(sizeof(TestCase));

				memset(item, 0, sizeof(TestCase));

				item->initTestEnvironment = initTestEnvironment;

				item->quitTestEnvironment = quitTestEnvironment;

				item->testSetUp = testSetUp;

				item->testTearDown = testTearDown;

				item->testCase = testCase;

				item->countFailedAsserts = countFailedAsserts;

				// copy suite name

				int length = SDL_strlen(suiteReference->name) + 1;

				item->suiteName = SDL_malloc(length);

				if(item->suiteName == NULL) {

					SDL_free(item);

					return NULL;

				}

				strncpy(item->suiteName, suiteReference->name, length);

				// copy test name

				length = SDL_strlen(testReference->name) + 1;

				item->testName = SDL_malloc(length);

				if(item->testName == NULL) {

						SDL_free(item->suiteName);

						SDL_free(item);

						return NULL;

				}

				strncpy(item->testName, testReference->name, length);

				// copy test description

				length = SDL_strlen(testReference->description) + 1;

				item->description = SDL_malloc(length);

				if(item->description == NULL) {

						SDL_free(item->description);

						SDL_free(item->suiteName);

						SDL_free(item);

						return NULL;