// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

//Has to be first for StackAllocator swap overload to be taken

//into account (at least using GCC 4.0.1)

#include "stack_allocator.h"

#include <e32std.h>

#include <vector>

#include <algorithm>

#if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)

# include <stdexcept>

#endif

#include "cppunit/cppunit_proxy.h"

#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)

using namespace std;

#endif

//

// TestCase class

//

class VectorTest : public CPPUNIT_NS::TestCase

{

  CPPUNIT_TEST_SUITE(VectorTest);

  CPPUNIT_TEST(vec_test_1);

  CPPUNIT_TEST(vec_test_2);

  CPPUNIT_TEST(vec_test_3);

  CPPUNIT_TEST(vec_test_4);

  CPPUNIT_TEST(vec_test_5);

  CPPUNIT_TEST(vec_test_6);

  CPPUNIT_TEST(vec_test_7);

  CPPUNIT_TEST(capacity);

  CPPUNIT_TEST(at);

  CPPUNIT_TEST(pointer);

  CPPUNIT_TEST(auto_ref);

  CPPUNIT_TEST(allocator_with_state);

  CPPUNIT_TEST(iterators);

#if defined (STLPORT) && defined (_STLP_NO_MEMBER_TEMPLATES)

  CPPUNIT_IGNORE;

#endif

  CPPUNIT_TEST(optimizations_check);

  CPPUNIT_STOP_IGNORE;

  CPPUNIT_TEST(ebo);

  CPPUNIT_TEST(vec_cov1);

  CPPUNIT_TEST(vec_cov2);

  CPPUNIT_TEST(vec_cov3);

  CPPUNIT_TEST(vec_cov4);

  CPPUNIT_TEST_SUITE_END();

protected:

  void vec_test_1();

  void vec_test_2();

  void vec_test_3();

  void vec_test_4();

  void vec_test_5();

  void vec_test_6();

  void vec_test_7();

  void capacity();

  void at();

  void pointer();

  void auto_ref();

  void allocator_with_state();

  void iterators();

  void optimizations_check();

  void ebo();

  void vec_cov1();

  void vec_cov2();

  void vec_cov3();

  void vec_cov4();

};

CPPUNIT_TEST_SUITE_REGISTRATION(VectorTest);

//

// tests implementation

//

void VectorTest::vec_test_1()

{

  vector<int> v1; // Empty vector of integers.

  CPPUNIT_ASSERT( v1.empty() == true );

  CPPUNIT_ASSERT( v1.size() == 0 );

  // CPPUNIT_ASSERT( v1.max_size() == INT_MAX / sizeof(int) );

  // cout << "max_size = " << v1.max_size() << endl;

  v1.push_back(42); // Add an integer to the vector.

  CPPUNIT_ASSERT( v1.size() == 1 );

  CPPUNIT_ASSERT( v1[0] == 42 );

  {

    vector<vector<int> > vect(10);

    vector<vector<int> >::iterator it(vect.begin()), end(vect.end());

    for (; it != end; ++it) {

      CPPUNIT_ASSERT( (*it).empty() );

      CPPUNIT_ASSERT( (*it).size() == 0 );

      CPPUNIT_ASSERT( (*it).capacity() == 0 );

      CPPUNIT_ASSERT( (*it).begin() == (*it).end() );

    }

  }

}

void VectorTest::vec_test_2()

{

  vector<double> v1; // Empty vector of doubles.

  v1.push_back(32.1);

  v1.push_back(40.5);

  vector<double> v2; // Another empty vector of doubles.

  v2.push_back(3.56);

  CPPUNIT_ASSERT( v1.size() == 2 );

  CPPUNIT_ASSERT( v1[0] == 32.1 );

  CPPUNIT_ASSERT( v1[1] == 40.5 );

  CPPUNIT_ASSERT( v2.size() == 1 );

  CPPUNIT_ASSERT( v2[0] == 3.56 );

  v1.swap(v2); // Swap the vector's contents.

  CPPUNIT_ASSERT( v1.size() == 1 );

  CPPUNIT_ASSERT( v1[0] == 3.56 );

  CPPUNIT_ASSERT( v2.size() == 2 );

  CPPUNIT_ASSERT( v2[0] == 32.1 );

  CPPUNIT_ASSERT( v2[1] == 40.5 );

  v2 = v1; // Assign one vector to another.

  CPPUNIT_ASSERT( v2.size() == 1 );

  CPPUNIT_ASSERT( v2[0] == 3.56 );

}

void VectorTest::vec_test_3()

{

  typedef vector<char> vec_type;

  vec_type v1; // Empty vector of characters.

  v1.push_back('h');

  v1.push_back('i');

  CPPUNIT_ASSERT( v1.size() == 2 );

  CPPUNIT_ASSERT( v1[0] == 'h' );

  CPPUNIT_ASSERT( v1[1] == 'i' );

  vec_type v2(v1.begin(), v1.end());

  v2[1] = 'o'; // Replace second character.

  CPPUNIT_ASSERT( v2.size() == 2 );

  CPPUNIT_ASSERT( v2[0] == 'h' );

  CPPUNIT_ASSERT( v2[1] == 'o' );

  CPPUNIT_ASSERT( (v1 == v2) == false );

  CPPUNIT_ASSERT( (v1 < v2) == true );

}

void VectorTest::vec_test_4()

{

  vector<int> v(4);

  v[0] = 1;

  v[1] = 4;

  v[2] = 9;

  v[3] = 16;

  CPPUNIT_ASSERT( v.front() == 1 );

  CPPUNIT_ASSERT( v.back() == 16 );

  v.push_back(25);

  CPPUNIT_ASSERT( v.back() == 25 );

  CPPUNIT_ASSERT( v.size() == 5 );

  v.pop_back();

  CPPUNIT_ASSERT( v.back() == 16 );

  CPPUNIT_ASSERT( v.size() == 4 );

}

void VectorTest::vec_test_5()

{

  int array [] = { 1, 4, 9, 16 };

  vector<int> v(array, array + 4);

  CPPUNIT_ASSERT( v.size() == 4 );

  CPPUNIT_ASSERT( v[0] == 1 );

  CPPUNIT_ASSERT( v[1] == 4 );

  CPPUNIT_ASSERT( v[2] == 9 );

  CPPUNIT_ASSERT( v[3] == 16 );

}

void VectorTest::vec_test_6()

{

  int array [] = { 1, 4, 9, 16, 25, 36 };

  vector<int> v(array, array + 6);

  vector<int>::iterator vit;

  CPPUNIT_ASSERT( v.size() == 6 );

  CPPUNIT_ASSERT( v[0] == 1 );

  CPPUNIT_ASSERT( v[1] == 4 );

  CPPUNIT_ASSERT( v[2] == 9 );

  CPPUNIT_ASSERT( v[3] == 16 );

  CPPUNIT_ASSERT( v[4] == 25 );

  CPPUNIT_ASSERT( v[5] == 36 );

  vit = v.erase( v.begin() ); // Erase first element.

  CPPUNIT_ASSERT( *vit == 4 );

  CPPUNIT_ASSERT( v.size() == 5 );

  CPPUNIT_ASSERT( v[0] == 4 );

  CPPUNIT_ASSERT( v[1] == 9 );

  CPPUNIT_ASSERT( v[2] == 16 );

  CPPUNIT_ASSERT( v[3] == 25 );

  CPPUNIT_ASSERT( v[4] == 36 );

  vit = v.erase(v.end() - 1); // Erase last element.

  CPPUNIT_ASSERT( vit == v.end() );

  CPPUNIT_ASSERT( v.size() == 4 );

  CPPUNIT_ASSERT( v[0] == 4 );

  CPPUNIT_ASSERT( v[1] == 9 );

  CPPUNIT_ASSERT( v[2] == 16 );

  CPPUNIT_ASSERT( v[3] == 25 );

  v.erase(v.begin() + 1, v.end() - 1); // Erase all but first and last.

  CPPUNIT_ASSERT( v.size() == 2 );

  CPPUNIT_ASSERT( v[0] == 4 );

  CPPUNIT_ASSERT( v[1] == 25 );

}

void VectorTest::vec_test_7()

{

  int array1 [] = { 1, 4, 25 };

  int array2 [] = { 9, 16 };

  vector<int> v(array1, array1 + 3);

  vector<int>::iterator vit;

  vit = v.insert(v.begin(), 0); // Insert before first element.

  CPPUNIT_ASSERT( *vit == 0 );

  vit = v.insert(v.end(), 36);  // Insert after last element.

  CPPUNIT_ASSERT( *vit == 36 );

  CPPUNIT_ASSERT( v.size() == 5 );

  CPPUNIT_ASSERT( v[0] == 0 );

  CPPUNIT_ASSERT( v[1] == 1 );

  CPPUNIT_ASSERT( v[2] == 4 );

  CPPUNIT_ASSERT( v[3] == 25 );

  CPPUNIT_ASSERT( v[4] == 36 );

  // Insert contents of array2 before fourth element.

  v.insert(v.begin() + 3, array2, array2 + 2);

  CPPUNIT_ASSERT( v.size() == 7 );

  CPPUNIT_ASSERT( v[0] == 0 );

  CPPUNIT_ASSERT( v[1] == 1 );

  CPPUNIT_ASSERT( v[2] == 4 );

  CPPUNIT_ASSERT( v[3] == 9 );

  CPPUNIT_ASSERT( v[4] == 16 );

  CPPUNIT_ASSERT( v[5] == 25 );

  CPPUNIT_ASSERT( v[6] == 36 );

  v.clear();

  CPPUNIT_ASSERT( v.empty() );

  v.insert(v.begin(), 5, 10);

  CPPUNIT_ASSERT( v.size() == 5 );

  CPPUNIT_ASSERT( v[0] == 10 );

  CPPUNIT_ASSERT( v[1] == 10 );

  CPPUNIT_ASSERT( v[2] == 10 );

  CPPUNIT_ASSERT( v[3] == 10 );

  CPPUNIT_ASSERT( v[4] == 10 );

  /*

  {

    vector<float> vf(2.0f, 3.0f);

    CPPUNIT_ASSERT( vf.size() == 2 );

    CPPUNIT_ASSERT( vf.front() == 3.0f );

    CPPUNIT_ASSERT( vf.back() == 3.0f );

  }

  */

}

struct TestStruct

{

  unsigned int a[3];

};

void VectorTest::capacity()

{

  {

    vector<int> v;

    CPPUNIT_ASSERT( v.capacity() == 0 );

    v.push_back(42);

    CPPUNIT_ASSERT( v.capacity() >= 1 );

    v.reserve(5000);

    CPPUNIT_ASSERT( v.capacity() >= 5000 );

  }

  {

    //Test that used to generate an assertion when using __debug_alloc.

    vector<TestStruct> va;

    va.reserve(1);

    va.reserve(2);

  }

}

void VectorTest::at() {

  vector<int> v;

  vector<int> const& cv = v;

  v.push_back(10);

  CPPUNIT_ASSERT( v.at(0) == 10 );

  v.at(0) = 20;

  CPPUNIT_ASSERT( cv.at(0) == 20 );

#if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)

  for (;;) {

    try {

      v.at(1) = 20;

      CPPUNIT_ASSERT(false);

    }

    catch (out_of_range const&) {

      return;

    }

    catch (...) {

      CPPUNIT_ASSERT(false);

    }

  }

#endif

}

void VectorTest::pointer()

{

  vector<int *> v1;

  vector<int *> v2 = v1;

  vector<int *> v3;

  v3.insert( v3.end(), v1.begin(), v1.end() );

}

void VectorTest::auto_ref()

{

  vector<int> ref;

  for (int i = 0; i < 5; ++i) {

    ref.push_back(i);

  }

  vector<vector<int> > v_v_int(1, ref);

  v_v_int.push_back(v_v_int[0]);

  v_v_int.push_back(ref);

  v_v_int.push_back(v_v_int[0]);

  v_v_int.push_back(v_v_int[0]);

  v_v_int.push_back(ref);

  vector<vector<int> >::iterator vvit(v_v_int.begin()), vvitEnd(v_v_int.end());

  for (; vvit != vvitEnd; ++vvit) {

    CPPUNIT_ASSERT( *vvit == ref );

  }

  /*

   * Forbidden by the Standard:

  v_v_int.insert(v_v_int.end(), v_v_int.begin(), v_v_int.end());

  for (vvit = v_v_int.begin(), vvitEnd = v_v_int.end();

       vvit != vvitEnd; ++vvit) {

    CPPUNIT_ASSERT( *vvit == ref );

  }

   */

}

void VectorTest::allocator_with_state()

{

  char buf1[1024];

  StackAllocator<int> stack1(buf1, buf1 + sizeof(buf1));

  char buf2[1024];

  StackAllocator<int> stack2(buf2, buf2 + sizeof(buf2));

  {

    typedef vector<int, StackAllocator<int> > VectorInt;

    VectorInt vint1(10, 0, stack1);

    VectorInt vint1Cpy(vint1);

    VectorInt vint2(10, 1, stack2);

    VectorInt vint2Cpy(vint2);

    vint1.swap(vint2);

    CPPUNIT_ASSERT( vint1.get_allocator().swaped() );

    CPPUNIT_ASSERT( vint2.get_allocator().swaped() );

    CPPUNIT_ASSERT( vint1 == vint2Cpy );

    CPPUNIT_ASSERT( vint2 == vint1Cpy );

    CPPUNIT_ASSERT( vint1.get_allocator() == stack2 );

    CPPUNIT_ASSERT( vint2.get_allocator() == stack1 );

  }

  CPPUNIT_ASSERT( stack1.ok() );

  CPPUNIT_ASSERT( stack2.ok() );

}

struct Point {

  int x, y;

};

struct PointEx : public Point {

  PointEx() : builtFromBase(false) {}

  PointEx(const Point&) : builtFromBase(true) {}

  bool builtFromBase;

};

#if defined (STLPORT)

namespace std {

  template <>

  struct __type_traits<PointEx> {

    typedef __false_type has_trivial_default_constructor;

    typedef __true_type has_trivial_copy_constructor;

    typedef __true_type has_trivial_assignment_operator;

    typedef __true_type has_trivial_destructor;

    typedef __true_type is_POD_type;

  };

}

#endif

//This test check that vector implementation do not over optimize

//operation as PointEx copy constructor is trivial

void VectorTest::optimizations_check()

{

#if !defined (STLPORT) || !defined (_STLP_NO_MEMBER_TEMPLATES)

  vector<Point> v1(1);

  CPPUNIT_ASSERT( v1.size() == 1 );

  vector<PointEx> v2(v1.begin(), v1.end());

  CPPUNIT_ASSERT( v2.size() == 1 );

  CPPUNIT_ASSERT( v2[0].builtFromBase == true );

#endif

}

void VectorTest::iterators()

{

  vector<int> vint(10, 0);

  vector<int> const& crvint = vint;

  CPPUNIT_ASSERT( vint.begin() == vint.begin() );

  CPPUNIT_ASSERT( crvint.begin() == vint.begin() );

  CPPUNIT_ASSERT( vint.begin() == crvint.begin() );

  CPPUNIT_ASSERT( crvint.begin() == crvint.begin() );

  CPPUNIT_ASSERT( vint.begin() != vint.end() );

  CPPUNIT_ASSERT( crvint.begin() != vint.end() );

  CPPUNIT_ASSERT( vint.begin() != crvint.end() );

  CPPUNIT_ASSERT( crvint.begin() != crvint.end() );

  CPPUNIT_ASSERT( vint.rbegin() == vint.rbegin() );

  // Not Standard:

  //CPPUNIT_ASSERT( vint.rbegin() == crvint.rbegin() );

  //CPPUNIT_ASSERT( crvint.rbegin() == vint.rbegin() );

  CPPUNIT_ASSERT( crvint.rbegin() == crvint.rbegin() );

  CPPUNIT_ASSERT( vint.rbegin() != vint.rend() );

  // Not Standard:

  //CPPUNIT_ASSERT( vint.rbegin() != crvint.rend() );

  //CPPUNIT_ASSERT( crvint.rbegin() != vint.rend() );

  CPPUNIT_ASSERT( crvint.rbegin() != crvint.rend() );

}

#if defined (STLPORT)

#  define NOTHROW _STLP_NOTHROW

#else

#  define NOTHROW throw()

#endif

/* This allocator implementation purpose is simply to break some

 * internal STLport mecanism specific to the STLport own allocator

 * implementation. */

template <class _Tp>

struct NotSTLportAllocator : public allocator<_Tp> {

#if !defined (STLPORT) || defined (_STLP_MEMBER_TEMPLATE_CLASSES)

  template <class _Tp1> struct rebind {

    typedef NotSTLportAllocator<_Tp1> other;

  };

#endif

  NotSTLportAllocator() _STLP_NOTHROW {}

#if !defined (STLPORT) || defined (_STLP_MEMBER_TEMPLATES)

  template <class _Tp1> NotSTLportAllocator(const NotSTLportAllocator<_Tp1>&) NOTHROW {}

#endif

  NotSTLportAllocator(const NotSTLportAllocator<_Tp>&) NOTHROW {}

  ~NotSTLportAllocator() NOTHROW {}

};

/* This test check a potential issue with empty base class

 * optimization. Some compilers (VC6) do not implement it

 * correctly resulting ina wrong behavior. */

void VectorTest::ebo()

{

  // We use heap memory as test failure can corrupt vector internal

  // representation making executable crash on vector destructor invocation.

  // We prefer a simple memory leak, internal corruption should be reveal

  // by size or capacity checks.

  typedef vector<int, NotSTLportAllocator<int> > V;

  V *pv1 = new V(1, 1);

  V *pv2 = new V(10, 2);

  size_t v1Capacity = pv1->capacity();

  size_t v2Capacity = pv2->capacity();

  pv1->swap(*pv2);

  CPPUNIT_ASSERT( pv1->size() == 10 );

  CPPUNIT_ASSERT( pv1->capacity() == v2Capacity );

  CPPUNIT_ASSERT( (*pv1)[5] == 2 );

  CPPUNIT_ASSERT( pv2->size() == 1 );

  CPPUNIT_ASSERT( pv2->capacity() == v1Capacity );

  CPPUNIT_ASSERT( (*pv2)[0] == 1 );

  delete pv2;

  delete pv1;

}

void VectorTest::vec_cov1()

	{

	  __UHEAP_MARK;

		{

		vector<int> v;

		vector<int> const& cv = v;

		v.push_back(10);

		v.push_back(20);

		v.push_back(30);

		v.push_back(40);

		v.push_back(50);

		CPPUNIT_ASSERT( cv.front() == 10 );

		CPPUNIT_ASSERT( cv.back() == 50 );

		}

		{

		int i;

		vector<int> vec;

		for (i = 1 ; i < 6 ; ++i )

		   {

		   vec.push_back ( 3 * i );

		   }

		vector <int>::reverse_iterator rVPOS1 = vec.rend ( ) - 1;

		rVPOS1-=2;

		CPPUNIT_ASSERT( *rVPOS1 == 9 );

		vector <int>::reverse_iterator rVPOS2 =rVPOS1 + 2;

		CPPUNIT_ASSERT( *rVPOS2 == 3 );

		}

		{

		int i;

		vector<int> vec;

		for (i = 1 ; i < 6 ; ++i ) 

		   {

		   vec.push_back ( 2 * i );

		   }

		vector <int>::reverse_iterator rVPOS1 = vec.rbegin ( );

		rVPOS1+=2;

		CPPUNIT_ASSERT( *rVPOS1 == 6 );

		}

		  __UHEAP_MARKEND;

	}

void VectorTest::vec_cov2()

	{

	  __UHEAP_MARK;

		{

		int i;

		vector<int> vec;

		for (i = 1 ; i < 6 ; ++i )  

		   {

		   vec.push_back ( 2 * i - 1 );

		   }

		vector <int>::reverse_iterator rVPOS1 = vec.rend ( ) - 1;

		rVPOS1--;  

		CPPUNIT_ASSERT( *rVPOS1 == 3 );

		}

		{

		int i;

		vector<int> vec;

		for (i = 1 ; i < 6 ; ++i )

		   {

		   vec.push_back ( 2 * i );

		   }

		vector <int>::iterator pos;

		pos = find ( vec.begin ( ), vec.end ( ), 8 );

		reverse_iterator<vector<int>::iterator> rpos ( pos );

		reverse_iterator<vector<int>::iterator>::difference_type diff = 2;

		reverse_iterator<vector<int>::iterator>::reference refrpos = rpos [diff];

		CPPUNIT_ASSERT( refrpos == 2 );

		}

		{

		int i;

		vector<int> vec;

		for ( i = 1 ; i < 6 ; ++i )

		   {

		   vec.push_back ( i );

		   }

		vector <int>::iterator pos;

		pos = find ( vec.begin ( ), vec.end ( ), 4 );

		vector <int>::reverse_iterator rpos ( pos );

		CPPUNIT_ASSERT( *rpos == 3 );

		}

		  __UHEAP_MARKEND;

	}

void VectorTest::vec_cov3()

	{

	  __UHEAP_MARK;

		{

		int i;

		vector<int> vec;

		for (i = 1 ; i < 3 ; ++i )  

		   {

		   vec.push_back ( 10 * i );

		   }

		back_insert_iterator<vector<int> > backiter ( vec );

		*backiter = 30;

		backiter++;

		*backiter = 40;

		backiter++;

		vector <int>::iterator vIter;

		vIter = vec.begin ( ) ;

		CPPUNIT_ASSERT( *vIter == 10 );

		vIter++;

		CPPUNIT_ASSERT( *vIter == 20 );

		vIter++;

		CPPUNIT_ASSERT( *vIter == 30 );

		vIter++;

		CPPUNIT_ASSERT( *vIter == 40 );

		}

		{

		vector<int> vec;

        vec.push_back (10);

        insert_iterator<vector<int> > ii ( vec, vec.begin ( ) );

        *ii = 30;

        vector <int>::iterator vIter;

        vIter = vec.begin ( ) ;	

		CPPUNIT_ASSERT( *vIter == 30 );

		}

		{

		int i;

		vector<int> vec;

		for (i = 1 ; i < 6 ; ++i )

		   {

		   vec.push_back ( 3 * i );

		   }	

		vector <int>::reverse_iterator rVPOS1 = vec.rend ( ) - 1;

		vector <int>::reverse_iterator rVPOS2 = vec.rbegin ( );

		CPPUNIT_ASSERT(*rVPOS2 > *rVPOS1);

		}

		  __UHEAP_MARKEND;

	}

void VectorTest::vec_cov4() 

	{

	  __UHEAP_MARK;

	vector<int> v;

	size_t x;

	v.push_back(10);

	v.push_back(20);

	v.push_back(30);

	v.push_back(40);

	v.push_back(50);

	x=v.max_size();

	#if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)

	for (;;) {

	try {

    	v.reserve(x+1);

    	CPPUNIT_ASSERT(false);

		}

	catch (length_error const&) {

    	return;

		}

	catch (...) {

    	CPPUNIT_ASSERT(false);

		}

	}

#endif

	  __UHEAP_MARKEND;

}