test.cpp

#include "lista.h"
#include <iostream>
#include <sstream>
#include <string>
#include <cassert>
#include <cstdlib>
using namespace std;

template<class T>
void asegurar(const Lista<T>& l, string s) {
    ostringstream out;
    l.mostrarLista(out);
    string t = out.str();
    if (s != t) {
        cerr << s << " != " << t << endl;
        assert(false);
    }
}

template<class T>
void asegurar(const Lista<T>& l, const Lista<T>& lp) {
    ostringstream out;
    lp.mostrarLista(out);
    asegurar(l, out.str());
}

void randList(Lista<int>& l, int n) {
    while(!l.esVacia()) {
        l.eliminarCursor();
    }
    while(n--) {
        l.insertarAtrasDelCursor(rand()%1000);
    }
}

#define RUNTEST(t) { cout << "Corriendo test " << #t << endl; t(); cout << "Terminado test " << #t << endl; }

void testVacia() {
    Lista<int> l;
    Lista< Lista<int> > ll;
    Lista<int> lc(l);
    assert(l.esVacia());
    assert(ll.esVacia());
    assert(lc.esVacia());
    asegurar(l, "[]");
    asegurar(ll, "[]");
    asegurar(lc, "[]");
}

void testCopia() {
    Lista<int> l;
    randList(l, 10);
    Lista< Lista<int> > ll;
    ll.insertarAtrasDelCursor(l);
    l.eliminarCursor();
    ll.insertarAtrasDelCursor(l);
    Lista<int> lc(l);
    Lista< Lista<int> > llc(ll);
    asegurar(lc, l);
    asegurar(llc, ll);
}

void testIns() {
    Lista<int> l;
    l.insertarAdelanteDelCursor(4);
    l.insertarAtrasDelCursor(6);
    asegurar(l, "[4,6]");
    l.insertarAdelanteDelCursor(2);
    asegurar(l, "[2,4,6]");
    l.insertarAdelanteDelCursor(3);
    asegurar(l, "[2,3,4,6]");
    l.insertarAtrasDelCursor(5);
    asegurar(l, "[2,3,4,5,6]");
    l.retrocederCursorAlInicio();
    l.insertarAdelanteDelCursor(0);
    asegurar(l, "[0,2,3,4,5,6]");
    l.retrocederCursorAlInicio();
    l.insertarAtrasDelCursor(1);
    asegurar(l, "[0,1,2,3,4,5,6]");
    l.avanzarCursorAlFinal();
    l.insertarAtrasDelCursor(8);
    asegurar(l, "[0,1,2,3,4,5,6,8]");
    l.avanzarCursorAlFinal();
    l.insertarAdelanteDelCursor(7);
    asegurar(l, "[0,1,2,3,4,5,6,7,8]");
    Lista< Lista<int> > ll;
    ll.insertarAdelanteDelCursor(l);
    l.eliminarCursor();
    ll.insertarAdelanteDelCursor(l);
    asegurar(ll, "[[0,1,2,3,4,5,6,7],[0,1,2,3,4,5,6,7,8]]");
}

void testTamanio() {
    Lista<int> l;
    assert(l.tamanio() == 0);
    l.insertarAdelanteDelCursor(1);
    assert(l.tamanio() == 1);
    randList(l, 50);
    assert(l.tamanio() == 50);
}

void testActual() {
    Lista<int> l;
    l.insertarAdelanteDelCursor(5);
    for(int i = 1; i < 5; ++i)
        l.insertarAdelanteDelCursor(i);
    l.retrocederCursorAlInicio();
    assert(l.actual() == 1);
    l.retrocederCursor();
    assert(l.actual() == 1);
    l.avanzarCursor();
    assert(l.actual() == 2);
    l.avanzarCursorAlFinal();
    assert(l.actual() == 5);
    l.avanzarCursor();
    assert(l.actual() == 5);
    l.retrocederCursor();
    assert(l.actual() == 4);


    Lista<int> l2(l);
    assert(l2.actual() == 1);
    l2.retrocederCursor();
    assert(l2.actual() == 1);
    l2.avanzarCursor();
    assert(l2.actual() == 2);
    l2.avanzarCursorAlFinal();
    assert(l2.actual() == 5);
    l2.avanzarCursor();
    assert(l2.actual() == 5);
    l2.retrocederCursor();
    assert(l2.actual() == 4);

}

void testEliminar() {
    Lista<int> l;
    for(int i=1;i<=10;++i) {
        l.insertarAtrasDelCursor(i);
        l.avanzarCursorAlFinal();
    }
    asegurar(l, "[1,2,3,4,5,6,7,8,9,10]");
    l.eliminarCursor();
    asegurar(l, "[1,2,3,4,5,6,7,8,9]");
    l.eliminarCursor();
    asegurar(l, "[1,2,3,4,5,6,7,8]");
    l.retrocederCursorAlInicio();
    l.eliminarCursor();
    asegurar(l, "[2,3,4,5,6,7,8]");
    l.eliminarCursor();
    asegurar(l, "[3,4,5,6,7,8]");
    l.avanzarCursor();
    l.eliminarCursor();
    asegurar(l, "[3,5,6,7,8]");
    l.eliminarCursor();
    asegurar(l, "[3,6,7,8]");
    while(!l.esVacia())
        l.eliminarCursor();
}


void testSanidad() {
    Lista<int> l;
    assert(l.tamanio() == 0);
    l.insertarAtrasDelCursor(99);
    assert(l.tamanio() == 1);
    l.retrocederCursorAlInicio();
    l.eliminarCursor();
    assert(l.tamanio() == 0);
    asegurar(l, "[]");

    int i = 0;
    while(i < 10) l.insertarAtrasDelCursor(i++);
    assert(l.tamanio() == 10);
    while(i) {
        l.insertarAdelanteDelCursor(i--);
        assert(l.actual() == 0);
    }
    asegurar(l, "[10,9,8,7,6,5,4,3,2,1,0,9,8,7,6,5,4,3,2,1]");
    assert(l.tamanio() == 20);
    while(i++ < 10) {
        l.eliminarCursor();
        assert(l.actual() == 10-i || i == 10);
    }
    asegurar(l, "[10,9,8,7,6,5,4,3,2,1]");
    assert(l.tamanio() == 10);

    Lista<Lista<Lista<int > > > llli;
    llli.insertarAtrasDelCursor(Lista<Lista<int> >(3,Lista<int>(2,42)));
    llli.insertarAdelanteDelCursor(Lista<Lista<int> >(1, Lista<int>(5, 71)));
    asegurar(llli, "[[[71,71,71,71,71]],[[42,42],[42,42],[42,42]]]");
    assert(llli.tamanio() == 2);
    llli.avanzarCursorAlFinal();
    assert(llli.tamanio() == 2);
    llli.eliminarCursor();
    assert(llli.tamanio() == 1);
    asegurar(llli, "[[[71,71,71,71,71]]]");
    asegurar(llli.actual(), Lista<Lista<int> >(1, Lista<int>(5,71)));



}

void testManejoDeErrores() {
    Lista<char> foo;
    foo.avanzarCursorAlFinal();
    foo.avanzarCursor();
    foo.retrocederCursorAlInicio();
    foo.retrocederCursor();
    foo.insertarAdelanteDelCursor('X');
    asegurar(foo, "[X]");
    foo.insertarAtrasDelCursor('Y');
    asegurar(foo, "[X,Y]");
}

int main() {
    RUNTEST(testVacia);
    RUNTEST(testCopia);
    RUNTEST(testIns);
    RUNTEST(testTamanio);
    RUNTEST(testActual);
    RUNTEST(testEliminar);
    RUNTEST(testSanidad);
    RUNTEST(testManejoDeErrores);
    return 0;
}