1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
|
/***********************************************************************************
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_
|