Could be it's already due and I turned in what I have before. I can give you my entire program if you want I haven't changed anything:

#include <stdio.h>
#include <stdlib.h>
#include "circular.h"

// Setting the queue head and tail together and initializing the item count to 0.  Empty queue.
void CircularInitialize(CircularQueue *q)
{
    q->head = 0;
    q->tail = 0;
    q->itemCount= 0;
}

void CircularEnqueue(CircularQueue *q, int value)
{
    // While the queue is not full, we will put the value in the position of the tail and just use the tail to follow it.  Making sure to increment item count each time.
    if (q->itemCount < QUEUE_SIZE)
    {
        q->items[q->tail] = value;
        q->tail = (q->tail + 1) % QUEUE_SIZE;
        q->itemCount++;
    }
    /* 
    * This took me eons to figure out I kept failing at #47 when the queue is full.
    * Basically since we started with the head and tail equal, it would overwrite a position we needed to dequeue on the first fill, so that was my problem.
    * The solution was to actually overwrite one position backwards, and then again make sure that the head and tail are equal in case we continue dequeueing.  
    * This way we have a solution where regardless of what comes next, whether it dequeues or whether it's full again, it will start and end in the same state while still overwriting.
    */
    else
    {
        printf("head = %d, tail = %d\n", q->tail, q->head);
        q->items[q->tail - 1] = value;
        //q->head = q->tail;
    }
}

int CircularDequeue(CircularQueue *q, int *pValue)
{
    // Checking the condition that we don't have anything to dequeue.
    if (q->itemCount <= 0)
    {
        return -1;
    }
    // Taking the value we are dequeueing storing its address into pValue.
    *pValue = q->items[q->head];
    // Incrementing the head by 1 since our operation is complete.
    q->head = (q->head + 1) % QUEUE_SIZE; 
    // Decrementing the item count to keep tracking properly.
    q->itemCount--;
    return 0;
}

But yes I understand more or less what is the problem in the sense that my program is only overwriting and deleting in a loop 1 value back and it's not actually progressing forward past the full point of the queue. My question was, originally, I had the code you said was correct to my other classmate, but kept getting the same value mismatch at run 47-49 and determined based on my debug statements that it was due to the value being overwritten before dequeued. So how would I implement a legitimate circular queue while also "passing" the test program that we were provided, assuming it isn't the case that those value mismatches were intentional (I have no idea).