JSR166TestCase (Blazegraph Database Platform 2.1.5 API)

java.lang.Object
- junit.framework.Assert
- - junit.framework.TestCase
  - - com.bigdata.jsr166.JSR166TestCase

All Implemented Interfaces:

junit.framework.Test

Direct Known Subclasses:

BlockingQueueTest, LinkedBlockingDequeTest, LinkedBlockingQueueTest
```
public class JSR166TestCase
extends junit.framework.TestCase
```
Base class for JSR166 Junit TCK tests. Defines some constants, utility methods and classes, as well as a simple framework for helping to make sure that assertions failing in generated threads cause the associated test that generated them to itself fail (which JUnit does not otherwise arrange). The rules for creating such tests are:
1. All assertions in code running in generated threads must use the forms threadFail(java.lang.String), threadAssertTrue(boolean), threadAssertEquals(long, long), or threadAssertNull(java.lang.Object), (not fail, assertTrue, etc.) It is OK (but not particularly recommended) for other code to use these forms too. Only the most typically used JUnit assertion methods are defined this way, but enough to live with.
2. If you override setUp() or tearDown(), make sure to invoke super.setUp and super.tearDown within them. These methods are used to clear and check for thread assertion failures.
3. All delays and timeouts must use one of the constants SHORT_DELAY_MS, SMALL_DELAY_MS, MEDIUM_DELAY_MS, LONG_DELAY_MS. The idea here is that a SHORT is always discriminable from zero time, and always allows enough time for the small amounts of computation (creating a thread, calling a few methods, etc) needed to reach a timeout point. Similarly, a SMALL is always discriminable as larger than SHORT and smaller than MEDIUM. And so on. These constants are set to conservative values, but even so, if there is ever any doubt, they can all be increased in one spot to rerun tests on slower platforms.
4. All threads generated must be joined inside each test case method (or fail to do so) before returning from the method. The joinPool method can be used to do this when using Executors.
Other notes
- Usually, there is one testcase method per JSR166 method covering "normal" operation, and then as many exception-testing methods as there are exceptions the method can throw. Sometimes there are multiple tests per JSR166 method when the different "normal" behaviors differ significantly. And sometimes testcases cover multiple methods when they cannot be tested in isolation.
- The documentation style for testcases is to provide as javadoc a simple sentence or two describing the property that the testcase method purports to test. The javadocs do not say anything about how the property is tested. To find out, read the code.
- These tests are "conformance tests", and do not attempt to test throughput, latency, scalability or other performance factors (see the separate "jtreg" tests for a set intended to check these for the most central aspects of functionality.) So, most tests use the smallest sensible numbers of threads, collection sizes, etc needed to check basic conformance.
- The test classes currently do not declare inclusion in any particular package to simplify things for people integrating them in TCK test suites.
- As a convenience, the main of this class (JSR166TestCase) runs all JSR166 unit tests.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`JSR166TestCase.AdjustablePolicy` A security policy where new permissions can be dynamically added or all cleared.
`static class`	`JSR166TestCase.CallableOne`
`class`	`JSR166TestCase.CheckedBarrier` A CyclicBarrier that fails with AssertionFailedErrors instead of throwing checked exceptions.
`class`	`JSR166TestCase.CheckedCallable<T>`
`class`	`JSR166TestCase.CheckedInterruptedCallable<T>`
`class`	`JSR166TestCase.CheckedInterruptedRunnable`
`class`	`JSR166TestCase.CheckedRunnable`
`class`	`JSR166TestCase.LongPossiblyInterruptedRunnable`
`class`	`JSR166TestCase.MediumInterruptedRunnable`
`class`	`JSR166TestCase.MediumPossiblyInterruptedRunnable`
`class`	`JSR166TestCase.MediumRunnable`
`static class`	`JSR166TestCase.NoOpCallable`
`static class`	`JSR166TestCase.NoOpREHandler` For use as RejectedExecutionHandler in constructors
`static class`	`JSR166TestCase.NoOpRunnable`
`static class`	`JSR166TestCase.NPETask`
`class`	`JSR166TestCase.RunnableShouldThrow`
`class`	`JSR166TestCase.ShortInterruptedRunnable`
`class`	`JSR166TestCase.ShortRunnable`
`static class`	`JSR166TestCase.SimpleThreadFactory` For use as ThreadFactory in constructors
`class`	`JSR166TestCase.SmallCallable`
`class`	`JSR166TestCase.SmallPossiblyInterruptedRunnable`
`class`	`JSR166TestCase.SmallRunnable`
`static class`	`JSR166TestCase.StringTask`
`class`	`JSR166TestCase.ThreadShouldThrow`
`static class`	`JSR166TestCase.TrackedCallable`
`static class`	`JSR166TestCase.TrackedLongRunnable`
`static class`	`JSR166TestCase.TrackedMediumRunnable`
`static class`	`JSR166TestCase.TrackedNoOpRunnable`
`static interface`	`JSR166TestCase.TrackedRunnable`
`static class`	`JSR166TestCase.TrackedShortRunnable`
`static class`	`JSR166TestCase.TrackedSmallRunnable`

Field Summary

Fields
Modifier and Type	Field and Description
`static Integer`	`eight`
`protected static boolean`	`expensiveTests`
`static Integer`	`five`
`static Integer`	`four`
`static long`	`LONG_DELAY_MS`
`static Integer`	`m1`
`static Integer`	`m10`
`static Integer`	`m2`
`static Integer`	`m3`
`static Integer`	`m4`
`static Integer`	`m5`
`static Integer`	`m6`
`static long`	`MEDIUM_DELAY_MS`
`static Integer`	`nine`
`static Integer`	`one`
`static Integer`	`seven`
`static long`	`SHORT_DELAY_MS`
`static Integer`	`six`
`static int`	`SIZE` The number of elements to place in collections, arrays, etc.
`static long`	`SMALL_DELAY_MS`
`static String`	`TEST_STRING`
`static Integer`	`three`
`static Integer`	`two`
`static Integer`	`zero`

Constructor Summary

Constructors
Constructor and Description

JSR166TestCase()

Constructors
Constructor and Description
`JSR166TestCase()`

Method Summary

Methods
Modifier and Type	Method and Description
`Runnable`	`awaiter(CountDownLatch latch)`
`void`	`checkEmpty(BlockingQueue q)`
`protected long`	`getShortDelay()` Returns the shortest timed delay.
`void`	`joinPool(ExecutorService exec)` Waits out termination of a thread pool or fails doing so.
`Callable<String>`	`latchAwaitingStringTask(CountDownLatch latch)`
`static void`	`main(String[] args)` Runs all JSR166 unit tests using junit.textui.TestRunner
`static junit.framework.TestSuite`	`newTestSuite(Object... suiteOrClasses)`
`static Policy`	`permissivePolicy()` Returns a policy containing all the permissions we ever need.
`Runnable`	`possiblyInterruptedRunnable(long timeoutMillis)`
`protected void`	`runTest()`
`protected void`	`runTestProfiled()`
`void`	`runWithoutPermissions(Runnable r)` Runs a runnable without any permissions.
`void`	`runWithPermissions(Runnable r, Permission... permissions)` Runs Runnable r with a security policy that permits precisely the specified permissions.
`protected void`	`setDelays()` Sets delays as multiples of SHORT_DELAY.
`void`	`setUp()`
`void`	`shouldThrow()` Fails with message "should throw exception".
`void`	`shouldThrow(String exceptionName)` Fails with message "should throw " + exceptionName.
`static junit.framework.Test`	`suite()` Collects all JSR166 unit tests as one suite.
`void`	`tearDown()` Triggers test case failure if any thread assertions have failed, by rethrowing, in the test harness thread, any exception recorded earlier by threadRecordFailure.
`void`	`threadAssertEquals(long x, long y)` Just like assertEquals(x, y), but additionally recording (using threadRecordFailure) any AssertionFailedError thrown, so that the current testcase will fail.
`void`	`threadAssertEquals(Object x, Object y)` Just like assertEquals(x, y), but additionally recording (using threadRecordFailure) any AssertionFailedError thrown, so that the current testcase will fail.
`void`	`threadAssertFalse(boolean b)` Just like assertFalse(b), but additionally recording (using threadRecordFailure) any AssertionFailedError thrown, so that the current testcase will fail.
`void`	`threadAssertNull(Object x)` Just like assertNull(x), but additionally recording (using threadRecordFailure) any AssertionFailedError thrown, so that the current testcase will fail.
`void`	`threadAssertSame(Object x, Object y)` Just like assertSame(x, y), but additionally recording (using threadRecordFailure) any AssertionFailedError thrown, so that the current testcase will fail.
`void`	`threadAssertTrue(boolean b)` Just like assertTrue(b), but additionally recording (using threadRecordFailure) any AssertionFailedError thrown, so that the current testcase will fail.
`void`	`threadFail(String reason)` Just like fail(reason), but additionally recording (using threadRecordFailure) any AssertionFailedError thrown, so that the current testcase will fail.
`void`	`threadRecordFailure(Throwable t)` Records an exception so that it can be rethrown later in the test harness thread, triggering a test case failure.
`void`	`threadShouldThrow()` Calls threadFail with message "should throw exception".
`void`	`threadShouldThrow(String exceptionName)` Calls threadFail with message "should throw" + exceptionName.
`void`	`threadUnexpectedException(Throwable t)` Records the given exception using `threadRecordFailure(java.lang.Throwable)`, then rethrows the exception, wrapping it in an AssertionFailedError if necessary.
`static JSR166TestCase.TrackedRunnable`	`trackedRunnable(long timeoutMillis)`

Methods inherited from class junit.framework.TestCase
assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertFalse, assertFalse, assertNotNull, assertNotNull, assertNotSame, assertNotSame, assertNull, assertNull, assertSame, assertSame, assertTrue, assertTrue, countTestCases, createResult, fail, fail, failNotEquals, failNotSame, failSame, format, getName, run, run, runBare, setName, toString

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - expensiveTests
```
protected static final boolean expensiveTests
```
  - SHORT_DELAY_MS
```
public static long SHORT_DELAY_MS
```
  - SMALL_DELAY_MS
```
public static long SMALL_DELAY_MS
```
  - MEDIUM_DELAY_MS
```
public static long MEDIUM_DELAY_MS
```
  - LONG_DELAY_MS
```
public static long LONG_DELAY_MS
```
  - SIZE
```
public static final int SIZE
```
    The number of elements to place in collections, arrays, etc.
    
    See Also:
    Constant Field Values
  - zero
```
public static final Integer zero
```
  - one
```
public static final Integer one
```
  - two
```
public static final Integer two
```
  - three
```
public static final Integer three
```
  - four
```
public static final Integer four
```
  - five
```
public static final Integer five
```
  - six
```
public static final Integer six
```
  - seven
```
public static final Integer seven
```
  - eight
```
public static final Integer eight
```
  - nine
```
public static final Integer nine
```
  - m1
```
public static final Integer m1
```
  - m2
```
public static final Integer m2
```
  - m3
```
public static final Integer m3
```
  - m4
```
public static final Integer m4
```
  - m5
```
public static final Integer m5
```
  - m6
```
public static final Integer m6
```
  - m10
```
public static final Integer m10
```
  - TEST_STRING
```
public static final String TEST_STRING
```
    See Also:
    Constant Field Values
- Constructor Detail
  - JSR166TestCase
```
public JSR166TestCase()
```
- Method Detail
  - runTest
```
protected void runTest()
                throws Throwable
```
    Overrides:
    
    runTest in class junit.framework.TestCase
    
    Throws:
    
    Throwable
  - runTestProfiled
```
protected void runTestProfiled()
                        throws Throwable
```
    Throws:
    
    Throwable
  - main
```
public static void main(String[] args)
```
    Runs all JSR166 unit tests using junit.textui.TestRunner
  - newTestSuite
```
public static junit.framework.TestSuite newTestSuite(Object... suiteOrClasses)
```
  - suite
```
public static junit.framework.Test suite()
```
    Collects all JSR166 unit tests as one suite.
  - getShortDelay
```
protected long getShortDelay()
```
    Returns the shortest timed delay. This could be reimplemented to use for example a Property.
  - setDelays
```
protected void setDelays()
```
    Sets delays as multiples of SHORT_DELAY.
  - threadRecordFailure
```
public void threadRecordFailure(Throwable t)
```
    Records an exception so that it can be rethrown later in the test harness thread, triggering a test case failure. Only the first failure is recorded; subsequent calls to this method from within the same test have no effect.
  - setUp
```
public void setUp()
```
    Overrides:
    
    setUp in class junit.framework.TestCase
  - tearDown
```
public void tearDown()
              throws Exception
```
    Triggers test case failure if any thread assertions have failed, by rethrowing, in the test harness thread, any exception recorded earlier by threadRecordFailure.
    
    Overrides:
    
    tearDown in class junit.framework.TestCase
    
    Throws:
    
    Exception
  - threadFail
```
public void threadFail(String reason)
```
    Just like fail(reason), but additionally recording (using threadRecordFailure) any AssertionFailedError thrown, so that the current testcase will fail.
  - threadAssertTrue
```
public void threadAssertTrue(boolean b)
```
    Just like assertTrue(b), but additionally recording (using threadRecordFailure) any AssertionFailedError thrown, so that the current testcase will fail.
  - threadAssertFalse
```
public void threadAssertFalse(boolean b)
```
    Just like assertFalse(b), but additionally recording (using threadRecordFailure) any AssertionFailedError thrown, so that the current testcase will fail.
  - threadAssertNull
```
public void threadAssertNull(Object x)
```
    Just like assertNull(x), but additionally recording (using threadRecordFailure) any AssertionFailedError thrown, so that the current testcase will fail.
  - threadAssertEquals
```
public void threadAssertEquals(long x,
                      long y)
```
    Just like assertEquals(x, y), but additionally recording (using threadRecordFailure) any AssertionFailedError thrown, so that the current testcase will fail.
  - threadAssertEquals
```
public void threadAssertEquals(Object x,
                      Object y)
```
    Just like assertEquals(x, y), but additionally recording (using threadRecordFailure) any AssertionFailedError thrown, so that the current testcase will fail.
  - threadAssertSame
```
public void threadAssertSame(Object x,
                    Object y)
```
    Just like assertSame(x, y), but additionally recording (using threadRecordFailure) any AssertionFailedError thrown, so that the current testcase will fail.
  - threadShouldThrow
```
public void threadShouldThrow()
```
    Calls threadFail with message "should throw exception".
  - threadShouldThrow
```
public void threadShouldThrow(String exceptionName)
```
    Calls threadFail with message "should throw" + exceptionName.
  - threadUnexpectedException
```
public void threadUnexpectedException(Throwable t)
```
    Records the given exception using threadRecordFailure(java.lang.Throwable), then rethrows the exception, wrapping it in an AssertionFailedError if necessary.
  - joinPool
```
public void joinPool(ExecutorService exec)
```
    Waits out termination of a thread pool or fails doing so.
  - shouldThrow
```
public void shouldThrow()
```
    Fails with message "should throw exception".
  - shouldThrow
```
public void shouldThrow(String exceptionName)
```
    Fails with message "should throw " + exceptionName.
  - runWithPermissions
```
public void runWithPermissions(Runnable r,
                      Permission... permissions)
```
    Runs Runnable r with a security policy that permits precisely the specified permissions. If there is no current security manager, the runnable is run twice, both with and without a security manager. We require that any security manager permit getPolicy/setPolicy.
  - runWithoutPermissions
```
public void runWithoutPermissions(Runnable r)
```
    Runs a runnable without any permissions.
  - permissivePolicy
```
public static Policy permissivePolicy()
```
    Returns a policy containing all the permissions we ever need.
  - latchAwaitingStringTask
```
public Callable<String> latchAwaitingStringTask(CountDownLatch latch)
```
  - awaiter
```
public Runnable awaiter(CountDownLatch latch)
```
  - possiblyInterruptedRunnable
```
public Runnable possiblyInterruptedRunnable(long timeoutMillis)
```
  - trackedRunnable
```
public static JSR166TestCase.TrackedRunnable trackedRunnable(long timeoutMillis)
```
  - checkEmpty
```
public void checkEmpty(BlockingQueue q)
```

Class JSR166TestCase

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class junit.framework.TestCase

Methods inherited from class java.lang.Object

Field Detail

expensiveTests

SHORT_DELAY_MS

SMALL_DELAY_MS

MEDIUM_DELAY_MS

LONG_DELAY_MS

SIZE

zero

one

two

three

four

five

six

seven

eight

nine

m1

m2

m3

m4

m5

m6

m10

TEST_STRING

Constructor Detail

JSR166TestCase

Method Detail

runTest

runTestProfiled

main

newTestSuite

suite

getShortDelay

setDelays

threadRecordFailure

setUp

tearDown

threadFail

threadAssertTrue

threadAssertFalse

threadAssertNull

threadAssertEquals

threadAssertEquals

threadAssertSame

threadShouldThrow

threadShouldThrow

threadUnexpectedException

joinPool

shouldThrow

shouldThrow

runWithPermissions

runWithoutPermissions

permissivePolicy

latchAwaitingStringTask

awaiter

possiblyInterruptedRunnable

trackedRunnable

checkEmpty