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

  test_construct.h

 * 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.

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

#ifndef test_construct_H_

#define test_construct_H_

#include "Prefix.h"

#if defined (EH_NEW_HEADERS)

#  include <algorithm>

#  include <cassert>

#  include <cstdlib>

#else

#  include <algo.h>

#  include <assert.h>

#  include <stdlib.h>

#endif

USING_CSTD_NAME(size_t)

template <class T>

struct test_copy_construct {

  test_copy_construct() {

    gTestController.SetCurrentTestName("copy constructor");

  }

  void operator()( const T& t ) const {

    T aCopy( t );

    // Prevent simulated failures during verification

    gTestController.CancelFailureCountdown();

    //EH_ASSERT( aCopy == t );

    CheckInvariant(t);

  }

};

template <class T>

struct test_default_construct {

  test_default_construct() {

    gTestController.SetCurrentTestName("default constructor");

  }

  void operator()( int ) const {

    T t;

    CheckInvariant(t);

  }

};

template <class T>

struct test_construct_n {

  test_construct_n( size_t _n ) : n(_n+1) {

    gTestController.SetCurrentTestName("n-size constructor");

  }

  void operator()( int ) const {

    T t(n);

    CheckInvariant(t);

  }

  size_t n;

};

template <class T>

struct test_construct_n_instance {

  test_construct_n_instance( size_t _n ) : n(_n+1) {

    gTestController.SetCurrentTestName("n-size with instance constructor");

  }

  void operator()( int ) const {

    typedef typename T::value_type Value_type;

    Value_type Val = 0;

    T t( n, Val );

    CheckInvariant(t);

  }

  size_t n;

};

template <class T>

struct test_construct_pointer_range {

  test_construct_pointer_range( const typename T::value_type *first,

                                const typename T::value_type* last )

    : fItems( first ), fEnd( last ) {

    gTestController.SetCurrentTestName("pointer range constructor");

  }

  void operator()( int ) const {

    T t( fItems, fEnd );

    // Prevent simulated failures during verification

    gTestController.CancelFailureCountdown();

    CheckInvariant(t);

  }

  const typename T::value_type* fItems, *fEnd;

};

template <class T>

struct test_construct_iter_range {

  test_construct_iter_range( const T& src ) : fItems( src ) {

    gTestController.SetCurrentTestName("iterator range constructor");

  }

  void operator()( int ) const {

    T t( fItems.begin(), fItems.end() );

    // Prevent simulated failures during verification

    gTestController.CancelFailureCountdown();

    EH_ASSERT( t == fItems );

    CheckInvariant(t);

  }

  const T& fItems;

};

#endif // test_construct_H_