1 /***********************************************************************************
2 TestController.h
3
4 SUMMARY: An "faux-singleton" object to encapsulate a hodgepodge of state and
5 functionality relating to the test suite. Probably should be broken
6 into smaller pieces.
7
8 * Copyright (c) 1997
9 * Mark of the Unicorn, Inc.
10 *
11 * Permission to use, copy, modify, distribute and sell this software
12 * and its documentation for any purpose is hereby granted without fee,
13 * provided that the above copyright notice appear in all copies and
14 * that both that copyright notice and this permission notice appear
15 * in supporting documentation. Mark of the Unicorn makes no
16 * representations about the suitability of this software for any
17 * purpose. It is provided "as is" without express or implied warranty.
18
19 ***********************************************************************************/
20 #if !INCLUDED_MOTU_nc_alloc
21 #define INCLUDED_MOTU_nc_alloc 1
22
23 #include "Prefix.h"
24
25 #if defined (EH_NEW_HEADERS)
26 # include <utility>
27 #else
28 # include <pair.h>
29 #endif
30
31 extern long alloc_count;
32 extern long object_count;
33
34 struct TestController {
35 // Report that the current test has succeeded.
36 static void ReportSuccess(int);
37
38 //
39 // Leak detection
40 //
41
42 // Turn the recording of the addresses of individual allocated
43 // blocks on or off. If not called, allocations will only be
44 // counted, but deallocations won't be checked for validity.
45 static void TrackAllocations( bool );
46 static bool TrackingEnabled();
47
48 // Call this to begin a new leak-detection cycle. Resets all
49 // allocation counts, etc.
50 static void BeginLeakDetection();
51
52 // Returns true iff leak detection is currently in effect
53 static bool LeakDetectionEnabled();
54
55 // Ends leak detection and reports any resource leaks.
56 // Returns true if any occurred.
57 static bool ReportLeaked();
58
59 //
60 // Exception-safety
61 //
62
63 // Don't test for exception-safety
64 static void TurnOffExceptions();
65
66 // Set operator new to fail on the nth invocation
67 static void SetFailureCountdown( long n );
68
69 // Set operator new to never fail.
70 static void CancelFailureCountdown();
71
72 // Throws an exception if the count has been reached. Call this
73 // before every operation that might fail in the real world.
74 static void maybe_fail(long);
75
76 //
77 // Managing verbose feedback.
78 //
79
80 // Call to begin a strong, weak, or const test. If verbose
81 // reporting is enabled, prints the test category.
82 static void SetCurrentTestCategory( const char* str );
83
84 // Call to set the name of the container being tested.
85 static void SetCurrentContainer( const char* str );
86
87 // Sets the name of the current test.
88 static void SetCurrentTestName(const char* str);
89
90 // Turn verbose reporting on or off.
91 static void SetVerbose(bool val);
92
93 private:
94 enum { kNotInExceptionTest = -1 };
95
96 static void ClearAllocationSet();
97 static void EndLeakDetection();
98 static void PrintTestName( bool err=false );
99
100 static long& Failure_threshold();
101 static long possible_failure_count;
102 static const char* current_test;
103 static const char* current_test_category;
104 static const char* current_container;
105 static bool nc_verbose;
106 static bool never_fail;
107 static bool track_allocations;
108 static bool leak_detection_enabled;
109 };
110
111 extern TestController gTestController;
112
113 //
114 // inline implementations
115 //
116
simulate_possible_failure()117 inline void simulate_possible_failure() {
118 gTestController.maybe_fail(0);
119 }
120
simulate_constructor()121 inline void simulate_constructor() {
122 gTestController.maybe_fail(0);
123 ++object_count;
124 }
125
simulate_destructor()126 inline void simulate_destructor() {
127 --object_count;
128 }
129
TrackAllocations(bool track)130 inline void TestController::TrackAllocations(bool track) {
131 track_allocations = track;
132 }
133
TrackingEnabled()134 inline bool TestController::TrackingEnabled() {
135 return track_allocations;
136 }
137
SetFailureCountdown(long count)138 inline void TestController::SetFailureCountdown(long count) {
139 Failure_threshold() = count;
140 possible_failure_count = 0;
141 }
142
CancelFailureCountdown()143 inline void TestController::CancelFailureCountdown() {
144 Failure_threshold() = kNotInExceptionTest;
145 }
146
BeginLeakDetection()147 inline void TestController::BeginLeakDetection() {
148 alloc_count = 0;
149 object_count = 0;
150 ClearAllocationSet();
151 leak_detection_enabled = true;
152 }
153
LeakDetectionEnabled()154 inline bool TestController::LeakDetectionEnabled() {
155 return leak_detection_enabled;
156 }
157
EndLeakDetection()158 inline void TestController::EndLeakDetection() {
159 leak_detection_enabled = false;
160 }
161
SetCurrentTestCategory(const char * str)162 inline void TestController::SetCurrentTestCategory(const char* str) {
163 current_test_category = str;
164 if (nc_verbose)
165 PrintTestName();
166 }
167
SetCurrentContainer(const char * str)168 inline void TestController::SetCurrentContainer(const char* str) {
169 current_container=str;
170 }
171
SetCurrentTestName(const char * str)172 inline void TestController::SetCurrentTestName(const char* str) {
173 current_test = str;
174 }
175
SetVerbose(bool val)176 inline void TestController::SetVerbose(bool val) {
177 nc_verbose = val;
178 }
179
TurnOffExceptions()180 inline void TestController::TurnOffExceptions() {
181 never_fail = true;
182 }
183
184 #endif // INCLUDED_MOTU_nc_alloc
185