[Task 9.1] 71104 Vs. TigerShark Pair Reloaded

[^TiGeRShArK^]

Allora..
dopo tutte 'ste incomprensioni finalmente abbiamo deciso di iniziare stasera..
e io spero anche di finire dato che nei prox giorni non posso...
a tra poco a tutti i nostri internet-ascoltatori!

[^TiGeRShArK^]

Allora..
dopo un'accesa discussione abbiamo deciso di seguire il suggerimento di fek e di fare estendere inizialmente alla calsse Chest il tipo Gem.
Questo ha alcune conseguenze...
a quanto abbiamo capito i test per la creazione dei Chest e per tutti i metodi in comune con la classe Gem sono già testati, quindi la prima parte del nostro task consiste in un semplice refactoring.
Invece per la seconda parte dovremo testare che la probabilità di estrazione dei Chest sia quella voluta....
Per questo direi che ci sono essenzialmente due test fondamentali:
1)Che i Chest vengano generati in media alla frequenza voluta
2)Che due Chest consecutivi non possano uscire (è corretta quest'assunzione???Joc, Vic, Fek????)

[71104]

secondo me si, il secondo punto è esatto.

[cionci]

Originariamente inviato da ^TiGeRShArK^

2)Che due Chest consecutivi non possano uscire (è corretta quest'assunzione???Joc, Vic, Fek????)

No, non devono uscire due chest dello stesso tipo consecutivi...guardate l'ltimo post di Jocchan nel thread delal storia 9...

[^TiGeRShArK^]

ecco il codice del primo test:

public void TestChestType()
    {
        assertTrue("EMERALD_CHEST is not correctly recognized as a Chest", GemType.EMERALD_CHEST.isChest());
        assertTrue("RUBY_CHEST is not correctly recognized as a Chest", GemType.RUBY_CHEST.isChest());
        assertTrue("SAPPHIRE_CHEST is not correctly recognized as a Chest", GemType.SAPPHIRE_CHEST.isChest());
        assertTrue("TOPAZ_CHEST is not correctly recognized as a Chest", GemType.TOPAZ_CHEST.isChest());
        assertTrue("DIAMOND_CHEST is not correctly recognized as a Chest", GemType.DIAMOND_CHEST.isChest());
        assertFalse("EMERALD is not correctly recognized as a Gem", GemType.EMERALD.isChest());
        assertFalse("RUBY is not correctly recognized as a Gem", GemType.RUBY.isChest());
        assertFalse("SAPPHIRE is not correctly recognized as a Gem", GemType.SAPPHIRE.isChest());
        assertFalse("TOPAZ is not correctly recognized as a Gem", GemType.TOPAZ.isChest());
        assertFalse("DIAMOND is not correctly recognized as a Gem", GemType.DIAMOND.isChest());
    }

[71104]

ok, ed ecco come è diventata la classe GemType:

public final class GemType
{
    public static final GemType EMERALD = new GemType("emerald", 40, false);
    public static final GemType RUBY = new GemType("ruby", 50, false);
    public static final GemType SAPPHIRE = new GemType("sapphire", 60, false);
    public static final GemType TOPAZ = new GemType("topaz", 80, false);
    public static final GemType DIAMOND = new GemType("diamond", 100, false);
    
    public static final GemType EMERALD_CHEST = new GemType("emerald", 40, true);
    public static final GemType RUBY_CHEST = new GemType("ruby", 50, true);
    public static final GemType SAPPHIRE_CHEST = new GemType("sapphire", 60, true);
    public static final GemType TOPAZ_CHEST = new GemType("topaz", 80, true);
    public static final GemType DIAMOND_CHEST = new GemType("diamond", 100, true);
    
    private final String name;
    private final int score;
    private final boolean isChest;
    
    
    GemType(String name, int score, boolean isChest)
    {
        this.name = name;
        this.score = score;
        this.isChest = isChest;
    }
    
    
    public String name()
    {
        return name;
    }
    
    
    public int score()
    {
        return score;
    }
    
    
    public boolean isChest()
    {
        return isChest;
    }
}

ora, spiegazione: siccome ci è stato richiesto di derivbare una classe Chest da Gem, io e TigerShark abbiamo deciso di implementare quel metodo per capire quand'è che il metodo statico Gem.create deve creare un oggetto Gem e quand'è che deve creare Chest, in base a cosa ritorna il metodo isChest dall'oggetto gemType passato come parametro a create.

ora ci sarebbe da testare se create in base a cosa viene ritornato da isChest capisce se creare un oggetto Gem o un oggetto Chest, e la cosa riesce un po' difficoltosa a causa del fatto che in Java che io sappia non è direttamente possibile ricavare RTTI sul tipo di un oggetto, quindi penso di aggiungere un metodo virtuale isChest anche in Gem e di sovrascriverlo in Chest; fek e vic, se pensate che non ne valga la pena fermateci e reverteremo.

intanto scrivo il test per questo metodo che TigerShark implementerà.

[71104]

prossimi test:

    public void testGemIsNotChest()
    {
        Gem gem = Gem.createForTesting();
        assertFalse(gem.isChest());
    }
    
    public void testChestIsChest()
    {
        Gem gem = Chest.createForTesting();
        assertTrue(gem.isChest());
    }

questi due test servono a testare che isChest funzioni correttamente e che sia un metodo virtuale.

[fek]

Originariamente inviato da 71104

ora, spiegazione: siccome ci è stato richiesto di derivbare una classe Chest da Gem, io e TigerShark abbiamo deciso di implementare quel metodo per capire quand'è che il metodo statico Gem.create deve creare un oggetto Gem e quand'è che deve creare Chest, in base a cosa ritorna il metodo isChest dall'oggetto gemType passato come parametro a create.

Ti spezzo un braccio se ci provi. (Adoro le minacce fisiche )

Evitare metodi tipo isChest(), getType(), etc etc, sono l'esatto motivo per il quale esistono praticamente meta' dei Design Pattern. Trovate sicuramente un modo alternativo (un factory method in GemType?).

[fek]

Originariamente inviato da 71104

prossimi test:

    public void testGemIsNotChest()
    {
        Gem gem = Gem.createForTesting();
        assertFalse(gem.isChest());
    }
    
    public void testChestIsChest()
    {
        Gem gem = Chest.createForTesting();
        assertTrue(gem.isChest());
    }

questi due test servono a testare che isChest funzioni correttamente e che sia un metodo virtuale.

REVEEEEEEEEEEEEEEEEEEEEERT!

[Bonfo]

Fek...ma tu quindi la Reflection la usi??

[^TiGeRShArK^]

è stata colpa mia ke avrei dovuto pensarci avendolo usato un paio di volte questo pattern....
ma stasera sono proprio fuso

[71104]

eh...? :|
non ho capito cos'è che non devo fare... O_o'
che tipo di metodi devo evitare?

mi sembrava una soluzione semplicissima quella che avevo inventato... o_O' e funzionava pure...

TigerShark dice di aver capito che dobbiamo cambiare e fare in modo che Gem e Chest derivino da una stessa classe di base, ma... non eri stato tu a imporci di derivare Chest da Gem??? :|

boh, a me sembrava che andasse tutto liscio... che dobbiamo fare di preciso?

[71104]

AAAAAAAAAAHHHHHHHHHHHHHHH FERMIHOCAPITOTUTTO!!!

[Ufo13]

Scusatemi... Dal momento in cui avete GemType.isChest() cosa ve ne fate della derivazione? Tenete la classe Gem ormai no?

[^TiGeRShArK^]

....mi sa ke io sono OUT.....
stasera nn capisco piu' niente e nei prox giorni sono a reggio....

ke si fa?

[71104]

TigerShark, ricominciamo daccapo, e stavolta andremo più veloci; allora, ho capito il democratico suggerimento di fek, dobbiamo cancellare isChest e mettere un public static Gem createByType, giusto?

scrivo il test...

[71104]

Originariamente inviato da Ufo13

Scusatemi... Dal momento in cui avete GemType.isChest() cosa ve ne fate della derivazione? Tenete la classe Gem ormai no?

no, serviva anche la derivazione, altrimenti era tutto più complesso, ma adesso cambiamo tutto.

[^TiGeRShArK^]

C'è un volontario x continuare con 71104 ke io nei prox giorni non ci sarò???

[Ufo13]

Io prima di sabato niente mi spiace

[71104]

le cose si complicano: a TigerShark è caduta nuovamente la linea e a me per continuare serve di sapere la sintassi di instanceof, che serve in Java per ricavare RTTI; lo devo usare per forza nei test se non devo fare metodi virtuali, altrimenti il metodo statico Gem.create rimarrà non testato...
siccome s'è fatto tardi è meglio continuare domani, faccio un commit per essere sicuri che la codebase non contenga quei metodi virtuali che avevamo iniziato a scrivere.