int listar_fabricas(base_t* base,bool imprimir){
int hora,minutos;
fabrica_t* fabrica;
fabrica_t* anterior;
if (lista_esta_vacia(base->fabricasavisitar)){
//creo una lista con las fabricas que voy a visitar
anterior = heap_desencolar(base->cerradofabricas);
lista_insertar_ultimo(base->fabricasavisitar,(void*)anterior);
while (!heap_esta_vacio(base->cerradofabricas)){
fabrica = heap_desencolar(base->cerradofabricas);
if (fabrica->horarioentrada>=anterior->horariosalida){
lista_insertar_ultimo(base->fabricasavisitar,(void*)fabrica);
anterior = fabrica;
}
}
}
if (imprimir){
printf("Cantidad: %zu\n",lista_largo(base->fabricasavisitar));
lista_iter_t* iterador = lista_iter_crear(base->fabricasavisitar);
while(!lista_iter_al_final(iterador)){
fabrica = lista_iter_ver_actual(iterador);
conversion_horario(&hora,&minutos,fabrica->horarioentrada);
printf("%s,%02d:%02d,",fabrica->idfabrica,hora,minutos);
conversion_horario(&hora,&minutos,fabrica->horariosalida);
printf("%02d:%02d\n",hora,minutos);
lista_iter_avanzar(iterador);
}
lista_iter_destruir(iterador);
}
return 0;
}
int agregar_juguete(base_t* base,char* idfabrica,char* idjuguete,char* valor,char* peso){
if (!hash_pertenece(base->fabricas,idfabrica)) return -1; //verifico si la fabrica existe
//creo el juguete
juguete_t* juguete = crear_juguete(idjuguete,valor,peso);
if (juguete==NULL) return -2; //no se pudo crear el juguete
fabrica_t* fabrica = hash_obtener(base->fabricas,idfabrica);
if (lista_insertar_ultimo(fabrica->juguetes,(void*)juguete)!=true) return -3; //agrego el juguete y verifico si se pudo
return 0;
}
bool agregar_pedido(vector_t *vectorzonas, pedido_t* pedido)
{
if (pedido==NULL)
return false;
int i;
i=pedido->zona;
lista_t* listaaux=vector_obtener(vectorzonas, i-1);
lista_insertar_ultimo(listaaux,pedido);
printf("Se agrego el pedido %s en la zona %d \n",pedido->nombre,i);
return true;
}
int inscribir(char* padron, char* idc, base_t* basedatos){
int pos = existe_curso(idc,basedatos->listadecursos);
if (pos==-1) return -2;
char* anotar = malloc(LPADRON*sizeof(char));
strcpy(anotar,padron);
curso_t* curso = conseguir_curso(idc,basedatos->listadecursos);
if (alumno_inscripto(anotar,curso->inscriptos)!=-1){
free(anotar);
return -1;
}
lista_insertar_ultimo(curso->inscriptos,anotar);
if (curso->vacantes<lista_largo(curso->inscriptos)) return 2;
return 1;
}
bool agregar_votante( mesa_t* mesa_de_votos, char* tipo_dni, char* numero_dni )
{
int iDNI = atoi(numero_dni);
votante_t* votante_nuevo;
if( (votante_nuevo = malloc(sizeof(votante_t))) == NULL )
return false;
votante_nuevo->tipoDNI = strdup(tipo_dni);
votante_nuevo->numeroDNI = iDNI;
votante_nuevo->voto_realizado = false;
lista_insertar_ultimo(mesa_de_votos->personas_a_votar, votante_nuevo);
return true;
}
bool lista_iter_insertar(lista_iter_t *iter, void *dato){
bool res;
if (iter->actual == iter->lista->primero){
res = lista_insertar_primero(iter->lista, dato);
iter->actual = iter->lista->primero ;
return res;
}
if(lista_iter_al_final(iter)){
res = lista_insertar_ultimo(iter->lista, dato);
iter->actual = iter->lista->ultimo;
return res;
}
nodo_t* nodo = nodo_crear(dato);
if (!nodo) return false;
nodo->siguiente = iter->actual;
iter->actual = nodo;
iter->anterior->siguiente = nodo;
iter->lista->largo++ ;
return true;
}
bool almacenar(hash_t* hash, lista_t** tabla, daton_t* paquete, unsigned long largo){
bool resu;
unsigned long indice = fh(paquete->clave, largo );
if (!tabla[indice]){
tabla[indice] = lista_crear();
}
lista_iter_t* iter_l = busqueda(tabla[indice], paquete->clave);
if (lista_iter_al_final(iter_l)) { //no lo encontro
resu = lista_insertar_primero(tabla[indice], paquete);
hash->tam++;
lista_iter_destruir(iter_l);
return resu;
}
daton_t* aux = lista_iter_borrar(iter_l);
free(aux->clave);
if (hash->destruir_dato) hash->destruir_dato(aux->dato);
free(aux);
resu = lista_insertar_ultimo(tabla[indice], paquete);
lista_iter_destruir(iter_l);
return resu;
}
bool lista_insertar(lista_t *lista, lista_iter_t *iter, void *dato) {
// Si estoy en la primera posición del iterador
if (!iter->anterior) {
if (lista_insertar_primero(lista, dato)) iter->actual = lista->inicio;
else return false;
}
// Si estoy en la última posición del iterador
else if (lista_iter_al_final(iter)) {
if (lista_insertar_ultimo(lista, dato)) iter->actual = lista->fin;
else return false;
}
// Si estoy en cualquier otra posición del iterador
else {
nodo_t* nodo = nodo_crear(dato);
if (!nodo) return false;
iter->anterior->siguiente = nodo;
nodo->siguiente = iter->actual;
iter->actual = nodo;
lista->largo++;
}
return true;
}
// Inserta un nuevo elemento a la lista en la posicion del iterador,
// devuelve falso en caso de error.
// Pre: la lista y el iterador fueron creados.
// Post: se insertó un nuevo elemento en la lista.
bool lista_insertar(lista_t *lista, lista_iter_t *iter, void *dato)
{
/* Creamos una variable para verificar que, en caso de ser usadas,
* insertar_primero o insertar_ultimo funcionaron correctamente */
bool exito = true;
/* Si el iterador está al principio de la lista o la lista
* está vacía, insertamos en el primero */
if (!iter->anterior && (exito = lista_insertar_primero(lista, dato))){
iter->actual = lista->primero;
return true;
}
/* Si el iterador está al final de la lista insertamos en el ultimo */
if (lista_iter_al_final(iter) && (exito = lista_insertar_ultimo(lista, dato))){
iter->actual = lista->ultimo;
return true;
}
/* El iterador no está al final ni al principio de la lista */
if (exito){
/* Creamos el nuevo nodo con el dato a insertar */
nodo_t* nodo_nuevo = crear_nodo(dato);
if (!nodo_nuevo)
return false;
/* Ubicamos el nuevo nodo en la posicion en donde se
* encontraba el iterador, iter->actual pasa a ser el nuevo
* nodo insertado e iter->anterior se mantiene constante */
nodo_nuevo->prox = iter->actual;
iter->actual = nodo_nuevo;
iter->anterior->prox = nodo_nuevo;
lista->cantidad++;
return true;
}
/* lista_insertar_primero o lista_insertar_ultimo devolvió false */
return false;
}
void registrar_pedido(vector_t* vectorzonas){
bool resultado;
pedido_t *pedido=malloc(sizeof(pedido_t));
lista_t *listaaux;
if (pedido==NULL){
printf("Ocurrio un error, pruebe de vuelta\n");
return;
};
int cantidad=vector_obtener_cantidad(vectorzonas);
printf("Ingrese la zona del cliente:\n");
scanf("%d", &(pedido->zona));
while ((pedido->zona)<1 || (pedido->zona)> cantidad){
printf ("la zona tiene que se del 1 al %d. Ingresela de vuelta\n",cantidad);
scanf("%d", &(pedido->zona));
}
printf("A continuacion ingrese el nombre del cliente:\n");
scanf("%s", pedido->nombre);
printf("Ahora ingrese la cantidad de pizzas pedidas:\n");
scanf("%d", &(pedido->cantidad));
while ((pedido->cantidad)<1 || (pedido->cantidad)> 5){
printf ("la cantidad tiene que se del 1 al 5. Ingresela de vuelta\n");
scanf("%d", &(pedido->cantidad));
}
pedido->preparado=false;
listaaux = (lista_t*) vector_obtener(vectorzonas,pedido->zona-1);
resultado=lista_insertar_ultimo(listaaux, pedido);
if (resultado==false){
printf("Error al ingresar pedido\n");
}else {
printf("Se agrego el pedido correctamente\n");
}
}
int sesion_inscribir(char* idc,base_t* basedatos, sesion_t* sesion){
//verifico si hay sesion iniciada
if (strcmp(sesion->padron,"00000")==0) return -3;
//verifico si existe el curso
int pos = existe_curso(idc,basedatos->listadecursos);
if (pos==-1) return -2;
//verifico si ya estaba programada la inscripcion
bool yaanotado = false;
inscripcion_t* inscripcion;
lista_iter_t* iterador = lista_iter_crear(sesion->inscripciones);
while(!lista_iter_al_final(iterador) && !yaanotado){
inscripcion = (inscripcion_t*)lista_iter_ver_actual(iterador);
if (strcmp(inscripcion->curso,idc)==0) yaanotado=true;
lista_iter_avanzar(iterador);
}
lista_iter_destruir(iterador);
if (yaanotado==true) return -4;
//consigo el curso
int i;
iterador = lista_iter_crear(basedatos->listadecursos);
for(i=0;i<pos;i++) lista_iter_avanzar(iterador);
curso_t* curso = (curso_t*) lista_iter_ver_actual(iterador);
lista_iter_destruir(iterador);
//verifico si ya esta anotado en el curso
if (alumno_inscripto(sesion->padron,curso->inscriptos)!=-1) return -1;
//creo la inscripcion
inscripcion = malloc(sizeof(inscripcion_t));
if (inscripcion==NULL) return -5;
//programo la inscripcion
inscripcion->curso = malloc(LIDC*sizeof(char));
strcpy(inscripcion->curso,idc);
((curso->vacantes)>lista_largo(curso->inscriptos)) ? (inscripcion->estado=false) : (inscripcion->estado=true);
lista_insertar_ultimo(sesion->inscripciones,inscripcion);
if (inscripcion->estado) return 1;
return 2;
}
int agregar_curso(char* idc,char* descripcion,char* materia,char* vacantes, base_t* basedatos){
if (existe_curso(idc,basedatos->listadecursos)!=-1) return -1;
curso_t* curso = crear_curso(idc,descripcion,materia,vacantes);
lista_insertar_ultimo(basedatos->listadecursos,curso);
return 0;
}
/* Pruebas */
void prueba_tipos() {
// Declaro de variables
lista_iter_t *iter;
lista_t* lista;
alumno_t* alumno1;
alumno_t* alumno2;
alumno_t* alumno3;
int padron1=94111;
int padron2=77777;
int padron3=10104;
// las inicializo
lista = lista_crear();
alumno1=alumno_crear(padron1);
alumno2=alumno_crear(padron2);
alumno3=alumno_crear(padron3);
printf("---------------------------PRUEBAS---------------------------\n");
//pruebo que este vacia
print_test("Pruebo que la lista se crea vacía", lista_esta_vacia(lista) );
//inserto 1er elemento
print_test("Inserto primer elemento alumno1", lista_insertar_primero(lista,alumno1) );
//inserto ultimo
print_test("Inserto ultimo elemento alumno2", lista_insertar_ultimo(lista,alumno2) );
//inesrto un nuevo ultimo
print_test("Inserto ultimo elemento alumno3", lista_insertar_ultimo(lista,alumno3) );
//veo el primero
print_test("Veo el primer elemento(alumno1)", alumno1==lista_ver_primero(lista));
//borro el primero y veo devuelta
print_test("Borro el primero", lista_borrar_primero(lista));
print_test("Veo el primer elemento(alumno2)", alumno2==lista_ver_primero(lista));
//veo el largo de la lista
print_test("Veo el largo de la lista (2)", 2==lista_largo(lista));
//creo iterador
iter= lista_iter_crear(lista);
//pruebas del iterador
print_test("Hago avanza al iterador", lista_iter_avanzar(iter));
print_test("Veo elemento actual del iterador (alumno3)", alumno3==lista_iter_ver_actual(iter));
print_test("Hago avanza al iterador", lista_iter_avanzar(iter));
print_test("Veo si esta al final", lista_iter_al_final(iter));
//pruebas de lista junto con iterador
print_test("Inserto de nuevo alumno1", lista_insertar(lista,iter,alumno1));
print_test("Lo borro", alumno1==lista_borrar(lista,iter));
//inserto 1er elemento
print_test("Inserto primer elemento alumno1", lista_insertar_primero(lista,alumno1) );
//destruyo el iterador
lista_iter_destruir(iter);
//creo iterador
iter= lista_iter_crear(lista);
print_test("Destruyo iterador,lo creo devuelta y borro el primer elemento (alumno1)", alumno1==lista_borrar(lista,iter));
destruir_dato(alumno1);
//destruyo lista e iterador
lista_iter_destruir(iter);
lista_destruir(lista,destruir_dato);
}
void lista_prueba(){
//Pruebo crear listas
lista_t* lista1 = lista_crear();
lista_t* lista2 = lista_crear();
lista_t* lista3 = lista_crear();
print_test("Probando si lista1 se creo bien", lista1!=NULL);
print_test("Probando si lista1 esta vacia", lista_esta_vacia(lista1));
print_test("Probando si el largo de lista2 es 0", lista_largo(lista2)==0);
int vector[]={ 1, 2, 3, 4};
char vector2[]="hola que tal";
// Probando insertar en la lista;
print_test("Probando si se inserta al principio un elemento en la lista1", lista_insertar_primero(lista1, &vector));
print_test("Probando si se inserta al final un elemento en la lista1", lista_insertar_ultimo(lista1, &vector2));
// Probando el largo de la lista con 2 elementos
print_test("Probando que el largo de la lista1 sea dos", lista_largo(lista1)==2);
// Probando el lista borrar primero en la lista 1
print_test("Probando si se borra el primer elemento en la lista1", lista_borrar_primero(lista1) == vector);
// Probando el lista ver primero
print_test("Probando ver el primero de la lista 1", lista_ver_primero(lista1) == vector2 );
// Probando agregar al principio en lista 3
print_test("Probando si se inserta al principio un elemento en la lista3", lista_insertar_primero(lista3, &vector));
lista_insertar_ultimo(lista3, &vector2);
// PRUEBAS CON EL ITERADOR CON LA LISTA 3
lista_iter_t* iter = lista_iter_crear(lista3);
// Probando el iter avanzar
print_test("Probando el iter avanzar", lista_iter_avanzar(iter));
// Probando el iter ver actual
print_test("Probando el iter ver actual", lista_iter_ver_actual(iter) == vector2);
// Probando el iter al final
print_test("Probando el iter avanzar", lista_iter_avanzar(iter));
print_test("Probando el iter avanzar (no puede avanzar mas)", lista_iter_avanzar(iter) == false);
print_test("Probando el iter al final", lista_iter_al_final(iter));
print_test("Probando si el iter esta el final el ver_actual", lista_iter_ver_actual(iter) == NULL);
lista_iter_destruir(iter);
// Probando lista_insertar con iterador
lista_iter_t* iter2 = lista_iter_crear(lista2);
char vector3[]="chau";
print_test("Probando el lista_insertar en la lista con el iter", lista_insertar(lista2,iter2,&vector3));
print_test("Probando ver el primero de la lista2", lista_ver_primero(lista2) == &vector3 );
print_test("Probando borrar con el iter", lista_borrar(lista2,iter2) == vector3 );
print_test("Probando el lista_ver_primero con los nodos borrados", lista_ver_primero(lista2) == NULL );
print_test("Probando el largo de una lista vacia", lista_largo(lista2) == 0 );
print_test("Probando el lista_borrar_primero en una lista vacia", lista_borrar_primero(lista2) == NULL );
lista_iter_destruir(iter2);
// Pruebo Agregar 30 Datos y luego borrarlos
for ( int i=0 ; i < 30 ; i++){
lista_insertar_ultimo(lista2, &i);
}
print_test("Probando el largo de la lista2 luego de agregar 30 elementos", lista_largo(lista2) == 30);
lista_iter_t* iter3=lista_iter_crear(lista2);
while (!lista_iter_al_final(iter3)){
lista_borrar(lista2,iter3);
}
print_test("Probando que se borraron todos los elementos" , lista_largo(lista2) == 0);
print_test("Prubando borrar un elemento en una lista vacia" , lista_borrar(lista2,iter3) == NULL);
lista_iter_destruir(iter3);
//Finalmente, pruebo si estan vacias las 3 listas
print_test( "Probando que la lista1 no este vacia", lista_esta_vacia(lista1) == false );
print_test( "Probando que la lista2 este vacia", lista_esta_vacia(lista2) );
print_test( "Probando que la lista3 no este vacia", lista_esta_vacia(lista3) == false );
//Elimino las 3 listas
lista_destruir(lista1, NULL);
lista_destruir(lista2, NULL);
lista_destruir(lista3, NULL);
/* ******************************************************************
* Pruebas con lista 4
* *****************************************************************/
//Creo otra lista y le inserto 10 nodos
lista_t* lista4 = lista_crear();
for( int num=1; num <= 10 ; num++){
int elemento=1;
lista_insertar_ultimo(lista4 , &elemento);
}
print_test("Probando largo de la lista 4", lista_largo(lista4) == 10 );
lista_iter_t* iter4= lista_iter_crear(lista4);
print_test("Probando que se creo el iter 4", iter4!=NULL);
print_test("Probando que el iter 4 no este al final", lista_iter_al_final(iter4) == false);
for (int j=1; j<=10; j++){
lista_iter_avanzar(iter4);
}
print_test("Probando que el iter 4 este al final", lista_iter_al_final(iter4));
char prueba[] = "prueba";
print_test("Probando lista_insertar con el iter al final ", lista_insertar(lista4, iter4, &prueba));
print_test("Probando que el iter 4 no este al final", lista_iter_al_final(iter4) == false);
print_test("Probando avanzar con el iter 4 al final", lista_iter_avanzar(iter4));
print_test("Probando lista_borrar con el iter 4 al final", lista_borrar(lista4,iter4) == NULL);
print_test("Probando lista_insertar con el iter 4 al final ", lista_insertar(lista4, iter4, &prueba));
print_test("Probando lista_borrar con el iter 4", lista_borrar(lista4,iter4) == prueba);
for (int j=0; j<=10; j++){
lista_borrar_primero(lista4);
}
print_test("Probando largo de la lista 4", lista_largo(lista4) == 0 );
// elimino el iter 4
lista_iter_destruir(iter4);
//Elimino la lista
lista_destruir(lista4, free);
/* ******************************************************************
* Pruebas con lista 5
* *****************************************************************/
//Creo otra lista y le inserto 10 nodos
lista_t* lista5 = lista_crear();
// le creo un iter
lista_iter_t* iter5= lista_iter_crear(lista5);
print_test("Probando que se creo el iter 5", iter5!=NULL);
for( int num=1; num <= 10 ; num++){
char elemento2[]="hola";
lista_insertar(lista5, iter5, &elemento2);
}
print_test("Probando largo de la lista 5", lista_largo(lista5) == 10 );
print_test("Probando que el iter 5 no este al final", lista_iter_al_final(iter5) == false);
char prueba2[] = "prueba";
print_test("Probando lista_borrar con el iter 5 al principio", lista_borrar(lista5,iter5) != NULL);
print_test("Probando lista_insertar con el iter 5 al principio", lista_insertar(lista5, iter5, &prueba2));
print_test("Probando lista_borrar con el iter 5 ", lista_borrar(lista5,iter5) == prueba2);
for (int j=0; j<=10; j++){
lista_borrar(lista5, iter5);
}
print_test("Probando largo de la lista 5", lista_largo(lista5) == 0 );
print_test("Probando que la lista 5 este vacia", lista_esta_vacia(lista5));
print_test("Probando lista ver_primero de la lista 5", lista_ver_primero(lista5) == NULL);
print_test("Probando avanzar con el iter 5 al final", lista_iter_avanzar(iter5) == false);
print_test("Probando avanzar con el iter 5 al final", lista_iter_ver_actual(iter5) == NULL);
// elimino el iter 5
lista_iter_destruir(iter5);
//Elimino la lista
lista_destruir(lista5, free);
/* ******************************************************************
* Pruebas con lista 6
* *****************************************************************/
// Creo una nueva Lista
lista_t* lista6 = lista_crear();
// le creo un iter
lista_iter_t* iter6= lista_iter_crear(lista6);
print_test("Probando que se creo el iter 6", iter6!=NULL);
void* elemento = malloc(sizeof(void*)) ;
print_test("Probando agregar un elemento con lista_insertar con la lista 6 vacia", lista_insertar(lista6, iter6, elemento));
print_test("Probando largo de la lista 6", lista_largo(lista6) == 1 );
print_test("Probando que el iter 6 no este al final", lista_iter_al_final(iter6) == false);
print_test("Probando si puedo avanzar con el iter 6", lista_iter_avanzar(iter6));
print_test("Probando que el iter 6 este al final", lista_iter_al_final(iter6));
void* borrar=lista_borrar_primero(lista6);
free(borrar);
// elimino el iter 6
lista_iter_destruir(iter6);
//Elimino la lista 6
lista_destruir(lista6, free);
/* ******************************************************************
* Pruebas con lista 7
* *****************************************************************/
lista_t* lista7 = lista_crear();
for (int x=1 ; x<=10 ; x++){
lista_insertar_primero(lista7, &x);
}
lista_iter_t* iter7 = lista_iter_crear(lista7);
print_test("Probando que el largo de la lista7 sea 10", lista_largo(lista7) == 10);
while (!lista_iter_al_final(iter7)){
lista_iter_avanzar(iter7);
}
void* y;
print_test("Probando si se puede ver el elemento actual del iter", lista_iter_ver_actual(iter7) == NULL);
print_test("Probando insetar un elemento al final de la lista7", lista_insertar(lista7, iter7, &y));
print_test("Probando que el largo de la lista7 sea 11", lista_largo(lista7) == 11);
print_test("Probando borrar el ultimo elemento de lista7", lista_borrar(lista7,iter7) == &y);
print_test("Probando que el largo de la lista7 sea 10", lista_largo(lista7) == 10);
print_test("Probando insetar un elemento al final de la lista7", lista_insertar(lista7, iter7, &y));
print_test("Probando que el iter7 no quede al final", lista_iter_al_final(iter7) == false);
lista_iter_destruir(iter7);
lista_destruir(lista7, NULL);
/* ******************************************************************
* Pruebas con lista 8
* *****************************************************************/
lista_t* lista8 = lista_crear();
for (int x=1 ; x<=5 ; x++){
lista_insertar_ultimo(lista8, &x);
}
print_test("Probando que el largo de la lista8 sea 5", lista_largo(lista8) == 5);
lista_iter_t* iter8 = lista_iter_crear(lista8);
int elem=0;
print_test("Probando que el elemento actual del iter8 no es null", lista_iter_ver_actual(iter8) != NULL);
print_test("Probando insertar al principio con el iter en lista8", lista_insertar(lista8, iter8, &elem));
print_test("Probando que el largo de lista8 sea 6", lista_largo(lista8) == 6);
print_test("Probando eliminar el primer elemento de la lista8 con el iter", lista_borrar(lista8, iter8) == &elem);
print_test("Probado que el largo de la lista8 es 5", lista_largo(lista8) == 5);
print_test("Probando insertar un elemento en la primera posicion de lista8", lista_insertar_primero(lista8, &elem));
print_test("Probando que el actual del iter8 sea distinto que el primero de lista8", lista_ver_primero(lista8) != lista_iter_ver_actual(iter8));
lista_iter_destruir(iter8);
lista_destruir(lista8 , NULL);
/* ******************************************************************
* Pruebas con lista 9
* *****************************************************************/
lista_t* lista9 = lista_crear();
int num;
print_test("Probando insertar el elemento en la lista9", lista_insertar_primero(lista9, &num));
print_test("Probando que el largo de lista9 es 1", lista_largo(lista9));
lista_iter_t* iter9 = lista_iter_crear(lista9);
print_test("Probando que el elemento actual del iter9 no es null", lista_iter_ver_actual(iter9) != NULL);
print_test("Probando borrar el elemento de lista9 con el iter", lista_borrar(lista9, iter9) == &num);
print_test("Probando que el largo de lista9 es 0", lista_largo(lista9) == 0);
print_test("Probando borrar un elemento de la lista9 que esta vacia", lista_borrar(lista9, iter9) == NULL);
print_test("Probando avanzar en lista9 que esta vacia", lista_iter_avanzar(iter9) == false);
print_test("Probando agregar un elemento con el iter9", lista_insertar(lista9, iter9, &num));
print_test("Probando eliminar el ultimo elemento con el iter9", lista_borrar(lista9, iter9) == &num);
print_test("Probando agregar un elemento en la lista9", lista_insertar_primero(lista9, &num));
print_test("Probando eliminar el ultimo elemento con borrar primero", lista_borrar_primero(lista9) == &num);
lista_iter_destruir(iter9);
lista_destruir(lista9 , NULL);
lista_t* lista10= lista_crear();
int i=0;
print_test("Probando agregar un elemento a lista10", lista_insertar_primero(lista10 , &i));
print_test("Probando eliminar primer elemento", lista_borrar_primero(lista10) != NULL);
lista_destruir(lista10, NULL);
}
mesa_t* abrir_mesa(char *mesa_electoral, char *padron)
{
mesa_t* la_mesa;
if( !(la_mesa = malloc(sizeof(mesa_t))) )
return NULL;
la_mesa->estado = false;
la_mesa->boletas_en_mesa = lista_crear();
la_mesa->personas_a_votar = lista_crear();
la_mesa->padron = lista_crear();
if( !la_mesa->boletas_en_mesa || !la_mesa->personas_a_votar || !la_mesa->padron )
{
fprintf(stderr, "ERROR1\n");
return NULL;
}
if( mesa_electoral == NULL || padron == NULL )
{
fprintf(stderr, "ERROR1\n");
lista_destruir(la_mesa->boletas_en_mesa, NULL);
lista_destruir(la_mesa->personas_a_votar, NULL);
lista_destruir(la_mesa->padron, NULL);
free(la_mesa);
return NULL;
}
FILE *postulantes, *votantes;
if( !(postulantes = fopen(mesa_electoral, "r")) )
{
fprintf(stderr, "ERROR2\n");
lista_destruir(la_mesa->personas_a_votar, NULL);
lista_destruir(la_mesa->boletas_en_mesa, NULL);
lista_destruir(la_mesa->padron, NULL);
free(la_mesa);
return NULL;
}
if( !(votantes = fopen(padron, "r")) )
{
fprintf(stderr, "ERROR2\n");
fclose(postulantes);
lista_destruir(la_mesa->personas_a_votar, NULL);
lista_destruir(la_mesa->boletas_en_mesa, NULL);
lista_destruir(la_mesa->padron, NULL);
free(la_mesa);
return NULL;
}
char *linea_fixeada;
fila_csv_t* parseado;
while( (linea_fixeada = leer_linea(postulantes)) != NULL )
{
parseado = parsear_linea_csv(linea_fixeada, 5);
boleta_t* nueva_boleta;
if( ( nueva_boleta = malloc(sizeof(boleta_t)) ) == NULL )
{
lista_destruir(la_mesa->boletas_en_mesa, NULL);
lista_destruir(la_mesa->personas_a_votar, NULL);
lista_destruir(la_mesa->padron, NULL);
fclose(postulantes);
fclose(votantes);
free(la_mesa);
return NULL;
}
nueva_boleta->IDpartido = atoi(obtener_columna(parseado, 0));
nueva_boleta->nombrePartido = strdup(obtener_columna(parseado, 1));
nueva_boleta->presidente = strdup(obtener_columna(parseado, 2));
nueva_boleta->gobernador = strdup(obtener_columna(parseado, 3));
nueva_boleta->intendente = strdup(obtener_columna(parseado, 4));
nueva_boleta->votos_recibidos[0] = 0;
nueva_boleta->votos_recibidos[1] = 0;
nueva_boleta->votos_recibidos[2] = 0;
lista_insertar_ultimo(la_mesa->boletas_en_mesa, nueva_boleta);
destruir_fila_csv(parseado, false);
}
while( (linea_fixeada = leer_linea(votantes)) != NULL )
{
parseado = parsear_linea_csv(linea_fixeada, 2);
votante_t* nuevo_votante;
if( ( nuevo_votante = malloc(sizeof(votante_t)) ) == NULL )
{
lista_destruir(la_mesa->boletas_en_mesa, destruir_boleta);
lista_destruir(la_mesa->personas_a_votar, NULL);
lista_destruir(la_mesa->padron, NULL);
fclose(postulantes);
fclose(votantes);
free(la_mesa);
return NULL;
}
nuevo_votante->tipoDNI = strdup(obtener_columna(parseado, 0));
nuevo_votante->numeroDNI = atoi((obtener_columna(parseado, 1)));
nuevo_votante->voto_realizado = false;
lista_insertar_ultimo(la_mesa->padron, nuevo_votante);
destruir_fila_csv(parseado, false);
}
fclose(votantes);
fclose(postulantes);
return la_mesa;
}
/* 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);
}
