// test_class_SSArray_ctor_dctor_count // Test suite for class template SSArray, number of class to item type // ctor, dctor. // Pre: None. // Post: // Pass/fail status of tests have been registered with t. // Appropriate messages have been printed to cout. // Does not throw (No-Throw Guarantee) void test_class_SSArray_ctor_dctor_count(Tester & t) { std::cout << "Test Suite: class template SSArray - ctor, dctor count" << std::endl; // Check number of value type ctor/dctor calls // on array creation & destruction Counter::reset(); { // Block, so we get dctor calls before function ends const SSArray<Counter> tacc(10); t.test(Counter::getCtorCount() == 10, "Counting default ctor calls due to array creation"); Counter::reset(); } t.test(Counter::getDctorCount() == 10, "Counting dctor calls due to destruction"); /* // Check correct number of value type ctor & dctor calls // on self-assignment SSArray<Counter> tacc2(10); Counter::reset(); tacc2 = tacc2; int i1 = Counter::getCtorCount() + Counter::getDctorCount(); t.test(i1 == 0 || i1 == 20, "Self-assignment ctor/dctor calls"); */ }
// test_class_KSArray_types // Test suite for class KSArray, types // Pre: None. // Post: // Pass/fail status of tests have been registered with t. // Appropriate messages have been printed to cout. // Does not throw (No-Throw Guarantee) void test_class_KSArray_types(Tester & t) { std::cout << "Test Suite: class KSArray - types" << std::endl; bool correctType; // result of type checking // value_type test #1: int KSArray<int>::value_type i1 = 0; correctType = TypeCheck<int>::check(i1); t.test(correctType, "value_type test #1"); // value_type test #2: double KSArray<double>::value_type d1 = 0.; correctType = TypeCheck<double>::check(d1); t.test(correctType, "value_type test #2"); // value_type check modifiability (only needs to compile) KSArray<double>::value_type d2; d2 = 0.; t.test(true, "value_type check modifiability"); // size_type test KSArray<Counter>::size_type s1 = 0; correctType = TypeCheck<std::size_t>::check(s1) || TypeCheck<std::ptrdiff_t>::check(s1); t.test(correctType, "size_type test"); // size_type check modifiability (only needs to compile) KSArray<Counter>::size_type s2; s2 = 0; t.test(true, "size_type check modifiability"); }
// test_class_SSArray_bracket_op // Test suite for class Product, bracket operator // Pre: None. // Post: // Pass/fail status of tests have been registered with t. // Appropriate have been messages printed to cout. void test_class_SSArray_bracket_op(Tester & t) { std::cout << "Test Suite: class Product, bracket operator" << std::endl; const int theSize = 10; bool noErrors; // True if no errors encountered int i; // Counter SSArray<int> ssai(theSize); for (i = 0; i < theSize; ++i) ssai[i] = 15 - i * i; noErrors = true; for (i = 0; i < theSize; ++i) { if (ssai[i] != 15 - i * i) noErrors = false; } t.test(noErrors, "Bracket operator (non-const)"); // Make const version, no copy const SSArray<int> & ssaiRef = ssai; noErrors = true; for (i = 0; i < theSize; ++i) { if (ssaiRef[i] != 15 - i * i) noErrors = false; } t.test(noErrors, "Bracket operator (const)"); }
// test_class_SSArray_ctor_from_size_and_val // Test suite for class template SSArray, ctor from size & value // Pre: None. // Post: // Pass/fail status of tests have been registered with t. // Appropriate have been messages printed to cout. // Does not throw (No-Throw Guarantee) void test_class_SSArray_ctor_from_size_and_val(Tester & t) { std::cout << "Test Suite: class template SSArray - " << "ctor from size & value" << std::endl; const int theSize = 1000; bool noErrors; // True if no errors encountered const double val = -3.2; SSArray<double> tad(theSize, val); // check size t.test(tad.size() == theSize, "Ctor from size & value - check size"); // check values typedef SSArray<double>::size_type ST; noErrors = true; for (auto i = static_cast<ST>(0); i < tad.size(); ++i) { if (tad[i] != val) noErrors = false; } t.test(noErrors, "Ctor from size & value - check values"); }
// test_class_SSArray_copy_assn // Test suite for class SSArray, copy assignment // Pre: None. // Post: // Pass/fail status of tests have been registered with t. // Appropriate have been messages printed to cout. void test_class_SSArray_copy_assn(Tester & t) { std::cout << "Test Suite: class SSArray - copy assignment" << std::endl; const int theSize = 10; bool noErrors; // True if no errors encountered int i; // Counter SSArray<int> ssai(theSize); for (i = 0; i < theSize; ++i) ssai[i] = 15 - i * i; // Make const version, no copy const SSArray<int> & ssaiRef = ssai; // Make copy (copy assignment) SSArray<int> ssaiCopy(1); ssaiCopy = ssaiRef; t.test(ssaiCopy.size() == theSize, "Copy assignment - check size"); noErrors = true; for (i = 0; i < theSize; ++i) { if (ssaiCopy[i] != 15 - i * i) noErrors = false; } t.test(noErrors, "Copy assignment - check values"); }
// test_class_SSArray_equality_comparisons // Test suite for class template SSArray, comparisons ==, != // Pre: None. // Post: // Pass/fail status of tests have been registered with t. // Appropriate messages have been printed to cout. // Does not throw (No-Throw Guarantee) void test_class_SSArray_equality_comparisons(Tester & t) { std::cout << "Test Suite: class template SSArray - " << "equality comparisons" << std::endl; bool correctType; // result of type checking const int theSize = 10; int i; // Counter SSArray<int> tai1(theSize); for (i = 0; i < theSize; ++i) tai1[i] = 15 - i * i; const SSArray<int> & tai1Ref = tai1; SSArray<int> tai1Copy(tai1Ref); SSArray<int> tai2(theSize-1); for (i = 0; i < theSize-1; ++i) tai2[i] = 15 - i * i; const SSArray<int> & tai2Ref = tai2; // operator== return type correctType = TypeCheck<bool>::check(tai1 == tai1Copy); t.test(correctType, "operator==, return type"); // operator!= return type correctType = TypeCheck<bool>::check(tai1 != tai1Copy); t.test(correctType, "operator!=, return type"); // Check equality of copies t.test(tai1 == tai1Copy, "Equality of copies"); // Check inequality of copies t.test(!(tai1 != tai1Copy), "Inequality of copies"); // Check equality of different sizes #1 // (compilation checks constness of op==) t.test(!(tai1Ref == tai2Ref), "Equality of different sizes #1"); // Check inequality of different sizes #1 // (compilation checks constness of op!=) t.test(tai1Ref != tai2Ref, "Inequality of different sizes #1"); // Check equality of different sizes #2 t.test(!(tai2Ref == tai1Ref), "Equality of different sizes #2"); // Check inequality of different sizes #2 t.test(tai2Ref != tai1Ref, "Inequality of different sizes #2"); // Modify copy ++tai1Copy[theSize-1]; // Check equality of modification of copy t.test(!(tai1 == tai1Copy), "Equality of modification of copy"); // Check inequality of modification of copy t.test(tai1 != tai1Copy, "Inequality of modification of copy"); }
// test_class_SSArray_bracket_op // Test suite for class template SSArray, bracket operator // Pre: None. // Post: // Pass/fail status of tests have been registered with t. // Appropriate messages have been printed to cout. // Does not throw (No-Throw Guarantee) void test_class_SSArray_bracket_op(Tester & t) { std::cout << "Test Suite: class template SSArray, bracket operator" << std::endl; bool correctType; // result of type checking const int theSize = 10; bool noErrors; // True if no errors encountered int i; // Counter SSArray<double> tad1; correctType = TypeCheck<SSArray<double>::value_type>::check(tad1[1]); t.test(correctType, "Bracket operator (non-const), return type"); SSArray<int> tai(theSize); for (i = 0; i < theSize; ++i) tai[i] = 15 - i * i; noErrors = true; for (i = 0; i < theSize; ++i) { if (tai[i] != 15 - i * i) noErrors = false; } t.test(noErrors, "Bracket operator (non-const) #1"); tai[2] = 1000; noErrors = true; for (i = 0; i < theSize; ++i) { if (tai[i] != ((i == 2) ? 1000 : 15 - i * i)) noErrors = false; } t.test(noErrors, "Bracket operator (non-const) #2"); // Make const version, no copy const SSArray<int> & taiRef = tai; const SSArray<double> tad2; correctType = TypeCheck<SSArray<double>::value_type>::check(tad2[1]); t.test(correctType, "Bracket operator (const), return type"); noErrors = true; for (i = 0; i < theSize; ++i) { if (taiRef[i] != ((i == 2) ? 1000 : 15 - i * i)) noErrors = false; } t.test(noErrors, "Bracket operator (const)"); }
// test_class_SSArray_size_and_ctor_from_size // Test suite for class SSArray, function size and ctor from size // Pre: None. // Post: // Pass/fail status of tests have been registered with t. // Appropriate have been messages printed to cout. void test_class_SSArray_size_and_ctor_from_size(Tester & t) { std::cout << "Test Suite: class SSArray - function size, ctor from size" << std::endl; const SSArray<int> ssai(10); t.test(ssai.size() == 10, "size, ctor from size (const) #1"); const SSArray<double> ssad(100); t.test(ssad.size() == 100, "size, ctor from size (const) #2)"); SSArray<int> ssai2(20); t.test(ssai2.size() == 20, "size, ctor from size (non-const)"); }
// test_class_KSArray_begin_end // Test suite for class KSArray, functions begin & end // Pre: None. // Post: // Pass/fail status of tests have been registered with t. // Appropriate messages have been printed to cout. // Does not throw (No-Throw Guarantee) void test_class_KSArray_begin_end(Tester & t) { std::cout << "Test Suite: class KSArray - functions begin & end" << std::endl; bool correctType; // result of type checking const int theSize = 10; bool noErrors; // True if no errors encountered int i; // Counter int * iter; // iterator const int * citer; // const_iterator KSArray<int> tai(theSize); for (iter = tai.begin(), i = 0; iter != tai.end(); ++iter, ++i) *iter = 15 - i * i; // Non-const test KSArray<double> tad1; correctType = TypeCheck<KSArray<double>::value_type *>::check(tad1.begin()); t.test(correctType, "begin (non-const), return type"); correctType = TypeCheck<KSArray<double>::value_type *>::check(tad1.end()); t.test(correctType, "end (non-const), return type"); t.test(tai.begin() != tai.end(), "begin/end - inequality (non-const)"); t.test (tai.end() - tai.begin() == theSize, "begin/end - check difference (non-const)"); noErrors = true; for (iter = tai.begin(), i = 0; iter != tai.end(); ++iter, ++i) { if (*iter != 15 - i * i) noErrors = false; } t.test(noErrors, "begin/end - check values (non-const)"); // Make const version, no copy const KSArray<int> & taiRef = tai; // Const test const KSArray<double> tad2; correctType = TypeCheck<const KSArray<double>::value_type *>::check(tad2.begin()); t.test(correctType, "begin (const), return type"); correctType = TypeCheck<const KSArray<double>::value_type *>::check(tad2.end()); t.test(correctType, "end (const), return type"); t.test(taiRef.end() - taiRef.begin() == theSize, "begin/end - check difference (const)"); noErrors = true; for (citer = taiRef.begin(), i = 0; citer != taiRef.end(); ++citer, ++i) { if (*citer != 15 - i * i) noErrors = false; } t.test(noErrors, "begin/end - check values (const)"); }
// test_class_KSArray_default_ctor // Test suite for class KSArray, default ctor // Pre: None. // Post: // Pass/fail status of tests have been registered with t. // Appropriate have been messages printed to cout. // Does not throw (No-Throw Guarantee) void test_class_KSArray_default_ctor(Tester & t) { std::cout << "Test Suite: class KSArray - default ctor" << std::endl; const KSArray<int> tai1; t.test(tai1.size() == 10, "default ctor, size"); }
int main( int argc, char **argv ) { QApplication app( argc, argv ); Tester t; t.test(); return 0; }
// gcd_single_test // Helper function for testing function gcd // Pre: // a, b are nonnegative, not both zero. // c is the GCD of a, b. // Post: // gcd(a, b) == c has been tested. // Pass/fail status has been registered with t. // Appropriate messages have been printed to cout. // Does not throw (No-Throw Guarantee void gcd_single_test(Tester & t, int a, int b, int c) { std::ostringstream oss; int result = gcd(a, b); oss << "gcd(" << a << ", " << b << ") = " << c; if (c != result) oss << " [actual return value: " << result << "]"; t.test(result == c, oss.str()); }
// test_class_SSArray_ctor_dctor_count // Test suite for class SSArray, number of class to item type // ctor, dctor. // Pre: None. // Post: // Pass/fail status of tests have been registered with t. // Appropriate have been messages printed to cout. void test_class_SSArray_ctor_dctor_count(Tester & t) { std::cout << "Test Suite: class SSArray - ctor, dctor count" << std::endl; // Check number of value type ctor/dctor calls on array creation & destruction TestItem::resetCount(); { // Block, so we get dctor calls before function ends const SSArray<TestItem> ssat(10); t.test(TestItem::getCount() == 10, "Counting default ctor calls due to array creation"); TestItem::resetCount(); } t.test(TestItem::getCount() == 10, "Counting dctor calls after due to destruction"); // Check number of value type ctor/dctor calls on self-assignment SSArray<TestItem> ssat2(10); TestItem::resetCount(); ssat2 = ssat2; t.test(TestItem::getCount() == 0, "Self-assignment should generate no ctor/dctor calls"); }
// test_class_KSArray_size_and_ctor_from_size // Test suite for class KSArray, function size and ctor from size // Pre: None. // Post: // Pass/fail status of tests have been registered with t. // Appropriate messages have been printed to cout. // Does not throw (No-Throw Guarantee) void test_class_KSArray_size_and_ctor_from_size(Tester & t) { std::cout << "Test Suite: class KSArray - function size, ctor from size" << std::endl; bool correctType; // result of type checking const KSArray<int> tai1(1); correctType = TypeCheck<KSArray<int>::size_type>::check(tai1.size()); t.test(correctType, "size, return type"); t.test(tai1.size() == 1, "ctor from size (const) #1, check size"); const KSArray<int> tai2(10); t.test(tai2.size() == 10, "ctor from size (const) #2, check size"); const KSArray<double> tad(100); t.test(tad.size() == 100, "ctor from size (const) #3, check size"); KSArray<int> tai3(20); t.test(tai3.size() == 20, "ctor from size (non-const), check size"); const KSArray<int> tai4(0); t.test(tai4.size() == 0, "ctor from size (size 0), check size"); }
// test_class_SSArray_comparisons // Test suite for class SSArray, comparisons // Pre: None. // Post: // Pass/fail status of tests have been registered with t. // Appropriate have been messages printed to cout. void test_class_SSArray_comparisons(Tester & t) { std::cout << "Test Suite: class SSArray - comparisons" << std::endl; const int theSize = 10; int i; // Counter SSArray<int> ssai1(theSize); for (i = 0; i < theSize; ++i) ssai1[i] = 15 - i * i; const SSArray<int> & ssai1Ref = ssai1; const SSArray<int> ssai2(theSize + 1); SSArray<int> ssai1Copy(ssai1Ref); // Check equality of copies t.test(ssai1 == ssai1Copy, "Equality of copies"); // Check inequality of copies t.test(!(ssai1 != ssai1Copy), "Inequality of copies"); // Check equality of different sizes (compilation checks constness of op==) t.test(!(ssai1Ref == ssai2), "Equality of different sizes"); // Check inequality of different sizes (compilation checks constness of op!=) t.test(ssai1Ref != ssai2, "Inequality of different sizes"); // Modify copy ++ssai1Copy[4]; // Check equality of modification of copy t.test(!(ssai1 == ssai1Copy), "Equality of modification of copy"); // Check inequality of modification of copy t.test(ssai1 != ssai1Copy, "Inequality of modification of copy"); }
// test_class_KSArray_ctor_from_size_and_val // Test suite for class KSArray, ctor from size & value // Pre: None. // Post: // Pass/fail status of tests have been registered with t. // Appropriate have been messages printed to cout. // Does not throw (No-Throw Guarantee) void test_class_KSArray_ctor_from_size_and_val(Tester & t) { std::cout << "Test Suite: class KSArray - ctor from size & value" << std::endl; const int theSize = 1000; bool noErrors; // True if no errors encountered const double val = -3.2; KSArray<double> tad(theSize, val); // check size t.test(tad.size() == theSize, "Ctor from size & value - check size"); // check values noErrors = true; for (unsigned int i = 0; i < tad.size(); ++i) { if (tad[i] != val) noErrors = false; } t.test(noErrors, "Ctor from size & value - check values"); }
// test_class_SSArray_begin_end // Test suite for class SSArray, functions begin & end // Pre: None. // Post: // Pass/fail status of tests have been registered with t. // Appropriate have been messages printed to cout. void test_class_SSArray_begin_end(Tester & t) { std::cout << "Test Suite: class SSArray - functions begin & end" << std::endl; const int theSize = 10; bool noErrors; // True if no errors encountered int i; // Counter int * iter; // iterator const int * citer; // const_iterator SSArray<int> ssai(theSize); for (iter = ssai.begin(), i = 0; iter != ssai.end(); ++iter, ++i) *iter = 15 - i * i; // Non-const test t.test (ssai.end() - ssai.begin() == theSize, "begin/end - check difference (non-const)"); noErrors = true; for (iter = ssai.begin(), i = 0; iter != ssai.end(); ++iter, ++i) { if (*iter != 15 - i * i) noErrors = false; } t.test(noErrors, "begin/end - check values (non-const)"); // Make const version, no copy const SSArray<int> & ssaiRef = ssai; // Const test t.test(ssaiRef.end() - ssaiRef.begin() == theSize, "begin/end - check difference (const)"); noErrors = true; for (citer = ssaiRef.begin(), i = 0; citer != ssaiRef.end(); ++citer, ++i) { if (*citer != 15 - i * i) noErrors = false; } t.test(noErrors, "begin/end - check values (const)"); }
int main(){ vector <int> test_vec; Tester t; Tester2 tt; insert_iterator <vector <int> > ll (test_vec,test_vec.begin()); t.test(ll); vector <int>::iterator it; for(it = test_vec.begin(); it != test_vec.end(); ++it){ cout << *it << " "; } cout << endl; return 0; }
int run_main(int, ACE_TCHAR* []) { ACE_START_TEST (ACE_TEXT ("UUID_Test")); Tester tester; int const result = tester.test(); if (result == 0) ACE_DEBUG((LM_DEBUG, ACE_TEXT ("UUID_Test succeeded\n"))); else ACE_ERROR((LM_ERROR, ACE_TEXT ("UUID_Test failed\n"))); ACE_END_TEST; return result; }
// test_function_gcd // Test suite for function gcd // Pre: None. // Post: // Pass/fail status of tests have been registered with t. // Appropriate messages have been printed to cout. // Does not throw (No-Throw Guarantee) void test_function_gcd(Tester & t) { std::cout << "Test Suite: function template gcd (Exercise D)" << std::endl; // Check return type of gcd t.test(TypeCheck<int>::check(gcd(2, 3)), "gcd: return type"); // GCD function data // Three integers: a, b, GCD of a & b std::vector<std::vector<int> > gcd_data { { 0, 1, 1 }, { 1, 0, 1 }, { 1, 1, 1 }, { 3, 10, 1 }, { 10, 3, 1 }, { 6, 15, 3 }, { 15, 6, 3 }, { 5, 100000, 5 }, { 100000, 5, 5 }, { 5, 100001, 1 }, { 100001, 5, 1 }, { 910, 42, 14 }, { 42, 910, 14 }, { 311850, 429975, 4725 }, { 429975, 311850, 4725 }, { 196418, 317811, 1 }, { 317811, 196418, 1 }, { 196418, 317812, 2 }, { 317812, 196418, 2 }, }; // Test function gcd using the above vector for (const auto & v : gcd_data) { gcd_single_test(t, v[0], v[1], v[2]); } }
int main() { // PICTURE Tester *tester = new Tester("Picture"); Picture p; tester->test(p.data, std::string(""), "constructor without filename make an empty string"); p.getPictureFromFile(std::string("file.test")); tester->test(p.data, std::string("this is a test\ncool"), "when a correct filename is provided, it correctly reads the file"); p.getPictureFromFile(std::string("notExistingFile.test")); tester->test(p.data, std::string("ERROR"), "when there is an error, the string is set to ERROR"); delete tester; // PICTURE // TOY tester = new Tester("Toy"); Toy t; tester->test(t.getType(), Toy::BASIC_TOY, "default constructor set the type to BASIC_TOY"); tester->test(t.getName(), std::string("toy"), "default constructor set the name to toy"); tester->test(t.getAscii(), std::string(""), "default constructor set the ascii to ''"); Toy t2(Toy::ALIEN, std::string("E.T"), std::string("file.test")); tester->test(t2.getType(), Toy::ALIEN, "constructor set the type correctly"); tester->test(t2.getName(), std::string("E.T"), "constructor set the name correctly"); tester->test(t2.getAscii(), std::string("this is a test\ncool"), "constructor set the ascii correctly"); t = t2; tester->test(t.getType(), t2.getType() , "operator= set the type correctly"); tester->test(t.getName(), t2.getName(), "operator= set the name correctly"); tester->test(t.getAscii(), t2.getAscii(), "operator= set the ascii correctly"); delete tester; // TOY // BUZZ + WOODY tester = new Tester("Buzz and Woody"); Buzz buzz(std::string("foo")); Woody woody(std::string("bar"), std::string("file.test")); tester->test(buzz.getType(), Toy::BUZZ, "Buzz constructor (no file) set the type correctly"); tester->test(buzz.getName(), std::string("foo"), "Buzz constructor (no file) set the name correctly"); tester->test(buzz.getAscii(), std::string("Buzz !!!"), "Buzz constructor (no file) set the ascii correctly"); tester->test(woody.getType(), Toy::WOODY, "Woody constructor set the type correctly"); tester->test(woody.getName(), std::string("bar"), "Woody constructor set the name correctly"); tester->test(woody.getAscii(), std::string("this is a test\ncool"), "Woody constructor set the ascii correctly"); tester->warn("The following tests cannot be unit tested, please check by hand"); t.speak("I cannot unit test this... Does it work ? (toy)"); buzz.speak("I cannot unit test this... Does it work ? (buzz)"); woody.speak("I cannot unit test this... Does it work ? (woody)"); delete tester; // BUZZ + WOODY // OPERATOR<< tester = new Tester("operator<<"); t << "woohoo"; tester->test(t.getAscii(), std::string("woohoo"), "operator<< with TOY and STRING"); tester->warn("The following test cannot be unit tested, please check by hand"); std::cout << t; delete tester; // OPERATOR<< return 0; }
void sortThreeOfThreeEqual() { T data[] = { 1, 1, 1 }; T expected[] = { 1, 1, 1 }; tester.test(data, expected); }
void sortLimitValues() { T data[] = { max, 0, max, min }; T expected[] = { min, 0, max, max }; tester.test(data, expected); }
/* * Other tests */ void sortLargeA() { T data[] = { 37, min, big, -2, 231, small, big, max, 0, min }; T expected[] = { min, min, small, -2, 0, 37, 231, big, big, max }; tester.test(data, expected); }
void sortOne() { T data[] = { 1 }; T expected[] = { 1 }; tester.test(data, expected); }
void sortTwoIn() { T data[] = { 0, 1 }; T expected[] = { 0, 1 }; tester.test(data, expected); }
// test_class_KSArray_order_comparisons // Test suite for class KSArray, comparisons <, <=, >, >= // Pre: None. // Post: // Pass/fail status of tests have been registered with t. // Appropriate messages have been printed to cout. // Does not throw (No-Throw Guarantee) void test_class_KSArray_order_comparisons(Tester & t) { std::cout << "Test Suite: class KSArray - comparisons" << std::endl; bool correctType; // result of type checking const int theSize = 10; int i; // Counter KSArray<int> tai1(theSize); for (i = 0; i < theSize; ++i) tai1[i] = 15 - i * i; const KSArray<int> tai1Eq(tai1); // Equal to tai1 KSArray<int> tai1Sm1(tai1); // Smaller than tai1, due to values --tai1Sm1[5]; KSArray<int> tai1Sm2(theSize-2); // Smaller than tai1, due to size for (i = 0; i < tai1Sm2.size(); ++i) tai1Sm2[i] = tai1[i]; KSArray<int> cmh(theSize+1); for (i = 0; i < theSize; ++i) cmh[i] = 15 - i * i; cmh[theSize-1]--; // operator< return type correctType = TypeCheck<bool>::check(tai1 < tai1Eq); t.test(correctType, "operator<, return type"); // operator<= return type correctType = TypeCheck<bool>::check(tai1 <= tai1Eq); t.test(correctType, "operator<=, return type"); // operator> return type correctType = TypeCheck<bool>::check(tai1 > tai1Eq); t.test(correctType, "operator>, return type"); // operator>= return type correctType = TypeCheck<bool>::check(tai1 >= tai1Eq); t.test(correctType, "operator>=, return type"); // Equal arrays, operator< t.test(!(tai1 < tai1Eq), "Equal arrays, operator<"); // Equal arrays, operator<= t.test(tai1 <= tai1Eq, "Equal arrays, operator<="); // Equal arrays, operator> t.test(!(tai1 > tai1Eq), "Equal arrays, operator>"); // Equal arrays, operator>= t.test(tai1 >= tai1Eq, "Equal arrays, operator>="); // Differing values #1, operator< t.test(!(tai1 < tai1Sm1), "Differing values #1, operator<"); t.test(!(tai1<cmh),"! 223<222"); // Differing values #1, operator<= t.test(!(tai1 <= tai1Sm1), "Differing values #1, operator<="); // Differing values #1, operator> t.test(tai1 > tai1Sm1, "Differing values #1, operator>"); // Differing values #1, operator>= t.test(tai1 >= tai1Sm1, "Differing values #1, operator>="); // Differing values #2, operator< t.test(tai1Sm1 < tai1, "Differing values #2, operator<"); // Differing values #2, operator<= t.test(tai1Sm1 <= tai1, "Differing values #2, operator<="); // Differing values #2, operator> t.test(!(tai1Sm1 > tai1), "Differing values #2, operator>"); // Differing values #2, operator>= t.test(!(tai1Sm1 >= tai1), "Differing values #2, operator>="); // Differing sizes #1, operator< t.test(!(tai1 < tai1Sm2), "Differing sizes #1, operator<"); // Differing sizes #1, operator<= t.test(!(tai1 <= tai1Sm2), "Differing sizes #1, operator<="); // Differing sizes #1, operator> t.test(tai1 > tai1Sm2, "Differing sizes #1, operator>"); // Differing sizes #1, operator>= t.test(tai1 >= tai1Sm2, "Differing sizes #1, operator>="); // Differing sizes #2, operator< t.test(tai1Sm2 < tai1, "Differing sizes #2, operator<"); // Differing sizes #2, operator<= t.test(tai1Sm2 <= tai1, "Differing sizes #2, operator<="); // Differing sizes #2, operator> t.test(!(tai1Sm2 > tai1), "Differing sizes #2, operator>"); // Differing sizes #2, operator>= t.test(!(tai1Sm2 >= tai1), "Differing sizes #2, operator>="); }
// test_class_SSArray_order_comparisons // Test suite for class template SSArray, comparisons <, <=, >, >= // Pre: None. // Post: // Pass/fail status of tests have been registered with t. // Appropriate messages have been printed to cout. // Does not throw (No-Throw Guarantee) void test_class_SSArray_order_comparisons(Tester & t) { std::cout << "Test Suite: class template SSArray - order comparisons" << std::endl; bool correctType; // result of type checking // Make vector of 10 SSArray<int> objects, in ascending order auto NUM_ARRAYS = static_cast<std::size_t>(10); std::vector<SSArray<int> > vv(NUM_ARRAYS); vv[0] = SSArray<int>(0); vv[1] = SSArray<int>(1); vv[1][0] = -1; vv[2] = SSArray<int>(2); vv[2][0] = -1; vv[2][1] = -1; vv[3] = SSArray<int>(99); for (auto & x : vv[3]) x = -1; vv[4] = SSArray<int>(100); for (auto & x : vv[4]) x = -1; vv[5] = SSArray<int>(100); for (auto & x : vv[5]) x = -1; vv[5][90] = 1; vv[6] = SSArray<int>(2); vv[6][0] = -1; vv[6][1] = 1; vv[7] = SSArray<int>(1); vv[7][0] = 1; vv[8] = SSArray<int>(2); vv[8][0] = 1; vv[8][1] = -1; vv[9] = SSArray<int>(2); vv[9][0] = 1; vv[9][1] = 1; // operator< return type correctType = TypeCheck<bool>::check(vv[0] < vv[1]); t.test(correctType, "operator<, return type"); // operator<= return type correctType = TypeCheck<bool>::check(vv[0] <= vv[1]); t.test(correctType, "operator<=, return type"); // operator> return type correctType = TypeCheck<bool>::check(vv[0] > vv[1]); t.test(correctType, "operator>, return type"); // operator>= return type correctType = TypeCheck<bool>::check(vv[0] >= vv[1]); t.test(correctType, "operator>=, return type"); for (std::size_t i = 0; i < NUM_ARRAYS; ++i) { for (std::size_t j = 0; j < NUM_ARRAYS; ++j) { std::ostringstream os; os << ", test " << i << "," << j; t.test((vv[i] < vv[j]) == (i < j), "operator<" + os.str()); t.test((vv[i] <= vv[j]) == (i <= j), "operator<=" + os.str()); t.test((vv[i] > vv[j]) == (i > j), "operator>" + os.str()); t.test((vv[i] >= vv[j]) == (i >= j), "operator>=" + os.str()); t.test((vv[i] == vv[j]) == (i == j), "operator==" + os.str()); t.test((vv[i] != vv[j]) == (i != j), "operator!=" + os.str()); } } }
// test_class_KSArray_copy_assn // Test suite for class KSArray, copy assignment // Pre: None. // Post: // Pass/fail status of tests have been registered with t. // Appropriate messages have been printed to cout. // Does not throw (No-Throw Guarantee) void test_class_KSArray_copy_assn(Tester & t) { std::cout << "Test Suite: class KSArray - copy assignment" << std::endl; bool correctType; // result of type checking const int theSize = 10; bool noErrors; // True if no errors encountered int i; // Counter KSArray<int> tai(theSize); for (i = 0; i < theSize; ++i) tai[i] = 15 - i * i; // Make const version, no copy const KSArray<int> & taiRef = tai; // Make copy (copy ctor) KSArray<int> taiCopy(1); taiCopy = taiRef; // Do copy assignment & check return type correctType = TypeCheck<KSArray<int> >::check(taiCopy = taiRef); t.test(correctType, "Copy assn - return type"); t.test(taiCopy.size() == theSize, "Copy assn - check size, copy"); noErrors = true; for (i = 0; i < theSize; ++i) { if (taiCopy[i] != 15 - i * i) noErrors = false; } t.test(noErrors, "Copy assn - check values, copy"); // Change original tai[2] = 1000; // Check original noErrors = true; for (i = 0; i < theSize; ++i) { if (tai[i] != ((i == 2) ? 1000 : 15 - i * i)) noErrors = false; } t.test(noErrors, "Copy assn - change original, check values, original"); // Check copy noErrors = true; for (i = 0; i < theSize; ++i) { if (taiCopy[i] != 15 - i * i) noErrors = false; } t.test(noErrors, "Copy assn - change original, check values, copy"); // Change copy taiCopy[3] = 2000; // Check original noErrors = true; for (i = 0; i < theSize; ++i) { if (tai[i] != ((i == 2) ? 1000 : 15 - i * i)) noErrors = false; } t.test(noErrors, "Copy assn - change copy, check values, original"); // Check copy noErrors = true; for (i = 0; i < theSize; ++i) { if (taiCopy[i] != ((i == 3) ? 2000 : 15 - i * i)) noErrors = false; } t.test(noErrors, "Copy assn - change copy, check values, copy"); // Check self-assignment taiCopy = taiCopy; noErrors = true; for (i = 0; i < theSize; ++i) { if (taiCopy[i] != ((i == 3) ? 2000 : 15 - i * i)) noErrors = false; } t.test(noErrors, "Copy assn - values after self-assignment"); }
// test_class_KSArray_copy_ctor // Test suite for class KSArray, copy ctor // Pre: None. // Post: // Pass/fail status of tests have been registered with t. // Appropriate messages have been printed to cout. // Does not throw (No-Throw Guarantee) void test_class_KSArray_copy_ctor(Tester & t) { std::cout << "Test Suite: class KSArray - copy ctor" << std::endl; const int theSize = 10; bool noErrors; // True if no errors encountered int i; // Counter KSArray<int> tai(theSize); for (i = 0; i < theSize; ++i) tai[i] = 15 - i * i; // Make const version, no copy const KSArray<int> & taiRef = tai; // Make copy (copy ctor) KSArray<int> taiCopy(taiRef); t.test(taiCopy.size() == theSize, "Copy ctor - check size, copy"); noErrors = true; for (i = 0; i < theSize; ++i) { if (taiCopy[i] != 15 - i * i) noErrors = false; } t.test(noErrors, "Copy ctor - check values, copy"); // Change original tai[2] = 1000; // Check original noErrors = true; for (i = 0; i < theSize; ++i) { if (tai[i] != ((i == 2) ? 1000 : 15 - i * i)) noErrors = false; } t.test(noErrors, "Copy ctor - change original, check values, original"); // Check copy noErrors = true; for (i = 0; i < theSize; ++i) { if (taiCopy[i] != 15 - i * i) noErrors = false; } t.test(noErrors, "Copy ctor - change original, check values, copy"); // Change copy taiCopy[3] = 2000; // Check original noErrors = true; for (i = 0; i < theSize; ++i) { if (tai[i] != ((i == 2) ? 1000 : 15 - i * i)) noErrors = false; } t.test(noErrors, "Copy ctor - change copy, check values, original"); // Check copy noErrors = true; for (i = 0; i < theSize; ++i) { if (taiCopy[i] != ((i == 3) ? 2000 : 15 - i * i)) noErrors = false; } t.test(noErrors, "Copy ctor - change copy, check values, copy"); }