[CICLO 5 STORIA 2] Test Driven Development (Cover - TigerShark)

[^TiGeRShArK^]

Iniziamo questa sessione di TDD in pair programming.
Al solito NON COMMITTATE perchè lo stato del repository sarà precario dopo quello che faremo!

[cover]

Ok, proviamo ^^

Anche aggiungendo noi la gemma, ci serve comunque un test che ci dica quando ne è presente un'altra subito sotto la posizione corrente del diamante. Noi sappiamo che è presente perchè la aggiungiamo tramite insertGemAt, però quando la gemma scende deve poter controllare se il blocco successivo sia libero per poter scendere ancora. Quindi il primo test è di aggiungere due gemme e controllare che sotto la prima ci sia la seconda. Ecco il test (speriamo in bene ):

    public void testGemInNextRow()
    {
        grid.insertGem(4, 3, gem1);
        grid.insertGem(5, 3, gem2);
        assertTrue("another gem in next row,in same column", grid.thereIsGemBelow(gem1));
    }

[cionci]

Prima dovevo finire il 5.2.1

Ora lo committo...

[cionci]

Perchè i test nuovi o aggiunti non li mettete in it.diamonds.test.ignore ? Almeno la build machine non fa una build rossa...

Ancora un attimo epr il mio commit... Vi devo togliere il test che avete fatto...

[^TiGeRShArK^]

Perfetto.
il test fallisce correttamente
per farlo passare basta scrivere questo codice:

public boolean isGemBelow(Gem gem)
    {
        return true;
    }

ho preferito chiamare il test isGemBelow() al posto di thereIsGemBelow() e ho aggiornato conseguentemente la classe TestGrid.
Ma ora posso anche pingermi un pochino avanti e controllare effettivamente se ci sia o meno una gemma nella casella sottostante....
per questo:

public boolean isGemBelow(Gem gem)
    {
        Cell currentCell = findGemCell(gem);
        return isGemAt(currentCell.row() + 1, currentCell.column());
    }

bene Build verde.....
ovviamente questo codice ancora "puzza" un pò.... ma dato che fa passare i test fa il suo compito e per ora può andare

[fek]

Ragazzi, quando fate il commit di un test che fallisce, mettetelo in tests.ignore cosi' la build non si rompe.

Grazie

[^TiGeRShArK^]

si sistemato..
ho lasciato il test che passa in TestGrid ma ora ho creato TestGrid sotto ignore per poter lavorare tranquillamente là

[cionci]

NON FATE COMMITTTTTTTT !!!

[cionci]

Ora potete lavor4arci, attenzione che ho rimosso il vostro codice...

[cover]

Fek, mea culpa ^^

Ho modificato il test in questo modo:

    public void testGemInNextRow()
    {
        grid.insertGem(4, 3, gem1);
        assertFalse("Cell under current position is not empty", grid.isGemBelow(gem1));
        grid.insertGem(5, 3, gem2);
        assertTrue("Cell under current position is empty", grid.isGemBelow(gem1));
    }

Per avere una certezza in più del suo funzionamento (ovviamente ora passa perchè hai già fatto la modifica prima)

[^TiGeRShArK^]

si in effetti mi sono fatto prendere un pò la mano
però mi sentivo abbastanza sicuro da scrivere 2 righe di codice (letterlamente ) senza test.
Ora grazie a te abbiamo pure il test che ci assicura il corretto funzionamento del codice da me scritto

Torniamo a noi...
A questo punto direi di verificare che la gemma continui la sua caduta se la cella sottostante è libera:

public void testGemIsMovingWhenNextCellIsEmpty()
    {
        grid.insertGem(4, 3, gem1);
        grid.setGemUnderControl(gem1);
        grid.setGravity(1.0f);
        float oldPosY = gem1.getY();
        grid.update();
        assertEquals("Gem is not moving when cell under current position is empty", gem1.getY(), oldPosY + 1.0, 0.0000001);
    }

il test passa dopo aver aggiunto la precisione.... suppongo sia un errore di arrotondamento.....

a te

[fek]

Originariamente inviato da ^TiGeRShArK^

si in effetti mi sono fatto prendere un pò la mano
però mi sentivo abbastanza sicuro da scrivere 2 righe di codice (letterlamente ) senza test.

Riprovaci e ti sego entrambe le mani

Si scrive nuovo codice solo in presenza di un test che fallisce.

[^TiGeRShArK^]

Originariamente inviato da fek

Riprovaci e ti sego entrambe le mani

Si scrive nuovo codice solo in presenza di un test che fallisce.

mi è scappato kiedo venia!
cmq me ne sono reso conto subito e ho detto a cover d aggiungere il test corrispondente
(e ci aveva pensato pure lui contemporaneamente )

[cover]

Bene, ora direi di controllare che la gemma non effettui alcun movimento in caso di una gemma presente nella riga sotto.

Test:

    public void testGemIsStopWhenNextCellIsFull()
    {
        grid.insertGem(5, 2, gem1);
        grid.insertGem(6, 2, gem2);
        grid.setGemUnderControl(gem1);
        grid.setGravity(1.0f);
        grid.update();
        assertTrue("Gem has overlapped one already present", gem1.notMoved);
    }

Però sono indeciso per:

        assertTrue("Gem has overlapped one already present", gem1.notMoved);

si potrebbe anche fare:

        assertFalse("Gem has overlapped one already present", gem1.Moved);

Alla fine il concetto è uguale, però in questo caso qual'è meglio e più adatta?
Forse assertFalse, tu che dici ?

[^TiGeRShArK^]

personalmente preferirei l'assertFalse in combinazione con moved....
comunque ora scrivo il codice e vedo quale suona meglio per sicurezza

[cover]

Ricordati di scrivere il minimo ed indispensabile per compilare il programma, ed in seguito per far passare il test, nulla di più.
Sempre se tieni alle mani

[^TiGeRShArK^]

Allora...
piccolo refactoring:

public void testGemIsMovingWhenLowerCellIsEmpty()
    {
        grid.insertGem(4, 3, gem1);
        grid.setGemUnderControl(gem1);
        grid.setGravity(1.0f);
        float oldPosY = gem1.getY();
        grid.update();
        assertEquals("Gem is not moving when cell under current position is empty", gem1.getY(), oldPosY + 1.0, 0.0000001);
    }
    
    
    public void testGemIsStoppedWhenLowerCellIsFull()
    {
        grid.insertGem(5, 2, gem1);
        grid.insertGem(6, 2, gem2);
        grid.setGemUnderControl(gem1);
        grid.setGravity(1.0f);
        grid.update();
        assertFalse("Gem has overlapped one already present", gem1.moved());
    }

ho cambiato il nome dei test perchè credo che LowerCell renda meglio l'idea di NextCell e ho creato il codice minimo per farlo passare

public boolean moved()
    {
        return false;
    }

avanti così che mi inizia a piacere!

[cover]

Ma...ma...ma cosa vedo, che bello! Questo metodo non è male, ci serve anche per il test precedente, infatti possiamo usare direttamente .moved per controllare che effettivamente la gemma si sia mossa, senza utilizzare direttamente le coordinate nel test
Quindi cambierei il test precedente da:

public void testGemIsMovingWhenLowerCellIsEmpty()
    {
        grid.insertGem(4, 3, gem1);
        grid.setGemUnderControl(gem1);
        grid.setGravity(1.0f);
        float oldPosY = gem1.getY();
        grid.update();
        assertEquals("Gem is not moving when cell under current position is empty", gem1.getY(), oldPosY + 1.0, 0.0000001);
    }

A questa nuova versione:

    public void testGemIsMovingWhenLowerCellIsEmpty()
    {
        grid.insertGem(4, 3, gem1);
        grid.setGemUnderControl(gem1);
        grid.setGravity(1.0f);
        grid.update();
        assertTrue("Gem is not moving when cell under current position is empty", gem1.moved());
    }

[^TiGeRShArK^]

oh che bello!
il test appena modificato fallisce!
per farlo passare aggiungo:

    private boolean moved;

    public boolean moved()
    {
        return moved;
    }
    
    
    public void setMoved(boolean moved)
    {
        this.moved = moved;
    }

e ovviamente setto moved a true quando viene spostata la gemma ovvero:

private void applyGravity(Gem gem, Cell cell)
    {
        if(gemHasCollidedWithBottom(gem))
        {
            final float heightFromGround = bounds.bottom() - gem.getHeight()
                - gem.getY();

            gem.move(0, heightFromGround);
            if(!gem.wasDropped())
            {
                gem.drop();
            }
        }
        else
        {
            gem.move(0, actualGravity);
            gem.setMoved(true);
        }
    }

indovina un pò quale test fallisce ora?

[cover]

Per la serie: Notte Horror, questa sera presentiamo in prima visione: "Code Horror", un film tratto da una storia vera

Non mi è venuto in mente niente a parte questa modifica ( ) di applyGravity:

    private void applyGravity(Gem gem, Cell cell)
    {
        boolean isGemBelow = false;
        if(!gemHasCollidedWithBottom(gem))
        {
            try
            {
            isGemBelow = isGemBelow(gem);
            }
            catch(IllegalArgumentException e)
            {
            
            }          
        }
        if(gemHasCollidedWithBottom(gem) || isGemBelow)

Però i test passano tutti, il gioco funziona...anche se le gemme vengono disegnate in fondo le celle vengono occupate, da diamanti "fantasma"