1 /***********************************************************************************

     2   TestClass.h

     3 

     4  * Copyright (c) 1997-1998

     5  * Mark of the Unicorn, Inc.

     6  *

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

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

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

    10  * that both that copyright notice and this permission notice appear

    11  * in supporting documentation.  Mark of the Unicorn makes no

    12  * representations about the suitability of this software for any

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

    14 

    15     SUMMARY: TestClass simulates a class that uses resources. It is designed to

    16       cause exceptions when it is constructed or copied.

    17 

    18 ***********************************************************************************/

    19 #ifndef INCLUDED_MOTU_TestClass

    20 #define INCLUDED_MOTU_TestClass 1

    21 

    22 # include "Prefix.h"

    23 

    24 #  include <functional>

    25 #  include <utility>

    26 #  include <climits>

    27 

    28 #include <iosfwd>

    29 #include "random_number.h"

    30 #include "nc_alloc.h"

    31 

    32 class TestClass

    33 {

    34 public:

    35     inline TestClass();

    36     inline TestClass( int value );

    37     inline TestClass( const TestClass& rhs );

    38     inline ~TestClass();

    39 

    40     inline TestClass& operator=( const TestClass& rhs );

    41     inline int value() const;

    42 

    43     inline TestClass operator!() const;

    44 

    45     bool operator==( const TestClass& rhs ) const

    46     {

    47       return value() == rhs.value();

    48     }

    49 

    50     bool operator<( const TestClass& rhs ) const {

    51       return value() < rhs.value();

    52     }

    53 

    54 protected:

    55     static inline unsigned int get_random(unsigned range = UINT_MAX);

    56 private:

    57   inline void Init( int value );

    58 

    59 #if TESTCLASS_DEEP_DATA

    60     int *p;

    61 #else

    62   int v;

    63 #endif

    64 };

    65 

    66 #if defined( __MWERKS__ ) && __MWERKS__ <= 0x3000 && !__SGI_STL

    67 # if defined( __MSL__ ) && __MSL__ < 0x2406

    68 #  include <iterator.h>

    69 __MSL_FIX_ITERATORS__(TestClass);

    70 __MSL_FIX_ITERATORS__(const TestClass);

    71 typedef EH_STD::pair<const TestClass, TestClass> pair_testclass_testclass;

    72 __MSL_FIX_ITERATORS__( pair_testclass_testclass );

    73 __MSL_FIX_ITERATORS__( const pair_testclass_testclass );

    74 # endif

    75 #endif

    76 

    77 inline void TestClass::Init( int value )

    78 {

    79 #if TESTCLASS_DEEP_DATA

    80   p = new int( value );

    81 #else

    82   simulate_constructor();

    83   v = value;

    84 #endif

    85 }

    86 

    87 inline TestClass::TestClass()

    88 {

    89   Init( int(get_random()) );

    90 }

    91 

    92 inline TestClass::TestClass( int value )

    93 {

    94   Init( value );

    95 }

    96 

    97 inline TestClass::TestClass( const TestClass& rhs )

    98 {

    99   Init( rhs.value() );

   100 }

   101 

   102 inline TestClass::~TestClass()

   103 {

   104 #if TESTCLASS_DEEP_DATA

   105   delete p;

   106 #else

   107   simulate_destructor();

   108 #endif

   109 }

   110 

   111 inline TestClass& TestClass::operator=( const TestClass& rhs )

   112 {

   113 #if TESTCLASS_DEEP_DATA

   114   int *newP = new int( rhs.value() );

   115   delete p;

   116   p = newP;

   117 #else

   118   simulate_possible_failure();

   119     v = rhs.value();

   120 #endif

   121     return *this;

   122 }

   123 

   124 inline int TestClass::value() const

   125 {

   126 #if TESTCLASS_DEEP_DATA

   127   return *p;

   128 #else

   129   return v;

   130 #endif

   131 }

   132 

   133 inline TestClass TestClass::operator!() const

   134 {

   135     return TestClass( value()+1 );

   136 }

   137 

   138 inline bool operator>( const TestClass& lhs, const TestClass& rhs ) {

   139     return rhs < lhs;

   140 }

   141 

   142 inline bool operator>=( const TestClass& lhs, const TestClass& rhs ) {

   143     return !(lhs < rhs);

   144 }

   145 

   146 inline bool operator<=( const TestClass& lhs, const TestClass& rhs ) {

   147     return !(rhs < lhs);

   148 }

   149 

   150 inline bool operator != ( const TestClass& lhs, const TestClass& rhs ) {

   151     return lhs.value() != rhs.value();

   152 }

   153 

   154 inline unsigned int TestClass::get_random( unsigned range )

   155 {

   156     return random_number( range );

   157 }

   158 

   159 extern std::ostream& operator << ( std::ostream& s, const TestClass&);

   160 

   161 #endif // INCLUDED_MOTU_TestClass