test: fix AssertJ code generation (#5673)

flake.nix

@@ -102,9 +102,9 @@
           '';
           codegen = pkgs.writeScriptBin "codegen" ''
            set -eu
-           mvn test -Dgroups=codegen
+           mvn test -Dtest=spoon.testing.assertions.codegen.AssertJCodegen
            mvn spotless:apply
-           git diff --exit-code || "::error::Generated code is not up to date. Execute mvn test -Dgroups=codegen, mvn spotless:apply and commit your changes."
+           git diff --exit-code || echo "::error::Generated code is not up to date. Execute mvn test -Dtest=spoon.testing.assertions.codegen.AssertJCodegen, mvn spotless:apply and commit your changes."
            '';
           extra = pkgs.writeScriptBin "extra" (if !extraChecks then "exit 2" else ''
             set -eu

src/test/java/spoon/testing/assertions/CtAbstractInvocationAssert.java

@@ -0,0 +1,23 @@
+package spoon.testing.assertions;
+import org.assertj.core.api.AbstractObjectAssert;
+import spoon.reflect.code.CtAbstractInvocation;
+public class CtAbstractInvocationAssert extends AbstractObjectAssert<CtAbstractInvocationAssert, CtAbstractInvocation<?>> implements CtAbstractInvocationAssertInterface<CtAbstractInvocationAssert, CtAbstractInvocation<?>> {
+	CtAbstractInvocationAssert(CtAbstractInvocation<?> actual) {
+		super(actual, CtAbstractInvocationAssert.class);
+	}
+
+	@Override
+	public CtAbstractInvocationAssert self() {
+		return this;
+	}
+
+	@Override
+	public CtAbstractInvocation<?> actual() {
+		return this.actual;
+	}
+
+	@Override
+	public void failWithMessage(String errorMessage, Object... arguments) {
+		super.failWithMessage(errorMessage, arguments);
+	}
+}

src/test/java/spoon/testing/assertions/CtAbstractInvocationAssertInterface.java

@@ -4,7 +4,7 @@
 import org.assertj.core.api.ListAssert;
 import spoon.reflect.code.CtAbstractInvocation;
 import spoon.reflect.code.CtExpression;
-interface CtAbstractInvocationAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtAbstractInvocation<?>> extends CtElementAssertInterface<A, W> , SpoonAssert<A, W> {
+public interface CtAbstractInvocationAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtAbstractInvocation<?>> extends CtElementAssertInterface<A, W> , SpoonAssert<A, W> {
 	default ListAssert<CtExpression<?>> getArguments() {
 		return Assertions.assertThat(actual().getArguments());
 	}

src/test/java/spoon/testing/assertions/CtAbstractSwitchAssert.java

@@ -0,0 +1,23 @@
+package spoon.testing.assertions;
+import org.assertj.core.api.AbstractObjectAssert;
+import spoon.reflect.code.CtAbstractSwitch;
+public class CtAbstractSwitchAssert extends AbstractObjectAssert<CtAbstractSwitchAssert, CtAbstractSwitch<?>> implements CtAbstractSwitchAssertInterface<CtAbstractSwitchAssert, CtAbstractSwitch<?>> {
+	CtAbstractSwitchAssert(CtAbstractSwitch<?> actual) {
+		super(actual, CtAbstractSwitchAssert.class);
+	}
+
+	@Override
+	public CtAbstractSwitchAssert self() {
+		return this;
+	}
+
+	@Override
+	public CtAbstractSwitch<?> actual() {
+		return this.actual;
+	}
+
+	@Override
+	public void failWithMessage(String errorMessage, Object... arguments) {
+		super.failWithMessage(errorMessage, arguments);
+	}
+}

src/test/java/spoon/testing/assertions/CtAbstractSwitchAssertInterface.java

@@ -4,7 +4,7 @@
 import org.assertj.core.api.ListAssert;
 import spoon.reflect.code.CtAbstractSwitch;
 import spoon.reflect.code.CtCase;
-interface CtAbstractSwitchAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtAbstractSwitch<?>> extends CtElementAssertInterface<A, W> , SpoonAssert<A, W> {
+public interface CtAbstractSwitchAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtAbstractSwitch<?>> extends CtElementAssertInterface<A, W> , SpoonAssert<A, W> {
 	default ListAssert<CtCase<?>> getCases() {
 		return Assertions.assertThat(actual().getCases());
 	}

src/test/java/spoon/testing/assertions/CtActualTypeContainerAssert.java

@@ -0,0 +1,23 @@
+package spoon.testing.assertions;
+import org.assertj.core.api.AbstractObjectAssert;
+import spoon.reflect.reference.CtActualTypeContainer;
+public class CtActualTypeContainerAssert extends AbstractObjectAssert<CtActualTypeContainerAssert, CtActualTypeContainer> implements CtActualTypeContainerAssertInterface<CtActualTypeContainerAssert, CtActualTypeContainer> {
+	CtActualTypeContainerAssert(CtActualTypeContainer actual) {
+		super(actual, CtActualTypeContainerAssert.class);
+	}
+
+	@Override
+	public CtActualTypeContainerAssert self() {
+		return this;
+	}
+
+	@Override
+	public CtActualTypeContainer actual() {
+		return this.actual;
+	}
+
+	@Override
+	public void failWithMessage(String errorMessage, Object... arguments) {
+		super.failWithMessage(errorMessage, arguments);
+	}
+}

src/test/java/spoon/testing/assertions/CtActualTypeContainerAssertInterface.java

@@ -4,7 +4,7 @@
 import org.assertj.core.api.ListAssert;
 import spoon.reflect.reference.CtActualTypeContainer;
 import spoon.reflect.reference.CtTypeReference;
-interface CtActualTypeContainerAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtActualTypeContainer> extends SpoonAssert<A, W> {
+public interface CtActualTypeContainerAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtActualTypeContainer> extends SpoonAssert<A, W> {
 	default ListAssert<CtTypeReference<?>> getActualTypeArguments() {
 		return Assertions.assertThat(actual().getActualTypeArguments());
 	}

src/test/java/spoon/testing/assertions/CtAnnotationAssertInterface.java

@@ -4,7 +4,7 @@
 import org.assertj.core.api.MapAssert;
 import spoon.reflect.code.CtExpression;
 import spoon.reflect.declaration.CtAnnotation;
-interface CtAnnotationAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtAnnotation<?>> extends SpoonAssert<A, W> , CtExpressionAssertInterface<A, W> , CtShadowableAssertInterface<A, W> {
+public interface CtAnnotationAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtAnnotation<?>> extends SpoonAssert<A, W> , CtExpressionAssertInterface<A, W> , CtShadowableAssertInterface<A, W> {
 	default CtTypeReferenceAssertInterface<?, ?> getAnnotationType() {
 		return SpoonAssertions.assertThat(actual().getAnnotationType());
 	}

src/test/java/spoon/testing/assertions/CtAnnotationFieldAccessAssertInterface.java

@@ -1,7 +1,7 @@
 package spoon.testing.assertions;
 import org.assertj.core.api.AbstractObjectAssert;
 import spoon.reflect.code.CtAnnotationFieldAccess;
-interface CtAnnotationFieldAccessAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtAnnotationFieldAccess<?>> extends CtVariableReadAssertInterface<A, W> , SpoonAssert<A, W> , CtTargetedExpressionAssertInterface<A, W> {
+public interface CtAnnotationFieldAccessAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtAnnotationFieldAccess<?>> extends CtVariableReadAssertInterface<A, W> , SpoonAssert<A, W> , CtTargetedExpressionAssertInterface<A, W> {
 	default CtFieldReferenceAssertInterface<?, ?> getVariable() {
 		return SpoonAssertions.assertThat(actual().getVariable());
 	}

src/test/java/spoon/testing/assertions/CtAnnotationMethodAssertInterface.java

@@ -1,7 +1,7 @@
 package spoon.testing.assertions;
 import org.assertj.core.api.AbstractObjectAssert;
 import spoon.reflect.declaration.CtAnnotationMethod;
-interface CtAnnotationMethodAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtAnnotationMethod<?>> extends SpoonAssert<A, W> , CtMethodAssertInterface<A, W> {
+public interface CtAnnotationMethodAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtAnnotationMethod<?>> extends SpoonAssert<A, W> , CtMethodAssertInterface<A, W> {
 	default CtExpressionAssertInterface<?, ?> getDefaultExpression() {
 		return SpoonAssertions.assertThat(actual().getDefaultExpression());
 	}

src/test/java/spoon/testing/assertions/CtAnnotationTypeAssertInterface.java

@@ -1,4 +1,4 @@
 package spoon.testing.assertions;
 import org.assertj.core.api.AbstractObjectAssert;
 import spoon.reflect.declaration.CtAnnotationType;
-interface CtAnnotationTypeAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtAnnotationType<?>> extends SpoonAssert<A, W> , CtTypeAssertInterface<A, W> {}
+public interface CtAnnotationTypeAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtAnnotationType<?>> extends SpoonAssert<A, W> , CtTypeAssertInterface<A, W> {}

src/test/java/spoon/testing/assertions/CtAnonymousExecutableAssertInterface.java

@@ -1,4 +1,4 @@
 package spoon.testing.assertions;
 import org.assertj.core.api.AbstractObjectAssert;
 import spoon.reflect.declaration.CtAnonymousExecutable;
-interface CtAnonymousExecutableAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtAnonymousExecutable> extends SpoonAssert<A, W> , CtExecutableAssertInterface<A, W> , CtTypeMemberAssertInterface<A, W> {}
+public interface CtAnonymousExecutableAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtAnonymousExecutable> extends SpoonAssert<A, W> , CtExecutableAssertInterface<A, W> , CtTypeMemberAssertInterface<A, W> {}

src/test/java/spoon/testing/assertions/CtArrayAccessAssertInterface.java

@@ -1,7 +1,7 @@
 package spoon.testing.assertions;
 import org.assertj.core.api.AbstractObjectAssert;
 import spoon.reflect.code.CtArrayAccess;
-interface CtArrayAccessAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtArrayAccess<?, ?>> extends SpoonAssert<A, W> , CtTargetedExpressionAssertInterface<A, W> {
+public interface CtArrayAccessAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtArrayAccess<?, ?>> extends SpoonAssert<A, W> , CtTargetedExpressionAssertInterface<A, W> {
 	default CtExpressionAssertInterface<?, ?> getIndexExpression() {
 		return SpoonAssertions.assertThat(actual().getIndexExpression());
 	}

src/test/java/spoon/testing/assertions/CtArrayReadAssertInterface.java

@@ -1,4 +1,4 @@
 package spoon.testing.assertions;
 import org.assertj.core.api.AbstractObjectAssert;
 import spoon.reflect.code.CtArrayRead;
-interface CtArrayReadAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtArrayRead<?>> extends SpoonAssert<A, W> , CtArrayAccessAssertInterface<A, W> {}
+public interface CtArrayReadAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtArrayRead<?>> extends SpoonAssert<A, W> , CtArrayAccessAssertInterface<A, W> {}

src/test/java/spoon/testing/assertions/CtArrayTypeReferenceAssertInterface.java

@@ -3,7 +3,7 @@
 import org.assertj.core.api.AbstractStringAssert;
 import org.assertj.core.api.Assertions;
 import spoon.reflect.reference.CtArrayTypeReference;
-interface CtArrayTypeReferenceAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtArrayTypeReference<?>> extends CtTypeReferenceAssertInterface<A, W> , SpoonAssert<A, W> {
+public interface CtArrayTypeReferenceAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtArrayTypeReference<?>> extends CtTypeReferenceAssertInterface<A, W> , SpoonAssert<A, W> {
 	default CtTypeReferenceAssertInterface<?, ?> getComponentType() {
 		return SpoonAssertions.assertThat(actual().getComponentType());
 	}

src/test/java/spoon/testing/assertions/CtArrayWriteAssertInterface.java

@@ -1,4 +1,4 @@
 package spoon.testing.assertions;
 import org.assertj.core.api.AbstractObjectAssert;
 import spoon.reflect.code.CtArrayWrite;
-interface CtArrayWriteAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtArrayWrite<?>> extends SpoonAssert<A, W> , CtArrayAccessAssertInterface<A, W> {}
+public interface CtArrayWriteAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtArrayWrite<?>> extends SpoonAssert<A, W> , CtArrayAccessAssertInterface<A, W> {}

src/test/java/spoon/testing/assertions/CtAssertAssertInterface.java

@@ -1,7 +1,7 @@
 package spoon.testing.assertions;
 import org.assertj.core.api.AbstractObjectAssert;
 import spoon.reflect.code.CtAssert;
-interface CtAssertAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtAssert<?>> extends SpoonAssert<A, W> , CtStatementAssertInterface<A, W> {
+public interface CtAssertAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtAssert<?>> extends SpoonAssert<A, W> , CtStatementAssertInterface<A, W> {
 	default CtExpressionAssertInterface<?, ?> getAssertExpression() {
 		return SpoonAssertions.assertThat(actual().getAssertExpression());
 	}

src/test/java/spoon/testing/assertions/CtAssignmentAssertInterface.java

@@ -1,7 +1,7 @@
 package spoon.testing.assertions;
 import org.assertj.core.api.AbstractObjectAssert;
 import spoon.reflect.code.CtAssignment;
-interface CtAssignmentAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtAssignment<?, ?>> extends SpoonAssert<A, W> , CtStatementAssertInterface<A, W> , CtRHSReceiverAssertInterface<A, W> , CtExpressionAssertInterface<A, W> {
+public interface CtAssignmentAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtAssignment<?, ?>> extends SpoonAssert<A, W> , CtStatementAssertInterface<A, W> , CtRHSReceiverAssertInterface<A, W> , CtExpressionAssertInterface<A, W> {
 	default CtExpressionAssertInterface<?, ?> getAssigned() {
 		return SpoonAssertions.assertThat(actual().getAssigned());
 	}

src/test/java/spoon/testing/assertions/CtBinaryOperatorAssertInterface.java

@@ -4,7 +4,7 @@
 import org.assertj.core.api.ObjectAssert;
 import spoon.reflect.code.BinaryOperatorKind;
 import spoon.reflect.code.CtBinaryOperator;
-interface CtBinaryOperatorAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtBinaryOperator<?>> extends SpoonAssert<A, W> , CtExpressionAssertInterface<A, W> {
+public interface CtBinaryOperatorAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtBinaryOperator<?>> extends SpoonAssert<A, W> , CtExpressionAssertInterface<A, W> {
 	default ObjectAssert<BinaryOperatorKind> getKind() {
 		return Assertions.assertThatObject(actual().getKind());
 	}

src/test/java/spoon/testing/assertions/CtBlockAssertInterface.java

@@ -1,4 +1,4 @@
 package spoon.testing.assertions;
 import org.assertj.core.api.AbstractObjectAssert;
 import spoon.reflect.code.CtBlock;
-interface CtBlockAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtBlock<?>> extends SpoonAssert<A, W> , CtStatementAssertInterface<A, W> , CtStatementListAssertInterface<A, W> {}
+public interface CtBlockAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtBlock<?>> extends SpoonAssert<A, W> , CtStatementAssertInterface<A, W> , CtStatementListAssertInterface<A, W> {}

src/test/java/spoon/testing/assertions/CtBodyHolderAssert.java

@@ -0,0 +1,23 @@
+package spoon.testing.assertions;
+import org.assertj.core.api.AbstractObjectAssert;
+import spoon.reflect.code.CtBodyHolder;
+public class CtBodyHolderAssert extends AbstractObjectAssert<CtBodyHolderAssert, CtBodyHolder> implements CtBodyHolderAssertInterface<CtBodyHolderAssert, CtBodyHolder> {
+	CtBodyHolderAssert(CtBodyHolder actual) {
+		super(actual, CtBodyHolderAssert.class);
+	}
+
+	@Override
+	public CtBodyHolderAssert self() {
+		return this;
+	}
+
+	@Override
+	public CtBodyHolder actual() {
+		return this.actual;
+	}
+
+	@Override
+	public void failWithMessage(String errorMessage, Object... arguments) {
+		super.failWithMessage(errorMessage, arguments);
+	}
+}

src/test/java/spoon/testing/assertions/CtBodyHolderAssertInterface.java

@@ -1,7 +1,7 @@
 package spoon.testing.assertions;
 import org.assertj.core.api.AbstractObjectAssert;
 import spoon.reflect.code.CtBodyHolder;
-interface CtBodyHolderAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtBodyHolder> extends CtElementAssertInterface<A, W> , SpoonAssert<A, W> {
+public interface CtBodyHolderAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtBodyHolder> extends CtElementAssertInterface<A, W> , SpoonAssert<A, W> {
 	default CtStatementAssertInterface<?, ?> getBody() {
 		return SpoonAssertions.assertThat(actual().getBody());
 	}

src/test/java/spoon/testing/assertions/CtBreakAssertInterface.java

@@ -1,4 +1,4 @@
 package spoon.testing.assertions;
 import org.assertj.core.api.AbstractObjectAssert;
 import spoon.reflect.code.CtBreak;
-interface CtBreakAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtBreak> extends SpoonAssert<A, W> , CtLabelledFlowBreakAssertInterface<A, W> {}
+public interface CtBreakAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtBreak> extends SpoonAssert<A, W> , CtLabelledFlowBreakAssertInterface<A, W> {}

src/test/java/spoon/testing/assertions/CtCFlowBreakAssert.java

@@ -0,0 +1,23 @@
+package spoon.testing.assertions;
+import org.assertj.core.api.AbstractObjectAssert;
+import spoon.reflect.code.CtCFlowBreak;
+public class CtCFlowBreakAssert extends AbstractObjectAssert<CtCFlowBreakAssert, CtCFlowBreak> implements CtCFlowBreakAssertInterface<CtCFlowBreakAssert, CtCFlowBreak> {
+	CtCFlowBreakAssert(CtCFlowBreak actual) {
+		super(actual, CtCFlowBreakAssert.class);
+	}
+
+	@Override
+	public CtCFlowBreakAssert self() {
+		return this;
+	}
+
+	@Override
+	public CtCFlowBreak actual() {
+		return this.actual;
+	}
+
+	@Override
+	public void failWithMessage(String errorMessage, Object... arguments) {
+		super.failWithMessage(errorMessage, arguments);
+	}
+}

src/test/java/spoon/testing/assertions/CtCFlowBreakAssertInterface.java

@@ -1,4 +1,4 @@
 package spoon.testing.assertions;
 import org.assertj.core.api.AbstractObjectAssert;
 import spoon.reflect.code.CtCFlowBreak;
-interface CtCFlowBreakAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtCFlowBreak> extends SpoonAssert<A, W> , CtStatementAssertInterface<A, W> {}
+public interface CtCFlowBreakAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtCFlowBreak> extends SpoonAssert<A, W> , CtStatementAssertInterface<A, W> {}

src/test/java/spoon/testing/assertions/CtCaseAssertInterface.java

@@ -1,17 +1,22 @@
 package spoon.testing.assertions;
+import org.assertj.core.api.AbstractBooleanAssert;
 import org.assertj.core.api.AbstractObjectAssert;
 import org.assertj.core.api.Assertions;
 import org.assertj.core.api.ListAssert;
 import org.assertj.core.api.ObjectAssert;
 import spoon.reflect.code.CaseKind;
 import spoon.reflect.code.CtCase;
 import spoon.reflect.code.CtExpression;
-interface CtCaseAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtCase<?>> extends SpoonAssert<A, W> , CtStatementAssertInterface<A, W> , CtStatementListAssertInterface<A, W> {
+public interface CtCaseAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtCase<?>> extends SpoonAssert<A, W> , CtStatementAssertInterface<A, W> , CtStatementListAssertInterface<A, W> {
 	default ListAssert<CtExpression<?>> getCaseExpressions() {
 		return Assertions.assertThat(actual().getCaseExpressions());
 	}
 
 	default ObjectAssert<CaseKind> getCaseKind() {
 		return Assertions.assertThatObject(actual().getCaseKind());
 	}
+
+	default AbstractBooleanAssert<?> getIncludesDefault() {
+		return Assertions.assertThat(actual().getIncludesDefault());
+	}
 }

src/test/java/spoon/testing/assertions/CtCasePatternAssert.java

@@ -0,0 +1,23 @@
+package spoon.testing.assertions;
+import org.assertj.core.api.AbstractObjectAssert;
+import spoon.reflect.code.CtCasePattern;
+public class CtCasePatternAssert extends AbstractObjectAssert<CtCasePatternAssert, CtCasePattern> implements CtCasePatternAssertInterface<CtCasePatternAssert, CtCasePattern> {
+	CtCasePatternAssert(CtCasePattern actual) {
+		super(actual, CtCasePatternAssert.class);
+	}
+
+	@Override
+	public CtCasePatternAssert self() {
+		return this;
+	}
+
+	@Override
+	public CtCasePattern actual() {
+		return this.actual;
+	}
+
+	@Override
+	public void failWithMessage(String errorMessage, Object... arguments) {
+		super.failWithMessage(errorMessage, arguments);
+	}
+}

src/test/java/spoon/testing/assertions/CtCasePatternAssertInterface.java

@@ -0,0 +1,12 @@
+package spoon.testing.assertions;
+import org.assertj.core.api.AbstractObjectAssert;
+import spoon.reflect.code.CtCasePattern;
+public interface CtCasePatternAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtCasePattern> extends SpoonAssert<A, W> , CtExpressionAssertInterface<A, W> {
+	default CtExpressionAssertInterface<?, ?> getGuard() {
+		return SpoonAssertions.assertThat(actual().getGuard());
+	}
+
+	default CtPatternAssertInterface<?, ?> getPattern() {
+		return SpoonAssertions.assertThat(actual().getPattern());
+	}
+}

src/test/java/spoon/testing/assertions/CtCatchAssertInterface.java

@@ -1,7 +1,7 @@
 package spoon.testing.assertions;
 import org.assertj.core.api.AbstractObjectAssert;
 import spoon.reflect.code.CtCatch;
-interface CtCatchAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtCatch> extends CtBodyHolderAssertInterface<A, W> , SpoonAssert<A, W> , CtCodeElementAssertInterface<A, W> {
+public interface CtCatchAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtCatch> extends CtBodyHolderAssertInterface<A, W> , SpoonAssert<A, W> , CtCodeElementAssertInterface<A, W> {
 	default CtBlockAssertInterface<?, ?> getBody() {
 		return SpoonAssertions.assertThat(actual().getBody());
 	}

src/test/java/spoon/testing/assertions/CtCatchVariableAssertInterface.java

@@ -1,7 +1,7 @@
 package spoon.testing.assertions;
 import org.assertj.core.api.AbstractObjectAssert;
 import spoon.reflect.code.CtCatchVariable;
-interface CtCatchVariableAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtCatchVariable<?>> extends CtVariableAssertInterface<A, W> , SpoonAssert<A, W> , CtMultiTypedElementAssertInterface<A, W> , CtCodeElementAssertInterface<A, W> {
+public interface CtCatchVariableAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtCatchVariable<?>> extends CtVariableAssertInterface<A, W> , SpoonAssert<A, W> , CtMultiTypedElementAssertInterface<A, W> , CtCodeElementAssertInterface<A, W> {
 	default CtTypeReferenceAssertInterface<?, ?> getType() {
 		return SpoonAssertions.assertThat(actual().getType());
 	}

src/test/java/spoon/testing/assertions/CtCatchVariableReferenceAssertInterface.java

@@ -1,4 +1,4 @@
 package spoon.testing.assertions;
 import org.assertj.core.api.AbstractObjectAssert;
 import spoon.reflect.reference.CtCatchVariableReference;
-interface CtCatchVariableReferenceAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtCatchVariableReference<?>> extends CtVariableReferenceAssertInterface<A, W> , SpoonAssert<A, W> {}
+public interface CtCatchVariableReferenceAssertInterface<A extends AbstractObjectAssert<A, W>, W extends CtCatchVariableReference<?>> extends CtVariableReferenceAssertInterface<A, W> , SpoonAssert<A, W> {}