OS/2 Shareware BBS: 10 Tools/10-Tools.zip/stl2vac.zip/STLport-4_5_3.zip/STLport-4.5.3/test/eh/nc_alloc.h

C/C++ Source or Header | 2000-12-07 | 5KB | 198 lines

/***********************************************************************************
    TestController.h

        SUMMARY: An "faux-singleton" object to encapsulate a hodgepodge of state and
            functionality relating to the test suite. Probably should be broken
            into smaller pieces.

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

***********************************************************************************/
#if !INCLUDED_MOTU_nc_alloc
#define INCLUDED_MOTU_nc_alloc 1

#include "Prefix.h"

# if defined (EH_NEW_HEADERS)
#  include <utility>
# else
#  include <pair.h>
# endif

extern long alloc_count;
extern long object_count;

struct TestController
{
    // Report that the current test has succeeded.
    static void ReportSuccess(int);

    //
    // Leak detection
    //

    // Turn the recording of the addresses of individual allocated
    // blocks on or off. If not called, allocations will only be
    // counted, but deallocations won't be checked for validity.
    static void TrackAllocations( bool );
    static bool TrackingEnabled();

    // Call this to begin a new leak-detection cycle. Resets all
    // allocation counts, etc.
    static void BeginLeakDetection();

    // Returns true iff leak detection is currently in effect
    static bool LeakDetectionEnabled();

    // Ends leak detection and reports any resource leaks.
    // Returns true if any occurred.
    static bool ReportLeaked();

    //
    // Exception-safety
    //

    // Don't test for exception-safety
    static void TurnOffExceptions();

    // Set operator new to fail on the nth invocation
    static void SetFailureCountdown( long n );

    // Set operator new to never fail.
    static void CancelFailureCountdown();

    // Throws an exception if the count has been reached. Call this
    // before every operation that might fail in the real world.
    static void maybe_fail(long);

    //
    // Managing verbose feedback.
    //

    // Call to begin a strong, weak, or const test. If verbose
    // reporting is enabled, prints the test category.
    static void SetCurrentTestCategory( const char* str );

    // Call to set the name of the container being tested.
    static void SetCurrentContainer( const char* str );

    // Sets the name of the current test.
    static void SetCurrentTestName(const char* str);

    // Turn verbose reporting on or off.
    static void SetVerbose(bool val);

private:
    enum { kNotInExceptionTest = -1 };

    static void ClearAllocationSet();
    static void EndLeakDetection();
    static void PrintTestName( bool err=false );

    static long& Failure_threshold();
    static long possible_failure_count;
    static const char* current_test;
    static const char* current_test_category;
    static const char* current_container;
    static bool  nc_verbose;
    static bool  never_fail;
    static bool track_allocations;
    static bool leak_detection_enabled;
};

extern TestController gTestController;

//
// inline implementations
//

inline void simulate_possible_failure()
{
   gTestController.maybe_fail(0);
}

inline void simulate_constructor()
{
   gTestController.maybe_fail(0);
   object_count++;
}

inline void simulate_destructor()
{
   object_count--;
}

inline void TestController::TrackAllocations( bool track )
{
    track_allocations = track;
}

inline bool TestController::TrackingEnabled()
{
    return track_allocations;
}

inline void TestController::SetFailureCountdown(long count) {
    Failure_threshold() = count;
    possible_failure_count = 0;
}

inline void TestController::CancelFailureCountdown() {
    Failure_threshold() = kNotInExceptionTest;
}

inline void TestController::BeginLeakDetection()
{
    alloc_count = 0;
    object_count = 0;
       ClearAllocationSet();
       leak_detection_enabled = true;
}

inline bool TestController::LeakDetectionEnabled()
{
    return leak_detection_enabled;
}

inline void TestController::EndLeakDetection()
{
    leak_detection_enabled = false;
}

inline void TestController::SetCurrentTestCategory(const char* str)
{
    current_test_category=str;
    if (nc_verbose)
        PrintTestName();
}

inline void TestController::SetCurrentContainer(const char* str) {
    current_container=str;
}

inline void TestController::SetCurrentTestName(const char* str)
{
    current_test=str;
}

inline void TestController::SetVerbose(bool val)
{
    nc_verbose=val;
}

inline void TestController::TurnOffExceptions()
{
    never_fail = true;
}

#endif // INCLUDED_MOTU_nc_alloc