fixup! fix containsInArchitecture check adding wrong object

Signed-off-by: Peter Gafert <peter.gafert@archunit.org>

archunit/src/test/java/com/tngtech/archunit/testutil/assertion/ArchRuleCheckAssertion.java

@@ -1,11 +1,13 @@
 package com.tngtech.archunit.testutil.assertion;
 
+import java.util.Collection;
 import java.util.List;
 import java.util.Optional;
-import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.Set;
 import java.util.function.Predicate;
 
 import com.google.common.base.Joiner;
+import com.google.common.collect.ImmutableSet;
 import com.tngtech.archunit.core.domain.JavaClasses;
 import com.tngtech.archunit.lang.ArchRule;
 import com.tngtech.archunit.lang.EvaluationResult;
@@ -81,22 +83,24 @@ public ArchRuleCheckAssertion hasOnlyOneViolation(Predicate<Object> correspondin
                 .first().isEqualTo(violationMessage);
         assertThat(error.get().getMessage()).contains(violationMessage);
 
-        AtomicBoolean violationsMatch = new AtomicBoolean(false);
-        evaluationResult.handleViolations((objects, message) -> {
-            if (!violationsMatch.get()) {
-                violationsMatch.set(
-                        objects.size() == 1
-                                && correspondingObjectPredicate.test(getOnlyElement(objects))
-                                && message.equals(violationMessage)
-                );
-            }
-        });
-        assertThat(violationsMatch.get())
-                .as("Some violation matches corresponding object predicate and message")
+        Set<HandledViolation> handledViolations = getHandledViolations(evaluationResult);
+        HandledViolation handledViolation = getOnlyElement(handledViolations);
+        Object correspondingObject = getOnlyElement(handledViolation.correspondingObjects);
+        assertThat(correspondingObjectPredicate.test(correspondingObject))
+                .as("corresponding object satisfies predicate")
                 .isTrue();
+        assertThat(handledViolation.violationMessage).as("violation message").isEqualTo(violationMessage);
         return this;
     }
 
+    private Set<HandledViolation> getHandledViolations(EvaluationResult evaluationResult) {
+        ImmutableSet.Builder<HandledViolation> result = ImmutableSet.builder();
+        evaluationResult.handleViolations((objects, message) -> {
+            result.add(new HandledViolation(objects, message));
+        });
+        return result.build();
+    }
+
     public ArchRuleCheckAssertion hasOnlyOneViolationWithStandardPattern(Class<?> violatingClass, String violationDescription) {
         String violationMessage = toViolationMessage(violatingClass, violationDescription);
         return hasOnlyOneViolation(violationMessage);
@@ -153,4 +157,14 @@ public void hasNoViolation() {
     private String toViolationMessage(Class<?> violatingClass, String violationDescription) {
         return "Class <" + violatingClass.getName() + "> " + violationDescription + " in (" + violatingClass.getSimpleName() + ".java:0)";
     }
+
+    private static class HandledViolation {
+        private final Collection<Object> correspondingObjects;
+        private final String violationMessage;
+
+        HandledViolation(Collection<Object> correspondingObjects, String violationMessage) {
+            this.correspondingObjects = correspondingObjects;
+            this.violationMessage = violationMessage;
+        }
+    }
 }