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);
}
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_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);
}
/* 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);
}
// Destruye la cola. Si se recibe la función destruir_dato por parámetro,
// para cada uno de los elementos de la cola llama a destruir_dato.
// Pre: la cola fue creada. destruir_dato es una función capaz de destruir
// los datos de la cola, o NULL en caso de que no se la utilice.
// Post: se eliminaron todos los elementos de la cola.
void cola_destruir(cola_t *cola, void destruir_dato(void*))
{
while (!cola_esta_vacia(cola))
if (destruir_dato != NULL)
destruir_dato(cola_desencolar(cola));
else
cola_desencolar(cola);
free(cola);
}
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_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 cola_destruir(cola_t *cola, void destruir_dato(void*)){
void* acceso_dato;
while (!cola_esta_vacia(cola)){
acceso_dato = cola_desencolar(cola);
if (destruir_dato != NULL)
destruir_dato(acceso_dato);
}
free (cola);
}
/*
Desencolar y realizar validacion del Documento tipo/numero del votante y no haber votado
Crear pila para ciclo de votacion actual
*/
bool comando_votar_inicio(maquina_votacion_t* maquina) {
#ifdef DEBUG
printf("Comando votar inicio ejecutado.\n");
#endif
// Error handling
if(maquina->estado == CERRADA) { return error_manager(MESA_CERRADA); }
if(maquina->estado == VOTACION) { return error_manager(OTRO); }
if(cola_esta_vacia(maquina->cola)) { return error_manager(NO_VOTANTES); }
votante_t* votante_padron = NULL;
bool enpadronado = false;
votante_t* votante_espera = cola_desencolar(maquina->cola);
if(!votante_espera) return error_manager(OTRO);
#ifdef DEBUG
printf("Votante desencolado: %s, %s\n", votante_espera->documento_tipo, votante_espera->documento_numero);
#endif
pila_t* ciclo_votacion = pila_crear();
lista_iter_t* lista_iter = lista_iter_crear(maquina->padron);
if(!ciclo_votacion || !lista_iter) {
if(ciclo_votacion) pila_destruir(ciclo_votacion, NULL);
if(lista_iter) free(lista_iter);
return error_manager(OTRO);
}
while(!lista_iter_al_final(lista_iter))
{
votante_padron = lista_iter_ver_actual(lista_iter);
if(votante_iguales(votante_padron, votante_espera))
{
enpadronado = true;
break;
}
lista_iter_avanzar(lista_iter);
}
lista_iter_destruir(lista_iter);
votante_destruir(votante_espera);
if(!enpadronado || votante_get_voto_realizado(votante_padron))
{
pila_destruir(ciclo_votacion, NULL);
return enpadronado ? error_manager(VOTO_REALIZADO) : error_manager(NO_ENPADRONADO);
}
votante_set_voto_realizado(votante_padron);
maquina->estado = VOTACION;
maquina->ciclo = ciclo_votacion;
maquina->votando_cargo = PRESIDENTE;
mostrar_menu_votacion(maquina);
return true;
}
void cola_destruir(cola_t *cola, void destruir_dato(void*))
{
while( !cola_esta_vacia(cola) )
{
void *dato = cola_desencolar(cola);
if( destruir_dato )
destruir_dato(dato);
}
free(cola);
}
void cola_destruir(cola_t *cola, void destruir_dato(void *)){
if (cola==NULL) return;
if (cola->prim == NULL){
free(cola);
return;
}
void* borrado;
int i;
for (i=0; i<cola->tamanio; i++){
borrado = cola_desencolar(cola);
if (destruir_dato!= NULL){
destruir_dato(borrado);
}
}
free(cola);
}
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);
}
// Destruye la cola. Si se recibe la función destruir_dato por parámetro,
// para cada uno de los elementos de la cola llama a destruir_dato.
// Pre: la cola fue creada. destruir_dato es una función capaz de destruir
// los datos de la cola, o NULL en caso de que no se la utilice.
// Post: se eliminaron todos los elementos de la cola.
void cola_destruir(cola_t *cola, void destruir_dato(void*)){
if (destruir_dato == NULL){
while (cola->primero != NULL){
cola_desencolar(cola);
}
}
else{
while (cola->primero != NULL){
nodo_cola_t *nodo = cola->primero;
cola->primero = cola->primero->proximo;
destruir_dato(nodo->dato);
free(nodo);
}
}
free(cola);
}
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);
}
