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_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_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); }
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_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); }
/* Crear maquina de votacion con respectivos TDAs Procesar comandos de entrada. */ int main() { maquina_votacion_t* maquina = malloc(sizeof(maquina_votacion_t)); if(!maquina) return 1; cola_t* cola = cola_crear(); if(!cola) { free(maquina); return 2; } maquina->estado = CERRADA; maquina->cola = cola; maquina->ciclo = NULL; maquina->listas = NULL; maquina->padron = NULL; maquina->votando_cargo = 0; COMANDOS_FUNCIONES[CMD_ABRIR] = comando_abrir; COMANDOS_FUNCIONES[CMD_INGRESAR] = comando_ingresar; COMANDOS_FUNCIONES[CMD_CERRAR] = comando_cerrar; COMANDOS_FUNCIONES[CMD_VOTAR] = comando_votar; leer_entrada(maquina); cerrar_maquina(maquina); free(maquina); return 0; }
void pruebas_cola_vacia(){ printf("***** Inicio de pruebas cola vacia *****\n"); cola_t* cola = cola_crear(); print_test("cola creada con exito ",cola!=NULL); print_test("cola esta vacia ",cola_esta_vacia(cola)); print_test("cola ver primero devuelve NULL", !cola_ver_primero(cola)); print_test("cola desencolar devuelve NULL", !cola_desencolar(cola)); cola_destruir(cola,NULL); }
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_vacia() { printf("\nINICIO DE PRUEBAS CON COLA VACIA\n"); /* Declaro las variables a utilizar*/ cola_t* cola = cola_crear(); /* Inicio de pruebas */ print_test("Prueba crear cola", cola != NULL); print_test("Prueba cola esta vacia despues de crearla", cola_esta_vacia(cola)); print_test("Prueba ver primero cola vacia", !cola_ver_primero(cola)); print_test("Prueba desencolar cola vacia", !cola_desencolar(cola)); /* Destruyo la cola */ cola_destruir(cola, NULL); print_test("La cola fue destruida", true); }
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_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); }