void pruebas_cola_con_elementos() {
printf("\nINICIO DE PRUEBAS CON COLA CON ELEMENTOS\n");
/* Declaro las variables a utilizar*/
cola_t* cola = cola_crear();
int a = 1, b = 2, c = 3, d = 4, e = 5;
int* p_a = &a;
int* p_b = &b;
int* p_c = &c;
int* p_d = &d;
int* p_e = &e;
/* Inicio de pruebas */
print_test("Prueba encolar &a", cola_encolar(cola, p_a));
print_test("Prueba encolar &b", cola_encolar(cola, p_b));
print_test("Prueba encolar &c", cola_encolar(cola, p_c));
print_test("Prueba encolar &d", cola_encolar(cola, p_d));
print_test("Prueba encolar &e", cola_encolar(cola, p_e));
print_test("Prueba ver primero igual a &a", cola_ver_primero(cola) == p_a);
print_test("Prueba cola NO esta vacia despues de encolar", !cola_esta_vacia(cola));
print_test("Prueba desencolar igual a &a", cola_desencolar(cola) == p_a);
print_test("Prueba desencolar igual a &b", cola_desencolar(cola) == p_b);
print_test("Prueba desencolar igual a &c", cola_desencolar(cola) == p_c);
print_test("Prueba desencolar igual a &d", cola_desencolar(cola) == p_d);
print_test("Prueba desencolar igual a &e", cola_desencolar(cola) == p_e);
print_test("Prueba cola esta vacia despues de desencolar todos", cola_esta_vacia(cola));
/* Destruyo la cola */
cola_destruir(cola, NULL);
print_test("La cola fue destruida", true);
}
void pruebas_encolar_desencolar(){
printf("\n ***Inicio de pruebas cola_encolar cola_desencolar *** \n");
int a=3;
int b=1;
cola_t* cola = cola_crear();
print_test("Encolo el elemento 3 cola2",cola_encolar(cola,&a));
print_test("La cola no esta vacia",!cola_esta_vacia(cola));
print_test("Encolo el elemento 1 cola2",cola_encolar(cola,&b));
print_test("Encolo el numero 3 cola2",cola_encolar(cola,&a));
print_test("Ver primero me devuelve 3 ",*(int*)cola_ver_primero(cola)==3);
print_test("Desencolo el primer elemento y devuelve valor ",*(int*)cola_desencolar(cola)==3);
print_test("Ver primero me devuelve 1 ",*(int*)cola_ver_primero(cola)==1);
print_test("Desencolo el primer elemento y devuelve valor ",*(int*)cola_desencolar(cola)==1);
print_test("Ver primero me devuelve 3 ",*(int*)cola_ver_primero(cola)==3);
print_test("Desencolo el primer elemento y devuelve valor ",*(int*)cola_desencolar(cola)==3);
print_test("Devuelve NUll Cuando ya no hay elementos para desencolar",cola_desencolar(cola)==NULL);
print_test("la cola esta vacia", cola_esta_vacia(cola));
print_test("Vuelvo a encolar el elemento 3 ",cola_encolar(cola,&a));
print_test("Vuelvo a encolar el elemento 1 ",cola_encolar(cola,&b));
print_test("**Cola destrida con elementos **",true);
cola_destruir(cola,NULL);
}
void pruebas_cola_de_pilas() {
printf("\nINICIO DE PRUEBAS CON COLA DE PILAS\n");
/* Declaro las variables a utilizar*/
cola_t* cola = cola_crear();
pila_t* pila = pila_crear();
pila_t* pila2 = pila_crear();
int a = 1, b = 2, c = 3, d = 4, e = 5;
int* p_a = &a;
int* p_b = &b;
int* p_c = &c;
int* p_d = &d;
int* p_e = &e;
/* Inicio de pruebas */
// Apilo todos los elementos
pila_apilar(pila, p_a);
pila_apilar(pila, p_b);
pila_apilar(pila, p_c);
pila_apilar(pila2, p_d);
pila_apilar(pila2, p_e);
// Encolo las pilas
print_test("Prueba encolar pila 1", cola_encolar(cola, pila));
print_test("Prueba encolar pila 2", cola_encolar(cola, pila2));
/* Destruyo la cola */
cola_destruir(cola, pila_destruir_wrapper);
print_test("La cola fue destruida", true);
}
void pruebas_cola_destruir(){
//19
punto* p = malloc(sizeof(punto));
p->x = 1;
p->y = 2;
cola_t *cola =cola_crear();
cola_encolar(cola, p);
print_test("Ver primero igual a struct punto", cola_ver_primero(cola) == p);
cola_desencolar(cola);
//20
print_test("Desencolar struct punto, cola vacia", cola_esta_vacia(cola));
//21
cola_encolar(cola, p);
cola_destruir(cola, destruir_punto);
print_test("Destruir cola con struct punto encolado", true);
//22
cola_t* cola_1 = cola_crear();
for(int i = 0; i<500; i++){
if (i%2==0)
cola_encolar(cola_1, p);
else
cola_desencolar(cola_1);
}
print_test("Intercalar encolar y desencolar", cola_esta_vacia(cola_1));
cola_destruir(cola_1, destruir_punto);
destruir_punto(p);
}
/* Prueba que las primitivas de la cola funcionen correctamente. */
void prueba_cola()
{
/* Declaro las variables a utilizar */
cola_t *c1, *c2;
int *valor1, *valor2, *valor_aux;
valor1 = malloc(sizeof(int));
valor2 = malloc(sizeof(int));
*valor1 = 2;
*valor2 = 4;
bool exito;
int acumulador_exitos = 0;
/* Creación de las colas */
printf("Se crean dos colas vacias c1 y c2\n");
c1 = cola_crear();
c2 = cola_crear();
/* Pruebo cola encolar */
printf("Probaremos encolar 20 valores en c1:\n");
for (int x = 0; x < 20 ; x++){
if (x%2 == 0)
exito = cola_encolar(c1, valor1);
else
exito = cola_encolar(c1,valor2);
if (exito == true)
acumulador_exitos++;
}
print_test("Prueba cola encolar de la cola c1", acumulador_exitos == 20);
/* Pruebo cola ver primero 2 veces seguidas en c1 y en la cola vacia c2 */
print_test("Prueba ver primero de la cola c1", cola_ver_primero(c1) == valor1);
print_test("Prueba ver primero de la cola c1", cola_ver_primero(c1) == valor1);
print_test("Prueba ver primero de la cola c2", cola_ver_primero(c2) == NULL);
/* Pruebo cola esta vacia*/
print_test("Prueba de cola esta vacia c1", cola_esta_vacia(c1) == false);
print_test("Prueba de cola esta vacia c2", cola_esta_vacia(c2) == true);
print_test("Prueba de encolar en la cola c2", cola_encolar(c2,valor1) == true);
print_test("Prueba de desencolar en la cola c2", cola_desencolar(c2) == valor1);
print_test("Prueba de cola esta vacia c2", cola_esta_vacia(c2) == true);
/* Pruebo desencolar cola */
printf("Probaremos desencolar 18 valores de c1\n");
acumulador_exitos = 0;
for ( int x = 0; x < 18 ; x++){
valor_aux = cola_desencolar(c1);
if (x % 2 == 0 && valor_aux == valor1)
acumulador_exitos++;
else if (valor_aux == valor2)
acumulador_exitos++;
}
print_test("Prueba de desencolar la cola c1", acumulador_exitos==18);
print_test("Prueba de desencolar la cola c2", cola_desencolar(c2) == NULL);
print_test("Prueba de cola esta vacia c1", cola_esta_vacia(c1) == false);
/* Destruimos las colas */
cola_destruir(c1,destruir_dato);
cola_destruir(c2, NULL);
}
void pruebas_volumen(){
printf("***** Inicio de pruebas de volumen *****\n");
bool ok = true;
cola_t* cola = cola_crear();
print_test("cola esta vacia", cola_esta_vacia(cola));
int vec[TAM_PRUEBAS];
for(int a =0; a < TAM_PRUEBAS; a++){
vec[a] = a;
ok = cola_encolar(cola, &vec[a]);
if (!ok) break;
}
print_test("Todos los elementos fueron encolados con exito", ok);
for(int b = 0; b < TAM_PRUEBAS ; b++){
ok = *(int*)cola_desencolar(cola) == vec[b] ? true : false ;
if (!ok) break;
}
print_test("Todos los elementos fueron desencolados en orden", ok);
cola_destruir(cola, NULL);
}
/* Crear y encolar struct votante_t. */
bool comando_ingresar(maquina_votacion_t* maquina, char* entrada[]) {
#ifdef DEBUG
printf("Comando ingresar ejecutado: %s , %s \n", entrada[ENTRADA_DOC_TIPO], entrada[ENTRADA_DOC_NUM]);
#endif
// Error handling
if(maquina->estado == CERRADA) { return error_manager(MESA_CERRADA); }
if(!entrada[ENTRADA_DOC_TIPO] || !entrada[ENTRADA_DOC_NUM]) { return error_manager(NUMERO_NEGATIVO); } // Segun las pruebas
if(strtol(entrada[ENTRADA_DOC_NUM], NULL, 10) < 1) { return error_manager(NUMERO_NEGATIVO); }
char* doc_tipo_copia = copiar_clave(entrada[ENTRADA_DOC_TIPO]);
char* doc_num_copia = copiar_clave(entrada[ENTRADA_DOC_NUM]);
votante_t* votante = votante_crear(doc_tipo_copia, doc_num_copia);
if(!votante) { return error_manager(OTRO); free(doc_num_copia); free(doc_tipo_copia); }
#ifdef DEBUG
printf("Votante ingresado: %s, %s\n", votante_ver_doc_tipo(votante), votante_ver_doc_num(votante));
#endif
if( cola_encolar(maquina->cola, votante) )
return true;
return error_manager(OTRO);
}
void pruebas_cola_volumen() {
printf("\nINICIO DE PRUEBAS DE VOLUMEN\n");
/* Declaro las variables a utilizar*/
cola_t* cola = cola_crear();
int a = 1;
int* p_a = &a;
/* Inicio de pruebas */
for (int i = 1; i <= MAX_VOLUMEN; i++) {
cola_encolar(cola, p_a);
}
print_test("Prueba cola NO esta vacia despues de encolar", !cola_esta_vacia(cola));
for (int i = 1; i <= MAX_VOLUMEN; i++) {
cola_desencolar(cola);
}
print_test("Prueba cola esta vacia despues de desencolar todos", cola_esta_vacia(cola));
/* Destruyo la cola */
cola_destruir(cola, NULL);
print_test("La cola fue destruida", true);
}
void pruebas_structs(){
/* PRUEBA CON FUNCION FREE */
printf("\n ***Inicio de pruebas con structs *** \n");
printf("PRUEBAS CON FUNCION FREE \n");
cola_t* cola3=cola_crear();
cola_t* cola4=cola_crear();
tipo_t* temp1=malloc(sizeof(tipo_t));
tipo_t* temp2=malloc(sizeof(tipo_t));
print_test("Encolo un cola_t ",cola_encolar(cola3,cola4));
print_test("Encolo un tipo_t",cola_encolar(cola3,temp1));
print_test("Encolo un tipo_t",cola_encolar(cola3,temp2));
print_test("cola no esta vacia",!cola_esta_vacia(cola3));
cola_destruir(cola3, free);
cola_t* cola5 = cola_crear();
cola_destruir(cola5, NULL);
/* PRUEBA CON FUNCION DISTINTO DE FREE*/
printf("\n PRUEBAS CON FUNCION DISTINTO DE FREE \n");
vector_t* vec1 = crear_cargar_vector();
vector_t* vec2 = crear_cargar_vector();
vector_t* vec3 = crear_cargar_vector();
cola_t* cola = cola_crear();
print_test("la cola esta vacia",cola_esta_vacia(cola));
print_test("cola encolar vec1 ", cola_encolar(cola, vec1));
print_test("cola no esta vacia", !cola_esta_vacia(cola));
print_test("cola ver primero es vec1", cola_ver_primero(cola) == vec1);
print_test("cola encolar vec2 ", cola_encolar(cola, vec2));
print_test("cola ver primero sigue siendo vec1", cola_ver_primero(cola) == vec1);
print_test("cola encolar ve3", cola_encolar(cola, vec3));
cola_destruir(cola, destruir_vector);
print_test("cola destruid",true);
}
void pruebas_cola_generales(){
//1
cola_t *cola = cola_crear();
print_test("Se creo la cola", cola != NULL);
//2
print_test("Cola esta vacia", cola_esta_vacia(cola));
//3
int num = 5;
int* mun = #
cola_encolar(cola, mun);
print_test("Cola no esta vacia", !cola_esta_vacia(cola));
//4
print_test("Primer elemento cola igual a 5",cola_ver_primero(cola) == mun);
//5
int aux = *((int*) cola_desencolar(cola));
print_test("Desencole y es igual a 5", aux == num);
//6
print_test("Cola esta vacia", cola_esta_vacia(cola));
//7
void* nada = cola_desencolar(cola);
print_test("Desencolar cola vacia igual a NULL",nada == NULL);
//8
print_test("cola vacia", cola_esta_vacia(cola));
cola_t *cola_1 = cola_crear();
cola_encolar(cola, cola_1);
print_test("Encolar otra cola", !cola_esta_vacia(cola));
//9
print_test("Primer elemento igual a cola", cola_ver_primero(cola) == cola_1);
//10
print_test("Desencolar cola, igual a cola", cola_desencolar(cola) == cola_1);
//11
cola_destruir(cola, NULL);
cola_destruir(cola_1, NULL);
print_test("Destruir las dos colas", true);
//12
cola_t *cola_2 = cola_crear();
char h = 'h', o ='o', l = 'l';
char* h_ = &h;
char* o_ = &o;
char* l_ = &l;
//13
cola_encolar(cola_2, h_);
print_test("Encolar igual h", cola_ver_primero(cola_2) == h_);
cola_encolar(cola_2, o_);
cola_encolar(cola_2, l_);
//14
print_test("Desencolar igual h", *((char*) cola_desencolar(cola_2)) == h);
//15
print_test("Desencolar igual o", *((char*) cola_desencolar(cola_2)) == o);
//16
print_test("Desencolar igual l", *((char*) cola_desencolar(cola_2)) == l);
//17
print_test("Cola esta vacia", cola_esta_vacia(cola_2));
//18
for (int i = 0; i < 500; i++){
cola_encolar(cola_2, h_);
}
cola_destruir(cola_2,NULL);
print_test("Destruir cola con 500 elementos", true);
}
/* PRUEBA_ABB */
void prueba_abb(void){
//~
//~ // DATOS ESTATICOS
char *val1 = "pez espada";
char *val2 = "puerco";
char *val3 = "carpintero";
char *val4 = "ornitorrinco";
char *val5 = "oso hormiguero";
char *val6 = "ballena franca";
char *val7 = "colibri";
char *val8 = "perro callejero";
char *val9 = "marsupial";
char *val10 = "mariposa";
char *val11 = "pavo real";
// Datos dinámicos tipo lista
lista_t* val12 = lista_crear();
lista_t* val13 = lista_crear();
lista_t* val14 = lista_crear();
lista_t* val15 = lista_crear();
lista_t* val16 = lista_crear();
lista_t* val17 = lista_crear();
lista_t* val18 = lista_crear();
lista_t* val19 = lista_crear();
lista_t* val20 = lista_crear();
lista_t* val21 = lista_crear();
lista_t* val22 = lista_crear();
lista_insertar_ultimo(val12, "a");
lista_insertar_ultimo(val12, "b");
lista_insertar_ultimo(val12, "c");
lista_insertar_ultimo(val13, "d");
lista_insertar_ultimo(val13, "e");
lista_insertar_ultimo(val14, "f");
lista_insertar_ultimo(val15, "g");
lista_insertar_ultimo(val16, "h");
lista_insertar_ultimo(val17, "i");
lista_insertar_ultimo(val17, "j");
lista_insertar_ultimo(val18, "k");
lista_insertar_ultimo(val19, "l");
lista_insertar_ultimo(val20, "m");
lista_insertar_ultimo(val22, "n");
lista_insertar_ultimo(val22, "o");
// Creo un arbol vacio
abb_t* arbol0 = abb_crear(*cmp, NULL);
print_test("Prueba arbol0 vacio: ", arbol0);
print_test("Cantidad de arbol0 es 0: ", abb_cantidad(arbol0) == 0);
// Guardo clave 5, pez espada en la raiz de arbol0
print_test("Guardo clave 52, pez espada en la raiz de arbol0: ", abb_guardar(arbol0, "52", val1));
print_test("El 52 pertenece", abb_pertenece(arbol0, "52"));
print_test("Cantidad de arbol0 es 1: ", abb_cantidad(arbol0) == 1);
// Guardo clave 2, puerco en arbol0. Debe guardarse en el hijo izquierdo de 5.
print_test("Guardo clave 2, puerco en arbol0: ", abb_guardar(arbol0, "2", val2));
print_test("El 2 pertenece", abb_pertenece(arbol0, "2"));
print_test("Cantidad de arbol0 es 2: ", abb_cantidad(arbol0) == 2);
// Guardo clave 33, carpintero en arbol0. Debe guardarse en el hijo derecho de 2.
print_test("Guardo clave 33, carpintero en arbol0: ", abb_guardar(arbol0, "33", val3));
print_test("El 33 pertenece", abb_pertenece(arbol0, "33"));
print_test("Cantidad de arbol0 es 3: ", abb_cantidad(arbol0) == 3);
// Guardo clave 99, ornitorrinco en arbol0. Debe guardarse en el hijo derecho de 5.
print_test("Guardo clave 99, ornitorrinco en arbol0: ", abb_guardar(arbol0, "99", val4));
print_test("El 99 pertenece", abb_pertenece(arbol0, "99"));
print_test("Cantidad de arbol0 es 4: ", abb_cantidad(arbol0) == 4);
// Guardo clave 2, oso hormiguero en arbol0. Debe reemplazar a (2, puerco).
print_test("Reemplazo dato de clave 2 por oso hormiguero en arbol0: ", abb_guardar(arbol0, "2", val5));
// La cantidad debe haber permanecido constante.
print_test("Cantidad de arbol0 es 4: ", abb_cantidad(arbol0) == 4);
//~
//~ // Busco clave 2
print_test("Busco clave 2 con abb_obtener, devuelve oso hormiguero: ", val5 == abb_obtener(arbol0, "2"));
//~ // Busco clave 111, no existe
print_test("Busco clave 111 con abb_obtener, devuelve NULL: ", NULL == abb_obtener(arbol0, "111"));
//~ // Busco clave 33
print_test("Busco clave 33 con abb_pertenece, devuelve true: ", abb_pertenece(arbol0, "33"));
puts("");
//~ // Busco clave 10, no pertenece
print_test("Busco clave 10 con abb_pertenece, devuelve false: ", !abb_pertenece(arbol0, "10"));
//~
//~
// Borrar
print_test("Cantidad de arbol0 antes de borrar es 4: ", abb_cantidad(arbol0) == 4);
print_test("Borro nodo hoja, clave 33, devuelve el dato carpintero: ", abb_borrar(arbol0, "33") == val3);
print_test("Busco el nodo borrado con abb_pertenece, devuelve false: ", !abb_pertenece(arbol0, "33"));
print_test("Cantidad de arbol0 despues de borrar es 3: ", abb_cantidad(arbol0) == 3);
print_test("Cantidad de hojas arbol0 despues de borrar es 2: ", abb_contar_hojas(arbol0) == 2);
//~
print_test("Guardo clave 30, ballena franca en arbol0: ", abb_guardar(arbol0, "30", val6));
print_test("Guardo clave -1, colibri en arbol0: ", abb_guardar(arbol0, "-1", val7));
print_test("Guardo clave -6, perro callejero en arbol0: ", abb_guardar(arbol0, "-6", val8));
print_test("Guardo clave 15, marsupial en arbol0: ", abb_guardar(arbol0, "15", val9));
print_test("Cantidad de hojas arbol0 es 3: ", abb_contar_hojas(arbol0) == 3);
print_test("Borro nodo con un solo hijo, clave -1, devuelve el dato colibri: ", abb_borrar(arbol0, "-1") == val7);
print_test("Busco el nodo borrado con abb_pertenece, devuelve false: ", !abb_pertenece(arbol0, "-1"));
print_test("Cantidad de arbol0 despues de borrar es 6: ", abb_cantidad(arbol0) == 6);
print_test("Cantidad de hojas arbol0 despues de borrar es 3: ", abb_contar_hojas(arbol0) == 3);
print_test("Borro nodo con un solo hijo, clave 30, devuelve el dato ballena franca: ", abb_borrar(arbol0, "30") == val6);
print_test("Busco el nodo borrado con abb_pertenece, devuelve false: ", !abb_pertenece(arbol0, "30"));
print_test("Cantidad de arbol0 despues de borrar es 5: ", abb_cantidad(arbol0) == 5);
print_test("Cantidad de hojas arbol0 despues de borrar es 3: ", abb_contar_hojas(arbol0) == 3);
print_test("Guardo clave -7, mariposa en arbol0: ", abb_guardar(arbol0, "-7", val10));
print_test("Guardo clave 0, pavo real en arbol0: ", abb_guardar(arbol0, "0", val11));
print_test("Cantidad de hojas arbol0 es 4: ", abb_contar_hojas(arbol0) == 4);
print_test("Borro nodo con un dos hijos, clave 2, devuelve el dato oso hormiguero: ", abb_borrar(arbol0, "2") == val5);
print_test("Busco el nodo borrado con abb_pertenece, devuelve false: ", !abb_pertenece(arbol0, "2"));
print_test("Cantidad de arbol0 despues de borrar es 6: ", abb_cantidad(arbol0) == 6);
print_test("Cantidad de hojas arbol0 despues de borrar es 3: ", abb_contar_hojas(arbol0) == 3);
print_test("Borro nodo raiz con un dos hijos, clave 52, devuelve el dato pez espada: ", abb_borrar(arbol0, "52") == val1);
print_test("Busco el nodo borrado con abb_pertenece, devuelve false: ", !abb_pertenece(arbol0, "52"));
print_test("Cantidad de arbol0 despues de borrar es 5: ", abb_cantidad(arbol0) == 5);
print_test("Cantidad de hojas arbol0 despues de borrar es 3: ", abb_contar_hojas(arbol0) == 2);
//~
abb_t* arbol3 = abb_crear(cmp, NULL);
print_test("Guardo clave -7, mariposa en arbol3: ", abb_guardar(arbol3, "-7", val10));
print_test("Busco clave -7 con abb_obtener, devuelve mariposa: ", val10 == abb_obtener(arbol3, "-7"));
print_test("Borro nodo raiz sin hijos, clave -7, devuelve el dato mariposa: ", abb_borrar(arbol3, "-7") == val10);
abb_destruir(arbol3);
// Iterador externo
printf("Iterador inorder con función de impresión: \n");
abb_in_order(arbol0, printear_dato_est, NULL);
// Iterador interno
// Con arbol no vacio
abb_iter_t* iter = abb_iter_in_crear(arbol0);
print_test("Iterador interno (al final es false): ", !abb_iter_in_al_final(iter));
const char* clave = abb_iter_in_ver_actual(iter);
int clave_int = atoi(clave);
print_test("Iterador interno (-7): ", clave_int == -7);
abb_iter_in_avanzar(iter);
clave = abb_iter_in_ver_actual(iter);
clave_int = atoi(clave);
print_test("Iterador interno (avanzar (-6)): ", clave_int == -6);
abb_iter_in_avanzar(iter);
clave = abb_iter_in_ver_actual(iter);
clave_int = atoi(clave);
print_test("Iterador interno (avanzar (0)): ", clave_int == 0);
print_test("Iterador interno (al final es false): ", !abb_iter_in_al_final(iter));
abb_iter_in_avanzar(iter);
clave = abb_iter_in_ver_actual(iter);
clave_int = atoi(clave);
print_test("Iterador interno (avanzar (15)): ", clave_int == 15);
abb_iter_in_avanzar(iter);
clave = abb_iter_in_ver_actual(iter);
clave_int = atoi(clave);
print_test("Iterador interno (avanzar (99)): ", clave_int == 99);
abb_iter_in_avanzar(iter);
print_test("Iterador interno (avanzar, al final): ", !abb_iter_in_ver_actual(iter));
print_test("Iterador interno (al final es true): ", abb_iter_in_al_final(iter));
abb_iter_in_destruir(iter);
// Con arbol vacio
abb_t* arbol1 = abb_crear(cmp, NULL);
abb_iter_t* iter1 = abb_iter_in_crear(arbol1);
print_test("Iterador interno, arbol vacio (ver actual es NULL): ", !abb_iter_in_ver_actual(iter1));
print_test("Iterador interno, arbol vacio (al final es true): ", abb_iter_in_al_final(iter1));
print_test("Iterador interno, arbol vacio (avanzar es false): ", !abb_iter_in_avanzar(iter1));
abb_iter_in_destruir(iter1);
// Destruir arbol
abb_destruir(arbol0);
abb_destruir(arbol1);
/*Arbol con datos dinamicos tipo listas*/
// Creo un arbol vacio
abb_t* arbol2 = abb_crear(*cmp, *destruir_dato_lista);
print_test("Prueba arbol2 vacio: ", arbol2);
print_test("Cantidad de arbol2 es 0: ", abb_cantidad(arbol2) == 0);
// Guardo clave 5, val12 en la raiz de arbol2
print_test("Guardo clave 52, val12 en la raiz de arbol2: ", abb_guardar(arbol2, "52", val12));
print_test("Cantidad de arbol2 es 1: ", abb_cantidad(arbol2) == 1);
// Guardo clave 2, val13 en arbol2. Debe guardarse en el hijo izquierdo de 5.
print_test("Guardo clave 2, val13 en arbol2: ", abb_guardar(arbol2, "2", val13));
print_test("Cantidad de arbol2 es 2: ", abb_cantidad(arbol2) == 2);
// Guardo clave 33, val14 en arbol2. Debe guardarse en el hijo derecho de 2.
print_test("Guardo clave 33, val14 en arbol2: ", abb_guardar(arbol2, "33", val14));
print_test("Cantidad de arbol2 es 3: ", abb_cantidad(arbol2) == 3);
// Guardo clave 99, val15 en arbol2. Debe guardarse en el hijo derecho de 5.
print_test("Guardo clave 99, val15 en arbol2: ", abb_guardar(arbol2, "99", val15));
print_test("Cantidad de arbol2 es 4: ", abb_cantidad(arbol2) == 4);
// Guardo clave 2, val16 en arbol2. Debe reemplazar a (2, val13).
print_test("Reemplazo dato de clave 2 por val16 en arbol2: ", abb_guardar(arbol2, "2", val16));
// La cantidad debe haber permanecido constante.
print_test("Cantidad de arbol2 es 4: ", abb_cantidad(arbol2) == 4);
// Busco clave 2
print_test("Busco clave 2 con abb_obtener, devuelve val16: ", val16 == abb_obtener(arbol2, "2"));
// Busco clave 111, no existe
print_test("Busco clave 111 con abb_obtener, devuelve NULL: ", NULL == abb_obtener(arbol2, "111"));
// Busco clave 33
print_test("Busco clave 33 con abb_pertenece, devuelve true: ", abb_pertenece(arbol2, "33"));
// Busco clave 10, no pertenece
print_test("Busco clave 10 con abb_pertenece, devuelve false: ", !abb_pertenece(arbol2, "10"));
// Borrar
print_test("Cantidad de arbol2 antes de borrar es 4: ", abb_cantidad(arbol2) == 4);
print_test("Borro nodo hoja, clave 33, devuelve el dato val14: ", abb_borrar(arbol2, "33") == val14);
print_test("Busco el nodo borrado con abb_pertenece, devuelve false: ", !abb_pertenece(arbol2, "33"));
print_test("Cantidad de arbol2 despues de borrar es 3: ", abb_cantidad(arbol2) == 3);
print_test("Cantidad de hojas arbol2 despues de borrar es 2: ", abb_contar_hojas(arbol2) == 2);
print_test("Guardo clave 30, val17 en arbol2: ", abb_guardar(arbol2, "30", val17));
print_test("Guardo clave -1, val18 en arbol2: ", abb_guardar(arbol2, "-1", val18));
print_test("Guardo clave -6, val19 en arbol2: ", abb_guardar(arbol2, "-6", val19));
print_test("Guardo clave 15, val20 en arbol2: ", abb_guardar(arbol2, "15", val20));
print_test("Cantidad de hojas arbol2 es 3: ", abb_contar_hojas(arbol2) == 3);
print_test("Borro nodo con un solo hijo, clave -1, devuelve el dato val18: ", abb_borrar(arbol2, "-1") == val18);
print_test("Busco el nodo borrado con abb_pertenece, devuelve false: ", !abb_pertenece(arbol2, "-1"));
print_test("Cantidad de arbol2 despues de borrar es 6: ", abb_cantidad(arbol2) == 6);
print_test("Cantidad de hojas arbol2 despues de borrar es 3: ", abb_contar_hojas(arbol2) == 3);
print_test("Borro nodo con un solo hijo, clave 30, devuelve el dato val17: ", abb_borrar(arbol2, "30") == val17);
print_test("Busco el nodo borrado con abb_pertenece, devuelve false: ", !abb_pertenece(arbol2, "30"));
print_test("Cantidad de arbol2 despues de borrar es 5: ", abb_cantidad(arbol2) == 5);
print_test("Cantidad de hojas arbol2 despues de borrar es 3: ", abb_contar_hojas(arbol2) == 3);
print_test("Guardo clave -7, val21 en arbol2: ", abb_guardar(arbol2, "-7", val21));
print_test("Guardo clave 0, val22 en arbol2: ", abb_guardar(arbol2, "0", val22));
print_test("Cantidad de hojas arbol2 es 4: ", abb_contar_hojas(arbol2) == 4);
print_test("Borro nodo con un dos hijos, clave 2, devuelve el dato val16: ", abb_borrar(arbol2, "2") == val16);
print_test("Busco el nodo borrado con abb_pertenece, devuelve false: ", !abb_pertenece(arbol2, "2"));
print_test("Cantidad de arbol2 despues de borrar es 6: ", abb_cantidad(arbol2) == 6);
print_test("Cantidad de hojas arbol2 despues de borrar es 3: ", abb_contar_hojas(arbol2) == 3);
print_test("Borro nodo raiz con un dos hijos, clave 52, devuelve el dato val12: ", abb_borrar(arbol2, "52") == val12);
print_test("Busco el nodo borrado con abb_pertenece, devuelve false: ", !abb_pertenece(arbol2, "52"));
print_test("Cantidad de arbol2 despues de borrar es 5: ", abb_cantidad(arbol2) == 5);
print_test("Cantidad de hojas arbol2 despues de borrar es 3: ", abb_contar_hojas(arbol2) == 2);
// Iterador externo
printf("Iterador inorder con funcion de impresion:\n");
abb_in_order(arbol2, printear, NULL);
// Iterador interno
abb_iter_t* iter_Auto = abb_iter_in_crear(arbol2);
int contador = 0;
while (!abb_iter_in_al_final(iter_Auto)){
abb_iter_in_avanzar(iter_Auto);
contador++;
}
print_test("Iterador interno recorre todos los elementos: ", abb_cantidad(arbol2) == contador);
abb_iter_in_destruir(iter_Auto);
abb_iter_t* iter2 = abb_iter_in_crear(arbol2);
print_test("Iterador interno (al final es false): ", !abb_iter_in_al_final(iter2));
clave = abb_iter_in_ver_actual(iter2);
clave_int = atoi(clave);
print_test("Iterador interno (-7): ", clave_int == -7);
abb_iter_in_avanzar(iter2);
clave = abb_iter_in_ver_actual(iter2);
clave_int = atoi(clave);
print_test("Iterador interno (avanzar (-6)): ", clave_int == -6);
abb_iter_in_avanzar(iter2);
clave = abb_iter_in_ver_actual(iter2);
clave_int = atoi(clave);
print_test("Iterador interno (avanzar (0)): ", clave_int == 0);
print_test("Iterador interno (al final es false): ", !abb_iter_in_al_final(iter2));
abb_iter_in_avanzar(iter2);
clave = abb_iter_in_ver_actual(iter2);
clave_int = atoi(clave);
print_test("Iterador interno (avanzar (15)): ", clave_int == 15);
abb_iter_in_avanzar(iter2);
clave = abb_iter_in_ver_actual(iter2);
clave_int = atoi(clave);
print_test("Iterador interno (avanzar (99)): ", clave_int == 99);
abb_iter_in_avanzar(iter2);
print_test("Iterador interno (avanzar, al final): ", !abb_iter_in_ver_actual(iter2));
print_test("Iterador interno (al final es true): ", abb_iter_in_al_final(iter2));
abb_iter_in_destruir(iter2);
// Destruir arbol
abb_destruir(arbol2); // Destruyo val20, val21, val15, val19, val22. Ya destrui val13
// Destruyo las listas que quedaron
//~ lista_destruir(val12, NULL);
//~ //lista_destruir(val13, NULL);
//~ lista_destruir(val14, NULL);
//~ lista_destruir(val16, NULL);
//~ lista_destruir(val17, NULL);
//~ lista_destruir(val18, NULL);
//~
// Nuevas pruebas
cola_t* val23 = cola_crear();
cola_t* val24 = cola_crear();
char* clave2 = "2";
char* clave3 = "3";
cola_encolar(val23, "a");
cola_encolar(val24, "d");
abb_t* arbol4 = abb_crear(*cmp, destruir_cola);
print_test("Cantidad de arbol4 es 0: ", abb_cantidad(arbol4) == 0);
print_test("Guardo clave 2 en la raiz de arbol4: ", abb_guardar(arbol4, clave2, val23));
print_test("Cantidad de arbol4 es 1: ", abb_cantidad(arbol4) == 1);
print_test("Prueba abb_obtener clave 2 es val23: ", abb_obtener(arbol4, clave2) == val23);
print_test("Borro clave 2: ", abb_borrar(arbol4, clave2) == val23);
print_test("Cantidad de arbol4 es 0: ", abb_cantidad(arbol4) == 0);
print_test("Prueba abb_obtener clave 2 es falso: ", !abb_obtener(arbol4, clave2));
print_test("Guardo clave 2 en la raiz de arbol4: ", abb_guardar(arbol4, clave2, val24));
print_test("Cantidad de arbol4 es 1: ", abb_cantidad(arbol4) == 1);
print_test("Prueba abb_obtener clave 2 es val24: ", abb_obtener(arbol4, clave2) == val24);
print_test("Reemplazo el valor de clave 2, en arbol4: ", abb_guardar(arbol4, clave2, val23));
print_test("Cantidad de arbol4 es 1: ", abb_cantidad(arbol4) == 1);
print_test("Prueba abb_obtener clave 2 es val23: ", abb_obtener(arbol4, clave2) == val23);
print_test("Borro clave 2: ", abb_borrar(arbol4, clave2) == val23);
print_test("Cantidad de arbol4 es 0: ", abb_cantidad(arbol4) == 0);
print_test("Prueba abb_obtener clave 2 es falso: ", !abb_obtener(arbol4, clave2));
print_test("Guardo clave 3, en arbol4: ", abb_guardar(arbol4, clave3, val23));
print_test("Cantidad de arbol4 es 1: ", abb_cantidad(arbol4) == 1);
print_test("Prueba abb_obtener clave 3 es val23: ", abb_obtener(arbol4, clave3) == val23);
print_test("Reemplazo clave 3, en arbol4: ", abb_guardar(arbol4, clave3, val24));
print_test("Cantidad de arbol4 es 1: ", abb_cantidad(arbol4) == 1);
print_test("Prueba abb_obtener clave 3 es val24: ", abb_obtener(arbol4, clave3) == val24);
print_test("Guardo clave 2 en la raiz de arbol4: ", abb_guardar(arbol4, clave2, val24));
print_test("Cantidad de arbol4 es 2: ", abb_cantidad(arbol4) == 2);
print_test("Prueba abb_obtener clave 2 es val24: ", abb_obtener(arbol4, clave2) == val24);
print_test("Borro clave 3: ", abb_borrar(arbol4, clave3) == val24);
print_test("Cantidad de arbol4 es 1: ", abb_cantidad(arbol4) == 1);
print_test("Prueba abb_obtener clave 3 es falso: ", !abb_obtener(arbol4, clave3));
//Modifico desde afuera clave2 (valor original "2"):
clave2 = "33";
// Sin embargo en el arbol sigue estando "2"
print_test("Prueba abb_obtener clave 2 es val24: ", abb_obtener(arbol4, "2") == val24);
print_test("Borro clave 2: ", abb_borrar(arbol4, "2") == val24);
print_test("Cantidad de arbol4 es 0: ", abb_cantidad(arbol4) == 0);
print_test("Prueba abb_obtener clave 2 es falso: ", !abb_obtener(arbol4, "2"));
abb_iter_t* iter4 = abb_iter_in_crear(arbol4);
abb_iter_in_destruir(iter4);
abb_iter_t* iter5 = abb_iter_in_crear(arbol4);
print_test("Iterador interno (actual NULL): ", !abb_iter_in_ver_actual(iter5));
print_test("Iterador interno (avanzar falso): ", !abb_iter_in_avanzar(iter5));
abb_iter_in_destruir(iter5);
//~ cola_destruir(val23, NULL);
//~ cola_destruir(val24, NULL);
//~
abb_destruir(arbol4);
}
