int testSeleccion()
{
lista* A = lista_crear();
jugador* Gino = crear_jugador("Ginobili", "Argentina", 6, 198);
jugador* GinoPies = normalizar_jugador(Gino);
jugador* Gino2 = crear_jugador("Ginobili", "Argentina", 6, 198);
jugador* GinoPies2 = normalizar_jugador(Gino);
insertar_ordenado(A, (void*)GinoPies, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(A, (void*)Gino, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(A, (void*)GinoPies2, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(A, (void*)Gino2, (tipo_funcion_cmp)&menor_jugador);
seleccion* w = crear_seleccion("Argentina", altura_promedio(A), A);
lista* B = lista_crear();
jugador* a = crear_jugador("a", "Argentina", 6, 143);
jugador* b = normalizar_jugador(Gino);
jugador* c = crear_jugador("b", "Argentina", 6, 400);
jugador* d= normalizar_jugador(Gino);
insertar_ordenado(B, (void*)a, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(B, (void*)b, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(B, (void*)c, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(B, (void*)d, (tipo_funcion_cmp)&menor_jugador);
seleccion* j = crear_seleccion("Argentina", altura_promedio(B), B);
lista *listaDeSelecciones = lista_crear();
insertar_ordenado(listaDeSelecciones, w, (tipo_funcion_cmp)menor_seleccion);
insertar_ordenado(listaDeSelecciones, j, (tipo_funcion_cmp)menor_seleccion);
lista_borrar(listaDeSelecciones, (tipo_funcion_borrar)borrar_seleccion);
printf("OK\n");
return 0;
}
void listadesels() {
lista* l = lista_crear();
jugador* j1 = crear_jugador("Ginobili", "Argentina", 5, 198);
jugador* j2 = crear_jugador("Scola", "Argentina", 6, 198);
jugador* j3 = crear_jugador("Prigioni", "Argentina", 7, 198);
jugador* j4 = crear_jugador("Ginobili", "Argentina", 9, 199);
jugador* j5 = crear_jugador("Ginobili", "Argentina", 10, 199);
insertar_ordenado(l, (void*)j1, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(l, (void*)j2, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(l, (void*)j3, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(l, (void*)j4, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(l, (void*)j5, (tipo_funcion_cmp)&menor_jugador);
seleccion* s=crear_seleccion("Uruguay",altura_promedio(l),l);
lista* l2 = lista_crear();
seleccion* s2=crear_seleccion("Andorra",0,l2);
lista* partido=lista_crear();
insertar_ordenado(partido, (void*)s, (tipo_funcion_cmp)&menor_seleccion);
insertar_ordenado(partido, (void*)s2, (tipo_funcion_cmp)&menor_seleccion);
assert(((seleccion*)partido->primero->datos)->jugadores->primero== NULL);
assert(((seleccion*)partido->primero->sig->datos)->alturaPromedio==(992/5.0));
lista_imprimir(partido, "hola.out",(tipo_funcion_imprimir)&imprimir_seleccion);
lista_borrar(partido,(tipo_funcion_borrar)&borrar_seleccion);
}
int p4a(){
lista *l= lista_crear();
lista *jugadores = lista_crear();
seleccion *sel = crear_seleccion("hola", 21.0, jugadores);
insertar_ordenado(l,sel,(tipo_funcion_cmp)&menor_seleccion);
lista_imprimir(l,"p4a.txt",(tipo_funcion_imprimir)&imprimir_seleccion);
lista_borrar(l,(tipo_funcion_borrar) &borrar_seleccion);
return 0;
}
void ordenar() {
lista* l = lista_crear();
jugador* j1 = crear_jugador("Ginobili", "Argentina", 5, 198);
nodo* n1 = nodo_crear(j1);
jugador* j2 = crear_jugador("Scola", "Argentina", 6, 198);
nodo* n2 = nodo_crear(j2);
jugador* j3 = crear_jugador("Prigioni", "Argentina", 7, 198);
nodo* n3 = nodo_crear(j3);
jugador* j4 = crear_jugador("Ginobili", "Argentina", 9, 199);
nodo* n4 = nodo_crear(j4);
jugador* j5 = crear_jugador("Ginobili", "Argentina", 10, 199);
nodo* n5 = nodo_crear(j5);
insertar_ultimo(l, n1);
lista* lord=ordenar_lista_jugadores(l);
lista_imprimir(lord, "hola.out",(tipo_funcion_imprimir)&imprimir_jugador);
assert(((jugador*)lord->primero->datos)->altura==j1->altura);
lista_borrar(lord,(tipo_funcion_borrar)&borrar_jugador);
insertar_ultimo(l, n2);
insertar_ultimo(l, n3);
insertar_ultimo(l, n4);
insertar_ultimo(l, n5);
lista* lord2=ordenar_lista_jugadores(l);
assert(((jugador*)lord2->primero->datos)->altura==j1->altura);
lista_imprimir(lord2, "hola.out",(tipo_funcion_imprimir)&imprimir_jugador);
lista_borrar(lord2,(tipo_funcion_borrar)&borrar_jugador);
lista_borrar(l,(tipo_funcion_borrar)&borrar_jugador);
}
void filtrar() {
lista* l = lista_crear();
jugador* j1 = crear_jugador("Ginobili", "Argentina", 5, 198);
jugador* j2 = crear_jugador("Scola", "Antartida", 6, 198);
jugador* j3 = crear_jugador("Prigioni", "Argentina", 7, 198);
nodo* n3 = nodo_crear(j3);
jugador* j4 = crear_jugador("Ginobili", "Argentina", 9, 199);
jugador* j5 = crear_jugador("Ginobili", "Antartida", 10, 199);
insertar_ultimo(l, n3);
insertar_ordenado(l, (void*)j1, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(l, (void*)j2, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(l, (void*)j4, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(l, (void*)j5, (tipo_funcion_cmp)&menor_jugador);
lista* lfil=filtrar_jugadores(l, (tipo_funcion_cmp)&menor_jugador,n3);
lista_imprimir(lfil, "hola.out",(tipo_funcion_imprimir)&imprimir_jugador);
assert(((jugador*)lfil->primero->sig->sig->datos)->altura==j4->altura);
lista_borrar(lfil,(tipo_funcion_borrar)&borrar_jugador);
lista* lfil2=filtrar_jugadores(l, (tipo_funcion_cmp)&pais_jugador,n3);
lista_imprimir(lfil2, "hola.out",(tipo_funcion_imprimir)&imprimir_jugador);
assert(((jugador*)lfil2->primero->sig->sig->datos)->altura==j3->altura);
lista_borrar(lfil2,(tipo_funcion_borrar)&borrar_jugador);
lista_borrar(l,(tipo_funcion_borrar)&borrar_jugador);
}
void generar() {
lista* l = lista_crear();
jugador* j1 = crear_jugador("Ginobili", "Argentina", 5, 198);
jugador* j2 = crear_jugador("Scola", "Transnistria", 6, 198);
jugador* j3 = crear_jugador("Prigioni", "Argentina", 7, 198);
jugador* j4 = crear_jugador("Ginobili", "Argentina", 9, 199);
jugador* j5 = crear_jugador("Ginobili", "Transnistria", 10, 199);
insertar_ordenado(l, (void*)j1, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(l, (void*)j2, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(l, (void*)j3, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(l, (void*)j4, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(l, (void*)j5, (tipo_funcion_cmp)&menor_jugador);
lista* gen=generar_selecciones(l);
lista_imprimir(gen, "hola.out",(tipo_funcion_imprimir)&imprimir_seleccion);
assert(((seleccion*)gen->primero->sig->datos)->alturaPromedio==6);
//Los dos Transnistrios son de 6 pies
assert(((jugador*)((seleccion*)gen->primero->datos)->jugadores->primero->datos)->altura==6);
//El primero de argentina es Gino (6 pies)
lista_borrar(gen,(tipo_funcion_borrar)&borrar_seleccion);
lista_borrar(l,(tipo_funcion_borrar)&borrar_jugador);
}
int p1()
{
lista *l = lista_crear();
lista_imprimir(l,"test.txt",(tipo_funcion_imprimir)&g);
lista_borrar(l,(tipo_funcion_borrar) &f);
return 0;
}
void map() {
lista* l = lista_crear();
jugador* j1 = crear_jugador("Ginobili", "Argentina", 5, 198);
jugador* j2 = crear_jugador("Scola", "Argentina", 6, 198);
jugador* j3 = crear_jugador("Prigioni", "Argentina", 7, 198);
jugador* j4 = crear_jugador("Ginobili", "Argentina", 9, 199);
jugador* j5 = crear_jugador("Ginobili", "Argentina", 10, 199);
insertar_ordenado(l, (void*)j1, (tipo_funcion_cmp)&menor_jugador);
lista* lmap=mapear(l, (tipo_funcion_mapear)&i);
assert(((jugador*)lmap->primero->datos)->altura==j1->altura);
lista_imprimir(lmap, "hola.out",(tipo_funcion_imprimir)&imprimir_jugador);
lista_borrar(lmap,(tipo_funcion_borrar)&borrar_jugador);
insertar_ordenado(l, (void*)j2, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(l, (void*)j3, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(l, (void*)j4, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(l, (void*)j5, (tipo_funcion_cmp)&menor_jugador);
lista* lmap2=mapear(l, (tipo_funcion_mapear)&normalizar_jugador);
lista_imprimir(lmap2, "hola.out",(tipo_funcion_imprimir)&imprimir_jugador);
jugador* n1 = normalizar_jugador(j1);
assert(((jugador*)lmap2->primero->datos)->altura==n1->altura);
borrar_jugador(n1);
lista_borrar(lmap2,(tipo_funcion_borrar)&borrar_jugador);
lista_borrar(l,(tipo_funcion_borrar)&borrar_jugador);
}
void listavacia() {
FILE* archivo = fopen("hola.out","a");
lista* l = lista_crear();
assert(l->primero == NULL);
lista_imprimir_f(l, archivo, (tipo_funcion_imprimir)&g);
lista_borrar(l,(tipo_funcion_borrar)&f);
fclose(archivo);
}
vector_t* crear_zonas(int tam) {
int i;
vector_t* vector=vector_crear(tam);
for (i=0;i<tam;i++){
vector_guardar(vector,-1,lista_crear());
}
return vector;
}
base_t* inicializar_base_de_datos(){
base_t* basededatos = malloc(sizeof(base_t));
if (basededatos==NULL) return NULL;
basededatos->listadecursos = lista_crear();
if (basededatos->listadecursos==NULL){
free(basededatos);
return NULL;
}
return basededatos;
}
void listade1(void) {
lista* l = lista_crear();
jugador* j = crear_jugador("Ginobili", "Argentina", 5, 198);
nodo* n=nodo_crear(j);
//insertar_ordenado(l, (void*)Gino, (tipo_funcion_cmp)&menor_jugador);
insertar_ultimo(l, n);
lista_imprimir(l, "hola.out", (tipo_funcion_imprimir)&imprimir_jugador);
assert(((jugador*)l->primero->datos)->nombre == j->nombre);
lista_borrar(l,(tipo_funcion_borrar)&borrar_jugador);
}
void selvacia() {
FILE* archivo = fopen("hola.out","a");
lista* l = lista_crear();
seleccion* s=crear_seleccion("Andorra",1,l);
assert(s->jugadores->primero == NULL);
assert(s->alturaPromedio == 1);
imprimir_seleccion(s, archivo);
borrar_seleccion(s);
fclose(archivo);
}
int p2()
{
char *nombre = "pepe";
char *pais = "pepe";
jugador *pepe = crear_jugador(nombre ,pais, 4 ,30);
lista *l = lista_crear();
insertar_ordenado(l,pepe,(tipo_funcion_cmp)&menor_jugador);
lista_imprimir(l, "mitest.txt",(tipo_funcion_imprimir) &imprimir_jugador);
lista_borrar(l,(tipo_funcion_borrar) &borrar_jugador);
return 0;
}
int testLista()
{
char *nombre = "aaa";
char *pais = "pepe";
jugador *pepe = crear_jugador(nombre ,pais,'4',196);
char *nombre2 = "ccc";
char *pais2 = "pepe";
jugador *pepe2 = crear_jugador(nombre2 ,pais2,'4',196);
char *nombre3 = "bbb";
char *pais3 = "pepe";
jugador *pepe3 = crear_jugador(nombre3 ,pais3,'4',196);
lista *miLista;
printf("Creando Lista...\n");
miLista = lista_crear();
printf("Insertando jugador 1\n");
insertar_ordenado(miLista,(void*)pepe, (tipo_funcion_cmp)&menor_jugador);
printf("Insertando jugador 2\n");
insertar_ordenado(miLista,(void*)pepe2, (tipo_funcion_cmp)&menor_jugador);
printf("Insertando jugador 3\n");
insertar_ordenado(miLista,(void*)pepe3, (tipo_funcion_cmp)&menor_jugador);
lista *backUp = miLista;
miLista = ordenar_lista_jugadores(backUp);
lista_borrar(backUp, (tipo_funcion_borrar)&borrar_jugador);
nodo *unNodo = miLista->primero;
jugador *unj = unNodo->datos;
printf("Nombre: %s \n",unj->nombre);
unNodo = miLista->primero->sig;
unj = unNodo->datos;
printf("Nombre: %s \n",unj->nombre);
unNodo = miLista->primero->sig->sig;
unj = unNodo->datos;
printf("Nombre: %s \n",unj->nombre);
lista* B = mapear(miLista, (tipo_funcion_mapear)&normalizar_jugador);
printf("Borrando Lista...\n");
lista_borrar(B, (tipo_funcion_borrar)&borrar_jugador);
lista_borrar(miLista, (tipo_funcion_borrar)&borrar_jugador);
printf("Ok!\n");
return 0;
}
int p4b(){
lista *jugadores = lista_crear();
lista *l = lista_crear();
char *nombre = "aaa";
char *pais = "pepe";
jugador *pepe = crear_jugador(nombre ,pais, 4 ,30);
char *nombre2 = "bbb";
char *pais2 = "pepe";
jugador *pepe2 = crear_jugador(nombre2 ,pais2, 4 ,30);
insertar_ordenado(jugadores,pepe,(tipo_funcion_cmp)&h);
insertar_ordenado(jugadores,pepe2,(tipo_funcion_cmp)&h);
seleccion *sel = crear_seleccion("hola", 21.0, jugadores);
insertar_ordenado(l,sel,(tipo_funcion_cmp)&menor_seleccion);
lista_imprimir(l,"testSeleccion.txt",(tipo_funcion_imprimir)&imprimir_seleccion);
lista_borrar(l,(tipo_funcion_borrar) &borrar_seleccion);
return 0;
}
listaP *predecir_palabras(trie *t, char *teclas) {
listaP *res = lista_crear();
char buffer[1024];
char const *buffer_original = buffer;
combinaciones_posibles(teclas,buffer,res,t,buffer_original);
return res;
}
bool agregar_zona(vector_t *vectorzonas, vector_t *vectorprecios)
{
int *precio = malloc(sizeof(int*));
vector_guardar(vectorzonas, -1, lista_crear() );
printf("Ingrese el precio unitario por pizza para la nueva zona en pesos: \n");
scanf("%d",precio);
vector_guardar(vectorprecios, -1, precio);
return true;
}
sesion_t* sesion_crear(){
sesion_t* sesion = calloc(1,sizeof(sesion_t));
if (sesion==NULL) return NULL;
sesion->padron = calloc(LPADRON+1,sizeof(char));
sesion->inscripciones = lista_crear();
if (sesion->inscripciones== NULL || sesion->padron==NULL){
if (sesion->inscripciones!=NULL) free(sesion->inscripciones);
if (sesion->padron!=NULL) free(sesion->padron);
free(sesion);
return NULL;
}
strcpy(sesion->padron,"00000");
return sesion;
}
//funciones auxiliares para crear las fabricas y juguetes
fabrica_t* crear_fabrica(char* idfabrica,char* idesquina,char* horaentrada,char* horasalida){
fabrica_t* fabrica = malloc(sizeof(fabrica_t));
if (fabrica==NULL) return NULL;
fabrica->juguetes = lista_crear();
if (fabrica->juguetes==NULL){
free(fabrica);
return NULL;
}
fabrica->idfabrica = malloc(strlen(idfabrica)+1);
strcpy(fabrica->idfabrica,idfabrica);
fabrica->idesquina = atoi(idesquina);
fabrica->horarioentrada = atoi(horaentrada);
fabrica->horariosalida = atoi(horasalida);
return fabrica;
}
int testJugadores()
{
lista* A = lista_crear();
jugador* Gino = crear_jugador("Ginobili", "Argentina", 6, 198);
jugador* GinoPies = normalizar_jugador(Gino);
insertar_ordenado(A, (void*)GinoPies, (tipo_funcion_cmp)&menor_jugador);
borrar_jugador(Gino);
Gino = A->primero->datos;
printf("NORMALIZADO\n");
printf("numero: %c \n",Gino->numero);
printf("Nombre: %s \n",Gino->nombre);
printf("Pais: %s \n",Gino->pais);
printf("Altura: %u \n",(unsigned int)Gino->altura);
lista_borrar(A, (tipo_funcion_borrar)&borrar_jugador);
return 0;
}
void listademas(void) {
lista* l = lista_crear();
jugador* j1 = crear_jugador("Ginobili", "Argentina", 5, 198);
jugador* j2 = crear_jugador("Scola", "Argentina", 6, 190);
jugador* j3 = crear_jugador("Prigioni", "Argentina", 7, 190);
jugador* j4 = crear_jugador("Ginobili", "Argentina", 9, 199);
jugador* j5 = crear_jugador("Ginobili", "Argentina", 10, 202);
insertar_ordenado(l, (void*)j1, (tipo_funcion_cmp)&h); //j1
insertar_ordenado(l, (void*)j2, (tipo_funcion_cmp)&h); //j2->j1 (estoy usando h, que me da que es menor)
insertar_ordenado(l, (void*)j3, (tipo_funcion_cmp)&menor_jugador); //j3->j2->j1
insertar_ordenado(l, (void*)j4, (tipo_funcion_cmp)&menor_jugador); //j4->j3->j2->j1
insertar_ordenado(l, (void*)j5, (tipo_funcion_cmp)&menor_jugador); //j4->j5->j3->j2->j1
assert(((jugador*)l->primero->datos)->altura == j4->altura);
lista_imprimir(l,"hola.out", (tipo_funcion_imprimir)&imprimir_jugador);
lista_borrar(l,(tipo_funcion_borrar)&borrar_jugador);
}
int p3()
{
char *nombre = "aaa";
char *pais = "pepe";
jugador *pepe = crear_jugador(nombre ,pais, 4 ,30);
lista *l = lista_crear();
char *nombre2 = "bbb";
char *pais2 = "pepe";
jugador *pepe2 = crear_jugador(nombre2 ,pais2, 4 ,30);
char *nombre3 = "aaa";
char *pais3 = "pepe";
jugador *pepe3 = crear_jugador(nombre3 ,pais3, 4 ,30);
insertar_ordenado(l,pepe,(tipo_funcion_cmp)&h);
insertar_ordenado(l,pepe2,(tipo_funcion_cmp)&h);
insertar_ordenado(l,pepe3,(tipo_funcion_cmp)&h);
assert(l->primero->sig->sig->datos == pepe);
lista_borrar(l,(tipo_funcion_borrar) &borrar_jugador);
return 0;
}
bool almacenar(hash_t* hash, lista_t** tabla, daton_t* paquete, unsigned long largo){
bool resu;
unsigned long indice = fh(paquete->clave, largo );
if (!tabla[indice]){
tabla[indice] = lista_crear();
}
lista_iter_t* iter_l = busqueda(tabla[indice], paquete->clave);
if (lista_iter_al_final(iter_l)) { //no lo encontro
resu = lista_insertar_primero(tabla[indice], paquete);
hash->tam++;
lista_iter_destruir(iter_l);
return resu;
}
daton_t* aux = lista_iter_borrar(iter_l);
free(aux->clave);
if (hash->destruir_dato) hash->destruir_dato(aux->dato);
free(aux);
resu = lista_insertar_ultimo(tabla[indice], paquete);
lista_iter_destruir(iter_l);
return resu;
}
void selllena() {
FILE* archivo = fopen("hola.out","a");
lista* l = lista_crear();
jugador* j1 = crear_jugador("Ginobili", "Argentina", 5, 198);
jugador* j2 = crear_jugador("Scola", "Argentina", 6, 197);
jugador* j3 = crear_jugador("Prigioni", "Argentina", 7, 198);
jugador* j4 = crear_jugador("Ginobili", "Argentina", 9, 199);
jugador* j5 = crear_jugador("Ginobili", "Argentina", 10, 199);
insertar_ordenado(l, (void*)j1, (tipo_funcion_cmp)&menor_jugador);//j1
insertar_ordenado(l, (void*)j2, (tipo_funcion_cmp)&menor_jugador);//j1->j2
insertar_ordenado(l, (void*)j3, (tipo_funcion_cmp)&menor_jugador);//j1->j3->j2
insertar_ordenado(l, (void*)j4, (tipo_funcion_cmp)&menor_jugador);//j1->j4->j3->j2
insertar_ordenado(l, (void*)j5, (tipo_funcion_cmp)&menor_jugador);//j1->j5->j4->j3->j2, si son iguales se agrega antes
seleccion* s=crear_seleccion("Uruguay",altura_promedio(l),l);
assert(((jugador*)s->jugadores->primero->datos)->altura== 198);
imprimir_seleccion(s, archivo);
borrar_seleccion(s);
fclose(archivo);
}
base_t *base_crear(){
//creo la base
base_t* base = malloc(sizeof(base_t));
if (base == NULL) return NULL;
//creo los componentes de la base
base->mapa = grafo_crear();
base->fabricas = hash_crear((hash_destruir_dato_t)destruir_fabrica);
base->cerradofabricas = heap_crear((cmp_func_t)fabrica_cierra_primero);
base->fabricasavisitar = lista_crear();
//verifico si los componentes se crearon correctamente
if ((base->mapa==NULL) || (base->fabricas==NULL) || (base->cerradofabricas==NULL) || (base->fabricasavisitar==NULL)){
if (base->mapa!=NULL) grafo_destruir(base->mapa);
if (base->cerradofabricas!=NULL) heap_destruir(base->cerradofabricas,NULL);
if (base->fabricasavisitar!=NULL) lista_destruir(base->fabricasavisitar,NULL);
if (base->fabricas!=NULL) hash_destruir(base->fabricas);
return NULL;
}
base->capacidad = 0;
base->polonorte = 0;
//todo exitoso
return base;
}
curso_t* crear_curso(char* idc,char* descripcion,char* materia,char* vacantes){
curso_t* nuevocurso = calloc(1,sizeof(curso_t));
if (nuevocurso==NULL) return NULL;
nuevocurso->inscriptos = lista_crear();
if (nuevocurso->inscriptos==NULL){
free(nuevocurso);
return NULL;
}
nuevocurso->idc = malloc(LIDC*sizeof(char));
nuevocurso->descripcion = malloc(LDESCRIPCION*sizeof(char));
nuevocurso->materia = malloc(LMATERIA*sizeof(char));
if ((nuevocurso->idc==NULL) || (nuevocurso->descripcion==NULL) || (nuevocurso->materia==NULL)){
if (nuevocurso->idc==NULL) free(nuevocurso->idc);
if (nuevocurso->descripcion==NULL) free(nuevocurso->descripcion);
if (nuevocurso->materia==NULL) free(nuevocurso->materia);
free(nuevocurso);
}
strcpy(nuevocurso->idc,idc);
strcpy(nuevocurso->descripcion,descripcion);
strcpy(nuevocurso->materia,materia);
nuevocurso->vacantes = atoi(vacantes);
return nuevocurso;
}
int p5(){
char *nombre = "aaa";
char *pais = "pepe";
jugador *pepe = crear_jugador(nombre ,pais, 4 ,30);
char *nombre2 = "aab";
char *pais2 = "pepe";
jugador *pepe2 = crear_jugador(nombre2 ,pais2, 4 ,30);
char *nombre3 = "bbb";
char *pais3 = "pepe2";
jugador *pepe3 = crear_jugador(nombre3 ,pais3, 4 ,30);
lista *l = lista_crear();
insertar_ordenado(l,pepe,(tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(l,pepe2,(tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(l,pepe3,(tipo_funcion_cmp)&menor_jugador);
lista *pop = mapear(l, (tipo_funcion_mapear)&normalizar_jugador);
lista_imprimir(pop,"ultimoTest.txt",(tipo_funcion_imprimir)&imprimir_jugador);
lista *l2 = filtrar_jugadores(l, (tipo_funcion_cmp)&pais_jugador,(void*) l->primero);
assert(menor_jugador(l->primero->datos,l2->primero->datos) && menor_jugador(l2->primero->datos,l->primero->datos));
lista_imprimir(l2,"swapsds",(tipo_funcion_imprimir)&imprimir_jugador);
lista_borrar(pop,(tipo_funcion_borrar) &borrar_jugador);
lista_borrar(l2,(tipo_funcion_borrar) &borrar_jugador);
lista_borrar(l,(tipo_funcion_borrar) &borrar_jugador);
return 0;
}
/* Pruebas */
void prueba_tipos() {
// Declaro de variables
lista_iter_t *iter;
lista_t* lista;
alumno_t* alumno1;
alumno_t* alumno2;
alumno_t* alumno3;
int padron1=94111;
int padron2=77777;
int padron3=10104;
// las inicializo
lista = lista_crear();
alumno1=alumno_crear(padron1);
alumno2=alumno_crear(padron2);
alumno3=alumno_crear(padron3);
printf("---------------------------PRUEBAS---------------------------\n");
//pruebo que este vacia
print_test("Pruebo que la lista se crea vacía", lista_esta_vacia(lista) );
//inserto 1er elemento
print_test("Inserto primer elemento alumno1", lista_insertar_primero(lista,alumno1) );
//inserto ultimo
print_test("Inserto ultimo elemento alumno2", lista_insertar_ultimo(lista,alumno2) );
//inesrto un nuevo ultimo
print_test("Inserto ultimo elemento alumno3", lista_insertar_ultimo(lista,alumno3) );
//veo el primero
print_test("Veo el primer elemento(alumno1)", alumno1==lista_ver_primero(lista));
//borro el primero y veo devuelta
print_test("Borro el primero", lista_borrar_primero(lista));
print_test("Veo el primer elemento(alumno2)", alumno2==lista_ver_primero(lista));
//veo el largo de la lista
print_test("Veo el largo de la lista (2)", 2==lista_largo(lista));
//creo iterador
iter= lista_iter_crear(lista);
//pruebas del iterador
print_test("Hago avanza al iterador", lista_iter_avanzar(iter));
print_test("Veo elemento actual del iterador (alumno3)", alumno3==lista_iter_ver_actual(iter));
print_test("Hago avanza al iterador", lista_iter_avanzar(iter));
print_test("Veo si esta al final", lista_iter_al_final(iter));
//pruebas de lista junto con iterador
print_test("Inserto de nuevo alumno1", lista_insertar(lista,iter,alumno1));
print_test("Lo borro", alumno1==lista_borrar(lista,iter));
//inserto 1er elemento
print_test("Inserto primer elemento alumno1", lista_insertar_primero(lista,alumno1) );
//destruyo el iterador
lista_iter_destruir(iter);
//creo iterador
iter= lista_iter_crear(lista);
print_test("Destruyo iterador,lo creo devuelta y borro el primer elemento (alumno1)", alumno1==lista_borrar(lista,iter));
destruir_dato(alumno1);
//destruyo lista e iterador
lista_iter_destruir(iter);
lista_destruir(lista,destruir_dato);
}
void lista_prueba(){
//Pruebo crear listas
lista_t* lista1 = lista_crear();
lista_t* lista2 = lista_crear();
lista_t* lista3 = lista_crear();
print_test("Probando si lista1 se creo bien", lista1!=NULL);
print_test("Probando si lista1 esta vacia", lista_esta_vacia(lista1));
print_test("Probando si el largo de lista2 es 0", lista_largo(lista2)==0);
int vector[]={ 1, 2, 3, 4};
char vector2[]="hola que tal";
// Probando insertar en la lista;
print_test("Probando si se inserta al principio un elemento en la lista1", lista_insertar_primero(lista1, &vector));
print_test("Probando si se inserta al final un elemento en la lista1", lista_insertar_ultimo(lista1, &vector2));
// Probando el largo de la lista con 2 elementos
print_test("Probando que el largo de la lista1 sea dos", lista_largo(lista1)==2);
// Probando el lista borrar primero en la lista 1
print_test("Probando si se borra el primer elemento en la lista1", lista_borrar_primero(lista1) == vector);
// Probando el lista ver primero
print_test("Probando ver el primero de la lista 1", lista_ver_primero(lista1) == vector2 );
// Probando agregar al principio en lista 3
print_test("Probando si se inserta al principio un elemento en la lista3", lista_insertar_primero(lista3, &vector));
lista_insertar_ultimo(lista3, &vector2);
// PRUEBAS CON EL ITERADOR CON LA LISTA 3
lista_iter_t* iter = lista_iter_crear(lista3);
// Probando el iter avanzar
print_test("Probando el iter avanzar", lista_iter_avanzar(iter));
// Probando el iter ver actual
print_test("Probando el iter ver actual", lista_iter_ver_actual(iter) == vector2);
// Probando el iter al final
print_test("Probando el iter avanzar", lista_iter_avanzar(iter));
print_test("Probando el iter avanzar (no puede avanzar mas)", lista_iter_avanzar(iter) == false);
print_test("Probando el iter al final", lista_iter_al_final(iter));
print_test("Probando si el iter esta el final el ver_actual", lista_iter_ver_actual(iter) == NULL);
lista_iter_destruir(iter);
// Probando lista_insertar con iterador
lista_iter_t* iter2 = lista_iter_crear(lista2);
char vector3[]="chau";
print_test("Probando el lista_insertar en la lista con el iter", lista_insertar(lista2,iter2,&vector3));
print_test("Probando ver el primero de la lista2", lista_ver_primero(lista2) == &vector3 );
print_test("Probando borrar con el iter", lista_borrar(lista2,iter2) == vector3 );
print_test("Probando el lista_ver_primero con los nodos borrados", lista_ver_primero(lista2) == NULL );
print_test("Probando el largo de una lista vacia", lista_largo(lista2) == 0 );
print_test("Probando el lista_borrar_primero en una lista vacia", lista_borrar_primero(lista2) == NULL );
lista_iter_destruir(iter2);
// Pruebo Agregar 30 Datos y luego borrarlos
for ( int i=0 ; i < 30 ; i++){
lista_insertar_ultimo(lista2, &i);
}
print_test("Probando el largo de la lista2 luego de agregar 30 elementos", lista_largo(lista2) == 30);
lista_iter_t* iter3=lista_iter_crear(lista2);
while (!lista_iter_al_final(iter3)){
lista_borrar(lista2,iter3);
}
print_test("Probando que se borraron todos los elementos" , lista_largo(lista2) == 0);
print_test("Prubando borrar un elemento en una lista vacia" , lista_borrar(lista2,iter3) == NULL);
lista_iter_destruir(iter3);
//Finalmente, pruebo si estan vacias las 3 listas
print_test( "Probando que la lista1 no este vacia", lista_esta_vacia(lista1) == false );
print_test( "Probando que la lista2 este vacia", lista_esta_vacia(lista2) );
print_test( "Probando que la lista3 no este vacia", lista_esta_vacia(lista3) == false );
//Elimino las 3 listas
lista_destruir(lista1, NULL);
lista_destruir(lista2, NULL);
lista_destruir(lista3, NULL);
/* ******************************************************************
* Pruebas con lista 4
* *****************************************************************/
//Creo otra lista y le inserto 10 nodos
lista_t* lista4 = lista_crear();
for( int num=1; num <= 10 ; num++){
int elemento=1;
lista_insertar_ultimo(lista4 , &elemento);
}
print_test("Probando largo de la lista 4", lista_largo(lista4) == 10 );
lista_iter_t* iter4= lista_iter_crear(lista4);
print_test("Probando que se creo el iter 4", iter4!=NULL);
print_test("Probando que el iter 4 no este al final", lista_iter_al_final(iter4) == false);
for (int j=1; j<=10; j++){
lista_iter_avanzar(iter4);
}
print_test("Probando que el iter 4 este al final", lista_iter_al_final(iter4));
char prueba[] = "prueba";
print_test("Probando lista_insertar con el iter al final ", lista_insertar(lista4, iter4, &prueba));
print_test("Probando que el iter 4 no este al final", lista_iter_al_final(iter4) == false);
print_test("Probando avanzar con el iter 4 al final", lista_iter_avanzar(iter4));
print_test("Probando lista_borrar con el iter 4 al final", lista_borrar(lista4,iter4) == NULL);
print_test("Probando lista_insertar con el iter 4 al final ", lista_insertar(lista4, iter4, &prueba));
print_test("Probando lista_borrar con el iter 4", lista_borrar(lista4,iter4) == prueba);
for (int j=0; j<=10; j++){
lista_borrar_primero(lista4);
}
print_test("Probando largo de la lista 4", lista_largo(lista4) == 0 );
// elimino el iter 4
lista_iter_destruir(iter4);
//Elimino la lista
lista_destruir(lista4, free);
/* ******************************************************************
* Pruebas con lista 5
* *****************************************************************/
//Creo otra lista y le inserto 10 nodos
lista_t* lista5 = lista_crear();
// le creo un iter
lista_iter_t* iter5= lista_iter_crear(lista5);
print_test("Probando que se creo el iter 5", iter5!=NULL);
for( int num=1; num <= 10 ; num++){
char elemento2[]="hola";
lista_insertar(lista5, iter5, &elemento2);
}
print_test("Probando largo de la lista 5", lista_largo(lista5) == 10 );
print_test("Probando que el iter 5 no este al final", lista_iter_al_final(iter5) == false);
char prueba2[] = "prueba";
print_test("Probando lista_borrar con el iter 5 al principio", lista_borrar(lista5,iter5) != NULL);
print_test("Probando lista_insertar con el iter 5 al principio", lista_insertar(lista5, iter5, &prueba2));
print_test("Probando lista_borrar con el iter 5 ", lista_borrar(lista5,iter5) == prueba2);
for (int j=0; j<=10; j++){
lista_borrar(lista5, iter5);
}
print_test("Probando largo de la lista 5", lista_largo(lista5) == 0 );
print_test("Probando que la lista 5 este vacia", lista_esta_vacia(lista5));
print_test("Probando lista ver_primero de la lista 5", lista_ver_primero(lista5) == NULL);
print_test("Probando avanzar con el iter 5 al final", lista_iter_avanzar(iter5) == false);
print_test("Probando avanzar con el iter 5 al final", lista_iter_ver_actual(iter5) == NULL);
// elimino el iter 5
lista_iter_destruir(iter5);
//Elimino la lista
lista_destruir(lista5, free);
/* ******************************************************************
* Pruebas con lista 6
* *****************************************************************/
// Creo una nueva Lista
lista_t* lista6 = lista_crear();
// le creo un iter
lista_iter_t* iter6= lista_iter_crear(lista6);
print_test("Probando que se creo el iter 6", iter6!=NULL);
void* elemento = malloc(sizeof(void*)) ;
print_test("Probando agregar un elemento con lista_insertar con la lista 6 vacia", lista_insertar(lista6, iter6, elemento));
print_test("Probando largo de la lista 6", lista_largo(lista6) == 1 );
print_test("Probando que el iter 6 no este al final", lista_iter_al_final(iter6) == false);
print_test("Probando si puedo avanzar con el iter 6", lista_iter_avanzar(iter6));
print_test("Probando que el iter 6 este al final", lista_iter_al_final(iter6));
void* borrar=lista_borrar_primero(lista6);
free(borrar);
// elimino el iter 6
lista_iter_destruir(iter6);
//Elimino la lista 6
lista_destruir(lista6, free);
/* ******************************************************************
* Pruebas con lista 7
* *****************************************************************/
lista_t* lista7 = lista_crear();
for (int x=1 ; x<=10 ; x++){
lista_insertar_primero(lista7, &x);
}
lista_iter_t* iter7 = lista_iter_crear(lista7);
print_test("Probando que el largo de la lista7 sea 10", lista_largo(lista7) == 10);
while (!lista_iter_al_final(iter7)){
lista_iter_avanzar(iter7);
}
void* y;
print_test("Probando si se puede ver el elemento actual del iter", lista_iter_ver_actual(iter7) == NULL);
print_test("Probando insetar un elemento al final de la lista7", lista_insertar(lista7, iter7, &y));
print_test("Probando que el largo de la lista7 sea 11", lista_largo(lista7) == 11);
print_test("Probando borrar el ultimo elemento de lista7", lista_borrar(lista7,iter7) == &y);
print_test("Probando que el largo de la lista7 sea 10", lista_largo(lista7) == 10);
print_test("Probando insetar un elemento al final de la lista7", lista_insertar(lista7, iter7, &y));
print_test("Probando que el iter7 no quede al final", lista_iter_al_final(iter7) == false);
lista_iter_destruir(iter7);
lista_destruir(lista7, NULL);
/* ******************************************************************
* Pruebas con lista 8
* *****************************************************************/
lista_t* lista8 = lista_crear();
for (int x=1 ; x<=5 ; x++){
lista_insertar_ultimo(lista8, &x);
}
print_test("Probando que el largo de la lista8 sea 5", lista_largo(lista8) == 5);
lista_iter_t* iter8 = lista_iter_crear(lista8);
int elem=0;
print_test("Probando que el elemento actual del iter8 no es null", lista_iter_ver_actual(iter8) != NULL);
print_test("Probando insertar al principio con el iter en lista8", lista_insertar(lista8, iter8, &elem));
print_test("Probando que el largo de lista8 sea 6", lista_largo(lista8) == 6);
print_test("Probando eliminar el primer elemento de la lista8 con el iter", lista_borrar(lista8, iter8) == &elem);
print_test("Probado que el largo de la lista8 es 5", lista_largo(lista8) == 5);
print_test("Probando insertar un elemento en la primera posicion de lista8", lista_insertar_primero(lista8, &elem));
print_test("Probando que el actual del iter8 sea distinto que el primero de lista8", lista_ver_primero(lista8) != lista_iter_ver_actual(iter8));
lista_iter_destruir(iter8);
lista_destruir(lista8 , NULL);
/* ******************************************************************
* Pruebas con lista 9
* *****************************************************************/
lista_t* lista9 = lista_crear();
int num;
print_test("Probando insertar el elemento en la lista9", lista_insertar_primero(lista9, &num));
print_test("Probando que el largo de lista9 es 1", lista_largo(lista9));
lista_iter_t* iter9 = lista_iter_crear(lista9);
print_test("Probando que el elemento actual del iter9 no es null", lista_iter_ver_actual(iter9) != NULL);
print_test("Probando borrar el elemento de lista9 con el iter", lista_borrar(lista9, iter9) == &num);
print_test("Probando que el largo de lista9 es 0", lista_largo(lista9) == 0);
print_test("Probando borrar un elemento de la lista9 que esta vacia", lista_borrar(lista9, iter9) == NULL);
print_test("Probando avanzar en lista9 que esta vacia", lista_iter_avanzar(iter9) == false);
print_test("Probando agregar un elemento con el iter9", lista_insertar(lista9, iter9, &num));
print_test("Probando eliminar el ultimo elemento con el iter9", lista_borrar(lista9, iter9) == &num);
print_test("Probando agregar un elemento en la lista9", lista_insertar_primero(lista9, &num));
print_test("Probando eliminar el ultimo elemento con borrar primero", lista_borrar_primero(lista9) == &num);
lista_iter_destruir(iter9);
lista_destruir(lista9 , NULL);
lista_t* lista10= lista_crear();
int i=0;
print_test("Probando agregar un elemento a lista10", lista_insertar_primero(lista10 , &i));
print_test("Probando eliminar primer elemento", lista_borrar_primero(lista10) != NULL);
lista_destruir(lista10, NULL);
}
