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;
}
