cola.c

#include "cola.h"
#include <stdlib.h>
#include <stdbool.h>

//Estructuras Cola y Nodo

struct nodo{
	void* dato;
	struct nodo* sig;
} typedef nodo_t;

struct cola {
    nodo_t* primero;
	nodo_t* ultimo;

}typedef cola_t;
	
//Primitivas de la Cola
//o nodo-t?
nodo_t* crear_nodo(void){
	nodo_t* nodo_nuevo= malloc(sizeof(nodo_t));
	return nodo_nuevo;
}

cola_t* cola_crear(void){
	cola_t* cola=malloc(sizeof(cola_t)); 
	if(cola==NULL)return NULL;
	cola->primero=NULL;
	cola->ultimo=NULL;
	return cola;
}

bool cola_esta_vacia(const cola_t *cola){
	return cola->primero==NULL;
}

bool cola_encolar(cola_t *cola, void* valor){
	nodo_t* nodo_nuevo= crear_nodo();
	if (nodo_nuevo==NULL)return false;
	nodo_nuevo->dato=valor;
	nodo_nuevo->sig=NULL; 
	if (cola->primero==NULL){
		cola->primero=nodo_nuevo;
	}
	else{
		cola->ultimo->sig=nodo_nuevo;
	}
	cola->ultimo=nodo_nuevo;
	return true;
	
}

void* cola_desencolar(cola_t *cola){
	if(cola_esta_vacia(cola))return NULL; 
	void* dato= cola->primero->dato;
	nodo_t* nodo_aux= cola->primero;
	cola->primero=nodo_aux->sig;
	free(nodo_aux);
	return dato;	
	}


void* cola_ver_primero(const cola_t *cola){
	if (cola->primero==NULL)return NULL;
	return cola->primero->dato;
}
		
void cola_destruir(cola_t *cola, void destruir_dato(void*)){
	while (cola_esta_vacia(cola)==false){
		if (destruir_dato!=NULL)destruir_dato(cola->primero->dato);
		cola_desencolar(cola);
	}
	free(cola);	 
}

pruebas.c

#include "cola.h"
#include "testing.h"
#include <stddef.h>
#include <stdlib.h>
#include <stdio.h>
#include "pila.h"


void pruebas_cola_vacia(void){
    printf("COMIENZO DE PRUEBAS CON COLA VACIA \n");
    //creo una pila, que no contienen ningun elemento
	cola_t* cola_0 = cola_crear();
	
	//pruebo que existe la pila y que no es NULL al estar vacía.
	print_test("Creo una cola con con 0 elementos", cola_0 != NULL);
	
	//pruebo que está vacía
	print_test("Está vacía", cola_esta_vacia(cola_0)==true);
	
	//veo que ver tope me de NULL
	print_test("La pila vacía no tiene tope",cola_ver_primero(cola_0)==NULL);
	
	//pruebo que no puedo sacar elementos de una pila vacía
	print_test("No se pueden sacar elementos de una cola vacía",cola_desencolar(cola_0)==NULL);
	
	//Elimino la pila
	cola_destruir(cola_0,NULL);
	print_test("Se elimina la cola", true);
}

void pruebas_cola_con_elementos(void){	
	printf("COMIENZO DE PRUEBAS CON COLA CON ALGUNOS ELEMENTOS \n");
	
	cola_t* cola_1 = cola_crear();
	
	printf("Agrego algunos elementos a la cola \n");
	
	int a[2];
	int b[3];

	cola_encolar(cola_1, a);
	cola_encolar(cola_1,b);
	print_test("El primer elemento en entrar fue el primero en salir",cola_desencolar(cola_1)==a);
	print_test("Saco el último elemento de la cola",cola_desencolar(cola_1)==b);
	print_test("La cola está vacía luego de haberse desencolado todos los elementos",cola_esta_vacia(cola_1)==true);
	cola_destruir(cola_1,NULL);
	print_test("Se elimina la cola", true);
}

void pruebas_cola_con_pilas(void){
	printf("COMIENZO DE PRUEBAS CON COLA CON PILAS \n");
	
	printf("Se crea una nueva cola \n");
	cola_t* cola_2 = cola_crear();
	
	void puntero_pila_destruir(void* pila){
		pila_destruir((pila_t*)pila);
	}
	//creo el puntero a pila_destruir
	void (*puntero_funcion)(void*)= puntero_pila_destruir;
	
	printf("Le agrego pilas \n");
	
	pila_t* pila_1 = pila_crear();
	pila_t* pila_2 = pila_crear();
	
	cola_encolar(cola_2,pila_1);
	cola_encolar(cola_2,pila_2);
	
	printf("Desencolo los elementos de la cola \n");
	
	while(cola_esta_vacia(cola_2)==false){
		cola_desencolar(cola_2);
	}
	print_test("La cola está vacía luego de haberse desencolado todos los elementos",cola_esta_vacia(cola_2)==true);
	cola_destruir(cola_2,puntero_funcion);
	printf("Se elimina la cola \n");
}



void pruebas_cola_alumno() {
	pruebas_cola_vacia();
	pruebas_cola_con_elementos();
	pruebas_cola_con_pilas();
}