refactor(testing): migrate to SpoonAssertions and deprecate old assertion package

src/main/java/spoon/testing/AbstractAssert.java

@@ -5,7 +5,7 @@
  *
  * Spoon is available either under the terms of the MIT License (see LICENSE-MIT.txt) or the Cecill-C License (see LICENSE-CECILL-C.txt). You as the user are entitled to choose the terms under which to adopt Spoon.
  */
 package spoon.testing;
 
 import spoon.SpoonException;
 import spoon.processing.Processor;
@@ -20,7 +20,9 @@
  * 		the self type of this assertion class.
  * @param <A>
  * 		the type of the actual value.
+ * @deprecated Use {@code spoon.testing.assertions.SpoonAssertions} instead.
  */
+@Deprecated(since = "11", forRemoval = true)
 public abstract class AbstractAssert<T extends AbstractAssert<T, A>, A> {
 	protected final LinkedList<Processor<?>> processors = new LinkedList<>();
 	protected final A actual;

src/main/java/spoon/testing/AbstractCtElementAssert.java

@@ -5,16 +5,20 @@
  *
  * Spoon is available either under the terms of the MIT License (see LICENSE-MIT.txt) or the Cecill-C License (see LICENSE-CECILL-C.txt). You as the user are entitled to choose the terms under which to adopt Spoon.
  */
 package spoon.testing;
 
 import spoon.reflect.declaration.CtElement;
 
 import static spoon.testing.utils.Check.assertCtElementEquals;
 import static spoon.testing.utils.Check.assertNotNull;
 import static spoon.testing.utils.Check.assertIsSame;
 import static spoon.testing.utils.ProcessorUtils.process;
 
+/**
+ * @deprecated Use {@code spoon.testing.assertions.SpoonAssertions} instead.
+ */
+@Deprecated(since = "11", forRemoval = true)
 public abstract class AbstractCtElementAssert<T extends AbstractCtElementAssert<T>> extends AbstractAssert<T, CtElement> {
 	protected AbstractCtElementAssert(CtElement actual, Class<?> selfType) {
 		super(actual, selfType);
 	}
@@ -28,14 +32,14 @@
 	 */
 	public T isEqualTo(CtElement expected) {
 		assertNotNull(expected);
 		assertIsSame(actual, expected);
 
 		process(actual.getFactory(), processors);
 
 		// using the new method to have a nice error message
 		assertCtElementEquals(expected, actual);
 
 		return this.myself;
 	}
 
 	/**
@@ -48,11 +52,11 @@
 	public T isEqualTo(String expected) {
 		assertNotNull(expected);
 
 		process(actual.getFactory(), processors);
 
 		if (!actual.toString().equals(expected)) {
 			throw new AssertionError(String.format("%1$s and %2$s aren't equals.", actual.getShortRepresentation(), expected));
 		}
 		return this.myself;
 	}
 }

src/main/java/spoon/testing/AbstractCtPackageAssert.java

@@ -5,7 +5,7 @@
  *
  * Spoon is available either under the terms of the MIT License (see LICENSE-MIT.txt) or the Cecill-C License (see LICENSE-CECILL-C.txt). You as the user are entitled to choose the terms under which to adopt Spoon.
  */
 package spoon.testing;
 
 import spoon.reflect.declaration.CtPackage;
 import spoon.reflect.declaration.CtType;
@@ -15,11 +15,15 @@
 import java.util.Comparator;
 import java.util.List;
 
 import static spoon.testing.Assert.assertThat;
 import static spoon.testing.utils.Check.assertNotNull;
 import static spoon.testing.utils.ProcessorUtils.process;
 
+/**
+ * @deprecated Use {@code spoon.testing.assertions.SpoonAssertions} instead.
+ */
+@Deprecated(since = "11", forRemoval = true)
 public abstract class AbstractCtPackageAssert<T extends AbstractCtPackageAssert<T>> extends AbstractAssert<T, CtPackage> {
 	protected AbstractCtPackageAssert(CtPackage actual, Class<?> selfType) {
 		super(actual, selfType);
 	}
@@ -34,12 +38,12 @@
 	public T isEqualTo(CtPackage expected) {
 		assertNotNull(expected);
 
 		if (!actual.getSimpleName().equals(expected.getSimpleName())) {
 			throw new AssertionError(String.format("The actual package named %1$s isn't equals to the expected package named %2$s", actual.getSimpleName(), expected.getSimpleName()));
 		}
 
 		if (processors != null && !processors.isEmpty()) {
 			process(actual.getFactory(), processors);
 		}
 
 		class TypeComparator implements Comparator<CtType<?>> {
@@ -49,11 +53,11 @@
 			}
 		}
 
 		final List<CtType<?>> actualTypes = new ArrayList<>(actual.getTypes());
 		Collections.sort(actualTypes, new TypeComparator());
 		final List<CtType<?>> expectedTypes = new ArrayList<>(expected.getTypes());
 		Collections.sort(expectedTypes, new TypeComparator());
 		for (int i = 0; i < actual.getTypes().size(); i++) {
 			final CtType<?> actualType = actualTypes.get(i);
 			final CtType<?> expectedType = expectedTypes.get(i);
 			if (!actualType.toString().equals(expectedType.toString())) {
@@ -68,7 +72,7 @@
 			}
 		}
 
 		final List<CtPackage> actualPackages = new ArrayList<>(actual.getPackages());
 		Collections.sort(actualPackages, new PackageComparator());
 		final List<CtPackage> expectedPackages = new ArrayList<>(expected.getPackages());
 		Collections.sort(expectedPackages, new PackageComparator());
@@ -76,9 +80,9 @@
 		for (int i = 0; i < actualPackages.size(); i++) {
 			final CtPackage actualPackage = actualPackages.get(i);
 			final CtPackage expectedPackage = expectedPackages.get(i);
 			assertThat(actualPackage).isEqualTo(expectedPackage);
 		}
 
 		return this.myself;
 	}
 }

src/main/java/spoon/testing/AbstractFileAssert.java

@@ -5,7 +5,7 @@
  *
  * Spoon is available either under the terms of the MIT License (see LICENSE-MIT.txt) or the Cecill-C License (see LICENSE-CECILL-C.txt). You as the user are entitled to choose the terms under which to adopt Spoon.
  */
 package spoon.testing;
 
 import spoon.reflect.declaration.CtType;
 import spoon.reflect.factory.Factory;
@@ -13,12 +13,16 @@
 import java.io.File;
 import java.util.List;
 
 import static spoon.testing.utils.Check.assertExists;
 import static spoon.testing.utils.Check.assertNotNull;
 import static spoon.testing.utils.ModelUtils.build;
 import static spoon.testing.utils.ProcessorUtils.process;
 
+/**
+ * @deprecated Use {@code spoon.testing.assertions.SpoonAssertions} instead.
+ */
+@Deprecated(since = "11", forRemoval = true)
 public abstract class AbstractFileAssert<T extends AbstractFileAssert<T>> extends AbstractAssert<T, File> {
 	public AbstractFileAssert(File actual, Class<?> selfType) {
 		super(actual, selfType);
 	}
@@ -45,10 +49,10 @@
 		assertNotNull(expected);
 		assertExists(expected);
 
 		final Factory actualFactory = build(actual);
 		final Factory expectedFactory = build(expected);
 
 		process(actualFactory, processors);
 		final List<CtType<?>> allActual = actualFactory.Type().getAll();
 		final List<CtType<?>> allExpected = expectedFactory.Type().getAll();
 		for (int i = 0; i < allActual.size(); i++) {
@@ -58,6 +62,6 @@
 				throw new AssertionError(String.format("%1$s and %2$s aren't equals.", currentActual.getQualifiedName(), currentExpected.getQualifiedName()));
 			}
 		}
 		return this.myself;
 	}
 }

src/main/java/spoon/testing/Assert.java

@@ -5,50 +5,53 @@
  *
  * Spoon is available either under the terms of the MIT License (see LICENSE-MIT.txt) or the Cecill-C License (see LICENSE-CECILL-C.txt). You as the user are entitled to choose the terms under which to adopt Spoon.
  */
 package spoon.testing;
 
 import spoon.reflect.declaration.CtElement;
 import spoon.reflect.declaration.CtPackage;
 
 import java.io.File;
 
 import static spoon.testing.utils.Check.assertExists;
 import static spoon.testing.utils.Check.assertNotNull;
 
 /**
  * Entry point for assertion methods for different data types.
  * Each method in this class is a static factory for the type-specific
  * assertion objects. The purpose of this class is to make test code
  * more readable.
+ *
+ * @deprecated Use {@code spoon.testing.assertions.SpoonAssertions} instead.
  */
+@Deprecated(since = "11", forRemoval = true)
 public class Assert {
 	private Assert() { }
 	/**
 	 * Create a new instance of <code>{@link FileAssert}</code>.
 	 *
 	 * @param actual
 	 * 		The actual value.
 	 * @return the created assertion object.
 	 */
 	public static AbstractFileAssert<?> assertThat(String actual) {
 		return assertThat(new File(actual));
 	}
 
 	/**
 	 * Create a new instance of <code>{@link FileAssert}</code>.
 	 *
 	 * @param actual
 	 * 		The actual value.
 	 * @return the created assertion object.
 	 */
 	public static AbstractFileAssert<?> assertThat(File actual) {
 		assertNotNull(actual);
 		assertExists(actual);
 		return new FileAssert(actual);
 	}
 
 	/**
 	 * Create a new instance of <code>{@link CtElementAssert}</code>.
 	 * Note that a package typed by CtElement will call this method and
 	 * not {@link Assert#assertThat(CtPackage)}.
 	 *
@@ -56,13 +59,13 @@
 	 * 		The actual value.
 	 * @return the created assertion object.
 	 */
 	public static AbstractCtElementAssert<?> assertThat(CtElement actual) {
 		assertNotNull(actual);
 		return new CtElementAssert(actual);
 	}
 
 	/**
 	 * Create a new instance of <code>{@link CtPackageAssert}</code>.
 	 * Note that this assert will be make a deep equals with its content
 	 * (all types).
 	 *
@@ -70,8 +73,8 @@
 	 * 		The actual value.
 	 * @return the created assertion object.
 	 */
 	public static AbstractCtPackageAssert<?> assertThat(CtPackage actual) {
 		assertNotNull(actual);
 		return new CtPackageAssert(actual);
 	}
 }

src/main/java/spoon/testing/CtElementAssert.java

@@ -5,11 +5,15 @@
  *
  * Spoon is available either under the terms of the MIT License (see LICENSE-MIT.txt) or the Cecill-C License (see LICENSE-CECILL-C.txt). You as the user are entitled to choose the terms under which to adopt Spoon.
  */
 package spoon.testing;
 
 import spoon.reflect.declaration.CtElement;
 
+/**
+ * @deprecated Use {@code spoon.testing.assertions.SpoonAssertions} instead.
+ */
+@Deprecated(since = "11", forRemoval = true)
 public class CtElementAssert extends AbstractCtElementAssert<CtElementAssert> {
 	protected CtElementAssert(CtElement actual) {
 		super(actual, CtElementAssert.class);
 	}

src/main/java/spoon/testing/CtPackageAssert.java

@@ -5,11 +5,15 @@
  *
  * Spoon is available either under the terms of the MIT License (see LICENSE-MIT.txt) or the Cecill-C License (see LICENSE-CECILL-C.txt). You as the user are entitled to choose the terms under which to adopt Spoon.
  */
 package spoon.testing;
 
 import spoon.reflect.declaration.CtPackage;
 
+/**
+ * @deprecated Use {@code spoon.testing.assertions.SpoonAssertions} instead.
+ */
+@Deprecated(since = "11", forRemoval = true)
 public class CtPackageAssert extends AbstractCtPackageAssert<CtPackageAssert> {
 	public CtPackageAssert(CtPackage actual) {
 		super(actual, CtPackageAssert.class);
 	}

src/main/java/spoon/testing/FileAssert.java

@@ -5,11 +5,15 @@
  *
  * Spoon is available either under the terms of the MIT License (see LICENSE-MIT.txt) or the Cecill-C License (see LICENSE-CECILL-C.txt). You as the user are entitled to choose the terms under which to adopt Spoon.
  */
 package spoon.testing;
 
 import java.io.File;
 
+/**
+ * @deprecated Use {@code spoon.testing.assertions.SpoonAssertions} instead.
+ */
+@Deprecated(since = "11", forRemoval = true)
 public class FileAssert extends AbstractFileAssert<FileAssert> {
 	public FileAssert(File actual) {
 		super(actual, FileAssert.class);
 	}

src/main/java/spoon/testing/package-info.java

@@ -0,0 +1,21 @@
+/*
+ * SPDX-License-Identifier: (MIT OR CECILL-C)
+ *
+ * Copyright (C) 2006-2023 INRIA and contributors
+ *
+ * Spoon is available either under the terms of the MIT License (see LICENSE-MIT.txt) or the Cecill-C License (see LICENSE-CECILL-C.txt). You as the user are entitled to choose the terms under which to adopt Spoon.
+ */
+/**
+ * Deprecated assertion classes for Spoon elements.
+ *
+ * <p>Use {@code spoon.testing.assertions.SpoonAssertions} instead, which provides
+ * AssertJ-based fluent assertions for all Spoon types. Example:
+ * <pre>
+ *   import static spoon.testing.assertions.SpoonAssertions.assertThat;
+ *   assertThat(myCtClass).isEqualTo(otherCtClass);
+ * </pre>
+ *
+ * @deprecated Use {@code spoon.testing.assertions.SpoonAssertions} instead.
+ */
+@Deprecated(since = "11", forRemoval = true)
+package spoon.testing;

src/test/java/spoon/processing/CtGenerationTest.java

@@ -37,7 +37,7 @@
 import java.util.regex.Pattern;
 import java.util.stream.Stream;
 
-import static spoon.testing.Assert.assertThat;
+import static spoon.testing.assertions.SpoonAssertions.assertThat;
 import static spoon.testing.utils.ModelUtils.build;
 
 public class CtGenerationTest {

src/test/java/spoon/processing/ProcessingTest.java

@@ -16,6 +16,7 @@
  */
 package spoon.processing;
 
+import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;
 import spoon.Launcher;
@@ -29,16 +30,22 @@
 import spoon.test.processing.processors.MyProcessor;
 import spoon.test.template.testclasses.AssertToIfAssertedStatementTemplate;
 
+import spoon.reflect.declaration.CtType;
+import spoon.reflect.factory.Factory;
+import spoon.testing.utils.ModelTest;
+
 import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.List;
 
-import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
-import static spoon.testing.Assert.assertThat;
+import static spoon.testing.assertions.SpoonAssertions.assertThat;
+import static spoon.testing.utils.ModelUtils.build;
 
 public class ProcessingTest {
 
@@ -129,9 +136,9 @@ public void testNullPointerException() throws IOException {
 		l.setSourceOutputDirectory(path.toFile());
 		l.run();
 	}
-	
-	@Test
-	public void testTemplateNotInOutput() throws IOException {
+
+	@ModelTest("src/test/resources/spoon/test/template/SimpleIfAsserted.java")
+	public void testTemplateNotInOutput(Factory expectedFactory) throws IOException {
 		// https://github.com/INRIA/spoon/issues/2987
 		class AssertProcessor extends AbstractProcessor<CtAssert<?>> {
 			public void process(CtAssert<?> element) {
@@ -141,24 +148,29 @@ public void process(CtAssert<?> element) {
 				);
 			}
 		}
-		
+
 		String templatePath = "src/test/java/spoon/test/template/testclasses/AssertToIfAssertedStatementTemplate.java";
 		String resourcePath = "src/test/resources/spoon/test/template/";
-		
+
 		final Launcher l = new Launcher();
 		Path outputPath = Files.createTempDirectory("emptydir");
-		
+
 		l.addProcessor(new AssertProcessor());
 		l.addTemplateResource(new FileSystemFile(templatePath));
-		
+
 		l.addInputResource(resourcePath + "SimpleAssert.java");
 		l.setSourceOutputDirectory(outputPath.toFile());
 		l.run();
 
 		// If template is applied to itself then there will be modified spoon/...Template.java on output
-		assertArrayEquals(new String[]{"SimpleAssert.java"}, outputPath.toFile().list(), "Template source found in output");
+		Assertions.assertThat(outputPath.toFile().list())
+			.containsExactly("SimpleAssert.java");
 		// Check that the template worked as intended
-		assertThat(outputPath.toString() + "/SimpleAssert.java")
-			.isEqualTo(resourcePath + "SimpleIfAsserted.java");
+		List<CtType<?>> actualTypes = build(new File(outputPath.toString() + "/SimpleAssert.java")).Type().getAll();
+		List<CtType<?>> expectedTypes = expectedFactory.Type().getAll();
+		Assertions.assertThat(actualTypes).hasSameSizeAs(expectedTypes);
+		for (int i = 0; i < actualTypes.size(); i++) {
+			assertThat(actualTypes.get(i)).isEqualTo(expectedTypes.get(i));
+		}
 	}
 }

src/test/java/spoon/support/TypeAdaptorTest.java

@@ -27,7 +27,7 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
-import static spoon.testing.Assert.assertThat;
+import static spoon.testing.assertions.SpoonAssertions.assertThat;
 
 class TypeAdaptorTest {
 

src/test/java/spoon/test/fieldaccesses/FieldAccessTest.java

@@ -65,7 +65,7 @@
 import static org.junit.jupiter.api.Assertions.assertSame;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
-import static spoon.testing.Assert.assertThat;
+import static spoon.testing.assertions.SpoonAssertions.assertThat;
 import static spoon.testing.utils.ModelUtils.build;
 import static spoon.testing.utils.ModelUtils.buildClass;
 
@@ -332,7 +332,7 @@ public void testTypeDeclaredInAnonymousClass() throws Exception {
 
 		assertEquals(1, elements.size());
 		assertTrue(elements.get(0).getType().getDeclaringType().isAnonymous());
-		assertThat(elements.get(0)).isEqualTo("private final Test test = new Test();");
+		assertThat(elements.get(0)).hasToString("private final Test test = new Test();");
 	}
 
 	@Test

src/test/java/spoon/test/pkg/PackageTest.java

@@ -69,7 +69,7 @@
 import static org.junit.jupiter.api.Assertions.assertSame;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
-import static spoon.testing.Assert.assertThat;
+import static spoon.testing.assertions.SpoonAssertions.assertThat;
 import static spoon.testing.utils.ModelUtils.canBeBuilt;
 import static spoon.testing.utils.ModelUtils.createFactory;
 

src/test/java/spoon/testing/AbstractAssertTest.java

@@ -16,42 +16,43 @@
  */
 package spoon.testing;
 
-import org.junit.jupiter.api.Test;
+import org.assertj.core.api.Assertions;
 import spoon.processing.AbstractProcessor;
 import spoon.reflect.declaration.CtField;
 import spoon.reflect.declaration.CtType;
+import spoon.reflect.factory.Factory;
 import spoon.testing.processors.FooToBarProcessor;
+import spoon.testing.utils.ByClass;
+import spoon.testing.utils.ModelTest;
+import spoon.testing.utils.ProcessorUtils;
 
-import static spoon.testing.Assert.assertThat;
-import static spoon.testing.utils.ModelUtils.buildNoClasspath;
+import java.io.File;
+import java.util.List;
 
-public class AbstractAssertTest {
-	public static final String PATH = "./src/test/java/spoon/testing/testclasses/";
-
-	@Test
-	public void testTransformationWithProcessorInstantiated() {
-		assertThat(PATH + "Foo.java").withProcessor(new FooToBarProcessor()).isEqualTo(PATH + "Bar.java");
-	}
+import static spoon.testing.assertions.SpoonAssertions.assertThat;
+import static spoon.testing.utils.ModelUtils.build;
 
-	@Test
-	public void testTransformationWithProcessorClass() {
-		assertThat(PATH + "Foo.java").withProcessor(FooToBarProcessor.class).isEqualTo(PATH + "Bar.java");
-	}
+public class AbstractAssertTest {
 
-	@Test
-	public void testTransformationWithProcessorName() {
-		assertThat(PATH + "Foo.java").withProcessor(FooToBarProcessor.class.getName()).isEqualTo(PATH + "Bar.java");
+	@ModelTest("./src/test/java/spoon/testing/testclasses/Foo.java")
+	public void testTransformationWithProcessor(Factory actual) {
+		ProcessorUtils.process(actual, List.of(new FooToBarProcessor()));
+		List<CtType<?>> actualTypes = actual.Type().getAll();
+		List<CtType<?>> expectedTypes = build(new File("./src/test/java/spoon/testing/testclasses/Bar.java")).Type().getAll();
+		Assertions.assertThat(actualTypes).containsExactlyElementsOf(expectedTypes);
 	}
 
-	@Test
-	public void testTransformationFromCtElementWithProcessor() throws Exception {
+	@ModelTest("./src/test/java/spoon/testing/CtElementAssertTest.java")
+	public void testTransformationFromCtElementWithProcessor(
+		@ByClass(CtElementAssertTest.class) CtType<CtElementAssertTest> type, Factory factory) throws Exception {
 		class MyProcessor extends AbstractProcessor<CtField<?>> {
 			@Override
 			public void process(CtField<?> element) {
 				element.setSimpleName("j");
 			}
 		}
-		final CtType<CtElementAssertTest> type = buildNoClasspath(CtElementAssertTest.class).Type().get(CtElementAssertTest.class);
-		assertThat(type.getField("i")).withProcessor(new MyProcessor()).isEqualTo("public int j;");
+		CtField<?> field = type.getField("i");
+		ProcessorUtils.process(factory, List.of(new MyProcessor()));
+		Assertions.assertThat(field.toString()).isEqualTo("public int j;");
 	}
 }

src/test/java/spoon/testing/CtElementAssertTest.java

@@ -16,24 +16,25 @@
  */
 package spoon.testing;
 
+import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
 import spoon.reflect.code.CtFieldAccess;
 import spoon.reflect.declaration.CtField;
 import spoon.reflect.declaration.CtType;
 import spoon.reflect.declaration.ModifierKind;
 import spoon.reflect.factory.Factory;
+import spoon.testing.utils.ByClass;
+import spoon.testing.utils.ModelTest;
 
-import static org.junit.jupiter.api.Assertions.assertThrows;
-import static spoon.testing.Assert.assertThat;
-import static spoon.testing.utils.ModelUtils.buildNoClasspath;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static spoon.testing.assertions.SpoonAssertions.assertThat;
 import static spoon.testing.utils.ModelUtils.createFactory;
 
 public class CtElementAssertTest {
 	public int i;
 
-	@Test
-	public void testEqualityBetweenTwoCtElement() throws Exception {
-		final CtType<CtElementAssertTest> type = buildNoClasspath(CtElementAssertTest.class).Type().get(CtElementAssertTest.class);
+	@ModelTest("./src/test/java/spoon/testing/CtElementAssertTest.java")
+	public void testEqualityBetweenTwoCtElement(@ByClass(CtElementAssertTest.class) CtType<CtElementAssertTest> type) throws Exception {
 		final Factory factory = createFactory();
 		final CtField<Integer> expected = factory.Core().createField();
 		expected.setSimpleName("i");
@@ -43,29 +44,31 @@ public void testEqualityBetweenTwoCtElement() throws Exception {
 		assertThat(f).isEqualTo(expected);
 	}
 
-	@Test
-	public void testEqualityBetweenACtElementAndAString() throws Exception {
-		final CtType<CtElementAssertTest> type = buildNoClasspath(CtElementAssertTest.class).Type().get(CtElementAssertTest.class);
-		assertThat(type.getField("i")).isEqualTo("public int i;");
+	@ModelTest("./src/test/java/spoon/testing/CtElementAssertTest.java")
+	public void testEqualityBetweenACtElementAndAString(@ByClass(CtElementAssertTest.class) CtType<CtElementAssertTest> type) throws Exception {
+		Assertions.assertThat(type.getField("i").toString()).isEqualTo("public int i;");
 	}
 
 	@Test
 	public void testEqualityBetweenTwoCtElementWithTypeDifferent() {
-		assertThrows(AssertionError.class, ()-> assertThat(createFactory().Core().createAnnotation()).isEqualTo(createFactory().Core().createBlock()));
+		assertThatThrownBy(() -> assertThat(createFactory().Core().createAnnotation()).isEqualTo(createFactory().Core().createBlock()))
+			.isInstanceOf(AssertionError.class);
 	}
 
-	@Test
-	public void testEqualityBetweenTwoCtElementWithTheSameSignatureButNotTheSameContent() throws Exception {
-		assertThrows(AssertionError.class, ()-> assertThat(buildNoClasspath(CtElementAssertTest.class).Type().get(CtElementAssertTest.class)).isEqualTo(createFactory().Class().create(CtElementAssertTest.class.getName())));
+	@ModelTest("./src/test/java/spoon/testing/CtElementAssertTest.java")
+	public void testEqualityBetweenTwoCtElementWithTheSameSignatureButNotTheSameContent(
+		@ByClass(CtElementAssertTest.class) CtType<CtElementAssertTest> actual, Factory factory) {
+		assertThatThrownBy(() -> assertThat(actual).isEqualTo(factory.Class().create(CtElementAssertTest.class.getName())))
+			.isInstanceOf(AssertionError.class);
 	}
 
-	@Test
-	public void testEqualityBetweenTwoDifferentCtElement() throws Exception {
+	@ModelTest("./src/test/java/spoon/testing/CtElementAssertTest.java")
+	public void testEqualityBetweenTwoDifferentCtElement(Factory factory) throws Exception {
 		class String {
 		}
-		final Factory build = buildNoClasspath(CtElementAssertTest.class);
-		final CtFieldAccess<Class<String>> actual = build.Code().createClassAccess(build.Type().<String>get(String.class).getReference());
+		final CtFieldAccess<Class<String>> actual = factory.Code().createClassAccess(factory.Type().<String>get(String.class).getReference());
 		final CtFieldAccess<Class<java.lang.String>> expected = createFactory().Code().createClassAccess(createFactory().Type().stringType());
-		assertThrows(AssertionError.class, ()-> assertThat(actual).isEqualTo(expected));
+		assertThatThrownBy(() -> assertThat(actual).isEqualTo(expected))
+			.isInstanceOf(AssertionError.class);
 	}
 }