#include <vector>

#include <list>

#include <algorithm>

#include <numeric>

#include "iota.h"

#include "cppunit/cppunit_proxy.h"

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

using namespace std;

#endif

//

// TestCase class

//

class IterTest : public CPPUNIT_NS::TestCase

{

  CPPUNIT_TEST_SUITE(IterTest);

  CPPUNIT_TEST(iter1);

  CPPUNIT_TEST(iter3);

  CPPUNIT_TEST(iter4);

  CPPUNIT_TEST(iterswp0);

  CPPUNIT_TEST(iterswp1);

  CPPUNIT_TEST(iterswp2);

  CPPUNIT_TEST(iterswp3);

  CPPUNIT_TEST_SUITE_END();

protected:

  void iter1();

  void iter3();

  void iter4();

  void iterswp0();

  void iterswp1();

  void iterswp2();

  void iterswp3();

};

CPPUNIT_TEST_SUITE_REGISTRATION(IterTest);

//

// tests implementation

//

void IterTest::iter1()

{

  vector<const char*> v; // Vector of character strings.

  v.push_back("zippy"); // First element.

  v.push_back("motorboy"); // Second element.

  typedef vector<const char*> vec;

  unsigned counter = 0;

  for (vec::iterator i = v.begin(); i != v.end(); ++i, ++counter) {

    switch (counter) {

      case 0:

        CPPUNIT_ASSERT(!strcmp(*i, "zippy"));

        break;

      case 1:

        CPPUNIT_ASSERT(!strcmp(*i, "motorboy"));

        break;

      default:

        CPPUNIT_ASSERT(false);

    }

  }

}

void IterTest::iter3()

{

  typedef vector<const char*> Vec;

  Vec v; // Vector of character strings.

  v.push_back("zippy"); // First element.

  v.push_back("motorboy"); // Second element.

  Vec::reverse_iterator it;

  unsigned counter = 0;

  for (it = v.rbegin(); it != v.rend(); ++it, ++counter) {

    switch (counter) {

      case 1:

        CPPUNIT_ASSERT(!strcmp(*it, "zippy"));

        break;

      case 0:

        CPPUNIT_ASSERT(!strcmp(*it, "motorboy"));

        break;

      default:

        CPPUNIT_ASSERT(false);

    }

  }

  CPPUNIT_ASSERT(true);

}

void IterTest::iter4()

{

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

  v.push_back(1);

  v.push_back(2);

  v.push_back(3);

  // Position immediately after last item.

  vector<int>::iterator i = v.end();

  // Move back one and then access.

  CPPUNIT_ASSERT((*--i)==3);

  i -= 2; // Jump back two items.

  CPPUNIT_ASSERT((*i)==1);

}

void IterTest::iterswp0()

{

  int numbers[6] = { 0, 1, 2, 3, 4, 5 };

  iter_swap(numbers, numbers + 3);

  CPPUNIT_ASSERT(numbers[0]==3);

  CPPUNIT_ASSERT(numbers[1]==1);

  CPPUNIT_ASSERT(numbers[2]==2);

  CPPUNIT_ASSERT(numbers[3]==0);

  CPPUNIT_ASSERT(numbers[4]==4);

  CPPUNIT_ASSERT(numbers[5]==5);

}

void IterTest::iterswp1()

{

  vector<int> v1(6);

  __iota(v1.begin(), v1.end(), 0);

  iter_swap( v1.begin(), v1.begin() + 3 );

  CPPUNIT_ASSERT(v1[0]==3);

  CPPUNIT_ASSERT(v1[1]==1);

  CPPUNIT_ASSERT(v1[2]==2);

  CPPUNIT_ASSERT(v1[3]==0);

  CPPUNIT_ASSERT(v1[4]==4);

  CPPUNIT_ASSERT(v1[5]==5);

}

void IterTest::iterswp2()

{

  vector<bool> boolVector;

  boolVector.push_back( true );

  boolVector.push_back( false );

  vector<bool>::iterator i1 = boolVector.begin();

  vector<bool>::iterator i2 = boolVector.begin();

  ++i2;

  bool v0 = *i1;

  bool v1 = *i2;

  iter_swap( i1, i2 );

  CPPUNIT_ASSERT(( *i1 == v1 && *i2 == v0 ));

}

void IterTest::iterswp3()

{

  vector<int> vvref(10, 10);

  vector<int> lvref(10, 20);

  vector<vector<int> > vvints(4, vvref);

  list<vector<int> > lvints(4, lvref);

  iter_swap(vvints.begin(), lvints.begin());

  CPPUNIT_CHECK( vvints.front() == lvref );

  CPPUNIT_CHECK( lvints.front() == vvref );

#if defined (STLPORT) && defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)

  int *pvvint = &vvints.front().front();

  int *plvint = &lvints.front().front();

  iter_swap(vvints.begin(), lvints.begin());

  //Check that elements have been swaped:

  CPPUNIT_CHECK( pvvint == &lvints.front().front() );

  CPPUNIT_CHECK( plvint == &vvints.front().front() );

#endif

}