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

  TestClass.h

 * Copyright (c) 1997-1998

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

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

      cause exceptions when it is constructed or copied.

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

#ifndef INCLUDED_MOTU_TestClass

#define INCLUDED_MOTU_TestClass 1

# include "Prefix.h"

#  include <functional>

#  include <utility>

#  include <climits>

#include <iosfwd>

#include "random_number.h"

#include "nc_alloc.h"

class TestClass

{

public:

    inline TestClass();

    inline TestClass( int value );

    inline TestClass( const TestClass& rhs );

    inline ~TestClass();

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

    inline int value() const;

    inline TestClass operator!() const;

    bool operator==( const TestClass& rhs ) const

    {

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

    }

    bool operator<( const TestClass& rhs ) const {

      return value() < rhs.value();

    }

protected:

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

private:

  inline void Init( int value );

#if TESTCLASS_DEEP_DATA

    int *p;

#else

  int v;

#endif

};

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

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

#  include <iterator.h>

__MSL_FIX_ITERATORS__(TestClass);

__MSL_FIX_ITERATORS__(const TestClass);

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

__MSL_FIX_ITERATORS__( pair_testclass_testclass );

__MSL_FIX_ITERATORS__( const pair_testclass_testclass );

# endif

#endif

inline void TestClass::Init( int value )

{

#if TESTCLASS_DEEP_DATA

  p = new int( value );

#else

  simulate_constructor();

  v = value;

#endif

}

inline TestClass::TestClass()

{

  Init( int(get_random()) );

}

inline TestClass::TestClass( int value )

{

  Init( value );

}

inline TestClass::TestClass( const TestClass& rhs )

{

  Init( rhs.value() );

}

inline TestClass::~TestClass()

{

#if TESTCLASS_DEEP_DATA

  delete p;

#else

  simulate_destructor();

#endif

}

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

{

#if TESTCLASS_DEEP_DATA

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

  delete p;

  p = newP;

#else

  simulate_possible_failure();

    v = rhs.value();

#endif

    return *this;

}

inline int TestClass::value() const

{

#if TESTCLASS_DEEP_DATA

  return *p;

#else

  return v;

#endif

}

inline TestClass TestClass::operator!() const

{

    return TestClass( value()+1 );

}

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

    return rhs < lhs;

}

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

    return !(lhs < rhs);

}

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

    return !(rhs < lhs);

}

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

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

}

inline unsigned int TestClass::get_random( unsigned range )

{

    return random_number( range );

}

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

#endif // INCLUDED_MOTU_TestClass