C++ Linked Lists Practice No documentation (commenting) is required for this ass
ID: 3698771 • Letter: C
Question
C++ Linked Lists Practice
No documentation (commenting) is required for this assignment.
Use linked lists to implement a sequence class.
Specification
The specification of the class is below. There are 9 member functions (not counting the big 3) and 2 types to define. The idea behind this class is that there will be an internal iterator, i.e., an iterator that the client cannot access, but that the class itself manages. For example, if we have a sequence object named s, we would use s.start() to set the iterator to the beginning of the list, and s.advance() to move the iterator to the next node in the list.
(I'm making the analogy to iterators as a way to help you understand the point of what we are doing. If trying to think in terms of iterators is confusing, just forget about iterators and focus on following the specification below.)
You are required to implement all of these functions except for attach() and remove_current(). You are also not required to implement the big-3.
Also, your class should be placed in a namespace "cs_sequence".
Here is an example of a simple client program, to give you an idea about how sequences might be used. You can also use this to test your class, but it's far from exhaustive. Keep in mind as you write your class that you should test each member function after you write it.
This client program will print the numbers 5 4 3 2 1 0. (They are backward because insert() inserts each new item at the front of the list.)
Implementation
We will be using the following implementation of type sequence, which includes 5 data members.
o0o numItems. Stores the number of items in the sequence.
o0o headPtr and tailPtr. The head and tail pointers of the linked list. If the sequence has no items, then these pointers are both NULL. The reason for the tail pointer is the attach function. Normally this function adds a new item immediately after the current node. But if there is no current node, then attach places its new item at the tail of the list, so it makes sense to keep a tail pointer around.
o0o cursor. Points to the node with the current item (or NULL if there is no current item).
o0o precursor. Points to the node before current item, or NULL if there is no current item or if the current item is the first node. Note that precursor points to NULL if there is no current item, or, to put it another way, points to NULL whenever cursor points to NULL. Can you figure out why we propose a precursor? The answer is the insert function, which normally adds a new item immediately before the current node. But the linked-list functions have no way of inserting a new node before a speci- fied node. We can only add new nodes after a specified node. Therefore, the insert function will work by adding the new item after the precursor node -- which is also just before the cursor node.
You must use this implementation. That means that you will have 5 data members, you won't have a header node, and precursor must be NULL if cursor is NULL. (What is a header node? If you don't know what it is, you probably aren't using it and shouldn't worry about it. It's not the same thing as a headPtr data member, which you WILL be using in this assignment.)
You should implement nodes using the same technique shown in the lecture videos and in the examples in the written lesson. In other words, there should not be a node class; rather, a node struct should be defined inside the sequence class.
Many students make the mistake of thinking that this assignment will very closely track with the examples done in lecture. In this assignment perhaps more than any other so far I am expecting you to use the concepts taught in the lesson and text to implement a class that is very different from the ones done in the lessons and the text (instead of implementing a class that is pretty similar to the ones done in the lesson and text).
I am providing my solution to the insert() function. This should make it easier to get started: you can use this insert() function and do all of this week's functions (default constructor, size(), start(), advance(), current(), and is_item()) and then write a client program to test what you have so far.
Explanation / Answer
Please find my implementation:
########### sequenceClass.h ###########
#ifndef sequenceClass_h
#define sequenceClass_h
#include <iostream>
#include <cstdlib>
namespace cs_sequenceClass {
class sequence {
typedef int value_type;
typedef std::size_t size_type;
private:
struct node {
value_type data;
node *next;
};
node *headPtr;
node *tailPtr;
node *cursor;
node *precursor;
public:
value_type numItems;
sequence(const sequence& copy);
void debug();
// deconstructor
~sequence();
sequence();
// postcondition: The sequence has been initialized to an empty sequence.
// helper function for copy constructor
void copySequence(const sequence& inputSeq);
void start();
// postcondition: The first item in the sequence becomes the current item (but if the
// sequence is empty, then there is no current item).
void advance();
// precondition: is_item() returns true
// Postcondition: If the current item was already the last item in the sequence, then there
// is no longer any current item. Otherwise, the new item is the item immediately after
// the original current item.
void insert(const value_type& entry);
// Postcondition: A new copy of entry has been inserted in the sequence before the
// current item. If there was no current item, then the new entry has been inserted at the
// front. In either case, the new item is now the current item of the sequence.
void attach(const value_type& entry);
// Postcondition: A new copy of entry has been inserted in the sequence after the current
// item. If there was no current item, then the new entry has been attached to the end of
// the sequence. In either case, the new item is now the current item of the sequence.
void remove_current();
// Precondition: is_item returns true.
// Postcondition: The current item has been removed from the sequence, and the
// item after this (if there is one) is now the new current item.
size_type size() const;
// Postcondition: Returns the number of items in the sequence.
bool is_item() const;
// Postcondition: A true return value indicates that there is a valid “current†item that
// may be retrieved by the current member function (listed below). A false return value
// indicates that there is no valid current item.
value_type current() const;
// Precondition: is_item() returns true
// Postcondition: The current item in the sequence is returned.
sequence operator =(const sequence& right);
void deleteSequence();
};
}
#endif /* sequenceClass_h */
############## sequenceClass.cpp ##############
#include "sequenceClass.h"
namespace cs_sequenceClass {
// constructor
sequence::sequence() {
numItems = 0;
cursor = nullptr;
headPtr = nullptr;
tailPtr = nullptr;
}
// copy constructor
sequence::sequence(const sequence& copy) {
copySequence(copy);
}
// deconstructor
sequence::~sequence() {
deleteSequence();
}
void sequence::deleteSequence() {
// start from top
node* tempcursor = headPtr;
// std::cout << "DEBUG: HEADPTR IS @ " << headPtr->data << std::endl;
while(tempcursor != NULL) {
headPtr = headPtr->next;
delete tempcursor;
tempcursor = headPtr;
}
// // set to temp
// tempptr = cursor;
// // delete cursor
// delete cursor;
// // set cursor to next in line
// cursor = tempptr->next;
//
}
void sequence::copySequence(const sequence& inputSeq) {
node* tempptr = inputSeq.headPtr;
/* TODO: better way to handle each condition, this is a workaround */
if (tempptr == NULL) {
// null sequence? call init? i don't know?
headPtr = new node;
node* curptr = headPtr;
curptr->data = tempptr->data;
headPtr = headPtr->next;
while (headPtr != NULL) {
curptr->next = new node;
curptr = curptr->next;
curptr->data = tempptr->data;
tempptr = tempptr->next;
}
} else {
headPtr = NULL;
}
}
void sequence::insert(const value_type& entry) {
numItems++;
node* tempptr = new node;
tempptr -> data = entry;
if (headPtr == NULL) { // inserting into empty list.
tempptr -> next = NULL; // precursor remains NULL.
headPtr = tempptr;
tailPtr = tempptr;
} else if (cursor == NULL || cursor == headPtr) { // inserting at front.
// tailptr and precursor don't change.
tempptr -> next = headPtr;
headPtr = tempptr;
} else { // inserting anywhere else.
tempptr -> next = cursor; // tailptr, headptr and precursor don't change.
precursor -> next = tempptr;
}
cursor = tempptr;
}
void sequence::attach(const value_type& entry) {
numItems++;
node* tempptr = new node;
tempptr -> data = entry;
// empty sequence
if (headPtr == NULL) {
std::cout << " HEAD HIT " << std::endl;
headPtr = tempptr;
// tailPtr = tempptr->next;
tempptr->next = NULL;
tailPtr = tempptr;
}
// no current item
else if (cursor == NULL) {
// insert @ end
tailPtr = tempptr;
std:: cout << " CURS HIT" << std::endl;
} else {
// seems ILLEGAL
cursor -> next = tempptr;
}
cursor = tempptr;
// debug();
}
sequence::size_type sequence::size() const {
return numItems;
}
void sequence::start() {
// there is nothing in the sequence
if (headPtr == NULL) {
cursor = NULL;
} else {
// set cursor to first item in the sequence
cursor = headPtr;
}
}
void sequence::debug() {
cursor = headPtr;
while (cursor != tailPtr -> next){
std::cout << "CURSOR: " <<
cursor->data << std::endl;
cursor = cursor->next;
}
}
void sequence::advance() {
assert(is_item());
if (cursor == precursor) {
cursor = NULL;
} else {
precursor = cursor;
cursor = cursor->next;
}
}
sequence::value_type sequence::current() const {
// I am confused so I will have this return the data of the node
return cursor->data;
}
bool sequence::is_item() const {
return (cursor != NULL);
}
void sequence::remove_current() {
numItems--;
// todo: need more condition
if (is_item()) {
// set to temp
node* tempptr = cursor;
// delete cursor
delete cursor;
// set cursor to next in line
cursor = tempptr->next;
}
}
sequence sequence::operator =(const sequence& right) {
if (this != &right) {
// deallocate & copy construct
deleteSequence();
copySequence(right);
}
return *this;
}
}
####################
main.cpp
// Non-interactive test program for the sequence class using a linked sequence
//
// DESCRIPTION:
// Each function of this program tests part of the sequence class, returning
// some number of points to indicate how much of the test was passed.
// A description and result of each test is printed to cout.
// Maximum number of points awarded by this program is determined by the
// constants POINTS[1], POINTS[2]...
#include // Provides cout.
#include // Provides size_t.
#include "sequenceClass.h" // Provides the sequence class with double items.
using namespace std;
/****************************************
CHANGE THIS LINE: */
using namespace cs_sequenceClass;
/****************************************/
// Descriptions and points for each of the tests:
const size_t MANY_TESTS = 6;
const int POINTS[MANY_TESTS+1] = {
18, // Total points for all tests.
4, // Test 1 points
4, // Test 2 points
4, // Test 3 points
2, // Test 4 points
2, // Test 5 points
2 // Test 6 points
};
const char DESCRIPTION[MANY_TESTS+1][256] = {
"tests for sequence Class with a linked sequence",
"Testing insert, attach, and the constant member functions",
"Testing situations where the cursor goes off the sequence",
"Testing remove_current",
"Testing the copy constructor",
"Testing the assignment operator",
"Testing insert/attach for somewhat larger sequences"
};
// **************************************************************************
// bool test_basic(const sequence& test, size_t s, bool has_cursor)
// Postcondition: A return value of true indicates:
// a. test.size() is s, and
// b. test.is_item() is has_cursor.
// Otherwise the return value is false.
// In either case, a description of the test result is printed to cout.
// **************************************************************************
bool test_basic(const sequence& test, size_t s, bool has_cursor)
{
bool answer;
cout << "Testing that size() returns " << s << " ... ";
cout.flush( );
answer = (test.size( ) == s);
cout << (answer ? "Passed." : "Failed.") << endl;
if (answer)
{
cout << "Testing that is_item() returns ";
cout << (has_cursor ? "true" : "false") << " ... ";
cout.flush( );
answer = (test.is_item( ) == has_cursor);
cout << (answer ? "Passed." : "Failed.") << endl;
}
return answer;
}
// **************************************************************************
// bool test_items(sequence& test, size_t s, size_t i, double items[])
// The function determines if the test sequence has the correct items
// Precondition: The size of the items array is at least s.
// Postcondition: A return value of true indicates that test.current()
// is equal to items[i], and after test.advance() the result of
// test.current() is items[i+1], and so on through items[s-1].
// At this point, one more advance takes the cursor off the sequence.
// If any of this fails, the return value is false.
// NOTE: The test sequence has been changed by advancing its cursor.
// **************************************************************************
bool test_items(sequence& test, size_t s, size_t i, double items[])
{
bool answer = true;
cout << "The cursor should be at item [" << i << "]" << " of the sequence ";
cout << "(counting the first item as [0]). I will advance the cursor ";
cout << "to the end of the sequence, checking that each item is correct...";
cout.flush( );
while ((i < s) && test.is_item( ) && (test.current( ) == items[i]))
{
i++;
test.advance( );
}
if ((i != s) && !test.is_item( ))
{ // The test.is_item( ) function returns false too soon.
cout << " Cursor fell off the sequence too soon." << endl;
answer = false;
}
else if (i != s)
{ // The test.current( ) function returned a wrong value.
cout << " The item [" << i << "] should be " << items[i] << ", ";
cout << " but it was " << test.current( ) << " instead. ";
answer = false;
}
else if (test.is_item( ))
{ // The test.is_item( ) function returns true after moving off the sequence.
cout << " The cursor was moved off the sequence,";
cout << " but is_item still returns true." << endl;
answer = false;
}
cout << (answer ? "Passed." : "Failed.") << endl;
return answer;
}
// **************************************************************************
// bool correct(sequence& test, size_t s, size_t cursor_spot, double items[])
// This function determines if the sequence (test) is "correct" according to
// these requirements:
// a. it has exactly s items.
// b. the items (starting at the front) are equal to
// items[0] ... items[s-1]
// c. if cursor_spot < s, then test's cursor must be at
// the location given by cursor_spot.
// d. if cursor_spot >= s, then test must not have a cursor.
// NOTE: The function also moves the cursor off the sequence.
// **************************************************************************
bool correct(sequence& test, size_t size, size_t cursor_spot, double items[])
{
bool has_cursor = (cursor_spot < size);
// Check the sequence's size and whether it has a cursor.
if (!test_basic(test, size, has_cursor))
{
cout << "Basic test of size() or is_item() failed." << endl << endl;
return false;
}
// If there is a cursor, check the items from cursor to end of the sequence.
if (has_cursor && !test_items(test, size, cursor_spot, items))
{
cout << "Test of the sequence's items failed." << endl << endl;
return false;
}
// Restart the cursor at the front of the sequence and test items again.
cout << "I'll call start() and look at the items one more time..." << endl;
test.start( );
if (has_cursor && !test_items(test, size, 0, items))
{
cout << "Test of the sequence's items failed." << endl << endl;
return false;
}
// If the code reaches here, then all tests have been passed.
cout << "All tests passed for this sequence." << endl << endl;
return true;
}
// **************************************************************************
// int test1( )
// Performs some basic tests of insert, attach, and the constant member
// functions. Returns POINTS[1] if the tests are passed. Otherwise returns 0.
// **************************************************************************
int test1( )
{
sequence empty; // An empty sequence
sequence test; // A sequence to add items to
double items1[4] = { 5, 10, 20, 30 }; // These 4 items are put in a sequence
double items2[4] = { 10, 15, 20, 30 }; // These are put in another sequence
// Test that the empty sequence is really empty
cout << "Starting with an empty sequence." << endl;
if (!correct(empty, 0, 0, items1)) return 0;
// Test the attach function to add something to an empty sequence
cout << "I am now using attach to put 10 into an empty sequence." << endl;
test.attach(10);
if (!correct(test, 1, 0, items2)) return 0;
// Test the insert function to add something to an empty sequence
cout << "I am now using insert to put 10 into an empty sequence." << endl;
test = empty;
test.insert(10);
if (!correct(test, 1, 0, items2)) return 0;
// Test the insert function to add an item at the front of a sequence
cout << "I am now using attach to put 10,20,30 in an empty sequence. ";
cout << "Then I move the cursor to the start and insert 5." << endl;
test = empty;
test.attach(10);
test.attach(20);
test.attach(30);
test.start( );
test.insert(5);
if (!correct(test, 4, 0, items1)) return 0;
// Test the insert function to add an item in the middle of a sequence
cout << "I am now using attach to put 10,20,30 in an empty sequence. ";
cout << "Then I move the cursor to the start, advance once, ";
cout << "and insert 15." << endl;
test = empty;
test.attach(10);
test.attach(20);
test.attach(30);
test.start( );
test.advance( );
test.insert(15);
if (!correct(test, 4, 1, items2)) return 0;
// Test the attach function to add an item in the middle of a sequence
cout << "I am now using attach to put 10,20,30 in an empty sequence. ";
cout << "Then I move the cursor to the start and attach 15 ";
cout << "after the 10." << endl;
test = empty;
test.attach(10);
test.attach(20);
test.attach(30);
test.start( );
test.attach(15);
if (!correct(test, 4, 1, items2)) return 0;
// All tests have been passed
cout << "All tests of this first function have been passed." << endl;
return POINTS[1];
}
// **************************************************************************
// int test2( )
// Performs a test to ensure that the cursor can correctly be run off the end
// of the sequence. Also tests that attach/insert work correctly when there is
// no cursor. Returns POINTS[2] if the tests are passed. Otherwise returns 0.
// **************************************************************************
int test2( )
{
const size_t TESTSIZE = 30;
sequence test;
size_t i;
// Put three items in the sequence
cout << "Using attach to put 20 and 30 in the sequence, and then calling ";
cout << "advance, so that is_item should return false ... ";
cout.flush( );
test.attach(20);
test.attach(30);
test.advance( );
if (test.is_item( ))
{
cout << "failed." << endl;
return 0;
}
cout << "passed." << endl;
// Insert 10 at the front and run the cursor off the end again
cout << "Inserting 10, which should go at the sequence's front." << endl;
cout << "Then calling advance three times to run cursor off the sequence ...";
cout.flush( );
test.insert(10);
test.advance( ); // advance to the 20
test.advance( ); // advance to the 30
test.advance( ); // advance right off the sequence
if (test.is_item( ))
{
cout << " failed." << endl;
return false;
}
cout << " passed." << endl;
// Attach more items until the sequence becomes full.
// Note that the first attach should attach to the end of the sequence.
cout << "Calling attach to put the numbers 40, 50, 60 ...";
cout << TESTSIZE*10 << " at the sequence's end." << endl;
for (i = 4; i <= TESTSIZE; i++)
test.attach(i*10);
// Test that the sequence is correctly filled.
cout << "Now I will test that the sequence has 10, 20, 30, ...";
cout << TESTSIZE*10 << "." << endl;
test.start( );
for (i = 1; i <= TESTSIZE; i++)
{
if ((!test.is_item( )) || test.current( ) != i*10)
{
cout << " Test failed to find " << i*10 << endl;
return 0;
}
test.advance( );
}
if (test.is_item( ))
{
cout << " There are too many items on the sequence." << endl;
return false;
}
// All tests passed
cout << "All tests of this second function have been passed." << endl;
return POINTS[2];
}
// **************************************************************************
// int test3( )
// Performs basic tests for the remove_current function.
// Returns POINTS[3] if the tests are passed.
// Otherwise returns 0.
// **************************************************************************
int test3( )
{
const size_t TESTSIZE = 30;
sequence test;
// Within this function, I create several different sequences using the
// items in these arrays:
double items1[1] = { 30 };
double items2[2] = { 10, 30 };
double items3[3] = { 10, 20, 30 };
size_t i; // for-loop control variable
// Build a sequence with three items 10, 20, 30, and remove the middle,
// and last and then first.
cout << "Using attach to build a sequence with 10,30." << endl;
test.attach(10);
test.attach(30);
cout << "Insert a 20 before the 30, so entire sequence is 10,20,30." << endl;
test.insert(20);
if (!correct(test, 3, 1, items3)) return 0;
cout << "Remove the 20, so entire sequence is now 10,30." << endl;
test.start( );
test.advance( );
test.remove_current( );
if (!correct(test, 2, 1, items2)) return 0;
cout << "Remove the 30, so entire sequence is now just 10 with no cursor.";
cout << endl;
test.start( );
test.advance( );
test.remove_current( );
if (!correct(test, 1, 1, items2)) return 0;
cout << "Set the cursor to the start and remove the 10." << endl;
test.start( );
test.remove_current( );
if (!correct(test, 0, 0, items2)) return 0;
//test.start();
//cout << test.current() << " ";
//test.advance();
//cout << test.current() << " ";
//test.advance();
//cout << test.current() << " ";
//test.advance();
//cout << test.current() << " ";
//test.advance();
//cout << test.is_item() << endl;
// Build a sequence with three items 10, 20, 30, and remove the middle,
// and then first and then last.
cout << "Using attach to build another sequence with 10,30." << endl;
test.attach(10);
//test.start();
//cout << test.current() << " ";
//test.advance();
//cout << test.current() << " ";
//test.advance();
//cout << test.current() << " ";
//test.advance();
//cout << test.current() << " ";
//test.advance();
//cout << test.is_item() << endl;
test.attach(30);
//test.start();
//cout << test.current() << " ";
//test.advance();
//cout << test.current() << " ";
//test.advance();
//cout << test.current() << " ";
//test.advance();
//cout << test.current() << " ";
//test.advance();
//cout << test.is_item() << endl;
cout << "Insert a 20 before the 30, so entire sequence is 10,20,30." << endl;
test.insert(20);
//test.start();
//cout << test.current() << " ";
//test.advance();
//cout << test.current() << " ";
//test.advance();
//cout << test.current() << " ";
//test.advance();
//cout << test.current() << " ";
//test.advance();
//cout << test.is_item() << endl;
if (!correct(test, 3, 1, items3)) return 0;
cout << "Remove the 20, so entire sequence is now 10,30." << endl;
test.start( );
test.advance( );
test.remove_current( );
if (!correct(test, 2, 1, items2)) return 0;
cout << "Set the cursor to the start and remove the 10," << endl;
cout << "so the sequence should now contain just 30." << endl;
test.start( );
test.remove_current( );
if (!correct(test, 1, 0, items1)) return 0;
cout << "Remove the 30 from the sequence, resulting in an empty sequence." << endl;
test.start( );
test.remove_current( );
if (!correct(test, 0, 0, items1)) return 0;
// Build a sequence with three items 10, 20, 30, and remove the first.
cout << "Build a new sequence by inserting 30, 10, 20 (so the sequence ";
cout << "is 20, then 10, then 30). Then remove the 20." << endl;
test.insert(30);
test.insert(10);
test.insert(20);
test.remove_current( );
if (!correct(test, 2, 0, items2)) return 0;
test.start( );
test.remove_current( );
test.remove_current( );
// Just for fun, fill up the sequence, and empty it!
cout << "Just for fun, I'll empty the sequence then fill it up, then ";
cout << "empty it again. During this process, I'll try to determine ";
cout << "whether any of the sequence's member functions access the ";
cout << "array outside of its legal indexes." << endl;
for (i = 0; i < TESTSIZE; i++)
test.insert(0);
for (i = 0; i < TESTSIZE; i++)
test.remove_current( );
// All tests passed
cout << "All tests of this third function have been passed." << endl;
return POINTS[3];
}
// **************************************************************************
// int test4( )
// Performs some tests of the copy constructor.
// Returns POINTS[4] if the tests are passed. Otherwise returns 0.
// **************************************************************************
int test4( )
{
const size_t TESTSIZE = 30;
sequence original; // A sequence that we'll copy.
double items[2*TESTSIZE];
size_t i;
// Set up the items array to conatin 1...2*TESTSIZE.
for (i = 1; i <= 2*TESTSIZE; i++)
items[i-1] = i;
// Test copying of an empty sequence. After the copying, we change original.
cout << "Copy constructor test: for an empty sequence." << endl;
sequence copy1(original);
original.attach(1); // Changes the original sequence, but not the copy.
if (!correct(copy1, 0, 0, items)) return 0;
// Test copying of a sequence with current item at the tail.
cout << "Copy constructor test: for a sequence with cursor at tail." << endl;
for (i=2; i <= 2*TESTSIZE; i++)
original.attach(i);
sequence copy2(original);
original.remove_current( ); // Delete tail from original, but not the copy
original.start( );
original.advance( );
original.remove_current( ); // Delete 2 from original, but not the copy.
if (!correct
(copy2, 2*TESTSIZE, 2*TESTSIZE-1, items)
)
return 0;
// Test copying of a sequence with cursor near the middle.
cout << "Copy constructor test: with cursor near middle." << endl;
original.insert(2);
for (i = 1; i < TESTSIZE; i++)
original.advance( );
// Cursor is now at location [TESTSIZE] (counting [0] as the first spot).
sequence copy3(original);
original.start( );
original.advance( );
original.remove_current( ); // Delete 2 from original, but not the copy.
if (!correct
(copy3, 2*TESTSIZE-1, TESTSIZE, items)
)
return 0;
// Test copying of a sequence with cursor at the front.
cout << "Copy constructor test: for a sequence with cursor at front." << endl;
original.insert(2);
original.start( );
// Cursor is now at the front.
sequence copy4(original);
original.start( );
original.advance( );
original.remove_current( ); // Delete 2 from original, but not the copy.
if (!correct
(copy4, 2*TESTSIZE-1, 0, items)
)
return 0;
// Test copying of a sequence with no current item.
cout << "Copy constructor test: for a sequence with no current item." << endl;
original.insert(2);
while (original.is_item( ))
original.advance( );
// There is now no current item.
sequence copy5(original);
original.start( );
original.advance( );
original.remove_current( ); // Delete 2 from original, but not the copy.
if (!correct
(copy5, 2*TESTSIZE-1, 2*TESTSIZE, items)
)
return 0;
// All tests passed
cout << "All tests of this fourth function have been passed." << endl;
return POINTS[4];
}
// **************************************************************************
// int test5( )
// Performs some tests of the assignment operator.
// Returns POINTS[5] if the tests are passed. Otherwise returns 0.
// **************************************************************************
int test5( )
{
const size_t TESTSIZE = 30;
sequence original; // A sequence that we'll copy.
double items[2*TESTSIZE];
size_t i;
// Set up the items array to conatin 1...2*TESTSIZE.
for (i = 1; i <= 2*TESTSIZE; i++)
items[i-1] = i;
// Test copying of an empty sequence. After the copying, we change original.
cout << "Assignment operator test: for an empty sequence." << endl;
sequence copy1;
copy1 = original;
original.attach(1); // Changes the original sequence, but not the copy.
if (!correct(copy1, 0, 0, items)) return 0;
// Test copying of a sequence with current item at the tail.
cout << "Assignment operator test: cursor at tail." << endl;
for (i=2; i <= 2*TESTSIZE; i++)
original.attach(i);
sequence copy2;
copy2 = original;
original.remove_current( ); // Delete tail from original, but not the copy
original.start( );
original.advance( );
original.remove_current( ); // Delete 2 from original, but not the copy.
if (!correct
(copy2, 2*TESTSIZE, 2*TESTSIZE-1, items)
)
return 0;
// Test copying of a sequence with cursor near the middle.
cout << "Assignment operator test: with cursor near middle." << endl;
original.insert(2);
for (i = 1; i < TESTSIZE; i++)
original.advance( );
// Cursor is now at location [TESTSIZE] (counting [0] as the first spot).
sequence copy3;
copy3 = original;
original.start( );
original.advance( );
original.remove_current( ); // Delete 2 from original, but not the copy.
if (!correct
(copy3, 2*TESTSIZE-1, TESTSIZE, items)
)
return 0;
// Test copying of a sequence with cursor at the front.
cout << "Assignment operator test: with cursor at front." << endl;
original.insert(2);
original.start( );
// Cursor is now at the front.
sequence copy4;
copy4 = original;
original.start( );
original.advance( );
original.remove_current( ); // Delete 2 from original, but not the copy.
if (!correct
(copy4, 2*TESTSIZE-1, 0, items)
)
return 0;
// Test copying of a sequence with no current item.
cout << "Assignment operator test: with no current item." << endl;
original.insert(2);
while (original.is_item( ))
original.advance( );
// There is now no current item.
sequence copy5;
copy5 = original;
original.start( );
original.advance( );
original.remove_current( ); // Deletes 2 from the original, but not copy.
if (!correct
(copy5, 2*TESTSIZE-1, 2*TESTSIZE, items)
)
return 0;
cout << "Checking correctness of a self-assignment x = x;" << endl;
original.insert(2);
original = original;
if (!correct
(original, 2*TESTSIZE-1, 1, items)
)
return 0;
// All tests passed
cout << "All tests of this fifth function have been passed." << endl;
return POINTS[5];
}
// **************************************************************************
// int test6( )
// Performs some basic tests of insert and attach for the case where the
// current capacity has been reached.
// Returns POINTS[6] if the tests are passed. Otherwise returns 0.
// **************************************************************************
int test6( )
{
const size_t TESTSIZE = 30;
sequence testa, testi;
double items[2*TESTSIZE];
size_t i;
// Set up the items array to conatin 1...2*TESTSIZE.
for (i = 1; i <= 2*TESTSIZE; i++)
items[i-1] = i;
cout << "Testing to see that attach works correctly when the ";
cout << "current capacity is exceeded." << endl;
for (i = 1; i <= 2*TESTSIZE; i++)
testa.attach(i);
if (!correct
(testa, 2*TESTSIZE, 2*TESTSIZE-1, items)
)
return 0;
cout << "Testing to see that insert works correctly when the ";
cout << "current capacity is exceeded." << endl;
for (i = 2*TESTSIZE; i >= 1; i--)
testi.insert(i);
if (!correct
(testi, 2*TESTSIZE, 0, items)
)
return 0;
// All tests passed
cout << "All tests of this sixth function have been passed." << endl;
return POINTS[6];
}
int run_a_test(int number, const char message[], int test_function( ), int max)
{
int result;
cout << endl << "START OF TEST " << number << ":" << endl;
cout << message << " (" << max << " points)." << endl;
result = test_function( );
if (result > 0)
{
cout << "Test " << number << " got " << result << " points";
cout << " out of a possible " << max << "." << endl;
}
else
cout << "Test " << number << " failed." << endl;
cout << "END OF TEST " << number << "." << endl << endl;
return result;
}
// **************************************************************************
// int main( )
// The main program calls all tests and prints the sum of all points
// earned from the tests.
// **************************************************************************
int main( )
{
int sum = 0;
cout << "Running " << DESCRIPTION[0] << endl;
sum += run_a_test(1, DESCRIPTION[1], test1, POINTS[1]); cout << sum << endl;
// sum += run_a_test(2, DESCRIPTION[2], test2, POINTS[2]); cout << sum << endl;
// sum += run_a_test(3, DESCRIPTION[3], test3, POINTS[3]); cout << sum << endl;
// sum += run_a_test(4, DESCRIPTION[4], test4, POINTS[4]); cout << sum << endl;
// sum += run_a_test(5, DESCRIPTION[5], test5, POINTS[5]); cout << sum << endl;
// sum += run_a_test(6, DESCRIPTION[6], test6, POINTS[6]); cout << sum << endl;
cout << "If you submit this sequence to Dora now, you will have ";
cout << sum << " points out of the " << POINTS[0];
cout << " points from this test program. ";
return EXIT_SUCCESS;
}
Related Questions
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.