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

	
	Viene formalizzato il seguente modello a partire dai requisiti:
	
-	L'entità Cella rappresenta l'elemento più semplice del sistema; è un entità atomica,
	il suo comportamento prevede due stati: viva o morta.
	
	
		public interface ICell {
			/* La cella ha la capacità di modificare il proprio stato, rappresentato da un booleano */
			void setStatus(boolean v);
			
			/* La cella ha la capacità di restituire il proprio stato */
			boolean isAlive();
			
			/* La cella ha la capacità di permutare il proprio stato, da viva a morta e viceversa */
			void switchCellState();
		}
	
	
-	L'entità Griglia è un aggregato di Celle. Il suo comportamento mira
	a gestire l'insieme di celle che rappresenta.
	
	Esempio domande al committente:
	/STRUTTURA/
	*Da cosa è composta? Celle*
	*In quante dimensioni? Bidimensionale*
	*Quali sono le dimensioni? Altezza, lungezza / colonne, righe*
	/COMPORTAMENTO/
	*Deve restituire una sua cell? Si*
	
	
	public interface IGrid {
		  /* La griglia ha la capacità di restituire il numero di righe della griglia stessa */
		  public int getRowsNum();
		  
		  /* La griglia ha la capacità di restituire il numero di colonne della griglia stessa */
		  public int getColsNum();
		  
		  /* La griglia ha la capacità di modificare lo stato di una cella tramite le sue coordinate sulla griglia stessa */
		  public void setCellValue(int x, int y, boolean state);
		  
		  /* La griglia ha la capacità di restituire l'entità cella tramite le sue coordinate */
		  public ICell getCell(int x, int y);
		  
		  /* La griglia ha la capacità di restituire lo stato di una cella tramite le sue coordinate*/
		  public boolean getCellValue(int x, int y);
		  
		  /* La griglia è capace di cambiare lo stato di tutte le celle (a morte)*/
		  public void reset();
	}
    
	
-	L'entità Life rappresenterà le regole di gioco. Life ha una relazione di 
	molteplicità con la Griglia tale da gestirne una alla volta.
	
	
	public interface LifeInterface {
		/* Life calcola l'evoluzione dello stato della griglia alla generazione successiva */
	    void nextGeneration();

	    /* Life restituisce lo stato di una cella tramite le sue coordinate */
	    boolean isAlive(int row, int col);

	    /* Life imposta lo stato di una cella tramite le sue coordinate*/
	    void setCell(int row, int col, boolean alive);
	    
	    /* Life ha la capacità di restituire una cella */
	    ICell getCell(int x, int y);
	    
	    /* Life ha la capacità di restituire la griglia */
	    IGrid getGrid();
	    
	    /* Life ha la capacità di resettare la griglia */
	    void resetGrids();
		
		/* Ulteriori funzioni non primitive: */
			   
		/* Restituisce il numero di righe e colonne */
		//    int getRows();
		//    int getCols();
	    
	    /* Restituisce una rappresentazione grafica testuale della grglia */
	    //public String gridRep( );
	}
	
	
	Le interazioni verrano mediate tramite interfacce.

Problem analysis

Test plans

	
-	CellTest: Test sul comportamento della cella


	public class CellTest {
		private ICell c;

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


	
-	GridTest: Test sul comportamento della griglia.


	public class GridTest {
		
	private Grid grid;

		@Before
		public void setup() {
			System.out.println("GridTest | setup");	
			grid= null;
		}
		@After
		public void down() {
			System.out.println("GridTest | down");
		}
		
		@Test
		public void testDims() {
			System.out.println("GridTest | dims" );
			int nr = grid.getRowsNum();
			int nc = grid.getColsNum();
			assertTrue( nr==nRows && nc==nCols );
		}
		@Test
		public void testCGridCellValue() {
			System.out.println("GridTest | cell value");
			grid.setCellValue(0,0,true);
			assertTrue(   grid.getCellValue(0,0) );
			assertFalse(  grid.getCellValue(0,1) );
		}
		@Test
		public void testGridRep() {
			System.out.println("GridTest | grid rep" );
	 		System.out.println(""+grid);
			assertTrue( grid.toString().startsWith(". . . . ."));
		}
		@Test
		public void testPrintGrid() {
			System.out.println("GridTest | print grid" );
			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();
		}

	}
	

	
-	LifeTest: Test su Life
	

	public class LifeTest {
	private LifeInterface lifeModel;

		@Before
		public void setup() {
			System.out.println("LifeTest | setup");	
			lifeModel = null;
		}
		@After
		public void down() {
			System.out.println("LifeTest | down");
		}
		
		@Test
	    void testIsAliveAfterSet() {
			System.out.println("LifeTest | cell is alive");
	        lifeModel.setCell(3, 3, true);
	        boolean state = lifeModel.isAlive(3, 3);

	        assertTrue(state);
	    }
		
		@Test
	    void testSetCellDead() {
			System.out.println("LifeTest | cell is dead");
	        lifeModel.setCell(2, 2, false);
	        assertFalse(lifeModel.isAlive(2, 2));
	    }
		
		@Test
	    void testGetCell() {
			System.out.println("LifeTest | get cell");
	        ICell cell = lifeModel.getCell(0, 0);

	        assertNotNull(cell);
	    }
		
		 @Test
		    void testGetGrid() {
				System.out.println("LifeTest | get grid");
		        IGrid grid = lifeModel.getGrid();

		        assertNotNull(grid);
		    }

	}

Project

	
 	main.java.conway.domain
	Vengono implementate le interfacce sopra descritte nella seguente maniera:
	
-	Codice Cell
	Lo stato della cella (viva o morta) è rappresentata da un intero.

- 	Codice Griglia
	Una matrice di celle.

- 	Codice Life
	Usa due griglie per calcolare la generazione successiva.
	Implementa le regole del gioco.

	Viene implementato un controller che fungerà da regista del gioco:
	
-	Interfaccia Controller
	Codice LifeController

	A partire da ICell, IGrid e LifeInterface è possibile definire un contratto di output:

-	Interfaccia IOutDev

	main.java.conway.devices
	Mock per test GUI SPRINT1.

Testing

-	Oltre ai test pensati nel Test Plans, viene aggiungo un test 
	sul corretto funzionamento delle regole basato su comportamenti noti:
	Test
	

Deployment

	
	conway26Java-1.0.jar
	

Maintenance