/**
    @(#)TestRotador.java 2009
    adolfo@di-mare.com
    Datos de prueba para {@code rotaIzquierdo()}.

    @author Adolfo Di Mare <adolfo@di-mare.com>
*/

import junit.framework.*;

/** Datos de prueba para la rutina {@code rotaIzquierdo()}. */
public class TestRotador extends TestCase {

    /** Rota {@code n} posiciones hacia la izquierda los valores del vector {@code V[]}.
      */
    public static void rotaIzquierdo( int n , int V[] ) {
        if ( V.equals(null) ) { // V[] no existe todavía
            return;
        }
        else if ( V.length==0 ) {
            return;
        }
        n = n % V.length;
        if ( n < 0 ) {
            n += V.length;
        }
        if ( n==0 ) {
            return;
        }
        // VEC_copia[] es una copia "rotada" del vector V[]
        int VEC_copia[] = new int[V.length];
        int LEN_n = V.length-n;
        {
            /******************************\
            *                              *
            *   RELLENE CON SU ALGORITMO   *
            *                              *
            \******************************/
        }
        // Copia en su lugar el vector final
        for ( int i=0; i<V.length ; ++i ) {
             V[i] = VEC_copia[i];
        }
        return;
    }

    /** test -> {@code rotaIzquierdo()}. */
    public void test_rotaIzquierdo() {
        { int V[]={4,5,6,7,1,2  }; rotaIzquierdo( 4 , V );
          int R[]={1,2,4,5,6,7  }; assertTrue( isEqual( V,R ) ); }
        { int V[]={5,6,7,1,2,3  }; rotaIzquierdo( 3 , V );
          int R[]={1,2,3,5,6,7  }; assertTrue( isEqual( V,R ) ); }
        { int V[]={0,1,2,3,4,5  }; rotaIzquierdo( 1 , V );
          int R[]={1,2,3,4,5,0  }; assertTrue( isEqual( V,R ) ); }

        { int V[]={4,5,6,7,1,2,3}; rotaIzquierdo( 4 , V );
          int R[]={1,2,3,4,5,6,7}; assertTrue( isEqual( V,R ) ); }
        { int V[]={5,6,7,1,2,3,4}; rotaIzquierdo( 3 , V );
          int R[]={1,2,3,4,5,6,7}; assertTrue( isEqual( V,R ) ); }
        { int V[]={0,1,2,3,4,5,6}; rotaIzquierdo( 1 , V );
          int R[]={1,2,3,4,5,6,0}; assertTrue( isEqual( V,R ) ); }

        { int V[]={1,2,3,4,5    };   rotaIzquierdo( 0 , V );
          int R[]={1,2,3,4,5    };   assertTrue( isEqual( V,R ) ); }

        { int V[]={1,2,3,4,5,6  };   rotaIzquierdo( 0 , V );
          int R[]={1,2,3,4,5,6  };   assertTrue( isEqual( V,R ) ); }

        { int V[]={5,6,7,1,2,3,4}; rotaIzquierdo( -4 , V );
          int R[]={1,2,3,4,5,6,7}; assertTrue( isEqual( V,R ) ); }

        { int V[]={ };              rotaIzquierdo( 3 , V );
          int R[]={ };              assertTrue( isEqual( V,R ) ); }
    }

    /** Verifica que los vectores {@code L[]} y {@code R[]} tengan exactamente los mismos valores */
    public static boolean isEqual( int L[] , int R[] ) {
        if ( L.length != R.length ) {
            return false;
        }
        for ( int i=0; i<L.length; ++i ) {
           if ( L[i] != R[i] ) {
               return false;
           }
        }
        return true;
    }

    /** Graba el nombre {@code name} y el valor del vector {@code V[]}. */
    public static void grabeVec( String name , int V[] ) {
       System.out.print("\n" + name + " ");
       for ( int i=0; i<V.length; ++i ) {
           System.out.print( " " + V[i] );
       }
    }


    /** Retorna la cantidad de dígitos del número "N" en base "base". */
    public static int nDigitos( long N , long base ) {
        /* *** RELLENE CON SU ALGORITMO *** */
        return 0;
    }

    /** Traslada los primeros "n" dígitos de "N" al final.
      * Retorna cero si alguno de los parámetros no es positivo.
      */
    public static long rotaIzquierdo( long n, long N ) {
        /* *** RELLENE CON SU ALGORITMO *** */
        return 0;
    }

    /** Traslada los últimos  "n" dígitos de "N" al principio.
      * Retorna cero si alguno de los parámetros no es positivo.
      */
    public static long rotaDerecho( long n, long N ) {
        /* *** RELLENE CON SU ALGORITMO *** */
        return 0;
    }

    public void test_rotaIzquierdo_int() {
        assertTrue( 2==nDigitos(   +43,10 ) );
        assertTrue( 3==nDigitos(  -102,10 ) );
        assertTrue( 4==nDigitos( +1000,10 ) );

        assertTrue( 678_12345==rotaIzquierdo( 3*8,678_12345 ) );
        assertTrue( 123456_78==rotaIzquierdo(   2,78_123456 ) );
        assertTrue( 12345_678==rotaIzquierdo(   3,678_12345 ) );
        assertTrue(         0==rotaIzquierdo(  -3,678_12345 ) );
        assertTrue(         0==rotaIzquierdo(   2,-78_12345 ) );

        assertTrue( 678_12345==rotaDerecho(    3*8,678_12345 ) );
        assertTrue( 123456_78==rotaDerecho(      6,78_123456 ) );
        assertTrue( 12345_678==rotaDerecho(      5,678_12345 ) );
        assertTrue(         0==rotaDerecho(     -3,678_12345 ) );
        assertTrue(         0==rotaDerecho(      2,-78_12345 ) );
    }

}

// EOF: TestRotador.java