diff --git a/LICENSE.TXT b/LICENSE.TXT
index 3384159..1ea08c9 100644
--- a/LICENSE.TXT
+++ b/LICENSE.TXT
@@ -1,4 +1,4 @@
-Copyright 2019-2022 Chris Hodges <chrisly@platon42.de>
+Copyright 2019-2024 Chris Hodges <chrisly@platon42.de>
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -10,4 +10,4 @@ Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
-limitations under the License.
\ No newline at end of file
+limitations under the License.
diff --git a/README.md b/README.md
index 65d1583..8732422 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,5 @@
-# Cajon - Concise AssertJ Optimizing Nitpicker [![Build Status](https://app.travis-ci.com/chrisly42/cajon-plugin.svg?branch=master)](https://app.travis-ci.com/chrisly42/cajon-plugin) [![Coverage Status](https://coveralls.io/repos/github/chrisly42/cajon-plugin/badge.svg?branch=master)](https://coveralls.io/github/chrisly42/cajon-plugin?branch=master)
+# Cajon - Concise AssertJ Optimizing Nitpicker
+
 Cajon is an IntelliJ IDEA Plugin for shortening and optimizing [AssertJ](https://assertj.github.io/doc/) assertions.
 
 ## Purpose
@@ -39,14 +40,15 @@ Cajon also warns about bogus or incorrect uses of AssertJ.
 
 ## Lookup and refactoring of string-based extracting()
 
-AssertJ allows [extracting POJO fields/properties on iterables/arrays](http://joel-costigliola.github.io/assertj/assertj-core-features-highlight.html#extracted-properties-assertion).
+AssertJ
+allows [extracting POJO fields/properties on iterables/arrays](http://joel-costigliola.github.io/assertj/assertj-core-features-highlight.html#extracted-properties-assertion).
 
 Using strings is not safe for refactoring (and before Java 8 Lambdas were available,
 creating extractor functions just for testing purpose was a bit too tedious).
 
-This plugin adds support for referencing these fields (so you can ctrl(/cmd)-click on the 
-string to go to the definition) and allows safe refactoring on the 
-fields (refactoring a getter method without a corresponding field will not work 
+This plugin adds support for referencing these fields (so you can ctrl(/cmd)-click on the
+string to go to the definition) and allows safe refactoring on the
+fields (refactoring a getter method without a corresponding field will not work
 correctly right now) too.
 
 ## Usage
@@ -61,10 +63,11 @@ The plugin will report inspections in your opened editor file as warnings.
 You can then quick-fix these with your quick-fix hotkey (usually Alt-Return or Opt-Return).
 
 Or, you can use the "Run Inspection by Name..." action to run one inspection on a bigger scope (e.g. the whole project).
-Applying a quick fix might result in further optimization possibilities, so 
+Applying a quick fix might result in further optimization possibilities, so
 you might need to perform a couple of fixes before you get to the final result.
 
 Check out this example where every line represents the result after a Cajon quickfix:
+
 ```
 assertFalse(!(array.length == collection.size()));
 
@@ -82,7 +85,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 ## Implemented inspections and quickfixes
 
 - JoinAssertThatStatements
-  
+
   Joins multiple ```assertThat()``` statements with same actual expression together.
 
   ```
@@ -97,16 +100,16 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 
   The comments of the statements will be preserved. When using ```extracting()``` or similar,
   the statements will not be merged.
-  
+
   The behavior regarding the insertion of line breaks between the expressions can be configured in the
   inspection settings.
 
 - JoinVarArgsContains
 
-  Looks for ```.contains()```, ```.doesNotContain()```, and .```containsOnlyOnce()``` calls for iterables 
+  Looks for ```.contains()```, ```.doesNotContain()```, and .```containsOnlyOnce()``` calls for iterables
   within the same statement. The available quickfix can join the arguments to variadic version of the call
   and remove the surplus one.
-  
+
   ```
   from: assertThat(expected).contains("foo").doesNotContain("bar").contains("etc").doesNotContain("huh");
     to: assertThat(expected).contains("foo", "etc").doesNotContain("bar", "huh");
@@ -115,7 +118,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
   changing semantics or losing descriptions.
 
   Note that the quickfix does not handle comments very well and might remove them during the operation.
-  
+
   You may need to perform some manual reformatting, if the line gets too long after applying the fix.
 
 - AssertThatObjectIsNullOrNotNull
@@ -143,7 +146,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 
   Inverts the boolean condition in either ```assertThat()``` or ```isEqualTo()```/```isNotEqualTo()```
   to make it more readable.
-  
+
   ```
   from: assertThat(!booleanValue).isEqualTo(true/false/Boolean.TRUE/Boolean.FALSE);  
   from: assertThat(!booleanValue).isTrue()/isFalse();  
@@ -200,9 +203,9 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
   The ```assertThat(string.length()).isEqualTo(0);``` case is handled in the AssertThatSize inspection.
 
 - AssertThatStringExpression
-  
+
   Moves string operations inside ```assertThat()``` out.
-  
+
   ```
   from: assertThat(stringActual.isEmpty()).isTrue();
     to: assertThat(stringActual).isEmpty();
@@ -227,7 +230,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
     to: assertThat(stringActual).matches(stringExpected);
   ```
   Analogously with ```isFalse()```.
-  
+
   More funny stuff (excerpt):
 
   ```
@@ -255,7 +258,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 - AssertThatObjectExpression
 
   Handles ```equals()```, ```toString()``` and ```hashCode()``` inside an expected expression.
-  
+
   ```
   from: assertThat(objActual.equals(objExpected)).isTrue();
     to: assertThat(objActual).isEqualTo(objExpected);
@@ -270,7 +273,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 - AssertThatComparableExpression
 
   Handles ```compareTo()``` inside an expected expression.
-  
+
   ```
   from: assertThat(obj1.compareTo(obj2)).isEqualTo(0);
     to: assertThat(obj1).isEqualByComparingTo(obj2);
@@ -336,7 +339,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
   from: assertThat(map.get(key)).isNull();
     to: assertThat(map).doesNotContainKey(key);
   ```
-  
+
   The last transformation is the default, but may not be 100% equivalent depending upon the map
   being a degenerated case with ```null``` values, where ```map.get(key)``` returns ```null```,
   but ```containsKey(key)``` is ```true```.
@@ -440,10 +443,10 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 
   Uses ```isEmpty()``` for ```hasSize(0)```, ```hasSizeLessThanOrEqualTo(0)```, and
   ```hasSizeLessThan(1)``` iterable (enumerable) assertions instead.
-  
-  Also suggests ```isNotEmpty()``` for ```hasSizeGreaterThan(0)``` and 
+
+  Also suggests ```isNotEmpty()``` for ```hasSizeGreaterThan(0)``` and
   ```hasSizeGreaterThanOrEqualTo(1)```.
-  
+
   ```
   from: assertThat(enumerable).hasSize(0);
   from: assertThat(enumerable).hasSizeLessThanOrEqualTo(0);
@@ -531,7 +534,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 
   Examines the actual expression for common mistakes such as mixing expected and actual expression.
   For simple cases, a quick fix is offered to swap them. Otherwise, only a warning is issued.
-  
+
   ```
   from: assertThat(5).isEqualTo(variable);
     to: assertThat(variable).isEqualTo(5);
@@ -541,13 +544,13 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
   ```
 
   There are, of course, more variations of the theme.
-  
+
   If both sides of an assertion are constant expressions, the problem will only appear as
   a weak warning without a quick fix.
-  
+
   Constants used on the actual side of ```.matches()``` and ```doesNotMatch()``` will not be
   reported for regular expression testing.
-  
+
   Neither will a ```Class``` type be considered a constant in the classic sense, so
   ```assertThat(SomeClass.class).isAssignableFrom(SomeOtherClass.class)``` will not be reported.
 
@@ -626,9 +629,9 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 - AssertThatJava8Optional
 
   Examines the statement for Java 8 ```Optional``` type and whether the statement
-  effectively tries to assert the presence, absence or content and then 
+  effectively tries to assert the presence, absence or content and then
   replaces the statement by better assertions.
-  
+
   ```
   from: assertThat(opt.isPresent()).isEqualTo(true);
   from: assertThat(opt.isPresent()).isNotEqualTo(false);
@@ -666,7 +669,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 - AssertThatGuavaOptional
 
   Examines the statement for Google Guava ```Optional``` type and whether the statement
-  effectively tries to assert the presence, absence or content and then 
+  effectively tries to assert the presence, absence or content and then
   replaces the statement by better assertions.
 
   ```
@@ -705,26 +708,26 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 - AssumeThatInsteadOfReturn
 
   Tries to detect bogus uses of return statements in test methods and replaces them by ```assumeThat()``` calls.
-  
+
   Novices will use these to skip test execution by bailing out early on some preconditions not met.
   However, this suggests that the test has actually been run and passed instead of showing the test
   as being skipped.
 
-  Return statements in ```if``` statements in main test methods (must be annotated with JUnit 4 or 
+  Return statements in ```if``` statements in main test methods (must be annotated with JUnit 4 or
   Jupiter ```@Test``` annotations) will be verified to have at least one ```assertThat()``` statement in the code flow.
   Method calls within the same class will be examined for ```assertThat()``` statements, too.
   However, at most 50 statements and down to five recursions will be tolerated before giving up.
-  
+
   Currently, the quickfix may lose some comments during operation. The other branch of the ```if``` statement
   will be inlined (blocks with declarations will remain a code block due to variable scope).
   The quickfix will only work with AssertJ >= 2.9.0 (for 2.x releases) or >= 3.9.0 (for 3.x releases).
-  
+
   The generated ```assumeThat()``` statement could be optimized further (similar to ```assertThat()```), but
   there is currently no support in Cajon for this (you could rename the method to ```assertThat()``` optimize it
   and turn it back into ```assumeThat()``` in the end).
 
   Example:
-  
+
   ```
       @Test
       public void check_fuel_emission() {
@@ -748,14 +751,14 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 - JUnitAssertToAssertJ
 
   Tries to convert most of the JUnit 4 assertions and assumptions to AssertJ format.
-  Sometimes the expected and actual expressions are specified in wrong order -- 
+  Sometimes the expected and actual expressions are specified in wrong order --
   Cajon tries to swap these when it detects the supposed actual expression to be a
   constant while the expected one is not.
 
   Does not support Hamcrest-Matchers.
   If you need that kind of conversion, you might want to check out the
   [Assertions2AssertJ plugin](https://plugins.jetbrains.com/plugin/10345-assertions2assertj) by Ric Emery.
-  
+
   ```
   assertTrue(condition);
   assertTrue(message, condition);
@@ -793,8 +796,9 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 
 ### Implemented referencing
 
-  You can ctrl-click on references inside .extracting() method parameters to go the
-  referencing method definition.
+You can ctrl-click on references inside .extracting() method parameters to go the
+referencing method definition.
+
   ```
   .extracting("field")
   .extracting("outerField.fieldInsideObjectTypeOfOuterField.andSoOn")
@@ -808,9 +812,10 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
   .flatExtracting(Extractors.byName("fieldOrPropertyOrBareMethod.orAPathLikeAbove")
   .flatExtracting(Extractors.resultOf("bareMethod")
   ```
-  This works on both POJOs and ```Iterable```s/```Array```s. 
-  Implementation is very basic though and does not work with fancy cascaded ```.extracting()``` sequences.
-  If there's demand, I could add it.
+
+This works on both POJOs and ```Iterable```s/```Array```s.
+Implementation is very basic though and does not work with fancy cascaded ```.extracting()``` sequences.
+If there's demand, I could add it.
 
 ## Development notice
 
@@ -821,6 +826,7 @@ The IntelliJ framework actually uses the JUnit 3 TestCase for plugin testing, an
 Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for your projects (with attribution).
 
 ## Planned features
+
 - More Optional fixes such as ```opt1.get() == opt2.get()``` etc.
 - More moving out of methods for LocalDate/Time etc.
 - assertThat(foo.toLowerCase()/toUpperCase()).isEqualTo("foo") -> assertThat(foo).isEqualToIgnoringCase()
@@ -834,9 +840,18 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
 
 ## Changelog
 
+### V1.14 (19-Feb-24)
+
+- Now requires minimum version 2022.2.
+- Maintenance. Updated various dependencies (Kotlin 1.9.22) and AssertJ 3.25.3 and AssertJ-Guava 3.25.3.
+- Reworked JUnit 5 test framework to work again. However, all the tests are broken.
+  I spent several days trying to figure out what is going on, but I'm giving up on this pile of crap called IntelliJ.
+  Jetbrains keeps breaking the APIs and implementations every year and I just cannot be bothered anymore.
+- This is very likely the last version.
+
 ### V1.13 (18-Aug-22)
 
-- API change in IntelliJ platforms now requires minimum version 2019.3.1. Sorry, giving up to maintain compatibilty after four attempts.
+- API change in IntelliJ platforms now requires minimum version 2019.3.1. Sorry, giving up to maintain compatibility after four attempts.
 - Maintenance. Updated various dependencies (Kotlin 1.7.10) and AssertJ 3.23.1 and AssertJ-Guava 3.5.0.
 - Tried to fix unreproducible issue #9.
 - Added AssertThatIsZeroOne inspection demanded by issue #5.
@@ -859,10 +874,12 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
   inspection.
 
 #### V1.10 (31-Jul-20) Friday the 31st Edition
+
 - Updated libraries to the latest versions (including AssertJ 3.16.1 and Kotlin 1.40-rc).
 - Fixed two possible index out-of-bounds exceptions in ExtractorReferenceContributor and BogusAssertionInspection.
 
 #### V1.9 (25-Feb-20) Mardi Gras Edition
+
 - TwistedAssertion inspection will no longer warn for ```.matches()``` and ```doesNotMatch()``` for regular expressions.
   Apparently, ```assertThat("somestring").matches(regex)``` is a valid test if the regex is what needs to be tested.
   If the actual expression is of ```Class``` type, this will no longer be reported.
@@ -873,12 +890,14 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
   the warning will be reduced to information level as the assertion may be testing ```equals()``` or ```hashCode()``` for validity.
 
 #### V1.8 (14-Feb-20) Valentine Edition
+
 - Maintenance. Removed experimental API use. Updated dependencies. Fixed testing problems introduced with IntelliJ IDEA 2019.3
 - Added new TwistedAssertion inspection that will warn about assertions with the actual expression being a constant indicating
   swapped use of actual and expected expressions.
 - Added new BogusAssertion inspection that showing typical copy and paste errors where actual and expected expressions are the same.
 
 #### V1.7 (19-Nov-19)
+
 - Fixed a lapsuus in AssertThatFileExpression also transforming ```.listFiles()``` with a filter argument.
 - Added first version of AssertThatPathExpression for a limited number transformations (more stuff is possible,
   but requires detection and transformation of static ```Files```-methods).
@@ -886,6 +905,7 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
 - Added ```hasSize(), isEmpty()``` and ```isNotEmpty()``` for AssertThatFileExpression when using AssertJ >= 3.14.0.
 
 #### V1.6 (30-Sep-19)
+
 - Really fixed AssertThatGuavaOptional inspections to avoid conversions from ```.get()``` to ```.contains()```
   for array types. Sigh. Shouldn't be working >12h a day and then do some more stuff at home.
 - Fixed a bug in AssertThatBinaryExpression inspection for ```assertThat(null != expression)``` and related
@@ -896,6 +916,7 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
   Specifically, uses of ```matches()```, ```compareToIgnoreCase()```, ```indexOf()```, and ```trim()```.
 
 #### V1.5 (24-Sep-19)
+
 - Fix for AssertThatCollectionOrMap inspection sometimes causing an index out-of-bounds exception.
 - AssertThatGuavaOptional inspections will now avoid conversions from ```.get()``` to ```.contains()```
   for array types (currently not correctly supported by ```contains()``` in AssertJ-Guava).
@@ -906,23 +927,27 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
   combinations for ```.hasSameSizeAs()``` are supported.
 
 #### V1.4 (25-Aug-19)
+
 - Minor fix for highlighting of JoinVarArgsContains inspection.
 - Extended AssertThatSize inspection to Maps, too.
 - Extended AssertThatCollectionOrMap inspection for several ```assertThat(map.get())``` cases as suggested by Georgij G.
 
 #### V1.3 (03-Aug-19)
+
 - New JoinVarArgsContains inspection that will detect multiple ```.contains()```, ```.doesNotContain()```,
   and ```.containsOnlyOnce()``` calls within the same statement that could be joined together using variadic arguments.
 - AssertJ 3.13.0 broke some inspections due to new ```AbstractStringAssert::isEqualTo()``` method.
 - AssertThatJava8Optional and AssertThatGuavaOptional inspections do not longer try to fix
   ```assertThat(optional).isEqualTo(Optional.fromNullable(expression))``` to ```contains()```
   when ```expression``` is not a non-null constant expression.
-  
+
 #### V1.2 (23-Jun-19)
+
 - Due to popular demand the JoinAssertThatStatements inspection will now add line breaks on joining statements.
   The amount of statements joined without causing line breaks can be configured but defaults to 1 (always).
-          
+
 #### V1.1 (09-Jun-19)
+
 - Improved JoinAssertThatStatements detection of expressions with side-effects and added pre/post-increment/decrement detection.
 - Added Guava Optional ```opt.orNull() == null``` case. You know, I'm not making this stuff up, people actually write this kind of code.
 - Added Java 8 Optional ```opt.orElse(null) == null``` case, too.
@@ -933,14 +958,18 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
 - Added new AssertThatObjectExpression inspection for ```toString()``` and ```hashCode()``` and moved ```equals()``` from AssertThatBinaryExpression there.
 
 #### V1.0 (06-May-19)
+
 - First release to be considered stable enough for production use.
 - Fixed a NPE in AssumeThatInsteadOfReturn inspection quickfix for empty else branches.
 - Fixed missing description for AssumeThatInsteadOfReturn inspection.
-- Added new AssertThatCollectionOrMapExpression inspection that tries to pull out methods such as ```isEmpty()``` or ```contains()``` out of an actual ```assertThat()``` expression.
+- Added new AssertThatCollectionOrMapExpression inspection that tries to pull out methods such as ```isEmpty()``` or ```contains()``` out of an actual ```assertThat()```
+  expression.
 
 #### V0.8 (05-May-19)
+
 - Fixed missing description for JoinAssertThatStatements and detection of equivalent expressions (sorry, released it too hastily).
-- Fixed ```isEmpty()``` for enumerables and strings and ```isNull()``` for object conversions to be applied only if it is the terminal method call as ```isEmpty()``` and ```isNull()``` return void.
+- Fixed ```isEmpty()``` for enumerables and strings and ```isNull()``` for object conversions to be applied only if it is the terminal method call as ```isEmpty()```
+  and ```isNull()``` return void.
 - Heavily reworked inspections for edge cases, such as multiple ```isEqualTo()``` calls inside a single statement.
 - Some inspections could generate bogus code for weird situations, this has been made more fool-proof.
 - Corrected highlighting for many inspections.
@@ -949,6 +978,7 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
 - Added a first version of a new inspection that tries to detect bogus uses of return statements in test methods and replaces them by ```assumeThat()``` calls.
 
 #### V0.7 (28-Apr-19)
+
 - Another fix for AssertThatGuavaOptional inspection regarding using the same family name for slightly different quick fix executions
   (really, Jetbrains, this sucks for no reason).
 - Extended AssertThatSize inspection to transform ```hasSize()``` into ```hasSameSizeAs()```, if possible.
@@ -956,6 +986,7 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
   actual object together, preserving comments.
 
 #### V0.6 (22-Apr-19)
+
 - New AssertThatStringExpression inspection that will move ```isEmpty()```, ```equals()```, ```equalsIgnoreCase()```, ```contains()```,
   ```startsWith()```, and ```endsWith()``` out of actual expression.
 - Extended AssertThatSize inspection to take ```String```s and ```CharSequences``` into account, too.
@@ -964,28 +995,36 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
 - New AssertThatInstanceOf inspection that moves instanceof expressions out of ```assertThat()```.
 
 #### V0.5 (18-Apr-19)
+
 - Fixed incompatibility with IDEA versions < 2018.2 (affected AssertThatSizeInspection). Minimal version is now 2017.3.
 - Fixed missing Guava imports (if not already present) for AssertThatGuavaInspection. This was a major PITA to get right.
 - Added support for referencing and refactoring inside ```.extracting()``` methods with fields, properties and methods (though
   getter renaming does not work that perfect, but I'm giving up for now as the IntelliJ SDK docs are seriously lacking).
-- Fixed an exception in batch mode if the description string was the same but for different fixes. 
+- Fixed an exception in batch mode if the description string was the same but for different fixes.
   Now descriptions are different for quick fixes triggered by AssertThatJava8OptionalInspection and AssertThatGuavaOptionalInspection.
 
 #### V0.4 (11-Apr-19)
+
 - Reduced minimal supported IDEA version from 2018.2 to 2017.2.
-- New inspection AssertThatJava8Optional that operates on Java 8 ```Optional``` objects and tries to use ```contains()```, ```containsSame()```, ```isPresent()```, and ```isNotPresent()``` instead.
+- New inspection AssertThatJava8Optional that operates on Java 8 ```Optional``` objects and tries to use ```contains()```, ```containsSame()```, ```isPresent()```,
+  and ```isNotPresent()``` instead.
 - New inspection AssertThatGuavaOptional that operates on Guava ```Optional``` objects and tries to use ```contains()```, ```isPresent()```, and ```isAbsent()``` instead.
 - Added support in AssertThatBinaryExpressionIsTrueOrFalse for ```is(Not)EqualTo(Boolean.TRUE/FALSE)```.
 
 #### V0.3 (07-Apr-19)
-- New inspection AssertThatBinaryExpressionIsTrueOrFalse that will find and fix common binary expressions and ```equals()``` statements (more than 150 combinations) inside ```assertThat()```.
+
+- New inspection AssertThatBinaryExpressionIsTrueOrFalse that will find and fix common binary expressions and ```equals()``` statements (more than 150 combinations)
+  inside ```assertThat()```.
 - Merged AssertThatObjectIsNull and AssertThatObjectIsNotNull to AssertThatObjectIsNullOrNotNull.
-- Support for ```hasSizeLessThan()```, ```hasSizeLessThanOrEqualTo()```, ```hasSizeGreaterThanOrEqualTo()```, and ```hasSizeGreaterThan()``` for AssertThatSizeInspection (with AssertJ >=3.12.0).
+- Support for ```hasSizeLessThan()```, ```hasSizeLessThanOrEqualTo()```, ```hasSizeGreaterThanOrEqualTo()```, and ```hasSizeGreaterThan()``` for AssertThatSizeInspection (with
+  AssertJ >=3.12.0).
 - Really fixed highlighting for JUnit conversion. Sorry.
 
 #### V0.2 (01-Apr-19)
+
 - Fixed descriptions and quick fix texts.
 - Fixed highlighting of found problems and 'Run inspection by Name' returning nothing, too.
 
 #### V0.1 (31-Mar-19)
-- Initial release.
\ No newline at end of file
+
+- Initial release.
diff --git a/build.gradle b/build.gradle
deleted file mode 100644
index d684989..0000000
--- a/build.gradle
+++ /dev/null
@@ -1,93 +0,0 @@
-plugins {
-    id 'java'
-    id 'org.jetbrains.intellij' version '1.8.0'
-    id 'org.jetbrains.kotlin.jvm' version '1.7.10'
-    id 'jacoco'
-    id 'com.github.kt3k.coveralls' version '2.12.0'
-}
-
-group 'de.platon42'
-version '1.13'
-sourceCompatibility = "1.8"
-targetCompatibility = "1.8"
-
-repositories {
-    mavenCentral()
-}
-
-/*
-  To run tests in IntelliJ use these VM Options for run configuration 
-  -ea -Didea.system.path=build/idea-sandbox/system-test -Didea.config.path=build/idea-sandbox/config-test -Didea.plugins.path=build/idea-sandbox/plugins-test
- */
-
-dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
-    testImplementation "org.assertj:assertj-core:3.23.1"
-    testImplementation "org.assertj:assertj-guava:3.5.0"
-    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.9.0'
-    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.9.0'
-    testImplementation "org.jetbrains.kotlin:kotlin-test"
-    testImplementation "org.jetbrains.kotlin:kotlin-reflect"
-    testImplementation 'org.junit.platform:junit-platform-launcher:1.9.0'
-//    testImplementation "org.jetbrains.kotlin:kotlin-test-junit"
-}
-
-compileKotlin {
-    kotlinOptions.jvmTarget = "1.8"
-}
-
-compileTestKotlin {
-    kotlinOptions.jvmTarget = "1.8"
-}
-
-intellij {
-    setVersion("2022.2") // LATEST-EAP-SNAPSHOT
-    //pluginName.set(provider { 'Concise AssertJ Optimizing Nitpicker (Cajon)' })
-    setUpdateSinceUntilBuild(false)
-    setPlugins(["com.intellij.java"])
-}
-
-runPluginVerifier {
-    ideVersions = ["IC-193.5662.53", "IC-222.3345.118"] // 2019.3.1 - 2022.2
-    downloadDir = System.getProperty("user.home") + "/.gradle/caches/modules-2/files-2.1/com.jetbrains.intellij.idea/verifier"
-}
-
-patchPluginXml {
-    setChangeNotes("""
-  <h4>V1.13 (18-Aug-22)</h4>
-    <ul>
-      <li>API change in IntelliJ platforms now requires minimum version 2019.3.1. Sorry, giving up to maintain compatibilty after four attempts.
-      <li>Maintenance. Updated various dependencies (Kotlin 1.7.10) and AssertJ 3.23.1 and AssertJ-Guava 3.5.0.
-      <li>Tried to fix unreproducible issue #9.
-      <li>Added AssertThatIsZeroOne inspection demanded by issue #5.
-      <li>Fix for wrongly joining statements that cannot be trivially joined (e.g. with filteredOn). Fixes issue #6.
-    </ul>
-  <p>Full changelog available at <a href="https://github.com/chrisly42/cajon-plugin#changelog">Github project site</a>.</p>
-""")
-}
-
-test {
-    useJUnitPlatform()
-    testLogging {
-        events "passed", "skipped", "failed"
-    }
-}
-
-tasks.coveralls {
-    dependsOn jacocoTestReport
-}
-
-jacoco {
-    toolVersion = '0.8.8'
-}
-
-jacocoTestReport {
-    reports {
-        xml.required.set(true)
-        csv.required.set(false)
-    }
-}
-
-publishPlugin {
-    setToken(intellijPublishToken)
-}
\ No newline at end of file
diff --git a/build.gradle.kts b/build.gradle.kts
new file mode 100644
index 0000000..2e2ea63
--- /dev/null
+++ b/build.gradle.kts
@@ -0,0 +1,131 @@
+plugins {
+    id("java")
+    id("org.jetbrains.intellij") version "1.17.1"
+    id("org.jetbrains.kotlin.jvm") version "1.9.22"
+    id("jacoco")
+    id("com.github.kt3k.coveralls") version "2.12.2"
+}
+
+group = "de.platon42"
+version = "1.14"
+
+repositories {
+    mavenCentral()
+}
+
+/*
+  To run tests in IntelliJ use these VM Options for run configuration
+  -ea -Didea.system.path=build/idea-sandbox/system-test -Didea.config.path=build/idea-sandbox/config-test -Didea.plugins.path=build/idea-sandbox/plugins-test
+ */
+
+dependencies {
+    //implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
+    testImplementation("org.assertj:assertj-core:3.25.3")
+    testImplementation("org.assertj:assertj-guava:3.25.3")
+    testImplementation("org.junit.jupiter:junit-jupiter-api:5.10.2")
+    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.10.2")
+    testImplementation("org.jetbrains.kotlin:kotlin-test")
+    testImplementation("org.jetbrains.kotlin:kotlin-reflect")
+    testImplementation("org.junit.platform:junit-platform-launcher:1.10.2")
+//    testImplementation "org.jetbrains.kotlin:kotlin-test-junit"
+}
+
+intellij {
+    version.set("2022.2") // LATEST-EAP-SNAPSHOT
+    //pluginName.set(provider { 'Concise AssertJ Optimizing Nitpicker (Cajon)' })
+    updateSinceUntilBuild.set(false)
+    plugins.set(listOf("com.intellij.java"))
+}
+
+tasks {
+    withType<JavaCompile> {
+        sourceCompatibility = "11"
+        targetCompatibility = "11"
+    }
+    withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
+        kotlinOptions.jvmTarget = "11"
+    }
+
+    test {
+        useJUnitPlatform()
+        testLogging {
+            events("passed", "skipped", "failed")
+        }
+    }
+
+
+    prepareSandbox {
+        enabled = true
+    }
+
+    verifyPlugin {
+        enabled = true
+    }
+
+    verifyPluginConfiguration {
+        enabled = true
+    }
+
+    patchPluginXml {
+        enabled = true
+        sinceBuild.set("222")
+        changeNotes.set(
+            """
+  <h4>V1.14 (19-Feb-24)</h4>
+    <ul>
+      <li>Now requires minimum version 2022.2.
+      <li>Maintenance. Updated various dependencies (Kotlin 1.9.22) and AssertJ 3.25.3 and AssertJ-Guava 3.25.3.
+      <li>Reworked JUnit 5 test framework to work again. However, all the tests are broken.
+      I spent several days trying to figure out what is going on, but I'm giving up on this pile of crap called IntelliJ. 
+      Jetbrains keeps breaking the APIs and implementations every year and I just cannot be bothered anymore.
+      <li>This is very likely the last version.
+    </ul>
+  <h4>V1.13 (18-Aug-22)</h4>
+    <ul>
+      <li>API change in IntelliJ platforms now requires minimum version 2019.3.1. Sorry, giving up to maintain compatibility after four attempts.
+      <li>Maintenance. Updated various dependencies (Kotlin 1.7.10) and AssertJ 3.23.1 and AssertJ-Guava 3.5.0.
+      <li>Tried to fix unreproducible issue #9.
+      <li>Added AssertThatIsZeroOne inspection demanded by issue #5.
+      <li>Fix for wrongly joining statements that cannot be trivially joined (e.g. with filteredOn). Fixes issue #6.
+    </ul>
+  <p>Full changelog available at <a href="https://git.platon42.de/chrisly42/cajon-plugin#changelog">Gitea project site</a>.</p>
+"""
+        )
+    }
+
+    publishPlugin {
+        token.set(System.getProperty("org.gradle.project.intellijPublishToken"))
+    }
+
+    runIde {
+        enabled = true
+        if (project.hasProperty("ideDir")) {
+            ideDir.set(file(project.property("ideDir")!!))
+            jbrVersion.set(project.property("ideJBR")!! as String)
+        }
+        autoReloadPlugins.set(false)
+    }
+
+
+    runPluginVerifier {
+        ideVersions.set(listOf("IC-222.4167.29", "IC-233.14015.106")) // 2022.2.2 - 2023.3.3
+        downloadDir.set(System.getenv("user.home") + "/.gradle/caches/modules-2/files-2.1/com.jetbrains.intellij.idea/verifier")
+    }
+
+
+}
+
+//tasks.coveralls {
+//    dependsOn(jacocoTestReport)
+//}
+
+//jacoco {
+//    toolVersion = '0.8.8'
+//}
+//
+//jacocoTestReport {
+//    reports {
+//        xml.required.set(true)
+//        csv.required.set(false)
+//    }
+//}
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index ae04661..17655d0 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.5.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.6-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/AssertJClassNames.kt b/src/main/java/de/platon42/intellij/plugins/cajon/AssertJClassNames.kt
index 349e9e0..e004bbe 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/AssertJClassNames.kt
+++ b/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"
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/Extensions.kt b/src/main/java/de/platon42/intellij/plugins/cajon/Extensions.kt
index ccd53e0..39a011f 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/Extensions.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/Extensions.kt
@@ -180,4 +180,4 @@ fun PsiExpression.getAllTheSameNullNotNullConstants(): Boolean? {
         }
     }
     return lockedResult
-}
\ No newline at end of file
+}
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AbstractAssertJInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AbstractAssertJInspection.kt
index a780187..dad6425 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AbstractAssertJInspection.kt
+++ b/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)
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatJava8OptionalInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatJava8OptionalInspection.kt
index 1f70f95..8ad6acd 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatJava8OptionalInspection.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatJava8OptionalInspection.kt
@@ -76,4 +76,4 @@ class AssertThatJava8OptionalInspection : AbstractAssertJInspection() {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatObjectIsNullOrNotNullInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatObjectIsNullOrNotNullInspection.kt
index 1df6370..02e56b4 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatObjectIsNullOrNotNullInspection.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatObjectIsNullOrNotNullInspection.kt
@@ -32,4 +32,4 @@ class AssertThatObjectIsNullOrNotNullInspection : AbstractAssertJInspection() {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/resources/META-INF/plugin.xml b/src/main/resources/META-INF/plugin.xml
index 6467f0d..043ce5d 100644
--- a/src/main/resources/META-INF/plugin.xml
+++ b/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>
\ No newline at end of file
+</idea-plugin>
diff --git a/src/test/java/de/platon42/intellij/jupiter/AbstractJUnit5TestCase.kt b/src/test/java/de/platon42/intellij/jupiter/AbstractJUnit5TestCase.kt
new file mode 100644
index 0000000..afa0dae
--- /dev/null
+++ b/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()
+}
diff --git a/src/test/java/de/platon42/intellij/jupiter/AddLocalJarToModule.kt b/src/test/java/de/platon42/intellij/jupiter/AddLocalJarToModule.kt
index 8967788..df75306 100644
--- a/src/test/java/de/platon42/intellij/jupiter/AddLocalJarToModule.kt
+++ b/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();
-}
\ No newline at end of file
+annotation class AddLocalJarToModule(vararg val value: KClass<*>)
diff --git a/src/test/java/de/platon42/intellij/jupiter/AddMavenDependencyToModule.kt b/src/test/java/de/platon42/intellij/jupiter/AddMavenDependencyToModule.kt
index d8428cb..659c935 100644
--- a/src/test/java/de/platon42/intellij/jupiter/AddMavenDependencyToModule.kt
+++ b/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();
-    }
-}
\ No newline at end of file
+    annotation class List(vararg val value: AddMavenDependencyToModule)
+}
diff --git a/src/test/java/de/platon42/intellij/jupiter/EdtInterceptorExtension.kt b/src/test/java/de/platon42/intellij/jupiter/EdtInterceptorExtension.kt
new file mode 100644
index 0000000..d9aff4f
--- /dev/null
+++ b/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()
+                }
+            }
+        }
+    }
+}
diff --git a/src/test/java/de/platon42/intellij/jupiter/LightCodeInsightExtension.java b/src/test/java/de/platon42/intellij/jupiter/LightCodeInsightExtension.java
deleted file mode 100644
index ef2ea0c..0000000
--- a/src/test/java/de/platon42/intellij/jupiter/LightCodeInsightExtension.java
+++ /dev/null
@@ -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());
-        }
-    }
-}
diff --git a/src/test/java/de/platon42/intellij/jupiter/MyFixture.java b/src/test/java/de/platon42/intellij/jupiter/MyFixture.java
deleted file mode 100644
index 593efbb..0000000
--- a/src/test/java/de/platon42/intellij/jupiter/MyFixture.java
+++ /dev/null
@@ -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 {
-}
diff --git a/src/test/java/de/platon42/intellij/jupiter/MyTestCase.java b/src/test/java/de/platon42/intellij/jupiter/MyTestCase.java
deleted file mode 100644
index 65d46a1..0000000
--- a/src/test/java/de/platon42/intellij/jupiter/MyTestCase.java
+++ /dev/null
@@ -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 {
-}
diff --git a/src/test/java/de/platon42/intellij/jupiter/TestDataPath.kt b/src/test/java/de/platon42/intellij/jupiter/TestDataPath.kt
index 3b07a79..6337aca 100644
--- a/src/test/java/de/platon42/intellij/jupiter/TestDataPath.kt
+++ b/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)
diff --git a/src/test/java/de/platon42/intellij/jupiter/TestDataSubPath.kt b/src/test/java/de/platon42/intellij/jupiter/TestDataSubPath.kt
index 2c7d3fc..80be221 100644
--- a/src/test/java/de/platon42/intellij/jupiter/TestDataSubPath.kt
+++ b/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)
diff --git a/src/test/java/de/platon42/intellij/jupiter/TestJdk.kt b/src/test/java/de/platon42/intellij/jupiter/TestJdk.kt
index 0e83797..079bdc7 100644
--- a/src/test/java/de/platon42/intellij/jupiter/TestJdk.kt
+++ b/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;
-}
\ No newline at end of file
+annotation class TestJdk(val value: LanguageLevel)
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/AbstractCajonTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/AbstractCajonTest.kt
index c8cf73f..1dd0fde 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/AbstractCajonTest.kt
+++ b/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("$")
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBinaryExpressionInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBinaryExpressionInspectionTest.kt
index fd48e2f..9d62a73 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBinaryExpressionInspectionTest.kt
+++ b/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")
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBooleanConditionInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBooleanConditionInspectionTest.kt
index 9ca3354..236f29d 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBooleanConditionInspectionTest.kt
+++ b/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")
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatCollectionOrMapExpressionInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatCollectionOrMapExpressionInspectionTest.kt
index e0a0ddd..0e091fd 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatCollectionOrMapExpressionInspectionTest.kt
+++ b/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)
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatComparableInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatComparableInspectionTest.kt
index 3108141..00cd04f 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatComparableInspectionTest.kt
+++ b/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")
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatEnumerableIsEmptyInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatEnumerableIsEmptyInspectionTest.kt
index edd994e..45d0c88 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatEnumerableIsEmptyInspectionTest.kt
+++ b/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")
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatFileExpressionInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatFileExpressionInspectionTest.kt
index d729ea7..4c4f112 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatFileExpressionInspectionTest.kt
+++ b/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")
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatGuavaOptionalInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatGuavaOptionalInspectionTest.kt
index 3b65e35..b170e52 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatGuavaOptionalInspectionTest.kt
+++ b/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")
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInstanceOfInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInstanceOfInspectionTest.kt
index c0901e0..1cf1f1b 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInstanceOfInspectionTest.kt
+++ b/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")
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInvertedBooleanConditionInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInvertedBooleanConditionInspectionTest.kt
index c414e23..7fdc534 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInvertedBooleanConditionInspectionTest.kt
+++ b/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")
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatIsZeroOneInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatIsZeroOneInspectionTest.kt
index a2e2c37..9a3d9b7 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatIsZeroOneInspectionTest.kt
+++ b/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")
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatJava8OptionalInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatJava8OptionalInspectionTest.kt
index 1bc7467..532628a 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatJava8OptionalInspectionTest.kt
+++ b/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")
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatObjectExpressionInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatObjectExpressionInspectionTest.kt
index 72cbfa3..31251e4 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatObjectExpressionInspectionTest.kt
+++ b/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")
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatObjectIsNullOrNotNullInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatObjectIsNullOrNotNullInspectionTest.kt
index 8ab6b0b..7fad861 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatObjectIsNullOrNotNullInspectionTest.kt
+++ b/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")
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatPathExpressionInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatPathExpressionInspectionTest.kt
index 2a9e295..c4df028 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatPathExpressionInspectionTest.kt
+++ b/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")
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatSizeInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatSizeInspectionTest.kt
index 8fc0c29..80c5ab8 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatSizeInspectionTest.kt
+++ b/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")
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringExpressionInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringExpressionInspectionTest.kt
index 4d7e780..feb1317 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringExpressionInspectionTest.kt
+++ b/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")
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringIsEmptyInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringIsEmptyInspectionTest.kt
index d917259..51adf69 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringIsEmptyInspectionTest.kt
+++ b/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")
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssumeThatInsteadOfReturnInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssumeThatInsteadOfReturnInspectionTest.kt
index 85ea523..856f338 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssumeThatInsteadOfReturnInspectionTest.kt
+++ b/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")
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/BogusAssertionInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/BogusAssertionInspectionTest.kt
index 5c3cc75..dc015a1 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/BogusAssertionInspectionTest.kt
+++ b/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()")
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/ImplicitAssertionInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/ImplicitAssertionInspectionTest.kt
index 362ba6e..82dd451 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/ImplicitAssertionInspectionTest.kt
+++ b/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")
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/JUnitAssertToAssertJInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/JUnitAssertToAssertJInspectionTest.kt
index bbd85d0..6e500cd 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/JUnitAssertToAssertJInspectionTest.kt
+++ b/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")
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/JoinAssertThatStatementsInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/JoinAssertThatStatementsInspectionTest.kt
index b573762..ee02bba 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/JoinAssertThatStatementsInspectionTest.kt
+++ b/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")
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/JoinVarArgsContainsInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/JoinVarArgsContainsInspectionTest.kt
index 561e6c4..4dc98a9 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/JoinVarArgsContainsInspectionTest.kt
+++ b/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")
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/TwistedAssertionInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/TwistedAssertionInspectionTest.kt
index 99f2346..25b786f 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/TwistedAssertionInspectionTest.kt
+++ b/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")
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/references/ExtractorReferenceContributorTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/references/ExtractorReferenceContributorTest.kt
index 0278de6..eb8dc21 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/references/ExtractorReferenceContributorTest.kt
+++ b/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)
     }
-}
\ No newline at end of file
+}