void pruebas_cola_con_elementos() { printf("\nINICIO DE PRUEBAS CON COLA CON ELEMENTOS\n"); /* Declaro las variables a utilizar*/ cola_t* cola = cola_crear(); int a = 1, b = 2, c = 3, d = 4, e = 5; int* p_a = &a; int* p_b = &b; int* p_c = &c; int* p_d = &d; int* p_e = &e; /* Inicio de pruebas */ print_test("Prueba encolar &a", cola_encolar(cola, p_a)); print_test("Prueba encolar &b", cola_encolar(cola, p_b)); print_test("Prueba encolar &c", cola_encolar(cola, p_c)); print_test("Prueba encolar &d", cola_encolar(cola, p_d)); print_test("Prueba encolar &e", cola_encolar(cola, p_e)); print_test("Prueba ver primero igual a &a", cola_ver_primero(cola) == p_a); print_test("Prueba cola NO esta vacia despues de encolar", !cola_esta_vacia(cola)); print_test("Prueba desencolar igual a &a", cola_desencolar(cola) == p_a); print_test("Prueba desencolar igual a &b", cola_desencolar(cola) == p_b); print_test("Prueba desencolar igual a &c", cola_desencolar(cola) == p_c); print_test("Prueba desencolar igual a &d", cola_desencolar(cola) == p_d); print_test("Prueba desencolar igual a &e", cola_desencolar(cola) == p_e); print_test("Prueba cola esta vacia despues de desencolar todos", cola_esta_vacia(cola)); /* Destruyo la cola */ cola_destruir(cola, NULL); print_test("La cola fue destruida", true); }
void pruebas_encolar_desencolar(){ printf("\n ***Inicio de pruebas cola_encolar cola_desencolar *** \n"); int a=3; int b=1; cola_t* cola = cola_crear(); print_test("Encolo el elemento 3 cola2",cola_encolar(cola,&a)); print_test("La cola no esta vacia",!cola_esta_vacia(cola)); print_test("Encolo el elemento 1 cola2",cola_encolar(cola,&b)); print_test("Encolo el numero 3 cola2",cola_encolar(cola,&a)); print_test("Ver primero me devuelve 3 ",*(int*)cola_ver_primero(cola)==3); print_test("Desencolo el primer elemento y devuelve valor ",*(int*)cola_desencolar(cola)==3); print_test("Ver primero me devuelve 1 ",*(int*)cola_ver_primero(cola)==1); print_test("Desencolo el primer elemento y devuelve valor ",*(int*)cola_desencolar(cola)==1); print_test("Ver primero me devuelve 3 ",*(int*)cola_ver_primero(cola)==3); print_test("Desencolo el primer elemento y devuelve valor ",*(int*)cola_desencolar(cola)==3); print_test("Devuelve NUll Cuando ya no hay elementos para desencolar",cola_desencolar(cola)==NULL); print_test("la cola esta vacia", cola_esta_vacia(cola)); print_test("Vuelvo a encolar el elemento 3 ",cola_encolar(cola,&a)); print_test("Vuelvo a encolar el elemento 1 ",cola_encolar(cola,&b)); print_test("**Cola destrida con elementos **",true); cola_destruir(cola,NULL); }
void pruebas_cola_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* cola_desencolar(cola_t *cola) { if( cola_esta_vacia(cola) ) return NULL; /* sacamos el dato de cola->ptrPrimero */ void *aux_dato = cola_ver_primero(cola); /* ahora, el primero es el siguiente del primero * Sin embargo, hay que armar un vagón temporal que 'storee' * el primer nodo , así liberar posteriormente * la memoria pedida por el nodo en 'encolar' */ nodo_cola_t *nodo_auxiliar = cola->ptrPrimero; if( cola->ptrPrimero == cola->ptrUltimo ) { /* si ingresó aqui significa que solo habia 1 elemento */ /* La cola ahora empieza vacia sin referencia ni al final ni al primero */ cola->ptrPrimero = NULL; cola->ptrUltimo = NULL; } else { /* hay mas nodos, hay que ahora setear el primero de la * cola con el siguiente del elemento a borrar */ cola->ptrPrimero = cola->ptrPrimero->siguiente; } free(nodo_auxiliar); return aux_dato; }
bool cola_encolar(cola_t *cola, void* valor) { nodo_cola_t* vagon; vagon = malloc( sizeof(nodo_cola_t) ); if( vagon == NULL ) return false; vagon->dato = valor; /* es el ultimo vagon el agregado ,por ende el siguiente es NULL */ vagon->siguiente = NULL; if( cola_esta_vacia(cola) ) { /* La cola está vacia? este vagon procede a ser el primero * y a la vez tambien el último*/ cola->ptrPrimero = vagon; } else { /* como todo vagón a agregar debe ir al final de la cola * referenciamos el último vagon que teniamos * (cola->ptrUltimo) al vagon actual */ cola->ptrUltimo->siguiente = vagon; } /* ahora, nuestro ultimo vagon es el ingresado */ cola->ptrUltimo = vagon; return true; }
/* Procesar todos los votos y volcar resultados */ bool comando_cerrar(maquina_votacion_t* maquina, char* entrada[]) { #ifdef DEBUG printf("Comando cerrar ejecutado\n"); #endif if(maquina->estado < ABIERTA) return error_manager(OTRO); if(maquina->estado > ABIERTA || !cola_esta_vacia(maquina->cola) ) return error_manager(COLA_NO_VACIA); lista_iter_t* iter = lista_iter_crear(maquina->listas); if(!iter) return error_manager(OTRO); while(!lista_iter_al_final(iter)) { partido_politico_t* partido = lista_iter_ver_actual(iter); if(!partido) { lista_iter_destruir(iter); return error_manager(OTRO); } printf("%s:\n", partido_nombre(partido)); for(size_t i=0;i<partido_largo(partido);i++) { size_t* votos = partido_votos(partido)[i]; printf("%s: %zu votos\n", CARGOS[i], *votos); } // Liberar memoria destruir_partido(partido); lista_iter_avanzar(iter); } lista_iter_destruir(iter); lista_destruir(maquina->listas, NULL); maquina->listas = NULL; return false; }
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* cola_ver_primero(const cola_t *cola){ if (cola_esta_vacia(cola)){ return NULL; } else { nodo_cola_t* temp = cola->primero; return temp->dato; } }
// Saca el primer elemento de la cola. Si la cola tiene elementos, se quita el // primero de la cola, y se devuelve su valor, si está vacía, devuelve NULL. // Pre: la cola fue creada. // Post: se devolvió el valor del primer elemento anterior, la cola // contiene un elemento menos, si la cola no estaba vacía. void* cola_desencolar(cola_t *cola) { if (cola_esta_vacia(cola)) return NULL; nodo_t *nodo = cola->primero; cola->primero = nodo->siguiente; void* dato = nodo->dato; free(nodo); return dato; }
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); }
// 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* cola_ver_primero(const cola_t *cola) { if (cola != NULL) { if (cola_esta_vacia(cola)) { return NULL; } void* dato = cola->primero->dato; return dato; } return 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; }
// Saca el primer elemento de la cola. Si la cola tiene elementos, se quita el // primero de la cola, y se devuelve su valor, si está vacía, devuelve NULL. // Pre: la cola fue creada. // Post: se devolvió el valor del primer elemento anterior, la cola // contiene un elemento menos, si la cola no estaba vacía. void* cola_desencolar(cola_t *cola){ if (cola_esta_vacia(cola)) return NULL; nodo_cola_t *nodo = cola->primero; void* valor = nodo->dato; cola->primero = cola->primero->proximo; free(nodo); return valor; }
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); }
// Agrega un nuevo elemento a la cola. Devuelve falso en caso de error. // Pre: la cola fue creada. // Post: se agregó un nuevo elemento a la cola, valor se encuentra al final // de la cola. bool cola_encolar(cola_t *cola, void* valor) { nodo_t* nodo = malloc(sizeof(nodo_t)); if (nodo == NULL) return false; nodo->dato = valor; nodo->siguiente = NULL; if (cola_esta_vacia(cola)) cola->primero = nodo; else cola->ultimo->siguiente = nodo; cola->ultimo = nodo; return true; }
void* cola_desencolar(cola_t *cola){ if (cola_esta_vacia(cola)) return NULL; nodo_cola_t* nodo_temp = cola->primero; void* dato = nodo_temp->dato; cola->primero = nodo_temp->proximo; if (cola->ultimo == nodo_temp) cola->ultimo = NULL; free(nodo_temp); return dato; }
void pruebas_cola_volumen() { printf("\nINICIO DE PRUEBAS DE VOLUMEN\n"); /* Declaro las variables a utilizar*/ cola_t* cola = cola_crear(); int a = 1; int* p_a = &a; /* Inicio de pruebas */ for (int i = 1; i <= MAX_VOLUMEN; i++) { cola_encolar(cola, p_a); } print_test("Prueba cola NO esta vacia despues de encolar", !cola_esta_vacia(cola)); for (int i = 1; i <= MAX_VOLUMEN; i++) { cola_desencolar(cola); } print_test("Prueba cola esta vacia despues de desencolar todos", cola_esta_vacia(cola)); /* Destruyo la cola */ cola_destruir(cola, NULL); print_test("La cola fue destruida", true); }
void pruebas_structs(){ /* PRUEBA CON FUNCION FREE */ printf("\n ***Inicio de pruebas con structs *** \n"); printf("PRUEBAS CON FUNCION FREE \n"); cola_t* cola3=cola_crear(); cola_t* cola4=cola_crear(); tipo_t* temp1=malloc(sizeof(tipo_t)); tipo_t* temp2=malloc(sizeof(tipo_t)); print_test("Encolo un cola_t ",cola_encolar(cola3,cola4)); print_test("Encolo un tipo_t",cola_encolar(cola3,temp1)); print_test("Encolo un tipo_t",cola_encolar(cola3,temp2)); print_test("cola no esta vacia",!cola_esta_vacia(cola3)); cola_destruir(cola3, free); cola_t* cola5 = cola_crear(); cola_destruir(cola5, NULL); /* PRUEBA CON FUNCION DISTINTO DE FREE*/ printf("\n PRUEBAS CON FUNCION DISTINTO DE FREE \n"); vector_t* vec1 = crear_cargar_vector(); vector_t* vec2 = crear_cargar_vector(); vector_t* vec3 = crear_cargar_vector(); cola_t* cola = cola_crear(); print_test("la cola esta vacia",cola_esta_vacia(cola)); print_test("cola encolar vec1 ", cola_encolar(cola, vec1)); print_test("cola no esta vacia", !cola_esta_vacia(cola)); print_test("cola ver primero es vec1", cola_ver_primero(cola) == vec1); print_test("cola encolar vec2 ", cola_encolar(cola, vec2)); print_test("cola ver primero sigue siendo vec1", cola_ver_primero(cola) == vec1); print_test("cola encolar ve3", cola_encolar(cola, vec3)); cola_destruir(cola, destruir_vector); print_test("cola destruid",true); }
void* cola_desencolar(cola_t *cola) { if (cola != NULL) { if (cola_esta_vacia(cola)) { return NULL; } struct nodo_cola* nodo_a_desencolar = cola->primero; void* dato_a_devolver = nodo_a_desencolar->dato; cola->primero = nodo_a_desencolar->siguiente; if (cola->primero == NULL) { cola->ultimo = NULL; } free(nodo_a_desencolar); return dato_a_devolver; } return NULL; }
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); }
// Saca el primer elemento de la cola. Si la cola tiene elementos, se quita el // primero de la cola, y se devuelve su valor, si está vacÃa, devuelve NULL. // Pre: la cola fue creada. // Post: se devolvió el valor del primer elemento anterior, la cola // contiene un elemento menos, si la cola no estaba vacÃa. void* cola_desencolar(cola_t *cola) { if (cola_esta_vacia(cola) == true) return NULL; nodo_t* nodo_aux = NULL; //Guardo el valor a desencolar void* desencolado = (cola->prim)->valor; // Cambio la referencia de prim. Ahora vale la referencia al segundo nodo. nodo_aux = cola->prim; cola->prim = (cola->prim)->ref; // Destruyo el nodo desencolado? ¿¿?? free(nodo_aux); // Disminuyo el tamanio cola->tamanio -= 1; // Devuelvo el valor del desencolado return desencolado; }
bool cola_encolar(cola_t *cola, void* valor) { if (cola != NULL) { struct nodo_cola* nuevo_nodo = malloc(sizeof(struct nodo_cola)); if (nuevo_nodo == NULL) { return false; } nuevo_nodo->dato = valor; nuevo_nodo->siguiente = NULL; if (!cola_esta_vacia(cola)) { cola->ultimo->siguiente = nuevo_nodo; cola->ultimo = nuevo_nodo; return true; } cola->primero = nuevo_nodo; cola->ultimo = nuevo_nodo; return true; } return false; }
void cola_destruir(cola_t *cola, void (*destruir_dato)(void*)) { if (cola != NULL) { if (!cola_esta_vacia(cola)) { struct nodo_cola* nodo = cola->primero; struct nodo_cola* nodo_aux; void* dato; while (nodo != NULL) { if (destruir_dato != NULL) { dato = nodo->dato; destruir_dato(dato); } nodo_aux = nodo->siguiente; free(nodo); nodo = nodo_aux; } } free(cola); } }
// Agrega un nuevo elemento a la cola. Devuelve falso en caso de error. // Pre: la cola fue creada. // Post: se agregó un nuevo elemento a la cola, valor se encuentra al final // de la cola. bool cola_encolar(cola_t *cola, void* valor){ nodo_cola_t* nodo_nuevo = malloc(sizeof(nodo_cola_t)); if (nodo_nuevo == NULL) return false; nodo_nuevo->dato = valor; nodo_nuevo->proximo = NULL; if (cola_esta_vacia(cola)){ cola->primero = nodo_nuevo; cola->ultimo = nodo_nuevo; return true; } else{ cola->ultimo->proximo = nodo_nuevo; cola->ultimo = nodo_nuevo; return true; } }
// Obtiene el valor del primer elemento de la cola. Si la cola tiene // elementos, se devuelve el valor del primero, si está vacÃa devuelve NULL. // Pre: la cola fue creada. // Post: se devolvió el primer elemento de la cola, cuando no está vacÃa. void* cola_ver_primero(const cola_t *cola) { if (cola_esta_vacia(cola)==true) return NULL; void* primero = (cola->prim)->valor; return primero; }
void* cola_ver_primero(const cola_t *cola) { return cola_esta_vacia(cola) ? NULL : cola->ptrPrimero->dato; }
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); }