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);
}
Beispiel #2
0
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);
  

}
Beispiel #3
0
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);

}
Beispiel #4
0
/* 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);
}
Beispiel #5
0
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;
}
Beispiel #6
0
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;
}
Beispiel #7
0
/* 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;
}
Beispiel #8
0
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);
}
Beispiel #9
0
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;
	}
}
Beispiel #10
0
// 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;
}
Beispiel #11
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);
}
Beispiel #12
0
// 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);
}
Beispiel #13
0
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;
}
Beispiel #14
0
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);
}
Beispiel #15
0
/*
 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;
}
Beispiel #16
0
// 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;
	
}
Beispiel #17
0
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);
}
Beispiel #18
0
// 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;
}
Beispiel #19
0
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;
}
Beispiel #20
0
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);
}
Beispiel #21
0
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);

}
Beispiel #22
0
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;
}
Beispiel #23
0
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);
}
Beispiel #24
0
// 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;
}    
Beispiel #25
0
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;
}
Beispiel #26
0
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);   
    }
}
Beispiel #27
0
// 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;
	}
}
Beispiel #28
0
// 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;
}
Beispiel #29
0
void* cola_ver_primero(const cola_t *cola)
{
	return cola_esta_vacia(cola) ? NULL : cola->ptrPrimero->dato;
}
Beispiel #30
0
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 = &num;
	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);

}