CS计算机代考程序代写 chain Java junit cache Hive META-INF/MANIFEST.MF

META-INF/MANIFEST.MF

org/junit/ClassRule.class

org/junit/Assert.class

org/junit/After.class

org/junit/rules/Stopwatch$Clock.class

org/junit/rules/DisableOnDebug.class

org/junit/rules/ExternalResource.class

org/junit/rules/TestWatcher$1.class

org/junit/rules/TemporaryFolder.class

org/junit/rules/Timeout$Builder.class

org/junit/rules/RunRules.class

org/junit/rules/TestWatchman$1.class

org/junit/rules/Verifier$1.class

org/junit/rules/ExpectedException.class

org/junit/rules/ExpectedException$ExpectedExceptionStatement.class

org/junit/rules/RuleChain.class

org/junit/rules/ErrorCollector$1.class

org/junit/rules/TestRule.class

org/junit/rules/Verifier.class

org/junit/rules/Stopwatch.class

org/junit/rules/Stopwatch$1.class

org/junit/rules/Timeout.class

org/junit/rules/ExpectedExceptionMatcherBuilder.class

org/junit/rules/MethodRule.class

org/junit/rules/Timeout$1.class

org/junit/rules/ExternalResource$1.class

org/junit/rules/TestWatchman.class

org/junit/rules/ErrorCollector.class

org/junit/rules/TestWatcher.class

org/junit/rules/Stopwatch$InternalWatcher.class

org/junit/rules/TestName.class

org/junit/AssumptionViolatedException.class

org/junit/ComparisonFailure$ComparisonCompactor$DiffExtractor.class

org/junit/Assume.class

org/junit/runners/AllTests.class

org/junit/runners/Suite$SuiteClasses.class

org/junit/runners/JUnit4.class

org/junit/runners/ParentRunner$1.class

org/junit/runners/BlockJUnit4ClassRunner.class

org/junit/runners/Parameterized$Parameters.class

org/junit/runners/MethodSorters.class

org/junit/runners/ParentRunner$2.class

org/junit/runners/ParentRunner$3.class

org/junit/runners/Parameterized$UseParametersRunnerFactory.class

org/junit/runners/ParentRunner$4.class

org/junit/runners/ParentRunner.class

org/junit/runners/BlockJUnit4ClassRunner$1.class

org/junit/runners/Parameterized$Parameter.class

org/junit/runners/parameterized/ParametersRunnerFactory.class

org/junit/runners/parameterized/TestWithParameters.class

org/junit/runners/parameterized/BlockJUnit4ClassRunnerWithParameters.class

org/junit/runners/parameterized/BlockJUnit4ClassRunnerWithParametersFactory.class

org/junit/runners/Suite.class

org/junit/runners/model/MultipleFailureException.class

org/junit/runners/model/RunnerScheduler.class

org/junit/runners/model/NoGenericTypeParametersValidator.class

org/junit/runners/model/TestClass$1.class

org/junit/runners/model/RunnerBuilder.class

org/junit/runners/model/Annotatable.class

org/junit/runners/model/FrameworkField.class

org/junit/runners/model/Statement.class

org/junit/runners/model/TestTimedOutException.class

org/junit/runners/model/FrameworkMember.class

org/junit/runners/model/TestClass.class

org/junit/runners/model/TestClass$FieldComparator.class

org/junit/runners/model/FrameworkMethod.class

org/junit/runners/model/TestClass$MethodComparator.class

org/junit/runners/model/InitializationError.class

org/junit/runners/model/FrameworkMethod$1.class

org/junit/runners/Parameterized.class

org/junit/ComparisonFailure.class

org/junit/matchers/JUnitMatchers.class

org/junit/Test$None.class

org/junit/runner/FilterFactory.class

org/junit/runner/Result.class

org/junit/runner/JUnitCommandLineParseResult$CommandLineParserError.class

org/junit/runner/Result$Listener.class

org/junit/runner/JUnitCommandLineParseResult.class

org/junit/runner/Describable.class

org/junit/runner/FilterFactories.class

org/junit/runner/Result$SerializedForm.class

org/junit/runner/Runner.class

org/junit/runner/RunWith.class

org/junit/runner/manipulation/NoTestsRemainException.class

org/junit/runner/manipulation/Sortable.class

org/junit/runner/manipulation/Filter.class

org/junit/runner/manipulation/Filter$2.class

org/junit/runner/manipulation/Filter$3.class

org/junit/runner/manipulation/Sorter.class

org/junit/runner/manipulation/Sorter$1.class

org/junit/runner/manipulation/Filterable.class

org/junit/runner/manipulation/Filter$1.class

org/junit/runner/JUnitCore.class

org/junit/runner/FilterFactory$FilterNotCreatedException.class

org/junit/runner/Result$1.class

org/junit/runner/Request.class

org/junit/runner/FilterFactoryParams.class

org/junit/runner/Computer$1.class

org/junit/runner/Request$1.class

org/junit/runner/notification/Failure.class

org/junit/runner/notification/RunNotifier.class

org/junit/runner/notification/RunNotifier$1.class

org/junit/runner/notification/RunNotifier$2.class

org/junit/runner/notification/RunNotifier$3.class

org/junit/runner/notification/RunListener$ThreadSafe.class

org/junit/runner/notification/RunNotifier$4.class

org/junit/runner/notification/SynchronizedRunListener.class

org/junit/runner/notification/RunNotifier$SafeNotifier.class

org/junit/runner/notification/RunNotifier$5.class

org/junit/runner/notification/StoppedByUserException.class

org/junit/runner/notification/RunNotifier$6.class

org/junit/runner/notification/RunNotifier$7.class

org/junit/runner/notification/RunListener.class

org/junit/runner/Description.class

org/junit/runner/Computer.class

org/junit/validator/AnnotationsValidator$FieldValidator.class

org/junit/validator/TestClassValidator.class

org/junit/validator/ValidateWith.class

org/junit/validator/AnnotationsValidator$AnnotatableValidator.class

org/junit/validator/AnnotationsValidator$MethodValidator.class

org/junit/validator/AnnotationsValidator$ClassValidator.class

org/junit/validator/AnnotationValidatorFactory.class

org/junit/validator/AnnotationValidator.class

org/junit/validator/AnnotationsValidator$1.class

org/junit/validator/AnnotationsValidator.class

org/junit/validator/PublicClassValidator.class

org/junit/ComparisonFailure$1.class

org/junit/Ignore.class

org/junit/BeforeClass.class

org/junit/Before.class

org/junit/Test.class

org/junit/AfterClass.class

org/junit/FixMethodOrder.class

org/junit/ComparisonFailure$ComparisonCompactor.class

org/junit/internal/ExactComparisonCriteria.class

org/junit/internal/matchers/ThrowableMessageMatcher.class

org/junit/internal/matchers/TypeSafeMatcher.class

org/junit/internal/matchers/StacktracePrintingMatcher.class

org/junit/internal/matchers/ThrowableCauseMatcher.class

org/junit/internal/ArrayComparisonFailure.class

org/junit/internal/InexactComparisonCriteria.class

org/junit/internal/TextListener.class

org/junit/internal/MethodSorter.class

org/junit/internal/JUnitSystem.class

org/junit/internal/runners/JUnit38ClassRunner$OldTestClassAdaptingListener.class

org/junit/internal/runners/JUnit4ClassRunner$1.class

org/junit/internal/runners/MethodRoadie$2.class

org/junit/internal/runners/TestMethod.class

org/junit/internal/runners/rules/RuleMemberValidator.class

org/junit/internal/runners/rules/RuleMemberValidator$MethodMustBeARule.class

org/junit/internal/runners/rules/RuleMemberValidator$MemberMustBePublic.class

org/junit/internal/runners/rules/ValidationError.class

org/junit/internal/runners/rules/RuleMemberValidator$MemberMustBeStatic.class

org/junit/internal/runners/rules/RuleMemberValidator$Builder.class

org/junit/internal/runners/rules/RuleMemberValidator$MemberMustBeNonStaticOrAlsoClassRule.class

org/junit/internal/runners/rules/RuleMemberValidator$FieldMustBeARule.class

org/junit/internal/runners/rules/RuleMemberValidator$MethodMustBeATestRule.class

org/junit/internal/runners/rules/RuleMemberValidator$RuleValidator.class

org/junit/internal/runners/rules/RuleMemberValidator$1.class

org/junit/internal/runners/rules/RuleMemberValidator$DeclaringClassMustBePublic.class

org/junit/internal/runners/rules/RuleMemberValidator$FieldMustBeATestRule.class

org/junit/internal/runners/MethodRoadie$1.class

org/junit/internal/runners/TestClass.class

org/junit/internal/runners/ErrorReportingRunner.class

org/junit/internal/runners/JUnit4ClassRunner.class

org/junit/internal/runners/FailedBefore.class

org/junit/internal/runners/statements/FailOnTimeout$1.class

org/junit/internal/runners/statements/Fail.class

org/junit/internal/runners/statements/FailOnTimeout.class

org/junit/internal/runners/statements/RunAfters.class

org/junit/internal/runners/statements/RunBefores.class

org/junit/internal/runners/statements/ExpectException.class

org/junit/internal/runners/statements/InvokeMethod.class

org/junit/internal/runners/statements/FailOnTimeout$Builder.class

org/junit/internal/runners/statements/FailOnTimeout$CallableStatement.class

org/junit/internal/runners/JUnit4ClassRunner$2.class

org/junit/internal/runners/MethodValidator.class

org/junit/internal/runners/JUnit38ClassRunner.class

org/junit/internal/runners/SuiteMethod.class

org/junit/internal/runners/MethodRoadie.class

org/junit/internal/runners/InitializationError.class

org/junit/internal/runners/ClassRoadie.class

org/junit/internal/runners/JUnit38ClassRunner$1.class

org/junit/internal/runners/MethodRoadie$1$1.class

org/junit/internal/runners/model/ReflectiveCallable.class

org/junit/internal/runners/model/EachTestNotifier.class

org/junit/internal/runners/model/MultipleFailureException.class

org/junit/internal/requests/FilterRequest.class

org/junit/internal/requests/ClassRequest.class

org/junit/internal/requests/SortingRequest.class

org/junit/internal/AssumptionViolatedException.class

org/junit/internal/RealSystem.class

org/junit/internal/MethodSorter$2.class

org/junit/internal/ComparisonCriteria.class

org/junit/internal/Throwables.class

org/junit/internal/MethodSorter$1.class

org/junit/internal/Classes.class

org/junit/internal/builders/IgnoredClassRunner.class

org/junit/internal/builders/JUnit4Builder.class

org/junit/internal/builders/AnnotatedBuilder.class

org/junit/internal/builders/IgnoredBuilder.class

org/junit/internal/builders/JUnit3Builder.class

org/junit/internal/builders/AllDefaultPossibilitiesBuilder.class

org/junit/internal/builders/NullBuilder.class

org/junit/internal/builders/SuiteMethodBuilder.class

org/junit/experimental/results/ResultMatchers$1.class

org/junit/experimental/results/ResultMatchers$2.class

org/junit/experimental/results/FailureList.class

org/junit/experimental/results/ResultMatchers$3.class

org/junit/experimental/results/ResultMatchers.class

org/junit/experimental/results/PrintableResult.class

org/junit/experimental/ParallelComputer$1.class

org/junit/experimental/max/MaxHistory$RememberingListener.class

org/junit/experimental/max/MaxCore.class

org/junit/experimental/max/MaxHistory$1.class

org/junit/experimental/max/MaxHistory$TestComparator.class

org/junit/experimental/max/MaxCore$1.class

org/junit/experimental/max/MaxCore$1$1.class

org/junit/experimental/max/CouldNotReadCoreException.class

org/junit/experimental/max/MaxHistory.class

org/junit/experimental/ParallelComputer.class

org/junit/experimental/theories/ParameterSignature.class

org/junit/experimental/theories/Theories$TheoryAnchor$2.class

org/junit/experimental/theories/Theories$TheoryAnchor.class

org/junit/experimental/theories/Theory.class

org/junit/experimental/theories/PotentialAssignment$1.class

org/junit/experimental/theories/Theories$TheoryAnchor$1$1.class

org/junit/experimental/theories/FromDataPoints.class

org/junit/experimental/theories/DataPoints.class

org/junit/experimental/theories/suppliers/TestedOnSupplier.class

org/junit/experimental/theories/suppliers/TestedOn.class

org/junit/experimental/theories/Theories$TheoryAnchor$1.class

org/junit/experimental/theories/PotentialAssignment.class

org/junit/experimental/theories/ParametersSuppliedBy.class

org/junit/experimental/theories/Theories.class

org/junit/experimental/theories/DataPoint.class

org/junit/experimental/theories/internal/AllMembersSupplier$MethodParameterValue.class

org/junit/experimental/theories/internal/AllMembersSupplier.class

org/junit/experimental/theories/internal/EnumSupplier.class

org/junit/experimental/theories/internal/Assignments.class

org/junit/experimental/theories/internal/SpecificDataPointsSupplier.class

org/junit/experimental/theories/internal/BooleanSupplier.class

org/junit/experimental/theories/internal/AllMembersSupplier$1.class

org/junit/experimental/theories/internal/ParameterizedAssertionError.class

org/junit/experimental/theories/PotentialAssignment$CouldNotGenerateValueException.class

org/junit/experimental/theories/ParameterSupplier.class

org/junit/experimental/categories/ExcludeCategories$ExcludesAny.class

org/junit/experimental/categories/IncludeCategories.class

org/junit/experimental/categories/ExcludeCategories.class

org/junit/experimental/categories/Categories$CategoryFilter.class

org/junit/experimental/categories/Categories$ExcludeCategory.class

org/junit/experimental/categories/CategoryValidator.class

org/junit/experimental/categories/IncludeCategories$IncludesAny.class

org/junit/experimental/categories/Category.class

org/junit/experimental/categories/CategoryFilterFactory.class

org/junit/experimental/categories/Categories.class

org/junit/experimental/categories/Categories$IncludeCategory.class

org/junit/experimental/runners/Enclosed.class

org/junit/Rule.class

junit/framework/TestCase.class

junit/framework/TestResult.class

junit/framework/TestFailure.class

junit/framework/JUnit4TestAdapter.class

junit/framework/TestResult$1.class

junit/framework/TestSuite$1.class

junit/framework/AssertionFailedError.class

junit/framework/TestSuite.class

junit/framework/ComparisonCompactor.class

junit/framework/JUnit4TestAdapterCache.class

junit/framework/Assert.class

junit/framework/ComparisonFailure.class

junit/framework/JUnit4TestCaseFacade.class

junit/framework/TestListener.class

junit/framework/Protectable.class

junit/framework/JUnit4TestAdapterCache$1.class

junit/framework/Test.class

junit/runner/Version.class

junit/runner/smalllogo.gif

junit/runner/logo.gif

junit/runner/TestRunListener.class

junit/runner/BaseTestRunner.class

junit/extensions/TestDecorator.class

junit/extensions/ActiveTestSuite$1.class

junit/extensions/TestSetup.class

junit/extensions/ActiveTestSuite.class

junit/extensions/TestSetup$1.class

junit/extensions/RepeatedTest.class

junit/textui/TestRunner.class

junit/textui/ResultPrinter.class

LICENSE-junit.txt

Manifest-Version: 1.0
Implementation-Vendor: JUnit
Implementation-Title: JUnit
Implementation-Version: 4.12
Implementation-Vendor-Id: junit
Built-By: jenkins
Build-Jdk: 1.6.0_45
Created-By: Apache Maven 3.0.4
Archiver-Version: Plexus Archiver

ClassRule

package org.junit;
public abstract interface ClassRule extends annotation.Annotation {
}

Assert

package org.junit;
public synchronized class Assert {
protected void Assert();
public static void assertTrue(String, boolean);
public static void assertTrue(boolean);
public static void assertFalse(String, boolean);
public static void assertFalse(boolean);
public static void fail(String);
public static void fail();
public static void assertEquals(String, Object, Object);
private static boolean equalsRegardingNull(Object, Object);
private static boolean isEquals(Object, Object);
public static void assertEquals(Object, Object);
public static void assertNotEquals(String, Object, Object);
public static void assertNotEquals(Object, Object);
private static void failEquals(String, Object);
public static void assertNotEquals(String, long, long);
public static void assertNotEquals(long, long);
public static void assertNotEquals(String, double, double, double);
public static void assertNotEquals(double, double, double);
public static void assertNotEquals(float, float, float);
public static void assertArrayEquals(String, Object[], Object[]) throws internal.ArrayComparisonFailure;
public static void assertArrayEquals(Object[], Object[]);
public static void assertArrayEquals(String, boolean[], boolean[]) throws internal.ArrayComparisonFailure;
public static void assertArrayEquals(boolean[], boolean[]);
public static void assertArrayEquals(String, byte[], byte[]) throws internal.ArrayComparisonFailure;
public static void assertArrayEquals(byte[], byte[]);
public static void assertArrayEquals(String, char[], char[]) throws internal.ArrayComparisonFailure;
public static void assertArrayEquals(char[], char[]);
public static void assertArrayEquals(String, short[], short[]) throws internal.ArrayComparisonFailure;
public static void assertArrayEquals(short[], short[]);
public static void assertArrayEquals(String, int[], int[]) throws internal.ArrayComparisonFailure;
public static void assertArrayEquals(int[], int[]);
public static void assertArrayEquals(String, long[], long[]) throws internal.ArrayComparisonFailure;
public static void assertArrayEquals(long[], long[]);
public static void assertArrayEquals(String, double[], double[], double) throws internal.ArrayComparisonFailure;
public static void assertArrayEquals(double[], double[], double);
public static void assertArrayEquals(String, float[], float[], float) throws internal.ArrayComparisonFailure;
public static void assertArrayEquals(float[], float[], float);
private static void internalArrayEquals(String, Object, Object) throws internal.ArrayComparisonFailure;
public static void assertEquals(String, double, double, double);
public static void assertEquals(String, float, float, float);
public static void assertNotEquals(String, float, float, float);
private static boolean doubleIsDifferent(double, double, double);
private static boolean floatIsDifferent(float, float, float);
public static void assertEquals(long, long);
public static void assertEquals(String, long, long);
public static void assertEquals(double, double);
public static void assertEquals(String, double, double);
public static void assertEquals(double, double, double);
public static void assertEquals(float, float, float);
public static void assertNotNull(String, Object);
public static void assertNotNull(Object);
public static void assertNull(String, Object);
public static void assertNull(Object);
private static void failNotNull(String, Object);
public static void assertSame(String, Object, Object);
public static void assertSame(Object, Object);
public static void assertNotSame(String, Object, Object);
public static void assertNotSame(Object, Object);
private static void failSame(String);
private static void failNotSame(String, Object, Object);
private static void failNotEquals(String, Object, Object);
static String format(String, Object, Object);
private static String formatClassAndValue(Object, String);
public static void assertEquals(String, Object[], Object[]);
public static void assertEquals(Object[], Object[]);
public static void assertThat(Object, org.hamcrest.Matcher);
public static void assertThat(String, Object, org.hamcrest.Matcher);
}

After

package org.junit;
public abstract interface After extends annotation.Annotation {
}

Stopwatch$Clock

package org.junit.rules;
synchronized class Stopwatch$Clock {
void Stopwatch$Clock();
public long nanoTime();
}

DisableOnDebug

package org.junit.rules;
public synchronized class DisableOnDebug implements TestRule {
private final TestRule rule;
private final boolean debugging;
public void DisableOnDebug(TestRule);
void DisableOnDebug(TestRule, java.util.List);
public org.junit.runners.model.Statement apply(org.junit.runners.model.Statement, org.junit.runner.Description);
private static boolean isDebugging(java.util.List);
public boolean isDebugging();
}

ExternalResource

package org.junit.rules;
public abstract synchronized class ExternalResource implements TestRule {
public void ExternalResource();
public org.junit.runners.model.Statement apply(org.junit.runners.model.Statement, org.junit.runner.Description);
private org.junit.runners.model.Statement statement(org.junit.runners.model.Statement);
protected void before() throws Throwable;
protected void after();
}

TestWatcher$1

package org.junit.rules;
synchronized class TestWatcher$1 extends org.junit.runners.model.Statement {
void TestWatcher$1(TestWatcher, org.junit.runner.Description, org.junit.runners.model.Statement) throws Exception;
public void evaluate() throws Throwable;
}

TemporaryFolder

package org.junit.rules;
public synchronized class TemporaryFolder extends ExternalResource {
private final java.io.File parentFolder;
private java.io.File folder;
public void TemporaryFolder();
public void TemporaryFolder(java.io.File);
protected void before() throws Throwable;
protected void after();
public void create() throws java.io.IOException;
public java.io.File newFile(String) throws java.io.IOException;
public java.io.File newFile() throws java.io.IOException;
public java.io.File newFolder(String) throws java.io.IOException;
public transient java.io.File newFolder(String[]) throws java.io.IOException;
private void validateFolderName(String) throws java.io.IOException;
private boolean isLastElementInArray(int, String[]);
public java.io.File newFolder() throws java.io.IOException;
private java.io.File createTemporaryFolderIn(java.io.File) throws java.io.IOException;
public java.io.File getRoot();
public void delete();
private void recursiveDelete(java.io.File);
}

Timeout$Builder

package org.junit.rules;
public synchronized class Timeout$Builder {
private boolean lookForStuckThread;
private long timeout;
private java.util.concurrent.TimeUnit timeUnit;
protected void Timeout$Builder();
public Timeout$Builder withTimeout(long, java.util.concurrent.TimeUnit);
protected long getTimeout();
protected java.util.concurrent.TimeUnit getTimeUnit();
public Timeout$Builder withLookingForStuckThread(boolean);
protected boolean getLookingForStuckThread();
public Timeout build();
}

RunRules

package org.junit.rules;
public synchronized class RunRules extends org.junit.runners.model.Statement {
private final org.junit.runners.model.Statement statement;
public void RunRules(org.junit.runners.model.Statement, Iterable, org.junit.runner.Description);
public void evaluate() throws Throwable;
private static org.junit.runners.model.Statement applyAll(org.junit.runners.model.Statement, Iterable, org.junit.runner.Description);
}

TestWatchman$1

package org.junit.rules;
synchronized class TestWatchman$1 extends org.junit.runners.model.Statement {
void TestWatchman$1(TestWatchman, org.junit.runners.model.FrameworkMethod, org.junit.runners.model.Statement) throws Throwable;
public void evaluate() throws Throwable;
}

Verifier$1

package org.junit.rules;
synchronized class Verifier$1 extends org.junit.runners.model.Statement {
void Verifier$1(Verifier, org.junit.runners.model.Statement) throws Throwable;
public void evaluate() throws Throwable;
}

ExpectedException

package org.junit.rules;
public synchronized class ExpectedException implements TestRule {
private final ExpectedExceptionMatcherBuilder matcherBuilder;
private String missingExceptionMessage;
public static ExpectedException none();
private void ExpectedException();
public ExpectedException handleAssertionErrors();
public ExpectedException handleAssumptionViolatedExceptions();
public ExpectedException reportMissingExceptionWithMessage(String);
public org.junit.runners.model.Statement apply(org.junit.runners.model.Statement, org.junit.runner.Description);
public void expect(org.hamcrest.Matcher);
public void expect(Class);
public void expectMessage(String);
public void expectMessage(org.hamcrest.Matcher);
public void expectCause(org.hamcrest.Matcher);
private void handleException(Throwable) throws Throwable;
private boolean isAnyExceptionExpected();
private void failDueToMissingException() throws AssertionError;
private String missingExceptionMessage();
}

ExpectedException$ExpectedExceptionStatement

package org.junit.rules;
synchronized class ExpectedException$ExpectedExceptionStatement extends org.junit.runners.model.Statement {
private final org.junit.runners.model.Statement next;
public void ExpectedException$ExpectedExceptionStatement(ExpectedException, org.junit.runners.model.Statement);
public void evaluate() throws Throwable;
}

RuleChain

package org.junit.rules;
public synchronized class RuleChain implements TestRule {
private static final RuleChain EMPTY_CHAIN;
private java.util.List rulesStartingWithInnerMost;
public static RuleChain emptyRuleChain();
public static RuleChain outerRule(TestRule);
private void RuleChain(java.util.List);
public RuleChain around(TestRule);
public org.junit.runners.model.Statement apply(org.junit.runners.model.Statement, org.junit.runner.Description);
static void ();
}

ErrorCollector$1

package org.junit.rules;
synchronized class ErrorCollector$1 implements java.util.concurrent.Callable {
void ErrorCollector$1(ErrorCollector, String, Object, org.hamcrest.Matcher);
public Object call() throws Exception;
}

TestRule

package org.junit.rules;
public abstract interface TestRule {
public abstract org.junit.runners.model.Statement apply(org.junit.runners.model.Statement, org.junit.runner.Description);
}

Verifier

package org.junit.rules;
public abstract synchronized class Verifier implements TestRule {
public void Verifier();
public org.junit.runners.model.Statement apply(org.junit.runners.model.Statement, org.junit.runner.Description);
protected void verify() throws Throwable;
}

Stopwatch

package org.junit.rules;
public abstract synchronized class Stopwatch implements TestRule {
private final Stopwatch$Clock clock;
private volatile long startNanos;
private volatile long endNanos;
public void Stopwatch();
void Stopwatch(Stopwatch$Clock);
public long runtime(java.util.concurrent.TimeUnit);
protected void succeeded(long, org.junit.runner.Description);
protected void failed(long, Throwable, org.junit.runner.Description);
protected void skipped(long, org.junit.AssumptionViolatedException, org.junit.runner.Description);
protected void finished(long, org.junit.runner.Description);
private long getNanos();
private void starting();
private void stopping();
public final org.junit.runners.model.Statement apply(org.junit.runners.model.Statement, org.junit.runner.Description);
}

Stopwatch$1

package org.junit.rules;
synchronized class Stopwatch$1 {
}

Timeout

package org.junit.rules;
public synchronized class Timeout implements TestRule {
private final long timeout;
private final java.util.concurrent.TimeUnit timeUnit;
private final boolean lookForStuckThread;
public static Timeout$Builder builder();
public void Timeout(int);
public void Timeout(long, java.util.concurrent.TimeUnit);
protected void Timeout(Timeout$Builder);
public static Timeout millis(long);
public static Timeout seconds(long);
protected final long getTimeout(java.util.concurrent.TimeUnit);
protected final boolean getLookingForStuckThread();
protected org.junit.runners.model.Statement createFailOnTimeoutStatement(org.junit.runners.model.Statement) throws Exception;
public org.junit.runners.model.Statement apply(org.junit.runners.model.Statement, org.junit.runner.Description);
}

ExpectedExceptionMatcherBuilder

package org.junit.rules;
synchronized class ExpectedExceptionMatcherBuilder {
private final java.util.List matchers;
void ExpectedExceptionMatcherBuilder();
void add(org.hamcrest.Matcher);
boolean expectsThrowable();
org.hamcrest.Matcher build();
private org.hamcrest.Matcher allOfTheMatchers();
private java.util.List castedMatchers();
private org.hamcrest.Matcher cast(org.hamcrest.Matcher);
}

MethodRule

package org.junit.rules;
public abstract interface MethodRule {
public abstract org.junit.runners.model.Statement apply(org.junit.runners.model.Statement, org.junit.runners.model.FrameworkMethod, Object);
}

Timeout$1

package org.junit.rules;
synchronized class Timeout$1 extends org.junit.runners.model.Statement {
void Timeout$1(Timeout, Exception);
public void evaluate() throws Throwable;
}

ExternalResource$1

package org.junit.rules;
synchronized class ExternalResource$1 extends org.junit.runners.model.Statement {
void ExternalResource$1(ExternalResource, org.junit.runners.model.Statement) throws Throwable;
public void evaluate() throws Throwable;
}

TestWatchman

package org.junit.rules;
public synchronized class TestWatchman implements MethodRule {
public void TestWatchman();
public org.junit.runners.model.Statement apply(org.junit.runners.model.Statement, org.junit.runners.model.FrameworkMethod, Object);
public void succeeded(org.junit.runners.model.FrameworkMethod);
public void failed(Throwable, org.junit.runners.model.FrameworkMethod);
public void starting(org.junit.runners.model.FrameworkMethod);
public void finished(org.junit.runners.model.FrameworkMethod);
}

ErrorCollector

package org.junit.rules;
public synchronized class ErrorCollector extends Verifier {
private java.util.List errors;
public void ErrorCollector();
protected void verify() throws Throwable;
public void addError(Throwable);
public void checkThat(Object, org.hamcrest.Matcher);
public void checkThat(String, Object, org.hamcrest.Matcher);
public Object checkSucceeds(java.util.concurrent.Callable);
}

TestWatcher

package org.junit.rules;
public abstract synchronized class TestWatcher implements TestRule {
public void TestWatcher();
public org.junit.runners.model.Statement apply(org.junit.runners.model.Statement, org.junit.runner.Description);
private void succeededQuietly(org.junit.runner.Description, java.util.List);
private void failedQuietly(Throwable, org.junit.runner.Description, java.util.List);
private void skippedQuietly(org.junit.internal.AssumptionViolatedException, org.junit.runner.Description, java.util.List);
private void startingQuietly(org.junit.runner.Description, java.util.List);
private void finishedQuietly(org.junit.runner.Description, java.util.List);
protected void succeeded(org.junit.runner.Description);
protected void failed(Throwable, org.junit.runner.Description);
protected void skipped(org.junit.AssumptionViolatedException, org.junit.runner.Description);
protected void skipped(org.junit.internal.AssumptionViolatedException, org.junit.runner.Description);
protected void starting(org.junit.runner.Description);
protected void finished(org.junit.runner.Description);
}

Stopwatch$InternalWatcher

package org.junit.rules;
synchronized class Stopwatch$InternalWatcher extends TestWatcher {
private void Stopwatch$InternalWatcher(Stopwatch);
protected void starting(org.junit.runner.Description);
protected void finished(org.junit.runner.Description);
protected void succeeded(org.junit.runner.Description);
protected void failed(Throwable, org.junit.runner.Description);
protected void skipped(org.junit.AssumptionViolatedException, org.junit.runner.Description);
}

TestName

package org.junit.rules;
public synchronized class TestName extends TestWatcher {
private String name;
public void TestName();
protected void starting(org.junit.runner.Description);
public String getMethodName();
}

AssumptionViolatedException

package org.junit;
public synchronized class AssumptionViolatedException extends internal.AssumptionViolatedException {
private static final long serialVersionUID = 1;
public void AssumptionViolatedException(Object, org.hamcrest.Matcher);
public void AssumptionViolatedException(String, Object, org.hamcrest.Matcher);
public void AssumptionViolatedException(String);
public void AssumptionViolatedException(String, Throwable);
}

ComparisonFailure$ComparisonCompactor$DiffExtractor

package org.junit;
synchronized class ComparisonFailure$ComparisonCompactor$DiffExtractor {
private final String sharedPrefix;
private final String sharedSuffix;
private void ComparisonFailure$ComparisonCompactor$DiffExtractor(ComparisonFailure$ComparisonCompactor);
public String expectedDiff();
public String actualDiff();
public String compactPrefix();
public String compactSuffix();
private String extractDiff(String);
}

Assume

package org.junit;
public synchronized class Assume {
public void Assume();
public static void assumeTrue(boolean);
public static void assumeFalse(boolean);
public static void assumeTrue(String, boolean);
public static void assumeFalse(String, boolean);
public static transient void assumeNotNull(Object[]);
public static void assumeThat(Object, org.hamcrest.Matcher);
public static void assumeThat(String, Object, org.hamcrest.Matcher);
public static void assumeNoException(Throwable);
public static void assumeNoException(String, Throwable);
}

AllTests

package org.junit.runners;
public synchronized class AllTests extends org.junit.internal.runners.SuiteMethod {
public void AllTests(Class) throws Throwable;
}

Suite$SuiteClasses

package org.junit.runners;
public abstract interface Suite$SuiteClasses extends annotation.Annotation {
public abstract Class[] value();
}

JUnit4

package org.junit.runners;
public final synchronized class JUnit4 extends BlockJUnit4ClassRunner {
public void JUnit4(Class) throws model.InitializationError;
}

ParentRunner$1

package org.junit.runners;
synchronized class ParentRunner$1 implements model.RunnerScheduler {
void ParentRunner$1(ParentRunner);
public void schedule(Runnable);
public void finished();
}

BlockJUnit4ClassRunner

package org.junit.runners;
public synchronized class BlockJUnit4ClassRunner extends ParentRunner {
private final java.util.concurrent.ConcurrentHashMap methodDescriptions;
public void BlockJUnit4ClassRunner(Class) throws model.InitializationError;
protected void runChild(model.FrameworkMethod, org.junit.runner.notification.RunNotifier);
protected boolean isIgnored(model.FrameworkMethod);
protected org.junit.runner.Description describeChild(model.FrameworkMethod);
protected java.util.List getChildren();
protected java.util.List computeTestMethods();
protected void collectInitializationErrors(java.util.List);
protected void validateNoNonStaticInnerClass(java.util.List);
protected void validateConstructor(java.util.List);
protected void validateOnlyOneConstructor(java.util.List);
protected void validateZeroArgConstructor(java.util.List);
private boolean hasOneConstructor();
protected void validateInstanceMethods(java.util.List);
protected void validateFields(java.util.List);
private void validateMethods(java.util.List);
protected void validateTestMethods(java.util.List);
protected Object createTest() throws Exception;
protected String testName(model.FrameworkMethod);
protected model.Statement methodBlock(model.FrameworkMethod);
protected model.Statement methodInvoker(model.FrameworkMethod, Object);
protected model.Statement possiblyExpectingExceptions(model.FrameworkMethod, Object, model.Statement);
protected model.Statement withPotentialTimeout(model.FrameworkMethod, Object, model.Statement);
protected model.Statement withBefores(model.FrameworkMethod, Object, model.Statement);
protected model.Statement withAfters(model.FrameworkMethod, Object, model.Statement);
private model.Statement withRules(model.FrameworkMethod, Object, model.Statement);
private model.Statement withMethodRules(model.FrameworkMethod, java.util.List, Object, model.Statement);
private java.util.List getMethodRules(Object);
protected java.util.List rules(Object);
private model.Statement withTestRules(model.FrameworkMethod, java.util.List, model.Statement);
protected java.util.List getTestRules(Object);
private Class getExpectedException(org.junit.Test);
private boolean expectsException(org.junit.Test);
private long getTimeout(org.junit.Test);
}

Parameterized$Parameters

package org.junit.runners;
public abstract interface Parameterized$Parameters extends annotation.Annotation {
public abstract String name();
}

MethodSorters

package org.junit.runners;
public final synchronized enum MethodSorters {
public static final MethodSorters NAME_ASCENDING;
public static final MethodSorters JVM;
public static final MethodSorters DEFAULT;
private final java.util.Comparator comparator;
public static final MethodSorters[] values();
public static MethodSorters valueOf(String);
private void MethodSorters(String, int, java.util.Comparator);
public java.util.Comparator getComparator();
static void ();
}

ParentRunner$2

package org.junit.runners;
synchronized class ParentRunner$2 extends model.Statement {
void ParentRunner$2(ParentRunner, org.junit.runner.notification.RunNotifier);
public void evaluate();
}

ParentRunner$3

package org.junit.runners;
synchronized class ParentRunner$3 implements Runnable {
void ParentRunner$3(ParentRunner, Object, org.junit.runner.notification.RunNotifier);
public void run();
}

Parameterized$UseParametersRunnerFactory

package org.junit.runners;
public abstract interface Parameterized$UseParametersRunnerFactory extends annotation.Annotation {
public abstract Class value();
}

ParentRunner$4

package org.junit.runners;
synchronized class ParentRunner$4 implements java.util.Comparator {
void ParentRunner$4(ParentRunner, org.junit.runner.manipulation.Sorter);
public int compare(Object, Object);
}

ParentRunner

package org.junit.runners;
public abstract synchronized class ParentRunner extends org.junit.runner.Runner implements org.junit.runner.manipulation.Filterable, org.junit.runner.manipulation.Sortable {
private static final java.util.List VALIDATORS;
private final Object childrenLock;
private final model.TestClass testClass;
private volatile java.util.Collection filteredChildren;
private volatile model.RunnerScheduler scheduler;
protected void ParentRunner(Class) throws model.InitializationError;
protected model.TestClass createTestClass(Class);
protected abstract java.util.List getChildren();
protected abstract org.junit.runner.Description describeChild(Object);
protected abstract void runChild(Object, org.junit.runner.notification.RunNotifier);
protected void collectInitializationErrors(java.util.List);
private void applyValidators(java.util.List);
protected void validatePublicVoidNoArgMethods(Class, boolean, java.util.List);
private void validateClassRules(java.util.List);
protected model.Statement classBlock(org.junit.runner.notification.RunNotifier);
private boolean areAllChildrenIgnored();
protected model.Statement withBeforeClasses(model.Statement);
protected model.Statement withAfterClasses(model.Statement);
private model.Statement withClassRules(model.Statement);
protected java.util.List classRules();
protected model.Statement childrenInvoker(org.junit.runner.notification.RunNotifier);
protected boolean isIgnored(Object);
private void runChildren(org.junit.runner.notification.RunNotifier);
protected String getName();
public final model.TestClass getTestClass();
protected final void runLeaf(model.Statement, org.junit.runner.Description, org.junit.runner.notification.RunNotifier);
protected annotation.Annotation[] getRunnerAnnotations();
public org.junit.runner.Description getDescription();
public void run(org.junit.runner.notification.RunNotifier);
public void filter(org.junit.runner.manipulation.Filter) throws org.junit.runner.manipulation.NoTestsRemainException;
public void sort(org.junit.runner.manipulation.Sorter);
private void validate() throws model.InitializationError;
private java.util.Collection getFilteredChildren();
private boolean shouldRun(org.junit.runner.manipulation.Filter, Object);
private java.util.Comparator comparator(org.junit.runner.manipulation.Sorter);
public void setScheduler(model.RunnerScheduler);
static void ();
}

BlockJUnit4ClassRunner$1

package org.junit.runners;
synchronized class BlockJUnit4ClassRunner$1 extends org.junit.internal.runners.model.ReflectiveCallable {
void BlockJUnit4ClassRunner$1(BlockJUnit4ClassRunner) throws Exception;
protected Object runReflectiveCall() throws Throwable;
}

Parameterized$Parameter

package org.junit.runners;
public abstract interface Parameterized$Parameter extends annotation.Annotation {
public abstract int value();
}

ParametersRunnerFactory

package org.junit.runners.parameterized;
public abstract interface ParametersRunnerFactory {
public abstract org.junit.runner.Runner createRunnerForTestWithParameters(TestWithParameters) throws org.junit.runners.model.InitializationError;
}

TestWithParameters

package org.junit.runners.parameterized;
public synchronized class TestWithParameters {
private final String name;
private final org.junit.runners.model.TestClass testClass;
private final java.util.List parameters;
public void TestWithParameters(String, org.junit.runners.model.TestClass, java.util.List);
public String getName();
public org.junit.runners.model.TestClass getTestClass();
public java.util.List getParameters();
public int hashCode();
public boolean equals(Object);
public String toString();
private static void notNull(Object, String);
}

BlockJUnit4ClassRunnerWithParameters

package org.junit.runners.parameterized;
public synchronized class BlockJUnit4ClassRunnerWithParameters extends org.junit.runners.BlockJUnit4ClassRunner {
private final Object[] parameters;
private final String name;
public void BlockJUnit4ClassRunnerWithParameters(TestWithParameters) throws org.junit.runners.model.InitializationError;
public Object createTest() throws Exception;
private Object createTestUsingConstructorInjection() throws Exception;
private Object createTestUsingFieldInjection() throws Exception;
protected String getName();
protected String testName(org.junit.runners.model.FrameworkMethod);
protected void validateConstructor(java.util.List);
protected void validateFields(java.util.List);
protected org.junit.runners.model.Statement classBlock(org.junit.runner.notification.RunNotifier);
protected annotation.Annotation[] getRunnerAnnotations();
private java.util.List getAnnotatedFieldsByParameter();
private boolean fieldsAreAnnotated();
}

BlockJUnit4ClassRunnerWithParametersFactory

package org.junit.runners.parameterized;
public synchronized class BlockJUnit4ClassRunnerWithParametersFactory implements ParametersRunnerFactory {
public void BlockJUnit4ClassRunnerWithParametersFactory();
public org.junit.runner.Runner createRunnerForTestWithParameters(TestWithParameters) throws org.junit.runners.model.InitializationError;
}

Suite

package org.junit.runners;
public synchronized class Suite extends ParentRunner {
private final java.util.List runners;
public static org.junit.runner.Runner emptySuite();
private static Class[] getAnnotatedClasses(Class) throws model.InitializationError;
public void Suite(Class, model.RunnerBuilder) throws model.InitializationError;
public void Suite(model.RunnerBuilder, Class[]) throws model.InitializationError;
protected void Suite(Class, Class[]) throws model.InitializationError;
protected void Suite(model.RunnerBuilder, Class, Class[]) throws model.InitializationError;
protected void Suite(Class, java.util.List) throws model.InitializationError;
protected java.util.List getChildren();
protected org.junit.runner.Description describeChild(org.junit.runner.Runner);
protected void runChild(org.junit.runner.Runner, org.junit.runner.notification.RunNotifier);
}

MultipleFailureException

package org.junit.runners.model;
public synchronized class MultipleFailureException extends Exception {
private static final long serialVersionUID = 1;
private final java.util.List fErrors;
public void MultipleFailureException(java.util.List);
public java.util.List getFailures();
public String getMessage();
public static void assertEmpty(java.util.List) throws Exception;
}

RunnerScheduler

package org.junit.runners.model;
public abstract interface RunnerScheduler {
public abstract void schedule(Runnable);
public abstract void finished();
}

NoGenericTypeParametersValidator

package org.junit.runners.model;
synchronized class NoGenericTypeParametersValidator {
private final reflect.Method method;
void NoGenericTypeParametersValidator(reflect.Method);
void validate(java.util.List);
private void validateNoTypeParameterOnType(reflect.Type, java.util.List);
private void validateNoTypeParameterOnParameterizedType(reflect.ParameterizedType, java.util.List);
private void validateNoTypeParameterOnWildcardType(reflect.WildcardType, java.util.List);
private void validateNoTypeParameterOnGenericArrayType(reflect.GenericArrayType, java.util.List);
}

TestClass$1

package org.junit.runners.model;
synchronized class TestClass$1 {
}

RunnerBuilder

package org.junit.runners.model;
public abstract synchronized class RunnerBuilder {
private final java.util.Set parents;
public void RunnerBuilder();
public abstract org.junit.runner.Runner runnerForClass(Class) throws Throwable;
public org.junit.runner.Runner safeRunnerForClass(Class);
Class addParent(Class) throws InitializationError;
void removeParent(Class);
public java.util.List runners(Class, Class[]) throws InitializationError;
public java.util.List runners(Class, java.util.List) throws InitializationError;
private java.util.List runners(Class[]);
}

Annotatable

package org.junit.runners.model;
public abstract interface Annotatable {
public abstract annotation.Annotation[] getAnnotations();
public abstract annotation.Annotation getAnnotation(Class);
}

FrameworkField

package org.junit.runners.model;
public synchronized class FrameworkField extends FrameworkMember {
private final reflect.Field field;
void FrameworkField(reflect.Field);
public String getName();
public annotation.Annotation[] getAnnotations();
public annotation.Annotation getAnnotation(Class);
public boolean isShadowedBy(FrameworkField);
protected int getModifiers();
public reflect.Field getField();
public Class getType();
public Class getDeclaringClass();
public Object get(Object) throws IllegalArgumentException, IllegalAccessException;
public String toString();
}

Statement

package org.junit.runners.model;
public abstract synchronized class Statement {
public void Statement();
public abstract void evaluate() throws Throwable;
}

TestTimedOutException

package org.junit.runners.model;
public synchronized class TestTimedOutException extends Exception {
private static final long serialVersionUID = 31935685163547539;
private final java.util.concurrent.TimeUnit timeUnit;
private final long timeout;
public void TestTimedOutException(long, java.util.concurrent.TimeUnit);
public long getTimeout();
public java.util.concurrent.TimeUnit getTimeUnit();
}

FrameworkMember

package org.junit.runners.model;
public abstract synchronized class FrameworkMember implements Annotatable {
public void FrameworkMember();
abstract boolean isShadowedBy(FrameworkMember);
boolean isShadowedBy(java.util.List);
protected abstract int getModifiers();
public boolean isStatic();
public boolean isPublic();
public abstract String getName();
public abstract Class getType();
public abstract Class getDeclaringClass();
}

TestClass

package org.junit.runners.model;
public synchronized class TestClass implements Annotatable {
private static final TestClass$FieldComparator FIELD_COMPARATOR;
private static final TestClass$MethodComparator METHOD_COMPARATOR;
private final Class clazz;
private final java.util.Map methodsForAnnotations;
private final java.util.Map fieldsForAnnotations;
public void TestClass(Class);
protected void scanAnnotatedMembers(java.util.Map, java.util.Map);
private static reflect.Field[] getSortedDeclaredFields(Class);
protected static void addToAnnotationLists(FrameworkMember, java.util.Map);
private static java.util.Map makeDeeplyUnmodifiable(java.util.Map);
public java.util.List getAnnotatedMethods();
public java.util.List getAnnotatedMethods(Class);
public java.util.List getAnnotatedFields();
public java.util.List getAnnotatedFields(Class);
private java.util.List collectValues(java.util.Map);
private static java.util.List getAnnotatedMembers(java.util.Map, Class, boolean);
private static boolean runsTopToBottom(Class);
private static java.util.List getSuperClasses(Class);
public Class getJavaClass();
public String getName();
public reflect.Constructor getOnlyConstructor();
public annotation.Annotation[] getAnnotations();
public annotation.Annotation getAnnotation(Class);
public java.util.List getAnnotatedFieldValues(Object, Class, Class);
public java.util.List getAnnotatedMethodValues(Object, Class, Class);
public boolean isPublic();
public boolean isANonStaticInnerClass();
public int hashCode();
public boolean equals(Object);
static void ();
}

TestClass$FieldComparator

package org.junit.runners.model;
synchronized class TestClass$FieldComparator implements java.util.Comparator {
private void TestClass$FieldComparator();
public int compare(reflect.Field, reflect.Field);
}

FrameworkMethod

package org.junit.runners.model;
public synchronized class FrameworkMethod extends FrameworkMember {
private final reflect.Method method;
public void FrameworkMethod(reflect.Method);
public reflect.Method getMethod();
public transient Object invokeExplosively(Object, Object[]) throws Throwable;
public String getName();
public void validatePublicVoidNoArg(boolean, java.util.List);
public void validatePublicVoid(boolean, java.util.List);
protected int getModifiers();
public Class getReturnType();
public Class getType();
public Class getDeclaringClass();
public void validateNoTypeParametersOnArgs(java.util.List);
public boolean isShadowedBy(FrameworkMethod);
public boolean equals(Object);
public int hashCode();
public boolean producesType(reflect.Type);
private Class[] getParameterTypes();
public annotation.Annotation[] getAnnotations();
public annotation.Annotation getAnnotation(Class);
public String toString();
}

TestClass$MethodComparator

package org.junit.runners.model;
synchronized class TestClass$MethodComparator implements java.util.Comparator {
private void TestClass$MethodComparator();
public int compare(FrameworkMethod, FrameworkMethod);
}

InitializationError

package org.junit.runners.model;
public synchronized class InitializationError extends Exception {
private static final long serialVersionUID = 1;
private final java.util.List fErrors;
public void InitializationError(java.util.List);
public void InitializationError(Throwable);
public void InitializationError(String);
public java.util.List getCauses();
}

FrameworkMethod$1

package org.junit.runners.model;
synchronized class FrameworkMethod$1 extends org.junit.internal.runners.model.ReflectiveCallable {
void FrameworkMethod$1(FrameworkMethod, Object, Object[]) throws reflect.InvocationTargetException, IllegalAccessException;
protected Object runReflectiveCall() throws Throwable;
}

Parameterized

package org.junit.runners;
public synchronized class Parameterized extends Suite {
private static final parameterized.ParametersRunnerFactory DEFAULT_FACTORY;
private static final java.util.List NO_RUNNERS;
private final java.util.List runners;
public void Parameterized(Class) throws Throwable;
private parameterized.ParametersRunnerFactory getParametersRunnerFactory(Class) throws InstantiationException, IllegalAccessException;
protected java.util.List getChildren();
private parameterized.TestWithParameters createTestWithNotNormalizedParameters(String, int, Object);
private Iterable allParameters() throws Throwable;
private model.FrameworkMethod getParametersMethod() throws Exception;
private java.util.List createRunnersForParameters(Iterable, String, parameterized.ParametersRunnerFactory) throws model.InitializationError, Exception;
private java.util.List createTestsForParameters(Iterable, String) throws Exception;
private Exception parametersMethodReturnedWrongType() throws Exception;
private static parameterized.TestWithParameters createTestWithParameters(model.TestClass, String, int, Object[]);
static void ();
}

ComparisonFailure

package org.junit;
public synchronized class ComparisonFailure extends AssertionError {
private static final int MAX_CONTEXT_LENGTH = 20;
private static final long serialVersionUID = 1;
private String fExpected;
private String fActual;
public void ComparisonFailure(String, String, String);
public String getMessage();
public String getActual();
public String getExpected();
}

JUnitMatchers

package org.junit.matchers;
public synchronized class JUnitMatchers {
public void JUnitMatchers();
public static org.hamcrest.Matcher hasItem(Object);
public static org.hamcrest.Matcher hasItem(org.hamcrest.Matcher);
public static transient org.hamcrest.Matcher hasItems(Object[]);
public static transient org.hamcrest.Matcher hasItems(org.hamcrest.Matcher[]);
public static org.hamcrest.Matcher everyItem(org.hamcrest.Matcher);
public static org.hamcrest.Matcher containsString(String);
public static org.hamcrest.core.CombinableMatcher$CombinableBothMatcher both(org.hamcrest.Matcher);
public static org.hamcrest.core.CombinableMatcher$CombinableEitherMatcher either(org.hamcrest.Matcher);
public static org.hamcrest.Matcher isThrowable(org.hamcrest.Matcher);
public static org.hamcrest.Matcher isException(org.hamcrest.Matcher);
}

Test$None

package org.junit;
public synchronized class Test$None extends Throwable {
private static final long serialVersionUID = 1;
private void Test$None();
}

FilterFactory

package org.junit.runner;
public abstract interface FilterFactory {
public abstract manipulation.Filter createFilter(FilterFactoryParams) throws FilterFactory$FilterNotCreatedException;
}

Result

package org.junit.runner;
public synchronized class Result implements java.io.Serializable {
private static final long serialVersionUID = 1;
private static final java.io.ObjectStreamField[] serialPersistentFields;
private final java.util.concurrent.atomic.AtomicInteger count;
private final java.util.concurrent.atomic.AtomicInteger ignoreCount;
private final java.util.concurrent.CopyOnWriteArrayList failures;
private final java.util.concurrent.atomic.AtomicLong runTime;
private final java.util.concurrent.atomic.AtomicLong startTime;
private Result$SerializedForm serializedForm;
public void Result();
private void Result(Result$SerializedForm);
public int getRunCount();
public int getFailureCount();
public long getRunTime();
public java.util.List getFailures();
public int getIgnoreCount();
public boolean wasSuccessful();
private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
private void readObject(java.io.ObjectInputStream) throws ClassNotFoundException, java.io.IOException;
private Object readResolve();
public notification.RunListener createListener();
static void ();
}

JUnitCommandLineParseResult$CommandLineParserError

package org.junit.runner;
public synchronized class JUnitCommandLineParseResult$CommandLineParserError extends Exception {
private static final long serialVersionUID = 1;
public void JUnitCommandLineParseResult$CommandLineParserError(String);
}

Result$Listener

package org.junit.runner;
synchronized class Result$Listener extends notification.RunListener {
private void Result$Listener(Result);
public void testRunStarted(Description) throws Exception;
public void testRunFinished(Result) throws Exception;
public void testFinished(Description) throws Exception;
public void testFailure(notification.Failure) throws Exception;
public void testIgnored(Description) throws Exception;
public void testAssumptionFailure(notification.Failure);
}

JUnitCommandLineParseResult

package org.junit.runner;
synchronized class JUnitCommandLineParseResult {
private final java.util.List filterSpecs;
private final java.util.List classes;
private final java.util.List parserErrors;
void JUnitCommandLineParseResult();
public java.util.List getFilterSpecs();
public java.util.List getClasses();
public static JUnitCommandLineParseResult parse(String[]);
private void parseArgs(String[]);
transient String[] parseOptions(String[]);
private String[] copyArray(String[], int, int);
void parseParameters(String[]);
private Request errorReport(Throwable);
public Request createRequest(Computer);
private Request applyFilterSpecs(Request);
}

Describable

package org.junit.runner;
public abstract interface Describable {
public abstract Description getDescription();
}

FilterFactories

package org.junit.runner;
synchronized class FilterFactories {
void FilterFactories();
public static manipulation.Filter createFilterFromFilterSpec(Request, String) throws FilterFactory$FilterNotCreatedException;
public static manipulation.Filter createFilter(String, FilterFactoryParams) throws FilterFactory$FilterNotCreatedException;
public static manipulation.Filter createFilter(Class, FilterFactoryParams) throws FilterFactory$FilterNotCreatedException;
static FilterFactory createFilterFactory(String) throws FilterFactory$FilterNotCreatedException;
static FilterFactory createFilterFactory(Class) throws FilterFactory$FilterNotCreatedException;
}

Result$SerializedForm

package org.junit.runner;
synchronized class Result$SerializedForm implements java.io.Serializable {
private static final long serialVersionUID = 1;
private final java.util.concurrent.atomic.AtomicInteger fCount;
private final java.util.concurrent.atomic.AtomicInteger fIgnoreCount;
private final java.util.List fFailures;
private final long fRunTime;
private final long fStartTime;
public void Result$SerializedForm(Result);
private void Result$SerializedForm(java.io.ObjectInputStream$GetField) throws java.io.IOException;
public void serialize(java.io.ObjectOutputStream) throws java.io.IOException;
public static Result$SerializedForm deserialize(java.io.ObjectInputStream) throws ClassNotFoundException, java.io.IOException;
}

Runner

package org.junit.runner;
public abstract synchronized class Runner implements Describable {
public void Runner();
public abstract Description getDescription();
public abstract void run(notification.RunNotifier);
public int testCount();
}

RunWith

package org.junit.runner;
public abstract interface RunWith extends annotation.Annotation {
public abstract Class value();
}

NoTestsRemainException

package org.junit.runner.manipulation;
public synchronized class NoTestsRemainException extends Exception {
private static final long serialVersionUID = 1;
public void NoTestsRemainException();
}

Sortable

package org.junit.runner.manipulation;
public abstract interface Sortable {
public abstract void sort(Sorter);
}

Filter

package org.junit.runner.manipulation;
public abstract synchronized class Filter {
public static final Filter ALL;
public void Filter();
public static Filter matchMethodDescription(org.junit.runner.Description);
public abstract boolean shouldRun(org.junit.runner.Description);
public abstract String describe();
public void apply(Object) throws NoTestsRemainException;
public Filter intersect(Filter);
static void ();
}

Filter$2

package org.junit.runner.manipulation;
synchronized class Filter$2 extends Filter {
void Filter$2(org.junit.runner.Description);
public boolean shouldRun(org.junit.runner.Description);
public String describe();
}

Filter$3

package org.junit.runner.manipulation;
synchronized class Filter$3 extends Filter {
void Filter$3(Filter, Filter, Filter);
public boolean shouldRun(org.junit.runner.Description);
public String describe();
}

Sorter

package org.junit.runner.manipulation;
public synchronized class Sorter implements java.util.Comparator {
public static final Sorter NULL;
private final java.util.Comparator comparator;
public void Sorter(java.util.Comparator);
public void apply(Object);
public int compare(org.junit.runner.Description, org.junit.runner.Description);
static void ();
}

Sorter$1

package org.junit.runner.manipulation;
synchronized class Sorter$1 implements java.util.Comparator {
void Sorter$1();
public int compare(org.junit.runner.Description, org.junit.runner.Description);
}

Filterable

package org.junit.runner.manipulation;
public abstract interface Filterable {
public abstract void filter(Filter) throws NoTestsRemainException;
}

Filter$1

package org.junit.runner.manipulation;
synchronized class Filter$1 extends Filter {
void Filter$1();
public boolean shouldRun(org.junit.runner.Description);
public String describe();
public void apply(Object) throws NoTestsRemainException;
public Filter intersect(Filter);
}

JUnitCore

package org.junit.runner;
public synchronized class JUnitCore {
private final notification.RunNotifier notifier;
public void JUnitCore();
public static transient void main(String[]);
public static transient Result runClasses(Class[]);
public static transient Result runClasses(Computer, Class[]);
transient Result runMain(org.junit.internal.JUnitSystem, String[]);
public String getVersion();
public transient Result run(Class[]);
public transient Result run(Computer, Class[]);
public Result run(Request);
public Result run(junit.framework.Test);
public Result run(Runner);
public void addListener(notification.RunListener);
public void removeListener(notification.RunListener);
static Computer defaultComputer();
}

FilterFactory$FilterNotCreatedException

package org.junit.runner;
public synchronized class FilterFactory$FilterNotCreatedException extends Exception {
public void FilterFactory$FilterNotCreatedException(Exception);
}

Result$1

package org.junit.runner;
synchronized class Result$1 {
}

Request

package org.junit.runner;
public abstract synchronized class Request {
public void Request();
public static Request method(Class, String);
public static Request aClass(Class);
public static Request classWithoutSuiteMethod(Class);
public static transient Request classes(Computer, Class[]);
public static transient Request classes(Class[]);
public static Request errorReport(Class, Throwable);
public static Request runner(Runner);
public abstract Runner getRunner();
public Request filterWith(manipulation.Filter);
public Request filterWith(Description);
public Request sortWith(java.util.Comparator);
}

FilterFactoryParams

package org.junit.runner;
public final synchronized class FilterFactoryParams {
private final Description topLevelDescription;
private final String args;
public void FilterFactoryParams(Description, String);
public String getArgs();
public Description getTopLevelDescription();
}

Computer$1

package org.junit.runner;
synchronized class Computer$1 extends org.junit.runners.model.RunnerBuilder {
void Computer$1(Computer, org.junit.runners.model.RunnerBuilder) throws Throwable;
public Runner runnerForClass(Class) throws Throwable;
}

Request$1

package org.junit.runner;
synchronized class Request$1 extends Request {
void Request$1(Runner);
public Runner getRunner();
}

Failure

package org.junit.runner.notification;
public synchronized class Failure implements java.io.Serializable {
private static final long serialVersionUID = 1;
private final org.junit.runner.Description fDescription;
private final Throwable fThrownException;
public void Failure(org.junit.runner.Description, Throwable);
public String getTestHeader();
public org.junit.runner.Description getDescription();
public Throwable getException();
public String toString();
public String getTrace();
public String getMessage();
}

RunNotifier

package org.junit.runner.notification;
public synchronized class RunNotifier {
private final java.util.List listeners;
private volatile boolean pleaseStop;
public void RunNotifier();
public void addListener(RunListener);
public void removeListener(RunListener);
RunListener wrapIfNotThreadSafe(RunListener);
public void fireTestRunStarted(org.junit.runner.Description);
public void fireTestRunFinished(org.junit.runner.Result);
public void fireTestStarted(org.junit.runner.Description) throws StoppedByUserException;
public void fireTestFailure(Failure);
private void fireTestFailures(java.util.List, java.util.List);
public void fireTestAssumptionFailed(Failure);
public void fireTestIgnored(org.junit.runner.Description);
public void fireTestFinished(org.junit.runner.Description);
public void pleaseStop();
public void addFirstListener(RunListener);
}

RunNotifier$1

package org.junit.runner.notification;
synchronized class RunNotifier$1 extends RunNotifier$SafeNotifier {
void RunNotifier$1(RunNotifier, org.junit.runner.Description) throws Exception;
protected void notifyListener(RunListener) throws Exception;
}

RunNotifier$2

package org.junit.runner.notification;
synchronized class RunNotifier$2 extends RunNotifier$SafeNotifier {
void RunNotifier$2(RunNotifier, org.junit.runner.Result) throws Exception;
protected void notifyListener(RunListener) throws Exception;
}

RunNotifier$3

package org.junit.runner.notification;
synchronized class RunNotifier$3 extends RunNotifier$SafeNotifier {
void RunNotifier$3(RunNotifier, org.junit.runner.Description) throws Exception;
protected void notifyListener(RunListener) throws Exception;
}

RunListener$ThreadSafe

package org.junit.runner.notification;
public abstract interface RunListener$ThreadSafe extends annotation.Annotation {
}

RunNotifier$4

package org.junit.runner.notification;
synchronized class RunNotifier$4 extends RunNotifier$SafeNotifier {
void RunNotifier$4(RunNotifier, java.util.List, java.util.List) throws Exception;
protected void notifyListener(RunListener) throws Exception;
}

SynchronizedRunListener

package org.junit.runner.notification;
final synchronized class SynchronizedRunListener extends RunListener {
private final RunListener listener;
private final Object monitor;
void SynchronizedRunListener(RunListener, Object);
public void testRunStarted(org.junit.runner.Description) throws Exception;
public void testRunFinished(org.junit.runner.Result) throws Exception;
public void testStarted(org.junit.runner.Description) throws Exception;
public void testFinished(org.junit.runner.Description) throws Exception;
public void testFailure(Failure) throws Exception;
public void testAssumptionFailure(Failure);
public void testIgnored(org.junit.runner.Description) throws Exception;
public int hashCode();
public boolean equals(Object);
public String toString();
}

RunNotifier$SafeNotifier

package org.junit.runner.notification;
abstract synchronized class RunNotifier$SafeNotifier {
private final java.util.List currentListeners;
void RunNotifier$SafeNotifier(RunNotifier);
void RunNotifier$SafeNotifier(RunNotifier, java.util.List);
void run();
protected abstract void notifyListener(RunListener) throws Exception;
}

RunNotifier$5

package org.junit.runner.notification;
synchronized class RunNotifier$5 extends RunNotifier$SafeNotifier {
void RunNotifier$5(RunNotifier, Failure);
protected void notifyListener(RunListener) throws Exception;
}

StoppedByUserException

package org.junit.runner.notification;
public synchronized class StoppedByUserException extends RuntimeException {
private static final long serialVersionUID = 1;
public void StoppedByUserException();
}

RunNotifier$6

package org.junit.runner.notification;
synchronized class RunNotifier$6 extends RunNotifier$SafeNotifier {
void RunNotifier$6(RunNotifier, org.junit.runner.Description) throws Exception;
protected void notifyListener(RunListener) throws Exception;
}

RunNotifier$7

package org.junit.runner.notification;
synchronized class RunNotifier$7 extends RunNotifier$SafeNotifier {
void RunNotifier$7(RunNotifier, org.junit.runner.Description) throws Exception;
protected void notifyListener(RunListener) throws Exception;
}

RunListener

package org.junit.runner.notification;
public synchronized class RunListener {
public void RunListener();
public void testRunStarted(org.junit.runner.Description) throws Exception;
public void testRunFinished(org.junit.runner.Result) throws Exception;
public void testStarted(org.junit.runner.Description) throws Exception;
public void testFinished(org.junit.runner.Description) throws Exception;
public void testFailure(Failure) throws Exception;
public void testAssumptionFailure(Failure);
public void testIgnored(org.junit.runner.Description) throws Exception;
}

Description

package org.junit.runner;
public synchronized class Description implements java.io.Serializable {
private static final long serialVersionUID = 1;
private static final java.util.regex.Pattern METHOD_AND_CLASS_NAME_PATTERN;
public static final Description EMPTY;
public static final Description TEST_MECHANISM;
private final java.util.Collection fChildren;
private final String fDisplayName;
private final java.io.Serializable fUniqueId;
private final annotation.Annotation[] fAnnotations;
private volatile Class fTestClass;
public static transient Description createSuiteDescription(String, annotation.Annotation[]);
public static transient Description createSuiteDescription(String, java.io.Serializable, annotation.Annotation[]);
public static transient Description createTestDescription(String, String, annotation.Annotation[]);
public static transient Description createTestDescription(Class, String, annotation.Annotation[]);
public static Description createTestDescription(Class, String);
public static Description createTestDescription(String, String, java.io.Serializable);
private static String formatDisplayName(String, String);
public static Description createSuiteDescription(Class);
private transient void Description(Class, String, annotation.Annotation[]);
private transient void Description(Class, String, java.io.Serializable, annotation.Annotation[]);
public String getDisplayName();
public void addChild(Description);
public java.util.ArrayList getChildren();
public boolean isSuite();
public boolean isTest();
public int testCount();
public int hashCode();
public boolean equals(Object);
public String toString();
public boolean isEmpty();
public Description childlessCopy();
public annotation.Annotation getAnnotation(Class);
public java.util.Collection getAnnotations();
public Class getTestClass();
public String getClassName();
public String getMethodName();
private String methodAndClassNamePatternGroupOrDefault(int, String);
static void ();
}

Computer

package org.junit.runner;
public synchronized class Computer {
public void Computer();
public static Computer serial();
public Runner getSuite(org.junit.runners.model.RunnerBuilder, Class[]) throws org.junit.runners.model.InitializationError;
protected Runner getRunner(org.junit.runners.model.RunnerBuilder, Class) throws Throwable;
}

AnnotationsValidator$FieldValidator

package org.junit.validator;
synchronized class AnnotationsValidator$FieldValidator extends AnnotationsValidator$AnnotatableValidator {
private void AnnotationsValidator$FieldValidator();
Iterable getAnnotatablesForTestClass(org.junit.runners.model.TestClass);
java.util.List validateAnnotatable(AnnotationValidator, org.junit.runners.model.FrameworkField);
}

TestClassValidator

package org.junit.validator;
public abstract interface TestClassValidator {
public abstract java.util.List validateTestClass(org.junit.runners.model.TestClass);
}

ValidateWith

package org.junit.validator;
public abstract interface ValidateWith extends annotation.Annotation {
public abstract Class value();
}

AnnotationsValidator$AnnotatableValidator

package org.junit.validator;
abstract synchronized class AnnotationsValidator$AnnotatableValidator {
private static final AnnotationValidatorFactory ANNOTATION_VALIDATOR_FACTORY;
private void AnnotationsValidator$AnnotatableValidator();
abstract Iterable getAnnotatablesForTestClass(org.junit.runners.model.TestClass);
abstract java.util.List validateAnnotatable(AnnotationValidator, org.junit.runners.model.Annotatable);
public java.util.List validateTestClass(org.junit.runners.model.TestClass);
private java.util.List validateAnnotatable(org.junit.runners.model.Annotatable);
static void ();
}

AnnotationsValidator$MethodValidator

package org.junit.validator;
synchronized class AnnotationsValidator$MethodValidator extends AnnotationsValidator$AnnotatableValidator {
private void AnnotationsValidator$MethodValidator();
Iterable getAnnotatablesForTestClass(org.junit.runners.model.TestClass);
java.util.List validateAnnotatable(AnnotationValidator, org.junit.runners.model.FrameworkMethod);
}

AnnotationsValidator$ClassValidator

package org.junit.validator;
synchronized class AnnotationsValidator$ClassValidator extends AnnotationsValidator$AnnotatableValidator {
private void AnnotationsValidator$ClassValidator();
Iterable getAnnotatablesForTestClass(org.junit.runners.model.TestClass);
java.util.List validateAnnotatable(AnnotationValidator, org.junit.runners.model.TestClass);
}

AnnotationValidatorFactory

package org.junit.validator;
public synchronized class AnnotationValidatorFactory {
private static final java.util.concurrent.ConcurrentHashMap VALIDATORS_FOR_ANNOTATION_TYPES;
public void AnnotationValidatorFactory();
public AnnotationValidator createAnnotationValidator(ValidateWith);
static void ();
}

AnnotationValidator

package org.junit.validator;
public abstract synchronized class AnnotationValidator {
private static final java.util.List NO_VALIDATION_ERRORS;
public void AnnotationValidator();
public java.util.List validateAnnotatedClass(org.junit.runners.model.TestClass);
public java.util.List validateAnnotatedField(org.junit.runners.model.FrameworkField);
public java.util.List validateAnnotatedMethod(org.junit.runners.model.FrameworkMethod);
static void ();
}

AnnotationsValidator$1

package org.junit.validator;
synchronized class AnnotationsValidator$1 {
}

AnnotationsValidator

package org.junit.validator;
public final synchronized class AnnotationsValidator implements TestClassValidator {
private static final java.util.List VALIDATORS;
public void AnnotationsValidator();
public java.util.List validateTestClass(org.junit.runners.model.TestClass);
static void ();
}

PublicClassValidator

package org.junit.validator;
public synchronized class PublicClassValidator implements TestClassValidator {
private static final java.util.List NO_VALIDATION_ERRORS;
public void PublicClassValidator();
public java.util.List validateTestClass(org.junit.runners.model.TestClass);
static void ();
}

ComparisonFailure$1

package org.junit;
synchronized class ComparisonFailure$1 {
}

Ignore

package org.junit;
public abstract interface Ignore extends annotation.Annotation {
public abstract String value();
}

BeforeClass

package org.junit;
public abstract interface BeforeClass extends annotation.Annotation {
}

Before

package org.junit;
public abstract interface Before extends annotation.Annotation {
}

Test

package org.junit;
public abstract interface Test extends annotation.Annotation {
public abstract Class expected();
public abstract long timeout();
}

AfterClass

package org.junit;
public abstract interface AfterClass extends annotation.Annotation {
}

FixMethodOrder

package org.junit;
public abstract interface FixMethodOrder extends annotation.Annotation {
public abstract runners.MethodSorters value();
}

ComparisonFailure$ComparisonCompactor

package org.junit;
synchronized class ComparisonFailure$ComparisonCompactor {
private static final String ELLIPSIS = …;
private static final String DIFF_END = ];
private static final String DIFF_START = [;
private final int contextLength;
private final String expected;
private final String actual;
public void ComparisonFailure$ComparisonCompactor(int, String, String);
public String compact(String);
private String sharedPrefix();
private String sharedSuffix(String);
}

ExactComparisonCriteria

package org.junit.internal;
public synchronized class ExactComparisonCriteria extends ComparisonCriteria {
public void ExactComparisonCriteria();
protected void assertElementsEqual(Object, Object);
}

ThrowableMessageMatcher

package org.junit.internal.matchers;
public synchronized class ThrowableMessageMatcher extends org.hamcrest.TypeSafeMatcher {
private final org.hamcrest.Matcher matcher;
public void ThrowableMessageMatcher(org.hamcrest.Matcher);
public void describeTo(org.hamcrest.Description);
protected boolean matchesSafely(Throwable);
protected void describeMismatchSafely(Throwable, org.hamcrest.Description);
public static org.hamcrest.Matcher hasMessage(org.hamcrest.Matcher);
}

TypeSafeMatcher

package org.junit.internal.matchers;
public abstract synchronized class TypeSafeMatcher extends org.hamcrest.BaseMatcher {
private Class expectedType;
public abstract boolean matchesSafely(Object);
protected void TypeSafeMatcher();
private static Class findExpectedType(Class);
private static boolean isMatchesSafelyMethod(reflect.Method);
protected void TypeSafeMatcher(Class);
public final boolean matches(Object);
}

StacktracePrintingMatcher

package org.junit.internal.matchers;
public synchronized class StacktracePrintingMatcher extends org.hamcrest.TypeSafeMatcher {
private final org.hamcrest.Matcher throwableMatcher;
public void StacktracePrintingMatcher(org.hamcrest.Matcher);
public void describeTo(org.hamcrest.Description);
protected boolean matchesSafely(Throwable);
protected void describeMismatchSafely(Throwable, org.hamcrest.Description);
private String readStacktrace(Throwable);
public static org.hamcrest.Matcher isThrowable(org.hamcrest.Matcher);
public static org.hamcrest.Matcher isException(org.hamcrest.Matcher);
}

ThrowableCauseMatcher

package org.junit.internal.matchers;
public synchronized class ThrowableCauseMatcher extends org.hamcrest.TypeSafeMatcher {
private final org.hamcrest.Matcher causeMatcher;
public void ThrowableCauseMatcher(org.hamcrest.Matcher);
public void describeTo(org.hamcrest.Description);
protected boolean matchesSafely(Throwable);
protected void describeMismatchSafely(Throwable, org.hamcrest.Description);
public static org.hamcrest.Matcher hasCause(org.hamcrest.Matcher);
}

ArrayComparisonFailure

package org.junit.internal;
public synchronized class ArrayComparisonFailure extends AssertionError {
private static final long serialVersionUID = 1;
private final java.util.List fIndices;
private final String fMessage;
public void ArrayComparisonFailure(String, AssertionError, int);
public void addDimension(int);
public String getMessage();
public String toString();
}

InexactComparisonCriteria

package org.junit.internal;
public synchronized class InexactComparisonCriteria extends ComparisonCriteria {
public Object fDelta;
public void InexactComparisonCriteria(double);
public void InexactComparisonCriteria(float);
protected void assertElementsEqual(Object, Object);
}

TextListener

package org.junit.internal;
public synchronized class TextListener extends org.junit.runner.notification.RunListener {
private final java.io.PrintStream writer;
public void TextListener(JUnitSystem);
public void TextListener(java.io.PrintStream);
public void testRunFinished(org.junit.runner.Result);
public void testStarted(org.junit.runner.Description);
public void testFailure(org.junit.runner.notification.Failure);
public void testIgnored(org.junit.runner.Description);
private java.io.PrintStream getWriter();
protected void printHeader(long);
protected void printFailures(org.junit.runner.Result);
protected void printFailure(org.junit.runner.notification.Failure, String);
protected void printFooter(org.junit.runner.Result);
protected String elapsedTimeAsString(long);
}

MethodSorter

package org.junit.internal;
public synchronized class MethodSorter {
public static final java.util.Comparator DEFAULT;
public static final java.util.Comparator NAME_ASCENDING;
public static reflect.Method[] getDeclaredMethods(Class);
private void MethodSorter();
private static java.util.Comparator getSorter(org.junit.FixMethodOrder);
static void ();
}

JUnitSystem

package org.junit.internal;
public abstract interface JUnitSystem {
public abstract void exit(int);
public abstract java.io.PrintStream out();
}

JUnit38ClassRunner$OldTestClassAdaptingListener

package org.junit.internal.runners;
final synchronized class JUnit38ClassRunner$OldTestClassAdaptingListener implements junit.framework.TestListener {
private final org.junit.runner.notification.RunNotifier notifier;
private void JUnit38ClassRunner$OldTestClassAdaptingListener(org.junit.runner.notification.RunNotifier);
public void endTest(junit.framework.Test);
public void startTest(junit.framework.Test);
public void addError(junit.framework.Test, Throwable);
private org.junit.runner.Description asDescription(junit.framework.Test);
private Class getEffectiveClass(junit.framework.Test);
private String getName(junit.framework.Test);
public void addFailure(junit.framework.Test, junit.framework.AssertionFailedError);
}

JUnit4ClassRunner$1

package org.junit.internal.runners;
synchronized class JUnit4ClassRunner$1 implements Runnable {
void JUnit4ClassRunner$1(JUnit4ClassRunner, org.junit.runner.notification.RunNotifier);
public void run();
}

MethodRoadie$2

package org.junit.internal.runners;
synchronized class MethodRoadie$2 implements Runnable {
void MethodRoadie$2(MethodRoadie);
public void run();
}

TestMethod

package org.junit.internal.runners;
public synchronized class TestMethod {
private final reflect.Method method;
private TestClass testClass;
public void TestMethod(reflect.Method, TestClass);
public boolean isIgnored();
public long getTimeout();
protected Class getExpectedException();
boolean isUnexpected(Throwable);
boolean expectsException();
java.util.List getBefores();
java.util.List getAfters();
public void invoke(Object) throws IllegalArgumentException, IllegalAccessException, reflect.InvocationTargetException;
}

RuleMemberValidator

package org.junit.internal.runners.rules;
public synchronized class RuleMemberValidator {
public static final RuleMemberValidator CLASS_RULE_VALIDATOR;
public static final RuleMemberValidator RULE_VALIDATOR;
public static final RuleMemberValidator CLASS_RULE_METHOD_VALIDATOR;
public static final RuleMemberValidator RULE_METHOD_VALIDATOR;
private final Class annotation;
private final boolean methods;
private final java.util.List validatorStrategies;
void RuleMemberValidator(RuleMemberValidator$Builder);
public void validate(org.junit.runners.model.TestClass, java.util.List);
private void validateMember(org.junit.runners.model.FrameworkMember, java.util.List);
private static RuleMemberValidator$Builder classRuleValidatorBuilder();
private static RuleMemberValidator$Builder testRuleValidatorBuilder();
private static boolean isRuleType(org.junit.runners.model.FrameworkMember);
private static boolean isTestRule(org.junit.runners.model.FrameworkMember);
private static boolean isMethodRule(org.junit.runners.model.FrameworkMember);
static void ();
}

RuleMemberValidator$MethodMustBeARule

package org.junit.internal.runners.rules;
final synchronized class RuleMemberValidator$MethodMustBeARule implements RuleMemberValidator$RuleValidator {
private void RuleMemberValidator$MethodMustBeARule();
public void validate(org.junit.runners.model.FrameworkMember, Class, java.util.List);
}

RuleMemberValidator$MemberMustBePublic

package org.junit.internal.runners.rules;
final synchronized class RuleMemberValidator$MemberMustBePublic implements RuleMemberValidator$RuleValidator {
private void RuleMemberValidator$MemberMustBePublic();
public void validate(org.junit.runners.model.FrameworkMember, Class, java.util.List);
}

ValidationError

package org.junit.internal.runners.rules;
synchronized class ValidationError extends Exception {
public void ValidationError(org.junit.runners.model.FrameworkMember, Class, String);
}

RuleMemberValidator$MemberMustBeStatic

package org.junit.internal.runners.rules;
final synchronized class RuleMemberValidator$MemberMustBeStatic implements RuleMemberValidator$RuleValidator {
private void RuleMemberValidator$MemberMustBeStatic();
public void validate(org.junit.runners.model.FrameworkMember, Class, java.util.List);
}

RuleMemberValidator$Builder

package org.junit.internal.runners.rules;
synchronized class RuleMemberValidator$Builder {
private final Class annotation;
private boolean methods;
private final java.util.List validators;
private void RuleMemberValidator$Builder(Class);
RuleMemberValidator$Builder forMethods();
RuleMemberValidator$Builder withValidator(RuleMemberValidator$RuleValidator);
RuleMemberValidator build();
}

RuleMemberValidator$MemberMustBeNonStaticOrAlsoClassRule

package org.junit.internal.runners.rules;
final synchronized class RuleMemberValidator$MemberMustBeNonStaticOrAlsoClassRule implements RuleMemberValidator$RuleValidator {
private void RuleMemberValidator$MemberMustBeNonStaticOrAlsoClassRule();
public void validate(org.junit.runners.model.FrameworkMember, Class, java.util.List);
}

RuleMemberValidator$FieldMustBeARule

package org.junit.internal.runners.rules;
final synchronized class RuleMemberValidator$FieldMustBeARule implements RuleMemberValidator$RuleValidator {
private void RuleMemberValidator$FieldMustBeARule();
public void validate(org.junit.runners.model.FrameworkMember, Class, java.util.List);
}

RuleMemberValidator$MethodMustBeATestRule

package org.junit.internal.runners.rules;
final synchronized class RuleMemberValidator$MethodMustBeATestRule implements RuleMemberValidator$RuleValidator {
private void RuleMemberValidator$MethodMustBeATestRule();
public void validate(org.junit.runners.model.FrameworkMember, Class, java.util.List);
}

RuleMemberValidator$RuleValidator

package org.junit.internal.runners.rules;
abstract interface RuleMemberValidator$RuleValidator {
public abstract void validate(org.junit.runners.model.FrameworkMember, Class, java.util.List);
}

RuleMemberValidator$1

package org.junit.internal.runners.rules;
synchronized class RuleMemberValidator$1 {
}

RuleMemberValidator$DeclaringClassMustBePublic

package org.junit.internal.runners.rules;
final synchronized class RuleMemberValidator$DeclaringClassMustBePublic implements RuleMemberValidator$RuleValidator {
private void RuleMemberValidator$DeclaringClassMustBePublic();
public void validate(org.junit.runners.model.FrameworkMember, Class, java.util.List);
private boolean isDeclaringClassPublic(org.junit.runners.model.FrameworkMember);
}

RuleMemberValidator$FieldMustBeATestRule

package org.junit.internal.runners.rules;
final synchronized class RuleMemberValidator$FieldMustBeATestRule implements RuleMemberValidator$RuleValidator {
private void RuleMemberValidator$FieldMustBeATestRule();
public void validate(org.junit.runners.model.FrameworkMember, Class, java.util.List);
}

MethodRoadie$1

package org.junit.internal.runners;
synchronized class MethodRoadie$1 implements Runnable {
void MethodRoadie$1(MethodRoadie, long);
public void run();
}

TestClass

package org.junit.internal.runners;
public synchronized class TestClass {
private final Class klass;
public void TestClass(Class);
public java.util.List getTestMethods();
java.util.List getBefores();
java.util.List getAfters();
public java.util.List getAnnotatedMethods(Class);
private boolean runsTopToBottom(Class);
private boolean isShadowed(reflect.Method, java.util.List);
private boolean isShadowed(reflect.Method, reflect.Method);
private java.util.List getSuperClasses(Class);
public reflect.Constructor getConstructor() throws SecurityException, NoSuchMethodException;
public Class getJavaClass();
public String getName();
}

ErrorReportingRunner

package org.junit.internal.runners;
public synchronized class ErrorReportingRunner extends org.junit.runner.Runner {
private final java.util.List causes;
private final Class testClass;
public void ErrorReportingRunner(Class, Throwable);
public org.junit.runner.Description getDescription();
public void run(org.junit.runner.notification.RunNotifier);
private java.util.List getCauses(Throwable);
private org.junit.runner.Description describeCause(Throwable);
private void runCause(Throwable, org.junit.runner.notification.RunNotifier);
}

JUnit4ClassRunner

package org.junit.internal.runners;
public synchronized class JUnit4ClassRunner extends org.junit.runner.Runner implements org.junit.runner.manipulation.Filterable, org.junit.runner.manipulation.Sortable {
private final java.util.List testMethods;
private TestClass testClass;
public void JUnit4ClassRunner(Class) throws InitializationError;
protected java.util.List getTestMethods();
protected void validate() throws InitializationError;
public void run(org.junit.runner.notification.RunNotifier);
protected void runMethods(org.junit.runner.notification.RunNotifier);
public org.junit.runner.Description getDescription();
protected annotation.Annotation[] classAnnotations();
protected String getName();
protected Object createTest() throws Exception;
protected void invokeTestMethod(reflect.Method, org.junit.runner.notification.RunNotifier);
private void testAborted(org.junit.runner.notification.RunNotifier, org.junit.runner.Description, Throwable);
protected TestMethod wrapMethod(reflect.Method);
protected String testName(reflect.Method);
protected org.junit.runner.Description methodDescription(reflect.Method);
protected annotation.Annotation[] testAnnotations(reflect.Method);
public void filter(org.junit.runner.manipulation.Filter) throws org.junit.runner.manipulation.NoTestsRemainException;
public void sort(org.junit.runner.manipulation.Sorter);
protected TestClass getTestClass();
}

FailedBefore

package org.junit.internal.runners;
synchronized class FailedBefore extends Exception {
private static final long serialVersionUID = 1;
void FailedBefore();
}

FailOnTimeout$1

package org.junit.internal.runners.statements;
synchronized class FailOnTimeout$1 {
}

Fail

package org.junit.internal.runners.statements;
public synchronized class Fail extends org.junit.runners.model.Statement {
private final Throwable error;
public void Fail(Throwable);
public void evaluate() throws Throwable;
}

FailOnTimeout

package org.junit.internal.runners.statements;
public synchronized class FailOnTimeout extends org.junit.runners.model.Statement {
private final org.junit.runners.model.Statement originalStatement;
private final java.util.concurrent.TimeUnit timeUnit;
private final long timeout;
private final boolean lookForStuckThread;
private volatile ThreadGroup threadGroup;
public static FailOnTimeout$Builder builder();
public void FailOnTimeout(org.junit.runners.model.Statement, long);
private void FailOnTimeout(FailOnTimeout$Builder, org.junit.runners.model.Statement);
public void evaluate() throws Throwable;
private Throwable getResult(java.util.concurrent.FutureTask, Thread);
private Exception createTimeoutException(Thread);
private StackTraceElement[] getStackTrace(Thread);
private Thread getStuckThread(Thread);
private Thread[] getThreadArray(ThreadGroup);
private Thread[] copyThreads(Thread[], int);
private long cpuTime(Thread);
}

RunAfters

package org.junit.internal.runners.statements;
public synchronized class RunAfters extends org.junit.runners.model.Statement {
private final org.junit.runners.model.Statement next;
private final Object target;
private final java.util.List afters;
public void RunAfters(org.junit.runners.model.Statement, java.util.List, Object);
public void evaluate() throws Throwable;
}

RunBefores

package org.junit.internal.runners.statements;
public synchronized class RunBefores extends org.junit.runners.model.Statement {
private final org.junit.runners.model.Statement next;
private final Object target;
private final java.util.List befores;
public void RunBefores(org.junit.runners.model.Statement, java.util.List, Object);
public void evaluate() throws Throwable;
}

ExpectException

package org.junit.internal.runners.statements;
public synchronized class ExpectException extends org.junit.runners.model.Statement {
private final org.junit.runners.model.Statement next;
private final Class expected;
public void ExpectException(org.junit.runners.model.Statement, Class);
public void evaluate() throws Exception;
}

InvokeMethod

package org.junit.internal.runners.statements;
public synchronized class InvokeMethod extends org.junit.runners.model.Statement {
private final org.junit.runners.model.FrameworkMethod testMethod;
private final Object target;
public void InvokeMethod(org.junit.runners.model.FrameworkMethod, Object);
public void evaluate() throws Throwable;
}

FailOnTimeout$Builder

package org.junit.internal.runners.statements;
public synchronized class FailOnTimeout$Builder {
private boolean lookForStuckThread;
private long timeout;
private java.util.concurrent.TimeUnit unit;
private void FailOnTimeout$Builder();
public FailOnTimeout$Builder withTimeout(long, java.util.concurrent.TimeUnit);
public FailOnTimeout$Builder withLookingForStuckThread(boolean);
public FailOnTimeout build(org.junit.runners.model.Statement);
}

FailOnTimeout$CallableStatement

package org.junit.internal.runners.statements;
synchronized class FailOnTimeout$CallableStatement implements java.util.concurrent.Callable {
private final java.util.concurrent.CountDownLatch startLatch;
private void FailOnTimeout$CallableStatement(FailOnTimeout);
public Throwable call() throws Exception;
public void awaitStarted() throws InterruptedException;
}

JUnit4ClassRunner$2

package org.junit.internal.runners;
synchronized class JUnit4ClassRunner$2 implements java.util.Comparator {
void JUnit4ClassRunner$2(JUnit4ClassRunner, org.junit.runner.manipulation.Sorter);
public int compare(reflect.Method, reflect.Method);
}

MethodValidator

package org.junit.internal.runners;
public synchronized class MethodValidator {
private final java.util.List errors;
private TestClass testClass;
public void MethodValidator(TestClass);
public void validateInstanceMethods();
public void validateStaticMethods();
public java.util.List validateMethodsForDefaultRunner();
public void assertValid() throws InitializationError;
public void validateNoArgConstructor();
private void validateTestMethods(Class, boolean);
}

JUnit38ClassRunner

package org.junit.internal.runners;
public synchronized class JUnit38ClassRunner extends org.junit.runner.Runner implements org.junit.runner.manipulation.Filterable, org.junit.runner.manipulation.Sortable {
private volatile junit.framework.Test test;
public void JUnit38ClassRunner(Class);
public void JUnit38ClassRunner(junit.framework.Test);
public void run(org.junit.runner.notification.RunNotifier);
public junit.framework.TestListener createAdaptingListener(org.junit.runner.notification.RunNotifier);
public org.junit.runner.Description getDescription();
private static org.junit.runner.Description makeDescription(junit.framework.Test);
private static annotation.Annotation[] getAnnotations(junit.framework.TestCase);
private static String createSuiteDescription(junit.framework.TestSuite);
public void filter(org.junit.runner.manipulation.Filter) throws org.junit.runner.manipulation.NoTestsRemainException;
public void sort(org.junit.runner.manipulation.Sorter);
private void setTest(junit.framework.Test);
private junit.framework.Test getTest();
}

SuiteMethod

package org.junit.internal.runners;
public synchronized class SuiteMethod extends JUnit38ClassRunner {
public void SuiteMethod(Class) throws Throwable;
public static junit.framework.Test testFromSuiteMethod(Class) throws Throwable;
}

MethodRoadie

package org.junit.internal.runners;
public synchronized class MethodRoadie {
private final Object test;
private final org.junit.runner.notification.RunNotifier notifier;
private final org.junit.runner.Description description;
private TestMethod testMethod;
public void MethodRoadie(Object, TestMethod, org.junit.runner.notification.RunNotifier, org.junit.runner.Description);
public void run();
private void runWithTimeout(long);
public void runTest();
public void runBeforesThenTestThenAfters(Runnable);
protected void runTestMethod();
private void runBefores() throws FailedBefore;
private void runAfters();
protected void addFailure(Throwable);
}

InitializationError

package org.junit.internal.runners;
public synchronized class InitializationError extends Exception {
private static final long serialVersionUID = 1;
private final java.util.List fErrors;
public void InitializationError(java.util.List);
public transient void InitializationError(Throwable[]);
public void InitializationError(String);
public java.util.List getCauses();
}

ClassRoadie

package org.junit.internal.runners;
public synchronized class ClassRoadie {
private org.junit.runner.notification.RunNotifier notifier;
private TestClass testClass;
private org.junit.runner.Description description;
private final Runnable runnable;
public void ClassRoadie(org.junit.runner.notification.RunNotifier, TestClass, org.junit.runner.Description, Runnable);
protected void runUnprotected();
protected void addFailure(Throwable);
public void runProtected();
private void runBefores() throws FailedBefore;
private void runAfters();
}

JUnit38ClassRunner$1

package org.junit.internal.runners;
synchronized class JUnit38ClassRunner$1 {
}

MethodRoadie$1$1

package org.junit.internal.runners;
synchronized class MethodRoadie$1$1 implements java.util.concurrent.Callable {
void MethodRoadie$1$1(MethodRoadie$1);
public Object call() throws Exception;
}

ReflectiveCallable

package org.junit.internal.runners.model;
public abstract synchronized class ReflectiveCallable {
public void ReflectiveCallable();
public Object run() throws Throwable;
protected abstract Object runReflectiveCall() throws Throwable;
}

EachTestNotifier

package org.junit.internal.runners.model;
public synchronized class EachTestNotifier {
private final org.junit.runner.notification.RunNotifier notifier;
private final org.junit.runner.Description description;
public void EachTestNotifier(org.junit.runner.notification.RunNotifier, org.junit.runner.Description);
public void addFailure(Throwable);
private void addMultipleFailureException(org.junit.runners.model.MultipleFailureException);
public void addFailedAssumption(org.junit.internal.AssumptionViolatedException);
public void fireTestFinished();
public void fireTestStarted();
public void fireTestIgnored();
}

MultipleFailureException

package org.junit.internal.runners.model;
public synchronized class MultipleFailureException extends org.junit.runners.model.MultipleFailureException {
private static final long serialVersionUID = 1;
public void MultipleFailureException(java.util.List);
}

FilterRequest

package org.junit.internal.requests;
public final synchronized class FilterRequest extends org.junit.runner.Request {
private final org.junit.runner.Request request;
private final org.junit.runner.manipulation.Filter fFilter;
public void FilterRequest(org.junit.runner.Request, org.junit.runner.manipulation.Filter);
public org.junit.runner.Runner getRunner();
}

ClassRequest

package org.junit.internal.requests;
public synchronized class ClassRequest extends org.junit.runner.Request {
private final Object runnerLock;
private final Class fTestClass;
private final boolean canUseSuiteMethod;
private volatile org.junit.runner.Runner runner;
public void ClassRequest(Class, boolean);
public void ClassRequest(Class);
public org.junit.runner.Runner getRunner();
}

SortingRequest

package org.junit.internal.requests;
public synchronized class SortingRequest extends org.junit.runner.Request {
private final org.junit.runner.Request request;
private final java.util.Comparator comparator;
public void SortingRequest(org.junit.runner.Request, java.util.Comparator);
public org.junit.runner.Runner getRunner();
}

AssumptionViolatedException

package org.junit.internal;
public synchronized class AssumptionViolatedException extends RuntimeException implements org.hamcrest.SelfDescribing {
private static final long serialVersionUID = 2;
private final String fAssumption;
private final boolean fValueMatcher;
private final Object fValue;
private final org.hamcrest.Matcher fMatcher;
public void AssumptionViolatedException(String, boolean, Object, org.hamcrest.Matcher);
public void AssumptionViolatedException(Object, org.hamcrest.Matcher);
public void AssumptionViolatedException(String, Object, org.hamcrest.Matcher);
public void AssumptionViolatedException(String);
public void AssumptionViolatedException(String, Throwable);
public String getMessage();
public void describeTo(org.hamcrest.Description);
}

RealSystem

package org.junit.internal;
public synchronized class RealSystem implements JUnitSystem {
public void RealSystem();
public void exit(int);
public java.io.PrintStream out();
}

MethodSorter$2

package org.junit.internal;
synchronized class MethodSorter$2 implements java.util.Comparator {
void MethodSorter$2();
public int compare(reflect.Method, reflect.Method);
}

ComparisonCriteria

package org.junit.internal;
public abstract synchronized class ComparisonCriteria {
public void ComparisonCriteria();
public void arrayEquals(String, Object, Object) throws ArrayComparisonFailure;
private boolean isArray(Object);
private int assertArraysAreSameLength(Object, Object, String);
protected abstract void assertElementsEqual(Object, Object);
}

Throwables

package org.junit.internal;
public final synchronized class Throwables {
private void Throwables();
public static Exception rethrowAsException(Throwable) throws Exception;
private static void rethrow(Throwable) throws Throwable;
}

MethodSorter$1

package org.junit.internal;
synchronized class MethodSorter$1 implements java.util.Comparator {
void MethodSorter$1();
public int compare(reflect.Method, reflect.Method);
}

Classes

package org.junit.internal;
public synchronized class Classes {
public void Classes();
public static Class getClass(String) throws ClassNotFoundException;
}

IgnoredClassRunner

package org.junit.internal.builders;
public synchronized class IgnoredClassRunner extends org.junit.runner.Runner {
private final Class clazz;
public void IgnoredClassRunner(Class);
public void run(org.junit.runner.notification.RunNotifier);
public org.junit.runner.Description getDescription();
}

JUnit4Builder

package org.junit.internal.builders;
public synchronized class JUnit4Builder extends org.junit.runners.model.RunnerBuilder {
public void JUnit4Builder();
public org.junit.runner.Runner runnerForClass(Class) throws Throwable;
}

AnnotatedBuilder

package org.junit.internal.builders;
public synchronized class AnnotatedBuilder extends org.junit.runners.model.RunnerBuilder {
private static final String CONSTRUCTOR_ERROR_FORMAT = Custom runner class %s should have a public constructor with signature %s(Class testClass);
private final org.junit.runners.model.RunnerBuilder suiteBuilder;
public void AnnotatedBuilder(org.junit.runners.model.RunnerBuilder);
public org.junit.runner.Runner runnerForClass(Class) throws Exception;
private Class getEnclosingClassForNonStaticMemberClass(Class);
public org.junit.runner.Runner buildRunner(Class, Class) throws Exception;
}

IgnoredBuilder

package org.junit.internal.builders;
public synchronized class IgnoredBuilder extends org.junit.runners.model.RunnerBuilder {
public void IgnoredBuilder();
public org.junit.runner.Runner runnerForClass(Class);
}

JUnit3Builder

package org.junit.internal.builders;
public synchronized class JUnit3Builder extends org.junit.runners.model.RunnerBuilder {
public void JUnit3Builder();
public org.junit.runner.Runner runnerForClass(Class) throws Throwable;
boolean isPre4Test(Class);
}

AllDefaultPossibilitiesBuilder

package org.junit.internal.builders;
public synchronized class AllDefaultPossibilitiesBuilder extends org.junit.runners.model.RunnerBuilder {
private final boolean canUseSuiteMethod;
public void AllDefaultPossibilitiesBuilder(boolean);
public org.junit.runner.Runner runnerForClass(Class) throws Throwable;
protected JUnit4Builder junit4Builder();
protected JUnit3Builder junit3Builder();
protected AnnotatedBuilder annotatedBuilder();
protected IgnoredBuilder ignoredBuilder();
protected org.junit.runners.model.RunnerBuilder suiteMethodBuilder();
}

NullBuilder

package org.junit.internal.builders;
public synchronized class NullBuilder extends org.junit.runners.model.RunnerBuilder {
public void NullBuilder();
public org.junit.runner.Runner runnerForClass(Class) throws Throwable;
}

SuiteMethodBuilder

package org.junit.internal.builders;
public synchronized class SuiteMethodBuilder extends org.junit.runners.model.RunnerBuilder {
public void SuiteMethodBuilder();
public org.junit.runner.Runner runnerForClass(Class) throws Throwable;
public boolean hasSuiteMethod(Class);
}

ResultMatchers$1

package org.junit.experimental.results;
synchronized class ResultMatchers$1 extends org.hamcrest.TypeSafeMatcher {
void ResultMatchers$1(int);
public void describeTo(org.hamcrest.Description);
public boolean matchesSafely(PrintableResult);
}

ResultMatchers$2

package org.junit.experimental.results;
synchronized class ResultMatchers$2 extends org.hamcrest.BaseMatcher {
void ResultMatchers$2(String);
public boolean matches(Object);
public void describeTo(org.hamcrest.Description);
}

FailureList

package org.junit.experimental.results;
synchronized class FailureList {
private final java.util.List failures;
public void FailureList(java.util.List);
public org.junit.runner.Result result();
}

ResultMatchers$3

package org.junit.experimental.results;
synchronized class ResultMatchers$3 extends org.hamcrest.BaseMatcher {
void ResultMatchers$3(String);
public boolean matches(Object);
public void describeTo(org.hamcrest.Description);
}

ResultMatchers

package org.junit.experimental.results;
public synchronized class ResultMatchers {
public void ResultMatchers();
public static org.hamcrest.Matcher isSuccessful();
public static org.hamcrest.Matcher failureCountIs(int);
public static org.hamcrest.Matcher hasSingleFailureContaining(String);
public static org.hamcrest.Matcher hasFailureContaining(String);
}

PrintableResult

package org.junit.experimental.results;
public synchronized class PrintableResult {
private org.junit.runner.Result result;
public static PrintableResult testResult(Class);
public static PrintableResult testResult(org.junit.runner.Request);
public void PrintableResult(java.util.List);
private void PrintableResult(org.junit.runner.Result);
public int failureCount();
public String toString();
}

ParallelComputer$1

package org.junit.experimental;
synchronized class ParallelComputer$1 implements org.junit.runners.model.RunnerScheduler {
private final java.util.concurrent.ExecutorService fService;
void ParallelComputer$1();
public void schedule(Runnable);
public void finished();
}

MaxHistory$RememberingListener

package org.junit.experimental.max;
final synchronized class MaxHistory$RememberingListener extends org.junit.runner.notification.RunListener {
private long overallStart;
private java.util.Map starts;
private void MaxHistory$RememberingListener(MaxHistory);
public void testStarted(org.junit.runner.Description) throws Exception;
public void testFinished(org.junit.runner.Description) throws Exception;
public void testFailure(org.junit.runner.notification.Failure) throws Exception;
public void testRunFinished(org.junit.runner.Result) throws Exception;
}

MaxCore

package org.junit.experimental.max;
public synchronized class MaxCore {
private static final String MALFORMED_JUNIT_3_TEST_CLASS_PREFIX = malformed JUnit 3 test class: ;
private final MaxHistory history;
public static MaxCore forFolder(String);
public static MaxCore storedLocally(java.io.File);
private void MaxCore(java.io.File);
public org.junit.runner.Result run(Class);
public org.junit.runner.Result run(org.junit.runner.Request);
public org.junit.runner.Result run(org.junit.runner.Request, org.junit.runner.JUnitCore);
public org.junit.runner.Request sortRequest(org.junit.runner.Request);
private org.junit.runner.Request constructLeafRequest(java.util.List);
private org.junit.runner.Runner buildRunner(org.junit.runner.Description);
private Class getMalformedTestClass(org.junit.runner.Description);
public java.util.List sortedLeavesForTest(org.junit.runner.Request);
private java.util.List findLeaves(org.junit.runner.Request);
private void findLeaves(org.junit.runner.Description, org.junit.runner.Description, java.util.List);
}

MaxHistory$1

package org.junit.experimental.max;
synchronized class MaxHistory$1 {
}

MaxHistory$TestComparator

package org.junit.experimental.max;
synchronized class MaxHistory$TestComparator implements java.util.Comparator {
private void MaxHistory$TestComparator(MaxHistory);
public int compare(org.junit.runner.Description, org.junit.runner.Description);
private Long getFailure(org.junit.runner.Description);
}

MaxCore$1

package org.junit.experimental.max;
synchronized class MaxCore$1 extends org.junit.runner.Request {
void MaxCore$1(MaxCore, java.util.List);
public org.junit.runner.Runner getRunner();
}

MaxCore$1$1

package org.junit.experimental.max;
synchronized class MaxCore$1$1 extends org.junit.runners.Suite {
void MaxCore$1$1(MaxCore$1, Class, java.util.List) throws org.junit.runners.model.InitializationError;
}

CouldNotReadCoreException

package org.junit.experimental.max;
public synchronized class CouldNotReadCoreException extends Exception {
private static final long serialVersionUID = 1;
public void CouldNotReadCoreException(Throwable);
}

MaxHistory

package org.junit.experimental.max;
public synchronized class MaxHistory implements java.io.Serializable {
private static final long serialVersionUID = 1;
private final java.util.Map fDurations;
private final java.util.Map fFailureTimestamps;
private final java.io.File fHistoryStore;
public static MaxHistory forFolder(java.io.File);
private static MaxHistory readHistory(java.io.File) throws CouldNotReadCoreException;
private void MaxHistory(java.io.File);
private void save() throws java.io.IOException;
Long getFailureTimestamp(org.junit.runner.Description);
void putTestFailureTimestamp(org.junit.runner.Description, long);
boolean isNewTest(org.junit.runner.Description);
Long getTestDuration(org.junit.runner.Description);
void putTestDuration(org.junit.runner.Description, long);
public org.junit.runner.notification.RunListener listener();
public java.util.Comparator testComparator();
}

ParallelComputer

package org.junit.experimental;
public synchronized class ParallelComputer extends org.junit.runner.Computer {
private final boolean classes;
private final boolean methods;
public void ParallelComputer(boolean, boolean);
public static org.junit.runner.Computer classes();
public static org.junit.runner.Computer methods();
private static org.junit.runner.Runner parallelize(org.junit.runner.Runner);
public org.junit.runner.Runner getSuite(org.junit.runners.model.RunnerBuilder, Class[]) throws org.junit.runners.model.InitializationError;
protected org.junit.runner.Runner getRunner(org.junit.runners.model.RunnerBuilder, Class) throws Throwable;
}

ParameterSignature

package org.junit.experimental.theories;
public synchronized class ParameterSignature {
private static final java.util.Map CONVERTABLE_TYPES_MAP;
private final Class type;
private final annotation.Annotation[] annotations;
private static java.util.Map buildConvertableTypesMap();
private static void putSymmetrically(java.util.Map, Object, Object);
public static java.util.ArrayList signatures(reflect.Method);
public static java.util.List signatures(reflect.Constructor);
private static java.util.ArrayList signatures(Class[], annotation.Annotation[][]);
private void ParameterSignature(Class, annotation.Annotation[]);
public boolean canAcceptValue(Object);
public boolean canAcceptType(Class);
public boolean canPotentiallyAcceptType(Class);
private boolean isAssignableViaTypeConversion(Class, Class);
public Class getType();
public java.util.List getAnnotations();
public boolean hasAnnotation(Class);
public annotation.Annotation findDeepAnnotation(Class);
private annotation.Annotation findDeepAnnotation(annotation.Annotation[], Class, int);
public annotation.Annotation getAnnotation(Class);
static void ();
}

Theories$TheoryAnchor$2

package org.junit.experimental.theories;
synchronized class Theories$TheoryAnchor$2 extends org.junit.runners.model.Statement {
void Theories$TheoryAnchor$2(Theories$TheoryAnchor, internal.Assignments, org.junit.runners.model.FrameworkMethod, Object) throws Throwable;
public void evaluate() throws Throwable;
}

Theories$TheoryAnchor

package org.junit.experimental.theories;
public synchronized class Theories$TheoryAnchor extends org.junit.runners.model.Statement {
private int successes;
private final org.junit.runners.model.FrameworkMethod testMethod;
private final org.junit.runners.model.TestClass testClass;
private java.util.List fInvalidParameters;
public void Theories$TheoryAnchor(org.junit.runners.model.FrameworkMethod, org.junit.runners.model.TestClass);
private org.junit.runners.model.TestClass getTestClass();
public void evaluate() throws Throwable;
protected void runWithAssignment(internal.Assignments) throws Throwable;
protected void runWithIncompleteAssignment(internal.Assignments) throws Throwable;
protected void runWithCompleteAssignment(internal.Assignments) throws Throwable;
private org.junit.runners.model.Statement methodCompletesWithParameters(org.junit.runners.model.FrameworkMethod, internal.Assignments, Object);
protected void handleAssumptionViolation(org.junit.internal.AssumptionViolatedException);
protected transient void reportParameterizedError(Throwable, Object[]) throws Throwable;
private boolean nullsOk();
protected void handleDataPointSuccess();
}

Theory

package org.junit.experimental.theories;
public abstract interface Theory extends annotation.Annotation {
public abstract boolean nullsAccepted();
}

PotentialAssignment$1

package org.junit.experimental.theories;
synchronized class PotentialAssignment$1 extends PotentialAssignment {
void PotentialAssignment$1(Object, String);
public Object getValue();
public String toString();
public String getDescription();
}

Theories$TheoryAnchor$1$1

package org.junit.experimental.theories;
synchronized class Theories$TheoryAnchor$1$1 extends org.junit.runners.model.Statement {
void Theories$TheoryAnchor$1$1(Theories$TheoryAnchor$1, org.junit.runners.model.Statement) throws Throwable;
public void evaluate() throws Throwable;
}

FromDataPoints

package org.junit.experimental.theories;
public abstract interface FromDataPoints extends annotation.Annotation {
public abstract String value();
}

DataPoints

package org.junit.experimental.theories;
public abstract interface DataPoints extends annotation.Annotation {
public abstract String[] value();
public abstract Class[] ignoredExceptions();
}

TestedOnSupplier

package org.junit.experimental.theories.suppliers;
public synchronized class TestedOnSupplier extends org.junit.experimental.theories.ParameterSupplier {
public void TestedOnSupplier();
public java.util.List getValueSources(org.junit.experimental.theories.ParameterSignature);
}

TestedOn

package org.junit.experimental.theories.suppliers;
public abstract interface TestedOn extends annotation.Annotation {
public abstract int[] ints();
}

Theories$TheoryAnchor$1

package org.junit.experimental.theories;
synchronized class Theories$TheoryAnchor$1 extends org.junit.runners.BlockJUnit4ClassRunner {
void Theories$TheoryAnchor$1(Theories$TheoryAnchor, Class, internal.Assignments) throws Throwable;
protected void collectInitializationErrors(java.util.List);
public org.junit.runners.model.Statement methodBlock(org.junit.runners.model.FrameworkMethod);
protected org.junit.runners.model.Statement methodInvoker(org.junit.runners.model.FrameworkMethod, Object);
public Object createTest() throws Exception;
}

PotentialAssignment

package org.junit.experimental.theories;
public abstract synchronized class PotentialAssignment {
public void PotentialAssignment();
public static PotentialAssignment forValue(String, Object);
public abstract Object getValue() throws PotentialAssignment$CouldNotGenerateValueException;
public abstract String getDescription() throws PotentialAssignment$CouldNotGenerateValueException;
}

ParametersSuppliedBy

package org.junit.experimental.theories;
public abstract interface ParametersSuppliedBy extends annotation.Annotation {
public abstract Class value();
}

Theories

package org.junit.experimental.theories;
public synchronized class Theories extends org.junit.runners.BlockJUnit4ClassRunner {
public void Theories(Class) throws org.junit.runners.model.InitializationError;
protected void collectInitializationErrors(java.util.List);
private void validateDataPointFields(java.util.List);
private void validateDataPointMethods(java.util.List);
protected void validateConstructor(java.util.List);
protected void validateTestMethods(java.util.List);
private void validateParameterSupplier(Class, java.util.List);
protected java.util.List computeTestMethods();
public org.junit.runners.model.Statement methodBlock(org.junit.runners.model.FrameworkMethod);
}

DataPoint

package org.junit.experimental.theories;
public abstract interface DataPoint extends annotation.Annotation {
public abstract String[] value();
public abstract Class[] ignoredExceptions();
}

AllMembersSupplier$MethodParameterValue

package org.junit.experimental.theories.internal;
synchronized class AllMembersSupplier$MethodParameterValue extends org.junit.experimental.theories.PotentialAssignment {
private final org.junit.runners.model.FrameworkMethod method;
private void AllMembersSupplier$MethodParameterValue(org.junit.runners.model.FrameworkMethod);
public Object getValue() throws org.junit.experimental.theories.PotentialAssignment$CouldNotGenerateValueException;
public String getDescription() throws org.junit.experimental.theories.PotentialAssignment$CouldNotGenerateValueException;
}

AllMembersSupplier

package org.junit.experimental.theories.internal;
public synchronized class AllMembersSupplier extends org.junit.experimental.theories.ParameterSupplier {
private final org.junit.runners.model.TestClass clazz;
public void AllMembersSupplier(org.junit.runners.model.TestClass);
public java.util.List getValueSources(org.junit.experimental.theories.ParameterSignature) throws Throwable;
private void addMultiPointMethods(org.junit.experimental.theories.ParameterSignature, java.util.List) throws Throwable;
private void addSinglePointMethods(org.junit.experimental.theories.ParameterSignature, java.util.List);
private void addMultiPointFields(org.junit.experimental.theories.ParameterSignature, java.util.List);
private void addSinglePointFields(org.junit.experimental.theories.ParameterSignature, java.util.List);
private void addDataPointsValues(Class, org.junit.experimental.theories.ParameterSignature, String, java.util.List, Object);
private void addArrayValues(org.junit.experimental.theories.ParameterSignature, String, java.util.List, Object);
private void addIterableValues(org.junit.experimental.theories.ParameterSignature, String, java.util.List, Iterable);
private Object getStaticFieldValue(reflect.Field);
private static boolean isAssignableToAnyOf(Class[], Object);
protected java.util.Collection getDataPointsMethods(org.junit.experimental.theories.ParameterSignature);
protected java.util.Collection getSingleDataPointFields(org.junit.experimental.theories.ParameterSignature);
protected java.util.Collection getDataPointsFields(org.junit.experimental.theories.ParameterSignature);
protected java.util.Collection getSingleDataPointMethods(org.junit.experimental.theories.ParameterSignature);
}

EnumSupplier

package org.junit.experimental.theories.internal;
public synchronized class EnumSupplier extends org.junit.experimental.theories.ParameterSupplier {
private Class enumType;
public void EnumSupplier(Class);
public java.util.List getValueSources(org.junit.experimental.theories.ParameterSignature);
}

Assignments

package org.junit.experimental.theories.internal;
public synchronized class Assignments {
private final java.util.List assigned;
private final java.util.List unassigned;
private final org.junit.runners.model.TestClass clazz;
private void Assignments(java.util.List, java.util.List, org.junit.runners.model.TestClass);
public static Assignments allUnassigned(reflect.Method, org.junit.runners.model.TestClass);
public boolean isComplete();
public org.junit.experimental.theories.ParameterSignature nextUnassigned();
public Assignments assignNext(org.junit.experimental.theories.PotentialAssignment);
public Object[] getActualValues(int, int) throws org.junit.experimental.theories.PotentialAssignment$CouldNotGenerateValueException;
public java.util.List potentialsForNextUnassigned() throws Throwable;
private java.util.List generateAssignmentsFromTypeAlone(org.junit.experimental.theories.ParameterSignature);
private org.junit.experimental.theories.ParameterSupplier getSupplier(org.junit.experimental.theories.ParameterSignature) throws Exception;
private org.junit.experimental.theories.ParameterSupplier buildParameterSupplierFromClass(Class) throws Exception;
public Object[] getConstructorArguments() throws org.junit.experimental.theories.PotentialAssignment$CouldNotGenerateValueException;
public Object[] getMethodArguments() throws org.junit.experimental.theories.PotentialAssignment$CouldNotGenerateValueException;
public Object[] getAllArguments() throws org.junit.experimental.theories.PotentialAssignment$CouldNotGenerateValueException;
private int getConstructorParameterCount();
public Object[] getArgumentStrings(boolean) throws org.junit.experimental.theories.PotentialAssignment$CouldNotGenerateValueException;
}

SpecificDataPointsSupplier

package org.junit.experimental.theories.internal;
public synchronized class SpecificDataPointsSupplier extends AllMembersSupplier {
public void SpecificDataPointsSupplier(org.junit.runners.model.TestClass);
protected java.util.Collection getSingleDataPointFields(org.junit.experimental.theories.ParameterSignature);
protected java.util.Collection getDataPointsFields(org.junit.experimental.theories.ParameterSignature);
protected java.util.Collection getSingleDataPointMethods(org.junit.experimental.theories.ParameterSignature);
protected java.util.Collection getDataPointsMethods(org.junit.experimental.theories.ParameterSignature);
}

BooleanSupplier

package org.junit.experimental.theories.internal;
public synchronized class BooleanSupplier extends org.junit.experimental.theories.ParameterSupplier {
public void BooleanSupplier();
public java.util.List getValueSources(org.junit.experimental.theories.ParameterSignature);
}

AllMembersSupplier$1

package org.junit.experimental.theories.internal;
synchronized class AllMembersSupplier$1 {
}

ParameterizedAssertionError

package org.junit.experimental.theories.internal;
public synchronized class ParameterizedAssertionError extends AssertionError {
private static final long serialVersionUID = 1;
public transient void ParameterizedAssertionError(Throwable, String, Object[]);
public boolean equals(Object);
public int hashCode();
public static transient String join(String, Object[]);
public static String join(String, java.util.Collection);
private static String stringValueOf(Object);
}

PotentialAssignment$CouldNotGenerateValueException

package org.junit.experimental.theories;
public synchronized class PotentialAssignment$CouldNotGenerateValueException extends Exception {
private static final long serialVersionUID = 1;
public void PotentialAssignment$CouldNotGenerateValueException();
public void PotentialAssignment$CouldNotGenerateValueException(Throwable);
}

ParameterSupplier

package org.junit.experimental.theories;
public abstract synchronized class ParameterSupplier {
public void ParameterSupplier();
public abstract java.util.List getValueSources(ParameterSignature) throws Throwable;
}

ExcludeCategories$ExcludesAny

package org.junit.experimental.categories;
synchronized class ExcludeCategories$ExcludesAny extends Categories$CategoryFilter {
public void ExcludeCategories$ExcludesAny(java.util.List);
public void ExcludeCategories$ExcludesAny(java.util.Set);
public String describe();
}

IncludeCategories

package org.junit.experimental.categories;
public final synchronized class IncludeCategories extends CategoryFilterFactory {
public void IncludeCategories();
protected org.junit.runner.manipulation.Filter createFilter(java.util.List);
}

ExcludeCategories

package org.junit.experimental.categories;
public final synchronized class ExcludeCategories extends CategoryFilterFactory {
public void ExcludeCategories();
protected org.junit.runner.manipulation.Filter createFilter(java.util.List);
}

Categories$CategoryFilter

package org.junit.experimental.categories;
public synchronized class Categories$CategoryFilter extends org.junit.runner.manipulation.Filter {
private final java.util.Set included;
private final java.util.Set excluded;
private final boolean includedAny;
private final boolean excludedAny;
public static transient Categories$CategoryFilter include(boolean, Class[]);
public static Categories$CategoryFilter include(Class);
public static transient Categories$CategoryFilter include(Class[]);
public static transient Categories$CategoryFilter exclude(boolean, Class[]);
public static Categories$CategoryFilter exclude(Class);
public static transient Categories$CategoryFilter exclude(Class[]);
public static Categories$CategoryFilter categoryFilter(boolean, java.util.Set, boolean, java.util.Set);
protected void Categories$CategoryFilter(boolean, java.util.Set, boolean, java.util.Set);
public String describe();
public String toString();
public boolean shouldRun(org.junit.runner.Description);
private boolean hasCorrectCategoryAnnotation(org.junit.runner.Description);
private boolean matchesAnyParentCategories(java.util.Set, java.util.Set);
private boolean matchesAllParentCategories(java.util.Set, java.util.Set);
private static java.util.Set categories(org.junit.runner.Description);
private static org.junit.runner.Description parentDescription(org.junit.runner.Description);
private static Class[] directCategories(org.junit.runner.Description);
private static java.util.Set copyAndRefine(java.util.Set);
private static transient boolean hasNull(Class[]);
}

Categories$ExcludeCategory

package org.junit.experimental.categories;
public abstract interface Categories$ExcludeCategory extends annotation.Annotation {
public abstract Class[] value();
public abstract boolean matchAny();
}

CategoryValidator

package org.junit.experimental.categories;
public final synchronized class CategoryValidator extends org.junit.validator.AnnotationValidator {
private static final java.util.Set INCOMPATIBLE_ANNOTATIONS;
public void CategoryValidator();
public java.util.List validateAnnotatedMethod(org.junit.runners.model.FrameworkMethod);
private void addErrorMessage(java.util.List, Class);
static void ();
}

IncludeCategories$IncludesAny

package org.junit.experimental.categories;
synchronized class IncludeCategories$IncludesAny extends Categories$CategoryFilter {
public void IncludeCategories$IncludesAny(java.util.List);
public void IncludeCategories$IncludesAny(java.util.Set);
public String describe();
}

Category

package org.junit.experimental.categories;
public abstract interface Category extends annotation.Annotation {
public abstract Class[] value();
}

CategoryFilterFactory

package org.junit.experimental.categories;
abstract synchronized class CategoryFilterFactory implements org.junit.runner.FilterFactory {
void CategoryFilterFactory();
public org.junit.runner.manipulation.Filter createFilter(org.junit.runner.FilterFactoryParams) throws org.junit.runner.FilterFactory$FilterNotCreatedException;
protected abstract org.junit.runner.manipulation.Filter createFilter(java.util.List);
private java.util.List parseCategories(String) throws ClassNotFoundException;
}

Categories

package org.junit.experimental.categories;
public synchronized class Categories extends org.junit.runners.Suite {
public void Categories(Class, org.junit.runners.model.RunnerBuilder) throws org.junit.runners.model.InitializationError;
private static java.util.Set getIncludedCategory(Class);
private static boolean isAnyIncluded(Class);
private static java.util.Set getExcludedCategory(Class);
private static boolean isAnyExcluded(Class);
private static void assertNoCategorizedDescendentsOfUncategorizeableParents(org.junit.runner.Description) throws org.junit.runners.model.InitializationError;
private static void assertNoDescendantsHaveCategoryAnnotations(org.junit.runner.Description) throws org.junit.runners.model.InitializationError;
private static boolean canHaveCategorizedChildren(org.junit.runner.Description);
private static boolean hasAssignableTo(java.util.Set, Class);
private static transient java.util.Set createSet(Class[]);
}

Categories$IncludeCategory

package org.junit.experimental.categories;
public abstract interface Categories$IncludeCategory extends annotation.Annotation {
public abstract Class[] value();
public abstract boolean matchAny();
}

Enclosed

package org.junit.experimental.runners;
public synchronized class Enclosed extends org.junit.runners.Suite {
public void Enclosed(Class, org.junit.runners.model.RunnerBuilder) throws Throwable;
private static Class[] filterAbstractClasses(Class[]);
}

Rule

package org.junit;
public abstract interface Rule extends annotation.Annotation {
}

TestCase

package junit.framework;
public abstract synchronized class TestCase extends Assert implements Test {
private String fName;
public void TestCase();
public void TestCase(String);
public int countTestCases();
protected TestResult createResult();
public TestResult run();
public void run(TestResult);
public void runBare() throws Throwable;
protected void runTest() throws Throwable;
public static void assertTrue(String, boolean);
public static void assertTrue(boolean);
public static void assertFalse(String, boolean);
public static void assertFalse(boolean);
public static void fail(String);
public static void fail();
public static void assertEquals(String, Object, Object);
public static void assertEquals(Object, Object);
public static void assertEquals(String, String, String);
public static void assertEquals(String, String);
public static void assertEquals(String, double, double, double);
public static void assertEquals(double, double, double);
public static void assertEquals(String, float, float, float);
public static void assertEquals(float, float, float);
public static void assertEquals(String, long, long);
public static void assertEquals(long, long);
public static void assertEquals(String, boolean, boolean);
public static void assertEquals(boolean, boolean);
public static void assertEquals(String, byte, byte);
public static void assertEquals(byte, byte);
public static void assertEquals(String, char, char);
public static void assertEquals(char, char);
public static void assertEquals(String, short, short);
public static void assertEquals(short, short);
public static void assertEquals(String, int, int);
public static void assertEquals(int, int);
public static void assertNotNull(Object);
public static void assertNotNull(String, Object);
public static void assertNull(Object);
public static void assertNull(String, Object);
public static void assertSame(String, Object, Object);
public static void assertSame(Object, Object);
public static void assertNotSame(String, Object, Object);
public static void assertNotSame(Object, Object);
public static void failSame(String);
public static void failNotSame(String, Object, Object);
public static void failNotEquals(String, Object, Object);
public static String format(String, Object, Object);
protected void setUp() throws Exception;
protected void tearDown() throws Exception;
public String toString();
public String getName();
public void setName(String);
}

TestResult

package junit.framework;
public synchronized class TestResult {
protected java.util.List fFailures;
protected java.util.List fErrors;
protected java.util.List fListeners;
protected int fRunTests;
private boolean fStop;
public void TestResult();
public synchronized void addError(Test, Throwable);
public synchronized void addFailure(Test, AssertionFailedError);
public synchronized void addListener(TestListener);
public synchronized void removeListener(TestListener);
private synchronized java.util.List cloneListeners();
public void endTest(Test);
public synchronized int errorCount();
public synchronized java.util.Enumeration errors();
public synchronized int failureCount();
public synchronized java.util.Enumeration failures();
protected void run(TestCase);
public synchronized int runCount();
public void runProtected(Test, Protectable);
public synchronized boolean shouldStop();
public void startTest(Test);
public synchronized void stop();
public synchronized boolean wasSuccessful();
}

TestFailure

package junit.framework;
public synchronized class TestFailure {
protected Test fFailedTest;
protected Throwable fThrownException;
public void TestFailure(Test, Throwable);
public Test failedTest();
public Throwable thrownException();
public String toString();
public String trace();
public String exceptionMessage();
public boolean isFailure();
}

JUnit4TestAdapter

package junit.framework;
public synchronized class JUnit4TestAdapter implements Test, org.junit.runner.manipulation.Filterable, org.junit.runner.manipulation.Sortable, org.junit.runner.Describable {
private final Class fNewTestClass;
private final org.junit.runner.Runner fRunner;
private final JUnit4TestAdapterCache fCache;
public void JUnit4TestAdapter(Class);
public void JUnit4TestAdapter(Class, JUnit4TestAdapterCache);
public int countTestCases();
public void run(TestResult);
public java.util.List getTests();
public Class getTestClass();
public org.junit.runner.Description getDescription();
private org.junit.runner.Description removeIgnored(org.junit.runner.Description);
private boolean isIgnored(org.junit.runner.Description);
public String toString();
public void filter(org.junit.runner.manipulation.Filter) throws org.junit.runner.manipulation.NoTestsRemainException;
public void sort(org.junit.runner.manipulation.Sorter);
}

TestResult$1

package junit.framework;
synchronized class TestResult$1 implements Protectable {
void TestResult$1(TestResult, TestCase) throws Throwable;
public void protect() throws Throwable;
}

TestSuite$1

package junit.framework;
synchronized class TestSuite$1 extends TestCase {
void TestSuite$1(String, String);
protected void runTest();
}

AssertionFailedError

package junit.framework;
public synchronized class AssertionFailedError extends AssertionError {
private static final long serialVersionUID = 1;
public void AssertionFailedError();
public void AssertionFailedError(String);
private static String defaultString(String);
}

TestSuite

package junit.framework;
public synchronized class TestSuite implements Test {
private String fName;
private java.util.Vector fTests;
public static Test createTest(Class, String);
public static reflect.Constructor getTestConstructor(Class) throws NoSuchMethodException;
public static Test warning(String);
private static String exceptionToString(Throwable);
public void TestSuite();
public void TestSuite(Class);
private void addTestsFromTestCase(Class);
public void TestSuite(Class, String);
public void TestSuite(String);
public transient void TestSuite(Class[]);
private Test testCaseForClass(Class);
public void TestSuite(Class[], String);
public void addTest(Test);
public void addTestSuite(Class);
public int countTestCases();
public String getName();
public void run(TestResult);
public void runTest(Test, TestResult);
public void setName(String);
public Test testAt(int);
public int testCount();
public java.util.Enumeration tests();
public String toString();
private void addTestMethod(reflect.Method, java.util.List, Class);
private boolean isPublicTestMethod(reflect.Method);
private boolean isTestMethod(reflect.Method);
}

ComparisonCompactor

package junit.framework;
public synchronized class ComparisonCompactor {
private static final String ELLIPSIS = …;
private static final String DELTA_END = ];
private static final String DELTA_START = [;
private int fContextLength;
private String fExpected;
private String fActual;
private int fPrefix;
private int fSuffix;
public void ComparisonCompactor(int, String, String);
public String compact(String);
private String compactString(String);
private void findCommonPrefix();
private void findCommonSuffix();
private String computeCommonPrefix();
private String computeCommonSuffix();
private boolean areStringsEqual();
}

JUnit4TestAdapterCache

package junit.framework;
public synchronized class JUnit4TestAdapterCache extends java.util.HashMap {
private static final long serialVersionUID = 1;
private static final JUnit4TestAdapterCache fInstance;
public void JUnit4TestAdapterCache();
public static JUnit4TestAdapterCache getDefault();
public Test asTest(org.junit.runner.Description);
Test createTest(org.junit.runner.Description);
public org.junit.runner.notification.RunNotifier getNotifier(TestResult, JUnit4TestAdapter);
public java.util.List asTestList(org.junit.runner.Description);
static void ();
}

Assert

package junit.framework;
public synchronized class Assert {
protected void Assert();
public static void assertTrue(String, boolean);
public static void assertTrue(boolean);
public static void assertFalse(String, boolean);
public static void assertFalse(boolean);
public static void fail(String);
public static void fail();
public static void assertEquals(String, Object, Object);
public static void assertEquals(Object, Object);
public static void assertEquals(String, String, String);
public static void assertEquals(String, String);
public static void assertEquals(String, double, double, double);
public static void assertEquals(double, double, double);
public static void assertEquals(String, float, float, float);
public static void assertEquals(float, float, float);
public static void assertEquals(String, long, long);
public static void assertEquals(long, long);
public static void assertEquals(String, boolean, boolean);
public static void assertEquals(boolean, boolean);
public static void assertEquals(String, byte, byte);
public static void assertEquals(byte, byte);
public static void assertEquals(String, char, char);
public static void assertEquals(char, char);
public static void assertEquals(String, short, short);
public static void assertEquals(short, short);
public static void assertEquals(String, int, int);
public static void assertEquals(int, int);
public static void assertNotNull(Object);
public static void assertNotNull(String, Object);
public static void assertNull(Object);
public static void assertNull(String, Object);
public static void assertSame(String, Object, Object);
public static void assertSame(Object, Object);
public static void assertNotSame(String, Object, Object);
public static void assertNotSame(Object, Object);
public static void failSame(String);
public static void failNotSame(String, Object, Object);
public static void failNotEquals(String, Object, Object);
public static String format(String, Object, Object);
}

ComparisonFailure

package junit.framework;
public synchronized class ComparisonFailure extends AssertionFailedError {
private static final int MAX_CONTEXT_LENGTH = 20;
private static final long serialVersionUID = 1;
private String fExpected;
private String fActual;
public void ComparisonFailure(String, String, String);
public String getMessage();
public String getActual();
public String getExpected();
}

JUnit4TestCaseFacade

package junit.framework;
public synchronized class JUnit4TestCaseFacade implements Test, org.junit.runner.Describable {
private final org.junit.runner.Description fDescription;
void JUnit4TestCaseFacade(org.junit.runner.Description);
public String toString();
public int countTestCases();
public void run(TestResult);
public org.junit.runner.Description getDescription();
}

TestListener

package junit.framework;
public abstract interface TestListener {
public abstract void addError(Test, Throwable);
public abstract void addFailure(Test, AssertionFailedError);
public abstract void endTest(Test);
public abstract void startTest(Test);
}

Protectable

package junit.framework;
public abstract interface Protectable {
public abstract void protect() throws Throwable;
}

JUnit4TestAdapterCache$1

package junit.framework;
synchronized class JUnit4TestAdapterCache$1 extends org.junit.runner.notification.RunListener {
void JUnit4TestAdapterCache$1(JUnit4TestAdapterCache, TestResult);
public void testFailure(org.junit.runner.notification.Failure) throws Exception;
public void testFinished(org.junit.runner.Description) throws Exception;
public void testStarted(org.junit.runner.Description) throws Exception;
}

Test

package junit.framework;
public abstract interface Test {
public abstract int countTestCases();
public abstract void run(TestResult);
}

Version

package junit.runner;
public synchronized class Version {
private void Version();
public static String id();
public static void main(String[]);
}

TestRunListener

package junit.runner;
public abstract interface TestRunListener {
public static final int STATUS_ERROR = 1;
public static final int STATUS_FAILURE = 2;
public abstract void testRunStarted(String, int);
public abstract void testRunEnded(long);
public abstract void testRunStopped(long);
public abstract void testStarted(String);
public abstract void testEnded(String);
public abstract void testFailed(int, String, String);
}

BaseTestRunner

package junit.runner;
public abstract synchronized class BaseTestRunner implements junit.framework.TestListener {
public static final String SUITE_METHODNAME = suite;
private static java.util.Properties fPreferences;
static int fgMaxMessageLength;
static boolean fgFilterStack;
boolean fLoading;
public void BaseTestRunner();
public synchronized void startTest(junit.framework.Test);
protected static void setPreferences(java.util.Properties);
protected static java.util.Properties getPreferences();
public static void savePreferences() throws java.io.IOException;
public static void setPreference(String, String);
public synchronized void endTest(junit.framework.Test);
public synchronized void addError(junit.framework.Test, Throwable);
public synchronized void addFailure(junit.framework.Test, junit.framework.AssertionFailedError);
public abstract void testStarted(String);
public abstract void testEnded(String);
public abstract void testFailed(int, junit.framework.Test, Throwable);
public junit.framework.Test getTest(String);
public String elapsedTimeAsString(long);
protected String processArguments(String[]);
public void setLoading(boolean);
public String extractClassName(String);
public static String truncate(String);
protected abstract void runFailed(String);
protected Class loadSuiteClass(String) throws ClassNotFoundException;
protected void clearStatus();
protected boolean useReloadingTestSuiteLoader();
private static java.io.File getPreferencesFile();
private static void readPreferences();
public static String getPreference(String);
public static int getPreference(String, int);
public static String getFilteredTrace(Throwable);
public static String getFilteredTrace(String);
protected static boolean showStackRaw();
static boolean filterLine(String);
static void ();
}

TestDecorator

package junit.extensions;
public synchronized class TestDecorator extends junit.framework.Assert implements junit.framework.Test {
protected junit.framework.Test fTest;
public void TestDecorator(junit.framework.Test);
public void basicRun(junit.framework.TestResult);
public int countTestCases();
public void run(junit.framework.TestResult);
public String toString();
public junit.framework.Test getTest();
}

ActiveTestSuite$1

package junit.extensions;
synchronized class ActiveTestSuite$1 extends Thread {
void ActiveTestSuite$1(ActiveTestSuite, junit.framework.Test, junit.framework.TestResult);
public void run();
}

TestSetup

package junit.extensions;
public synchronized class TestSetup extends TestDecorator {
public void TestSetup(junit.framework.Test);
public void run(junit.framework.TestResult);
protected void setUp() throws Exception;
protected void tearDown() throws Exception;
}

ActiveTestSuite

package junit.extensions;
public synchronized class ActiveTestSuite extends junit.framework.TestSuite {
private volatile int fActiveTestDeathCount;
public void ActiveTestSuite();
public void ActiveTestSuite(Class);
public void ActiveTestSuite(String);
public void ActiveTestSuite(Class, String);
public void run(junit.framework.TestResult);
public void runTest(junit.framework.Test, junit.framework.TestResult);
synchronized void waitUntilFinished();
public synchronized void runFinished();
}

TestSetup$1

package junit.extensions;
synchronized class TestSetup$1 implements junit.framework.Protectable {
void TestSetup$1(TestSetup, junit.framework.TestResult) throws Exception;
public void protect() throws Exception;
}

RepeatedTest

package junit.extensions;
public synchronized class RepeatedTest extends TestDecorator {
private int fTimesRepeat;
public void RepeatedTest(junit.framework.Test, int);
public int countTestCases();
public void run(junit.framework.TestResult);
public String toString();
}

TestRunner

package junit.textui;
public synchronized class TestRunner extends junit.runner.BaseTestRunner {
private ResultPrinter fPrinter;
public static final int SUCCESS_EXIT = 0;
public static final int FAILURE_EXIT = 1;
public static final int EXCEPTION_EXIT = 2;
public void TestRunner();
public void TestRunner(java.io.PrintStream);
public void TestRunner(ResultPrinter);
public static void run(Class);
public static junit.framework.TestResult run(junit.framework.Test);
public static void runAndWait(junit.framework.Test);
public void testFailed(int, junit.framework.Test, Throwable);
public void testStarted(String);
public void testEnded(String);
protected junit.framework.TestResult createTestResult();
public junit.framework.TestResult doRun(junit.framework.Test);
public junit.framework.TestResult doRun(junit.framework.Test, boolean);
protected void pause(boolean);
public static void main(String[]);
public junit.framework.TestResult start(String[]) throws Exception;
protected junit.framework.TestResult runSingleMethod(String, String, boolean) throws Exception;
protected void runFailed(String);
public void setPrinter(ResultPrinter);
}

ResultPrinter

package junit.textui;
public synchronized class ResultPrinter implements junit.framework.TestListener {
java.io.PrintStream fWriter;
int fColumn;
public void ResultPrinter(java.io.PrintStream);
synchronized void print(junit.framework.TestResult, long);
void printWaitPrompt();
protected void printHeader(long);
protected void printErrors(junit.framework.TestResult);
protected void printFailures(junit.framework.TestResult);
protected void printDefects(java.util.Enumeration, int, String);
public void printDefect(junit.framework.TestFailure, int);
protected void printDefectHeader(junit.framework.TestFailure, int);
protected void printDefectTrace(junit.framework.TestFailure);
protected void printFooter(junit.framework.TestResult);
protected String elapsedTimeAsString(long);
public java.io.PrintStream getWriter();
public void addError(junit.framework.Test, Throwable);
public void addFailure(junit.framework.Test, junit.framework.AssertionFailedError);
public void endTest(junit.framework.Test);
public void startTest(junit.framework.Test);
}

JUnit

Eclipse Public License – v 1.0

THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC
LICENSE (“AGREEMENT”). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM
CONSTITUTES RECIPIENT’S ACCEPTANCE OF THIS AGREEMENT.

1. DEFINITIONS

“Contribution” means:

a) in the case of the initial Contributor, the initial code and
documentation distributed under this Agreement, and
b) in the case of each subsequent Contributor:

i) changes to the Program, and

ii) additions to the Program;

where such changes and/or additions to the Program originate from and are
distributed by that particular Contributor. A Contribution ‘originates’ from a
Contributor if it was added to the Program by such Contributor itself or anyone
acting on such Contributor’s behalf. Contributions do not include additions to
the Program which: (i) are separate modules of software distributed in
conjunction with the Program under their own license agreement, and (ii) are
not derivative works of the Program.

“Contributor” means any person or entity that distributes the Program.

“Licensed Patents ” mean patent claims licensable by a Contributor which are
necessarily infringed by the use or sale of its Contribution alone or when
combined with the Program.

“Program” means the Contributions distributed in accordance with this Agreement.

“Recipient” means anyone who receives the Program under this Agreement,
including all Contributors.

2. GRANT OF RIGHTS

a) Subject to the terms of this Agreement, each Contributor hereby grants
Recipient a non-exclusive, worldwide, royalty-free copyright license to
reproduce, prepare derivative works of, publicly display, publicly perform,
distribute and sublicense the Contribution of such Contributor, if any, and
such derivative works, in source code and object code form.

b) Subject to the terms of this Agreement, each Contributor hereby grants
Recipient a non-exclusive, worldwide, royalty-free patent license under
Licensed Patents to make, use, sell, offer to sell, import and otherwise
transfer the Contribution of such Contributor, if any, in source code and
object code form. This patent license shall apply to the combination of the
Contribution and the Program if, at the time the Contribution is added by the
Contributor, such addition of the Contribution causes such combination to be
covered by the Licensed Patents. The patent license shall not apply to any
other combinations which include the Contribution. No hardware per se is
licensed hereunder.

c) Recipient understands that although each Contributor grants the
licenses to its Contributions set forth herein, no assurances are provided by
any Contributor that the Program does not infringe the patent or other
intellectual property rights of any other entity. Each Contributor disclaims
any liability to Recipient for claims brought by any other entity based on
infringement of intellectual property rights or otherwise. As a condition to
exercising the rights and licenses granted hereunder, each Recipient hereby
assumes sole responsibility to secure any other intellectual property rights
needed, if any. For example, if a third party patent license is required to
allow Recipient to distribute the Program, it is Recipient’s responsibility to
acquire that license before distributing the Program.

d) Each Contributor represents that to its knowledge it has sufficient
copyright rights in its Contribution, if any, to grant the copyright license
set forth in this Agreement.

3. REQUIREMENTS

A Contributor may choose to distribute the Program in object code form under
its own license agreement, provided that:

a) it complies with the terms and conditions of this Agreement; and

b) its license agreement:

i) effectively disclaims on behalf of all Contributors all warranties and
conditions, express and implied, including warranties or conditions of title
and non-infringement, and implied warranties or conditions of merchantability
and fitness for a particular purpose;

ii) effectively excludes on behalf of all Contributors all liability for
damages, including direct, indirect, special, incidental and consequential
damages, such as lost profits;

iii) states that any provisions which differ from this Agreement are
offered by that Contributor alone and not by any other party; and

iv) states that source code for the Program is available from such
Contributor, and informs licensees how to obtain it in a reasonable manner on
or through a medium customarily used for software exchange.

When the Program is made available in source code form:

a) it must be made available under this Agreement; and

b) a copy of this Agreement must be included with each copy of the
Program.

Contributors may not remove or alter any copyright notices contained within the
Program.

Each Contributor must identify itself as the originator of its Contribution, if
any, in a manner that reasonably allows subsequent Recipients to identify the
originator of the Contribution.

4. COMMERCIAL DISTRIBUTION

Commercial distributors of software may accept certain responsibilities with
respect to end users, business partners and the like. While this license is
intended to facilitate the commercial use of the Program, the Contributor who
includes the Program in a commercial product offering should do so in a manner
which does not create potential liability for other Contributors. Therefore, if
a Contributor includes the Program in a commercial product offering, such
Contributor (“Commercial Contributor”) hereby agrees to defend and indemnify
every other Contributor (“Indemnified Contributor”) against any losses, damages
and costs (collectively “Losses”) arising from claims, lawsuits and other legal
actions brought by a third party against the Indemnified Contributor to the
extent caused by the acts or omissions of such Commercial Contributor in
connection with its distribution of the Program in a commercial product
offering. The obligations in this section do not apply to any claims or Losses
relating to any actual or alleged intellectual property infringement. In order
to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
Contributor in writing of such claim, and b) allow the Commercial Contributor
to control, and cooperate with the Commercial Contributor in, the defense and
any related settlement negotiations. The Indemnified Contributor may
participate in any such claim at its own expense.

For example, a Contributor might include the Program in a commercial product
offering, Product X. That Contributor is then a Commercial Contributor. If that
Commercial Contributor then makes performance claims, or offers warranties
related to Product X, those performance claims and warranties are such
Commercial Contributor’s responsibility alone. Under this section, the
Commercial Contributor would have to defend claims against the other
Contributors related to those performance claims and warranties, and if a court
requires any other Contributor to pay any damages as a result, the Commercial
Contributor must pay those damages.

5. NO WARRANTY

EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN
“AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR
IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE,
NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each
Recipient is solely responsible for determining the appropriateness of using
and distributing the Program and assumes all risks associated with its exercise
of rights under this Agreement, including but not limited to the risks and
costs of program errors, compliance with applicable laws, damage to or loss of
data, programs or equipment, and unavailability or interruption of operations.

6. DISCLAIMER OF LIABILITY

EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY
CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST
PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

7. GENERAL

If any provision of this Agreement is invalid or unenforceable under applicable
law, it shall not affect the validity or enforceability of the remainder of the
terms of this Agreement, and without further action by the parties hereto, such
provision shall be reformed to the minimum extent necessary to make such
provision valid and enforceable.

If Recipient institutes patent litigation against any
entity (including a cross-claim or counterclaim in a lawsuit) alleging that the
Program itself (excluding combinations of the Program with other software or
hardware) infringes such Recipient’s patent(s), then such Recipient’s rights
granted under Section 2(b) shall terminate as of the date such litigation is
filed.

All Recipient’s rights under this Agreement shall terminate if it fails to
comply with any of the material terms or conditions of this Agreement and does
not cure such failure in a reasonable period of time after becoming aware of
such noncompliance. If all Recipient’s rights under this Agreement terminate,
Recipient agrees to cease use and distribution of the Program as soon as
reasonably practicable. However, Recipient’s obligations under this Agreement
and any licenses granted by Recipient relating to the Program shall continue
and survive.

Everyone is permitted to copy and distribute copies of this Agreement, but in
order to avoid inconsistency the Agreement is copyrighted and may only be
modified in the following manner. The Agreement Steward reserves the right to
publish new versions (including revisions) of this Agreement from time to time.
No one other than the Agreement Steward has the right to modify this Agreement.
The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation may assign the responsibility to
serve as the Agreement Steward to a suitable separate entity. Each new version
of the Agreement will be given a distinguishing version number. The Program
(including Contributions) may always be distributed subject to the version of
the Agreement under which it was received. In addition, after a new version of
the Agreement is published, Contributor may elect to distribute the Program
(including its Contributions) under the new version. Except as expressly stated
in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
the intellectual property of any Contributor under this Agreement, whether
expressly, by implication, estoppel or otherwise. All rights in the Program not
expressly granted under this Agreement are reserved.

This Agreement is governed by the laws of the State of New York and the
intellectual property laws of the United States of America. No party to this
Agreement will bring a legal action under this Agreement more than one year
after the cause of action arose. Each party waives its rights to a jury trial
in any resulting litigation.