/*Free functions*/
void destroySet(int lines, Cache destroyMe, int assoc){
if(destroyMe->nextLevel!=NULL){
/*need to determine kind*/
if(strcmp(destroyMe->nextLevel->type, "direct")==0){
destroyDirect(destroyMe->nextLevel->numofSet, destroyMe->nextLevel, destroyMe->nextLevel->assoc);
}
if((strlen(destroyMe->nextLevel->type)>=7)&&(strncmp(destroyMe->nextLevel->type,"assoc:", 5)==0)){
// printf("I came here");
destroySet(destroyMe->nextLevel->numofSet, destroyMe->nextLevel, destroyMe->nextLevel->assoc);
}
if((strlen(destroyMe->nextLevel->type)==5)&& (strcmp(destroyMe->nextLevel->type,"assoc")==0)){
destroySet(destroyMe->nextLevel->numofSet, destroyMe->nextLevel, destroyMe->nextLevel->assoc);
}
}
for (int i=0;i<lines;i++){
if((strlen(destroyMe->type)>=7)&&(strncmp(destroyMe->type,"assoc:", 5)==0)){
/*destroy dll for each individual set*/
if(destroyMe->blocks[i]->LRU!=NULL){
SLDestroy(destroyMe->blocks[i]->LRU);
destroyMe->blocks[i]->LRU=NULL;
}
else{
destroyQueue(destroyMe->blocks[i]->FIFO);
destroyMe->blocks[i]->FIFO=NULL;
}
/*destroy queue for each individual set*/
}
free(destroyMe->blocks[i]);
}
/*destroy FA's fifo or lru*/
if((strcmp(destroyMe->type,"FA")==0)||((strlen(destroyMe->type)==5)&& (strcmp(destroyMe->type,"assoc")==0))){
/*only for FA*/
if(destroyMe->LRU!=NULL){
SLDestroy(destroyMe->LRU);
destroyMe->LRU=NULL;
}
else{
destroyQueue(destroyMe->FIFO);
destroyMe->FIFO=NULL;
}
}
free(destroyMe->blocks);
free(destroyMe);
destroyMe=NULL;
return;
}
static void _traverseBFT (BSTNODE* root, void (*process) (PACKAGE* package) )
{
BSTNODE* currentNode;
BSTNODE* tempNode;
QUEUE* queue;
queue = createQueue();
if(!queue)
{
printf("\nMemory Overflow!\n");
exit(201);
}
currentNode = root;
while(currentNode != NULL)
{
process ( currentNode->ptrPackage );
if(currentNode->left != NULL)
enqueue(queue, currentNode->left);
if(currentNode->right != NULL)
enqueue(queue, currentNode->right);
if(!emptyQueue(queue))
{
dequeue(queue, (void**)&tempNode);
currentNode = tempNode;
}
else currentNode = NULL;
}
queue = destroyQueue(queue);
return;
}// _traverseBFT
int main(void) {
QueuePtr queue = initQueue();
char buffer[20];
char sel = 0;
while (sel != 'X'&&sel!='x') {
printf("+++ Queue +++\n");
printQueue(queue);
printf("++++++\n");
printf("1) Enqueue printID\n");
printf("2) Enqueue printHello\n");
printf("3) Enqueue printDate\n");
printf("4) Dequeue and execute\n");
printf("X) Exit\n");
sel = getchar();
while (getchar() != '\n');
switch (sel) {
case '1':
enqueue(queue, printID, "printID");
break;
case '2':
enqueue(queue, printHello, "printHello");
break;
case '3':
enqueue(queue, printDate, "printDate");
break;
case '4':
dequeue(queue, buffer);
if(buffer[0]!='\0'&&buffer[0]!=NULL){
printf("Executed: %s\n",buffer);
}
}
}
destroyQueue(queue);
return 0;
}
int main() {
char *array[] = {"mona", "is", "the", "best", "yes", "and", "that", "is", "the", "total", "truth", "ikram", "a3"};
queueNode *myQueue; /*creates a queue*/
int i; /*interator to add elements to the queue*/
myQueue = createQueue(compareTest, copy, destroy);
for (i = 0; i < 13; i++)
enqueue(myQueue, array[i]);
printf("\nafter elements added...\n");
printQueue(myQueue, printTest);
dequeue(myQueue);
dequeue(myQueue);
dequeue(myQueue);
dequeue(myQueue);
dequeue(myQueue);
printf("\nafter 4 elements deleted...\n");
printQueue(myQueue, printTest);
destroyQueue(myQueue);
return 0;
}
void destroyQueue( process * list ) {
if( list == NULL )
return;
destroyQueue(list->next);
free(list->name);
free(list);
return;
}
/*
command line args: threads, infile, outfile
*/
int main(int argc, char** argv){
listSize = 0;
srand(time(NULL));
initQueue();
list = getList(argv[2]);
numThreads = atoi(argv[1]);
pthread_t pool[numThreads];
mailbox = malloc(sizeof(struct qnode) * numThreads);
lock = malloc(sizeof(pthread_mutex_t) * numThreads);
pthread_mutex_init(&qlock, NULL);
int t = 0;
int *args = malloc(sizeof(int) * numThreads);
for(; t < numThreads; t++){
args[t] = t;
pthread_mutex_init(&lock[t], NULL);
mailbox[t].start = -1;
mailbox[t].end = -1;
pthread_create(&pool[t], NULL, &bootstrap, &args[t]);
}
for(t = 0; t < numThreads; t++){
pthread_join(pool[t], NULL);
pthread_mutex_destroy(&lock[t]);
}
pthread_mutex_destroy(&qlock);
writeList(argv[3], list);
free(list);
free(args);
free(lock);
free(mailbox);
destroyQueue();
return 0;
}
void levelOrderNonRecur(struct binaryTreeNode *root) {
struct binaryTreeNode *temp;
struct Queue *q = createQueue();
if (!root)
return;
enQueue(q, root);
while (!isEmptyQueue(q)) {
temp = deQueue(q);
//Process current node
printf("%d ", temp->data);
if (temp->left)
enQueue(q, temp->left);
if (temp->right)
enQueue(q, temp->right);
}
destroyQueue(q);
}
/*
find deepest node in binary tree
Time Complexity: O(n)
Space Complexity: O(n)
*/
struct binaryTreeNode *deepestNodeInBT(struct binaryTreeNode *root) {
struct binaryTreeNode *temp;
struct Queue *q;
if (!root)
return NULL;
q = createQueue();
enQueue(q, root);
while (!isEmptyQueue(q)) {
temp = deQueue(q);
if (temp->left)
enQueue(q, temp->left);
if (temp->right)
enQueue(q, temp->right);
}
destroyQueue(q);
return temp;
}
void lQueueTestMain()
{
SqQueue<float> Q;
initQueue(Q);
for(int i=0;i<18;++i)
enQueue(Q,3.14f*i);
queueTraverse(Q);
float a;
for(int i=0;i<4;++i)
deQueue(Q,a);
queueTraverse(Q);
cout<<queueLength(Q)<<endl;
getQueueHead(Q,a);
cout<<a<<endl;
clearQueue(Q);
destroyQueue(Q);
int aa=100;
}
int main()
{
queue* Q = createQueue();
int i;
do
{
printf("(1)enQueue (2)deQueue (3)getElement (4)clearQueue (5)traverse (6)length (7)exit : ");
scanf("%d", &i);
if (i == 1)
{
element ele;
int temp;
scanf("%d", &temp);
ele.val = temp;
enQueue(Q, ele);
}
else if (i == 2)
printf("%s\n", deQueue(Q) ? "success" : "fail");
else if (i == 3)
printf("%d\n", getElement(Q).val);
else if (i == 4)
clearQueue(Q);
else if (i == 5)
{
traverseQueue(Q, printElement);
putchar('\n');
}
else if(i == 6)
printf("%d\n",getLength(Q));
} while (i != 7);
destroyQueue(Q);
return 0;
}
void BFSTraverse(graph *g, void (*visitFunc)(char e))
{
visitFunc = print;
int v = 0, w = 0;
for(v = 0; v < g->verNum; v++)
visited[v] = 0;
char elem;
queue *q = NULL;
q = initQueue(q);
for(v = 0; v < g->verNum; v++)
{
if(!visited[v])
{
(*visitFunc)(g->vertex[v]);
visited[v] = 1;
enQueue(q, g->vertex[v]);
}
while(!queueEmpty(*q))
{
deQueue(q, &elem);
v = findIndex(*g, elem);
if(v != -1)
{
for(w = firstAdjVex(g, v); w >= 0; w = nextAdjVex(g, v, w))
{
if(!visited[w])
{
visited[w] = 1;
(*visitFunc)(g->vertex[w]);
enQueue(q, g->vertex[w]);
}
}
}
}
}
destroyQueue(q);
}
/*
Get the number of full node within binary tree
Time Complexity: O(n)
Space Complexity: O(n)
*/
int fullNodeNumberInBt(struct binaryTreeNode *root) {
struct binaryTreeNode *temp;
struct Queue *q;
int count = 0;
if (!root)
return 0;
q = createQueue();
enQueue(q, root);
while(!isEmptyQueue(q)) {
temp = deQueue(q);
if (temp->left && temp->right)
count++;
if (temp->left)
enQueue(q, temp->left);
if (temp->right)
enQueue(q, temp->right);
}
destroyQueue(q);
return count;
}
int main(void)
{
Queue *queueOne = NULL, *queueTwo = NULL;
node *persOne = NULL, *persTwo = NULL, *persThree, *firstPersOut = NULL;
int i;
int stationOne = 0, stationTwo = 0, stationThree = 0;
int totTime = 0;
printf("\nAirport Security Checkpoint Simulator\n");
printf("=====================================\n\n");
queueOne = createQueue();
queueTwo = createQueue();
srand( (unsigned)time(NULL) );
/* Assign random values to each person in the queue, between 60 and 180 seconds */
for (i = 0 ; i < 1000 ; i++)
{
int num = 0;
num = rand()%(180-60) + 60;
enqueue(queueOne, num);
}
printf("Number of people in line: %d\n", getLength(queueOne));
persOne = dequeue(queueOne);
stationOne = persOne->nodeValue;
enqueue(queueTwo, persOne->nodeValue);
persTwo = dequeue(queueOne);
stationTwo = persTwo->nodeValue;
enqueue(queueTwo, persTwo->nodeValue);
while (getLength(queueOne) != 0)
{
stationOne--;
stationTwo--;
if (stationOne == 0)
{
firstPersOut = persOne;
persOne = dequeue(queueOne);
stationOne = persOne->nodeValue;
enqueue(queueTwo, firstPersOut->nodeValue);
}
else if (stationTwo == 0)
{
firstPersOut = persTwo;
persTwo = dequeue(queueOne);
stationTwo = persTwo->nodeValue;
enqueue(queueTwo, firstPersOut->nodeValue);
}
totTime++;
}
destroyQueue(queueOne);
printf("Total Time for Two Stations: %.2f virtual minutes\n", (totTime/60.0));
/* Test with 3 stations */
totTime = 0;
persOne = dequeue(queueTwo);
stationOne = persOne->nodeValue;
persTwo = dequeue(queueTwo);
stationTwo = persTwo->nodeValue;
persThree = dequeue(queueTwo);
stationThree = persThree->nodeValue;
while (getLength(queueTwo) != 0)
{
stationOne--;
stationTwo--;
stationThree--;
if (stationOne == 0)
{
firstPersOut = persOne;
persOne = dequeue(queueTwo);
stationOne = persOne->nodeValue;
}
else if (stationTwo == 0)
{
firstPersOut = persTwo;
persTwo = dequeue(queueTwo);
stationTwo = persTwo->nodeValue;
}
else if (stationThree == 0)
{
firstPersOut = persThree;
persThree = dequeue(queueTwo);
stationThree = persThree->nodeValue;
}
totTime++;
}
printf("Total Time for three Stations: %.2f virtual minutes\n", (totTime/60.0));
destroyQueue(queueTwo);
return (EXIT_SUCCESS);
}
int main(int argc, char * argv[]) {
//so many variables :S
process * waitQueue = NULL; //process waiting to be loaded
process * memQueue = NULL; //list of processes in memory
process * endQueue = NULL; //processes that have been laoded three times; if any
process * workingProc = NULL; //process currently being operated on
process * tempProc = NULL; //temp variable for swapping
int i,k; //iterators
int numLoads = 0; //number of loads completed
int processes = 0; //number of process currently loaded
int totalProcesses = 0; //cumulative process loaded across all operations
int insertIndex = -1; //the index where the process will be put into memory
int holes = 0; //current number of holes
int currentHole = 0; //currently selected hole
int mostSuitedHole = -1; //hole most suited for a process, used only by best/worst fit
int totalHoles = 0; //total number of holes across all operations
int memory[128]; //array representing memory
int memUsage = 0; //amount of memory being used
int totalMemUsage = 0; //cumulative usage across all operations
FILE * fp; //file pointer is a file pointer
for( k = 0; k < 4; k++ ) { //loop once for each memory management method
//k = 0: first fit; 1: best fit; 2: next fit; 3: worst fit
for( i = 0; i < 128; i++ ) { //memory initialisation
memory[i] = 0;
}
fp = fopen( argv[1], "r" );
if( fp == NULL ) { //teriminate if no file was entered on the command line
printf("No file entered\n");
return 0;
}
waitQueue = readFile(fp);
if( k == 0 ) { //DEBUG
print(waitQueue);
printf("\n");
} //END DEBUG
while( waitQueue != NULL && k != 2 ) { //loop until all processes are in memory or have been completed
workingProc = popFromQueue( &waitQueue ); //pop the next process from the ready queue
while( insertIndex == -1 ) { //loop until a suitable hole has been found
if( k == 0 && workingProc->size <= holeSize(memory, currentHole) ) { //first fit, simply if hole fits the process
insertIndex = currentHole;
} else if ( k == 1 && workingProc->size <= holeSize(memory, currentHole) ) { //best fit, will rotate throguh all of memory first
if( mostSuitedHole == -1 ) { //first hole that meets criteria
mostSuitedHole = currentHole;
} else if (holeSize(memory, currentHole) < holeSize(memory, mostSuitedHole)) { //curhole is a better fit
mostSuitedHole = currentHole;
}
if( currentHole == nextHole(memory, currentHole)) {
insertIndex = mostSuitedHole;
}
} else if ( k == 3 && workingProc->size <= holeSize(memory, currentHole) ) { //best fit, will rotate throguh all of memory first
if( mostSuitedHole == -1 ) { //first hole that meets criteria
mostSuitedHole = currentHole;
} else if (holeSize(memory, currentHole) > holeSize(memory, mostSuitedHole)) { //curhole is a better fit
mostSuitedHole = currentHole;
}
if( currentHole == nextHole(memory, currentHole)) {
insertIndex = mostSuitedHole;
}
}
if( k != 2 && currentHole == nextHole(memory, currentHole) && insertIndex == -1 ) { //if no valid hole is found above
//swap oldest process out
tempProc = popFromQueue(&memQueue);
if( tempProc->loaded != 3 ) { //not the third time its been swapped
waitQueue = addToQueue(waitQueue, tempProc); //send it to the wait list
} else {
endQueue = addToQueue(endQueue, tempProc);
}
CLEARMEMORY(tempProc->start, tempProc->end); //unset its memory
processes--;
memUsage -= tempProc->size;
}
if( currentHole == nextHole(memory, currentHole) ) {
currentHole = 0;
} else {
currentHole = nextHole(memory, currentHole);
}
}
if( k != 2 ) //only if not working under next fit, we reset the chosen hole everytime
currentHole = 0;
//a spot has been found
//data tracking
numLoads++;
processes++;
holes = countHoles(memory);
totalProcesses += processes;
totalHoles += holes;
memUsage += workingProc->size;
totalMemUsage += memUsage;
//annoucement
printf("%s loaded, #processes = %d, #holes = %d, %%memusage = %.0f, cumulative %%memusage = %.0f\n", workingProc->name, processes, holes, (float)memUsage / 128.0 * 100, \
((float) totalMemUsage / (float)numLoads) / 128.0 * 100 );
//inserting process
workingProc->start = insertIndex;
workingProc->end = workingProc->start + workingProc->size;
workingProc->loaded++;
SETMEMORY(workingProc->start, workingProc->end);
memQueue = addToQueue( memQueue, workingProc );
mostSuitedHole = -1;
insertIndex = -1;
}
switch(k) {
case 0: printf("\nFirst Fit \n"); break;
case 1: printf("\nBest Fit\n"); break;
case 2: printf("\nNext Fit - not implemented\n"); break;
case 3: printf("\nWorst Fit\n"); break;
}
printf("Total loads = %d, average #processes = %.1f, average #holes = %.1f, cumulative %%memory = %.0f\n\n", numLoads, (float)totalProcesses / (float)numLoads, \
(float)totalHoles / (float)numLoads, ((float) totalMemUsage / (float)numLoads / 128.0 * 100) );
fclose(fp);
destroyQueue(waitQueue);
destroyQueue(memQueue);
destroyQueue(endQueue);
waitQueue = NULL;
memQueue = NULL;
endQueue = NULL;
numLoads = 0;
processes = 0;
totalProcesses = 0;
insertIndex = -1;
holes = 0;
currentHole = 0;
mostSuitedHole = -1;
totalHoles = 0;
memUsage = 0;
totalMemUsage = 0;
}
return 0;
}
int main() {
// create the tree
struct TreeNode *root = NULL;
root = (struct TreeNode *)malloc(sizeof(struct TreeNode));
root->data = 1;
root->left = (struct TreeNode *)malloc(sizeof(struct TreeNode));
(root->left)->data = 2;
(root->left)->right = NULL;
(root->left)->left = (struct TreeNode *)malloc(sizeof(struct TreeNode));
((root->left)->left)->data = 4;
((root->left)->left)->left = NULL;
((root->left)->left)->right = NULL;
(root->left)->right = (struct TreeNode *)malloc(sizeof(struct TreeNode));
((root->left)->right)->data = 5;
((root->left)->right)->left = NULL;
((root->left)->right)->right = NULL;
(root->right) = (struct TreeNode *)malloc(sizeof(struct TreeNode));
(root->right)->data = 3;
(root->right)->right = NULL;
(root->right)->left = (struct TreeNode *)malloc(sizeof(struct TreeNode));
((root->right)->left)->data = 6;
((root->right)->left)->left = NULL;
((root->right)->left)->right = NULL;
(root->right)->right = (struct TreeNode *)malloc(sizeof(struct TreeNode));
((root->right)->right)->data = 7;
((root->right)->right)->left = NULL;
((root->right)->right)->right = NULL;
printf(" 1 \n");
printf(" / \\ \n");
printf(" 2 3 \n");
printf(" / \\ / \\ \n");
printf("4 5 6 7 \n");
printf("\nPreOrder Traversal\n");
preOrderTraversal(root);
printf("\n");
printf("InOrder Traversal\n");
inOrderTraversal(root);
printf("\n");
printf("PostOrder Traversal\n");
postOrderTraversal(root);
printf("\n");
printf("LevelOrder Traversal\n");
struct TreeNode *temp = NULL;
struct Queue *queue = createQueue();
enqueue(queue, root);
while(queue->front != NULL) {
temp = dequeue(queue);
printf(" %d ", temp->data);
if(temp->left != NULL) {
enqueue(queue, temp->left);
}
if(temp->right != NULL) {
enqueue(queue, temp->right);
}
}
printf("\n");
destroyQueue(&queue);
return 0;
}
int search(struct position source, struct position target, int (*blocked)(struct position))
{
struct position current;
current = source;
Dict d;
d = DictCreate();
PQ* q;
q = initQueue();
heapNode hn;
hn.distFromSource = 0;
hn.value = abs(current.x - target.x) + abs(current.y - target.y);
hn.pos = current;
enqueue(hn,q);
DictInsert(d,current.x,current.y,hn.distFromSource);
while(q->size) //stops when priority queue is empty
{
int i;
hn = dequeue(q);
current = hn.pos;
if(foundTarget(current,target)) //hooray! target found!!
{
DictDestroy(d);
destroyQueue(q);
return hn.distFromSource;
}
for(i = 0; i < 4; i++) //for loop explores all the four neighbors defined as 0...3
{
struct position neighbor = createNeighbor(current,i);
int dictSearchDist = DictSearch(d,neighbor.x,neighbor.y);
if(!blocked(neighbor) && dictSearchDist < 0) //add the neighbor to PQ
{
DictInsert(d,neighbor.x,neighbor.y,hn.distFromSource + 1);
heapNode node;
int distToTarget = abs(neighbor.x - target.x) + abs(neighbor.y - target.y); //manhattan distance
node.value = (hn.distFromSource + 1) + distToTarget;
node.pos = neighbor;
node.distFromSource = hn.distFromSource + 1;
enqueue(node,q);
}
else if(dictSearchDist >= 0)
{
if(dictSearchDist > hn.distFromSource + 1)
{
DictInsert(d,neighbor.x,neighbor.y,hn.distFromSource + 1);
heapNode node;
int distToTarget = abs(neighbor.x - target.x) + abs(neighbor.y - target.y); //manhattan distance
node.value = (hn.distFromSource + 1) + distToTarget;
node.pos = neighbor;
node.distFromSource = hn.distFromSource + 1;
enqueue(node,q);
}
}
}
}
DictDestroy(d);
destroyQueue(q);
return NO_PATH;
}
int sthread_sem_destroy(sthread_sem_t *sem)
{
destroyQueue(sem->sem_queue);
free ((void *)sem->mutex);
return 0;
}
///////////////////////////////////////////////////////////////////////////////
//
// MAIN
//
///////////////////////////////////////////////////////////////////////////////
int main(int argc, char *argv[]) {
// Обработка сигнала
struct sigaction act;
memset(&act, 0, sizeof(act));
act.sa_handler = handleSigInt;
sigaction(SIGINT, &act, 0);
// Проверка количества аргументов
if (argc < 4) {
fprintf(stderr, "Too few arguments\n");
exit(EXIT_FAILURE);
}
// Количество потоков - 1й параметр запуска
int numberOfWorkers = atoi(argv[1]);
// Порт - 2й параметр запуска
char port[4];
strcpy(port, argv[2]);
// Путь к файлу с паролями - 3й параметр запуска
readPasswordsFromFile(argv[3]);
// Инициализация connections
memset(connections, 0, sizeof(connections));
struct addrinfo* addresses = getAvailableAddresses(port);
if (!addresses)
exit(EXIT_FAILURE);
// Получаем дескриптор сокета
int _socketfd = getSocket(addresses);
if (_socketfd == -1) {
exit(EXIT_FAILURE);
}
setSocketFd(_socketfd);
// Начинаем слушать сокет
if (listen(socketfd, SOMAXCONN) == -1) {
perror("listen\n");
exit(EXIT_FAILURE);
}
// Создаём потоки
pthread_t workers[numberOfWorkers];
pthread_mutex_t mutex;
pthread_mutexattr_t mutexattr;
pthread_mutexattr_init(&mutexattr);
pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_ERRORCHECK);
pthread_mutex_init(&mutex, &mutexattr);
pthread_mutex_init(&connectionsMutex, &mutexattr);
pthread_cond_t condition;
pthread_cond_init(&condition, NULL);
// Создаём отдельный поток для отслеживания таймаута соединений
pthread_t timeoutWatcher;
pthread_create(&timeoutWatcher, NULL, watchTimeout, NULL);
// Создаём очередь
struct Queue queue;
initQueue(&queue, sizeof(struct epoll_event));
struct WorkerArgs workerArgs;
initWorkerArgs(&workerArgs, &queue, &mutex, &condition);
for (int i = 0; i < sizeof(workers) / sizeof(pthread_t); i++) {
pthread_create(&workers[i], NULL, worker, (void *) &workerArgs);
}
// Создаём epoll
int _epollfd = epoll_create1(0);
if (_epollfd == -1) {
perror("epoll_create error\n");
exit(EXIT_FAILURE);
}
setEpollFd(_epollfd);
// Добавляем сокет в epoll
if (addToEpoll(epollfd, socketfd, EPOLLET | EPOLLIN) == -1)
exit(EXIT_FAILURE);
int maxEventNum = numberOfWorkers;
struct epoll_event events[maxEventNum];
int timeout = -1;
printf("Main thread: %d\n", (int)pthread_self());
while(!done) {
int eventsNumber = epoll_wait(epollfd, events, maxEventNum, timeout);
if (!eventsNumber)
printf("No events\n");
for (int i = 0; i < eventsNumber; i++) {
pthread_mutex_lock(&mutex);
pushQueue(&queue, &events[i]);
pthread_cond_signal(&condition);
pthread_mutex_unlock(&mutex);
}
}
// Освобождение ресурсов
pthread_mutex_destroy(&connectionsMutex);
pthread_mutex_destroy(&mutex);
pthread_mutexattr_destroy(&mutexattr);
free(passPairs);
destroyQueue(&queue);
close(socketfd);
close(epollfd);
printf("DONE!!!");
return 0;
}
int main( void )
{
QUEUE *queue;
QUEUE_NODE *queueNode;
void* dataInPtr;
void* dataOutPtr;
int queue_status;
int queue_element_count;
queue = createQueue ();
//a.print queue status, Empty
printf("Test Case(a) : Print queue status, Empty\n\n");
queue_status = emptyQueue(queue);
if(queue_status == 1)
{
printf("queue status : Empty\n");
}
else
{
printf("queue status : not empty\n");
}
printf("\n\n");
//b.Dequeue and print data. Should return error
printf("Test Case(b) : Dequeue and print data\n\n");
dequeue( queue, &dataOutPtr );
printf("\n\n");
//c. Enqueue data into queue
printf("Test Case(c) : Enqueue data into queue : Ann\n\n");
dataInPtr = (char*)calloc((strlen("Ann")+1), sizeof(char) );
strcpy(dataInPtr, "Ann");
enqueue( queue, dataInPtr);
//d. Enqueue data into queue
printf("Test Case(d) : Enqueue data into queue : Bob\n\n");
dataInPtr = (char*)calloc(strlen("Bob")+1, sizeof(char) );
strcpy(dataInPtr, "Bob");
enqueue( queue, dataInPtr);
//e.Print queue status, Empty
printf("Test Case(e) : Print queue status, Empty\n\n");
queue_status = emptyQueue(queue);
if(queue_status == 1)
{
printf("queue status : Empty\n");
}
else
{
printf("queue status : not empty\n");
}
printf("\n\n");
//f.Print queue status, Full
printf("Test Case(f) : Print queue status, Full\n\n");
queue_status = fullQueue( queue );
if(queue_status == 1)
{
printf("queue status : Full\n");
}
else
{
printf("queue status : not full\n");
}
printf("\n\n");
//g. Print data at the front
printf("Test Case(g) : Print data at the front\n\n");
queueFront ( queue, &dataOutPtr );
printf("Data at the queue front is : %s\n", queue->front->dataPtr);
printf("\n\n");
//h. Print data at the rear
printf("Test Case(h) : Print data at the rear\n\n");
queueRear ( queue, &dataOutPtr );
printf("Data at the queue rear is : %s\n", queue->rear->dataPtr);
printf("\n\n");
//i. Print entire queue
printf("Test Case(i) : Print entire queue\n\n");
printf("The entire queue is : ");
queueNode = queue->front;
while(queueNode != NULL)
{
printf("%s ", queueNode->dataPtr);
queueNode = queueNode->link;
}
printf("\n\n");
//j.Print number of element in queue
printf("Test Case(j) : Print number of element in queue\n\n");
queue_element_count = queueCount( queue );
printf("total no of element in queue is %d\n", queue_element_count);
printf("\n\n");
//k.Dequeue and print data
printf("Test Case(k) : Dequeue and print data\n\n");
dequeue( queue, &dataOutPtr );
printf("after dequeueing we got : %s\n", dataOutPtr);
free(dataOutPtr);
printf("\n\n");
//l.Dequeue and print data
printf("Test Case(l) : Dequeue and print data\n\n");
dequeue( queue, &dataOutPtr );
printf("after dequeueing we got : %s\n", dataOutPtr);
free(dataOutPtr);
printf("\n\n");
//m.Dequeue and print data
printf("Test Case(m) : Dequeue and print data\n\n");
dequeue( queue, &dataOutPtr );
printf("\n\n");
//n. Enqueue data into queue
printf("Test Case(n) : Enqueue and print data : Dan\n\n");
dataInPtr = (char*)calloc(strlen("Dan")+1, sizeof(char) );
strcpy(dataInPtr, "Dan");
enqueue( queue, dataInPtr );
//o. Print data at the front
printf("Test Case(o) : Print data at the front\n\n");
queueFront ( queue, &dataOutPtr );
printf("Data at the queue front is : %s\n", queue->front->dataPtr);
printf("\n\n");
//p. Print data at the rear
printf("Test Case(p) : Print data at the rear\n\n");
queueRear ( queue, &dataOutPtr );
printf("Data at the queue rear is : %s\n", queue->rear->dataPtr);
printf("\n\n");
//q. Enqueue data into queue
printf("Test Case(q) : Enqueue data into queue : Tom\n\n");
dataInPtr = (char*)calloc(strlen("Tom")+1, sizeof(char) );
strcpy(dataInPtr, "Tom");
enqueue( queue, dataInPtr );
//r. print data at the front
printf("Test Case(r) : Print data at the front\n\n");
queueFront( queue, &dataOutPtr );
printf("Data at the queue front is : %s\n", queue->front->dataPtr);
printf("\n\n");
//s. Print data at the rear
printf("Test Case(s) : Print data at the rear\n\n");
queueRear ( queue, &dataOutPtr );
printf("Data at the queue rear is : %s\n", queue->rear->dataPtr);
printf("\n\n");
//t. Destroy queue and quit
printf("Test Case(t) : Destroy queue and quit\n\n");
destroyQueue( queue );
#ifdef _MSC_VER
printf( _CrtDumpMemoryLeaks() ? "Memory Leak\n" : "No Memory Leak\n");
#endif
system("pause");
return 0;
}
