/***********************************************************************************

  test_bit_vector.cpp

 * Copyright (c) 1997

 * Mark of the Unicorn, Inc.

 *

 * Permission to use, copy, modify, distribute and sell this software

 * and its documentation for any purpose is hereby granted without fee,

 * provided that the above copyright notice appear in all copies and

 * that both that copyright notice and this permission notice appear

 * in supporting documentation.  Mark of the Unicorn makes no

 * representations about the suitability of this software for any

 * purpose.  It is provided "as is" without express or implied warranty.

***********************************************************************************/

#include "Tests.h"

#if defined( EH_BIT_VECTOR_IMPLEMENTED )

# if defined (EH_NEW_HEADERS)

# ifdef __SUNPRO_CC

# include <stdio.h>

# endif

#include <vector>

# else

#include <bvector.h>

# endif

#include "LeakCheck.h"

#include "test_construct.h"

#include "test_assign_op.h"

#include "test_push_back.h"

#include "test_insert.h"

#include "test_push_front.h"

typedef EH_BIT_VECTOR BitVector;

inline sequence_container_tag

container_category(const BitVector&)

{

  return sequence_container_tag();

}

USING_CSTD_NAME(size_t)

  //

// test_BitVector_reserve

//

struct test_BitVector_reserve

{

    test_BitVector_reserve( size_t n ) : fAmount(n)

    {

        gTestController.SetCurrentTestName("BitVector::reserve()");

    }

    void operator()( BitVector& v ) const

    {

        v.reserve( fAmount );

    }

private:

    size_t fAmount;

};

/*===================================================================================

  test_bit_vector

  EFFECTS:  Performs tests on bit vectors

====================================================================================*/

void test_bit_vector()

{

#define __WORD_BIT_LOCAL (int(CHAR_BIT*sizeof(unsigned int)))

  // Make some bit vectors to work with.

  BitVector emptyVector;

  BitVector testVector, testVector2;

  EH_ASSERT( testVector.size() == 0 );

  size_t BitVectorSize = random_number( random_base );

  // Half the time, choose a size that will guarantee immediate reallocation

  if ( random_number(2) )

    BitVectorSize = BitVectorSize / __WORD_BIT_LOCAL * __WORD_BIT_LOCAL;

  EH_ASSERT( testVector.size() == 0 );

  testVector.reserve(BitVectorSize);

  EH_ASSERT( testVector.size() == 0 );

  while (testVector.size() < BitVectorSize) {

    testVector.push_back(random_number(2) != 0);

    testVector2.push_back(random_number(2) != 0);

  }

  // Test insertions

  StrongCheck(testVector, test_insert_one<BitVector>(testVector) );

  StrongCheck(testVector, test_insert_one<BitVector>(testVector,0) );

  StrongCheck(testVector, test_insert_one<BitVector>(testVector, (int)testVector.size()) );

  StrongCheck(testVector, test_insert_n<BitVector>(testVector, random_number(random_base) ) );

  StrongCheck(testVector, test_insert_n<BitVector>(testVector, random_number(random_base),0 ) );

  StrongCheck(testVector, test_insert_n<BitVector>(testVector, random_number(random_base), (int)testVector.size()) );

#if 0

  // Allocate some random bools to insert

  size_t insCnt = 1 + random_number(random_base);

  bool *insFirst = new BitVector::value_type[insCnt];

  for (size_t n = 0; n < insCnt; n++)

    insFirst[n] = random_number(2);

  StrongCheck(testVector, insert_range_tester(testVector, insFirst, insFirst+insCnt));

  StrongCheck(testVector, insert_range_at_begin_tester(testVector, insFirst, insFirst+insCnt));

  StrongCheck(testVector, insert_range_at_end_tester(testVector, insFirst, insFirst+insCnt));

  ConstCheck(0, test_construct_pointer_range<BitVector>( insFirst, insFirst + insCnt));

  delete[] insFirst;

#endif

  StrongCheck(testVector, insert_range_tester(testVector, testVector2.begin(), testVector2.end()));

  StrongCheck(testVector, insert_range_at_begin_tester(testVector, testVector2.begin(),

                                                                   testVector2.end()));

  StrongCheck(testVector, insert_range_at_end_tester(testVector, testVector2.begin(),

                                                                 testVector2.end()));

  StrongCheck(testVector, test_BitVector_reserve( testVector.capacity() + random_number(50)));

  StrongCheck(testVector, test_push_back<BitVector>(testVector));

  StrongCheck(emptyVector, test_push_back<BitVector>(emptyVector));

  ConstCheck(0, test_default_construct<BitVector>());

  ConstCheck(0, test_construct_n<BitVector>(random_number(random_base)));

  ConstCheck(0, test_construct_n_instance<BitVector>(random_number(random_base)));

  ConstCheck(0, test_construct_iter_range<BitVector>(testVector2));

  ConstCheck(testVector, test_copy_construct<BitVector>() );

  WeakCheck(testVector, test_assign_op<BitVector>(testVector2) );

}

# endif /* BIT_VECTOR_IMPLEMENTED */