package zlomky;

/*******************************************************************************
 * Testovací třída Zlomek_4Test slouží ke komplexnímu otestování vzorového
 * řešení definice třídy zlomků spolu s operacemi zlomkové aritmetiky.
 *
 * @author    Rudolf Pecinovský
 * @version   0.00.000,  0.0.2003
 */
public class Zlomek_4Test extends junit.framework.TestCase
{
    Zlomek_4 z0, z1, z2, z12, z34, z56;
    Zlomek_4 v1, v2, v3;
    
//== METODY TŘÍDY PRO PŘÍPRAVU A SPUŠTĚNÍ SADY =================================
//##############################################################################
//== 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()
    {
        System.out.println( "\n" + getName() );
        z0 = new Zlomek_4( 0 );
        z1 = new Zlomek_4( 1 );
        z2 = new Zlomek_4( 2 );
        z12 = new Zlomek_4( 1, 2 );
        z34 = new Zlomek_4( 3, 4 );
        z56 = new Zlomek_4( 5, 6 );
    }


    /***************************************************************************
     * Úklid po testu - tato metoda se spustí po vykonání každého testu.
     */
    protected void tearDown()
    {
    }


//== SOUKROMÉ A POMOCNÉ METODY TŘÍDY ===========================================
    
    /***************************************************************************
     * Pomocná metoda tisknoucí zadanou operaci na standardní výstup.
     * 
     * @param v    Výsledek
     * @param z1   Levý operand
     * @param op   Znak operace
     * @param z2   Pravý operand
     */
    public static void tiskni( Zlomek_4 v, Zlomek_4 z1, char op, Zlomek_4 z2 )
    {
        System.out.println( v + " = " + z1 + ' ' + op + ' ' + z2 );
    }
    
    
    /***************************************************************************
     * Pomocná metoda tisknoucí zadanou operaci na standardní výstup.
     * 
     * @param číslo    Výsledek převedený na řetězec
     * @param z        Převáděný zlomek
     */
    public static void tiskni( String číslo, Zlomek_4 z )
    {
        System.out.println( číslo + " = " + z );
    }
    

//== SOUKROMÉ A POMOCNÉ METODY INSTANCÍ ========================================
//== VNOŘENÉ A VNITŘNÍ TŘÍDY ===================================================
//== VLASTNÍ TESTY =============================================================

    /***************************************************************************
     * Testuje konstruktory a převod zlomku na řetězec.
     */
    public void testToString()
    {
        z1 = new Zlomek_4( 2 );
        System.out.println("Zlomek_4(2) = " + z1);
        assertEquals( "[2/1]", z1.toString() );

        z1 = new Zlomek_4( 1, 2 );
        System.out.println("Zlomek_4(1, 2) = " + z1);
        assertEquals( "[1/2]", z1.toString() );

        z1 = new Zlomek_4( 2, 4 );
        System.out.println("Zlomek_4(2, 4) = " + z1);
        assertEquals( "[1/2]", z1.toString() );

        z2 = new Zlomek_4( z1 );
        System.out.println("Zlomek_4(" + z1 + ") = " + z2);
        assertEquals(z1.getČitatel(), z2.getČitatel());
        assertEquals(z1.getJmenovatel(), z2.getJmenovatel());
    }
    

    /***************************************************************************
     * Testuje sčítání zlomků a zlomku a čísla.
     */
    public void testPlus()
    {
        v1 = z1.plus( z2 );    
        tiskni( v1, z1, '+', z2 );
        assertEquals( "[3/1]", v1.toString() );
        
        v2 = z12.plus( z34 );  
        tiskni( v2, z12, '+', z34 );
        assertEquals( "[5/4]", v2.toString() );
        
        v2 = z34.plus( z12 );  
        tiskni( v2, z34, '+', z12 );
        assertEquals( "[5/4]", v2.toString() );
        
        v3 = v1.plus(v2);      
        tiskni( v3, v1, '+', v2 );
        assertEquals( "[17/4]", v3.toString() );
        
        v3 = v2.plus(v2);      
        tiskni( v3, v2, '+', v2 );
        assertEquals( "[5/2]", v3.toString() );
        
        v3 = v2.plus(2);      
        tiskni( v3, v2, '+', new Zlomek_4(2) );
        assertEquals( "[13/4]", v3.toString() );
    }
    

    /***************************************************************************
     * Testuje odčítání zlomků a zlomku a čísla.
     */
    public void testMínus()
    {
        v1 = z1.mínus( z2 );    
        tiskni( v1, z1, '-', z2 );
        assertEquals( "[-1/1]", v1.toString() );
        
        v2 = z12.mínus( z34 );
        tiskni( v2, z12, '-', z34 );
        assertEquals( "[-1/4]", v2.toString() );
        
        v2 = z34.mínus( z12 );
        tiskni( v2, z34, '-', z12 );
        assertEquals( "[1/4]", v2.toString() );
        
        v3 = v1.mínus(v2);
        tiskni( v3, v1, '-', v2 );
        assertEquals( "[-5/4]", v3.toString() );
        
        v3 = v2.mínus(v2);
        tiskni( v3, v2, '-', v2 );
        assertEquals( "[0/1]", v3.toString() );
        
        v3 = v2.mínus(2);
        tiskni( v3, v2, '-', new Zlomek_4(2) );
        assertEquals( "[-7/4]", v3.toString() );
        
        v3 = v2.odečtiOd(2);
        tiskni( v3, new Zlomek_4(2), '-', v2 );
        assertEquals( "[7/4]", v3.toString() );
    }

    
    /***************************************************************************
     * Testuje násobení zlomků a zlomku a čísla.
     */
    public void testKrát()
    {
        v1 = z1.krát( z2 );
        tiskni( v1, z1, '*', z2 );
        assertEquals( "[2/1]", v1.toString() );
        
        v2 = z12.krát( z34 );
        tiskni( v2, z12, '*', z34 );
        assertEquals( "[3/8]", v2.toString() );
        
        v2 = z34.krát( z12 );
        tiskni( v2, z34, '*', z12 );
        assertEquals( "[3/8]", v2.toString() );
        
        v3 = v1.krát(v2);
        tiskni( v3, v1, '*', v2 );
        assertEquals( "[3/4]", v3.toString() );
        
        v3 = v2.krát(v2);
        tiskni( v3, v2, '*', v2 );
        assertEquals( "[9/64]", v3.toString() );
        
        v3 = v2.krát(2);
        tiskni( v3, v2, '*', new Zlomek_4(2) );
        assertEquals( "[3/4]", v3.toString() );
    }
    

    /***************************************************************************
     * Testuje dělení zlomků a zlomku a čísla.
     */
    public void testDěleno()
    {
        v1 = z1.děleno( z2 );    
        tiskni( v1, z1, ':', z2 );
        assertEquals( "[1/2]", v1.toString() );
        
        v2 = z12.děleno( z34 );
        tiskni( v2, z12, ':', z34 );
        assertEquals( "[2/3]", v2.toString() );
        
        v2 = z34.děleno( z12 );
        tiskni( v2, z34, ':', z12 );
        assertEquals( "[3/2]", v2.toString() );
        
        v3 = v1.děleno(v2);
        tiskni( v3, v1, ':', v2 );
        assertEquals( "[1/3]", v3.toString() );
        
        v3 = v2.děleno(v2);
        tiskni( v3, v2, ':', v2 );
        assertEquals( "[1/1]", v3.toString() );
        
        v3 = v2.děleno(2);
        tiskni( v3, v2, ':', new Zlomek_4(2) );
        assertEquals( "[3/4]", v3.toString() );
        
        v3 = v2.dělČíslo(2);
        tiskni( v3, new Zlomek_4(2), ':', v2 );
        assertEquals( "[4/3]", v3.toString() );
    }


    /***************************************************************************
     * Test převodů zlomku na číslo
     */
    public void testPřevody()
    {
        int i;
        double d;
        Zlomek_4 z125 = new Zlomek_4( 12, 5 );
        
        i = z1.intValue();
        tiskni( ""+i, z1 );
        assertEquals( 1, i );
        
        i = z34.intValue();
        tiskni( ""+i, z34 );
        assertEquals( 0, i );
        
        i = z125.intValue();
        tiskni( ""+i, z125 );
        assertEquals( 2, i, 0 );
        
        d = z1.doubleValue();
        tiskni( ""+d, z1 );
        assertEquals( 1.0, d, 0 );
        
        d = z12.doubleValue();
        tiskni( ""+d, z34 );
        assertEquals( 0.5, d, 0 );
        
        d = z125.doubleValue();
        tiskni( ""+d, z125 );
        assertEquals( 2.4, d, 0 );
    }
    
    
}


