Pruebas unitarias Minicalc

7/23/2019 Pruebas unitarias Minicalc

http://slidepdf.com/reader/full/pruebas-unitarias-minicalc 1/13

MATERIALES DE TRABAJO DE EVOLUCIÓN Y PRUEBAS DE SOFTWARE

PRÁCTICA DE LABORATORIO N˚ 01

Instrucciones : Desarrolle las actividades solicitadas.

PRUEBAS UNITARIAS CON NUNIT

PROYECTO MINICALC

EJERCICIO 1: CREAR SOLUCION Y PROYECTOS

1. Crear una solución en blanco llamado MiniCalc.

2. Añadir un proyecto C# Windows Forms Application, llamado MiniCalc.

3. Añadir un proyecto C# Unit Test Project, llamado CalcTest.

4. Renombrar la clase UnitTest1 por CalcTest.

5. Inserte el siguiente código en la clase CalcTest.:

using System;using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace CalcTest{

[TestClass] public class UnitTest1

{ [TestMethod] public void PruebaFalla(){

Console.Out.WriteLine("Llamando a PruebaFalla");Assert.Fail("Esta prueba falla!");

}

[TestMethod] public void PruebaExito(){

Console.Out.WriteLine("Llamando a PruebaExito");Assert.IsTrue(true,"Esta prueba es un exito!");

}

}

}

6. Construya la solución (Biuld Solution).

7. Corra la pruebas.

EJERCICIO 2: ESCRIBIR UNA PRUEBA Y PROBAR ALGUNA FUNCIONALIDAD

1. Añada el método TestAdd a la clase CalcTest.

[TestMethod] public void TestAdd(){

Console.Out.WriteLine("TestAddition called");

Calculator testCalc = new Calculator();//test for case of zeros'Assert.AreEqual(0, testCalc.Add(0, 0), "Adding 0 to 0 should produce 0");//test that param ordering isn't important

Sección : …………………..

Docente : Daniel Gamarra Moreno

Unidad ; ……… Semana : …….

Apellidos : ………………………………..

Nombres : ………………………………..

Fecha : …/…/… Duración: …….

1




Assert.AreEqual(1, testCalc.Add(1, 0), "Adding 1 to 0 should produce 1");Assert.AreEqual(1, testCalc.Add(0, 1), "Adding 0 to 1 should produce 1");//test for non zero caseAssert.AreEqual(3, testCalc.Add(1, 2), "Adding 1 to 2 should produce 3");int nResult;try{

nResult = testCalc.Add(int.MaxValue, int.MaxValue);

Assert.Fail("Should throw a ResultOutofRangeException");}catch (ResultOutOfRangeException){}

testCalc = null;}

2. Añada la clase Calculator.

3. Crea el esqueleto de la clase Calculator y la excepcion.

using System;using System.Collections.Generic;

using System.Linq;using System.Text;using System.Threading.Tasks;

namespace MiniCalc{

public class ResultOutOfRangeException : ApplicationException{}

public class Calculator{

public int Add(int a, int b){

return 0;}

}}

4. Remueva los métodos PruebeFalla y PruebaExito de CalcTest.

5. Añadir la referencia MiniCalc a CalcTest.

6. Inserte la directiva “using MiniCalc;” en el archivo CalcTest.cs

7. Compila el proyecto (Build Solution).

8. Corra la prueba y ….. falla la prueba porque falta la funcionalidad.

9. Modifica el método Add de Calculator, para darle funcionalidad.


return a + b;}

10. Falla la prueba debido a que no se lanza la excepción.

11. Modifica el método Add, que incluye la excepción.


int result;result = a + b;

if (result < 0){

ResultOutOfRangeException rangeEx = new ResultOutOfRangeException();

2




throw rangeEx;}return result;

}

12. Compila el proyecto (Build Solution) y corra el NUnit.

EJERCICIO 3: CONECTE LA LOGICA DE NEGOCIO A LA INTERFACE DE USUARIO

1. Crea la siguiente interface:

Figura 1. Interface de usuario – Proyecto MiniCalc.

Añada dos controles NumericUpDown llamados NumberA y NumberB, una etiqueta con el texto +, un botónllamado EqualsButton con el texto = y una etiqueta llamada Result (mostrado como 3 en la figura).

2. Doble click en el control EqualsButton para generar el evento handler. En este evento inserte el siguiente código.

private void EqualsButton_Click(object sender, EventArgs e){

try{

Calculator calc = new Calculator();Result.Text = (calc.Add((int)NumberA.Value, (int)NumberB.Value).ToString());

}catch (ResultOutOfRangeException){

Result.Text = "Out of Range";}

}

3. Construya la solución (Biuld Solution) y ejecuta la aplicación.

Usar una capa de interface te permite probar la lógica de negocio y cambiar la capa de interface sin cambiar la lógicade negocio. Además, es una buena práctica.

EJERCICIO 4: CONECTE LA LOGICA DE NEGOCIO A UNA INTERFACE DIFERENTE

1. Cambie el código del método main de la clase MiniCalc al siguiente código.

static void Main(){

int nA, nB;

string result;Console.WriteLine("Welcome to Mini Calc");Console.WriteLine("Please enter the first number to add");nA = Convert.ToInt32(Console.ReadLine());Console.WriteLine("Please enter the second number to add");nB = Convert.ToInt32(Console.ReadLine());try{

Calculator calc = new Calculator();result = (calc.Add(nA, nB)).ToString();


result = "Out of Range";}Console.WriteLine(result);

Console.ReadLine();}

3




2. Cambie la propiedad del proyecto. (Botón derecho en la solución explorer) Configurar la salida Consoleaplication.

3. Construya la solución (Biuld Solution) y ejecuta la aplicación desde la línea de comandos.

Al desarrollar el software aplicando las pruebas unitarias, uno de las reglas es: Si puedo pensar una forma de romperla aplicación, escriba una prueba para comprobar que puede romperla.

EJERCICIO 5: ESCRIBIR UNA PRUEBA PARA CORREGIR UN BUG

1. En la clase Calctest añada el método TestAddNegatives.

[TestMethod] public void TestAddNegatives(){

Console.Out.WriteLine("TestAddNegatives called");Calculator testCalc = new Calculator();int nResult;

try{

nResult = testCalc.Add(-1, 0);

Assert.Fail("Should throw a NegativeParameterException");}catch (NegativeParameterException ){ }

try{

nResult = testCalc.Add(0, -1);Assert.Fail("Should throw a NegativeParameterException");

}catch (NegativeParameterException){ }

try{

nResult = testCalc.Add(int.MinValue, int.MinValue);

Assert.Fail("Should throw a NegativeParameterException");}catch (NegativeParameterException){ }

testCalc = null;}

2. Note que hemos añadido un nuevo tipo de excepción, por lo debemos tener una clase o un método en la prueba.Necesitamos crear la excepción en el archivo de la Clase Calculator.

public class NegativeParameterException:ApplicationException{}

3. Compila y corra las pruebas de nuevo. La prueba de fracasar, como se esperaba. Escriba el código paraarreglarla. Correr las pruebas es una buena práctica.


int result;if (a < 0 || b < 0 ){

NegativeParameterException npEx = new NegativeParameterException();throw npEx;

}

result = a + b;

if (result < 0){

ResultOutOfRangeException rangeEx = new ResultOutOfRangeException();throw rangeEx;

}return result;

4




}

4. Compila y corral as pruebas. La prueba es exitosa.

A estas alturas el código de CalcTests es el siguiente.

using System;

using Microsoft.VisualStudio.TestTools.UnitTesting;using MiniCalc;

namespace CalcTest{

[TestClass] public class CalcTest{

[TestMethod] public void TestAdd(){

Console.Out.WriteLine("TestAddition called");Calculator testCalc = new Calculator();//test for case of zeros'Assert.AreEqual(0, testCalc.Add(0, 0), "Adding 0 to 0 should produce 0");//test that param ordering isn't important

Assert.AreEqual(1, testCalc.Add(1, 0), "Adding 1 to 0 should produce 1");Assert.AreEqual(1, testCalc.Add(0, 1), "Adding 0 to 1 should produce 1");//test for non zero caseAssert.AreEqual(3, testCalc.Add(1, 2), "Adding 1 to 2 should produce 3");int nResult;try{

nResult = testCalc.Add(int.MaxValue, int.MaxValue);Assert.Fail("Should throw a ResultOutofRangeException");

}catch (ResultOutOfRangeException){}testCalc = null;

}


Console.Out.WriteLine("TestAddNegatives called");Calculator testCalc = new Calculator();int nResult;

try{

nResult = testCalc.Add(-1, 0);Assert.Fail("Should throw a NegativeParameterException");


try

{ nResult = testCalc.Add(0, -1);Assert.Fail("Should throw a NegativeParameterException");


try{

nResult = testCalc.Add(int.MinValue, int.MinValue);Assert.Fail("Should throw a NegativeParameterException");


testCalc = null;

}}}

5




EJERCICIO 6: ESCRIBIR UNA PRUEBA Y LUEGO OTRA FUNCION

1. Añada un nuevo método a CalcTests llamado TestSubtract.

[TestMethod] public void TestSubtract(){

Console.Out.WriteLine("TestSubtract called");Calculator testCalc = new Calculator();int nResult;

Assert.AreEqual(0, testCalc.Subtract(0, 0), "Subtracting 0 from 0 should produce 0");Assert.AreEqual(1, testCalc.Subtract(0, 1), "Subtracting 0 from 1 should produce 1");

try{

nResult = testCalc.Subtract(1, 0);Assert.Fail("Subtracting 1 from 0 should throw a ResultOutofRangeException");

}catch (ResultOutOfRangeException){ }

Assert.AreEqual(0,testCalc.Subtract(int.MaxValue, int.MaxValue), "Subtracting max value from max value should produce 0");

try{

nResult = testCalc.Subtract(-1, 0);Assert.Fail("Should throw a NegativeParameterException");


try{

nResult = testCalc.Subtract(0, -1);Assert.Fail("Should throw a NegativeParameterException");


try{

nResult = testCalc.Subtract(int.MinValue, int.MinValue);Assert.Fail("Should throw a NegativeParameterException");


}

2. Escriba el esqueleto del método que se necesitará en la clase Calculator.

public int Subtract(int numberToSubtract, int subtractFrom ){

return 0;}

3. Compila y corra las pruebas. Como era de esperar fracaso la prueba TestSubtract. Estamos en la posición deescribir el código para pasar la prueba.

public int Subtract(int numberToSubtract, int subtractFrom ){

int result;if (subtractFrom < 0 || numberToSubtract < 0 ){


}

result = subtractFrom - numberToSubtract;if (result < 0){

ResultOutOfRangeException rangeEx = new ResultOutOfRangeException();throw rangeEx;

}return result;

6




}

4. Compila y corral as pruebas. Ahora si paso.

Si observa cuidadosamente, notara que existe código duplicado, la verificación de los parámetros negativos serepiten en los métodos Add y Subtract, esto se puede extraer a un método.

EJERCICIO 7: ESCRIBIR UNA PRUEBA Y LUEGO EXTRAER EL METODO

1. Antes de cambiar el código debemos escribir una prueba que valide la funcionalidad, por lo que tenemos extraerque hace este nuevo código (método). Añada el método TestCheckForNegativeNumbers a la clase CalcTests.

[TestMethod] public void TestCheckForNegativeNumbers(){

Console.Out.WriteLine("TestSubtract called");Calculator testCalc = new Calculator();

try{

testCalc.CheckForNegativeNumbers(0, 0);}

catch (NegativeParameterException){

Assert.Fail("Zeros are not negative numbers");}

try{

testCalc.CheckForNegativeNumbers(1, 1);}catch (NegativeParameterException){

Assert.Fail("1's are not negative numbers");}

try{

testCalc.CheckForNegativeNumbers(int.MaxValue, int.MaxValue);

}catch (NegativeParameterException){

Assert.Fail("Max Vals are not negative numbers");}

try{

testCalc.CheckForNegativeNumbers(-1, -1);Assert.Fail("-1's are negative numbers");


try{

testCalc.CheckForNegativeNumbers(int.MinValue, int.MinValue);Assert.Fail("Min Vals are negative numbers");


}

2. Añada el esqueleto del método a la clase Calculator.

public void CheckForNegativeNumbers (int a, int b){ }

3. Compila y corra las pruebas. Como se espera no pasa a prueba CheckForNegativeNumbers, por lo quedebemos escribir el siguiente código.

public void CheckForNegativeNumbers (int a, int b)

7




{if (a < 0 || b < 0 ){


}}

4. Recompila y corra las pruebas otra vez, ahora las pruebas son exitosas. Remplace el código duplicado de losmétodos Add y Subtract, de esta manera:


int result;

if (a < 0 || b < 0 ){


}...

}

A esto:


int result;

CheckForNegativeNumbers (a, b);...

}

5. Después que ha reemplazado el código con CheckForNegative, compila y corra las pruebas de nuevo para

asegurar que no hemos roto la funcionalidad ensayada en los métodos Add y Subtract.

EJERCICIO 8:

1. Todo está listo para conectar el método Subtract a la interface de usuario. Asegúrese que el proyecto regrese ala interface gráfica, cambiando la llamada del método Application.Run con una nueva instancia del formulario. Elnombre de los botones de radio a añadir son AddRButton y SubtractRButton.

Figura 2. Interface de usuario – añada botón de radio.

2. Cambie el código del botón Equals para el evento click.

private void EqualsButton_Click(object sender, System.EventArgs e){

try{

Calculator calc = new Calculator();if (AddRButton.Checked){

Result.Text = (calc.Add((int)NumberA.Value, (int)NumberB.Value).ToString());}else

{Result.Text = (calc.Subtract((int)NumberB.Value, (int)NumberA.Value).ToString());

}}

8




catch (ResultOutOfRangeException){

Result.Text = "Out of Range";}catch (NegativeParameterException){

Result.Text = "Negatives not allowed";}

}

3. Compila y corra la aplicación. Debe ser capaz de sumar y restar números enteros positivos. No olvide demodificar las propiedades del proyecto a “Windows Application”. Además, de modificar el método main.

static void Main(){

Application.EnableVisualStyles();Application.SetCompatibleTextRenderingDefault(false);Application.Run(new Form1());

}

Note que el valor mínimo de los controles de NumericUpDown es cero, no se puede ingresar un númeronegativo. Si quiere probar con negativos, necesita cambiar la propiedad Minimum de los controles.

EJERCICIO 9: EXTRAER LA FUNCIONALIDAD FUERA DE LA CAPA DE INTERFACE

1. Comienza descomponiendo la decisión de que ejecutar. Crea un método la clase Calculator para ejecutar másde un tipo de cálculo, como: la suma o resta. Para esto crea un tipo enumerado, pero primero escribe la pruebadel nuevo método.

[TestMethod] public void TestCalculate(){

Assert.AreEqual(2,testCalc.Calculate(1, CalcOperation.eAdd, 1),"Adding 1 to 1 failed");Assert.AreEqual(0,testCalc.Calculate(1, CalcOperation.eSubtract, 1),"Subtracting 1 from 1 failed");

}

2. Otra vez esto no compila. Para corregirlo cree el tipo enumerado en el fichero de la clase Calculator, pero fuerade la clase.

public enum CalcOperation{

eAdd = 0,eSubtract = 1,

}

Añada el método Calculate a la clase Calculator.

public int Calculate(int a, CalcOperation op, int b){

return 0;}

3. Compila y corra las pruebas. Falla en la sentencia de Assert.AreEqual.

4. Modifica el método Calculate.

public int Calculate(int a, CalcOperation op, int b){

int nResult = 0;if (CalcOperation.eAdd == op){

nResult = Add(a, b);}else if (CalcOperation.eSubtract == op){

nResult = Subtract(b, a);}return nResult;

}

9




5. Compila y corra las pruebas. Ahora pasa. Modificamos el método EqualsButton_Click del formulario.


try{

Calculator calc = new Calculator();CalcOperation op = new CalcOperation();

if (AddRButton.Checked){

op = CalcOperation.Add;}else{

op = CalcOperation.Subtract;}Result.Text = calc.Calculate((int)NumberA.Value, op, (int)NumberB.Value).ToString();




}

6. Añada los handlers de los botones de radio. Para eso define un campo en la clase Form.

private CalcOperation op = CalcOperation.eAdd;

Añada nuevos métodos para los handlers de los botones de radio cuando se haga click.

private void AddRButton_CheckedChanged(object sender, System.EventArgs e){

if (AddRButton.Checked){

op = CalcOperation.eAdd;

}}

private void SubtractRButton_CheckedChanged(object sender, System.EventArgs e){

if (SubtractRButton.Checked){

op = CalcOperation.eSubtract;}

}


try{

Calculator calc = new Calculator();Result.Text = calc.Calculate((int)NumberA.Value, op, (int)NumberB.Value).ToString();




}

CONTENDIDO FINAL CALCTEST.CS

Se ha añadido el campo testCal de tipo Calculator; los métodos: Initialize y Cleanup(). Luego se optimizado el código.

using System;using Microsoft.VisualStudio.TestTools.UnitTesting;

10




using MiniCalc;

namespace CalcTest{

[TestClass] public class CalcTest{

Calculator testCalc;

[TestInitialize] public void Initialize(){

testCalc = new Calculator();}

[TestCleanup] public void Cleanup(){

testCalc = null;}

[TestMethod] public void TestAdd()

{Console.Out.WriteLine("TestAddition called");

//test for case of zeros'Assert.AreEqual(0, testCalc.Add(0, 0), "Adding 0 to 0 should produce 0");//test that param ordering isn't importantAssert.AreEqual(1, testCalc.Add(1, 0), "Adding 1 to 0 should produce 1");Assert.AreEqual(1, testCalc.Add(0, 1), "Adding 0 to 1 should produce 1");//test for non zero caseAssert.AreEqual(3, testCalc.Add(1, 2), "Adding 1 to 2 should produce 3");int nResult;

try{

nResult = testCalc.Add(int.MaxValue, int.MaxValue);Assert.Fail("Should throw a ResultOutofRangeException");

}catch (ResultOutOfRangeException){}testCalc = null;

}


Console.Out.WriteLine("TestAddNegatives called");

int nResult;

try{

nResult = testCalc.Add(-1, 0);Assert.Fail("Should throw a NegativeParameterException");}catch (NegativeParameterException){ }

try{

nResult = testCalc.Add(0, -1);Assert.Fail("Should throw a NegativeParameterException");


try{

nResult = testCalc.Add(int.MinValue, int.MinValue);Assert.Fail("Should throw a NegativeParameterException");


11




testCalc = null;}

[TestMethod] public void TestSubtract(){

Console.Out.WriteLine("TestSubtract called");

int nResult;

Assert.AreEqual(0, testCalc.Subtract(0, 0), "Subtracting 0 from 0 should produce 0");Assert.AreEqual(1, testCalc.Subtract(0, 1), "Subtracting 0 from 1 should produce 1");

try{

nResult = testCalc.Subtract(1, 0);Assert.Fail("Subtracting 1 from 0 should throw a ResultOutofRangeException");

}catch (ResultOutOfRangeException){ }

Assert.AreEqual(0, testCalc.Subtract(int.MaxValue, int.MaxValue), "Subtracting max value from max value should produce 0");

try{

nResult = testCalc.Subtract(-1, 0);Assert.Fail("Should throw a NegativeParameterException");


try{

nResult = testCalc.Subtract(0, -1);Assert.Fail("Should throw a NegativeParameterException");


try{nResult = testCalc.Subtract(int.MinValue, int.MinValue);Assert.Fail("Should throw a NegativeParameterException");


}

[TestMethod] public void TestCheckForNegativeNumbers(){

Console.Out.WriteLine("TestSubtract called");

try{


Assert.Fail("Zeros are not negative numbers");}

try{


Assert.Fail("1's are not negative numbers");}

try{

testCalc.CheckForNegativeNumbers(int.MaxValue, int.MaxValue);

}

12




catch (NegativeParameterException){

Assert.Fail("Max Vals are not negative numbers");}

try{

testCalc.CheckForNegativeNumbers(-1, -1);

Assert.Fail("-1's are negative numbers");}catch (NegativeParameterException){ }

try{

testCalc.CheckForNegativeNumbers(int.MinValue, int.MinValue);Assert.Fail("Min Vals are negative numbers");


}

[TestMethod]

public void TestCalculate(){

Console.Out.WriteLine("TestCalculate called");

Assert.AreEqual(2, testCalc.Calculate(1, CalcOperation.eAdd, 1), "Adding 1 to 1 failed");Assert.AreEqual(0, testCalc.Calculate(1, CalcOperation.eSubtract, 1), "Subtracting 1 from 1 failed");

}}

}

RESUMEN

En este conjunto de ejercicios se aplicó los principios de desarrollo de basado en pruebas. A continuación se resumelos pasos:

1. Decida que funcionalidad se va ha de implementar, podría ser también corregir un defecto (bug).

2. Escriba las pruebas del código.

3. Escriba el esqueleto del código que nos permita compilar.

4. Compila y corra las pruebas (debe fallar).

5. Complete el esqueleto de manera que pase las pruebas.

6. Compila y corra las pruebas. Si las pruebas fracasan, vuelva al paso 5.

7. Simplifique el código donde sea posible; esto puede involucrar los pasos del 1 al 6 de nuevo.

8. Esto a terminado. Tome un descanso y comience de nuevo.

Cada paso en el ciclo es un simple hacer y al final del ciclo se habrá añadido una unidad de la funcionalidad (oarreglado un defecto) que pasaron las pruebas. Puede programar otras unidades de la funcionalidad con más laconfianza.

CUESTIONARIO

1. Elabore un mapa mental del procedimiento utilizado para implementar el proyecto minicalc.

2. Realice un comentario sobre el procedimiento utilizado para implementar el proyecto minicalc.

13

Documents

Pruebas unitarias Minicalc