#include <memory>

#include <vector>

#include <list>

#include "cppunit/cppunit_proxy.h"

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

using namespace std;

#endif

//

// TestCase class

//

class UninitializedTest : public CPPUNIT_NS::TestCase

{

  CPPUNIT_TEST_SUITE(UninitializedTest);

  CPPUNIT_TEST(copy_test);

  //CPPUNIT_TEST(fill_test);

  //CPPUNIT_TEST(fill_n_test);

  CPPUNIT_TEST_SUITE_END();

protected:

  void copy_test();

  void fill_test();

  void fill_n_test();

};

CPPUNIT_TEST_SUITE_REGISTRATION(UninitializedTest);

struct NotTrivialCopyStruct {

  NotTrivialCopyStruct() : member(0) {}

  NotTrivialCopyStruct(NotTrivialCopyStruct const&) : member(1) {}

  int member;

};

struct TrivialCopyStruct {

  TrivialCopyStruct() : member(0) {}

  TrivialCopyStruct(TrivialCopyStruct const&) : member(1) {}

  int member;

};

struct TrivialInitStruct {

  TrivialInitStruct()

  { ++nbConstructorCalls; }

  static size_t nbConstructorCalls;

};

size_t TrivialInitStruct::nbConstructorCalls = 0;

#if defined (STLPORT)

namespace std

{

  _STLP_TEMPLATE_NULL

  struct __type_traits<TrivialCopyStruct> {

     typedef __false_type has_trivial_default_constructor;

     //This is a wrong declaration just to check that internaly a simple memcpy is called:

     typedef __true_type has_trivial_copy_constructor;

     typedef __true_type has_trivial_assignment_operator;

     typedef __true_type has_trivial_destructor;

     typedef __false_type is_POD_type;

  };

  _STLP_TEMPLATE_NULL

  struct __type_traits<TrivialInitStruct> {

     //This is a wrong declaration just to check that internaly no initialization is done:

     typedef __true_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 __false_type is_POD_type;

  };

}

#endif

struct base {};

struct derived : public base {};

//

// tests implementation

//

void UninitializedTest::copy_test()

{

  {

    //Random iterators

    {

      vector<NotTrivialCopyStruct> src(10);

      vector<NotTrivialCopyStruct> dst(10);

      uninitialized_copy(src.begin(), src.end(), dst.begin());

      vector<NotTrivialCopyStruct>::const_iterator it(dst.begin()), end(dst.end());

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

        CPPUNIT_ASSERT( (*it).member == 1 );

      }

    }

    {

      /** Note: we use static arrays here so the iterators are always

      pointers, even in debug mode. */

      size_t const count = 10;

      TrivialCopyStruct src[count];

      TrivialCopyStruct dst[count];

      TrivialCopyStruct* it = src + 0;

      TrivialCopyStruct* end = src + count;

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

        (*it).member = 0;

      }

      uninitialized_copy(src+0, src+count, dst+0);

      for (it = dst+0, end = dst+count; it != end; ++it) {

#if defined (STLPORT)

        /* If the member is 1, it means that library has not found any

        optimization oportunity and called the regular copy-ctor instead. */

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

#else

        CPPUNIT_ASSERT( (*it).member == 1 );

#endif

      }

    }

  }

  {

    //Bidirectional iterator

    {

      vector<NotTrivialCopyStruct> src(10);

      list<NotTrivialCopyStruct> dst(10);

      list<NotTrivialCopyStruct>::iterator it(dst.begin()), end(dst.end());

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

        (*it).member = -1;

      }

      uninitialized_copy(src.begin(), src.end(), dst.begin());

      for (it = dst.begin(); it != end; ++it) {

        CPPUNIT_ASSERT( (*it).member == 1 );

      }

    }

    {

      list<NotTrivialCopyStruct> src(10);

      vector<NotTrivialCopyStruct> dst(10);

      vector<NotTrivialCopyStruct>::iterator it(dst.begin()), end(dst.end());

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

        (*it).member = -1;

      }

      uninitialized_copy(src.begin(), src.end(), dst.begin());

      for (it = dst.begin(); it != end; ++it) {

        CPPUNIT_ASSERT( (*it).member == 1 );

      }

    }

  }

  {

    //Using containers of native types:

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

    {

      vector<int> src;

      int i;

      for (i = -5; i < 6; ++i) {

        src.push_back(i);

      }

      //Building a vector result in a uninitialized_copy call internally

      vector<unsigned int> dst(src.begin(), src.end());

      vector<unsigned int>::const_iterator it(dst.begin());

      for (i = -5; i < 6; ++i, ++it) {

        CPPUNIT_ASSERT( *it == (unsigned int)i );

      }

    }

    {

      vector<char> src;

      char i;

      for (i = -5; i < 6; ++i) {

        src.push_back(i);

      }

      //Building a vector result in a uninitialized_copy call internally

      vector<unsigned int> dst(src.begin(), src.end());

      vector<unsigned int>::const_iterator it(dst.begin());

      for (i = -5; i < 6; ++i, ++it) {

        CPPUNIT_ASSERT( *it == (unsigned int)i );

      }

    }

    {

      vector<int> src;

      int i;

      for (i = -5; i < 6; ++i) {

        src.push_back(i);

      }

      //Building a vector result in a uninitialized_copy call internally

      vector<float> dst(src.begin(), src.end());

      vector<float>::const_iterator it(dst.begin());

      for (i = -5; i < 6; ++i, ++it) {

        CPPUNIT_ASSERT( *it == (float)i );

      }

    }

    {

      vector<vector<float>*> src(10);

      vector<vector<float>*> dst(src.begin(), src.end());

    }

    {

      derived d;

      //base *pb = &d;

      derived *pd = &d;

      //base **ppb = &pd;

      vector<derived*> src(10, pd);

      vector<base*> dst(src.begin(), src.end());

      vector<base*>::iterator it(dst.begin()), end(dst.end());

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

        CPPUNIT_ASSERT( (*it) == pd );

      }

    }

#endif

  }

  {

    //Vector initialization:

    vector<TrivialInitStruct> vect(10);

    //Just 1 constructor call for the default value:

    CPPUNIT_ASSERT( TrivialInitStruct::nbConstructorCalls == 1  );

  }

}

/*

void UninitializedTest::fill_test()

{

}

void UninitializedTest::fill_n_test()

{

}

*/