Tema 3. Test Driven Development

Tema 3. Test Driven Development Ejercicios Resueltos Ejercicio 01. Desarrolle mediante TDD una implementación del algoritmo de la Criba de Eratóstenes para calcular la lista de los números primos desde 2 hasta un número n indicado. Si no existiera ningún primo, el algoritmo devolverá una lista vacía. El algoritmo de la criba de Eratóstenes se muestra a continuación. 1. Se crea una lista con los números desde 2 hasta n. 2. Se elige el siguiente número x no marcado (inicialmente el 2). 3. Se marcan todos los múltiplos de dicho número (x*2, x*3, etc.). 4. Se repite desde el paso 2. Cuando se ha terminado con todos los números aquellos que queden sin marcar son primos. Más información sobre la criba de Eratóstenes en la Wikipedia: http://en.wikipedia.org/wiki/sieve_of_eratosthenes Solución Antes de comenzar con la implementación es interesante pararse un momento a estudiar los posibles casos de prueba de este algoritmo. El único valor de entrada de las pruebas es el número n límite para calcular los números primos. Los casos de prueba se pueden dividir en varias particiones equivalentes en función de dicho n. Vamos a describir estas particiones a continuación. La primera partición engloba a todos los números menores de 2. Para cualquier valor de dicha partición el resultado de esta implementación será siempre el mismo: una lista vacía de números. Después, podemos definir tantas particiones como valores son necesarios para incluir a un nuevo número primo. También podemos jugar con particiones que terminan justo en un valor primo o justo después (por ejemplo, calcular todos los primos hasta 11 o hasta 12). Todos son equivalentes a la hora de generar ya que el proceso para calcularlo son los mismos, pero alguna prueba adicional puede ayudarnos a detectar errores ocultos. Veamos las primeras evoluciones aplicando TDD. public void testcalculaconvalorinicialuno() { List<Integer> l = CrivaDeEratosthenes.Calcula(1); asserttrue(l.isempty()); static class CrivaDeEratosthenes { 1

public static List<Integer> Calcula(int i) { return new ArrayList<Integer>(); //----------------------------------- public void testcalculaconvalorinicialdos() { List<Integer> l = CrivaDeEratosthenes.Calcula(2); // (*) assertequals(1, l.size()); assertequals(new Integer(2), l.get(0)); public static List<Integer> Calcula(int i) { List<Integer> l = new ArrayList<Integer>(); if (i >= 2) l.add(2); return l; (*) Aunque los dos asserts verifican lo mismo, con el primer assert evitamos que la prueba falle por una excepción si no hay ningún elemento en la lista. Hacer este cambio hace más legible la traza de la prueba cuando no hay ningún elemento en la lista. Al final de la traza veremos una manera más cómoda de escribir este tipo de asserts utilizando la librería de Java. Continuamos aplicando TDD. public void testcalculaconvalorinicialuno() { List<Integer> l = CrivaDeEratosthenes.Calcula(1); asserttrue(l.isempty()); public void testcalculaconvalorinicialdos() { List<Integer> l = CrivaDeEratosthenes.Calcula(2); assertequals(new Integer(2), l.get(0)); public void testcalculaconvalorinicialtres() { List<Integer> l = CrivaDeEratosthenes.Calcula(3); assertequals(2, l.size()); assertequals(new Integer(2), l.get(0)); assertequals(new Integer(3), l.get(1)); public static List<Integer> Calcula(int i) { List<Integer> l = new ArrayList<Integer>(); if (i >= 2) { l.add(2); l.add(3); return l; 2

En este nuevo paso vemos dos detalles interesantes. La primera es que ha sido necesario quitar el assert que pusimos para evitar un error por excepción. La segunda es que introducir una nueva prueba no ha hecho avanzar. Es necesario cambiar de enfoque. Llegados a este punto ya nos damos cuenta de que los casos de prueba no ayudan a evolucionar el código. Tendríamos que dar un paso muy grande con muchos cambios que pueden salir mal para implementar el código del algoritmo. Este es el momento de buscar alternativas para hacer pruebas más pequeñas y avanzar pasos más diminutos. Para ello cada paso del algoritmo será un método y cada uno de los métodos irá creciendo guiado por pruebas. Aunque dichos métodos deberían ser privados, los pondremos con el ámbito de visibilidad necesario para poder probarlos. En el próximo módulo veremos las técnicas y herramientas para poder probar métodos privados. Empezamos con una primera prueba que nos haga avanzar en este paso. El primer paso que vamos a abordar es crear una matriz de booleanos para indicar qué números están marcados y cuáles no. public void testcrealistadenumerossinmarcar() { int tope = 4; List<Boolean> l = CrivaDeEratosthenes.CreaListaDeNumerosSinMarcar(tope); assertequals((tope+1), l.size()); for (Boolean b:l) { assertfalse(b); public static List<Boolean> CreaListaDeNumerosSinMarcar(int i) { List<Boolean> lb = new ArrayList<Boolean>(); for (int c=0; c<=i; c++) lb.add(false); return lb; Necesitamos incrementar el tope en 1 ya que para que el número 4 aparezca en la lista de marcados, es necesario que la lista tenga 5 elementos (del 0 al 5). Como trabajamos con listas, ignoraremos las posiciones 0 y 1 que siempre serán false ya que no intervienen. Continuamos. public void testmarcarmultiplos() { int tope = 2; List<Boolean> l = CrivaDeEratosthenes.CreaListaDeNumerosSinMarcar(2); CrivaDeEratosthenes.MarcarMultiplos(l); assertfalse(l.get(2)); public static void MarcarMultiplos(List<Boolean> l) { Cuidado! Hemos descubierto un mal caso de prueba, el nombre es poco descriptivo y no le estamos pidiendo a nuestro sistema que haga nada por eso un método vacío lo pasa. Vamos a cambiar este caso de prueba. Vamos a utilizar como valor de prueba 4 porque es el primer valor que introduce un cambio. Continuamos. 3

public void testmarcarmultiploshasta4() { List<Boolean> l = CrivaDeEratosthenes.CreaListaDeNumerosSinMarcar(4); CrivaDeEratosthenes.MarcarMultiplos(l); assertfalse(l.get(2)); assertfalse(l.get(3)); asserttrue(l.get(4)); public static void MarcarMultiplos(List<Boolean> l) { for (int num = 2; num < l.size(); num++) { for (int mul = (num*2); mul < l.size(); mul += num) { l.set(mul, true); //----------------------------------- public void testcrearlistadeprimoshasta4() { List<Boolean> l = CrivaDeEratosthenes.CreaListaDeNumerosSinMarcar(4); CrivaDeEratosthenes.MarcarMultiplos(l); List<Integer> primos = CrivaDeEratosthenes.CreaListaDePrimos(l); assertequals(2, primos.size()); assertequals(new Integer(2), primos.get(0)); assertequals(new Integer(3), primos.get(1)); public static List<Integer> CreaListaDePrimos(List<Boolean> l) { List<Integer> lb = new ArrayList<Integer>(); for (int c = 2; c < l.size();c++) { if (!l.get(c)) { lb.add(c); return lb; Ya tenemos implementados y probados todos los pasos. Ahora es el momento de refactorizar el método que calcula la criba de Eratóstenes y comprobar que las primeras pruebas que escribimos siguen funcionando. Veamos la refactorización. public static List<Integer> Calcula(int i) { List<Boolean> lb = CreaListaDeNumerosSinMarcar(i); MarcarMultiplos(lb); return CreaListaDePrimos(lb); Las pruebas siguen funcionando por lo que ya podemos dar por terminada la implementación. Si embargo podemos añadir algunas pruebas más jugando con las particiones que comentamos al principio. Por ejemplo: 4

public void testgeneraprimoshastadoce() { List<Integer> l = CrivaDeEratosthenes.Calcula(12); Assert.assertEquals(l, Arrays.asList(2, 3, 5, 7, 11)); Consideraciones finales Este desarrollo ha tenido una carencia. No se ha podido hacer TDD para definir que el método principal llame a los demás métodos ni verifica si el orden en que los llama es el correcto, con lo que hemos diseñado esa parte sin el soporte de pruebas. Este tipo de TDD lo realizaremos mediante mocks los cuáles estudiaremos en el siguiente módulo. Ejercicio 02. Se desea crear una clase que funcione como un contador. Se cuenta con los siguientes requisitos. Al crear el contador indicamos el valor inicial del mismo, el incremento y el valor límite. El valor inicial y el incremento tomarán un valor de 0 y 1 respectivamente si no se indica nada. El límite es necesario indicarlo siempre. Ninguno de los tres valores (valor inicial, incremento y límite) pueden cambiarse una vez creado el contador Al incrementar el contador se suma al valor actual el incremento y nos indican si se superó el límite. Cuando se supere el límite, el valor actual del contador vuelve a ser el valor inicial. En cualquier momento se puede conocer el valor actual del contador y E cualquier momento se puede establecer el contador a su valor inicial. Implemente los requisitos anteriores utilizando TDD. Solución Esta solución muestra la línea temporal del trabajo hecho. Cada boque de código (entre dos comentarios con guiones) es la implementación de una característica en el código. Primero se muestra el código de prueba y, después, la implementación. También se indican las refactorizaciones realizadas. 5

Esta misma traza y el código Java obtenido pueden descargarse en la sección de materiales del curso. En el boletín de ejercicios de este tema se plantean cuestiones adicionales a partir de esta solución. public void testvervalordelcontadorpordefecto() { ContadorCircular cc = new ContadorCircular(); assertequals(0, cc.getvalor()); public class ContadorCircular { public int getvalor() { return 0; //----------------------------------------- public void testvervalordelcontadorconvalorinicial5() { ContadorCircular cc = new ContadorCircular(5); assertequals(5, cc.getvalor()); public class ContadorCircular { int valor; public ContadorCircular(int i) { this.valor = i; public ContadorCircular() { this(0); public int getvalor() { return this.valor; //----------------------------------------------- public void testincrementarcontadorpordefecto() { ContadorCircular cc = new ContadorCircular(); cc.incrementa(); assertequals(1, cc.getvalor()); public void incrementa() { this.valor++; //------------------------------------------------- 6

public void testincrementarcontadorde5a10() { ContadorCircular cc = new ContadorCircular(5, 5); cc.incrementa(); assertequals(10, cc.getvalor()); public class ContadorCircular { int valor; int incremento; public ContadorCircular(int i) { this.valor = i; this.incremento = 1; public ContadorCircular() { this(0); public ContadorCircular(int i, int j) { this(i); this.incremento = j; public int getvalor() { return this.valor; public void incrementa() { //------------------------------------------------- /* Refactorizamos - Nombres de parámetros de constructores más descriptivos - Quitamos un constructor. - Creamos los contadores en el setup - nombres más descriptivos para los contadores de pruebas */ public class TestContadorCircular { ContadorCircular ccpordefecto; ContadorCircular cccincoencinco; @Before public void setup() throws Exception { ccpordefecto = new ContadorCircular(); cccincoencinco = new ContadorCircular(5, 5); public void testvervalordelcontadorpordefecto() { assertequals(0, ccpordefecto.getvalor()); public void testvervalordelcontadorconvalorinicial5() { assertequals(5, cccincoencinco.getvalor()); 7

public void testincrementarcontadorpordefecto() { ccpordefecto.incrementa(); assertequals(1, ccpordefecto.getvalor()); public void testincrementarcontadorde5a10() { cccincoencinco.incrementa(); assertequals(10, cccincoencinco.getvalor()); public class ContadorCircular { int valor; int incremento; public ContadorCircular(int valor, int incremento) { this.valor =valor; this.incremento = incremento; public ContadorCircular() { this(0, 1); public int getvalor() { return this.valor; public void incrementa() { @Before public void setup() throws Exception { ccpordefecto = new ContadorCircular(1); cccincoencinco = new ContadorCircular(5, 5); public void testlimitenosuperadocontadorpordefecto() { boolean b = this.ccpordefecto.incrementa(); assertfalse(b); int limite; public ContadorCircular(int limite) { this(0, 1); this.limite = limite; public boolean incrementa() { return false; 8

public void testlimitesuperadocontadorpordefecto() { this.ccpordefecto.incrementa(); boolean b = this.ccpordefecto.incrementa(); asserttrue(b); public boolean incrementa() { return this.valor > this.limite; public void testlimitesuperadocontadorde5en5() { this.cccincoencinco.incrementa(); boolean b = this.cccincoencinco.incrementa(); asserttrue(b); public ContadorCircular(int valor, int incremento, int limite) { this.valor =valor; this.incremento = incremento; this.limite = limite; public ContadorCircular(int limite) { this(0, 1, limite); { public void testcontadorpordefectovuelvealvalorinicialasuperarellimite() this.ccpordefecto.incrementa(); this.ccpordefecto.incrementa(); assertequals(0, this.ccpordefecto.getvalor()); int inicial; public ContadorCircular(int valor, int incremento, int limite) { this.inicial = valor; this.valor =valor; this.incremento = incremento; this.limite = limite; public boolean incrementa() { boolean b = this.valor > this.limite; if (b) { this.valor = this.inicial; return b; public void testresetearcontadorpordefecto() { 9

this.ccpordefecto.incrementa(); this.ccpordefecto.resetea(); assertequals(0, this.ccpordefecto.getvalor()); public void resetea() { this.valor = this.inicial; /* Refactorizamos - Evitamos código repetido */ public boolean incrementa() { boolean b = this.valor > this.limite; if (b) { this.resetea(); return b; 10