Showing preview only (2,027K chars total). Download the full file or copy to clipboard to get everything.
Repository: junit-team/junit4
Branch: main
Commit: 71c33ce55523
Files: 560
Total size: 1.8 MB
Directory structure:
gitextract_yvgvpu6o/
├── .gitattributes
├── .github/
│ ├── ISSUE_TEMPLATE/
│ │ ├── bug_report.md
│ │ └── config.yml
│ ├── PULL_REQUEST_TEMPLATE.md
│ └── workflows/
│ ├── main.yml
│ └── settings.xml
├── .gitignore
├── .mvn/
│ └── wrapper/
│ └── maven-wrapper.properties
├── .settings/
│ ├── org.eclipse.jdt.core.prefs
│ └── org.eclipse.jdt.ui.prefs
├── BUILDING
├── CODING_STYLE.txt
├── CONTRIBUTING.md
├── KEYS
├── LEGACY_CODING_STYLE.txt
├── LICENSE-junit.txt
├── NOTICE.txt
├── README.md
├── SECURITY.md
├── acknowledgements.txt
├── doc/
│ ├── ReleaseNotes4.10.html
│ ├── ReleaseNotes4.10.md
│ ├── ReleaseNotes4.10.txt
│ ├── ReleaseNotes4.11.html
│ ├── ReleaseNotes4.11.md
│ ├── ReleaseNotes4.11.txt
│ ├── ReleaseNotes4.12.md
│ ├── ReleaseNotes4.13.1.md
│ ├── ReleaseNotes4.13.2.md
│ ├── ReleaseNotes4.13.md
│ ├── ReleaseNotes4.4.html
│ ├── ReleaseNotes4.4.md
│ ├── ReleaseNotes4.4.txt
│ ├── ReleaseNotes4.5.html
│ ├── ReleaseNotes4.5.md
│ ├── ReleaseNotes4.5.txt
│ ├── ReleaseNotes4.6.html
│ ├── ReleaseNotes4.6.md
│ ├── ReleaseNotes4.6.txt
│ ├── ReleaseNotes4.7.html
│ ├── ReleaseNotes4.7.md
│ ├── ReleaseNotes4.7.txt
│ ├── ReleaseNotes4.8.1.html
│ ├── ReleaseNotes4.8.1.md
│ ├── ReleaseNotes4.8.1.txt
│ ├── ReleaseNotes4.8.2.html
│ ├── ReleaseNotes4.8.2.md
│ ├── ReleaseNotes4.8.2.txt
│ ├── ReleaseNotes4.8.html
│ ├── ReleaseNotes4.8.md
│ ├── ReleaseNotes4.8.txt
│ ├── ReleaseNotes4.9.1.md
│ ├── ReleaseNotes4.9.1.txt
│ ├── ReleaseNotes4.9.html
│ ├── ReleaseNotes4.9.md
│ ├── ReleaseNotes4.9.txt
│ ├── building-junit.txt
│ ├── cookstour/
│ │ └── cookstour.htm
│ ├── markdown.sh
│ └── testinfected/
│ └── testing.htm
├── epl-v10.html
├── mvnw
├── mvnw.cmd
├── pom.xml
├── src/
│ ├── main/
│ │ ├── java/
│ │ │ ├── junit/
│ │ │ │ ├── extensions/
│ │ │ │ │ ├── ActiveTestSuite.java
│ │ │ │ │ ├── RepeatedTest.java
│ │ │ │ │ ├── TestDecorator.java
│ │ │ │ │ ├── TestSetup.java
│ │ │ │ │ └── package-info.java
│ │ │ │ ├── framework/
│ │ │ │ │ ├── Assert.java
│ │ │ │ │ ├── AssertionFailedError.java
│ │ │ │ │ ├── ComparisonCompactor.java
│ │ │ │ │ ├── ComparisonFailure.java
│ │ │ │ │ ├── JUnit4TestAdapter.java
│ │ │ │ │ ├── JUnit4TestAdapterCache.java
│ │ │ │ │ ├── JUnit4TestCaseFacade.java
│ │ │ │ │ ├── Protectable.java
│ │ │ │ │ ├── Test.java
│ │ │ │ │ ├── TestCase.java
│ │ │ │ │ ├── TestFailure.java
│ │ │ │ │ ├── TestListener.java
│ │ │ │ │ ├── TestResult.java
│ │ │ │ │ ├── TestSuite.java
│ │ │ │ │ └── package-info.java
│ │ │ │ ├── runner/
│ │ │ │ │ ├── BaseTestRunner.java
│ │ │ │ │ ├── TestRunListener.java
│ │ │ │ │ ├── Version.java
│ │ │ │ │ ├── Version.java.template
│ │ │ │ │ └── package-info.java
│ │ │ │ └── textui/
│ │ │ │ ├── ResultPrinter.java
│ │ │ │ ├── TestRunner.java
│ │ │ │ └── package-info.java
│ │ │ └── org/
│ │ │ └── junit/
│ │ │ ├── After.java
│ │ │ ├── AfterClass.java
│ │ │ ├── Assert.java
│ │ │ ├── Assume.java
│ │ │ ├── AssumptionViolatedException.java
│ │ │ ├── Before.java
│ │ │ ├── BeforeClass.java
│ │ │ ├── ClassRule.java
│ │ │ ├── ComparisonFailure.java
│ │ │ ├── FixMethodOrder.java
│ │ │ ├── Ignore.java
│ │ │ ├── Rule.java
│ │ │ ├── Test.java
│ │ │ ├── TestCouldNotBeSkippedException.java
│ │ │ ├── experimental/
│ │ │ │ ├── ParallelComputer.java
│ │ │ │ ├── categories/
│ │ │ │ │ ├── Categories.java
│ │ │ │ │ ├── Category.java
│ │ │ │ │ ├── CategoryFilterFactory.java
│ │ │ │ │ ├── CategoryValidator.java
│ │ │ │ │ ├── ExcludeCategories.java
│ │ │ │ │ └── IncludeCategories.java
│ │ │ │ ├── max/
│ │ │ │ │ ├── CouldNotReadCoreException.java
│ │ │ │ │ ├── MaxCore.java
│ │ │ │ │ └── MaxHistory.java
│ │ │ │ ├── results/
│ │ │ │ │ ├── FailureList.java
│ │ │ │ │ ├── PrintableResult.java
│ │ │ │ │ └── ResultMatchers.java
│ │ │ │ ├── runners/
│ │ │ │ │ └── Enclosed.java
│ │ │ │ └── theories/
│ │ │ │ ├── DataPoint.java
│ │ │ │ ├── DataPoints.java
│ │ │ │ ├── FromDataPoints.java
│ │ │ │ ├── ParameterSignature.java
│ │ │ │ ├── ParameterSupplier.java
│ │ │ │ ├── ParametersSuppliedBy.java
│ │ │ │ ├── PotentialAssignment.java
│ │ │ │ ├── Theories.java
│ │ │ │ ├── Theory.java
│ │ │ │ ├── internal/
│ │ │ │ │ ├── AllMembersSupplier.java
│ │ │ │ │ ├── Assignments.java
│ │ │ │ │ ├── BooleanSupplier.java
│ │ │ │ │ ├── EnumSupplier.java
│ │ │ │ │ ├── ParameterizedAssertionError.java
│ │ │ │ │ └── SpecificDataPointsSupplier.java
│ │ │ │ └── suppliers/
│ │ │ │ ├── TestedOn.java
│ │ │ │ └── TestedOnSupplier.java
│ │ │ ├── function/
│ │ │ │ └── ThrowingRunnable.java
│ │ │ ├── internal/
│ │ │ │ ├── ArrayComparisonFailure.java
│ │ │ │ ├── AssumptionViolatedException.java
│ │ │ │ ├── Checks.java
│ │ │ │ ├── Classes.java
│ │ │ │ ├── ComparisonCriteria.java
│ │ │ │ ├── ExactComparisonCriteria.java
│ │ │ │ ├── InexactComparisonCriteria.java
│ │ │ │ ├── JUnitSystem.java
│ │ │ │ ├── MethodSorter.java
│ │ │ │ ├── RealSystem.java
│ │ │ │ ├── SerializableMatcherDescription.java
│ │ │ │ ├── SerializableValueDescription.java
│ │ │ │ ├── TextListener.java
│ │ │ │ ├── Throwables.java
│ │ │ │ ├── builders/
│ │ │ │ │ ├── AllDefaultPossibilitiesBuilder.java
│ │ │ │ │ ├── AnnotatedBuilder.java
│ │ │ │ │ ├── IgnoredBuilder.java
│ │ │ │ │ ├── IgnoredClassRunner.java
│ │ │ │ │ ├── JUnit3Builder.java
│ │ │ │ │ ├── JUnit4Builder.java
│ │ │ │ │ ├── NullBuilder.java
│ │ │ │ │ └── SuiteMethodBuilder.java
│ │ │ │ ├── management/
│ │ │ │ │ ├── FakeRuntimeMXBean.java
│ │ │ │ │ ├── FakeThreadMXBean.java
│ │ │ │ │ ├── ManagementFactory.java
│ │ │ │ │ ├── ReflectiveRuntimeMXBean.java
│ │ │ │ │ ├── ReflectiveThreadMXBean.java
│ │ │ │ │ ├── RuntimeMXBean.java
│ │ │ │ │ └── ThreadMXBean.java
│ │ │ │ ├── matchers/
│ │ │ │ │ ├── StacktracePrintingMatcher.java
│ │ │ │ │ ├── ThrowableCauseMatcher.java
│ │ │ │ │ ├── ThrowableMessageMatcher.java
│ │ │ │ │ └── TypeSafeMatcher.java
│ │ │ │ ├── requests/
│ │ │ │ │ ├── ClassRequest.java
│ │ │ │ │ ├── FilterRequest.java
│ │ │ │ │ ├── MemoizingRequest.java
│ │ │ │ │ ├── OrderingRequest.java
│ │ │ │ │ ├── SortingRequest.java
│ │ │ │ │ └── package-info.java
│ │ │ │ └── runners/
│ │ │ │ ├── ClassRoadie.java
│ │ │ │ ├── ErrorReportingRunner.java
│ │ │ │ ├── FailedBefore.java
│ │ │ │ ├── InitializationError.java
│ │ │ │ ├── JUnit38ClassRunner.java
│ │ │ │ ├── JUnit4ClassRunner.java
│ │ │ │ ├── MethodRoadie.java
│ │ │ │ ├── MethodValidator.java
│ │ │ │ ├── SuiteMethod.java
│ │ │ │ ├── TestClass.java
│ │ │ │ ├── TestMethod.java
│ │ │ │ ├── model/
│ │ │ │ │ ├── EachTestNotifier.java
│ │ │ │ │ ├── MultipleFailureException.java
│ │ │ │ │ └── ReflectiveCallable.java
│ │ │ │ ├── package-info.java
│ │ │ │ ├── rules/
│ │ │ │ │ ├── RuleMemberValidator.java
│ │ │ │ │ └── ValidationError.java
│ │ │ │ └── statements/
│ │ │ │ ├── ExpectException.java
│ │ │ │ ├── Fail.java
│ │ │ │ ├── FailOnTimeout.java
│ │ │ │ ├── InvokeMethod.java
│ │ │ │ ├── RunAfters.java
│ │ │ │ └── RunBefores.java
│ │ │ ├── matchers/
│ │ │ │ ├── JUnitMatchers.java
│ │ │ │ └── package-info.java
│ │ │ ├── package-info.java
│ │ │ ├── rules/
│ │ │ │ ├── DisableOnDebug.java
│ │ │ │ ├── ErrorCollector.java
│ │ │ │ ├── ExpectedException.java
│ │ │ │ ├── ExpectedExceptionMatcherBuilder.java
│ │ │ │ ├── ExternalResource.java
│ │ │ │ ├── MethodRule.java
│ │ │ │ ├── RuleChain.java
│ │ │ │ ├── RunRules.java
│ │ │ │ ├── Stopwatch.java
│ │ │ │ ├── TemporaryFolder.java
│ │ │ │ ├── TestName.java
│ │ │ │ ├── TestRule.java
│ │ │ │ ├── TestWatcher.java
│ │ │ │ ├── TestWatchman.java
│ │ │ │ ├── Timeout.java
│ │ │ │ └── Verifier.java
│ │ │ ├── runner/
│ │ │ │ ├── Computer.java
│ │ │ │ ├── Describable.java
│ │ │ │ ├── Description.java
│ │ │ │ ├── FilterFactories.java
│ │ │ │ ├── FilterFactory.java
│ │ │ │ ├── FilterFactoryParams.java
│ │ │ │ ├── JUnitCommandLineParseResult.java
│ │ │ │ ├── JUnitCore.java
│ │ │ │ ├── OrderWith.java
│ │ │ │ ├── OrderWithValidator.java
│ │ │ │ ├── Request.java
│ │ │ │ ├── Result.java
│ │ │ │ ├── RunWith.java
│ │ │ │ ├── Runner.java
│ │ │ │ ├── manipulation/
│ │ │ │ │ ├── Alphanumeric.java
│ │ │ │ │ ├── Filter.java
│ │ │ │ │ ├── Filterable.java
│ │ │ │ │ ├── InvalidOrderingException.java
│ │ │ │ │ ├── NoTestsRemainException.java
│ │ │ │ │ ├── Orderable.java
│ │ │ │ │ ├── Orderer.java
│ │ │ │ │ ├── Ordering.java
│ │ │ │ │ ├── Sortable.java
│ │ │ │ │ ├── Sorter.java
│ │ │ │ │ └── package-info.java
│ │ │ │ ├── notification/
│ │ │ │ │ ├── Failure.java
│ │ │ │ │ ├── RunListener.java
│ │ │ │ │ ├── RunNotifier.java
│ │ │ │ │ ├── StoppedByUserException.java
│ │ │ │ │ ├── SynchronizedRunListener.java
│ │ │ │ │ └── package-info.java
│ │ │ │ └── package-info.java
│ │ │ ├── runners/
│ │ │ │ ├── AllTests.java
│ │ │ │ ├── BlockJUnit4ClassRunner.java
│ │ │ │ ├── JUnit4.java
│ │ │ │ ├── MethodSorters.java
│ │ │ │ ├── Parameterized.java
│ │ │ │ ├── ParentRunner.java
│ │ │ │ ├── RuleContainer.java
│ │ │ │ ├── Suite.java
│ │ │ │ ├── model/
│ │ │ │ │ ├── Annotatable.java
│ │ │ │ │ ├── FrameworkField.java
│ │ │ │ │ ├── FrameworkMember.java
│ │ │ │ │ ├── FrameworkMethod.java
│ │ │ │ │ ├── InitializationError.java
│ │ │ │ │ ├── InvalidTestClassError.java
│ │ │ │ │ ├── MemberValueConsumer.java
│ │ │ │ │ ├── MultipleFailureException.java
│ │ │ │ │ ├── NoGenericTypeParametersValidator.java
│ │ │ │ │ ├── RunnerBuilder.java
│ │ │ │ │ ├── RunnerScheduler.java
│ │ │ │ │ ├── Statement.java
│ │ │ │ │ ├── TestClass.java
│ │ │ │ │ └── TestTimedOutException.java
│ │ │ │ ├── package-info.java
│ │ │ │ └── parameterized/
│ │ │ │ ├── BlockJUnit4ClassRunnerWithParameters.java
│ │ │ │ ├── BlockJUnit4ClassRunnerWithParametersFactory.java
│ │ │ │ ├── ParametersRunnerFactory.java
│ │ │ │ └── TestWithParameters.java
│ │ │ └── validator/
│ │ │ ├── AnnotationValidator.java
│ │ │ ├── AnnotationValidatorFactory.java
│ │ │ ├── AnnotationsValidator.java
│ │ │ ├── PublicClassValidator.java
│ │ │ ├── TestClassValidator.java
│ │ │ └── ValidateWith.java
│ │ └── javadoc/
│ │ └── stylesheet.css
│ ├── site/
│ │ ├── fml/
│ │ │ └── faq.fml
│ │ ├── markdown/
│ │ │ └── cookbook.md
│ │ ├── resources/
│ │ │ ├── css/
│ │ │ │ ├── carousel.css
│ │ │ │ ├── junit-lambda.css
│ │ │ │ └── plain-links.css
│ │ │ └── scripts/
│ │ │ └── index.js
│ │ ├── site.xml
│ │ ├── xdoc/
│ │ │ └── index.xml
│ │ └── xhtml/
│ │ ├── junit-lambda-campaign.xhtml
│ │ ├── junit-lambda-contributors.xhtml
│ │ ├── junit-lambda-spending.xhtml
│ │ ├── junit-lambda.xhtml
│ │ └── junit5.xhtml
│ └── test/
│ ├── java/
│ │ ├── junit/
│ │ │ ├── samples/
│ │ │ │ ├── AllTests.java
│ │ │ │ ├── ListTest.java
│ │ │ │ ├── SimpleTest.java
│ │ │ │ ├── money/
│ │ │ │ │ ├── IMoney.java
│ │ │ │ │ ├── Money.java
│ │ │ │ │ ├── MoneyBag.java
│ │ │ │ │ ├── MoneyTest.java
│ │ │ │ │ └── package-info.java
│ │ │ │ └── package-info.java
│ │ │ └── tests/
│ │ │ ├── AllTests.java
│ │ │ ├── SampleJUnit3Tests.java
│ │ │ ├── WasRun.java
│ │ │ ├── extensions/
│ │ │ │ ├── ActiveTestTest.java
│ │ │ │ ├── AllTests.java
│ │ │ │ ├── ExtensionTest.java
│ │ │ │ ├── RepeatedTestTest.java
│ │ │ │ └── package-info.java
│ │ │ ├── framework/
│ │ │ │ ├── AllTests.java
│ │ │ │ ├── AssertTest.java
│ │ │ │ ├── AssertionFailedErrorTest.java
│ │ │ │ ├── ComparisonCompactorTest.java
│ │ │ │ ├── ComparisonFailureTest.java
│ │ │ │ ├── DoublePrecisionAssertTest.java
│ │ │ │ ├── Failure.java
│ │ │ │ ├── FloatAssertTest.java
│ │ │ │ ├── InheritedTestCase.java
│ │ │ │ ├── NoArgTestCaseTest.java
│ │ │ │ ├── NoTestCaseClass.java
│ │ │ │ ├── NoTestCases.java
│ │ │ │ ├── NotPublicTestCase.java
│ │ │ │ ├── NotVoidTestCase.java
│ │ │ │ ├── OneTestCase.java
│ │ │ │ ├── OverrideTestCase.java
│ │ │ │ ├── Success.java
│ │ │ │ ├── SuiteTest.java
│ │ │ │ ├── TestCaseTest.java
│ │ │ │ ├── TestImplementorTest.java
│ │ │ │ ├── TestListenerTest.java
│ │ │ │ ├── ThreeTestCases.java
│ │ │ │ └── package-info.java
│ │ │ ├── package-info.java
│ │ │ └── runner/
│ │ │ ├── AllTests.java
│ │ │ ├── BaseTestRunnerTest.java
│ │ │ ├── ResultTest.java
│ │ │ ├── StackFilterTest.java
│ │ │ ├── TextFeedbackTest.java
│ │ │ ├── TextRunnerSingleMethodTest.java
│ │ │ ├── TextRunnerTest.java
│ │ │ └── package-info.java
│ │ └── org/
│ │ └── junit/
│ │ ├── AssumptionViolatedExceptionTest.java
│ │ ├── experimental/
│ │ │ └── categories/
│ │ │ ├── AllCategoriesTests.java
│ │ │ ├── CategoriesAndParameterizedTest.java
│ │ │ ├── CategoryFilterFactoryTest.java
│ │ │ ├── CategoryTest.java
│ │ │ ├── CategoryValidatorTest.java
│ │ │ ├── JavadocTest.java
│ │ │ └── MultiCategoryTest.java
│ │ ├── internal/
│ │ │ ├── AllInternalTests.java
│ │ │ ├── ArrayComparisonFailureTest.java
│ │ │ ├── ChecksTest.java
│ │ │ ├── MethodSorterTest.java
│ │ │ ├── StackTracesTest.java
│ │ │ ├── builders/
│ │ │ │ └── AnnotatedBuilderTest.java
│ │ │ ├── matchers/
│ │ │ │ ├── StacktracePrintingMatcherTest.java
│ │ │ │ └── ThrowableCauseMatcherTest.java
│ │ │ └── runners/
│ │ │ ├── ErrorReportingRunnerTest.java
│ │ │ └── statements/
│ │ │ ├── ExpectExceptionTest.java
│ │ │ └── FailOnTimeoutTest.java
│ │ ├── rules/
│ │ │ ├── AllRulesTests.java
│ │ │ ├── BlockJUnit4ClassRunnerOverrideTest.java
│ │ │ ├── ClassRulesTest.java
│ │ │ ├── DisableOnDebugTest.java
│ │ │ ├── ErrorCollectorTest.java
│ │ │ ├── EventCollector.java
│ │ │ ├── ExpectedExceptionTest.java
│ │ │ ├── ExternalResourceRuleTest.java
│ │ │ ├── LoggingMethodRule.java
│ │ │ ├── LoggingStatement.java
│ │ │ ├── LoggingTestRule.java
│ │ │ ├── LoggingTestWatcher.java
│ │ │ ├── MethodRulesTest.java
│ │ │ ├── NameRulesTest.java
│ │ │ ├── RuleChainTest.java
│ │ │ ├── RuleMemberValidatorTest.java
│ │ │ ├── StopwatchTest.java
│ │ │ ├── TempFolderRuleTest.java
│ │ │ ├── TemporaryFolderRuleAssuredDeletionTest.java
│ │ │ ├── TemporaryFolderUsageTest.java
│ │ │ ├── TestRuleTest.java
│ │ │ ├── TestWatcherTest.java
│ │ │ ├── TestWatchmanTest.java
│ │ │ ├── TimeoutRuleTest.java
│ │ │ └── VerifierRuleTest.java
│ │ ├── runner/
│ │ │ ├── AllRunnerTests.java
│ │ │ ├── FilterFactoriesTest.java
│ │ │ ├── FilterOptionIntegrationTest.java
│ │ │ ├── JUnitCommandLineParseResultTest.java
│ │ │ ├── JUnitCoreTest.java
│ │ │ ├── MainRunner.java
│ │ │ ├── OrderWithValidatorTest.java
│ │ │ ├── RequestTest.java
│ │ │ ├── RunnerSpy.java
│ │ │ └── notification/
│ │ │ ├── AllNotificationTests.java
│ │ │ ├── ConcurrentRunNotifierTest.java
│ │ │ ├── RunNotifierTest.java
│ │ │ └── SynchronizedRunListenerTest.java
│ │ ├── runners/
│ │ │ ├── AllRunnersTests.java
│ │ │ ├── CustomBlockJUnit4ClassRunnerTest.java
│ │ │ ├── RuleContainerTest.java
│ │ │ ├── model/
│ │ │ │ ├── AllModelTests.java
│ │ │ │ ├── FrameworkFieldTest.java
│ │ │ │ ├── FrameworkMethodTest.java
│ │ │ │ ├── InvalidTestClassErrorTest.java
│ │ │ │ ├── RunnerBuilderStub.java
│ │ │ │ └── TestClassTest.java
│ │ │ └── parameterized/
│ │ │ ├── AllParameterizedTests.java
│ │ │ ├── BlockJUnit4ClassRunnerWithParametersTest.java
│ │ │ ├── ParameterizedNamesTest.java
│ │ │ └── TestWithParametersTest.java
│ │ ├── samples/
│ │ │ ├── AllSamplesTests.java
│ │ │ ├── ListTest.java
│ │ │ ├── SimpleTest.java
│ │ │ ├── money/
│ │ │ │ ├── MoneyTest.java
│ │ │ │ └── package-info.java
│ │ │ └── package-info.java
│ │ ├── tests/
│ │ │ ├── AllTests.java
│ │ │ ├── ObjectContractTest.java
│ │ │ ├── SampleJUnit4Tests.java
│ │ │ ├── TestSystem.java
│ │ │ ├── assertion/
│ │ │ │ ├── AllAssertionTests.java
│ │ │ │ ├── AssertionTest.java
│ │ │ │ ├── ComparisonFailureTest.java
│ │ │ │ └── MultipleFailureExceptionTest.java
│ │ │ ├── deprecated/
│ │ │ │ ├── AllDeprecatedTests.java
│ │ │ │ └── JUnit4ClassRunnerTest.java
│ │ │ ├── description/
│ │ │ │ ├── AllDescriptionTests.java
│ │ │ │ ├── AnnotatedDescriptionTest.java
│ │ │ │ ├── SuiteDescriptionTest.java
│ │ │ │ ├── TestDescriptionMethodNameTest.java
│ │ │ │ └── TestDescriptionTest.java
│ │ │ ├── experimental/
│ │ │ │ ├── AllExperimentalTests.java
│ │ │ │ ├── AssumptionTest.java
│ │ │ │ ├── MatcherTest.java
│ │ │ │ ├── max/
│ │ │ │ │ ├── AllMaxTests.java
│ │ │ │ │ ├── DescriptionTest.java
│ │ │ │ │ ├── JUnit38SortingTest.java
│ │ │ │ │ └── MaxStarterTest.java
│ │ │ │ ├── parallel/
│ │ │ │ │ ├── AllParallelTests.java
│ │ │ │ │ ├── ParallelClassTest.java
│ │ │ │ │ └── ParallelMethodTest.java
│ │ │ │ ├── results/
│ │ │ │ │ ├── AllResultsTests.java
│ │ │ │ │ ├── PrintableResultTest.java
│ │ │ │ │ └── ResultMatchersTest.java
│ │ │ │ └── theories/
│ │ │ │ ├── AllTheoriesTests.java
│ │ │ │ ├── AssumingInTheoriesTest.java
│ │ │ │ ├── ParameterSignatureTest.java
│ │ │ │ ├── PotentialAssignmentTest.java
│ │ │ │ ├── TestedOnSupplierTest.java
│ │ │ │ ├── TheoryTestUtils.java
│ │ │ │ ├── extendingwithstubs/
│ │ │ │ │ ├── Correspondent.java
│ │ │ │ │ ├── Guesser.java
│ │ │ │ │ ├── GuesserQueue.java
│ │ │ │ │ ├── MethodCall.java
│ │ │ │ │ ├── ReguessableValue.java
│ │ │ │ │ ├── StringableObject.java
│ │ │ │ │ ├── Stub.java
│ │ │ │ │ ├── StubbedTheories.java
│ │ │ │ │ └── StubbedTheoriesTest.java
│ │ │ │ ├── internal/
│ │ │ │ │ ├── AllMembersSupplierTest.java
│ │ │ │ │ ├── AllTheoriesInternalTests.java
│ │ │ │ │ ├── ParameterizedAssertionErrorTest.java
│ │ │ │ │ └── SpecificDataPointsSupplierTest.java
│ │ │ │ └── runner/
│ │ │ │ ├── AllTheoriesRunnerTests.java
│ │ │ │ ├── FailingDataPointMethods.java
│ │ │ │ ├── SuccessfulWithDataPointFields.java
│ │ │ │ ├── TheoriesPerformanceTest.java
│ │ │ │ ├── TypeMatchingBetweenMultiDataPointsMethod.java
│ │ │ │ ├── UnsuccessfulWithDataPointFields.java
│ │ │ │ ├── WhenNoParametersMatch.java
│ │ │ │ ├── WithAutoGeneratedDataPoints.java
│ │ │ │ ├── WithDataPointMethod.java
│ │ │ │ ├── WithExtendedParameterSources.java
│ │ │ │ ├── WithNamedDataPoints.java
│ │ │ │ ├── WithOnlyTestAnnotations.java
│ │ │ │ ├── WithParameterSupplier.java
│ │ │ │ └── WithUnresolvedGenericTypeVariablesOnTheoryParms.java
│ │ │ ├── junit3compatibility/
│ │ │ │ ├── AllJUnit3CompatibilityTests.java
│ │ │ │ ├── AllTestsTest.java
│ │ │ │ ├── ClassRequestTest.java
│ │ │ │ ├── ForwardCompatibilityPrintingTest.java
│ │ │ │ ├── ForwardCompatibilityTest.java
│ │ │ │ ├── InitializationErrorForwardCompatibilityTest.java
│ │ │ │ ├── JUnit38ClassRunnerTest.java
│ │ │ │ ├── JUnit4TestAdapterTest.java
│ │ │ │ ├── OldTestClassAdaptingListenerTest.java
│ │ │ │ ├── OldTests.java
│ │ │ │ └── SuiteMethodTest.java
│ │ │ ├── listening/
│ │ │ │ ├── AllListeningTests.java
│ │ │ │ ├── ListenerTest.java
│ │ │ │ ├── RunnerTest.java
│ │ │ │ ├── TestListenerTest.java
│ │ │ │ ├── TextListenerTest.java
│ │ │ │ └── UserStopTest.java
│ │ │ ├── manipulation/
│ │ │ │ ├── AllManipulationTests.java
│ │ │ │ ├── AlphanumericOrdering.java
│ │ │ │ ├── ComparatorBasedOrdering.java
│ │ │ │ ├── Comparators.java
│ │ │ │ ├── FilterTest.java
│ │ │ │ ├── FilterableTest.java
│ │ │ │ ├── OrderWithTest.java
│ │ │ │ ├── OrderableTest.java
│ │ │ │ ├── ReverseAlphanumericOrdering.java
│ │ │ │ ├── ReverseAlphanumericSorter.java
│ │ │ │ ├── SingleMethodTest.java
│ │ │ │ └── SortableTest.java
│ │ │ ├── package-info.java
│ │ │ ├── running/
│ │ │ │ ├── AllRunningTests.java
│ │ │ │ ├── classes/
│ │ │ │ │ ├── AllClassesTests.java
│ │ │ │ │ ├── BlockJUnit4ClassRunnerTest.java
│ │ │ │ │ ├── ClassLevelMethodsWithIgnoredTestsTest.java
│ │ │ │ │ ├── EnclosedTest.java
│ │ │ │ │ ├── IgnoreClassTest.java
│ │ │ │ │ ├── ParameterizedTestTest.java
│ │ │ │ │ ├── ParentRunnerFilteringTest.java
│ │ │ │ │ ├── ParentRunnerTest.java
│ │ │ │ │ ├── RunWithTest.java
│ │ │ │ │ ├── SuiteTest.java
│ │ │ │ │ ├── ThreadsTest.java
│ │ │ │ │ ├── UseSuiteAsASuperclassTest.java
│ │ │ │ │ └── parent/
│ │ │ │ │ ├── ParentRunnerClassLoaderTest.java
│ │ │ │ │ └── TestWithClassRule.java
│ │ │ │ ├── core/
│ │ │ │ │ ├── AllCoreTests.java
│ │ │ │ │ ├── CommandLineTest.java
│ │ │ │ │ ├── JUnitCoreReturnsCorrectExitCodeTest.java
│ │ │ │ │ └── SystemExitTest.java
│ │ │ │ └── methods/
│ │ │ │ ├── AllMethodsTests.java
│ │ │ │ ├── AnnotationTest.java
│ │ │ │ ├── ExpectedTest.java
│ │ │ │ ├── InheritedTestTest.java
│ │ │ │ ├── ParameterizedTestMethodTest.java
│ │ │ │ ├── TestMethodTest.java
│ │ │ │ └── TimeoutTest.java
│ │ │ └── validation/
│ │ │ ├── AllValidationTests.java
│ │ │ ├── BadlyFormedClassesTest.java
│ │ │ ├── FailedConstructionTest.java
│ │ │ ├── ValidationTest.java
│ │ │ └── anotherpackage/
│ │ │ ├── Sub.java
│ │ │ └── Super.java
│ │ └── validator/
│ │ ├── AllValidatorTests.java
│ │ ├── AnnotationValidatorFactoryTest.java
│ │ ├── AnnotationsValidatorTest.java
│ │ └── PublicClassValidatorTest.java
│ └── resources/
│ ├── junit/
│ │ └── tests/
│ │ └── runner/
│ │ ├── testRunAssumptionFailedResultCanBeReserialised_v4_12
│ │ ├── testRunAssumptionFailedResultCanBeReserialised_v4_13
│ │ ├── testRunFailureResultCanBeReserialised_v4_12
│ │ ├── testRunSuccessResultCanBeReserialised_v4_12
│ │ └── testRunSuccessResultCanBeReserialised_v4_13
│ └── org/
│ └── junit/
│ ├── assumptionViolatedExceptionWithValueAndMatcherCanBeReserialized_v4_13
│ ├── assumptionViolatedExceptionWithoutValueAndMatcherCanBeReserialized_v4_13
│ └── internal/
│ ├── arrayComparisonFailure_411
│ └── arrayComparisonFailure_412
└── to-do.txt
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitattributes
================================================
* text eol=lf
*.gif binary
*.GIF binary
*.jar binary
*.png binary
*.jpg binary
*.svg text eol=lf
# These files do not have unix line endings. Do not normalize them for now.
# Will fix these right before we cut JUnit 4.13.
/src/main/java/org/junit/experimental/categories/CategoryFilterFactory.java -text
/src/main/java/org/junit/experimental/categories/ExcludeCategories.java -text
/src/main/java/org/junit/experimental/categories/IncludeCategories.java -text
/src/main/java/org/junit/internal/Classes.java -text
/src/main/java/org/junit/runner/FilterFactories.java -text
/src/main/java/org/junit/runner/FilterFactory.java -text
/src/main/java/org/junit/runner/FilterFactoryParams.java -text
/src/main/java/org/junit/runner/JUnitCommandLineParseResult.java -text
/src/test/java/org/junit/experimental/categories/CategoryFilterFactoryTest.java -text
/src/test/java/org/junit/runner/FilterFactoriesTest.java -text
/src/test/java/org/junit/runner/JUnitCommandLineParseResultTest.java -text
================================================
FILE: .github/ISSUE_TEMPLATE/bug_report.md
================================================
---
name: Report a critical bug
about: Please only report critical bugs since the project is in maintenance mode
type: Bug
---
> [!IMPORTANT]
> **JUnit 4 is in maintenance mode.**
>
> At this point, only critical bugs and security issues will be fixed.<br>
> All other issues and PRs will therefore be declined.<br>
> For ongoing development, please check out the [junit-framework](https://github.com/junit-team/junit-framework/) repository.
================================================
FILE: .github/ISSUE_TEMPLATE/config.yml
================================================
blank_issues_enabled: false
================================================
FILE: .github/PULL_REQUEST_TEMPLATE.md
================================================
> [!IMPORTANT]
> **JUnit 4 is in maintenance mode.**
>
> At this point, only critical bugs and security issues will be fixed.<br>
> All other issues and PRs will therefore be declined.<br>
> For ongoing development, please check out the [junit-framework](https://github.com/junit-team/junit-framework/) repository.
## Overview
<!-- Please describe your changes here and list any open questions you might have. -->
================================================
FILE: .github/workflows/main.yml
================================================
name: CI
on:
push:
branches:
- main
pull_request:
branches:
- '*'
permissions:
contents: read # to fetch code (actions/checkout)
jobs:
build-and-verify:
name: Build and verify (JDK ${{ matrix.java }})
runs-on: ubuntu-latest
strategy:
fail-fast: false
matrix:
java: ['8', '11', '17', '21']
steps:
- uses: actions/checkout@v2
- name: Download Maven # Download with default JDK because OpenJDK 6 does not support TLS 1.2
run: ./mvnw --version
- name: Set up JDK 6
if: ${{ matrix.java == '6'}}
uses: actions/setup-java@v4
with:
java-version: ${{ matrix.java }}
distribution: temurin
- name: Set up JDK
if: ${{ matrix.java != '6'}}
uses: actions/setup-java@v4
with:
java-version: ${{ matrix.java }}
distribution: temurin
cache: maven
- name: Build and verify
run: ./mvnw verify javadoc:javadoc site:site --batch-mode --errors --settings .github/workflows/settings.xml
publish-snapshots:
name: Publish snapshot artifacts
if: github.event_name == 'push' && github.repository == 'junit-team/junit4' && github.ref == 'refs/heads/main'
needs: build-and-verify
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Download Maven # Download with default JDK because OpenJDK 6 does not support TLS 1.2
run: ./mvnw --version
- name: Set up JDK
uses: actions/setup-java@v4
with:
java-version: 8
distribution: temurin
- name: Publish snapshot artifacts
env:
MAVEN_CENTRAL_USERNAME: ${{ secrets.MAVEN_CENTRAL_USERNAME }}
MAVEN_CENTRAL_PASSWORD: ${{ secrets.MAVEN_CENTRAL_PASSWORD }}
run: ./mvnw deploy --batch-mode --errors --activate-profiles generate-docs --settings .github/workflows/settings.xml
================================================
FILE: .github/workflows/settings.xml
================================================
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 https://maven.apache.org/xsd/settings-1.0.0.xsd">
<servers>
<server>
<id>central-portal</id>
<username>${env.MAVEN_CENTRAL_USERNAME}</username>
<password>${env.MAVEN_CENTRAL_PASSWORD}</password>
</server>
</servers>
</settings>
================================================
FILE: .gitignore
================================================
MaxCore.ser
bin
junit4.*
target
MaxCore.max
# IntelliJ
.idea
*.ipr
*.iml
*.iws
out
java.hprof.txt
.DS_Store
================================================
FILE: .mvn/wrapper/maven-wrapper.properties
================================================
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
wrapperVersion=3.3.1
distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.6/apache-maven-3.9.6-bin.zip
================================================
FILE: .settings/org.eclipse.jdt.core.prefs
================================================
#Mon Oct 12 21:57:10 EDT 2009
eclipse.preferences.version=1
org.eclipse.jdt.core.codeComplete.argumentPrefixes=
org.eclipse.jdt.core.codeComplete.argumentSuffixes=
org.eclipse.jdt.core.codeComplete.fieldPrefixes=f
org.eclipse.jdt.core.codeComplete.fieldSuffixes=
org.eclipse.jdt.core.codeComplete.localPrefixes=
org.eclipse.jdt.core.codeComplete.localSuffixes=
org.eclipse.jdt.core.codeComplete.staticFieldPrefixes=
org.eclipse.jdt.core.codeComplete.staticFieldSuffixes=
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
org.eclipse.jdt.core.compiler.compliance=1.5
org.eclipse.jdt.core.compiler.debug.lineNumber=generate
org.eclipse.jdt.core.compiler.debug.localVariable=generate
org.eclipse.jdt.core.compiler.debug.sourceFile=generate
org.eclipse.jdt.core.compiler.doc.comment.support=enabled
org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning
org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
org.eclipse.jdt.core.compiler.problem.autoboxing=ignore
org.eclipse.jdt.core.compiler.problem.comparingIdentical=warning
org.eclipse.jdt.core.compiler.problem.deadCode=warning
org.eclipse.jdt.core.compiler.problem.deprecation=warning
org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled
org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=disabled
org.eclipse.jdt.core.compiler.problem.discouragedReference=ignore
org.eclipse.jdt.core.compiler.problem.emptyStatement=ignore
org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
org.eclipse.jdt.core.compiler.problem.fallthroughCase=ignore
org.eclipse.jdt.core.compiler.problem.fatalOptionalError=enabled
org.eclipse.jdt.core.compiler.problem.fieldHiding=ignore
org.eclipse.jdt.core.compiler.problem.finalParameterBound=warning
org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=warning
org.eclipse.jdt.core.compiler.problem.forbiddenReference=error
org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=warning
org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=warning
org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=ignore
org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=ignore
org.eclipse.jdt.core.compiler.problem.invalidJavadoc=warning
org.eclipse.jdt.core.compiler.problem.invalidJavadocTags=disabled
org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsDeprecatedRef=disabled
org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsNotVisibleRef=disabled
org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility=protected
org.eclipse.jdt.core.compiler.problem.localVariableHiding=ignore
org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=warning
org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=warning
org.eclipse.jdt.core.compiler.problem.missingHashCodeMethod=ignore
org.eclipse.jdt.core.compiler.problem.missingJavadocComments=ignore
org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding=disabled
org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility=protected
org.eclipse.jdt.core.compiler.problem.missingJavadocTagDescription=no_tag
org.eclipse.jdt.core.compiler.problem.missingJavadocTags=ignore
org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding=disabled
org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility=protected
org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation=warning
org.eclipse.jdt.core.compiler.problem.missingSerialVersion=warning
org.eclipse.jdt.core.compiler.problem.missingSynchronizedOnInheritedMethod=ignore
org.eclipse.jdt.core.compiler.problem.noEffectAssignment=warning
org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=warning
org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=ignore
org.eclipse.jdt.core.compiler.problem.nullReference=warning
org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=warning
org.eclipse.jdt.core.compiler.problem.parameterAssignment=ignore
org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=ignore
org.eclipse.jdt.core.compiler.problem.potentialNullReference=ignore
org.eclipse.jdt.core.compiler.problem.rawTypeReference=warning
org.eclipse.jdt.core.compiler.problem.redundantNullCheck=ignore
org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=warning
org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled
org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=warning
org.eclipse.jdt.core.compiler.problem.suppressWarnings=enabled
org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=ignore
org.eclipse.jdt.core.compiler.problem.typeParameterHiding=warning
org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation=warning
org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=ignore
org.eclipse.jdt.core.compiler.problem.unhandledWarningToken=warning
org.eclipse.jdt.core.compiler.problem.unnecessaryElse=ignore
org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=warning
org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore
org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=warning
org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionExemptExceptionAndThrowable=enabled
org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionIncludeDocCommentReference=enabled
org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=disabled
org.eclipse.jdt.core.compiler.problem.unusedImport=warning
org.eclipse.jdt.core.compiler.problem.unusedLabel=warning
org.eclipse.jdt.core.compiler.problem.unusedLocal=warning
org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore
org.eclipse.jdt.core.compiler.problem.unusedParameterIncludeDocCommentReference=enabled
org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract=disabled
org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete=disabled
org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=warning
org.eclipse.jdt.core.compiler.problem.unusedWarningToken=warning
org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
org.eclipse.jdt.core.compiler.source=1.5
org.eclipse.jdt.core.compiler.taskCaseSensitive=enabled
org.eclipse.jdt.core.compiler.taskPriorities=NORMAL,NORMAL,HIGH,NORMAL
org.eclipse.jdt.core.compiler.taskTags=TODO,REVISIT,HACK,QUESTION
org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant=16
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call=16
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation=16
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression=16
org.eclipse.jdt.core.formatter.alignment_for_assignment=0
org.eclipse.jdt.core.formatter.alignment_for_binary_expression=16
org.eclipse.jdt.core.formatter.alignment_for_compact_if=16
org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=80
org.eclipse.jdt.core.formatter.alignment_for_enum_constants=0
org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer=16
org.eclipse.jdt.core.formatter.alignment_for_multiple_fields=16
org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration=16
org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration=16
org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation=16
org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration=16
org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration=16
org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration=16
org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration=16
org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration=16
org.eclipse.jdt.core.formatter.blank_lines_after_imports=1
org.eclipse.jdt.core.formatter.blank_lines_after_package=1
org.eclipse.jdt.core.formatter.blank_lines_before_field=1
org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration=0
org.eclipse.jdt.core.formatter.blank_lines_before_imports=1
org.eclipse.jdt.core.formatter.blank_lines_before_member_type=1
org.eclipse.jdt.core.formatter.blank_lines_before_method=1
org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk=1
org.eclipse.jdt.core.formatter.blank_lines_before_package=0
org.eclipse.jdt.core.formatter.blank_lines_between_import_groups=1
org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations=1
org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration=end_of_line
org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration=end_of_line
org.eclipse.jdt.core.formatter.brace_position_for_array_initializer=end_of_line
org.eclipse.jdt.core.formatter.brace_position_for_block=end_of_line
org.eclipse.jdt.core.formatter.brace_position_for_block_in_case=end_of_line
org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration=end_of_line
org.eclipse.jdt.core.formatter.brace_position_for_enum_constant=end_of_line
org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration=end_of_line
org.eclipse.jdt.core.formatter.brace_position_for_method_declaration=end_of_line
org.eclipse.jdt.core.formatter.brace_position_for_switch=end_of_line
org.eclipse.jdt.core.formatter.brace_position_for_type_declaration=end_of_line
org.eclipse.jdt.core.formatter.comment.clear_blank_lines=false
org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment=false
org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment=false
org.eclipse.jdt.core.formatter.comment.format_block_comments=true
org.eclipse.jdt.core.formatter.comment.format_comments=true
org.eclipse.jdt.core.formatter.comment.format_header=false
org.eclipse.jdt.core.formatter.comment.format_html=true
org.eclipse.jdt.core.formatter.comment.format_javadoc_comments=true
org.eclipse.jdt.core.formatter.comment.format_line_comments=true
org.eclipse.jdt.core.formatter.comment.format_source_code=true
org.eclipse.jdt.core.formatter.comment.indent_parameter_description=true
org.eclipse.jdt.core.formatter.comment.indent_root_tags=true
org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags=insert
org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=insert
org.eclipse.jdt.core.formatter.comment.line_length=80
org.eclipse.jdt.core.formatter.compact_else_if=true
org.eclipse.jdt.core.formatter.continuation_indentation=2
org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer=2
org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line=false
org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header=true
org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header=true
org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header=true
org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header=true
org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases=true
org.eclipse.jdt.core.formatter.indent_empty_lines=false
org.eclipse.jdt.core.formatter.indent_statements_compare_to_block=true
org.eclipse.jdt.core.formatter.indent_statements_compare_to_body=true
org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases=true
org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch=false
org.eclipse.jdt.core.formatter.indentation.size=4
org.eclipse.jdt.core.formatter.insert_new_line_after_annotation=insert
org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable=insert
org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_member=insert
org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter=do not insert
org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer=do not insert
org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing=do not insert
org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement=do not insert
org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer=do not insert
org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement=do not insert
org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement=do not insert
org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement=do not insert
org.eclipse.jdt.core.formatter.insert_new_line_in_empty_annotation_declaration=insert
org.eclipse.jdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration=insert
org.eclipse.jdt.core.formatter.insert_new_line_in_empty_block=insert
org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_constant=insert
org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_declaration=insert
org.eclipse.jdt.core.formatter.insert_new_line_in_empty_method_body=insert
org.eclipse.jdt.core.formatter.insert_new_line_in_empty_type_declaration=insert
org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter=insert
org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator=insert
org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation=do not insert
org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration=do not insert
org.eclipse.jdt.core.formatter.insert_space_after_binary_operator=insert
org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments=insert
org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters=insert
org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block=insert
org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast=insert
org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert=insert
org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case=insert
org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional=insert
org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for=insert
org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement=insert
org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression=insert
org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation=insert
org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer=insert
org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters=insert
org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws=insert
org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments=insert
org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations=insert
org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments=insert
org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments=insert
org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits=insert
org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters=insert
org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws=insert
org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments=insert
org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations=insert
org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations=insert
org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference=insert
org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces=insert
org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments=insert
org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters=insert
org.eclipse.jdt.core.formatter.insert_space_after_ellipsis=insert
org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference=do not insert
org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments=do not insert
org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters=do not insert
org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer=insert
org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression=do not insert
org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference=do not insert
org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation=do not insert
org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast=do not insert
org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch=do not insert
org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration=do not insert
org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant=do not insert
org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for=do not insert
org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if=do not insert
org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration=do not insert
org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation=do not insert
org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression=do not insert
org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch=do not insert
org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized=do not insert
org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while=do not insert
org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator=do not insert
org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator=do not insert
org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional=insert
org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard=do not insert
org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for=insert
org.eclipse.jdt.core.formatter.insert_space_after_unary_operator=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter=insert
org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator=insert
org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration=insert
org.eclipse.jdt.core.formatter.insert_space_before_binary_operator=insert
org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer=insert
org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert=insert
org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional=insert
org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for=insert
org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_ellipsis=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration=insert
org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration=insert
org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer=insert
org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block=insert
org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration=insert
org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant=insert
org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration=insert
org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration=insert
org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch=insert
org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration=insert
org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch=insert
org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for=insert
org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if=insert
org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch=insert
org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized=insert
org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while=insert
org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return=insert
org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_throw=insert
org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional=insert
org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_semicolon=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for=do not insert
org.eclipse.jdt.core.formatter.insert_space_before_unary_operator=do not insert
org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference=do not insert
org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer=do not insert
org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression=do not insert
org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration=do not insert
org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration=do not insert
org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant=do not insert
org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration=do not insert
org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation=do not insert
org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line=false
org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line=false
org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line=false
org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line=false
org.eclipse.jdt.core.formatter.lineSplit=80
org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column=false
org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column=false
org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body=0
org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve=1
org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line=true
org.eclipse.jdt.core.formatter.tabulation.char=space
org.eclipse.jdt.core.formatter.tabulation.size=4
org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations=false
org.eclipse.jdt.core.formatter.wrap_before_binary_operator=true
================================================
FILE: .settings/org.eclipse.jdt.ui.prefs
================================================
#Tue Jul 22 09:31:38 PDT 2008
eclipse.preferences.version=1
formatter_profile=_junit
formatter_settings_version=11
internal.default.compliance=default
org.eclipse.jdt.ui.exception.name=e
org.eclipse.jdt.ui.gettersetter.use.is=true
org.eclipse.jdt.ui.ignorelowercasenames=true
org.eclipse.jdt.ui.importorder=java;javax;com;
org.eclipse.jdt.ui.keywordthis=false
org.eclipse.jdt.ui.ondemandthreshold=99
org.eclipse.jdt.ui.overrideannotation=true
org.eclipse.jdt.ui.text.custom_code_templates=<?xml version\="1.0" encoding\="UTF-8" standalone\="no"?><templates/>
================================================
FILE: BUILDING
================================================
BUILDING FROM GITHUB:
=====================
git clone https://github.com/junit-team/junit4.git
cd junit4
mvn install
BUILDING FROM JARS OR ZIPS:
===========================
The contents of the zip and jar files are largely maintained for historical
reasons. We do not at this time have an official way to build from the src
jar or zip. If this is an important missing feature, please let us know
at http://github.com/junit-team/junit4/issues
================================================
FILE: CODING_STYLE.txt
================================================
JUnit project uses the Google Java Style (https://github.com/google/styleguide) for all new
code (under org.junit.*). Deviating from this, indentation is 4 spaces instead of 2.
Be sure to set text file encoding to UTF-8 and line delimiters to UNIX style.
Since not all code has been formatted yet, please format only code lines you changed to avoid extraneous changes.
Legacy code (under junit.*) used the legacy guide specified in LEGACY_CODING_STYLE.txt in the
project root.
================================================
FILE: CONTRIBUTING.md
================================================
## Project License: Eclipse Public License v1.0
- You will only Submit Contributions where You have authored 100% of the content.
- You will only Submit Contributions to which You have the necessary rights. This means that if You are employed You have received the necessary permissions from Your employer to make the Contributions.
- Whatever content You Contribute will be provided under the Project License(s).
## Building
### Command line
You need to have Maven and a JDK (at least version 1.5) installed.
Run `./mvnw verify` to build the code and run the tests
### Eclipse
Maven can generate project files for Eclipse. See [these instructions](https://mkyong.com/maven/how-to-convert-maven-java-project-to-support-eclipse-ide/) for details.
## Coding Conventions
### Formatting
See [CODING_STYLE.txt](CODING_STYLE.txt) for how we format our code.
## How to submit a pull request
We love pull requests. Here is a quick guide:
1. You need to have Maven and a JDK (at least version 1.5) installed.
2. [Fork the repo](https://help.github.com/articles/fork-a-repo).
3. [Create a new branch](https://help.github.com/articles/creating-and-deleting-branches-within-your-repository/) from `main`.
4. Ensure that you have a clean state by running `./mvnw verify`.
5. Add your change together with a test (tests are not needed for refactorings and documentation changes).
6. Format your code: Import the JUnit project in Eclipse and use its formatter or apply the rules in the `CODING_STYLE` file manually. Only format the code you've changed; reformatting unrelated code makes it harder for us to review your changes.
7. Run `./mvnw verify` again and ensure all tests are passing.
8. Push to your fork and [submit a pull request](https://help.github.com/articles/creating-a-pull-request/).
Now you are waiting on us. We review your pull request and at least leave some comments.
Note that if you are thinking of providing a fix for one of the bugs or feature requests, it's usually
a good idea to add a comment to the bug to make sure that there's agreement on how we should proceed.
## Limitations
The JUnit team is not accepting changes to the code under the following paths:
* `src/main/java/junit`
* `test/java/junit/tests/framework`
* `test/java/junit/tests/extensions`
The reasoning is that the JUnit team feels that our users should focus on using either the JUnit4 or JUnit5 APIs.
The team is also reluctant to accept changes that only update code from one code style to another.
Generally the code in JUnit was approved by at least one person, so two people agreed that the style was reasonable.
To find other places where you can have an impact, please see the [Issues tagged "up-for-grabs"](https://github.com/junit-team/junit4/issues?q=is%3Aissue+is%3Aopen+label%3Aup-for-grabs).
================================================
FILE: KEYS
================================================
This file contains the PGP key that is used to sign releases.
Importing: `pgp < KEYS` or `gpg --import KEYS`
Adding a key:
`pgp -kxa <your name> >> KEYS`,
or `(pgpk -ll <your name> && pgpk -xa <your name>) >> KEYS`,
or `(gpg --list-sigs <your name> && gpg --armor --export <your name>) >> KEYS`
================================
pub rsa4096 2018-04-08 [SC]
FF6E2C001948C5F2F38B0CC385911F425EC61B51
uid [ unknown] Open Source Development <mail@marcphilipp.de>
sig 3 85911F425EC61B51 2018-04-08 Open Source Development <mail@marcphilipp.de>
sub rsa4096 2018-04-08 [E]
sig 85911F425EC61B51 2018-04-08 Open Source Development <mail@marcphilipp.de>
-----BEGIN PGP PUBLIC KEY BLOCK-----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=l0XA
-----END PGP PUBLIC KEY BLOCK-----
================================================
FILE: LEGACY_CODING_STYLE.txt
================================================
==================================
Coding style
==================================
----------------------------------
Tabs and Indents
----------------------------------
* Tab size : 4
* Indent : 4
* Continuation indent : 8
* Label indent : 0
> Don't use tab characters.
----------------------------------
Spaces
----------------------------------
Before Parentheses
* if parentheses
* for parentheses
* while parentheses
* switch parentheses
* try parentheses
* catch parentheses
* synchronized parentheses
Around Operators
* Assignment operators (=, +=, …)
* Logical operators (&&, ||)
* Equality operators (==, !=)
* Relational operators (<, >, <=, >=)
* Bitwise operators (&, |, ^)
* Additive operators (+, -)
* Multiplicative operators (*, /, %)
* Shift operators (<<, >>, >>>)
Before Left Brace
* Class left brace
* Method left brace
* if left brace
* else left brace
* for left brace
* while left brace
* do left brace
* switch left brace
* try left brace
* catch left brace
* finally left brace
* synchronized left brace
Before Keywords
* else keyword
* while keyword
* catch keyword
* finally keyword
In Ternary Operator (?:)
* Before ?
* After ?
* Before :
* After :
Within Type Arguments
* After comma
Other
* After comma
* After semicolon
* After type cast
----------------------------------
Wrapping and Braces
----------------------------------
Braces placement
* In class declaration : End of line
* In method declaration : End of line
* Other : End of line
Use Of Braces
* if() statement : When multiline
* for() statement : When multiline
* while() statement : When multiline
* do .. while() statement : When multiline
Annotations
* Class annotations : Wrap always
* Method annotations : Wrap always
* Field annotations : Wrap always
* Parameter annotations : Do not wrap
* Local variable annotations : Do not wrap
----------------------------------
Blank Lines
----------------------------------
Minimum Blank Lines
* Before package statement : 0
* After package statement : 1
* Before imports : 1
* After imports : 1
* Around class : 1
* After class header : 0
* After anonymous class header : 0
* Around field in interface : 0
* Around field : 0
* Around method in interface : 1
* Around method : 1
* Before method body : 0
----------------------------------
JavaDoc
----------------------------------
Alignment
* Align thrown exception descriptions
Blank Lines
* After description
Other
* Enable leading asterisks
* Use @throws rather than @exception
* Keep empty lines
----------------------------------
Imports
----------------------------------
import static (all other imports)
<blank line>
import java.*
import javax.*
import com.*
<blank line>
import (all other imports)
================================================
FILE: LICENSE-junit.txt
================================================
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.
================================================
FILE: NOTICE.txt
================================================
===================================================================================
== Notices and attributions required by libraries that the project depends on ==
===================================================================================
The JUnit depends on Java Hamcrest (http://hamcrest.org/JavaHamcrest/).
================================================
FILE: README.md
================================================
# JUnit 4
JUnit is a simple framework to write repeatable tests. It is an instance of the xUnit architecture for unit testing frameworks.
> [!IMPORTANT]
> **JUnit 4 is in maintenance mode.**
>
> At this point, only critical bugs and security issues will be fixed.<br>
> All other issues and PRs will therefore be declined.<br>
> For ongoing development, please check out the [junit-framework](https://github.com/junit-team/junit-framework/) repository.
For more information, please visit:
* [Wiki](https://github.com/junit-team/junit4/wiki)
* [Download and Install guide](https://github.com/junit-team/junit4/wiki/Download-and-Install)
* [Getting Started](https://github.com/junit-team/junit4/wiki/Getting-started)
[](https://github.com/junit-team/junit4/actions)
================================================
FILE: SECURITY.md
================================================
# Security Policy
## Supported Versions
| Version | Supported |
| ------- | ------------------ |
| 4.13.x | :white_check_mark: |
| < 4.13 | :x: |
## Reporting a Vulnerability
To report a security vulnerability, please send an email to security@junit.org.
================================================
FILE: acknowledgements.txt
================================================
2006 March 9
Matthias Schmidt: improved org.junit package javadoc
2006 August 3
giovanni: better test for TestCase without a name.
Matthias Pfau: better error message when test case constructor fails
2006 November 21
dakcalouro: Found defect with comparing ints and longs (1555161)
Ben Maurer: Found defect with timeouts taking twice as long as specified (1536198)
2007 February 08
Kazimierz Pogoda: Found defect with null array elements (1438163)
2007 July 09
wangqq: Found defect with @After not running after a timeout (1745048)
2007 July 18
Andrew Dick: Found defect with assertEquals comparing non-Integer Numbers (1715326)
Michael Schechter: Found defect with Filters and suite() methods (1739095)
2008 February 5
Walter Gildersleeve: Found assertEquals(null, "null") defect (1857283)
2008 July 1
Johannes Link: Submitted test for running subclasses of Suite
2008 July 23
Daniel Brolund: Submitted patch for build.xml, fixing 1.5 compatibility (2021396)
2008 Aug 1
Nat Pryce: Found defect in treatment of validation errors from custom
subclasses of the legacy JUnit4ClassRunner.
2008 Aug 18
Nir Soffer: Suggested adding to the cookbook information about running
running JUnit from the command line.
2008 Aug 19
Jack Woehr: Discovered build.xml was missing from junit-4.x.zip
2009 Jan 5
Amanda Robinson: Fixed overly permissive @DataPoint processing.
2009 Feb 9
Mark Shapiro: Discovered bug in test counting after an ignored method (2106324)
2009 Apr 20
Chris Felaco: Discovered regression in handling suite() methods with JUnit 3 runner (1812200)
Toby Byron: Suggested updating linking in javadoc (2090230)
Raphael Parree: Improved docs on Parameterized (2186792)
Robin de Silva Jayasinghe: Fixed Javadoc code sample for AfterClass (2126279)
2009 May 04
James Abbley: Submitted a patch that fixed the 2-second limit on Parallel execution.
2009 Nov 16
Kristian Rosenvold: Submitted a patch (github#16) that improves thread-safety of
result counting
2010 Feb 08
Paul Holser: Submitted additional test for TestName rule.
2010 May 03
jonas22@github: Found bug (github#98) with assumptions and expected exceptions.
2011 Jan 03
jens.schauder@freenet.de: Found bug (github#74) with Categories and
Parameterized.
2011 Jan 18
Markus Keller: Reported bug (github#163):
Bad comparison failure message when using assertEquals(String, String)
Kevin Cooney (kcooney@github):
Patches for runLeaf, public multiple failure exception,
assertion messages and null.
2011 Mar 04
Jerome Lacoste (lacostej@github) for initial patch for GH-191.
2011 Apr 15
reinholdfuereder@github For initial test for GH-39
2011 Apr 15
ububenheimer@github for bug report https://github.com/junit-team/junit4/issues/208
2011 Apr 29
reinholdfuereder@github: bug report, test, and fix for GH-38:
ParentRunner filtering
2011 Apr 29
Markus Keller (mkeller@github): Report for GH-187:
Unintentional dependency on Java 6
2011 May 31
Kevin Cooney (kcooney@github): Patches for filtering test suites:
copy List returned by getChildren() before mutating it;
optimize ParentRunner.filter for nested suites;
optimize Filter.intersect for common cases
2011 Jun 06
Vampire@github: Report for GH-235: 4.7 release notes incorrect.
2011 Jun 24
Samuel Le Berrigaud (sleberrigaud@github): Report for GH-248:
protected BlockJUnit4ClassRunner#rules method removed from 4.8.2
2011 Jun 24
Daniel Rothmaler (drothmaler@github):
#299: random temp file/folder creation
#300: ErrorCollector.checkThat overload
2011 Jun 25
Juan Cortez (jcortez@github): Fixed issue #219 where floats were being
printed and represented as doubles in error messages.
2011 Jul 06
Stefan Birkner: Fixed wrong documentation of ClassRule (github#254).
2011 Jul 08
Paul Holser (pholser@alumni.rice.edu): Beginnings of fix for GH-64:
Theories doesn't honor parameterized types
2011 Jul 09
Nigel Charman: Reported Rules bugs github#257 and gihub#258.
2011 Jul 09
Stefan Birkner: Fixed rules bugs (github#257, gihub#258, github#260).
2011 Jul 09
Stefan Birkner: Fixed rules bugs (github#257, gihub#258, github#260).
2011 Jul 16
Rob Dawson: Submitted a patch that makes Results serlializable.
2011 Jul 20
Asaf Ary, Stefan Birkner: Fixed FailOnTimeout class (github#265).
2011 Jul 22
Andreas Köhler, Stefan Birkner: Fixed wrong documentation of Parameterized (github#89).
2011 Jul 28
electrickery, Stefan Birkner: Fixed typo in JavaDoc (github#134).
2011 Aug 07
Esko Luontola: Fixed TemporaryFolder creating files in the current working directory (github#278).
2011 Aug 09
Stefan Birkner: Fixed JavaDoc links.
2011 Aug 10
rodolfoliviero@github and JoseRibeiro@github: feature to create recursive temporary folders.
2011 Aug 12
Esko Luontola: Fixed syntax error in Parameterized's usage example (github#285).
2011 Sep 09
Robert Munteanu, Stefan Birkner:
TestWatcher and TestWatchman don't call failed when assumption is violated (github#296).
digulla@github, Stefan Birkner: Removed useless code (github#289).
== NOTE: as of September 2011, we have stopped recording contributions here.
For a full list of everyone who has contributed great bug reports and code, please see
http://github.com/junit-team/junit4
================================================
FILE: doc/ReleaseNotes4.10.html
================================================
<h2>Summary of Changes in version 4.10</h2>
<p>A full summary of commits between 4.9 and 4.10 is on <a href="https://github.com/junit-team/junit4/compare/r4.9...r4.10">github</a></p>
<h3>junit-dep has correct contents</h3>
<p>junit-dep-4.9.jar incorrectly contained hamcrest classes, which could lead to version conflicts in projects that depend on hamcrest directly. This is fixed in 4.10 [@dsaff, closing gh-309]</p>
<h3>RuleChain</h3>
<p>The RuleChain rule allows ordering of TestRules:</p>
<pre><code>public static class UseRuleChain {
@Rule
public TestRule chain= RuleChain
.outerRule(new LoggingRule("outer rule")
.around(new LoggingRule("middle rule")
.around(new LoggingRule("inner rule");
@Test
public void example() {
assertTrue(true);
}
}
</code></pre>
<p>writes the log</p>
<pre><code>starting outer rule
starting middle rule
starting inner rule
finished inner rule
finished middle rule
finished outer rule
</code></pre>
<h3>TemporaryFolder</h3>
<ul>
<li><code>TemporaryFolder#newFolder(String... folderNames)</code> creates recursively deep temporary folders
[@rodolfoliviero, closing gh-283]</li>
<li><code>TemporaryFolder#newFile()</code> creates a randomly named new file, and <code>#newFolder()</code> creates a randomly named new folder
[@Daniel Rothmaler, closing gh-299]</li>
</ul>
<h3>Theories</h3>
<p>The <code>Theories</code> runner does not anticipate theory parameters that have generic
types, as reported by github#64. Fixing this won't happen until <code>Theories</code> is
moved to junit-contrib. In anticipation of this, 4.9.1 adds some of the
necessary machinery to the runner classes, and deprecates a method that only
the <code>Theories</code> runner uses, <code>FrameworkMethod</code>#producesType().
The Common Public License that JUnit is released under is now included
in the source repository.</p>
<p>Thanks to <code>@pholser</code> for identifying a potential resolution for github#64
and initiating work on it.</p>
<h3>Bug fixes</h3>
<ul>
<li>Built-in Rules implementations
<ul>
<li>TemporaryFolder should not create files in the current working directory if applying the rule fails
[@orfjackal, fixing gh-278]</li>
<li>TestWatcher and TestWatchman should not call failed for AssumptionViolatedExceptions
[@stefanbirkner, fixing gh-296]</li>
</ul></li>
<li>Javadoc bugs
<ul>
<li>Assert documentation [@stefanbirkner, fixing gh-134]</li>
<li>ClassRule [@stefanbirkner, fixing gh-254]</li>
<li>Parameterized [@stefanbirkner, fixing gh-89]</li>
<li>Parameterized, again [@orfjackal, fixing gh-285]</li>
</ul></li>
<li>Miscellaneous
<ul>
<li>Useless code in RunAfters [@stefanbirkner, fixing gh-289]</li>
<li>Parameterized test classes should be able to have <code>@Category</code> annotations
[@dsaff, fixing gh-291]</li>
<li>Error count should be initialized in junit.tests.framework.TestListenerTest [@stefanbirkner, fixing gh-225]</li>
<li>AssertionFailedError constructor shouldn't call super with null message [@stefanbirkner, fixing gh-318]</li>
<li>Clearer error message for non-static inner test classes [@stefanbirkner, fixing gh-42]</li>
</ul></li>
</ul>
<h3>Minor changes</h3>
<ul>
<li>Description, Result and Failure are Serializable [@ephox-rob, closing gh-101]</li>
<li>FailOnTimeout is reusable, allowing for retrying Rules [@stefanbirkner, closing gh-265]</li>
<li>New <code>ErrorCollector.checkThat</code> overload, that allows you to specify a reason [@drothmaler, closing gh-300]</li>
</ul>
================================================
FILE: doc/ReleaseNotes4.10.md
================================================
## Summary of Changes in version 4.10 ##
Thanks to a full cast of contributors of bug fixes and new features.
A full summary of commits between 4.9 and 4.10 is on [github](https://github.com/junit-team/junit4/compare/r4.9...r4.10)
### junit-dep has correct contents ###
junit-dep-4.9.jar incorrectly contained hamcrest classes, which could lead to version conflicts in projects that depend on hamcrest directly. This is fixed in 4.10 [@dsaff, closing gh-309]
### RuleChain ###
The RuleChain rule allows ordering of TestRules:
```java
public static class UseRuleChain {
@Rule
public TestRule chain= RuleChain
.outerRule(new LoggingRule("outer rule")
.around(new LoggingRule("middle rule")
.around(new LoggingRule("inner rule");
@Test
public void example() {
assertTrue(true);
}
}
```
writes the log
starting outer rule
starting middle rule
starting inner rule
finished inner rule
finished middle rule
finished outer rule
### TemporaryFolder ###
- `TemporaryFolder#newFolder(String... folderNames)` creates recursively deep temporary folders
[@rodolfoliviero, closing gh-283]
- `TemporaryFolder#newFile()` creates a randomly named new file, and `#newFolder()` creates a randomly named new folder
[@Daniel Rothmaler, closing gh-299]
### Theories ###
The `Theories` runner does not anticipate theory parameters that have generic
types, as reported by github#64. Fixing this won't happen until `Theories` is
moved to junit-contrib. In anticipation of this, 4.9.1 adds some of the
necessary machinery to the runner classes, and deprecates a method that only
the `Theories` runner uses, `FrameworkMethod`#producesType().
The Common Public License that JUnit is released under is now included
in the source repository.
Thanks to `@pholser` for identifying a potential resolution for github#64
and initiating work on it.
### Bug fixes ###
- Built-in Rules implementations
- TemporaryFolder should not create files in the current working directory if applying the rule fails
[@orfjackal, fixing gh-278]
- TestWatcher and TestWatchman should not call failed for AssumptionViolatedExceptions
[@stefanbirkner, fixing gh-296]
- Javadoc bugs
- Assert documentation [@stefanbirkner, fixing gh-134]
- ClassRule [@stefanbirkner, fixing gh-254]
- Parameterized [@stefanbirkner, fixing gh-89]
- Parameterized, again [@orfjackal, fixing gh-285]
- Miscellaneous
- Useless code in RunAfters [@stefanbirkner, fixing gh-289]
- Parameterized test classes should be able to have `@Category` annotations
[@dsaff, fixing gh-291]
- Error count should be initialized in junit.tests.framework.TestListenerTest [@stefanbirkner, fixing gh-225]
- AssertionFailedError constructor shouldn't call super with null message [@stefanbirkner, fixing gh-318]
- Clearer error message for non-static inner test classes [@stefanbirkner, fixing gh-42]
### Minor changes ###
- Description, Result and Failure are Serializable [@ephox-rob, closing gh-101]
- FailOnTimeout is reusable, allowing for retrying Rules [@stefanbirkner, closing gh-265]
- New `ErrorCollector.checkThat` overload, that allows you to specify a reason [@drothmaler, closing gh-300]
================================================
FILE: doc/ReleaseNotes4.10.txt
================================================
Please see ReleaseNotes4.10.md
================================================
FILE: doc/ReleaseNotes4.11.html
================================================
<h2>Summary of changes in version 4.11</h2>
<h3>Matchers: Upgrade to Hamcrest 1.3</h3>
<p>JUnit now uses the latest version of Hamcrest. Thus, you can use all the available matchers and benefit from an improved <code>assertThat</code> which will now print the mismatch description from the matcher when an assertion fails.</p>
<h4>Example</h4>
<pre><code>assertThat(Long.valueOf(1), instanceOf(Integer.class));
</code></pre>
<p>Old error message:</p>
<pre><code>Expected: an instance of java.lang.Integer
got: <1L>
</code></pre>
<p>New error message:</p>
<pre><code>Expected: an instance of java.lang.Integer
but: <1L> is a java.lang.Long
</code></pre>
<p>Hamcrest's new <code>FeatureMatcher</code> makes writing custom matchers that make use of custom mismatch descriptions quite easy:</p>
<pre><code>@Test
public void featureMatcher() throws Exception {
assertThat("Hello World!", length(is(0)));
}
private Matcher<String> length(Matcher<? super Integer> matcher) {
return new FeatureMatcher<String, Integer>(matcher, "a String of length that", "length") {
@Override
protected Integer featureValueOf(String actual) {
return actual.length();
}
};
}
</code></pre>
<p>Running this test will return the following failure message:</p>
<pre><code>Expected: a String of length that is <0>
but: length was <12>
</code></pre>
<p>Most of the matchers in <code>JUnitMatchers</code> have been deprecated. Please use <code>org.hamcrest.CoreMatchers</code> directly.</p>
<h3>Parameterized Tests</h3>
<p>In order to easily identify the individual test cases in a Parameterized test, you may provide a name using the <code>@Parameters</code> annotation. This name is allowed to contain placeholders that are replaced at runtime:</p>
<ul>
<li><code>{index}</code>: the current parameter index</li>
<li><code>{0}</code>, <code>{1}</code>, …: the first, second, and so on, parameter value</li>
</ul>
<h4>Example</h4>
<pre><code>@RunWith(Parameterized.class)
public class FibonacciTest {
@Parameters(name = "{index}: fib({0})={1}")
public static Iterable<Object[]> data() {
return Arrays.asList(new Object[][] { { 0, 0 }, { 1, 1 }, { 2, 1 },
{ 3, 2 }, { 4, 3 }, { 5, 5 }, { 6, 8 } });
}
private int input;
private int expected;
public FibonacciTest(int input, int expected) {
this.input = input;
this.expected = expected;
}
@Test
public void test() {
assertEquals(expected, Fibonacci.compute(input));
}
}
</code></pre>
<p>In the example given above, the <code>Parameterized</code> runner creates names like <code>[1: fib(3)=2]</code>. If you don't specify a name, the current parameter index will be used by default.</p>
<h3>Test execution order</h3>
<p>By design, JUnit does not specify the execution order of test method invocations. Until now, the methods were simply invoked in the order returned by the reflection API. However, using the JVM order is unwise since the Java platform does not specify any particular order, and in fact JDK 7 returns a more or less random order. Of course, well-written test code would not assume any order, but some does, and a predictable failure is better than a random failure on certain platforms.</p>
<p>From now on, JUnit will by default use a deterministic, but not predictable, order (<code>MethodSorters.DEFAULT</code>). To change the test execution order simply annotate your test class using <code>@FixMethodOrder</code> and specify one of the available <code>MethodSorters</code>:</p>
<ul>
<li><p><code>@FixMethodOrder(MethodSorters.JVM)</code>: Leaves the test methods in the order returned by the JVM. This order may vary from run to run.</p></li>
<li><p><code>@FixMethodOrder(MethodSorters.NAME_ASCENDING)</code>: Sorts the test methods by method name, in lexicographic order.</p></li>
</ul>
<h3>Maven artifacts</h3>
<p>Up until now there were two Maven artifacts for JUnit: <code>junit:junit-dep</code> and <code>junit:junit</code>. From a Maven point-of-view only the former made sense because it did not contain the Hamcrest classes but declared a dependency to the Hamcrest Maven artifact. The latter included the Hamcrest classes which was very un-Maven-like.</p>
<p>From this release on, you should use <code>junit:junit</code> which will be what <code>junit:junit-dep</code> used to. If you still reference <code>junit:junit-dep</code>, Maven will automatically relocate you to the new <code>junit:junit</code> and issue a warning for you to fix.</p>
<h3>Rules</h3>
<p>A number of improvements have been made to Rules:</p>
<ul>
<li><code>MethodRule</code> is no longer deprecated.</li>
<li>Both <code>@Rule</code> and <code>@ClassRule</code> can now be used on methods that return a <code>TestRule</code>.</li>
<li><code>ExpectedException</code> now always prints the stacktrace of the actual exception in case of failure.</li>
<li>A parent folder can be specified for <code>TemporaryFolder</code>. In addition, the <code>newFile</code>/<code>newFolder</code> methods will now fail when the file or folder could not be created.</li>
<li><code>TestWatcher</code> has a new template method called <code>skipped</code> that is invoked when a test is skipped due to a failed assumption.</li>
</ul>
<h3>Improvements to Assert and Assume</h3>
<ul>
<li><code>assertNotEquals</code> has been added to <code>Assert</code>.</li>
<li><code>assertEquals</code> has been overloaded in order to check whether two floats are equal given a certain float delta.</li>
<li>Most methods in <code>Assume</code> now allow to pass a custom message.</li>
</ul>
================================================
FILE: doc/ReleaseNotes4.11.md
================================================
## Summary of changes in version 4.11
### Matchers: Upgrade to Hamcrest 1.3
JUnit now uses the latest version of Hamcrest. Thus, you can use all the available matchers and benefit from an improved `assertThat` which will now print the mismatch description from the matcher when an assertion fails.
#### Example
```java
assertThat(Long.valueOf(1), instanceOf(Integer.class));
```
Old error message:
Expected: an instance of java.lang.Integer
got: <1L>
New error message:
Expected: an instance of java.lang.Integer
but: <1L> is a java.lang.Long
Hamcrest's new `FeatureMatcher` makes writing custom matchers that make use of custom mismatch descriptions quite easy:
```java
@Test
public void featureMatcher() throws Exception {
assertThat("Hello World!", length(is(0)));
}
private Matcher<String> length(Matcher<? super Integer> matcher) {
return new FeatureMatcher<String, Integer>(matcher, "a String of length that", "length") {
@Override
protected Integer featureValueOf(String actual) {
return actual.length();
}
};
}
```
Running this test will return the following failure message:
Expected: a String of length that is <0>
but: length was <12>
Most of the matchers in `JUnitMatchers` have been deprecated. Please use `org.hamcrest.CoreMatchers` directly.
### Parameterized Tests
In order to easily identify the individual test cases in a Parameterized test, you may provide a name using the `@Parameters` annotation. This name is allowed to contain placeholders that are replaced at runtime:
* `{index}`: the current parameter index
* `{0}`, `{1}`, …: the first, second, and so on, parameter value
#### Example
```java
@RunWith(Parameterized.class)
public class FibonacciTest {
@Parameters(name = "{index}: fib({0})={1}")
public static Iterable<Object[]> data() {
return Arrays.asList(new Object[][] { { 0, 0 }, { 1, 1 }, { 2, 1 },
{ 3, 2 }, { 4, 3 }, { 5, 5 }, { 6, 8 } });
}
private int input;
private int expected;
public FibonacciTest(int input, int expected) {
this.input = input;
this.expected = expected;
}
@Test
public void test() {
assertEquals(expected, Fibonacci.compute(input));
}
}
```
In the example given above, the `Parameterized` runner creates names like `[1: fib(3)=2]`. If you don't specify a name, the current parameter index will be used by default.
### Test execution order
By design, JUnit does not specify the execution order of test method invocations. Until now, the methods were simply invoked in the order returned by the reflection API. However, using the JVM order is unwise since the Java platform does not specify any particular order, and in fact JDK 7 returns a more or less random order. Of course, well-written test code would not assume any order, but some does, and a predictable failure is better than a random failure on certain platforms.
From now on, JUnit will by default use a deterministic, but not predictable, order (`MethodSorters.DEFAULT`). To change the test execution order simply annotate your test class using `@FixMethodOrder` and specify one of the available `MethodSorters`:
* `@FixMethodOrder(MethodSorters.JVM)`: Leaves the test methods in the order returned by the JVM. This order may vary from run to run.
* `@FixMethodOrder(MethodSorters.NAME_ASCENDING)`: Sorts the test methods by method name, in lexicographic order.
### Maven artifacts
Up until now there were two Maven artifacts for JUnit: `junit:junit-dep` and `junit:junit`. From a Maven point-of-view only the former made sense because it did not contain the Hamcrest classes but declared a dependency to the Hamcrest Maven artifact. The latter included the Hamcrest classes which was very un-Maven-like.
From this release on, you should use `junit:junit` which will be what `junit:junit-dep` used to. If you still reference `junit:junit-dep`, Maven will automatically relocate you to the new `junit:junit` and issue a warning for you to fix.
### Rules
A number of improvements have been made to Rules:
* `MethodRule` is no longer deprecated.
* Both `@Rule` and `@ClassRule` can now be used on methods that return a `TestRule`.
* `ExpectedException` now always prints the stacktrace of the actual exception in case of failure.
* A parent folder can be specified for `TemporaryFolder`. In addition, the `newFile`/`newFolder` methods will now fail when the file or folder could not be created.
* `TestWatcher` has a new template method called `skipped` that is invoked when a test is skipped due to a failed assumption.
### Improvements to Assert and Assume
* `assertNotEquals` has been added to `Assert`.
* `assertEquals` has been overloaded in order to check whether two floats are equal given a certain float delta.
* Most methods in `Assume` now allow to pass a custom message.
================================================
FILE: doc/ReleaseNotes4.11.txt
================================================
Please see ReleaseNotes4.11.md
================================================
FILE: doc/ReleaseNotes4.12.md
================================================
## Summary of changes in version 4.12
# Assertions
### [Pull request #611:](https://github.com/junit-team/junit4/pull/611) Assert.assertNotEquals() for `float` parameters
Version 4.11 added `Assert.assertEquals()` for `float` parameters with a delta, and `Assert.assertNotEquals()`. This is the combination of those two features.
### [Pull request #632:](https://github.com/junit-team/junit4/pull/632) Assert.assertArrayEquals() for `boolean[]` parameters.
`Assert.assertArrayEquals()` previously existed for all primitive array types, except `boolean[]`. This has now been added for `boolean[]`.
### [Pull request #918:](https://github.com/junit-team/junit4/pull/918) Avoid potentially expensive reflection-based loop in Assert.assertArrayEquals()
In the usual case, where the array elements are in fact exactly equal, the potentially expensive reflection-based loop to compare them is avoided by using `Arrays.deepEquals()` first. The exact comparison is only executed when `deepEquals()` returns `false`.
# Command-line options
### [Pull request #647:](https://github.com/junit-team/junit4/pull/647) Support command-line `--filter` param.
When running JUnit from the command line, a command-line parameter can be supplied using `--filter`, which supplies a filter that will restrict which tests and subtests from the rest of the command will be run. For example, this will run only the tests in ExampleTestSuite that are in categories Cat1 or Cat2:
```
java org.junit.runner.JUnitCore \
--filter=org.junit.experimental.categories.IncludeCategories=pkg.of.Cat1,pkg.of.Cat2 \
com.example.ExampleTestSuite
```
In general, the argument to `--filter` should be `ClassName=param`, where `ClassName` names an implementation of `FilterFactory`, whose `createFilter` method will be called with an instance of `FilterFactoryParams` that contains `"param"`, in order to return the filter to be applied.
# Test Runners
### [Pull request #763:](https://github.com/junit-team/junit4/pull/763) Allow custom test runners to create their own TestClasses and customize the scanning of annotations.
This introduces some extension points to `ParentRunner` to allow subclasses to control creation
of the `TestClass` instance and to scan for annotations.
### [Pull request #817:](https://github.com/junit-team/junit4/pull/817) Support for context hierarchies
The `AnnotatedBuilder` is a strategy for constructing runners for test classes that have been annotated with the `@RunWith` annotation. All tests within such a class will be executed using the runner that was specified within the annotation.
Prior to JUnit 4.12, this covered only the tests within the annotated test class. With 4.12, the `AnnotationBuilder` will also support inner member classes. If a custom test runner supports inner member classes (which JUnit does not support out-of-the-box), the member classes will inherit the runner from the enclosing class, e.g.:
```java
@RunWith(MyRunner.class)
public class MyTest {
// some tests might go here
public class MyMemberClass {
@Test
public void thisTestRunsWith_MyRunner() {
// some test logic
}
// some more tests might go here
}
@RunWith(AnotherRunner.class)
public class AnotherMemberClass {
// some tests might go here
public class DeepInnerClass {
@Test
public void thisTestRunsWith_AnotherRunner() {
// some test logic
}
}
public class DeepInheritedClass extends SuperTest {
@Test
public void thisTestRunsWith_SuperRunner() {
// some test logic
}
}
}
}
@RunWith(SuperRunner.class)
public class SuperTest {
// some tests might go here
}
```
The key points to note here are:
* If there is no `@RunWith` annotation, no runner will be created.
* The resolve step is inside-out, e.g. the closest `@RunWith` annotation wins.
* `@RunWith` annotations are inherited and work as if the class was annotated itself.
* The default JUnit runner does not support inner member classes, so this is only valid for custom runners that support inner member classes.
* Custom runners with support for inner classes may or may not support `@RunWith` annotations for member classes. Please refer to the custom runner documentation.
One example of a runner that makes use of this extension is the Hierarchical Context Runner (see https://github.com/bechte/junit-hierarchicalcontextrunner/wiki).
### [Pull request #716:](https://github.com/junit-team/junit4/pull/716) Fix annotation collection from superclasses of JUnit3 tests.
Previously `Description.getAnnotations()` would always return an empty list for _test*_ methods derived from superclasses.
### [Pull request #625 (commit 72af03c49f):](https://github.com/junit-team/junit4/commit/72af03c49fdad5f10e36c7eb4e7045feb971d253) Make `RunNotifier` code concurrent.
When running tests from multiple threads, JUnit will now call `RunListener` methods from multiple threads if the listener class is annotated with `@RunListener.ThreadSafe`. In addition, the code in `RunNotifier` has been modified to not use locks.
### [Pull request #684:](https://github.com/junit-team/junit4/pull/684) Adding `AnnotationValidator` framework and validation checks for `@Category`.
This allows for validation to be added to annotations. Validators should extend `AnnotationValidator` and be attached to annotations with the `@ValidateWith` annotation. `CategoryValidator` extends `AnnotationValidator` and ensures that incompatible annotations (`@BeforeClass`, `@AfterClass`, `@Before`, `@After`) are not used in conjunction with `@Category`.
# Exception Testing
### [Pull request #583:](https://github.com/junit-team/junit4/pull/583) [Pull request #720:](https://github.com/junit-team/junit4/pull/720) Fix handling of `AssertionError` and `AssumptionViolatedException` in `ExpectedException` rule.
`ExpectedException` didn't handle `AssertionError`s and `AssumptionViolatedException` well. This has been fixed. The new documentation explains the usage of `ExpectedException` for testing these exceptions. The two methods `handleAssertionErrors()` and `handleAssumptionViolatedExceptions()` are not needed anymore. If you have used them, just remove it and read `ExpectedException`'s documentation.
### [Pull request #818:](https://github.com/junit-team/junit4/pull/818) [Pull request #993:](https://github.com/junit-team/junit4/pull/993) External version of AssumptionViolatedException
In JUnit 4.11 and earlier, if you wanted to write a custom runner that handled
`AssumptionViolatedException` or you needed to create an instance of `AssumptionViolatedException`
directly, you needed to import an internal class (`org.junit.internal.AssumptionViolatedException`).
Now you can import `org.junit.AssumptionViolatedException` (which extends
`org.junit.internal.AssumptionViolatedException`).
The classes in `Assume` have been modified to throw `org.junit.AssumptionViolatedException`.
The constructors in the external `AssumptionViolatedException` are also
simpler than the ones in the internal version. That being said,
it's recommended that you create `AssumptionViolatedException` via the methods in `Assume`.
### [Pull request #985:](https://github.com/junit-team/junit4/pull/985) Change AssumptionViolatedException to not set the cause to null; fixes issue #494
Previously, the `AssumptionViolatedException` constructors would explicitly set the cause to `null`
(unless you use a constructor where you provide a `Throwable`, in which case it would set that as
the cause). This prevented code directly creating the exception from setting a cause.
With this change, the cause is only set if you pass in a `Throwable`.
It's recommended that you create `AssumptionViolatedException` via the methods in `Assume`.
### [Pull request #542:](https://github.com/junit-team/junit4/pull/542) Customized failure message for `ExpectedException`
`ExpectedException` now allows customization of the failure message when the test does not throw the expected exception. For example:
```java
thrown.reportMissingExceptionWithMessage("FAIL: Expected exception to be thrown");
```
If a custom failure message is not provided, a default message is used.
### [Pull request #1013:](https://github.com/junit-team/junit4/pull/1013) Make ErrorCollector#checkSucceeds generic
The method `ErrorCollector.checkSucceeds()` is now generic. Previously, you could only pass
in a `Callable<Object>` and it returned `Object`. You can now pass any `Callable` and the
return type will match the type of the callable.
# Timeout for Tests
*See also [Timeout for tests](https://github.com/junit-team/junit4/wiki/Timeout-for-tests)*
### [Pull request #823:](https://github.com/junit-team/junit4/pull/823) Throw `TestFailedOnTimeoutException` instead of plain `Exception` on timeout
When a test times out, a `org.junit.runners.model.TestTimedOutException` is now thrown instead of a plain `java.lang.Exception`.
### [Pull request #742:](https://github.com/junit-team/junit4/pull/742) [Pull request #986:](https://github.com/junit-team/junit4/pull/986) `Timeout` exceptions now include stack trace from stuck thread (experimental)
`Timeout` exceptions try to determine if there is a child thread causing the problem, and if so its stack trace is included in the exception in addition to the one of the main thread. This feature must be enabled with the timeout rule by creating it through the new `Timeout.builder()` method:
```java
public class HasGlobalTimeout {
@Rule public final TestRule timeout = Timeout.builder()
.withTimeout(10, TimeUnit.SECONDS)
.withLookingForStuckThread(true)
.build();
@Test
public void testInfiniteLoop() {
for (;;) {
}
}
}
```
### [Pull request #544:](https://github.com/junit-team/junit4/pull/544) New constructor and factories in `Timeout`
`Timeout` deprecated the old constructor `Timeout(int millis)`.
A new constructor is available: `Timeout(long timeout, TimeUnit unit)`. It enables you to use different granularities of time units like `NANOSECONDS`, `MICROSECONDS`, `MILLISECONDS`, and `SECONDS`. Examples:
```java
@Rule public final TestRule globalTimeout = new Timeout(50, TimeUnit.MILLISECONDS);
```
```java
@Rule public final TestRule globalTimeout = new Timeout(10, TimeUnit.SECONDS);
```
and factory methods in `Timeout`:
```java
@Rule public final TestRule globalTimeout = Timeout.millis(50);
```
```java
@Rule public final TestRule globalTimeout = Timeout.seconds(10);
```
This usage avoids the truncation, which was the problem in the deprecated constructor `Timeout(int millis)` when casting `long` to `int`.
### [Pull request #549:](https://github.com/junit-team/junit4/pull/549) fixes for #544 and #545
The `Timeout` rule applies the same timeout to all test methods in a class:
```java
public class HasGlobalTimeout {
@Rule
public Timeout globalTimeout = new Timeout(10, TimeUnit.SECONDS);
@Test
public void testInfiniteLoop() {
for (;;) {
}
}
@Test
public synchronized void testInterruptableLock() throws InterruptedException {
wait();
}
@Test
public void testInterruptableIO() throws IOException {
for (;;) {
FileChannel channel = new RandomAccessFile(file, "rw").getChannel();
// Interrupted thread closes channel and throws ClosedByInterruptException.
channel.write(buffer);
channel.close();
}
}
}
```
Each test is run in a new _daemon_ thread. If the specified timeout elapses before the test completes, its execution is interrupted via `Thread#interrupt()`. This happens in interruptable I/O (operations throwing `java.io.InterruptedIOException` and `java.nio.channels.ClosedByInterruptException`), locks (package `java.util.concurrent`) and methods in `java.lang.Object` and `java.lang.Thread` throwing `java.lang.InterruptedException`.
### [Pull request #876:](https://github.com/junit-team/junit4/pull/876) The timeout rule never times out if you pass in a timeout of zero.
A specified timeout of 0 will be interpreted as not set, however tests still launch from separate threads. This can be useful for disabling timeouts in environments where they are dynamically set based on some property.
# Parameterized Tests
### [Pull request #702:](https://github.com/junit-team/junit4/pull/702) Support more return types for the `@Parameters` method of the `Parameterized` runner
The return types `Iterator<? extends Object>`, `Object[]` and `Object[][]` are now supported on methods annotated with `@Parameters`. You don't have to wrap arrays with `Iterable`s and single parameters with `Object` arrays.
### [Pull request #773:](https://github.com/junit-team/junit4/pull/773) Allow configurable creation of child runners of parameterized suites
The factory for creating the `Runner` instance of a single set of parameters is now configurable. It can be specified by the `@UseParametersRunnerFactory` annotation.
# Rules
### [Pull request #552:](https://github.com/junit-team/junit4/pull/552) [Pull request #937:](https://github.com/junit-team/junit4/pull/937) `Stopwatch` rule
The `Stopwatch` Rule notifies one of its own protected methods of the time spent by a test. Override them to get the time in nanoseconds. For example, this class will keep logging the time spent by each passed, failed, skipped, and finished test:
```java
public static class StopwatchTest {
private static final Logger logger = Logger.getLogger("");
private static void logInfo(String testName, String status, long nanos) {
logger.info(String.format("Test %s %s, spent %d microseconds",
testName, status, Stopwatch.toMicros(nanos)));
}
@Rule
public Stopwatch stopwatch = new Stopwatch() {
@Override
protected void succeeded(long nanos, Description description) {
logInfo(description.getMethodName(), "succeeded", nanos);
}
@Override
protected void failed(long nanos, Throwable e, Description description) {
logInfo(description.getMethodName(), "failed", nanos);
}
@Override
protected void skipped(long nanos, AssumptionViolatedException e, Description description) {
logInfo(description.getMethodName(), "skipped", nanos);
}
@Override
protected void finished(long nanos, Description description) {
logInfo(description.getMethodName(), "finished", nanos);
}
};
@Test
public void succeeds() {
}
@Test
public void fails() {
fail();
}
@Test
public void skips() {
assumeTrue(false);
}
}
```
An example to assert running time:
```java
@Test
public void performanceTest() throws InterruptedException {
long delta = 30;
Thread.sleep(300L);
assertEquals(300D, stopwatch.runtime(MILLISECONDS), delta);
Thread.sleep(500L);
assertEquals(800D, stopwatch.runtime(MILLISECONDS), delta);
}
```
### [Pull request #932:](https://github.com/junit-team/junit4/pull/932) Allow static `@Rule`s also annotated with `@ClassRule`
JUnit 4.11 introduced restrictions requiring `@Rule` members to be non-static and `@ClassRule` members to be static. These restrictions have been relaxed slightly, in that a static member annotated with both `@Rule` and `@ClassRule` is now considered valid. This means a single rule may be used to perform actions both before/after a class (e.g. setup/tear down an external resource) and between tests (e.g. reset the external resource), without the need for any workarounds mentioned in issue [#793](https://github.com/junit-team/junit4/issues/793).
Note that a non-static `@ClassRule` annotated member is still considered invalid, even if annotated with `@Rule`.
```java
public class CommonRuleTest {
@Rule
@ClassRule
public static MySetupResetAndTearDownRule rule = new MySetupResetAndTearDownRule();
}
```
Be warned that if you have static methods or fields annotated with `@Rule` you will not be able to run your test methods in parallel.
### [Pull request #956:](https://github.com/junit-team/junit4/pull/956) `DisableOnDebug` rule
The `DisableOnDebug` rule allows users to disable other rules when the JVM is launched in debug mode. Prior to this feature the common approach to disable rules that make debugging difficult was to comment them out and remember to revert the change. When using this feature users no longer have to modify their test code nor do they need to remember to revert changes.
This rule is particularly useful in combination with the `Timeout` rule.
```
@Rule
public DisableOnDebug timeout = new DisableOnDebug(Timeout.seconds(1));
```
See the Javadoc for more detail and limitations. Related to https://github.com/junit-team/junit4/issues/738
### [Pull request #974:](https://github.com/junit-team/junit4/pull/974) Updated `TemporaryFolder.newFolder()` to give an error message if a path contains a slash.
If you call `TemporaryFolder.newFolder("foo/bar")` in JUnit 4.10 the method returns a `File` object for the new folder but actually fails to create it. That is contrary to the expected behaviour of the method which is to actually create the folder. In JUnit 4.11 the same call throws an exception. Nowhere in the documentation does it explain that the String(s) passed to that method can only be single path components.
With this fix, folder names are validated to contain single path name. If the folder name consists of multiple path names, an exception is thrown stating that usage of multiple path components in a string containing folder name is disallowed.
### [Pull request #1015:](https://github.com/junit-team/junit4/pull/1015) Methods annotated with `Rule` can return a `MethodRule`.
Methods annotated with `@Rule` can now return either a `TestRule` (or subclass) or a
`MethodRule` (or subclass).
Prior to this change, all public methods annotated with `@Rule` were called, but the
return value was ignored if it could not be assigned to a `TestRule`. After this change,
the method is only called if the return type could be assigned to `TestRule` or
`MethodRule`. For methods annotated with `@Rule` that return other values, see the notes
for pull request #1020.
### [Pull request #1020:](https://github.com/junit-team/junit4/pull/1020) Added validation that @ClassRule should only be implementation of TestRule.
Prior to this change, fields annotated with `@ClassRule` that did not have a type of `TestRule`
(or a class that implements `TestRule`) were ignored. With this change, the test will fail
with a validation error.
Prior to this change, methods annotated with `@ClassRule` that did specify a return type
of `TestRule`(or a class that implements `TestRule`) were ignored. With this change, the test
will fail with a validation error.
### [Pull request #1021:](https://github.com/junit-team/junit4/pull/1021) JavaDoc of TemporaryFolder: folder not guaranteed to be deleted.
Adjusted JavaDoc of TemporaryFolder to reflect that temporary folders are not guaranteed to be
deleted.
# Theories
### [Pull request #529:](https://github.com/junit-team/junit4/pull/529) `@DataPoints`-annotated methods can now yield `null` values
Up until JUnit 4.11 a `@DataPoints`-annotated array field could contain `null` values, but the array returned by a `@DataPoints`-annotated method could not. This asymmetry has been resolved: _both_ can now provide a `null` data point.
### [Pull request #572:](https://github.com/junit-team/junit4/pull/572) Ensuring no-generic-type-parms validator called/tested for theories
The `Theories` runner now disallows `Theory` methods with parameters that have "unresolved" generic type parameters (e.g. `List<T>` where `T` is a type variable). It is exceedingly difficult for the `DataPoint(s)` scraper or other `ParameterSupplier`s to correctly decide values that can legitimately be assigned to such parameters in a type-safe way, so JUnit now disallows them altogether. Theory parameters such as `List<String>` and `Iterable<? extends Number>` are still allowed.
The machinery to perform this validation was in the code base for some time, but not used. It now is used.
[junit.contrib](https://github.com/junit-team/junit.contrib)'s rendition of theories performs the same validation.
### [Pull request #607:](https://github.com/junit-team/junit4/pull/607) Improving theory failure messages
Theory failure messages previously were of the form: `ParameterizedAssertionError: theoryTest(badDatapoint, allValues[1], otherVar)`, where allValues, badDatapoint and otherVar were the variables the datapoints was sourced from. These messages are now of the form:
```java
ParameterizedAssertionError: theoryTest(null <from badDatapoint>, "good value" <from allValues[1]>,
[toString() threw RuntimeException: Error message] <from otherVar>)
```
### [Pull request #601:](https://github.com/junit-team/junit4/pull/601) Allow use of `Assume` in tests run by `Theories` runner
If, in a theory, all parameters were "assumed" away, the `Theories` runner would properly fail, informing you that no parameters were found to actually test something. However, if you had another method in that same class, that was not a theory (annotated with `@Test` only,) you could not use Assume in that test. Now, the `Theories` runner will verify the method is annotated with `@Theory` before failing due to no parameters being found.
```java
@RunWith(Theories.class)
public class TheoriesAndTestsTogether {
@DataPoint
public static Object o;
@Theory
public void theory(Object o) {
// this will still fail: java.lang.AssertionError: Never found parameters that satisfied method assumptions.
Assume.assumeTrue(false);
}
@Test
public void test() {
// this will no longer fail
Assume.assumeTrue(false);
}
}
```
### [Pull request #623:](https://github.com/junit-team/junit4/pull/623) Ensure data points array fields and methods are `public` and `static` in Theory classes.
Previously if a data points array field or method was non-`static` or non-`public` it would be silently ignored and the data points not used. Now the `Theories` runner verifies that all `@DataPoint` or `@DataPoints` annotated fields or methods in classes are both `public` and `static`, and such classes will fail to run with `InitializationError`s if they are not.
### [Pull request #621:](https://github.com/junit-team/junit4/pull/621) Added mechanism for matching specific data points in theories to specific parameters, by naming data points.
`@DataPoints` fields or methods can now be given (one or more) names in the annotation, and `@Theory` method parameters can be annotated with `@FromDataPoints(name)`, to limit the data points considered for that parameter to only the data points with that name:
```java
@DataPoints
public static String[] unnamed = new String[] { ... };
@DataPoints("regexes")
public static String[] regexStrings = new String[] { ... };
@DataPoints({"forMatching", "alphanumeric"})
public static String[] testStrings = new String[] { ... };
@Theory
public void stringTheory(String param) {
// This will be called with every value in 'regexStrings',
// 'testStrings' and 'unnamed'.
}
@Theory
public void regexTheory(@FromDataPoints("regexes") String regex,
@FromDataPoints("forMatching") String value) {
// This will be called with only the values in 'regexStrings' as
// regex, only the values in 'testStrings' as value, and none
// of the values in 'unnamed'.
}
```
### [Pull request #654:](https://github.com/junit-team/junit4/pull/654) Auto-generation of `enum` and `boolean` data points
Any theory method parameters with `boolean` or `enum` types that cannot be supplied with values by any other sources will be automatically supplied with default values: `true` and `false`, or every value of the given `enum`. If other explicitly defined values are available (e.g. from a specified `ParameterSupplier` or some `DataPoints` method in the theory class), only those explicitly defined values will be used.
### [Pull request #651:](https://github.com/junit-team/junit4/pull/651) Improvements to Theory parameter and DataPoint type matching
* Validity of `DataPoints` for theory parameters for all field data points and multi-valued method data points (i.e. not single-valued method data points) is now done on runtime type, not field/method return type (previously this was the case for multi-valued array methods only).
* Validity of `DataPoints` for theory parameters for all data points now correctly handles boxing and unboxing for primitive and wrapper types; e.g. `int` values will be considered for theory parameters that are `Integer` assignable, and vice versa.
### [Pull request #639:](https://github.com/junit-team/junit4/pull/639) Failing theory datapoint methods now cause theory test failures
Previously `@DataPoint(s)` methods that threw exceptions were quietly ignored and if another `DataPoint` source was available then those values alone were used, leaving the theory passing using only a subset of the (presumably) intended input values. Now, any data point method failures during invocation of a theory will cause the theory being tested to fail immediately.
*This is a non-backward-compatible change*, and could potentially break theory tests that depended on failing methods. If that was desired behavior, then the expected exceptions can instead be specifically ignored using the new `ignoredExceptions` array attribute on `@DataPoint` and `@DataPoints` methods. Adding an exception to this `ignoredExceptions` array will stop theory methods from failing if the given exception, or subclasses of it, are thrown in the annotated method. This attribute has no effect on data point fields.
### [Pull request #658:](https://github.com/junit-team/junit4/pull/658) `Iterable`s can now be used as data points
Previously, when building sets of data points for theory parameters, the only valid multi-valued `@DataPoints` types were arrays. This has now been extended to also take parameters from `Iterable` `@DataPoints` methods and fields.
# Categories
### [Pull request #566:](https://github.com/junit-team/junit4/pull/566) Enables inheritance on `Category` by adding `@Inherited`
`@interface Category` now is annotated with `@Inherited` itself. This enables inheritance of categories from ancestors (e.g. abstract test-classes). Note that you are able to "overwrite" `@Category` on inheritors and that this has no effect on method-level categories (see [@Inherited](http://docs.oracle.com/javase/1.5.0/docs/api/java/lang/annotation/Inherited.html)).
### [Pull request #503:](https://github.com/junit-team/junit4/pull/503) Configurable Categories
From a given set of test classes, the `Categories` runner runs only the classes and methods
that are annotated with either the category given with the `@IncludeCategory` annotation, or a subtype of that category. Either classes or interfaces can be used as categories. Subtyping works, so if you say `@IncludeCategory(SuperClass.class)`, a test marked `@Category({SubClass.class})` will be run.
You can also exclude categories by using the `@ExcludeCategory` annotation; see `SlowTestSuiteWithoutFast`.
The suite `FastOrSmokeTestSuite` is an example to run multiple categories.
To execute tests which match all categories, use `matchAny = false` in annotations. See `FastAndSmokeTestSuite`.
Example:
```java
public static interface FastTests { /* category marker */ }
public static interface SlowTests { /* category marker */ }
public static interface SmokeTests { /* category marker */ }
public static class A {
public void a() {
fail();
}
@Category(SlowTests.class)
@Test
public void b() {
}
@Category({FastTests.class, SmokeTests.class})
@Test
public void c() {
}
}
@Category({SlowTests.class, FastTests.class})
public static class B {
@Test
public void d() {
}
}
@RunWith(Categories.class)
@Categories.IncludeCategory(SlowTests.class)
@Suite.SuiteClasses({A.class, B.class})
public static class SlowTestSuite {
// Will run A.b and B.d, but not A.a and A.c
}
@RunWith(Categories.class)
@Categories.IncludeCategory({FastTests.class, SmokeTests.class})
@Suite.SuiteClasses({A.class, B.class})
public static class FastOrSmokeTestSuite {
// Will run A.c and B.d, but not A.b because it is not any of FastTests or SmokeTests
}
@RunWith(Categories.class)
@Categories.IncludeCategory(value = {FastTests.class, SmokeTests.class}, matchAny = false)
@Suite.SuiteClasses({A.class, B.class})
public static class FastAndSmokeTestSuite {
// Will run only A.c => match both FastTests AND SmokeTests
}
@RunWith(Categories.class)
@Categories.IncludeCategory(SlowTests.class)
@Categories.ExcludeCategory(FastTests.class)
@Suite.SuiteClasses({A.class, B.class}) // Note that Categories is a kind of Suite
public class SlowTestSuiteWithoutFast {
// Will run A.b, but not A.a, A.c or B.d
}
```
# Use with Maven
### [Pull request #879:] (https://github.com/junit-team/junit4/pull/879) Add the default 'Implementation-*' headers to the manifest
The default Maven-style 'Implementation-*' headers are now present in the manifest of `junit.jar`. Example:
```
Implementation-Vendor: JUnit
Implementation-Title: JUnit
Implementation-Version: 4.12
Implementation-Vendor-Id: junit
```
### [Pull request #511:](https://github.com/junit-team/junit4/pull/511) Maven project junit:junit:jar
#### How to install Maven
Download the Maven binary [http://www.us.apache.org/dist/maven/maven-3/3.0.4/binaries](http://www.us.apache.org/dist/maven/maven-3/3.0.4/binaries).
(wget http://www.us.apache.org/dist/maven/maven-3/3.0.4/binaries/apache-maven-3.0.4-bin.tar.gz)
If you are in the project root, extract the archive (tar xvzf apache-maven-3.0.4-bin.tar.gz).
Create directory _.m2_ in your _user home_. Then the artifacts and plugins are stored in `~/.m2/repository`.
( _~_ stands for user home)
#### How to launch the build from the command line
Clone the project (git clone https://github.com/junit-team/junit4.git) and navigate to the project root on your local system (cd junit).
Clean the previous build in _target_ directory, build the project, and install new artifacts in your local repository:
`apache-maven-3.0.4/bin/mvn clean install`
On Windows type the command `apache-maven-3.0.4\bin\mvn clean install`.
Set the environment variables `M2_HOME` and `PATH` when frequently building via command line `mvn clean install`.
[http://maven.apache.org/guides/development/guide-building-m2.html#Building_Maven_Without_Maven_Installed](http://maven.apache.org/guides/development/guide-building-m2.html#Building_Maven_Without_Maven_Installed)
#### How to install and build the Maven project in Eclipse
I made a clone of JUnit project from GitHub to local folder `C:\cygwin\usr\local\etc\junit`.
In menu go to _File -> Import..._
In the popup menu open section _Maven_, click on _Existing Maven Projects_ and click on _Next_. In _Import Maven Projects_ specify the project root, and next proceed further with installing maven support plugin in Eclipse.
You have created the Maven project, and now build the project.
In the Package Explorer click on _pom.xml_. In the menu _Run -> Run As -> 2 Maven build..._ open the popup _Edit Configuration_ and specify the build phase _clean install_ in section _Goals_. Click on _Run_ and build the project.
#### How to install and build the Maven project in IntelliJ IDEA
In IDEA menu create a new project _File -> New Project..._.
Select _Create Java project from existing sources_, then click on Next and specify _Project file location_.
On the right-hand side is the _Maven Projects_ tab. Click on + and add _pom.xml_ into the project. Then click on the icon _Maven Settings_, and set _Maven home directory_ as the location of extracted Maven archive on your system. Click on the green triangle and launch the build.
See the IntelliJ IDEA Web help
[http://www.jetbrains.com/idea/webhelp/maven-2.html](http://www.jetbrains.com/idea/webhelp/maven-2.html)
#### How to install the Maven project with documentation
Use the profile `generate-docs` to build _sources.jar_ and _javadoc.jar_. Building Maven site is not yeat supported.
Example: `mvn -Pgenerate-docs install`
#### How to activate and deactivate Maven profiles in Integrated Development Environments:
In _Eclipse_, from the main menu navigate to Run -> Run As -> 2 Maven build..., open the popup _Edit Configuration_ and specify the profiles.
Follow this link for _IntelliJ IDEA_: [http://www.jetbrains.com/idea/webhelp/activating-and-deactivating-maven-profiles.html](http://www.jetbrains.com/idea/webhelp/activating-and-deactivating-maven-profiles.html)
# Miscellaneous
### [Pull request #776:](https://github.com/junit-team/junit4/pull/776) Add support for [Travis CI](http://travis-ci.org)
Travis CI is a free CI server for public Github repositories. Every pull request is run by Travis CI and Github's web interface shows the CI result for each pull request. Every user can use Travis CI for testing her branches, too.
### [Pull request #921:](https://github.com/junit-team/junit4/pull/921) Apply Google Code Style
JUnit is now using the well documented [Google Code Style](http://google-styleguide.googlecode.com/svn/trunk/javaguide.html)
### [Pull request #939](https://github.com/junit-team/junit4/pull/939) Renamed license file
While using JUnit in Android apps, if any other referenced library has a file named `LICENSE.txt`, the APK generation failed with the following error -
`Error generating final archive: Found duplicate file for APK: LICENSE.txt`
To avoid this, the license file has been renamed to `LICENSE-junit.txt`
### [Pull request #962:](https://github.com/junit-team/junit4/pull/962) Do not include thread start time in test timeout measurements.
The time it takes to start a thread can be surprisingly large.
Especially in virtualized cloud environments where noisy neighbours.
This change reduces the probability of non-deterministic failures of
tests with timeouts (@Test(timeout=…)) by not beginning the timeout
clock until we have observed the starting of the task thread – the
thread that runs the actual test. This should make tests with small
timeout values more reliable in general, and especially in cloud CI
environments.
# Fixes to issues introduced in JUnit 4.12
The following section lists fixes to problems introduced in the first
release candidates for JUnit 4.12. You can ignore this section if you are
trying to understand the changes between 4.11 and 4.12.
### [Pull request #961:](https://github.com/junit-team/junit4/pull/961) Restore field names with f prefix.
In order to make the JUnit code more consistent with current coding practices, we changed
a number of field names to not start with the prefix "f". Unfortunately, at least one IDE
referenced a private field via reflection. This change reverts the field names for fields
known to be read via reflection.
### [Pull request #988:](https://github.com/junit-team/junit4/pull/988) Revert "Delete classes that are deprecated for six years."
In [745ca05](https://github.com/junit-team/junit4/commit/745ca05dccf5cc907e43a58142bb8be97da2b78f)
we removed classes that were deprecated for many releases. There was some concern that people
might not expect classes to be removed in a 4.x release. Even though we are not aware of any
problems from the deletion, we decided to add them back.
These classes may be removed in JUnit 5.0 or later.
### [Pull request #989:](https://github.com/junit-team/junit4/pull/989) Add JUnitSystem.exit() back.
In [917a88f](https://github.com/junit-team/junit4/commit/917a88fad06ce108a596a8fdb4607b1a2fbb3f3e)
the exit() method in JUnit was removed. This caused problems for at least one user. Even
though this class is in an internal package, we decided to add it back, and deprecated it.
This method may be removed in JUnit 5.0 or later.
### [Pull request #994:](https://github.com/junit-team/junit4/pull/994) [Pull request #1000:](https://github.com/junit-team/junit4/pull/1000) Ensure serialization compatibility where possible.
JUnit 4.12 RC1 introduced serilization incompatibilities with some of the classes. For example,
these pre-release versions of JUnit could not read instances of `Result` that were serialized
in JUnit 4.11 and earlier. These changes fix that problem.
================================================
FILE: doc/ReleaseNotes4.13.1.md
================================================
## Summary of changes in version 4.13.1
# Rules
### Security fix: `TemporaryFolder` now limits access to temporary folders on Java 1.7 or later
A local information disclosure vulnerability in `TemporaryFolder` has been fixed. See the published [security advisory](https://github.com/junit-team/junit4/security/advisories/GHSA-269g-pwp5-87pp) for details.
# Test Runners
### [Pull request #1669:](https://github.com/junit-team/junit/pull/1669) Make `FrameworkField` constructor public
Prior to this change, custom runners could make `FrameworkMethod` instances, but not `FrameworkField` instances. This small change allows for both now, because `FrameworkField`'s constructor has been promoted from package-private to public.
================================================
FILE: doc/ReleaseNotes4.13.2.md
================================================
## Summary of changes in version 4.13.2
# Rules
### [Pull request #1687:](https://github.com/junit-team/junit/pull/1687) Mark ThreadGroups created by FailOnTimeout as daemon groups
In JUnit 4.13 ([pull request #1517](https://github.com/junit-team/junit4/pull/1517)) an attempt was
made to fix leakage of the `ThreadGroup` instances created when a test is run with a timeout. That
change explicitly destroyed the `ThreadGroup` that was created for the time-limited test. Numerous
people reported problems that were caused by explicitly destroying the `ThreadGroup`.
In this change, the code was updated to call `ThreadGroup.setDaemon(true)` instead of destroying the
ThreadGroup.
### [Pull request $1691:](https://github.com/junit-team/junit/pull/1691) Only create ThreadGroups if FailOnTimeout.lookForStuckThread is true.
In JUnit 4.12 ([pull request #742](https://github.com/junit-team/junit4/pull/742)) the `Timeout`
Rule was updated to optionally display the stacktrace of the thread that appears to be stuck
(enabled on an opt-in basis by passing `true` to `Timeout.Builder.lookForStuckThread(boolean)`).
When that change was made, time-limited tests were changed to start the new thread in a new
`ThreadGroup`, even if the test did not call `lookForStuckThread()`. This subtle change in
behavior resulted in visible behavior changes to some tests (for example, tests of code that uses
`java.beans.ThreadGroupContext`).
In this change, the code is updated to only create a new `ThreadGroup` if the caller calls
`Timeout.Builder.lookForStuckThread(true)`. Tests with timeouts that do not make this call will
behave as they did in JUnit 4.11 (and more similar to tests that do not have a timeout). This
unfortunately could result in visible changes of tests written or updated since the 4.12
release. If this change adversely affects your tests, you can create the `Timeout` rule via the
builder and call `Timeout.Builder.lookForStuckThread(true)`.
# Exceptions
### [Pull request #1654:](https://github.com/junit-team/junit/pull/1654) Fix for issue #1192: NotSerializableException with AssumptionViolatedException
This change fixes an issue where `AssumptionViolatedException` instances could not be serialized
if they were created with a constructor that takes in an `org.hamcrest.Matcher` instance (these
constructors are used if you use one of the `assumeThat()` methods in `org.junit.Assume`).
================================================
FILE: doc/ReleaseNotes4.13.md
================================================
## Summary of changes in version 4.13
# Assertions
### [Pull request #1054:](https://github.com/junit-team/junit/pull/1054) Improved error message for `assertArrayEquals` when multi-dimensional arrays have different lengths
Previously, JUnit's assertion error message would indicate only that some array lengths _x_ and _y_ were unequal, without indicating whether this pertained to the outer array or some nested array. Now, in case of a length mismatch between two nested arrays, JUnit will tell at which indices they reside.
### [Pull request #1154](https://github.com/junit-team/junit/pull/1154) and [#1504](https://github.com/junit-team/junit/pull/1504) Add `assertThrows`
The `Assert` class now includes methods that can assert that a given function call (specified, for instance, as a lambda expression or method reference) results in a particular type of exception being thrown. In addition it returns the exception that was thrown, so that further assertions can be made (e.g. to verify that the message and cause are correct).
### [Pull request #1300:](https://github.com/junit-team/junit/pull/1300) Show contents of actual array when array lengths differ
Previously, when comparing two arrays which differ in length, `assertArrayEquals()` would only report that they differ in length. Now, it does the usual array comparison even when arrays differ in length, producing a failure message which combines the difference in length and the first difference in content. Where the content is another array, it is described by its type and length.
### [Pull request #1315:](https://github.com/junit-team/junit4/pull/1315) `assertArrayEquals` shouldn't throw an NPE when test suites are compiled/run across versions of junit
A redundant field, `fCause`, was removed on v4.12, and was seemingly harmless because `Throwable#initCause()` could directly initialize `cause` in the constructor. Unfortunately, this backwards incompatible change got aggravated when a test class, compiled with the latest (4.12+), ran with an older version that depended on fCause when building the assertion message<sup>[1](#1315-f1)</sup>.
This change adds back `fCause`, and overrides `getCause()` to handle forward compatibility<sup>[2](#1315-f2)</sup>.
To ensure serializability of further changes in `ArrayAssertionFailure` (until excising these fields by a major rev), a unit test now runs against v4.11, v4.12 failures, asserting around `#toString/getCause()`.
<a name="1315-f1">[1]</a> [Issue #1178](https://github.com/junit-team/junit4/issues/1178) details a particular case where gradle v2.2 is packaged with junit v4.11 and is used on running a test, generating test reports, despite specifying a particular version of junit (users would specify v4.12, or v4.+) in the test compile dependencies).
<a name="1315-f2">[2]</a> [Case](https://github.com/junit-team/junit4/pull/1315#issuecomment-222905229) if the test class is compiled with <= v4.11, where only `fCause` is initialized and not `Throwable#cause`, it can now fallback to the field, `fCause`, when building the message.
### [Pull request #1150:](https://github.com/junit-team/junit4/pull/1150) Deprecate `Assert#assertThat`
The method `assertThat` is used for writing assertions with Hamcrest. Hamcrest is an independent assertion library and contains an own `assertThat` method in the class `org.hamcrest.MatcherAssert`. It is available both in the old Hamcrest 1.3 release and in the current Hamcrest 2.1. Therefore the JUnit team recommends to use Hamcrest's own `assertThat` directly.
# Test Runners
### [Pull request #1037:](https://github.com/junit-team/junit/pull/1037) `BlockJUnit4ClassRunner#createTest` now accepts `FrameworkMethod`
Subclasses of `BlockJUnit4ClassRunner` can now produce a custom test object based on the `FrameworkMethod` test being executed by implementing the new `createTest(FrameworkMethod)` method. The default implementation calls the existing `createTest()` method.
### [Pull request #1082](https://github.com/junit-team/junit/pull/1082): Ensure exceptions from `BlockJUnit4ClassRunner.methodBlock()` don't result in unrooted tests
The introduction of the `runLeaf()` method in `BlockJUnit4ClassRunner` in JUnit 4.9 introduced a regression with regard to exception handling. Specifically, in JUnit 4.9 through 4.12 the invocation of `methodBlock()` is no longer executed within a try-catch block as was the case in previous versions of JUnit. Custom modifications to `methodBlock()` or the methods it invokes may in fact throw exceptions, and such exceptions cause the current test execution to abort immediately. As a result, the failing test method is unrooted in test reports, and subsequent test methods are never invoked. Furthermore, any `RunListener` registered with JUnit is not notified.
As of JUnit 4.13, the invocation of `methodBlock()` is once again wrapped within a try-catch block. If an exception is _not_ thrown, the resulting `Statement` is passed to `runLeaf()`. If an exception _is_ thrown, it is wrapped in a `Fail` statement which is passed to `runLeaf()`.
### [Pull request #1286](https://github.com/junit-team/junit/pull/1286): Provide better feedback to the user in case of invalid test classes
Only one exception per invalid test class is now thrown, rather than one per validation error.
The message of the exception includes all of the validation errors.
Example:
org.junit.runners.InvalidTestClassError: Invalid test class 'com.example.MyTest':
1. Method staticAfterMethod() should not be static
2. Method staticBeforeMethod() should not be static
is the exception thrown when running the following test class with any kind of `ParentRunner`:
public class MyTest {
@Before
public static void staticBeforeMethod() { .. }
@After
public static void staticAfterMethod() { .. }
@Test
public void myTest() { .. }
}
Validation errors for the same test class now count only once in the failure count. Therefore, in the example above, `Result#getFailureCount` will return 1.
### [Pull request #1252](https://github.com/junit-team/junit4/pull/1252): Restore ability use ParentRunner lost in separate class loader
`ParentRunner.getDescription()` now uses the class instance of the test class to create the description
(previously the class instance was loaded using the current classloader).
### [Pull request #1377](https://github.com/junit-team/junit4/pull/1377): Description produced by Request.classes() shouldn't be null
When obtaining a `Runner` via [Request.classes(Class<?>... classes)](http://junit.org/junit4/javadoc/4.12/org/junit/runner/Request.html#classes(java.lang.Class...)), that Runner's `Description` will now print "classes" for the root item. This replaces the misleading output of String "null".
### [Issue #1290](https://github.com/junit-team/junit4/issues/1290): Tests expecting AssumptionViolatedException are now correctly marked as passed
@Test(expected = AssumptionViolatedException.class)
public void shouldThrowAssumptionViolatedException() {
throw new AssumptionViolatedException("expected");
}
This test would previously be marked as skipped; now will be marked as passed.
### [Pull request #1465](https://github.com/junit-team/junit/pull/1465): Provide helpful message if parameter cannot be set.
JUnit throws an exception with a message like
Cannot set parameter 'name'. Ensure that the the field 'name' is public.
if a field of a parameterized test is annotated `@Parameter`, but its visibility is not public. Before an IllegalAccessException was thrown with a message like "Class ... can not access a member of class X with modifiers private".
### [Issue #1329](https://github.com/junit-team/junit4/issus/1329): Support assumptions in `@Parameters` method
No test is run when an assumption in the `@Parameters` method fails. The test result for this test class contains one assumption failure and run count is zero.
### [Pull request #1449](https://github.com/junit-team/junit/pull/1449): Parameterized runner reuses TestClass instance
Reduce memory consumption of parameterized tests by not creating a new instance of `TestClass` for every test.
### [Pull request #1130](https://github.com/junit-team/junit/pull/1130): Add Ordering, Orderable and @OrderWith
Test classes can now be annotated with `@OrderWith` to specify that the tests should execute in a particular
order. All runners extending `ParentRunner` support `@OrderWith`. Runners can also be ordered using
`Request.orderWith(Ordering)`
Classes annotated with `@RunWith(Suite.class)` can also be ordered with `@OrderWith`. Note that if this is done, nested classes annotated with `@FixMethodOrder` will not be reordered (i.e. the `@FixMethodOrder` annotation is
always respected). Having a test class annotated with both `@OrderWith` and `@FixMethodOrder` will result in a
validation error (see
[pull request #1638](https://github.com/junit-team/junit4/pull/1638)).
### [Pull request #1408](https://github.com/junit-team/junit/pull/1408): Suites don't have to be public
Classes annotated with `@RunWith(Suite.class)` do not need to be public. This fixes a regression bug in JUnit 4.12. Suites didn't had to be public before 4.12.
### [Pull request #1638](https://github.com/junit-team/junit4/pull/1638): Never reorder classes annotated with @FixMethodOrder
Changing the order of a test run using `Request.sortWith()` no longer changes the order of test classes annotated
with `@FixMethodOrder`. The same holds true when you reorder tests with `Request.orderWith()` (`orderWith()`
was introduced in [Pull request #1130](https://github.com/junit-team/junit/pull/1130)).
This was done because usually `@FixMethodOrder` is added to a class because the tests in the class they only pass
if run in a specific order.
Test suites annotated with `@OrderWith` will also respect the `@FixMethodOrder` annotation.
Having a test class annotated with both `@OrderWith` and `@FixMethodOrder` will result in a validation error.
# Rules
### [Pull request #1044:](https://github.com/junit-team/junit/pull/1044) Strict verification of resource deletion in `TemporaryFolder` rule
Previously `TemporaryFolder` rule did not fail the test if some temporary resources could not be deleted. With this change a new `assuredDeletion` parameter is introduced which will fail the test with an `AssertionError`, if resource deletion fails. The default behavior of `TemporaryFolder` is unchanged.
This feature must be enabled by creating a `TemporaryFolder` using the `TemporaryFolder.builder()` method:
```java
@Rule public TemporaryFolder folder = TemporaryFolder.builder().assureDeletion().build();
```
### [Issue #1100:](https://github.com/junit-team/junit/issues/1110) StopWatch does not need to be abstract.
Previously `StopWatch` was an abstract class, which means it cannot be used without extending it or using an anonymous class. The abstract modifier has been removed and StopWatch can be used easily now.
### [Issue #1157:](https://github.com/junit-team/junit/issues/1157) TestName: Make 'name' field volatile
The `name` field in the `TestName` rule was updated to be volatile. This should ensure that the name
is published even when tests are running in parallel.
### [Issue #1223:](https://github.com/junit-team/junit/issues/1223) TemporaryFolder doesn't work for parallel test execution in several JVMs
Previously `TemporaryFolder` rule silently succeeded if it failed to create a fresh temporary directory. With this change it will notice the failure, retry with a new name, and ultimately throw an `IOException` if all such attempts fail.
### [Pull request #1305:](https://github.com/junit-team/junit/pull/1305) Add `ErrorCollector.checkThrows`
The `ErrorCollector` class now has a `checkThrows` method that can assert that a given function call (specified, for instance, as a lambda expression or method reference) results in a particular type of exception being thrown.
### [Issue #1303:](https://github.com/junit-team/junit/issues/1303) Prevent following symbolic links when deleting temporary directories
Previously, `TemporaryFolder` would follow symbolic links; now it just deletes them.
Following symbolic links when removing files can lead to the removal of files outside the directory structure rooted in the temporary folder, and it can lead to unbounded recursion if a symbolic link points to a directory where the link is directly reachable from.
### [Issue #1295:](https://github.com/junit-team/junit/issues/1295) Javadoc for RuleChain contains errors
Removed error from RuleChain Javadoc and clarified how it works with existing rules. Removed `static` modifier, added missing closing parenthesis of method calls and added clarification.
### [Pull request #1313](https://github.com/junit-team/junit4/pull/1313): `RuleChain.around()` rejects null arguments
`RuleChain.around()` now implements a fail-fast strategy which also allows for better feedback to the final user, as the stacktrace will point to the exact line where the null rule is declared.
### [Pull request #1397](https://github.com/junit-team/junit4/pull/1397): Change generics on `ExpectedException.expectCause()`
The signature of `ExpectedException.expectCause()` would not allow the caller to pass in a `Matcher<Object>` (which is returned by `CoreMatchers.notNullValue()`). This was fixed by changing the method to take in a
`Matcher<?>` (ideally, the method should take in `Matcher<? super Throwable>` but there was concern that
changing the parameter type to `Matcher<? super Throwable>` would break some callers).
### [Pull request #1443](https://github.com/junit-team/junit4/pull/1443): `ExpectedException.isAnyExceptionExpected()` is now public
The method `ExpectedException.isAnyExceptionExpected()` returns `true` if there is at least one expectation present for the `ExpectedException` rule.
### [Pull request #1395](https://github.com/junit-team/junit4/pull/1395): Wrap assumption violations in ErrorCollector
Both `ErrorCollector.addError()` and `ErrorCollector.checkSucceeds()` now wrap `AssumptionViolatedException`.
In addition, `ErrorCollector.addError()` will throw a `NullPointerException` if you pass in a `null` value.
### [Pull request #1402](https://github.com/junit-team/junit4/pull/1402): TemporaryFolder.newFolder(String) supports paths with slashes
There was a regression in JUnit 4.12 where `TemporaryFolder.newFolder(String)` no longer supported passing
in strings with separator characters. This has been fixed. he overload of newFolder() that
supports passing in multiple strings still does not allow path separators.
### [Pull requests #1406 (part 1)](https://github.com/junit-team/junit4/pull/1406) and [#1568](https://github.com/junit-team/junit4/pull/1568): Improve error message when TemporaryFolder.newFolder(String) fails
When `newFolder(String path)` was not able to create the folder then it always failed with the error message "a folder with the name '`<path>`' already exists" although the reason for the failure could be something else. This message is now only used if the folder really exists. The message is "a file with the path '`<path>`' exists" if the whole path or a part of the path points to a file. In all other cases it fails now with the message "could not create a folder with the path '`<path>`'"
### [Pull request #1406 (part 2)](https://github.com/junit-team/junit4/pull/1406): TemporaryFolder.newFolder(String...) supports path separator
You can now pass paths with path separators to `TemporaryFolder.newFolder(String...)`. E.g.
tempFolder.newFolder("temp1", "temp2", "temp3/temp4")
It creates a folder `temp1/temp2/temp3/temp4`.
### [Pull request #1406 (part 3)](https://github.com/junit-team/junit4/pull/1406): TemporaryFolder.newFolder(String...) fails for empty array
When you call
tempFolder.newFolder(new String[])
then it throws an `IllegalArgumentException` instead of returning an already existing folder.
### [Pull request #1335](https://github.com/junit-team/junit4/pull/1335): Fix ExternalResource: the test failure could be lost
When both the test failed and closing the resource failed, only the exception coming from the `after()` method was propagated, as per semantics of the try-finally (see also http://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.20.2).
The new behavior is compatible with @After method semantics, as implemented in [RunAfters](https://github.com/junit-team/junit4/blob/HEAD/src/main/java/org/junit/internal/runners/statements/RunAfters.java).
### [Pull request #1435](https://github.com/junit-team/junit4/pull/1435): @BeforeParam/@AfterParam method annotations for Parameterized tests.
This allows having preparation and/or cleanup in tests for specific parameter values.
### [Pull request #1460](https://github.com/junit-team/junit4/pull/1460): Handle assumption violations in the @Parameters method for Parameterized tests.
This allows skipping the whole test class when its assumptions are not met.
### [Pull request #1445](https://github.com/junit-team/junit4/pull/1445) and [Pull request #1335](https://github.com/junit-team/junit4/pull/1501): Declarative ordering of rules.
The order in which rules are executed is specified by the annotation attribute: `@Rule(order = N)`, deprecating `RuleChain`. This may be used for avoiding some common pitfalls with `TestWatcher, `ErrorCollector` and `ExpectedException` for example. The Javadoc of `TestWatcher` was retrofitted accordingly.
### [Pull request #1517](https://github.com/junit-team/junit4/pull/1517): Timeout rule destroys its ThreadGroups at the end
The `ThreadGroup` created for handling the timeout of tests is now destroyed, so the main thread group no longer keeps a reference to all timeout groups created during the tests. This caused the `threadGroup` to remain in memory, and all of its context along with it.
### [Pull request #1633](https://github.com/junit-team/junit4/pull/1633): Deprecate ExpectedException.none()
The method Assert.assertThrows provides a nicer way for verifying exceptions. In addition the use of ExpectedException is error-prone when used with other rules like TestWatcher because the order of rules is important in that case.
### [Pull request #1413](https://github.com/junit-team/junit4/pull/1413): Ignore bridge methods when scanning for annotated methods
In a setup with a class hierarchy for test classes the order of rules (from methods), before methods, after methods and others depends on the class that contains these methods. Compilers can add bridge methods to child classes and therefore the order of the aforementioned methods can change in older JUnit releases. This is now fixed because bridge methods are ignored when scanning for annotated methods.
### [Pull request #1612](https://github.com/junit-team/junit4/pull/1612): Make @ValidateWith only applicable to annotation types
`@Target(ANNOTATION_TYPE)` has been added to `@ValidateWith` since it's only designed to be applied to another annotation.
# Run Listener
### [Pull request #1118:](https://github.com/junit-team/junit4/pull/1118) Add suite start/finish events to listener
The `RunListener` class now has `fireTestSuiteStarted` and `fireTestSuiteFinished` methods that notify when test suites are about to be started/finished.
# Exception Testing
### [Pull request #1359:](https://github.com/junit-team/junit4/pull/1359) Fixes how `MultipleFailureException` stack traces are printed
Previously, calling `MultipleFailureException.printStackTrace()` only printed the stack trace for the `MultipleFailureException` itself. After this change, the stack trace for each exception caught in the `MultipleFailureException` is printed.
### [Pull request #1376:](https://github.com/junit-team/junit4/pull/1376) Initializing MultipleFailureException with an empty list will now fail the test
Previously, initializing `MultipleFailureException` with an empty list of contained Exceptions and throwing it in a test case wouldn't actually fail the test. Now an `IllegalArgumentException` will be raised in this situation and thus also fail the test.
### [Pull request #1371:](https://github.com/junit-team/junit4/pull/1371) Update MultipleFailureException.assertEmpty() to wrap assumption failure
`MultipleFailureException` will now wrap `MultipleFailureException` with `TestCouldNotBeSkippedException`. Previously, if you passed `MultipleFailureException` one `MultipleFailureException`--and no other exceptions--
then the test would be skipped, otherwise it would fail. With the new behavior, it will always fail.
### [Issue #1290:](https://github.com/junit-team/junit4/issues/1290) `@Test(expected = AssumptionViolatedException.class)` passes for AssumptionViolatedException
Tests annotated with `@test(expected = AssumptionViolatedException.class)`
which throw AssumptionViolatedException had been marked as skipped. Now the are marked as successful tests.
# JUnit 3 Changes
### [Pull request #1227:](https://github.com/junit-team/junit/pull/1227) Behave better if the `SecurityManager` denies access to `junit.properties`
Previously, running tests with a `SecurityManager` would cause the test runner itself to throw an `AccessControlException` if the security policy didn't want it reading from `~/junit.properties`. This will now be treated the same as if the file does not exist.
# Misc
### [Pull request #1571:](https://github.com/junit-team/junit4/pull/1571) Set "junit" as "Automatic-Module-Name"
For existing releases of JUnit the `Automatic-Module-Name` was derived from the name of the jar. In most cases it is already the name "junit". JUnit 4.13 explicitly sets the module name to "junit" so that it is independent from the jar's name.
### [Pull request #1028:](https://github.com/junit-team/junit4/pull/1028) Trim stack trace
JUnit's command-line runner (`JUnitCore`) prints smaller stack traces. It skips all stack trace elements that come before the test method so that it starts at the test method. E.g. the output for the example from [Getting started](https://github.com/junit-team/junit4/wiki/Getting-started) page is now
.E
Time: 0,006
There was 1 failure:
1) evaluatesExpression(CalculatorTest)
java.lang.AssertionError: expected:<6> but was:<-6>
at org.junit.Assert.fail(Assert.java:89)
at org.junit.Assert.failNotEquals(Assert.java:835)
at org.junit.Assert.assertEquals(Assert.java:647)
at org.junit.Assert.assertEquals(Assert.java:633)
at CalculatorTest.evaluatesExpression(CalculatorTest.java:9)
FAILURES!!!
Tests run: 1, Failures: 1
### [Pull request #1403:](https://github.com/junit-team/junit4/pull/1403) Restore CategoryFilter constructor
The constructor `CategoryFilter(Class<?> includedCategory, Class<?> excludedCategory)` has been removed in JUnit 4.12. It is now available again.
### [Pull request #1530:](https://github.com/junit-team/junit4/pull/1530) Add Result#getAssumptionFailureCount
Add method `getAssumptionFailureCount()` to `Result` which returns the number of assumption failures.
### [Pull request #1292:](https://github.com/junit-team/junit4/pull/1292) Fix ResultMatchers#hasFailureContaining
`ResultMatchers.hasFailureContaining()` should return `false` when the given `PrintableResult` has no failures.
### [Pull request #1380:](https://github.com/junit-team/junit4/pull/1380) Fix Assume#assumeNotNull
`Assume.assumeNotNull` should throw AssumptionViolatedException when called with a `null` array.
### [Pull request #1557:](https://github.com/junit-team/junit4/pull/1380) MaxCore always closes stream of history file
MaxCore didn't close the output stream of the history file when write failed. Now it does.
### Signing
The 4.13 release is signed with a new key (id 5EC61B51):
https://github.com/junit-team/junit4/blob/8c0df64ff17fead54c304a8b189da839084925c2/KEYS
================================================
FILE: doc/ReleaseNotes4.4.html
================================================
<h2>Summary of Changes in version 4.5</h2>
<h3>Categories</h3>
<p>Each test method and test class can be annotated as belonging to a <em>category</em>:</p>
<pre><code>public static class SomeUITests {
@Category(UserAvailable.class)
@Test
public void askUserToPressAKey() { }
@Test
public void simulatePressingKey() { }
}
@Category(InternetConnected.class)
public static class InternetTests {
@Test
public void pingServer() { }
}
</code></pre>
<p>To run all of the tests in a particular category, you must currently explicitly create a custom request:</p>
<pre><code>new JUnitCore().run(Request.aClass(SomeUITests.class).inCategories(UserAvailable.class));
</code></pre>
<p>This feature will very likely be improved before the final release of JUnit 4.5</p>
<h3>Miscellaneous</h3>
<ul>
<li><p><code>@Before</code> and <code>@After</code> methods are run before and after each set of attempted parameters
on a Theory</p></li>
<li><p>Refactoring removed duplication that used to exist in classes MethodRoadie and ClassRoadie</p></li>
<li><p>Exposed API <code>ParameterSignature.getType()</code></p></li>
</ul>
<h2>Summary of Changes in version 4.4</h2>
<p>JUnit is designed to efficiently capture developers' intentions about
their code, and quickly check their code matches those intentions.
Over the last year, we've been talking about what things developers
would like to say about their code that have been difficult in the
past, and how we can make them easier.</p>
<p><a href="http://sourceforge.net/project/showfiles.php?group_id=15278">Download</a></p>
<h3>assertThat</h3>
<p>Two years ago, Joe Walnes built a <a href="http://joewalnes.com/2005/05/13/flexible-junit-assertions-with-assertthat/">new assertion mechanism</a> on top of what was
then <a href="http://www.jmock.org/download.html">JMock 1</a>. The method name was <code>assertThat</code>, and the syntax looked like this:</p>
<pre><code>assertThat(x, is(3));
assertThat(x, is(not(4)));
assertThat(responseString, either(containsString("color")).or(containsString("colour")));
assertThat(myList, hasItem("3"));
</code></pre>
<p>More generally:</p>
<pre><code>assertThat([value], [matcher statement]);
</code></pre>
<p>Advantages of this assertion syntax include:</p>
<ul>
<li><p>More readable and typeable: this syntax allows you to think in terms of subject, verb, object
(assert "x is 3") rather than <code>assertEquals</code>, which uses verb, object, subject (assert "equals 3 x")</p></li>
<li><p>Combinations: any matcher statement <code>s</code> can be negated (<code>not(s)</code>), combined (<code>either(s).or(t)</code>),
mapped to a collection (<code>each(s)</code>), or used in custom combinations (<code>afterFiveSeconds(s)</code>)</p></li>
<li><p>Readable failure messages. Compare</p>
<pre><code>assertTrue(responseString.contains("color") || responseString.contains("colour"));
// ==> failure message:
// java.lang.AssertionError:
assertThat(responseString, anyOf(containsString("color"), containsString("colour")));
// ==> failure message:
// java.lang.AssertionError:
// Expected: (a string containing "color" or a string containing "colour")
// got: "Please choose a font"
</code></pre></li>
<li><p>Custom Matchers. By implementing the <code>Matcher</code> interface yourself, you can get all of the
above benefits for your own custom assertions.</p></li>
<li><p>For a more thorough description of these points, see <a href="http://joewalnes.com/2005/05/13/flexible-junit-assertions-with-assertthat/">Joe Walnes's
original post</a>.</p></li>
</ul>
<p>We have decided to include this API directly in JUnit.
It's an extensible and readable syntax, and it enables
new features, like <a href="#assumptions">assumptions</a> and <a href="#theories">theories</a>.</p>
<p>Some notes:</p>
<ul>
<li>The old assert methods are never, ever, going away. Developers may
continue using the old <code>assertEquals</code>, <code>assertTrue</code>, and so on.</li>
<li><p>The second parameter of an <code>assertThat</code> statement is a <code>Matcher</code>.
We include the Matchers we want as static imports, like this:</p>
<pre><code>import static org.hamcrest.CoreMatchers.is;
</code></pre>
<p>or:</p>
<pre><code>import static org.hamcrest.CoreMatchers.*;
</code></pre></li>
<li><p>Manually importing <code>Matcher</code> methods can be frustrating. <a href="http://www.eclipse.org/downloads/">Eclipse 3.3</a> includes the ability to
define
"Favorite" classes to import static methods from, which makes it easier
(Search for "Favorites" in the Preferences dialog).
We expect that support for static imports will improve in all Java IDEs in the future.</p></li>
<li><p>To allow compatibility with a wide variety of possible matchers,
we have decided to include the classes from hamcrest-core,
from the <a href="http://code.google.com/p/hamcrest/">Hamcrest</a> project. This is the first time that
third-party classes have been included in JUnit. </p></li>
<li><p>JUnit currently ships with a few matchers, defined in
<code>org.hamcrest.CoreMatchers</code> and <code>org.junit.matchers.JUnitMatchers</code>. <br />
To use many, many more, consider downloading the <a href="http://hamcrest.googlecode.com/files/hamcrest-all-1.1.jar">full hamcrest package</a>.</p></li>
<li><p>JUnit contains special support for comparing string and array
values, giving specific information on how they differ. This is not
yet available using the <code>assertThat</code> syntax, but we hope to bring
the two assert methods into closer alignment in future releases.</p></li>
</ul>
<p><a name="assumptions" /></p>
<h3>Assumptions</h3>
<p>Ideally, the developer writing a test has control of all of the forces that might cause a test to fail.
If this isn't immediately possible, making dependencies explicit can often improve a design. <br />
For example, if a test fails when run in a different locale than the developer intended,
it can be fixed by explicitly passing a locale to the domain code.</p>
<p>However, sometimes this is not desirable or possible. <br />
It's good to be able to run a test against the code as it is currently written,
implicit assumptions and all, or to write a test that exposes a known bug.
For these situations, JUnit now includes the ability to express "assumptions":</p>
<pre><code>import static org.junit.Assume.*
@Test public void filenameIncludesUsername() {
assumeThat(File.separatorChar, is('/'));
assertThat(new User("optimus").configFileName(), is("configfiles/optimus.cfg"));
}
@Test public void correctBehaviorWhenFilenameIsNull() {
assumeTrue(bugFixed("13356")); // bugFixed is not included in JUnit
assertThat(parse(null), is(new NullDocument()));
}
</code></pre>
<p>With this release, a failed assumption will lead to the test being marked as passing,
regardless of what the code below the assumption may assert.
In the future, this may change, and a failed assumption may lead to the test being ignored:
however, third-party runners do not currently allow this option.</p>
<p>We have included <code>assumeTrue</code> for convenience, but thanks to the
inclusion of Hamcrest, we do not need to create <code>assumeEquals</code>,
<code>assumeSame</code>, and other analogues to the <code>assert*</code> methods. All of
those functionalities are subsumed in <code>assumeThat</code>, with the appropriate
matcher.</p>
<p>A failing assumption in a <code>@Before</code> or <code>@BeforeClass</code> method will have the same effect
as a failing assumption in each <code>@Test</code> method of the class.</p>
<p><a name="theories" /></p>
<h3>Theories</h3>
<p>More flexible and expressive assertions, combined with the ability to
state assumptions clearly, lead to a new kind of statement of intent,
which we call a "Theory". A test captures the intended behavior in
one particular scenario. A theory captures some aspect of the
intended behavior in possibly
infinite numbers of potential scenarios. For example:</p>
<pre><code>@RunWith(Theories.class)
public class UserTest {
@DataPoint public static String GOOD_USERNAME = "optimus";
@DataPoint public static String USERNAME_WITH_SLASH = "optimus/prime";
@Theory public void filenameIncludesUsername(String username) {
assumeThat(username, not(containsString("/")));
assertThat(new User(username).configFileName(), containsString(username));
}
}
</code></pre>
<p>This makes it clear that the user's filename should be included in the
config file name, only if it doesn't contain a slash. Another test
or theory might define what happens when a username does contain a slash.</p>
<p><code>UserTest</code> will attempt to run <code>filenameIncludesUsername</code> on
every compatible <code>DataPoint</code> defined in the class. If any of the
assumptions fail, the data point is silently ignored. If all of the
assumptions pass, but an assertion fails, the test fails.</p>
<p>The support for Theories has been absorbed from the <a href="http://popper.tigris.org">Popper</a>
project, and <a href="http://popper.tigris.org/tutorial.html">more complete documentation</a> can be found
there.</p>
<p>Defining general statements in this way can jog the developer's memory
about other potential data points and tests, also allows <a href="http://www.junitfactory.org">automated
tools</a> to <a href="http://shareandenjoy.saff.net/2007/04/popper-and-junitfactory.html">search</a> for new, unexpected data
points that expose bugs.</p>
<h3>Other changes</h3>
<p>This release contains other bug fixes and new features. Among them:</p>
<ul>
<li><p>Annotated descriptions</p>
<p>Runner UIs, Filters, and Sorters operate on Descriptions of test
methods and test classes. These Descriptions now include the
annotations on the original Java source element, allowing for richer
display of test results, and easier development of annotation-based
filters.</p></li>
<li><p>Bug fix (1715326): assertEquals now compares all Numbers using their
native implementation of <code>equals</code>. This assertion, which passed in
4.3, will now fail:</p>
<pre><code>assertEquals(new Integer(1), new Long(1));
</code></pre>
<p>Non-integer Numbers (Floats, Doubles, BigDecimals, etc),
which were compared incorrectly in 4.3, are now fixed.</p></li>
<li><p><code>assertEquals(long, long)</code> and <code>assertEquals(double, double)</code> have
been re-introduced to the <code>Assert</code> class, to take advantage of
Java's native widening conversions. Therefore, this still passes:</p>
<pre><code>assertEquals(1, 1L);
</code></pre></li>
<li><p>The default runner for JUnit 4 test classes has been refactored.
The old version was named <code>TestClassRunner</code>, and the new is named
<code>JUnit4ClassRunner</code>. Likewise, <code>OldTestClassRunner</code> is now
<code>JUnit3ClassRunner</code>. The new design allows variations in running
individual test classes to be expressed with fewer custom classes.
For a good example, see the source to
<code>org.junit.experimental.theories.Theories</code>.</p></li>
<li><p>The rules for determining which runner is applied by default to a
test class have been simplified:</p>
<ol>
<li><p>If the class has a <code>@RunWith</code> annotation, the annotated runner
class is used.</p></li>
<li><p>If the class can be run with the JUnit 3 test runner (it
subclasses <code>TestCase</code>, or contains a <code>public static Test suite()</code>
method), JUnit38ClassRunner is used.</p></li>
<li><p>Otherwise, JUnit4ClassRunner is used.</p></li>
</ol>
<p>This default guess can always be overridden by an explicit
<code>@RunWith(JUnit4ClassRunner.class)</code> or
<code>@RunWith(JUnit38ClassRunner.class)</code> annotation.</p>
<p>The old class names <code>TestClassRunner</code> and <code>OldTestClassRunner</code>
remain as deprecated.</p></li>
<li><p>Bug fix (1739095): Filters and Sorters work correctly on test
classes that contain a <code>suite</code> method like:</p>
<pre><code>public static junit.framework.Test suite() {
return new JUnit4TestAdapter(MyTest.class);
}
</code></pre></li>
<li><p>Bug fix (1745048): @After methods are now correctly called
after a test method times out.</p></li>
</ul>
================================================
FILE: doc/ReleaseNotes4.4.md
================================================
## Summary of Changes in version 4.5 ##
### Categories ###
Each test method and test class can be annotated as belonging to a _category_:
```java
public static class SomeUITests {
@Category(UserAvailable.class)
@Test
public void askUserToPressAKey() { }
@Test
public void simulatePressingKey() { }
}
@Category(InternetConnected.class)
public static class InternetTests {
@Test
public void pingServer() { }
}
```
To run all of the tests in a particular category, you must currently explicitly create a custom request:
```java
new JUnitCore().run(Request.aClass(SomeUITests.class).inCategories(UserAvailable.class));
```
This feature will very likely be improved before the final release of JUnit 4.5
### Theories ###
- `@Before` and `@After` methods are run before and after each set of attempted parameters
on a Theory, and each set of parameters is run on a new instance of the test class.
- Exposed API's `ParameterSignature.getType()` and `ParameterSignature.getAnnotations()`
- An array of data points can be introduced by a field or method marked with the new annotation `@DataPoints`
- The Theories custom runner has been refactored to make it easier to extend
### JUnit 4 Runner API ###
- There has been a drastic rewrite of the API for custom Runners in 4.5. This
needs to be written up separately before release.
- Tests with failed assumptions are now marked as Ignored, rather than silently passing.
This may change behavior in some client tests, and also will require some new support
on the part of IDE's.
## Summary of Changes in version 4.4 ##
JUnit is designed to efficiently capture developers' intentions about
their code, and quickly check their code matches those intentions.
Over the last year, we've been talking about what things developers
would like to say about their code that have been difficult in the
past, and how we can make them easier.
[Download][]
[Download]: http://sourceforge.net/project/showfiles.php?group_id=15278
### assertThat ###
Two years ago, Joe Walnes built a [new assertion mechanism][walnes] on top of what was
then [JMock 1][]. The method name was `assertThat`, and the syntax looked like this:
[walnes]: http://joewalnes.com/2005/05/13/flexible-junit-assertions-with-assertthat/
[JMock 1]: http://www.jmock.org/download.html
```java
assertThat(x, is(3));
assertThat(x, is(not(4)));
assertThat(responseString, either(containsString("color")).or(containsString("colour")));
assertThat(myList, hasItem("3"));
```
More generally:
```java
assertThat([value], [matcher statement]);
```
Advantages of this assertion syntax include:
- More readable and typeable: this syntax allows you to think in terms of subject, verb, object
(assert "x is 3") rather than `assertEquals`, which uses verb, object, subject (assert "equals 3 x")
- Combinations: any matcher statement `s` can be negated (`not(s)`), combined (`either(s).or(t)`),
mapped to a collection (`each(s)`), or used in custom combinations (`afterFiveSeconds(s)`)
- Readable failure messages. Compare
```java
assertTrue(responseString.contains("color") || responseString.contains("colour"));
// ==> failure message:
// java.lang.AssertionError:
assertThat(responseString, anyOf(containsString("color"), containsString("colour")));
// ==> failure message:
// java.lang.AssertionError:
// Expected: (a string containing "color" or a string containing "colour")
// got: "Please choose a font"
```
- Custom Matchers. By implementing the `Matcher` interface yourself, you can get all of the
above benefits for your own custom assertions.
- For a more thorough description of these points, see [Joe Walnes's
original post][walnes].
We have decided to include this API directly in JUnit.
It's an extensible and readable syntax, and it enables
new features, like [assumptions][] and [theories][].
[assumptions]: #assumptions
[theories]: #theories
Some notes:
- The old assert methods are never, ever, going away. Developers may
continue using the old `assertEquals`, `assertTrue`, and so on.
- The second parameter of an `assertThat` statement is a `Matcher`.
We include the Matchers we want as static imports, like this:
```java
import static org.hamcrest.CoreMatchers.is;
```
or:
```java
import static org.hamcrest.CoreMatchers.*;
```
- Manually importing `Matcher` methods can be frustrating. [Eclipse 3.3][] includes the ability to
define
"Favorite" classes to import static methods from, which makes it easier
(Search for "Favorites" in the Preferences dialog).
We expect that support for static imports will improve in all Java IDEs in the future.
[Eclipse 3.3]: http://www.eclipse.org/downloads/
- To allow compatibility with a wide variety of possible matchers,
we have decided to include the classes from hamcrest-core,
from the [Hamcrest][] project. This is the first time that
third-party classes have been included in JUnit.
[Hamcrest]: http://code.google.com/p/hamcrest/
- JUnit currently ships with a few matchers, defined in
`org.hamcrest.CoreMatchers` and `org.junit.matchers.JUnitMatchers`.
To use many, many more, consider downloading the [full hamcrest package][].
[full hamcrest package]: http://hamcrest.googlecode.com/files/hamcrest-all-1.1.jar
- JUnit contains special support for comparing string and array
values, giving specific information on how they differ. This is not
yet available using the `assertThat` syntax, but we hope to bring
the two assert methods into closer alignment in future releases.
<a name="assumptions" />
### Assumptions ###
Ideally, the developer writing a test has control of all of the forces that might cause a test to fail.
If this isn't immediately possible, making dependencies explicit can often improve a design.
For example, if a test fails when run in a different locale than the developer intended,
it can be fixed by explicitly passing a locale to the domain code.
However, sometimes this is not desirable or possible.
It's good to be able to run a test against the code as it is currently written,
implicit assumptions and all, or to write a test that exposes a known bug.
For these situations, JUnit now includes the ability to express "assumptions":
```java
import static org.junit.Assume.*
@Test public void filenameIncludesUsername() {
assumeThat(File.separatorChar, is('/'));
assertThat(new User("optimus").configFileName(), is("configfiles/optimus.cfg"));
}
@Test public void correctBehaviorWhenFilenameIsNull() {
assumeTrue(bugFixed("13356")); // bugFixed is not included in JUnit
assertThat(parse(null), is(new NullDocument()));
}
```
With this release, a failed assumption will lead to the test being marked as passing,
regardless of what the code below the assumption may assert.
In the future, this may change, and a failed assumption may lead to the test being ignored:
however, third-party runners do not currently allow this option.
We have included `assumeTrue` for convenience, but thanks to the
inclusion of Hamcrest, we do not need to create `assumeEquals`,
`assumeSame`, and other analogues to the `assert*` methods. All of
those functionalities are subsumed in `assumeThat`, with the appropriate
matcher.
A failing assumption in a `@Before` or `@BeforeClass` method will have the same effect
as a failing assumption in each `@Test` method of the class.
<a name="theories" />
### Theories ###
More flexible and expressive assertions, combined with the ability to
state assumptions clearly, lead to a new kind of statement of intent,
which we call a "Theory". A test captures the intended behavior in
one particular scenario. A theory captures some aspect of the
intended behavior in possibly
infinite numbers of potential scenarios. For example:
```java
@RunWith(Theories.class)
public class UserTest {
@DataPoint public static String GOOD_USERNAME = "optimus";
@DataPoint public static String USERNAME_WITH_SLASH = "optimus/prime";
@Theory public void filenameIncludesUsername(String username) {
assumeThat(username, not(containsString("/")));
assertThat(new User(username).configFileName(), containsString(username));
}
}
```
This makes it clear that the user's filename should be included in the
config file name, only if it doesn't contain a slash. Another test
or theory might define what happens when a username does contain a slash.
`UserTest` will attempt to run `filenameIncludesUsername` on
every compatible `DataPoint` defined in the class. If any of the
assumptions fail, the data point is silently ignored. If all of the
assumptions pass, but an assertion fails, the test fails.
The support for Theories has been absorbed from the [Popper][]
project, and [more complete documentation][popper-docs] can be found
there.
[Popper]: http://popper.tigris.org
[popper-docs]: http://popper.tigris.org/tutorial.html
Defining general statements in this way can jog the developer's memory
about other potential data points and tests, also allows [automated
tools][junit-factory] to [search][my-blog] for new, unexpected data
points that expose bugs.
[junit-factory]: http://www.junitfactory.org
[my-blog]: http://shareandenjoy.saff.net/2007/04/popper-and-junitfactory.html
### Other changes ###
This release contains other bug fixes and new features. Among them:
- Annotated descriptions
Runner UIs, Filters, and Sorters operate on Descriptions of test
methods and test classes. These Descriptions now include the
annotations on the original Java source element, allowing for richer
display of test results, and easier development of annotation-based
filters.
- Bug fix (1715326): assertEquals now compares all Numbers using their
native implementation of `equals`. This assertion, which passed in
4.3, will now fail:
```java
assertEquals(new Integer(1), new Long(1));
```
Non-integer Numbers (Floats, Doubles, BigDecimals, etc),
which were compared incorrectly in 4.3, are now fixed.
- `assertEquals(long, long)` and `assertEquals(double, double)` have
been re-introduced to the `Assert` class, to take advantage of
Java's native widening conversions. Therefore, this still passes:
```java
assertEquals(1, 1L);
```
- The default runner for JUnit 4 test classes has been refactored.
The old version was named `TestClassRunner`, and the new is named
`JUnit4ClassRunner`. Likewise, `OldTestClassRunner` is now
`JUnit3ClassRunner`. The new design allows variations in running
individual test classes to be expressed with fewer custom classes.
For a good example, see the source to
`org.junit.experimental.theories.Theories`.
- The rules for determining which runner is applied by default to a
test class have been simplified:
1. If the class has a `@RunWith` annotation, the annotated runner
class is used.
2. If the class can be run with the JUnit 3 test runner (it
subclasses `TestCase`, or contains a `public static Test suite()`
method), JUnit38ClassRunner is used.
3. Otherwise, JUnit4ClassRunner is used.
This default guess can always be overridden by an explicit
`@RunWith(JUnit4ClassRunner.class)` or
`@RunWith(JUnit38ClassRunner.class)` annotation.
The old class names `TestClassRunner` and `OldTestClassRunner`
remain as deprecated.
- Bug fix (1739095): Filters and Sorters work correctly on test
classes that contain a `suite` method like:
```java
public static junit.framework.Test suite() {
return new JUnit4TestAdapter(MyTest.class);
}
```
- Bug fix (1745048): @After methods are now correctly called
after a test method times out.
================================================
FILE: doc/ReleaseNotes4.4.txt
================================================
Please see ReleaseNotes4.4.md
================================================
FILE: doc/ReleaseNotes4.5.html
================================================
<h2>Summary of Changes in version 4.5</h2>
<h3>Installation</h3>
<ul>
<li>We are releasing <code>junit-4.5.jar</code>, which contains all the classes
necessary to run JUnit, and <code>junit-dep-4.5.jar</code>, which leaves out
hamcrest classes, for developers who already use hamcrest outside of
JUnit.</li>
</ul>
<h3>Basic JUnit operation</h3>
<ul>
<li><p>JUnitCore now more often exits with the correct exit code (0 for
success, 1 for failure)</p></li>
<li><p>Badly formed test classes (exceptions in constructors, classes
without tests, multiple constructors, Suite without @SuiteClasses)
produce more helpful error messages</p></li>
<li><p>Test classes whose only test methods are inherited from superclasses
now run.</p></li>
<li><p>Optimization to annotation processing can cut JUnit overhead by more than half
on large test classes, especially when using Theories. [Bug 1796847]</p></li>
<li><p>A failing assumption in a constructor ignores the class</p></li>
<li><p>Correct results when comparing the string "null" with potentially
null values. [Bug 1857283]</p></li>
<li><p>Annotating a class with <code>@RunWith(JUnit4.class)</code> will always invoke the
default JUnit 4 runner in the current version of JUnit. This default changed
from <code>JUnit4ClassRunner</code> in 4.4 to <code>BlockJUnit4ClassRunner</code> in 4.5 (see below),
and may change again.</p></li>
</ul>
<h3>Extension</h3>
<ul>
<li><p><code>BlockJUnit4Runner</code> is a new implementation of the standard JUnit 4
test class functionality. In contrast to <code>JUnit4ClassRunner</code> (the old
implementation):</p>
<ul>
<li><p><code>BlockJUnit4Runner</code> has a much simpler implementation based on
Statements, allowing new operations to be inserted into the
appropriate point in the execution flow.</p></li>
<li><p><code>BlockJUnit4Runner</code> is published, and extension and reuse are
encouraged, whereas <code>JUnit4ClassRunner</code> was in an internal package,
and is now deprecated.</p></li>
</ul></li>
<li><p><code>ParentRunner</code> is a base class for runners that iterate over
a list of "children", each an object representing a test or suite to run.
<code>ParentRunner</code> provides filtering, sorting, <code>@BeforeClass</code>, <code>@AfterClass</code>,
and method validation to subclasses.</p></li>
<li><p><code>TestClass</code> wraps a class to be run, providing efficient, repeated access
to all methods with a given annotation.</p></li>
<li><p>The new <code>RunnerBuilder</code> API allows extending the behavior of
Suite-like custom runners.</p></li>
<li><p><code>AssumptionViolatedException.toString()</code> is more informative</p></li>
</ul>
<h3>Extra Runners</h3>
<ul>
<li><p><code>Parameterized.eachOne()</code> has been removed</p></li>
<li><p>New runner <code>Enclosed</code> runs all static inner classes of an outer class.</p></li>
</ul>
<h3>Theories</h3>
<ul>
<li><p><code>@Before</code> and <code>@After</code> methods are run before and after each set of attempted parameters
on a Theory, and each set of parameters is run on a new instance of the test class.</p></li>
<li><p>Exposed API's <code>ParameterSignature.getType()</code> and <code>ParameterSignature.getAnnotations()</code></p></li>
<li><p>An array of data points can be introduced by a field or method
marked with the new annotation <code>@DataPoints</code></p></li>
<li><p>The Theories custom runner has been refactored to make it faster and
easier to extend</p></li>
</ul>
<h3>Development</h3>
<ul>
<li><p>Source has been split into directories <code>src/main/java</code> and
<code>src/test/java</code>, making it easier to exclude tests from builds, and
making JUnit more maven-friendly</p></li>
<li><p>Test classes in <code>org.junit.tests</code> have been organized into
subpackages, hopefully making finding tests easier.</p></li>
<li><p><code>ResultMatchers</code> has more informative descriptions.</p></li>
<li><p><code>TestSystem</code> allows testing return codes and other system-level interactions.</p></li>
</ul>
<h2>Summary of Changes in version 4.4</h2>
<p>JUnit is designed to efficiently capture developers' intentions about
their code, and quickly check their code matches those intentions.
Over the last year, we've been talking about what things developers
would like to say about their code that have been difficult in the
past, and how we can make them easier.</p>
<h3>assertThat</h3>
<p>Two years ago, Joe Walnes built a <a href="http://joewalnes.com/2005/05/13/flexible-junit-assertions-with-assertthat/">new assertion mechanism</a> on top of what was
then <a href="http://www.jmock.org/download.html">JMock 1</a>. The method name was <code>assertThat</code>, and the syntax looked like this:</p>
<pre><code>assertThat(x, is(3));
assertThat(x, is(not(4)));
assertThat(responseString, either(containsString("color")).or(containsString("colour")));
assertThat(myList, hasItem("3"));
</code></pre>
<p>More generally:</p>
<pre><code>assertThat([value], [matcher statement]);
</code></pre>
<p>Advantages of this assertion syntax include:</p>
<ul>
<li><p>More readable and typeable: this syntax allows you to think in terms of subject, verb, object
(assert "x is 3") rathern than <code>assertEquals</code>, which uses verb, object, subject (assert "equals 3 x")</p></li>
<li><p>Combinations: any matcher statement <code>s</code> can be negated (<code>not(s)</code>), combined (<code>either(s).or(t)</code>),
mapped to a collection (<code>each(s)</code>), or used in custom combinations (<code>afterFiveSeconds(s)</code>)</p></li>
<li><p>Readable failure messages. Compare</p>
<pre><code>assertTrue(responseString.contains("color") || responseString.contains("colour"));
// ==> failure message:
// java.lang.AssertionError:
assertThat(responseString, anyOf(containsString("color"), containsString("colour")));
// ==> failure message:
// java.lang.AssertionError:
// Expected: (a string containing "color" or a string containing "colour")
// got: "Please choose a font"
</code></pre></li>
<li><p>Custom Matchers. By implementing the <code>Matcher</code> interface yourself, you can get all of the
above benefits for your own custom assertions.</p></li>
<li><p>For a more thorough description of these points, see <a href="http://joewalnes.com/2005/05/13/flexible-junit-assertions-with-assertthat/">Joe Walnes's
original post</a>.:</p></li>
</ul>
<p>We have decided to include this API directly in JUnit.
It's an extensible and readable syntax, and because it enables
new features, like <a href="#assumptions">assumptions</a> and <a href="#theories">theories</a>.</p>
<p>Some notes:</p>
<ul>
<li>The old assert methods are never, ever, going away. <br />
Developers may continue using the old <code>assertEquals</code>, <code>assertTrue</code>, and
so on.</li>
<li><p>The second parameter of an <code>assertThat</code> statement is a <code>Matcher</code>.
We include the Matchers we want as static imports, like this:</p>
<pre><code>import static org.hamcrest.CoreMatchers.is;
</code></pre>
<p>or:</p>
<pre><code>import static org.hamcrest.CoreMatchers.*;
</code></pre></li>
<li><p>Manually importing <code>Matcher</code> methods can be frustrating. [Eclipse
3.3][] includes the ability to
define
"Favorite" classes to import static methods from, which makes it easier
(Search for "Favorites" in the Preferences dialog).
We expect that support for static imports will improve in all Java IDEs in the future.</p></li>
<li><p>To allow compatibility with a wide variety of possible matchers,
we have decided to include the classes from hamcrest-core,
from the <a href="http://code.google.com/p/hamcrest/">Hamcrest</a> project. This is the first time that
third-party classes have been included in JUnit. </p></li>
<li><p>To allow developers to maintain full control of the classpath contents, the JUnit distribution also provides an unbundled junit-dep jar,
ie without hamcrest-core classes included. This is intended for situations when using other libraries that also depend on hamcrest-core, to
avoid classloading conflicts or issues. Developers using junit-dep should ensure a compatible version of hamcrest-core jar (ie 1.1+) is present in the classpath.</p></li>
<li><p>JUnit currently ships with a few matchers, defined in
<code>org.hamcrest.CoreMatchers</code> and <code>org.junit.matchers.JUnitMatchers</code>. <br />
To use many, many more, consider downloading the <a href="http://hamcrest.googlecode.com/files/hamcrest-all-1.1.jar">full hamcrest package</a>.</p></li>
<li><p>JUnit contains special support for comparing string and array
values, giving specific information on how they differ. This is not
yet available using the <code>assertThat</code> syntax, but we hope to bring
the two assert methods into closer alignment in future releases.</p></li>
</ul>
<h3>assumeThat</h3>
<p><a name="assumptions" />
Ideally, the developer writing a test has control of all of the forces that might cause a test to fail.
If this isn't immediately possible, making dependencies explicit can often improve a design. <br />
For example, if a test fails when run in a different locale than the developer intended,
it can be fixed by explicitly passing a locale to the domain code.</p>
<p>However, sometimes this is not desirable or possible. <br />
It's good to be able to run a test against the code as it is currently written,
implicit assumptions and all, or to write a test that exposes a known bug.
For these situations, JUnit now includes the ability to express "assumptions":</p>
<pre><code>import static org.junit.Assume.*
@Test public void filenameIncludesUsername() {
assumeThat(File.separatorChar, is('/'));
assertThat(new User("optimus").configFileName(), is("configfiles/optimus.cfg"));
}
@Test public void correctBehaviorWhenFilenameIsNull() {
assumeTrue(bugFixed("13356")); // bugFixed is not included in JUnit
assertThat(parse(null), is(new NullDocument()));
}
</code></pre>
<p>With this beta release, a failed assumption will lead to the test being marked as passing,
regardless of what the code below the assumption may assert.
In the future, this may change, and a failed assumption may lead to the test being ignored:
however, third-party runners do not currently allow this option.</p>
<p>We have included <code>assumeTrue</code> for convenience, but thanks to the
inclusion of Hamcrest, we do not need to create <code>assumeEquals</code>,
<code>assumeSame</code>, and other analogues to the <code>assert*</code> methods. All of
those functionalities are subsumed in assumeThat, with the appropriate
matcher.</p>
<p>A failing assumption in a <code>@Before</code> or <code>@BeforeClass</code> method will have the same effect
as a failing assumption in each <code>@Test</code> method of the class.</p>
<h3>Theories</h3>
<p><a name="theories" />
More flexible and expressive assertions, combined with the ability to
state assumptions clearly, lead to a new kind of statement of intent,
which we call a "Theory". A test captures the intended behavior in
one particular scenario. A theory allows a developer to be
as precise as desired about the behavior of the code in possibly
infinite numbers of possible scenarios. For example:</p>
<pre><code>@RunWith(Theories.class)
public class UserTest {
@DataPoint public static String GOOD_USERNAME = "optimus";
@DataPoint public static String USERNAME_WITH_SLASH = "optimus/prime";
@Theory public void filenameIncludesUsername(String username) {
assumeThat(username, not(containsString("/")));
assertThat(new User(username).configFileName(), containsString(username));
}
}
</code></pre>
<p>This makes it clear that the user's filename should be included in the
config file name, only if it doesn't contain a slash. Another test
or theory might define what happens when a username does contain a slash.</p>
<p><code>UserTest</code> will attempt to run <code>filenameIncludesUsername</code> on
every compatible <code>DataPoint</code> defined in the class. If any of the
assumptions fail, the data point is silently ignored. If all of the
assumptions pass, but an assertion fails, the test fails.</p>
<p>The support for Theories has been absorbed from the <a href="http://popper.tigris.org">Popper</a>
project, and <a href="http://popper.tigris.org/tutorial.html">more complete documentation</a> can be found
there.</p>
<p>Defining general statements in this way can jog the developer's memory
about other potential data points and tests, also allows <a href="http://www.junitfactory.org">automated
tools</a> to <a href="http://shareandenjoy.saff.net/2007/04/popper-and-junitfactory.html">search</a> for new, unexpected data
points that expose bugs.</p>
<h3>Other changes</h3>
<p>This release contains other bug fixes and new features. Among them:</p>
<ul>
<li><p>Annotated descriptions</p>
<p>Runner UIs, Filters, and Sorters operate on Descriptions of test
methods and test classes. These Descriptions now include the
annotations on the original Java source element, allowing for richer
display of test results, and easier development of annotation-based
filters.</p></li>
<li><p>Bug fix (1715326): assertEquals now compares all Numbers using their
native implementation of <code>equals</code>. This assertion, which passed in
4.3, will now fail:</p>
<p>assertEquals(new Integer(1), new Long(1));</p>
<p>Non-integer Numbers (Floats, Doubles, BigDecimals, etc),
which were compared incorrectly in 4.3, are now fixed.</p></li>
<li><p><code>assertEquals(long, long)</code> and <code>assertEquals(double, double)</code> have
been re-introduced to the <code>Assert</code> class, to take advantage of
Java's native widening conversions. Therefore, this still passes:</p>
<p>assertEquals(1, 1L);</p></li>
<li><p>The default runner for JUnit 4 test classes has been refactored.
The old version was named <code>TestClassRunner</code>, and the new is named
<code>JUnit4ClassRunner</code>. Likewise, <code>OldTestClassRunner</code> is now
<code>JUnit3ClassRunner</code>. The new design allows variations in running
individual test classes to be expressed with fewer custom classes.
For a good example, see the source to
<code>org.junit.experimental.theories.Theories</code>.</p></li>
<li><p>The rules for determining which runner is applied by default to a
test class have been simplified:</p>
<ol>
<li><p>If the class has a <code>@RunWith</code> annotation, the annotated runner
class is used.</p></li>
<li><p>If the class can be run with the JUnit 3 test runner (it
subclasses <code>TestCase</code>, or contains a <code>public static Test suite()</code>
method), JUnit38ClassRunner is used.</p></li>
<li><p>Otherwise, JUnit4ClassRunner is used.</p></li>
</ol>
<p>This default guess can always be overridden by an explicit
<code>@RunWith(JUnit4ClassRunner.class)</code> or
<code>@RunWith(JUnit38ClassRunner.class)</code> annotation.</p>
<p>The old class names <code>TestClassRunner</code> and <code>OldTestClassRunner</code>
remain as deprecated.</p></li>
<li><p>Bug fix (1739095): Filters and Sorters work correctly on test
classes that contain a <code>suite</code> method like:</p>
<p>public static junit.framework.Test suite() {
return new JUnit4TestAdapter(MyTest.class);
}</p></li>
<li><p>Bug fix (1745048): @After methods are now correctly called
after a test method times out.</p></li>
</ul>
================================================
FILE: doc/ReleaseNotes4.5.md
================================================
## Summary of Changes in version 4.5 ##
### Installation ###
- We are releasing `junit-4.5.jar`, which contains all the classes
necessary to run JUnit, and `junit-dep-4.5.jar`, which leaves out
hamcrest classes, for developers who already use hamcrest outside of
JUnit.
### Basic JUnit operation ###
- JUnitCore now more often exits with the correct exit code (0 for
success, 1 for failure)
- Badly formed test classes (exceptions in constructors, classes
without tests, multiple constructors, Suite without @SuiteClasses)
produce more helpful error messages
- Test classes whose only test methods are inherited from superclasses
now run.
- Optimization to annotation processing can cut JUnit overhead by more than half
on large test classes, especially when using Theories. [Bug 1796847]
- A failing assumption in a constructor ignores the class
- Correct results when comparing the string "null" with potentially
null values. [Bug 1857283]
- Annotating a class with `@RunWith(JUnit4.class)` will always invoke the
default JUnit 4 runner in the current version of JUnit. This default changed
from `JUnit4ClassRunner` in 4.4 to `BlockJUnit4ClassRunner` in 4.5 (see below),
and may change again.
### Extension ###
- `BlockJUnit4Runner` is a new implementation of the standard JUnit 4
test class functionality. In contrast to `JUnit4ClassRunner` (the old
implementation):
- `BlockJUnit4Runner` has a much simpler implementation based on
Statements, allowing new operations to be inserted into the
appropriate point in the execution flow.
- `BlockJUnit4Runner` is published, and extension and reuse are
encouraged, whereas `JUnit4ClassRunner` was in an internal package,
and is now deprecated.
- `ParentRunner` is a base class for runners that iterate over
a list of "children", each an object representing a test or suite to run.
`ParentRunner` provides filtering, sorting, `@BeforeClass`, `@AfterClass`,
and method validation to subclasses.
- `TestClass` wraps a class to be run, providing efficient, repeated access
to all methods with a given annotation.
- The new `RunnerBuilder` API allows extending the behavior of
Suite-like custom runners.
- `AssumptionViolatedException.toString()` is more informative
### Extra Runners ###
- `Parameterized.eachOne()` has been removed
- New runner `Enclosed` runs all static inner classes of an outer class.
### Theories ###
- `@Before` and `@After` methods are run before and after each set of attempted parameters
on a Theory, and each set of parameters is run on a new instance of the test class.
- Exposed API's `ParameterSignature.getType()` and `ParameterSignature.getAnnotations()`
- An array of data points can be introduced by a field or method
marked with the new annotation `@DataPoints`
- The Theories custom runner has been refactored to make it faster and
easier to extend
### Development ###
- Source has been split into directories `src/main/java` and
`src/test/java`, making it easier to exclude tests from builds, and
making JUnit more maven-friendly
- Test classes in `org.junit.tests` have been organized into
subpackages, hopefully making finding tests easier.
- `ResultMatchers` has more informative descriptions.
- `TestSystem` allows testing return codes and other system-level interactions.
### Incompatible changes ###
- Removed Request.classes(String, Class<?>...) factory method
================================================
FILE: doc/ReleaseNotes4.5.txt
================================================
Please see ReleaseNotes4.5.md
================================================
FILE: doc/ReleaseNotes4.6.html
================================================
<h2>Summary of Changes in version 4.6</h2>
<h3>Max</h3>
<p>JUnit now includes a new experimental Core, <code>MaxCore</code>. <code>MaxCore</code>
remembers the results of previous test runs in order to run new
tests out of order. <code>MaxCore</code> prefers new tests to old tests, fast
tests to slow tests, and recently failing tests to tests that last
failed long ago. There's currently not a standard UI for running
<code>MaxCore</code> included in JUnit, but there is a UI included in the JUnit
Max Eclipse plug-in at:</p>
<p>http://www.junitmax.com/junitmax/subscribe.html</p>
<p>Example:</p>
<pre><code>public static class TwoUnEqualTests {
@Test
public void slow() throws InterruptedException {
Thread.sleep(100);
fail();
}
@Test
public void fast() {
fail();
}
}
@Test
public void rememberOldRuns() {
File maxFile = new File("history.max");
MaxCore firstMax = MaxCore.storedLocally(maxFile);
firstMax.run(TwoUnEqualTests.class);
MaxCore useHistory= MaxCore.storedLocally(maxFile);
List<Failure> failures= useHistory.run(TwoUnEqualTests.class)
.getFailures();
assertEquals("fast", failures.get(0).getDescription().getMethodName());
assertEquals("slow", failures.get(1).getDescription().getMethodName());
}
</code></pre>
<h3>Test scheduling strategies</h3>
<p><code>JUnitCore</code> now includes an experimental method that allows you to
specify a model of the <code>Computer</code> that runs your tests. Currently,
the only built-in Computers are the default, serial runner, and two
runners provided in the <code>ParallelRunner</code> class:
<code>ParallelRunner.classes()</code>, which runs classes in parallel, and
<code>ParallelRunner.methods()</code>, which runs classes and methods in parallel.</p>
<p>This feature is currently less stable than MaxCore, and may be
merged with MaxCore in some way in the future.</p>
<p>Example:</p>
<pre><code>public static class Example {
@Test public void one() throws InterruptedException {
Thread.sleep(1000);
}
@Test public void two() throws InterruptedException {
Thread.sleep(1000);
}
}
@Test public void testsRunInParallel() {
long start= System.currentTimeMillis();
Result result= JUnitCore.runClasses(ParallelComputer.methods(),
Example.class);
assertTrue(result.wasSuccessful());
long end= System.currentTimeMillis();
assertThat(end - start, betweenInclusive(1000, 1500));
}
</code></pre>
<h3>Comparing double arrays</h3>
<p>Arrays of doubles can be compared, using a delta allowance for equality:</p>
<pre><code>@Test
public void doubleArraysAreEqual() {
assertArrayEquals(new double[] {1.0, 2.0}, new double[] {1.0, 2.0}, 0.01);
}
</code></pre>
<h3><code>Filter.matchDescription</code> API</h3>
<p>Since 4.0, it has been possible to run a single method using the <code>Request.method</code>
API. In 4.6, the filter that implements this is exposed as <code>Filter.matchDescription</code>.</p>
<h3>Documentation</h3>
<ul>
<li><p>A couple classes and packages that once had empty javadoc have been
doc'ed.</p></li>
<li><p>Added how to run JUnit from the command line to the cookbook.</p></li>
<li><p>junit-4.x.zip now contains build.xml</p></li>
</ul>
<h3>Bug fixes</h3>
<ul>
<li>Fixed overly permissive @DataPoint processing (2191102)</li>
<li>Fixed bug in test counting after an ignored method (2106324)</li>
</ul>
================================================
FILE: doc/ReleaseNotes4.6.md
================================================
## Summary of Changes in version 4.6 ##
### Max ###
JUnit now includes a new experimental Core, `MaxCore`. `MaxCore`
remembers the results of previous test runs in order to run new
tests out of order. `MaxCore` prefers new tests to old tests, fast
tests to slow tests, and recently failing tests to tests that last
failed long ago. There's currently not a standard UI for running
`MaxCore` included in JUnit, but there is a UI included in the JUnit
Max Eclipse plug-in at:
http://www.junitmax.com/junitmax/subscribe.html
Example:
```java
public static class TwoUnEqualTests {
@Test
public void slow() throws InterruptedException {
Thread.sleep(100);
fail();
}
@Test
public void fast() {
fail();
}
}
@Test
public void rememberOldRuns() {
File maxFile = new File("history.max");
MaxCore firstMax = MaxCore.storedLocally(maxFile);
firstMax.run(TwoUnEqualTests.class);
MaxCore useHistory= MaxCore.storedLocally(maxFile);
List<Failure> failures= useHistory.run(TwoUnEqualTests.class)
.getFailures();
assertEquals("fast", failures.get(0).getDescription().getMethodName());
assertEquals("slow", failures.get(1).getDescription().getMethodName());
}
```
### Test scheduling strategies ###
`JUnitCore` now includes an experimental method that allows you to
specify a model of the `Computer` that runs your tests. Currently,
the only built-in Computers are the default, serial runner, and two
runners provided in the `ParallelRunner` class:
`ParallelRunner.classes()`, which runs classes in parallel, and
`ParallelRunner.methods()`, which runs classes and methods in parallel.
This feature is currently less stable than MaxCore, and may be
merged with MaxCore in some way in the future.
Example:
```java
public static class Example {
@Test public void one() throws InterruptedException {
Thread.sleep(1000);
}
@Test public void two() throws InterruptedException {
Thread.sleep(1000);
}
}
@Test public void testsRunInParallel() {
long start= System.currentTimeMillis();
Result result= JUnitCore.runClasses(ParallelComputer.methods(),
Example.class);
assertTrue(result.wasSuccessful());
long end= System.currentTimeMillis();
assertThat(end - start, betweenInclusive(1000, 1500));
}
```
### Comparing double arrays ###
Arrays of doubles can be compared, using a delta allowance for equality:
```java
@Test
public void doubleArraysAreEqual() {
assertArrayEquals(new double[] {1.0, 2.0}, new double[] {1.0, 2.0}, 0.01);
}
```
### `Filter.matchDescription` API ###
Since 4.0, it has been possible to run a single method using the `Request.method`
API. In 4.6, the filter that implements this is exposed as `Filter.matchDescription`.
### Documentation ###
- A couple classes and packages that once had empty javadoc have been
doc'ed.
- Added how to run JUnit from the command line to the cookbook.
- junit-4.x.zip now contains build.xml
### Bug fixes ###
- Fixed overly permissive @DataPoint processing (2191102)
- Fixed bug in test counting after an ignored method (2106324)
================================================
FILE: doc/ReleaseNotes4.6.txt
================================================
Please see ReleaseNotes4.6.md
================================================
FILE: doc/ReleaseNotes4.7.html
================================================
<h2>Summary of Changes in version 4.7</h2>
<h3>Rules</h3>
<ul>
<li><p>Rules allow very flexible addition or redefinition of the behavior
of each test method in a test class. Testers can reuse or extend one of the
provided Rules below, or write their own.</p>
<p>For more on this feature, see http://www.threeriversinstitute.org/blog/?p=155</p></li>
<li><p>The TemporaryFolder Rule allows creation of files and folders
that are guaranteed to be deleted when the test method finishes
(whether it passes or fails):</p>
<p>public static class HasTempFolder {
@Rule
public TemporaryFolder folder= new TemporaryFolder();</p>
<pre><code>@Test
public void testUsingTempFolder() throws IOException {
File createdFile= folder.newFile("myfile.txt");
File createdFolder= folder.newFolder("subfolder");
// ...
}
</code></pre>
<p>}</p></li>
<li><p>ExternalResource is a base class for Rules (like TemporaryFolder)
that set up an external resource before a test (a file, socket, server,
database connection, etc.), and guarantee to t
gitextract_yvgvpu6o/ ├── .gitattributes ├── .github/ │ ├── ISSUE_TEMPLATE/ │ │ ├── bug_report.md │ │ └── config.yml │ ├── PULL_REQUEST_TEMPLATE.md │ └── workflows/ │ ├── main.yml │ └── settings.xml ├── .gitignore ├── .mvn/ │ └── wrapper/ │ └── maven-wrapper.properties ├── .settings/ │ ├── org.eclipse.jdt.core.prefs │ └── org.eclipse.jdt.ui.prefs ├── BUILDING ├── CODING_STYLE.txt ├── CONTRIBUTING.md ├── KEYS ├── LEGACY_CODING_STYLE.txt ├── LICENSE-junit.txt ├── NOTICE.txt ├── README.md ├── SECURITY.md ├── acknowledgements.txt ├── doc/ │ ├── ReleaseNotes4.10.html │ ├── ReleaseNotes4.10.md │ ├── ReleaseNotes4.10.txt │ ├── ReleaseNotes4.11.html │ ├── ReleaseNotes4.11.md │ ├── ReleaseNotes4.11.txt │ ├── ReleaseNotes4.12.md │ ├── ReleaseNotes4.13.1.md │ ├── ReleaseNotes4.13.2.md │ ├── ReleaseNotes4.13.md │ ├── ReleaseNotes4.4.html │ ├── ReleaseNotes4.4.md │ ├── ReleaseNotes4.4.txt │ ├── ReleaseNotes4.5.html │ ├── ReleaseNotes4.5.md │ ├── ReleaseNotes4.5.txt │ ├── ReleaseNotes4.6.html │ ├── ReleaseNotes4.6.md │ ├── ReleaseNotes4.6.txt │ ├── ReleaseNotes4.7.html │ ├── ReleaseNotes4.7.md │ ├── ReleaseNotes4.7.txt │ ├── ReleaseNotes4.8.1.html │ ├── ReleaseNotes4.8.1.md │ ├── ReleaseNotes4.8.1.txt │ ├── ReleaseNotes4.8.2.html │ ├── ReleaseNotes4.8.2.md │ ├── ReleaseNotes4.8.2.txt │ ├── ReleaseNotes4.8.html │ ├── ReleaseNotes4.8.md │ ├── ReleaseNotes4.8.txt │ ├── ReleaseNotes4.9.1.md │ ├── ReleaseNotes4.9.1.txt │ ├── ReleaseNotes4.9.html │ ├── ReleaseNotes4.9.md │ ├── ReleaseNotes4.9.txt │ ├── building-junit.txt │ ├── cookstour/ │ │ └── cookstour.htm │ ├── markdown.sh │ └── testinfected/ │ └── testing.htm ├── epl-v10.html ├── mvnw ├── mvnw.cmd ├── pom.xml ├── src/ │ ├── main/ │ │ ├── java/ │ │ │ ├── junit/ │ │ │ │ ├── extensions/ │ │ │ │ │ ├── ActiveTestSuite.java │ │ │ │ │ ├── RepeatedTest.java │ │ │ │ │ ├── TestDecorator.java │ │ │ │ │ ├── TestSetup.java │ │ │ │ │ └── package-info.java │ │ │ │ ├── framework/ │ │ │ │ │ ├── Assert.java │ │ │ │ │ ├── AssertionFailedError.java │ │ │ │ │ ├── ComparisonCompactor.java │ │ │ │ │ ├── ComparisonFailure.java │ │ │ │ │ ├── JUnit4TestAdapter.java │ │ │ │ │ ├── JUnit4TestAdapterCache.java │ │ │ │ │ ├── JUnit4TestCaseFacade.java │ │ │ │ │ ├── Protectable.java │ │ │ │ │ ├── Test.java │ │ │ │ │ ├── TestCase.java │ │ │ │ │ ├── TestFailure.java │ │ │ │ │ ├── TestListener.java │ │ │ │ │ ├── TestResult.java │ │ │ │ │ ├── TestSuite.java │ │ │ │ │ └── package-info.java │ │ │ │ ├── runner/ │ │ │ │ │ ├── BaseTestRunner.java │ │ │ │ │ ├── TestRunListener.java │ │ │ │ │ ├── Version.java │ │ │ │ │ ├── Version.java.template │ │ │ │ │ └── package-info.java │ │ │ │ └── textui/ │ │ │ │ ├── ResultPrinter.java │ │ │ │ ├── TestRunner.java │ │ │ │ └── package-info.java │ │ │ └── org/ │ │ │ └── junit/ │ │ │ ├── After.java │ │ │ ├── AfterClass.java │ │ │ ├── Assert.java │ │ │ ├── Assume.java │ │ │ ├── AssumptionViolatedException.java │ │ │ ├── Before.java │ │ │ ├── BeforeClass.java │ │ │ ├── ClassRule.java │ │ │ ├── ComparisonFailure.java │ │ │ ├── FixMethodOrder.java │ │ │ ├── Ignore.java │ │ │ ├── Rule.java │ │ │ ├── Test.java │ │ │ ├── TestCouldNotBeSkippedException.java │ │ │ ├── experimental/ │ │ │ │ ├── ParallelComputer.java │ │ │ │ ├── categories/ │ │ │ │ │ ├── Categories.java │ │ │ │ │ ├── Category.java │ │ │ │ │ ├── CategoryFilterFactory.java │ │ │ │ │ ├── CategoryValidator.java │ │ │ │ │ ├── ExcludeCategories.java │ │ │ │ │ └── IncludeCategories.java │ │ │ │ ├── max/ │ │ │ │ │ ├── CouldNotReadCoreException.java │ │ │ │ │ ├── MaxCore.java │ │ │ │ │ └── MaxHistory.java │ │ │ │ ├── results/ │ │ │ │ │ ├── FailureList.java │ │ │ │ │ ├── PrintableResult.java │ │ │ │ │ └── ResultMatchers.java │ │ │ │ ├── runners/ │ │ │ │ │ └── Enclosed.java │ │ │ │ └── theories/ │ │ │ │ ├── DataPoint.java │ │ │ │ ├── DataPoints.java │ │ │ │ ├── FromDataPoints.java │ │ │ │ ├── ParameterSignature.java │ │ │ │ ├── ParameterSupplier.java │ │ │ │ ├── ParametersSuppliedBy.java │ │ │ │ ├── PotentialAssignment.java │ │ │ │ ├── Theories.java │ │ │ │ ├── Theory.java │ │ │ │ ├── internal/ │ │ │ │ │ ├── AllMembersSupplier.java │ │ │ │ │ ├── Assignments.java │ │ │ │ │ ├── BooleanSupplier.java │ │ │ │ │ ├── EnumSupplier.java │ │ │ │ │ ├── ParameterizedAssertionError.java │ │ │ │ │ └── SpecificDataPointsSupplier.java │ │ │ │ └── suppliers/ │ │ │ │ ├── TestedOn.java │ │ │ │ └── TestedOnSupplier.java │ │ │ ├── function/ │ │ │ │ └── ThrowingRunnable.java │ │ │ ├── internal/ │ │ │ │ ├── ArrayComparisonFailure.java │ │ │ │ ├── AssumptionViolatedException.java │ │ │ │ ├── Checks.java │ │ │ │ ├── Classes.java │ │ │ │ ├── ComparisonCriteria.java │ │ │ │ ├── ExactComparisonCriteria.java │ │ │ │ ├── InexactComparisonCriteria.java │ │ │ │ ├── JUnitSystem.java │ │ │ │ ├── MethodSorter.java │ │ │ │ ├── RealSystem.java │ │ │ │ ├── SerializableMatcherDescription.java │ │ │ │ ├── SerializableValueDescription.java │ │ │ │ ├── TextListener.java │ │ │ │ ├── Throwables.java │ │ │ │ ├── builders/ │ │ │ │ │ ├── AllDefaultPossibilitiesBuilder.java │ │ │ │ │ ├── AnnotatedBuilder.java │ │ │ │ │ ├── IgnoredBuilder.java │ │ │ │ │ ├── IgnoredClassRunner.java │ │ │ │ │ ├── JUnit3Builder.java │ │ │ │ │ ├── JUnit4Builder.java │ │ │ │ │ ├── NullBuilder.java │ │ │ │ │ └── SuiteMethodBuilder.java │ │ │ │ ├── management/ │ │ │ │ │ ├── FakeRuntimeMXBean.java │ │ │ │ │ ├── FakeThreadMXBean.java │ │ │ │ │ ├── ManagementFactory.java │ │ │ │ │ ├── ReflectiveRuntimeMXBean.java │ │ │ │ │ ├── ReflectiveThreadMXBean.java │ │ │ │ │ ├── RuntimeMXBean.java │ │ │ │ │ └── ThreadMXBean.java │ │ │ │ ├── matchers/ │ │ │ │ │ ├── StacktracePrintingMatcher.java │ │ │ │ │ ├── ThrowableCauseMatcher.java │ │ │ │ │ ├── ThrowableMessageMatcher.java │ │ │ │ │ └── TypeSafeMatcher.java │ │ │ │ ├── requests/ │ │ │ │ │ ├── ClassRequest.java │ │ │ │ │ ├── FilterRequest.java │ │ │ │ │ ├── MemoizingRequest.java │ │ │ │ │ ├── OrderingRequest.java │ │ │ │ │ ├── SortingRequest.java │ │ │ │ │ └── package-info.java │ │ │ │ └── runners/ │ │ │ │ ├── ClassRoadie.java │ │ │ │ ├── ErrorReportingRunner.java │ │ │ │ ├── FailedBefore.java │ │ │ │ ├── InitializationError.java │ │ │ │ ├── JUnit38ClassRunner.java │ │ │ │ ├── JUnit4ClassRunner.java │ │ │ │ ├── MethodRoadie.java │ │ │ │ ├── MethodValidator.java │ │ │ │ ├── SuiteMethod.java │ │ │ │ ├── TestClass.java │ │ │ │ ├── TestMethod.java │ │ │ │ ├── model/ │ │ │ │ │ ├── EachTestNotifier.java │ │ │ │ │ ├── MultipleFailureException.java │ │ │ │ │ └── ReflectiveCallable.java │ │ │ │ ├── package-info.java │ │ │ │ ├── rules/ │ │ │ │ │ ├── RuleMemberValidator.java │ │ │ │ │ └── ValidationError.java │ │ │ │ └── statements/ │ │ │ │ ├── ExpectException.java │ │ │ │ ├── Fail.java │ │ │ │ ├── FailOnTimeout.java │ │ │ │ ├── InvokeMethod.java │ │ │ │ ├── RunAfters.java │ │ │ │ └── RunBefores.java │ │ │ ├── matchers/ │ │ │ │ ├── JUnitMatchers.java │ │ │ │ └── package-info.java │ │ │ ├── package-info.java │ │ │ ├── rules/ │ │ │ │ ├── DisableOnDebug.java │ │ │ │ ├── ErrorCollector.java │ │ │ │ ├── ExpectedException.java │ │ │ │ ├── ExpectedExceptionMatcherBuilder.java │ │ │ │ ├── ExternalResource.java │ │ │ │ ├── MethodRule.java │ │ │ │ ├── RuleChain.java │ │ │ │ ├── RunRules.java │ │ │ │ ├── Stopwatch.java │ │ │ │ ├── TemporaryFolder.java │ │ │ │ ├── TestName.java │ │ │ │ ├── TestRule.java │ │ │ │ ├── TestWatcher.java │ │ │ │ ├── TestWatchman.java │ │ │ │ ├── Timeout.java │ │ │ │ └── Verifier.java │ │ │ ├── runner/ │ │ │ │ ├── Computer.java │ │ │ │ ├── Describable.java │ │ │ │ ├── Description.java │ │ │ │ ├── FilterFactories.java │ │ │ │ ├── FilterFactory.java │ │ │ │ ├── FilterFactoryParams.java │ │ │ │ ├── JUnitCommandLineParseResult.java │ │ │ │ ├── JUnitCore.java │ │ │ │ ├── OrderWith.java │ │ │ │ ├── OrderWithValidator.java │ │ │ │ ├── Request.java │ │ │ │ ├── Result.java │ │ │ │ ├── RunWith.java │ │ │ │ ├── Runner.java │ │ │ │ ├── manipulation/ │ │ │ │ │ ├── Alphanumeric.java │ │ │ │ │ ├── Filter.java │ │ │ │ │ ├── Filterable.java │ │ │ │ │ ├── InvalidOrderingException.java │ │ │ │ │ ├── NoTestsRemainException.java │ │ │ │ │ ├── Orderable.java │ │ │ │ │ ├── Orderer.java │ │ │ │ │ ├── Ordering.java │ │ │ │ │ ├── Sortable.java │ │ │ │ │ ├── Sorter.java │ │ │ │ │ └── package-info.java │ │ │ │ ├── notification/ │ │ │ │ │ ├── Failure.java │ │ │ │ │ ├── RunListener.java │ │ │ │ │ ├── RunNotifier.java │ │ │ │ │ ├── StoppedByUserException.java │ │ │ │ │ ├── SynchronizedRunListener.java │ │ │ │ │ └── package-info.java │ │ │ │ └── package-info.java │ │ │ ├── runners/ │ │ │ │ ├── AllTests.java │ │ │ │ ├── BlockJUnit4ClassRunner.java │ │ │ │ ├── JUnit4.java │ │ │ │ ├── MethodSorters.java │ │ │ │ ├── Parameterized.java │ │ │ │ ├── ParentRunner.java │ │ │ │ ├── RuleContainer.java │ │ │ │ ├── Suite.java │ │ │ │ ├── model/ │ │ │ │ │ ├── Annotatable.java │ │ │ │ │ ├── FrameworkField.java │ │ │ │ │ ├── FrameworkMember.java │ │ │ │ │ ├── FrameworkMethod.java │ │ │ │ │ ├── InitializationError.java │ │ │ │ │ ├── InvalidTestClassError.java │ │ │ │ │ ├── MemberValueConsumer.java │ │ │ │ │ ├── MultipleFailureException.java │ │ │ │ │ ├── NoGenericTypeParametersValidator.java │ │ │ │ │ ├── RunnerBuilder.java │ │ │ │ │ ├── RunnerScheduler.java │ │ │ │ │ ├── Statement.java │ │ │ │ │ ├── TestClass.java │ │ │ │ │ └── TestTimedOutException.java │ │ │ │ ├── package-info.java │ │ │ │ └── parameterized/ │ │ │ │ ├── BlockJUnit4ClassRunnerWithParameters.java │ │ │ │ ├── BlockJUnit4ClassRunnerWithParametersFactory.java │ │ │ │ ├── ParametersRunnerFactory.java │ │ │ │ └── TestWithParameters.java │ │ │ └── validator/ │ │ │ ├── AnnotationValidator.java │ │ │ ├── AnnotationValidatorFactory.java │ │ │ ├── AnnotationsValidator.java │ │ │ ├── PublicClassValidator.java │ │ │ ├── TestClassValidator.java │ │ │ └── ValidateWith.java │ │ └── javadoc/ │ │ └── stylesheet.css │ ├── site/ │ │ ├── fml/ │ │ │ └── faq.fml │ │ ├── markdown/ │ │ │ └── cookbook.md │ │ ├── resources/ │ │ │ ├── css/ │ │ │ │ ├── carousel.css │ │ │ │ ├── junit-lambda.css │ │ │ │ └── plain-links.css │ │ │ └── scripts/ │ │ │ └── index.js │ │ ├── site.xml │ │ ├── xdoc/ │ │ │ └── index.xml │ │ └── xhtml/ │ │ ├── junit-lambda-campaign.xhtml │ │ ├── junit-lambda-contributors.xhtml │ │ ├── junit-lambda-spending.xhtml │ │ ├── junit-lambda.xhtml │ │ └── junit5.xhtml │ └── test/ │ ├── java/ │ │ ├── junit/ │ │ │ ├── samples/ │ │ │ │ ├── AllTests.java │ │ │ │ ├── ListTest.java │ │ │ │ ├── SimpleTest.java │ │ │ │ ├── money/ │ │ │ │ │ ├── IMoney.java │ │ │ │ │ ├── Money.java │ │ │ │ │ ├── MoneyBag.java │ │ │ │ │ ├── MoneyTest.java │ │ │ │ │ └── package-info.java │ │ │ │ └── package-info.java │ │ │ └── tests/ │ │ │ ├── AllTests.java │ │ │ ├── SampleJUnit3Tests.java │ │ │ ├── WasRun.java │ │ │ ├── extensions/ │ │ │ │ ├── ActiveTestTest.java │ │ │ │ ├── AllTests.java │ │ │ │ ├── ExtensionTest.java │ │ │ │ ├── RepeatedTestTest.java │ │ │ │ └── package-info.java │ │ │ ├── framework/ │ │ │ │ ├── AllTests.java │ │ │ │ ├── AssertTest.java │ │ │ │ ├── AssertionFailedErrorTest.java │ │ │ │ ├── ComparisonCompactorTest.java │ │ │ │ ├── ComparisonFailureTest.java │ │ │ │ ├── DoublePrecisionAssertTest.java │ │ │ │ ├── Failure.java │ │ │ │ ├── FloatAssertTest.java │ │ │ │ ├── InheritedTestCase.java │ │ │ │ ├── NoArgTestCaseTest.java │ │ │ │ ├── NoTestCaseClass.java │ │ │ │ ├── NoTestCases.java │ │ │ │ ├── NotPublicTestCase.java │ │ │ │ ├── NotVoidTestCase.java │ │ │ │ ├── OneTestCase.java │ │ │ │ ├── OverrideTestCase.java │ │ │ │ ├── Success.java │ │ │ │ ├── SuiteTest.java │ │ │ │ ├── TestCaseTest.java │ │ │ │ ├── TestImplementorTest.java │ │ │ │ ├── TestListenerTest.java │ │ │ │ ├── ThreeTestCases.java │ │ │ │ └── package-info.java │ │ │ ├── package-info.java │ │ │ └── runner/ │ │ │ ├── AllTests.java │ │ │ ├── BaseTestRunnerTest.java │ │ │ ├── ResultTest.java │ │ │ ├── StackFilterTest.java │ │ │ ├── TextFeedbackTest.java │ │ │ ├── TextRunnerSingleMethodTest.java │ │ │ ├── TextRunnerTest.java │ │ │ └── package-info.java │ │ └── org/ │ │ └── junit/ │ │ ├── AssumptionViolatedExceptionTest.java │ │ ├── experimental/ │ │ │ └── categories/ │ │ │ ├── AllCategoriesTests.java │ │ │ ├── CategoriesAndParameterizedTest.java │ │ │ ├── CategoryFilterFactoryTest.java │ │ │ ├── CategoryTest.java │ │ │ ├── CategoryValidatorTest.java │ │ │ ├── JavadocTest.java │ │ │ └── MultiCategoryTest.java │ │ ├── internal/ │ │ │ ├── AllInternalTests.java │ │ │ ├── ArrayComparisonFailureTest.java │ │ │ ├── ChecksTest.java │ │ │ ├── MethodSorterTest.java │ │ │ ├── StackTracesTest.java │ │ │ ├── builders/ │ │ │ │ └── AnnotatedBuilderTest.java │ │ │ ├── matchers/ │ │ │ │ ├── StacktracePrintingMatcherTest.java │ │ │ │ └── ThrowableCauseMatcherTest.java │ │ │ └── runners/ │ │ │ ├── ErrorReportingRunnerTest.java │ │ │ └── statements/ │ │ │ ├── ExpectExceptionTest.java │ │ │ └── FailOnTimeoutTest.java │ │ ├── rules/ │ │ │ ├── AllRulesTests.java │ │ │ ├── BlockJUnit4ClassRunnerOverrideTest.java │ │ │ ├── ClassRulesTest.java │ │ │ ├── DisableOnDebugTest.java │ │ │ ├── ErrorCollectorTest.java │ │ │ ├── EventCollector.java │ │ │ ├── ExpectedExceptionTest.java │ │ │ ├── ExternalResourceRuleTest.java │ │ │ ├── LoggingMethodRule.java │ │ │ ├── LoggingStatement.java │ │ │ ├── LoggingTestRule.java │ │ │ ├── LoggingTestWatcher.java │ │ │ ├── MethodRulesTest.java │ │ │ ├── NameRulesTest.java │ │ │ ├── RuleChainTest.java │ │ │ ├── RuleMemberValidatorTest.java │ │ │ ├── StopwatchTest.java │ │ │ ├── TempFolderRuleTest.java │ │ │ ├── TemporaryFolderRuleAssuredDeletionTest.java │ │ │ ├── TemporaryFolderUsageTest.java │ │ │ ├── TestRuleTest.java │ │ │ ├── TestWatcherTest.java │ │ │ ├── TestWatchmanTest.java │ │ │ ├── TimeoutRuleTest.java │ │ │ └── VerifierRuleTest.java │ │ ├── runner/ │ │ │ ├── AllRunnerTests.java │ │ │ ├── FilterFactoriesTest.java │ │ │ ├── FilterOptionIntegrationTest.java │ │ │ ├── JUnitCommandLineParseResultTest.java │ │ │ ├── JUnitCoreTest.java │ │ │ ├── MainRunner.java │ │ │ ├── OrderWithValidatorTest.java │ │ │ ├── RequestTest.java │ │ │ ├── RunnerSpy.java │ │ │ └── notification/ │ │ │ ├── AllNotificationTests.java │ │ │ ├── ConcurrentRunNotifierTest.java │ │ │ ├── RunNotifierTest.java │ │ │ └── SynchronizedRunListenerTest.java │ │ ├── runners/ │ │ │ ├── AllRunnersTests.java │ │ │ ├── CustomBlockJUnit4ClassRunnerTest.java │ │ │ ├── RuleContainerTest.java │ │ │ ├── model/ │ │ │ │ ├── AllModelTests.java │ │ │ │ ├── FrameworkFieldTest.java │ │ │ │ ├── FrameworkMethodTest.java │ │ │ │ ├── InvalidTestClassErrorTest.java │ │ │ │ ├── RunnerBuilderStub.java │ │ │ │ └── TestClassTest.java │ │ │ └── parameterized/ │ │ │ ├── AllParameterizedTests.java │ │ │ ├── BlockJUnit4ClassRunnerWithParametersTest.java │ │ │ ├── ParameterizedNamesTest.java │ │ │ └── TestWithParametersTest.java │ │ ├── samples/ │ │ │ ├── AllSamplesTests.java │ │ │ ├── ListTest.java │ │ │ ├── SimpleTest.java │ │ │ ├── money/ │ │ │ │ ├── MoneyTest.java │ │ │ │ └── package-info.java │ │ │ └── package-info.java │ │ ├── tests/ │ │ │ ├── AllTests.java │ │ │ ├── ObjectContractTest.java │ │ │ ├── SampleJUnit4Tests.java │ │ │ ├── TestSystem.java │ │ │ ├── assertion/ │ │ │ │ ├── AllAssertionTests.java │ │ │ │ ├── AssertionTest.java │ │ │ │ ├── ComparisonFailureTest.java │ │ │ │ └── MultipleFailureExceptionTest.java │ │ │ ├── deprecated/ │ │ │ │ ├── AllDeprecatedTests.java │ │ │ │ └── JUnit4ClassRunnerTest.java │ │ │ ├── description/ │ │ │ │ ├── AllDescriptionTests.java │ │ │ │ ├── AnnotatedDescriptionTest.java │ │ │ │ ├── SuiteDescriptionTest.java │ │ │ │ ├── TestDescriptionMethodNameTest.java │ │ │ │ └── TestDescriptionTest.java │ │ │ ├── experimental/ │ │ │ │ ├── AllExperimentalTests.java │ │ │ │ ├── AssumptionTest.java │ │ │ │ ├── MatcherTest.java │ │ │ │ ├── max/ │ │ │ │ │ ├── AllMaxTests.java │ │ │ │ │ ├── DescriptionTest.java │ │ │ │ │ ├── JUnit38SortingTest.java │ │ │ │ │ └── MaxStarterTest.java │ │ │ │ ├── parallel/ │ │ │ │ │ ├── AllParallelTests.java │ │ │ │ │ ├── ParallelClassTest.java │ │ │ │ │ └── ParallelMethodTest.java │ │ │ │ ├── results/ │ │ │ │ │ ├── AllResultsTests.java │ │ │ │ │ ├── PrintableResultTest.java │ │ │ │ │ └── ResultMatchersTest.java │ │ │ │ └── theories/ │ │ │ │ ├── AllTheoriesTests.java │ │ │ │ ├── AssumingInTheoriesTest.java │ │ │ │ ├── ParameterSignatureTest.java │ │ │ │ ├── PotentialAssignmentTest.java │ │ │ │ ├── TestedOnSupplierTest.java │ │ │ │ ├── TheoryTestUtils.java │ │ │ │ ├── extendingwithstubs/ │ │ │ │ │ ├── Correspondent.java │ │ │ │ │ ├── Guesser.java │ │ │ │ │ ├── GuesserQueue.java │ │ │ │ │ ├── MethodCall.java │ │ │ │ │ ├── ReguessableValue.java │ │ │ │ │ ├── StringableObject.java │ │ │ │ │ ├── Stub.java │ │ │ │ │ ├── StubbedTheories.java │ │ │ │ │ └── StubbedTheoriesTest.java │ │ │ │ ├── internal/ │ │ │ │ │ ├── AllMembersSupplierTest.java │ │ │ │ │ ├── AllTheoriesInternalTests.java │ │ │ │ │ ├── ParameterizedAssertionErrorTest.java │ │ │ │ │ └── SpecificDataPointsSupplierTest.java │ │ │ │ └── runner/ │ │ │ │ ├── AllTheoriesRunnerTests.java │ │ │ │ ├── FailingDataPointMethods.java │ │ │ │ ├── SuccessfulWithDataPointFields.java │ │ │ │ ├── TheoriesPerformanceTest.java │ │ │ │ ├── TypeMatchingBetweenMultiDataPointsMethod.java │ │ │ │ ├── UnsuccessfulWithDataPointFields.java │ │ │ │ ├── WhenNoParametersMatch.java │ │ │ │ ├── WithAutoGeneratedDataPoints.java │ │ │ │ ├── WithDataPointMethod.java │ │ │ │ ├── WithExtendedParameterSources.java │ │ │ │ ├── WithNamedDataPoints.java │ │ │ │ ├── WithOnlyTestAnnotations.java │ │ │ │ ├── WithParameterSupplier.java │ │ │ │ └── WithUnresolvedGenericTypeVariablesOnTheoryParms.java │ │ │ ├── junit3compatibility/ │ │ │ │ ├── AllJUnit3CompatibilityTests.java │ │ │ │ ├── AllTestsTest.java │ │ │ │ ├── ClassRequestTest.java │ │ │ │ ├── ForwardCompatibilityPrintingTest.java │ │ │ │ ├── ForwardCompatibilityTest.java │ │ │ │ ├── InitializationErrorForwardCompatibilityTest.java │ │ │ │ ├── JUnit38ClassRunnerTest.java │ │ │ │ ├── JUnit4TestAdapterTest.java │ │ │ │ ├── OldTestClassAdaptingListenerTest.java │ │ │ │ ├── OldTests.java │ │ │ │ └── SuiteMethodTest.java │ │ │ ├── listening/ │ │ │ │ ├── AllListeningTests.java │ │ │ │ ├── ListenerTest.java │ │ │ │ ├── RunnerTest.java │ │ │ │ ├── TestListenerTest.java │ │ │ │ ├── TextListenerTest.java │ │ │ │ └── UserStopTest.java │ │ │ ├── manipulation/ │ │ │ │ ├── AllManipulationTests.java │ │ │ │ ├── AlphanumericOrdering.java │ │ │ │ ├── ComparatorBasedOrdering.java │ │ │ │ ├── Comparators.java │ │ │ │ ├── FilterTest.java │ │ │ │ ├── FilterableTest.java │ │ │ │ ├── OrderWithTest.java │ │ │ │ ├── OrderableTest.java │ │ │ │ ├── ReverseAlphanumericOrdering.java │ │ │ │ ├── ReverseAlphanumericSorter.java │ │ │ │ ├── SingleMethodTest.java │ │ │ │ └── SortableTest.java │ │ │ ├── package-info.java │ │ │ ├── running/ │ │ │ │ ├── AllRunningTests.java │ │ │ │ ├── classes/ │ │ │ │ │ ├── AllClassesTests.java │ │ │ │ │ ├── BlockJUnit4ClassRunnerTest.java │ │ │ │ │ ├── ClassLevelMethodsWithIgnoredTestsTest.java │ │ │ │ │ ├── EnclosedTest.java │ │ │ │ │ ├── IgnoreClassTest.java │ │ │ │ │ ├── ParameterizedTestTest.java │ │ │ │ │ ├── ParentRunnerFilteringTest.java │ │ │ │ │ ├── ParentRunnerTest.java │ │ │ │ │ ├── RunWithTest.java │ │ │ │ │ ├── SuiteTest.java │ │ │ │ │ ├── ThreadsTest.java │ │ │ │ │ ├── UseSuiteAsASuperclassTest.java │ │ │ │ │ └── parent/ │ │ │ │ │ ├── ParentRunnerClassLoaderTest.java │ │ │ │ │ └── TestWithClassRule.java │ │ │ │ ├── core/ │ │ │ │ │ ├── AllCoreTests.java │ │ │ │ │ ├── CommandLineTest.java │ │ │ │ │ ├── JUnitCoreReturnsCorrectExitCodeTest.java │ │ │ │ │ └── SystemExitTest.java │ │ │ │ └── methods/ │ │ │ │ ├── AllMethodsTests.java │ │ │ │ ├── AnnotationTest.java │ │ │ │ ├── ExpectedTest.java │ │ │ │ ├── InheritedTestTest.java │ │ │ │ ├── ParameterizedTestMethodTest.java │ │ │ │ ├── TestMethodTest.java │ │ │ │ └── TimeoutTest.java │ │ │ └── validation/ │ │ │ ├── AllValidationTests.java │ │ │ ├── BadlyFormedClassesTest.java │ │ │ ├── FailedConstructionTest.java │ │ │ ├── ValidationTest.java │ │ │ └── anotherpackage/ │ │ │ ├── Sub.java │ │ │ └── Super.java │ │ └── validator/ │ │ ├── AllValidatorTests.java │ │ ├── AnnotationValidatorFactoryTest.java │ │ ├── AnnotationsValidatorTest.java │ │ └── PublicClassValidatorTest.java │ └── resources/ │ ├── junit/ │ │ └── tests/ │ │ └── runner/ │ │ ├── testRunAssumptionFailedResultCanBeReserialised_v4_12 │ │ ├── testRunAssumptionFailedResultCanBeReserialised_v4_13 │ │ ├── testRunFailureResultCanBeReserialised_v4_12 │ │ ├── testRunSuccessResultCanBeReserialised_v4_12 │ │ └── testRunSuccessResultCanBeReserialised_v4_13 │ └── org/ │ └── junit/ │ ├── assumptionViolatedExceptionWithValueAndMatcherCanBeReserialized_v4_13 │ ├── assumptionViolatedExceptionWithoutValueAndMatcherCanBeReserialized_v4_13 │ └── internal/ │ ├── arrayComparisonFailure_411 │ └── arrayComparisonFailure_412 └── to-do.txt
Showing preview only (426K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (5371 symbols across 431 files)
FILE: src/main/java/junit/extensions/ActiveTestSuite.java
class ActiveTestSuite (line 14) | public class ActiveTestSuite extends TestSuite {
method ActiveTestSuite (line 17) | public ActiveTestSuite() {
method ActiveTestSuite (line 20) | public ActiveTestSuite(Class<? extends TestCase> theClass) {
method ActiveTestSuite (line 24) | public ActiveTestSuite(String name) {
method ActiveTestSuite (line 28) | public ActiveTestSuite(Class<? extends TestCase> theClass, String name) {
method run (line 32) | @Override
method runTest (line 39) | @Override
method waitUntilFinished (line 56) | synchronized void waitUntilFinished() {
method runFinished (line 66) | public synchronized void runFinished() {
FILE: src/main/java/junit/extensions/RepeatedTest.java
class RepeatedTest (line 9) | public class RepeatedTest extends TestDecorator {
method RepeatedTest (line 12) | public RepeatedTest(Test test, int repeat) {
method countTestCases (line 20) | @Override
method run (line 25) | @Override
method toString (line 35) | @Override
FILE: src/main/java/junit/extensions/TestDecorator.java
class TestDecorator (line 12) | @SuppressWarnings("deprecation")
method TestDecorator (line 16) | public TestDecorator(Test test) {
method basicRun (line 23) | public void basicRun(TestResult result) {
method countTestCases (line 27) | public int countTestCases() {
method run (line 31) | public void run(TestResult result) {
method toString (line 35) | @Override
method getTest (line 40) | public Test getTest() {
FILE: src/main/java/junit/extensions/TestSetup.java
class TestSetup (line 12) | public class TestSetup extends TestDecorator {
method TestSetup (line 14) | public TestSetup(Test test) {
method run (line 18) | @Override
method setUp (line 33) | protected void setUp() throws Exception {
method tearDown (line 40) | protected void tearDown() throws Exception {
FILE: src/main/java/junit/framework/Assert.java
class Assert (line 8) | @Deprecated
method Assert (line 13) | protected Assert() {
method assertTrue (line 20) | public static void assertTrue(String message, boolean condition) {
method assertTrue (line 30) | public static void assertTrue(boolean condition) {
method assertFalse (line 38) | public static void assertFalse(String message, boolean condition) {
method assertFalse (line 46) | public static void assertFalse(boolean condition) {
method fail (line 53) | public static void fail(String message) {
method fail (line 63) | public static void fail() {
method assertEquals (line 71) | public static void assertEquals(String message, Object expected, Objec...
method assertEquals (line 85) | public static void assertEquals(Object expected, Object actual) {
method assertEquals (line 92) | public static void assertEquals(String message, String expected, Strin...
method assertEquals (line 106) | public static void assertEquals(String expected, String actual) {
method assertEquals (line 115) | public static void assertEquals(String message, double expected, doubl...
method assertEquals (line 128) | public static void assertEquals(double expected, double actual, double...
method assertEquals (line 137) | public static void assertEquals(String message, float expected, float ...
method assertEquals (line 150) | public static void assertEquals(float expected, float actual, float de...
method assertEquals (line 158) | public static void assertEquals(String message, long expected, long ac...
method assertEquals (line 165) | public static void assertEquals(long expected, long actual) {
method assertEquals (line 173) | public static void assertEquals(String message, boolean expected, bool...
method assertEquals (line 180) | public static void assertEquals(boolean expected, boolean actual) {
method assertEquals (line 188) | public static void assertEquals(String message, byte expected, byte ac...
method assertEquals (line 195) | public static void assertEquals(byte expected, byte actual) {
method assertEquals (line 203) | public static void assertEquals(String message, char expected, char ac...
method assertEquals (line 210) | public static void assertEquals(char expected, char actual) {
method assertEquals (line 218) | public static void assertEquals(String message, short expected, short ...
method assertEquals (line 225) | public static void assertEquals(short expected, short actual) {
method assertEquals (line 233) | public static void assertEquals(String message, int expected, int actu...
method assertEquals (line 240) | public static void assertEquals(int expected, int actual) {
method assertNotNull (line 247) | public static void assertNotNull(Object object) {
method assertNotNull (line 255) | public static void assertNotNull(String message, Object object) {
method assertNull (line 266) | public static void assertNull(Object object) {
method assertNull (line 276) | public static void assertNull(String message, Object object) {
method assertSame (line 284) | public static void assertSame(String message, Object expected, Object ...
method assertSame (line 295) | public static void assertSame(Object expected, Object actual) {
method assertNotSame (line 304) | public static void assertNotSame(String message, Object expected, Obje...
method assertNotSame (line 314) | public static void assertNotSame(Object expected, Object actual) {
method failSame (line 318) | public static void failSame(String message) {
method failNotSame (line 323) | public static void failNotSame(String message, Object expected, Object...
method failNotEquals (line 328) | public static void failNotEquals(String message, Object expected, Obje...
method format (line 332) | public static String format(String message, Object expected, Object ac...
FILE: src/main/java/junit/framework/AssertionFailedError.java
class AssertionFailedError (line 6) | public class AssertionFailedError extends AssertionError {
method AssertionFailedError (line 13) | public AssertionFailedError() {
method AssertionFailedError (line 22) | public AssertionFailedError(String message) {
method defaultString (line 26) | private static String defaultString(String message) {
FILE: src/main/java/junit/framework/ComparisonCompactor.java
class ComparisonCompactor (line 3) | public class ComparisonCompactor {
method ComparisonCompactor (line 15) | public ComparisonCompactor(int contextLength, String expected, String ...
method compact (line 21) | @SuppressWarnings("deprecation")
method compactString (line 34) | private String compactString(String source) {
method findCommonPrefix (line 45) | private void findCommonPrefix() {
method findCommonSuffix (line 55) | private void findCommonSuffix() {
method computeCommonPrefix (line 66) | private String computeCommonPrefix() {
method computeCommonSuffix (line 70) | private String computeCommonSuffix() {
method areStringsEqual (line 75) | private boolean areStringsEqual() {
FILE: src/main/java/junit/framework/ComparisonFailure.java
class ComparisonFailure (line 8) | public class ComparisonFailure extends AssertionFailedError {
method ComparisonFailure (line 22) | public ComparisonFailure(String message, String expected, String actua...
method getMessage (line 34) | @Override
method getActual (line 44) | public String getActual() {
method getExpected (line 53) | public String getExpected() {
FILE: src/main/java/junit/framework/JUnit4TestAdapter.java
class JUnit4TestAdapter (line 28) | public class JUnit4TestAdapter implements Test, Filterable, Orderable, D...
method JUnit4TestAdapter (line 35) | public JUnit4TestAdapter(Class<?> newTestClass) {
method JUnit4TestAdapter (line 39) | public JUnit4TestAdapter(final Class<?> newTestClass, JUnit4TestAdapte...
method countTestCases (line 45) | public int countTestCases() {
method run (line 49) | public void run(TestResult result) {
method getTests (line 54) | public List<Test> getTests() {
method getTestClass (line 59) | public Class<?> getTestClass() {
method getDescription (line 63) | public Description getDescription() {
method removeIgnored (line 68) | private Description removeIgnored(Description description) {
method isIgnored (line 82) | private boolean isIgnored(Description description) {
method toString (line 86) | @Override
method filter (line 91) | public void filter(Filter filter) throws NoTestsRemainException {
method sort (line 95) | public void sort(Sorter sorter) {
method order (line 104) | public void order(Orderer orderer) throws InvalidOrderingException {
FILE: src/main/java/junit/framework/JUnit4TestAdapterCache.java
class JUnit4TestAdapterCache (line 13) | public class JUnit4TestAdapterCache extends HashMap<Description, Test> {
method getDefault (line 17) | public static JUnit4TestAdapterCache getDefault() {
method asTest (line 21) | public Test asTest(Description description) {
method createTest (line 32) | Test createTest(Description description) {
method getNotifier (line 44) | public RunNotifier getNotifier(final TestResult result, final JUnit4Te...
method asTestList (line 65) | public List<Test> asTestList(Description description) {
FILE: src/main/java/junit/framework/JUnit4TestCaseFacade.java
class JUnit4TestCaseFacade (line 6) | public class JUnit4TestCaseFacade implements Test, Describable {
method JUnit4TestCaseFacade (line 9) | JUnit4TestCaseFacade(Description description) {
method toString (line 13) | @Override
method countTestCases (line 18) | public int countTestCases() {
method run (line 22) | public void run(TestResult result) {
method getDescription (line 27) | public Description getDescription() {
FILE: src/main/java/junit/framework/Protectable.java
type Protectable (line 8) | public interface Protectable {
method protect (line 13) | public abstract void protect() throws Throwable;
FILE: src/main/java/junit/framework/Test.java
type Test (line 8) | public interface Test {
method countTestCases (line 12) | public abstract int countTestCases();
method run (line 17) | public abstract void run(TestResult result);
FILE: src/main/java/junit/framework/TestCase.java
class TestCase (line 76) | @SuppressWarnings("deprecation")
method TestCase (line 87) | public TestCase() {
method TestCase (line 94) | public TestCase(String name) {
method countTestCases (line 101) | public int countTestCases() {
method createResult (line 110) | protected TestResult createResult() {
method run (line 120) | public TestResult run() {
method run (line 129) | public void run(TestResult result) {
method runBare (line 138) | public void runBare() throws Throwable {
method runTest (line 160) | protected void runTest() throws Throwable {
method assertTrue (line 191) | public static void assertTrue(String message, boolean condition) {
method assertTrue (line 199) | public static void assertTrue(boolean condition) {
method assertFalse (line 207) | public static void assertFalse(String message, boolean condition) {
method assertFalse (line 215) | public static void assertFalse(boolean condition) {
method fail (line 222) | public static void fail(String message) {
method fail (line 229) | public static void fail() {
method assertEquals (line 237) | public static void assertEquals(String message, Object expected, Objec...
method assertEquals (line 245) | public static void assertEquals(Object expected, Object actual) {
method assertEquals (line 252) | public static void assertEquals(String message, String expected, Strin...
method assertEquals (line 259) | public static void assertEquals(String expected, String actual) {
method assertEquals (line 268) | public static void assertEquals(String message, double expected, doubl...
method assertEquals (line 276) | public static void assertEquals(double expected, double actual, double...
method assertEquals (line 285) | public static void assertEquals(String message, float expected, float ...
method assertEquals (line 293) | public static void assertEquals(float expected, float actual, float de...
method assertEquals (line 301) | public static void assertEquals(String message, long expected, long ac...
method assertEquals (line 308) | public static void assertEquals(long expected, long actual) {
method assertEquals (line 316) | public static void assertEquals(String message, boolean expected, bool...
method assertEquals (line 323) | public static void assertEquals(boolean expected, boolean actual) {
method assertEquals (line 331) | public static void assertEquals(String message, byte expected, byte ac...
method assertEquals (line 338) | public static void assertEquals(byte expected, byte actual) {
method assertEquals (line 346) | public static void assertEquals(String message, char expected, char ac...
method assertEquals (line 353) | public static void assertEquals(char expected, char actual) {
method assertEquals (line 361) | public static void assertEquals(String message, short expected, short ...
method assertEquals (line 368) | public static void assertEquals(short expected, short actual) {
method assertEquals (line 376) | public static void assertEquals(String message, int expected, int actu...
method assertEquals (line 383) | public static void assertEquals(int expected, int actual) {
method assertNotNull (line 390) | public static void assertNotNull(Object object) {
method assertNotNull (line 398) | public static void assertNotNull(String message, Object object) {
method assertNull (line 409) | public static void assertNull(Object object) {
method assertNull (line 417) | public static void assertNull(String message, Object object) {
method assertSame (line 425) | public static void assertSame(String message, Object expected, Object ...
method assertSame (line 433) | public static void assertSame(Object expected, Object actual) {
method assertNotSame (line 442) | public static void assertNotSame(String message, Object expected, Obje...
method assertNotSame (line 450) | public static void assertNotSame(Object expected, Object actual) {
method failSame (line 454) | public static void failSame(String message) {
method failNotSame (line 458) | public static void failNotSame(String message, Object expected, Object...
method failNotEquals (line 462) | public static void failNotEquals(String message, Object expected, Obje...
method format (line 466) | public static String format(String message, Object expected, Object ac...
method setUp (line 474) | protected void setUp() throws Exception {
method tearDown (line 481) | protected void tearDown() throws Exception {
method toString (line 487) | @Override
method getName (line 497) | public String getName() {
method setName (line 506) | public void setName(String name) {
FILE: src/main/java/junit/framework/TestFailure.java
class TestFailure (line 12) | public class TestFailure {
method TestFailure (line 19) | public TestFailure(Test failedTest, Throwable thrownException) {
method failedTest (line 27) | public Test failedTest() {
method thrownException (line 34) | public Throwable thrownException() {
method toString (line 41) | @Override
method trace (line 50) | public String trace() {
method exceptionMessage (line 57) | public String exceptionMessage() {
method isFailure (line 66) | public boolean isFailure() {
FILE: src/main/java/junit/framework/TestListener.java
type TestListener (line 6) | public interface TestListener {
method addError (line 10) | public void addError(Test test, Throwable e);
method addFailure (line 15) | public void addFailure(Test test, AssertionFailedError e);
method endTest (line 20) | public void endTest(Test test);
method startTest (line 25) | public void startTest(Test test);
FILE: src/main/java/junit/framework/TestResult.java
class TestResult (line 17) | public class TestResult {
method TestResult (line 24) | public TestResult() {
method addError (line 36) | public synchronized void addError(Test test, Throwable e) {
method addFailure (line 47) | public synchronized void addFailure(Test test, AssertionFailedError e) {
method addListener (line 57) | public synchronized void addListener(TestListener listener) {
method removeListener (line 64) | public synchronized void removeListener(TestListener listener) {
method cloneListeners (line 71) | private synchronized List<TestListener> cloneListeners() {
method endTest (line 80) | public void endTest(Test test) {
method errorCount (line 89) | public synchronized int errorCount() {
method errors (line 96) | public synchronized Enumeration<TestFailure> errors() {
method failureCount (line 104) | public synchronized int failureCount() {
method failures (line 111) | public synchronized Enumeration<TestFailure> failures() {
method run (line 118) | protected void run(final TestCase test) {
method runCount (line 133) | public synchronized int runCount() {
method runProtected (line 140) | public void runProtected(final Test test, Protectable p) {
method shouldStop (line 155) | public synchronized boolean shouldStop() {
method startTest (line 162) | public void startTest(Test test) {
method stop (line 175) | public synchronized void stop() {
method wasSuccessful (line 182) | public synchronized boolean wasSuccessful() {
FILE: src/main/java/junit/framework/TestSuite.java
class TestSuite (line 43) | public class TestSuite implements Test {
method createTest (line 49) | static public Test createTest(Class<?> theClass, String name) {
method getTestConstructor (line 80) | public static Constructor<?> getTestConstructor(Class<?> theClass) thr...
method warning (line 92) | public static Test warning(final String message) {
method TestSuite (line 108) | public TestSuite() {
method TestSuite (line 117) | public TestSuite(final Class<?> theClass) {
method addTestsFromTestCase (line 121) | private void addTestsFromTestCase(final Class<?> theClass) {
method TestSuite (line 153) | public TestSuite(Class<? extends TestCase> theClass, String name) {
method TestSuite (line 161) | public TestSuite(String name) {
method TestSuite (line 170) | public TestSuite(Class<?>... classes) {
method testCaseForClass (line 176) | private Test testCaseForClass(Class<?> each) {
method TestSuite (line 189) | public TestSuite(Class<? extends TestCase>[] classes, String name) {
method addTest (line 197) | public void addTest(Test test) {
method addTestSuite (line 204) | public void addTestSuite(Class<? extends TestCase> testClass) {
method countTestCases (line 211) | public int countTestCases() {
method getName (line 224) | public String getName() {
method run (line 231) | public void run(TestResult result) {
method runTest (line 240) | public void runTest(Test test, TestResult result) {
method setName (line 249) | public void setName(String name) {
method testAt (line 256) | public Test testAt(int index) {
method testCount (line 263) | public int testCount() {
method tests (line 270) | public Enumeration<Test> tests() {
method toString (line 276) | @Override
method addTestMethod (line 284) | private void addTestMethod(Method m, List<String> names, Class<?> theC...
method isPublicTestMethod (line 299) | private boolean isPublicTestMethod(Method m) {
method isTestMethod (line 303) | private boolean isTestMethod(Method m) {
FILE: src/main/java/junit/runner/BaseTestRunner.java
class BaseTestRunner (line 29) | public abstract class BaseTestRunner implements TestListener {
method startTest (line 40) | public synchronized void startTest(Test test) {
method setPreferences (line 44) | protected static void setPreferences(Properties preferences) {
method getPreferences (line 48) | protected static Properties getPreferences() {
method savePreferences (line 58) | public static void savePreferences() throws IOException {
method setPreference (line 67) | public static void setPreference(String key, String value) {
method endTest (line 71) | public synchronized void endTest(Test test) {
method addError (line 75) | public synchronized void addError(final Test test, final Throwable e) {
method addFailure (line 79) | public synchronized void addFailure(final Test test, final AssertionFa...
method testStarted (line 85) | public abstract void testStarted(String testName);
method testEnded (line 87) | public abstract void testEnded(String testName);
method testFailed (line 89) | public abstract void testFailed(int status, Test test, Throwable e);
method getTest (line 95) | public Test getTest(String suiteClassName) {
method elapsedTimeAsString (line 147) | public String elapsedTimeAsString(long runTime) {
method processArguments (line 155) | protected String processArguments(String[] args) {
method setLoading (line 179) | public void setLoading(boolean enable) {
method extractClassName (line 186) | public String extractClassName(String className) {
method truncate (line 196) | public static String truncate(String s) {
method runFailed (line 207) | protected abstract void runFailed(String message);
method loadSuiteClass (line 212) | protected Class<?> loadSuiteClass(String suiteClassName) throws ClassN...
method clearStatus (line 219) | protected void clearStatus() { // Belongs in the GUI TestRunner class
method useReloadingTestSuiteLoader (line 222) | protected boolean useReloadingTestSuiteLoader() {
method getPreferencesFile (line 226) | private static File getPreferencesFile() {
method readPreferences (line 231) | private static void readPreferences() {
method getPreference (line 249) | public static String getPreference(String key) {
method getPreference (line 253) | public static int getPreference(String key, int dflt) {
method getFilteredTrace (line 269) | public static String getFilteredTrace(Throwable e) {
method getFilteredTrace (line 276) | public static String getFilteredTrace(String stack) {
method showStackRaw (line 299) | protected static boolean showStackRaw() {
method filterLine (line 303) | static boolean filterLine(String line) {
FILE: src/main/java/junit/runner/TestRunListener.java
type TestRunListener (line 9) | public interface TestRunListener {
method testRunStarted (line 14) | void testRunStarted(String testSuiteName, int testCount);
method testRunEnded (line 16) | void testRunEnded(long elapsedTime);
method testRunStopped (line 18) | void testRunStopped(long elapsedTime);
method testStarted (line 20) | void testStarted(String testName);
method testEnded (line 22) | void testEnded(String testName);
method testFailed (line 24) | void testFailed(int status, String testName, String trace);
FILE: src/main/java/junit/runner/Version.java
class Version (line 6) | public class Version {
method Version (line 7) | private Version() {
method id (line 11) | public static String id() {
method main (line 15) | public static void main(String[] args) {
FILE: src/main/java/junit/textui/ResultPrinter.java
class ResultPrinter (line 14) | public class ResultPrinter implements TestListener {
method ResultPrinter (line 18) | public ResultPrinter(PrintStream writer) {
method print (line 24) | synchronized void print(TestResult result, long runTime) {
method printWaitPrompt (line 31) | void printWaitPrompt() {
method printHeader (line 38) | protected void printHeader(long runTime) {
method printErrors (line 43) | protected void printErrors(TestResult result) {
method printFailures (line 47) | protected void printFailures(TestResult result) {
method printDefects (line 51) | protected void printDefects(Enumeration<TestFailure> booBoos, int coun...
method printDefect (line 63) | public void printDefect(TestFailure booBoo, int count) { // only publi...
method printDefectHeader (line 68) | protected void printDefectHeader(TestFailure booBoo, int count) {
method printDefectTrace (line 74) | protected void printDefectTrace(TestFailure booBoo) {
method printFooter (line 78) | protected void printFooter(TestResult result) {
method elapsedTimeAsString (line 98) | protected String elapsedTimeAsString(long runTime) {
method getWriter (line 102) | public PrintStream getWriter() {
method addError (line 109) | public void addError(Test test, Throwable e) {
method addFailure (line 116) | public void addFailure(Test test, AssertionFailedError t) {
method endTest (line 123) | public void endTest(Test test) {
method startTest (line 129) | public void startTest(Test test) {
FILE: src/main/java/junit/textui/TestRunner.java
class TestRunner (line 30) | public class TestRunner extends BaseTestRunner {
method TestRunner (line 40) | public TestRunner() {
method TestRunner (line 47) | public TestRunner(PrintStream writer) {
method TestRunner (line 54) | public TestRunner(ResultPrinter printer) {
method run (line 61) | static public void run(Class<? extends TestCase> testClass) {
method run (line 75) | static public TestResult run(Test test) {
method runAndWait (line 84) | static public void runAndWait(Test suite) {
method testFailed (line 89) | @Override
method testStarted (line 93) | @Override
method testEnded (line 97) | @Override
method createTestResult (line 104) | protected TestResult createTestResult() {
method doRun (line 108) | public TestResult doRun(Test test) {
method doRun (line 112) | public TestResult doRun(Test suite, boolean wait) {
method pause (line 125) | protected void pause(boolean wait) {
method main (line 134) | public static void main(String[] args) {
method start (line 152) | public TestResult start(String[] args) throws Exception {
method runSingleMethod (line 189) | protected TestResult runSingleMethod(String testCase, String method, b...
method runFailed (line 195) | @Override
method setPrinter (line 201) | public void setPrinter(ResultPrinter printer) {
FILE: src/main/java/org/junit/Assert.java
class Assert (line 25) | public class Assert {
method Assert (line 29) | protected Assert() {
method assertTrue (line 40) | public static void assertTrue(String message, boolean condition) {
method assertTrue (line 52) | public static void assertTrue(boolean condition) {
method assertFalse (line 64) | public static void assertFalse(String message, boolean condition) {
method assertFalse (line 74) | public static void assertFalse(boolean condition) {
method fail (line 85) | public static void fail(String message) {
method fail (line 95) | public static void fail() {
method assertEquals (line 110) | public static void assertEquals(String message, Object expected,
method equalsRegardingNull (line 124) | private static boolean equalsRegardingNull(Object expected, Object act...
method isEquals (line 132) | private static boolean isEquals(Object expected, Object actual) {
method assertEquals (line 145) | public static void assertEquals(Object expected, Object actual) {
method assertNotEquals (line 160) | public static void assertNotEquals(String message, Object unexpected,
method assertNotEquals (line 176) | public static void assertNotEquals(Object unexpected, Object actual) {
method failEquals (line 180) | private static void failEquals(String message, Object actual) {
method assertNotEquals (line 199) | public static void assertNotEquals(String message, long unexpected, lo...
method assertNotEquals (line 212) | public static void assertNotEquals(long unexpected, long actual) {
method assertNotEquals (line 231) | public static void assertNotEquals(String message, double unexpected,
method assertNotEquals (line 250) | public static void assertNotEquals(double unexpected, double actual, d...
method assertNotEquals (line 266) | public static void assertNotEquals(float unexpected, float actual, flo...
method assertArrayEquals (line 283) | public static void assertArrayEquals(String message, Object[] expecteds,
method assertArrayEquals (line 299) | public static void assertArrayEquals(Object[] expecteds, Object[] actu...
method assertArrayEquals (line 314) | public static void assertArrayEquals(String message, boolean[] expecteds,
method assertArrayEquals (line 328) | public static void assertArrayEquals(boolean[] expecteds, boolean[] ac...
method assertArrayEquals (line 341) | public static void assertArrayEquals(String message, byte[] expecteds,
method assertArrayEquals (line 353) | public static void assertArrayEquals(byte[] expecteds, byte[] actuals) {
method assertArrayEquals (line 366) | public static void assertArrayEquals(String message, char[] expecteds,
method assertArrayEquals (line 378) | public static void assertArrayEquals(char[] expecteds, char[] actuals) {
method assertArrayEquals (line 391) | public static void assertArrayEquals(String message, short[] expecteds,
method assertArrayEquals (line 403) | public static void assertArrayEquals(short[] expecteds, short[] actual...
method assertArrayEquals (line 416) | public static void assertArrayEquals(String message, int[] expecteds,
method assertArrayEquals (line 428) | public static void assertArrayEquals(int[] expecteds, int[] actuals) {
method assertArrayEquals (line 441) | public static void assertArrayEquals(String message, long[] expecteds,
method assertArrayEquals (line 453) | public static void assertArrayEquals(long[] expecteds, long[] actuals) {
method assertArrayEquals (line 469) | public static void assertArrayEquals(String message, double[] expecteds,
method assertArrayEquals (line 484) | public static void assertArrayEquals(double[] expecteds, double[] actu...
method assertArrayEquals (line 500) | public static void assertArrayEquals(String message, float[] expecteds,
method assertArrayEquals (line 515) | public static void assertArrayEquals(float[] expecteds, float[] actual...
method internalArrayEquals (line 532) | private static void internalArrayEquals(String message, Object expecteds,
method assertEquals (line 552) | public static void assertEquals(String message, double expected,
method assertEquals (line 574) | public static void assertEquals(String message, float expected,
method assertNotEquals (line 596) | public static void assertNotEquals(String message, float unexpected,
method doubleIsDifferent (line 603) | private static boolean doubleIsDifferent(double d1, double d2, double ...
method floatIsDifferent (line 614) | private static boolean floatIsDifferent(float f1, float f2, float delt...
method assertEquals (line 632) | public static void assertEquals(long expected, long actual) {
method assertEquals (line 645) | public static void assertEquals(String message, long expected, long ac...
method assertEquals (line 656) | @Deprecated
method assertEquals (line 666) | @Deprecated
method assertEquals (line 684) | public static void assertEquals(double expected, double actual, double...
method assertEquals (line 700) | public static void assertEquals(float expected, float actual, float de...
method assertNotNull (line 712) | public static void assertNotNull(String message, Object object) {
method assertNotNull (line 722) | public static void assertNotNull(Object object) {
method assertNull (line 734) | public static void assertNull(String message, Object object) {
method assertNull (line 747) | public static void assertNull(Object object) {
method failNotNull (line 751) | private static void failNotNull(String message, Object actual) {
method assertSame (line 768) | public static void assertSame(String message, Object expected, Object ...
method assertSame (line 782) | public static void assertSame(Object expected, Object actual) {
method assertNotSame (line 796) | public static void assertNotSame(String message, Object unexpected,
method assertNotSame (line 811) | public static void assertNotSame(Object unexpected, Object actual) {
method failSame (line 815) | private static void failSame(String message) {
method failNotSame (line 823) | private static void failNotSame(String message, Object expected,
method failNotEquals (line 833) | private static void failNotEquals(String message, Object expected,
method format (line 838) | static String format(String message, Object expected, Object actual) {
method formatClass (line 855) | private static String formatClass(Class<?> value) {
method formatClassAndValue (line 860) | private static String formatClassAndValue(Object value, String valueSt...
method assertEquals (line 879) | @Deprecated
method assertEquals (line 897) | @Deprecated
method assertThat (line 928) | @Deprecated
method assertThat (line 961) | @Deprecated
method assertThrows (line 979) | public static <T extends Throwable> T assertThrows(Class<T> expectedTh...
method assertThrows (line 998) | public static <T extends Throwable> T assertThrows(String message, Cla...
method buildPrefix (line 1031) | private static String buildPrefix(String message) {
FILE: src/main/java/org/junit/Assume.java
class Assume (line 36) | public class Assume {
method Assume (line 42) | @Deprecated
method assumeTrue (line 49) | public static void assumeTrue(boolean b) {
method assumeFalse (line 56) | public static void assumeFalse(boolean b) {
method assumeTrue (line 67) | public static void assumeTrue(String message, boolean b) {
method assumeFalse (line 74) | public static void assumeFalse(String message, boolean b) {
method assumeNotNull (line 82) | public static void assumeNotNull(Object... objects) {
method assumeThat (line 104) | public static <T> void assumeThat(T actual, Matcher<T> matcher) {
method assumeThat (line 127) | public static <T> void assumeThat(String message, T actual, Matcher<T>...
method assumeNoException (line 152) | public static void assumeNoException(Throwable e) {
method assumeNoException (line 166) | public static void assumeNoException(String message, Throwable e) {
FILE: src/main/java/org/junit/AssumptionViolatedException.java
class AssumptionViolatedException (line 13) | @SuppressWarnings("deprecation")
method AssumptionViolatedException (line 21) | public <T> AssumptionViolatedException(T actual, Matcher<T> matcher) {
method AssumptionViolatedException (line 29) | public <T> AssumptionViolatedException(String message, T expected, Mat...
method AssumptionViolatedException (line 36) | public AssumptionViolatedException(String message) {
method AssumptionViolatedException (line 43) | public AssumptionViolatedException(String message, Throwable t) {
FILE: src/main/java/org/junit/ComparisonFailure.java
class ComparisonFailure (line 12) | public class ComparisonFailure extends AssertionError {
method ComparisonFailure (line 36) | public ComparisonFailure(String message, String expected, String actua...
method getMessage (line 47) | @Override
method getActual (line 57) | public String getActual() {
method getExpected (line 66) | public String getExpected() {
class ComparisonCompactor (line 70) | private static class ComparisonCompactor {
method ComparisonCompactor (line 89) | public ComparisonCompactor(int contextLength, String expected, Strin...
method compact (line 95) | public String compact(String message) {
method sharedPrefix (line 108) | private String sharedPrefix() {
method sharedSuffix (line 118) | private String sharedSuffix(String prefix) {
class DiffExtractor (line 131) | private class DiffExtractor {
method DiffExtractor (line 138) | private DiffExtractor() {
method expectedDiff (line 143) | public String expectedDiff() {
method actualDiff (line 147) | public String actualDiff() {
method compactPrefix (line 151) | public String compactPrefix() {
method compactSuffix (line 158) | public String compactSuffix() {
method extractDiff (line 165) | private String extractDiff(String source) {
FILE: src/main/java/org/junit/Test.java
class None (line 90) | static class None extends Throwable {
method None (line 93) | private None() {
FILE: src/main/java/org/junit/TestCouldNotBeSkippedException.java
class TestCouldNotBeSkippedException (line 12) | public class TestCouldNotBeSkippedException extends RuntimeException {
method TestCouldNotBeSkippedException (line 16) | public TestCouldNotBeSkippedException(org.junit.internal.AssumptionVio...
FILE: src/main/java/org/junit/experimental/ParallelComputer.java
class ParallelComputer (line 14) | public class ParallelComputer extends Computer {
method ParallelComputer (line 19) | public ParallelComputer(boolean classes, boolean methods) {
method classes (line 24) | public static Computer classes() {
method methods (line 28) | public static Computer methods() {
method parallelize (line 32) | private static Runner parallelize(Runner runner) {
method getSuite (line 54) | @Override
method getRunner (line 61) | @Override
FILE: src/main/java/org/junit/experimental/categories/Categories.java
class Categories (line 83) | public class Categories extends Suite {
class CategoryFilter (line 115) | public static class CategoryFilter extends Filter {
method include (line 121) | public static CategoryFilter include(boolean matchAny, Class<?>... c...
method include (line 125) | public static CategoryFilter include(Class<?> category) {
method include (line 129) | public static CategoryFilter include(Class<?>... categories) {
method exclude (line 133) | public static CategoryFilter exclude(boolean matchAny, Class<?>... c...
method exclude (line 137) | public static CategoryFilter exclude(Class<?> category) {
method exclude (line 141) | public static CategoryFilter exclude(Class<?>... categories) {
method categoryFilter (line 145) | public static CategoryFilter categoryFilter(boolean matchAnyInclusio...
method CategoryFilter (line 150) | @Deprecated
method CategoryFilter (line 158) | protected CategoryFilter(boolean matchAnyIncludes, Set<Class<?>> inc...
method CategoryFilter (line 166) | private CategoryFilter(boolean matchAnyIncludes, Class<?>[] inclusions,
method describe (line 177) | @Override
method toString (line 195) | @Override public String toString() {
method shouldRun (line 204) | @Override
method hasCorrectCategoryAnnotation (line 219) | private boolean hasCorrectCategoryAnnotation(Description description) {
method matchesAnyParentCategories (line 255) | private boolean matchesAnyParentCategories(Set<Class<?>> childCatego...
method matchesAllParentCategories (line 268) | private boolean matchesAllParentCategories(Set<Class<?>> childCatego...
method categories (line 277) | private static Set<Class<?>> categories(Description description) {
method parentDescription (line 284) | private static Description parentDescription(Description description) {
method directCategories (line 289) | private static Class<?>[] directCategories(Description description) {
method copyAndRefine (line 298) | private static Set<Class<?>> copyAndRefine(Set<Class<?>> classes) {
method Categories (line 308) | public Categories(Class<?> klass, RunnerBuilder builder) throws Initia...
method getIncludedCategory (line 322) | private static Set<Class<?>> getIncludedCategory(Class<?> klass) {
method isAnyIncluded (line 327) | private static boolean isAnyIncluded(Class<?> klass) {
method getExcludedCategory (line 332) | private static Set<Class<?>> getExcludedCategory(Class<?> klass) {
method isAnyExcluded (line 337) | private static boolean isAnyExcluded(Class<?> klass) {
method hasAssignableTo (line 342) | private static boolean hasAssignableTo(Set<Class<?>> assigns, Class<?>...
method createSet (line 351) | private static Set<Class<?>> createSet(Class<?>[] classes) {
method nullableClassToSet (line 368) | private static Set<Class<?>> nullableClassToSet(Class<?> nullableClass) {
FILE: src/main/java/org/junit/experimental/categories/CategoryFilterFactory.java
class CategoryFilterFactory (line 14) | abstract class CategoryFilterFactory implements FilterFactory {
method createFilter (line 21) | public Filter createFilter(FilterFactoryParams params) throws FilterNo...
method createFilter (line 34) | protected abstract Filter createFilter(List<Class<?>> categories);
method parseCategories (line 36) | private List<Class<?>> parseCategories(String categories) throws Class...
FILE: src/main/java/org/junit/experimental/categories/CategoryValidator.java
class CategoryValidator (line 27) | public final class CategoryValidator extends AnnotationValidator {
method validateAnnotatedMethod (line 43) | @Override
method addErrorMessage (line 57) | private void addErrorMessage(List<Exception> errors, Class<?> clazz) {
FILE: src/main/java/org/junit/experimental/categories/ExcludeCategories.java
class ExcludeCategories (line 26) | public final class ExcludeCategories extends CategoryFilterFactory {
method createFilter (line 33) | @Override
class ExcludesAny (line 38) | private static class ExcludesAny extends CategoryFilter {
method ExcludesAny (line 39) | public ExcludesAny(List<Class<?>> categories) {
method ExcludesAny (line 43) | public ExcludesAny(Set<Class<?>> categories) {
method describe (line 47) | @Override
FILE: src/main/java/org/junit/experimental/categories/IncludeCategories.java
class IncludeCategories (line 26) | public final class IncludeCategories extends CategoryFilterFactory {
method createFilter (line 33) | @Override
class IncludesAny (line 38) | private static class IncludesAny extends CategoryFilter {
method IncludesAny (line 39) | public IncludesAny(List<Class<?>> categories) {
method IncludesAny (line 43) | public IncludesAny(Set<Class<?>> categories) {
method describe (line 47) | @Override
FILE: src/main/java/org/junit/experimental/max/CouldNotReadCoreException.java
class CouldNotReadCoreException (line 6) | public class CouldNotReadCoreException extends Exception {
method CouldNotReadCoreException (line 12) | public CouldNotReadCoreException(Throwable e) {
FILE: src/main/java/org/junit/experimental/max/MaxCore.java
class MaxCore (line 32) | public class MaxCore {
method forFolder (line 40) | @Deprecated
method storedLocally (line 48) | public static MaxCore storedLocally(File storedResults) {
method MaxCore (line 54) | private MaxCore(File storedResults) {
method run (line 63) | public Result run(Class<?> testClass) {
method run (line 73) | public Result run(Request request) {
method run (line 87) | public Result run(Request request, JUnitCore core) {
method sortRequest (line 95) | public Request sortRequest(Request request) {
method constructLeafRequest (line 105) | private Request constructLeafRequest(List<Description> leaves) {
method buildRunner (line 123) | private Runner buildRunner(Description each) {
method getMalformedTestClass (line 145) | private Class<?> getMalformedTestClass(Description each) {
method sortedLeavesForTest (line 158) | public List<Description> sortedLeavesForTest(Request request) {
method findLeaves (line 162) | private List<Description> findLeaves(Request request) {
method findLeaves (line 168) | private void findLeaves(Description parent, Description description, L...
FILE: src/main/java/org/junit/experimental/max/MaxHistory.java
class MaxHistory (line 26) | public class MaxHistory implements Serializable {
method forFolder (line 33) | public static MaxHistory forFolder(File file) {
method readHistory (line 45) | private static MaxHistory readHistory(File storedResults)
method MaxHistory (line 73) | private MaxHistory(File storedResults) {
method save (line 77) | private void save() throws IOException {
method getFailureTimestamp (line 89) | Long getFailureTimestamp(Description key) {
method putTestFailureTimestamp (line 93) | void putTestFailureTimestamp(Description key, long end) {
method isNewTest (line 97) | boolean isNewTest(Description key) {
method getTestDuration (line 101) | Long getTestDuration(Description key) {
method putTestDuration (line 105) | void putTestDuration(Description description, long duration) {
class RememberingListener (line 109) | private final class RememberingListener extends RunListener {
method testStarted (line 114) | @Override
method testFinished (line 120) | @Override
method testFailure (line 127) | @Override
method testRunFinished (line 132) | @Override
class TestComparator (line 138) | private class TestComparator implements Comparator<Description> {
method compare (line 139) | public int compare(Description o1, Description o2) {
method getFailure (line 154) | private Long getFailure(Description key) {
method listener (line 167) | public RunListener listener() {
method testComparator (line 175) | public Comparator<Description> testComparator() {
FILE: src/main/java/org/junit/experimental/results/FailureList.java
class FailureList (line 9) | class FailureList {
method FailureList (line 12) | public FailureList(List<Failure> failures) {
method result (line 16) | public Result result() {
FILE: src/main/java/org/junit/experimental/results/PrintableResult.java
class PrintableResult (line 22) | public class PrintableResult {
method testResult (line 28) | public static PrintableResult testResult(Class<?> type) {
method testResult (line 35) | public static PrintableResult testResult(Request request) {
method PrintableResult (line 42) | public PrintableResult(List<Failure> failures) {
method PrintableResult (line 46) | private PrintableResult(Result result) {
method failureCount (line 53) | public int failureCount() {
method failures (line 62) | public List<Failure> failures() {
method toString (line 66) | @Override
FILE: src/main/java/org/junit/experimental/results/ResultMatchers.java
class ResultMatchers (line 16) | public class ResultMatchers {
method ResultMatchers (line 22) | @Deprecated
method isSuccessful (line 29) | public static Matcher<PrintableResult> isSuccessful() {
method failureCountIs (line 36) | public static Matcher<PrintableResult> failureCountIs(final int count) {
method hasSingleFailureContaining (line 52) | public static Matcher<Object> hasSingleFailureContaining(final String ...
method hasSingleFailureMatching (line 69) | public static Matcher<PrintableResult> hasSingleFailureMatching(final ...
method hasFailureContaining (line 87) | public static Matcher<PrintableResult> hasFailureContaining(final Stri...
FILE: src/main/java/org/junit/experimental/runners/Enclosed.java
class Enclosed (line 26) | public class Enclosed extends Suite {
method Enclosed (line 30) | public Enclosed(Class<?> klass, RunnerBuilder builder) throws Throwable {
method filterAbstractClasses (line 34) | private static Class<?>[] filterAbstractClasses(final Class<?>[] class...
FILE: src/main/java/org/junit/experimental/theories/ParameterSignature.java
class ParameterSignature (line 13) | public class ParameterSignature {
method buildConvertableTypesMap (line 17) | private static Map<Class<?>, Class<?>> buildConvertableTypesMap() {
method putSymmetrically (line 32) | private static <T> void putSymmetrically(Map<T, T> map, T a, T b) {
method signatures (line 37) | public static ArrayList<ParameterSignature> signatures(Method method) {
method signatures (line 42) | public static List<ParameterSignature> signatures(Constructor<?> const...
method signatures (line 47) | private static ArrayList<ParameterSignature> signatures(
method ParameterSignature (line 61) | private ParameterSignature(Class<?> type, Annotation[] annotations) {
method canAcceptValue (line 66) | public boolean canAcceptValue(Object candidate) {
method canAcceptType (line 70) | public boolean canAcceptType(Class<?> candidate) {
method canPotentiallyAcceptType (line 75) | public boolean canPotentiallyAcceptType(Class<?> candidate) {
method isAssignableViaTypeConversion (line 81) | private boolean isAssignableViaTypeConversion(Class<?> targetType, Cla...
method getType (line 90) | public Class<?> getType() {
method getAnnotations (line 94) | public List<Annotation> getAnnotations() {
method hasAnnotation (line 98) | public boolean hasAnnotation(Class<? extends Annotation> type) {
method findDeepAnnotation (line 102) | public <T extends Annotation> T findDeepAnnotation(Class<T> annotation...
method findDeepAnnotation (line 107) | private <T extends Annotation> T findDeepAnnotation(
method getAnnotation (line 126) | public <T extends Annotation> T getAnnotation(Class<T> annotationType) {
FILE: src/main/java/org/junit/experimental/theories/ParameterSupplier.java
class ParameterSupplier (line 41) | public abstract class ParameterSupplier {
method getValueSources (line 42) | public abstract List<PotentialAssignment> getValueSources(ParameterSig...
FILE: src/main/java/org/junit/experimental/theories/PotentialAssignment.java
class PotentialAssignment (line 5) | public abstract class PotentialAssignment {
class CouldNotGenerateValueException (line 6) | public static class CouldNotGenerateValueException extends Exception {
method CouldNotGenerateValueException (line 9) | public CouldNotGenerateValueException() {
method CouldNotGenerateValueException (line 12) | public CouldNotGenerateValueException(Throwable e) {
method forValue (line 17) | public static PotentialAssignment forValue(final String name, final Ob...
method getValue (line 49) | public abstract Object getValue() throws CouldNotGenerateValueException;
method getDescription (line 51) | public abstract String getDescription() throws CouldNotGenerateValueEx...
FILE: src/main/java/org/junit/experimental/theories/Theories.java
class Theories (line 71) | public class Theories extends BlockJUnit4ClassRunner {
method Theories (line 72) | public Theories(Class<?> klass) throws InitializationError {
method Theories (line 77) | protected Theories(TestClass testClass) throws InitializationError {
method collectInitializationErrors (line 81) | @Override
method validateDataPointFields (line 88) | private void validateDataPointFields(List<Throwable> errors) {
method validateDataPointMethods (line 104) | private void validateDataPointMethods(List<Throwable> errors) {
method validateConstructor (line 120) | @Override
method validateTestMethods (line 125) | @Override
method validateParameterSupplier (line 144) | private void validateParameterSupplier(Class<? extends ParameterSuppli...
method computeTestMethods (line 159) | @Override
method methodBlock (line 168) | @Override
class TheoryAnchor (line 173) | public static class TheoryAnchor extends Statement {
method TheoryAnchor (line 181) | public TheoryAnchor(FrameworkMethod testMethod, TestClass testClass) {
method getTestClass (line 186) | private TestClass getTestClass() {
method evaluate (line 190) | @Override
method runWithAssignment (line 204) | protected void runWithAssignment(Assignments parameterAssignment)
method runWithIncompleteAssignment (line 213) | protected void runWithIncompleteAssignment(Assignments incomplete)
method runWithCompleteAssignment (line 221) | protected void runWithCompleteAssignment(final Assignments complete)
method methodCompletesWithParameters (line 268) | private Statement methodCompletesWithParameters(
method handleAssumptionViolation (line 284) | protected void handleAssumptionViolation(AssumptionViolatedException...
method reportParameterizedError (line 288) | protected void reportParameterizedError(Throwable e, Object... params)
method nullsOk (line 297) | private boolean nullsOk() {
method handleDataPointSuccess (line 306) | protected void handleDataPointSuccess() {
FILE: src/main/java/org/junit/experimental/theories/internal/AllMembersSupplier.java
class AllMembersSupplier (line 23) | public class AllMembersSupplier extends ParameterSupplier {
class MethodParameterValue (line 24) | static class MethodParameterValue extends PotentialAssignment {
method MethodParameterValue (line 27) | private MethodParameterValue(FrameworkMethod dataPointMethod) {
method getValue (line 31) | @Override
method getDescription (line 49) | @Override
method AllMembersSupplier (line 60) | public AllMembersSupplier(TestClass type) {
method getValueSources (line 64) | @Override
method addMultiPointMethods (line 76) | private void addMultiPointMethods(ParameterSignature sig, List<Potenti...
method addSinglePointMethods (line 97) | private void addSinglePointMethods(ParameterSignature sig, List<Potent...
method addMultiPointFields (line 105) | private void addMultiPointFields(ParameterSignature sig, List<Potentia...
method addSinglePointFields (line 112) | private void addSinglePointFields(ParameterSignature sig, List<Potenti...
method addDataPointsValues (line 122) | private void addDataPointsValues(Class<?> type, ParameterSignature sig...
method addArrayValues (line 132) | private void addArrayValues(ParameterSignature sig, String name, List<...
method addIterableValues (line 141) | private void addIterableValues(ParameterSignature sig, String name, Li...
method getStaticFieldValue (line 153) | private Object getStaticFieldValue(final Field field) {
method isAssignableToAnyOf (line 165) | private static boolean isAssignableToAnyOf(Class<?>[] typeArray, Objec...
method getDataPointsMethods (line 174) | protected Collection<FrameworkMethod> getDataPointsMethods(ParameterSi...
method getSingleDataPointFields (line 178) | protected Collection<Field> getSingleDataPointFields(ParameterSignatur...
method getDataPointsFields (line 189) | protected Collection<Field> getDataPointsFields(ParameterSignature sig) {
method getSingleDataPointMethods (line 200) | protected Collection<FrameworkMethod> getSingleDataPointMethods(Parame...
FILE: src/main/java/org/junit/experimental/theories/internal/Assignments.java
class Assignments (line 21) | public class Assignments {
method Assignments (line 28) | private Assignments(List<PotentialAssignment> assigned,
method allUnassigned (line 39) | public static Assignments allUnassigned(Method testMethod,
method isComplete (line 49) | public boolean isComplete() {
method nextUnassigned (line 53) | public ParameterSignature nextUnassigned() {
method assignNext (line 57) | public Assignments assignNext(PotentialAssignment source) {
method getActualValues (line 65) | public Object[] getActualValues(int start, int stop)
method potentialsForNextUnassigned (line 74) | public List<PotentialAssignment> potentialsForNextUnassigned()
method generateAssignmentsFromTypeAlone (line 86) | private List<PotentialAssignment> generateAssignmentsFromTypeAlone(Par...
method getSupplier (line 98) | private ParameterSupplier getSupplier(ParameterSignature unassigned)
method buildParameterSupplierFromClass (line 110) | private ParameterSupplier buildParameterSupplierFromClass(
method getConstructorArguments (line 125) | public Object[] getConstructorArguments()
method getMethodArguments (line 130) | public Object[] getMethodArguments() throws CouldNotGenerateValueExcep...
method getAllArguments (line 134) | public Object[] getAllArguments() throws CouldNotGenerateValueException {
method getConstructorParameterCount (line 138) | private int getConstructorParameterCount() {
method getArgumentStrings (line 145) | public Object[] getArgumentStrings(boolean nullsOk)
FILE: src/main/java/org/junit/experimental/theories/internal/BooleanSupplier.java
class BooleanSupplier (line 10) | public class BooleanSupplier extends ParameterSupplier {
method getValueSources (line 12) | @Override
FILE: src/main/java/org/junit/experimental/theories/internal/EnumSupplier.java
class EnumSupplier (line 10) | public class EnumSupplier extends ParameterSupplier {
method EnumSupplier (line 14) | public EnumSupplier(Class<?> enumType) {
method getValueSources (line 18) | @Override
FILE: src/main/java/org/junit/experimental/theories/internal/ParameterizedAssertionError.java
class ParameterizedAssertionError (line 7) | public class ParameterizedAssertionError extends AssertionError {
method ParameterizedAssertionError (line 10) | public ParameterizedAssertionError(Throwable targetException,
method equals (line 16) | @Override
method hashCode (line 21) | @Override
method join (line 26) | public static String join(String delimiter, Object... params) {
method join (line 30) | public static String join(String delimiter, Collection<Object> values) {
method stringValueOf (line 43) | private static String stringValueOf(Object next) {
FILE: src/main/java/org/junit/experimental/theories/internal/SpecificDataPointsSupplier.java
class SpecificDataPointsSupplier (line 16) | public class SpecificDataPointsSupplier extends AllMembersSupplier {
method SpecificDataPointsSupplier (line 18) | public SpecificDataPointsSupplier(TestClass testClass) {
method getSingleDataPointFields (line 22) | @Override
method getDataPointsFields (line 39) | @Override
method getSingleDataPointMethods (line 56) | @Override
method getDataPointsMethods (line 73) | @Override
FILE: src/main/java/org/junit/experimental/theories/suppliers/TestedOnSupplier.java
class TestedOnSupplier (line 14) | public class TestedOnSupplier extends ParameterSupplier {
method getValueSources (line 15) | @Override
FILE: src/main/java/org/junit/function/ThrowingRunnable.java
type ThrowingRunnable (line 12) | public interface ThrowingRunnable {
method run (line 13) | void run() throws Throwable;
FILE: src/main/java/org/junit/internal/ArrayComparisonFailure.java
class ArrayComparisonFailure (line 13) | public class ArrayComparisonFailure extends AssertionError {
method ArrayComparisonFailure (line 34) | public ArrayComparisonFailure(String message, AssertionError cause, in...
method addDimension (line 41) | public void addDimension(int index) {
method getCause (line 45) | @Override
method getMessage (line 50) | @Override
method toString (line 70) | @Override
FILE: src/main/java/org/junit/internal/AssumptionViolatedException.java
class AssumptionViolatedException (line 18) | public class AssumptionViolatedException extends RuntimeException implem...
method AssumptionViolatedException (line 34) | @Deprecated
method AssumptionViolatedException (line 52) | @Deprecated
method AssumptionViolatedException (line 63) | @Deprecated
method AssumptionViolatedException (line 73) | @Deprecated
method AssumptionViolatedException (line 83) | @Deprecated
method getMessage (line 89) | @Override
method describeTo (line 94) | public void describeTo(Description description) {
method writeObject (line 123) | private void writeObject(ObjectOutputStream objectOutputStream) throws...
FILE: src/main/java/org/junit/internal/Checks.java
class Checks (line 4) | public final class Checks {
method Checks (line 6) | private Checks() {}
method notNull (line 15) | public static <T> T notNull(T value) {
method notNull (line 31) | public static <T> T notNull(T value, String message) {
FILE: src/main/java/org/junit/internal/Classes.java
class Classes (line 8) | public class Classes {
method Classes (line 14) | @Deprecated
method getClass (line 25) | public static Class<?> getClass(String className) throws ClassNotFound...
method getClass (line 38) | public static Class<?> getClass(String className, Class<?> callingClas...
FILE: src/main/java/org/junit/internal/ComparisonCriteria.java
class ComparisonCriteria (line 12) | public abstract class ComparisonCriteria {
method arrayEquals (line 26) | public void arrayEquals(String message, Object expecteds, Object actuals)
method arrayEquals (line 31) | private void arrayEquals(String message, Object expecteds, Object actu...
method getToStringableArrayElement (line 96) | private Object getToStringableArrayElement(Object array, int length, i...
method objectWithToString (line 109) | private static Object objectWithToString(final String string) {
method componentTypeName (line 118) | private String componentTypeName(Class<?> arrayClass) {
method isArray (line 127) | private boolean isArray(Object expected) {
method assertElementsEqual (line 131) | protected abstract void assertElementsEqual(Object expected, Object ac...
FILE: src/main/java/org/junit/internal/ExactComparisonCriteria.java
class ExactComparisonCriteria (line 5) | public class ExactComparisonCriteria extends ComparisonCriteria {
method assertElementsEqual (line 6) | @Override
FILE: src/main/java/org/junit/internal/InexactComparisonCriteria.java
class InexactComparisonCriteria (line 5) | public class InexactComparisonCriteria extends ComparisonCriteria {
method InexactComparisonCriteria (line 8) | public InexactComparisonCriteria(double delta) {
method InexactComparisonCriteria (line 12) | public InexactComparisonCriteria(float delta) {
method assertElementsEqual (line 16) | @Override
FILE: src/main/java/org/junit/internal/JUnitSystem.java
type JUnitSystem (line 5) | public interface JUnitSystem {
method exit (line 10) | @Deprecated
method out (line 13) | PrintStream out();
FILE: src/main/java/org/junit/internal/MethodSorter.java
class MethodSorter (line 9) | public class MethodSorter {
method compare (line 14) | public int compare(Method m1, Method m2) {
method compare (line 28) | public int compare(Method m1, Method m2) {
method getDeclaredMethods (line 51) | public static Method[] getDeclaredMethods(Class<?> clazz) {
method MethodSorter (line 62) | private MethodSorter() {
method getSorter (line 65) | private static Comparator<Method> getSorter(FixMethodOrder fixMethodOr...
FILE: src/main/java/org/junit/internal/RealSystem.java
class RealSystem (line 5) | public class RealSystem implements JUnitSystem {
method exit (line 10) | @Deprecated
method out (line 15) | public PrintStream out() {
FILE: src/main/java/org/junit/internal/SerializableMatcherDescription.java
class SerializableMatcherDescription (line 18) | class SerializableMatcherDescription<T> extends BaseMatcher<T> implement...
method SerializableMatcherDescription (line 22) | private SerializableMatcherDescription(Matcher<T> matcher) {
method matches (line 26) | public boolean matches(Object o) {
method describeTo (line 30) | public void describeTo(Description description) {
method asSerializableMatcher (line 40) | static <T> Matcher<T> asSerializableMatcher(Matcher<T> matcher) {
FILE: src/main/java/org/junit/internal/SerializableValueDescription.java
class SerializableValueDescription (line 13) | class SerializableValueDescription implements Serializable {
method SerializableValueDescription (line 16) | private SerializableValueDescription(Object value) {
method asSerializableValue (line 26) | static Object asSerializableValue(Object value) {
method toString (line 34) | @Override
FILE: src/main/java/org/junit/internal/TextListener.java
class TextListener (line 12) | public class TextListener extends RunListener {
method TextListener (line 16) | public TextListener(JUnitSystem system) {
method TextListener (line 20) | public TextListener(PrintStream writer) {
method testRunFinished (line 24) | @Override
method testStarted (line 31) | @Override
method testFailure (line 36) | @Override
method testIgnored (line 41) | @Override
method getWriter (line 50) | private PrintStream getWriter() {
method printHeader (line 54) | protected void printHeader(long runTime) {
method printFailures (line 59) | protected void printFailures(Result result) {
method printFailure (line 75) | protected void printFailure(Failure each, String prefix) {
method printFooter (line 80) | protected void printFooter(Result result) {
method elapsedTimeAsString (line 98) | protected String elapsedTimeAsString(long runTime) {
FILE: src/main/java/org/junit/internal/Throwables.java
class Throwables (line 21) | public final class Throwables {
method Throwables (line 23) | private Throwables() {
method rethrowAsException (line 45) | public static Exception rethrowAsException(Throwable e) throws Excepti...
method rethrow (line 50) | @SuppressWarnings("unchecked")
method getStacktrace (line 60) | public static String getStacktrace(Throwable exception) {
method getTrimmedStackTrace (line 73) | public static String getTrimmedStackTrace(Throwable exception) {
method getTrimmedStackTraceLines (line 85) | private static List<String> getTrimmedStackTraceLines(Throwable except...
method initGetSuppressed (line 110) | private static Method initGetSuppressed() {
method hasSuppressed (line 118) | private static boolean hasSuppressed(Throwable exception) {
method getCauseStackTraceLines (line 130) | private static List<String> getCauseStackTraceLines(Throwable exceptio...
method getFullStackTrace (line 156) | private static String getFullStackTrace(Throwable exception) {
method appendStackTraceLines (line 163) | private static void appendStackTraceLines(
method asReversedList (line 170) | private static <T> List<T> asReversedList(final List<T> list) {
type State (line 185) | private enum State {
method processLine (line 187) | @Override public State processLine(String methodName) {
method processLine (line 195) | @Override public State processLine(String methodName) {
method processLine (line 205) | @Override public State processLine(String methodName) {
method processLine (line 216) | @Override public State processLine(String methodName) {
method processLine (line 222) | protected abstract State processLine(String methodName);
method processStackTraceElement (line 225) | public final State processStackTraceElement(StackTraceElement elemen...
method isTestFrameworkMethod (line 245) | private static boolean isTestFrameworkMethod(String methodName) {
method isReflectionMethod (line 260) | private static boolean isReflectionMethod(String methodName) {
method isMatchingMethod (line 264) | private static boolean isMatchingMethod(String methodName, String[] me...
FILE: src/main/java/org/junit/internal/builders/AllDefaultPossibilitiesBuilder.java
class AllDefaultPossibilitiesBuilder (line 9) | public class AllDefaultPossibilitiesBuilder extends RunnerBuilder {
method AllDefaultPossibilitiesBuilder (line 15) | public AllDefaultPossibilitiesBuilder() {
method AllDefaultPossibilitiesBuilder (line 22) | @Deprecated
method runnerForClass (line 27) | @Override
method junit4Builder (line 45) | protected JUnit4Builder junit4Builder() {
method junit3Builder (line 49) | protected JUnit3Builder junit3Builder() {
method annotatedBuilder (line 53) | protected AnnotatedBuilder annotatedBuilder() {
method ignoredBuilder (line 57) | protected IgnoredBuilder ignoredBuilder() {
method suiteMethodBuilder (line 61) | protected RunnerBuilder suiteMethodBuilder() {
FILE: src/main/java/org/junit/internal/builders/AnnotatedBuilder.java
class AnnotatedBuilder (line 71) | public class AnnotatedBuilder extends RunnerBuilder {
method AnnotatedBuilder (line 76) | public AnnotatedBuilder(RunnerBuilder suiteBuilder) {
method runnerForClass (line 80) | @Override
method getEnclosingClassForNonStaticMemberClass (line 93) | private Class<?> getEnclosingClassForNonStaticMemberClass(Class<?> cur...
method buildRunner (line 101) | public Runner buildRunner(Class<? extends Runner> runnerClass,
FILE: src/main/java/org/junit/internal/builders/IgnoredBuilder.java
class IgnoredBuilder (line 7) | public class IgnoredBuilder extends RunnerBuilder {
method runnerForClass (line 8) | @Override
FILE: src/main/java/org/junit/internal/builders/IgnoredClassRunner.java
class IgnoredClassRunner (line 7) | public class IgnoredClassRunner extends Runner {
method IgnoredClassRunner (line 10) | public IgnoredClassRunner(Class<?> testClass) {
method run (line 14) | @Override
method getDescription (line 19) | @Override
FILE: src/main/java/org/junit/internal/builders/JUnit3Builder.java
class JUnit3Builder (line 7) | public class JUnit3Builder extends RunnerBuilder {
method runnerForClass (line 8) | @Override
method isPre4Test (line 16) | boolean isPre4Test(Class<?> testClass) {
FILE: src/main/java/org/junit/internal/builders/JUnit4Builder.java
class JUnit4Builder (line 7) | public class JUnit4Builder extends RunnerBuilder {
method runnerForClass (line 8) | @Override
FILE: src/main/java/org/junit/internal/builders/NullBuilder.java
class NullBuilder (line 6) | public class NullBuilder extends RunnerBuilder {
method runnerForClass (line 7) | @Override
FILE: src/main/java/org/junit/internal/builders/SuiteMethodBuilder.java
class SuiteMethodBuilder (line 7) | public class SuiteMethodBuilder extends RunnerBuilder {
method runnerForClass (line 8) | @Override
method hasSuiteMethod (line 16) | public boolean hasSuiteMethod(Class<?> testClass) {
FILE: src/main/java/org/junit/internal/management/FakeRuntimeMXBean.java
class FakeRuntimeMXBean (line 9) | class FakeRuntimeMXBean implements RuntimeMXBean {
method getInputArguments (line 16) | public List<String> getInputArguments() {
FILE: src/main/java/org/junit/internal/management/FakeThreadMXBean.java
class FakeThreadMXBean (line 6) | final class FakeThreadMXBean implements ThreadMXBean {
method getThreadCpuTime (line 13) | public long getThreadCpuTime(long id) {
method isThreadCpuTimeSupported (line 22) | public boolean isThreadCpuTimeSupported() {
FILE: src/main/java/org/junit/internal/management/ManagementFactory.java
class ManagementFactory (line 10) | public class ManagementFactory {
class FactoryHolder (line 11) | private static final class FactoryHolder {
method getBeanObject (line 24) | static Object getBeanObject(String methodName) {
class RuntimeHolder (line 44) | private static final class RuntimeHolder {
method getBean (line 48) | private static final RuntimeMXBean getBean(Object runtimeMxBean) {
class ThreadHolder (line 54) | private static final class ThreadHolder {
method getBean (line 58) | private static final ThreadMXBean getBean(Object threadMxBean) {
method getRuntimeMXBean (line 67) | public static RuntimeMXBean getRuntimeMXBean() {
method getThreadMXBean (line 74) | public static ThreadMXBean getThreadMXBean() {
FILE: src/main/java/org/junit/internal/management/ReflectiveRuntimeMXBean.java
class ReflectiveRuntimeMXBean (line 13) | final class ReflectiveRuntimeMXBean implements RuntimeMXBean {
class Holder (line 16) | private static final class Holder {
method ReflectiveRuntimeMXBean (line 34) | ReflectiveRuntimeMXBean(Object runtimeMxBean) {
method getInputArguments (line 42) | @SuppressWarnings("unchecked")
FILE: src/main/java/org/junit/internal/management/ReflectiveThreadMXBean.java
class ReflectiveThreadMXBean (line 11) | final class ReflectiveThreadMXBean implements ThreadMXBean {
class Holder (line 15) | private static final class Holder {
method ReflectiveThreadMXBean (line 40) | ReflectiveThreadMXBean(Object threadMxBean) {
method getThreadCpuTime (line 48) | public long getThreadCpuTime(long id) {
method isThreadCpuTimeSupported (line 74) | public boolean isThreadCpuTimeSupported() {
FILE: src/main/java/org/junit/internal/management/RuntimeMXBean.java
type RuntimeMXBean (line 8) | public interface RuntimeMXBean {
method getInputArguments (line 13) | List<String> getInputArguments();
FILE: src/main/java/org/junit/internal/management/ThreadMXBean.java
type ThreadMXBean (line 6) | public interface ThreadMXBean {
method getThreadCpuTime (line 10) | long getThreadCpuTime(long id);
method isThreadCpuTimeSupported (line 15) | boolean isThreadCpuTimeSupported();
FILE: src/main/java/org/junit/internal/matchers/StacktracePrintingMatcher.java
class StacktracePrintingMatcher (line 13) | public class StacktracePrintingMatcher<T extends Throwable> extends
method StacktracePrintingMatcher (line 18) | public StacktracePrintingMatcher(Matcher<T> throwableMatcher) {
method describeTo (line 22) | public void describeTo(Description description) {
method matchesSafely (line 26) | @Override
method describeMismatchSafely (line 31) | @Override
method readStacktrace (line 38) | private String readStacktrace(Throwable throwable) {
method isThrowable (line 42) | @Factory
method isException (line 48) | @Factory
FILE: src/main/java/org/junit/internal/matchers/ThrowableCauseMatcher.java
class ThrowableCauseMatcher (line 14) | public class ThrowableCauseMatcher<T extends Throwable> extends
method ThrowableCauseMatcher (line 19) | public ThrowableCauseMatcher(Matcher<?> causeMatcher) {
method describeTo (line 23) | public void describeTo(Description description) {
method matchesSafely (line 28) | @Override
method describeMismatchSafely (line 33) | @Override
method hasCause (line 46) | @Factory
FILE: src/main/java/org/junit/internal/matchers/ThrowableMessageMatcher.java
class ThrowableMessageMatcher (line 8) | public class ThrowableMessageMatcher<T extends Throwable> extends
method ThrowableMessageMatcher (line 13) | public ThrowableMessageMatcher(Matcher<String> matcher) {
method describeTo (line 17) | public void describeTo(Description description) {
method matchesSafely (line 22) | @Override
method describeMismatchSafely (line 27) | @Override
method hasMessage (line 33) | @Factory
FILE: src/main/java/org/junit/internal/matchers/TypeSafeMatcher.java
class TypeSafeMatcher (line 15) | @Deprecated
method matchesSafely (line 24) | public abstract boolean matchesSafely(T item);
method TypeSafeMatcher (line 26) | protected TypeSafeMatcher() {
method findExpectedType (line 30) | private static Class<?> findExpectedType(Class<?> fromClass) {
method isMatchesSafelyMethod (line 42) | private static boolean isMatchesSafelyMethod(Method method) {
method TypeSafeMatcher (line 48) | protected TypeSafeMatcher(Class<T> expectedType) {
method matches (line 57) | @SuppressWarnings({"unchecked"})
FILE: src/main/java/org/junit/internal/requests/ClassRequest.java
class ClassRequest (line 8) | public class ClassRequest extends MemoizingRequest {
method ClassRequest (line 17) | public ClassRequest(Class<?> testClass, boolean canUseSuiteMethod) {
method ClassRequest (line 22) | public ClassRequest(Class<?> testClass) {
method createRunner (line 26) | @Override
class CustomAllDefaultPossibilitiesBuilder (line 31) | private class CustomAllDefaultPossibilitiesBuilder extends AllDefaultP...
method suiteMethodBuilder (line 33) | @Override
class CustomSuiteMethodBuilder (line 44) | private class CustomSuiteMethodBuilder extends SuiteMethodBuilder {
method runnerForClass (line 46) | @Override
FILE: src/main/java/org/junit/internal/requests/FilterRequest.java
class FilterRequest (line 12) | public final class FilterRequest extends Request {
method FilterRequest (line 28) | public FilterRequest(Request request, Filter filter) {
method getRunner (line 33) | @Override
FILE: src/main/java/org/junit/internal/requests/MemoizingRequest.java
class MemoizingRequest (line 9) | abstract class MemoizingRequest extends Request {
method getRunner (line 13) | @Override
method createRunner (line 29) | protected abstract Runner createRunner();
FILE: src/main/java/org/junit/internal/requests/OrderingRequest.java
class OrderingRequest (line 10) | public class OrderingRequest extends MemoizingRequest {
method OrderingRequest (line 14) | public OrderingRequest(Request request, Ordering ordering) {
method createRunner (line 19) | @Override
FILE: src/main/java/org/junit/internal/requests/SortingRequest.java
class SortingRequest (line 10) | public class SortingRequest extends Request {
method SortingRequest (line 14) | public SortingRequest(Request request, Comparator<Description> compara...
method getRunner (line 19) | @Override
FILE: src/main/java/org/junit/internal/runners/ClassRoadie.java
class ClassRoadie (line 18) | @Deprecated
method ClassRoadie (line 25) | public ClassRoadie(RunNotifier notifier, TestClass testClass,
method runUnprotected (line 33) | protected void runUnprotected() {
method addFailure (line 37) | protected void addFailure(Throwable targetException) {
method runProtected (line 41) | public void runProtected() {
method runBefores (line 51) | private void runBefores() throws FailedBefore {
method runAfters (line 69) | private void runAfters() {
FILE: src/main/java/org/junit/internal/runners/ErrorReportingRunner.java
class ErrorReportingRunner (line 15) | public class ErrorReportingRunner extends Runner {
method ErrorReportingRunner (line 20) | public ErrorReportingRunner(Class<?> testClass, Throwable cause) {
method ErrorReportingRunner (line 24) | public ErrorReportingRunner(Throwable cause, Class<?>... testClasses) {
method getDescription (line 37) | @Override
method run (line 50) | @Override
method getClassNames (line 57) | private String getClassNames(Class<?>... testClasses) {
method getCauses (line 68) | @SuppressWarnings("deprecation")
method describeCause (line 86) | private Description describeCause() {
method runCause (line 90) | private void runCause(Throwable child, RunNotifier notifier) {
FILE: src/main/java/org/junit/internal/runners/FailedBefore.java
class FailedBefore (line 10) | @Deprecated
FILE: src/main/java/org/junit/internal/runners/InitializationError.java
class InitializationError (line 11) | @Deprecated
method InitializationError (line 22) | public InitializationError(List<Throwable> errors) {
method InitializationError (line 26) | public InitializationError(Throwable... errors) {
method InitializationError (line 30) | public InitializationError(String string) {
method getCauses (line 34) | public List<Throwable> getCauses() {
FILE: src/main/java/org/junit/internal/runners/JUnit38ClassRunner.java
class JUnit38ClassRunner (line 27) | public class JUnit38ClassRunner extends Runner implements Filterable, Or...
class OldTestClassAdaptingListener (line 28) | private static final class OldTestClassAdaptingListener implements
method OldTestClassAdaptingListener (line 32) | private OldTestClassAdaptingListener(RunNotifier notifier) {
method endTest (line 36) | public void endTest(Test test) {
method startTest (line 40) | public void startTest(Test test) {
method addError (line 45) | public void addError(Test test, Throwable e) {
method asDescription (line 50) | private Description asDescription(Test test) {
method getEffectiveClass (line 58) | private Class<? extends Test> getEffectiveClass(Test test) {
method getName (line 62) | private String getName(Test test) {
method addFailure (line 70) | public void addFailure(Test test, AssertionFailedError t) {
method JUnit38ClassRunner (line 77) | public JUnit38ClassRunner(Class<?> klass) {
method JUnit38ClassRunner (line 81) | public JUnit38ClassRunner(Test test) {
method run (line 86) | @Override
method createAdaptingListener (line 93) | public TestListener createAdaptingListener(final RunNotifier notifier) {
method getDescription (line 97) | @Override
method makeDescription (line 102) | private static Description makeDescription(Test test) {
method getAnnotations (line 133) | private static Annotation[] getAnnotations(TestCase test) {
method createSuiteDescription (line 143) | private static String createSuiteDescription(TestSuite ts) {
method filter (line 149) | public void filter(Filter filter) throws NoTestsRemainException {
method sort (line 170) | public void sort(Sorter sorter) {
method order (line 182) | public void order(Orderer orderer) throws InvalidOrderingException {
method setTest (line 189) | private void setTest(Test test) {
method getTest (line 193) | private Test getTest() {
FILE: src/main/java/org/junit/internal/runners/JUnit4ClassRunner.java
class JUnit4ClassRunner (line 27) | @Deprecated
method JUnit4ClassRunner (line 32) | public JUnit4ClassRunner(Class<?> klass) throws InitializationError {
method getTestMethods (line 38) | protected List<Method> getTestMethods() {
method validate (line 42) | protected void validate() throws InitializationError {
method run (line 48) | @Override
method runMethods (line 57) | protected void runMethods(final RunNotifier notifier) {
method getDescription (line 63) | @Override
method classAnnotations (line 73) | protected Annotation[] classAnnotations() {
method getName (line 77) | protected String getName() {
method createTest (line 81) | protected Object createTest() throws Exception {
method invokeTestMethod (line 85) | protected void invokeTestMethod(Method method, RunNotifier notifier) {
method testAborted (line 101) | private void testAborted(RunNotifier notifier, Description description,
method wrapMethod (line 108) | protected TestMethod wrapMethod(Method method) {
method testName (line 112) | protected String testName(Method method) {
method methodDescription (line 116) | protected Description methodDescription(Method method) {
method testAnnotations (line 120) | protected Annotation[] testAnnotations(Method method) {
method filter (line 124) | public void filter(Filter filter) throws NoTestsRemainException {
method sort (line 136) | public void sort(final Sorter sorter) {
method getTestClass (line 144) | protected TestClass getTestClass() {
FILE: src/main/java/org/junit/internal/runners/MethodRoadie.java
class MethodRoadie (line 25) | @Deprecated
method MethodRoadie (line 32) | public MethodRoadie(Object test, TestMethod method, RunNotifier notifi...
method run (line 39) | public void run() {
method runWithTimeout (line 57) | private void runWithTimeout(final long timeout) {
method runTest (line 86) | public void runTest() {
method runBeforesThenTestThenAfters (line 94) | public void runBeforesThenTestThenAfters(Runnable test) {
method runTestMethod (line 106) | protected void runTestMethod() {
method runBefores (line 128) | private void runBefores() throws FailedBefore {
method runAfters (line 146) | private void runAfters() {
method addFailure (line 159) | protected void addFailure(Throwable e) {
FILE: src/main/java/org/junit/internal/runners/MethodValidator.java
class MethodValidator (line 21) | @Deprecated
method MethodValidator (line 28) | public MethodValidator(TestClass testClass) {
method validateInstanceMethods (line 32) | public void validateInstanceMethods() {
method validateStaticMethods (line 43) | public void validateStaticMethods() {
method validateMethodsForDefaultRunner (line 48) | public List<Throwable> validateMethodsForDefaultRunner() {
method assertValid (line 55) | public void assertValid() throws InitializationError {
method validateNoArgConstructor (line 61) | public void validateNoArgConstructor() {
method validateTestMethods (line 69) | private void validateTestMethods(Class<? extends Annotation> annotation,
FILE: src/main/java/org/junit/internal/runners/SuiteMethod.java
class SuiteMethod (line 22) | public class SuiteMethod extends JUnit38ClassRunner {
method SuiteMethod (line 23) | public SuiteMethod(Class<?> klass) throws Throwable {
method testFromSuiteMethod (line 27) | public static Test testFromSuiteMethod(Class<?> klass) throws Throwable {
FILE: src/main/java/org/junit/internal/runners/TestClass.java
class TestClass (line 22) | @Deprecated
method TestClass (line 26) | public TestClass(Class<?> klass) {
method getTestMethods (line 30) | public List<Method> getTestMethods() {
method getBefores (line 34) | List<Method> getBefores() {
method getAfters (line 38) | List<Method> getAfters() {
method getAnnotatedMethods (line 42) | public List<Method> getAnnotatedMethods(Class<? extends Annotation> an...
method runsTopToBottom (line 59) | private boolean runsTopToBottom(Class<? extends Annotation> annotation) {
method isShadowed (line 63) | private boolean isShadowed(Method method, List<Method> results) {
method isShadowed (line 72) | private boolean isShadowed(Method current, Method previous) {
method getSuperClasses (line 87) | private List<Class<?>> getSuperClasses(Class<?> testClass) {
method getConstructor (line 97) | public Constructor<?> getConstructor() throws SecurityException, NoSuc...
method getJavaClass (line 101) | public Class<?> getJavaClass() {
method getName (line 105) | public String getName() {
FILE: src/main/java/org/junit/internal/runners/TestMethod.java
class TestMethod (line 19) | @Deprecated
method TestMethod (line 24) | public TestMethod(Method method, TestClass testClass) {
method isIgnored (line 29) | public boolean isIgnored() {
method getTimeout (line 33) | public long getTimeout() {
method getExpectedException (line 42) | protected Class<? extends Throwable> getExpectedException() {
method isUnexpected (line 51) | boolean isUnexpected(Throwable exception) {
method expectsException (line 55) | boolean expectsException() {
method getBefores (line 59) | List<Method> getBefores() {
method getAfters (line 63) | List<Method> getAfters() {
method invoke (line 67) | public void invoke(Object test) throws IllegalArgumentException, Illeg...
FILE: src/main/java/org/junit/internal/runners/model/EachTestNotifier.java
class EachTestNotifier (line 9) | public class EachTestNotifier {
method EachTestNotifier (line 14) | public EachTestNotifier(RunNotifier notifier, Description description) {
method addFailure (line 19) | public void addFailure(Throwable targetException) {
method addMultipleFailureException (line 27) | private void addMultipleFailureException(MultipleFailureException mfe) {
method addFailedAssumption (line 33) | public void addFailedAssumption(AssumptionViolatedException e) {
method fireTestFinished (line 37) | public void fireTestFinished() {
method fireTestStarted (line 41) | public void fireTestStarted() {
method fireTestIgnored (line 45) | public void fireTestIgnored() {
method fireTestSuiteStarted (line 56) | public void fireTestSuiteStarted() {
method fireTestSuiteFinished (line 68) | public void fireTestSuiteFinished() {
FILE: src/main/java/org/junit/internal/runners/model/MultipleFailureException.java
class MultipleFailureException (line 5) | @Deprecated
method MultipleFailureException (line 9) | public MultipleFailureException(List<Throwable> errors) {
FILE: src/main/java/org/junit/internal/runners/model/ReflectiveCallable.java
class ReflectiveCallable (line 9) | public abstract class ReflectiveCallable {
method run (line 10) | public Object run() throws Throwable {
method runReflectiveCall (line 18) | protected abstract Object runReflectiveCall() throws Throwable;
FILE: src/main/java/org/junit/internal/runners/rules/RuleMemberValidator.java
class RuleMemberValidator (line 28) | public class RuleMemberValidator {
method RuleMemberValidator (line 75) | RuleMemberValidator(Builder builder) {
method validate (line 88) | public void validate(TestClass target, List<Throwable> errors) {
method validateMember (line 97) | private void validateMember(FrameworkMember<?> member, List<Throwable>...
method classRuleValidatorBuilder (line 103) | private static Builder classRuleValidatorBuilder() {
method testRuleValidatorBuilder (line 107) | private static Builder testRuleValidatorBuilder() {
class Builder (line 111) | private static class Builder {
method Builder (line 116) | private Builder(Class<? extends Annotation> annotation) {
method forMethods (line 122) | Builder forMethods() {
method withValidator (line 127) | Builder withValidator(RuleValidator validator) {
method build (line 132) | RuleMemberValidator build() {
method isRuleType (line 137) | private static boolean isRuleType(FrameworkMember<?> member) {
method isTestRule (line 141) | private static boolean isTestRule(FrameworkMember<?> member) {
method isMethodRule (line 145) | private static boolean isMethodRule(FrameworkMember<?> member) {
type RuleValidator (line 153) | interface RuleValidator {
method validate (line 160) | void validate(FrameworkMember<?> member, Class<? extends Annotation>...
class MemberMustBeNonStaticOrAlsoClassRule (line 166) | private static final class MemberMustBeNonStaticOrAlsoClassRule implem...
method validate (line 167) | public void validate(FrameworkMember<?> member, Class<? extends Anno...
class MemberMustBeStatic (line 191) | private static final class MemberMustBeStatic implements RuleValidator {
method validate (line 192) | public void validate(FrameworkMember<?> member, Class<? extends Anno...
class DeclaringClassMustBePublic (line 203) | private static final class DeclaringClassMustBePublic implements RuleV...
method validate (line 204) | public void validate(FrameworkMember<?> member, Class<? extends Anno...
method isDeclaringClassPublic (line 211) | private boolean isDeclaringClassPublic(FrameworkMember<?> member) {
class MemberMustBePublic (line 219) | private static final class MemberMustBePublic implements RuleValidator {
method validate (line 220) | public void validate(FrameworkMember<?> member, Class<? extends Anno...
class FieldMustBeARule (line 231) | private static final class FieldMustBeARule implements RuleValidator {
method validate (line 232) | public void validate(FrameworkMember<?> member, Class<? extends Anno...
class MethodMustBeARule (line 244) | private static final class MethodMustBeARule implements RuleValidator {
method validate (line 245) | public void validate(FrameworkMember<?> member, Class<? extends Anno...
class MethodMustBeATestRule (line 256) | private static final class MethodMustBeATestRule implements RuleValida...
method validate (line 257) | public void validate(FrameworkMember<?> member,
class FieldMustBeATestRule (line 269) | private static final class FieldMustBeATestRule implements RuleValidat...
method validate (line 271) | public void validate(FrameworkMember<?> member,
FILE: src/main/java/org/junit/internal/runners/rules/ValidationError.java
class ValidationError (line 7) | class ValidationError extends Exception {
method ValidationError (line 11) | public ValidationError(FrameworkMember<?> member, Class<? extends Anno...
FILE: src/main/java/org/junit/internal/runners/statements/ExpectException.java
class ExpectException (line 6) | public class ExpectException extends Statement {
method ExpectException (line 10) | public ExpectException(Statement next, Class<? extends Throwable> expe...
method evaluate (line 15) | @Override
FILE: src/main/java/org/junit/internal/runners/statements/Fail.java
class Fail (line 5) | public class Fail extends Statement {
method Fail (line 8) | public Fail(Throwable e) {
method evaluate (line 12) | @Override
FILE: src/main/java/org/junit/internal/runners/statements/FailOnTimeout.java
class FailOnTimeout (line 19) | public class FailOnTimeout extends Statement {
method builder (line 30) | public static Builder builder() {
method FailOnTimeout (line 41) | @Deprecated
method FailOnTimeout (line 46) | private FailOnTimeout(Builder builder, Statement statement) {
class Builder (line 58) | public static class Builder {
method Builder (line 63) | private Builder() {
method withTimeout (line 79) | public Builder withTimeout(long timeout, TimeUnit unit) {
method withLookingForStuckThread (line 100) | public Builder withLookingForStuckThread(boolean enable) {
method build (line 111) | public FailOnTimeout build(Statement statement) {
method evaluate (line 119) | @Override
method threadGroupForNewThread (line 134) | private ThreadGroup threadGroupForNewThread() {
method getResult (line 164) | private Throwable getResult(FutureTask<Throwable> task, Thread thread) {
method createTimeoutException (line 181) | private Exception createTimeoutException(Thread thread) {
method getStackTrace (line 207) | private StackTraceElement[] getStackTrace(Thread thread) {
method getStuckThread (line 225) | private Thread getStuckThread(Thread mainThread) {
method getThreadsInGroup (line 258) | private List<Thread> getThreadsInGroup(ThreadGroup group) {
method cpuTime (line 282) | private long cpuTime(Thread thr) {
class CallableStatement (line 293) | private class CallableStatement implements Callable<Throwable> {
method call (line 296) | public Throwable call() throws Exception {
method awaitStarted (line 308) | public void awaitStarted() throws InterruptedException {
FILE: src/main/java/org/junit/internal/runners/statements/InvokeMethod.java
class InvokeMethod (line 6) | public class InvokeMethod extends Statement {
method InvokeMethod (line 10) | public InvokeMethod(FrameworkMethod testMethod, Object target) {
method evaluate (line 15) | @Override
FILE: src/main/java/org/junit/internal/runners/statements/RunAfters.java
class RunAfters (line 10) | public class RunAfters extends Statement {
method RunAfters (line 17) | public RunAfters(Statement next, List<FrameworkMethod> afters, Object ...
method evaluate (line 23) | @Override
method invokeMethod (line 45) | protected void invokeMethod(FrameworkMethod method) throws Throwable {
FILE: src/main/java/org/junit/internal/runners/statements/RunBefores.java
class RunBefores (line 8) | public class RunBefores extends Statement {
method RunBefores (line 15) | public RunBefores(Statement next, List<FrameworkMethod> befores, Objec...
method evaluate (line 21) | @Override
method invokeMethod (line 32) | protected void invokeMethod(FrameworkMethod method) throws Throwable {
FILE: src/main/java/org/junit/matchers/JUnitMatchers.java
class JUnitMatchers (line 15) | public class JUnitMatchers {
method hasItem (line 20) | @Deprecated
method hasItem (line 29) | @Deprecated
method hasItems (line 38) | @Deprecated
method hasItems (line 49) | @Deprecated
method everyItem (line 58) | @Deprecated
method containsString (line 67) | @Deprecated
method both (line 80) | @Deprecated
method either (line 93) | @Deprecated
method isThrowable (line 102) | public static <T extends Throwable> Matcher<T> isThrowable(Matcher<T> ...
method isException (line 110) | public static <T extends Exception> Matcher<T> isException(Matcher<T> ...
FILE: src/main/java/org/junit/rules/DisableOnDebug.java
class DisableOnDebug (line 46) | public class DisableOnDebug implements TestRule {
method DisableOnDebug (line 56) | public DisableOnDebug(TestRule rule) {
method DisableOnDebug (line 68) | DisableOnDebug(TestRule rule, List<String> inputArguments) {
method apply (line 76) | public Statement apply(Statement base, Description description) {
method isDebugging (line 104) | private static boolean isDebugging(List<String> arguments) {
method isDebugging (line 121) | public boolean isDebugging() {
FILE: src/main/java/org/junit/rules/ErrorCollector.java
class ErrorCollector (line 37) | public class ErrorCollector extends Verifier {
method verify (line 40) | @Override
method addError (line 48) | public void addError(Throwable error) {
method checkThat (line 65) | public <T> void checkThat(final T value, final Matcher<T> matcher) {
method checkThat (line 74) | public <T> void checkThat(final String reason, final T value, final Ma...
method checkSucceeds (line 88) | public <T> T checkSucceeds(Callable<T> callable) {
method checkThrows (line 112) | public void checkThrows(Class<? extends Throwable> expectedThrowable, ...
FILE: src/main/java/org/junit/rules/ExpectedException.java
class ExpectedException (line 111) | public class ExpectedException implements TestRule {
method none (line 121) | @Deprecated
method ExpectedException (line 130) | private ExpectedException() {
method handleAssertionErrors (line 138) | @Deprecated
method handleAssumptionViolatedExceptions (line 148) | @Deprecated
method reportMissingExceptionWithMessage (line 163) | public ExpectedException reportMissingExceptionWithMessage(String mess...
method apply (line 168) | public Statement apply(Statement base,
method expect (line 183) | public void expect(Matcher<?> matcher) {
method expect (line 196) | public void expect(Class<? extends Throwable> type) {
method expectMessage (line 209) | public void expectMessage(String substring) {
method expectMessage (line 222) | public void expectMessage(Matcher<String> matcher) {
method expectCause (line 236) | public void expectCause(Matcher<?> expectedCause) {
method isAnyExceptionExpected (line 244) | public final boolean isAnyExceptionExpected() {
class ExpectedExceptionStatement (line 248) | private class ExpectedExceptionStatement extends Statement {
method ExpectedExceptionStatement (line 251) | public ExpectedExceptionStatement(Statement base) {
method evaluate (line 255) | @Override
method handleException (line 269) | private void handleException(Throwable e) throws Throwable {
method failDueToMissingException (line 277) | private void failDueToMissingException() throws AssertionError {
method missingExceptionMessage (line 281) | private String missingExceptionMessage() {
FILE: src/main/java/org/junit/rules/ExpectedExceptionMatcherBuilder.java
class ExpectedExceptionMatcherBuilder (line 14) | class ExpectedExceptionMatcherBuilder {
method add (line 18) | void add(Matcher<?> matcher) {
method expectsThrowable (line 22) | boolean expectsThrowable() {
method build (line 26) | Matcher<Throwable> build() {
method allOfTheMatchers (line 30) | private Matcher<Throwable> allOfTheMatchers() {
method castedMatchers (line 37) | @SuppressWarnings({"unchecked", "rawtypes"})
method cast (line 42) | @SuppressWarnings("unchecked")
FILE: src/main/java/org/junit/rules/ExternalResource.java
class ExternalResource (line 41) | public abstract class ExternalResource implements TestRule {
method apply (line 42) | public Statement apply(Statement base, Description description) {
method statement (line 46) | private Statement statement(final Statement base) {
method before (line 74) | protected void before() throws Throwable {
method after (line 81) | protected void after() {
FILE: src/main/java/org/junit/rules/MethodRule.java
type MethodRule (line 20) | public interface MethodRule {
method apply (line 31) | Statement apply(Statement base, FrameworkMethod method, Object target);
FILE: src/main/java/org/junit/rules/RuleChain.java
class RuleChain (line 58) | public class RuleChain implements TestRule {
method emptyRuleChain (line 70) | public static RuleChain emptyRuleChain() {
method outerRule (line 81) | public static RuleChain outerRule(TestRule outerRule) {
method RuleChain (line 85) | private RuleChain(List<TestRule> rules) {
method around (line 97) | public RuleChain around(TestRule enclosedRule) {
method apply (line 110) | public Statement apply(Statement base, Description description) {
FILE: src/main/java/org/junit/rules/RunRules.java
class RunRules (line 11) | public class RunRules extends Statement {
method RunRules (line 14) | public RunRules(Statement base, Iterable<TestRule> rules, Description ...
method evaluate (line 18) | @Override
method applyAll (line 23) | private static Statement applyAll(Statement result, Iterable<TestRule>...
FILE: src/main/java/org/junit/rules/Stopwatch.java
class Stopwatch (line 79) | public class Stopwatch implements TestRule {
method Stopwatch (line 84) | public Stopwatch() {
method Stopwatch (line 88) | Stopwatch(Clock clock) {
method runtime (line 98) | public long runtime(TimeUnit unit) {
method succeeded (line 105) | protected void succeeded(long nanos, Description description) {
method failed (line 111) | protected void failed(long nanos, Throwable e, Description description) {
method skipped (line 117) | protected void skipped(long nanos, AssumptionViolatedException e, Desc...
method finished (line 123) | protected void finished(long nanos, Description description) {
method getNanos (line 126) | private long getNanos() {
method starting (line 138) | private void starting() {
method stopping (line 143) | private void stopping() {
method apply (line 147) | public final Statement apply(Statement base, Description description) {
class InternalWatcher (line 151) | private class InternalWatcher extends TestWatcher {
method starting (line 153) | @Override protected void starting(Description description) {
method finished (line 157) | @Override protected void finished(Description description) {
method succeeded (line 161) | @Override protected void succeeded(Description description) {
method failed (line 166) | @Override protected void failed(Throwable e, Description description) {
method skipped (line 171) | @Override protected void skipped(AssumptionViolatedException e, Desc...
class Clock (line 177) | static class Clock {
method nanoTime (line 179) | public long nanoTime() {
FILE: src/main/java/org/junit/rules/TemporaryFolder.java
class TemporaryFolder (line 45) | public class TemporaryFolder extends ExternalResource {
method TemporaryFolder (line 57) | public TemporaryFolder() {
method TemporaryFolder (line 68) | public TemporaryFolder(File parentFolder) {
method TemporaryFolder (line 77) | protected TemporaryFolder(Builder builder) {
method builder (line 87) | public static Builder builder() {
class Builder (line 96) | public static class Builder {
method Builder (line 100) | protected Builder() {}
method parentFolder (line 109) | public Builder parentFolder(File parentFolder) {
method assureDeletion (line 121) | public Builder assureDeletion() {
method build (line 129) | public TemporaryFolder build() {
method before (line 134) | @Override
method after (line 139) | @Override
method create (line 149) | public void create() throws IOException {
method newFile (line 156) | public File newFile(String fileName) throws IOException {
method newFile (line 168) | public File newFile() throws IOException {
method newFolder (line 176) | public File newFolder(String path) throws IOException {
method newFolder (line 187) | public File newFolder(String... paths) throws IOException {
method newFolder (line 231) | public File newFolder() throws IOException {
method createTemporaryFolderIn (line 235) | private static File createTemporaryFolderIn(File parentFolder) throws ...
method createTemporaryFolderWithNioApi (line 257) | private static File createTemporaryFolderWithNioApi(File parentFolder)...
method createTemporaryFolderWithFileApi (line 273) | private static File createTemporaryFolderWithFileApi(File parentFolder...
method getRoot (line 297) | public File getRoot() {
method delete (line 312) | public void delete() {
method tryDelete (line 327) | private boolean tryDelete() {
method recursiveDelete (line 335) | private boolean recursiveDelete(File file) {
FILE: src/main/java/org/junit/rules/TestName.java
class TestName (line 27) | public class TestName extends TestWatcher {
method starting (line 30) | @Override
method getMethodName (line 38) | public String getMethodName() {
FILE: src/main/java/org/junit/rules/TestRule.java
type TestRule (line 45) | public interface TestRule {
method apply (line 55) | Statement apply(Statement base, Description description);
FILE: src/main/java/org/junit/rules/TestWatcher.java
class TestWatcher (line 52) | public abstract class TestWatcher implements TestRule {
method apply (line 53) | public Statement apply(final Statement base, final Description descrip...
method succeededQuietly (line 78) | private void succeededQuietly(Description description,
method failedQuietly (line 87) | private void failedQuietly(Throwable e, Description description,
method skippedQuietly (line 96) | private void skippedQuietly(
method startingQuietly (line 110) | private void startingQuietly(Description description,
method finishedQuietly (line 119) | private void finishedQuietly(Description description,
method succeeded (line 131) | protected void succeeded(Description description) {
method failed (line 137) | protected void failed(Throwable e, Description description) {
method skipped (line 143) | protected void skipped(AssumptionViolatedException e, Description desc...
method skipped (line 154) | @Deprecated
method starting (line 162) | protected void starting(Description description) {
method finished (line 168) | protected void finished(Description description) {
FILE: src/main/java/org/junit/rules/TestWatchman.java
class TestWatchman (line 44) | @Deprecated
method apply (line 46) | public Statement apply(final Statement base, final FrameworkMethod met...
method succeeded (line 70) | public void succeeded(FrameworkMethod method) {
method failed (line 76) | public void failed(Throwable e, FrameworkMethod method) {
method starting (line 82) | public void starting(FrameworkMethod method) {
method finished (line 89) | public void finished(FrameworkMethod method) {
FILE: src/main/java/org/junit/rules/Timeout.java
class Timeout (line 40) | public class Timeout implements TestRule {
method builder (line 50) | public static Builder builder() {
method Timeout (line 66) | @Deprecated
method Timeout (line 80) | public Timeout(long timeout, TimeUnit timeUnit) {
method Timeout (line 92) | protected Timeout(Builder builder) {
method millis (line 104) | public static Timeout millis(long millis) {
method seconds (line 114) | public static Timeout seconds(long seconds) {
method getTimeout (line 123) | protected final long getTimeout(TimeUnit unit) {
method getLookingForStuckThread (line 133) | protected final boolean getLookingForStuckThread() {
method createFailOnTimeoutStatement (line 145) | protected Statement createFailOnTimeoutStatement(
method apply (line 153) | public Statement apply(Statement base, Description description) {
class Builder (line 170) | public static class Builder {
method Builder (line 175) | protected Builder() {
method withTimeout (line 193) | public Builder withTimeout(long timeout, TimeUnit unit) {
method getTimeout (line 199) | protected long getTimeout() {
method getTimeUnit (line 203) | protected TimeUnit getTimeUnit() {
method withLookingForStuckThread (line 216) | public Builder withLookingForStuckThread(boolean enable) {
method getLookingForStuckThread (line 221) | protected boolean getLookingForStuckThread() {
method build (line 229) | public Timeout build() {
FILE: src/main/java/org/junit/rules/Verifier.java
class Verifier (line 30) | public abstract class Verifier implements TestRule {
method apply (line 31) | public Statement apply(final Statement base, Description description) {
method verify (line 45) | protected void verify() throws Throwable {
FILE: src/main/java/org/junit/runner/Computer.java
class Computer (line 14) | public class Computer {
method serial (line 18) | public static Computer serial() {
method getSuite (line 26) | public Runner getSuite(final RunnerBuilder builder,
method getRunner (line 49) | protected Runner getRunner(RunnerBuilder builder, Class<?> testClass) ...
FILE: src/main/java/org/junit/runner/Describable.java
type Describable (line 9) | public interface Describable {
method getDescription (line 13) | Description getDescription();
FILE: src/main/java/org/junit/runner/Description.java
class Description (line 30) | public class Description implements Serializable {
method createSuiteDescription (line 44) | public static Description createSuiteDescription(String name, Annotati...
method createSuiteDescription (line 57) | public static Description createSuiteDescription(String name, Serializ...
method createTestDescription (line 72) | public static Description createTestDescription(String className, Stri...
method createTestDescription (line 85) | public static Description createTestDescription(Class<?> clazz, String...
method createTestDescription (line 98) | public static Description createTestDescription(Class<?> clazz, String...
method createTestDescription (line 109) | public static Description createTestDescription(String className, Stri...
method formatDisplayName (line 113) | private static String formatDisplayName(String name, String className) {
method createSuiteDescription (line 123) | public static Description createSuiteDescription(Class<?> testClass) {
method createSuiteDescription (line 134) | public static Description createSuiteDescription(Class<?> testClass, A...
method Description (line 161) | private Description(Class<?> clazz, String displayName, Annotation... ...
method Description (line 165) | private Description(Class<?> testClass, String displayName, Serializab...
method getDisplayName (line 183) | public String getDisplayName() {
method addChild (line 192) | public void addChild(Description description) {
method getChildren (line 200) | public ArrayList<Description> getChildren() {
method isSuite (line 207) | public boolean isSuite() {
method isTest (line 214) | public boolean isTest() {
method testCount (line 221) | public int testCount() {
method hashCode (line 232) | @Override
method equals (line 237) | @Override
method toString (line 246) | @Override
method isEmpty (line 254) | public boolean isEmpty() {
method childlessCopy (line 262) | public Description childlessCopy() {
method getAnnotation (line 270) | public <T extends Annotation> T getAnnotation(Class<T> annotationType) {
method getAnnotations (line 282) | public Collection<Annotation> getAnnotations() {
method getTestClass (line 290) | public Class<?> getTestClass() {
method getClassName (line 310) | public String getClassName() {
method getMethodName (line 318) | public String getMethodName() {
method methodAndClassNamePatternGroupOrDefault (line 322) | private String methodAndClassNamePatternGroupOrDefault(int group,
FILE: src/main/java/org/junit/runner/FilterFactories.java
class FilterFactories (line 10) | class FilterFactories {
method createFilterFromFilterSpec (line 20) | public static Filter createFilterFromFilterSpec(Request request, Strin...
method createFilter (line 40) | public static Filter createFilter(String filterFactoryFqcn, FilterFact...
method createFilter (line 54) | public static Filter createFilter(Class<? extends FilterFactory> filte...
method createFilterFactory (line 61) | static FilterFactory createFilterFactory(String filterFactoryFqcn) thr...
method createFilterFactory (line 73) | static FilterFactory createFilterFactory(Class<? extends FilterFactory...
FILE: src/main/java/org/junit/runner/FilterFactory.java
type FilterFactory (line 8) | public interface FilterFactory {
method createFilter (line 14) | Filter createFilter(FilterFactoryParams params) throws FilterNotCreate...
class FilterNotCreatedException (line 19) | @SuppressWarnings("serial")
method FilterNotCreatedException (line 21) | public FilterNotCreatedException(Exception exception) {
FILE: src/main/java/org/junit/runner/FilterFactoryParams.java
class FilterFactoryParams (line 3) | public final class FilterFactoryParams {
method FilterFactoryParams (line 7) | public FilterFactoryParams(Description topLevelDescription, String arg...
method getArgs (line 16) | public String getArgs() {
method getTopLevelDescription (line 20) | public Description getTopLevelDescription() {
FILE: src/main/java/org/junit/runner/JUnitCommandLineParseResult.java
class JUnitCommandLineParseResult (line 12) | class JUnitCommandLineParseResult {
method JUnitCommandLineParseResult (line 20) | JUnitCommandLineParseResult() {}
method getFilterSpecs (line 25) | public List<String> getFilterSpecs() {
method getClasses (line 32) | public List<Class<?>> getClasses() {
method parse (line 41) | public static JUnitCommandLineParseResult parse(String[] args) {
method parseArgs (line 49) | private void parseArgs(String[] args) {
method parseOptions (line 53) | String[] parseOptions(String... args) {
method copyArray (line 87) | private String[] copyArray(String[] args, int from, int to) {
method parseParameters (line 95) | void parseParameters(String[] args) {
method errorReport (line 105) | private Request errorReport(Throwable cause) {
method createRequest (line 114) | public Request createRequest(Computer computer) {
method applyFilterSpecs (line 124) | private Request applyFilterSpecs(Request request) {
class CommandLineParserError (line 140) | public static class CommandLineParserError extends Exception {
method CommandLineParserError (line 143) | public CommandLineParserError(String message) {
FILE: src/main/java/org/junit/runner/JUnitCore.java
class JUnitCore (line 24) | public class JUnitCore {
method main (line 35) | public static void main(String... args) {
method runMain (line 39) | static int runMain(String[] args) {
method runClasses (line 52) | public static Result runClasses(Class<?>... classes) {
method runClasses (line 65) | public static Result runClasses(Computer computer, Class<?>... classes) {
method runMain (line 73) | Result runMain(JUnitSystem system, String... args) {
method getVersion (line 87) | public String getVersion() {
method run (line 97) | public Result run(Class<?>... classes) {
method run (line 108) | public Result run(Computer computer, Class<?>... classes) {
method run (line 118) | public Result run(Request request) {
method run (line 128) | public Result run(junit.framework.Test test) {
method run (line 135) | public Result run(Runner runner) {
method addListener (line 155) | public void addListener(RunListener listener) {
method removeListener (line 164) | public void removeListener(RunListener listener) {
method defaultComputer (line 168) | static Computer defaultComputer() {
FILE: src/main/java/org/junit/runner/OrderWithValidator.java
class OrderWithValidator (line 19) | public final class OrderWithValidator extends AnnotationValidator {
method validateAnnotatedClass (line 30) | @Override
FILE: src/main/java/org/junit/runner/Request.java
class Request (line 29) | public abstract class Request {
method method (line 39) | public static Request method(Class<?> clazz, String methodName) {
method aClass (line 51) | public static Request aClass(Class<?> clazz) {
method classWithoutSuiteMethod (line 62) | public static Request classWithoutSuiteMethod(Class<?> clazz) {
method classes (line 74) | public static Request classes(Computer computer, Class<?>... classes) {
method classes (line 91) | public static Request classes(Class<?>... classes) {
method errorReport (line 100) | public static Request errorReport(Class<?> klass, Throwable cause) {
method runner (line 108) | public static Request runner(final Runner runner) {
method getRunner (line 122) | public abstract Runner getRunner();
method filterWith (line 131) | public Request filterWith(Filter filter) {
method filterWith (line 145) | public Request filterWith(Description desiredDescription) {
method sortWith (line 171) | public Request sortWith(Comparator<Description> comparator) {
method orderWith (line 199) | public Request orderWith(Ordering ordering) {
FILE: src/main/java/org/junit/runner/Result.java
class Result (line 25) | public class Result implements Serializable {
method Result (line 39) | public Result() {
method Result (line 48) | private Result(SerializedForm serializedForm) {
method getRunCount (line 60) | public int getRunCount() {
method getFailureCount (line 67) | public int getFailureCount() {
method getRunTime (line 74) | public long getRunTime() {
method getFailures (line 81) | public List<Failure> getFailures() {
method getIgnoreCount (line 88) | public int getIgnoreCount() {
method getAssumptionFailureCount (line 98) | public int getAssumptionFailureCount() {
method wasSuccessful (line 109) | public boolean wasSuccessful() {
method writeObject (line 113) | private void writeObject(ObjectOutputStream s) throws IOException {
method readObject (line 118) | private void readObject(ObjectInputStream s)
method readResolve (line 123) | private Object readResolve() {
class Listener (line 127) | @RunListener.ThreadSafe
method testRunStarted (line 129) | @Override
method testRunFinished (line 134) | @Override
method testFinished (line 140) | @Override
method testFailure (line 145) | @Override
method testIgnored (line 150) | @Override
method testAssumptionFailure (line 155) | @Override
method createListener (line 164) | public RunListener createListener() {
class SerializedForm (line 172) | private static class SerializedForm implements Serializable {
method SerializedForm (line 181) | public SerializedForm(Result result) {
method SerializedForm (line 190) | @SuppressWarnings("unchecked")
method serialize (line 200) | public void serialize(ObjectOutputStream s) throws IOException {
method deserialize (line 211) | public static SerializedForm deserialize(ObjectInputStream s)
FILE: src/main/java/org/junit/runner/Runner.java
class Runner (line 22) | public abstract class Runner implements Describable {
method getDescription (line 27) | public abstract Description getDescription();
method run (line 35) | public abstract void run(RunNotifier notifier);
method testCount (line 40) | public int testCount() {
FILE: src/main/java/org/junit/runner/manipulation/Alphanumeric.java
class Alphanumeric (line 12) | public final class Alphanumeric extends Sorter implements Ordering.Facto...
method Alphanumeric (line 14) | public Alphanumeric() {
method create (line 18) | public Ordering create(Context context) {
method compare (line 23) | public int compare(Description o1, Description o2) {
FILE: src/main/java/org/junit/runner/manipulation/Filter.java
class Filter (line 17) | public abstract class Filter {
method shouldRun (line 22) | @Override
method describe (line 27) | @Override
method apply (line 32) | @Override
method intersect (line 37) | @Override
method matchMethodDescription (line 47) | public static Filter matchMethodDescription(final Description desiredD...
method shouldRun (line 76) | public abstract boolean shouldRun(Description description);
method describe (line 83) | public abstract String describe();
method apply (line 92) | public void apply(Object child) throws NoTestsRemainException {
method intersect (line 104) | public Filter intersect(final Filter second) {
FILE: src/main/java/org/junit/runner/manipulation/Filterable.java
type Filterable (line 9) | public interface Filterable {
method filter (line 17) | void filter(Filter filter) throws NoTestsRemainException;
FILE: src/main/java/org/junit/runner/manipulation/InvalidOrderingException.java
class InvalidOrderingException (line 8) | public class InvalidOrderingException extends Exception {
method InvalidOrderingException (line 11) | public InvalidOrderingException() {
method InvalidOrderingException (line 14) | public InvalidOrderingException(String message) {
method InvalidOrderingException (line 18) | public InvalidOrderingException(String message, Throwable cause) {
FILE: src/main/java/org/junit/runner/manipulation/NoTestsRemainException.java
class NoTestsRemainException (line 8) | public class NoTestsRemainException extends Exception {
FILE: src/main/java/org/junit/runner/manipulation/Orderable.java
type Orderable (line 12) | public interface Orderable extends Sortable {
method order (line 20) | void order(Orderer orderer) throws InvalidOrderingException;
FILE: src/main/java/org/junit/runner/manipulation/Orderer.java
class Orderer (line 16) | public final class Orderer {
method Orderer (line 19) | Orderer(Ordering delegate) {
method order (line 28) | public List<Description> order(Collection<Description> descriptions)
method apply (line 56) | public void apply(Object target) throws InvalidOrderingException {
FILE: src/main/java/org/junit/runner/manipulation/Ordering.java
class Ordering (line 22) | public abstract class Ordering {
method shuffledBy (line 31) | public static Ordering shuffledBy(final Random random) {
method definedBy (line 55) | public static Ordering definedBy(
method definedBy (line 88) | public static Ordering definedBy(
method getClassName (line 101) | private static String getClassName(Class<?> clazz) {
method apply (line 115) | public void apply(Object target) throws InvalidOrderingException {
method validateOrderingIsCorrect (line 131) | boolean validateOrderingIsCorrect() {
method orderItems (line 140) | protected abstract List<Description> orderItems(Collection<Description...
class Context (line 143) | public static class Context {
method getTarget (line 149) | public Description getTarget() {
method Context (line 153) | private Context(Description description) {
type Factory (line 164) | public interface Factory {
method create (line 170) | Ordering create(Context context);
FILE: src/main/java/org/junit/runner/manipulation/Sortable.java
type Sortable (line 11) | public interface Sortable {
method sort (line 18) | void sort(Sorter sorter);
FILE: src/main/java/org/junit/runner/manipulation/Sorter.java
class Sorter (line 18) | public class Sorter extends Ordering implements Comparator<Description> {
method compare (line 23) | public int compare(Description o1, Description o2) {
method Sorter (line 37) | public Sorter(Comparator<Description> comparator) {
method apply (line 46) | @Override
method compare (line 59) | public int compare(Description o1, Description o2) {
method orderItems (line 68) | @Override
method validateOrderingIsCorrect (line 86) | @Override
FILE: src/main/java/org/junit/runner/notification/Failure.java
class Failure (line 17) | public class Failure implements Serializable {
method Failure (line 34) | public Failure(Description description, Throwable thrownException) {
method getTestHeader (line 42) | public String getTestHeader() {
method getDescription (line 49) | public Description getDescription() {
method getException (line 57) | public Throwable getException() {
method toString (line 61) | @Override
method getTrace (line 69) | public String getTrace() {
method getTrimmedTrace (line 78) | public String getTrimmedTrace() {
method getMessage (line 87) | public String getMessage() {
FILE: src/main/java/org/junit/runner/notification/RunListener.java
class RunListener (line 52) | public class RunListener {
method testRunStarted (line 60) | public void testRunStarted(Description description) throws Exception {
method testRunFinished (line 69) | public void testRunFinished(Result result) throws Exception {
method testSuiteStarted (line 86) | public void testSuiteStarted(Description description) throws Exception {
method testSuiteFinished (line 97) | public void testSuiteFinished(Description description) throws Exception {
method testStarted (line 106) | public void testStarted(Description description) throws Exception {
method testFinished (line 114) | public void testFinished(Description description) throws Exception {
method testFailure (line 131) | public void testFailure(Failure failure) throws Exception {
method testAssumptionFailure (line 141) | public void testAssumptionFailure(Failure failure) {
method testIgnored (line 150) | public void testIgnored(Description description) throws Exception {
FILE: src/main/java/org/junit/runner/notification/RunNotifier.java
class RunNotifier (line 21) | public class RunNotifier {
method addListener (line 28) | public void addListener(RunListener listener) {
method removeListener (line 38) | public void removeListener(RunListener listener) {
method wrapIfNotThreadSafe (line 49) | RunListener wrapIfNotThreadSafe(RunListener listener) {
class SafeNotifier (line 55) | private abstract class SafeNotifier {
method SafeNotifier (line 58) | SafeNotifier() {
method SafeNotifier (line 62) | SafeNotifier(List<RunListener> currentListeners) {
method run (line 66) | void run() {
method notifyListener (line 81) | protected abstract void notifyListener(RunListener each) throws Exce...
method fireTestRunStarted (line 87) | public void fireTestRunStarted(final Description description) {
method fireTestRunFinished (line 99) | public void fireTestRunFinished(final Result result) {
method fireTestSuiteStarted (line 117) | public void fireTestSuiteStarted(final Description description) {
method fireTestSuiteFinished (line 134) | public void fireTestSuiteFinished(final Description description) {
method fireTestStarted (line 149) | public void fireTestStarted(final Description description) throws Stop...
method fireTestFailure (line 166) | public void fireTestFailure(Failure failure) {
method fireTestFailures (line 170) | private void fireTestFailures(List<RunListener> listeners,
method fireTestAssumptionFailed (line 191) | public void fireTestAssumptionFailed(final Failure failure) {
method fireTestIgnored (line 205) | public void fireTestIgnored(final Description description) {
method fireTestFinished (line 221) | public void fireTestFinished(final Description description) {
method pleaseStop (line 236) | public void pleaseStop() {
method addFirstListener (line 243) | public void addFirstListener(RunListener listener) {
FILE: src/main/java/org/junit/runner/notification/StoppedByUserException.java
class StoppedByUserException (line 10) | public class StoppedByUserException extends RuntimeException {
FILE: src/main/java/org/junit/runner/notification/SynchronizedRunListener.java
class SynchronizedRunListener (line 22) | @RunListener.ThreadSafe
method SynchronizedRunListener (line 27) | SynchronizedRunListener(RunListener listener, Object monitor) {
method testRunStarted (line 32) | @Override
method testRunFinished (line 39) | @Override
method testSuiteStarted (line 55) | @Override
method testSuiteFinished (line 69) | @Override
method testStarted (line 76) | @Override
method testFinished (line 83) | @Override
method testFailure (line 90) | @Override
method testAssumptionFailure (line 97) | @Override
method testIgnored (line 104) | @Override
method hashCode (line 111) | @Override
method equals (line 116) | @Override
method toString (line 129) | @Override
FILE: src/main/java/org/junit/runners/AllTests.java
class AllTests (line 20) | public class AllTests extends SuiteMethod {
method AllTests (line 24) | public AllTests(Class<?> klass) throws Throwable {
FILE: src/main/java/org/junit/runners/BlockJUnit4ClassRunner.java
class BlockJUnit4ClassRunner (line 63) | public class BlockJUnit4ClassRunner extends ParentRunner<FrameworkMethod> {
method BlockJUnit4ClassRunner (line 73) | public BlockJUnit4ClassRunner(Class<?> testClass) throws Initializatio...
method BlockJUnit4ClassRunner (line 83) | protected BlockJUnit4ClassRunner(TestClass testClass) throws Initializ...
method runChild (line 91) | @Override
method isIgnored (line 111) | @Override
method describeChild (line 116) | @Override
method getChildren (line 129) | @Override
method computeTestMethods (line 143) | protected List<FrameworkMethod> computeTestMethods() {
method collectInitializationErrors (line 147) | @Override
method validatePublicConstructor (line 159) | private void validatePublicConstructor(List<Throwable> errors) {
method validateNoNonStaticInnerClass (line 165) | protected void validateNoNonStaticInnerClass(List<Throwable> errors) {
method validateConstructor (line 178) | protected void validateConstructor(List<Throwable> errors) {
method validateOnlyOneConstructor (line 187) | protected void validateOnlyOneConstructor(List<Throwable> errors) {
method validateZeroArgConstructor (line 198) | protected void validateZeroArgConstructor(List<Throwable> errors) {
method hasOneConstructor (line 207) | private boolean hasOneConstructor() {
method validateInstanceMethods (line 217) | @Deprecated
method validateFields (line 228) | protected void validateFields(List<Throwable> errors) {
method validateMethods (line 232) | private void validateMethods(List<Throwable> errors) {
method validateTestMethods (line 240) | protected void validateTestMethods(List<Throwable> errors) {
method createTest (line 249) | protected Object createTest() throws Exception {
method createTest (line 259) | protected Object createTest(FrameworkMethod method) throws Exception {
method testName (line 267) | protected String testName(FrameworkMethod method) {
method methodBlock (line 303) | protected Statement methodBlock(final FrameworkMethod method) {
method methodInvoker (line 333) | protected Statement methodInvoker(FrameworkMethod method, Object test) {
method possiblyExpectingExceptions (line 343) | protected Statement possiblyExpectingExceptions(FrameworkMethod method,
method withPotentialTimeout (line 356) | @Deprecated
method withBefores (line 373) | protected Statement withBefores(FrameworkMethod method, Object target,
method withAfters (line 388) | protected Statement withAfters(FrameworkMethod method, Object target,
method withRules (line 396) | private Statement withRules(FrameworkMethod method, Object target, Sta...
method rules (line 420) | protected List<MethodRule> rules(Object target) {
method getTestRules (line 434) | protected List<TestRule> getTestRules(Object target) {
method getExpectedException (line 441) | private Class<? extends Throwable> getExpectedException(Test annotatio...
method getTimeout (line 449) | private long getTimeout(Test annotation) {
class RuleCollector (line 459) | private static class RuleCollector<T> implements MemberValueConsumer<T> {
method accept (line 462) | public void accept(FrameworkMember<?> member, T value) {
FILE: src/main/java/org/junit/runners/JUnit4.java
class JUnit4 (line 18) | public final class JUnit4 extends BlockJUnit4ClassRunner {
method JUnit4 (line 22) | public JUnit4(Class<?> klass) throws InitializationError {
FILE: src/main/java/org/junit/runners/MethodSorters.java
type MethodSorters (line 14) | public enum MethodSorters {
method MethodSorters (line 34) | private MethodSorters(Comparator<Method> comparator) {
method getComparator (line 38) | public Comparator<Method> getComparator() {
FILE: src/main/java/org/junit/runners/Parameterized.java
class Parameterized (line 205) | public class Parameterized extends Suite {
method Parameterized (line 302) | public Parameterized(Class<?> klass) throws Throwable {
method Parameterized (line 306) | private Parameterized(Class<?> klass, RunnersFactory runnersFactory) t...
method validateBeforeParamAndAfterParamMethods (line 311) | private void validateBeforeParamAndAfterParamMethods(Integer parameter...
method validatePublicStaticVoidMethods (line 321) | private void validatePublicStaticVoidMethods(
class AssumptionViolationRunner (line 337) | private static class AssumptionViolationRunner extends Runner {
method AssumptionViolationRunner (line 341) | AssumptionViolationRunner(TestClass testClass, String methodName,
method getDescription (line 349) | @Override
method run (line 354) | @Override
class RunnersFactory (line 360) | private static class RunnersFactory {
method RunnersFactory (line 369) | private RunnersFactory(Class<?> klass) throws Throwable {
method createRunners (line 387) | private List<Runner> createRunners() throws Exception {
method getParametersRunnerFactory (line 397) | private ParametersRunnerFactory getParametersRunnerFactory()
method createTestWithNotNormalizedParameters (line 410) | private TestWithParameters createTestWithNotNormalizedParameters(
method normalizeParameters (line 416) | private static Object[] normalizeParameters(Object parametersOrSingl...
method allParameters (line 421) | @SuppressWarnings("unchecked")
method getParametersMethod (line 442) | private static FrameworkMethod getParametersMethod(TestClass testCla...
method createRunnersForParameters (line 455) | private List<Runner> createRunnersForParameters(
method createTestsForParameters (line 472) | private List<TestWithParameters> createTestsForParameters(
method parametersMethodReturnedWrongType (line 484) | private static Exception parametersMethodReturnedWrongType(
method createTestWithParameters (line 494) | private TestWithParameters createTestWithParameters(
FILE: src/main/java/org/junit/runners/ParentRunner.java
class ParentRunner (line 66) | public abstract class ParentRunner<T> extends Runner implements Filterable,
method schedule (line 78) | public void schedule(Runnable childStatement) {
method finished (line 82) | public void finished() {
method ParentRunner (line 90) | protected ParentRunner(Class<?> testClass) throws InitializationError {
method ParentRunner (line 100) | protected ParentRunner(TestClass testClass) throws InitializationError {
method createTestClass (line 109) | @Deprecated
method getChildren (line 121) | protected abstract List<T> getChildren();
method describeChild (line 127) | protected abstract Description describeChild(T child);
method runChild (line 135) | protected abstract void runChild(T child, RunNotifier notifier);
method collectInitializationErrors (line 147) | protected void collectInitializationErrors(List<Throwable> errors) {
method applyValidators (line 154) | private void applyValidators(List<Throwable> errors) {
method validatePublicVoidNoArgMethods (line 173) | protected void validatePublicVoidNoArgMethods(Class<? extends Annotati...
method validateClassRules (line 182) | private void validateClassRules(List<Throwable> errors) {
method classBlock (line 212) | protected Statement classBlock(final RunNotifier notifier) {
method areAllChildrenIgnored (line 223) | private boolean areAllChildrenIgnored() {
method withBeforeClasses (line 237) | protected Statement withBeforeClasses(Statement statement) {
method withAfterClasses (line 251) | protected Statement withAfterClasses(Statement statement) {
method withClassRules (line 267) | private Statement withClassRules(Statement statement) {
method classRules (line 277) | protected List<TestRule> classRules() {
method childrenInvoker (line 289) | protected Statement childrenInvoker(final RunNotifier notifier) {
method withInterruptIsolation (line 301) | protected final Statement withInterruptIsolation(final Statement state...
method isIgnored (line 321) | protected boolean isIgnored(T child) {
method runChildren (line 325) | private void runChildren(final RunNotifier notifier) {
method getName (line 343) | protected String getName() {
method getTestClass (line 354) | public final TestClass getTestClass() {
method runLeaf (line 361) | protected final void runLeaf(Statement statement, Description descript...
method getRunnerAnnotations (line 380) | protected Annotation[] getRunnerAnnotations() {
method getDescription (line 388) | @Override
method run (line 406) | @Override
method filter (line 429) | public void filter(Filter filter) throws NoTestsRemainException {
method sort (line 454) | public void sort(Sorter sorter) {
method order (line 477) | public void order(Orderer orderer) throws InvalidOrderingException {
method shouldNotReorder (line 516) | private boolean shouldNotReorder() {
method validate (line 521) | private void validate() throws InitializationError {
method getFilteredChildren (line 529) | private List<T> getFilteredChildren() {
method shouldRun (line 544) | private boolean shouldRun(Filter filter, T each) {
method comparator (line 548) | private Comparator<? super T> comparator(final Sorter sorter) {
method setScheduler (line 560) | public void setScheduler(RunnerScheduler scheduler) {
class ClassRuleCollector (line 564) | private static class ClassRuleCollector implements MemberValueConsumer...
method accept (line 567) | public void accept(FrameworkMember<?> member, TestRule value) {
method getOrderedRules (line 573) | public List<TestRule> getOrderedRules() {
FILE: src/main/java/org/junit/runners/RuleContainer.java
class RuleContainer (line 21) | class RuleContainer {
method setOrder (line 29) | public void setOrder(Object rule, int order) {
method add (line 33) | public void add(MethodRule methodRule) {
method add (line 37) | public void add(TestRule testRule) {
method compare (line 42) | public int compare(RuleEntry o1, RuleEntry o2) {
method compareInt (line 47) | private int compareInt(int a, int b) {
method getSortedEntries (line 55) | private List<RuleEntry> getSortedEntries() {
method apply (line 71) | public Statement apply(FrameworkMethod method, Description description...
method getSortedRules (line 91) | List<Object> getSortedRules() {
class RuleEntry (line 99) | static class RuleEntry {
method RuleEntry (line 107) | RuleEntry(Object rule, int type, Integer order) {
FILE: src/main/java/org/junit/runners/Suite.java
class Suite (line 27) | public class Suite extends ParentRunner<Runner> {
method emptySuite (line 31) | public static Runner emptySuite() {
method getAnnotatedClasses (line 53) | private static Class<?>[] getAnnotatedClasses(Class<?> klass) throws I...
method Suite (line 69) | public Suite(Class<?> klass, RunnerBuilder builder) throws Initializat...
method Suite (line 80) | public Suite(RunnerBuilder builder, Class<?>[] classes) throws Initial...
method Suite (line 90) | protected Suite(Class<?> klass, Class<?>[] suiteClasses) throws Initia...
method Suite (line 101) | protected Suite(RunnerBuilder builder, Class<?> klass, Class<?>[] suit...
method Suite (line 111) | protected Suite(Class<?> klass, List<Runner> runners) throws Initializ...
method getChildren (line 116) | @Override
method describeChild (line 121) | @Override
method runChild (line 126) | @Override
FILE: src/main/java/org/junit/runners/model/Annotatable.java
type Annotatable (line 10) | public interface Annotatable {
method getAnnotations (line 14) | Annotation[] getAnnotations();
method getAnnotation (line 19) | <T extends Annotation> T getAnnotation(Class<T> annotationType);
FILE: src/main/java/org/junit/runners/model/FrameworkField.java
class FrameworkField (line 14) | public class FrameworkField extends FrameworkMember<FrameworkField> {
method FrameworkField (line 22) | public FrameworkField(Field field) {
method getName (line 39) | @Override
method getAnnotations (line 44) | public Annotation[] getAnnotations() {
method getAnnotation (line 48) | public <T extends Annotation> T getAnnotation(Class<T> annotationType) {
method isShadowedBy (line 52) | @Override
method isBridgeMethod (line 57) | @Override
method getModifiers (line 62) | @Override
method getField (line 70) | public Field getField() {
method getType (line 78) | @Override
method getDeclaringClass (line 83) | @Override
method get (line 91) | public Object get(Object target) throws IllegalArgumentException, Ille...
method toString (line 95) | @Override
FILE: src/main/java/org/junit/runners/model/FrameworkMember.java
class FrameworkMember (line 11) | public abstract class FrameworkMember<T extends FrameworkMember<T>> impl...
method isShadowedBy (line 13) | abstract boolean isShadowedBy(T otherMember);
method handlePossibleBridgeMethod (line 15) | T handlePossibleBridgeMethod(List<T> members) {
method isBridgeMethod (line 40) | abstract boolean isBridgeMethod();
method getModifiers (line 42) | protected abstract int getModifiers();
method isStatic (line 47) | public boolean isStatic() {
method isPublic (line 54) | public boolean isPublic() {
method getName (line 58) | public abstract String getName();
method getType (line 60) | public abstract Class<?> getType();
method getDeclaringClass (line 62) | public abstract Class<?> getDeclaringClass();
FILE: src/main/java/org/junit/runners/model/FrameworkMethod.java
class FrameworkMethod (line 19) | public class FrameworkMethod extends FrameworkMember<FrameworkMethod> {
method FrameworkMethod (line 25) | public FrameworkMethod(Method method) {
method getMethod (line 45) | public Method getMethod() {
method invokeExplosively (line 54) | public Object invokeExplosively(final Object target, final Object... p...
method getName (line 67) | @Override
method validatePublicVoidNoArg (line 82) | public void validatePublicVoidNoArg(boolean isStatic, List<Throwable> ...
method validatePublicVoid (line 99) | public void validatePublicVoid(boolean isStatic, List<Throwable> error...
method getModifiers (line 112) | @Override
method getReturnType (line 120) | public Class<?> getReturnType() {
method getType (line 127) | @Override
method getDeclaringClass (line 135) | @Override
method validateNoTypeParametersOnArgs (line 140) | public void validateNoTypeParametersOnArgs(List<Throwable> errors) {
method isShadowedBy (line 144) | @Override
method isBridgeMethod (line 160) | @Override
method equals (line 165) | @Override
method hashCode (line 173) | @Override
method producesType (line 187) | @Deprecated
method getParameterTypes (line 193) | private Class<?>[] getParameterTypes() {
method getAnnotations (line 200) | public Annotation[] getAnnotations() {
method getAnnotation (line 208) | public <T extends Annotation> T getAnnotation(Class<T> annotationType) {
method toString (line 212) | @Override
FILE: src/main/java/org/junit/runners/model/InitializationError.java
class InitializationError (line 11) | public class InitializationError extends Exception {
method InitializationError (line 25) | public InitializationError(List<Throwable> errors) {
method InitializationError (line 29) | public InitializationError(Throwable error) {
method InitializationError (line 37) | public InitializationError(String string) {
method getCauses (line 44) | public List<Throwable> getCauses() {
FILE: src/main/java/org/junit/runners/model/InvalidTestClassError.java
class InvalidTestClassError (line 12) | public class InvalidTestClassError extends InitializationError {
method InvalidTestClassError (line 17) | public InvalidTestClassError(Class<?> offendingTestClass, List<Throwab...
method createMessage (line 22) | private static String createMessage(Class<?> testClass, List<Throwable...
method getMessage (line 35) | @Override
FILE: src/main/java/org/junit/runners/model/MemberValueConsumer.java
type MemberValueConsumer (line 10) | public interface MemberValueConsumer<T> {
method accept (line 17) | void accept(FrameworkMember<?> member, T value);
FILE: src/main/java/org/junit/runners/model/MultipleFailureException.java
class MultipleFailureException (line 18) | public class MultipleFailureException extends Exception {
method MultipleFailureException (line 28) | public MultipleFailureException(List<Throwable> errors) {
method getFailures (line 42) | public List<Throwable> getFailures() {
method getMessage (line 46) | @Override
method printStackTrace (line 56) | @Override
method printStackTrace (line 63) | @Override
method printStackTrace (line 70) | @Override
method assertEmpty (line 86) | @SuppressWarnings("deprecation")
FILE: src/main/java/org/junit/runners/model/NoGenericTypeParametersValidator.java
class NoGenericTypeParametersValidator (line 11) | class NoGenericTypeParametersValidator {
method NoGenericTypeParametersValidator (line 14) | NoGenericTypeParametersValidator(Method method) {
method validate (line 18) | void validate(List<Throwable> errors) {
method validateNoTypeParameterOnType (line 24) | private void validateNoTypeParameterOnType(Type type, List<Throwable> ...
method validateNoTypeParameterOnParameterizedType (line 37) | private void validateNoTypeParameterOnParameterizedType(ParameterizedT...
method validateNoTypeParameterOnWildcardType (line 44) | private void validateNoTypeParameterOnWildcardType(WildcardType wildcard,
method validateNoTypeParameterOnGenericArrayType (line 54) | private void validateNoTypeParameterOnGenericArrayType(
FILE: src/main/java/org/junit/runners/model/RunnerBuilder.java
class RunnerBuilder (line 43) | public abstract class RunnerBuilder {
method runnerForClass (line 53) | public abstract Runner runnerForClass(Class<?> testClass) throws Throw...
method safeRunnerForClass (line 68) | public Runner safeRunnerForClass(Class<?> testClass) {
method configureRunner (line 80) | private void configureRunner(Runner runner) throws InvalidOrderingExce...
method addParent (line 89) | Class<?> addParent(Class<?> parent) throws InitializationError {
method removeParent (line 96) | void removeParent(Class<?> klass) {
method runners (line 106) | public List<Runner> runners(Class<?> parent, Class<?>[] children)
method runners (line 117) | public List<Runner> runners(Class<?> parent, List<Class<?>> children)
method runners (line 122) | private List<Runner> runners(Class<?>[] children) {
FILE: src/main/java/org/junit/runners/model/RunnerScheduler.java
type RunnerScheduler (line 11) | public interface RunnerScheduler {
method schedule (line 15) | void schedule(Runnable childStatement);
method finished (line 22) | void finished();
FILE: src/main/java/org/junit/runners/model/Statement.java
class Statement (line 10) | public abstract class Statement {
method evaluate (line 14) | public abstract void evaluate() throws Throwable;
FILE: src/main/java/org/junit/runners/model/TestClass.java
class TestClass (line 31) | public class TestClass implements Annotatable {
method TestClass (line 45) | public TestClass(Class<?> clazz) {
method scanAnnotatedMembers (line 63) | protected void scanAnnotatedMembers(Map<Class<? extends Annotation>, L...
method getSortedDeclaredFields (line 76) | private static Field[] getSortedDeclaredFields(Class<?> clazz) {
method addToAnnotationLists (line 82) | protected static <T extends FrameworkMember<T>> void addToAnnotationLi...
method makeDeeplyUnmodifiable (line 99) | private static <T extends FrameworkMember<T>> Map<Class<? extends Anno...
method getAnnotatedMethods (line 115) | public List<FrameworkMethod> getAnnotatedMethods() {
method getAnnotatedMethods (line 125) | public List<FrameworkMethod> getAnnotatedMethods(
method getAnnotatedFields (line 136) | public List<FrameworkField> getAnnotatedFields() {
method getAnnotatedFields (line 144) | public List<FrameworkField> getAnnotatedFields(
method collectValues (line 149) | private <T> List<T> collectValues(Map<?, List<T>> map) {
method getAnnotatedMembers (line 157) | private static <T> List<T> getAnnotatedMembers(Map<Class<? extends Ann...
method runsTopToBottom (line 166) | private static boolean runsTopToBottom(Class<? extends Annotation> ann...
method getSuperClasses (line 171) | private static List<Class<?>> getSuperClasses(Class<?> testClass) {
method getJavaClass (line 184) | public Class<?> getJavaClass() {
method getName (line 191) | public String getName() {
method getOnlyConstructor (line 203) | public Constructor<?> getOnlyConstructor() {
method getAnnotations (line 212) | public Annotation[] getAnnotations() {
method getAnnotation (line 219) | public <T extends Annotation> T getAnnotation(Class<T> annotationType) {
method getAnnotatedFieldValues (line 226) | public <T> List<T> getAnnotatedFieldValues(Object test,
method collectAnnotatedFieldValues (line 244) | public <T> void collectAnnotatedFieldValues(Object test,
method getAnnotatedMethodValues (line 260) | public <T> List<T> getAnnotatedMethodValues(Object test,
method collectAnnotatedMethodValues (line 278) | public <T> void collectAnnotatedMethodValues(Object test,
method isPublic (line 302) | public boolean isPublic() {
method isANonStaticInnerClass (line 306) | public boolean isANonStaticInnerClass() {
method hashCode (line 310) | @Override
method equals (line 315) | @Override
class FieldComparator (line 333) | private static class FieldComparator implements Comparator<Field> {
method compare (line 334) | public int compare(Field left, Field right) {
class MethodComparator (line 342) | private static class MethodComparator implements
method compare (line 344) | public int compare(FrameworkMethod left, FrameworkMethod right) {
FILE: src/main/java/org/junit/runners/model/TestTimedOutException.java
class TestTimedOutException (line 11) | public class TestTimedOutException extends Exception {
method TestTimedOutException (line 24) | public TestTimedOutException(long timeout, TimeUnit timeUnit) {
method getTimeout (line 34) | public long getTimeout() {
method getTimeUnit (line 41) | public TimeUnit getTimeUnit() {
FILE: src/main/java/org/junit/runners/parameterized/BlockJUnit4ClassRunnerWithParameters.java
class BlockJUnit4ClassRunnerWithParameters (line 23) | public class BlockJUnit4ClassRunnerWithParameters extends
type InjectionType (line 25) | private enum InjectionType {
method BlockJUnit4ClassRunnerWithParameters (line 33) | public BlockJUnit4ClassRunnerWithParameters(TestWithParameters test)
method createTest (line 41) | @Override
method createTestUsingConstructorInjection (line 55) | private Object createTestUsingConstructorInjection() throws Exception {
method createTestUsingFieldInjection (line 59) | private Object createTestUsingFieldInjection() throws Exception {
method getName (line 96) | @Override
method testName (line 101) | @Override
method validateConstructor (line 106) | @Override
method validateFields (line 114) | @Override
method classBlock (line 146) | @Override
method withBeforeParams (line 154) | private Statement withBeforeParams(Statement statement) {
class RunBeforeParams (line 160) | private class RunBeforeParams extends RunBefores {
method RunBeforeParams (line 161) | RunBeforeParams(Statement next, List<FrameworkMethod> befores) {
method invokeMethod (line 165) | @Override
method withAfterParams (line 172) | private Statement withAfterParams(Statement statement) {
class RunAfterParams (line 178) | private class RunAfterParams extends RunAfters {
method RunAfterParams (line 179) | RunAfterParams(Statement next, List<FrameworkMethod> afters) {
method invokeMethod (line 183) | @Override
method getRunnerAnnotations (line 190) | @Override
method getAnnotatedFieldsByParameter (line 204) | private List<FrameworkField> getAnnotatedFieldsByParameter() {
method getInjectionType (line 208) | private InjectionType getInjectionType() {
method fieldsAreAnnotated (line 216) | private boolean fieldsAreAnnotated() {
FILE: src/main/java/org/junit/runners/parameterized/BlockJUnit4ClassRunnerWithParametersFactory.java
class BlockJUnit4ClassRunnerWithParametersFactory (line 12) | public class BlockJUnit4ClassRunnerWithParametersFactory implements
method createRunnerForTestWithParameters (line 14) | public Runner createRunnerForTestWithParameters(TestWithParameters test)
FILE: src/main/java/org/junit/runners/parameterized/ParametersRunnerFactory.java
type ParametersRunnerFactory (line 12) | public interface ParametersRunnerFactory {
method createRunnerForTestWithParameters (line 19) | Runner createRunnerForTestWithParameters(TestWithParameters test)
FILE: src/main/java/org/junit/runners/parameterized/TestWithParameters.java
class TestWithParameters (line 18) | public class TestWithParameters {
method TestWithParameters (line 25) | public TestWithParameters(String name, TestClass testClass,
method getName (line 35) | public String getName() {
method getTestClass (line 39) | public TestClass getTestClass() {
method getParameters (line 43) | public List<Object> getParameters() {
method hashCode (line 47) | @Override
method equals (line 55) | @Override
method toString (line 72) | @Override
FILE: src/main/java/org/junit/validator/AnnotationValidator.java
class AnnotationValidator (line 20) | public abstract class AnnotationValidator {
method validateAnnotatedClass (line 32) | public List<Exception> validateAnnotatedClass(TestClass testClass) {
method validateAnnotatedField (line 44) | public List<Exception> validateAnnotatedField(FrameworkField field) {
method validateAnnotatedMethod (line 57) | public List<Exception> validateAnnotatedMethod(FrameworkMethod method) {
FILE: src/main/java/org/junit/validator/AnnotationValidatorFactory.java
class AnnotationValidatorFactory (line 10) | public class AnnotationValidatorFactory {
method createAnnotationValidator (line 23) | public AnnotationValidator createAnnotationValidator(ValidateWith vali...
FILE: src/main/java/org/junit/validator/AnnotationsValidator.java
class AnnotationsValidator (line 21) | public final class AnnotationsValidator implements TestClassValidator {
method validateTestClass (line 33) | public List<Exception> validateTestClass(TestClass testClass) {
class AnnotatableValidator (line 43) | private abstract static class AnnotatableValidator<T extends Annotatab...
method getAnnotatablesForTestClass (line 46) | abstract Iterable<T> getAnnotatablesForTestClass(TestClass testClass);
method validateAnnotatable (line 48) | abstract List<Exception> validateAnnotatable(
method validateTestClass (line 51) | public List<Exception> validateTestClass(TestClass testClass) {
method validateAnnotatable (line 60) | private List<Exception> validateAnnotatable(T annotatable) {
class ClassValidator (line 79) | private static class ClassValidator extends AnnotatableValidator<TestC...
method getAnnotatablesForTestClass (line 80) | @Override
method validateAnnotatable (line 85) | @Override
class MethodValidator (line 92) | private static class MethodValidator extends
method getAnnotatablesForTestClass (line 94) | @Override
method validateAnnotatable (line 100) | @Override
class FieldValidator (line 107) | private static class FieldValidator extends
method getAnnotatablesForTestClass (line 109) | @Override
method validateAnnotatable (line 114) | @Override
FILE: src/main/java/org/junit/validator/PublicClassValidator.java
class PublicClassValidator (line 15) | public class PublicClassValidator implements TestClassValidator {
method validateTestClass (line 25) | public List<Exception> validateTestClass(TestClass testClass) {
FILE: src/main/java/org/junit/validator/TestClassValidator.java
type TestClassValidator (line 12) | public interface TestClassValidator {
method validateTestClass (line 20) | List<Exception> validateTestClass(TestClass testClass);
FILE: src/test/java/junit/samples/AllTests.java
class AllTests (line 9) | public class AllTests {
method main (line 11) | public static void main(String[] args) {
method suite (line 15) | public static Test suite() {
FILE: src/test/java/junit/samples/ListTest.java
class ListTest (line 13) | public class ListTest extends TestCase {
method setUp (line 18) | @Override
method suite (line 27) | public static Test suite() {
method testCapacity (line 31) | public void testCapacity() {
method testContains (line 39) | public void testContains() {
method testElementAt (line 44) | public void testElementAt() {
method testRemoveAll (line 56) | public void testRemoveAll() {
method testRemoveElement (line 63) | public void testRemoveElement() {
FILE: src/test/java/junit/samples/SimpleTest.java
class SimpleTest (line 10) | public class SimpleTest extends TestCase {
method setUp (line 14) | @Override
method suite (line 20) | public static Test suite() {
method testAdd (line 46) | public void testAdd() {
method testDivideByZero (line 54) | public void testDivideByZero() {
method testEquals (line 60) | public void testEquals() {
method main (line 69) | public static void main(String[] args) {
FILE: src/test/java/junit/samples/money/IMoney.java
type IMoney (line 6) | public interface IMoney {
method add (line 10) | IMoney add(IMoney m);
method addMoney (line 16) | IMoney addMoney(Money m);
method addMoneyBag (line 22) | IMoney addMoneyBag(MoneyBag s);
method isZero (line 27) | boolean isZero();
method multiply (line 32) | IMoney multiply(int factor);
method negate (line 37) | IMoney negate();
method subtract (line 42) | IMoney subtract(IMoney m);
method appendTo (line 50) | void appendTo(MoneyBag m);
FILE: src/test/java/junit/samples/money/Money.java
class Money (line 6) | public class Money implements IMoney {
method Money (line 14) | public Money(int amount, String currency) {
method add (line 22) | public IMoney add(IMoney m) {
method addMoney (line 26) | public IMoney addMoney(Money m) {
method addMoneyBag (line 33) | public IMoney addMoneyBag(MoneyBag s) {
method amount (line 37) | public int amount() {
method currency (line 41) | public String currency() {
method equals (line 45) | @Override
method hashCode (line 60) | @Override
method isZero (line 68) | public boolean isZero() {
method multiply (line 72) | public IMoney multiply(int factor) {
method negate (line 76) | public IMoney negate() {
method subtract (line 80) | public IMoney subtract(IMoney m) {
method toString (line 84) | @Override
method appendTo (line 89) | public /*this makes no sense*/ void appendTo(MoneyBag m) {
FILE: src/test/java/junit/samples/money/MoneyBag.java
class MoneyBag (line 17) | public class MoneyBag implements IMoney {
method create (line 20) | public static IMoney create(IMoney m1, IMoney m2) {
method add (line 27) | public IMoney add(IMoney m) {
method addMoney (line 31) | public IMoney addMoney(Money m) {
method addMoneyBag (line 35) | public IMoney addMoneyBag(MoneyBag s) {
method appendBag (line 39) | void appendBag(MoneyBag aBag) {
method appendMoney (line 45) | void appendMoney(Money aMoney) {
method equals (line 60) | @Override
method findMoney (line 84) | private Money findMoney(String currency) {
method contains (line 93) | private boolean contains(Money m) {
method hashCode (line 99) | @Override
method isZero (line 108) | public boolean isZero() {
method multiply (line 112) | public IMoney multiply(int factor) {
method negate (line 122) | public IMoney negate() {
method simplify (line 130) | private IMoney simplify() {
method subtract (line 137) | public IMoney subtract(IMoney m) {
method toString (line 141) | @Override
method appendTo (line 152) | public void appendTo(MoneyBag m) {
FILE: src/test/java/junit/samples/money/MoneyTest.java
class MoneyTest (line 5) | public class MoneyTest extends TestCase {
method main (line 14) | public static void main(String args[]) {
method setUp (line 18) | @Override
method testBagMultiply (line 29) | public void testBagMultiply() {
method testBagNegate (line 37) | public void testBagNegate() {
method testBagSimpleAdd (line 43) | public void testBagSimpleAdd() {
method testBagSubtract (line 49) | public void testBagSubtract() {
method testBagSumAdd (line 55) | public void testBagSumAdd() {
method testIsZero (line 61) | public void testIsZero() {
method testMixedSimpleAdd (line 66) | public void testMixedSimpleAdd() {
method testBagNotEquals (line 72) | public void testBagNotEquals() {
method testMoneyBagEquals (line 77) | public void testMoneyBagEquals() {
method testMoneyBagHash (line 88) | public void testMoneyBagHash() {
method testMoneyEquals (line 93) | public void testMoneyEquals() {
method testMoneyHash (line 102) | public void testMoneyHash() {
method testSimplify (line 108) | public void testSimplify() {
method testNormalize2 (line 113) | public void testNormalize2() {
method testNormalize3 (line 119) | public void testNormalize3() {
method testNormalize4 (line 126) | public void testNormalize4() {
method testPrint (line 133) | public void testPrint() {
method testSimpleAdd (line 137) | public void testSimpleAdd() {
method testSimpleBagAdd (line 143) | public void testSimpleBagAdd() {
method testSimpleMultiply (line 149) | public void testSimpleMultiply() {
method testSimpleNegate (line 155) | public void testSimpleNegate() {
method testSimpleSubtract (line 161) | public void testSimpleSubtract() {
FILE: src/test/java/junit/tests/AllTests.java
class AllTests (line 9) | public class AllTests {
method main (line 11) | public static void main(String[] args) {
method suite (line 15) | public static Test suite() {
FILE: src/test/java/junit/tests/SampleJUnit3Tests.java
class SampleJUnit3Tests (line 8) | public class SampleJUnit3Tests {
class TestWithOneThrowingTestMethod (line 10) | public static class TestWithOneThrowingTestMethod extends TestCase {
method testAlwaysThrows (line 12) | public void testAlwaysThrows() {
class TestWithThrowingSetUpMethod (line 17) | public static class TestWithThrowingSetUpMethod extends TestCase {
method setUp (line 19) | @Override
method testAlwaysPasses (line 25) | public void testAlwaysPasses() {
class FakeClassUnderTest (line 29) | private static class FakeClassUnderTest {
method throwsExceptionWithCause (line 31) | public void throwsExceptionWithCause() {
method throwsExceptionWithoutCause (line 35) | public void throwsExceptionWithoutCause() {
method doThrowExceptionWithCause (line 39) | private void doThrowExceptionWithCause() {
method doThrowExceptionWithoutCause (line 47) | private void doThrowExceptionWithoutCause() {
FILE: src/test/java/junit/tests/WasRun.java
class WasRun (line 9) | public class WasRun extends TestCase {
method runTest (line 12) | @Override
FILE: src/test/java/junit/tests/extensions/ActiveTestTest.java
class ActiveTestTest (line 12) | public class ActiveTestTest extends TestCase {
class SuccessTest (line 14) | public static class SuccessTest extends TestCase {
method runTest (line 15) | @Override
method testActiveTest (line 20) | public void testActiveTest() {
method testActiveRepeatedTest (line 29) | public void testActiveRepeatedTest() {
method testActiveRepeatedTest0 (line 38) | public void testActiveRepeatedTest0() {
method testActiveRepeatedTest1 (line 47) | public void testActiveRepeatedTest1() {
method createActiveTestSuite (line 56) | ActiveTestSuite createActiveTestSuite() {
FILE: src/test/java/junit/tests/extensions/AllTests.java
class AllTests (line 9) | public class AllTests {
method main (line 11) | public static void main(String[] args) {
method suite (line 15) | public static Test suite() { // Collect tests manually because we have...
FILE: src/test/java/junit/tests/extensions/ExtensionTest.java
class ExtensionTest (line 13) | public class ExtensionTest extends TestCase {
class TornDown (line 14) | static class TornDown extends TestSetup {
method TornDown (line 17) | TornDown(Test test) {
method tearDown (line 21) | @Override
method testRunningErrorInTestSetup (line 27) | public void testRunningErrorInTestSetup() {
method testRunningErrorsInTestSetup (line 42) | public void testRunningErrorsInTestSetup() {
method testSetupErrorDontTearDown (line 70) | public void testSetupErrorDontTearDown() {
method testSetupErrorInTestSetup (line 87) | public void testSetupErrorInTestSetup() {
FILE: src/test/java/junit/tests/extensions/RepeatedTestTest.java
class RepeatedTestTest (line 12) | public class RepeatedTestTest extends TestCase {
class SuccessTest (line 15) | public static class SuccessTest extends TestCase {
method runTest (line 17) | @Override
method RepeatedTestTest (line 22) | public RepeatedTestTest(String name) {
method testRepeatedOnce (line 29) | public void testRepeatedOnce() {
method testRepeatedMoreThanOnce (line 37) | public void testRepeatedMoreThanOnce() {
method testRepeatedZero (line 45) | public void testRepeatedZero() {
method testRepeatedNegative (line 53) | public void testRepeatedNegative() {
FILE: src/test/java/junit/tests/framework/AllTests.java
class AllTests (line 9) | public class AllTests {
method main (line 11) | public static void main(String[] args) {
method suite (line 15) | public static Test suite() {
FILE: src/test/java/junit/tests/framework/AssertTest.java
class AssertTest (line 7) | public class AssertTest extends TestCase {
method testFail (line 18) | public void testFail() {
method testAssertionFailedErrorToStringWithNoMessage (line 29) | public void testAssertionFailedErrorToStringWithNoMessage() {
method testAssertionFailedErrorToStringWithMessage (line 41) | public void testAssertionFailedErrorToStringWithMessage() {
method testAssertEquals (line 53) | public void testAssertEquals() {
method testAssertEqualsNull (line 64) | public void testAssertEqualsNull() {
method testAssertStringEquals (line 68) | public void testAssertStringEquals() {
method testAssertNullNotEqualsString (line 72) | public void testAssertNullNotEqualsString() {
method testAssertStringNotEqualsNull (line 80) | public void testAssertStringNotEqualsNull() {
method testAssertNullNotEqualsNull (line 89) | public void testAssertNullNotEqualsNull() {
method testAssertNull (line 99) | public void testAssertNull() {
method testAssertNotNull (line 109) | public void testAssertNotNull() {
method testAssertTrue (line 119) | public void testAssertTrue() {
method testAssertFalse (line 129) | public void testAssertFalse() {
method testAssertSame (line 139) | public void testAssertSame() {
method testAssertNotSame (line 150) | public void testAssertNotSame() {
method testAssertNotSameFailsNull (line 163) | public void testAssertNotSameFailsNull() {
class MyInt (line 172) | private static final class MyInt {
method MyInt (line 175) | MyInt(int value) {
method equals (line 179) | @Override
method hashCode (line 184) | @Override
method toString (line 189) | @Override
FILE: src/test/java/junit/tests/framework/AssertionFailedErrorTest.java
class AssertionFailedErrorTest (line 6) | public class AssertionFailedErrorTest extends TestCase {
method testCreateErrorWithoutMessage (line 9) | public void testCreateErrorWithoutMessage() throws Exception {
method testCreateErrorWithMessage (line 14) | public void testCreateErrorWithMessage() throws Exception {
method testCreateErrorWithoutMessageInsteadOfNull (line 19) | public void testCreateErrorWithoutMessageInsteadOfNull() throws Except...
FILE: src/test/java/junit/tests/framework/ComparisonCompactorTest.java
class ComparisonCompactorTest (line 6) | public class ComparisonCompactorTest extends TestCase {
method testMessage (line 8) | public void testMessage() {
method testStartSame (line 13) | public void testStartSame() {
method testEndSame (line 18) | public void testEndSame() {
method testSame (line 23) | public void testSame() {
method testNoContextStartAndEndSame (line 28) | public void testNoContextStartAndEndSame() {
method testStartAndEndContext (line 33) | public void testStartAndEndContext() {
method testStartAndEndContextWithEllipses (line 38) | public void testStartAndEndContextWithEllipses() {
method testComparisonErrorStartSameComplete (line 43) | public void testComparisonErrorStartSameComplete() {
method testComparisonErrorEndSameComplete (line 48) | public void testComparisonErrorEndSameComplete() {
method testComparisonErrorEndSameCompleteContext (line 53) | public void testComparisonErrorEndSameCompleteContext() {
method testComparisonErrorOverlappingMatches (line 58) | public void testComparisonErrorOverlappingMatches() {
method testComparisonErrorOverlappingMatchesContext (line 63) | public void testComparisonErrorOverlappingMatchesContext() {
method testComparisonErrorOverlappingMatches2 (line 68) | public void testComparisonErrorOverlappingMatches2() {
method testComparisonErrorOverlappingMatches2Context (line 73) | public void testComparisonErrorOverlappingMatches2Context() {
method testComparisonErrorWithActualNull (line 78) | public void testComparisonErrorWithActualNull() {
method testComparisonErrorWithActualNullContext (line 83) | public void testComparisonErrorWithActualNullContext() {
method testComparisonErrorWithExpectedNull (line 88) | public void testComparisonErrorWithExpectedNull() {
method testComparisonErrorWithExpectedNullContext (line 93) | public void testComparisonErrorWithExpectedNullContext() {
method testBug609972 (line 98) | public void testBug609972() {
FILE: src/test/java/junit/tests/framework/ComparisonFailureTest.java
class ComparisonFailureTest (line 6) | public class ComparisonFailureTest extends TestCase {
method testConnection (line 9) | public void testConnection() {
method testThrowing (line 15) | public void testThrowing() {
method testExceptionToStringWithMessage (line 24) | public void testExceptionToStringWithMessage() {
method testExceptionToStringWithoutMessage (line 36) | public void testExceptionToStringWithoutMessage() {
FILE: src/test/java/junit/tests/framework/DoublePrecisionAssertTest.java
class DoublePrecisionAssertTest (line 6) | public class DoublePrecisionAssertTest extends TestCase {
method testAssertEqualsNaNFails (line 11) | public void testAssertEqualsNaNFails() {
method testAssertNaNEqualsFails (line 20) | public void testAssertNaNEqualsFails() {
method testAssertNaNEqualsNaN (line 29) | public void testAssertNaNEqualsNaN() {
method testAssertPosInfinityNotEqualsNegInfinity (line 33) | public void testAssertPosInfinityNotEqualsNegInfinity() {
method testAssertPosInfinityNotEquals (line 42) | public void testAssertPosInfinityNotEquals() {
method testAssertPosInfinityEqualsInfinity (line 51) | public void testAssertPosInfinityEqualsInfinity() {
method testAssertNegInfinityEqualsInfinity (line 55) | public void testAssertNegInfinityEqualsInfinity() {
FILE: src/test/java/junit/tests/framework/Failure.java
class Failure (line 8) | public class Failure extends TestCase {
method runTest (line 9) | @Override
FILE: src/test/java/junit/tests/framework/FloatAssertTest.java
class FloatAssertTest (line 6) | public class FloatAssertTest extends TestCase {
method testAssertEqualsNaNFails (line 11) | public void testAssertEqualsNaNFails() {
method testAssertNaNEqualsFails (line 20) | public void testAssertNaNEqualsFails() {
method testAssertNaNEqualsNaN (line 29) | public void testAssertNaNEqualsNaN() {
method testAssertPosInfinityNotEqualsNegInfinity (line 33) | public void testAssertPosInfinityNotEqualsNegInfinity() {
method testAssertPosInfinityNotEquals (line 42) | public void testAssertPosInfinityNotEquals() {
method testAssertPosInfinityEqualsInfinity (line 51) | public void testAssertPosInfinityEqualsInfinity() {
method testAssertNegInfinityEqualsInfinity (line 55) | public void testAssertNegInfinityEqualsInfinity() {
method testAllInfinities (line 59) | public void testAllInfinities() {
FILE: src/test/java/junit/tests/framework/InheritedTestCase.java
class InheritedTestCase (line 6) | public class InheritedTestCase extends OneTestCase {
method test2 (line 7) | public void test2() {
FILE: src/test/java/junit/tests/framework/NoArgTestCaseTest.java
class NoArgTestCaseTest (line 5) | public class NoArgTestCaseTest extends TestCase {
method testNothing (line 6) | public void testNothing() { // If this compiles, the no arg ctor is there
FILE: src/test/java/junit/tests/framework/NoTestCaseClass.java
class NoTestCaseClass (line 6) | public class NoTestCaseClass extends Object {
method testSuccess (line 7) | public void testSuccess() {
FILE: src/test/java/junit/tests/framework/NoTestCases.java
class NoTestCases (line 8) | public class NoTestCases extends TestCase {
method noTestCase (line 9) | public void noTestCase() {
FILE: src/test/java/junit/tests/framework/NotPublicTestCase.java
class NotPublicTestCase (line 8) | public class NotPublicTestCase extends TestCase {
method testNotPublic (line 9) | protected void testNotPublic() {
method testPublic (line 12) | public void testPublic() {
FILE: src/test/java/junit/tests/framework/NotVoidTestCase.java
class NotVoidTestCase (line 8) | public class NotVoidTestCase extends TestCase {
method testNotVoid (line 9) | public int testNotVoid() {
method testVoid (line 13) | public void testVoid() {
FILE: src/test/java/junit/tests/framework/OneTestCase.java
class OneTestCase (line 8) | public class OneTestCase extends TestCase {
method noTestCase (line 9) | public void noTestCase() {
method testCase (line 12) | public void testCase() {
method testCase (line 15) | public void testCase(int arg) {
FILE: src/test/java/junit/tests/framework/OverrideTestCase.java
class OverrideTestCase (line 6) | public class OverrideTestCase extends OneTestCase {
method testCase (line 7) | @Override
FILE: src/test/java/junit/tests/framework/Success.java
class Success (line 8) | public class Success extends TestCase {
method runTest (line 10) | @Override
method testSuccess (line 14) | public void testSuccess() {
FILE: src/test/java/junit/tests/framework/SuiteTest.java
class SuiteTest (line 13) | public class SuiteTest extends TestCase {
method SuiteTest (line 16) | public SuiteTest(String name) {
method setUp (line 20) | @Override
method suite (line 25) | public static Test suite() {
method testInheritedTests (line 44) | public void testInheritedTests() {
method testNoTestCaseClass (line 51) | public void testNoTestCaseClass() {
method testNoTestCases (line 58) | public void testNoTestCases() {
method testNotExistingTestCase (line 66) | public void testNotExistingTestCase() {
method testNotPublicTestCase (line 74) | public void testNotPublicTestCase() {
method testNotVoidTestCase (line 80) | public void testNotVoidTestCase() {
method testOneTestCase (line 85) | public void testOneTestCase() {
method testOneTestCaseEclipseSeesSameStructureAs381 (line 94) | public void testOneTestCaseEclipseSeesSameStructureAs381() {
method testShadowedTests (line 99) | public void testShadowedTests() {
method testAddTestSuite (line 105) | public void testAddTestSuite() {
method testCreateSuiteFromArray (line 112) | public void testCreateSuiteFromArray() {
FILE: src/test/java/junit/tests/framework/TestCaseTest.java
class TestCaseTest (line 13) | public class TestCaseTest extends TestCase {
class TornDown (line 15) | static class TornDown extends TestCase {
method tearDown (line 18) | @Override
method runTest (line 23) | @Override
method testCaseToString (line 29) | public void testCaseToString() {
method testError (line 36) | public void testError() {
method testRunAndTearDownFails (line 46) | public void testRunAndTearDownFails() {
method testSetupFails (line 63) | public void testSetupFails() {
method testSuccess (line 77) | public void testSuccess() {
method testFailure (line 86) | public void testFailure() {
method testTearDownAfterError (line 96) | public void testTearDownAfterError() {
method testTearDownFails (line 102) | public void testTearDownFails() {
method testTearDownSetupFails (line 116) | public void testTearDownSetupFails() {
method testWasRun (line 127) | public void testWasRun() {
method testExceptionRunningAndTearDown (line 133) | public void testExceptionRunningAndTearDown() {
method testErrorTearingDownDoesntMaskErrorRunning (line 149) | public void testErrorTearingDownDoesntMaskErrorRunning() {
method testNoArgTestCasePasses (line 169) | public void testNoArgTestCasePasses() {
method testNamelessTestCase (line 178) | public void testNamelessTestCase() {
method verifyError (line 185) | void verifyError(TestCase test) {
method verifyFailure (line 192) | void verifyFailure(TestCase test) {
method verifySuccess (line 199) | void verifySuccess(TestCase test) {
FILE: src/test/java/junit/tests/framework/TestImplementorTest.java
class TestImplementorTest (line 11) | public class TestImplementorTest extends TestCase {
class DoubleTestCase (line 12) | public static class DoubleTestCase implements Test {
method DoubleTestCase (line 15) | public DoubleTestCase(TestCase testCase) {
method countTestCases (line 19) | public int countTestCases() {
method run (line 23) | public void run(TestResult result) {
method TestImplementorTest (line 38) | public TestImplementorTest() {
method testSuccessfulRun (line 47) | public void testSuccessfulRun() {
FILE: src/test/java/junit/tests/framework/TestListenerTest.java
class TestListenerTest (line 12) | public class TestListenerTest extends TestCase implements TestListener {
method addError (line 19) | public void addError(Test test, Throwable e) {
method addFailure (line 23) | public void addFailure(Test test, AssertionFailedError t) {
method endTest (line 27) | public void endTest(Test test) {
method setUp (line 31) | @Override
method startTest (line 42) | public void startTest(Test test) {
method testError (line 46) | public void testError() {
method testFailure (line 58) | public void testFailure() {
method testStartStop (line 70) | public void testStartStop() {
FILE: src/test/java/junit/tests/framework/ThreeTestCases.java
class ThreeTestCases (line 8) | public class ThreeTestCases extends TestCase {
method testCase (line 9) | public void testCase() {
method testCase2 (line 12) | public void testCase2() {
method testCase3thisTimeItsPersonal (line 15) | public void testCase3thisTimeItsPersonal() {
FILE: src/test/java/junit/tests/runner/AllTests.java
class AllTests (line 9) | public class AllTests {
method main (line 11) | public static void main(String[] args) {
method suite (line 15) | public static Test suite() { // Collect tests manually because we have...
method isJDK11 (line 26) | static boolean isJDK11() {
FILE: src/test/java/junit/tests/runner/BaseTestRunnerTest.java
class BaseTestRunnerTest (line 8) | public class BaseTestRunnerTest extends TestCase {
class MockRunner (line 9) | public static class MockRunner extends BaseTestRunner {
method runFailed (line 12) | @Override
method testEnded (line 17) | @Override
method testFailed (line 21) | @Override
method testStarted (line 25) | @Override
class NonStatic (line 30) | public static class NonStatic {
method suite (line 31) | public Test suite() {
method testInvokeNonStaticSuite (line 36) | public void testInvokeNonStaticSuite() {
class DoesntExtendTestCase (line 41) | public static class DoesntExtendTestCase {
method suite (line 42) | public static Test suite() {
method testInvokeSuiteOnNonSubclassOfTestCase (line 47) | public void testInvokeSuiteOnNonSubclassOfTestCase() {
FILE: src/test/java/junit/tests/runner/ResultTest.java
class ResultTest (line 19) | public class ResultTest extends TestCase {
method testRunFailureResultCanBeSerialised (line 23) | public void testRunFailureResultCanBeSerialised() throws Exception {
method testRunFailureResultCanBeReserialised_v4_12 (line 29) | public void testRunFailureResultCanBeReserialised_v4_12() throws Excep...
method testRunAssumptionFailedResultCanBeSerialised (line 35) | public void testRunAssumptionFailedResultCanBeSerialised() throws Exce...
method testRunAssumptionFailedResultCanBeReserialised_v4_12 (line 41) | public void testRunAssumptionFailedResultCanBeReserialised_v4_12() thr...
method testRunAssumptionFailedResultCanBeReserialised_v4_13 (line 47) | public void testRunAssumptionFailedResultCanBeReserialised_v4_13() thr...
method testRunSuccessResultCanBeSerialised (line 53) | public void testRunSuccessResultCanBeSerialised() throws Exception {
method testRunSuccessResultCanBeReserialised_v4_12 (line 59) | public void testRunSuccessResultCanBeReserialised_v4_12() throws Excep...
method testRunSuccessResultCanBeReserialised_v4_13 (line 65) | public void testRunSuccessResultCanBeReserialised_v4_13() throws Excep...
type SerializationFormat (line 71) | private enum SerializationFormat {
method assertResultSerializable (line 76) | private void assertResultSerializable(Result result) throws IOExceptio...
method assertResultReserializable (line 87) | private void assertResultReserializable(Result result, SerializationFo...
class AssumptionFailedTest (line 99) | public static class AssumptionFailedTest {
method assumptionFailed (line 100) | @Test
class ResultWithFixedRunTime (line 110) | private static class ResultWithFixedRunTime extends Result {
method ResultWithFixedRunTime (line 116) | public ResultWithFixedRunTime(Result delegate) {
method getRunCount (line 120) | @Override
method getFailureCount (line 125) | @Override
method getRunTime (line 130) | @Override
method getFailures (line 135) | @Override
method getIgnoreCount (line 140) | @Override
method getAssumptionFailureCount (line 145) | @Override
method assertSerializedCorrectly (line 151) | private void assertSerializedCorrectly(
FILE: src/test/java/junit/tests/runner/StackFilterTest.java
class StackFilterTest (line 9) | public class StackFilterTest extends TestCase {
method setUp (line 13) | @Override
method testFilter (line 43) | public void testFilter() {
FILE: src/test/java/junit/tests/runner/TextFeedbackTest.java
class TextFeedbackTest (line 14) | public class TextFeedbackTest extends TestCase {
class TestResultPrinter (line 18) | static class TestResultPrinter extends ResultPrinter {
method TestResultPrinter (line 19) | TestResultPrinter(PrintStream writer) {
method elapsedTimeAsString (line 25) | @Override
method main (line 31) | public static void main(String[] args) {
method setUp (line 35) | @Override
method testEmptySuite (line 41) | public void testEmptySuite() {
method testOneTest (line 48) | public void testOneTest() {
method testTwoTests (line 60) | public void testTwoTests() {
method testFailure (line 77) | public void testFailure() {
method testError (line 97) | public void testError() {
method expected (line 117) | private String expected(String[] lines) {
FILE: src/test/java/junit/tests/runner/TextRunnerSingleMethodTest.java
class TextRunnerSingleMethodTest (line 13) | public class TextRunnerSingleMethodTest extends TestCase {
class InvocationTest (line 17) | public static class InvocationTest extends TestCase {
method testWasInvoked (line 19) | public void testWasInvoked() {
method testNotInvoked (line 23) | public void testNotInvoked() {
method testSingle (line 28) | public void testSingle() throws Exception {
FILE: src/test/java/junit/tests/runner/TextRunnerTest.java
class TextRunnerTest (line 13) | public class TextRunnerTest extends TestCase {
method testFailure (line 15) | public void testFailure() throws Exception {
method testSuccess (line 19) | public void testSuccess() throws Exception {
method testError (line 23) | public void testError() throws Exception {
method execTest (line 27) | void execTest(String testClass, boolean success) throws Exception {
method testRunReturnsResult (line 44) | public void testRunReturnsResult() {
FILE: src/test/java/org/junit/AssumptionViolatedExceptionTest.java
class AssumptionViolatedExceptionTest (line 30) | @RunWith(Theories.class)
method toStringReportsMatcher (line 49) | @Theory
method toStringReportsValue (line 56) | @Theory
method assumptionViolatedExceptionWithMatcherDescribesItself (line 62) | @Test
method simpleAssumptionViolatedExceptionDescribesItself (line 68) | @Test
method canInitCauseWithInstanceCreatedWithString (line 74) | @Test
method canSetCauseWithInstanceCreatedWithObjectAndMatcher (line 82) | @Test
method canSetCauseWithInstanceCreatedWithAssumptionObjectAndMatcher (line 92) | @Test
method canSetCauseWithInstanceCreatedWithMainConstructor (line 102) | @Test
method canSetCauseWithInstanceCreatedWithExplicitThrowableConstructor (line 112) | @Test
method assumptionViolatedExceptionWithoutValueAndMatcherCanBeReserialized_v4_13 (line 119) | @Test
method assumptionViolatedExceptionWithValueAndMatcherCanBeReserialized_v4_13 (line 125) | @Test
method unserializableValueAndMatcherCanBeSerialized (line 131) | @Test
method nullValueAndMatcherCanBeSerialized (line 139) | @Test
method serializableValueAndMatcherCanBeSerialized (line 146) | @Test
method assertCanBeSerialized (line 154) | private void assertCanBeSerialized(AssumptionViolatedException exception)
method assertReserializable (line 167) | private void assertReserializable(AssumptionViolatedException expected)
method assertSerializedCorrectly (line 178) | private void assertSerializedCorrectly(
class SerializableIsThreeMatcher (line 190) | private static class SerializableIsThreeMatcher<T> extends BaseMatcher...
method matches (line 192) | public boolean matches(Object item) {
method describeTo (line 196) | public void describeTo(Description description) {
class UnserializableClass (line 201) | private static class UnserializableClass {
method toString (line 202) | @Override
FILE: src/test/java/org/junit/experimental/categories/AllCategoriesTests.java
class AllCategoriesTests (line 7) | @RunWith(Suite.class)
FILE: src/test/java/org/junit/experimental/categories/CategoriesAndParameterizedTest.java
class CategoriesAndParameterizedTest (line 17) | public class CategoriesAndParameterizedTest {
class Token (line 18) | public static class Token {
class ParameterizedTestWithoutCategory (line 22) | @RunWith(Parameterized.class)
method getParameters (line 24) | @Parameters
method testSomething (line 32) | @Test
class TestThatAvoidsNoTestRemainsException (line 38) | @Category(Token.class)
method testSomething (line 40) | @Test
class SuiteWithParameterizedTestWithoutCategory (line 46) | @RunWith(Categories.class)
method doesNotRunTestsWithoutCategory (line 53) | @Test
class ParameterizedTestWithCategory (line 61) | @RunWith(Parameterized.class)
method getParameters (line 64) | @Parameters
method testSomething (line 72) | @Test
class SuiteWithParameterizedTestWithCategory (line 78) | @RunWith(Categories.class)
method runsTestsWithoutCategory (line 84) | @Test
class ParameterizedTestWithMethodWithCategory (line 92) | @RunWith(Parameterized.class)
method getParameters (line 94) | @Parameters
method testSomething (line 102) | @Test
method testThatIsNotExecuted (line 108) | @Test
class SuiteWithParameterizedTestWithMethodWithCategory (line 114) | @RunWith(Categories.class)
method runsTestMethodWithCategory (line 120) | @Test
FILE: src/test/java/org/junit/experimental/categories/CategoryFilterFactoryTest.java
class CategoryFilterFactoryTest (line 18) | public class CategoryFilterFactoryTest {
method shouldCreateFilter (line 27) | @Test
method shouldThrowException (line 37) | @Test
class CategoryFilterFactoryStub (line 48) | private static class CategoryFilterFactoryStub extends CategoryFilterF...
method createFilter (line 49) | @Override
class DummyFilter (line 55) | private static class DummyFilter extends Filter {
method shouldRun (line 56) | @Override
method describe (line 61) | @Override
FILE: src/test/java/org/junit/experimental/categories/CategoryTest.java
class CategoryTest (line 35) | public class CategoryTest {
type FastTests (line 36) | public interface FastTests {
type SlowTests (line 40) | public interface SlowTests {
type ReallySlowTests (line 44) | public interface ReallySlowTests {
class OneOfEach (line 48) | public static class OneOfEach {
method a (line 50) | @Category(FastTests.class)
method b (line 55) | @Category(SlowTests.class)
method c (line 60) | @Category(ReallySlowTests.class)
class A (line 66) | public static class A {
method a (line 67) | @Test
method b (line 72) | @Category(SlowTests.class)
class B (line 78) | @Category(SlowTests.class)
method c (line 80) | @Test
class C (line 86) | public static class C {
method d (line 87) | @Test
class SlowTestSuite (line 93) | @RunWith(Categories.class)
class JustA (line 99) | @RunWith(Categories.class)
method testCountOnJustA (line 105) | @Test
method testCount (line 110) | @Test
class Category1 (line 115) | public static class Category1 {
class Category2 (line 118) | public static class Category2 {
class SomeAreSlow (line 121) | public static class SomeAreSlow {
method noCategory (line 122) | @Test
method justCategory1 (line 126) | @Category(Category1.class)
method justCategory2 (line 131) | @Category(Category2.class)
method both (line 136) | @Category({Category1.class, Category2.class})
method bothReversed (line 141) | @Category({Category2.class, Category1.class})
class SomeAreSlowSuite (line 147) | @RunWith(Categories.class)
method testCountOnAWithoutSlowTests (line 153) | @Test
class IncludeAndExcludeSuite (line 161) | @RunWith(Categories.class)
method testsThatAreBothIncludedAndExcludedAreExcluded (line 168) | @Test
class TestSuiteWithNoCategories (line 175) | @RunWith(Suite.class)
method testCountWithExplicitIncludeFilter (line 180) | @Test
method testCountWithExplicitExcludeFilter (line 189) | @Test
method testCountWithExplicitExcludeFilter_usingConstructor (line 198) | @Test
method categoryFilterLeavesOnlyMatchingMethods (line 207) | @Test
method categoryFilterLeavesOnlyMatchingMethods_usingConstructor (line 216) | @Test
class OneFastOneSlow (line 225) | public static class OneFastOneSlow {
method a (line 226) | @Category(FastTests.class)
method b (line 232) | @Category(SlowTests.class)
method categoryFilterRejectsIncompatibleCategory (line 239) | @Test
class OneFast (line 249) | public static class OneFast {
method a (line 250) | @Category(FastTests.class)
class OneFastSuite (line 257) | @RunWith(Categories.class)
method ifNoTestsToRunUseErrorRunner (line 263) | @Test
method describeACategoryFilter (line 271) | @Test
method describeMultipleCategoryFilter (line 277) | @Test
class OneThatIsBothFastAndSlow (line 286) | public static class OneThatIsBothFastAndSlow {
method a (line 287) | @Category({FastTests.class, SlowTests.class})
class ChooseSlowFromBoth (line 294) | @RunWith(Categories.class)
method runMethodWithTwoCategories (line 300) | @Test
type VerySlowTests (line 305) | public interface VerySlowTests extends SlowTests {
class OneVerySlowTest (line 309) | public static class OneVerySlowTest {
method a (line 310) | @Category(VerySlowTests.class)
class RunSlowFromVerySlow (line 317) | @RunWith(Categories.class)
method subclassesOfIncludedCategoriesAreRun (line 323) | @Test
type MultiA (line 328) | public interface MultiA {
type MultiB (line 331) | public interface MultiB {
type MultiC (line 334) | public interface MultiC {
class AllIncludedMustBeMatchedSuite (line 337) | @RunWith(Categories.class)
class AllIncludedMustMatched (line 343) | public static class AllIncludedMustMatched {
method a (line 344) | @Test
method b (line 349) | @Test
method allIncludedSuiteCategoriesMustBeMatched (line 357) | @Test
class MultiIncludeWithExcludeCategorySuite (line 364) | @RunWith(Categories.class)
class MultipleIncludesAndExcludeOnMethod (line 371) | public static class MultipleIncludesAndExcludeOnMethod {
method a (line 372) | @Test
method b (line 377) | @Test
method anyMethodWithExcludedCategoryWillBeExcluded (line 385) | @Test
class ClassAsCategory (line 392) | public static class ClassAsCategory {
class OneMoreTest (line 395) | public static class OneMoreTest {
method a (line 396) | @Category(ClassAsCategory.class)
class RunClassAsCategory (line 402) | @RunWith(Categories.class)
method classesCanBeCategories (line 408) | @Test
class Ancestor (line 413) | @Category(SlowTests.class)
class Inherited (line 416) | public static class Inherited extends Ancestor {
method a (line 417) | @Test
type InheritanceSuite (line 422) | @RunWith(Categories.class)
method testInheritance (line 427) | @Test
class EmptyCategoriesSuite (line 434) | @RunWith(Categories.class)
method emptyCategoriesSuite (line 441) | @Test public void emptyCategoriesSuite() {
class NoTest (line 445) | @Category(Runnable.class)
class IgnoredTest (line 449) | @Category(Runnable.class)
method test (line 452) | @Ignore
class IgnoredTestCategoriesSuite (line 459) | @RunWith(Categories.class)
method ignoredTest (line 465) | @Test
class ExcludedTest1 (line 474) | @Category(Runnable.class)
method test (line 477) | @Test
class ExcludedTest2 (line 483) | @Category(Runnable.class)
method test (line 486) | @Test
class IncludedTest (line 493) | public static class IncludedTest {
method test (line 495) | @Test
class IncludedExcludedSameSuite (line 501) | @RunWith(Categories.class)
method oneRunnableOthersAvoided (line 508) | @Test
method testCountWithMultipleExcludeFilter (line 515) | @Test
method testCountWithMultipleIncludeFilter (line 527) | @Test
class NoIncludeCategoryAnnotationSuite (line 536) | @RunWith(Categories.class)
class NoIncludeCategoryAnnotationTest (line 542) | @Category(CharSequence.class)
method test2 (line 545) | @Test
method test1 (line 549) | @Test
method noIncludeCategoryAnnotation (line 554) | @Test
class SameAsNoIncludeCategoryAnnotationSuite (line 561) | @RunWith(Categories.class)
method sameAsNoIncludeCategoryAnnotation (line 568) | @Test
FILE: src/test/java/org/junit/experimental/categories/CategoryValidatorTest.java
class CategoryValidatorTest (line 16) | public class CategoryValidatorTest {
class SampleCategory (line 18) | public static class SampleCategory {
class CategoryTest (line 21) | public static class CategoryTest {
method methodWithCategoryAndBeforeClass (line 22) | @BeforeClass
method methodWithCategoryAndAfterClass (line 27) | @AfterClass
method methodWithCategoryAndBefore (line 32) | @Before
method methodWithCategoryAndAfter (line 37) | @After
method methodWithCategory (line 42) | @Category(value = SampleCategory.class)
method errorIsAddedWhenCategoryIsUsedWithBeforeClass (line 47) | @Test
method errorIsAddedWhenCategoryIsUsedWithAfterClass (line 53) | @Test
method errorIsAddedWhenCategoryIsUsedWithBefore (line 59) | @Test
method errorIsAddedWhenCategoryIsUsedWithAfter (line 65) | @Test
method testAndAssertErrorMessage (line 71) | private void testAndAssertErrorMessage(FrameworkMethod method, String ...
method errorIsNotAddedWhenCategoryIsNotCombinedWithIllegalCombination (line 79) | @Test
FILE: src/test/java/org/junit/experimental/categories/JavadocTest.java
class JavadocTest (line 19) | public class JavadocTest {
type FastTests (line 20) | public static interface FastTests {}
type SlowTests (line 21) | public static interface SlowTests {}
type SmokeTests (line 22) | public static interface SmokeTests {}
class A (line 24) | public static class A {
method a (line 25) | public void a() {
method b (line 29) | @Category(SlowTests.class)
method c (line 34) | @Category({FastTests.class, SmokeTests.class})
class B (line 40) | @Category({SlowTests.class, FastTests.class})
method d (line 42) | @Test
class SlowTestSuite (line 47) | @RunWith(Categories.class)
class FastOrSmokeTestSuite (line 54) | @RunWith(Categories.class)
method slowTests (line 61) | @Test
method fastSmokeTests (line 69) | @Test
FILE: src/test/java/org/junit/experimental/categories/MultiCategoryTest.java
class MultiCategoryTest (line 20) | public final class MultiCategoryTest {
type A (line 21) | public interface A {}
type B (line 22) | public interface B {}
type C (line 23) | public interface C {}
method runSuite (line 29) | @Test
class MultiCategorySuite (line 39) | @RunWith(Categories.class)
class CategoriesTest (line 45) | public static final class CategoriesTest {
method a (line 47) | @Test
method b (line 51) | @Test
method c (line 55)
Condensed preview — 560 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (2,018K chars).
[
{
"path": ".gitattributes",
"chars": 988,
"preview": "* text eol=lf\n*.gif binary\n*.GIF binary\n*.jar binary\n*.png binary\n*.jpg binary\n*.svg text eol=lf\n\n# These files do not h"
},
{
"path": ".github/ISSUE_TEMPLATE/bug_report.md",
"chars": 445,
"preview": "---\nname: Report a critical bug\nabout: Please only report critical bugs since the project is in maintenance mode\ntype: B"
},
{
"path": ".github/ISSUE_TEMPLATE/config.yml",
"chars": 28,
"preview": "blank_issues_enabled: false\n"
},
{
"path": ".github/PULL_REQUEST_TEMPLATE.md",
"chars": 418,
"preview": "> [!IMPORTANT] \n> **JUnit 4 is in maintenance mode.**\n>\n> At this point, only critical bugs and security issues will be"
},
{
"path": ".github/workflows/main.yml",
"chars": 1936,
"preview": "name: CI\n\non:\n push:\n branches:\n - main\n pull_request:\n branches:\n - '*'\n\npermissions:\n contents: rea"
},
{
"path": ".github/workflows/settings.xml",
"chars": 468,
"preview": "<settings xmlns=\"http://maven.apache.org/SETTINGS/1.0.0\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n "
},
{
"path": ".gitignore",
"chars": 108,
"preview": "MaxCore.ser\nbin\njunit4.*\ntarget\nMaxCore.max\n# IntelliJ\n.idea\n*.ipr\n*.iml\n*.iws\nout\njava.hprof.txt\n.DS_Store\n"
},
{
"path": ".mvn/wrapper/maven-wrapper.properties",
"chars": 922,
"preview": "# Licensed to the Apache Software Foundation (ASF) under one\n# or more contributor license agreements. See the NOTICE f"
},
{
"path": ".settings/org.eclipse.jdt.core.prefs",
"chars": 28431,
"preview": "#Mon Oct 12 21:57:10 EDT 2009\neclipse.preferences.version=1\norg.eclipse.jdt.core.codeComplete.argumentPrefixes=\norg.ecli"
},
{
"path": ".settings/org.eclipse.jdt.ui.prefs",
"chars": 559,
"preview": "#Tue Jul 22 09:31:38 PDT 2008\neclipse.preferences.version=1\nformatter_profile=_junit\nformatter_settings_version=11\ninter"
},
{
"path": "BUILDING",
"chars": 447,
"preview": "BUILDING FROM GITHUB:\n=====================\n\ngit clone https://github.com/junit-team/junit4.git\ncd junit4\nmvn install\n\nB"
},
{
"path": "CODING_STYLE.txt",
"chars": 480,
"preview": "JUnit project uses the Google Java Style (https://github.com/google/styleguide) for all new\ncode (under org.junit.*). De"
},
{
"path": "CONTRIBUTING.md",
"chars": 2810,
"preview": "## Project License: Eclipse Public License v1.0\n\n- You will only Submit Contributions where You have authored 100% of t"
},
{
"path": "KEYS",
"chars": 3833,
"preview": "This file contains the PGP key that is used to sign releases.\n\nImporting: `pgp < KEYS` or `gpg --import KEYS`\n\nAdding a "
},
{
"path": "LEGACY_CODING_STYLE.txt",
"chars": 2717,
"preview": "==================================\nCoding style\n==================================\n\n----------------------------------\nT"
},
{
"path": "LICENSE-junit.txt",
"chars": 11376,
"preview": "JUnit\n\nEclipse Public License - v 1.0\n\nTHE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC\nLICEN"
},
{
"path": "NOTICE.txt",
"chars": 335,
"preview": " ===================================================================================\n == Notices and attributions r"
},
{
"path": "README.md",
"chars": 842,
"preview": "# JUnit 4\nJUnit is a simple framework to write repeatable tests. It is an instance of the xUnit architecture for unit te"
},
{
"path": "SECURITY.md",
"chars": 285,
"preview": "# Security Policy\n\n## Supported Versions\n\n| Version | Supported |\n| ------- | ------------------ |\n| 4.13.x | "
},
{
"path": "acknowledgements.txt",
"chars": 5613,
"preview": "2006 March 9\n\tMatthias Schmidt: improved org.junit package javadoc\n\t\n2006 August 3\n\tgiovanni: better test for TestCase w"
},
{
"path": "doc/ReleaseNotes4.10.html",
"chars": 3580,
"preview": "<h2>Summary of Changes in version 4.10</h2>\n\n<p>A full summary of commits between 4.9 and 4.10 is on <a href=\"https://gi"
},
{
"path": "doc/ReleaseNotes4.10.md",
"chars": 3276,
"preview": "## Summary of Changes in version 4.10 ##\n\nThanks to a full cast of contributors of bug fixes and new features.\n\nA full s"
},
{
"path": "doc/ReleaseNotes4.10.txt",
"chars": 31,
"preview": "Please see ReleaseNotes4.10.md\n"
},
{
"path": "doc/ReleaseNotes4.11.html",
"chars": 5712,
"preview": "<h2>Summary of changes in version 4.11</h2>\n\n<h3>Matchers: Upgrade to Hamcrest 1.3</h3>\n\n<p>JUnit now uses the latest ve"
},
{
"path": "doc/ReleaseNotes4.11.md",
"chars": 4918,
"preview": "## Summary of changes in version 4.11\n\n### Matchers: Upgrade to Hamcrest 1.3\n\nJUnit now uses the latest version of Hamcr"
},
{
"path": "doc/ReleaseNotes4.11.txt",
"chars": 31,
"preview": "Please see ReleaseNotes4.11.md\n"
},
{
"path": "doc/ReleaseNotes4.12.md",
"chars": 36791,
"preview": "## Summary of changes in version 4.12\n\n# Assertions\n\n### [Pull request #611:](https://github.com/junit-team/junit4/pull/"
},
{
"path": "doc/ReleaseNotes4.13.1.md",
"chars": 731,
"preview": "## Summary of changes in version 4.13.1\n\n# Rules\n\n### Security fix: `TemporaryFolder` now limits access to temporary fol"
},
{
"path": "doc/ReleaseNotes4.13.2.md",
"chars": 2411,
"preview": "## Summary of changes in version 4.13.2\n\n# Rules\n\n### [Pull request #1687:](https://github.com/junit-team/junit/pull/168"
},
{
"path": "doc/ReleaseNotes4.13.md",
"chars": 23959,
"preview": "## Summary of changes in version 4.13\n\n# Assertions\n\n### [Pull request #1054:](https://github.com/junit-team/junit/pull/"
},
{
"path": "doc/ReleaseNotes4.4.html",
"chars": 12213,
"preview": "<h2>Summary of Changes in version 4.5</h2>\n\n<h3>Categories</h3>\n\n<p>Each test method and test class can be annotated as "
},
{
"path": "doc/ReleaseNotes4.4.md",
"chars": 11667,
"preview": "## Summary of Changes in version 4.5 ##\n\n### Categories ###\nEach test method and test class can be annotated as belongin"
},
{
"path": "doc/ReleaseNotes4.4.txt",
"chars": 30,
"preview": "Please see ReleaseNotes4.4.md\n"
},
{
"path": "doc/ReleaseNotes4.5.html",
"chars": 15379,
"preview": "<h2>Summary of Changes in version 4.5</h2>\n\n<h3>Installation</h3>\n\n<ul>\n<li>We are releasing <code>junit-4.5.jar</code>,"
},
{
"path": "doc/ReleaseNotes4.5.md",
"chars": 3457,
"preview": "## Summary of Changes in version 4.5 ##\n\n### Installation ###\n\n- We are releasing `junit-4.5.jar`, which contains all th"
},
{
"path": "doc/ReleaseNotes4.5.txt",
"chars": 30,
"preview": "Please see ReleaseNotes4.5.md\n"
},
{
"path": "doc/ReleaseNotes4.6.html",
"chars": 3463,
"preview": "<h2>Summary of Changes in version 4.6</h2>\n\n<h3>Max</h3>\n\n<p>JUnit now includes a new experimental Core, <code>MaxCore</"
},
{
"path": "doc/ReleaseNotes4.6.md",
"chars": 3034,
"preview": "## Summary of Changes in version 4.6 ##\n\n### Max ###\n\nJUnit now includes a new experimental Core, `MaxCore`. `MaxCore`\n"
},
{
"path": "doc/ReleaseNotes4.6.txt",
"chars": 30,
"preview": "Please see ReleaseNotes4.6.md\n"
},
{
"path": "doc/ReleaseNotes4.7.html",
"chars": 5841,
"preview": "<h2>Summary of Changes in version 4.7</h2>\n\n<h3>Rules</h3>\n\n<ul>\n<li><p>Rules allow very flexible addition or redefiniti"
},
{
"path": "doc/ReleaseNotes4.7.md",
"chars": 5317,
"preview": "## Summary of Changes in version 4.7 ##\n\n### Rules ###\n\n- Rules allow very flexible addition or redefinition of the beha"
},
{
"path": "doc/ReleaseNotes4.7.txt",
"chars": 30,
"preview": "Please see ReleaseNotes4.7.md\n"
},
{
"path": "doc/ReleaseNotes4.8.1.html",
"chars": 208,
"preview": "<h2>Summary of Changes in version 4.8.1</h2>\n\n<p>This was a quick bugfix release for an important bug</p>\n\n<h3>Bug fixes"
},
{
"path": "doc/ReleaseNotes4.8.1.md",
"chars": 178,
"preview": "## Summary of Changes in version 4.8.1 ##\n\nThis was a quick bugfix release for an important bug\n\n### Bug fixes ###\n\n- gi"
},
{
"path": "doc/ReleaseNotes4.8.1.txt",
"chars": 32,
"preview": "Please see ReleaseNotes4.8.1.md\n"
},
{
"path": "doc/ReleaseNotes4.8.2.html",
"chars": 219,
"preview": "<h2>Summary of Changes in version 4.8.2</h2>\n\n<p>This was a quick bugfix release</p>\n\n<h3>Bug fixes</h3>\n\n<ul>\n<li>githu"
},
{
"path": "doc/ReleaseNotes4.8.2.md",
"chars": 192,
"preview": "## Summary of Changes in version 4.8.2 ##\n\nThis was a quick bugfix release\n\n### Bug fixes ###\n\n- github#96: TestSuite(My"
},
{
"path": "doc/ReleaseNotes4.8.2.txt",
"chars": 32,
"preview": "Please see ReleaseNotes4.8.2.md\n"
},
{
"path": "doc/ReleaseNotes4.8.html",
"chars": 1545,
"preview": "<h2>Summary of Changes in version 4.8</h2>\n\n<h3>Categories</h3>\n\n<p>From a given set of test classes, the <code>Categori"
},
{
"path": "doc/ReleaseNotes4.8.md",
"chars": 1395,
"preview": "## Summary of Changes in version 4.8 ##\n\n### Categories ###\n\nFrom a given set of test classes, the `Categories` runner\nr"
},
{
"path": "doc/ReleaseNotes4.8.txt",
"chars": 30,
"preview": "Please see ReleaseNotes4.8.md\n"
},
{
"path": "doc/ReleaseNotes4.9.1.md",
"chars": 643,
"preview": "## Summary of Changes in version 4.9.1 [unreleased!] ##\n\n### Theories ###\n\nThe `Theories` runner does not anticipate the"
},
{
"path": "doc/ReleaseNotes4.9.1.txt",
"chars": 32,
"preview": "Please see ReleaseNotes4.9.1.md\n"
},
{
"path": "doc/ReleaseNotes4.9.html",
"chars": 3471,
"preview": "<h2>Summary of Changes in version 4.9, final</h2>\n\n<p>Release theme: Test-class and suite level Rules.</p>\n\n<h3>ClassRul"
},
{
"path": "doc/ReleaseNotes4.9.md",
"chars": 3022,
"preview": "## Summary of Changes in version 4.9, final ##\n\nRelease theme: Test-class and suite level Rules.\n\n### ClassRule ###\n\nThe"
},
{
"path": "doc/ReleaseNotes4.9.txt",
"chars": 30,
"preview": "Please see ReleaseNotes4.9.md\n"
},
{
"path": "doc/building-junit.txt",
"chars": 4498,
"preview": "Steps to build junit:\n\n- Must be manual\n - Write release notes\n- Not too tedious:\n - Push to github (junit-team)\n - R"
},
{
"path": "doc/cookstour/cookstour.htm",
"chars": 38225,
"preview": "<!doctype html public \"-//w3c//dtd html 4.0 transitional//en\">\n<html>\n<head>\n <meta http-equiv=\"Content-Type\" content="
},
{
"path": "doc/markdown.sh",
"chars": 59,
"preview": "~/bin/Markdown.pl ReleaseNotes4.8.txt >ReleaseNotes4.8.html"
},
{
"path": "doc/testinfected/testing.htm",
"chars": 31473,
"preview": "<!doctype html public \"-//w3c//dtd html 4.0 transitional//en\">\n<html>\n<head>\n <meta http-equiv=\"Content-Type\" content="
},
{
"path": "epl-v10.html",
"chars": 12637,
"preview": "<?xml version=\"1.0\" encoding=\"ISO-8859-1\" ?>\n<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www."
},
{
"path": "mvnw",
"chars": 10294,
"preview": "#!/bin/sh\n# ----------------------------------------------------------------------------\n# Licensed to the Apache Softwa"
},
{
"path": "mvnw.cmd",
"chars": 6797,
"preview": "<# : batch portion\n@REM ----------------------------------------------------------------------------\n@REM Licensed to th"
},
{
"path": "pom.xml",
"chars": 28723,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project xmlns=\"http://maven.apache.org/POM/4.0.0\" xmlns:xsi=\"http://www.w3.org/2"
},
{
"path": "src/main/java/junit/extensions/ActiveTestSuite.java",
"chars": 1783,
"preview": "package junit.extensions;\n\nimport junit.framework.Test;\nimport junit.framework.TestCase;\nimport junit.framework.TestResu"
},
{
"path": "src/main/java/junit/extensions/RepeatedTest.java",
"chars": 887,
"preview": "package junit.extensions;\n\nimport junit.framework.Test;\nimport junit.framework.TestResult;\n\n/**\n * A Decorator that runs"
},
{
"path": "src/main/java/junit/extensions/TestDecorator.java",
"chars": 936,
"preview": "package junit.extensions;\n\nimport junit.framework.Assert;\nimport junit.framework.Test;\nimport junit.framework.TestResult"
},
{
"path": "src/main/java/junit/extensions/TestSetup.java",
"chars": 1057,
"preview": "package junit.extensions;\n\nimport junit.framework.Protectable;\nimport junit.framework.Test;\nimport junit.framework.TestR"
},
{
"path": "src/main/java/junit/extensions/package-info.java",
"chars": 84,
"preview": "/**\n * Provides extended functionality for JUnit v3.x.\n */\npackage junit.extensions;"
},
{
"path": "src/main/java/junit/framework/Assert.java",
"chars": 10824,
"preview": "package junit.framework;\n\n/**\n * A set of assert methods. Messages are only displayed when an assert fails.\n *\n * @depr"
},
{
"path": "src/main/java/junit/framework/AssertionFailedError.java",
"chars": 820,
"preview": "package junit.framework;\n\n/**\n * Thrown when an assertion failed.\n */\npublic class AssertionFailedError extends Assertio"
},
{
"path": "src/main/java/junit/framework/ComparisonCompactor.java",
"chars": 2673,
"preview": "package junit.framework;\n\npublic class ComparisonCompactor {\n\n private static final String ELLIPSIS = \"...\";\n priv"
},
{
"path": "src/main/java/junit/framework/ComparisonFailure.java",
"chars": 1432,
"preview": "package junit.framework;\n\n/**\n * Thrown when an assert equals for Strings failed.\n *\n * Inspired by a patch from Alex Ch"
},
{
"path": "src/main/java/junit/framework/JUnit4TestAdapter.java",
"chars": 3052,
"preview": "package junit.framework;\n\nimport java.util.List;\n\nimport org.junit.Ignore;\nimport org.junit.runner.Describable;\nimport o"
},
{
"path": "src/main/java/junit/framework/JUnit4TestAdapterCache.java",
"chars": 2524,
"preview": "package junit.framework;\n\nimport java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.HashMap;\nimport java.uti"
},
{
"path": "src/main/java/junit/framework/JUnit4TestCaseFacade.java",
"chars": 699,
"preview": "package junit.framework;\n\nimport org.junit.runner.Describable;\nimport org.junit.runner.Description;\n\npublic class JUnit4"
},
{
"path": "src/main/java/junit/framework/Protectable.java",
"chars": 266,
"preview": "package junit.framework;\n\n/**\n * A <em>Protectable</em> can be run and can throw a Throwable.\n *\n * @see TestResult\n */\n"
},
{
"path": "src/main/java/junit/framework/Test.java",
"chars": 399,
"preview": "package junit.framework;\n\n/**\n * A <em>Test</em> can be run and collect its results.\n *\n * @see TestResult\n */\npublic in"
},
{
"path": "src/main/java/junit/framework/TestCase.java",
"chars": 15374,
"preview": "package junit.framework;\n\nimport java.lang.reflect.InvocationTargetException;\nimport java.lang.reflect.Method;\nimport ja"
},
{
"path": "src/main/java/junit/framework/TestFailure.java",
"chars": 1629,
"preview": "package junit.framework;\n\nimport org.junit.internal.Throwables;\n\n\n/**\n * A {@code TestFailure} collects a failed test to"
},
{
"path": "src/main/java/junit/framework/TestListener.java",
"chars": 450,
"preview": "package junit.framework;\n\n/**\n * A Listener for test progress\n */\npublic interface TestListener {\n /**\n * An erro"
},
{
"path": "src/main/java/junit/framework/TestResult.java",
"chars": 4705,
"preview": "package junit.framework;\n\nimport java.util.ArrayList;\nimport java.util.Collections;\nimport java.util.Enumeration;\nimport"
},
{
"path": "src/main/java/junit/framework/TestSuite.java",
"chars": 9013,
"preview": "package junit.framework;\n\nimport java.lang.reflect.Constructor;\nimport java.lang.reflect.InvocationTargetException;\nimpo"
},
{
"path": "src/main/java/junit/framework/package-info.java",
"chars": 69,
"preview": "/**\n * Provides JUnit v3.x core classes.\n */\npackage junit.framework;"
},
{
"path": "src/main/java/junit/runner/BaseTestRunner.java",
"chars": 9764,
"preview": "package junit.runner;\n\nimport java.io.BufferedReader;\nimport java.io.File;\nimport java.io.FileInputStream;\nimport java.i"
},
{
"path": "src/main/java/junit/runner/TestRunListener.java",
"chars": 633,
"preview": "package junit.runner;\n\n/**\n * A listener interface for observing the\n * execution of a test run. Unlike TestListener,\n *"
},
{
"path": "src/main/java/junit/runner/Version.java",
"chars": 290,
"preview": "package junit.runner;\n\n/**\n * This class defines the current version of JUnit\n */\npublic class Version {\n\tprivate Versio"
},
{
"path": "src/main/java/junit/runner/Version.java.template",
"chars": 284,
"preview": "package junit.runner;\n\n/**\n * This class defines the current version of JUnit\n */\npublic class Version {\n\tprivate Versio"
},
{
"path": "src/main/java/junit/runner/package-info.java",
"chars": 66,
"preview": "/**\n * Provides JUnit v3.x test runners.\n */\npackage junit.runner;"
},
{
"path": "src/main/java/junit/textui/ResultPrinter.java",
"chars": 4065,
"preview": "package junit.textui;\n\nimport java.io.PrintStream;\nimport java.text.NumberFormat;\nimport java.util.Enumeration;\n\nimport "
},
{
"path": "src/main/java/junit/textui/TestRunner.java",
"chars": 5872,
"preview": "package junit.textui;\n\n\nimport java.io.PrintStream;\n\nimport junit.framework.Test;\nimport junit.framework.TestCase;\nimpor"
},
{
"path": "src/main/java/junit/textui/package-info.java",
"chars": 90,
"preview": "/**\n * Provides JUnit v3.x command line based tool to run tests.\n */\npackage junit.textui;"
},
{
"path": "src/main/java/org/junit/After.java",
"chars": 1290,
"preview": "package org.junit;\n\nimport java.lang.annotation.ElementType;\nimport java.lang.annotation.Retention;\nimport java.lang.ann"
},
{
"path": "src/main/java/org/junit/AfterClass.java",
"chars": 1440,
"preview": "package org.junit;\n\nimport java.lang.annotation.ElementType;\nimport java.lang.annotation.Retention;\nimport java.lang.ann"
},
{
"path": "src/main/java/org/junit/Assert.java",
"chars": 40581,
"preview": "package org.junit;\n\nimport org.hamcrest.Matcher;\nimport org.hamcrest.MatcherAssert;\nimport org.junit.function.ThrowingRu"
},
{
"path": "src/main/java/org/junit/Assume.java",
"chars": 6166,
"preview": "package org.junit;\n\nimport static java.util.Arrays.asList;\nimport static org.hamcrest.CoreMatchers.everyItem;\nimport sta"
},
{
"path": "src/main/java/org/junit/AssumptionViolatedException.java",
"chars": 1436,
"preview": "package org.junit;\n\nimport org.hamcrest.Matcher;\n\n/**\n * An exception class used to implement <i>assumptions</i> (state "
},
{
"path": "src/main/java/org/junit/Before.java",
"chars": 1118,
"preview": "package org.junit;\n\nimport java.lang.annotation.ElementType;\nimport java.lang.annotation.Retention;\nimport java.lang.ann"
},
{
"path": "src/main/java/org/junit/BeforeClass.java",
"chars": 1123,
"preview": "package org.junit;\n\nimport java.lang.annotation.ElementType;\nimport java.lang.annotation.Retention;\nimport java.lang.ann"
},
{
"path": "src/main/java/org/junit/ClassRule.java",
"chars": 3993,
"preview": "package org.junit;\n\nimport java.lang.annotation.ElementType;\nimport java.lang.annotation.Retention;\nimport java.lang.ann"
},
{
"path": "src/main/java/org/junit/ComparisonFailure.java",
"chars": 6080,
"preview": "package org.junit;\n\n/**\n * Thrown when an {@link org.junit.Assert#assertEquals(Object, Object) assertEquals(String, Stri"
},
{
"path": "src/main/java/org/junit/FixMethodOrder.java",
"chars": 1442,
"preview": "package org.junit;\n\nimport java.lang.annotation.ElementType;\nimport java.lang.annotation.Retention;\nimport java.lang.ann"
},
{
"path": "src/main/java/org/junit/Ignore.java",
"chars": 1454,
"preview": "package org.junit;\n\nimport java.lang.annotation.ElementType;\nimport java.lang.annotation.Retention;\nimport java.lang.ann"
},
{
"path": "src/main/java/org/junit/Rule.java",
"chars": 3310,
"preview": "package org.junit;\n\nimport java.lang.annotation.ElementType;\nimport java.lang.annotation.Retention;\nimport java.lang.ann"
},
{
"path": "src/main/java/org/junit/Test.java",
"chars": 4920,
"preview": "package org.junit;\n\nimport org.junit.function.ThrowingRunnable;\n\nimport java.lang.annotation.ElementType;\nimport java.la"
},
{
"path": "src/main/java/org/junit/TestCouldNotBeSkippedException.java",
"chars": 715,
"preview": "package org.junit;\n\n/**\n * Indicates that a test that indicated that it should be skipped could not be skipped.\n * This "
},
{
"path": "src/main/java/org/junit/experimental/ParallelComputer.java",
"chars": 2167,
"preview": "package org.junit.experimental;\n\nimport java.util.concurrent.ExecutorService;\nimport java.util.concurrent.Executors;\nimp"
},
{
"path": "src/main/java/org/junit/experimental/categories/Categories.java",
"chars": 14022,
"preview": "package org.junit.experimental.categories;\n\nimport java.lang.annotation.Retention;\nimport java.lang.annotation.Retention"
},
{
"path": "src/main/java/org/junit/experimental/categories/Category.java",
"chars": 1034,
"preview": "package org.junit.experimental.categories;\n\nimport java.lang.annotation.Inherited;\nimport java.lang.annotation.Retention"
},
{
"path": "src/main/java/org/junit/experimental/categories/CategoryFilterFactory.java",
"chars": 1799,
"preview": "package org.junit.experimental.categories;\r\n\r\nimport java.util.ArrayList;\r\nimport java.util.List;\r\n\r\nimport org.junit.in"
},
{
"path": "src/main/java/org/junit/experimental/categories/CategoryValidator.java",
"chars": 2184,
"preview": "package org.junit.experimental.categories;\n\nimport static java.util.Arrays.asList;\nimport static java.util.Collections.u"
},
{
"path": "src/main/java/org/junit/experimental/categories/ExcludeCategories.java",
"chars": 1546,
"preview": "package org.junit.experimental.categories;\r\n\r\nimport java.util.HashSet;\r\nimport java.util.List;\r\nimport java.util.Set;\r\n"
},
{
"path": "src/main/java/org/junit/experimental/categories/IncludeCategories.java",
"chars": 1542,
"preview": "package org.junit.experimental.categories;\r\n\r\nimport java.util.HashSet;\r\nimport java.util.List;\r\nimport java.util.Set;\r\n"
},
{
"path": "src/main/java/org/junit/experimental/max/CouldNotReadCoreException.java",
"chars": 327,
"preview": "package org.junit.experimental.max;\n\n/**\n * Thrown when Max cannot read the MaxCore serialization\n */\npublic class Could"
},
{
"path": "src/main/java/org/junit/experimental/max/MaxCore.java",
"chars": 6413,
"preview": "package org.junit.experimental.max;\n\nimport java.io.File;\nimport java.util.ArrayList;\nimport java.util.Collections;\nimpo"
},
{
"path": "src/main/java/org/junit/experimental/max/MaxHistory.java",
"chars": 5516,
"preview": "package org.junit.experimental.max;\n\nimport java.io.File;\nimport java.io.FileInputStream;\nimport java.io.FileOutputStrea"
},
{
"path": "src/main/java/org/junit/experimental/results/FailureList.java",
"chars": 745,
"preview": "package org.junit.experimental.results;\n\nimport java.util.List;\n\nimport org.junit.runner.Result;\nimport org.junit.runner"
},
{
"path": "src/main/java/org/junit/experimental/results/PrintableResult.java",
"chars": 1824,
"preview": "package org.junit.experimental.results;\n\nimport java.io.ByteArrayOutputStream;\nimport java.io.PrintStream;\nimport java.u"
},
{
"path": "src/main/java/org/junit/experimental/results/ResultMatchers.java",
"chars": 3108,
"preview": "package org.junit.experimental.results;\n\nimport org.hamcrest.BaseMatcher;\nimport org.hamcrest.Description;\nimport org.ha"
},
{
"path": "src/main/java/org/junit/experimental/runners/Enclosed.java",
"chars": 1512,
"preview": "package org.junit.experimental.runners;\n\nimport java.lang.reflect.Modifier;\nimport java.util.ArrayList;\nimport java.util"
},
{
"path": "src/main/java/org/junit/experimental/theories/DataPoint.java",
"chars": 2116,
"preview": "package org.junit.experimental.theories;\n\nimport static java.lang.annotation.ElementType.FIELD;\nimport static java.lang."
},
{
"path": "src/main/java/org/junit/experimental/theories/DataPoints.java",
"chars": 2556,
"preview": "package org.junit.experimental.theories;\n\nimport static java.lang.annotation.ElementType.FIELD;\nimport static java.lang."
},
{
"path": "src/main/java/org/junit/experimental/theories/FromDataPoints.java",
"chars": 2006,
"preview": "package org.junit.experimental.theories;\n\nimport java.lang.annotation.ElementType;\nimport java.lang.annotation.Retention"
},
{
"path": "src/main/java/org/junit/experimental/theories/ParameterSignature.java",
"chars": 4625,
"preview": "package org.junit.experimental.theories;\n\nimport java.lang.annotation.Annotation;\nimport java.lang.reflect.Constructor;\n"
},
{
"path": "src/main/java/org/junit/experimental/theories/ParameterSupplier.java",
"chars": 1658,
"preview": "package org.junit.experimental.theories;\n\nimport java.util.List;\n\n/**\n * Abstract parent class for suppliers of input da"
},
{
"path": "src/main/java/org/junit/experimental/theories/ParametersSuppliedBy.java",
"chars": 1463,
"preview": "package org.junit.experimental.theories;\n\nimport static java.lang.annotation.ElementType.ANNOTATION_TYPE;\nimport static "
},
{
"path": "src/main/java/org/junit/experimental/theories/PotentialAssignment.java",
"chars": 1604,
"preview": "package org.junit.experimental.theories;\n\nimport static java.lang.String.format;\n\npublic abstract class PotentialAssignm"
},
{
"path": "src/main/java/org/junit/experimental/theories/Theories.java",
"chars": 13032,
"preview": "package org.junit.experimental.theories;\n\nimport java.lang.reflect.Constructor;\nimport java.lang.reflect.Field;\nimport j"
},
{
"path": "src/main/java/org/junit/experimental/theories/Theory.java",
"chars": 528,
"preview": "package org.junit.experimental.theories;\n\nimport static java.lang.annotation.ElementType.METHOD;\n\nimport java.lang.annot"
},
{
"path": "src/main/java/org/junit/experimental/theories/internal/AllMembersSupplier.java",
"chars": 7788,
"preview": "package org.junit.experimental.theories.internal;\n\nimport java.lang.reflect.Array;\nimport java.lang.reflect.Field;\nimpor"
},
{
"path": "src/main/java/org/junit/experimental/theories/internal/Assignments.java",
"chars": 5467,
"preview": "package org.junit.experimental.theories.internal;\n\nimport static java.util.Collections.emptyList;\n\nimport java.lang.refl"
},
{
"path": "src/main/java/org/junit/experimental/theories/internal/BooleanSupplier.java",
"chars": 587,
"preview": "package org.junit.experimental.theories.internal;\n\nimport java.util.Arrays;\nimport java.util.List;\n\nimport org.junit.exp"
},
{
"path": "src/main/java/org/junit/experimental/theories/internal/EnumSupplier.java",
"chars": 883,
"preview": "package org.junit.experimental.theories.internal;\n\nimport java.util.ArrayList;\nimport java.util.List;\n\nimport org.junit."
},
{
"path": "src/main/java/org/junit/experimental/theories/internal/ParameterizedAssertionError.java",
"chars": 1488,
"preview": "package org.junit.experimental.theories.internal;\n\nimport java.util.Arrays;\nimport java.util.Collection;\nimport java.uti"
},
{
"path": "src/main/java/org/junit/experimental/theories/internal/SpecificDataPointsSupplier.java",
"chars": 3411,
"preview": "package org.junit.experimental.theories.internal;\n\nimport java.lang.reflect.Field;\nimport java.util.ArrayList;\nimport ja"
},
{
"path": "src/main/java/org/junit/experimental/theories/suppliers/TestedOn.java",
"chars": 1001,
"preview": "package org.junit.experimental.theories.suppliers;\n\nimport static java.lang.annotation.ElementType.PARAMETER;\n\nimport ja"
},
{
"path": "src/main/java/org/junit/experimental/theories/suppliers/TestedOnSupplier.java",
"chars": 875,
"preview": "package org.junit.experimental.theories.suppliers;\n\nimport java.util.ArrayList;\nimport java.util.List;\n\nimport org.junit"
},
{
"path": "src/main/java/org/junit/function/ThrowingRunnable.java",
"chars": 443,
"preview": "package org.junit.function;\n\n/**\n * This interface facilitates the use of\n * {@link org.junit.Assert#assertThrows(Class,"
},
{
"path": "src/main/java/org/junit/internal/ArrayComparisonFailure.java",
"chars": 2061,
"preview": "package org.junit.internal;\n\nimport java.util.ArrayList;\nimport java.util.List;\n\nimport org.junit.Assert;\n\n/**\n * Thrown"
},
{
"path": "src/main/java/org/junit/internal/AssumptionViolatedException.java",
"chars": 5025,
"preview": "package org.junit.internal;\n\nimport java.io.IOException;\nimport java.io.ObjectOutputStream;\n\nimport org.hamcrest.Descrip"
},
{
"path": "src/main/java/org/junit/internal/Checks.java",
"chars": 1093,
"preview": "package org.junit.internal;\n\n/** @since 4.13 */\npublic final class Checks {\n\n private Checks() {}\n\n /**\n * Che"
},
{
"path": "src/main/java/org/junit/internal/Classes.java",
"chars": 1418,
"preview": "package org.junit.internal;\r\n\r\nimport static java.lang.Thread.currentThread;\r\n\r\n/**\r\n * Miscellaneous functions dealing "
},
{
"path": "src/main/java/org/junit/internal/ComparisonCriteria.java",
"chars": 5098,
"preview": "package org.junit.internal;\n\nimport java.lang.reflect.Array;\nimport java.util.Arrays;\n\nimport org.junit.Assert;\n\n/**\n * "
},
{
"path": "src/main/java/org/junit/internal/ExactComparisonCriteria.java",
"chars": 263,
"preview": "package org.junit.internal;\n\nimport org.junit.Assert;\n\npublic class ExactComparisonCriteria extends ComparisonCriteria {"
},
{
"path": "src/main/java/org/junit/internal/InexactComparisonCriteria.java",
"chars": 649,
"preview": "package org.junit.internal;\n\nimport org.junit.Assert;\n\npublic class InexactComparisonCriteria extends ComparisonCriteria"
},
{
"path": "src/main/java/org/junit/internal/JUnitSystem.java",
"chars": 222,
"preview": "package org.junit.internal;\n\nimport java.io.PrintStream;\n\npublic interface JUnitSystem {\n\n /**\n * Will be removed"
},
{
"path": "src/main/java/org/junit/internal/MethodSorter.java",
"chars": 2418,
"preview": "package org.junit.internal;\n\nimport java.lang.reflect.Method;\nimport java.util.Arrays;\nimport java.util.Comparator;\n\nimp"
},
{
"path": "src/main/java/org/junit/internal/RealSystem.java",
"chars": 323,
"preview": "package org.junit.internal;\n\nimport java.io.PrintStream;\n\npublic class RealSystem implements JUnitSystem {\n\n /**\n "
},
{
"path": "src/main/java/org/junit/internal/SerializableMatcherDescription.java",
"chars": 1902,
"preview": "package org.junit.internal;\n\nimport java.io.Serializable;\n\nimport org.hamcrest.BaseMatcher;\nimport org.hamcrest.Descript"
},
{
"path": "src/main/java/org/junit/internal/SerializableValueDescription.java",
"chars": 1475,
"preview": "package org.junit.internal;\n\nimport java.io.Serializable;\n\n/**\n * This class exists solely to provide a serializable des"
},
{
"path": "src/main/java/org/junit/internal/TextListener.java",
"chars": 2771,
"preview": "package org.junit.internal;\n\nimport java.io.PrintStream;\nimport java.text.NumberFormat;\nimport java.util.List;\n\nimport o"
},
{
"path": "src/main/java/org/junit/internal/Throwables.java",
"chars": 9765,
"preview": "package org.junit.internal;\n\nimport java.io.BufferedReader;\nimport java.io.IOException;\nimport java.io.PrintWriter;\nimpo"
},
{
"path": "src/main/java/org/junit/internal/builders/AllDefaultPossibilitiesBuilder.java",
"chars": 1726,
"preview": "package org.junit.internal.builders;\n\nimport java.util.Arrays;\nimport java.util.List;\n\nimport org.junit.runner.Runner;\ni"
},
{
"path": "src/main/java/org/junit/internal/builders/AnnotatedBuilder.java",
"chars": 4267,
"preview": "package org.junit.internal.builders;\n\nimport org.junit.runner.RunWith;\nimport org.junit.runner.Runner;\nimport org.junit."
},
{
"path": "src/main/java/org/junit/internal/builders/IgnoredBuilder.java",
"chars": 416,
"preview": "package org.junit.internal.builders;\n\nimport org.junit.Ignore;\nimport org.junit.runner.Runner;\nimport org.junit.runners."
},
{
"path": "src/main/java/org/junit/internal/builders/IgnoredClassRunner.java",
"chars": 566,
"preview": "package org.junit.internal.builders;\n\nimport org.junit.runner.Description;\nimport org.junit.runner.Runner;\nimport org.ju"
},
{
"path": "src/main/java/org/junit/internal/builders/JUnit3Builder.java",
"chars": 564,
"preview": "package org.junit.internal.builders;\n\nimport org.junit.internal.runners.JUnit38ClassRunner;\nimport org.junit.runner.Runn"
},
{
"path": "src/main/java/org/junit/internal/builders/JUnit4Builder.java",
"chars": 333,
"preview": "package org.junit.internal.builders;\n\nimport org.junit.runner.Runner;\nimport org.junit.runners.JUnit4;\nimport org.junit."
},
{
"path": "src/main/java/org/junit/internal/builders/NullBuilder.java",
"chars": 275,
"preview": "package org.junit.internal.builders;\n\nimport org.junit.runner.Runner;\nimport org.junit.runners.model.RunnerBuilder;\n\npub"
},
{
"path": "src/main/java/org/junit/internal/builders/SuiteMethodBuilder.java",
"chars": 637,
"preview": "package org.junit.internal.builders;\n\nimport org.junit.internal.runners.SuiteMethod;\nimport org.junit.runner.Runner;\nimp"
},
{
"path": "src/main/java/org/junit/internal/management/FakeRuntimeMXBean.java",
"chars": 395,
"preview": "package org.junit.internal.management;\n\nimport java.util.Collections;\nimport java.util.List;\n\n/**\n * No-op implementatio"
},
{
"path": "src/main/java/org/junit/internal/management/FakeThreadMXBean.java",
"chars": 513,
"preview": "package org.junit.internal.management;\n\n/**\n * No-op implementation of ThreadMXBean when the platform doesn't provide it"
},
{
"path": "src/main/java/org/junit/internal/management/ManagementFactory.java",
"chars": 2367,
"preview": "package org.junit.internal.management;\n\nimport org.junit.internal.Classes;\n\nimport java.lang.reflect.InvocationTargetExc"
},
{
"path": "src/main/java/org/junit/internal/management/ReflectiveRuntimeMXBean.java",
"chars": 1822,
"preview": "package org.junit.internal.management;\n\nimport org.junit.internal.Classes;\n\nimport java.lang.reflect.InvocationTargetExc"
},
{
"path": "src/main/java/org/junit/internal/management/ReflectiveThreadMXBean.java",
"chars": 2755,
"preview": "package org.junit.internal.management;\n\nimport org.junit.internal.Classes;\n\nimport java.lang.reflect.InvocationTargetExc"
},
{
"path": "src/main/java/org/junit/internal/management/RuntimeMXBean.java",
"chars": 280,
"preview": "package org.junit.internal.management;\n\nimport java.util.List;\n\n/**\n * Wrapper for {@link java.lang.management.RuntimeMX"
},
{
"path": "src/main/java/org/junit/internal/management/ThreadMXBean.java",
"chars": 376,
"preview": "package org.junit.internal.management;\n\n/**\n * Wrapper for {@link java.lang.management.ThreadMXBean}.\n */\npublic interfa"
},
{
"path": "src/main/java/org/junit/internal/matchers/StacktracePrintingMatcher.java",
"chars": 1596,
"preview": "package org.junit.internal.matchers;\n\nimport org.hamcrest.Description;\nimport org.hamcrest.Factory;\nimport org.hamcrest."
},
{
"path": "src/main/java/org/junit/internal/matchers/ThrowableCauseMatcher.java",
"chars": 1536,
"preview": "package org.junit.internal.matchers;\n\nimport org.hamcrest.Description;\nimport org.hamcrest.Factory;\nimport org.hamcrest."
},
{
"path": "src/main/java/org/junit/internal/matchers/ThrowableMessageMatcher.java",
"chars": 1075,
"preview": "package org.junit.internal.matchers;\n\nimport org.hamcrest.Description;\nimport org.hamcrest.Factory;\nimport org.hamcrest."
},
{
"path": "src/main/java/org/junit/internal/matchers/TypeSafeMatcher.java",
"chars": 2034,
"preview": "package org.junit.internal.matchers;\n\nimport java.lang.reflect.Method;\n\nimport org.hamcrest.BaseMatcher;\nimport org.juni"
},
{
"path": "src/main/java/org/junit/internal/requests/ClassRequest.java",
"chars": 1745,
"preview": "package org.junit.internal.requests;\n\nimport org.junit.internal.builders.AllDefaultPossibilitiesBuilder;\nimport org.juni"
},
{
"path": "src/main/java/org/junit/internal/requests/FilterRequest.java",
"chars": 1418,
"preview": "package org.junit.internal.requests;\n\nimport org.junit.internal.runners.ErrorReportingRunner;\nimport org.junit.runner.Re"
},
{
"path": "src/main/java/org/junit/internal/requests/MemoizingRequest.java",
"chars": 829,
"preview": "package org.junit.internal.requests;\n\nimport java.util.concurrent.locks.Lock;\nimport java.util.concurrent.locks.Reentran"
},
{
"path": "src/main/java/org/junit/internal/requests/OrderingRequest.java",
"chars": 860,
"preview": "package org.junit.internal.requests;\n\nimport org.junit.internal.runners.ErrorReportingRunner;\nimport org.junit.runner.Re"
},
{
"path": "src/main/java/org/junit/internal/requests/SortingRequest.java",
"chars": 678,
"preview": "package org.junit.internal.requests;\n\nimport java.util.Comparator;\n\nimport org.junit.runner.Description;\nimport org.juni"
},
{
"path": "src/main/java/org/junit/internal/requests/package-info.java",
"chars": 126,
"preview": "/**\n * Provides implementations of {@link org.junit.runner.Request}.\n *\n * @since 4.0\n */\npackage org.junit.internal.req"
},
{
"path": "src/main/java/org/junit/internal/runners/ClassRoadie.java",
"chars": 2463,
"preview": "package org.junit.internal.runners;\n\nimport java.lang.reflect.InvocationTargetException;\nimport java.lang.reflect.Method"
},
{
"path": "src/main/java/org/junit/internal/runners/ErrorReportingRunner.java",
"chars": 3258,
"preview": "package org.junit.internal.runners;\n\nimport java.lang.reflect.InvocationTargetException;\nimport java.util.List;\n\nimport "
},
{
"path": "src/main/java/org/junit/internal/runners/FailedBefore.java",
"chars": 422,
"preview": "package org.junit.internal.runners;\n\nimport org.junit.runners.BlockJUnit4ClassRunner;\n\n/**\n * @deprecated Included for b"
},
{
"path": "src/main/java/org/junit/internal/runners/InitializationError.java",
"chars": 931,
"preview": "package org.junit.internal.runners;\n\nimport java.util.Arrays;\nimport java.util.List;\n\n/**\n * Use the published version:\n"
},
{
"path": "src/main/java/org/junit/internal/runners/JUnit38ClassRunner.java",
"chars": 6613,
"preview": "package org.junit.internal.runners;\n\nimport java.lang.annotation.Annotation;\nimport java.lang.reflect.Method;\n\nimport ju"
},
{
"path": "src/main/java/org/junit/internal/runners/JUnit4ClassRunner.java",
"chars": 4849,
"preview": "package org.junit.internal.runners;\n\nimport java.lang.annotation.Annotation;\nimport java.lang.reflect.InvocationTargetEx"
},
{
"path": "src/main/java/org/junit/internal/runners/MethodRoadie.java",
"chars": 5610,
"preview": "package org.junit.internal.runners;\n\nimport java.lang.reflect.InvocationTargetException;\nimport java.lang.reflect.Method"
},
{
"path": "src/main/java/org/junit/internal/runners/MethodValidator.java",
"chars": 3235,
"preview": "package org.junit.internal.runners;\n\nimport java.lang.annotation.Annotation;\nimport java.lang.reflect.Method;\nimport jav"
},
{
"path": "src/main/java/org/junit/internal/runners/SuiteMethod.java",
"chars": 1219,
"preview": "package org.junit.internal.runners;\n\nimport java.lang.reflect.InvocationTargetException;\nimport java.lang.reflect.Method"
},
{
"path": "src/main/java/org/junit/internal/runners/TestClass.java",
"chars": 3331,
"preview": "package org.junit.internal.runners;\n\nimport java.lang.annotation.Annotation;\nimport java.lang.reflect.Constructor;\nimpor"
},
{
"path": "src/main/java/org/junit/internal/runners/TestMethod.java",
"chars": 1997,
"preview": "package org.junit.internal.runners;\n\nimport java.lang.reflect.InvocationTargetException;\nimport java.lang.reflect.Method"
},
{
"path": "src/main/java/org/junit/internal/runners/model/EachTestNotifier.java",
"chars": 2389,
"preview": "package org.junit.internal.runners.model;\n\nimport org.junit.internal.AssumptionViolatedException;\nimport org.junit.runne"
},
{
"path": "src/main/java/org/junit/internal/runners/model/MultipleFailureException.java",
"chars": 323,
"preview": "package org.junit.internal.runners.model;\n\nimport java.util.List;\n\n@Deprecated\npublic class MultipleFailureException ext"
},
{
"path": "src/main/java/org/junit/internal/runners/model/ReflectiveCallable.java",
"chars": 545,
"preview": "package org.junit.internal.runners.model;\n\nimport java.lang.reflect.InvocationTargetException;\n\n/**\n * When invoked, thr"
},
{
"path": "src/main/java/org/junit/internal/runners/package-info.java",
"chars": 123,
"preview": "/**\n * Provides implementations of {@link org.junit.runner.Runner}\n *\n * @since 4.0\n */\npackage org.junit.internal.runne"
},
{
"path": "src/main/java/org/junit/internal/runners/rules/RuleMemberValidator.java",
"chars": 10792,
"preview": "package org.junit.internal.runners.rules;\n\nimport org.junit.ClassRule;\nimport org.junit.Rule;\nimport org.junit.rules.Met"
},
{
"path": "src/main/java/org/junit/internal/runners/rules/ValidationError.java",
"chars": 470,
"preview": "package org.junit.internal.runners.rules;\n\nimport org.junit.runners.model.FrameworkMember;\n\nimport java.lang.annotation."
},
{
"path": "src/main/java/org/junit/internal/runners/statements/ExpectException.java",
"chars": 1241,
"preview": "package org.junit.internal.runners.statements;\n\nimport org.junit.internal.AssumptionViolatedException;\nimport org.junit."
},
{
"path": "src/main/java/org/junit/internal/runners/statements/Fail.java",
"chars": 311,
"preview": "package org.junit.internal.runners.statements;\n\nimport org.junit.runners.model.Statement;\n\npublic class Fail extends Sta"
},
{
"path": "src/main/java/org/junit/internal/runners/statements/FailOnTimeout.java",
"chars": 12253,
"preview": "package org.junit.internal.runners.statements;\n\nimport java.util.Arrays;\nimport java.util.Collections;\nimport java.util."
},
{
"path": "src/main/java/org/junit/internal/runners/statements/InvokeMethod.java",
"chars": 522,
"preview": "package org.junit.internal.runners.statements;\n\nimport org.junit.runners.model.FrameworkMethod;\nimport org.junit.runners"
},
{
"path": "src/main/java/org/junit/internal/runners/statements/RunAfters.java",
"chars": 1278,
"preview": "package org.junit.internal.runners.statements;\n\nimport java.util.ArrayList;\nimport java.util.List;\n\nimport org.junit.run"
},
{
"path": "src/main/java/org/junit/internal/runners/statements/RunBefores.java",
"chars": 851,
"preview": "package org.junit.internal.runners.statements;\n\nimport java.util.List;\n\nimport org.junit.runners.model.FrameworkMethod;\n"
}
]
// ... and 360 more files (download for full content)
About this extraction
This page contains the full source code of the junit-team/junit4 GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 560 files (1.8 MB), approximately 435.4k tokens, and a symbol index with 5371 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.