(C++) Change the following program so that it uses a dynamic array i.pdf

(C++) Change the following program so that it uses a dynamic array instead of a static one. Test
it with sequence_exam2.cpp.
sequence1.cpp
#include "sequence1.h"
#include
#include
namespace sequencelab
{
sequence::sequence()
{
used = 0;
current_index = 0;
}
void sequence::start()
{
if (used > 0)
{
current_index = 0;
}
else
{
current_index = used;
}
}
void sequence::advance()
{
if (is_item())
{
current_index++;
}
else
{
std::cout << "Nothing here!" << std::endl;
}
}

void sequence::insert(const value_type& figure)
{
if (size() < CAPACITY)
{
if (!is_item())
{
start();
}
for (size_t i = used; i > current_index; i--)
{
data[i] = data[i-1];
}
data[current_index] = figure;
used++;
}
else
{
std::cout << "Did not insert, size is larger/equal to the capacity." << std::endl;
}
}
void sequence::attach(const value_type& figure)
{
{
if (is_item())
{
for (size_t i = used; i > current_index + 1; i--)
{
}
data[current_index + 1] = figure;
current_index++;
used++;
}
else
{

data[used] = figure;
used++;
}
}
else
{
std::cout << "Did not attach, size is larger/equal to the capacity." << std::endl;
}
}
void sequence::remove_current()
{
if (is_item())
{
for (size_t i = current_index; i < used; i++)
{
data[i] = data[i+1];
}
used--;
}
else
{
}
}
sequence::size_type sequence::size() const
{
return used;
}
bool sequence::is_item() const
{
return ((current_index >= 0) && (current_index < used) && (used != 0));
}
sequence::value_type sequence::current() const
{
if (is_item())

{
return data[current_index];
}
else
{
}
}
}
----------------------------------------------------------------------------------
sequence1.h
#ifndef MAIN_SAVITCH_SEQUENCE_H
#define MAIN_SAVITCH_SEQUENCE_H
#include
{
class sequence
{
public:
typedef double value_type;
typedef std::size_t size_type;
static const size_type CAPACITY = 30;
sequence( );
void insert(const value_type& figure);
void attach(const value_type& figure);
void start( );
void advance( );
void remove_current( );
value_type current( ) const;
size_type size( ) const;
bool is_item( ) const;
private:
value_type data[CAPACITY];
size_type used;
size_type current_index;

};
}
#endif
------------------------------------------------------------------------------------
sequence_exam2.cpp
#include // Provides cout.
#include // Provides memcpy.
#include // Provides size_t.
#include "sequence2.h" // Provides the Sequence class with double items.
using namespace std;
using namespace main_savitch_4;
// Descriptions and points for each of the tests:
const size_t MANY_TESTS = 7;
const int POINTS[MANY_TESTS+1] = {
21, // 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
3 // Test 7 points
};
const char DESCRIPTION[MANY_TESTS+1][256] = {
"tests for sequence class with a dynamic array",
"Testing insert, attach, and the constant member functions",
"Testing situations where the cursor goes off the sequence",
"Testing remove_current",
"Testing the resize member function",
"Testing the copy constructor",
"Testing the assignment operator",
"Testing insert/attach when current DEFAULT_CAPACITY exceeded"
};
// **************************************************************************
// 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);
}
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;
}
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))
{
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);
// 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);

// Test the insert function to add an item in the middle of a 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);
// Test the attach function to add an item in the middle of a 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);
// 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( )
{
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 right off the sequence
{
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 << test.DEFAULT_CAPACITY*10 << " at the sequence's end." << endl;

for (i = 4; i <= test.DEFAULT_CAPACITY; 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 << test.DEFAULT_CAPACITY*10 << "." << endl;
test.start( );
for (i = 1; i <= test.DEFAULT_CAPACITY; i++)
{
if ((!test.is_item( )) || test.current( ) != i*10)
{
cout << " Test failed to find " << i*10 << endl;
return 0;
}
test.advance( );
}
{
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. Returns POINTS[3] / 4 if almost
// all the tests are passed. Otherwise returns 0.
// **************************************************************************
int test3( )
{
// In the next declarations, I am declaring a sequence called test.
// Both before and after the sequence, I declare a small array of characters,
// and I put the character 'x' into each spot of these arrays.

// Later, if I notice that one of the x's has been changed, or if
// I notice an 'x' inside of the sequence, then the most
// likely reason was that one of the sequence's member functions accessed
// the sequence's array outside of its legal indexes.
char prefix[4] = {'x', 'x', 'x', 'x'};
sequence test;
char suffix[4] = {'x', 'x', 'x', 'x'};
// 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
char *char_ptr; // Variable to loop at each character in a sequence's memory
// 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);
cout << "Remove the 20, so entire sequence is now 10,30." << endl;
test.start( );
test.advance( );
test.remove_current( );
cout << "Remove the 30, so entire sequence is now just 10 with no cursor.";
cout << endl;
test.start( );
test.advance( );
cout << "Set the cursor to the start and remove the 10." << endl;
test.start( );

// and then first and then last.
cout << "Using attach to build another sequence with 10,30." << endl;
test.attach(10);
test.attach(30);
test.insert(20);
test.start( );
test.advance( );
cout << "Set the cursor to the start and remove the 10," << endl;
cout << "so the sequence should now contain just 30." << endl;
test.start( );
cout << "Remove the 30 from the sequence, resulting in an empty sequence." << endl;
test.start( );
// 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.start( );
// 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 < test.DEFAULT_CAPACITY; i++)
test.insert(0);
for (i = 0; i < test.DEFAULT_CAPACITY; i++)
// Make sure that the character 'x' didn't somehow get into the sequence,
// as that would indicate that the sequence member functions are
// copying data from before or after the sequence into the sequence.
char_ptr = (char *) &test;
for (i = 0; i < sizeof(sequence); i++)
if (char_ptr[i] == 'x')
{
cout << "Illegal array access detected." << endl;
return POINTS[3] / 4;
}
// Make sure that the prefix and suffix arrays still have four
// x's each. Otherwise one of the sequence operations wrote outside of
// the legal boundaries of its array.
for (i = 0; i < 4; i++)
if ((suffix[i] != 'x') || (prefix[i] != 'x'))
{
}
// All tests passed
cout << "All tests of this third function have been passed." << endl;
return POINTS[3];
}
// **************************************************************************
// int test4( )
// Performs some tests of resize.

// Returns POINTS[4] if the tests are passed. Otherwise returns 0.
// **************************************************************************
int test4( )
{
sequence test;
size_t i;
char bytes[sizeof(sequence)];
char newbytes[sizeof(sequence)];
size_t mismatches;
cout << "I will now resize a sequence to a larger capacity, and then ";
cout << "attach that many items. The sequence should NOT need to ";
cout << "resize itself under this situation." << endl;
test.resize(2*test.DEFAULT_CAPACITY);
test.attach(0);
memcpy(bytes, (char *) &test, sizeof(sequence));
// At this point, I should be able to insert 2*DEFAULT_CAPACITY-1
// more items without calling resize again. Therefore, at most 1 byte
// of the object will change (the least significant byte of used).
for (i = 1; i < 2*test.DEFAULT_CAPACITY; i++)
test.attach(i);
test.start( );
memcpy(newbytes, (char *) &test, sizeof(sequence));
for (i = 0; i < 2*test.DEFAULT_CAPACITY; i++)
{
if (test.current( ) != i)
{
cout << " sequence does not contain correct items." << endl;
return 0;
}
test.advance( );
}
test.start( );
mismatches = 0;

if (bytes[i] != newbytes[i])
mismatches++;
if (mismatches > 1)
{
cout << " sequence was resized when it should not be." << endl;
return 0;
}
else
cout << " Test passed." << endl;
cout << "Now I will call resize(1) for the sequence, but the actual ";
cout << "sequence should not change because the sequence already has ";
cout << test.DEFAULT_CAPACITY*2 << " items." << endl;
test.resize(1);
mismatches = 0;
mismatches++;
if (mismatches > 0)
{
return 0;
}
else
// All tests passed
cout << "All tests of this fourth function have been passed." << endl;
return POINTS[4];
}
// **************************************************************************
// int test5( )
// Performs some tests of the copy constructor.

// **************************************************************************
int test5( )
{
sequence original; // A sequence that we'll copy.
double items[2*original.DEFAULT_CAPACITY];
size_t i;
// Set up the items array to conatin 1...2*DEFAULT_CAPACITY.
for (i = 1; i <= 2*original.DEFAULT_CAPACITY; i++)
items[i-1] = i;
// Test copying of an empty sequence. After the copying, we change the 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*original.DEFAULT_CAPACITY; i++)
original.attach(i);
original.start( );
original.advance( );
original.remove_current( ); // Removes 2 from the original, but not the copy.
if (!correct
(copy2, 2*original.DEFAULT_CAPACITY, 2*original.DEFAULT_CAPACITY-1, items)
)
return 0;
// Test copying of a sequence with cursor near the middle.
cout << "Copy constructor test: for a sequence with cursor near middle." << endl;
original.insert(2);
for (i = 1; i < original.DEFAULT_CAPACITY; i++)
// Cursor is now at location [DEFAULT_CAPACITY] (counting [0] as the first spot).
original.start( );

if (!correct
(copy3, 2*original.DEFAULT_CAPACITY, original.DEFAULT_CAPACITY, items)
)
return 0;
// Test copying of a sequence with cursor at the front.
original.insert(2);
original.start( );
// Cursor is now at the front.
original.start( );
if (!correct
(copy4, 2*original.DEFAULT_CAPACITY, 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( ))
// There is now no current item.
original.start( );
if (!correct
(copy5, 2*original.DEFAULT_CAPACITY, 2*original.DEFAULT_CAPACITY, items)
)
return 0;
// All tests passed
cout << "All tests of this fifth function have been passed." << endl;
return POINTS[5];
}

// **************************************************************************
// int test6( )
// Performs some tests of the assignment operator.
// **************************************************************************
int test6( )
{
double items[2*original.DEFAULT_CAPACITY];
size_t i;
for (i = 1; i <= 2*original.DEFAULT_CAPACITY; i++)
items[i-1] = i;
cout << "Assignment operator test: for an empty sequence." << endl;
sequence copy1;
copy1 = original;
cout << "Assignment operator test: for a sequence with cursor at tail." << endl;
for (i=2; i <= 2*original.DEFAULT_CAPACITY; i++)
original.attach(i);
sequence copy2;
copy2 = original;
original.start( );
if (!correct
(copy2, 2*original.DEFAULT_CAPACITY, 2*original.DEFAULT_CAPACITY-1, items)
)
return 0;
cout << "Assignment operator test: for a sequence with cursor near middle." << endl;

original.insert(2);
for (i = 1; i < original.DEFAULT_CAPACITY; i++)
sequence copy3;
copy3 = original;
original.start( );
if (!correct
(copy3, 2*original.DEFAULT_CAPACITY, original.DEFAULT_CAPACITY, items)
)
return 0;
original.insert(2);
original.start( );
sequence copy4;
copy4 = original;
original.start( );
if (!correct
(copy4, 2*original.DEFAULT_CAPACITY, 0, items)
)
return 0;
cout << "Assignment operator test: for a sequence with no current item." << endl;
original.insert(2);
sequence copy5;
copy5 = original;
original.start( );

if (!correct
(copy5, 2*original.DEFAULT_CAPACITY, 2*original.DEFAULT_CAPACITY, items)
)
return 0;
cout << "Checking correctness of a self-assignment x = x;" << endl;
original.insert(2);
original = original;
if (!correct
(original, 2*original.DEFAULT_CAPACITY, 1, items)
)
return 0;
// All tests passed
cout << "All tests of this sixth function have been passed." << endl;
return POINTS[6];
}
// **************************************************************************
// int test7( )
// Performs some basic tests of insert and attach for the case where the
// current capacity has been reached.
// **************************************************************************
int test7( )
{
sequence testa, testi;
double items[2*testa.DEFAULT_CAPACITY];
size_t i;
for (i = 1; i <= 2*testa.DEFAULT_CAPACITY; 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*testa.DEFAULT_CAPACITY; i++)

testa.attach(i);
if (!correct
(testa, 2*testa.DEFAULT_CAPACITY, 2*testa.DEFAULT_CAPACITY-1, items)
)
return 0;
cout << "Testing to see that insert works correctly when the ";
for (i = 2*testi.DEFAULT_CAPACITY; i >= 1; i--)
testi.insert(i);
if (!correct
(testi, 2*testi.DEFAULT_CAPACITY, 0, items)
)
return 0;
// All tests passed
cout << "All tests of this seventh function have been passed." << endl;
return POINTS[7];
}
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 << "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;
}
Solution
//change to dynamic array is working fine..But already some of the functions were not available.
I did not take that into consideration since it is out of scope for this question.
PROGRAM CODE:
sequence1.h
/*
* sequence1.h
*
* Created on: 24-Feb-2017
* Author: kasturi

*/
#ifndef MAIN_SAVITCH_SEQUENCE_H
#define MAIN_SAVITCH_SEQUENCE_H
#include
{
class sequence
{
public:
typedef double value_type;
typedef std::size_t size_type;
size_type CAPACITY;
sequence( );
void insert(const value_type& figure);
void attach(const value_type& figure);
void start( );
void advance( );
void remove_current( );
value_type current( ) const;
size_type size( ) const;
bool is_item( ) const;
private:
value_type *data;
size_type used;
size_type current_index;
};
}
#endif
sequence1.cpp
/*
* sequence1.cpp
*
* Author: kasturi
*/
#include "sequence1.h"

#include
#include
{
sequence::sequence()
{
used = 0;
current_index = 0;
CAPACITY = 30;
data = new value_type[CAPACITY];
}
void sequence::start()
{
if (used > 0)
{
current_index = 0;
}
else
{
}
}
void sequence::advance()
{
if (is_item())
{
current_index++;
}
else
{
}
}
void sequence::insert(const value_type& figure)
{

{
if (!is_item())
{
start();
}
for (size_t i = used; i > current_index; i--)
{
}
data[current_index] = figure;
used++;
}
else
{
std::cout << "Did not insert, size is larger/equal to the capacity." << std::endl;
}
}
void sequence::attach(const value_type& figure)
{
if (used < CAPACITY)
{
if (is_item())
{
for (size_t i = used; i > current_index + 1; i--)
{
}
data[current_index + 1] = figure;
current_index++;
used++;
}
else
{
data[used] = figure;
used++;

}
}
else
{
std::cout << "Did not attach, size is larger/equal to the capacity." << std::endl;
}
}
void sequence::remove_current()
{
if (is_item())
{
for (size_t i = current_index; i < used; i++)
{
data[i] = data[i+1];
}
used--;
}
else
{
}
}
sequence::size_type sequence::size() const
{
return used;
}
bool sequence::is_item() const
{
return ((current_index >= 0) && (current_index < used) && (used != 0));
}
sequence::value_type sequence::current() const
{
if (is_item())
{
return data[current_index];
}

else
{
}
}
}
sequence_exam2.cpp
/*
* sequence_exam2.cpp
*
* Author: kasturi
*/
#include // Provides cout.
#include // Provides memcpy.
#include // Provides size_t.
#include "sequence1.h" // Provides the Sequence class with double items.
using namespace std;
using namespace sequencelab;
// Descriptions and points for each of the tests:
const size_t MANY_TESTS = 7;
const int POINTS[MANY_TESTS+1] = {
21, // 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
3 // Test 7 points
};
const char DESCRIPTION[MANY_TESTS+1][256] = {
"tests for sequence class with a dynamic array",
"Testing insert, attach, and the constant member functions",
"Testing situations where the cursor goes off the sequence",
"Testing remove_current",

"Testing the resize member function",
"Testing the copy constructor",
"Testing the assignment operator",
"Testing insert/attach when current DEFAULT_CAPACITY exceeded"
};
// **************************************************************************
// 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);
if (answer)
{
cout << "Testing that is_item() returns ";
cout << (has_cursor ? "true" : "false") << " ... ";
cout.flush( );
answer = (test.is_item( ) == has_cursor);
}
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;
}
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))
{
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))
{
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);
// 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);
// Test the insert function to add an item at the front of a 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);

// Test the insert function to add an item in the middle of a 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);
// Test the attach function to add an item in the middle of a 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);
// 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( )
{

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( );
{
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 right off the sequence
{
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 << test.CAPACITY*10 << " at the sequence's end." << endl;
for (i = 4; i <= test.CAPACITY; 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 << test.CAPACITY*10 << "." << endl;
test.start( );
for (i = 1; i <= test.CAPACITY; i++)
{
if ((!test.is_item( )) || test.current( ) != i*10)
{
cout << " Test failed to find " << i*10 << endl;
return 0;
}
test.advance( );
}
{
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. Returns POINTS[3] / 4 if almost
// all the tests are passed. Otherwise returns 0.
// **************************************************************************
int test3( )
{
// In the next declarations, I am declaring a sequence called test.
// Both before and after the sequence, I declare a small array of characters,
// and I put the character 'x' into each spot of these arrays.
// Later, if I notice that one of the x's has been changed, or if
// I notice an 'x' inside of the sequence, then the most
// likely reason was that one of the sequence's member functions accessed
// the sequence's array outside of its legal indexes.

char prefix[4] = {'x', 'x', 'x', 'x'};
sequence test;
char suffix[4] = {'x', 'x', 'x', 'x'};
// 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
char *char_ptr; // Variable to loop at each character in a sequence's memory
// and last and then first.
cout << "Using attach to build a sequence with 10,30." << endl;
test.attach(10);
test.attach(30);
test.insert(20);
test.start( );
test.advance( );
cout << "Remove the 30, so entire sequence is now just 10 with no cursor.";
cout << endl;
test.start( );
test.advance( );
cout << "Set the cursor to the start and remove the 10." << endl;
test.start( );
// and then first and then last.
cout << "Using attach to build another sequence with 10,30." << endl;

test.attach(10);
test.attach(30);
test.insert(20);
test.start( );
test.advance( );
cout << "Set the cursor to the start and remove the 10," << endl;
cout << "so the sequence should now contain just 30." << endl;
test.start( );
cout << "Remove the 30 from the sequence, resulting in an empty sequence." << endl;
test.start( );
// 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.start( );
// 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 < test.CAPACITY; i++)

test.insert(0);
for (i = 0; i < test.CAPACITY; i++)
// Make sure that the character 'x' didn't somehow get into the sequence,
// as that would indicate that the sequence member functions are
// copying data from before or after the sequence into the sequence.
char_ptr = (char *) &test;
if (char_ptr[i] == 'x')
{
}
// Make sure that the prefix and suffix arrays still have four
// x's each. Otherwise one of the sequence operations wrote outside of
// the legal boundaries of its array.
for (i = 0; i < 4; i++)
if ((suffix[i] != 'x') || (prefix[i] != 'x'))
{
}
// All tests passed
cout << "All tests of this third function have been passed." << endl;
return POINTS[3];
}
// **************************************************************************
// int test4( )
// Performs some tests of resize.
// **************************************************************************
int test4( )
{
sequence test;
size_t i;
char bytes[sizeof(sequence)];

char newbytes[sizeof(sequence)];
size_t mismatches;
cout << "I will now resize a sequence to a larger capacity, and then ";
cout << "attach that many items. The sequence should NOT need to ";
cout << "resize itself under this situation." << endl;
//test.resize(2*test.CAPACITY);
cout<<"Current size: "< 1)
{
return 0;
}
else
cout << "Now I will call resize(1) for the sequence, but the actual ";
cout << "sequence should not change because the sequence already has ";
cout << test.CAPACITY*2 << " items." << endl;
// test.resize(1);
mismatches = 0;
mismatches++;
if (mismatches > 0)
{
return 0;
}
else
// All tests passed
cout << "All tests of this fourth function have been passed." << endl;
return POINTS[4];
}
// **************************************************************************
// int test5( )
// Performs some tests of the copy constructor.

// **************************************************************************
int test5( )
{
double items[2*original.CAPACITY];
size_t i;
for (i = 1; i <= 2*original.CAPACITY; i++)
items[i-1] = i;
cout << "Copy constructor test: for an empty sequence." << endl;
cout << "Copy constructor test: for a sequence with cursor at tail." << endl;
for (i=2; i <= 2*original.CAPACITY; i++)
original.attach(i);
original.start( );
if (!correct(copy2, 2*original.CAPACITY, 2*original.CAPACITY-1, items))
return 0;
original.insert(2);
for (i = 1; i < original.CAPACITY; i++)
original.start( );
if (!correct

(copy3, 2*original.CAPACITY, original.CAPACITY, items)
)
return 0;
original.insert(2);
original.start( );
original.start( );
if (!correct
(copy4, 2*original.CAPACITY, 0, items)
)
return 0;
cout << "Copy constructor test: for a sequence with no current item." << endl;
original.insert(2);
original.start( );
if (!correct
(copy5, 2*original.CAPACITY, 2*original.CAPACITY, items)
)
return 0;
// All tests passed
cout << "All tests of this fifth function have been passed." << endl;
return POINTS[5];
}
// **************************************************************************
// int test6( )

// Performs some tests of the assignment operator.
// **************************************************************************
int test6( )
{
double items[2*original.CAPACITY];
size_t i;
for (i = 1; i <= 2*original.CAPACITY; i++)
items[i-1] = i;
cout << "Assignment operator test: for an empty sequence." << endl;
sequence copy1;
copy1 = original;
cout << "Assignment operator test: for a sequence with cursor at tail." << endl;
for (i=2; i <= 2*original.CAPACITY; i++)
original.attach(i);
sequence copy2;
copy2 = original;
original.start( );
if (!correct
(copy2, 2*original.CAPACITY, 2*original.CAPACITY-1, items)
)
return 0;
original.insert(2);
for (i = 1; i < original.CAPACITY; i++)

sequence copy3;
copy3 = original;
original.start( );
if (!correct
(copy3, 2*original.CAPACITY, original.CAPACITY, items)
)
return 0;
original.insert(2);
original.start( );
sequence copy4;
copy4 = original;
original.start( );
if (!correct
(copy4, 2*original.CAPACITY, 0, items)
)
return 0;
cout << "Assignment operator test: for a sequence with no current item." << endl;
original.insert(2);
sequence copy5;
copy5 = original;
original.start( );
if (!correct
(copy5, 2*original.CAPACITY, 2*original.CAPACITY, items)

)
return 0;
cout << "Checking correctness of a self-assignment x = x;" << endl;
original.insert(2);
//original = original;
if (!correct
(original, 2*original.CAPACITY, 1, items)
)
return 0;
// All tests passed
cout << "All tests of this sixth function have been passed." << endl;
return POINTS[6];
}
// **************************************************************************
// int test7( )
// Performs some basic tests of insert and attach for the case where the
// current capacity has been reached.
// **************************************************************************
int test7( )
{
sequence testa, testi;
double items[2*testa.CAPACITY];
size_t i;
for (i = 1; i <= 2*testa.CAPACITY; i++)
items[i-1] = i;
cout << "Testing to see that attach works correctly when the ";
for (i = 1; i <= 2*testa.CAPACITY; i++)
testa.attach(i);
if (!correct
(testa, 2*testa.CAPACITY, 2*testa.CAPACITY-1, items)
)
return 0;
cout << "Testing to see that insert works correctly when the ";

for (i = 2*testi.CAPACITY; i >= 1; i--)
testi.insert(i);
if (!correct
(testi, 2*testi.CAPACITY, 0, items)
)
return 0;
// All tests passed
cout << "All tests of this seventh function have been passed." << endl;
return POINTS[7];
}
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;

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;
}
OUTPUT:
Running tests for sequence class with a dynamic array
START OF TEST 1:
Testing insert, attach, and the constant member functions (4 points).
Starting with an empty sequence.
Testing that size() returns 0 ... Passed.
Testing that is_item() returns false ... Passed.
I'll call start() and look at the items one more time...
All tests passed for this sequence.
I am now using attach to put 10 into an empty sequence.
Testing that is_item() returns true ... Passed.
The cursor should be at item [0] of the sequence
(counting the first item as [0]). I will advance the cursor
to the end of the sequence, checking that each item is correct...Passed.
I am now using insert to put 10 into an empty sequence.

I am now using attach to put 10,20,30 in an empty sequence.
Then I move the cursor to the start and insert 5.
Then I move the cursor to the start, advance once, and insert 15.
Then I move the cursor to the start and attach 15 after the 10.

All tests of this first function have been passed.
Test 1 got 4 points out of a possible 4.
END OF TEST 1.
START OF TEST 2:
Testing situations where the cursor goes off the sequence (4 points).
Using attach to put 20 and 30 in the sequence, and then calling
advance, so that is_item should return false ... passed.
Inserting 10, which should go at the sequence's front.
Then calling advance three times to run cursor off the sequence ... passed.
Calling attach to put the numbers 40, 50, 60 ...300 at the sequence's end.
Now I will test that the sequence has 10, 20, 30, ...300.
All tests of this second function have been passed.
END OF TEST 2.
START OF TEST 3:
Testing remove_current (4 points).
Using attach to build a sequence with 10,30.
Insert a 20 before the 30, so entire sequence is 10,20,30.
Remove the 20, so entire sequence is now 10,30.

Remove the 30, so entire sequence is now just 10 with no cursor.
Set the cursor to the start and remove the 10.
Using attach to build another sequence with 10,30.
Insert a 20 before the 30, so entire sequence is 10,20,30.
Remove the 20, so entire sequence is now 10,30.

Set the cursor to the start and remove the 10,
so the sequence should now contain just 30.
Remove the 30 from the sequence, resulting in an empty sequence.
Build a new sequence by inserting 30, 10, 20 (so the sequence
is 20, then 10, then 30). Then remove the 20.

Just for fun, I'll empty the sequence then fill it up, then
empty it again. During this process, I'll try to determine
whether any of the sequence's member functions access the
array outside of its legal indexes.
All tests of this third function have been passed.
END OF TEST 3.

(C++) Change the following program so that it uses a dynamic array i.pdf

Recommended

More Related Content

Similar to (C++) Change the following program so that it uses a dynamic array i.pdf (20)

More from f3apparelsonline (20)

Recently uploaded (20)

(C++) Change the following program so that it uses a dynamic array i.pdf