LICENSE.TXT

@@ -1,4 +1,4 @@
-Copyright 2019-2024 Chris Hodges <chrisly@platon42.de>
+Copyright 2019-2022 Chris Hodges <chrisly@platon42.de>
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

README.md

@@ -1,5 +1,4 @@
-# Cajon - Concise AssertJ Optimizing Nitpicker
+# Cajon - Concise AssertJ Optimizing Nitpicker [![Build Status](https://app.travis-ci.com/chrisly42/cajon-plugin.svg?branch=master)](https://app.travis-ci.com/chrisly42/cajon-plugin) [![Coverage Status](https://coveralls.io/repos/github/chrisly42/cajon-plugin/badge.svg?branch=master)](https://coveralls.io/github/chrisly42/cajon-plugin?branch=master)
-
 Cajon is an IntelliJ IDEA Plugin for shortening and optimizing [AssertJ](https://assertj.github.io/doc/) assertions.
 
 ## Purpose
@@ -40,8 +39,7 @@ Cajon also warns about bogus or incorrect uses of AssertJ.
 
 ## Lookup and refactoring of string-based extracting()
 
-AssertJ
+AssertJ allows [extracting POJO fields/properties on iterables/arrays](http://joel-costigliola.github.io/assertj/assertj-core-features-highlight.html#extracted-properties-assertion).
-allows [extracting POJO fields/properties on iterables/arrays](http://joel-costigliola.github.io/assertj/assertj-core-features-highlight.html#extracted-properties-assertion).
 
 Using strings is not safe for refactoring (and before Java 8 Lambdas were available,
 creating extractor functions just for testing purpose was a bit too tedious).
@@ -67,7 +65,6 @@ Applying a quick fix might result in further optimization possibilities, so
 you might need to perform a couple of fixes before you get to the final result.
 
 Check out this example where every line represents the result after a Cajon quickfix:
-
 ```
 assertFalse(!(array.length == collection.size()));
 
@@ -796,9 +793,8 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 
 ### Implemented referencing
 
-You can ctrl-click on references inside .extracting() method parameters to go the
+  You can ctrl-click on references inside .extracting() method parameters to go the
-referencing method definition.
+  referencing method definition.
-
   ```
   .extracting("field")
   .extracting("outerField.fieldInsideObjectTypeOfOuterField.andSoOn")
@@ -812,10 +808,9 @@ referencing method definition.
   .flatExtracting(Extractors.byName("fieldOrPropertyOrBareMethod.orAPathLikeAbove")
   .flatExtracting(Extractors.resultOf("bareMethod")
   ```
-
+  This works on both POJOs and ```Iterable```s/```Array```s. 
-This works on both POJOs and ```Iterable```s/```Array```s.
+  Implementation is very basic though and does not work with fancy cascaded ```.extracting()``` sequences.
-Implementation is very basic though and does not work with fancy cascaded ```.extracting()``` sequences.
+  If there's demand, I could add it.
-If there's demand, I could add it.
 
 ## Development notice
 
@@ -826,7 +821,6 @@ The IntelliJ framework actually uses the JUnit 3 TestCase for plugin testing, an
 Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for your projects (with attribution).
 
 ## Planned features
-
 - More Optional fixes such as ```opt1.get() == opt2.get()``` etc.
 - More moving out of methods for LocalDate/Time etc.
 - assertThat(foo.toLowerCase()/toUpperCase()).isEqualTo("foo") -> assertThat(foo).isEqualToIgnoringCase()
@@ -840,18 +834,9 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
 
 ## Changelog
 
-### V1.14 (19-Feb-24)
-
-- Now requires minimum version 2022.2.
-- Maintenance. Updated various dependencies (Kotlin 1.9.22) and AssertJ 3.25.3 and AssertJ-Guava 3.25.3.
-- Reworked JUnit 5 test framework to work again. However, all the tests are broken.
-  I spent several days trying to figure out what is going on, but I'm giving up on this pile of crap called IntelliJ.
-  Jetbrains keeps breaking the APIs and implementations every year and I just cannot be bothered anymore.
-- This is very likely the last version.
-
 ### V1.13 (18-Aug-22)
 
-- API change in IntelliJ platforms now requires minimum version 2019.3.1. Sorry, giving up to maintain compatibility after four attempts.
+- API change in IntelliJ platforms now requires minimum version 2019.3.1. Sorry, giving up to maintain compatibilty after four attempts.
 - Maintenance. Updated various dependencies (Kotlin 1.7.10) and AssertJ 3.23.1 and AssertJ-Guava 3.5.0.
 - Tried to fix unreproducible issue #9.
 - Added AssertThatIsZeroOne inspection demanded by issue #5.
@@ -874,12 +859,10 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
   inspection.
 
 #### V1.10 (31-Jul-20) Friday the 31st Edition
-
 - Updated libraries to the latest versions (including AssertJ 3.16.1 and Kotlin 1.40-rc).
 - Fixed two possible index out-of-bounds exceptions in ExtractorReferenceContributor and BogusAssertionInspection.
 
 #### V1.9 (25-Feb-20) Mardi Gras Edition
-
 - TwistedAssertion inspection will no longer warn for ```.matches()``` and ```doesNotMatch()``` for regular expressions.
   Apparently, ```assertThat("somestring").matches(regex)``` is a valid test if the regex is what needs to be tested.
   If the actual expression is of ```Class``` type, this will no longer be reported.
@@ -890,14 +873,12 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
   the warning will be reduced to information level as the assertion may be testing ```equals()``` or ```hashCode()``` for validity.
 
 #### V1.8 (14-Feb-20) Valentine Edition
-
 - Maintenance. Removed experimental API use. Updated dependencies. Fixed testing problems introduced with IntelliJ IDEA 2019.3
 - Added new TwistedAssertion inspection that will warn about assertions with the actual expression being a constant indicating
   swapped use of actual and expected expressions.
 - Added new BogusAssertion inspection that showing typical copy and paste errors where actual and expected expressions are the same.
 
 #### V1.7 (19-Nov-19)
-
 - Fixed a lapsuus in AssertThatFileExpression also transforming ```.listFiles()``` with a filter argument.
 - Added first version of AssertThatPathExpression for a limited number transformations (more stuff is possible,
   but requires detection and transformation of static ```Files```-methods).
@@ -905,7 +886,6 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
 - Added ```hasSize(), isEmpty()``` and ```isNotEmpty()``` for AssertThatFileExpression when using AssertJ >= 3.14.0.
 
 #### V1.6 (30-Sep-19)
-
 - Really fixed AssertThatGuavaOptional inspections to avoid conversions from ```.get()``` to ```.contains()```
   for array types. Sigh. Shouldn't be working >12h a day and then do some more stuff at home.
 - Fixed a bug in AssertThatBinaryExpression inspection for ```assertThat(null != expression)``` and related
@@ -916,7 +896,6 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
   Specifically, uses of ```matches()```, ```compareToIgnoreCase()```, ```indexOf()```, and ```trim()```.
 
 #### V1.5 (24-Sep-19)
-
 - Fix for AssertThatCollectionOrMap inspection sometimes causing an index out-of-bounds exception.
 - AssertThatGuavaOptional inspections will now avoid conversions from ```.get()``` to ```.contains()```
   for array types (currently not correctly supported by ```contains()``` in AssertJ-Guava).
@@ -927,13 +906,11 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
   combinations for ```.hasSameSizeAs()``` are supported.
 
 #### V1.4 (25-Aug-19)
-
 - Minor fix for highlighting of JoinVarArgsContains inspection.
 - Extended AssertThatSize inspection to Maps, too.
 - Extended AssertThatCollectionOrMap inspection for several ```assertThat(map.get())``` cases as suggested by Georgij G.
 
 #### V1.3 (03-Aug-19)
-
 - New JoinVarArgsContains inspection that will detect multiple ```.contains()```, ```.doesNotContain()```,
   and ```.containsOnlyOnce()``` calls within the same statement that could be joined together using variadic arguments.
 - AssertJ 3.13.0 broke some inspections due to new ```AbstractStringAssert::isEqualTo()``` method.
@@ -942,12 +919,10 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
   when ```expression``` is not a non-null constant expression.
   
 #### V1.2 (23-Jun-19)
-
 - Due to popular demand the JoinAssertThatStatements inspection will now add line breaks on joining statements.
   The amount of statements joined without causing line breaks can be configured but defaults to 1 (always).
           
 #### V1.1 (09-Jun-19)
-
 - Improved JoinAssertThatStatements detection of expressions with side-effects and added pre/post-increment/decrement detection.
 - Added Guava Optional ```opt.orNull() == null``` case. You know, I'm not making this stuff up, people actually write this kind of code.
 - Added Java 8 Optional ```opt.orElse(null) == null``` case, too.
@@ -958,18 +933,14 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
 - Added new AssertThatObjectExpression inspection for ```toString()``` and ```hashCode()``` and moved ```equals()``` from AssertThatBinaryExpression there.
 
 #### V1.0 (06-May-19)
-
 - First release to be considered stable enough for production use.
 - Fixed a NPE in AssumeThatInsteadOfReturn inspection quickfix for empty else branches.
 - Fixed missing description for AssumeThatInsteadOfReturn inspection.
-- Added new AssertThatCollectionOrMapExpression inspection that tries to pull out methods such as ```isEmpty()``` or ```contains()``` out of an actual ```assertThat()```
+- Added new AssertThatCollectionOrMapExpression inspection that tries to pull out methods such as ```isEmpty()``` or ```contains()``` out of an actual ```assertThat()``` expression.
-  expression.
 
 #### V0.8 (05-May-19)
-
 - Fixed missing description for JoinAssertThatStatements and detection of equivalent expressions (sorry, released it too hastily).
-- Fixed ```isEmpty()``` for enumerables and strings and ```isNull()``` for object conversions to be applied only if it is the terminal method call as ```isEmpty()```
+- Fixed ```isEmpty()``` for enumerables and strings and ```isNull()``` for object conversions to be applied only if it is the terminal method call as ```isEmpty()``` and ```isNull()``` return void.
-  and ```isNull()``` return void.
 - Heavily reworked inspections for edge cases, such as multiple ```isEqualTo()``` calls inside a single statement.
 - Some inspections could generate bogus code for weird situations, this has been made more fool-proof.
 - Corrected highlighting for many inspections.
@@ -978,7 +949,6 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
 - Added a first version of a new inspection that tries to detect bogus uses of return statements in test methods and replaces them by ```assumeThat()``` calls.
 
 #### V0.7 (28-Apr-19)
-
 - Another fix for AssertThatGuavaOptional inspection regarding using the same family name for slightly different quick fix executions
   (really, Jetbrains, this sucks for no reason).
 - Extended AssertThatSize inspection to transform ```hasSize()``` into ```hasSameSizeAs()```, if possible.
@@ -986,7 +956,6 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
   actual object together, preserving comments.
 
 #### V0.6 (22-Apr-19)
-
 - New AssertThatStringExpression inspection that will move ```isEmpty()```, ```equals()```, ```equalsIgnoreCase()```, ```contains()```,
   ```startsWith()```, and ```endsWith()``` out of actual expression.
 - Extended AssertThatSize inspection to take ```String```s and ```CharSequences``` into account, too.
@@ -995,7 +964,6 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
 - New AssertThatInstanceOf inspection that moves instanceof expressions out of ```assertThat()```.
 
 #### V0.5 (18-Apr-19)
-
 - Fixed incompatibility with IDEA versions < 2018.2 (affected AssertThatSizeInspection). Minimal version is now 2017.3.
 - Fixed missing Guava imports (if not already present) for AssertThatGuavaInspection. This was a major PITA to get right.
 - Added support for referencing and refactoring inside ```.extracting()``` methods with fields, properties and methods (though
@@ -1004,27 +972,20 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
   Now descriptions are different for quick fixes triggered by AssertThatJava8OptionalInspection and AssertThatGuavaOptionalInspection.
 
 #### V0.4 (11-Apr-19)
-
 - Reduced minimal supported IDEA version from 2018.2 to 2017.2.
-- New inspection AssertThatJava8Optional that operates on Java 8 ```Optional``` objects and tries to use ```contains()```, ```containsSame()```, ```isPresent()```,
+- New inspection AssertThatJava8Optional that operates on Java 8 ```Optional``` objects and tries to use ```contains()```, ```containsSame()```, ```isPresent()```, and ```isNotPresent()``` instead.
-  and ```isNotPresent()``` instead.
 - New inspection AssertThatGuavaOptional that operates on Guava ```Optional``` objects and tries to use ```contains()```, ```isPresent()```, and ```isAbsent()``` instead.
 - Added support in AssertThatBinaryExpressionIsTrueOrFalse for ```is(Not)EqualTo(Boolean.TRUE/FALSE)```.
 
 #### V0.3 (07-Apr-19)
-
+- New inspection AssertThatBinaryExpressionIsTrueOrFalse that will find and fix common binary expressions and ```equals()``` statements (more than 150 combinations) inside ```assertThat()```.
-- New inspection AssertThatBinaryExpressionIsTrueOrFalse that will find and fix common binary expressions and ```equals()``` statements (more than 150 combinations)
-  inside ```assertThat()```.
 - Merged AssertThatObjectIsNull and AssertThatObjectIsNotNull to AssertThatObjectIsNullOrNotNull.
-- Support for ```hasSizeLessThan()```, ```hasSizeLessThanOrEqualTo()```, ```hasSizeGreaterThanOrEqualTo()```, and ```hasSizeGreaterThan()``` for AssertThatSizeInspection (with
+- Support for ```hasSizeLessThan()```, ```hasSizeLessThanOrEqualTo()```, ```hasSizeGreaterThanOrEqualTo()```, and ```hasSizeGreaterThan()``` for AssertThatSizeInspection (with AssertJ >=3.12.0).
-  AssertJ >=3.12.0).
 - Really fixed highlighting for JUnit conversion. Sorry.
 
 #### V0.2 (01-Apr-19)
-
 - Fixed descriptions and quick fix texts.
 - Fixed highlighting of found problems and 'Run inspection by Name' returning nothing, too.
 
 #### V0.1 (31-Mar-19)
-
 - Initial release.

build.gradle

@@ -0,0 +1,93 @@
+plugins {
+    id 'java'
+    id 'org.jetbrains.intellij' version '1.8.0'
+    id 'org.jetbrains.kotlin.jvm' version '1.7.10'
+    id 'jacoco'
+    id 'com.github.kt3k.coveralls' version '2.12.0'
+}
+
+group 'de.platon42'
+version '1.13'
+sourceCompatibility = "1.8"
+targetCompatibility = "1.8"
+
+repositories {
+    mavenCentral()
+}
+
+/*
+  To run tests in IntelliJ use these VM Options for run configuration 
+  -ea -Didea.system.path=build/idea-sandbox/system-test -Didea.config.path=build/idea-sandbox/config-test -Didea.plugins.path=build/idea-sandbox/plugins-test
+ */
+
+dependencies {
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
+    testImplementation "org.assertj:assertj-core:3.23.1"
+    testImplementation "org.assertj:assertj-guava:3.5.0"
+    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.9.0'
+    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.9.0'
+    testImplementation "org.jetbrains.kotlin:kotlin-test"
+    testImplementation "org.jetbrains.kotlin:kotlin-reflect"
+    testImplementation 'org.junit.platform:junit-platform-launcher:1.9.0'
+//    testImplementation "org.jetbrains.kotlin:kotlin-test-junit"
+}
+
+compileKotlin {
+    kotlinOptions.jvmTarget = "1.8"
+}
+
+compileTestKotlin {
+    kotlinOptions.jvmTarget = "1.8"
+}
+
+intellij {
+    setVersion("2022.2") // LATEST-EAP-SNAPSHOT
+    //pluginName.set(provider { 'Concise AssertJ Optimizing Nitpicker (Cajon)' })
+    setUpdateSinceUntilBuild(false)
+    setPlugins(["com.intellij.java"])
+}
+
+runPluginVerifier {
+    ideVersions = ["IC-193.5662.53", "IC-222.3345.118"] // 2019.3.1 - 2022.2
+    downloadDir = System.getProperty("user.home") + "/.gradle/caches/modules-2/files-2.1/com.jetbrains.intellij.idea/verifier"
+}
+
+patchPluginXml {
+    setChangeNotes("""
+  <h4>V1.13 (18-Aug-22)</h4>
+    <ul>
+      <li>API change in IntelliJ platforms now requires minimum version 2019.3.1. Sorry, giving up to maintain compatibilty after four attempts.
+      <li>Maintenance. Updated various dependencies (Kotlin 1.7.10) and AssertJ 3.23.1 and AssertJ-Guava 3.5.0.
+      <li>Tried to fix unreproducible issue #9.
+      <li>Added AssertThatIsZeroOne inspection demanded by issue #5.
+      <li>Fix for wrongly joining statements that cannot be trivially joined (e.g. with filteredOn). Fixes issue #6.
+    </ul>
+  <p>Full changelog available at <a href="https://github.com/chrisly42/cajon-plugin#changelog">Github project site</a>.</p>
+""")
+}
+
+test {
+    useJUnitPlatform()
+    testLogging {
+        events "passed", "skipped", "failed"
+    }
+}
+
+tasks.coveralls {
+    dependsOn jacocoTestReport
+}
+
+jacoco {
+    toolVersion = '0.8.8'
+}
+
+jacocoTestReport {
+    reports {
+        xml.required.set(true)
+        csv.required.set(false)
+    }
+}
+
+publishPlugin {
+    setToken(intellijPublishToken)
+}

build.gradle.kts

@@ -1,131 +0,0 @@
-plugins {
-    id("java")
-    id("org.jetbrains.intellij") version "1.17.1"
-    id("org.jetbrains.kotlin.jvm") version "1.9.22"
-    id("jacoco")
-    id("com.github.kt3k.coveralls") version "2.12.2"
-}
-
-group = "de.platon42"
-version = "1.14"
-
-repositories {
-    mavenCentral()
-}
-
-/*
-  To run tests in IntelliJ use these VM Options for run configuration
-  -ea -Didea.system.path=build/idea-sandbox/system-test -Didea.config.path=build/idea-sandbox/config-test -Didea.plugins.path=build/idea-sandbox/plugins-test
- */
-
-dependencies {
-    //implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
-    testImplementation("org.assertj:assertj-core:3.25.3")
-    testImplementation("org.assertj:assertj-guava:3.25.3")
-    testImplementation("org.junit.jupiter:junit-jupiter-api:5.10.2")
-    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.10.2")
-    testImplementation("org.jetbrains.kotlin:kotlin-test")
-    testImplementation("org.jetbrains.kotlin:kotlin-reflect")
-    testImplementation("org.junit.platform:junit-platform-launcher:1.10.2")
-//    testImplementation "org.jetbrains.kotlin:kotlin-test-junit"
-}
-
-intellij {
-    version.set("2022.2") // LATEST-EAP-SNAPSHOT
-    //pluginName.set(provider { 'Concise AssertJ Optimizing Nitpicker (Cajon)' })
-    updateSinceUntilBuild.set(false)
-    plugins.set(listOf("com.intellij.java"))
-}
-
-tasks {
-    withType<JavaCompile> {
-        sourceCompatibility = "11"
-        targetCompatibility = "11"
-    }
-    withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
-        kotlinOptions.jvmTarget = "11"
-    }
-
-    test {
-        useJUnitPlatform()
-        testLogging {
-            events("passed", "skipped", "failed")
-        }
-    }
-
-
-    prepareSandbox {
-        enabled = true
-    }
-
-    verifyPlugin {
-        enabled = true
-    }
-
-    verifyPluginConfiguration {
-        enabled = true
-    }
-
-    patchPluginXml {
-        enabled = true
-        sinceBuild.set("222")
-        changeNotes.set(
-            """
-  <h4>V1.14 (19-Feb-24)</h4>
-    <ul>
-      <li>Now requires minimum version 2022.2.
-      <li>Maintenance. Updated various dependencies (Kotlin 1.9.22) and AssertJ 3.25.3 and AssertJ-Guava 3.25.3.
-      <li>Reworked JUnit 5 test framework to work again. However, all the tests are broken.
-      I spent several days trying to figure out what is going on, but I'm giving up on this pile of crap called IntelliJ. 
-      Jetbrains keeps breaking the APIs and implementations every year and I just cannot be bothered anymore.
-      <li>This is very likely the last version.
-    </ul>
-  <h4>V1.13 (18-Aug-22)</h4>
-    <ul>
-      <li>API change in IntelliJ platforms now requires minimum version 2019.3.1. Sorry, giving up to maintain compatibility after four attempts.
-      <li>Maintenance. Updated various dependencies (Kotlin 1.7.10) and AssertJ 3.23.1 and AssertJ-Guava 3.5.0.
-      <li>Tried to fix unreproducible issue #9.
-      <li>Added AssertThatIsZeroOne inspection demanded by issue #5.
-      <li>Fix for wrongly joining statements that cannot be trivially joined (e.g. with filteredOn). Fixes issue #6.
-    </ul>
-  <p>Full changelog available at <a href="https://git.platon42.de/chrisly42/cajon-plugin#changelog">Gitea project site</a>.</p>
-"""
-        )
-    }
-
-    publishPlugin {
-        token.set(System.getProperty("org.gradle.project.intellijPublishToken"))
-    }
-
-    runIde {
-        enabled = true
-        if (project.hasProperty("ideDir")) {
-            ideDir.set(file(project.property("ideDir")!!))
-            jbrVersion.set(project.property("ideJBR")!! as String)
-        }
-        autoReloadPlugins.set(false)
-    }
-
-
-    runPluginVerifier {
-        ideVersions.set(listOf("IC-222.4167.29", "IC-233.14015.106")) // 2022.2.2 - 2023.3.3
-        downloadDir.set(System.getenv("user.home") + "/.gradle/caches/modules-2/files-2.1/com.jetbrains.intellij.idea/verifier")
-    }
-
-
-}
-
-//tasks.coveralls {
-//    dependsOn(jacocoTestReport)
-//}
-
-//jacoco {
-//    toolVersion = '0.8.8'
-//}
-//
-//jacocoTestReport {
-//    reports {
-//        xml.required.set(true)
-//        csv.required.set(false)
-//    }
-//}

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.6-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.5.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

src/main/resources/META-INF/plugin.xml

@@ -1,7 +1,7 @@
 <idea-plugin>
     <id>de.platon42.cajon</id>
     <name>Concise AssertJ Optimizing Nitpicker (Cajon)</name>
-    <vendor email="chrisly@platon42.de" url="https://git.platon42.de/chrisly42/cajon-plugin">Chris 'platon42' Hodges</vendor>
+    <vendor email="chrisly@platon42.de" url="https://github.com/chrisly42/cajon-plugin">Chris 'platon42' Hodges</vendor>
 
     <description><![CDATA[
     Cajon is an IntelliJ IDEA Plugin for shortening and optimizing AssertJ assertions.
@@ -14,6 +14,8 @@
     <a href="https://github.com/chrisly42/cajon-plugin/blob/master/README.md">Full documentation here...</a>
     ]]></description>
 
+    <idea-version since-build="193.5662.53"/>
+
     <depends>com.intellij.modules.lang</depends>
     <depends>com.intellij.modules.platform</depends>
     <depends>com.intellij.modules.java</depends>

src/test/java/de/platon42/intellij/jupiter/AbstractJUnit5TestCase.kt

@@ -1,151 +0,0 @@
-package de.platon42.intellij.jupiter
-
-import com.intellij.jarRepository.JarRepositoryManager
-import com.intellij.jarRepository.RemoteRepositoryDescription
-import com.intellij.openapi.module.Module
-import com.intellij.openapi.roots.ContentEntry
-import com.intellij.openapi.roots.DependencyScope
-import com.intellij.openapi.roots.ModifiableRootModel
-import com.intellij.openapi.vfs.LocalFileSystem
-import com.intellij.testFramework.IdeaTestUtil
-import com.intellij.testFramework.LightProjectDescriptor
-import com.intellij.testFramework.PlatformTestUtil
-import com.intellij.testFramework.PsiTestUtil
-import com.intellij.testFramework.fixtures.DefaultLightProjectDescriptor
-import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
-import com.intellij.testFramework.fixtures.LightJavaCodeInsightFixtureTestCase
-import com.intellij.testFramework.rules.TestNameExtension
-import org.jetbrains.idea.maven.utils.library.RepositoryLibraryProperties
-import org.junit.jupiter.api.extension.AfterEachCallback
-import org.junit.jupiter.api.extension.BeforeEachCallback
-import org.junit.jupiter.api.extension.ExtensionContext
-import org.junit.jupiter.api.extension.RegisterExtension
-import java.nio.file.Paths
-import java.util.*
-import java.util.function.Consumer
-import java.util.stream.Collectors
-import java.util.stream.Stream
-
-
-abstract class AbstractJUnit5TestCase {
-
-    @RegisterExtension
-    protected val testNameRule = TestNameExtension()
-
-    @RegisterExtension
-    protected val edtInterceptorExtension = EdtInterceptorExtension()
-
-    protected fun getTestName(lowercaseFirstLetter: Boolean): String {
-        return PlatformTestUtil.getTestName(testNameRule.methodName, lowercaseFirstLetter)
-    }
-
-    @RegisterExtension
-    private val testCase = object : LightJavaCodeInsightFixtureTestCase(), BeforeEachCallback, AfterEachCallback {
-
-        lateinit var extensionContext: ExtensionContext
-
-        override fun getProjectDescriptor(): LightProjectDescriptor {
-            val testJdk = getMethodOrClassAnnotation(TestJdk::class.java) ?: return super.getProjectDescriptor()
-            val projectDescriptor: DefaultLightProjectDescriptor = object : DefaultLightProjectDescriptor({ IdeaTestUtil.getMockJdk(testJdk.value.toJavaVersion()) }) {
-                override fun configureModule(module: Module, model: ModifiableRootModel, contentEntry: ContentEntry) {
-                    super.configureModule(module, model, contentEntry)
-                    val localJars = getMethodOrClassAnnotation(AddLocalJarToModule::class.java)
-                    if (localJars != null) {
-                        localJars.value.forEach {
-                            addJarContaining(
-                                model,
-                                it.java
-                            )
-                        }
-                    }
-                    val mavenDependencies = getMethodOrClassAnnotations(AddMavenDependencyToModule::class.java)
-                    mavenDependencies.forEach(Consumer { it: AddMavenDependencyToModule ->
-                        addFromMaven(
-                            model,
-                            it.value,
-                            it.includeTransitiveDependencies,
-                            it.scope
-                        )
-                    })
-                }
-            }
-
-            return projectDescriptor
-        }
-
-        fun addJarContaining(model: ModifiableRootModel?, clazz: Class<*>) {
-            val filename = clazz.getResource(clazz.simpleName + ".class").file
-            val jarName = filename.substring(0, filename.indexOf(".jar") + 4).removePrefix("file:")
-            val jarPath = Paths.get(jarName)
-
-            val jarFile = LocalFileSystem.getInstance().refreshAndFindFileByPath(jarName)
-            myFixture.allowTreeAccessForFile(jarFile!!)
-            PsiTestUtil.addLibrary(
-                model!!,
-                jarPath.fileName.toString().replace(".jar", ""),
-                jarPath.parent.toString(),
-                jarPath.fileName.toString()
-            )
-        }
-
-        fun addFromMaven(
-            model: ModifiableRootModel, mavenCoordinates: String,
-            includeTransitiveDependencies: Boolean, dependencyScope: DependencyScope?
-        ) {
-            val remoteRepositoryDescriptions = RemoteRepositoryDescription.DEFAULT_REPOSITORIES
-            val libraryProperties = RepositoryLibraryProperties(mavenCoordinates, includeTransitiveDependencies)
-            val roots =
-                JarRepositoryManager.loadDependenciesModal(model.project, libraryProperties, false, false, null, remoteRepositoryDescriptions)
-            val tableModel = model.moduleLibraryTable.modifiableModel
-            val library = tableModel.createLibrary(mavenCoordinates)
-            val libraryModel = library.modifiableModel
-            check(!roots.isEmpty()) { String.format("No roots for '%s'", mavenCoordinates) }
-
-            for (root in roots) {
-                libraryModel.addRoot(root.file, root.type)
-            }
-
-            val libraryOrderEntry = model.findLibraryOrderEntry(library) ?: throw java.lang.IllegalStateException("Unable to find registered library $mavenCoordinates")
-            libraryOrderEntry.scope = dependencyScope!!
-
-            libraryModel.commit()
-            tableModel.commit()
-        }
-
-        override fun getTestDataPath(): String {
-            val testDataPath = getMethodOrClassAnnotation(TestDataPath::class.java) ?: return super.getTestDataPath()
-            val testDataSubPath = getMethodOrClassAnnotation(TestDataSubPath::class.java) ?: return testDataPath.value
-            return Paths.get(testDataPath.value, testDataSubPath.value).toString()
-        }
-
-        fun getMyFixture(): JavaCodeInsightTestFixture = myFixture
-
-        private fun <T : Annotation?> getMethodOrClassAnnotation(clazz: Class<T>): T? {
-            var annotation = extensionContext.requiredTestMethod.getAnnotation(clazz)
-            if (annotation == null) {
-                annotation = extensionContext.requiredTestClass.getAnnotation(clazz)
-            }
-            return annotation
-        }
-
-        private fun <T : Annotation?> getMethodOrClassAnnotations(clazz: Class<T>): List<T> {
-            return Stream.of(
-                extensionContext.requiredTestMethod.getAnnotationsByType(clazz),
-                extensionContext.requiredTestClass.getAnnotationsByType(clazz)
-            )
-                .flatMap { array: Array<T>? -> Arrays.stream(array) }
-                .collect(Collectors.toList())
-        }
-
-        override fun beforeEach(context: ExtensionContext) {
-            extensionContext = context
-            setUp()
-        }
-
-        override fun afterEach(context: ExtensionContext) {
-            tearDown()
-        }
-    }
-
-    protected val fixture: JavaCodeInsightTestFixture get() = testCase.getMyFixture()
-}

src/test/java/de/platon42/intellij/jupiter/AddLocalJarToModule.java

@@ -0,0 +1,10 @@
+package de.platon42.intellij.jupiter;
+
+import java.lang.annotation.*;
+
+@Target({ElementType.TYPE, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Inherited
+public @interface AddLocalJarToModule {
+    Class<?>[] value();
+}

src/test/java/de/platon42/intellij/jupiter/AddLocalJarToModule.kt

@@ -1,9 +0,0 @@
-package de.platon42.intellij.jupiter
-
-import java.lang.annotation.Inherited
-import kotlin.reflect.KClass
-
-@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
-@Retention(AnnotationRetention.RUNTIME)
-@Inherited
-annotation class AddLocalJarToModule(vararg val value: KClass<*>)

src/test/java/de/platon42/intellij/jupiter/AddMavenDependencyToModule.java

@@ -0,0 +1,24 @@
+package de.platon42.intellij.jupiter;
+
+import com.intellij.openapi.roots.DependencyScope;
+
+import java.lang.annotation.*;
+
+@Target({ElementType.TYPE, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Inherited
+@Repeatable(AddMavenDependencyToModule.List.class)
+public @interface AddMavenDependencyToModule {
+    String value();
+
+    boolean includeTransitiveDependencies = false;
+
+    DependencyScope scope = DependencyScope.COMPILE;
+
+    @Target({ElementType.TYPE, ElementType.METHOD})
+    @Retention(RetentionPolicy.RUNTIME)
+    @Inherited
+    @interface List {
+        AddMavenDependencyToModule[] value();
+    }
+}

src/test/java/de/platon42/intellij/jupiter/AddMavenDependencyToModule.kt

@@ -1,17 +0,0 @@
-package de.platon42.intellij.jupiter
-
-import com.intellij.openapi.roots.DependencyScope
-import java.lang.annotation.Inherited
-
-@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
-@Retention(AnnotationRetention.RUNTIME)
-@Inherited
-@JvmRepeatable(
-    AddMavenDependencyToModule.List::class
-)
-annotation class AddMavenDependencyToModule(val value: String, val includeTransitiveDependencies: Boolean = false, val scope: DependencyScope = DependencyScope.COMPILE) {
-    @Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
-    @Retention(AnnotationRetention.RUNTIME)
-    @Inherited
-    annotation class List(vararg val value: AddMavenDependencyToModule)
-}

src/test/java/de/platon42/intellij/jupiter/EdtInterceptorExtension.kt

@@ -1,50 +0,0 @@
-package de.platon42.intellij.jupiter
-
-import com.intellij.testFramework.TestLoggerFactory
-import com.intellij.testFramework.fixtures.IdeaTestExecutionPolicy
-import com.intellij.testFramework.runInEdtAndWait
-import org.junit.jupiter.api.extension.ExtensionContext
-import org.junit.jupiter.api.extension.InvocationInterceptor
-import org.junit.jupiter.api.extension.ReflectiveInvocationContext
-import java.lang.reflect.Method
-
-class EdtInterceptorExtension : InvocationInterceptor {
-
-    override fun interceptTestMethod(
-        invocation: InvocationInterceptor.Invocation<Void>,
-        invocationContext: ReflectiveInvocationContext<Method>,
-        extensionContext: ExtensionContext
-    ) {
-        val throwables = arrayOfNulls<Throwable>(1)
-
-        val runnable = Runnable {
-            try {
-                TestLoggerFactory.onTestStarted()
-                invocation.proceed()
-                TestLoggerFactory.onTestFinished(true, extensionContext.displayName)
-            } catch (e: Throwable) {
-                TestLoggerFactory.onTestFinished(false, extensionContext.displayName)
-                throwables[0] = e
-            }
-        }
-
-        invokeTestRunnable(runnable)
-
-        if (throwables[0] != null) {
-            throw throwables[0]!!
-        }
-    }
-
-    companion object {
-        private fun invokeTestRunnable(runnable: Runnable) {
-            val policy = IdeaTestExecutionPolicy.current()
-            if (policy != null && !policy.runInDispatchThread()) {
-                runnable.run()
-            } else {
-                runInEdtAndWait {
-                    runnable.run()
-                }
-            }
-        }
-    }
-}

src/test/java/de/platon42/intellij/jupiter/LightCodeInsightExtension.java

@@ -0,0 +1,259 @@
+package de.platon42.intellij.jupiter;
+
+import com.intellij.jarRepository.JarRepositoryManager;
+import com.intellij.jarRepository.RemoteRepositoryDescription;
+import com.intellij.openapi.Disposable;
+import com.intellij.openapi.module.Module;
+import com.intellij.openapi.projectRoots.Sdk;
+import com.intellij.openapi.projectRoots.impl.JavaAwareProjectJdkTableImpl;
+import com.intellij.openapi.roots.ContentEntry;
+import com.intellij.openapi.roots.DependencyScope;
+import com.intellij.openapi.roots.LibraryOrderEntry;
+import com.intellij.openapi.roots.ModifiableRootModel;
+import com.intellij.openapi.roots.libraries.Library;
+import com.intellij.openapi.roots.libraries.LibraryTable;
+import com.intellij.openapi.roots.libraries.ui.OrderRoot;
+import com.intellij.openapi.util.Disposer;
+import com.intellij.openapi.vfs.LocalFileSystem;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.testFramework.EdtTestUtilKt;
+import com.intellij.testFramework.LightProjectDescriptor;
+import com.intellij.testFramework.PsiTestUtil;
+import com.intellij.testFramework.TestLoggerFactory;
+import com.intellij.testFramework.fixtures.IdeaTestExecutionPolicy;
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture;
+import com.intellij.testFramework.fixtures.LightJavaCodeInsightFixtureTestCase;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.idea.maven.utils.library.RepositoryLibraryProperties;
+import org.junit.jupiter.api.extension.*;
+import org.junit.jupiter.api.extension.ExtensionContext.Namespace;
+import org.junit.jupiter.api.extension.ExtensionContext.Store;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+import java.net.URISyntaxException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.logging.Logger;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class LightCodeInsightExtension implements ParameterResolver, AfterTestExecutionCallback, InvocationInterceptor {
+
+    private static final Logger LOG = Logger.getLogger(LightCodeInsightExtension.class.getName());
+
+    @Override
+    public boolean supportsParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException {
+        Parameter parameter = parameterContext.getParameter();
+        return parameter.isAnnotationPresent(MyFixture.class)
+                || parameter.isAnnotationPresent(MyTestCase.class);
+    }
+
+    @Override
+    public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException {
+        LightCodeInsightFixtureTestCaseWrapper testCase = getWrapper(extensionContext);
+        Parameter parameter = parameterContext.getParameter();
+        if (parameter.isAnnotationPresent(MyFixture.class)) {
+            return testCase.getMyFixture();
+        } else if (parameter.isAnnotationPresent(MyTestCase.class)) {
+            return testCase;
+        }
+        return null;
+    }
+
+    private LightCodeInsightFixtureTestCaseWrapper getWrapper(ExtensionContext extensionContext) {
+        Store store = getStore(extensionContext);
+        return (LightCodeInsightFixtureTestCaseWrapper) store.getOrComputeIfAbsent("testCase",
+                key -> {
+                    LightCodeInsightFixtureTestCaseWrapper wrapper = new LightCodeInsightFixtureTestCaseWrapper(extensionContext);
+                    try {
+                        wrapper.setUp();
+                    } catch (Exception e) {
+                        LOG.severe("Exception during setUp(): " + e);
+                        throw new IllegalStateException("Exception during setUp()", e);
+                    }
+                    return wrapper;
+                });
+    }
+
+    @Override
+    public void afterTestExecution(ExtensionContext context) throws Exception {
+        Store store = getStore(context);
+        LightCodeInsightFixtureTestCaseWrapper testCase = (LightCodeInsightFixtureTestCaseWrapper) store.get("testCase");
+        if (testCase != null) {
+            testCase.tearDown();
+        }
+    }
+
+    private static Store getStore(ExtensionContext context) {
+        return context.getStore(Namespace.create(LightCodeInsightExtension.class, context.getRequiredTestMethod()));
+    }
+
+    @Override
+    public void interceptTestMethod(Invocation<Void> invocation, ReflectiveInvocationContext<Method> invocationContext, ExtensionContext extensionContext) throws Throwable {
+        Throwable[] throwables = new Throwable[1];
+
+        Runnable runnable = () -> {
+            try {
+                TestLoggerFactory.onTestStarted();
+                invocation.proceed();
+                TestLoggerFactory.onTestFinished(true);
+            } catch (Throwable e) {
+                TestLoggerFactory.onTestFinished(false);
+                throwables[0] = e;
+            }
+        };
+
+        invokeTestRunnable(runnable);
+
+        if (throwables[0] != null) {
+            throw throwables[0];
+        }
+    }
+
+    private static void invokeTestRunnable(@NotNull Runnable runnable) {
+        IdeaTestExecutionPolicy policy = IdeaTestExecutionPolicy.current();
+        if (policy != null && !policy.runInDispatchThread()) {
+            runnable.run();
+        } else {
+            EdtTestUtilKt.runInEdtAndWait(() -> {
+                runnable.run();
+                return null;
+            });
+        }
+    }
+
+    private static class LightCodeInsightFixtureTestCaseWrapper extends LightJavaCodeInsightFixtureTestCase {
+        private final ExtensionContext extensionContext;
+
+        private LightCodeInsightFixtureTestCaseWrapper(ExtensionContext extensionContext) {
+            this.extensionContext = extensionContext;
+        }
+
+        @Override
+        public void setUp() throws Exception {
+            super.setUp();
+            Store store = getStore(extensionContext);
+            store.put("disposable", Disposer.newDisposable("LightCodeInsightFixtureTestCaseWrapper"));
+        }
+
+        @Override
+        public void tearDown() throws Exception {
+            Store store = getStore(extensionContext);
+            Disposable disposable = (Disposable) store.get("disposable");
+            if (myFixture != null && disposable != null) {
+                Disposer.dispose(disposable);
+                store.remove("disposable");
+            }
+            super.tearDown();
+        }
+
+        @NotNull
+        @Override
+        protected LightProjectDescriptor getProjectDescriptor() {
+            TestJdk testJdk = getMethodOrClassAnnotation(TestJdk.class);
+            if (testJdk == null) {
+                return super.getProjectDescriptor();
+            }
+            return new ProjectDescriptor(testJdk.value(), testJdk.annotations()) {
+                @Override
+                public Sdk getSdk() {
+                    return testJdk.useInternal()
+                            ? JavaAwareProjectJdkTableImpl.getInstanceEx().getInternalJdk()
+                            : super.getSdk();
+                }
+
+                @Override
+                public void configureModule(@NotNull Module module, @NotNull ModifiableRootModel model, @NotNull ContentEntry contentEntry) {
+                    super.configureModule(module, model, contentEntry);
+                    AddLocalJarToModule localJars = getMethodOrClassAnnotation(AddLocalJarToModule.class);
+                    if (localJars != null) {
+                        Stream.of(localJars.value()).forEach(it -> addJarContaining(model, it));
+                    }
+                    List<AddMavenDependencyToModule> mavenDependencies = getMethodOrClassAnnotations(AddMavenDependencyToModule.class);
+                    mavenDependencies.forEach(it -> addFromMaven(model, it.value(), it.includeTransitiveDependencies, it.scope));
+                }
+            };
+        }
+
+        void addJarContaining(ModifiableRootModel model, Class<?> clazz) {
+            try {
+                Path jarPath = Paths.get(clazz.getProtectionDomain().getCodeSource().getLocation().toURI());
+
+                VirtualFile jarFile = LocalFileSystem.getInstance().findFileByIoFile(jarPath.toFile());
+                myFixture.allowTreeAccessForFile(jarFile);
+                PsiTestUtil.addLibrary(
+                        model,
+                        jarPath.getFileName().toString().replace(".jar", ""),
+                        jarPath.getParent().toString(),
+                        jarPath.getFileName().toString()
+                );
+            } catch (URISyntaxException e) {
+                throw new IllegalArgumentException("Class URL malformed", e);
+            }
+        }
+
+        void addFromMaven(ModifiableRootModel model, String mavenCoordinates,
+                          boolean includeTransitiveDependencies, DependencyScope dependencyScope) {
+            List<RemoteRepositoryDescription> remoteRepositoryDescriptions = RemoteRepositoryDescription.DEFAULT_REPOSITORIES;
+            RepositoryLibraryProperties libraryProperties = new RepositoryLibraryProperties(mavenCoordinates, includeTransitiveDependencies);
+            Collection<OrderRoot> roots =
+                    JarRepositoryManager.loadDependenciesModal(model.getProject(), libraryProperties, false, false, null, remoteRepositoryDescriptions);
+            LibraryTable.ModifiableModel tableModel = model.getModuleLibraryTable().getModifiableModel();
+            Library library = tableModel.createLibrary(mavenCoordinates);
+            Library.ModifiableModel libraryModel = library.getModifiableModel();
+            if (roots.isEmpty()) {
+                throw new IllegalStateException(String.format("No roots for '%s'", mavenCoordinates));
+            }
+
+            for (OrderRoot root : roots) {
+                libraryModel.addRoot(root.getFile(), root.getType());
+            }
+
+            LibraryOrderEntry libraryOrderEntry = model.findLibraryOrderEntry(library);
+            if (libraryOrderEntry == null) {
+                throw new IllegalStateException("Unable to find registered library " + mavenCoordinates);
+            }
+            libraryOrderEntry.setScope(dependencyScope);
+
+            libraryModel.commit();
+            tableModel.commit();
+        }
+
+        @Override
+        protected String getTestDataPath() {
+            TestDataPath testDataPath = getMethodOrClassAnnotation(TestDataPath.class);
+            if (testDataPath == null) {
+                return super.getTestDataPath();
+            }
+            TestDataSubPath testDataSubPath = getMethodOrClassAnnotation(TestDataSubPath.class);
+            if (testDataSubPath == null) {
+                return testDataPath.value();
+            }
+            return Paths.get(testDataPath.value(), testDataSubPath.value()).toString();
+        }
+
+        public JavaCodeInsightTestFixture getMyFixture() {
+            return myFixture;
+        }
+
+        private <T extends Annotation> T getMethodOrClassAnnotation(Class<T> clazz) {
+            T annotation = extensionContext.getRequiredTestMethod().getAnnotation(clazz);
+            if (annotation == null) {
+                annotation = extensionContext.getRequiredTestClass().getAnnotation(clazz);
+            }
+            return annotation;
+        }
+
+        private <T extends Annotation> List<T> getMethodOrClassAnnotations(Class<T> clazz) {
+            return Stream.of(extensionContext.getRequiredTestMethod().getAnnotationsByType(clazz),
+                    extensionContext.getRequiredTestClass().getAnnotationsByType(clazz))
+                    .flatMap(Arrays::stream)
+                    .collect(Collectors.toList());
+        }
+    }
+}

src/test/java/de/platon42/intellij/jupiter/MyFixture.java

@@ -0,0 +1,11 @@
+package de.platon42.intellij.jupiter;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface MyFixture {
+}

src/test/java/de/platon42/intellij/jupiter/MyTestCase.java

@@ -0,0 +1,11 @@
+package de.platon42.intellij.jupiter;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface MyTestCase {
+}

src/test/java/de/platon42/intellij/jupiter/TestDataPath.java

@@ -0,0 +1,10 @@
+package de.platon42.intellij.jupiter;
+
+import java.lang.annotation.*;
+
+@Target({ElementType.TYPE, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Inherited
+public @interface TestDataPath {
+    String value();
+}

src/test/java/de/platon42/intellij/jupiter/TestDataPath.kt

@@ -1,8 +0,0 @@
-package de.platon42.intellij.jupiter
-
-import java.lang.annotation.Inherited
-
-@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
-@Retention(AnnotationRetention.RUNTIME)
-@Inherited
-annotation class TestDataPath(val value: String)

src/test/java/de/platon42/intellij/jupiter/TestDataSubPath.java

@@ -0,0 +1,10 @@
+package de.platon42.intellij.jupiter;
+
+import java.lang.annotation.*;
+
+@Target({ElementType.TYPE, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Inherited
+public @interface TestDataSubPath {
+    String value();
+}

src/test/java/de/platon42/intellij/jupiter/TestDataSubPath.kt

@@ -1,8 +0,0 @@
-package de.platon42.intellij.jupiter
-
-import java.lang.annotation.Inherited
-
-@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
-@Retention(AnnotationRetention.RUNTIME)
-@Inherited
-annotation class TestDataSubPath(val value: String)

src/test/java/de/platon42/intellij/jupiter/TestJdk.java

@@ -0,0 +1,16 @@
+package de.platon42.intellij.jupiter;
+
+import com.intellij.pom.java.LanguageLevel;
+
+import java.lang.annotation.*;
+
+@Target({ElementType.TYPE, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Inherited
+public @interface TestJdk {
+    LanguageLevel value();
+
+    boolean annotations() default false;
+
+    boolean useInternal() default false;
+}

src/test/java/de/platon42/intellij/jupiter/TestJdk.kt

@@ -1,9 +0,0 @@
-package de.platon42.intellij.jupiter
-
-import com.intellij.pom.java.LanguageLevel
-import java.lang.annotation.Inherited
-
-@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
-@Retention(AnnotationRetention.RUNTIME)
-@Inherited
-annotation class TestJdk(val value: LanguageLevel)

src/test/java/de/platon42/intellij/plugins/cajon/AbstractCajonTest.kt

@@ -2,44 +2,45 @@ package de.platon42.intellij.plugins.cajon
 
 import com.intellij.codeInsight.intention.IntentionAction
 import com.intellij.pom.java.LanguageLevel
-import de.platon42.intellij.jupiter.AbstractJUnit5TestCase
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
-import de.platon42.intellij.jupiter.AddLocalJarToModule
+import de.platon42.intellij.jupiter.AddMavenDependencyToModule
+import de.platon42.intellij.jupiter.LightCodeInsightExtension
 import de.platon42.intellij.jupiter.TestDataPath
 import de.platon42.intellij.jupiter.TestJdk
-import org.assertj.core.api.Assertions
 import org.assertj.core.api.Assertions.assertThat
 import org.assertj.core.api.Condition
 import org.junit.jupiter.api.DisplayNameGeneration
 import org.junit.jupiter.api.DisplayNameGenerator
+import org.junit.jupiter.api.extension.ExtendWith
 import java.lang.reflect.Method
 
+@ExtendWith(LightCodeInsightExtension::class)
 @TestDataPath("src/test/resources")
-@TestJdk(LanguageLevel.JDK_1_8)
+@TestJdk(LanguageLevel.JDK_1_8, annotations = true, useInternal = true)
-@AddLocalJarToModule(Assertions::class)
+//@AddLocalJarToModule(Assertions::class)
-//@AddMavenDependencyToModule("org.assertj:assertj-core:3.25.3", includeTransitiveDependencies = false, DependencyScope.COMPILE)
+@AddMavenDependencyToModule("org.assertj:assertj-core:3.15.0")
 @DisplayNameGeneration(AbstractCajonTest.CutOffFixtureDisplayNameGenerator::class)
-abstract class AbstractCajonTest : AbstractJUnit5TestCase() {
+abstract class AbstractCajonTest {
 
-    protected fun executeQuickFixes(regex: Regex, expectedFixes: Int) {
+    protected fun executeQuickFixes(myFixture: JavaCodeInsightTestFixture, regex: Regex, expectedFixes: Int) {
-        val quickfixes = getQuickFixes(regex, expectedFixes)
+        val quickfixes = getQuickFixes(myFixture, regex, expectedFixes)
         assertThat(quickfixes.groupBy { it.familyName }).hasSize(1)
-        quickfixes.forEach(fixture::launchAction)
+        quickfixes.forEach(myFixture::launchAction)
     }
 
-    protected fun executeQuickFixesNoFamilyNameCheck(regex: Regex, expectedFixes: Int) {
+    protected fun executeQuickFixesNoFamilyNameCheck(myFixture: JavaCodeInsightTestFixture, regex: Regex, expectedFixes: Int) {
-        val quickfixes = getQuickFixes(regex, expectedFixes)
+        val quickfixes = getQuickFixes(myFixture, regex, expectedFixes)
-        quickfixes.forEach(fixture::launchAction)
+        quickfixes.forEach(myFixture::launchAction)
     }
 
-    protected fun getQuickFixes(regex: Regex, expectedFixes: Int): List<IntentionAction> {
+    protected fun getQuickFixes(myFixture: JavaCodeInsightTestFixture, regex: Regex, expectedFixes: Int): List<IntentionAction> {
-        val allFixes = fixture.getAllQuickFixes()
+        val quickfixes = myFixture.getAllQuickFixes().filter { it.text.matches(regex) }
-        val quickfixes = allFixes.filter { it.text.matches(regex) }
+        assertThat(quickfixes).`as`("Fixes matched by $regex: ${myFixture.getAllQuickFixes().map { it.text }}").hasSize(expectedFixes)
-        assertThat(quickfixes).`as`("Fixes matched by $regex: ${allFixes.map { it.text }}").hasSize(expectedFixes)
         return quickfixes
     }
 
-    protected fun assertHighlightings(count: Int, snippet: String) {
+    protected fun assertHighlightings(myFixture: JavaCodeInsightTestFixture, count: Int, snippet: String) {
-        assertThat(fixture.doHighlighting())
+        assertThat(myFixture.doHighlighting())
             .areExactly(count, Condition({ it.description?.contains(snippet) ?: false }, "containing"))
     }
 

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBinaryExpressionInspectionTest.kt

@@ -1,19 +1,19 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import com.intellij.testFramework.RunsInEdt
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
-@TestDataSubPath("inspections/BinaryExpression")
 internal class AssertThatBinaryExpressionInspectionTest : AbstractCajonTest() {
 
     @Test
-    @RunsInEdt
+    @TestDataSubPath("inspections/BinaryExpression")
-    internal fun assertThat_of_binary_expression_can_be_moved_out() {
+    internal fun assertThat_of_binary_expression_can_be_moved_out(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.enableInspections(AssertThatBinaryExpressionInspection::class.java)
+        myFixture.enableInspections(AssertThatBinaryExpressionInspection::class.java)
-        fixture.configureByFile("BinaryExpressionBefore.java")
+        myFixture.configureByFile("BinaryExpressionBefore.java")
-        executeQuickFixes(Regex.fromLiteral("Split binary expression out of assertThat()"), 161)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Split binary expression out of assertThat()"), 161)
-        fixture.checkResultByFile("BinaryExpressionAfter.java")
+        myFixture.checkResultByFile("BinaryExpressionAfter.java")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBooleanConditionInspectionTest.kt

@@ -1,20 +1,22 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
-@TestDataSubPath("inspections/BooleanCondition")
 internal class AssertThatBooleanConditionInspectionTest : AbstractCajonTest() {
 
     @Test
-    internal fun assertThat_with_isEqualTo_true_or_false_can_use_isTrue_or_isFalse() {
+    @TestDataSubPath("inspections/BooleanCondition")
-        fixture.enableInspections(AssertThatBooleanConditionInspection::class.java)
+    internal fun assertThat_with_isEqualTo_true_or_false_can_use_isTrue_or_isFalse(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.configureByFile("BooleanConditionBefore.java")
+        myFixture.enableInspections(AssertThatBooleanConditionInspection::class.java)
-        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isTrue()"), 6)
+        myFixture.configureByFile("BooleanConditionBefore.java")
-        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isFalse()"), 5)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isTrue()"), 6)
-        executeQuickFixes(Regex.fromLiteral("Replace isNotEqualTo() with isTrue()"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isFalse()"), 5)
-        executeQuickFixes(Regex.fromLiteral("Replace isNotEqualTo() with isFalse()"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isTrue()"), 4)
-        fixture.checkResultByFile("BooleanConditionAfter.java")
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isFalse()"), 4)
+        myFixture.checkResultByFile("BooleanConditionAfter.java")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatCollectionOrMapExpressionInspectionTest.kt

@@ -1,5 +1,7 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.assertj.core.api.Assertions.assertThat
@@ -9,68 +11,68 @@ import org.junit.jupiter.api.Test
 internal class AssertThatCollectionOrMapExpressionInspectionTest : AbstractCajonTest() {
 
     @Test
-    internal fun assertThat_with_certain_Collection_and_Map_methods() {
+    internal fun assertThat_with_certain_Collection_and_Map_methods(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.enableInspections(AssertThatCollectionOrMapExpressionInspection::class.java)
+        myFixture.enableInspections(AssertThatCollectionOrMapExpressionInspection::class.java)
-        fixture.configureByFile("CollectionMapExpressionBefore.java")
+        myFixture.configureByFile("CollectionMapExpressionBefore.java")
-        executeQuickFixes(Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 4)
-        executeQuickFixes(Regex.fromLiteral("Remove contains() of actual expression and use assertThat().contains() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().contains() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove containsAll() of actual expression and use assertThat().containsAll() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsAll() of actual expression and use assertThat().containsAll() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().containsKey() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().containsKey() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().containsValue() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().containsValue() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 5)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 5)
-        executeQuickFixes(Regex.fromLiteral("Remove contains() of actual expression and use assertThat().doesNotContain() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().doesNotContain() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().doesNotContainKey() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().doesNotContainKey() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().doesNotContainValue() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().doesNotContainValue() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
-        executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 4)
-        fixture.checkResultByFile("CollectionMapExpressionAfter.java")
+        myFixture.checkResultByFile("CollectionMapExpressionAfter.java")
     }
 
     @Test
-    internal fun assertThat_with_certain_Collection_and_Map_methods_with_Null_values() {
+    internal fun assertThat_with_certain_Collection_and_Map_methods_with_Null_values(@MyFixture myFixture: JavaCodeInsightTestFixture) {
         val inspection = AssertThatCollectionOrMapExpressionInspection()
         inspection.behaviorForMapValueEqualsNull = 3
-        fixture.enableInspections(inspection)
+        myFixture.enableInspections(inspection)
-        fixture.configureByFile("CollectionMapExpressionBefore.java")
+        myFixture.configureByFile("CollectionMapExpressionBefore.java")
-        executeQuickFixes(Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 4)
-        executeQuickFixes(Regex.fromLiteral("Remove contains() of actual expression and use assertThat().contains() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().contains() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove containsAll() of actual expression and use assertThat().containsAll() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsAll() of actual expression and use assertThat().containsAll() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().containsKey() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().containsKey() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().containsValue() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().containsValue() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 5)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 5)
-        executeQuickFixes(Regex.fromLiteral("Remove contains() of actual expression and use assertThat().doesNotContain() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().doesNotContain() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().doesNotContainKey() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().doesNotContainKey() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().doesNotContainValue() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().doesNotContainValue() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 6)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 6)
-        executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
-        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
+        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
-        fixture.checkResultByFile("CollectionMapExpressionWithNullValuesAfter.java")
+        myFixture.checkResultByFile("CollectionMapExpressionWithNullValuesAfter.java")
     }
 
     @Test
-    internal fun assertThat_with_certain_Collection_and_Map_methods_with_no_quickfixes_for_get_equals_null() {
+    internal fun assertThat_with_certain_Collection_and_Map_methods_with_no_quickfixes_for_get_equals_null(@MyFixture myFixture: JavaCodeInsightTestFixture) {
         val inspection = AssertThatCollectionOrMapExpressionInspection()
         inspection.behaviorForMapValueEqualsNull = 0
 
-        fixture.enableInspections(inspection)
+        myFixture.enableInspections(inspection)
-        fixture.configureByFile("CollectionMapExpressionBefore.java")
+        myFixture.configureByFile("CollectionMapExpressionBefore.java")
-        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
+        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
-        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
+        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
-        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
+        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
-        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
+        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
     }
 
     @Test
-    internal fun assertThat_with_certain_Collection_and_Map_methods_with_only_warnings_for_get_equals_null() {
+    internal fun assertThat_with_certain_Collection_and_Map_methods_with_only_warnings_for_get_equals_null(@MyFixture myFixture: JavaCodeInsightTestFixture) {
         val inspection = AssertThatCollectionOrMapExpressionInspection()
         inspection.behaviorForMapValueEqualsNull = 1
 
-        fixture.enableInspections(inspection)
+        myFixture.enableInspections(inspection)
-        fixture.configureByFile("CollectionMapExpressionBefore.java")
+        myFixture.configureByFile("CollectionMapExpressionBefore.java")
-        val highlights = fixture.doHighlighting()
+        val highlights = myFixture.doHighlighting()
             .asSequence()
             .filter { it.description == "Moving get() expression out of assertThat() would be more concise" }
             .filter {
@@ -79,24 +81,24 @@ internal class AssertThatCollectionOrMapExpressionInspectionTest : AbstractCajon
             .toList()
         assertThat(highlights).hasSize(4)
 
-        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
+        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
-        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
+        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
-        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
+        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
-        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
+        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
     }
 
     @Test
-    internal fun assertThat_with_certain_Collection_and_Map_methods_with_both_quickfixes_for_get_equals_null() {
+    internal fun assertThat_with_certain_Collection_and_Map_methods_with_both_quickfixes_for_get_equals_null(@MyFixture myFixture: JavaCodeInsightTestFixture) {
         val inspection = AssertThatCollectionOrMapExpressionInspection()
         inspection.behaviorForMapValueEqualsNull = 4
 
-        fixture.enableInspections(inspection)
+        myFixture.enableInspections(inspection)
-        fixture.configureByFile("CollectionMapExpressionBefore.java")
+        myFixture.configureByFile("CollectionMapExpressionBefore.java")
-        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
+        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
-        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead (regular map)"), 4)
+        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead (regular map)"), 4)
-        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry(key, null) instead (degenerated map)"), 4)
+        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry(key, null) instead (degenerated map)"), 4)
-        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
+        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
-        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
+        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
-        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
+        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatComparableInspectionTest.kt

@@ -1,22 +1,24 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
-@TestDataSubPath("inspections/Comparable")
 internal class AssertThatComparableInspectionTest : AbstractCajonTest() {
 
     @Test
-    internal fun assertThat_with_compareTo_method() {
+    @TestDataSubPath("inspections/Comparable")
-        fixture.enableInspections(AssertThatComparableInspection::class.java)
+    internal fun assertThat_with_compareTo_method(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.configureByFile("ComparableBefore.java")
+        myFixture.enableInspections(AssertThatComparableInspection::class.java)
-        executeQuickFixes(Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isEqualByComparingTo() instead"), 2)
+        myFixture.configureByFile("ComparableBefore.java")
-        executeQuickFixes(Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isNotEqualByComparingTo() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isEqualByComparingTo() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isGreaterThanOrEqualTo() instead"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isNotEqualByComparingTo() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isGreaterThan() instead"), 5)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isGreaterThanOrEqualTo() instead"), 4)
-        executeQuickFixes(Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isLessThanOrEqualTo() instead"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isGreaterThan() instead"), 5)
-        executeQuickFixes(Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isLessThan() instead"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isLessThanOrEqualTo() instead"), 4)
-        fixture.checkResultByFile("ComparableAfter.java")
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isLessThan() instead"), 4)
+        myFixture.checkResultByFile("ComparableAfter.java")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatEnumerableIsEmptyInspectionTest.kt

@@ -1,21 +1,23 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
-@TestDataSubPath("inspections/EnumerableIsEmpty")
 internal class AssertThatEnumerableIsEmptyInspectionTest : AbstractCajonTest() {
 
     @Test
-    internal fun assertThat_with_hasSize_zero_and_similar_can_use_isEmpty() {
+    @TestDataSubPath("inspections/EnumerableIsEmpty")
-        fixture.enableInspections(AssertThatEnumerableIsEmptyInspection::class.java)
+    internal fun assertThat_with_hasSize_zero_and_similar_can_use_isEmpty(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.configureByFile("EnumerableIsEmptyBefore.java")
+        myFixture.enableInspections(AssertThatEnumerableIsEmptyInspection::class.java)
-        executeQuickFixes(Regex.fromLiteral("Replace hasSize() with isEmpty()"), 5)
+        myFixture.configureByFile("EnumerableIsEmptyBefore.java")
-        executeQuickFixes(Regex.fromLiteral("Replace hasSizeLessThan() with isEmpty()"), 5)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSize() with isEmpty()"), 5)
-        executeQuickFixes(Regex.fromLiteral("Replace hasSizeLessThanOrEqualTo() with isEmpty()"), 5)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSizeLessThan() with isEmpty()"), 5)
-        executeQuickFixes(Regex.fromLiteral("Replace hasSizeGreaterThan() with isNotEmpty()"), 6)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSizeLessThanOrEqualTo() with isEmpty()"), 5)
-        executeQuickFixes(Regex.fromLiteral("Replace hasSizeGreaterThanOrEqualTo() with isNotEmpty()"), 6)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSizeGreaterThan() with isNotEmpty()"), 6)
-        fixture.checkResultByFile("EnumerableIsEmptyAfter.java")
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSizeGreaterThanOrEqualTo() with isNotEmpty()"), 6)
+        myFixture.checkResultByFile("EnumerableIsEmptyAfter.java")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatFileExpressionInspectionTest.kt

@@ -1,36 +1,38 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
-@TestDataSubPath("inspections/FileExpression")
 internal class AssertThatFileExpressionInspectionTest : AbstractCajonTest() {
 
     @Test
-    internal fun assertThat_with_certain_File_methods() {
+    @TestDataSubPath("inspections/FileExpression")
-        fixture.enableInspections(AssertThatFileExpressionInspection::class.java)
+    internal fun assertThat_with_certain_File_methods(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.configureByFile("FileExpressionBefore.java")
+        myFixture.enableInspections(AssertThatFileExpressionInspection::class.java)
-        executeQuickFixes(Regex.fromLiteral("Remove canRead() of actual expression and use assertThat().canRead() instead"), 3)
+        myFixture.configureByFile("FileExpressionBefore.java")
-        executeQuickFixes(Regex.fromLiteral("Remove canWrite() of actual expression and use assertThat().canWrite() instead"), 3)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove canRead() of actual expression and use assertThat().canRead() instead"), 3)
-        executeQuickFixes(Regex.fromLiteral("Remove exists() of actual expression and use assertThat().exists() instead"), 3)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove canWrite() of actual expression and use assertThat().canWrite() instead"), 3)
-        executeQuickFixes(Regex.fromLiteral("Remove exists() of actual expression and use assertThat().doesNotExist() instead"), 3)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove exists() of actual expression and use assertThat().exists() instead"), 3)
-        executeQuickFixes(Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isAbsolute() instead"), 3)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove exists() of actual expression and use assertThat().doesNotExist() instead"), 3)
-        executeQuickFixes(Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isRelative() instead"), 3)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isAbsolute() instead"), 3)
-        executeQuickFixes(Regex.fromLiteral("Remove isDirectory() of actual expression and use assertThat().isDirectory() instead"), 3)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isRelative() instead"), 3)
-        executeQuickFixes(Regex.fromLiteral("Remove isFile() of actual expression and use assertThat().isFile() instead"), 3)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isDirectory() of actual expression and use assertThat().isDirectory() instead"), 3)
-        executeQuickFixes(Regex.fromLiteral("Remove getName() of actual expression and use assertThat().hasName() instead"), 3)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isFile() of actual expression and use assertThat().isFile() instead"), 3)
-        executeQuickFixes(Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasNoParent() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove getName() of actual expression and use assertThat().hasName() instead"), 3)
-        executeQuickFixes(Regex.fromLiteral("Remove getParentFile() of actual expression and use assertThat().hasNoParent() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasNoParent() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasParent() instead"), 1)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove getParentFile() of actual expression and use assertThat().hasNoParent() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove getParentFile() of actual expression and use assertThat().hasParent() instead"), 1)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasParent() instead"), 1)
-        executeQuickFixes(Regex.fromLiteral("Remove listFiles() of actual expression and use assertThat().isEmptyDirectory() instead"), 1)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove getParentFile() of actual expression and use assertThat().hasParent() instead"), 1)
-        executeQuickFixes(Regex.fromLiteral("Remove listFiles() of actual expression and use assertThat().isNotEmptyDirectory() instead"), 1)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove listFiles() of actual expression and use assertThat().isEmptyDirectory() instead"), 1)
-        executeQuickFixes(Regex.fromLiteral("Remove list() of actual expression and use assertThat().isEmptyDirectory() instead"), 1)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove listFiles() of actual expression and use assertThat().isNotEmptyDirectory() instead"), 1)
-        executeQuickFixes(Regex.fromLiteral("Remove list() of actual expression and use assertThat().isNotEmptyDirectory() instead"), 1)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove list() of actual expression and use assertThat().isEmptyDirectory() instead"), 1)
-        executeQuickFixes(Regex.fromLiteral("Remove length() of actual expression and use assertThat().isEmpty() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove list() of actual expression and use assertThat().isNotEmptyDirectory() instead"), 1)
-        executeQuickFixes(Regex.fromLiteral("Remove length() of actual expression and use assertThat().isNotEmpty() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove length() of actual expression and use assertThat().isEmpty() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove length() of actual expression and use assertThat().hasSize() instead"), 1)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove length() of actual expression and use assertThat().isNotEmpty() instead"), 2)
-        fixture.checkResultByFile("FileExpressionAfter.java")
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove length() of actual expression and use assertThat().hasSize() instead"), 1)
+        myFixture.checkResultByFile("FileExpressionAfter.java")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatGuavaOptionalInspectionTest.kt

@@ -1,45 +1,48 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import de.platon42.intellij.jupiter.AddMavenDependencyToModule
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.AddLocalJarToModule
+import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
+import org.assertj.core.api.Assertions
 import org.junit.jupiter.api.Test
 
-@AddMavenDependencyToModule("org.assertj:assertj-guava:3.25.3")
+@AddLocalJarToModule(com.google.common.base.Optional::class, org.assertj.guava.api.Assertions::class, Assertions::class)
 @TestDataSubPath("inspections/GuavaOptional")
 internal class AssertThatGuavaOptionalInspectionTest : AbstractCajonTest() {
 
     @Test
-    internal fun assertThat_get_or_isPresent_for_Guava_Optional_can_be_simplified() {
+    internal fun assertThat_get_or_isPresent_for_Guava_Optional_can_be_simplified(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
+        myFixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
-        fixture.configureByFile("GuavaOptionalBefore.java")
+        myFixture.configureByFile("GuavaOptionalBefore.java")
-        executeQuickFixes(Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isPresent() instead"), 6)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isPresent() instead"), 6)
-        executeQuickFixes(Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isAbsent() instead"), 5)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isAbsent() instead"), 5)
-        executeQuickFixes(Regex.fromLiteral("Remove orNull() of actual expression and use assertThat().isPresent() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove orNull() of actual expression and use assertThat().isPresent() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove orNull() of actual expression and use assertThat().isAbsent() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove orNull() of actual expression and use assertThat().isAbsent() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().contains() instead"), 1)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().contains() instead"), 1)
-        executeQuickFixes(Regex.fromLiteral("Unwrap expected expression and replace isEqualTo() with contains()"), 6)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap expected expression and replace isEqualTo() with contains()"), 6)
-        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with Guava assertThat().isAbsent()"), 3)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with Guava assertThat().isAbsent()"), 3)
-        executeQuickFixes(Regex.fromLiteral("Replace isNotEqualTo() with Guava assertThat().isPresent()"), 3)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with Guava assertThat().isPresent()"), 3)
-        fixture.checkResultByFile("GuavaOptionalAfter.java")
+        myFixture.checkResultByFile("GuavaOptionalAfter.java")
     }
 
     @Test
-    internal fun adds_missing_Guava_import_any_order() {
+    internal fun adds_missing_Guava_import_any_order(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
+        myFixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
-        fixture.configureByFile("WithoutPriorGuavaImportBefore.java")
+        myFixture.configureByFile("WithoutPriorGuavaImportBefore.java")
-        executeQuickFixesNoFamilyNameCheck(Regex(".*eplace .* with .*"), 4)
+        executeQuickFixesNoFamilyNameCheck(myFixture, Regex(".*eplace .* with .*"), 4)
-        executeQuickFixesNoFamilyNameCheck(Regex("Remove .*"), 3)
+        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Remove .*"), 3)
-        fixture.checkResultByFile("WithoutPriorGuavaImportAfter.java")
+        myFixture.checkResultByFile("WithoutPriorGuavaImportAfter.java")
     }
 
     @Test
-    internal fun adds_missing_Guava_import_isAbsent_first() {
+    internal fun adds_missing_Guava_import_isAbsent_first(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
+        myFixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
-        fixture.configureByFile("WithoutPriorGuavaImportBefore.java")
+        myFixture.configureByFile("WithoutPriorGuavaImportBefore.java")
-        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with Guava assertThat().isAbsent()"), 1)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with Guava assertThat().isAbsent()"), 1)
-        executeQuickFixesNoFamilyNameCheck(Regex(".*eplace .* with .*"), 3)
+        executeQuickFixesNoFamilyNameCheck(myFixture, Regex(".*eplace .* with .*"), 3)
-        executeQuickFixesNoFamilyNameCheck(Regex("Remove .*"), 3)
+        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Remove .*"), 3)
-        fixture.checkResultByFile("WithoutPriorGuavaImportAfter.java")
+        myFixture.checkResultByFile("WithoutPriorGuavaImportAfter.java")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInstanceOfInspectionTest.kt

@@ -1,18 +1,20 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
-@TestDataSubPath("inspections/InstanceOf")
 internal class AssertThatInstanceOfInspectionTest : AbstractCajonTest() {
 
     @Test
-    internal fun assertThat_with_instanceof_can_be_moved_out() {
+    @TestDataSubPath("inspections/InstanceOf")
-        fixture.enableInspections(AssertThatInstanceOfInspection::class.java)
+    internal fun assertThat_with_instanceof_can_be_moved_out(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.configureByFile("InstanceOfBefore.java")
+        myFixture.enableInspections(AssertThatInstanceOfInspection::class.java)
-        executeQuickFixes(Regex.fromLiteral("Remove instanceof in actual expression and use assertThat().isInstanceOf() instead"), 6)
+        myFixture.configureByFile("InstanceOfBefore.java")
-        executeQuickFixes(Regex.fromLiteral("Remove instanceof in actual expression and use assertThat().isNotInstanceOf() instead"), 6)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove instanceof in actual expression and use assertThat().isInstanceOf() instead"), 6)
-        fixture.checkResultByFile("InstanceOfAfter.java")
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove instanceof in actual expression and use assertThat().isNotInstanceOf() instead"), 6)
+        myFixture.checkResultByFile("InstanceOfAfter.java")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInvertedBooleanConditionInspectionTest.kt

@@ -1,19 +1,21 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
-@TestDataSubPath("inspections/InvertedBooleanCondition")
 internal class AssertThatInvertedBooleanConditionInspectionTest : AbstractCajonTest() {
 
     @Test
-    internal fun assertThat_with_inverted_boolean_condition_can_be_inverted() {
+    @TestDataSubPath("inspections/InvertedBooleanCondition")
-        fixture.enableInspections(AssertThatInvertedBooleanConditionInspection::class.java)
+    internal fun assertThat_with_inverted_boolean_condition_can_be_inverted(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.configureByFile("InvertedBooleanConditionBefore.java")
+        myFixture.enableInspections(AssertThatInvertedBooleanConditionInspection::class.java)
-        executeQuickFixes(Regex.fromLiteral("Invert condition in assertThat()"), 25)
+        myFixture.configureByFile("InvertedBooleanConditionBefore.java")
-        executeQuickFixes(Regex.fromLiteral("Invert condition in isEqualTo() and use isNotEqualTo() instead"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Invert condition in assertThat()"), 25)
-        executeQuickFixes(Regex.fromLiteral("Invert condition in isNotEqualTo() and use isEqualTo() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Invert condition in isEqualTo() and use isNotEqualTo() instead"), 4)
-        fixture.checkResultByFile("InvertedBooleanConditionAfter.java")
+        executeQuickFixes(myFixture, Regex.fromLiteral("Invert condition in isNotEqualTo() and use isEqualTo() instead"), 2)
+        myFixture.checkResultByFile("InvertedBooleanConditionAfter.java")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatIsZeroOneInspectionTest.kt

@@ -1,19 +1,21 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
-@TestDataSubPath("inspections/IsZeroOne")
 internal class AssertThatIsZeroOneInspectionTest : AbstractCajonTest() {
 
     @Test
-    internal fun assertThat_with_isEqualTo_zero_or_one_can_use_isZero_or_isOne_plus_isNotZero() {
+    @TestDataSubPath("inspections/IsZeroOne")
-        fixture.enableInspections(AssertThatIsZeroOneInspection::class.java)
+    internal fun assertThat_with_isEqualTo_zero_or_one_can_use_isZero_or_isOne_plus_isNotZero(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.configureByFile("IsZeroOneBefore.java")
+        myFixture.enableInspections(AssertThatIsZeroOneInspection::class.java)
-        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isZero()"), 10)
+        myFixture.configureByFile("IsZeroOneBefore.java")
-        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isOne()"), 10)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isZero()"), 10)
-        executeQuickFixes(Regex.fromLiteral("Replace isNotEqualTo() with isNotZero()"), 10)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isOne()"), 10)
-        fixture.checkResultByFile("IsZeroOneAfter.java")
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isNotZero()"), 10)
+        myFixture.checkResultByFile("IsZeroOneAfter.java")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatJava8OptionalInspectionTest.kt

@@ -1,25 +1,27 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
-@TestDataSubPath("inspections/Java8Optional")
 internal class AssertThatJava8OptionalInspectionTest : AbstractCajonTest() {
 
     @Test
-    internal fun assertThat_get_or_isPresent_for_Java8_Optional_can_be_simplified() {
+    @TestDataSubPath("inspections/Java8Optional")
-        fixture.enableInspections(AssertThatJava8OptionalInspection::class.java)
+    internal fun assertThat_get_or_isPresent_for_Java8_Optional_can_be_simplified(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.configureByFile("Java8OptionalBefore.java")
+        myFixture.enableInspections(AssertThatJava8OptionalInspection::class.java)
-        executeQuickFixes(Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isPresent() instead"), 6)
+        myFixture.configureByFile("Java8OptionalBefore.java")
-        executeQuickFixes(Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isNotPresent() instead"), 5)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isPresent() instead"), 6)
-        executeQuickFixes(Regex.fromLiteral("Remove orElse() of actual expression and use assertThat().isPresent() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isNotPresent() instead"), 5)
-        executeQuickFixes(Regex.fromLiteral("Remove orElse() of actual expression and use assertThat().isNotPresent() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove orElse() of actual expression and use assertThat().isPresent() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().contains() instead"), 1)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove orElse() of actual expression and use assertThat().isNotPresent() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsSame() instead"), 1)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().contains() instead"), 1)
-        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isNotPresent()"), 1)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsSame() instead"), 1)
-        executeQuickFixes(Regex.fromLiteral("Replace isNotEqualTo() with isPresent()"), 1)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isNotPresent()"), 1)
-        executeQuickFixes(Regex.fromLiteral("Unwrap expected expression and replace isEqualTo() with contains()"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isPresent()"), 1)
-        fixture.checkResultByFile("Java8OptionalAfter.java")
+        executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap expected expression and replace isEqualTo() with contains()"), 2)
+        myFixture.checkResultByFile("Java8OptionalAfter.java")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatObjectExpressionInspectionTest.kt

@@ -1,20 +1,22 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
-@TestDataSubPath("inspections/ObjectExpression")
 internal class AssertThatObjectExpressionInspectionTest : AbstractCajonTest() {
 
     @Test
-    internal fun assertThat_with_certain_Object_methods() {
+    @TestDataSubPath("inspections/ObjectExpression")
-        fixture.enableInspections(AssertThatObjectExpressionInspection::class.java)
+    internal fun assertThat_with_certain_Object_methods(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.configureByFile("ObjectExpressionBefore.java")
+        myFixture.enableInspections(AssertThatObjectExpressionInspection::class.java)
-        executeQuickFixes(Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isEqualTo() instead"), 4)
+        myFixture.configureByFile("ObjectExpressionBefore.java")
-        executeQuickFixes(Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isNotEqualTo() instead"), 3)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isEqualTo() instead"), 4)
-        executeQuickFixes(Regex.fromLiteral("Replace calls to hashCode() with hasSameHashCodeAs()"), 1)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isNotEqualTo() instead"), 3)
-        executeQuickFixes(Regex.fromLiteral("Remove toString() of actual expression and use assertThat().hasToString() instead"), 1)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace calls to hashCode() with hasSameHashCodeAs()"), 1)
-        fixture.checkResultByFile("ObjectExpressionAfter.java")
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove toString() of actual expression and use assertThat().hasToString() instead"), 1)
+        myFixture.checkResultByFile("ObjectExpressionAfter.java")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatObjectIsNullOrNotNullInspectionTest.kt

@@ -1,18 +1,20 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
-@TestDataSubPath("inspections/ObjectIsNullOrNotNull")
 internal class AssertThatObjectIsNullOrNotNullInspectionTest : AbstractCajonTest() {
 
     @Test
-    internal fun assertThat_with_isEqualTo_null_can_use_isNull() {
+    @TestDataSubPath("inspections/ObjectIsNullOrNotNull")
-        fixture.enableInspections(AssertThatObjectIsNullOrNotNullInspection::class.java)
+    internal fun assertThat_with_isEqualTo_null_can_use_isNull(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.configureByFile("ObjectIsNullOrNotNullBefore.java")
+        myFixture.enableInspections(AssertThatObjectIsNullOrNotNullInspection::class.java)
-        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isNull()"), 4)
+        myFixture.configureByFile("ObjectIsNullOrNotNullBefore.java")
-        executeQuickFixes(Regex.fromLiteral("Replace isNotEqualTo() with isNotNull()"), 5)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isNull()"), 4)
-        fixture.checkResultByFile("ObjectIsNullOrNotNullAfter.java")
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isNotNull()"), 5)
+        myFixture.checkResultByFile("ObjectIsNullOrNotNullAfter.java")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatPathExpressionInspectionTest.kt

@@ -1,22 +1,24 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
-@TestDataSubPath("inspections/PathExpression")
 internal class AssertThatPathExpressionInspectionTest : AbstractCajonTest() {
 
     @Test
-    internal fun assertThat_with_certain_Path_methods() {
+    @TestDataSubPath("inspections/PathExpression")
-        fixture.enableInspections(AssertThatPathExpressionInspection::class.java)
+    internal fun assertThat_with_certain_Path_methods(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.configureByFile("PathExpressionBefore.java")
+        myFixture.enableInspections(AssertThatPathExpressionInspection::class.java)
-        executeQuickFixes(Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isAbsolute() instead"), 3)
+        myFixture.configureByFile("PathExpressionBefore.java")
-        executeQuickFixes(Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isRelative() instead"), 3)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isAbsolute() instead"), 3)
-        executeQuickFixes(Regex.fromLiteral("Remove startsWith() of actual expression and use assertThat().startsWithRaw() instead"), 3)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isRelative() instead"), 3)
-        executeQuickFixes(Regex.fromLiteral("Remove endsWith() of actual expression and use assertThat().endsWithRaw() instead"), 3)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove startsWith() of actual expression and use assertThat().startsWithRaw() instead"), 3)
-        executeQuickFixes(Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasNoParentRaw() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove endsWith() of actual expression and use assertThat().endsWithRaw() instead"), 3)
-        executeQuickFixes(Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasParentRaw() instead"), 1)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasNoParentRaw() instead"), 2)
-        fixture.checkResultByFile("PathExpressionAfter.java")
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasParentRaw() instead"), 1)
+        myFixture.checkResultByFile("PathExpressionAfter.java")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatSizeInspectionTest.kt

@@ -1,32 +1,34 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
-@TestDataSubPath("inspections/Size")
 internal class AssertThatSizeInspectionTest : AbstractCajonTest() {
 
     @Test
-    internal fun assertThat_size_of_array_collection_or_map_can_be_simplified() {
+    @TestDataSubPath("inspections/Size")
-        fixture.enableInspections(AssertThatSizeInspection::class.java)
+    internal fun assertThat_size_of_array_collection_or_map_can_be_simplified(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.configureByFile("SizeBefore.java")
+        myFixture.enableInspections(AssertThatSizeInspection::class.java)
-        assertHighlightings(1, "Try to operate on the iterable itself rather than its size")
+        myFixture.configureByFile("SizeBefore.java")
+        assertHighlightings(myFixture, 1, "Try to operate on the iterable itself rather than its size")
 
-        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 5)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 5)
-        executeQuickFixes(Regex.fromLiteral("Replace isZero() with isEmpty()"), 5)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isZero() with isEmpty()"), 5)
-        executeQuickFixes(Regex.fromLiteral("Replace isNotZero() with isNotEmpty()"), 5)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotZero() with isNotEmpty()"), 5)
-        executeQuickFixes(Regex.fromLiteral("Replace isGreaterThan() with isNotEmpty()"), 5)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThan() with isNotEmpty()"), 5)
-        executeQuickFixes(Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with isNotEmpty()"), 5)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with isNotEmpty()"), 5)
-        executeQuickFixes(Regex.fromLiteral("Replace isLessThan() with isEmpty()"), 5)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThan() with isEmpty()"), 5)
-        executeQuickFixes(Regex.fromLiteral("Replace isLessThanOrEqualTo() with isEmpty()"), 5)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThanOrEqualTo() with isEmpty()"), 5)
-        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with hasSameSizeAs()"), 15)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with hasSameSizeAs()"), 15)
-        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with hasSize()"), 15)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with hasSize()"), 15)
-        executeQuickFixes(Regex.fromLiteral("Replace isGreaterThan() with hasSizeGreaterThan()"), 5)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThan() with hasSizeGreaterThan()"), 5)
-        executeQuickFixes(Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with hasSizeGreaterThanOrEqualTo()"), 5)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with hasSizeGreaterThanOrEqualTo()"), 5)
-        executeQuickFixes(Regex.fromLiteral("Replace isLessThan() with hasSizeLessThan()"), 5)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThan() with hasSizeLessThan()"), 5)
-        executeQuickFixes(Regex.fromLiteral("Replace isLessThanOrEqualTo() with hasSizeLessThanOrEqualTo()"), 5)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThanOrEqualTo() with hasSizeLessThanOrEqualTo()"), 5)
-        executeQuickFixes(Regex.fromLiteral("Remove size determination of expected expression and replace hasSize() with hasSameSizeAs()"), 17)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove size determination of expected expression and replace hasSize() with hasSameSizeAs()"), 17)
-        fixture.checkResultByFile("SizeAfter.java")
+        myFixture.checkResultByFile("SizeAfter.java")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringExpressionInspectionTest.kt

@@ -1,39 +1,41 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
-@TestDataSubPath("inspections/StringExpression")
 internal class AssertThatStringExpressionInspectionTest : AbstractCajonTest() {
 
     @Test
-    internal fun assertThat_with_certain_String_methods() {
+    @TestDataSubPath("inspections/StringExpression")
-        fixture.enableInspections(AssertThatStringExpressionInspection::class.java)
+    internal fun assertThat_with_certain_String_methods(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.configureByFile("StringExpressionBefore.java")
+        myFixture.enableInspections(AssertThatStringExpressionInspection::class.java)
-        executeQuickFixes(Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 3)
+        myFixture.configureByFile("StringExpressionBefore.java")
-        executeQuickFixes(Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isEqualTo() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 3)
-        executeQuickFixes(Regex.fromLiteral("Remove equalsIgnoreCase() of actual expression and use assertThat().isEqualToIgnoringCase() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isEqualTo() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove contentEquals() of actual expression and use assertThat().isEqualTo() instead"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove equalsIgnoreCase() of actual expression and use assertThat().isEqualToIgnoringCase() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove contains() of actual expression and use assertThat().contains() instead"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contentEquals() of actual expression and use assertThat().isEqualTo() instead"), 4)
-        executeQuickFixes(Regex.fromLiteral("Remove startsWith() of actual expression and use assertThat().startsWith() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().contains() instead"), 4)
-        executeQuickFixes(Regex.fromLiteral("Remove endsWith() of actual expression and use assertThat().endsWith() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove startsWith() of actual expression and use assertThat().startsWith() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove matches() of actual expression and use assertThat().matches() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove endsWith() of actual expression and use assertThat().endsWith() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove matches() of actual expression and use assertThat().doesNotMatch() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove matches() of actual expression and use assertThat().matches() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 3)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove matches() of actual expression and use assertThat().doesNotMatch() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isNotEqualTo() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 3)
-        executeQuickFixes(Regex.fromLiteral("Remove equalsIgnoreCase() of actual expression and use assertThat().isNotEqualToIgnoringCase() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isNotEqualTo() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove contentEquals() of actual expression and use assertThat().isNotEqualTo() instead"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove equalsIgnoreCase() of actual expression and use assertThat().isNotEqualToIgnoringCase() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove contains() of actual expression and use assertThat().doesNotContain() instead"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contentEquals() of actual expression and use assertThat().isNotEqualTo() instead"), 4)
-        executeQuickFixes(Regex.fromLiteral("Remove startsWith() of actual expression and use assertThat().doesNotStartWith() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().doesNotContain() instead"), 4)
-        executeQuickFixes(Regex.fromLiteral("Remove endsWith() of actual expression and use assertThat().doesNotEndWith() instead"), 3)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove startsWith() of actual expression and use assertThat().doesNotStartWith() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove compareToIgnoreCase() of actual expression and use assertThat().isEqualToIgnoringCase() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove endsWith() of actual expression and use assertThat().doesNotEndWith() instead"), 3)
-        executeQuickFixes(Regex.fromLiteral("Remove compareToIgnoreCase() of actual expression and use assertThat().isNotEqualToIgnoringCase() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove compareToIgnoreCase() of actual expression and use assertThat().isEqualToIgnoringCase() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove indexOf() of actual expression and use assertThat().startsWith() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove compareToIgnoreCase() of actual expression and use assertThat().isNotEqualToIgnoringCase() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove indexOf() of actual expression and use assertThat().doesNotStartWith() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove indexOf() of actual expression and use assertThat().startsWith() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove indexOf() of actual expression and use assertThat().contains() instead"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove indexOf() of actual expression and use assertThat().doesNotStartWith() instead"), 2)
-        executeQuickFixes(Regex.fromLiteral("Remove indexOf() of actual expression and use assertThat().doesNotContain() instead"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove indexOf() of actual expression and use assertThat().contains() instead"), 4)
-        executeQuickFixes(Regex.fromLiteral("Remove trim() of actual expression and use assertThat().isNotBlank() instead"), 1)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove indexOf() of actual expression and use assertThat().doesNotContain() instead"), 4)
-        fixture.checkResultByFile("StringExpressionAfter.java")
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove trim() of actual expression and use assertThat().isNotBlank() instead"), 1)
+        myFixture.checkResultByFile("StringExpressionAfter.java")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringIsEmptyInspectionTest.kt

@@ -1,25 +1,27 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.assertj.core.api.Assertions.assertThat
 import org.assertj.core.api.extrakting
 import org.junit.jupiter.api.Test
 
-@TestDataSubPath("inspections/StringIsEmpty")
 internal class AssertThatStringIsEmptyInspectionTest : AbstractCajonTest() {
 
     @Test
-    internal fun assertThat_with_isEqualTo_emptyString_can_use_isEmpty() {
+    @TestDataSubPath("inspections/StringIsEmpty")
-        fixture.enableInspections(AssertThatStringIsEmptyInspection::class.java)
+    internal fun assertThat_with_isEqualTo_emptyString_can_use_isEmpty(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.configureByFile("StringIsEmptyBefore.java")
+        myFixture.enableInspections(AssertThatStringIsEmptyInspection::class.java)
-        val highlights = fixture.doHighlighting()
+        myFixture.configureByFile("StringIsEmptyBefore.java")
+        val highlights = myFixture.doHighlighting()
             .asSequence()
             .filter { it.description?.contains(" can be simplified to") ?: false }
             .toList()
         assertThat(highlights).hasSize(6).extrakting { it.text }.doesNotContain("assertThat")
-        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 3)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 3)
-        executeQuickFixes(Regex.fromLiteral("Replace hasSize() with isEmpty()"), 3)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSize() with isEmpty()"), 3)
-        fixture.checkResultByFile("StringIsEmptyAfter.java")
+        myFixture.checkResultByFile("StringIsEmptyAfter.java")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssumeThatInsteadOfReturnInspectionTest.kt

@@ -1,20 +1,22 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import de.platon42.intellij.jupiter.AddMavenDependencyToModule
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.AddLocalJarToModule
+import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
+import org.assertj.core.api.Assertions
 import org.junit.jupiter.api.Test
 
-@AddMavenDependencyToModule("junit:junit:4.13.2")
+@AddLocalJarToModule(Assertions::class, Test::class, org.junit.Test::class)
-@AddMavenDependencyToModule("org.junit.jupiter:junit-jupiter-api:5.10.2")
-@TestDataSubPath("inspections/AssumeThat")
 internal class AssumeThatInsteadOfReturnInspectionTest : AbstractCajonTest() {
 
     @Test
-    internal fun conditional_returns_can_be_replaced_by_assumeThat() {
+    @TestDataSubPath("inspections/AssumeThat")
-        fixture.enableInspections(AssumeThatInsteadOfReturnInspection::class.java)
+    internal fun conditional_returns_can_be_replaced_by_assumeThat(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.configureByFile("AssumeThatBefore.java")
+        myFixture.enableInspections(AssumeThatInsteadOfReturnInspection::class.java)
-        executeQuickFixes(Regex.fromLiteral("Replace if statement by assumeTrue()"), 5)
+        myFixture.configureByFile("AssumeThatBefore.java")
-        fixture.checkResultByFile("AssumeThatAfter.java")
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace if statement by assumeTrue()"), 5)
+        myFixture.checkResultByFile("AssumeThatAfter.java")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/BogusAssertionInspectionTest.kt

@@ -1,17 +1,19 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
-@TestDataSubPath("inspections/BogusAssertion")
 internal class BogusAssertionInspectionTest : AbstractCajonTest() {
 
     @Test
-    internal fun reports_bogus_assertions() {
+    @TestDataSubPath("inspections/BogusAssertion")
-        fixture.enableInspections(BogusAssertionInspection::class.java)
+    internal fun reports_bogus_assertions(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.configureByFile("BogusAssertionBefore.java")
+        myFixture.enableInspections(BogusAssertionInspection::class.java)
-        assertHighlightings(14 * 9 + 10 + 12 + 8, "Actual expression in assertThat() is the same as expected")
+        myFixture.configureByFile("BogusAssertionBefore.java")
-        assertHighlightings(3, "Same actual and expected expression, but may be testing equals() or hashCode()")
+        assertHighlightings(myFixture, 14 * 9 + 10 + 12 + 8, "Actual expression in assertThat() is the same as expected")
+        assertHighlightings(myFixture, 3, "Same actual and expected expression, but may be testing equals() or hashCode()")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/ImplicitAssertionInspectionTest.kt

@@ -1,21 +1,24 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import de.platon42.intellij.jupiter.AddMavenDependencyToModule
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.AddLocalJarToModule
+import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
+import org.assertj.core.api.Assertions
 import org.junit.jupiter.api.Test
 
-@AddMavenDependencyToModule("org.assertj:assertj-guava:3.25.3")
+@AddLocalJarToModule(com.google.common.base.Optional::class, org.assertj.guava.api.Assertions::class, Assertions::class)
-@TestDataSubPath("inspections/ImplicitAssertion")
 internal class ImplicitAssertionInspectionTest : AbstractCajonTest() {
 
     @Test
-    internal fun implicit_assertions_can_be_removed() {
+    @TestDataSubPath("inspections/ImplicitAssertion")
-        fixture.enableInspections(ImplicitAssertionInspection::class.java)
+    internal fun implicit_assertions_can_be_removed(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.configureByFile("ImplicitAssertionBefore.java")
+        myFixture.enableInspections(ImplicitAssertionInspection::class.java)
-        executeQuickFixesNoFamilyNameCheck(Regex("Delete implicit isNotNull\\(\\) covered by .*"), 102)
+        myFixture.configureByFile("ImplicitAssertionBefore.java")
-        executeQuickFixesNoFamilyNameCheck(Regex("Delete implicit isNotEmpty\\(\\) covered by .*"), 17)
+        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Delete implicit isNotNull\\(\\) covered by .*"), 102)
-        executeQuickFixesNoFamilyNameCheck(Regex("Delete implicit isPresent\\(\\) covered by .*"), 8)
+        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Delete implicit isNotEmpty\\(\\) covered by .*"), 17)
-        fixture.checkResultByFile("ImplicitAssertionAfter.java")
+        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Delete implicit isPresent\\(\\) covered by .*"), 8)
+        myFixture.checkResultByFile("ImplicitAssertionAfter.java")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/JUnitAssertToAssertJInspectionTest.kt

@@ -1,20 +1,24 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import de.platon42.intellij.jupiter.AddMavenDependencyToModule
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.AddLocalJarToModule
+import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
+import org.assertj.core.api.Assertions
+import org.junit.Assert
 import org.junit.jupiter.api.Test
 
-@AddMavenDependencyToModule("junit:junit:4.13.2")
+@AddLocalJarToModule(Assert::class, Assertions::class)
-@TestDataSubPath("inspections/JUnitAssertToAssertJ")
 internal class JUnitAssertToAssertJInspectionTest : AbstractCajonTest() {
 
     @Test
-    internal fun junit_Assertions_can_be_converted_into_AssertJ() {
+    @TestDataSubPath("inspections/JUnitAssertToAssertJ")
-        fixture.enableInspections(JUnitAssertToAssertJInspection::class.java)
+    internal fun junit_Assertions_can_be_converted_into_AssertJ(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.configureByFile("JUnitAssertToAssertJInspectionBefore.java")
+        myFixture.enableInspections(JUnitAssertToAssertJInspection::class.java)
-        executeQuickFixesNoFamilyNameCheck(Regex("Convert assert.*\\(\\) to assertThat\\(\\).*"), 48)
+        myFixture.configureByFile("JUnitAssertToAssertJInspectionBefore.java")
-        executeQuickFixesNoFamilyNameCheck(Regex("Convert assume.*\\(\\) to assumeThat\\(\\).*"), 7)
+        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Convert assert.*\\(\\) to assertThat\\(\\).*"), 48)
-        fixture.checkResultByFile("JUnitAssertToAssertJInspectionAfter.java")
+        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Convert assume.*\\(\\) to assumeThat\\(\\).*"), 7)
+        myFixture.checkResultByFile("JUnitAssertToAssertJInspectionAfter.java")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/JoinAssertThatStatementsInspectionTest.kt

@@ -1,17 +1,19 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
-@TestDataSubPath("inspections/JoinStatements")
 internal class JoinAssertThatStatementsInspectionTest : AbstractCajonTest() {
 
     @Test
-    internal fun assertThat_statements_can_be_joined_together() {
+    @TestDataSubPath("inspections/JoinStatements")
-        fixture.enableInspections(JoinAssertThatStatementsInspection::class.java)
+    internal fun assertThat_statements_can_be_joined_together(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.configureByFile("JoinStatementsBefore.java")
+        myFixture.enableInspections(JoinAssertThatStatementsInspection::class.java)
-        executeQuickFixes(Regex.fromLiteral("Join assertThat() statements"), 5)
+        myFixture.configureByFile("JoinStatementsBefore.java")
-        fixture.checkResultByFile("JoinStatementsAfter.java")
+        executeQuickFixes(myFixture, Regex.fromLiteral("Join assertThat() statements"), 5)
+        myFixture.checkResultByFile("JoinStatementsAfter.java")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/JoinVarArgsContainsInspectionTest.kt

@@ -1,17 +1,19 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
-@TestDataSubPath("inspections/JoinVarArgsContains")
 internal class JoinVarArgsContainsInspectionTest : AbstractCajonTest() {
 
     @Test
-    internal fun join_contains_and_doesNotContain_together_where_possible() {
+    @TestDataSubPath("inspections/JoinVarArgsContains")
-        fixture.enableInspections(JoinVarArgsContainsInspection::class.java)
+    internal fun join_contains_and_doesNotContain_together_where_possible(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.configureByFile("JoinVarArgsContainsBefore.java")
+        myFixture.enableInspections(JoinVarArgsContainsInspection::class.java)
-        executeQuickFixes(Regex.fromLiteral("Join multiple arguments to variadic argument method calls"), 3)
+        myFixture.configureByFile("JoinVarArgsContainsBefore.java")
-        fixture.checkResultByFile("JoinVarArgsContainsAfter.java")
+        executeQuickFixes(myFixture, Regex.fromLiteral("Join multiple arguments to variadic argument method calls"), 3)
+        myFixture.checkResultByFile("JoinVarArgsContainsAfter.java")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/TwistedAssertionInspectionTest.kt

@@ -1,21 +1,23 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
-@TestDataSubPath("inspections/TwistedAssertion")
 internal class TwistedAssertionInspectionTest : AbstractCajonTest() {
 
     @Test
-    internal fun hint_twisted_actual_and_expected_and_provide_quickfix_where_possible() {
+    @TestDataSubPath("inspections/TwistedAssertion")
-        fixture.enableInspections(TwistedAssertionInspection::class.java)
+    internal fun hint_twisted_actual_and_expected_and_provide_quickfix_where_possible(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.configureByFile("TwistedAssertionBefore.java")
+        myFixture.enableInspections(TwistedAssertionInspection::class.java)
-        assertHighlightings(9, "Actual expression in assertThat() is a constant")
+        myFixture.configureByFile("TwistedAssertionBefore.java")
-        assertHighlightings(10, "Twisted actual and expected expressions")
+        assertHighlightings(myFixture, 9, "Actual expression in assertThat() is a constant")
+        assertHighlightings(myFixture, 10, "Twisted actual and expected expressions")
 
-        executeQuickFixes(Regex.fromLiteral("Swap actual and expected expressions in assertion"), 6)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Swap actual and expected expressions in assertion"), 6)
-        executeQuickFixesNoFamilyNameCheck(Regex("Replace .* by .* and swap actual and expected expressions"), 4)
+        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Replace .* by .* and swap actual and expected expressions"), 4)
-        fixture.checkResultByFile("TwistedAssertionAfter.java")
+        myFixture.checkResultByFile("TwistedAssertionAfter.java")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/references/ExtractorReferenceContributorTest.kt

@@ -1,5 +1,7 @@
 package de.platon42.intellij.plugins.cajon.references
 
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.assertj.core.api.Assertions.assertThat
@@ -11,68 +13,68 @@ import org.junit.jupiter.api.Test
 internal class ExtractorReferenceContributorTest : AbstractCajonTest() {
 
     @Test
-    internal fun extractor_is_able_to_find_reference_for_field_extracting() {
+    internal fun extractor_is_able_to_find_reference_for_field_extracting(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.configureByFiles("FindReference1.java", "Address.java", "Contact.java")
+        myFixture.configureByFiles("FindReference1.java", "Address.java", "Contact.java")
-        assertThat(fixture.elementAtCaret.text).isEqualTo("private String name;")
+        assertThat(myFixture.elementAtCaret.text).isEqualTo("private String name;")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_for_first_part_of_a_path() {
+    internal fun extractor_is_able_to_find_reference_for_first_part_of_a_path(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.configureByFiles("FindReference2.java", "Address.java", "Contact.java")
+        myFixture.configureByFiles("FindReference2.java", "Address.java", "Contact.java")
-        assertThat(fixture.elementAtCaret.text).isEqualTo("protected Address address;")
+        assertThat(myFixture.elementAtCaret.text).isEqualTo("protected Address address;")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_for_second_part_of_a_path_and_both_getter_and_field() {
+    internal fun extractor_is_able_to_find_reference_for_second_part_of_a_path_and_both_getter_and_field(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.configureByFiles("FindReference3.java", "Address.java", "Contact.java")
+        myFixture.configureByFiles("FindReference3.java", "Address.java", "Contact.java")
-        assertThat(fixture.elementAtCaret.text).startsWith("private String street;")
+        assertThat(myFixture.elementAtCaret.text).startsWith("private String street;")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_on_a_bare_method_call() {
+    internal fun extractor_is_able_to_find_reference_on_a_bare_method_call(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.configureByFiles("FindReference4.java", "Address.java", "Contact.java")
+        myFixture.configureByFiles("FindReference4.java", "Address.java", "Contact.java")
-        assertThat(fixture.elementAtCaret.text).startsWith("public Boolean getREALLYnoMAILINGS()")
+        assertThat(myFixture.elementAtCaret.text).startsWith("public Boolean getREALLYnoMAILINGS()")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_with_only_Getter_on_second_part() {
+    internal fun extractor_is_able_to_find_reference_with_only_Getter_on_second_part(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.configureByFiles("FindReference5.java", "Address.java", "Contact.java")
+        myFixture.configureByFiles("FindReference5.java", "Address.java", "Contact.java")
-        assertThat(fixture.elementAtCaret.text).startsWith("public boolean isNoMailings()")
+        assertThat(myFixture.elementAtCaret.text).startsWith("public boolean isNoMailings()")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_using_byName_extractor() {
+    internal fun extractor_is_able_to_find_reference_using_byName_extractor(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.configureByFiles("FindReference6.java", "Address.java", "Contact.java")
+        myFixture.configureByFiles("FindReference6.java", "Address.java", "Contact.java")
-        assertThat(fixture.elementAtCaret.text).isEqualTo("private String name;")
+        assertThat(myFixture.elementAtCaret.text).isEqualTo("private String name;")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_using_resultOf_extractor() {
+    internal fun extractor_is_able_to_find_reference_using_resultOf_extractor(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.configureByFiles("FindReference7.java", "Address.java", "Contact.java")
+        myFixture.configureByFiles("FindReference7.java", "Address.java", "Contact.java")
-        assertThat(fixture.elementAtCaret.text).startsWith("public String getStreetName()")
+        assertThat(myFixture.elementAtCaret.text).startsWith("public String getStreetName()")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_for_field_extraction_on_list() {
+    internal fun extractor_is_able_to_find_reference_for_field_extraction_on_list(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.configureByFiles("FindReference8.java", "Address.java", "Contact.java")
+        myFixture.configureByFiles("FindReference8.java", "Address.java", "Contact.java")
-        assertThat(fixture.elementAtCaret.text).isEqualTo("private String name;")
+        assertThat(myFixture.elementAtCaret.text).isEqualTo("private String name;")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_for_field_flat_extraction_of_path_on_list() {
+    internal fun extractor_is_able_to_find_reference_for_field_flat_extraction_of_path_on_list(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.configureByFiles("FindReference9.java", "Address.java", "Contact.java")
+        myFixture.configureByFiles("FindReference9.java", "Address.java", "Contact.java")
-        assertThat(fixture.elementAtCaret.text).startsWith("private String street;")
+        assertThat(myFixture.elementAtCaret.text).startsWith("private String street;")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_for_extraction_on_result_of_method() {
+    internal fun extractor_is_able_to_find_reference_for_extraction_on_result_of_method(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.configureByFiles("FindReference10.java", "Address.java", "Contact.java")
+        myFixture.configureByFiles("FindReference10.java", "Address.java", "Contact.java")
-        assertThat(fixture.elementAtCaret.text).startsWith("public String getStreetName()")
+        assertThat(myFixture.elementAtCaret.text).startsWith("public String getStreetName()")
     }
 
     @Test
-    internal fun extractor_is_unable_to_find_reference() {
+    internal fun extractor_is_unable_to_find_reference(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        fixture.configureByFiles("FindReference11.java", "Address.java", "Contact.java")
+        myFixture.configureByFiles("FindReference11.java", "Address.java", "Contact.java")
-        assertThatThrownBy { fixture.elementAtCaret.text }.isInstanceOf(AssertionError::class.java)
+        assertThatThrownBy { myFixture.elementAtCaret.text }.isInstanceOf(AssertionError::class.java)
     }
 }