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);
}
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);
}
/* Llama a las funciones de destruccion necesarias */
void cerrar_maquina(maquina_votacion_t* maquina) {
if(maquina->padron)
lista_destruir(maquina->padron, votante_destruir);
maquina->padron = NULL;
if(maquina->listas)
lista_destruir(maquina->listas, destruir_partido);
maquina->listas = NULL;
if(maquina->cola)
cola_destruir(maquina->cola, votante_destruir);
maquina->cola = NULL;
/* Destruye la pila del ciclo de votacion */
if(maquina->ciclo)
pila_destruir(maquina->ciclo, free);
maquina->ciclo = NULL;
}
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);
}
void destruir_cola (void* cola){
cola_destruir(cola, NULL);
return;
}
