ej Parcial cuatri pasado

Hola buenas, estoy teniendo problemas con este ejercicio de parcial del cuatri pasado, no da warnings pero no pasa los asserts agradeceria una ayuda.

miPrograma: test.c:22: main: Assertion `strcmp(nextByCounter(terminalA, 5), "Bar") == 0' failed.
Aborted

#include "ej1.h"
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <strings.h>
#include <string.h>

typedef struct listFirst * Plist;
typedef struct listFirst{
    Plist next;
    const char * name;
}listFirst;

typedef struct listHead * PlistHead;
typedef struct listHead{
    Plist first;
    Plist last;
    Plist iter;
    int dimPersonas;
}listHead;

typedef struct countersCDT{
    PlistHead vecDinamico;
    int Max;
}countersCDT;

Plist enterCounterLast(Plist last, const char * name);
void freeRec(Plist list);

countersADT newCounters(int maxCounters){
    if(maxCounters <= 0){
        return NULL;
    }
    countersADT new = calloc(1, sizeof(countersCDT));
    new->Max = maxCounters;
    new->vecDinamico = calloc(1, sizeof(listHead) * maxCounters);
    return new;
}

void enterCounter(countersADT counters, int counterNumber, const char * passenger){
    // lo ingresa al final.
    if(counterNumber<=0 || counterNumber > counters->Max){
        return;
    }

    if(counters->vecDinamico[counterNumber].dimPersonas == 0){
        counters->vecDinamico[counterNumber].last = enterCounterLast(counters->vecDinamico[counterNumber].last, passenger);
        counters->vecDinamico[counterNumber].first = counters->vecDinamico[counterNumber].last;
    } 

    counters->vecDinamico[counterNumber].last = enterCounterLast(counters->vecDinamico[counterNumber].last, passenger);
    counters->vecDinamico[counterNumber].dimPersonas++;
    return;
}

Plist enterCounterLast(Plist last, const char * name){

   Plist aux = calloc(1, sizeof(struct listFirst));
    aux->name = name;

    if(last != NULL){
    last->next = aux;
    }
    // aux->next == NULL; lo hace el calloc.
    return aux;

}

void toBeginByCounter(countersADT counters, int counterNumber){
    if(counterNumber<=0 || counterNumber > counters->Max){
        return;
    }
    counters->vecDinamico[counterNumber].iter = counters->vecDinamico[counterNumber].first;
    return;

}

int hasNextByCounter(const countersADT counters, int counterNumber){
    return (counters->vecDinamico[counterNumber].iter != NULL);
}

const char *nextByCounter(countersADT counters, int counterNumber) {
    if (hasNextByCounter(counters, counterNumber)) {
        const char *aux = counters->vecDinamico[counterNumber].iter->name;
        counters->vecDinamico[counterNumber].iter = counters->vecDinamico[counterNumber].iter->next;
        return aux;
    }
    return NULL;
}

/*
struct checkInResult {
    int counterNumber;
    const char * checkedInPassenger;
    int waitingPassengers;
};
*/

struct checkInResult *checkInCounters(countersADT counters, int *checkInResultDim) {
    struct checkInResult *aux = NULL;
    int auxcheck = 0;
    for (int i = 0; i < counters->Max; i++) {
        if (counters->vecDinamico[i].dimPersonas > 0) {
            aux = realloc(aux, (auxcheck + 1) * sizeof(struct checkInResult));
            aux[auxcheck].counterNumber = i;
            aux[auxcheck].checkedInPassenger = counters->vecDinamico[i].first->name; // No se asigna nueva memoria para el string.
            aux[auxcheck].waitingPassengers = counters->vecDinamico[i].dimPersonas;
            auxcheck++;
        }
    }
    *checkInResultDim = auxcheck;
    return aux;
}

void freeCounters(countersADT counters){
    for(int i = 0 ; i<counters->Max ; i++){
        freeRec(counters->vecDinamico[i].first);
    }
    free(counters);
}

void freeRec(Plist list) {
    if (list == NULL) {
        return;
    }
    freeRec(list->next);
    free(list);
}

typedef struct countersCDT * countersADT;

/* Crea un sistema de administración de mostradores a partir de la cantidad
* máxima #maxCounters de mostradores que tendrá el aeropuerto.
* Se asume que la gran mayoría de los mostradores serán utilizados por las aerolíneas.
* Si maxCounters es cero retorna NULL.
*/
countersADT newCounters(int maxCounters);

/* Ingresa al pasajero #passenger en la cola de espera del mostrador #counterNumber
* para luego poder hacer el checkIn de su vuelo.
* Un mismo pasajero puede ingresar múltiples veces al mismo mostrador o a varios
* mostradores distintos.
* Se asume que los nombres de los pasajeros son cortos.
* Falla si #counterNumber es mayor o igual a la cantidad máxima de mostradores.
*/
void enterCounter(countersADT counters, int counterNumber, const char * passenger);

/* Funciones de iteración para poder consultar para un mostrador los pasajeros que están
* esperando, en ORDEN DE LLEGADA (ver ejemplo en programa de prueba)
*/
void toBeginByCounter(countersADT counters, int counterNumber);
int hasNextByCounter(const countersADT counters, int counterNumber);
const char * nextByCounter(countersADT counters, int counterNumber);

/* Para cada mostrador, realiza el checkIn del pasajero que está esperando primero en la
* cola, si es que hay al menos un pasajero esperando en ese mostrador.
* Retorna un arreglo donde, para cada mostrador donde se hizo checkIn, se indica:
* - El número del mostrador
* - El nombre del pasajero que hizo checkIn en el mostrador y salió de la cola de espera
* - La cantidad de pasajeros esperando en el mostrador luego de la operación
* respetando el ORDEN ASCENDENTE por número de mostrador
* Deja en un parámetro de entrada/salida la dimensión del vector de retorno
*/

struct checkInResult {
    int counterNumber;
    const char * checkedInPassenger;
    int waitingPassengers;
};

struct checkInResult * checkInCounters(countersADT counters, int * checkInResultDim);

/*
 Libera los recursos utilizados por el TAD
*/

void freeCounters(countersADT counters);

#include "ej1.h"
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <strings.h>
#include <string.h>

int main(void) {
countersADT terminalA = newCounters(10);
enterCounter(terminalA, 5, "Foo"); // "Foo" ingresa a la cola del mostrador 5
enterCounter(terminalA, 5, "Bar");
enterCounter(terminalA, 5, "Bar");
enterCounter(terminalA, 4, "Abc");
enterCounter(terminalA, 4, "Xyz");
// Se desea consultar los pasajeros que están esperando en el mostrador 5
toBeginByCounter(terminalA, 5);
// "Foo" es el primero que ingresó al mostrador 5
assert(hasNextByCounter(terminalA, 5) == 1);
assert(strcmp(nextByCounter(terminalA, 5), "Foo") == 0);
assert(hasNextByCounter(terminalA, 5) == 1);
assert(strcmp(nextByCounter(terminalA, 5), "Bar") == 0);
toBeginByCounter(terminalA, 4);
assert(hasNextByCounter(terminalA, 4) == 1);
assert(strcmp(nextByCounter(terminalA, 4), "Abc") == 0);
// Se pueden usar en simultáneo las funciones de iteración para consultar
// los pasajeros que están esperando en distintos mostradores
assert(hasNextByCounter(terminalA, 5) == 1);
assert(strcmp(nextByCounter(terminalA, 5), "Bar") == 0);
assert(hasNextByCounter(terminalA, 4) == 1);
assert(strcmp(nextByCounter(terminalA, 4), "Xyz") == 0);
assert(hasNextByCounter(terminalA, 5) == 0);
assert(hasNextByCounter(terminalA, 4) == 0);
// Se realiza, para cada mostrador, el checkIn del pasajero que está primero
// esperando en la cola
int checkInResultDim;
struct checkInResult * checkInResultVec;
checkInResultVec = checkInCounters(terminalA, &checkInResultDim);
assert(checkInResultDim == 2); // Se realizó el checkIn en dos mostradores: 4 y 5
// Resultado del checkIn en el mostrador 4
assert(checkInResultVec[0].counterNumber == 4);
assert(checkInResultVec[0].waitingPassengers == 1);
assert(strcmp(checkInResultVec[0].checkedInPassenger, "Abc") == 0);

// Resultado del checkIn en el mostrador 5
assert(checkInResultVec[1].counterNumber == 5);
assert(checkInResultVec[1].waitingPassengers == 2);
assert(strcmp(checkInResultVec[1].checkedInPassenger, "Foo") == 0);
free(checkInResultVec);
toBeginByCounter(terminalA, 5);
toBeginByCounter(terminalA, 4);
assert(strcmp(nextByCounter(terminalA, 5), "Bar") == 0);
assert(strcmp(nextByCounter(terminalA, 4), "Xyz") == 0);
checkInResultVec = checkInCounters(terminalA, &checkInResultDim);
assert(checkInResultDim == 2); // Se hizo checkIn en dos mostradores: 4 y 5
// Resultado del checkIn en el mostrador 4
assert(checkInResultVec[0].counterNumber == 4);
assert(checkInResultVec[0].waitingPassengers == 0);
assert(strcmp(checkInResultVec[0].checkedInPassenger, "Xyz") == 0);
// Resultado del checkIn en el mostrador 5
assert(checkInResultVec[1].counterNumber == 5);
assert(checkInResultVec[1].waitingPassengers == 1);
assert(strcmp(checkInResultVec[1].checkedInPassenger, "Bar") == 0);
free(checkInResultVec);
toBeginByCounter(terminalA, 5);
toBeginByCounter(terminalA, 4);
assert(strcmp(nextByCounter(terminalA, 5), "Bar") == 0);
assert(hasNextByCounter(terminalA, 4) == 0);
checkInResultVec = checkInCounters(terminalA, &checkInResultDim);
assert(checkInResultDim == 1);
// Resultado del checkIn en el mostrador 5
assert(checkInResultVec[0].counterNumber == 5);
assert(checkInResultVec[0].waitingPassengers == 0);
assert(strcmp(checkInResultVec[0].checkedInPassenger, "Bar") == 0);
free(checkInResultVec);
toBeginByCounter(terminalA, 5);
toBeginByCounter(terminalA, 4);
assert(hasNextByCounter(terminalA, 5) == 0);
assert(hasNextByCounter(terminalA, 4) == 0);
checkInResultVec = checkInCounters(terminalA, &checkInResultDim);
assert(checkInResultDim == 0); // Ningún mostrador hizo checkIn
assert(checkInResultVec == NULL);
freeCounters(terminalA);
return 0;
}

PI-ITBA / 2024_02

ej Parcial cuatri pasado #170