/* Lab18.java (c) 2009 adolfo@di-mare.com */

/**
    @(#)Lab18.java 2009
    Muestra que Java pasa copias de referencias a los objetos.
    Eso implica que se puede cambiar el objeto referenciado, pero no la referencia.
    Si se cambia la copia de la referencia, no se cambia la referencia original.
    Si se puede cambiar el valor referenciado, pero no se puede cambiar la referencia original.
    @author Adolfo Di Mare <adolfo@di-mare.com>
*/

import java.io.*;         // Clases para leer desde el teclado
import java.util.*;       // Random
import junit.framework.*; // TestCase

/** Muestra que Java pasa copias de referencias a los objetos. */
public class Lab18 extends TestCase {

    /** Muestra que los parámetros escalares no se pasan por referencia.
      * <ul><li> Tanto {@code P} como {@code Q} conservan su valor original. </li>
      * <li> Lo que el método usa es una copia de {@code P} y otra de {@code Q}. </li></ul>
    */
    public static void noIntercambia( int P, int Q ) {
       int temp = P;
       P = Q;
       Q = temp;
    }

    /** test -> {@code noIntercambia()}. */
    public void test_noIntercambia() {
        int P=12, Q=13;
        noIntercambia( P , Q );
        assertTrue( P == 12 && Q == 13  );
        assertTrue( P != 13 && Q != 12  );
    }

    /** Intercambia <code>V[i] <==> V[j]</code>. */
    static void intercambie( int V[], int i, int j ) {
        int tmp = V[i];
        V[i] = V[j];
        V[j] = tmp;
    }

    /** test -> {@code intercambie()}. */
    public void test_intercambie() {
        int V[] = { 0,1,2,3,4,5 };
        assertTrue( V.length == 6 ); // dimensión 6
        assertTrue( V[3] == 3 && V[5] == 5 );
        intercambie( V , 3,5 );
        assertTrue( V[3] == 5 && V[5] == 3 );
        // V[] sí fue modificado
    }

    /** Graba en {@code VEC_doble[]} 2 veces cada valor de {@code V[]}.
      * <ul><li> La dimensión de {@code VEC_doble[]} debe ser el doble de la de {@code V[]}.</li>
      * <li> Si las dimensiones <code> ( VEC_doble.length != V.length*2 ) </code> no hace nada.</li>
      * <li> <code> V[]= { 5,3,8,2 } ==> VEC_doble = { 5,5 3,3 8,8 2,2 } </code>.</li>
    */
    public static void duplicador( int VEC_doble[] , int V[] ) {
        if ( VEC_doble.length != V.length*2 ) {
            return;
        }
        for ( int i=0; i<V.length; ++i ) {
            VEC_doble[2*i+0] = V[i];
            VEC_doble[2*i+1] = V[i];
        }
    }

    /** test -> {@code duplicador()}. */
    public void test_duplicador() {
        int VEC[] = { 5,3,8,2 };
        int DUP[] = { 5,5, 3,3, 8,8, 2,2 };
        int VEC_copia[] = new int[VEC.length*2]; // lo hace del tamaño adecuado
        duplicador( VEC_copia , VEC );
        assertTrue( isEqual( VEC_copia,DUP ) );
        duplicador( VEC , DUP ); // no cambia VEC[] porque no calzan las dimensiones
        assertFalse( isEqual(VEC,DUP) );
    }

    /** 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;
    }

    /** Muestra que los vectores no pasan por referencia.
      * Java pasa copias de la referencia.
      * Por eso, al modificar la copia no se modifica el original.
      * Como {@code V} es una copia de la referencia original, es
      * esa copia la que queda modificada y por eso el vector
      * {@code V[]} queda con el valor que originalmente tiene.
    */
    public static void noModifica( int V[] ) {
        int VEC_copia[] = new int[V.length * 2]; // OJO: dimensión correcta
        duplicador( VEC_copia, V );
        V = VEC_copia;
        // V es una copia de la referencia original
        // - El vector V[] original no es modificado
    }

    /** test -> {@code noModifica()}. */
    public void test_noModifica() {
        int VEC[] = { 5,3,8,2 };
        int DUP[] = { 5,5, 3,3, 8,8, 2,2 };
        noModifica( VEC );
        assertFalse( isEqual(VEC,DUP) );
        assertTrue( VEC.length == 4 );            // dimensión original
        assertTrue( VEC[0] == 5 && VEC[1] == 3 ); // valores originales
        assertTrue( VEC[2] == 8 && VEC[3] == 2 ); // valores originales
    }

}

// EOF: Lab18.java