Last update 1.14. Reworked so much without success it was just painful.

src/main/java/de/platon42/intellij/plugins/cajon/AssertJClassNames.kt

@@ -109,4 +109,4 @@ class AssertJClassNames {
         @NonNls
         const val GUAVA_OPTIONAL_ASSERTIONS_CLASSNAME = "org.assertj.guava.api.OptionalAssert"
     }
-}
+}

src/main/java/de/platon42/intellij/plugins/cajon/Extensions.kt

@@ -180,4 +180,4 @@ fun PsiExpression.getAllTheSameNullNotNullConstants(): Boolean? {
         }
     }
     return lockedResult
-}
+}

src/main/java/de/platon42/intellij/plugins/cajon/inspections/AbstractAssertJInspection.kt

@@ -307,4 +307,4 @@ abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool()
     ) {
         registerConciseMethod(REMOVE_EXPECTED_OUTMOST_DESCRIPTION_TEMPLATE, holder, expression, oldExpectedCallExpression, replacementMethod, quickFixSupplier)
     }
-}
+}

src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatJava8OptionalInspection.kt

@@ -76,4 +76,4 @@ class AssertThatJava8OptionalInspection : AbstractAssertJInspection() {
             }
         }
     }
-}
+}

src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatObjectIsNullOrNotNullInspection.kt

@@ -32,4 +32,4 @@ class AssertThatObjectIsNullOrNotNullInspection : AbstractAssertJInspection() {
             }
         }
     }
-}
+}

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://github.com/chrisly42/cajon-plugin">Chris 'platon42' Hodges</vendor>
+    <vendor email="chrisly@platon42.de" url="https://git.platon42.de/chrisly42/cajon-plugin">Chris 'platon42' Hodges</vendor>
 
     <description><![CDATA[
     Cajon is an IntelliJ IDEA Plugin for shortening and optimizing AssertJ assertions.
@@ -14,8 +14,6 @@
     <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>
@@ -81,4 +79,4 @@
 
     <actions>
     </actions>
-</idea-plugin>
+</idea-plugin>

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

@@ -0,0 +1,151 @@
+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.kt

@@ -1,10 +1,9 @@
-package de.platon42.intellij.jupiter;
+package de.platon42.intellij.jupiter
 
-import java.lang.annotation.*;
+import java.lang.annotation.Inherited
+import kotlin.reflect.KClass
 
-@Target({ElementType.TYPE, ElementType.METHOD})
-@Retention(RetentionPolicy.RUNTIME)
+@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
+@Retention(AnnotationRetention.RUNTIME)
 @Inherited
-public @interface AddLocalJarToModule {
-    Class<?>[] value();
-}
+annotation class AddLocalJarToModule(vararg val value: KClass<*>)

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

@@ -1,24 +1,17 @@
-package de.platon42.intellij.jupiter;
+package de.platon42.intellij.jupiter
 
-import com.intellij.openapi.roots.DependencyScope;
+import com.intellij.openapi.roots.DependencyScope
+import java.lang.annotation.Inherited
 
-import java.lang.annotation.*;
-
-@Target({ElementType.TYPE, ElementType.METHOD})
-@Retention(RetentionPolicy.RUNTIME)
+@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
+@Retention(AnnotationRetention.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)
+@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
-    @interface List {
-        AddMavenDependencyToModule[] value();
-    }
-}
+    annotation class List(vararg val value: AddMavenDependencyToModule)
+}

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

@@ -0,0 +1,50 @@
+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

@@ -1,259 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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.kt

@@ -1,10 +1,8 @@
-package de.platon42.intellij.jupiter;
+package de.platon42.intellij.jupiter
 
-import java.lang.annotation.*;
+import java.lang.annotation.Inherited
 
-@Target({ElementType.TYPE, ElementType.METHOD})
-@Retention(RetentionPolicy.RUNTIME)
+@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
+@Retention(AnnotationRetention.RUNTIME)
 @Inherited
-public @interface TestDataPath {
-    String value();
-}
+annotation class TestDataPath(val value: String)

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

@@ -1,10 +1,8 @@
-package de.platon42.intellij.jupiter;
+package de.platon42.intellij.jupiter
 
-import java.lang.annotation.*;
+import java.lang.annotation.Inherited
 
-@Target({ElementType.TYPE, ElementType.METHOD})
-@Retention(RetentionPolicy.RUNTIME)
+@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
+@Retention(AnnotationRetention.RUNTIME)
 @Inherited
-public @interface TestDataSubPath {
-    String value();
-}
+annotation class TestDataSubPath(val value: String)

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

@@ -1,16 +1,9 @@
-package de.platon42.intellij.jupiter;
+package de.platon42.intellij.jupiter
 
-import com.intellij.pom.java.LanguageLevel;
+import com.intellij.pom.java.LanguageLevel
+import java.lang.annotation.Inherited
 
-import java.lang.annotation.*;
-
-@Target({ElementType.TYPE, ElementType.METHOD})
-@Retention(RetentionPolicy.RUNTIME)
+@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
+@Retention(AnnotationRetention.RUNTIME)
 @Inherited
-public @interface TestJdk {
-    LanguageLevel value();
-
-    boolean annotations() default false;
-
-    boolean useInternal() default false;
-}
+annotation class TestJdk(val value: LanguageLevel)

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

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

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.fixtures.JavaCodeInsightTestFixture
-import de.platon42.intellij.jupiter.MyFixture
+import com.intellij.testFramework.RunsInEdt
 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
-    @TestDataSubPath("inspections/BinaryExpression")
-    internal fun assertThat_of_binary_expression_can_be_moved_out(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(AssertThatBinaryExpressionInspection::class.java)
-        myFixture.configureByFile("BinaryExpressionBefore.java")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Split binary expression out of assertThat()"), 161)
-        myFixture.checkResultByFile("BinaryExpressionAfter.java")
+    @RunsInEdt
+    internal fun assertThat_of_binary_expression_can_be_moved_out() {
+        fixture.enableInspections(AssertThatBinaryExpressionInspection::class.java)
+        fixture.configureByFile("BinaryExpressionBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Split binary expression out of assertThat()"), 161)
+        fixture.checkResultByFile("BinaryExpressionAfter.java")
     }
-}
+}

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

@@ -1,22 +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/BooleanCondition")
 internal class AssertThatBooleanConditionInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/BooleanCondition")
-    internal fun assertThat_with_isEqualTo_true_or_false_can_use_isTrue_or_isFalse(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(AssertThatBooleanConditionInspection::class.java)
-        myFixture.configureByFile("BooleanConditionBefore.java")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isTrue()"), 6)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isFalse()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isTrue()"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isFalse()"), 4)
-        myFixture.checkResultByFile("BooleanConditionAfter.java")
+    internal fun assertThat_with_isEqualTo_true_or_false_can_use_isTrue_or_isFalse() {
+        fixture.enableInspections(AssertThatBooleanConditionInspection::class.java)
+        fixture.configureByFile("BooleanConditionBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isTrue()"), 6)
+        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isFalse()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isNotEqualTo() with isTrue()"), 4)
+        executeQuickFixes(Regex.fromLiteral("Replace isNotEqualTo() with isFalse()"), 4)
+        fixture.checkResultByFile("BooleanConditionAfter.java")
     }
-}
+}

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

@@ -1,7 +1,5 @@
 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
@@ -11,68 +9,68 @@ import org.junit.jupiter.api.Test
 internal class AssertThatCollectionOrMapExpressionInspectionTest : AbstractCajonTest() {
 
     @Test
-    internal fun assertThat_with_certain_Collection_and_Map_methods(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(AssertThatCollectionOrMapExpressionInspection::class.java)
-        myFixture.configureByFile("CollectionMapExpressionBefore.java")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().contains() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsAll() of actual expression and use assertThat().containsAll() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().containsKey() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().containsValue() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().doesNotContain() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().doesNotContainKey() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().doesNotContainValue() instead"), 2)
-        executeQuickFixes(myFixture, 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().doesNotContainEntry() instead"), 2)
-        executeQuickFixes(myFixture, 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().doesNotContainKey() instead"), 4)
-        myFixture.checkResultByFile("CollectionMapExpressionAfter.java")
+    internal fun assertThat_with_certain_Collection_and_Map_methods() {
+        fixture.enableInspections(AssertThatCollectionOrMapExpressionInspection::class.java)
+        fixture.configureByFile("CollectionMapExpressionBefore.java")
+        executeQuickFixes(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(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(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(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(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(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(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 4)
+        fixture.checkResultByFile("CollectionMapExpressionAfter.java")
     }
 
     @Test
-    internal fun assertThat_with_certain_Collection_and_Map_methods_with_Null_values(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+    internal fun assertThat_with_certain_Collection_and_Map_methods_with_Null_values() {
         val inspection = AssertThatCollectionOrMapExpressionInspection()
         inspection.behaviorForMapValueEqualsNull = 3
-        myFixture.enableInspections(inspection)
-        myFixture.configureByFile("CollectionMapExpressionBefore.java")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().contains() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsAll() of actual expression and use assertThat().containsAll() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().containsKey() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().containsValue() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().doesNotContain() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().doesNotContainKey() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().doesNotContainValue() instead"), 2)
-        executeQuickFixes(myFixture, 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().doesNotContainEntry() instead"), 2)
-        executeQuickFixes(myFixture, 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().doesNotContainKey() instead"), 0)
-        myFixture.checkResultByFile("CollectionMapExpressionWithNullValuesAfter.java")
+        fixture.enableInspections(inspection)
+        fixture.configureByFile("CollectionMapExpressionBefore.java")
+        executeQuickFixes(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(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(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(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(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(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)
+        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
+        fixture.checkResultByFile("CollectionMapExpressionWithNullValuesAfter.java")
     }
 
     @Test
-    internal fun assertThat_with_certain_Collection_and_Map_methods_with_no_quickfixes_for_get_equals_null(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+    internal fun assertThat_with_certain_Collection_and_Map_methods_with_no_quickfixes_for_get_equals_null() {
         val inspection = AssertThatCollectionOrMapExpressionInspection()
         inspection.behaviorForMapValueEqualsNull = 0
 
-        myFixture.enableInspections(inspection)
-        myFixture.configureByFile("CollectionMapExpressionBefore.java")
-        getQuickFixes(myFixture, 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().doesNotContainEntry() instead"), 2)
-        getQuickFixes(myFixture, 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().doesNotContainKey() instead"), 0)
+        fixture.enableInspections(inspection)
+        fixture.configureByFile("CollectionMapExpressionBefore.java")
+        getQuickFixes(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(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)
     }
 
     @Test
-    internal fun assertThat_with_certain_Collection_and_Map_methods_with_only_warnings_for_get_equals_null(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+    internal fun assertThat_with_certain_Collection_and_Map_methods_with_only_warnings_for_get_equals_null() {
         val inspection = AssertThatCollectionOrMapExpressionInspection()
         inspection.behaviorForMapValueEqualsNull = 1
 
-        myFixture.enableInspections(inspection)
-        myFixture.configureByFile("CollectionMapExpressionBefore.java")
-        val highlights = myFixture.doHighlighting()
+        fixture.enableInspections(inspection)
+        fixture.configureByFile("CollectionMapExpressionBefore.java")
+        val highlights = fixture.doHighlighting()
             .asSequence()
             .filter { it.description == "Moving get() expression out of assertThat() would be more concise" }
             .filter {
@@ -81,24 +79,24 @@ internal class AssertThatCollectionOrMapExpressionInspectionTest : AbstractCajon
             .toList()
         assertThat(highlights).hasSize(4)
 
-        getQuickFixes(myFixture, 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().doesNotContainEntry() instead"), 2)
-        getQuickFixes(myFixture, 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().doesNotContainKey() instead"), 0)
+        getQuickFixes(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(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)
     }
 
     @Test
-    internal fun assertThat_with_certain_Collection_and_Map_methods_with_both_quickfixes_for_get_equals_null(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+    internal fun assertThat_with_certain_Collection_and_Map_methods_with_both_quickfixes_for_get_equals_null() {
         val inspection = AssertThatCollectionOrMapExpressionInspection()
         inspection.behaviorForMapValueEqualsNull = 4
 
-        myFixture.enableInspections(inspection)
-        myFixture.configureByFile("CollectionMapExpressionBefore.java")
-        getQuickFixes(myFixture, 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().doesNotContainKey() instead (regular map)"), 4)
-        getQuickFixes(myFixture, 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().doesNotContainEntry() instead"), 2)
-        getQuickFixes(myFixture, 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().doesNotContainKey() instead"), 0)
+        fixture.enableInspections(inspection)
+        fixture.configureByFile("CollectionMapExpressionBefore.java")
+        getQuickFixes(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(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(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)
     }
-}
+}

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

@@ -1,24 +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/Comparable")
 internal class AssertThatComparableInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/Comparable")
-    internal fun assertThat_with_compareTo_method(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(AssertThatComparableInspection::class.java)
-        myFixture.configureByFile("ComparableBefore.java")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isEqualByComparingTo() instead"), 2)
-        executeQuickFixes(myFixture, 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().isGreaterThanOrEqualTo() instead"), 4)
-        executeQuickFixes(myFixture, 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().isLessThanOrEqualTo() instead"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isLessThan() instead"), 4)
-        myFixture.checkResultByFile("ComparableAfter.java")
+    internal fun assertThat_with_compareTo_method() {
+        fixture.enableInspections(AssertThatComparableInspection::class.java)
+        fixture.configureByFile("ComparableBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isEqualByComparingTo() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isNotEqualByComparingTo() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isGreaterThanOrEqualTo() instead"), 4)
+        executeQuickFixes(Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isGreaterThan() instead"), 5)
+        executeQuickFixes(Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isLessThanOrEqualTo() instead"), 4)
+        executeQuickFixes(Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isLessThan() instead"), 4)
+        fixture.checkResultByFile("ComparableAfter.java")
     }
-}
+}

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

@@ -1,23 +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/EnumerableIsEmpty")
 internal class AssertThatEnumerableIsEmptyInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/EnumerableIsEmpty")
-    internal fun assertThat_with_hasSize_zero_and_similar_can_use_isEmpty(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(AssertThatEnumerableIsEmptyInspection::class.java)
-        myFixture.configureByFile("EnumerableIsEmptyBefore.java")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSize() with isEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSizeLessThan() with isEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSizeLessThanOrEqualTo() with isEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSizeGreaterThan() with isNotEmpty()"), 6)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSizeGreaterThanOrEqualTo() with isNotEmpty()"), 6)
-        myFixture.checkResultByFile("EnumerableIsEmptyAfter.java")
+    internal fun assertThat_with_hasSize_zero_and_similar_can_use_isEmpty() {
+        fixture.enableInspections(AssertThatEnumerableIsEmptyInspection::class.java)
+        fixture.configureByFile("EnumerableIsEmptyBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Replace hasSize() with isEmpty()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace hasSizeLessThan() with isEmpty()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace hasSizeLessThanOrEqualTo() with isEmpty()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace hasSizeGreaterThan() with isNotEmpty()"), 6)
+        executeQuickFixes(Regex.fromLiteral("Replace hasSizeGreaterThanOrEqualTo() with isNotEmpty()"), 6)
+        fixture.checkResultByFile("EnumerableIsEmptyAfter.java")
     }
-}
+}

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

@@ -1,38 +1,36 @@
 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
-    @TestDataSubPath("inspections/FileExpression")
-    internal fun assertThat_with_certain_File_methods(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(AssertThatFileExpressionInspection::class.java)
-        myFixture.configureByFile("FileExpressionBefore.java")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove canRead() of actual expression and use assertThat().canRead() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove canWrite() of actual expression and use assertThat().canWrite() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove exists() of actual expression and use assertThat().exists() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove exists() of actual expression and use assertThat().doesNotExist() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isAbsolute() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isRelative() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isDirectory() of actual expression and use assertThat().isDirectory() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isFile() of actual expression and use assertThat().isFile() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove getName() of actual expression and use assertThat().hasName() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasNoParent() instead"), 2)
-        executeQuickFixes(myFixture, 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().hasParent() instead"), 1)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove getParentFile() of actual expression and use assertThat().hasParent() instead"), 1)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove listFiles() 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(myFixture, Regex.fromLiteral("Remove list() of actual expression and use assertThat().isEmptyDirectory() instead"), 1)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove list() of actual expression and use assertThat().isNotEmptyDirectory() instead"), 1)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove length() of actual expression and use assertThat().isEmpty() instead"), 2)
-        executeQuickFixes(myFixture, 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().hasSize() instead"), 1)
-        myFixture.checkResultByFile("FileExpressionAfter.java")
+    internal fun assertThat_with_certain_File_methods() {
+        fixture.enableInspections(AssertThatFileExpressionInspection::class.java)
+        fixture.configureByFile("FileExpressionBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Remove canRead() of actual expression and use assertThat().canRead() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove canWrite() of actual expression and use assertThat().canWrite() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove exists() of actual expression and use assertThat().exists() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove exists() of actual expression and use assertThat().doesNotExist() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isAbsolute() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isRelative() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove isDirectory() of actual expression and use assertThat().isDirectory() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove isFile() of actual expression and use assertThat().isFile() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove getName() of actual expression and use assertThat().hasName() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasNoParent() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove getParentFile() of actual expression and use assertThat().hasNoParent() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasParent() instead"), 1)
+        executeQuickFixes(Regex.fromLiteral("Remove getParentFile() of actual expression and use assertThat().hasParent() instead"), 1)
+        executeQuickFixes(Regex.fromLiteral("Remove listFiles() of actual expression and use assertThat().isEmptyDirectory() instead"), 1)
+        executeQuickFixes(Regex.fromLiteral("Remove listFiles() of actual expression and use assertThat().isNotEmptyDirectory() instead"), 1)
+        executeQuickFixes(Regex.fromLiteral("Remove list() of actual expression and use assertThat().isEmptyDirectory() instead"), 1)
+        executeQuickFixes(Regex.fromLiteral("Remove list() of actual expression and use assertThat().isNotEmptyDirectory() instead"), 1)
+        executeQuickFixes(Regex.fromLiteral("Remove length() of actual expression and use assertThat().isEmpty() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove length() of actual expression and use assertThat().isNotEmpty() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove length() of actual expression and use assertThat().hasSize() instead"), 1)
+        fixture.checkResultByFile("FileExpressionAfter.java")
     }
-}
+}

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

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

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

@@ -1,20 +1,18 @@
 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
-    @TestDataSubPath("inspections/InstanceOf")
-    internal fun assertThat_with_instanceof_can_be_moved_out(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(AssertThatInstanceOfInspection::class.java)
-        myFixture.configureByFile("InstanceOfBefore.java")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove instanceof in actual expression and use assertThat().isInstanceOf() instead"), 6)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove instanceof in actual expression and use assertThat().isNotInstanceOf() instead"), 6)
-        myFixture.checkResultByFile("InstanceOfAfter.java")
+    internal fun assertThat_with_instanceof_can_be_moved_out() {
+        fixture.enableInspections(AssertThatInstanceOfInspection::class.java)
+        fixture.configureByFile("InstanceOfBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Remove instanceof in actual expression and use assertThat().isInstanceOf() instead"), 6)
+        executeQuickFixes(Regex.fromLiteral("Remove instanceof in actual expression and use assertThat().isNotInstanceOf() instead"), 6)
+        fixture.checkResultByFile("InstanceOfAfter.java")
     }
-}
+}

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

@@ -1,21 +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/InvertedBooleanCondition")
 internal class AssertThatInvertedBooleanConditionInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/InvertedBooleanCondition")
-    internal fun assertThat_with_inverted_boolean_condition_can_be_inverted(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(AssertThatInvertedBooleanConditionInspection::class.java)
-        myFixture.configureByFile("InvertedBooleanConditionBefore.java")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Invert condition in assertThat()"), 25)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Invert condition in isEqualTo() and use isNotEqualTo() instead"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Invert condition in isNotEqualTo() and use isEqualTo() instead"), 2)
-        myFixture.checkResultByFile("InvertedBooleanConditionAfter.java")
+    internal fun assertThat_with_inverted_boolean_condition_can_be_inverted() {
+        fixture.enableInspections(AssertThatInvertedBooleanConditionInspection::class.java)
+        fixture.configureByFile("InvertedBooleanConditionBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Invert condition in assertThat()"), 25)
+        executeQuickFixes(Regex.fromLiteral("Invert condition in isEqualTo() and use isNotEqualTo() instead"), 4)
+        executeQuickFixes(Regex.fromLiteral("Invert condition in isNotEqualTo() and use isEqualTo() instead"), 2)
+        fixture.checkResultByFile("InvertedBooleanConditionAfter.java")
     }
-}
+}

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

@@ -1,21 +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/IsZeroOne")
 internal class AssertThatIsZeroOneInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/IsZeroOne")
-    internal fun assertThat_with_isEqualTo_zero_or_one_can_use_isZero_or_isOne_plus_isNotZero(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(AssertThatIsZeroOneInspection::class.java)
-        myFixture.configureByFile("IsZeroOneBefore.java")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isZero()"), 10)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isOne()"), 10)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isNotZero()"), 10)
-        myFixture.checkResultByFile("IsZeroOneAfter.java")
+    internal fun assertThat_with_isEqualTo_zero_or_one_can_use_isZero_or_isOne_plus_isNotZero() {
+        fixture.enableInspections(AssertThatIsZeroOneInspection::class.java)
+        fixture.configureByFile("IsZeroOneBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isZero()"), 10)
+        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isOne()"), 10)
+        executeQuickFixes(Regex.fromLiteral("Replace isNotEqualTo() with isNotZero()"), 10)
+        fixture.checkResultByFile("IsZeroOneAfter.java")
     }
-}
+}

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

@@ -1,27 +1,25 @@
 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
-    @TestDataSubPath("inspections/Java8Optional")
-    internal fun assertThat_get_or_isPresent_for_Java8_Optional_can_be_simplified(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(AssertThatJava8OptionalInspection::class.java)
-        myFixture.configureByFile("Java8OptionalBefore.java")
-        executeQuickFixes(myFixture, 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().isNotPresent() instead"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove orElse() of actual expression and use assertThat().isPresent() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove orElse() of actual expression and use assertThat().isNotPresent() instead"), 2)
-        executeQuickFixes(myFixture, 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().containsSame() instead"), 1)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isNotPresent()"), 1)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isPresent()"), 1)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap expected expression and replace isEqualTo() with contains()"), 2)
-        myFixture.checkResultByFile("Java8OptionalAfter.java")
+    internal fun assertThat_get_or_isPresent_for_Java8_Optional_can_be_simplified() {
+        fixture.enableInspections(AssertThatJava8OptionalInspection::class.java)
+        fixture.configureByFile("Java8OptionalBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isPresent() instead"), 6)
+        executeQuickFixes(Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isNotPresent() instead"), 5)
+        executeQuickFixes(Regex.fromLiteral("Remove orElse() of actual expression and use assertThat().isPresent() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove orElse() of actual expression and use assertThat().isNotPresent() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().contains() instead"), 1)
+        executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsSame() instead"), 1)
+        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isNotPresent()"), 1)
+        executeQuickFixes(Regex.fromLiteral("Replace isNotEqualTo() with isPresent()"), 1)
+        executeQuickFixes(Regex.fromLiteral("Unwrap expected expression and replace isEqualTo() with contains()"), 2)
+        fixture.checkResultByFile("Java8OptionalAfter.java")
     }
-}
+}

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

@@ -1,22 +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/ObjectExpression")
 internal class AssertThatObjectExpressionInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/ObjectExpression")
-    internal fun assertThat_with_certain_Object_methods(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(AssertThatObjectExpressionInspection::class.java)
-        myFixture.configureByFile("ObjectExpressionBefore.java")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isEqualTo() instead"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isNotEqualTo() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace calls to hashCode() with hasSameHashCodeAs()"), 1)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove toString() of actual expression and use assertThat().hasToString() instead"), 1)
-        myFixture.checkResultByFile("ObjectExpressionAfter.java")
+    internal fun assertThat_with_certain_Object_methods() {
+        fixture.enableInspections(AssertThatObjectExpressionInspection::class.java)
+        fixture.configureByFile("ObjectExpressionBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isEqualTo() instead"), 4)
+        executeQuickFixes(Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isNotEqualTo() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Replace calls to hashCode() with hasSameHashCodeAs()"), 1)
+        executeQuickFixes(Regex.fromLiteral("Remove toString() of actual expression and use assertThat().hasToString() instead"), 1)
+        fixture.checkResultByFile("ObjectExpressionAfter.java")
     }
-}
+}

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

@@ -1,20 +1,18 @@
 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
-    @TestDataSubPath("inspections/ObjectIsNullOrNotNull")
-    internal fun assertThat_with_isEqualTo_null_can_use_isNull(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(AssertThatObjectIsNullOrNotNullInspection::class.java)
-        myFixture.configureByFile("ObjectIsNullOrNotNullBefore.java")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isNull()"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isNotNull()"), 5)
-        myFixture.checkResultByFile("ObjectIsNullOrNotNullAfter.java")
+    internal fun assertThat_with_isEqualTo_null_can_use_isNull() {
+        fixture.enableInspections(AssertThatObjectIsNullOrNotNullInspection::class.java)
+        fixture.configureByFile("ObjectIsNullOrNotNullBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isNull()"), 4)
+        executeQuickFixes(Regex.fromLiteral("Replace isNotEqualTo() with isNotNull()"), 5)
+        fixture.checkResultByFile("ObjectIsNullOrNotNullAfter.java")
     }
-}
+}

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

@@ -1,24 +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/PathExpression")
 internal class AssertThatPathExpressionInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/PathExpression")
-    internal fun assertThat_with_certain_Path_methods(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(AssertThatPathExpressionInspection::class.java)
-        myFixture.configureByFile("PathExpressionBefore.java")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isAbsolute() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isRelative() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove startsWith() of actual expression and use assertThat().startsWithRaw() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove endsWith() of actual expression and use assertThat().endsWithRaw() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasNoParentRaw() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasParentRaw() instead"), 1)
-        myFixture.checkResultByFile("PathExpressionAfter.java")
+    internal fun assertThat_with_certain_Path_methods() {
+        fixture.enableInspections(AssertThatPathExpressionInspection::class.java)
+        fixture.configureByFile("PathExpressionBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isAbsolute() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isRelative() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove startsWith() of actual expression and use assertThat().startsWithRaw() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove endsWith() of actual expression and use assertThat().endsWithRaw() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasNoParentRaw() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasParentRaw() instead"), 1)
+        fixture.checkResultByFile("PathExpressionAfter.java")
     }
-}
+}

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

@@ -1,34 +1,32 @@
 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
-    @TestDataSubPath("inspections/Size")
-    internal fun assertThat_size_of_array_collection_or_map_can_be_simplified(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(AssertThatSizeInspection::class.java)
-        myFixture.configureByFile("SizeBefore.java")
-        assertHighlightings(myFixture, 1, "Try to operate on the iterable itself rather than its size")
+    internal fun assertThat_size_of_array_collection_or_map_can_be_simplified() {
+        fixture.enableInspections(AssertThatSizeInspection::class.java)
+        fixture.configureByFile("SizeBefore.java")
+        assertHighlightings(1, "Try to operate on the iterable itself rather than its size")
 
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isZero() with isEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotZero() with isNotEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThan() with isNotEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with isNotEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThan() with isEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThanOrEqualTo() with isEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with hasSameSizeAs()"), 15)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with hasSize()"), 15)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThan() with hasSizeGreaterThan()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with hasSizeGreaterThanOrEqualTo()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThan() with hasSizeLessThan()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThanOrEqualTo() with hasSizeLessThanOrEqualTo()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove size determination of expected expression and replace hasSize() with hasSameSizeAs()"), 17)
-        myFixture.checkResultByFile("SizeAfter.java")
+        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isZero() with isEmpty()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isNotZero() with isNotEmpty()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isGreaterThan() with isNotEmpty()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with isNotEmpty()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isLessThan() with isEmpty()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isLessThanOrEqualTo() with isEmpty()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with hasSameSizeAs()"), 15)
+        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with hasSize()"), 15)
+        executeQuickFixes(Regex.fromLiteral("Replace isGreaterThan() with hasSizeGreaterThan()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with hasSizeGreaterThanOrEqualTo()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isLessThan() with hasSizeLessThan()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isLessThanOrEqualTo() with hasSizeLessThanOrEqualTo()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Remove size determination of expected expression and replace hasSize() with hasSameSizeAs()"), 17)
+        fixture.checkResultByFile("SizeAfter.java")
     }
-}
+}

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

@@ -1,41 +1,39 @@
 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
-    @TestDataSubPath("inspections/StringExpression")
-    internal fun assertThat_with_certain_String_methods(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(AssertThatStringExpressionInspection::class.java)
-        myFixture.configureByFile("StringExpressionBefore.java")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isEqualTo() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove equalsIgnoreCase() of actual expression and use assertThat().isEqualToIgnoringCase() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contentEquals() of actual expression and use assertThat().isEqualTo() instead"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().contains() instead"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove startsWith() of actual expression and use assertThat().startsWith() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove endsWith() of actual expression and use assertThat().endsWith() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove matches() of actual expression and use assertThat().matches() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove matches() of actual expression and use assertThat().doesNotMatch() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isNotEqualTo() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove equalsIgnoreCase() of actual expression and use assertThat().isNotEqualToIgnoringCase() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contentEquals() of actual expression and use assertThat().isNotEqualTo() instead"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().doesNotContain() instead"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove startsWith() of actual expression and use assertThat().doesNotStartWith() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove endsWith() of actual expression and use assertThat().doesNotEndWith() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove compareToIgnoreCase() of actual expression and use assertThat().isEqualToIgnoringCase() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove compareToIgnoreCase() of actual expression and use assertThat().isNotEqualToIgnoringCase() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove indexOf() of actual expression and use assertThat().startsWith() instead"), 2)
-        executeQuickFixes(myFixture, 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().contains() instead"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove indexOf() of actual expression and use assertThat().doesNotContain() instead"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove trim() of actual expression and use assertThat().isNotBlank() instead"), 1)
-        myFixture.checkResultByFile("StringExpressionAfter.java")
+    internal fun assertThat_with_certain_String_methods() {
+        fixture.enableInspections(AssertThatStringExpressionInspection::class.java)
+        fixture.configureByFile("StringExpressionBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isEqualTo() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove equalsIgnoreCase() of actual expression and use assertThat().isEqualToIgnoringCase() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove contentEquals() of actual expression and use assertThat().isEqualTo() instead"), 4)
+        executeQuickFixes(Regex.fromLiteral("Remove contains() of actual expression and use assertThat().contains() instead"), 4)
+        executeQuickFixes(Regex.fromLiteral("Remove startsWith() of actual expression and use assertThat().startsWith() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove endsWith() of actual expression and use assertThat().endsWith() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove matches() of actual expression and use assertThat().matches() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove matches() of actual expression and use assertThat().doesNotMatch() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isNotEqualTo() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove equalsIgnoreCase() of actual expression and use assertThat().isNotEqualToIgnoringCase() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove contentEquals() of actual expression and use assertThat().isNotEqualTo() instead"), 4)
+        executeQuickFixes(Regex.fromLiteral("Remove contains() of actual expression and use assertThat().doesNotContain() instead"), 4)
+        executeQuickFixes(Regex.fromLiteral("Remove startsWith() of actual expression and use assertThat().doesNotStartWith() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove endsWith() of actual expression and use assertThat().doesNotEndWith() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove compareToIgnoreCase() of actual expression and use assertThat().isEqualToIgnoringCase() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove compareToIgnoreCase() of actual expression and use assertThat().isNotEqualToIgnoringCase() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove indexOf() of actual expression and use assertThat().startsWith() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove indexOf() of actual expression and use assertThat().doesNotStartWith() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove indexOf() of actual expression and use assertThat().contains() instead"), 4)
+        executeQuickFixes(Regex.fromLiteral("Remove indexOf() of actual expression and use assertThat().doesNotContain() instead"), 4)
+        executeQuickFixes(Regex.fromLiteral("Remove trim() of actual expression and use assertThat().isNotBlank() instead"), 1)
+        fixture.checkResultByFile("StringExpressionAfter.java")
     }
-}
+}

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

@@ -1,27 +1,25 @@
 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
-    @TestDataSubPath("inspections/StringIsEmpty")
-    internal fun assertThat_with_isEqualTo_emptyString_can_use_isEmpty(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(AssertThatStringIsEmptyInspection::class.java)
-        myFixture.configureByFile("StringIsEmptyBefore.java")
-        val highlights = myFixture.doHighlighting()
+    internal fun assertThat_with_isEqualTo_emptyString_can_use_isEmpty() {
+        fixture.enableInspections(AssertThatStringIsEmptyInspection::class.java)
+        fixture.configureByFile("StringIsEmptyBefore.java")
+        val highlights = fixture.doHighlighting()
             .asSequence()
             .filter { it.description?.contains(" can be simplified to") ?: false }
             .toList()
         assertThat(highlights).hasSize(6).extrakting { it.text }.doesNotContain("assertThat")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSize() with isEmpty()"), 3)
-        myFixture.checkResultByFile("StringIsEmptyAfter.java")
+        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 3)
+        executeQuickFixes(Regex.fromLiteral("Replace hasSize() with isEmpty()"), 3)
+        fixture.checkResultByFile("StringIsEmptyAfter.java")
     }
-}
+}

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

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

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

@@ -1,19 +1,17 @@
 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
-    @TestDataSubPath("inspections/BogusAssertion")
-    internal fun reports_bogus_assertions(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(BogusAssertionInspection::class.java)
-        myFixture.configureByFile("BogusAssertionBefore.java")
-        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()")
+    internal fun reports_bogus_assertions() {
+        fixture.enableInspections(BogusAssertionInspection::class.java)
+        fixture.configureByFile("BogusAssertionBefore.java")
+        assertHighlightings(14 * 9 + 10 + 12 + 8, "Actual expression in assertThat() is the same as expected")
+        assertHighlightings(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,24 +1,21 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
-import de.platon42.intellij.jupiter.AddLocalJarToModule
-import de.platon42.intellij.jupiter.MyFixture
+import de.platon42.intellij.jupiter.AddMavenDependencyToModule
 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
 
-@AddLocalJarToModule(com.google.common.base.Optional::class, org.assertj.guava.api.Assertions::class, Assertions::class)
+@AddMavenDependencyToModule("org.assertj:assertj-guava:3.25.3")
+@TestDataSubPath("inspections/ImplicitAssertion")
 internal class ImplicitAssertionInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/ImplicitAssertion")
-    internal fun implicit_assertions_can_be_removed(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(ImplicitAssertionInspection::class.java)
-        myFixture.configureByFile("ImplicitAssertionBefore.java")
-        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Delete implicit isNotNull\\(\\) covered by .*"), 102)
-        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Delete implicit isNotEmpty\\(\\) covered by .*"), 17)
-        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Delete implicit isPresent\\(\\) covered by .*"), 8)
-        myFixture.checkResultByFile("ImplicitAssertionAfter.java")
+    internal fun implicit_assertions_can_be_removed() {
+        fixture.enableInspections(ImplicitAssertionInspection::class.java)
+        fixture.configureByFile("ImplicitAssertionBefore.java")
+        executeQuickFixesNoFamilyNameCheck(Regex("Delete implicit isNotNull\\(\\) covered by .*"), 102)
+        executeQuickFixesNoFamilyNameCheck(Regex("Delete implicit isNotEmpty\\(\\) covered by .*"), 17)
+        executeQuickFixesNoFamilyNameCheck(Regex("Delete implicit isPresent\\(\\) covered by .*"), 8)
+        fixture.checkResultByFile("ImplicitAssertionAfter.java")
     }
-}
+}

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

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

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

@@ -1,19 +1,17 @@
 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
-    @TestDataSubPath("inspections/JoinStatements")
-    internal fun assertThat_statements_can_be_joined_together(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(JoinAssertThatStatementsInspection::class.java)
-        myFixture.configureByFile("JoinStatementsBefore.java")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Join assertThat() statements"), 5)
-        myFixture.checkResultByFile("JoinStatementsAfter.java")
+    internal fun assertThat_statements_can_be_joined_together() {
+        fixture.enableInspections(JoinAssertThatStatementsInspection::class.java)
+        fixture.configureByFile("JoinStatementsBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Join assertThat() statements"), 5)
+        fixture.checkResultByFile("JoinStatementsAfter.java")
     }
-}
+}

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

@@ -1,19 +1,17 @@
 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
-    @TestDataSubPath("inspections/JoinVarArgsContains")
-    internal fun join_contains_and_doesNotContain_together_where_possible(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(JoinVarArgsContainsInspection::class.java)
-        myFixture.configureByFile("JoinVarArgsContainsBefore.java")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Join multiple arguments to variadic argument method calls"), 3)
-        myFixture.checkResultByFile("JoinVarArgsContainsAfter.java")
+    internal fun join_contains_and_doesNotContain_together_where_possible() {
+        fixture.enableInspections(JoinVarArgsContainsInspection::class.java)
+        fixture.configureByFile("JoinVarArgsContainsBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Join multiple arguments to variadic argument method calls"), 3)
+        fixture.checkResultByFile("JoinVarArgsContainsAfter.java")
     }
-}
+}

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

@@ -1,23 +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/TwistedAssertion")
 internal class TwistedAssertionInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/TwistedAssertion")
-    internal fun hint_twisted_actual_and_expected_and_provide_quickfix_where_possible(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(TwistedAssertionInspection::class.java)
-        myFixture.configureByFile("TwistedAssertionBefore.java")
-        assertHighlightings(myFixture, 9, "Actual expression in assertThat() is a constant")
-        assertHighlightings(myFixture, 10, "Twisted actual and expected expressions")
+    internal fun hint_twisted_actual_and_expected_and_provide_quickfix_where_possible() {
+        fixture.enableInspections(TwistedAssertionInspection::class.java)
+        fixture.configureByFile("TwistedAssertionBefore.java")
+        assertHighlightings(9, "Actual expression in assertThat() is a constant")
+        assertHighlightings(10, "Twisted actual and expected expressions")
 
-        executeQuickFixes(myFixture, Regex.fromLiteral("Swap actual and expected expressions in assertion"), 6)
-        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Replace .* by .* and swap actual and expected expressions"), 4)
-        myFixture.checkResultByFile("TwistedAssertionAfter.java")
+        executeQuickFixes(Regex.fromLiteral("Swap actual and expected expressions in assertion"), 6)
+        executeQuickFixesNoFamilyNameCheck(Regex("Replace .* by .* and swap actual and expected expressions"), 4)
+        fixture.checkResultByFile("TwistedAssertionAfter.java")
     }
-}
+}

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

@@ -1,7 +1,5 @@
 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
@@ -13,68 +11,68 @@ import org.junit.jupiter.api.Test
 internal class ExtractorReferenceContributorTest : AbstractCajonTest() {
 
     @Test
-    internal fun extractor_is_able_to_find_reference_for_field_extracting(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.configureByFiles("FindReference1.java", "Address.java", "Contact.java")
-        assertThat(myFixture.elementAtCaret.text).isEqualTo("private String name;")
+    internal fun extractor_is_able_to_find_reference_for_field_extracting() {
+        fixture.configureByFiles("FindReference1.java", "Address.java", "Contact.java")
+        assertThat(fixture.elementAtCaret.text).isEqualTo("private String name;")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_for_first_part_of_a_path(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.configureByFiles("FindReference2.java", "Address.java", "Contact.java")
-        assertThat(myFixture.elementAtCaret.text).isEqualTo("protected Address address;")
+    internal fun extractor_is_able_to_find_reference_for_first_part_of_a_path() {
+        fixture.configureByFiles("FindReference2.java", "Address.java", "Contact.java")
+        assertThat(fixture.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(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.configureByFiles("FindReference3.java", "Address.java", "Contact.java")
-        assertThat(myFixture.elementAtCaret.text).startsWith("private String street;")
+    internal fun extractor_is_able_to_find_reference_for_second_part_of_a_path_and_both_getter_and_field() {
+        fixture.configureByFiles("FindReference3.java", "Address.java", "Contact.java")
+        assertThat(fixture.elementAtCaret.text).startsWith("private String street;")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_on_a_bare_method_call(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.configureByFiles("FindReference4.java", "Address.java", "Contact.java")
-        assertThat(myFixture.elementAtCaret.text).startsWith("public Boolean getREALLYnoMAILINGS()")
+    internal fun extractor_is_able_to_find_reference_on_a_bare_method_call() {
+        fixture.configureByFiles("FindReference4.java", "Address.java", "Contact.java")
+        assertThat(fixture.elementAtCaret.text).startsWith("public Boolean getREALLYnoMAILINGS()")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_with_only_Getter_on_second_part(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.configureByFiles("FindReference5.java", "Address.java", "Contact.java")
-        assertThat(myFixture.elementAtCaret.text).startsWith("public boolean isNoMailings()")
+    internal fun extractor_is_able_to_find_reference_with_only_Getter_on_second_part() {
+        fixture.configureByFiles("FindReference5.java", "Address.java", "Contact.java")
+        assertThat(fixture.elementAtCaret.text).startsWith("public boolean isNoMailings()")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_using_byName_extractor(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.configureByFiles("FindReference6.java", "Address.java", "Contact.java")
-        assertThat(myFixture.elementAtCaret.text).isEqualTo("private String name;")
+    internal fun extractor_is_able_to_find_reference_using_byName_extractor() {
+        fixture.configureByFiles("FindReference6.java", "Address.java", "Contact.java")
+        assertThat(fixture.elementAtCaret.text).isEqualTo("private String name;")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_using_resultOf_extractor(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.configureByFiles("FindReference7.java", "Address.java", "Contact.java")
-        assertThat(myFixture.elementAtCaret.text).startsWith("public String getStreetName()")
+    internal fun extractor_is_able_to_find_reference_using_resultOf_extractor() {
+        fixture.configureByFiles("FindReference7.java", "Address.java", "Contact.java")
+        assertThat(fixture.elementAtCaret.text).startsWith("public String getStreetName()")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_for_field_extraction_on_list(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.configureByFiles("FindReference8.java", "Address.java", "Contact.java")
-        assertThat(myFixture.elementAtCaret.text).isEqualTo("private String name;")
+    internal fun extractor_is_able_to_find_reference_for_field_extraction_on_list() {
+        fixture.configureByFiles("FindReference8.java", "Address.java", "Contact.java")
+        assertThat(fixture.elementAtCaret.text).isEqualTo("private String name;")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_for_field_flat_extraction_of_path_on_list(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.configureByFiles("FindReference9.java", "Address.java", "Contact.java")
-        assertThat(myFixture.elementAtCaret.text).startsWith("private String street;")
+    internal fun extractor_is_able_to_find_reference_for_field_flat_extraction_of_path_on_list() {
+        fixture.configureByFiles("FindReference9.java", "Address.java", "Contact.java")
+        assertThat(fixture.elementAtCaret.text).startsWith("private String street;")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_for_extraction_on_result_of_method(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.configureByFiles("FindReference10.java", "Address.java", "Contact.java")
-        assertThat(myFixture.elementAtCaret.text).startsWith("public String getStreetName()")
+    internal fun extractor_is_able_to_find_reference_for_extraction_on_result_of_method() {
+        fixture.configureByFiles("FindReference10.java", "Address.java", "Contact.java")
+        assertThat(fixture.elementAtCaret.text).startsWith("public String getStreetName()")
     }
 
     @Test
-    internal fun extractor_is_unable_to_find_reference(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.configureByFiles("FindReference11.java", "Address.java", "Contact.java")
-        assertThatThrownBy { myFixture.elementAtCaret.text }.isInstanceOf(AssertionError::class.java)
+    internal fun extractor_is_unable_to_find_reference() {
+        fixture.configureByFiles("FindReference11.java", "Address.java", "Contact.java")
+        assertThatThrownBy { fixture.elementAtCaret.text }.isInstanceOf(AssertionError::class.java)
     }
-}
+}