ListTest Class Reference

Inheritance diagram for ListTest:

Collaboration diagram for ListTest:

Protected Member Functions
void	list1 ()
void	list2 ()
void	list3 ()
void	list4 ()
void	erase ()
void	resize ()
void	push_back ()
void	push_front ()
void	allocator_with_state ()
void	swap ()
void	adl ()

Private Member Functions
	CPPUNIT_TEST_SUITE (ListTest)
	CPPUNIT_TEST (list1)
	CPPUNIT_TEST (list2)
	CPPUNIT_TEST (list3)
	CPPUNIT_TEST (list4)
	CPPUNIT_TEST (erase)
	CPPUNIT_TEST (resize)
	CPPUNIT_TEST (push_back)
	CPPUNIT_TEST (push_front)
	CPPUNIT_TEST (allocator_with_state)
	CPPUNIT_TEST (swap)
	CPPUNIT_TEST (adl)
	CPPUNIT_TEST_SUITE_END ()

Detailed Description

Definition at line 18 of file list_test.cpp.

Member Function Documentation

adl()

void ListTest::adl ( )

protected

Definition at line 451 of file list_test.cpp.

{
  list<foo::bar> lbar;
  CPPUNIT_ASSERT( lbar.size() == 0);
}

allocator_with_state()

void ListTest::allocator_with_state ( )

protected

Definition at line 272 of file list_test.cpp.

{
  char buf1[1024];
  StackAllocator<int> stack1(buf1, buf1 + sizeof(buf1));
 
  char buf2[1024];
  StackAllocator<int> stack2(buf2, buf2 + sizeof(buf2));
 
  typedef list<int, StackAllocator<int> > ListInt;
  {
    //Swap with both list non empty
    ListInt lint1(10, 0, stack1);
    ListInt lint1Cpy(lint1);
 
    ListInt lint2(10, 1, stack2);
    ListInt lint2Cpy(lint2);
 
    lint1.swap(lint2);
 
    CPPUNIT_ASSERT( lint1.get_allocator().swaped() );
    CPPUNIT_ASSERT( lint2.get_allocator().swaped() );
 
    CPPUNIT_ASSERT( lint1 == lint2Cpy );
    CPPUNIT_ASSERT( lint2 == lint1Cpy );
    CPPUNIT_ASSERT( lint1.get_allocator() == stack2 );
    CPPUNIT_ASSERT( lint2.get_allocator() == stack1 );
  }
  CPPUNIT_CHECK( stack1.ok() );
  CPPUNIT_CHECK( stack2.ok() );
  stack1.reset(); stack2.reset();
 
  {
    //Swap with empty calle list
    ListInt lint1(10, 0, stack1);
    ListInt lint1Cpy(lint1);
 
    ListInt lint2(stack2);
    ListInt lint2Cpy(lint2);
 
    lint1.swap(lint2);
 
    CPPUNIT_ASSERT( lint1.get_allocator().swaped() );
    CPPUNIT_ASSERT( lint2.get_allocator().swaped() );
 
    CPPUNIT_ASSERT( lint1 == lint2Cpy );
    CPPUNIT_ASSERT( lint2 == lint1Cpy );
    CPPUNIT_ASSERT( lint1.get_allocator() == stack2 );
    CPPUNIT_ASSERT( lint2.get_allocator() == stack1 );
  }
  CPPUNIT_CHECK( stack1.ok() );
  CPPUNIT_CHECK( stack2.ok() );
  stack1.reset(); stack2.reset();
 
  {
    //Swap with empty caller list
    ListInt lint1(stack1);
    ListInt lint1Cpy(lint1);
 
    ListInt lint2(10, 0, stack2);
    ListInt lint2Cpy(lint2);
 
    lint1.swap(lint2);
 
    CPPUNIT_ASSERT( lint1.get_allocator().swaped() );
    CPPUNIT_ASSERT( lint2.get_allocator().swaped() );
 
    CPPUNIT_ASSERT( lint1 == lint2Cpy );
    CPPUNIT_ASSERT( lint2 == lint1Cpy );
    CPPUNIT_ASSERT( lint1.get_allocator() == stack2 );
    CPPUNIT_ASSERT( lint2.get_allocator() == stack1 );
  }
  CPPUNIT_CHECK( stack1.ok() );
  CPPUNIT_CHECK( stack2.ok() );
  stack1.reset(); stack2.reset();
 
  {
    ListInt lint1(10, 0, stack1);
    ListInt lint2(10, 1, stack2);
 
    lint1.splice(lint1.begin(), lint2);
    CPPUNIT_ASSERT( lint1.size() == 20 );
    CPPUNIT_ASSERT( lint2.empty() );
  }
  CPPUNIT_CHECK( stack1.ok() );
  CPPUNIT_CHECK( stack2.ok() );
  stack1.reset(); stack2.reset();
 
  {
    ListInt lint1(10, 0, stack1);
    ListInt lint2(10, 1, stack2);
 
    lint1.splice(lint1.begin(), lint2, lint2.begin());
    CPPUNIT_ASSERT( lint1.size() == 11 );
    CPPUNIT_ASSERT( lint2.size() == 9 );
  }
  CPPUNIT_CHECK( stack1.ok() );
  CPPUNIT_CHECK( stack2.ok() );
  stack1.reset(); stack2.reset();
 
  {
    ListInt lint1(10, 0, stack1);
    ListInt lint2(10, 1, stack2);
 
    ListInt::iterator lit(lint2.begin());
    advance(lit, 5);
    lint1.splice(lint1.begin(), lint2, lint2.begin(), lit);
    CPPUNIT_ASSERT( lint1.size() == 15 );
    CPPUNIT_ASSERT( lint2.size() == 5 );
  }
  CPPUNIT_CHECK( stack1.ok() );
  CPPUNIT_CHECK( stack2.ok() );
  stack1.reset(); stack2.reset();
 
  {
    ListInt lint1(10, 0, stack1);
    ListInt lint2(10, 1, stack2);
 
    ListInt lintref(stack2);
    lintref.insert(lintref.begin(), 10, 1);
    lintref.insert(lintref.begin(), 10, 0);
 
    lint1.merge(lint2);
    CPPUNIT_ASSERT( lint1.size() == 20 );
    CPPUNIT_ASSERT( lint1 == lintref );
    CPPUNIT_ASSERT( lint2.empty() );
  }
  CPPUNIT_CHECK( stack1.ok() );
  CPPUNIT_CHECK( stack2.ok() );
 
#if defined (STLPORT) && !defined (_STLP_NO_MEMBER_TEMPLATES) && \
    (!defined (_MSC_VER) || (_MSC_VER >= 1300))
  {
    //This is a compile time test.
    //We check that sort implementation is correct when list is instanciated
    //with an allocator that do not have a default constructor.
    ListInt lint1(10, 0, stack1);
    lint1.sort();
    lint1.sort(greater<int>());
  }
#endif
}

CPPUNIT_TEST() [1/11]

ListTest::CPPUNIT_TEST ( adl  )

private

CPPUNIT_TEST() [2/11]

ListTest::CPPUNIT_TEST ( allocator_with_state  )

private

CPPUNIT_TEST() [3/11]

ListTest::CPPUNIT_TEST ( erase  )

private

CPPUNIT_TEST() [4/11]

ListTest::CPPUNIT_TEST ( list1  )

private

CPPUNIT_TEST() [5/11]

ListTest::CPPUNIT_TEST ( list2  )

private

CPPUNIT_TEST() [6/11]

ListTest::CPPUNIT_TEST ( list3  )

private

CPPUNIT_TEST() [7/11]

ListTest::CPPUNIT_TEST ( list4  )

private

CPPUNIT_TEST() [8/11]

ListTest::CPPUNIT_TEST ( push_back  )

private

CPPUNIT_TEST() [9/11]

ListTest::CPPUNIT_TEST ( push_front  )

private

CPPUNIT_TEST() [10/11]

ListTest::CPPUNIT_TEST ( resize  )

private

CPPUNIT_TEST() [11/11]

ListTest::CPPUNIT_TEST ( swap  )

private

CPPUNIT_TEST_SUITE()

ListTest::CPPUNIT_TEST_SUITE ( ListTest  )

private

CPPUNIT_TEST_SUITE_END()

ListTest::CPPUNIT_TEST_SUITE_END ( )

private

erase()

void ListTest::erase ( )

protected

Definition at line 174 of file list_test.cpp.

{
  list<int> l;
  l.push_back( 1 );
  l.erase(l.begin());
  CPPUNIT_ASSERT( l.empty() );
 
  int array[] = { 0, 1, 2, 3 };
  l.assign(array, array + 4);
  list<int>::iterator lit;
  lit = l.erase(l.begin());
  CPPUNIT_ASSERT( *lit == 1 );
 
  lit = l.erase(l.begin(), --l.end());
  CPPUNIT_ASSERT( *lit == 3 );
 
  l.clear();
  CPPUNIT_ASSERT( l.empty() );
}

list1()

void ListTest::list1 ( )

protected

Definition at line 55 of file list_test.cpp.

{
  int array1 [] = { 9, 16, 36 };
  int array2 [] = { 1, 4 };
 
  list<int> l1(array1, array1 + 3);
  list<int> l2(array2, array2 + 2);
  list<int>::iterator i1 = l1.begin();
  list<int>::iterator i2 = l2.begin();
  list<int>::const_iterator ci(i1);
  list<int>::const_iterator ci1(ci);
  l1.splice(i1, l2);
  i1 = l1.begin();
  CPPUNIT_ASSERT( *i1++ == 1 );
  CPPUNIT_ASSERT( *i1++ == 4 );
  CPPUNIT_ASSERT( *i1++ == 9 );
  CPPUNIT_ASSERT( *i1++ == 16 );
  CPPUNIT_ASSERT( *i1++ == 36 );
 
#if defined (STLPORT) && \
   (!defined (_STLP_DEBUG) || (_STLP_DEBUG_LEVEL != _STLP_STANDARD_DBG_LEVEL))
  CPPUNIT_ASSERT( i2 == l1.begin() );
#endif
 
  //Default construct check (_STLP_DEF_CONST_PLCT_NEW_BUG)
  list<int> l(2);
  i1 = l.begin();
  CPPUNIT_ASSERT( *(i1++) == 0 );
  CPPUNIT_ASSERT( *i1 == 0 );
#if 0
  //A small compilation time check to be activated from time to time,
  //compilation should fail.
  {
    list<char>::iterator l_char_ite;
    list<int>::iterator l_int_ite;
    CPPUNIT_ASSERT( l_char_ite != l_int_ite );
  }
#endif
}

list2()

void ListTest::list2 ( )

protected

Definition at line 95 of file list_test.cpp.

{
  int array1 [] = { 1, 16 };
  int array2 [] = { 4, 9 };
 
  list<int> l1(array1, array1 + 2);
  list<int> l2(array2, array2 + 2);
  list<int>::iterator i = l1.begin();
  i++;
  l1.splice(i, l2, l2.begin(), l2.end());
  i = l1.begin();
  CPPUNIT_ASSERT(*i++==1);
  CPPUNIT_ASSERT(*i++==4);
  CPPUNIT_ASSERT(*i++==9);
  CPPUNIT_ASSERT(*i++==16);
}

list3()

void ListTest::list3 ( )

protected

Definition at line 112 of file list_test.cpp.

{
  char array [] = { 'x', 'l', 'x', 't', 's', 's' };
 
  list<char> str(array, array + 6);
  list<char>::iterator i;
 
  str.reverse();
  i = str.begin();
  CPPUNIT_ASSERT(*i++=='s');
  CPPUNIT_ASSERT(*i++=='s');
  CPPUNIT_ASSERT(*i++=='t');
  CPPUNIT_ASSERT(*i++=='x');
  CPPUNIT_ASSERT(*i++=='l');
  CPPUNIT_ASSERT(*i++=='x');
 
  str.remove('x');
  i = str.begin();
  CPPUNIT_ASSERT(*i++=='s');
  CPPUNIT_ASSERT(*i++=='s');
  CPPUNIT_ASSERT(*i++=='t');
  CPPUNIT_ASSERT(*i++=='l');
 
  str.unique();
  i = str.begin();
  CPPUNIT_ASSERT(*i++=='s');
  CPPUNIT_ASSERT(*i++=='t');
  CPPUNIT_ASSERT(*i++=='l');
 
  str.sort();
  i = str.begin();
  CPPUNIT_ASSERT(*i++=='l');
  CPPUNIT_ASSERT(*i++=='s');
  CPPUNIT_ASSERT(*i++=='t');
}

list4()

void ListTest::list4 ( )

protected

Definition at line 148 of file list_test.cpp.

{
  int array1 [] = { 1, 3, 6, 7 };
  int array2 [] = { 2, 4 };
 
  list<int> l1(array1, array1 + 4);
  list<int> l2(array2, array2 + 2);
  l1.merge(l2);
  list<int>::iterator i = l1.begin();
  CPPUNIT_ASSERT(*i++==1);
  CPPUNIT_ASSERT(*i++==2);
  CPPUNIT_ASSERT(*i++==3);
  CPPUNIT_ASSERT(*i++==4);
  CPPUNIT_ASSERT(*i++==6);
  CPPUNIT_ASSERT(*i++==7);
 
  //We use distance to avoid a simple call to an internal counter
  CPPUNIT_ASSERT(distance(l1.begin(), l1.end()) == 6);
  CPPUNIT_ASSERT(distance(l2.begin(), l2.end()) == 0);
 
  l1.swap(l2);
 
  CPPUNIT_ASSERT(distance(l1.begin(), l1.end()) == 0);
  CPPUNIT_ASSERT(distance(l2.begin(), l2.end()) == 6);
}

push_back()

void ListTest::push_back ( )

protected

Definition at line 232 of file list_test.cpp.

{
  list<int> l;
  l.push_back( 1 );
  l.push_back( 2 );
  l.push_back( 3 );
 
  list<int>::reverse_iterator r = l.rbegin();
 
  CPPUNIT_ASSERT( *r == 3 );
  l.push_back( 4 );
  /*
   * Following lines are commented, because ones show standard contradiction
   * (24.4.1 and 23.2.2.3); but present behaviour is valid, 24.4.1, paragraphs 1 and 2,
   * 24.4.1.3.3 and 23.1 paragraph 9 (Table 66). The 24.4.1 is more common rule,
   * so it has preference under 23.2.2.3, by my opinion.
   *
   *      - ptr
   */
  // CPPUNIT_ASSERT( *r == 3 );
  // ++r;
  // CPPUNIT_ASSERT( *r == 2 );
}

push_front()

void ListTest::push_front ( )

protected

Definition at line 256 of file list_test.cpp.

{
  list<int> l;
  l.push_back( 1 );
  l.push_back( 2 );
  l.push_back( 3 );
 
  list<int>::iterator i = l.begin();
 
  CPPUNIT_ASSERT( *i == 1 );
  l.push_front( 0 );
  CPPUNIT_ASSERT( *i == 1 );
  ++i;
  CPPUNIT_ASSERT( *i == 2 );
}

resize()

void ListTest::resize ( )

protected

Definition at line 195 of file list_test.cpp.

{
  {
    list<int> l;
    l.resize(5, 1);
 
    size_t i;
    list<int>::iterator lit(l.begin());
    for (i = 0; i < 5; ++i) {
      CPPUNIT_ASSERT( lit != l.end() );
      CPPUNIT_ASSERT( *(lit++) == 1 );
    }
    CPPUNIT_ASSERT( lit == l.end() );
 
    l.resize(3);
    lit = l.begin();
    for (i = 0; i < 3; ++i) {
      CPPUNIT_ASSERT( lit != l.end() );
      CPPUNIT_ASSERT( *(lit++) == 1 );
    }
    CPPUNIT_ASSERT( lit == l.end() );
  }
 
  {
    list<int> l;
    l.resize(5);
 
    size_t i;
    list<int>::iterator lit(l.begin());
    for (i = 0; i < 5; ++i) {
      CPPUNIT_ASSERT( lit != l.end() );
      CPPUNIT_ASSERT( *(lit++) == 0 );
    }
    CPPUNIT_ASSERT( lit == l.end() );
  }
}

swap()

void ListTest::swap ( )

protected

Definition at line 422 of file list_test.cpp.

{
  list<int> lst1;
  list<int> lst2;
 
  lst1.push_back(1);
  lst2.push_back(2);
 
  lst1.swap( lst2 );
 
  CPPUNIT_CHECK( lst1.front() == 2 );
  CPPUNIT_CHECK( lst2.front() == 1 );
  CPPUNIT_CHECK( lst1.size() == 1 );
  CPPUNIT_CHECK( lst2.size() == 1 );
 
  lst1.pop_front();
  lst2.pop_front();
 
  CPPUNIT_CHECK( lst1.empty() );
  CPPUNIT_CHECK( lst2.empty() );
}

---

The documentation for this class was generated from the following file:

• sdk/lib/3rdparty/stlport/test/unit/list_test.cpp