fix test and improve code

Author: krusche

src/main/java/de/tum/in/test/api/internal/sanitization/ThrowableSets.java

@@ -33,19 +33,19 @@ final class ThrowableSets {
 	private static final String OPENTEST4J_CHECK_CLASS = "org.opentest4j.AssertionFailedError"; //$NON-NLS-1$
 
 	static {
-		HashSet<Class<? extends Throwable>> join = new HashSet<>(Java.SAFE_TYPES);
-		join.addAll(Own.SAFE_TYPES);
+		HashSet<Class<? extends Throwable>> safeTypesJoin = new HashSet<>(Java.SAFE_TYPES);
+		safeTypesJoin.addAll(Own.SAFE_TYPES);
 		if (classCanBeFound(JUNIT4_CHECK_CLASS))
-			join.addAll(JUnit4.SAFE_TYPES);
+			safeTypesJoin.addAll(JUnit4.SAFE_TYPES);
 		if (classCanBeFound(JUNIT5_CHECK_CLASS))
-			join.addAll(JUnit5.SAFE_TYPES);
+			safeTypesJoin.addAll(JUnit5.SAFE_TYPES);
 		if (classCanBeFound(JQWIK_CHECK_CLASS))
-			join.addAll(Jqwik.SAFE_TYPES);
+			safeTypesJoin.addAll(Jqwik.SAFE_TYPES);
 		if (classCanBeFound(ASSERTJ_CHECK_CLASS))
-			join.addAll(AssertJ.SAFE_TYPES);
+			safeTypesJoin.addAll(AssertJ.SAFE_TYPES);
 		if (classCanBeFound(OPENTEST4J_CHECK_CLASS))
-			join.addAll(OpenTest4J.SAFE_TYPES);
-		SAFE_TYPES = Collections.unmodifiableSet(join);
+			safeTypesJoin.addAll(OpenTest4J.SAFE_TYPES);
+		SAFE_TYPES = Collections.unmodifiableSet(safeTypesJoin);
 	}
 
 	private ThrowableSets() {

src/main/java/de/tum/in/test/api/internal/sanitization/ThrowableUtils.java

@@ -77,8 +77,7 @@ static <T extends Throwable> Constructor<T> findPreferredConstructor(Class<T> ty
 		var classPropertyTypeCount = getRelevantPropertiesWithMethods(type, IGNORE_PROPERTIES).stream()
 				.collect(Collectors.groupingBy(property -> property.getValue().getReturnType(), Collectors.counting()));
 		return Stream.of(allConstructors)
-				.filter(constructor -> isSatisfiableByProperties(constructor, classPropertyTypeCount))
-				.sorted(getConstructorPreferenceOrder()).findFirst().orElse(allConstructors[0]);
+                .filter(constructor -> isSatisfiableByProperties(constructor, classPropertyTypeCount)).min(getConstructorPreferenceOrder()).orElse(allConstructors[0]);
 	}
 
 	static boolean isSatisfiableByProperties(Constructor<?> constructor,

src/test/java/de/tum/in/test/api/internal/sanitization/ThrowableUtilsTest.java

@@ -36,7 +36,8 @@ class ThrowableUtilsTest {
 	private static final Set<String> FALSE_POSITIVES = Set.of( //
 			"junit.framework.AssertionFailedError", // deviation for null message is not an issue
 			"java.util.IllformedLocaleException", // we don't need the index attribute itself
-			"java.awt.HeadlessException" // CI systems don't like this, but the constructor works
+			"java.awt.HeadlessException", // CI systems don't like this, but the constructor works
+			"org.assertj.core.util.introspection.IntrospectionError" // this is a wrapper for a Throwable, so it is not an issue
 	);
 
 	private static final Set<Class<?>> SAFE_PROPERTY_TYPES = Set.of(Throwable.class, Throwable[].class);
@@ -56,7 +57,7 @@ void testConstructorInstantiation() {
 			return !validate(type, preferredConstructor);
 		}).sorted(Comparator.comparing(Object::toString)).collect(Collectors.toList());
 		assertThat(duplicationFailures)
-				.as("the default Throwable duplication works for all SAFE_TYPE classes that are not specially handeled")
+				.as("the default Throwable duplication works for all SAFE_TYPE classes that are not specially handled")
 				.isEmpty();
 	}
 
@@ -89,18 +90,16 @@ void checkProperties() {
 				.map(Method::getReturnType).distinct().filter(type -> {
 					Class<?> containedType;
 					if (type.isArray())
-						containedType = Stream.<Class<?>>iterate(type, Class::getComponentType)
-								.takeWhile(Objects::nonNull).reduce(null, (a, b) -> b);
+						containedType = Stream.<Class<?>>iterate(type, Objects::nonNull, Class::getComponentType).reduce(null, (a, b) -> b);
 					else
 						containedType = type;
-					if (containedType.isPrimitive())
+                    assertThat(containedType).isNotNull();
+                    if (containedType.isPrimitive())
 						return false;
 					if (Modifier.isFinal(containedType.getModifiers()))
 						return false;
-					if (SAFE_PROPERTY_TYPES.stream().anyMatch(safeType -> safeType.isAssignableFrom(containedType)))
-						return false;
-					return true;
-				}).collect(Collectors.toSet());
+                    return SAFE_PROPERTY_TYPES.stream().noneMatch(safeType -> safeType.isAssignableFrom(containedType));
+                }).collect(Collectors.toSet());
 		assertThat(potentiallyUnsafeProperties).as("property types are all safe or sanitizable").isEmpty();
 	}