/**
    @(#)TestAlVerres.java 2010,2012
    adolfo@di-mare.com
    Datos de prueba para {@code alVerres()}.

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

import junit.framework.*;
import java.util.Random; // Clases para números aleatorios

/** Datos de prueba para el método {@code alVerres()}. */
public class TestAlVerres extends TestCase {

    /** Retorna una copia de {@code V[]} con los valores invertidos.
        <li> alVerres( {'a','b','c'} ) retorna {'c','b','a'} </li>
    */
    public static char[] alVerres( char V[] ) {
        if ( V == null ) {
            return null;
        }
        int size = V.length;          // dimensión de V[] y de R[]
        char R[] = new char[ size ];  // R[] es la copia invertida de V[]
        int i, j;                     // indices para V[] && R[]
        {
            /******************************\
            *                              *
            *   RELLENE CON SU ALGORITMO   *
            *                              *
            \******************************/
        //  System.out.println( "R" + vString(R) );
        }
        return R;
    }

    static char Vbcdefgh[] = { 'b','c','d','e','f','g','h' };
    static char Vhgfedcb[] = { 'h','g','f','e','d','c','b' };

    static char Vabababa[] = { 'a','b','a','b','a','b','a' };

    static char Vunos[]    = { '1','1','1','1','1','1','1' };

    static char Abbbb[]    = { 'b','b','b','b' };
    static char Aabcd[]    = { 'a','b','c','d' };
    static char Adcba[]    = { 'd','c','b','a' };

    static char Aba[]      = { 'b','a' };
    static char Aab[]      = { 'a','b' };
    static char Ab[]       = { 'b' };

    static char Ajjabcd[]  = { 'j','j','a','b','c','d' };
    static char Adcba99[]  = { 'd','c','b','a','j','j' };

    /** Prueba el método {@code alVerres()} nunca son modificados. */
    public void testAlVerres() {
        assertTrue( sonIguales( Vbcdefgh, alVerres(Vhgfedcb) ) );
        assertTrue( sonIguales( Vabababa, alVerres(Vabababa) ) );
        assertTrue( sonIguales( Vunos,    alVerres(Vunos)    ) );
        assertTrue( sonIguales( Abbbb,    alVerres(Abbbb)    ) );
        assertTrue( sonIguales( Aabcd,    alVerres(Adcba)    ) );
        assertTrue( sonIguales( Aab,      alVerres(Aba)      ) );
        assertTrue( sonIguales( Ab,       alVerres(Ab)       ) );
        assertTrue( sonIguales( Ajjabcd,  alVerres(Adcba99)  ) );

        assertTrue( sonIguales( Vhgfedcb, alVerres(Vbcdefgh) ) );
        assertTrue( sonIguales( Adcba,    alVerres(Aabcd)    ) );
        assertTrue( sonIguales( Aba,      alVerres(Aab)      ) );
        assertTrue( sonIguales( Adcba99,  alVerres(Ajjabcd)  ) );

        assertTrue(   sonIguales( null,     alVerres(null)   ) );
        assertTrue( ! sonIguales( Adcba99,  alVerres(null)   ) );

        Random rand = new Random( 213 );
        for ( int k=6; k<=17; ++k ) {
            char V[] = new char[k]; assertTrue( V.length == k );
            for ( int i=0; i<k; ++i ) {
                V[i] = (char)('0'+rand.nextInt(10)); // rellena con dígitos aleatorios
            }
            String Vstr = "V" + vString( alVerres(V) );
            String Rstr = "V" + vString( alVerresRecursivo(V) );
            String msg  = Vstr + " != " + Rstr;
            // compara el valor calculado por el alumno con el valor correcto
            assertTrue( msg, sonIguales( alVerres(V), alVerresRecursivo(V) ) );
        }
    }

    /** Verifica que los vectores {@code L[]} y {@code R[]} tengan exactamente los mismos valores */
    public static boolean sonIguales( char L[] , char R[] ) {
        if ( L == null && R == null ) {
            return true; // ambos están vacíos
        }
        else if ( L == null || R == null ) {
            return false; // solo uno está vacío
        }
        else if ( L.equals(R) ) {
            return true; // referencian el mismo objeto
        }
        if ( L.length != R.length ) {
            return false;
        }
        for ( int i=0; i<L.length; ++i ) {
            if ( L[i] != R[i] ) {
                return false; // este no calza
            }
        }
        return true;
    }

    /** Paso intermedio en la implementación recursiva de {@code alVerresRecursivo( char V[] )}.
    */
    public static void alVerresRecursivo( int i, char V[], char R[] ) {
        if ( i==V.length ) {
            return;
        }
        R[i] = V[ V.length-i-1 ];
        alVerresRecursivo( i+1,V,R );
        return;
    }

    /** Retorna una copia de {@code V[]} con los valores invertidos.
        <li> alVerres( {'a','b','c'} ) retorna {'c','b','a'}
    */
    public static char[] alVerresRecursivo( char V[] ) {
        if ( V ==null ) {
            return null;
        }
        int size = V.length;         // dimensión de V[] y de R[]
        char R[] = new char[ size ]; // R[] es la copia invertida de V[]
        alVerresRecursivo(0,V,R);
        return R;
    }

    /** Retorna una hilera que contiene los dígitos de {@code L[]}. */
    public static String vString( char L[] ) {
        if ( L == null ) {
            return "";
        }
        StringBuffer res = new StringBuffer();
        for ( int i=0; i<L.length; ++i ) {
            res.append( new Integer(L[i]).toString() );
        }
        return new String(res);
    }

}

// EOF: TestAlVerres.java