#include <memory>

#include <vector>

#include <cstdio>

#include "cppunit/cppunit_proxy.h"

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

using namespace std;

#endif

//

// TestCase class

//

class AllocatorTest : public CPPUNIT_NS::TestCase

{

  CPPUNIT_TEST_SUITE(AllocatorTest);

  CPPUNIT_TEST(zero_allocation);

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

  CPPUNIT_TEST(bad_alloc_test);

#endif

#if defined (STLPORT) && defined (_STLP_THREADS) && defined (_STLP_USE_PERTHREAD_ALLOC)

  CPPUNIT_TEST(per_thread_alloc);

#endif

  CPPUNIT_TEST_SUITE_END();

protected:

  void zero_allocation();

  void bad_alloc_test();

  void per_thread_alloc();

};

CPPUNIT_TEST_SUITE_REGISTRATION(AllocatorTest);

//

// tests implementation

//

void AllocatorTest::zero_allocation()

{

  typedef allocator<char> CharAllocator;

  CharAllocator charAllocator;

  char* buf = charAllocator.allocate(0);

  charAllocator.deallocate(buf, 0);

  charAllocator.deallocate(0, 0);

}

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

struct BigStruct

{

  char _data[4096];

};

void AllocatorTest::bad_alloc_test()

{

  typedef allocator<BigStruct> BigStructAllocType;

  BigStructAllocType bigStructAlloc;

  try {

    //Lets try to allocate almost 4096 Go (on most of the platforms) of memory:

    BigStructAllocType::pointer pbigStruct = bigStructAlloc.allocate(1024 * 1024 * 1024);

    //Allocation failed but no exception thrown

    CPPUNIT_ASSERT( pbigStruct != 0 );

  }

  catch (bad_alloc const&) {

  }

  catch (...) {

    //We shouldn't be there:

    //Not bad_alloc exception thrown.

    CPPUNIT_ASSERT( false );

  }

}

#endif

#if defined (STLPORT) && defined (_STLP_THREADS) && defined (_STLP_USE_PERTHREAD_ALLOC)

#  include <pthread.h>

class SharedDatas

{

public:

  typedef vector<int, per_thread_allocator<int> > thread_vector;

  SharedDatas(size_t nbElems) : threadVectors(nbElems, (thread_vector*)0) {

    pthread_mutex_init(&mutex, 0);

    pthread_cond_init(&condition, 0);

  }

  ~SharedDatas() {

    for (size_t i = 0; i < threadVectors.size(); ++i) {

      delete threadVectors[i];

    }

  }

  size_t initThreadVector() {

    size_t ret;

    pthread_mutex_lock(&mutex);

    for (size_t i = 0; i < threadVectors.size(); ++i) {

      if (threadVectors[i] == 0) {

        threadVectors[i] = new thread_vector();

        ret = i;

        break;

      }

    }

    if (ret != threadVectors.size() - 1) {

      //We wait for other thread(s) to call this method too:

      printf("Thread %d wait\n", ret);

      pthread_cond_wait(&condition, &mutex);

    }

    else {

      //We are the last thread calling this method, we signal this

      //to the other thread(s) that might be waiting:

      printf("Thread %d signal\n", ret);

      pthread_cond_signal(&condition);

    }

    pthread_mutex_unlock(&mutex);

    return ret;

  }

  thread_vector& getThreadVector(size_t index) {

    //We return other thread thread_vector instance:

    return *threadVectors[(index + 1 == threadVectors.size()) ? 0 : index + 1];

  }

private:

  pthread_mutex_t mutex;

  pthread_cond_t condition;

  vector<thread_vector*> threadVectors;

};

void* f(void* pdatas) {

  SharedDatas *psharedDatas = (SharedDatas*)pdatas;

  int threadIndex = psharedDatas->initThreadVector();

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

    psharedDatas->getThreadVector(threadIndex).push_back(i);

  }

  return 0;

}

void AllocatorTest::per_thread_alloc()

{

  const size_t nth = 2;

  SharedDatas datas(nth);

  pthread_t t[nth];

  size_t i;

  for (i = 0; i < nth; ++i) {

    pthread_create(&t[i], 0, f, &datas);

  }

  for (i = 0; i < nth; ++i ) {

    pthread_join(t[i], 0);

  }

}

#endif