/*******************************************************************************
 * Testovací třída Strom_6aTest.
 * Upravuje dědictví od třídy Strom_5Test tak, aby chodilo v novém prostředí.
 * Musí rozchodit testy:
 *  - že se stromy umějí nakreslit a smazat 
 *  - základní bezparametrické posuny 
 *  - test posunů po změně kroku
 *  - test metody instance zarámuj()  
 *  - test PočítáníInstancí
 *  - test statické metody obrázek() 
 *    testuje metodu využívající konstruktor pracující s přepravkou Pozice  
 *  - test statické metody Alej
 *  - test statické metody zarámuj(int,int))  
 *
 * @author     Rudolf Pecinovský
 * @version    2.01, duben 2004
 */
public class Strom_6aTest extends junit.framework.TestCase
{
    private Strom_6a strom1;
    private Strom_6a strom2;
    private Strom_6a strom3;
    private Strom_6a strom4;


//##############################################################################
//== KONSTRUKTORY A TOVÁRNÍ METODY =============================================

    /***************************************************************************
     * Vytvoří test se zadaným názvem.
     *
     * @param název  Název konstruovaného testu
     */
    public Strom_6aTest(String název)
    {
        super( název );
    }



//== PŘÍPRAVA A ÚKLID PŘÍPRAVKU ================================================

    /***************************************************************************
     * Vytvoření přípravku (fixture), tj. sady objektů, s nimiž budou všechny
     * testy pracovat a která se proto vytvoří před spuštěním každého testu.         
     */
    protected void setUp()
    {
        AktivníPlátno plátno = AktivníPlátno.getPlátno();
        plátno.setKrokRozměr( 50, 6, 6 );
        plátno.setMřížka( true );
        plátno.odstraňVše();
        strom1 = new Strom_6a();                        
        strom2 = new Strom_6a( 25, 150);                
        strom3 = new Strom_6a(100, 100, 100,  90);      
        strom4 = new Strom_6a(200,   0, 100, 300, 3, 5);
        strom1.nakresli();
        strom2.nakresli();
        strom3.nakresli();
        strom4.nakresli();
    }


    /***************************************************************************
     * Úklid po testu - tato metoda se spustí po vykonání každého testu.
     * Bezparametrický konstruktor pro testovací třídu StromTest
     */
    protected void tearDown()
    {
    }


//== VLASTNÍ TESTY =============================================================

    public void testNakresliSmaž()
    {
        strom1.smaž();
        strom2.smaž();
        strom3.smaž();
        strom4.smaž();
        assertEquals(true, P.souhlas("Stromy smazány?"));
        strom1.nakresli();
        strom2.nakresli();
        strom3.nakresli();
        strom4.nakresli();
        assertEquals(true, P.souhlas(
            "Strom 1: x=0,   y=  0, š=100, v=150, šSt/šKm=10, vSt/vKo=3\n" +
            "Strom 2: x= 25, y=150, š=100, v=150, šSt/šKm=10, vSt/vKo=3\n" +
            "Strom 3: x=100, y=100, š=100, v= 90, šSt/šKm=10, vSt/vKo=3\n" +
            "Strom 4: x=200, y=100, š=100, v=300, šSt/šKm= 3, vSt/vKo=5\n" +
            "\nPozice, rozměry a poměry kmen a korun souhlasí?"));
    }

    public void testPosuny()
    {
        P.zpráva("Následuje posun vpravo");
        strom4.posunVpravo();
        strom3.posunVpravo();
        strom2.posunVpravo();
        strom1.posunVpravo();
        assertEquals(true, 
            P.souhlas("Posun vpravo vpořádku?\n\nNásleduje posun vlevo"));
        strom1.posunVlevo();
        strom2.posunVlevo();
        strom3.posunVlevo();
        strom4.posunVlevo();
        assertEquals(true, 
            P.souhlas("Posun vlevo vpořádku?\n\nNásleduje posun vzhůru"));
        strom1.posunVzhůru();
        strom3.posunVzhůru();
        strom4.posunVzhůru();
        strom2.posunVzhůru();
        assertEquals(true, 
            P.souhlas("Posun vzhůru vpořádku?\n\nNásleduje posun dolů"));
        strom2.posunDolů();
        strom4.posunDolů();
        strom3.posunDolů();
        strom1.posunDolů();
        assertEquals(true, 
            P.souhlas("Posun dolů vpořádku?"));
    }
    
    public void testKrok()
    {
        P.zpráva("Následuje změna kroku na 10");
        Strom_6a.setKrok(10);
        testPosuny();
    }
        
    public void testZarámuj()
    {
        strom1.zarámuj();
        assertTrue( P.souhlas("Implicitní strom zarámován?") );
        strom1.smaž();
        strom3.zarámuj();
        assertTrue( P.souhlas("Třetí strom zarámován?") );
        strom3.smaž();
        strom4.zarámuj();
        assertTrue( P.souhlas("Čtvrtý strom zarámován?") );
    }

    public void testPočítáníInstancí()
    {
        assertTrue( P.souhlas( "Test počítání instancí a převodu na řetězec\n" +
            strom1 + "\n" + strom2 + "\n" + strom3 + "\n" + strom4 + "\n" +
            "\n\nSouhlasi?"));
    }

    public void testObrázek()
    {
        Strom_6a.obrázek( new Oblast (100, 100, 100, 100), 10 );
        assertTrue( P.souhlas("V pořádku na středu zarámovaný strom?"));
    }

    public void testAlej()
    {
        AktivníPlátno.getPlátno().odstraňVše();
        Strom_6a.alej();
        assertTrue( P.souhlas("Alej nakreslena správně?"));
    }

    public void testStatickéZarámuj()
    {
        AktivníPlátno.getPlátno().odstraňVše();
        Strom_6a.zarámuj( 200, 300 );
        assertTrue( P.souhlas("Strom zarámován v okně 200×300?"));
    }


}

