/*****
*
*	Michael Riff
*	RPN software version 1.0  Oktob 2013.
*
*	Diese Datei wird nur zur Testzwecke benötigt.
*	Die in der Textdatei definierten Berechnungen werden hier in C implementiert.
*	Das Ergebnis der Ausführung der eingelesenen Berechnungen wird mit dem
*	Ergebnis der hier Implementierten Routine verglichen.
*
*	Version 1.1: 07 Jan 2014
*	modified Test11 to test bool negation function.
*
*	Version 1.6: 28 Sept 2014
*	Added two test routines to test extended end of for loop condition expression.
*
*	Version 1.7: 06 June 2016
*	Added check if selected graphik ID has an associated test function.
*	13 June 2016
*	Added additional test cases.
*
*	Version 1.8:  23 July 2016
*	Corrected Test18 & 19 routines
*	Modified Test13 to prevent endless loops and corrected difference to source text.
*	30 July 2016
*	Suppressed switch for ARG_DOUBLE in TestCall routine.
*
*****/

#include <math.h>

#include "Parser.h"

//extern Grph_struct	*Graphs;
extern int	aktGraphik;
extern double aktDaten[];
/* Fehler Wert Definierung */
extern double ValErr;	// defined in Calculs.c


double NoTest(double param1, double param2, double param3, double param4) {
	printf("Test error: non test routine\n");
	return 0;
}


double Test2(double param1, double param2, double param3, double param4) {
	double var;
	double index;
	
	var = ( 34 + 6 ) * 86 / -sin (log (35)) - 2 ;
	index =  0 ;
	while ((var - index * 1000) > 0 ) { index =  index + 1 ; }
	return index;

}

double Test1(double param1, double param2, double param3, double param4) {
	double var;
	var = ( 34 + 6 ) * 86 / -sin( log (35)) - 2 ;
	if (var <= 0 && 1 > 2) { return(- var + 100); } else { return param3; }
}

double Test3(double param1, double param2, double param3, double param4) {
	double var;
	double index;

	var = 20000;
	for(index=0;index<11;index++) {  var =  var - 1000 ; }
	return index;
}

double Test4(double param1, double param2, double param3, double param4) {
	
if (aktDaten[0] != 3) { return ValErr; } else { return (param1 + param2 + param3); }
}

double Test23(double param1, double param2, double param3, double param4) {
	double var1, var2, var3, var4;

	if (param1 < 6) {
		var1 = param1 - param2;
		var2 = param3 + param4;
		var3 = var1 * param3;
		var4 = param4 * var2;
		var2 /= exp(param3);
		return var2 + param1;
	} else {
		var1 =param1 + param2;
		var2 = param3 - param4;
		var3 = var2 * param3;
		var4 = param4 / exp(var2);
		if (12>=var1) {
			return var4;
		} else {
			return var2 - var3;
		}
	}
}


double Test5(double param1, double param2, double param3, double param4) {
	double var;
	var = ( 34 + 6 ) * 86 / -sin (log (35)) - 2;
	if (param1 < var) { return(-var); } else { return var; }
}


double TestOperat(double param1, double param2, double param3, double param4)
{
	double tmp1, tmp2;

	tmp1 = param1+param2;
	tmp2 = param3+param4;

	tmp1 -= 1.3*param4;
	tmp2 /= 0.45+param2;

	return tmp1+tmp2;
}



double	TestSigma(double param1, double param2, double param3, double param4)
{
	double loop;
	double result,sum;

	if (param1<1)
		return ValErr;

	result = 0;
	sum = 0;
	for (loop=1; loop<=(int)param1; loop++)
	{
		result += pow(loop,2);
		sum += loop;
	}
	result = (result-sum)/param1;
	result = pow(result, 0.5);
	return result;
}

/*
	Attention: lors d'écriture du paramètre, création d'une variable...
*/
double TestRegrLine(double param1, double param2, double param3, double param4)
{
	double	a, b, numVal;
	double	MnX, MnY, MnMult, MnSQ;

	if (param1<2)
		return ValErr;

	MnX = 0;
	MnY = 0;
	MnMult = 0;
	MnSQ = 0;
	numVal = param1;
	do {
		MnX += 0.35* numVal;
		MnY += sinh(0.35* numVal);

		MnMult += 0.35* numVal * sinh(0.35* numVal);
		MnSQ += pow(0.35*numVal, 2);
		
		numVal--;
	} while(numVal>0);

	MnX /= param1;
	MnY /= param1;

	a = (MnMult - param1*MnX*MnY) / (MnSQ - param1*pow(MnX,2));
	b = MnY - a * MnX;

	return b;
}

double Test9(double param1, double param2, double param3, double param4) {
	double var;
	var = (34+6.6)*86 / tan(35.8-15) - 4.5;
	if (param1 < var) { return(-var); } else { return var; }
}

double Test10(double param1, double param2, double param3, double param4) {
	double loop;
	double result, sum;

	result = 0;
	sum = 0;
	for (loop=1;loop<= param1;loop++) {
		if ( loop<4 || loop>9 && loop<=15) {
			result += pow((loop/2),2);
			sum = sum + loop/2;
		} else {
			result += pow(loop,2);
			sum += loop;
		}
	}
	result = (result-sum)/param1;
	result = pow(result,0.5);
	return result;
}

double Test11(double param1, double param2, double param3, double param4) {
	double loop;
	double result, sum;

	result = 0;
	sum = 0;

	if (!(param1>5 && param1<=10)) {
		loop = 10;
		while (loop>param2) {
			result += pow(loop,2);
			sum += loop;
			loop-=1;
		}
	}
	result = (result-sum)/param1;
	result = pow(result,0.5);
	return result;
}

double Test18(double param1, double param2, double param3, double param4) {
	return 5 + 3 * 10;
}

double Test19(double param1, double param2, double param3, double param4) {
	return 5 + 3 * 10;
}

#ifdef EXT_FOR

double Test20(double param1, double param2, double param3, double param4) {
	double count;
	double index;
	
	count = 13;
	for (index=-1; index<=15 && count<param1; index++)
		++count;
	return count-2;
}

double Test21(double param1, double param2, double param3, double param4) {
	double count;
	double index, tmp;

	index = -5;
	tmp=0;
	
	for(count=pow(2,3)-5; tmp<param1 && sin(index/30.0)<0.5; index+=1.5)
		tmp += count+index;
	return tmp;
}

double Test12(double param1, double param2, double param3, double param4) {
	double var;
	double loop;
	
	var = 0;
	if (param4<=0) {
		return ValErr;
	}
	for(loop=pow(param1*pow(2,param2),2); tanh(param3*5)<0.9 && loop<100; loop=loop+param4)
		var += loop/11;
	return var;
}

double Test13(double param1, double param2, double param3, double param4) {
	double vare_1, vare_2, vari, var;
	double lpext, lpint;

	vare_1=0; vare_2=0; vari=0;
	if (param2>0) {
		var = -param2;
	} else {
		var = param2;
	}
	if (0 == var) { var = 0.5; }
	for(lpext=-var; lpext<1.5*param3; lpext=lpext*2) {
		vare_1 += param1;
		for(lpint=param4-1; lpint<pow(2,param4); lpint++) {
			vari += lpint-lpext;
		}
		vare_2 += vari;
	}
	return vare_2;
}

#endif

double Test14(double param1, double param2, double param3, double param4) {
	double vare_1, vare_2;

	vare_1 = param1+param2*param3/param4;
	vare_2 = param1/param2*param3-param4;
	return vare_1+vare_2;
}



typedef double (*TestFuncType)(double, double, double, double);

TestFuncType	TestFunctions[24] = { NoTest, Test1, Test2, Test3, Test4, Test5, TestOperat, TestSigma, TestRegrLine, Test9,
#ifndef EXT_FOR
		Test10, Test11, NoTest, NoTest, Test14, NoTest, NoTest, NoTest, Test18, Test19, NoTest,
		NoTest, NoTest, Test23 };
#else
		Test10, Test11, Test12, Test13, Test14, NoTest, NoTest, NoTest, Test18, Test19, Test20,
		Test21, NoTest, Test23 };
#endif

#ifdef MIT_VAR
extern variables	*Valeurs;
#endif



/*	Corresponding test call	*/
void TestCall(int graphIdx, double actualValue) {
			
	double expectedVal;
					
	printf("-------\n\tModule Test:\n-------\n");
						
	// Set test values for module test
							
	/*	aktDaten[1] = ;
	aktDaten[2] = ; 
	aktDaten[3] = ; 
	aktDaten[4] = ; 
	*/
	if (aktGraphik<24) {
		// Actual unit testcall
		expectedVal = TestFunctions[aktGraphik](aktDaten[1],aktDaten[2],aktDaten[3],aktDaten[4]);
	} else {
		expectedVal = -1;
	}

	// Results check
	if (expectedVal != actualValue)
		printf("Test error for %d, results %f expected %f\n",graphIdx, (float)actualValue, (float)expectedVal);
}