Exemple #1
0
int main() {
    ListHndl intList;
    intList = newList();

    int data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
/*
 * Integer list testing
 *
 */

    printHeading(" INTEGER LIST ", '#', 80);
    printList(stdout, intList);
    accessorTest("isEmpty", 1, isEmpty(intList));
    
    for(int i = 0; i < 10; i++) {
        insertAtFront(intList, data[i]);
        mutatorTest("%s : data = %d", "insertAtFront", data[i]);
    }

    moveFirst(intList);

    for(int i = 0; i < 5; i++) {
        printList(stdout, intList);
        insertBeforeCurrent(intList, data[i]);
        mutatorTest("insertBeforeCurrent : data = %d", data[i]);
        moveNext(intList);
    }

    accessorTest("isEmpty", 0, isEmpty(intList));
    printList(stdout, intList);

    moveFirst(intList);
    while( !offEnd(intList) ) {
        printList(stdout, intList);
        moveNext(intList);
    }

    moveLast(intList);
    while( !offEnd(intList) ) {
        printList(stdout, intList);
        movePrev(intList);
    }

    makeEmpty(intList);
    mutatorTest("makeEmpty( intList)");

    printList(stdout, intList);
    accessorTest("isEmpty", 1, isEmpty(intList));

    freeList(intList);
    return 0;
}
Exemple #2
0
int main(){
	/*make list and output file*/
    ListHndl TheList = newList();
    FILE *out = fopen("out.out", "w");
    
    /*test empty in empty case*/
    if(isEmpty(TheList)) printf("Empty\n");
    else printf("not Empty\n");
    printf("testing insert one number\n");
    insertAtFront(TheList,(unsigned long*)25728);
    printf("%lu\n",(unsigned long)getFirst(TheList));
    printf("%lu\n",(unsigned long)getLast(TheList));
    /*should have same value*/
    
    printf("testing list with three numbers\n");
    insertAtFront(TheList,(unsigned long*)1589458);
    insertAtBack(TheList,(unsigned long*)35762111234);
    printf("%lu\n",(unsigned long)getFirst(TheList));
    
    /*test empty in full case*/
    if(isEmpty(TheList)) printf("Empty\n");
    else printf("not Empty\n");
    
	/*test moving the current pointer around*/
    moveFirst(TheList);
    moveNext(TheList);
    printf("%lu\n",(unsigned long)getCurrent(TheList));
    moveLast(TheList);
    movePrev(TheList);
    printf("%lu\n",(unsigned long)getCurrent(TheList));
    
	/*test printList*/
    printList(out, TheList);
    
	/*test makeEmpty*/
    makeEmpty(TheList);
    if(isEmpty(TheList)) printf("Empty\n");
    else printf("not Empty\n");
    
	/*test inserting functions*/
    insertAtFront(TheList,(unsigned long*)2);
    insertAtFront(TheList,(unsigned long*)1);
    insertAtFront(TheList,(unsigned long*)4);
    insertAtBack(TheList,(unsigned long*)4);
    moveLast(TheList);
    insertBeforeCurrent(TheList,(unsigned long*)3);
    printList(out,TheList);
    deleteFirst(TheList);
    deleteCurrent(TheList);
    deleteLast(TheList);
    printList(out,TheList);
    
    makeEmpty(TheList);
    printList(out,TheList);
    
	/*free list and close output file*/
    freeList(&TheList);
    fclose(out);
    return 0;
}
Exemple #3
0
void doBFS(GraphRef g, int source){
	ListRef list = newList();
	initGraph(g);
	insertAfterLast(list, source);
	g->color[source]= 1;
	g->distance[source]=0;
	while(!isEmpty(list)){
		int current = getFirst(list);
		if(current > g->numVertices){
			deleteFirst(list);
			 break;
		}
		ListRef edgeList = g->vertices[current];
		moveFirst(edgeList);
		while(!offEnd(edgeList)){
			int edge = getCurrent(edgeList);
			if(g->color[edge]==0){
				g->distance[edge] = g->distance[current]+1;
				g->color[edge] = 1;
				g->parent[edge] = current;
				insertAfterLast(list, edge);
			}
			moveNext(edgeList);
		}
		deleteFirst(list);
		g->color[current] = 2;
	}
	makeEmpty(list);
	freeList(list);
}
Exemple #4
0
// Perform breadth first search on graph with given source.
void doBFS(Graph *G, int source) {

    // Initialize graph first.
    for (int i = 0; i < G->numVertices; ++i) {
        G->color[i] = 0; // Set to white.
        G->distance[i] = 0;
        G->parent[i] = -1;
    }
    
    G->color[source] = 1; // Set to grey.
    G->distance[source] = 0;

    // Create a list Q and add source to it.
    ListHndl Q = newList();
    insertAtBack(Q, source);
    while (!isEmpty(Q)) {
        //Dequeue and delete first element.
        int u = getFirst(Q); deleteFirst(Q);
        // Move current position to point at first.
        if (!isEmpty(G->vertices[u])) moveFirst(G->vertices[u]);
        //Traverse vertices of u.
        while (!offEnd(G->vertices[u])) {
            int v = getCurrent(G->vertices[u]);
            if (G->color[v] == 0) { // Check if V is white.
                G->color[v] = 1; // Color V grey.
                G->distance[v] = G->distance[u] + 1;
                G->parent[v] = u;
                insertAtBack(Q, v);
            }
            moveNext(G->vertices[u]);
        }
        G->color[u] = 2; // Color u black.
    }
    freeList(&Q);
}
Exemple #5
0
void doBFS(GraphHndl g, int source)
{
	ListHndl tempList = NewList();

	/*Make the lists white, reset distances and parents*/
	for(int i = 0; i < g->vertNums; i++)
	{
		g->parentPtr[i] = -1;
		g->distancePtr[i] = INT_MAX;
		g->colorPtr[i] = 0;
	}

	/*Temporary list holds paths from source*/
	insertAtBack(tempList, source);
	g->colorPtr[source] = 1;
	g->distancePtr[source] = 0;

	/*For every node in the source's adjacency list..*/
	while(!isEmpty(tempList))
	{
		int currNode = getFirst(tempList);

		/*Handle case where we're passed a bigger node*/
		if(currNode > g->vertNums)
		{
			deleteFirst(tempList);
			break;
		}

		/*Second temporary list holds edge path*/
		ListHndl tempList2 = g->vertices[currNode];
		moveFirst(tempList2);

		/* For each of the next node's adjacent nodes .. */
		while(!offEnd(tempList2))
		{
			int tempEdge = getCurrent(tempList2);
			/* If the node was white, increase the distance,
 			 * color it grey and set it's parent to be currnode
 			 * and enqueue this node into the path list */
			if(g->colorPtr[tempEdge] == 0)
			{
				g->distancePtr[tempEdge] = g->distancePtr[currNode]+1;
				g->colorPtr[tempEdge] = 1;
				g->parentPtr[tempEdge] = currNode;
				insertAtBack(tempList, tempEdge);
			}
			moveNext(tempList2);
		}
		/*Dequeue the first element and set black to show we're done.*/
		deleteFirst(tempList);
		g->colorPtr[currNode] = 2;
	}
	makeEmpty(tempList);
	//freeList(tempList);
}
Exemple #6
0
/*This method prints out the IDs of the ListHndl in the Hash.*/
void printIDs(ListHndl L)
{
   moveFirst(L);
   while(!offEnd(L))
   {
      long* bookid = L->current->data;
      printf("%lu ", *bookid);
      moveNext(L);
   }printf("\n");
}
Exemple #7
0
void doBFS(Graph G, int source)
{
    assert(G->numVerts != 0);
    ListHndl L = newList();
    /*printf("start %d\n", source);*/
    insertAtBack(L, source);
    int i = 0;
    for(i = 0; i < G->numVerts; i++)
    {
        G->color[i]= WHITE;
        G->parent[i] = NULL;
        G->distance[i] = INFINITY;
    }
    G->color[source] = GREY;
    G->parent[source] = NULL;
    G->distance[source] = 0;
    while(!isEmpty(L))
    {
        int u = getFirst(L);
        /*printf("u: %d\n", u);*/
        if(u > G->numVerts)
        {
            deleteFirst(L);
            break;
        }
        ListHndl v = G->verts[u];
        int prev;
        moveFirst(v);
        while(!offEnd(v))
        {
            int E = getCurrent(v);
            if(prev == E)
            {
                break;
            }
            /*printf("   v: %d\n", E);*/
            if(G->color[E] == WHITE)
            {
                G->color[E] = GREY;
                G->parent[E] = u;
                if(G->distance[E] < 0)
                {
                    G->distance[E] = 0;
                }
                G->distance[E] = G->distance[u] + 1;
                insertAtBack(L, E);
            }
            prev = E;
            moveNext(v);
        }
        deleteFirst(L);
        G->color[u] = BLACK;
    }
}
Exemple #8
0
/* for debugging purposes*/
void printTable(HashTable H){
    assert (H != NULL);
	printf("HashTable: Size %d\n", H->tableSize);
    for(int i = 0; i < H->tableSize; i++){
        printf("%d:\n",i);
        if(isEmpty(H->array[i])) continue;
        moveFirst(H->array[i]);
        while(!offEnd(H->array[i])){
            HashNode N = getCurrent(H->array[i]);
            printf("-%s\n",N->name);
            moveFirst(N->L);
            while(!offEnd(N->L)){
                ListNode temp = getCurrent(N->L);
                printf("--%d\n",temp->num);
                moveNext(N->L);
            }
            moveNext(H->array[i]);
        }
    }
}
Exemple #9
0
/*Check if customer already purchased certain book*/
int customerCompare(long id, ListRef *customers, int custNum){
	ListRef l = customers[custNum];
	moveFirst(l);
	while(!offEnd(l)){
		if(getCurrent(l) == id)
			return true;
		if(atLast(l)) break;
		moveNext(l);	
	}
	return false;
}
Exemple #10
0
/*Inserts copurchases into hash*/
void addToHash(HashRef h, long bookId, ListRef * customers, int custNum, BookRef list){
	moveFirst(customers[custNum]);			//add cust previous books to hash of current book
	while(!offEnd(customers[custNum])){
			long current = getCurrent(customers[custNum]);
			if(getId(list)!= current){ //don't add itself to book list
				insertionSort(getBookList(list), current);
			}
			if(atLast(customers[custNum])) break;
				moveNext(customers[custNum]);
		
	}
}
Exemple #11
0
ListHndl lookup(HashTable H, char* key){
    assert (H != NULL);
    ListHndl slot = H->array[hash((unsigned char*)key) % H->tableSize];
    if(isEmpty(slot)) return NULL;
    else moveFirst(slot);
    while(!offEnd(slot)){
        HashNode temp = getCurrent(slot);
        if(strcmp(key,temp->name) == 0) return temp->L;
        else moveNext(slot);
    }
    return NULL;
}
Exemple #12
0
/*!
 * \brief This method creates a MockDataSet
 * \return Returns a mocked DataSet that has the required behavior for unittests
 */
te::da::MockDataSet* createMockDataSet()
{
  te::da::MockDataSet* mockDataSet(new te::da::MockDataSet());

  EXPECT_CALL(*mockDataSet, moveNext()).WillRepeatedly(::testing::Return(true));
  EXPECT_CALL(*mockDataSet, getAsString(::testing::An<const std::string&>(),::testing::_)).WillRepeatedly(::testing::Return(""));
  EXPECT_CALL(*mockDataSet, getAsString(::testing::An<std::size_t>(),::testing::_)).WillRepeatedly(::testing::Return(""));
  EXPECT_CALL(*mockDataSet, isNull(std::string())).WillRepeatedly(::testing::Return(false));
  EXPECT_CALL(*mockDataSet, getNumProperties()).WillRepeatedly(::testing::Return(0));
  EXPECT_CALL(*mockDataSet, moveFirst()).WillRepeatedly(::testing::Return(true));

  return mockDataSet;
}
Exemple #13
0
void deleteHashNode(HashTable H, char* name){
    assert (H != NULL);
    ListHndl slot = H->array[hash((unsigned char*)name) % H->tableSize];
    if(isEmpty(slot)) return;
    moveFirst(slot);
    while(!offEnd(slot)){
        HashNode temp = getCurrent(slot);
        if(strcmp(name, temp->name) == 0){
            ListHndl L = temp->L;
            freeList(&L);
            deleteCurrent(slot);
        }else moveNext(slot);
    }
}
Exemple #14
0
/* main program*/
int main(int argc, char *argv[]){
    for(int i = 1; i < argc; i++){
        // open file and read in numVerts and numQueries
        FILE* in = fopen(argv[i], "r");
        int numVerts, numQueries;
        char tempLine[1024];
        fgets(tempLine, 1024, in);
        sscanf(tempLine, "%d %d", &numVerts, &numQueries);
        
        // read in and make graph
        Graph Map = newGraph(numVerts);
        for(int i = 0; i < numVerts; i++){
            fgets(tempLine, 1024, in);
            int vert = atoi(strtok(tempLine, " "));
            char *tempTo = strtok(NULL, " ");
            while(tempTo != NULL){
                addEdge(Map, vert, atoi(tempTo));
                tempTo = strtok(NULL, " ");
            }
        }
        
        // process queries
        for(int i = 0; i < numQueries; i++){
            int from, to;
            fscanf(in, "%d %d", &from, &to);
            doBFS(Map, from);
            if(getDistance(Map, to) == -1)
                printf("No path from %d to %d exists.\n\n", from, to);
            else{
                printf("The shortest path from %d to %d requires %d edges: \n",
                       from, to, getDistance(Map, to));
                ListHndl L = getPathTo(Map, to);
                moveFirst(L);
                while(!atLast(L)){
                    printf("%d -> ", getCurrent(L));
                    moveNext(L);
                }
                printf("%d \n\n", getCurrent(L));
                freeList(&L);
            }
        }
    
        /*free everythingggggggggggg*/
        freeGraph(&Map);
        fclose(in);
    }
    
    /* end program */
    return 0;
}
Exemple #15
0
/*Gets best recommendation then prints it*/
void printRecommendation(HashRef h, long bookId, ListRef* customers, int custNum){
	moveFirst(customers[custNum]);
	int max=0;
	long maxId=0;
	if(getElement(h,bookId)==NULL){	
		printf("No recommendations for book: %lu\n", bookId);
		return;
	}
	ListRef l = getBookList(getElement(h,bookId));
	moveFirst(l);
	while(!offEnd(l)){
		if(getCount(l) >=max && !customerCompare(getCurrent(l), customers, custNum)){
			max = getCount(l);
			maxId=getCurrent(l);
		}
		if(atLast(l)) break;
		moveNext(l);
		}
	if(maxId!=0)
		printf("Recommendation for book %lu is : %lu\n",bookId,maxId);
	else	
		printf("No recommendations for book: %lu\n", bookId);
}
Exemple #16
0
/*This method prints out the IDs of the ListHndl in the Hash.*/
void printList(ListHndl L)
{
   moveFirst(L);
   while(!offEnd(L))
   {
      if(!atLast(L))
      {
         printf("%d -> ", L->current->data);
      }else{
         printf("%d \n", L->current->data);
      }
      moveNext(L);
   }
   printf("\n");
}
Exemple #17
0
void deleteListNode(HashTable H, char* name, int num){
    assert (H != NULL);
    ListHndl L = lookup(H, name);
    if(L == NULL) return;
    moveFirst(L);
    while(!offEnd(L)){
        ListNode temp = getCurrent(L);
        if(temp->num == num){
            deleteCurrent(L);
            break;
        }
        moveNext(L);
    }
    /* if library list of book ends up being empty, delete the book */
    if(isEmpty(L)) deleteHashNode(H, name);
}
Exemple #18
0
/*Gets copurchases then adds to hash*/
void addCopurchase(HashRef h, long bookId, ListRef * customers, int custNum){
	BookRef list = getElement(h, bookId);
	if(list==NULL)
		list = insert(h, bookId, NULL);
	addToHash(h, bookId, customers, custNum, list);//add symmetrically, need for loop to add
	moveFirst(customers[custNum]);
	while(!offEnd(customers[custNum])){
		long id = getCurrent(customers[custNum]);
		BookRef l = getElement(h, id);
		if(l==NULL) 
			l = insert(h, id, NULL); 
		addToHash(h, id, customers, custNum, l);
		if(atLast(customers[custNum])) break;
			moveNext(customers[custNum]);
	}

}
Exemple #19
0
void gTreeRow::moveAfter(char *key)
{
	gTreeRow *row;
	
	if (!key || !*key)
	{
		moveFirst();
		return;
	}
	
	row = tree->getRow(key);
	if (!row)
		return;
	if (strcmp(row->parent(), parent()))
		return;
	gtk_tree_store_move_after(tree->store, dataiter, row->dataiter);
}
Exemple #20
0
void printGraph(GraphRef g){
	for(int i=0; i<g->numVertices; i++){
		printf("Node %d:\n",  i);
		if(i!=0){
			printf("Parent ");
			printList(g->parent[i]);
		}
		printf("\tColor %d, Dist %d", g->color[i], g->distance[i]); 
		printf("\tEdges:");
		ListRef index = g->vertices[i];
		moveFirst(index);
		while(!offEnd(index)){
			printf("%d, ",getCurrent(index));	
		moveNext(index);
		}
		 
	}
} 
Exemple #21
0
void joyStickBusyWaitingMonitor( void ) {
	uint32_t i;

	while ( 1 ) {

		if ( ~(LPC_GPIO1->FIOPIN | ~UP ) ) {
			moveUp();
		} else if ( ~(LPC_GPIO1->FIOPIN | ~DOWN) ) {
			moveDown();
		} else if( ~(LPC_GPIO1->FIOPIN | ~FIRST ) ) {
			moveFirst();
		} else if( ~(LPC_GPIO1->FIOPIN | ~LAST ) ) {
			moveLast();
		}

		for ( i = 0; i < 100000; ++i ) {
			// Pause
		}
	}
}
Exemple #22
0
void freeTable(HashTable* H){
    assert ((*H) != NULL);
    for(int i = 0; i < (*H)->tableSize; i++){
        /* free all library lists first */
        if(!isEmpty((*H)->array[i])){
            moveFirst((*H)->array[i]);
            while(!offEnd((*H)->array[i])){
                HashNode N = getCurrent((*H)->array[i]);
                ListHndl L = N->L;
                freeList(&L);
                moveNext((*H)->array[i]);
            }
        }
        
        /*and then free the slot lists*/
        freeList(&((*H)->array[i]));
    }
    free((*H)->array);
    free(*H);
    (*H) = NULL;
}
Exemple #23
0
/* Debug print loop. Used in debug but not needed here. */
void printGraph(GraphHndl g)
{
	for(int i = 1; i < g->vertNums-1; i++)
	{
		printf(" For node %d: \n", i);
		if ( i != 0)
		{
			printf("It's parent is ");
			printList((ListHndl)g->parentPtr[i]);
		}
		printf("\tColor %d, Dist %d", g->colorPtr[i], g->distancePtr[i]);
		printf("\tEdges:");
		ListHndl tempList = g->vertices[i];
		moveFirst(tempList);
		while(!offEnd(tempList))
		{
			printf("%d, ", getCurrent(index));
			moveNext(tempList);
		}
	}
}
Exemple #24
0
/* main program*/
int main(){
	/* variables */
    char inName[128];
    char outName[128];
    ListHndl array[128];
    char tempLine[128];
    int customers;
    int purchases;
    int tempCust;
    unsigned long tempBook;
    FILE *in;
    FILE *out;
    
	/* greeting & prompt for input and output file names */
    printf("Welcome! Please enter your input file here: ");
    scanf("%s",inName);
    in = fopen(inName, "r");
    if(in == NULL){
        printf("Error: This input file does not exist.\n");
        exit(1);
    }
    printf("Please enter your output file here: ");
    scanf("%s",outName);
    out = fopen(outName, "w");
    
	/* check numbers of customer and purchased */
    do{
        if(fgets(tempLine, 128, in) == NULL) invalidInput();
    }while(strcmp(tempLine, "\n") == 0);
    if(sscanf(tempLine,"%d", &customers) != 1) invalidInput();
    do{
        if(fgets(tempLine, 128, in) == NULL) invalidInput();
    }while(strcmp(tempLine, "\n") == 0);
    if(sscanf(tempLine,"%d", &purchases) != 1) invalidInput();
    
    /*makes empty Lists and fills them up*/
    for(int i = 0; i<customers; i++) array[i] = newList();
    for(int i = 0; i<purchases; i++){
        do{
          if(fgets(tempLine, 128, in) == NULL){
            printf("Error: Number of purchases does not match (too little).\n");
            exit(1);
          }
        }while(strcmp(tempLine, "\n") == 0);
        if(sscanf(tempLine,"%d", &tempCust) != 1) invalidInput();
        if(sscanf(tempLine,"%*d%lu", &tempBook) != 1) invalidInput();
        if(tempCust > customers){
            printf("Error: Invalid customer number.\n");
            exit(1);
        }
        if(isEmpty(array[tempCust-1])){
            insertAtBack(array[tempCust-1],tempBook);
            continue;
        }
        moveFirst(array[tempCust-1]);
        while(!offEnd(array[tempCust-1])){
            if(tempBook < (unsigned)getCurrent(array[tempCust-1])){
                insertBeforeCurrent(array[tempCust-1], tempBook);
                break;
            }
            moveNext(array[tempCust-1]);
        }
        if(offEnd(array[tempCust-1])) insertAtBack(array[tempCust-1],tempBook);
    }
    
	/* checks for any lingering purchases */
    for(;;){
        if(fgets(tempLine, 128, in) == NULL) break;
        if(sscanf(tempLine,"%d", &tempCust) != 0){
            printf("Error: Number of purchases does not match (too many).\n");
            exit(1);
        }
    }
    
    /*printing store*/
    fprintf(out, "customer#   books purchased\n");
    for(int i = 0; i<customers; i++){
        fprintf(out, "%d   ",i+1);
        moveFirst(array[i]);
        while(!offEnd(array[i])){
            fprintf(out, "%lu ", getCurrent(array[i]));
            moveNext(array[i]);
        }
        fprintf(out, "\n");
    }
    
    /*free everythingggggggggggg*/
    for(int i = 0; i<customers; i++) freeList(&array[i]);
    fclose(in);
    fclose(out);
    
	/* end program */
    printf("Done.\n");
    return 0;
}
Exemple #25
0
int main(int argc, char **argv) {
    FILE *inFile;
    char str[20000];
    char *token;
    int nVerts;
    int nReqs;
    Graph pathGraph;

    /*
     * Validate input file
     *
     */

    if (argc < 2) {
        perror("Please specify an input file\n");
        return (-1);
    }

    inFile = fopen(argv[1], "r");
    if (inFile == NULL) {
        perror("Could not open input file");
        return (-1);
    }

    /*
     * Read Input file
     *
     */

    fgets(str, 60, inFile);
    strtok(str, "\n");
    token = strtok(str, " ");
    nVerts = atoi( token );
    token = strtok(NULL, " ");
    nReqs = atoi( token );


    /*
     * Build Graph & Insert Edges
     *
     */

    pathGraph = newGraph( nVerts );

    for (int from = 0; from < nVerts; ++from ) {
        fgets (str, 20000, inFile);
        strtok(str, "\n");

        token = strtok(str, " ");
        token = strtok (NULL, " ");

        while( token != NULL) {
            int to = atoi( token );

            insertEdge( pathGraph, from, to);
            token = strtok (NULL, " ");
        }
    }

    /*
     * Process requests and find paths
     *
     */

    for (int from = 0; from < nReqs; ++from ) {
        int source;
        int dest;
        fgets (str, 20000, inFile);
        strtok(str, "\n");

        token = strtok(str, " ");
        source = atoi( token );
        token = strtok(NULL, " ");
        dest = atoi( token );

        doBFS(pathGraph, source);
        int dist = getDistance( pathGraph, dest);
        if ( dist > -1) {
            printf("The shortest path from %d to %d requires %d edge(s):\n", source, dest, dist);
            ListHndl path = getPathTo( pathGraph, dest);
            moveFirst( path );
            while( !offEnd( path )) {
                printf("%d ", getCurrent( path));
                if ( !atLast( path )) { printf( "-> "); }
                else { printf("\n\n"); }
                moveNext( path );
            }

            freeList( path );

        } else {
            printf("No path from %d to %d exists\n\n", source, dest);
        }
    }

    fclose (inFile);

    freeGraph(pathGraph);

    return 0;
}
Exemple #26
0
int main (){

  /***Exercise List constructor***/
  ListHndl List;
  List = NULL;
  List = newList ();

  if(List){
    printf("List Created\n");
  }else{
    printf("List Not Created\n");
  }
  
  printf("isEmpty %d\n",isEmpty(List)); /*should print 1*/
  
  /***Populate with test data***/
  int i;
  for(i=0; i<=4; i++){
    insertAtFront(List,i);
  }
  
  printList(stdout, List);
  
  printf("isEmpty %d\n",isEmpty(List)); /*should print 0*/

  int j;
  for(j=5; j<=9; j++){
    insertAtBack(List,j);
  } 
  printList(stdout, List);
  
  /***Exercise all access functions***/
  printf("offEnd %d\n",offEnd(List));/*should print 0*/
  
  printf("atFirst %d\n",atFirst(List));/*should print 0*/
  
  printf("atLast %d\n",atLast(List));/*should print 0*/
  
  printf("getFirst %d\n", getFirst(List));/*should print 4*/
  
  printf("getLast %d\n", getLast(List));/*should print 9*/
  
  printf("getCurrent %d\n", getCurrent(List));/*should print 0*/
  
  /***Exercise all removal manipulation functions***/
  deleteLast(List);
  printList(stdout, List);
  printf("getLast %d\n", getLast(List));/*should print 8*/
  
  deleteFirst(List);
  printList(stdout, List);
  printf("getFirst 	\n", getFirst(List));/*should print 3*/
  
  deleteCurrent(List);
  printList(stdout, List);
  
  moveLast(List);
  printList(stdout, List);
  movePrev(List);
  printList(stdout, List);
  moveNext(List);
  printList(stdout, List);

  /***Exercise various edge cases***/  
  makeEmpty(List);
  insertAtFront(List, 40);
  moveFirst(List);
  deleteCurrent(List);
  
  insertAtFront(List, 41);
  insertAtBack(List, 42);
  moveFirst(List);
  insertBeforeCurrent(List, 43);
  printList(stdout, List);
  
  /***Exercise List destructors***/
  
  deleteCurrent(List);
  printList(stdout, List);
  
  makeEmpty(List);
  printf("offEnd %d\n",offEnd(List));/*should print 1*/
  

  freeList(&List);
  return(0);
}