%Automatiza la comprobación de tests
%Organiza los tests
%Los lanza en paquete
%Facilita la escritura de los tests
%Marcar el código que hay que medir
\subsubsection{FrameWork de ejecución de tests}

El cálculo de eficiencia de fragmentos de código se realizará mediante tests unitarios.
El motivo por el cual usamos esta práctica es, por un lado, la simplicidad y el automatismo que representa la creación de un test para el usuario y, por otro, porque, a partir de tests unitarios, podemos repetir la comprobación de eficiencia de un fragmento de código tantas veces como sea preciso y los resultados pueden ser repetibles, es decir, dos comprobaciones para un fragmento que no ha sido modificado devolverá el mismo resultado.
Otra ventaja de la realización de tests es que no obtenemos un único resultado del proceso global, si no que obtenemos la eficiencia para las partes de código en las cuales estamos interesados.
De esta manera, el usuario podrá visualizar qué partes de código mejoran la eficiencia y cuáles la empeoran.

Para realizar el testeo, nos basaremos en la librería de testeo para C/C++ CppUnit.
Para cada test tenemos la posibilidad de limitar los métodos de los cuales queremos calcular su coste mediante dos métodos: {\it Start()} y {\it Stop()}.
Un ejemplo de estructura sería el siguiente:


\begin{lstlisting}[
	caption={Ejemplo de estructura de un Test},
	label={list:TestStructure},
	language={C++}
	]
  	void xxxTest::testxxx()
	{
		Setup();
		int x,y,z;
		Sample sample;
		sample.NoTestedMethod();
		Start();
		x=sample.methodA();
		y=sammple.methodB();
		z=x+y;
		sample.methodC(z);
		Stop();
		sample.AnotherNoTestedMethod()
		TearDown();

      	}
\end{lstlisting}
	

El coste para este test será el del código delimitado entre {\it Start()} y {\it Stop()}.
El cálculo de la eficiencia tendrá en cuenta tanto los métodos como otras instrucciones como, en este caso, la suma de dos variables.
En el caso que se quisiera obtener el valor de todo el test, el programador tiene la posibilidad de prescindir de los métodos {\it Start()} y {\it Stop()}.
Otra característica de estos tests es la estructura de los nombres de la clase y del método. 
Todas las clases que sean suites de tests deben terminar su nombre con {\it Test} (obsérvese que la {\it T} es mayúscula), mientras que el nombre de los métodos de testeo deben iniciarse con test (esta vez, la {\it t} es minúscula).
Esta consideración es esencial para poder realizar el cálculo del coste ya que, como veremos en la explicación del parser, únicamente se tendrán en cuenta los métodos que cumplan dicha premisa.

Una vez los tests han sido creados y compilados, ejecutaremos el {\it callgrind}, el cual simulará una ejecución del programa y creará un fichero de salida.
Dicho fichero contendrá el cálculo de costes de todas las instrucciones del programa.
El problema del fichero de resultados es que no es comprensible a simple vista.
Por este motivo, unido a que nuestro interés radica en los resultados de unos métodos concretos, deberemos extraer la información que nos interesa y mostrar los resultados de manera que no sea necesario tener conocimientos previos de la estructura de resultados del fichero de {\it Callgrind}. 


