Compare commits
2 Commits
master
...
myplacedk/
| Author | SHA1 | Date | |
|---|---|---|---|
|
49a3b1aada | ||
|
|
f8b86ac78f |
@ -1,4 +1,4 @@
|
||||
Copyright 2019-2024 Chris Hodges <chrisly@platon42.de>
|
||||
Copyright 2019 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.
|
||||
limitations under the License.
|
||||
170
README.md
170
README.md
@ -1,4 +1,4 @@
|
||||
# Cajon - Concise AssertJ Optimizing Nitpicker
|
||||
# Cajon - Concise AssertJ Optimizing Nitpicker [](https://travis-ci.com/chrisly42/cajon-plugin) [](https://coveralls.io/github/chrisly42/cajon-plugin?branch=master)
|
||||
|
||||
Cajon is an IntelliJ IDEA Plugin for shortening and optimizing [AssertJ](https://assertj.github.io/doc/) assertions.
|
||||
|
||||
@ -32,7 +32,7 @@ Then AssertJ would tell you the _actual contents_ of the collection on failure.
|
||||
|
||||
## Conversion of JUnit assertions to AssertJ
|
||||
|
||||
The plugin also supports the conversion of the most common JUnit 4 assertions to AssertJ.
|
||||
The plugin also supports the conversion of the most common JUnit 4 and JUnit 5 assertions to AssertJ.
|
||||
|
||||
## Wrong use of AssertJ
|
||||
|
||||
@ -40,15 +40,14 @@ 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
|
||||
@ -63,11 +62,10 @@ 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()));
|
||||
|
||||
@ -85,7 +83,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.
|
||||
|
||||
```
|
||||
@ -100,16 +98,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");
|
||||
@ -118,7 +116,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
|
||||
@ -146,7 +144,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();
|
||||
@ -162,7 +160,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
|
||||
- AssertThatInstanceOf
|
||||
|
||||
Moves ```instanceof``` expressions out of ```assertThat()```.
|
||||
|
||||
|
||||
```
|
||||
from: assertThat(object instanceof classname).isEqualTo(true);
|
||||
from: assertThat(object instanceof classname).isTrue();
|
||||
@ -173,23 +171,6 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
|
||||
to: assertThat(object).isNotInstanceOf(classname.class);
|
||||
```
|
||||
|
||||
- AssertThatIsZeroOne
|
||||
|
||||
Uses ```isZero()```, ```isNotZero()``` and ```isOne()``` instead.
|
||||
Works with shorts, integers, longs, floats and doubles, and tries to evaluate
|
||||
constant expressions, too.
|
||||
|
||||
```
|
||||
from: assertThat(numeric).isEqualTo(0);
|
||||
to: assertThat(numeric).isZero();
|
||||
|
||||
from: assertThat(numeric).isNotEqualTo(0);
|
||||
to: assertThat(numeric).isNotZero();
|
||||
|
||||
from: assertThat(numeric).isEqualTo(1);
|
||||
to: assertThat(numeric).isOne();
|
||||
```
|
||||
|
||||
- AssertThatStringIsEmpty
|
||||
|
||||
Uses ```isEmpty()``` for empty string assertions.
|
||||
@ -203,9 +184,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();
|
||||
@ -230,7 +211,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):
|
||||
|
||||
```
|
||||
@ -258,7 +239,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);
|
||||
@ -273,7 +254,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);
|
||||
@ -339,7 +320,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```.
|
||||
@ -443,10 +424,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);
|
||||
@ -534,7 +515,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);
|
||||
@ -544,13 +525,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.
|
||||
|
||||
@ -629,9 +610,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);
|
||||
@ -669,7 +650,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.
|
||||
|
||||
```
|
||||
@ -708,26 +689,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 JUnit 5 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() {
|
||||
@ -750,15 +731,15 @@ 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 --
|
||||
Tries to convert most of the JUnit 4 and JUnit 5 assertions and assumptions to AssertJ format.
|
||||
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);
|
||||
@ -796,9 +777,8 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
|
||||
|
||||
### Implemented referencing
|
||||
|
||||
You can ctrl-click on references inside .extracting() method parameters to go the
|
||||
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")
|
||||
@ -812,21 +792,19 @@ referencing method definition.
|
||||
.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
|
||||
|
||||
Cajon is written in Kotlin 1.7.
|
||||
Cajon is written in Kotlin 1.4.
|
||||
|
||||
Cajon is probably the only plugin that uses JUnit 5 Jupiter for unit testing so far (or at least the only one I'm aware of ;) ).
|
||||
The IntelliJ framework actually uses the JUnit 3 TestCase for plugin testing, and it took me quite a while to make it work with JUnit 5.
|
||||
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()
|
||||
@ -836,26 +814,12 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
|
||||
from: assertThat(object).extracting("propOne", "propNoGetter", "propTwo.innerProp")...
|
||||
to: assertThat(object).extracting(type::getPropOne, it -> it.propNoGetter, it -> it.getPropTwo().getInnerProp())...
|
||||
```
|
||||
- Support primitives in assertThat(map.containsKey(1)).isTrue();
|
||||
|
||||
## Changelog
|
||||
|
||||
### V1.14 (19-Feb-24)
|
||||
#### V1.13 (unreleased)
|
||||
|
||||
- Now requires minimum version 2022.2.
|
||||
- Maintenance. Updated various dependencies (Kotlin 1.9.22) and AssertJ 3.25.3 and AssertJ-Guava 3.25.3.
|
||||
- Reworked JUnit 5 test framework to work again. However, all the tests are broken.
|
||||
I spent several days trying to figure out what is going on, but I'm giving up on this pile of crap called IntelliJ.
|
||||
Jetbrains keeps breaking the APIs and implementations every year and I just cannot be bothered anymore.
|
||||
- This is very likely the last version.
|
||||
|
||||
### V1.13 (18-Aug-22)
|
||||
|
||||
- API change in IntelliJ platforms now requires minimum version 2019.3.1. Sorry, giving up to maintain compatibility after four attempts.
|
||||
- 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.
|
||||
- Fix for wrongly joining statements that cannot be trivially joined (e.g. with filteredOn). Fixes issue #6.
|
||||
- Added support for converting JUnit 5 tests to AssertJ
|
||||
|
||||
### V1.12 (06-May-21)
|
||||
|
||||
@ -874,12 +838,10 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
|
||||
inspection.
|
||||
|
||||
#### V1.10 (31-Jul-20) Friday the 31st Edition
|
||||
|
||||
- Updated libraries to the latest versions (including AssertJ 3.16.1 and Kotlin 1.40-rc).
|
||||
- Fixed two possible index out-of-bounds exceptions in ExtractorReferenceContributor and BogusAssertionInspection.
|
||||
|
||||
#### V1.9 (25-Feb-20) Mardi Gras Edition
|
||||
|
||||
- TwistedAssertion inspection will no longer warn for ```.matches()``` and ```doesNotMatch()``` for regular expressions.
|
||||
Apparently, ```assertThat("somestring").matches(regex)``` is a valid test if the regex is what needs to be tested.
|
||||
If the actual expression is of ```Class``` type, this will no longer be reported.
|
||||
@ -890,14 +852,12 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
|
||||
the warning will be reduced to information level as the assertion may be testing ```equals()``` or ```hashCode()``` for validity.
|
||||
|
||||
#### V1.8 (14-Feb-20) Valentine Edition
|
||||
|
||||
- Maintenance. Removed experimental API use. Updated dependencies. Fixed testing problems introduced with IntelliJ IDEA 2019.3
|
||||
- Added new TwistedAssertion inspection that will warn about assertions with the actual expression being a constant indicating
|
||||
swapped use of actual and expected expressions.
|
||||
- Added new BogusAssertion inspection that showing typical copy and paste errors where actual and expected expressions are the same.
|
||||
|
||||
#### V1.7 (19-Nov-19)
|
||||
|
||||
- Fixed a lapsuus in AssertThatFileExpression also transforming ```.listFiles()``` with a filter argument.
|
||||
- Added first version of AssertThatPathExpression for a limited number transformations (more stuff is possible,
|
||||
but requires detection and transformation of static ```Files```-methods).
|
||||
@ -905,7 +865,6 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
|
||||
- Added ```hasSize(), isEmpty()``` and ```isNotEmpty()``` for AssertThatFileExpression when using AssertJ >= 3.14.0.
|
||||
|
||||
#### V1.6 (30-Sep-19)
|
||||
|
||||
- Really fixed AssertThatGuavaOptional inspections to avoid conversions from ```.get()``` to ```.contains()```
|
||||
for array types. Sigh. Shouldn't be working >12h a day and then do some more stuff at home.
|
||||
- Fixed a bug in AssertThatBinaryExpression inspection for ```assertThat(null != expression)``` and related
|
||||
@ -916,7 +875,6 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
|
||||
Specifically, uses of ```matches()```, ```compareToIgnoreCase()```, ```indexOf()```, and ```trim()```.
|
||||
|
||||
#### V1.5 (24-Sep-19)
|
||||
|
||||
- Fix for AssertThatCollectionOrMap inspection sometimes causing an index out-of-bounds exception.
|
||||
- AssertThatGuavaOptional inspections will now avoid conversions from ```.get()``` to ```.contains()```
|
||||
for array types (currently not correctly supported by ```contains()``` in AssertJ-Guava).
|
||||
@ -927,27 +885,23 @@ 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.
|
||||
@ -958,18 +912,14 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
|
||||
- Added new AssertThatObjectExpression inspection for ```toString()``` and ```hashCode()``` and moved ```equals()``` from AssertThatBinaryExpression there.
|
||||
|
||||
#### V1.0 (06-May-19)
|
||||
|
||||
- First release to be considered stable enough for production use.
|
||||
- Fixed a NPE in AssumeThatInsteadOfReturn inspection quickfix for empty else branches.
|
||||
- Fixed missing description for AssumeThatInsteadOfReturn inspection.
|
||||
- Added new AssertThatCollectionOrMapExpression inspection that tries to pull out methods such as ```isEmpty()``` or ```contains()``` out of an actual ```assertThat()```
|
||||
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.
|
||||
@ -978,7 +928,6 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
|
||||
- Added a first version of a new inspection that tries to detect bogus uses of return statements in test methods and replaces them by ```assumeThat()``` calls.
|
||||
|
||||
#### V0.7 (28-Apr-19)
|
||||
|
||||
- Another fix for AssertThatGuavaOptional inspection regarding using the same family name for slightly different quick fix executions
|
||||
(really, Jetbrains, this sucks for no reason).
|
||||
- Extended AssertThatSize inspection to transform ```hasSize()``` into ```hasSameSizeAs()```, if possible.
|
||||
@ -986,7 +935,6 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
|
||||
actual object together, preserving comments.
|
||||
|
||||
#### V0.6 (22-Apr-19)
|
||||
|
||||
- New AssertThatStringExpression inspection that will move ```isEmpty()```, ```equals()```, ```equalsIgnoreCase()```, ```contains()```,
|
||||
```startsWith()```, and ```endsWith()``` out of actual expression.
|
||||
- Extended AssertThatSize inspection to take ```String```s and ```CharSequences``` into account, too.
|
||||
@ -995,36 +943,28 @@ 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.
|
||||
- Initial release.
|
||||
79
build.gradle
Normal file
79
build.gradle
Normal file
@ -0,0 +1,79 @@
|
||||
plugins {
|
||||
id 'java'
|
||||
id 'org.jetbrains.intellij' version '1.1.3'
|
||||
id 'org.jetbrains.kotlin.jvm' version '1.5.21'
|
||||
id 'jacoco'
|
||||
id 'com.github.kt3k.coveralls' version '2.11.0'
|
||||
}
|
||||
|
||||
group 'de.platon42'
|
||||
version '1.12.1'
|
||||
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.20.2"
|
||||
testImplementation "org.assertj:assertj-guava:3.4.0"
|
||||
testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.0-M1'
|
||||
testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.0-M1'
|
||||
testImplementation "org.jetbrains.kotlin:kotlin-test"
|
||||
testImplementation "org.jetbrains.kotlin:kotlin-reflect"
|
||||
// testImplementation "org.jetbrains.kotlin:kotlin-test-junit"
|
||||
}
|
||||
|
||||
compileKotlin {
|
||||
kotlinOptions.jvmTarget = "1.8"
|
||||
}
|
||||
|
||||
compileTestKotlin {
|
||||
kotlinOptions.jvmTarget = "1.8"
|
||||
}
|
||||
|
||||
intellij {
|
||||
setVersion("2021.1.3") // LATEST-EAP-SNAPSHOT
|
||||
//pluginName.set(provider { 'Concise AssertJ Optimizing Nitpicker (Cajon)' })
|
||||
setUpdateSinceUntilBuild(false)
|
||||
setPlugins(["com.intellij.java"])
|
||||
}
|
||||
|
||||
patchPluginXml {
|
||||
setChangeNotes("""
|
||||
<h4>V1.13 (unreleased)</h4>
|
||||
<ul>
|
||||
<li>Added support for converting JUnit 5 tests to AssertJ
|
||||
</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"
|
||||
}
|
||||
}
|
||||
|
||||
jacoco {
|
||||
toolVersion = '0.8.7'
|
||||
}
|
||||
|
||||
jacocoTestReport {
|
||||
reports {
|
||||
xml.required.set(true)
|
||||
csv.required.set(false)
|
||||
}
|
||||
}
|
||||
|
||||
publishPlugin {
|
||||
setToken(intellijPublishToken)
|
||||
}
|
||||
131
build.gradle.kts
131
build.gradle.kts
@ -1,131 +0,0 @@
|
||||
plugins {
|
||||
id("java")
|
||||
id("org.jetbrains.intellij") version "1.17.1"
|
||||
id("org.jetbrains.kotlin.jvm") version "1.9.22"
|
||||
id("jacoco")
|
||||
id("com.github.kt3k.coveralls") version "2.12.2"
|
||||
}
|
||||
|
||||
group = "de.platon42"
|
||||
version = "1.14"
|
||||
|
||||
repositories {
|
||||
mavenCentral()
|
||||
}
|
||||
|
||||
/*
|
||||
To run tests in IntelliJ use these VM Options for run configuration
|
||||
-ea -Didea.system.path=build/idea-sandbox/system-test -Didea.config.path=build/idea-sandbox/config-test -Didea.plugins.path=build/idea-sandbox/plugins-test
|
||||
*/
|
||||
|
||||
dependencies {
|
||||
//implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
|
||||
testImplementation("org.assertj:assertj-core:3.25.3")
|
||||
testImplementation("org.assertj:assertj-guava:3.25.3")
|
||||
testImplementation("org.junit.jupiter:junit-jupiter-api:5.10.2")
|
||||
testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.10.2")
|
||||
testImplementation("org.jetbrains.kotlin:kotlin-test")
|
||||
testImplementation("org.jetbrains.kotlin:kotlin-reflect")
|
||||
testImplementation("org.junit.platform:junit-platform-launcher:1.10.2")
|
||||
// testImplementation "org.jetbrains.kotlin:kotlin-test-junit"
|
||||
}
|
||||
|
||||
intellij {
|
||||
version.set("2022.2") // LATEST-EAP-SNAPSHOT
|
||||
//pluginName.set(provider { 'Concise AssertJ Optimizing Nitpicker (Cajon)' })
|
||||
updateSinceUntilBuild.set(false)
|
||||
plugins.set(listOf("com.intellij.java"))
|
||||
}
|
||||
|
||||
tasks {
|
||||
withType<JavaCompile> {
|
||||
sourceCompatibility = "11"
|
||||
targetCompatibility = "11"
|
||||
}
|
||||
withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
|
||||
kotlinOptions.jvmTarget = "11"
|
||||
}
|
||||
|
||||
test {
|
||||
useJUnitPlatform()
|
||||
testLogging {
|
||||
events("passed", "skipped", "failed")
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
prepareSandbox {
|
||||
enabled = true
|
||||
}
|
||||
|
||||
verifyPlugin {
|
||||
enabled = true
|
||||
}
|
||||
|
||||
verifyPluginConfiguration {
|
||||
enabled = true
|
||||
}
|
||||
|
||||
patchPluginXml {
|
||||
enabled = true
|
||||
sinceBuild.set("222")
|
||||
changeNotes.set(
|
||||
"""
|
||||
<h4>V1.14 (19-Feb-24)</h4>
|
||||
<ul>
|
||||
<li>Now requires minimum version 2022.2.
|
||||
<li>Maintenance. Updated various dependencies (Kotlin 1.9.22) and AssertJ 3.25.3 and AssertJ-Guava 3.25.3.
|
||||
<li>Reworked JUnit 5 test framework to work again. However, all the tests are broken.
|
||||
I spent several days trying to figure out what is going on, but I'm giving up on this pile of crap called IntelliJ.
|
||||
Jetbrains keeps breaking the APIs and implementations every year and I just cannot be bothered anymore.
|
||||
<li>This is very likely the last version.
|
||||
</ul>
|
||||
<h4>V1.13 (18-Aug-22)</h4>
|
||||
<ul>
|
||||
<li>API change in IntelliJ platforms now requires minimum version 2019.3.1. Sorry, giving up to maintain compatibility after four attempts.
|
||||
<li>Maintenance. Updated various dependencies (Kotlin 1.7.10) and AssertJ 3.23.1 and AssertJ-Guava 3.5.0.
|
||||
<li>Tried to fix unreproducible issue #9.
|
||||
<li>Added AssertThatIsZeroOne inspection demanded by issue #5.
|
||||
<li>Fix for wrongly joining statements that cannot be trivially joined (e.g. with filteredOn). Fixes issue #6.
|
||||
</ul>
|
||||
<p>Full changelog available at <a href="https://git.platon42.de/chrisly42/cajon-plugin#changelog">Gitea project site</a>.</p>
|
||||
"""
|
||||
)
|
||||
}
|
||||
|
||||
publishPlugin {
|
||||
token.set(System.getProperty("org.gradle.project.intellijPublishToken"))
|
||||
}
|
||||
|
||||
runIde {
|
||||
enabled = true
|
||||
if (project.hasProperty("ideDir")) {
|
||||
ideDir.set(file(project.property("ideDir")!!))
|
||||
jbrVersion.set(project.property("ideJBR")!! as String)
|
||||
}
|
||||
autoReloadPlugins.set(false)
|
||||
}
|
||||
|
||||
|
||||
runPluginVerifier {
|
||||
ideVersions.set(listOf("IC-222.4167.29", "IC-233.14015.106")) // 2022.2.2 - 2023.3.3
|
||||
downloadDir.set(System.getenv("user.home") + "/.gradle/caches/modules-2/files-2.1/com.jetbrains.intellij.idea/verifier")
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
//tasks.coveralls {
|
||||
// dependsOn(jacocoTestReport)
|
||||
//}
|
||||
|
||||
//jacoco {
|
||||
// toolVersion = '0.8.8'
|
||||
//}
|
||||
//
|
||||
//jacocoTestReport {
|
||||
// reports {
|
||||
// xml.required.set(true)
|
||||
// csv.required.set(false)
|
||||
// }
|
||||
//}
|
||||
2
gradle/wrapper/gradle-wrapper.properties
vendored
2
gradle/wrapper/gradle-wrapper.properties
vendored
@ -1,5 +1,5 @@
|
||||
distributionBase=GRADLE_USER_HOME
|
||||
distributionPath=wrapper/dists
|
||||
distributionUrl=https\://services.gradle.org/distributions/gradle-8.6-bin.zip
|
||||
distributionUrl=https\://services.gradle.org/distributions/gradle-7.1.1-bin.zip
|
||||
zipStoreBase=GRADLE_USER_HOME
|
||||
zipStorePath=wrapper/dists
|
||||
|
||||
@ -12,101 +12,69 @@ class AssertJClassNames {
|
||||
|
||||
@NonNls
|
||||
const val DESCRIPTABLE_INTERFACE = "org.assertj.core.api.Descriptable"
|
||||
|
||||
@NonNls
|
||||
const val EXTENSION_POINTS_INTERFACE = "org.assertj.core.api.ExtensionPoints"
|
||||
|
||||
@NonNls
|
||||
const val ENUMERABLE_ASSERT_INTERFACE = "org.assertj.core.api.EnumerableAssert"
|
||||
|
||||
@NonNls
|
||||
const val OBJECT_ENUMERABLE_ASSERT_INTERFACE = "org.assertj.core.api.ObjectEnumerableAssert"
|
||||
|
||||
@NonNls
|
||||
const val ASSERT_INTERFACE = "org.assertj.core.api.Assert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_OBJECT_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractObjectAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_BOOLEAN_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractBooleanAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_SHORT_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractShortAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_INTEGER_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractIntegerAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_LONG_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractLongAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_FLOAT_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractFloatAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_DOUBLE_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractDoubleAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_COMPARABLE_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractComparableAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_STRING_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractStringAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractCharSequenceAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_MAP_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractMapAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_BOOLEAN_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractBooleanArrayAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_BYTE_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractByteArrayAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_SHORT_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractShortArrayAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_INT_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractIntArrayAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_LONG_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractLongArrayAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_FLOAT_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractFloatArrayAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_DOUBLE_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractDoubleArrayAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_CHAR_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractCharArrayAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_OBJECT_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractObjectArrayAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_ITERABLE_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractIterableAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_FILE_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractFileAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_OPTIONAL_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractOptionalAssert"
|
||||
|
||||
@NonNls
|
||||
const val EXTRACTORS_CLASSNAME = "org.assertj.core.extractor.Extractors"
|
||||
|
||||
@NonNls
|
||||
const val GUAVA_OPTIONAL_CLASSNAME = "com.google.common.base.Optional"
|
||||
|
||||
@NonNls
|
||||
const val GUAVA_ASSERTIONS_CLASSNAME = "org.assertj.guava.api.Assertions"
|
||||
|
||||
@NonNls
|
||||
const val GUAVA_OPTIONAL_ASSERTIONS_CLASSNAME = "org.assertj.guava.api.OptionalAssert"
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -50,21 +50,9 @@ val MORE_EXTENSION_POINTS = CallMatcher.instanceCall(
|
||||
"singleElement", "hasOnlyOneElementSatisfying", "anyMatch", "noneMatch", "anySatisfy", "noneSatisfy"
|
||||
)!!
|
||||
|
||||
val FILTERED_ON = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_ITERABLE_ASSERT_CLASSNAME, "filteredOn", "filteredOnNull", "filteredOnAssertions")!!
|
||||
|
||||
val COMPLEX_CALLS_THAT_MAKES_STUFF_TRICKY = CallMatcher.anyOf(
|
||||
EXTRACTING_CALL_MATCHERS,
|
||||
DESCRIBED_AS,
|
||||
WITH_REPRESENTATION_AND_SUCH,
|
||||
FILTERED_ON,
|
||||
USING_COMPARATOR,
|
||||
IN_HEXADECIMAL_OR_BINARY
|
||||
)!!
|
||||
|
||||
val COMPLEX_STUFF_THAT_MAKES_JOINING_IMPOSSIBLE = CallMatcher.anyOf(
|
||||
EXTRACTING_CALL_MATCHERS,
|
||||
WITH_REPRESENTATION_AND_SUCH,
|
||||
FILTERED_ON,
|
||||
USING_COMPARATOR,
|
||||
IN_HEXADECIMAL_OR_BINARY
|
||||
)!!
|
||||
|
||||
@ -115,7 +115,8 @@ fun PsiMethodCallExpression.getExpectedNullNonNullResult(): Boolean? {
|
||||
}
|
||||
|
||||
fun PsiMethodCallExpression.calculateConstantParameterValue(argIndex: Int): Any? {
|
||||
return getArgOrNull(argIndex)?.calculateConstantValue()
|
||||
if (argIndex >= argumentList.expressions.size) return null
|
||||
return getArg(argIndex).calculateConstantValue()
|
||||
}
|
||||
|
||||
fun PsiExpression.calculateConstantValue(): Any? {
|
||||
@ -180,4 +181,4 @@ fun PsiExpression.getAllTheSameNullNotNullConstants(): Boolean? {
|
||||
}
|
||||
}
|
||||
return lockedResult
|
||||
}
|
||||
}
|
||||
@ -17,25 +17,19 @@ class MethodNames {
|
||||
|
||||
@NonNls
|
||||
const val AS = "as"
|
||||
|
||||
@NonNls
|
||||
const val DESCRIBED_AS = "describedAs"
|
||||
|
||||
@NonNls
|
||||
const val IN_HEXADECIMAL = "inHexadecimal"
|
||||
|
||||
@NonNls
|
||||
const val IN_BINARY = "inBinary"
|
||||
|
||||
@NonNls
|
||||
const val IS_EQUAL_TO = "isEqualTo"
|
||||
|
||||
@NonNls
|
||||
const val IS_NOT_EQUAL_TO = "isNotEqualTo"
|
||||
|
||||
@NonNls
|
||||
const val IS_SAME_AS = "isSameAs"
|
||||
|
||||
@NonNls
|
||||
const val IS_NOT_SAME_AS = "isNotSameAs"
|
||||
|
||||
@ -44,133 +38,89 @@ class MethodNames {
|
||||
|
||||
@NonNls
|
||||
const val IS_GREATER_THAN = "isGreaterThan"
|
||||
|
||||
@NonNls
|
||||
const val IS_GREATER_THAN_OR_EQUAL_TO = "isGreaterThanOrEqualTo"
|
||||
|
||||
@NonNls
|
||||
const val IS_LESS_THAN = "isLessThan"
|
||||
|
||||
@NonNls
|
||||
const val IS_LESS_THAN_OR_EQUAL_TO = "isLessThanOrEqualTo"
|
||||
|
||||
@NonNls
|
||||
const val IS_ZERO = "isZero"
|
||||
|
||||
@NonNls
|
||||
const val IS_NOT_ZERO = "isNotZero"
|
||||
|
||||
@NonNls
|
||||
const val IS_ONE = "isOne"
|
||||
|
||||
@NonNls
|
||||
const val IS_TRUE = "isTrue"
|
||||
|
||||
@NonNls
|
||||
const val IS_FALSE = "isFalse"
|
||||
|
||||
@NonNls
|
||||
const val IS_NULL = "isNull" // terminal, returns void
|
||||
|
||||
@NonNls
|
||||
const val IS_NOT_NULL = "isNotNull"
|
||||
|
||||
@NonNls
|
||||
const val IS_CLOSE_TO = "isCloseTo"
|
||||
|
||||
@NonNls
|
||||
const val IS_NOT_CLOSE_TO = "isNotCloseTo"
|
||||
|
||||
@NonNls
|
||||
const val IS_INSTANCE_OF = "isInstanceOf"
|
||||
|
||||
@NonNls
|
||||
const val IS_NOT_INSTANCE_OF = "isNotInstanceOf"
|
||||
|
||||
@NonNls
|
||||
const val IS_NULL_OR_EMPTY = "isNullOrEmpty" // terminal, returns void
|
||||
|
||||
@NonNls
|
||||
const val IS_EMPTY = "isEmpty" // terminal, returns void
|
||||
|
||||
@NonNls
|
||||
const val IS_NOT_EMPTY = "isNotEmpty"
|
||||
|
||||
@NonNls
|
||||
const val HAS_SIZE = "hasSize"
|
||||
|
||||
@NonNls
|
||||
const val HAS_SIZE_LESS_THAN = "hasSizeLessThan"
|
||||
|
||||
@NonNls
|
||||
const val HAS_SIZE_LESS_THAN_OR_EQUAL_TO = "hasSizeLessThanOrEqualTo"
|
||||
|
||||
@NonNls
|
||||
const val HAS_SIZE_GREATER_THAN = "hasSizeGreaterThan"
|
||||
|
||||
@NonNls
|
||||
const val HAS_SIZE_GREATER_THAN_OR_EQUAL_TO = "hasSizeGreaterThanOrEqualTo"
|
||||
|
||||
@NonNls
|
||||
const val HAS_SAME_SIZE_AS = "hasSameSizeAs"
|
||||
|
||||
@NonNls
|
||||
const val CONTAINS = "contains"
|
||||
|
||||
@NonNls
|
||||
const val CONTAINS_ONLY_ONCE = "containsOnlyOnce"
|
||||
|
||||
@NonNls
|
||||
const val DOES_NOT_CONTAIN = "doesNotContain"
|
||||
|
||||
@NonNls
|
||||
const val CONTAINS_EXACTLY = "containsExactly"
|
||||
|
||||
@NonNls
|
||||
const val CONTAINS_ALL = "containsAll"
|
||||
|
||||
@NonNls
|
||||
const val CONTAINS_KEY = "containsKey"
|
||||
|
||||
@NonNls
|
||||
const val DOES_NOT_CONTAIN_KEY = "doesNotContainKey"
|
||||
|
||||
@NonNls
|
||||
const val CONTAINS_VALUE = "containsValue"
|
||||
|
||||
@NonNls
|
||||
const val DOES_NOT_CONTAIN_VALUE = "doesNotContainValue"
|
||||
|
||||
@NonNls
|
||||
const val CONTAINS_ENTRY = "containsEntry"
|
||||
|
||||
@NonNls
|
||||
const val DOES_NOT_CONTAIN_ENTRY = "doesNotContainEntry"
|
||||
|
||||
@NonNls
|
||||
const val IS_EQUAL_TO_IC = "isEqualToIgnoringCase"
|
||||
|
||||
@NonNls
|
||||
const val IS_NOT_EQUAL_TO_IC = "isNotEqualToIgnoringCase"
|
||||
|
||||
@NonNls
|
||||
const val STARTS_WITH = "startsWith"
|
||||
|
||||
@NonNls
|
||||
const val ENDS_WITH = "endsWith"
|
||||
|
||||
@NonNls
|
||||
const val DOES_NOT_START_WITH = "doesNotStartWith"
|
||||
|
||||
@NonNls
|
||||
const val DOES_NOT_END_WITH = "doesNotEndWith"
|
||||
|
||||
@NonNls
|
||||
const val CONTAINS_SAME = "containsSame"
|
||||
|
||||
@NonNls
|
||||
const val IS_PRESENT = "isPresent"
|
||||
|
||||
@NonNls
|
||||
const val IS_NOT_PRESENT = "isNotPresent"
|
||||
|
||||
|
||||
@ -15,7 +15,6 @@ import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_D
|
||||
import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_FLOAT_ASSERT_CLASSNAME
|
||||
import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_INTEGER_ASSERT_CLASSNAME
|
||||
import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_LONG_ASSERT_CLASSNAME
|
||||
import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_SHORT_ASSERT_CLASSNAME
|
||||
import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_STRING_ASSERT_CLASSNAME
|
||||
import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ASSERTIONS_CLASSNAME
|
||||
import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ASSERT_INTERFACE
|
||||
@ -89,8 +88,6 @@ abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool()
|
||||
.parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
|
||||
val IS_EQUAL_TO_STRING = CallMatcher.instanceCall(ABSTRACT_STRING_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
|
||||
.parameterTypes(CommonClassNames.JAVA_LANG_STRING)!!
|
||||
val IS_EQUAL_TO_SHORT = CallMatcher.instanceCall(ABSTRACT_SHORT_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
|
||||
.parameterTypes("short")!!
|
||||
val IS_EQUAL_TO_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
|
||||
.parameterTypes("int")!!
|
||||
val IS_EQUAL_TO_LONG = CallMatcher.instanceCall(ABSTRACT_LONG_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
|
||||
@ -106,8 +103,6 @@ abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool()
|
||||
.parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
|
||||
val IS_NOT_EQUAL_TO_BOOLEAN = CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, MethodNames.IS_NOT_EQUAL_TO)
|
||||
.parameterTypes("boolean")!!
|
||||
val IS_NOT_EQUAL_TO_SHORT = CallMatcher.instanceCall(ABSTRACT_SHORT_ASSERT_CLASSNAME, MethodNames.IS_NOT_EQUAL_TO)
|
||||
.parameterTypes("short")!!
|
||||
val IS_NOT_EQUAL_TO_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, MethodNames.IS_NOT_EQUAL_TO)
|
||||
.parameterTypes("int")!!
|
||||
val IS_NOT_EQUAL_TO_LONG = CallMatcher.instanceCall(ABSTRACT_LONG_ASSERT_CLASSNAME, MethodNames.IS_NOT_EQUAL_TO)
|
||||
@ -160,15 +155,15 @@ abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool()
|
||||
.parameterCount(0)!!
|
||||
val IS_NOT_ZERO_LONG = CallMatcher.instanceCall(ABSTRACT_LONG_ASSERT_CLASSNAME, MethodNames.IS_NOT_ZERO)
|
||||
.parameterCount(0)!!
|
||||
val IS_ONE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isOne")
|
||||
val IS_ONE = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isOne")
|
||||
.parameterCount(0)!!
|
||||
val IS_NEGATIVE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNegative")
|
||||
val IS_NEGATIVE = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNegative")
|
||||
.parameterCount(0)!!
|
||||
val IS_NOT_NEGATIVE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNotNegative")
|
||||
val IS_NOT_NEGATIVE = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNotNegative")
|
||||
.parameterCount(0)!!
|
||||
val IS_POSITIVE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isPositive")
|
||||
val IS_POSITIVE = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isPositive")
|
||||
.parameterCount(0)!!
|
||||
val IS_NOT_POSITIVE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNotPositive")
|
||||
val IS_NOT_POSITIVE = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNotPositive")
|
||||
.parameterCount(0)!!
|
||||
|
||||
val IS_TRUE = CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, MethodNames.IS_TRUE)
|
||||
@ -307,4 +302,4 @@ abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool()
|
||||
) {
|
||||
registerConciseMethod(REMOVE_EXPECTED_OUTMOST_DESCRIPTION_TEMPLATE, holder, expression, oldExpectedCallExpression, replacementMethod, quickFixSupplier)
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -8,10 +8,16 @@ abstract class AbstractJUnitAssertInspection : AbstractBaseJavaLocalInspectionTo
|
||||
|
||||
companion object {
|
||||
@NonNls
|
||||
const val JUNIT_ASSERT_CLASSNAME = "org.junit.Assert"
|
||||
const val JUNIT4_ASSERT_CLASSNAME = "org.junit.Assert"
|
||||
|
||||
@NonNls
|
||||
const val JUNIT_ASSUME_CLASSNAME = "org.junit.Assume"
|
||||
const val JUNIT5_ASSERT_CLASSNAME = "org.junit.jupiter.api.Assertions"
|
||||
|
||||
@NonNls
|
||||
const val JUNIT4_ASSUME_CLASSNAME = "org.junit.Assume"
|
||||
|
||||
@NonNls
|
||||
const val JUNIT5_ASSUME_CLASSNAME = "org.junit.jupiter.api.Assumptions"
|
||||
|
||||
@NonNls
|
||||
const val ASSERT_TRUE_METHOD = "assertTrue"
|
||||
|
||||
@ -52,7 +52,7 @@ class AssertThatComparableInspection : AbstractMoveOutInspection() {
|
||||
),
|
||||
MoveOutMapping(
|
||||
COMPARABLE_COMPARE_TO,
|
||||
MethodNames.IS_GREATER_THAN_OR_EQUAL_TO, expectedMatcher = IS_NOT_NEGATIVE_INT, replaceFromOriginalMethod = true
|
||||
MethodNames.IS_GREATER_THAN_OR_EQUAL_TO, expectedMatcher = IS_NOT_NEGATIVE, replaceFromOriginalMethod = true
|
||||
),
|
||||
|
||||
MoveOutMapping(
|
||||
@ -67,7 +67,7 @@ class AssertThatComparableInspection : AbstractMoveOutInspection() {
|
||||
),
|
||||
MoveOutMapping(
|
||||
COMPARABLE_COMPARE_TO,
|
||||
MethodNames.IS_GREATER_THAN, expectedMatcher = CallMatcher.anyOf(IS_POSITIVE_INT, IS_ONE_INT), replaceFromOriginalMethod = true
|
||||
MethodNames.IS_GREATER_THAN, expectedMatcher = CallMatcher.anyOf(IS_POSITIVE, IS_ONE), replaceFromOriginalMethod = true
|
||||
),
|
||||
|
||||
MoveOutMapping(
|
||||
@ -82,7 +82,7 @@ class AssertThatComparableInspection : AbstractMoveOutInspection() {
|
||||
),
|
||||
MoveOutMapping(
|
||||
COMPARABLE_COMPARE_TO,
|
||||
MethodNames.IS_LESS_THAN_OR_EQUAL_TO, expectedMatcher = IS_NOT_POSITIVE_INT, replaceFromOriginalMethod = true
|
||||
MethodNames.IS_LESS_THAN_OR_EQUAL_TO, expectedMatcher = IS_NOT_POSITIVE, replaceFromOriginalMethod = true
|
||||
),
|
||||
|
||||
MoveOutMapping(
|
||||
@ -97,7 +97,7 @@ class AssertThatComparableInspection : AbstractMoveOutInspection() {
|
||||
),
|
||||
MoveOutMapping(
|
||||
COMPARABLE_COMPARE_TO,
|
||||
MethodNames.IS_LESS_THAN, expectedMatcher = IS_NEGATIVE_INT, replaceFromOriginalMethod = true
|
||||
MethodNames.IS_LESS_THAN, expectedMatcher = IS_NEGATIVE, replaceFromOriginalMethod = true
|
||||
)
|
||||
)
|
||||
}
|
||||
|
||||
@ -1,81 +0,0 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import com.intellij.codeInspection.ProblemsHolder
|
||||
import com.intellij.psi.JavaElementVisitor
|
||||
import com.intellij.psi.PsiElementVisitor
|
||||
import com.intellij.psi.PsiMethodCallExpression
|
||||
import com.intellij.psi.util.TypeConversionUtil
|
||||
import com.siyeh.ig.callMatcher.CallMatcher
|
||||
import de.platon42.intellij.plugins.cajon.*
|
||||
|
||||
class AssertThatIsZeroOneInspection : AbstractAssertJInspection() {
|
||||
|
||||
companion object {
|
||||
private const val DISPLAY_NAME = "Asserting a zero or one value"
|
||||
}
|
||||
|
||||
override fun getDisplayName() = DISPLAY_NAME
|
||||
|
||||
override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
|
||||
return object : JavaElementVisitor() {
|
||||
override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
|
||||
super.visitMethodCallExpression(expression)
|
||||
if (!expression.hasAssertThat()) return
|
||||
val isEqualTo = CallMatcher.anyOf(IS_EQUAL_TO_OBJECT, IS_EQUAL_TO_SHORT, IS_EQUAL_TO_INT, IS_EQUAL_TO_LONG, IS_EQUAL_TO_FLOAT, IS_EQUAL_TO_DOUBLE).test(expression)
|
||||
val isNotEqualTo =
|
||||
CallMatcher.anyOf(IS_NOT_EQUAL_TO_OBJECT, IS_NOT_EQUAL_TO_SHORT, IS_NOT_EQUAL_TO_INT, IS_NOT_EQUAL_TO_LONG, IS_NOT_EQUAL_TO_FLOAT, IS_NOT_EQUAL_TO_DOUBLE)
|
||||
.test(expression)
|
||||
|
||||
if (!(isEqualTo || isNotEqualTo)) return
|
||||
|
||||
val expectedExpression = expression.firstArg
|
||||
if (!TypeConversionUtil.isNumericType(expectedExpression.type)) return
|
||||
|
||||
val expectedResult = expression.calculateConstantParameterValue(0) ?: return
|
||||
var isZero = false
|
||||
var isOne = false
|
||||
when (expectedResult) {
|
||||
is Short -> {
|
||||
isZero = (expectedResult == 0.toShort())
|
||||
isOne = (expectedResult == 1.toShort())
|
||||
}
|
||||
|
||||
is Int -> {
|
||||
isZero = (expectedResult == 0)
|
||||
isOne = (expectedResult == 1)
|
||||
}
|
||||
|
||||
is Long -> {
|
||||
isZero = (expectedResult == 0L)
|
||||
isOne = (expectedResult == 1L)
|
||||
}
|
||||
|
||||
is Float -> {
|
||||
isZero = (expectedResult == 0.0f)
|
||||
isOne = (expectedResult == 1.0f)
|
||||
}
|
||||
|
||||
is Double -> {
|
||||
isZero = (expectedResult == 0.0)
|
||||
isOne = (expectedResult == 1.0)
|
||||
}
|
||||
}
|
||||
if (isZero || isOne) {
|
||||
val numericBaseClass = listOf(
|
||||
AssertJClassNames.ABSTRACT_SHORT_ASSERT_CLASSNAME,
|
||||
AssertJClassNames.ABSTRACT_INTEGER_ASSERT_CLASSNAME,
|
||||
AssertJClassNames.ABSTRACT_LONG_ASSERT_CLASSNAME,
|
||||
AssertJClassNames.ABSTRACT_FLOAT_ASSERT_CLASSNAME,
|
||||
AssertJClassNames.ABSTRACT_DOUBLE_ASSERT_CLASSNAME
|
||||
).any { checkAssertedType(expression, it) }
|
||||
if (!numericBaseClass) return
|
||||
}
|
||||
if (isZero) {
|
||||
registerSimplifyMethod(holder, expression, isEqualTo.map(MethodNames.IS_ZERO, MethodNames.IS_NOT_ZERO))
|
||||
} else if (isOne && isEqualTo) {
|
||||
registerSimplifyMethod(holder, expression, MethodNames.IS_ONE)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -76,4 +76,4 @@ class AssertThatJava8OptionalInspection : AbstractAssertJInspection() {
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -32,4 +32,4 @@ class AssertThatObjectIsNullOrNotNullInspection : AbstractAssertJInspection() {
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -94,7 +94,7 @@ class AssertThatStringExpressionInspection : AbstractMoveOutInspection() {
|
||||
|
||||
MoveOutMapping(
|
||||
STRING_INDEX_OF,
|
||||
MethodNames.CONTAINS, expectedMatcher = IS_NOT_NEGATIVE_INT, replaceFromOriginalMethod = true
|
||||
MethodNames.CONTAINS, expectedMatcher = IS_NOT_NEGATIVE, replaceFromOriginalMethod = true
|
||||
),
|
||||
MoveOutMapping(
|
||||
STRING_INDEX_OF,
|
||||
@ -119,7 +119,7 @@ class AssertThatStringExpressionInspection : AbstractMoveOutInspection() {
|
||||
),
|
||||
MoveOutMapping(
|
||||
STRING_INDEX_OF,
|
||||
MethodNames.DOES_NOT_CONTAIN, expectedMatcher = IS_NEGATIVE_INT, replaceFromOriginalMethod = true
|
||||
MethodNames.DOES_NOT_CONTAIN, expectedMatcher = IS_NEGATIVE, replaceFromOriginalMethod = true
|
||||
),
|
||||
MoveOutMapping(
|
||||
STRING_INDEX_OF,
|
||||
|
||||
@ -3,6 +3,8 @@ package de.platon42.intellij.plugins.cajon.inspections
|
||||
import com.intellij.codeInspection.LocalQuickFix
|
||||
import com.intellij.codeInspection.ProblemsHolder
|
||||
import com.intellij.psi.*
|
||||
import com.intellij.psi.CommonClassNames.*
|
||||
import com.intellij.psi.PsiKeyword.*
|
||||
import com.intellij.psi.search.GlobalSearchScope
|
||||
import com.siyeh.ig.callMatcher.CallMatcher
|
||||
import com.siyeh.ig.callMatcher.CallMatcher.anyOf
|
||||
@ -20,94 +22,127 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
|
||||
private const val CONVERT_MESSAGE_TEMPLATE = "%s can be converted to AssertJ style"
|
||||
private const val CONVERT_DESCRIPTION_TEMPLATE = "Convert %s() to %s().%s()"
|
||||
|
||||
private const val DOUBLE_ARR = "$DOUBLE[]"
|
||||
private const val FLOAT_ARR = "$FLOAT[]"
|
||||
|
||||
private val ASSERT_MAPPINGS = listOf(
|
||||
Mapping(
|
||||
anyOf(
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_TRUE_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "boolean"),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_TRUE_METHOD).parameterTypes("boolean")
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_TRUE_METHOD).parameterTypes(JAVA_LANG_STRING, BOOLEAN),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_TRUE_METHOD).parameterTypes(BOOLEAN, JAVA_LANG_STRING),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_TRUE_METHOD).parameterTypes(BOOLEAN),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_TRUE_METHOD).parameterTypes(BOOLEAN),
|
||||
),
|
||||
MethodNames.IS_TRUE, hasExpected = false
|
||||
),
|
||||
Mapping(
|
||||
anyOf(
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "boolean"),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes("boolean")
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes(JAVA_LANG_STRING, BOOLEAN),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes(BOOLEAN, JAVA_LANG_STRING),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes(BOOLEAN),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes(BOOLEAN),
|
||||
),
|
||||
MethodNames.IS_FALSE, hasExpected = false
|
||||
),
|
||||
Mapping(
|
||||
anyOf(
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, CommonClassNames.JAVA_LANG_OBJECT),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(JAVA_LANG_STRING, JAVA_LANG_OBJECT),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(JAVA_LANG_OBJECT, JAVA_LANG_STRING),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(JAVA_LANG_OBJECT),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(JAVA_LANG_OBJECT),
|
||||
),
|
||||
MethodNames.IS_NULL, hasExpected = false
|
||||
),
|
||||
Mapping(
|
||||
anyOf(
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_NULL_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, CommonClassNames.JAVA_LANG_OBJECT),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_NULL_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_NULL_METHOD).parameterTypes(JAVA_LANG_STRING, JAVA_LANG_OBJECT),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_NULL_METHOD).parameterTypes(JAVA_LANG_OBJECT, JAVA_LANG_STRING),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_NULL_METHOD).parameterTypes(JAVA_LANG_OBJECT),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_NULL_METHOD).parameterTypes(JAVA_LANG_OBJECT),
|
||||
),
|
||||
MethodNames.IS_NOT_NULL, hasExpected = false
|
||||
),
|
||||
Mapping(
|
||||
anyOf(
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "double", "double", "double"),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes("double", "double", "double"),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "float", "float", "float"),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes("float", "float", "float")
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(JAVA_LANG_STRING, DOUBLE, DOUBLE, DOUBLE),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(DOUBLE, DOUBLE, DOUBLE, JAVA_LANG_STRING),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(DOUBLE, DOUBLE, DOUBLE),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(DOUBLE, DOUBLE, DOUBLE),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(JAVA_LANG_STRING, FLOAT, FLOAT, FLOAT),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(FLOAT, FLOAT, FLOAT, JAVA_LANG_STRING),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(FLOAT, FLOAT, FLOAT),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(FLOAT, FLOAT, FLOAT),
|
||||
),
|
||||
MethodNames.IS_CLOSE_TO, hasDelta = true
|
||||
),
|
||||
Mapping(
|
||||
anyOf(
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterCount(3),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterCount(2)
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterCount(3),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterCount(3),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterCount(2),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterCount(2),
|
||||
),
|
||||
MethodNames.IS_EQUAL_TO
|
||||
),
|
||||
Mapping(
|
||||
anyOf(
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "double", "double", "double"),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes("double", "double", "double"),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "float", "float", "float"),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes("float", "float", "float")
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(JAVA_LANG_STRING, DOUBLE, DOUBLE, DOUBLE),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(DOUBLE, DOUBLE, DOUBLE, JAVA_LANG_STRING),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(DOUBLE, DOUBLE, DOUBLE),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(DOUBLE, DOUBLE, DOUBLE),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(JAVA_LANG_STRING, FLOAT, FLOAT, FLOAT),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(FLOAT, FLOAT, FLOAT, JAVA_LANG_STRING),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(FLOAT, FLOAT, FLOAT),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(FLOAT, FLOAT, FLOAT),
|
||||
),
|
||||
MethodNames.IS_NOT_CLOSE_TO, hasDelta = true
|
||||
),
|
||||
Mapping(
|
||||
anyOf(
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterCount(3),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterCount(2)
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterCount(3),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterCount(3),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterCount(2),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterCount(2),
|
||||
),
|
||||
MethodNames.IS_NOT_EQUAL_TO
|
||||
),
|
||||
Mapping(
|
||||
anyOf(
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_SAME_METHOD).parameterCount(3),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_SAME_METHOD).parameterCount(2)
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_SAME_METHOD).parameterCount(3),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_SAME_METHOD).parameterCount(3),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_SAME_METHOD).parameterCount(2),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_SAME_METHOD).parameterCount(2),
|
||||
),
|
||||
MethodNames.IS_SAME_AS
|
||||
),
|
||||
Mapping(
|
||||
anyOf(
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_SAME_METHOD).parameterCount(3),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_SAME_METHOD).parameterCount(2)
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_SAME_METHOD).parameterCount(3),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_SAME_METHOD).parameterCount(3),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_SAME_METHOD).parameterCount(2),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_SAME_METHOD).parameterCount(2),
|
||||
),
|
||||
MethodNames.IS_NOT_SAME_AS
|
||||
),
|
||||
Mapping(
|
||||
anyOf(
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "double[]", "double[]", "double"),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes("double[]", "double[]", "double"),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "float[]", "float[]", "float"),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes("float[]", "float[]", "float")
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(JAVA_LANG_STRING, DOUBLE_ARR, DOUBLE_ARR, DOUBLE),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(DOUBLE_ARR, DOUBLE_ARR, DOUBLE, JAVA_LANG_STRING),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(DOUBLE_ARR, DOUBLE_ARR, DOUBLE),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(DOUBLE_ARR, DOUBLE_ARR, DOUBLE),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(JAVA_LANG_STRING, FLOAT_ARR, FLOAT_ARR, FLOAT),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(FLOAT_ARR, FLOAT_ARR, FLOAT, JAVA_LANG_STRING),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(FLOAT_ARR, FLOAT_ARR, FLOAT),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(FLOAT_ARR, FLOAT_ARR, FLOAT),
|
||||
),
|
||||
MethodNames.CONTAINS_EXACTLY, hasDelta = true
|
||||
),
|
||||
Mapping(
|
||||
anyOf(
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterCount(2),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterCount(3)
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterCount(2),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterCount(2),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterCount(3),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterCount(3),
|
||||
),
|
||||
MethodNames.CONTAINS_EXACTLY
|
||||
)
|
||||
@ -116,26 +151,35 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
|
||||
private val ASSUME_MAPPINGS = listOf(
|
||||
Mapping(
|
||||
anyOf(
|
||||
staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_TRUE_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "boolean"),
|
||||
staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_TRUE_METHOD).parameterTypes("boolean")
|
||||
staticCall(JUNIT4_ASSUME_CLASSNAME, ASSUME_TRUE_METHOD).parameterTypes(JAVA_LANG_STRING, BOOLEAN),
|
||||
staticCall(JUNIT5_ASSUME_CLASSNAME, ASSUME_TRUE_METHOD).parameterTypes(BOOLEAN, JAVA_LANG_STRING),
|
||||
staticCall(JUNIT4_ASSUME_CLASSNAME, ASSUME_TRUE_METHOD).parameterTypes(BOOLEAN),
|
||||
staticCall(JUNIT5_ASSUME_CLASSNAME, ASSUME_TRUE_METHOD).parameterTypes(BOOLEAN),
|
||||
),
|
||||
MethodNames.IS_TRUE, hasExpected = false
|
||||
),
|
||||
Mapping(
|
||||
anyOf(
|
||||
staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_FALSE_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "boolean"),
|
||||
staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_FALSE_METHOD).parameterTypes("boolean")
|
||||
staticCall(JUNIT4_ASSUME_CLASSNAME, ASSUME_FALSE_METHOD).parameterTypes(JAVA_LANG_STRING, BOOLEAN),
|
||||
staticCall(JUNIT5_ASSUME_CLASSNAME, ASSUME_FALSE_METHOD).parameterTypes(BOOLEAN, JAVA_LANG_STRING),
|
||||
staticCall(JUNIT4_ASSUME_CLASSNAME, ASSUME_FALSE_METHOD).parameterTypes(BOOLEAN),
|
||||
staticCall(JUNIT5_ASSUME_CLASSNAME, ASSUME_FALSE_METHOD).parameterTypes(BOOLEAN),
|
||||
),
|
||||
MethodNames.IS_FALSE, hasExpected = false
|
||||
),
|
||||
Mapping(
|
||||
staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_NOT_NULL_METHOD).parameterCount(1),
|
||||
anyOf(
|
||||
staticCall(JUNIT4_ASSUME_CLASSNAME, ASSUME_NOT_NULL_METHOD).parameterCount(1),
|
||||
staticCall(JUNIT5_ASSUME_CLASSNAME, ASSUME_NOT_NULL_METHOD).parameterCount(1),
|
||||
),
|
||||
MethodNames.IS_NOT_NULL, hasExpected = false, singleArgument = true
|
||||
),
|
||||
Mapping(
|
||||
anyOf(
|
||||
staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_NO_EXCEPTION).parameterTypes(CommonClassNames.JAVA_LANG_STRING, CommonClassNames.JAVA_LANG_THROWABLE),
|
||||
staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_NO_EXCEPTION).parameterTypes(CommonClassNames.JAVA_LANG_THROWABLE)
|
||||
staticCall(JUNIT4_ASSUME_CLASSNAME, ASSUME_NO_EXCEPTION).parameterTypes(JAVA_LANG_STRING, JAVA_LANG_THROWABLE),
|
||||
staticCall(JUNIT5_ASSUME_CLASSNAME, ASSUME_NO_EXCEPTION).parameterTypes(JAVA_LANG_THROWABLE, JAVA_LANG_STRING),
|
||||
staticCall(JUNIT4_ASSUME_CLASSNAME, ASSUME_NO_EXCEPTION).parameterTypes(JAVA_LANG_THROWABLE),
|
||||
staticCall(JUNIT5_ASSUME_CLASSNAME, ASSUME_NO_EXCEPTION).parameterTypes(JAVA_LANG_THROWABLE),
|
||||
),
|
||||
"doesNotThrowAnyException", hasExpected = false
|
||||
)
|
||||
@ -149,33 +193,41 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
|
||||
override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
|
||||
super.visitMethodCallExpression(expression)
|
||||
when (expression.resolveMethod()?.containingClass?.qualifiedName) {
|
||||
JUNIT_ASSERT_CLASSNAME -> {
|
||||
JavaPsiFacade.getInstance(expression.project)
|
||||
.findClass(AssertJClassNames.ASSERTIONS_CLASSNAME, GlobalSearchScope.allScope(expression.project)) ?: return
|
||||
val mapping = ASSERT_MAPPINGS.firstOrNull { it.callMatcher.test(expression) } ?: return
|
||||
if (mapping.hasDelta) {
|
||||
registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSERT_THAT, ::ReplaceJUnitDeltaAssertMethodCallQuickFix)
|
||||
} else {
|
||||
registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSERT_THAT) { desc, method ->
|
||||
ReplaceJUnitAssertMethodCallQuickFix(desc, method, !mapping.hasExpected)
|
||||
}
|
||||
}
|
||||
}
|
||||
JUNIT_ASSUME_CLASSNAME -> {
|
||||
JavaPsiFacade.getInstance(expression.project)
|
||||
.findClass(AssertJClassNames.ASSUMPTIONS_CLASSNAME, GlobalSearchScope.allScope(expression.project)) ?: return
|
||||
val mapping = ASSUME_MAPPINGS.firstOrNull { it.callMatcher.test(expression) } ?: return
|
||||
if (!mapping.singleArgument || expression.argumentList.expressions.size == 1) {
|
||||
registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSUME_THAT) { desc, method ->
|
||||
ReplaceJUnitAssumeMethodCallQuickFix(desc, method)
|
||||
}
|
||||
}
|
||||
}
|
||||
JUNIT4_ASSERT_CLASSNAME -> visitMethodCallExpressionAssert(holder, expression, false)
|
||||
JUNIT5_ASSERT_CLASSNAME -> visitMethodCallExpressionAssert(holder, expression, true)
|
||||
JUNIT4_ASSUME_CLASSNAME -> visitMethodCallExpressionAssume(holder, expression, false)
|
||||
JUNIT5_ASSUME_CLASSNAME -> visitMethodCallExpressionAssume(holder, expression, true)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun visitMethodCallExpressionAssert(holder: ProblemsHolder, expression: PsiMethodCallExpression, junit5: Boolean) {
|
||||
JavaPsiFacade.getInstance(expression.project)
|
||||
.findClass(AssertJClassNames.ASSERTIONS_CLASSNAME, GlobalSearchScope.allScope(expression.project)) ?: return
|
||||
val mapping = ASSERT_MAPPINGS.firstOrNull { it.callMatcher.test(expression) } ?: return
|
||||
if (mapping.hasDelta) {
|
||||
registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSERT_THAT) { desc, method ->
|
||||
ReplaceJUnitDeltaAssertMethodCallQuickFix(desc, method, junit5)
|
||||
}
|
||||
} else {
|
||||
registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSERT_THAT) { desc, method ->
|
||||
ReplaceJUnitAssertMethodCallQuickFix(desc, method, !mapping.hasExpected, junit5)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun visitMethodCallExpressionAssume(holder: ProblemsHolder, expression: PsiMethodCallExpression, junit5: Boolean) {
|
||||
JavaPsiFacade.getInstance(expression.project)
|
||||
.findClass(AssertJClassNames.ASSUMPTIONS_CLASSNAME, GlobalSearchScope.allScope(expression.project)) ?: return
|
||||
val mapping = ASSUME_MAPPINGS.firstOrNull { it.callMatcher.test(expression) } ?: return
|
||||
if (!mapping.singleArgument || expression.argumentList.expressions.size == 1) {
|
||||
registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSUME_THAT) { desc, method ->
|
||||
ReplaceJUnitAssumeMethodCallQuickFix(desc, method, junit5)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun registerConvertMethod(
|
||||
holder: ProblemsHolder,
|
||||
expression: PsiMethodCallExpression,
|
||||
|
||||
@ -72,7 +72,7 @@ class JoinAssertThatStatementsInspection : AbstractAssertJInspection() {
|
||||
if (!statement.hasAssertThat()) return null
|
||||
|
||||
val assertThatCall = PsiTreeUtil.findChildrenOfType(statement, PsiMethodCallExpression::class.java).find { ALL_ASSERT_THAT_MATCHERS.test(it) }
|
||||
return assertThatCall?.takeIf { it.findFluentCallTo(COMPLEX_STUFF_THAT_MAKES_JOINING_IMPOSSIBLE) == null }
|
||||
return assertThatCall?.takeIf { it.findFluentCallTo(EXTRACTING_CALL_MATCHERS) == null }
|
||||
}
|
||||
return null
|
||||
}
|
||||
@ -83,7 +83,6 @@ class JoinAssertThatStatementsInspection : AbstractAssertJInspection() {
|
||||
val matched = when (element) {
|
||||
is PsiUnaryExpression -> (element.operationTokenType == JavaTokenType.PLUSPLUS)
|
||||
|| (element.operationTokenType == JavaTokenType.MINUSMINUS)
|
||||
|
||||
is PsiMethodCallExpression -> KNOWN_METHODS_WITH_SIDE_EFFECTS.test(element)
|
||||
else -> false
|
||||
}
|
||||
|
||||
@ -56,8 +56,9 @@ class JoinStatementsQuickFix(private val separateLineLimit: Int) : AbstractCommo
|
||||
}
|
||||
|
||||
private fun addLineBreak(project: Project, lastElementBeforeConcat: PsiElement) {
|
||||
// was PsiParserFacade.getInstance(project).createWhiteSpaceFromText("\n\t"), changed due to breaking API changes
|
||||
val newLineNode = project.getService(PsiParserFacade::class.java).createWhiteSpaceFromText("\n\t")
|
||||
val newLineNode =
|
||||
PsiParserFacade.SERVICE.getInstance(project).createWhiteSpaceFromText("\n\t")
|
||||
|
||||
lastElementBeforeConcat.addAfter(newLineNode, lastElementBeforeConcat.firstChild)
|
||||
}
|
||||
|
||||
|
||||
@ -7,7 +7,7 @@ import com.intellij.psi.PsiMethodCallExpression
|
||||
import de.platon42.intellij.plugins.cajon.*
|
||||
import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.GUAVA_ASSERTIONS_CLASSNAME
|
||||
|
||||
class ReplaceJUnitAssertMethodCallQuickFix(description: String, private val replacementMethod: String, private val noExpectedExpression: Boolean) :
|
||||
class ReplaceJUnitAssertMethodCallQuickFix(description: String, private val replacementMethod: String, private val noExpectedExpression: Boolean, private val junit5: Boolean) :
|
||||
AbstractCommonQuickFix(description) {
|
||||
|
||||
companion object {
|
||||
@ -23,14 +23,20 @@ class ReplaceJUnitAssertMethodCallQuickFix(description: String, private val repl
|
||||
val methodCallExpression = element as? PsiMethodCallExpression ?: return
|
||||
val args = methodCallExpression.argumentList
|
||||
val count = args.expressions.size
|
||||
val actualExpression = args.expressions[count - 1] ?: return
|
||||
val (expectedExpressions, messageExpression) = if (noExpectedExpression) {
|
||||
val message = args.expressions.getOrNull(count - 2)
|
||||
emptyArray<PsiExpression>() to message
|
||||
val hasMessage = if (noExpectedExpression) count == 1 else count == 2;
|
||||
|
||||
val actualExpression: PsiExpression
|
||||
val expectedExpressions: Array<PsiExpression>
|
||||
val messageExpression: PsiExpression?
|
||||
|
||||
if (junit5) {
|
||||
actualExpression = args.expressions[if (noExpectedExpression) 0 else 1] ?: return
|
||||
messageExpression = if (hasMessage) null else args.expressions[count - 1]
|
||||
expectedExpressions = if (noExpectedExpression) emptyArray() else arrayOf(args.expressions[0])
|
||||
} else {
|
||||
val expected = args.expressions[count - 2] ?: return
|
||||
val message = args.expressions.getOrNull(count - 3)
|
||||
arrayOf(expected) to message
|
||||
actualExpression = args.expressions[count - 1] ?: return
|
||||
messageExpression = if (hasMessage) null else args.expressions[0]
|
||||
expectedExpressions = if (noExpectedExpression) emptyArray() else arrayOf(args.expressions[count - 2])
|
||||
}
|
||||
|
||||
val swapActualAndExpected = ((expectedExpressions.getOrNull(0)?.calculateConstantValue() == null)
|
||||
|
||||
@ -5,7 +5,7 @@ import com.intellij.openapi.project.Project
|
||||
import com.intellij.psi.PsiMethodCallExpression
|
||||
import de.platon42.intellij.plugins.cajon.*
|
||||
|
||||
class ReplaceJUnitAssumeMethodCallQuickFix(description: String, private val replacementMethod: String) :
|
||||
class ReplaceJUnitAssumeMethodCallQuickFix(description: String, private val replacementMethod: String, private val junit5: Boolean) :
|
||||
AbstractCommonQuickFix(description) {
|
||||
|
||||
companion object {
|
||||
@ -21,8 +21,8 @@ class ReplaceJUnitAssumeMethodCallQuickFix(description: String, private val repl
|
||||
val methodCallExpression = element as? PsiMethodCallExpression ?: return
|
||||
val args = methodCallExpression.argumentList
|
||||
val count = args.expressions.size
|
||||
val actualExpression = args.expressions[count - 1] ?: return
|
||||
val messageExpression = args.expressions.getOrNull(count - 2)
|
||||
val actualExpression = args.expressions[if (junit5) 0 else count - 1] ?: return
|
||||
val messageExpression = args.expressions.getOrNull(if (junit5) 1 else count - 2)
|
||||
|
||||
val expectedMethodCall = createExpectedMethodCall(element, replacementMethod)
|
||||
val newMethodCall = createAssumeThat(element, actualExpression)
|
||||
|
||||
@ -6,7 +6,7 @@ import com.intellij.psi.PsiMethodCallExpression
|
||||
import de.platon42.intellij.plugins.cajon.*
|
||||
import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.GUAVA_ASSERTIONS_CLASSNAME
|
||||
|
||||
class ReplaceJUnitDeltaAssertMethodCallQuickFix(description: String, private val replacementMethod: String) : AbstractCommonQuickFix(description) {
|
||||
class ReplaceJUnitDeltaAssertMethodCallQuickFix(description: String, private val replacementMethod: String, private val junit5: Boolean) : AbstractCommonQuickFix(description) {
|
||||
|
||||
companion object {
|
||||
private const val CONVERT_DESCRIPTION = "Convert JUnit assertions with delta to assertJ"
|
||||
@ -21,10 +21,10 @@ class ReplaceJUnitDeltaAssertMethodCallQuickFix(description: String, private val
|
||||
val methodCallExpression = element as? PsiMethodCallExpression ?: return
|
||||
val args = methodCallExpression.argumentList
|
||||
val count = args.expressions.size
|
||||
val messageExpression = args.expressions.getOrNull(count - 4)
|
||||
val expectedExpression = args.expressions[count - 3] ?: return
|
||||
val actualExpression = args.expressions[count - 2] ?: return
|
||||
val deltaExpression = args.expressions[count - 1] ?: return
|
||||
val messageExpression = args.expressions.getOrNull(if (junit5) 3 else count - 4)
|
||||
val expectedExpression = args.expressions[if (junit5) 0 else count - 3] ?: return
|
||||
val actualExpression = args.expressions[if (junit5) 1 else count - 2] ?: return
|
||||
val deltaExpression = args.expressions[if (junit5) 2 else count - 1] ?: return
|
||||
|
||||
val offsetMethodCall = createMethodCall(element, "org.assertj.core.data.Offset.offset", deltaExpression)
|
||||
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
<idea-plugin>
|
||||
<id>de.platon42.cajon</id>
|
||||
<name>Concise AssertJ Optimizing Nitpicker (Cajon)</name>
|
||||
<vendor email="chrisly@platon42.de" url="https://git.platon42.de/chrisly42/cajon-plugin">Chris 'platon42' Hodges</vendor>
|
||||
<vendor email="chrisly@platon42.de" url="https://github.com/chrisly42/cajon-plugin">Chris 'platon42' Hodges</vendor>
|
||||
|
||||
<description><![CDATA[
|
||||
Cajon is an IntelliJ IDEA Plugin for shortening and optimizing AssertJ assertions.
|
||||
@ -14,6 +14,8 @@
|
||||
<a href="https://github.com/chrisly42/cajon-plugin/blob/master/README.md">Full documentation here...</a>
|
||||
]]></description>
|
||||
|
||||
<idea-version since-build="173.2696.26"/>
|
||||
|
||||
<depends>com.intellij.modules.lang</depends>
|
||||
<depends>com.intellij.modules.platform</depends>
|
||||
<depends>com.intellij.modules.java</depends>
|
||||
@ -26,8 +28,6 @@
|
||||
implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatBooleanConditionInspection"/>
|
||||
<localInspection groupPath="Java" shortName="AssertThatInvertedBooleanCondition" enabledByDefault="true" level="WARNING"
|
||||
implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatInvertedBooleanConditionInspection"/>
|
||||
<localInspection groupPath="Java" shortName="AssertThatIsZeroOne" enabledByDefault="true" level="WARNING"
|
||||
implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatIsZeroOneInspection"/>
|
||||
<localInspection groupPath="Java" shortName="AssertThatInstanceOf" enabledByDefault="true" level="WARNING"
|
||||
implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatInstanceOfInspection"/>
|
||||
<localInspection groupPath="Java" shortName="AssertThatStringIsEmpty" enabledByDefault="true" level="WARNING"
|
||||
@ -79,4 +79,4 @@
|
||||
|
||||
<actions>
|
||||
</actions>
|
||||
</idea-plugin>
|
||||
</idea-plugin>
|
||||
@ -1,8 +0,0 @@
|
||||
<html>
|
||||
<body>
|
||||
Turns assertThat(numeric).isEqualTo(0/1) into assertThat(numeric).isZero()/isOne()
|
||||
or assertThat(numeric).isNotEqualTo(0) into assertThat(numeric).isNotZero().
|
||||
<!-- tooltip end -->
|
||||
<br>Also works with constant expressions.
|
||||
</body>
|
||||
</html>
|
||||
@ -1,151 +0,0 @@
|
||||
package de.platon42.intellij.jupiter
|
||||
|
||||
import com.intellij.jarRepository.JarRepositoryManager
|
||||
import com.intellij.jarRepository.RemoteRepositoryDescription
|
||||
import com.intellij.openapi.module.Module
|
||||
import com.intellij.openapi.roots.ContentEntry
|
||||
import com.intellij.openapi.roots.DependencyScope
|
||||
import com.intellij.openapi.roots.ModifiableRootModel
|
||||
import com.intellij.openapi.vfs.LocalFileSystem
|
||||
import com.intellij.testFramework.IdeaTestUtil
|
||||
import com.intellij.testFramework.LightProjectDescriptor
|
||||
import com.intellij.testFramework.PlatformTestUtil
|
||||
import com.intellij.testFramework.PsiTestUtil
|
||||
import com.intellij.testFramework.fixtures.DefaultLightProjectDescriptor
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import com.intellij.testFramework.fixtures.LightJavaCodeInsightFixtureTestCase
|
||||
import com.intellij.testFramework.rules.TestNameExtension
|
||||
import org.jetbrains.idea.maven.utils.library.RepositoryLibraryProperties
|
||||
import org.junit.jupiter.api.extension.AfterEachCallback
|
||||
import org.junit.jupiter.api.extension.BeforeEachCallback
|
||||
import org.junit.jupiter.api.extension.ExtensionContext
|
||||
import org.junit.jupiter.api.extension.RegisterExtension
|
||||
import java.nio.file.Paths
|
||||
import java.util.*
|
||||
import java.util.function.Consumer
|
||||
import java.util.stream.Collectors
|
||||
import java.util.stream.Stream
|
||||
|
||||
|
||||
abstract class AbstractJUnit5TestCase {
|
||||
|
||||
@RegisterExtension
|
||||
protected val testNameRule = TestNameExtension()
|
||||
|
||||
@RegisterExtension
|
||||
protected val edtInterceptorExtension = EdtInterceptorExtension()
|
||||
|
||||
protected fun getTestName(lowercaseFirstLetter: Boolean): String {
|
||||
return PlatformTestUtil.getTestName(testNameRule.methodName, lowercaseFirstLetter)
|
||||
}
|
||||
|
||||
@RegisterExtension
|
||||
private val testCase = object : LightJavaCodeInsightFixtureTestCase(), BeforeEachCallback, AfterEachCallback {
|
||||
|
||||
lateinit var extensionContext: ExtensionContext
|
||||
|
||||
override fun getProjectDescriptor(): LightProjectDescriptor {
|
||||
val testJdk = getMethodOrClassAnnotation(TestJdk::class.java) ?: return super.getProjectDescriptor()
|
||||
val projectDescriptor: DefaultLightProjectDescriptor = object : DefaultLightProjectDescriptor({ IdeaTestUtil.getMockJdk(testJdk.value.toJavaVersion()) }) {
|
||||
override fun configureModule(module: Module, model: ModifiableRootModel, contentEntry: ContentEntry) {
|
||||
super.configureModule(module, model, contentEntry)
|
||||
val localJars = getMethodOrClassAnnotation(AddLocalJarToModule::class.java)
|
||||
if (localJars != null) {
|
||||
localJars.value.forEach {
|
||||
addJarContaining(
|
||||
model,
|
||||
it.java
|
||||
)
|
||||
}
|
||||
}
|
||||
val mavenDependencies = getMethodOrClassAnnotations(AddMavenDependencyToModule::class.java)
|
||||
mavenDependencies.forEach(Consumer { it: AddMavenDependencyToModule ->
|
||||
addFromMaven(
|
||||
model,
|
||||
it.value,
|
||||
it.includeTransitiveDependencies,
|
||||
it.scope
|
||||
)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
return projectDescriptor
|
||||
}
|
||||
|
||||
fun addJarContaining(model: ModifiableRootModel?, clazz: Class<*>) {
|
||||
val filename = clazz.getResource(clazz.simpleName + ".class").file
|
||||
val jarName = filename.substring(0, filename.indexOf(".jar") + 4).removePrefix("file:")
|
||||
val jarPath = Paths.get(jarName)
|
||||
|
||||
val jarFile = LocalFileSystem.getInstance().refreshAndFindFileByPath(jarName)
|
||||
myFixture.allowTreeAccessForFile(jarFile!!)
|
||||
PsiTestUtil.addLibrary(
|
||||
model!!,
|
||||
jarPath.fileName.toString().replace(".jar", ""),
|
||||
jarPath.parent.toString(),
|
||||
jarPath.fileName.toString()
|
||||
)
|
||||
}
|
||||
|
||||
fun addFromMaven(
|
||||
model: ModifiableRootModel, mavenCoordinates: String,
|
||||
includeTransitiveDependencies: Boolean, dependencyScope: DependencyScope?
|
||||
) {
|
||||
val remoteRepositoryDescriptions = RemoteRepositoryDescription.DEFAULT_REPOSITORIES
|
||||
val libraryProperties = RepositoryLibraryProperties(mavenCoordinates, includeTransitiveDependencies)
|
||||
val roots =
|
||||
JarRepositoryManager.loadDependenciesModal(model.project, libraryProperties, false, false, null, remoteRepositoryDescriptions)
|
||||
val tableModel = model.moduleLibraryTable.modifiableModel
|
||||
val library = tableModel.createLibrary(mavenCoordinates)
|
||||
val libraryModel = library.modifiableModel
|
||||
check(!roots.isEmpty()) { String.format("No roots for '%s'", mavenCoordinates) }
|
||||
|
||||
for (root in roots) {
|
||||
libraryModel.addRoot(root.file, root.type)
|
||||
}
|
||||
|
||||
val libraryOrderEntry = model.findLibraryOrderEntry(library) ?: throw java.lang.IllegalStateException("Unable to find registered library $mavenCoordinates")
|
||||
libraryOrderEntry.scope = dependencyScope!!
|
||||
|
||||
libraryModel.commit()
|
||||
tableModel.commit()
|
||||
}
|
||||
|
||||
override fun getTestDataPath(): String {
|
||||
val testDataPath = getMethodOrClassAnnotation(TestDataPath::class.java) ?: return super.getTestDataPath()
|
||||
val testDataSubPath = getMethodOrClassAnnotation(TestDataSubPath::class.java) ?: return testDataPath.value
|
||||
return Paths.get(testDataPath.value, testDataSubPath.value).toString()
|
||||
}
|
||||
|
||||
fun getMyFixture(): JavaCodeInsightTestFixture = myFixture
|
||||
|
||||
private fun <T : Annotation?> getMethodOrClassAnnotation(clazz: Class<T>): T? {
|
||||
var annotation = extensionContext.requiredTestMethod.getAnnotation(clazz)
|
||||
if (annotation == null) {
|
||||
annotation = extensionContext.requiredTestClass.getAnnotation(clazz)
|
||||
}
|
||||
return annotation
|
||||
}
|
||||
|
||||
private fun <T : Annotation?> getMethodOrClassAnnotations(clazz: Class<T>): List<T> {
|
||||
return Stream.of(
|
||||
extensionContext.requiredTestMethod.getAnnotationsByType(clazz),
|
||||
extensionContext.requiredTestClass.getAnnotationsByType(clazz)
|
||||
)
|
||||
.flatMap { array: Array<T>? -> Arrays.stream(array) }
|
||||
.collect(Collectors.toList())
|
||||
}
|
||||
|
||||
override fun beforeEach(context: ExtensionContext) {
|
||||
extensionContext = context
|
||||
setUp()
|
||||
}
|
||||
|
||||
override fun afterEach(context: ExtensionContext) {
|
||||
tearDown()
|
||||
}
|
||||
}
|
||||
|
||||
protected val fixture: JavaCodeInsightTestFixture get() = testCase.getMyFixture()
|
||||
}
|
||||
@ -0,0 +1,10 @@
|
||||
package de.platon42.intellij.jupiter;
|
||||
|
||||
import java.lang.annotation.*;
|
||||
|
||||
@Target({ElementType.TYPE, ElementType.METHOD})
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
@Inherited
|
||||
public @interface AddLocalJarToModule {
|
||||
Class<?>[] value();
|
||||
}
|
||||
@ -1,9 +0,0 @@
|
||||
package de.platon42.intellij.jupiter
|
||||
|
||||
import java.lang.annotation.Inherited
|
||||
import kotlin.reflect.KClass
|
||||
|
||||
@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
|
||||
@Retention(AnnotationRetention.RUNTIME)
|
||||
@Inherited
|
||||
annotation class AddLocalJarToModule(vararg val value: KClass<*>)
|
||||
@ -0,0 +1,24 @@
|
||||
package de.platon42.intellij.jupiter;
|
||||
|
||||
import com.intellij.openapi.roots.DependencyScope;
|
||||
|
||||
import java.lang.annotation.*;
|
||||
|
||||
@Target({ElementType.TYPE, ElementType.METHOD})
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
@Inherited
|
||||
@Repeatable(AddMavenDependencyToModule.List.class)
|
||||
public @interface AddMavenDependencyToModule {
|
||||
String value();
|
||||
|
||||
boolean includeTransitiveDependencies = false;
|
||||
|
||||
DependencyScope scope = DependencyScope.COMPILE;
|
||||
|
||||
@Target({ElementType.TYPE, ElementType.METHOD})
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
@Inherited
|
||||
@interface List {
|
||||
AddMavenDependencyToModule[] value();
|
||||
}
|
||||
}
|
||||
@ -1,17 +0,0 @@
|
||||
package de.platon42.intellij.jupiter
|
||||
|
||||
import com.intellij.openapi.roots.DependencyScope
|
||||
import java.lang.annotation.Inherited
|
||||
|
||||
@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
|
||||
@Retention(AnnotationRetention.RUNTIME)
|
||||
@Inherited
|
||||
@JvmRepeatable(
|
||||
AddMavenDependencyToModule.List::class
|
||||
)
|
||||
annotation class AddMavenDependencyToModule(val value: String, val includeTransitiveDependencies: Boolean = false, val scope: DependencyScope = DependencyScope.COMPILE) {
|
||||
@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
|
||||
@Retention(AnnotationRetention.RUNTIME)
|
||||
@Inherited
|
||||
annotation class List(vararg val value: AddMavenDependencyToModule)
|
||||
}
|
||||
@ -1,50 +0,0 @@
|
||||
package de.platon42.intellij.jupiter
|
||||
|
||||
import com.intellij.testFramework.TestLoggerFactory
|
||||
import com.intellij.testFramework.fixtures.IdeaTestExecutionPolicy
|
||||
import com.intellij.testFramework.runInEdtAndWait
|
||||
import org.junit.jupiter.api.extension.ExtensionContext
|
||||
import org.junit.jupiter.api.extension.InvocationInterceptor
|
||||
import org.junit.jupiter.api.extension.ReflectiveInvocationContext
|
||||
import java.lang.reflect.Method
|
||||
|
||||
class EdtInterceptorExtension : InvocationInterceptor {
|
||||
|
||||
override fun interceptTestMethod(
|
||||
invocation: InvocationInterceptor.Invocation<Void>,
|
||||
invocationContext: ReflectiveInvocationContext<Method>,
|
||||
extensionContext: ExtensionContext
|
||||
) {
|
||||
val throwables = arrayOfNulls<Throwable>(1)
|
||||
|
||||
val runnable = Runnable {
|
||||
try {
|
||||
TestLoggerFactory.onTestStarted()
|
||||
invocation.proceed()
|
||||
TestLoggerFactory.onTestFinished(true, extensionContext.displayName)
|
||||
} catch (e: Throwable) {
|
||||
TestLoggerFactory.onTestFinished(false, extensionContext.displayName)
|
||||
throwables[0] = e
|
||||
}
|
||||
}
|
||||
|
||||
invokeTestRunnable(runnable)
|
||||
|
||||
if (throwables[0] != null) {
|
||||
throw throwables[0]!!
|
||||
}
|
||||
}
|
||||
|
||||
companion object {
|
||||
private fun invokeTestRunnable(runnable: Runnable) {
|
||||
val policy = IdeaTestExecutionPolicy.current()
|
||||
if (policy != null && !policy.runInDispatchThread()) {
|
||||
runnable.run()
|
||||
} else {
|
||||
runInEdtAndWait {
|
||||
runnable.run()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,259 @@
|
||||
package de.platon42.intellij.jupiter;
|
||||
|
||||
import com.intellij.jarRepository.JarRepositoryManager;
|
||||
import com.intellij.jarRepository.RemoteRepositoryDescription;
|
||||
import com.intellij.openapi.Disposable;
|
||||
import com.intellij.openapi.module.Module;
|
||||
import com.intellij.openapi.projectRoots.Sdk;
|
||||
import com.intellij.openapi.projectRoots.impl.JavaAwareProjectJdkTableImpl;
|
||||
import com.intellij.openapi.roots.ContentEntry;
|
||||
import com.intellij.openapi.roots.DependencyScope;
|
||||
import com.intellij.openapi.roots.LibraryOrderEntry;
|
||||
import com.intellij.openapi.roots.ModifiableRootModel;
|
||||
import com.intellij.openapi.roots.libraries.Library;
|
||||
import com.intellij.openapi.roots.libraries.LibraryTable;
|
||||
import com.intellij.openapi.roots.libraries.ui.OrderRoot;
|
||||
import com.intellij.openapi.util.Disposer;
|
||||
import com.intellij.openapi.vfs.LocalFileSystem;
|
||||
import com.intellij.openapi.vfs.VirtualFile;
|
||||
import com.intellij.testFramework.EdtTestUtilKt;
|
||||
import com.intellij.testFramework.LightProjectDescriptor;
|
||||
import com.intellij.testFramework.PsiTestUtil;
|
||||
import com.intellij.testFramework.TestLoggerFactory;
|
||||
import com.intellij.testFramework.fixtures.IdeaTestExecutionPolicy;
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture;
|
||||
import com.intellij.testFramework.fixtures.LightJavaCodeInsightFixtureTestCase;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.idea.maven.utils.library.RepositoryLibraryProperties;
|
||||
import org.junit.jupiter.api.extension.*;
|
||||
import org.junit.jupiter.api.extension.ExtensionContext.Namespace;
|
||||
import org.junit.jupiter.api.extension.ExtensionContext.Store;
|
||||
|
||||
import java.lang.annotation.Annotation;
|
||||
import java.lang.reflect.Method;
|
||||
import java.lang.reflect.Parameter;
|
||||
import java.net.URISyntaxException;
|
||||
import java.nio.file.Path;
|
||||
import java.nio.file.Paths;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collection;
|
||||
import java.util.List;
|
||||
import java.util.logging.Logger;
|
||||
import java.util.stream.Collectors;
|
||||
import java.util.stream.Stream;
|
||||
|
||||
public class LightCodeInsightExtension implements ParameterResolver, AfterTestExecutionCallback, InvocationInterceptor {
|
||||
|
||||
private static final Logger LOG = Logger.getLogger(LightCodeInsightExtension.class.getName());
|
||||
|
||||
@Override
|
||||
public boolean supportsParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException {
|
||||
Parameter parameter = parameterContext.getParameter();
|
||||
return parameter.isAnnotationPresent(MyFixture.class)
|
||||
|| parameter.isAnnotationPresent(MyTestCase.class);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException {
|
||||
LightCodeInsightFixtureTestCaseWrapper testCase = getWrapper(extensionContext);
|
||||
Parameter parameter = parameterContext.getParameter();
|
||||
if (parameter.isAnnotationPresent(MyFixture.class)) {
|
||||
return testCase.getMyFixture();
|
||||
} else if (parameter.isAnnotationPresent(MyTestCase.class)) {
|
||||
return testCase;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private LightCodeInsightFixtureTestCaseWrapper getWrapper(ExtensionContext extensionContext) {
|
||||
Store store = getStore(extensionContext);
|
||||
return (LightCodeInsightFixtureTestCaseWrapper) store.getOrComputeIfAbsent("testCase",
|
||||
key -> {
|
||||
LightCodeInsightFixtureTestCaseWrapper wrapper = new LightCodeInsightFixtureTestCaseWrapper(extensionContext);
|
||||
try {
|
||||
wrapper.setUp();
|
||||
} catch (Exception e) {
|
||||
LOG.severe("Exception during setUp(): " + e);
|
||||
throw new IllegalStateException("Exception during setUp()", e);
|
||||
}
|
||||
return wrapper;
|
||||
});
|
||||
}
|
||||
|
||||
@Override
|
||||
public void afterTestExecution(ExtensionContext context) throws Exception {
|
||||
Store store = getStore(context);
|
||||
LightCodeInsightFixtureTestCaseWrapper testCase = (LightCodeInsightFixtureTestCaseWrapper) store.get("testCase");
|
||||
if (testCase != null) {
|
||||
testCase.tearDown();
|
||||
}
|
||||
}
|
||||
|
||||
private static Store getStore(ExtensionContext context) {
|
||||
return context.getStore(Namespace.create(LightCodeInsightExtension.class, context.getRequiredTestMethod()));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void interceptTestMethod(Invocation<Void> invocation, ReflectiveInvocationContext<Method> invocationContext, ExtensionContext extensionContext) throws Throwable {
|
||||
Throwable[] throwables = new Throwable[1];
|
||||
|
||||
Runnable runnable = () -> {
|
||||
try {
|
||||
TestLoggerFactory.onTestStarted();
|
||||
invocation.proceed();
|
||||
TestLoggerFactory.onTestFinished(true);
|
||||
} catch (Throwable e) {
|
||||
TestLoggerFactory.onTestFinished(false);
|
||||
throwables[0] = e;
|
||||
}
|
||||
};
|
||||
|
||||
invokeTestRunnable(runnable);
|
||||
|
||||
if (throwables[0] != null) {
|
||||
throw throwables[0];
|
||||
}
|
||||
}
|
||||
|
||||
private static void invokeTestRunnable(@NotNull Runnable runnable) {
|
||||
IdeaTestExecutionPolicy policy = IdeaTestExecutionPolicy.current();
|
||||
if (policy != null && !policy.runInDispatchThread()) {
|
||||
runnable.run();
|
||||
} else {
|
||||
EdtTestUtilKt.runInEdtAndWait(() -> {
|
||||
runnable.run();
|
||||
return null;
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
private static class LightCodeInsightFixtureTestCaseWrapper extends LightJavaCodeInsightFixtureTestCase {
|
||||
private final ExtensionContext extensionContext;
|
||||
|
||||
private LightCodeInsightFixtureTestCaseWrapper(ExtensionContext extensionContext) {
|
||||
this.extensionContext = extensionContext;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setUp() throws Exception {
|
||||
super.setUp();
|
||||
Store store = getStore(extensionContext);
|
||||
store.put("disposable", Disposer.newDisposable("LightCodeInsightFixtureTestCaseWrapper"));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void tearDown() throws Exception {
|
||||
Store store = getStore(extensionContext);
|
||||
Disposable disposable = (Disposable) store.get("disposable");
|
||||
if (myFixture != null && disposable != null) {
|
||||
Disposer.dispose(disposable);
|
||||
store.remove("disposable");
|
||||
}
|
||||
super.tearDown();
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
protected LightProjectDescriptor getProjectDescriptor() {
|
||||
TestJdk testJdk = getMethodOrClassAnnotation(TestJdk.class);
|
||||
if (testJdk == null) {
|
||||
return super.getProjectDescriptor();
|
||||
}
|
||||
return new ProjectDescriptor(testJdk.value(), testJdk.annotations()) {
|
||||
@Override
|
||||
public Sdk getSdk() {
|
||||
return testJdk.useInternal()
|
||||
? JavaAwareProjectJdkTableImpl.getInstanceEx().getInternalJdk()
|
||||
: super.getSdk();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void configureModule(@NotNull Module module, @NotNull ModifiableRootModel model, @NotNull ContentEntry contentEntry) {
|
||||
super.configureModule(module, model, contentEntry);
|
||||
AddLocalJarToModule localJars = getMethodOrClassAnnotation(AddLocalJarToModule.class);
|
||||
if (localJars != null) {
|
||||
Stream.of(localJars.value()).forEach(it -> addJarContaining(model, it));
|
||||
}
|
||||
List<AddMavenDependencyToModule> mavenDependencies = getMethodOrClassAnnotations(AddMavenDependencyToModule.class);
|
||||
mavenDependencies.forEach(it -> addFromMaven(model, it.value(), it.includeTransitiveDependencies, it.scope));
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
void addJarContaining(ModifiableRootModel model, Class<?> clazz) {
|
||||
try {
|
||||
Path jarPath = Paths.get(clazz.getProtectionDomain().getCodeSource().getLocation().toURI());
|
||||
|
||||
VirtualFile jarFile = LocalFileSystem.getInstance().findFileByIoFile(jarPath.toFile());
|
||||
myFixture.allowTreeAccessForFile(jarFile);
|
||||
PsiTestUtil.addLibrary(
|
||||
model,
|
||||
jarPath.getFileName().toString().replace(".jar", ""),
|
||||
jarPath.getParent().toString(),
|
||||
jarPath.getFileName().toString()
|
||||
);
|
||||
} catch (URISyntaxException e) {
|
||||
throw new IllegalArgumentException("Class URL malformed", e);
|
||||
}
|
||||
}
|
||||
|
||||
void addFromMaven(ModifiableRootModel model, String mavenCoordinates,
|
||||
boolean includeTransitiveDependencies, DependencyScope dependencyScope) {
|
||||
List<RemoteRepositoryDescription> remoteRepositoryDescriptions = RemoteRepositoryDescription.DEFAULT_REPOSITORIES;
|
||||
RepositoryLibraryProperties libraryProperties = new RepositoryLibraryProperties(mavenCoordinates, includeTransitiveDependencies);
|
||||
Collection<OrderRoot> roots =
|
||||
JarRepositoryManager.loadDependenciesModal(model.getProject(), libraryProperties, false, false, null, remoteRepositoryDescriptions);
|
||||
LibraryTable.ModifiableModel tableModel = model.getModuleLibraryTable().getModifiableModel();
|
||||
Library library = tableModel.createLibrary(mavenCoordinates);
|
||||
Library.ModifiableModel libraryModel = library.getModifiableModel();
|
||||
if (roots.isEmpty()) {
|
||||
throw new IllegalStateException(String.format("No roots for '%s'", mavenCoordinates));
|
||||
}
|
||||
|
||||
for (OrderRoot root : roots) {
|
||||
libraryModel.addRoot(root.getFile(), root.getType());
|
||||
}
|
||||
|
||||
LibraryOrderEntry libraryOrderEntry = model.findLibraryOrderEntry(library);
|
||||
if (libraryOrderEntry == null) {
|
||||
throw new IllegalStateException("Unable to find registered library " + mavenCoordinates);
|
||||
}
|
||||
libraryOrderEntry.setScope(dependencyScope);
|
||||
|
||||
libraryModel.commit();
|
||||
tableModel.commit();
|
||||
}
|
||||
|
||||
@Override
|
||||
protected String getTestDataPath() {
|
||||
TestDataPath testDataPath = getMethodOrClassAnnotation(TestDataPath.class);
|
||||
if (testDataPath == null) {
|
||||
return super.getTestDataPath();
|
||||
}
|
||||
TestDataSubPath testDataSubPath = getMethodOrClassAnnotation(TestDataSubPath.class);
|
||||
if (testDataSubPath == null) {
|
||||
return testDataPath.value();
|
||||
}
|
||||
return Paths.get(testDataPath.value(), testDataSubPath.value()).toString();
|
||||
}
|
||||
|
||||
public JavaCodeInsightTestFixture getMyFixture() {
|
||||
return myFixture;
|
||||
}
|
||||
|
||||
private <T extends Annotation> T getMethodOrClassAnnotation(Class<T> clazz) {
|
||||
T annotation = extensionContext.getRequiredTestMethod().getAnnotation(clazz);
|
||||
if (annotation == null) {
|
||||
annotation = extensionContext.getRequiredTestClass().getAnnotation(clazz);
|
||||
}
|
||||
return annotation;
|
||||
}
|
||||
|
||||
private <T extends Annotation> List<T> getMethodOrClassAnnotations(Class<T> clazz) {
|
||||
return Stream.of(extensionContext.getRequiredTestMethod().getAnnotationsByType(clazz),
|
||||
extensionContext.getRequiredTestClass().getAnnotationsByType(clazz))
|
||||
.flatMap(Arrays::stream)
|
||||
.collect(Collectors.toList());
|
||||
}
|
||||
}
|
||||
}
|
||||
11
src/test/java/de/platon42/intellij/jupiter/MyFixture.java
Normal file
11
src/test/java/de/platon42/intellij/jupiter/MyFixture.java
Normal file
@ -0,0 +1,11 @@
|
||||
package de.platon42.intellij.jupiter;
|
||||
|
||||
import java.lang.annotation.ElementType;
|
||||
import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.RetentionPolicy;
|
||||
import java.lang.annotation.Target;
|
||||
|
||||
@Target(ElementType.PARAMETER)
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
public @interface MyFixture {
|
||||
}
|
||||
11
src/test/java/de/platon42/intellij/jupiter/MyTestCase.java
Normal file
11
src/test/java/de/platon42/intellij/jupiter/MyTestCase.java
Normal file
@ -0,0 +1,11 @@
|
||||
package de.platon42.intellij.jupiter;
|
||||
|
||||
import java.lang.annotation.ElementType;
|
||||
import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.RetentionPolicy;
|
||||
import java.lang.annotation.Target;
|
||||
|
||||
@Target(ElementType.PARAMETER)
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
public @interface MyTestCase {
|
||||
}
|
||||
10
src/test/java/de/platon42/intellij/jupiter/TestDataPath.java
Normal file
10
src/test/java/de/platon42/intellij/jupiter/TestDataPath.java
Normal file
@ -0,0 +1,10 @@
|
||||
package de.platon42.intellij.jupiter;
|
||||
|
||||
import java.lang.annotation.*;
|
||||
|
||||
@Target({ElementType.TYPE, ElementType.METHOD})
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
@Inherited
|
||||
public @interface TestDataPath {
|
||||
String value();
|
||||
}
|
||||
@ -1,8 +0,0 @@
|
||||
package de.platon42.intellij.jupiter
|
||||
|
||||
import java.lang.annotation.Inherited
|
||||
|
||||
@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
|
||||
@Retention(AnnotationRetention.RUNTIME)
|
||||
@Inherited
|
||||
annotation class TestDataPath(val value: String)
|
||||
@ -0,0 +1,10 @@
|
||||
package de.platon42.intellij.jupiter;
|
||||
|
||||
import java.lang.annotation.*;
|
||||
|
||||
@Target({ElementType.TYPE, ElementType.METHOD})
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
@Inherited
|
||||
public @interface TestDataSubPath {
|
||||
String value();
|
||||
}
|
||||
@ -1,8 +0,0 @@
|
||||
package de.platon42.intellij.jupiter
|
||||
|
||||
import java.lang.annotation.Inherited
|
||||
|
||||
@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
|
||||
@Retention(AnnotationRetention.RUNTIME)
|
||||
@Inherited
|
||||
annotation class TestDataSubPath(val value: String)
|
||||
16
src/test/java/de/platon42/intellij/jupiter/TestJdk.java
Normal file
16
src/test/java/de/platon42/intellij/jupiter/TestJdk.java
Normal file
@ -0,0 +1,16 @@
|
||||
package de.platon42.intellij.jupiter;
|
||||
|
||||
import com.intellij.pom.java.LanguageLevel;
|
||||
|
||||
import java.lang.annotation.*;
|
||||
|
||||
@Target({ElementType.TYPE, ElementType.METHOD})
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
@Inherited
|
||||
public @interface TestJdk {
|
||||
LanguageLevel value();
|
||||
|
||||
boolean annotations() default false;
|
||||
|
||||
boolean useInternal() default false;
|
||||
}
|
||||
@ -1,9 +0,0 @@
|
||||
package de.platon42.intellij.jupiter
|
||||
|
||||
import com.intellij.pom.java.LanguageLevel
|
||||
import java.lang.annotation.Inherited
|
||||
|
||||
@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
|
||||
@Retention(AnnotationRetention.RUNTIME)
|
||||
@Inherited
|
||||
annotation class TestJdk(val value: LanguageLevel)
|
||||
@ -2,45 +2,48 @@ package de.platon42.intellij.plugins.cajon
|
||||
|
||||
import com.intellij.codeInsight.intention.IntentionAction
|
||||
import com.intellij.pom.java.LanguageLevel
|
||||
import de.platon42.intellij.jupiter.AbstractJUnit5TestCase
|
||||
import de.platon42.intellij.jupiter.AddLocalJarToModule
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.AddMavenDependencyToModule
|
||||
import de.platon42.intellij.jupiter.LightCodeInsightExtension
|
||||
import de.platon42.intellij.jupiter.TestDataPath
|
||||
import de.platon42.intellij.jupiter.TestJdk
|
||||
import org.assertj.core.api.Assertions
|
||||
import org.assertj.core.api.Assertions.assertThat
|
||||
import org.assertj.core.api.Condition
|
||||
import org.junit.jupiter.api.DisplayNameGeneration
|
||||
import org.junit.jupiter.api.DisplayNameGenerator
|
||||
import org.junit.jupiter.api.extension.ExtendWith
|
||||
import java.lang.reflect.Method
|
||||
|
||||
@ExtendWith(LightCodeInsightExtension::class)
|
||||
@TestDataPath("src/test/resources")
|
||||
@TestJdk(LanguageLevel.JDK_1_8)
|
||||
@AddLocalJarToModule(Assertions::class)
|
||||
//@AddMavenDependencyToModule("org.assertj:assertj-core:3.25.3", includeTransitiveDependencies = false, DependencyScope.COMPILE)
|
||||
@TestJdk(LanguageLevel.JDK_1_8, annotations = true, useInternal = true)
|
||||
//@AddLocalJarToModule(Assertions::class)
|
||||
@AddMavenDependencyToModule("org.assertj:assertj-core:3.15.0")
|
||||
@DisplayNameGeneration(AbstractCajonTest.CutOffFixtureDisplayNameGenerator::class)
|
||||
abstract class AbstractCajonTest : AbstractJUnit5TestCase() {
|
||||
abstract class AbstractCajonTest {
|
||||
|
||||
protected fun executeQuickFixes(regex: Regex, expectedFixes: Int) {
|
||||
val quickfixes = getQuickFixes(regex, expectedFixes)
|
||||
protected fun executeQuickFixes(myFixture: JavaCodeInsightTestFixture, regex: Regex, expectedFixes: Int) {
|
||||
val quickfixes = getQuickFixes(myFixture, regex, expectedFixes)
|
||||
assertThat(quickfixes.groupBy { it.familyName }).hasSize(1)
|
||||
quickfixes.forEach(fixture::launchAction)
|
||||
quickfixes.forEach(myFixture::launchAction)
|
||||
}
|
||||
|
||||
protected fun executeQuickFixesNoFamilyNameCheck(regex: Regex, expectedFixes: Int) {
|
||||
val quickfixes = getQuickFixes(regex, expectedFixes)
|
||||
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 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)
|
||||
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)
|
||||
return quickfixes
|
||||
}
|
||||
|
||||
protected fun assertHighlightings(count: Int, snippet: String) {
|
||||
assertThat(fixture.doHighlighting())
|
||||
.areExactly(count, Condition({ it.description?.contains(snippet) ?: false }, "containing"))
|
||||
protected fun assertHighlightings(myFixture: JavaCodeInsightTestFixture, count: Int, snippet: String) {
|
||||
val highlights = myFixture.doHighlighting()
|
||||
.asSequence()
|
||||
.filter { it.description?.contains(snippet) ?: false }
|
||||
.toList()
|
||||
assertThat(highlights).hasSize(count)
|
||||
}
|
||||
|
||||
class CutOffFixtureDisplayNameGenerator : DisplayNameGenerator.ReplaceUnderscores() {
|
||||
@ -49,4 +52,4 @@ abstract class AbstractCajonTest : AbstractJUnit5TestCase() {
|
||||
return nameForMethod.substringBefore("$")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,19 +1,19 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import com.intellij.testFramework.RunsInEdt
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.MyFixture
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@TestDataSubPath("inspections/BinaryExpression")
|
||||
internal class AssertThatBinaryExpressionInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
@RunsInEdt
|
||||
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")
|
||||
@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")
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,20 +1,22 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.MyFixture
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@TestDataSubPath("inspections/BooleanCondition")
|
||||
internal class AssertThatBooleanConditionInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
internal fun assertThat_with_isEqualTo_true_or_false_can_use_isTrue_or_isFalse() {
|
||||
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")
|
||||
@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")
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,5 +1,7 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.MyFixture
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.assertj.core.api.Assertions.assertThat
|
||||
@ -9,68 +11,68 @@ import org.junit.jupiter.api.Test
|
||||
internal class AssertThatCollectionOrMapExpressionInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
internal fun assertThat_with_certain_Collection_and_Map_methods() {
|
||||
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")
|
||||
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")
|
||||
}
|
||||
|
||||
@Test
|
||||
internal fun assertThat_with_certain_Collection_and_Map_methods_with_Null_values() {
|
||||
internal fun assertThat_with_certain_Collection_and_Map_methods_with_Null_values(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
val inspection = AssertThatCollectionOrMapExpressionInspection()
|
||||
inspection.behaviorForMapValueEqualsNull = 3
|
||||
fixture.enableInspections(inspection)
|
||||
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")
|
||||
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")
|
||||
}
|
||||
|
||||
@Test
|
||||
internal fun assertThat_with_certain_Collection_and_Map_methods_with_no_quickfixes_for_get_equals_null() {
|
||||
internal fun assertThat_with_certain_Collection_and_Map_methods_with_no_quickfixes_for_get_equals_null(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
val inspection = AssertThatCollectionOrMapExpressionInspection()
|
||||
inspection.behaviorForMapValueEqualsNull = 0
|
||||
|
||||
fixture.enableInspections(inspection)
|
||||
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)
|
||||
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)
|
||||
}
|
||||
|
||||
@Test
|
||||
internal fun assertThat_with_certain_Collection_and_Map_methods_with_only_warnings_for_get_equals_null() {
|
||||
internal fun assertThat_with_certain_Collection_and_Map_methods_with_only_warnings_for_get_equals_null(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
val inspection = AssertThatCollectionOrMapExpressionInspection()
|
||||
inspection.behaviorForMapValueEqualsNull = 1
|
||||
|
||||
fixture.enableInspections(inspection)
|
||||
fixture.configureByFile("CollectionMapExpressionBefore.java")
|
||||
val highlights = fixture.doHighlighting()
|
||||
myFixture.enableInspections(inspection)
|
||||
myFixture.configureByFile("CollectionMapExpressionBefore.java")
|
||||
val highlights = myFixture.doHighlighting()
|
||||
.asSequence()
|
||||
.filter { it.description == "Moving get() expression out of assertThat() would be more concise" }
|
||||
.filter {
|
||||
@ -79,24 +81,24 @@ internal class AssertThatCollectionOrMapExpressionInspectionTest : AbstractCajon
|
||||
.toList()
|
||||
assertThat(highlights).hasSize(4)
|
||||
|
||||
getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
|
||||
getQuickFixes(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)
|
||||
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)
|
||||
}
|
||||
|
||||
@Test
|
||||
internal fun assertThat_with_certain_Collection_and_Map_methods_with_both_quickfixes_for_get_equals_null() {
|
||||
internal fun assertThat_with_certain_Collection_and_Map_methods_with_both_quickfixes_for_get_equals_null(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
val inspection = AssertThatCollectionOrMapExpressionInspection()
|
||||
inspection.behaviorForMapValueEqualsNull = 4
|
||||
|
||||
fixture.enableInspections(inspection)
|
||||
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)
|
||||
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)
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,22 +1,24 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.MyFixture
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@TestDataSubPath("inspections/Comparable")
|
||||
internal class AssertThatComparableInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
internal fun assertThat_with_compareTo_method() {
|
||||
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")
|
||||
@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")
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,21 +1,23 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.MyFixture
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@TestDataSubPath("inspections/EnumerableIsEmpty")
|
||||
internal class AssertThatEnumerableIsEmptyInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
internal fun assertThat_with_hasSize_zero_and_similar_can_use_isEmpty() {
|
||||
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")
|
||||
@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")
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,36 +1,38 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.MyFixture
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@TestDataSubPath("inspections/FileExpression")
|
||||
internal class AssertThatFileExpressionInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
internal fun assertThat_with_certain_File_methods() {
|
||||
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")
|
||||
@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")
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,45 +1,48 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import de.platon42.intellij.jupiter.AddMavenDependencyToModule
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.AddLocalJarToModule
|
||||
import de.platon42.intellij.jupiter.MyFixture
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.assertj.core.api.Assertions
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@AddMavenDependencyToModule("org.assertj:assertj-guava:3.25.3")
|
||||
@AddLocalJarToModule(com.google.common.base.Optional::class, org.assertj.guava.api.Assertions::class, Assertions::class)
|
||||
@TestDataSubPath("inspections/GuavaOptional")
|
||||
internal class AssertThatGuavaOptionalInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
internal fun assertThat_get_or_isPresent_for_Guava_Optional_can_be_simplified() {
|
||||
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")
|
||||
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")
|
||||
}
|
||||
|
||||
@Test
|
||||
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")
|
||||
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")
|
||||
}
|
||||
|
||||
@Test
|
||||
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")
|
||||
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")
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,18 +1,20 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.MyFixture
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@TestDataSubPath("inspections/InstanceOf")
|
||||
internal class AssertThatInstanceOfInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
internal fun assertThat_with_instanceof_can_be_moved_out() {
|
||||
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")
|
||||
@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")
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,19 +1,21 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.MyFixture
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@TestDataSubPath("inspections/InvertedBooleanCondition")
|
||||
internal class AssertThatInvertedBooleanConditionInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
internal fun assertThat_with_inverted_boolean_condition_can_be_inverted() {
|
||||
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")
|
||||
@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")
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,19 +0,0 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@TestDataSubPath("inspections/IsZeroOne")
|
||||
internal class AssertThatIsZeroOneInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
internal fun assertThat_with_isEqualTo_zero_or_one_can_use_isZero_or_isOne_plus_isNotZero() {
|
||||
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")
|
||||
}
|
||||
}
|
||||
@ -1,25 +1,27 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.MyFixture
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@TestDataSubPath("inspections/Java8Optional")
|
||||
internal class AssertThatJava8OptionalInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
internal fun assertThat_get_or_isPresent_for_Java8_Optional_can_be_simplified() {
|
||||
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")
|
||||
@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")
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,20 +1,22 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.MyFixture
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@TestDataSubPath("inspections/ObjectExpression")
|
||||
internal class AssertThatObjectExpressionInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
internal fun assertThat_with_certain_Object_methods() {
|
||||
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")
|
||||
@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")
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,18 +1,20 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.MyFixture
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@TestDataSubPath("inspections/ObjectIsNullOrNotNull")
|
||||
internal class AssertThatObjectIsNullOrNotNullInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
internal fun assertThat_with_isEqualTo_null_can_use_isNull() {
|
||||
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")
|
||||
@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")
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,22 +1,24 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.MyFixture
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@TestDataSubPath("inspections/PathExpression")
|
||||
internal class AssertThatPathExpressionInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
internal fun assertThat_with_certain_Path_methods() {
|
||||
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")
|
||||
@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")
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,32 +1,34 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.MyFixture
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@TestDataSubPath("inspections/Size")
|
||||
internal class AssertThatSizeInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
internal fun assertThat_size_of_array_collection_or_map_can_be_simplified() {
|
||||
fixture.enableInspections(AssertThatSizeInspection::class.java)
|
||||
fixture.configureByFile("SizeBefore.java")
|
||||
assertHighlightings(1, "Try to operate on the iterable itself rather than its size")
|
||||
@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")
|
||||
|
||||
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")
|
||||
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")
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,39 +1,41 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.MyFixture
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@TestDataSubPath("inspections/StringExpression")
|
||||
internal class AssertThatStringExpressionInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
internal fun assertThat_with_certain_String_methods() {
|
||||
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")
|
||||
@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")
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,25 +1,27 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.MyFixture
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.assertj.core.api.Assertions.assertThat
|
||||
import org.assertj.core.api.extrakting
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@TestDataSubPath("inspections/StringIsEmpty")
|
||||
internal class AssertThatStringIsEmptyInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
internal fun assertThat_with_isEqualTo_emptyString_can_use_isEmpty() {
|
||||
fixture.enableInspections(AssertThatStringIsEmptyInspection::class.java)
|
||||
fixture.configureByFile("StringIsEmptyBefore.java")
|
||||
val highlights = fixture.doHighlighting()
|
||||
@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()
|
||||
.asSequence()
|
||||
.filter { it.description?.contains(" can be simplified to") ?: false }
|
||||
.toList()
|
||||
assertThat(highlights).hasSize(6).extrakting { it.text }.doesNotContain("assertThat")
|
||||
executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 3)
|
||||
executeQuickFixes(Regex.fromLiteral("Replace hasSize() with isEmpty()"), 3)
|
||||
fixture.checkResultByFile("StringIsEmptyAfter.java")
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 3)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSize() with isEmpty()"), 3)
|
||||
myFixture.checkResultByFile("StringIsEmptyAfter.java")
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,20 +1,22 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import de.platon42.intellij.jupiter.AddMavenDependencyToModule
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.AddLocalJarToModule
|
||||
import de.platon42.intellij.jupiter.MyFixture
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.assertj.core.api.Assertions
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@AddMavenDependencyToModule("junit:junit:4.13.2")
|
||||
@AddMavenDependencyToModule("org.junit.jupiter:junit-jupiter-api:5.10.2")
|
||||
@TestDataSubPath("inspections/AssumeThat")
|
||||
@AddLocalJarToModule(Assertions::class, Test::class, org.junit.Test::class)
|
||||
internal class AssumeThatInsteadOfReturnInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
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")
|
||||
@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")
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,17 +1,19 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.MyFixture
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@TestDataSubPath("inspections/BogusAssertion")
|
||||
internal class BogusAssertionInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
internal fun reports_bogus_assertions() {
|
||||
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()")
|
||||
@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()")
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,21 +1,24 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import de.platon42.intellij.jupiter.AddMavenDependencyToModule
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.AddLocalJarToModule
|
||||
import de.platon42.intellij.jupiter.MyFixture
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.assertj.core.api.Assertions
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@AddMavenDependencyToModule("org.assertj:assertj-guava:3.25.3")
|
||||
@TestDataSubPath("inspections/ImplicitAssertion")
|
||||
@AddLocalJarToModule(com.google.common.base.Optional::class, org.assertj.guava.api.Assertions::class, Assertions::class)
|
||||
internal class ImplicitAssertionInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
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")
|
||||
@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")
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,23 @@
|
||||
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.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.assertj.core.api.Assertions
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@AddLocalJarToModule(org.junit.jupiter.api.Assertions::class, Assertions::class)
|
||||
internal class JUnit5AssertToAssertJInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
@TestDataSubPath("inspections/JUnit5AssertToAssertJ")
|
||||
internal fun junit5_Assertions_can_be_converted_into_AssertJ(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.enableInspections(JUnitAssertToAssertJInspection::class.java)
|
||||
myFixture.configureByFile("JUnit5AssertToAssertJInspectionBefore.java")
|
||||
executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Convert assert.*\\(\\) to assertThat\\(\\).*"), 48)
|
||||
executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Convert assume.*\\(\\) to assumeThat\\(\\).*"), 4)
|
||||
myFixture.checkResultByFile("JUnit5AssertToAssertJInspectionAfter.java")
|
||||
}
|
||||
}
|
||||
@ -1,20 +1,24 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import de.platon42.intellij.jupiter.AddMavenDependencyToModule
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.AddLocalJarToModule
|
||||
import de.platon42.intellij.jupiter.MyFixture
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.assertj.core.api.Assertions
|
||||
import org.junit.Assert
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@AddMavenDependencyToModule("junit:junit:4.13.2")
|
||||
@TestDataSubPath("inspections/JUnitAssertToAssertJ")
|
||||
@AddLocalJarToModule(Assert::class, Assertions::class)
|
||||
internal class JUnitAssertToAssertJInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
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")
|
||||
@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")
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,17 +1,19 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.MyFixture
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@TestDataSubPath("inspections/JoinStatements")
|
||||
internal class JoinAssertThatStatementsInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
internal fun assertThat_statements_can_be_joined_together() {
|
||||
fixture.enableInspections(JoinAssertThatStatementsInspection::class.java)
|
||||
fixture.configureByFile("JoinStatementsBefore.java")
|
||||
executeQuickFixes(Regex.fromLiteral("Join assertThat() statements"), 5)
|
||||
fixture.checkResultByFile("JoinStatementsAfter.java")
|
||||
@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")
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,17 +1,19 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.MyFixture
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@TestDataSubPath("inspections/JoinVarArgsContains")
|
||||
internal class JoinVarArgsContainsInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
internal fun join_contains_and_doesNotContain_together_where_possible() {
|
||||
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")
|
||||
@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")
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,21 +1,23 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.MyFixture
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@TestDataSubPath("inspections/TwistedAssertion")
|
||||
internal class TwistedAssertionInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
internal fun hint_twisted_actual_and_expected_and_provide_quickfix_where_possible() {
|
||||
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")
|
||||
@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")
|
||||
|
||||
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")
|
||||
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")
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,5 +1,7 @@
|
||||
package de.platon42.intellij.plugins.cajon.references
|
||||
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.MyFixture
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.assertj.core.api.Assertions.assertThat
|
||||
@ -11,68 +13,68 @@ import org.junit.jupiter.api.Test
|
||||
internal class ExtractorReferenceContributorTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
internal fun extractor_is_able_to_find_reference_for_field_extracting() {
|
||||
fixture.configureByFiles("FindReference1.java", "Address.java", "Contact.java")
|
||||
assertThat(fixture.elementAtCaret.text).isEqualTo("private String name;")
|
||||
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;")
|
||||
}
|
||||
|
||||
@Test
|
||||
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;")
|
||||
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;")
|
||||
}
|
||||
|
||||
@Test
|
||||
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;")
|
||||
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;")
|
||||
}
|
||||
|
||||
@Test
|
||||
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()")
|
||||
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()")
|
||||
}
|
||||
|
||||
@Test
|
||||
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()")
|
||||
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()")
|
||||
}
|
||||
|
||||
@Test
|
||||
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;")
|
||||
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;")
|
||||
}
|
||||
|
||||
@Test
|
||||
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()")
|
||||
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()")
|
||||
}
|
||||
|
||||
@Test
|
||||
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;")
|
||||
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;")
|
||||
}
|
||||
|
||||
@Test
|
||||
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;")
|
||||
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;")
|
||||
}
|
||||
|
||||
@Test
|
||||
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()")
|
||||
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()")
|
||||
}
|
||||
|
||||
@Test
|
||||
internal fun extractor_is_unable_to_find_reference() {
|
||||
fixture.configureByFiles("FindReference11.java", "Address.java", "Contact.java")
|
||||
assertThatThrownBy { fixture.elementAtCaret.text }.isInstanceOf(AssertionError::class.java)
|
||||
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)
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,67 +0,0 @@
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.assertj.core.api.Assertions.fail;
|
||||
|
||||
public class IsZeroOne {
|
||||
|
||||
private void isZeroOne() {
|
||||
short shortValue = 0;
|
||||
int intValue = 0;
|
||||
long longValue = 0L;
|
||||
float floatValue = 0.0f;
|
||||
double doubleValue = 0.0;
|
||||
|
||||
assertThat(shortValue).as("foo").isZero();
|
||||
assertThat(shortValue).isZero();
|
||||
assertThat(shortValue).as("foo").isOne();
|
||||
assertThat(shortValue).isOne();
|
||||
|
||||
assertThat(shortValue).as("foo").isNotZero();
|
||||
assertThat(shortValue).isNotZero();
|
||||
assertThat(shortValue).as("foo").isNotEqualTo(1);
|
||||
assertThat(shortValue).isNotEqualTo(0 + 1);
|
||||
|
||||
assertThat(intValue).as("foo").isZero();
|
||||
assertThat(intValue).isZero();
|
||||
assertThat(intValue).as("foo").isOne();
|
||||
assertThat(intValue).isOne();
|
||||
|
||||
assertThat(intValue).as("foo").isNotZero();
|
||||
assertThat(intValue).isNotZero();
|
||||
assertThat(intValue).as("foo").isNotEqualTo(1);
|
||||
assertThat(intValue).isNotEqualTo(0 + 1);
|
||||
|
||||
assertThat(longValue).as("foo").isZero();
|
||||
assertThat(longValue).isZero();
|
||||
assertThat(longValue).as("foo").isOne();
|
||||
assertThat(longValue).isOne();
|
||||
|
||||
assertThat(longValue).as("foo").isNotZero();
|
||||
assertThat(longValue).isNotZero();
|
||||
assertThat(longValue).as("foo").isNotEqualTo(1L);
|
||||
assertThat(longValue).isNotEqualTo(0L + 1L);
|
||||
|
||||
assertThat(floatValue).as("foo").isZero();
|
||||
assertThat(floatValue).isZero();
|
||||
assertThat(floatValue).as("foo").isOne();
|
||||
assertThat(floatValue).isOne();
|
||||
|
||||
assertThat(floatValue).as("foo").isNotZero();
|
||||
assertThat(floatValue).isNotZero();
|
||||
assertThat(floatValue).as("foo").isNotEqualTo(1.0f);
|
||||
assertThat(floatValue).isNotEqualTo(0.0f + 1.0f);
|
||||
|
||||
assertThat(doubleValue).as("foo").isZero();
|
||||
assertThat(doubleValue).isZero();
|
||||
assertThat(doubleValue).as("foo").isOne();
|
||||
assertThat(doubleValue).isOne();
|
||||
|
||||
assertThat(doubleValue).as("foo").isNotZero();
|
||||
assertThat(doubleValue).isNotZero();
|
||||
assertThat(doubleValue).as("foo").isNotEqualTo(1.0);
|
||||
assertThat(doubleValue).isNotEqualTo(0.0 + 1.0);
|
||||
|
||||
assertThat(intValue).as("foo").isEqualTo(2);
|
||||
|
||||
fail("oh no!");
|
||||
}
|
||||
}
|
||||
@ -1,67 +0,0 @@
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.assertj.core.api.Assertions.fail;
|
||||
|
||||
public class IsZeroOne {
|
||||
|
||||
private void isZeroOne() {
|
||||
short shortValue = 0;
|
||||
int intValue = 0;
|
||||
long longValue = 0L;
|
||||
float floatValue = 0.0f;
|
||||
double doubleValue = 0.0;
|
||||
|
||||
assertThat(shortValue).as("foo").isEqualTo(0);
|
||||
assertThat(shortValue).isEqualTo(1 - 1);
|
||||
assertThat(shortValue).as("foo").isEqualTo(1);
|
||||
assertThat(shortValue).isEqualTo(0 + 1);
|
||||
|
||||
assertThat(shortValue).as("foo").isNotEqualTo(0);
|
||||
assertThat(shortValue).isNotEqualTo(1 - 1);
|
||||
assertThat(shortValue).as("foo").isNotEqualTo(1);
|
||||
assertThat(shortValue).isNotEqualTo(0 + 1);
|
||||
|
||||
assertThat(intValue).as("foo").isEqualTo(0);
|
||||
assertThat(intValue).isEqualTo(1 - 1);
|
||||
assertThat(intValue).as("foo").isEqualTo(1);
|
||||
assertThat(intValue).isEqualTo(0 + 1);
|
||||
|
||||
assertThat(intValue).as("foo").isNotEqualTo(0);
|
||||
assertThat(intValue).isNotEqualTo(1 - 1);
|
||||
assertThat(intValue).as("foo").isNotEqualTo(1);
|
||||
assertThat(intValue).isNotEqualTo(0 + 1);
|
||||
|
||||
assertThat(longValue).as("foo").isEqualTo(0L);
|
||||
assertThat(longValue).isEqualTo(1L - 1L);
|
||||
assertThat(longValue).as("foo").isEqualTo(1L);
|
||||
assertThat(longValue).isEqualTo(0L + 1L);
|
||||
|
||||
assertThat(longValue).as("foo").isNotEqualTo(0L);
|
||||
assertThat(longValue).isNotEqualTo(1L - 1L);
|
||||
assertThat(longValue).as("foo").isNotEqualTo(1L);
|
||||
assertThat(longValue).isNotEqualTo(0L + 1L);
|
||||
|
||||
assertThat(floatValue).as("foo").isEqualTo(0.0f);
|
||||
assertThat(floatValue).isEqualTo(1.0f - 1.0f);
|
||||
assertThat(floatValue).as("foo").isEqualTo(1.0f);
|
||||
assertThat(floatValue).isEqualTo(0.0f + 1.0f);
|
||||
|
||||
assertThat(floatValue).as("foo").isNotEqualTo(0.0f);
|
||||
assertThat(floatValue).isNotEqualTo(1.0f - 1.0f);
|
||||
assertThat(floatValue).as("foo").isNotEqualTo(1.0f);
|
||||
assertThat(floatValue).isNotEqualTo(0.0f + 1.0f);
|
||||
|
||||
assertThat(doubleValue).as("foo").isEqualTo(0.0);
|
||||
assertThat(doubleValue).isEqualTo(1.0 - 1.0);
|
||||
assertThat(doubleValue).as("foo").isEqualTo(1.0);
|
||||
assertThat(doubleValue).isEqualTo(0.0 + 1.0);
|
||||
|
||||
assertThat(doubleValue).as("foo").isNotEqualTo(0.0);
|
||||
assertThat(doubleValue).isNotEqualTo(1.0 - 1.0);
|
||||
assertThat(doubleValue).as("foo").isNotEqualTo(1.0);
|
||||
assertThat(doubleValue).isNotEqualTo(0.0 + 1.0);
|
||||
|
||||
assertThat(intValue).as("foo").isEqualTo(2);
|
||||
|
||||
fail("oh no!");
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,86 @@
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.assertj.core.api.Assumptions.assumeThat;
|
||||
import static org.assertj.core.data.Offset.offset;
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
import static org.junit.jupiter.api.Assumptions.*;
|
||||
|
||||
public class JUnit5AssertToAssertJ {
|
||||
|
||||
private void jUnit5AssertToAssertJ() {
|
||||
String foo = "foo";
|
||||
String bar = "bar";
|
||||
int someInt = 1;
|
||||
double someDouble = 1.0;
|
||||
float someFloat = 1.0f;
|
||||
|
||||
assertThat(foo == "foo").isTrue();
|
||||
assertThat(foo == "foo").as("oh no!").isTrue();
|
||||
assertThat(foo == "bar").isFalse();
|
||||
assertThat(foo == "bar").as("boom!").isFalse();
|
||||
|
||||
assertThat(foo).isNull();
|
||||
assertThat(foo).as("oh no!").isNull();
|
||||
assertThat(foo).isNotNull();
|
||||
assertThat(foo).as("oh no!").isNotNull();
|
||||
|
||||
assertThat(foo).isEqualTo(bar);
|
||||
assertThat(foo).as("equals").isEqualTo(bar);
|
||||
assertThat(foo).isNotEqualTo(bar);
|
||||
assertThat(foo).as("equals").isNotEqualTo(bar);
|
||||
|
||||
assertThat(foo).isSameAs(bar);
|
||||
assertThat(foo).as("same").isSameAs(bar);
|
||||
assertThat(foo).isNotSameAs(bar);
|
||||
assertThat(foo).as("same").isNotSameAs(bar);
|
||||
|
||||
assertThat(2.0).isEqualTo(1.0);
|
||||
assertThat(2.0).isCloseTo(1.0, offset(0.1));
|
||||
assertThat(2.0).as("equals").isEqualTo(1.0);
|
||||
assertThat(2.0).as("equals").isCloseTo(1.0, offset(0.1));
|
||||
assertThat(2.0f).isEqualTo(1.0f);
|
||||
assertThat(2.0f).isCloseTo(1.0f, offset(0.1f));
|
||||
assertThat(2.0f).as("equals").isEqualTo(1.0f);
|
||||
assertThat(2.0f).as("equals").isCloseTo(1.0f, offset(0.1f));
|
||||
|
||||
assertThat(2.0).isNotEqualTo(1.0);
|
||||
assertThat(2.0).isNotCloseTo(1.0, offset(0.1));
|
||||
assertThat(2.0).as("equals").isNotEqualTo(1.0);
|
||||
assertThat(2.0).as("equals").isNotCloseTo(1.0, offset(0.1));
|
||||
assertThat(2.0f).isNotEqualTo(1.0f);
|
||||
assertThat(2.0f).isNotCloseTo(1.0f, offset(0.1f));
|
||||
assertThat(2.0f).as("equals").isNotEqualTo(1.0f);
|
||||
assertThat(2.0f).as("equals").isNotCloseTo(1.0f, offset(0.1f));
|
||||
|
||||
assertThat(new int[1]).containsExactly(new int[2]);
|
||||
assertThat(new int[1]).as("array equals").containsExactly(new int[2]);
|
||||
|
||||
assertThat(new double[1]).containsExactly(new double[2], offset(1.0));
|
||||
assertThat(new double[1]).as("array equals").containsExactly(new double[2], offset(1.0));
|
||||
assertThat(new float[1]).containsExactly(new float[2], offset(1.0f));
|
||||
assertThat(new float[1]).as("array equals").containsExactly(new float[2], offset(1.0f));
|
||||
|
||||
assertThat(foo).isEqualTo("bar");
|
||||
assertThat(bar).as("equals").isEqualTo("foo");
|
||||
assertThat(bar).isNotEqualTo("foo");
|
||||
assertThat(foo).as("equals").isNotEqualTo("bar");
|
||||
|
||||
assertThat(someInt).isEqualTo(2);
|
||||
assertThat(someDouble).isCloseTo(2.0, offset(0.1));
|
||||
assertThat(someDouble).as("equals").isEqualTo(1.0);
|
||||
assertThat(someDouble).as("equals").isCloseTo(1.0, offset(0.1));
|
||||
assertThat(someFloat).isEqualTo(1.0f);
|
||||
assertThat(someFloat).isCloseTo(2.0f, offset(0.1f));
|
||||
|
||||
fail();
|
||||
fail("oh no!")
|
||||
}
|
||||
|
||||
private void jUnit5AssumeToAssertJ() {
|
||||
String foo = "foo";
|
||||
String bar = "bar";
|
||||
assumeThat(foo == "foo").isTrue();
|
||||
assumeThat(foo == "foo").as("oh no!").isTrue();
|
||||
assumeThat(foo == "bar").isFalse();
|
||||
assumeThat(foo == "bar").as("boom!").isFalse();
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,83 @@
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
import static org.junit.jupiter.api.Assumptions.*;
|
||||
|
||||
public class JUnit5AssertToAssertJ {
|
||||
|
||||
private void jUnit5AssertToAssertJ() {
|
||||
String foo = "foo";
|
||||
String bar = "bar";
|
||||
int someInt = 1;
|
||||
double someDouble = 1.0;
|
||||
float someFloat = 1.0f;
|
||||
|
||||
assertTrue(foo == "foo");
|
||||
assertTrue(foo == "foo", "oh no!");
|
||||
assertFalse(foo == "bar");
|
||||
assertFalse(foo == "bar", "boom!");
|
||||
|
||||
assertNull(foo);
|
||||
assertNull(foo, "oh no!");
|
||||
assertNotNull(foo);
|
||||
assertNotNull(foo, "oh no!");
|
||||
|
||||
assertEquals(bar, foo);
|
||||
assertEquals(bar, foo, "equals");
|
||||
assertNotEquals(bar, foo);
|
||||
assertNotEquals(bar, foo, "equals");
|
||||
|
||||
assertSame(bar, foo);
|
||||
assertSame(bar, foo, "same");
|
||||
assertNotSame(bar, foo);
|
||||
assertNotSame(bar, foo, "same");
|
||||
|
||||
assertEquals(1.0, 2.0);
|
||||
assertEquals(1.0, 2.0, 0.1);
|
||||
assertEquals(1.0, 2.0, "equals");
|
||||
assertEquals(1.0, 2.0, 0.1, "equals");
|
||||
assertEquals(1.0f, 2.0f);
|
||||
assertEquals(1.0f, 2.0f, 0.1f);
|
||||
assertEquals(1.0f, 2.0f, "equals");
|
||||
assertEquals(1.0f, 2.0f, 0.1f, "equals");
|
||||
|
||||
assertNotEquals(1.0, 2.0);
|
||||
assertNotEquals(1.0, 2.0, 0.1);
|
||||
assertNotEquals(1.0, 2.0, "equals");
|
||||
assertNotEquals(1.0, 2.0, 0.1, "equals");
|
||||
assertNotEquals(1.0f, 2.0f);
|
||||
assertNotEquals(1.0f, 2.0f, 0.1f);
|
||||
assertNotEquals(1.0f, 2.0f, "equals");
|
||||
assertNotEquals(1.0f, 2.0f, 0.1f, "equals");
|
||||
|
||||
assertArrayEquals(new int[2], new int[1]);
|
||||
assertArrayEquals(new int[2], new int[1], "array equals");
|
||||
|
||||
assertArrayEquals(new double[2], new double[1], 1.0);
|
||||
assertArrayEquals(new double[2], new double[1], 1.0, "array equals");
|
||||
assertArrayEquals(new float[2], new float[1], 1.0f);
|
||||
assertArrayEquals(new float[2], new float[1], 1.0f, "array equals");
|
||||
|
||||
assertEquals("bar", foo);
|
||||
assertEquals(bar, "foo", "equals");
|
||||
assertNotEquals(bar, "foo");
|
||||
assertNotEquals("bar", foo, "equals");
|
||||
|
||||
assertEquals(someInt, 2);
|
||||
assertEquals(someDouble, 2.0, 0.1);
|
||||
assertEquals(1.0, someDouble, "equals");
|
||||
assertEquals(1.0, someDouble, 0.1, "equals");
|
||||
assertEquals(1.0f, someFloat);
|
||||
assertEquals(someFloat, 2.0f, 0.1f);
|
||||
|
||||
fail();
|
||||
fail("oh no!")
|
||||
}
|
||||
|
||||
private void jUnit5AssumeToAssertJ() {
|
||||
String foo = "foo";
|
||||
String bar = "bar";
|
||||
assumeTrue(foo == "foo");
|
||||
assumeTrue(foo == "foo", "oh no!");
|
||||
assumeFalse(foo == "bar");
|
||||
assumeFalse(foo == "bar", "boom!");
|
||||
}
|
||||
}
|
||||
@ -66,9 +66,6 @@ public class JoinStatements {
|
||||
assertThat(list.get(--i)).isEqualTo("foo");
|
||||
assertThat(list.get(--i)).isEqualTo("foo");
|
||||
|
||||
assertThat(list).filteredOn("foo", "foo").contains("narf");
|
||||
assertThat(list).filteredOn("bar", "bar").contains("puit");
|
||||
|
||||
org.junit.Assert.assertThat(list, null);
|
||||
fail("oh no!");
|
||||
}
|
||||
|
||||
@ -63,9 +63,6 @@ public class JoinStatements {
|
||||
assertThat(list.get(--i)).isEqualTo("foo");
|
||||
assertThat(list.get(--i)).isEqualTo("foo");
|
||||
|
||||
assertThat(list).filteredOn("foo", "foo").contains("narf");
|
||||
assertThat(list).filteredOn("bar", "bar").contains("puit");
|
||||
|
||||
org.junit.Assert.assertThat(list, null);
|
||||
fail("oh no!");
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user