package příklady;

/*******************************************************************************
 * Třída Časování obsahuje několik statickým metod, které testují
 * zrnitost údajů systémových hodin a rychlost porcesoru.
 * Metody vypisují počet milisekund uplynuvších mezi dvěma tiky hodin
 * a současně také počet běhů cyklem mezi těmito tiky.
 * Většina provádí tento test opakovaně a tak názorně demonstruje
 * nerovnoměrnou rychlost zpracování programů.
 *
 * @author     Rudolf Pecinovský
 * @version    0.00.000,  0.0.2003
 */
public class Časování
{
//== KONSTANTNÍ ATRIBUTY TŘÍDY =================================================
//== PROMĚNNÉ ATRIBUTY TŘÍDY ===================================================
//== KONSTANTNÍ ATRIBUTY INSTANCÍ ==============================================
//== PROMĚNNÉ ATRIBUTY INSTANCÍ ================================================
//== PŘÍSTUPOVÉ METODY VLASTNOSTÍ TŘÍDY ========================================
//== OSTATNÍ METODY TŘÍDY ======================================================

    /***************************************************************************
     * Jednorázový test využívající cyklus do.
     */
    public static void testHodin_do()
    {
        long první = System.currentTimeMillis();
        int  dotaz = 0;
        long druhý;

        do{
            dotaz++;
            druhý = System.currentTimeMillis();
        }while( první == druhý );
        System.out.println("Tik " + (druhý-první) +
                           " ms po " + dotaz + ". čtení" );
    }


    /***************************************************************************
     * Opakování předchozího testu v cyklu while.
     */
    public static void testHodin_while( int pokusů )
    {
        int pokus = 1;

        System.out.println("===== ZAČÁTEK TESTU WHILE =====");
        while( pokus <= pokusů )
        {
            System.out.print( "Pokus " + pokus + ": " );
            testHodin_do();
            pokus++;
        }
        System.out.println("===== KONEC TESTU WHILE =====");
    }


    /***************************************************************************
     * Opakování předchozího testu v cyklu while.
     */
    public static void testHodin_for( int pokusů )
    {
        System.out.println("===== ZAČÁTEK TESTU FOR =====");
        for( int pokus = 1;   pokus <= pokusů;   pokus++ )
        {
            System.out.print( "Pokus " + pokus + ": " );
            testHodin_do();
        }
//      System.out.println("Provedli jsme " + pokus + " pokusů" );
        System.out.println("===== KONEC TESTU FOR =====");
    }


    /***************************************************************************
     * Opakování předchozího testu v cyklu while.
     */
    public static void nekonečný()
    {
        System.out.println("===== ZAČÁTEK NEKONEČNÉHO TESTU =====");
        for(;;)
        {
            testHodin_do();
        }
    //      System.out.println("===== KONEC NEKONEČNÉHO TESTU =====");
    }


    /***************************************************************************
     * Sloučení obou předchozích testů do jediné metody.
     */
    public static void testHodin_vnořený( int pokusů )
    {
        System.out.println("===== ZAČÁTEK TESTU S VNOŘENÝM CYKLEM =====");

        long minule = System.currentTimeMillis();

        for( int pokus = 1;   pokus <= pokusů;   pokus++ )
        {
            int  dotaz = 0;
            long nyní;

            do{
                dotaz++;
                nyní = System.currentTimeMillis();
            }while( nyní == minule );
            System.out.println("Pokus " + pokus +
                               ": tik " + (nyní-minule) +
                               " ms po " + dotaz + ". čtení" );
            minule = nyní;
        }
        System.out.println("===== KONEC TESTU S VNOŘENÝM CYKLEM =====");
    }


    /***************************************************************************
     * Sloučení obou předchozích testů do jediné metody.
     */
    public static void testHodin_uprostřed( int sekund )
    {
        System.out.println("===== ZAČÁTEK TESTU S PEVNOU DOBOU MĚŘENÍ =====");

        long start  = System.currentTimeMillis();
        long minule = start;

        for(;;)
        {
            long nyní;
            int  dotaz = 0;

            do{
                nyní = System.currentTimeMillis();
                dotaz++;
            }while( nyní == minule );
            long měří_s = (int)((nyní - start)/1000);

            if( měří_s  >=  sekund )    //Podmínka testující setrvání v cyklu
                break;                  //Příkaz k ukončení cyklu

            int měří_ms = (int)((nyní - start)%1000);
            System.out.println("Čas " + měří_s + "s, " + měří_ms +
                               "ms, tik " + (nyní-minule) +
                               " ms po " + dotaz + ". čtení" );
            minule = nyní;
        }
        System.out.println("===== KONEC TESTU S PEVNOU DOBOU MĚŘENÍ =====");
    }


    /***************************************************************************
     * Metoda ukazuje, že v některých případech může mít cyklus prázdné tělo.
     */
    public static void testHodin_bezTěla( int sekund )
    {
        System.out.println("===== ZAČÁTEK TESTU S PRÁZDNÝM TĚLEM =====");
        long start  = System.currentTimeMillis();
        long minule = start;

        for(;;)
        {
            while( minule == System.currentTimeMillis() );
            long nyní = System.currentTimeMillis();
            long měří_s = (int)((nyní - start)/1000);

            if( měří_s  >=  sekund )    //Podmínka testující setrvání v cyklu
                break;                  //Příkaz k ukončení cyklu

            int měří_ms = (int)((nyní - start)%1000);
            System.out.println("Čas " + měří_s + "s, " + měří_ms +
                               "ms, tik " + (nyní-minule) );
            minule = nyní;
        }
        System.out.println("===== KONEC TESTU S PRÁZDNÝM TĚLEM =====");
    }



//##############################################################################
//== KONSTRUKTORY A TOVÁRNÍ METODY =============================================
//== PŘÍSTUPOVÉ METODY VLASTNOSTÍ INSTANCÍ =====================================
//== PŘEKRYTÉ METODY IMPLEMENTOVANÝCH ROZHRANÍ =================================
//== PŘEKRYTÉ ABSTRAKTNÍ METODY RODIČOVSKÉ TŘÍDY ===============================
//== PŘEKRYTÉ KONKRÉTNÍ METODY RODIČOVSKÉ TŘÍDY ================================
//== NOVĚ ZAVEDENÉ METODY INSTANCÍ =============================================
//== SOUKROMÉ A POMOCNÉ METODY TŘÍDY ===========================================
//== SOUKROMÉ A POMOCNÉ METODY INSTANCÍ ========================================
//== VNOŘENÉ A VNITŘNÍ TŘÍDY ===================================================
//== TESTY A METODA MAIN =======================================================
}

