path: root/runtime/org.eclipse.etrice.runtime.c/src/common/etUnit/etUnit.c

/*******************************************************************************
 * Copyright (c) 2011 protos software gmbh (http://www.protos.de).
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * CONTRIBUTORS:
 * 		Thomas Schuetz (initial contribution)
 *
 *******************************************************************************/

#include "etUnit/etUnit.h"
#include <string.h>
#include <time.h>
#include <stdlib.h>
#include "debugging/etLogger.h"
#include "osal/etSema.h"
#include "runtime/etRuntime.h"
#include "helpers/etTimeHelpers.h"

/*** member variables */

/* file handling */
static FILE* etUnit_reportfile = NULL;

/* counters */
static etInt16 etUnit_nextCaseId;
static etInt32 etUnit_errorCounter;

#define ETUNIT_MAX_TEST_CASES		256
static etBool etUnit_testcaseSuccess[ETUNIT_MAX_TEST_CASES];

#define ETUNIT_FAILURE_TEXT_LEN 256

/* time measuring */
static etTime etUnit_startTime;
static etTime etUnit_lastTestCaseTime;

etInt16 getCurrentEtUnitId() {
	return etUnit_nextCaseId - 1;
}

/* order */
#define ETUNIT_ORDER_MAX	16
typedef struct OrderInfo {
	etInt16 id;
	etInt16 currentIndex;
	etInt16 size;
	etInt16* list;
} OrderInfo;
static OrderInfo etUnit_orderInfo[ETUNIT_ORDER_MAX];

static OrderInfo* getOrderInfo(etInt16 id) {
	int i;
	for (i = 0; i < ETUNIT_ORDER_MAX; ++i)
		if (etUnit_orderInfo[i].id == id)
			return etUnit_orderInfo + i;

	return NULL;
}

/* float measuring */
#if defined (ET_FLOAT32) || defined (ET_FLOAT64)
#define ETUNIT_FLOAT
#ifdef ET_FLOAT64
typedef etFloat64 etUnitFloat;
#else
typedef etFloat32 etUnitFloat;
#endif
#endif

/* forward declarations of private functions */
static void expect_equal_int(etInt16 id, const char* message, etInt32 expected, etInt32 actual, const char* file, int line);
/* currently not used
static void expect_range_int(etInt16 id, const char* message, etInt32 min, etInt32 max, etInt32 actual, const char* file, int line);
*/
static void expect_equal_uint(etInt16 id, const char* message, etUInt32 expected, etUInt32 actual, const char* file, int line);
/* currently not used
static void expect_range_uint(etInt16 id, const char* message, etUInt32 min, etUInt32 max, etUInt32 actual, const char* file, int line);
*/

#ifdef ETUNIT_FLOAT
static void expect_equal_float(etInt16 id, const char* message, etUnitFloat expected, etUnitFloat actual, etUnitFloat precision, const char* file, int line);
static void expect_range_float(etInt16 id, const char* message, etUnitFloat min, etUnitFloat max, etUnitFloat actual, const char* file, int line);
#endif

static void etUnit_handleExpect(etInt16 id, etBool result, const char *trace, const char* expected, const char* actual, const char* file, int line);

/* public functions */

void etUnit_open(const char* testResultPath, const char* testFileName) {
	etLogger_logInfoF("************* TEST START (%s) **************", testFileName);

	{
		char filename[ETUNIT_FAILURE_TEXT_LEN];
		int i;

		if (testResultPath != NULL)
			snprintf(filename, sizeof(filename), "%s/%s.etu", testResultPath, testFileName);
		else
			snprintf(filename, sizeof(filename),"%s.etu", testFileName);

		/* init global data */
		for (i = 0; i < ETUNIT_ORDER_MAX; ++i)
			etUnit_orderInfo[i].id = 0;
		for (i = 0; i < ETUNIT_MAX_TEST_CASES; ++i)
			etUnit_testcaseSuccess[i] = ET_TRUE;
		etUnit_errorCounter = 0;
		etUnit_nextCaseId = 1;

		if (etUnit_reportfile == NULL) {
			etUnit_reportfile = etLogger_fopen(filename, "w+");
			if (etUnit_reportfile != NULL) {
				etLogger_fprintf(etUnit_reportfile, "etUnit report\n");
			} else {
				etLogger_logErrorF("Unable to open file %s", filename);
			}
		}
	}

	/* prepare time measurement */
	getTimeFromTarget(&etUnit_startTime);
}

void etUnit_close(void) {
	etTime endTime;
	if (etUnit_reportfile != NULL) {
		etLogger_fclose(etUnit_reportfile);
		etUnit_reportfile = NULL;
	}
	getTimeFromTarget(&endTime);
	etTimeHelpers_subtract(&endTime, &etUnit_startTime);
	etLogger_logInfoF("Elapsed Time: %ld ms", etTimeHelpers_convertToMSec(&endTime));
	if (etUnit_errorCounter == 0)
		etLogger_logInfoF("Error Counter: %ld", etUnit_errorCounter);
	else
		etLogger_logErrorF("Error Counter: %ld", etUnit_errorCounter);
	etLogger_logInfoF("************* TEST END **************");
}

void etUnit_openTestSuite(const char* testSuiteName) {
	if (etUnit_reportfile != NULL) {
		etLogger_fprintf(etUnit_reportfile, "ts start: %s\n", testSuiteName);
	}
}

void etUnit_closeTestSuite(void) {
}

etInt16 etUnit_openTestCase(const char* testCaseName) {
	etInt16 caseId = etUnit_nextCaseId++;

	if (caseId >= ETUNIT_MAX_TEST_CASES) {
		etLogger_logErrorF("Too many test cases. Maximum number of test cases is %d\n",
		ETUNIT_MAX_TEST_CASES);
		etLogger_logErrorF("ETUNIT_MAX_TEST_CASES (etUnit_openTestCase, %s: %d)", __FILE__,
		__LINE__);
		exit(-1);
	}
	if (etUnit_reportfile != NULL) {
		etLogger_fprintf(etUnit_reportfile, "tc start %d: %s\n", caseId, testCaseName);
		getTimeFromTarget(&etUnit_lastTestCaseTime);
	}

	return caseId;
}

void etUnit_closeTestCase(etInt16 id) {
	OrderInfo* info = getOrderInfo(id);
	if(info != NULL){
		if (info->currentIndex != info->size) {
			etUnit_handleExpect(id, ET_FALSE, "EXPECT_ORDER was not completed", NULL, NULL, 0, 0);
		}
	}

	if (etUnit_reportfile != NULL) {
		etTime time;
		getTimeFromTarget(&time);
		etTimeHelpers_subtract(&time, &etUnit_lastTestCaseTime);
		etLogger_fprintf(etUnit_reportfile, "tc end %d: %d\n", id, etTimeHelpers_convertToMSec(&time));
	}
}

void etUnit_skipTestCase(etInt16 id, const char* msg) {
	if (etUnit_reportfile != NULL) {
		etLogger_fprintf(etUnit_reportfile, "tc skip %d: %s\n", id, msg);
	}
}

etInt16 etUnit_openAll(const char* testResultPath, const char* testFileName, const char* testSuiteName, const char* testCaseName) {
	etUnit_open(testResultPath, testFileName);
	etUnit_openTestSuite(testSuiteName);
	return etUnit_openTestCase(testCaseName);
}

void etUnit_closeAll(etInt16 id) {
	etUnit_closeTestCase(id);
	etUnit_closeTestSuite();
	etUnit_close();
}

void etUnit_testFinished(etInt16 id) {
	etSema_wakeup(etRuntime_getTerminateSemaphore());
}

void expectTrue(etInt16 id, const char* message, etBool condition, const char* file, int line) {
	if (condition == ET_FALSE) {
		char testresult[ETUNIT_FAILURE_TEXT_LEN];
		snprintf(testresult, sizeof(testresult), "%s: *** EXPECT_TRUE == FALSE", message);
		etUnit_handleExpect(id, ET_FALSE, testresult, "TRUE", "FALSE", file, line);
	} else {
		etUnit_handleExpect(id, ET_TRUE, "", NULL, NULL, file, line);
	}
}

void expectFalse(etInt16 id, const char* message, etBool condition, const char* file, int line) {
	if (condition == ET_TRUE) {
		char testresult[ETUNIT_FAILURE_TEXT_LEN];
		snprintf(testresult, sizeof(testresult), "%s: EXPECT_FALSE == TRUE", message);
		etUnit_handleExpect(id, ET_FALSE, testresult, "FALSE", "TRUE", file, line);
	} else {
		etUnit_handleExpect(id, ET_TRUE, "", NULL, NULL, file, line);
	}
}

void expectEqualInt8(etInt16 id, const char* message, etInt8 expected, etInt8 actual, const char* file, int line) {
	expect_equal_int(id, message, (etInt32) expected, (etInt32) actual, file, line);
}

void expectEqualInt16(etInt16 id, const char* message, etInt16 expected, etInt16 actual, const char* file, int line) {
	expect_equal_int(id, message, (etInt32) expected, (etInt32) actual, file, line);
}

void expectEqualInt32(etInt16 id, const char* message, etInt32 expected, etInt32 actual, const char* file, int line) {
	expect_equal_int(id, message, (etInt32) expected, (etInt32) actual, file, line);
}

void expectEqualUInt8(etInt16 id, const char* message, etUInt8 expected, etUInt8 actual, const char* file, int line) {
	expect_equal_uint(id, message, (etUInt32) expected, (etUInt32) actual, file, line);
}

void expectEqualUInt16(etInt16 id, const char* message, etUInt16 expected, etUInt16 actual, const char* file, int line) {
	expect_equal_uint(id, message, (etUInt32) expected, (etUInt32) actual, file, line);
}

void expectEqualUInt32(etInt16 id, const char* message, etUInt32 expected, etUInt32 actual, const char* file, int line) {
	expect_equal_uint(id, message, (etUInt32) expected, (etUInt32) actual, file, line);
}

void expect_equal_void_ptr(etInt16 id, const char* message, const void* expected, const void* actual, const char* file, int line) {
	if (expected != actual) {
		char testresult[ETUNIT_FAILURE_TEXT_LEN];
		char exp[16], act[16];
		snprintf(testresult,  sizeof(testresult), "%s: expected=%p, actual=%p", message, expected, actual);
		sprintf(exp, "%p", expected);
		sprintf(act, "%p", actual);
		etUnit_handleExpect(id, ET_FALSE, testresult, exp, act, file, line);
	} else {
		etUnit_handleExpect(id, ET_TRUE, "", NULL, NULL, file, line);
	}
}

void expectEqualStr(etInt16 id, const char* message, const char* expected, const char* actual, const char* file, int line) {
	if (!(expected || actual || strcmp(expected, actual) == 0)) {
		char testresult[ETUNIT_FAILURE_TEXT_LEN];
		snprintf(testresult,  sizeof(testresult), "%s: expected=%s, actual=%s", message, expected, actual);
		etUnit_handleExpect(id, ET_FALSE, testresult, expected, actual, file, line);
	} else {
		etUnit_handleExpect(id, ET_TRUE, "", NULL, NULL, file, line);
	}
}

#ifdef ET_FLOAT32
void expectEqualFloat32(etInt16 id, const char* message, etFloat32 expected, etFloat32 actual, etFloat32 precision, const char* file, int line) {
	expect_equal_float(id, message, expected, actual, precision, file, line);
}

void expectRangeFloat32(etInt16 id, const char* message, etFloat32 min, etFloat32 max, etFloat32 actual, const char* file, int line) {
	expect_range_float(id, message, min, max, actual, file, line);
}
#endif

#ifdef ET_FLOAT64
void expectEqualFloat64(etInt16 id, const char* message, etFloat64 expected, etFloat64 actual, etFloat64 precision, const char* file, int line) {
	expect_equal_float(id, message, expected, actual, precision, file, line);
}

void expectRangeFloat64(etInt16 id, const char* message, etFloat64 min, etFloat64 max, etFloat64 actual, const char* file, int line) {
	expect_range_float(id, message, min, max, actual, file, line);
}
#endif

void expectOrderStart(etInt16 id, etInt16* list, etInt16 size, const char* file, int line) {
	int i;
	for (i = 0; i < ETUNIT_ORDER_MAX; ++i)
		if (etUnit_orderInfo[i].id == 0) {
			etUnit_orderInfo[i].id = id;
			etUnit_orderInfo[i].currentIndex = 0;
			etUnit_orderInfo[i].size = size;
			etUnit_orderInfo[i].list = list;
			break;
		}
}

void expectOrder(etInt16 id, const char* message, etInt16 identifier, const char* file, int line) {
	OrderInfo* info = getOrderInfo(id);
	if (info != NULL) {
		if (info->currentIndex < info->size) {
			if (info->list[info->currentIndex] != identifier) {
				char testresult[ETUNIT_FAILURE_TEXT_LEN];
				char exp[16], act[16];
				snprintf(testresult,  sizeof(testresult), "EXPECT_ORDER %s: index=%d, expected=%d, actual=%d", message, info->currentIndex, identifier,
						info->list[info->currentIndex]);
				sprintf(exp, "%d", identifier);
				sprintf(act, "%d", info->list[info->currentIndex]);
				etUnit_handleExpect(id, ET_FALSE, testresult, exp, act, file, line);
			} else {
				etUnit_handleExpect(id, ET_TRUE, "", NULL, NULL, file, line);
				info->currentIndex++;
			}
		} else {
			char testresult[ETUNIT_FAILURE_TEXT_LEN];
			snprintf(testresult, sizeof(testresult), "EXPECT_ORDER: index(%d) is too big in %s", info->currentIndex, message);
			etUnit_handleExpect(id, ET_FALSE, testresult, NULL, NULL, file, line);
			etLogger_logInfoF("EXPECT_ORDER: index too big in %s", message);
		}
	}
}

void expectOrderEnd(etInt16 id, const char* message, etInt16 identifier, const char* file, int line) {
	OrderInfo* info = getOrderInfo(id);
	expectOrder(id, message, identifier, file, line);
	if (info->currentIndex != info->size) {
		char testresult[ETUNIT_FAILURE_TEXT_LEN];
		snprintf(testresult,  sizeof(testresult), "EXPECT_ORDER_END %s: wrong index at the end: expected=%d, actual=%d", message, info->size, info->currentIndex);
		etUnit_handleExpect(id, ET_FALSE, testresult, NULL, NULL, file, line);
	}
}

etBool etUnit_isSuccess(etInt16 id) {
	return etUnit_testcaseSuccess[id];
}

/* private functions */

static void expect_equal_int(etInt16 id, const char* message, etInt32 expected, etInt32 actual, const char* file, int line) {
	if (expected != actual) {
		char testresult[ETUNIT_FAILURE_TEXT_LEN];
		char exp[16], act[16];
		snprintf(testresult, sizeof(testresult), "%s: expected=%d, actual=%d", message, expected, actual);
		sprintf(exp, "%d", expected);
		sprintf(act, "%d", actual);
		etUnit_handleExpect(id, ET_FALSE, testresult, exp, act, file, line);
	} else {
		etUnit_handleExpect(id, ET_TRUE, "", NULL, NULL, file, line);
	}
}

/* currently not used
static void expect_range_int(etInt16 id, const char* message, etInt32 min, etInt32 max, etInt32 actual, const char* file, int line) {
	if (actual < min || actual > max) {
		char testresult[ETUNIT_FAILURE_TEXT_LEN];
		char exp[64], act[16];
		sprintf(testresult, "%s: min=%ld, max=%ld, actual=%ld", message, min, max, actual);
		if (actual < min) {
			sprintf(exp, ">=%ld(min)", min);
			sprintf(act, "%ld", actual);
		} else {
			sprintf(exp, "<=%ld(max)", max);
			sprintf(act, "%ld", actual);
		}
		etUnit_handleExpect(id, ET_FALSE, testresult, exp, act, file, line);
	} else {
		etUnit_handleExpect(id, ET_TRUE, "", NULL, NULL, file, line);
	}
}
*/

static void expect_equal_uint(etInt16 id, const char* message, etUInt32 expected, etUInt32 actual, const char* file, int line) {
	if (expected != actual) {
		char testresult[ETUNIT_FAILURE_TEXT_LEN];
		char exp[16], act[16];
		snprintf(testresult, sizeof(testresult), "%s: expected=%u, actual=%u", message, expected, actual);
		sprintf(exp, "%u", expected);
		sprintf(act, "%u", actual);
		etUnit_handleExpect(id, ET_FALSE, testresult, exp, act, file, line);
	} else {
		etUnit_handleExpect(id, ET_TRUE, "", NULL, NULL, file, line);
	}
}

/* currently not used
static void expect_range_uint(etInt16 id, const char* message, etUInt32 min, etUInt32 max, etUInt32 actual, const char* file, int line) {
	if (actual < min || actual > max) {
		char testresult[ETUNIT_FAILURE_TEXT_LEN];
		char exp[64], act[16];
		sprintf(testresult, "%s: min=%lu, max=%lu, actual=%lu", message, min, max, actual);
		if (actual < min) {
			sprintf(exp, ">=%lu(min)", min);
			sprintf(act, "%lu", actual);
		} else {
			sprintf(exp, "<=%lu(max)", max);
			sprintf(act, "%lu", actual);
		}
		etUnit_handleExpect(id, ET_FALSE, testresult, exp, act, file, line);
	} else {
		etUnit_handleExpect(id, ET_TRUE, "", NULL, NULL, file, line);
	}
}
*/

#ifdef ETUNIT_FLOAT
static void expect_equal_float(etInt16 id, const char* message, etUnitFloat expected, etUnitFloat actual, etUnitFloat precision, const char* file, int line) {
	if (expected - actual < -precision || expected - actual > precision) {
		char testresult[ETUNIT_FAILURE_TEXT_LEN];
		char exp[16], act[16];
		snprintf(testresult, sizeof(testresult), "%s: expected=%f, actual=%f", message, expected, actual);
		sprintf(exp, "%f", expected);
		sprintf(act, "%f", actual);
		etUnit_handleExpect(id, ET_FALSE, testresult, exp, act, file, line);
	} else {
		etUnit_handleExpect(id, ET_TRUE, "", NULL, NULL, file, line);
	}
}

static void expect_range_float(etInt16 id, const char* message, etUnitFloat min, etUnitFloat max, etUnitFloat actual, const char* file, int line) {
	if (actual < min || actual > max) {
		char testresult[ETUNIT_FAILURE_TEXT_LEN];
		char exp[64], act[16];
		snprintf(testresult, sizeof(testresult), "%s: min=%f, max=%f, actual=%f", message, min, max, actual);
		if (actual < min) {
			sprintf(exp, ">=%f(min)", min);
			sprintf(act, "%f", actual);
		} else {
			sprintf(exp, "<=%f(max)", max);
			sprintf(act, "%f", actual);
		}
		etUnit_handleExpect(id, ET_FALSE, testresult, exp, act, file, line);
	} else {
		etUnit_handleExpect(id, ET_TRUE, "", NULL, NULL, file, line);
	}
}
#endif

static void etUnit_handleExpect(etInt16 id, etBool result, const char *resulttext, const char* exp, const char* act, const char* file, int line) {
	if (result == ET_TRUE) {
		/* nothing to do because no failure */
	} else {
		etUnit_errorCounter++;
		if (etUnit_testcaseSuccess[id] == ET_TRUE) {
			/* first failure will be remembered */
			etUnit_testcaseSuccess[id] = ET_FALSE;

			if (act != NULL && exp != NULL)
				etLogger_fprintf(etUnit_reportfile, "tc fail %d: #%s#%s#%s:%d#%s\n", id, exp, act, file, line, resulttext);
			else
				etLogger_fprintf(etUnit_reportfile, "tc fail %d: ###%s:%d#%s\n", id, file, line, resulttext);
		} else {
			/* more than one error will be ignored */
		}
	}
}