001: package com.clarkware.junitperf;
002:
003: import junit.framework.*;
004:
005: /**
006: * The <code>TimedTestTest</code> is a <code>TestCase</code>
007: * for the <code>TimedTest</code> class.
008: *
009: * @author <a href="mailto:mike@clarkware.com">Mike Clark</a>
010: * @author <a href="http://www.clarkware.com">Clarkware Consulting, Inc.</a>
011: * @author Ervin Varga
012: *
013: * @see junit.framework.TestCase
014: */
015:
016: public class TimedTestTest extends TestCase {
017:
018: private Test _oneSecondTest;
019: private Test _oneSecondFailedTest;
020: private Timer _twoSecondDelayTimer;
021:
022: public static final long tolerance = 100;
023:
024: public TimedTestTest(String name) {
025: super (name);
026:
027: _oneSecondTest = new MockTest("testOneSecondExecutionTime");
028:
029: _oneSecondFailedTest = new MockTest(
030: "testOneSecondExecutionTimeWithFailure");
031:
032: _twoSecondDelayTimer = new ConstantTimer(2000);
033: }
034:
035: public void testOneSecondResponseDefault() {
036:
037: Test test = new TimedTest(_oneSecondTest, 1000 + tolerance);
038:
039: assertEquals(1, test.countTestCases());
040:
041: TestResult result = new TestResult();
042: test.run(result);
043:
044: assertEquals(1, result.runCount());
045: assertEquals(0, result.errorCount());
046: assertEquals(0, result.failureCount());
047: }
048:
049: public void testOneSecondResponseNoWaitForCompletion() {
050:
051: Test test = new TimedTest(_oneSecondTest, 1000 + tolerance,
052: false);
053:
054: assertEquals(1, test.countTestCases());
055:
056: TestResult result = new TestResult();
057: test.run(result);
058:
059: assertEquals(1, result.runCount());
060: assertEquals(0, result.errorCount());
061: assertEquals(0, result.failureCount());
062: }
063:
064: public void testOneSecondResponseWaitForCompletion() {
065:
066: Test test = new TimedTest(_oneSecondTest, 1000 + tolerance,
067: true);
068:
069: assertEquals(1, test.countTestCases());
070:
071: TestResult result = new TestResult();
072: test.run(result);
073:
074: assertEquals(1, result.runCount());
075: assertEquals(0, result.errorCount());
076: assertEquals(0, result.failureCount());
077: }
078:
079: public void testOneSecondResponseFailure() {
080:
081: Test test = new TimedTest(_oneSecondTest, 900);
082:
083: assertEquals(1, test.countTestCases());
084:
085: TestResult result = new TestResult();
086: test.run(result);
087:
088: assertEquals(1, result.runCount());
089: assertEquals(0, result.errorCount());
090: assertEquals(1, result.failureCount());
091: }
092:
093: public void testOneSecondResponseOneUserLoadSuccess() {
094:
095: Test loadTest = new LoadTest(_oneSecondTest, 1);
096: Test test = new TimedTest(loadTest, 1000 + tolerance);
097:
098: assertEquals(1, test.countTestCases());
099:
100: TestResult result = new TestResult();
101: test.run(result);
102:
103: assertEquals(1, result.runCount());
104: assertEquals(0, result.errorCount());
105: assertEquals(0, result.failureCount());
106: }
107:
108: public void testOneSecondResponseOneUserLoadFailure() {
109:
110: Test loadTest = new LoadTest(_oneSecondTest, 1);
111: Test test = new TimedTest(loadTest, 900);
112:
113: assertEquals(1, test.countTestCases());
114:
115: TestResult result = new TestResult();
116: test.run(result);
117:
118: assertEquals(1, result.runCount());
119: assertEquals(0, result.errorCount());
120: assertEquals(1, result.failureCount());
121: }
122:
123: public void testOneSecondResponseMultiUserLoadSuccess() {
124:
125: Test loadTest = new LoadTest(_oneSecondTest, 2);
126: Test test = new TimedTest(loadTest, 1500);
127:
128: assertEquals(2, test.countTestCases());
129:
130: TestResult result = new TestResult();
131: test.run(result);
132:
133: assertEquals(2, result.runCount());
134: assertEquals(0, result.errorCount());
135: assertEquals(0, result.failureCount());
136: }
137:
138: public void testOneSecondResponseMultiUserLoadFailure() {
139:
140: Test loadTest = new LoadTest(_oneSecondTest, 2);
141: Test test = new TimedTest(loadTest, 1000);
142:
143: assertEquals(2, test.countTestCases());
144:
145: TestResult result = new TestResult();
146: test.run(result);
147:
148: assertEquals(2, result.runCount());
149: assertEquals(0, result.errorCount());
150: assertEquals(1, result.failureCount());
151: }
152:
153: public void testOneSecondResponseMultiUserLoadTwoSecondDelaySuccess() {
154:
155: Test loadTest = new LoadTest(_oneSecondTest, 2,
156: _twoSecondDelayTimer);
157: Test test = new TimedTest(loadTest, 4000 + tolerance);
158:
159: assertEquals(2, test.countTestCases());
160:
161: TestResult result = new TestResult();
162: test.run(result);
163:
164: assertEquals(2, result.runCount());
165: assertEquals(0, result.errorCount());
166: assertEquals(0, result.failureCount());
167: }
168:
169: public void testOneSecondResponseMultiUserLoadTwoSecondDelayFailure() {
170:
171: Test loadTest = new LoadTest(_oneSecondTest, 2,
172: _twoSecondDelayTimer);
173: Test test = new TimedTest(loadTest, 3700 + tolerance);
174:
175: assertEquals(2, test.countTestCases());
176:
177: TestResult result = new TestResult();
178: test.run(result);
179:
180: assertEquals(2, result.runCount());
181: assertEquals(0, result.errorCount());
182: assertEquals(1, result.failureCount());
183: }
184:
185: /**
186: * This test will succeed properly only when the timed
187: * test does not wait for the decorated test completion.
188: * Otherwise, if the timed test waits for the decorated
189: * test completion, this test will hang indefinitely.
190: */
191: public void testInfiniteNoWaitForCompletion() {
192:
193: Test mockTest = new MockTest("testInfiniteExecutionTime");
194: Test test = new TimedTest(mockTest, 1000 + tolerance, false);
195:
196: assertEquals(1, test.countTestCases());
197:
198: TestResult result = new TestResult();
199: test.run(result);
200:
201: assertEquals(1, result.runCount());
202: assertEquals(0, result.errorCount());
203: assertEquals(1, result.failureCount());
204: }
205:
206: /**
207: * This test will succeed properly regardless of whether the
208: * timed test waits for the decorated test completion or
209: * not. However, when the timed test does not wait for the
210: * decorated test completion, then it doesn't need to waste
211: * time waiting for the test to complete only then to
212: * signal a failure.
213: */
214: public void testLongResponseNoWaitForCompletion() {
215:
216: Test mockTest = new MockTest("testLongExecutionTime");
217: Test test = new TimedTest(mockTest, 2000 + tolerance, false);
218:
219: assertEquals(1, test.countTestCases());
220:
221: TestResult result = new TestResult();
222: test.run(result);
223:
224: assertEquals(1, result.runCount());
225: assertEquals(0, result.errorCount());
226: assertEquals(1, result.failureCount());
227: }
228:
229: /**
230: * This test will cause the test to hang indefinitely.
231: * The test will not properly fail after expiration
232: * of the specified maximum elapsed time.
233: */
234: /*
235: public void testInfiniteWaitForCompletion() {
236:
237: Test mockTest = new MockTest("testInfiniteExecutionTime");
238: Test test = new TimedTest(mockTest, 1000 + tolerance, true);
239:
240: assertEquals(1, test.countTestCases());
241:
242: TestResult result = new TestResult();
243: test.run(result);
244:
245: assertEquals(1, result.runCount());
246: assertEquals(0, result.errorCount());
247: assertEquals(1, result.failureCount());
248: }
249: */
250:
251: public void testOneSecondResponseSuccessWaiting() {
252:
253: Test test = new TimedTest(_oneSecondFailedTest,
254: 1000 + tolerance, true);
255:
256: assertEquals(1, test.countTestCases());
257:
258: TestResult result = new TestResult();
259: test.run(result);
260:
261: assertEquals(1, result.runCount());
262: assertEquals(0, result.errorCount());
263: assertEquals(1, result.failureCount());
264: }
265:
266: public void testOneSecondResponseSuccessNonWaiting() {
267:
268: Test test = new TimedTest(_oneSecondFailedTest,
269: 1000 + tolerance, false);
270:
271: assertEquals(1, test.countTestCases());
272:
273: TestResult result = new TestResult();
274: test.run(result);
275:
276: assertEquals(1, result.runCount());
277: assertEquals(0, result.errorCount());
278: assertEquals(1, result.failureCount());
279: }
280:
281: /**
282: * When the timed test waits for completion, the effects of
283: * the decorated test are still traced and recorded.
284: */
285: public void testOneSecondResponseFailureWaiting() {
286:
287: Test test = new TimedTest(_oneSecondFailedTest, 900, true);
288:
289: assertEquals(1, test.countTestCases());
290:
291: TestResult result = new TestResult();
292: test.run(result);
293:
294: assertEquals(1, result.runCount());
295: assertEquals(0, result.errorCount());
296: assertEquals(2, result.failureCount());
297: }
298:
299: /**
300: * Failure(s) from a decorated test will not be detected
301: * after the expiration of the max. elapsed time in a non-waiting
302: * timed test. This can cause possible ambiguities in the test,
303: * especially when a decorated test has a varying execution time.
304: *
305: * For example, if the decorated test would finish its execution in a
306: * 800 ms then the failureCount() will return 1 because the decorated
307: * test itself has failed. However, if a timing would cause a failure
308: * (the decorated test needed more then 900 ms to complete its execution)
309: * the failureCount() will be again 1. However, the root cause of the
310: * failure is ambiguous.
311: */
312: public void testOneSecondResponseNonWaitingWithAmbiguousFailure() {
313:
314: Test test = new TimedTest(_oneSecondFailedTest, 900, false);
315:
316: assertEquals(1, test.countTestCases());
317:
318: TestResult result = new TestResult();
319: test.run(result);
320:
321: assertEquals(1, result.runCount());
322: assertEquals(0, result.errorCount());
323: assertEquals(1, result.failureCount());
324: }
325:
326: /**
327: * Differentiates the cause of a non-waiting timed test's
328: * failure as a result of either the max elapsed time being
329: * exceeded or the test itself has failed.
330: */
331: public void testOneSecondResponseNonWaitingWithTimeFailure() {
332:
333: TimedTest test = new TimedTest(_oneSecondFailedTest, 900, false);
334:
335: assertEquals(1, test.countTestCases());
336:
337: TestResult result = new TestResult();
338: test.run(result);
339:
340: if (test.outOfTime()) {
341: // success
342: } else {
343: fail("Max elapsed time exceeded!");
344: }
345: }
346:
347: /**
348: * Differentiates the cause of a non-waiting timed test's
349: * failure as a result of either the max elapsed time being
350: * exceeded or the test itself has failed.
351: */
352: public void testOneSecondResponseNonWaitingWithTestFailure() {
353:
354: TimedTest test = new TimedTest(_oneSecondFailedTest, 1100,
355: false);
356:
357: assertEquals(1, test.countTestCases());
358:
359: TestResult result = new TestResult();
360: test.run(result);
361:
362: if (test.outOfTime()) {
363: fail("Should never get here!");
364: } else {
365: //
366: // Failed due to invalid test state.
367: //
368: assertEquals(1, result.runCount());
369: assertEquals(0, result.errorCount());
370: assertEquals(1, result.failureCount());
371: }
372: }
373:
374: public static Test suite() {
375: return new TestSuite(TimedTestTest.class);
376: }
377:
378: public static void main(String args[]) {
379: junit.textui.TestRunner.run(suite());
380: }
381: }
|