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

   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.

  * Portions Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

  *

  * 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 

 class TestController {

 public:

   // 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;

 }

 #if 1  //enable/disable inline functions

 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

 #endif // INCLUDED_MOTU_nc_alloc