ConwayLife Sprint1

Introduction

Requirements

R1  Realizzare una versione in Java del gioco Life di Conway, come gioco zero-player. 
    Il gioco consiste nell’introdurre una Griglia di Celle il cui stato (cella ‘viva’ o cella ‘morta’) 
    evolve come stabilito dallle regole di ConwayLife

R2  L’utente umano deve poter:
     - specificare la configurazione iniziale della griglia del gioco	
     - vedere l’evoluzione del gioco in forma opportuna 
        (si veda Problema della vista del gioco )
     - fermare e far ripartire l’evoluzione del gioco
     - pulire (a gioco fermo) la configurazione della griglia del gioco

Requirement analysis

    Per Cell dopo aver parlato con il committente formalizzo il seguente modello: 

    public interface ICell {
	    void setStatus(boolean v); //primitiva: la cella e' un ente e puo avere la capacita di modificare il proprio stato interno in base a un valore booleano che puo essere true o false
	    boolean isAlive(); //primitiva: la cella puo' essere viva o morta
	    void switchCellState(); //non primitiva: se e' viva una cella puo' diventare morta e viceversa
    }

    Per Grid dopo aver parlato con il committente formalizzo il seguente modello:

    public interface IGrid {
	    public int getRowsNum(); //primitiva: l'entita griglia e' composta da tot righe
	    public int getColsNum(); //primitiva: l'entita griglia e' composta da tot colonne
	    public void setCellValue(int x, int y, boolean state); //non primitiva: la griglia e' composta da entita 'celle che hanno un proprio stato (vero o falso) che puo' essere modificato
	    public ICell getCell(int x, int y); //primitiva: la griglia e' composta da entita' celle
	    public boolean getCellValue(int x, int y); //non primitiva: la griglia e' composta da entita' celle che possono essere vive o false
	    public void reset(); //non primitiva: la griglia puo' essere riportata allo stato iniziale
    }

    Per Life dopo aver parlato con il committente formalizzo il seguente modello: 

    public interface LifeInterface {
        void nextGeneration(); //primitiva: Calcola l'evoluzione dello stato alla generazione successiva
        boolean isAlive(int row, int col); //non primitiva: Restituisce lo stato di una cella specifica
        void setCell(int row, int col, boolean alive); //non primitiva: Imposta lo stato di una cella
        ICell getCell(int x, int y); //non primitiva: Restituisce la Cella
        IGrid getGrid(); //primitiva: Restituisce la grid
        void resetGrids(); //non primitiva: Restituisce una rappresentazione grafica testuale della griglia
    }
 

Problem analysis

Test plans

Test plan per l'entita' Cell:

public class CellTest {
private ICell c;

	@Before
	public void setup() {
		System.out.println("ConwayLifeTest | setup");	
	    c = new Cell();
	}
	@After
	public void down() {
		System.out.println("ConwayLifeTest | down");
	}
	
	@Test
	public void testCellAlive() {
		System.out.println("ConwayLifeTest | doing alive");
		c.setStatus(true);
		boolean r = c.isAlive();
		assertTrue(r);
		
	}
	
	@Test
	public void testCellDead() {
		System.out.println("ConwayLifeTest | doing dead");
		c.setStatus(false);
		boolean r = c.isAlive();
		assertTrue( !r);
	}	
}

Test Plan per l'entita' Grid:

public class GridTest {
	private static final int nRows=5;
	private static final int nCols=5;
	
private Grid grid;

	@Before
	public void setup() {
		System.out.println("GridTest | setup");	
		grid= new Grid(nRows,nCols);
	}
	@After
	public void down() {
		System.out.println("GridTest | down");
	}
	
	@Test
	public void testDims() {
		System.out.println("testDims ---------------------" );
		int nr = grid.getRowsNum();
		int nc = grid.getColsNum();
		assertTrue( nr==nRows && nc==nCols );
	}
	@Test
	public void testCGridCellValue() {
		System.out.println("testCGridCellValue ---------------------" );
		grid.setCellValue(0,0,true);
		assertTrue(   grid.getCellValue(0,0) );
		assertFalse(  grid.getCellValue(0,1) );
	}
	@Test
	public void testGridRep() {
		System.out.println("testGridRep ---------------------" );
 		System.out.println(""+grid);
		assertTrue( grid.toString().startsWith(". . . . ."));
	}
	@Test
	public void testPrintGrid() {
		System.out.println("testPrintGrid ---------------------" );
		grid.setCellValue(0,0,true);
		grid.setCellValue(0,1,true);
		grid.setCellValue(0,2,true);
		grid.setCellValue(0,3,true);
		grid.setCellValue(0,4,true);
		//grid.printGrid();
	}

}

Test Plan per l'entita' Life:

public class LifeTest {
private LifeInterface lifeModel;

	@Before
	public void setup() {
		System.out.println("GridTest | setup");	
		lifeModel = new Life(5, 5);  // se puoi usare il costruttore
	}
	
	@After
	public void down() {
		System.out.println("GridTest | down");
	}
	
	@Test
	public void testSetCellAlive() {
	    
	    lifeModel.setCell(2, 3, true);

	    assertTrue(lifeModel.isAlive(2, 3));
	}
	
	@Test
	public void testSetCellDead() {

	    lifeModel.setCell(1, 1, false);

	    assertFalse(lifeModel.isAlive(1, 1));
	}
	
	@Test
	public void testLonelyCellDies() {

	    lifeModel.setCell(1, 1, true);

	    lifeModel.nextGeneration();

	    assertFalse(lifeModel.isAlive(1, 1));
	}
	
	@Test
	public void testBlockStillLife() {

		lifeModel.setCell(1,1,true);
		lifeModel.setCell(1,2,true);
		lifeModel.setCell(2,1,true);
		lifeModel.setCell(2,2,true);

		lifeModel.nextGeneration();

	    assertTrue(lifeModel.isAlive(1,1));
	    assertTrue(lifeModel.isAlive(1,2));
	    assertTrue(lifeModel.isAlive(2,1));
	    assertTrue(lifeModel.isAlive(2,2));
	}
	
	@Test
	public void testReset() {

		lifeModel.setCell(2,2,true);

		lifeModel.resetGrids();

	    assertFalse(lifeModel.isAlive(2,2));
	}
	
	@Test
	public void testGetGrid() {

	    Grid grid = lifeModel.getGrid();

	    assertNotNull(grid);
	}

}

Project

Testing

Deployment

Maintenance