[PAIR] Fran vs Anonimo - The Beginning

[fek]

Il task consiste nel restituire un oggetto NullAudio, che implementa l'interfaccia AudioInterface, e che fa nulla, quando la creazione di un oggetto Audio fallisce.

Questo e' il test che alla fine del task deve passare:

    public void testAudioCreationFailure()
    {
        AudioFactory audioFactory = new FailingAudioFactory();

        AudioInterface audio = environment.createAudio(audioFactory);
        assertTrue(audio.isNull());
    }

Il test e' nel repository commentato. Non puo' passare perche' mancano tante cose all'appello:

- il metodo isNull() in AudioInterface
- la classe audioFactory()
- una versione del metodo createAudio() di environment che accetti un oggetto AudioFactory

Manca inoltre una classe NullAudio.

Partiamo con il metodo isNull(), questo e' il test in TestAudio.java:

    public void setUp()
    {
        audio = MockAudio.create();
    }

    public void testIsNullNotTrueForMockAudio()
    {
        assertFalse(audio.isNull());
    }

[AnonimoVeneziano]

Eccomi.

Per permettere la compilazione del test è stato aggiunto un metodo all'interfaccia AudioInterface :

   boolean isNull();

Successivamente sono stati aggiunti i seguenti metodi in OpenALAudio :

    public boolean isNull()
    {
            return false;
    }

e in MockAudio :

    public boolean isNull() 
    {
        return true;
    }

A questo punto il test compilava, ma falliva.

Per farlo passare è stato cambiato in MockAudio in questo modo :

    public boolean isNull()
    {
            return false;
    }

Test passato e avanti il prossimo

[fek]

Il prossimo test richiede una classe NullAudio che sia nulla:

    public void testNullAudioIsNull()
    {
        audio = new NullAudio();
        assertTrue(audio.isNull());
    }

[AnonimoVeneziano]

Ok, creata una classe NullAudio che implementa AudioInterface.

Eclipse ha creato automaticamente questa classe :

package it.diamonds.engine.audio;

public class NullAudio implements AudioInterface
{

    public Sound createSound(String name)
    {
        // TODO Auto-generated method stub
        return null;
    }


    public boolean isCreated()
    {
        // TODO Auto-generated method stub
        return false;
    }


    public boolean isInitialised()
    {
        // TODO Auto-generated method stub
        return false;
    }


    public boolean isMusicPlaying()
    {
        // TODO Auto-generated method stub
        return false;
    }


    public boolean isNull()
    {
        // TODO Auto-generated method stub
        return false;
    }


    public void playMusic()
    {
        // TODO Auto-generated method stub

    }


    public void shutDown()
    {
        // TODO Auto-generated method stub

    }


    public void stopMusic()
    {
        // TODO Auto-generated method stub

    }

}

cambiando l'implementazione di "isNull()" in :

    public boolean isNull()
    {
        return true;
    }

Il test passa.

[fek]

Ora ci serve l'AudioFactory, questo e' il test:

package it.diamonds.tests.engine;


import junit.framework.TestCase;

public class TestAudioFactory extends TestCase
{
    public void testAudioFactoryCreate()
    {
        AudioFactory factory = new AudioFactory();
        assertNotNull(factory.create());
    }
}

[AnonimoVeneziano]

Ok

Creazione di una classe it.diamonds.engine.AudioFactory :

package it.diamonds.engine;

public class AudioFactory
{
    public Object create() 
    {
        return null;
    }
}

Il test fallisce.

Cambiando in :

    public Object create() 
    {
        return 0;
    }

Il test riesce

[fek]

C'e' un bug in NullAudio, faccio prima a metterti il test che a spiegartelo:

package it.diamonds.tests.engine.audio;

import it.diamonds.engine.audio.AudioInterface;
import it.diamonds.engine.audio.NullAudio;
import junit.framework.TestCase;

public class TestNullAudio extends TestCase
{

    public void testNullAudioIsCreated()
    {
        AudioInterface audio = new NullAudio();
        assertTrue(audio.isCreated());
    }
}

[AnonimoVeneziano]

Non avevo mai visto un bug così

Il bug è stato risolto cambiando in it.diamonds.engine.audio.NullAudio :

    public boolean isCreated()
    {
        return false;
    }

in:

    public boolean isCreated()
    {
        return true;
    }

[fek]

Prossimo test:

package it.diamonds.tests.engine;


import it.diamonds.engine.AudioFactory;
import junit.framework.TestCase;

public class TestAudioFactory extends TestCase
{
    public void testAudioFactoryCreate()
    {
        AudioFactory factory = new AudioFactory();
        assertNotNull(factory.create());
    }

    public void testAudioFactoryCreateMockAudio()
    {
        AudioFactory factory = new MockAudioFactory();
        assertNotNull((MockAudio) factory.create());
    }

}

[AnonimoVeneziano]

Creata la classe it.diamonds.tests.mocks.MockAudioFactory :

public class MockAudioFactory extends AudioFactory
{
}

Da un errore di compilazione perchè la AudioFactory.create() di fatto ritorna un Integer.

Aggiungendo un override della create nella classe :

    public AudioInterface create() 
    {
        return MockAudio.create();
    }

Il test riesce.

[fek]

Chiudiamo il conto con AudioFactory

package it.diamonds.tests.engine;


import it.diamonds.engine.AudioFactory;
import it.diamonds.engine.audio.AudioInterface;
import it.diamonds.tests.mocks.MockAudio;
import it.diamonds.tests.mocks.MockAudioFactory;
import junit.framework.TestCase;

public class TestAudioFactory extends TestCase
{
    public void testAudioFactoryCreate()
    {
        AudioFactory factory = new AudioFactory();
        assertNotNull(factory.create());
    }

    public void testAudioFactoryCreateMockAudio()
    {
        AudioFactory factory = new MockAudioFactory();
        assertNotNull((MockAudio) factory.create());
    }

    public void testAudioFactoryCreateAudioInterface()
    {
        AudioFactory factory = new AudioFactory();
        assertNotNull((AudioInterface) factory.create());
    }

}

[AnonimoVeneziano]

Cambiamo :

     public Object create()
     {
           return 0;
     }

in:

    public AudioInterface create() 
    {
        return new NullAudio();
    }

Test passato!

[fek]

In TestEnvironment.java, un test che chieda di passare un AudioFactory al metodo createAudio di Environment:

    public void testAudioCreationWithFactory()
    {
        AudioFactory audioFactory = new AudioFactory();
        assertNotNull((AudioInterface) environment.createAudio(audioFactory));
    }

[AnonimoVeneziano]

Aggiunto il metodo in it.diamonds.Envionment :

    public AudioInterface createAudio(AudioFactory factory)
    {
        return factory.create();
    }

[fek]

Ora creiamo una classe mock che ritorni un eccezione quando tenta di creare un Audio.
Questo e' il test:

    public void testFailingAudioFactoryMockException()
    {
        try
        {
            AudioFactory audioFactory = new FailingAudioFactoryMock();
            audioFactory.create();
            fail();
        }
        catch (RuntimeException e)
        {
        }
    }

[AnonimoVeneziano]

Creata la classe it.diamonds.tests.mocks.FailingAudioFactoryMock :

public class FailingAudioFactoryMock extends AudioFactory
{
    public AudioInterface create()
    {
        throw new RuntimeException();
    }
}

Il Deathmatch continua ....

[fek]

Proviamo a dare un colpo all'ultimo test, vediamo se si riesce a far passare con un paio di righe di codice:

   public void testAudioCreationFailure()
    {
        AudioFactory audioFactory = new FailingAudioFactoryMock();

        AudioInterface audio = environment.createAudio(audioFactory);
        assertTrue(audio.isNull());
    }

[AnonimoVeneziano]

In it.diamonds.Environment la funzione createAudio(AudioFactory) è stata cambiata così :

    public AudioInterface createAudio(AudioFactory factory)
    {
      return new NullAudio();
    }

Adesso il test passa.

[fek]

Questo vuol dire che il primo test di verifica che ho scritto non dava abbastanza informazioni, ci serve un altro test:

    public void testAudioNotNullCreationWithFactory()
    {
        AudioFactory audioFactory = new MockAudioFactory();
        AudioInterface audio = environment.createAudio(audioFactory);
        assertFalse(audio.isNull());
    }

[AnonimoVeneziano]

Dopo grandi ed epiche lotte intestine tra Eclipse e il repository SVN ecco le modifiche al codice

Metodo Environment.createAudio(AudioFactory)

    public AudioInterface createAudio(AudioFactory factory)
    {
        try
        {
            audio = factory.create();
        } catch (RuntimeException e)
        {
            audio = new NullAudio();
        }
        
        return audio;
    }

Uomo 1 Macchina 0