int test_default_constructor() { { tested_sequence x; FAIL_RETURN_IF(CORBA::ULong(0), x.maximum()); FAIL_RETURN_IF(CORBA::ULong(0), x.length()); FAIL_RETURN_IF(true, x.release()); } }
int test_const_sequence_reverse () { // setup of an example sequence s_sequence setup; setup.length (4); const char * elem0_cstr = "elem0"; const char * elem1_cstr = "elem1"; const char * elem2_cstr = "elem2"; const char * elem3_cstr = "elem3"; setup[0] = CORBA::string_dup (elem0_cstr); setup[1] = CORBA::string_dup (elem1_cstr); setup[2] = CORBA::string_dup (elem2_cstr); setup[3] = CORBA::string_dup (elem3_cstr); const s_sequence a = setup; // test equality operator FAIL_RETURN_IF (!(a.begin () == a.begin ())); // test non-equality operator FAIL_RETURN_IF (a.end () != a.end ()); // test iterator copy constructor REVERSE_ITERATOR_T a_it (a.rbegin ()); FAIL_RETURN_IF (a_it != a.rbegin ()); // test assignment operator a_it = a.rbegin (); FAIL_RETURN_IF (a_it != a.rbegin ()); // test non const dereferencing // JWH2 - I don't think this test makes sense. I believe the compiler // will always return a const value since the dereference is on // the right hand side of the assignment (i.e., r value). //char* value0 = *a_it; //FAIL_RETURN_IF (ACE_OS::strcmp (value0, elem3_cstr) != 0); // test const dereferencing const char* const value1 = *a_it; FAIL_RETURN_IF (ACE_OS::strcmp (value1, elem3_cstr) != 0); // test increment operation a_it++; FAIL_RETURN_IF (a_it == a.rbegin()); FAIL_RETURN_IF (ACE_OS::strcmp (*a_it, elem2_cstr) != 0); // test < operator FAIL_RETURN_IF (!(a.rbegin () < a_it)); FAIL_RETURN_IF (a_it < a.rbegin ()); // test difference type int a_diff = a_it - a.rbegin (); FAIL_RETURN_IF (a_diff != 1); // test copy constructor REVERSE_ITERATOR_T a_it1 (a_it); FAIL_RETURN_IF (a_it1 != a_it); // test preincrement operator ++a_it1; FAIL_RETURN_IF ((a_it1 - a_it) != 1); // test = and += operator REVERSE_ITERATOR_T a_it2 = a_it += 3; FAIL_RETURN_IF (a_it2 != a_it); FAIL_RETURN_IF ((a_it - a_it1) != 2); // test + operator a_it2 = a_it1 + 3; FAIL_RETURN_IF ((a_it2 - a_it1) != 3); // test post-decrement operation a_it = a.rend (); a_it--; FAIL_RETURN_IF (a_it == a.rend ()); FAIL_RETURN_IF ((a.rend () - a_it) != 1); FAIL_RETURN_IF (ACE_OS::strcmp (*a_it, elem0_cstr) != 0); // test pre-decrement operator a_it = a.rend (); --a_it; FAIL_RETURN_IF (a_it == a.rend ()); FAIL_RETURN_IF ((a.rend () - a_it) != 1); FAIL_RETURN_IF (ACE_OS::strcmp (*a_it, elem0_cstr) != 0); // test -= operator a_it -= 3; FAIL_RETURN_IF ((a_it1 - a_it) != 2); // test - operator a_it2 = a_it1 - 2; FAIL_RETURN_IF ((a_it1 - a_it2) != 2); // test operator[] read a_it = a.rbegin (); FAIL_RETURN_IF (ACE_OS::strcmp (a_it[0],a[3]) != 0); a_it += 2; FAIL_RETURN_IF (ACE_OS::strcmp (a_it[0],a[1]) != 0); // test for loop behaviour s_sequence b = a; REVERSE_ITERATOR_T b_it = b.rbegin (); for (a_it = a.rbegin (); a_it != a.rend (); a_it++, b_it++) { FAIL_RETURN_IF (ACE_OS::strcmp (*a_it, *b_it) != 0); } s_sequence test; test.length (a.length ()); std::copy (a.begin (), a.end (), test.begin ()); FAIL_RETURN_IF (test.length () != a.length ()); REVERSE_ITERATOR_T copytest_iter = test.rbegin (); for (REVERSE_ITERATOR_T copya_iter = a.rbegin (); copya_iter != a.rend (); ++copya_iter, ++copytest_iter) { FAIL_RETURN_IF (ACE_OS::strcmp (*copya_iter, *copytest_iter) != 0); } /// Testing - using ostream_iterator std::ostringstream ostream; std::copy (a.rbegin (), a.rend (), // JWH2 - I changed value_type to const_value_type. Is that // the correct approach? std::ostream_iterator<s_sequence::const_value_type> (ostream, "\n")); FAIL_RETURN_IF ( ostream.str ().compare ("elem3\nelem2\nelem1\nelem0\n") != 0); return 0; }
int test_const_sequence_reverse () { // setup of an example sequence tested_sequence setup; setup.length (4); mock_reference* elem0 = mock_reference::allocate (0); mock_reference* elem1 = mock_reference::allocate (1); mock_reference* elem2 = mock_reference::allocate (2); mock_reference* elem3 = mock_reference::allocate (3); // setup of an example sequence setup[0] = elem0; setup[1] = elem1; setup[2] = elem2; setup[3] = elem3; const tested_sequence a = setup; // test equality operator FAIL_RETURN_IF (!(a.begin () == a.begin ())); // test non-equality operator FAIL_RETURN_IF (a.end () != a.end ()); // test iterator copy constructor REVERSE_ITERATOR_T a_it (a.rbegin ()); FAIL_RETURN_IF (a_it != a.rbegin ()); // test assignment operator a_it = a.rbegin (); FAIL_RETURN_IF (a_it != a.rbegin ()); // test non const dereferencing mock_reference* value0 = *a_it; FAIL_RETURN_IF (value0->id () != elem3->id ()); // test const dereferencing const mock_reference* const value1 = *a_it; FAIL_RETURN_IF (value1->id () != elem3->id ()); // test increment operation a_it++; FAIL_RETURN_IF (a_it == a.rbegin()); FAIL_RETURN_IF ((*a_it)->id () != elem2->id ()); // test < operator FAIL_RETURN_IF (!(a.rbegin () < a_it)); FAIL_RETURN_IF (a_it < a.rbegin ()); // test difference type int a_diff = a_it - a.rbegin (); FAIL_RETURN_IF (a_diff != 1); // test copy constructor REVERSE_ITERATOR_T a_it1 (a_it); FAIL_RETURN_IF (a_it1 != a_it); // test preincrement operator ++a_it1; FAIL_RETURN_IF ((a_it1 - a_it) != 1); // test = and += operator REVERSE_ITERATOR_T a_it2 = a_it += 3; FAIL_RETURN_IF (a_it2 != a_it); FAIL_RETURN_IF ((a_it - a_it1) != 2); // test + operator a_it2 = a_it1 + 3; FAIL_RETURN_IF ((a_it2 - a_it1) != 3); // test post-decrement operation a_it = a.rend (); a_it--; FAIL_RETURN_IF (a_it == a.rend ()); FAIL_RETURN_IF ((a.rend () - a_it) != 1); FAIL_RETURN_IF ((*a_it)->id () != elem0->id ()); // test pre-decrement operator a_it = a.rend (); --a_it; FAIL_RETURN_IF (a_it == a.rend ()); FAIL_RETURN_IF ((a.rend () - a_it) != 1); FAIL_RETURN_IF ((*a_it)->id () != elem0->id ()); // test -= operator a_it -= 3; FAIL_RETURN_IF ((a_it1 - a_it) != 2); // test - operator a_it2 = a_it1 - 2; FAIL_RETURN_IF ((a_it1 - a_it2) != 2); // test operator[] read a_it = a.rbegin (); FAIL_RETURN_IF ((a_it[0])->id () != a[3]->id ()); a_it += 2; FAIL_RETURN_IF ((a_it[0])->id () != a[1]->id ()); // test operator[] write // NOTE: This now changes the sequence a. // this is not possible for const iterators // a_it[0] = CORBA::string_dup (elem0_cstr); // FAIL_RETURN_IF (ACE_OS::strcmp (a[1],elem0_cstr) != 0); // reset content of sequence a //a[1] = CORBA::string_dup (elem1_cstr); // test for loop behaviour tested_sequence b = a; REVERSE_ITERATOR_T b_it = b.rbegin (); for (a_it = a.rbegin (); a_it != a.rend (); a_it++, b_it++) { FAIL_RETURN_IF ((*a_it)->id () != (*b_it)->id ()); } tested_sequence test; test.length (a.length ()); /* * The copy call below causes double deletes and seg faults. */ std::copy (a.begin (), a.end (), test.begin ()); FAIL_RETURN_IF (test.length () != a.length ()); REVERSE_ITERATOR_T copytest_iter = test.rbegin (); for (REVERSE_ITERATOR_T copya_iter = a.rbegin (); copya_iter != a.rend (); ++copya_iter, ++copytest_iter) { FAIL_RETURN_IF ((*copya_iter)->id () != (*copytest_iter)->id ()); } /// Testing - using ostream_iterator /// JWH2 - I don't think the ostream test makes sense for object references. /* std::ostringstream ostream; std::copy (a.rbegin (), a.rend (), std::ostream_iterator<tested_sequence::value_type> (ostream, "\n")); FAIL_RETURN_IF ( ostream.str ().compare ("elem3\nelem2\nelem1\nelem0\n") != 0); */ return 0; }
int test_const_sequence_reverse () { // setup of an example sequence v_sequence setup; setup.length (4); int elem0 = 0; int elem1 = 1; int elem2 = 2; int elem3 = 3; setup[0] = elem0; setup[1] = elem1; setup[2] = elem2; setup[3] = elem3; const v_sequence a = setup; // test equality operator FAIL_RETURN_IF (!(a.begin () == a.begin ())); // test non-equality operator FAIL_RETURN_IF (a.end () != a.end ()); // test iterator copy constructor REVERSE_ITERATOR_T a_it (a.rbegin ()); FAIL_RETURN_IF (a_it != a.rbegin ()); // test assignment operator a_it = a.rbegin (); FAIL_RETURN_IF (a_it != a.rbegin ()); // test non const dereferencing // JWH2 - I don't think this test makes sense. I believe the compiler // will always return a const value since the dereference is on // the right hand side of the assignment (i.e., r value). //int value0 = *a_it; //FAIL_RETURN_IF (value0 != elem3); // test const dereferencing int value1 = *a_it; FAIL_RETURN_IF (value1 != elem3); // test increment operation a_it++; FAIL_RETURN_IF (a_it == a.rbegin()); FAIL_RETURN_IF (*a_it != elem2); // test < operator FAIL_RETURN_IF (!(a.rbegin () < a_it)); FAIL_RETURN_IF (a_it < a.rbegin ()); // test difference type int a_diff = a_it - a.rbegin (); FAIL_RETURN_IF (a_diff != 1); // test copy constructor REVERSE_ITERATOR_T a_it1 (a_it); FAIL_RETURN_IF (a_it1 != a_it); // test preincrement operator ++a_it1; FAIL_RETURN_IF ((a_it1 - a_it) != 1); // test = and += operator REVERSE_ITERATOR_T a_it2 = a_it += 3; FAIL_RETURN_IF (a_it2 != a_it); FAIL_RETURN_IF ((a_it - a_it1) != 2); // test + operator a_it2 = a_it1 + 3; FAIL_RETURN_IF ((a_it2 - a_it1) != 3); // test post-decrement operation a_it = a.rend (); a_it--; FAIL_RETURN_IF (a_it == a.rend ()); FAIL_RETURN_IF ((a.rend () - a_it) != 1); FAIL_RETURN_IF (*a_it != elem0); // test pre-decrement operator a_it = a.rend (); --a_it; FAIL_RETURN_IF (a_it == a.rend ()); FAIL_RETURN_IF ((a.rend () - a_it) != 1); FAIL_RETURN_IF (*a_it != elem0); // test -= operator a_it -= 3; FAIL_RETURN_IF ((a_it1 - a_it) != 2); // test - operator a_it2 = a_it1 - 2; FAIL_RETURN_IF ((a_it1 - a_it2) != 2); // test operator[] read a_it = a.rbegin (); FAIL_RETURN_IF (a_it[0] != a[3]); a_it += 2; FAIL_RETURN_IF (a_it[0] != a[1]); // test operator[] write // NOTE: This now changes the sequence a. // this is not possible for const iterators // a_it[0] = elem0; // FAIL_RETURN_IF (a[1] != elem0); // reset content of sequence a //a[1] = elem1; // test for loop behaviour v_sequence b = a; REVERSE_ITERATOR_T b_it = b.rbegin (); for (a_it = a.rbegin (); a_it != a.rend (); a_it++, b_it++) { FAIL_RETURN_IF (*a_it != *b_it); } v_sequence test; test.length (a.length ()); std::copy (a.begin (), a.end (), test.begin ()); FAIL_RETURN_IF (test.length () != a.length ()); REVERSE_ITERATOR_T copytest_iter = test.rbegin (); for (REVERSE_ITERATOR_T copya_iter = a.rbegin (); copya_iter != a.rend (); ++copya_iter, ++copytest_iter) { FAIL_RETURN_IF (*copya_iter != *copytest_iter); } /// Testing - using ostream_iterator std::ostringstream ostream; std::copy (a.rbegin (), a.rend (), // JWH2 - I changed value_type to const_value_type. Is that // the correct approach? std::ostream_iterator<v_sequence::const_value_type> (ostream, "\n")); FAIL_RETURN_IF ( ostream.str ().compare ("3\n2\n1\n0\n") != 0); return 0; }
int test_sequence_reverse () { tested_sequence a; // test equality operator FAIL_RETURN_IF (!(a.begin () == a.begin ())); // test non-equality operator FAIL_RETURN_IF (a.end () != a.end ()); // test for correct behaviour for empty sequence FAIL_RETURN_IF (a.begin() != a.end ()); // setup of an example sequence a.length (4); mock_reference* elem0 = mock_reference::allocate (0); mock_reference* elem1 = mock_reference::allocate (1); mock_reference* elem2 = mock_reference::allocate (2); mock_reference* elem3 = mock_reference::allocate (3); // setup of an example sequence a.length (4); a[0] = elem0; a[1] = elem1; a[2] = elem2; a[3] = elem3; // test iterator copy constructor REVERSE_ITERATOR_T a_it (a.rbegin ()); FAIL_RETURN_IF (a_it != a.rbegin ()); // test assignment operator a_it = a.rbegin (); FAIL_RETURN_IF (a_it != a.rbegin ()); // test non const dereferencing mock_reference* value0 = *a_it; FAIL_RETURN_IF (value0->id () != elem3->id ()); // test const dereferencing const mock_reference* const value1 = *a_it; FAIL_RETURN_IF (value1->id () != elem3->id ()); // test increment operation a_it++; FAIL_RETURN_IF (a_it == a.rbegin()); FAIL_RETURN_IF ((*a_it)->id () != elem2->id ()); // test < operator FAIL_RETURN_IF (!(a.rbegin () < a_it)); FAIL_RETURN_IF (a_it < a.rbegin ()); // test difference type int a_diff = a_it - a.rbegin (); FAIL_RETURN_IF (a_diff != 1); // test copy constructor REVERSE_ITERATOR_T a_it1 (a_it); FAIL_RETURN_IF (a_it1 != a_it); // test preincrement operator ++a_it1; FAIL_RETURN_IF ((a_it1 - a_it) != 1); // test = and += operator REVERSE_ITERATOR_T a_it2 = a_it += 3; FAIL_RETURN_IF (a_it2 != a_it); FAIL_RETURN_IF ((a_it - a_it1) != 2); // test + operator a_it2 = a_it1 + 3; FAIL_RETURN_IF ((a_it2 - a_it1) != 3); // test post-decrement operation a_it = a.rend (); a_it--; FAIL_RETURN_IF (a_it == a.rend ()); FAIL_RETURN_IF ((a.rend () - a_it) != 1); FAIL_RETURN_IF ((*a_it)->id () != elem0->id ()); // test pre-decrement operator a_it = a.rend (); --a_it; FAIL_RETURN_IF (a_it == a.rend ()); FAIL_RETURN_IF ((a.rend () - a_it) != 1); FAIL_RETURN_IF ((*a_it)->id () != elem0->id ()); // test -= operator a_it -= 3; FAIL_RETURN_IF ((a_it1 - a_it) != 2); // test - operator a_it2 = a_it1 - 2; FAIL_RETURN_IF ((a_it1 - a_it2) != 2); // test operator[] read a_it = a.rbegin (); FAIL_RETURN_IF ((a_it[0])->id () != a[3]->id ()); a_it += 2; FAIL_RETURN_IF ((a_it[0])->id () != a[1]->id ()); // test for loop behaviour tested_sequence b = a; REVERSE_ITERATOR_T b_it = b.rbegin (); for (a_it = a.rbegin (); a_it != a.rend (); a_it++, b_it++) { FAIL_RETURN_IF ((*a_it)->id () != (*b_it)->id ()); } tested_sequence test; test.length (a.length ()); std::copy (a.begin (), a.end (), test.begin ()); FAIL_RETURN_IF (test.length () != a.length ()); REVERSE_ITERATOR_T copytest_iter = test.rbegin (); for (REVERSE_ITERATOR_T copya_iter = a.rbegin (); copya_iter != a.rend (); ++copya_iter, ++copytest_iter) { FAIL_RETURN_IF ((*copya_iter)->id () != (*copytest_iter)->id ()); } /// Testing - using ostream_iterator /// JWH2 - I don't think the ostream test makes sense for object references. /* std::ostringstream ostream; std::copy (a.rbegin (), a.rend (), std::ostream_iterator<tested_sequence::value_type> (ostream, "\n")); FAIL_RETURN_IF ( ostream.str ().compare ("elem3\nelem2\nelem1\nelem0\n") != 0); */ return 0; }