fixed validateSuccessor messages

Author: Torsten-Mumme

src/main/java/net/itarray/automotion/internal/UIElement.java

@@ -7,7 +7,6 @@
 import net.itarray.automotion.internal.geometry.Rectangle;
 import net.itarray.automotion.internal.geometry.Scalar;
 import net.itarray.automotion.internal.geometry.Vector;
-import net.itarray.automotion.internal.properties.ConstantExpression;
 import net.itarray.automotion.internal.properties.Context;
 import net.itarray.automotion.tools.general.SystemHelper;
 import net.itarray.automotion.tools.helpers.TextFinder;
@@ -337,15 +336,14 @@ public void validateIsAbove(UIElement element, Condition<Scalar> condition, Cont
 
     public void validateSuccessor(Direction direction, UIElement toBeValidatedSuccessor, Condition<Scalar> condition, Context context) {
         Expression<Scalar> signedDistance = Expression.signedDistance(end(direction), toBeValidatedSuccessor.begin(direction), direction);
-        if (!condition.isSatisfiedOn(signedDistance, context, direction)) {
-            context.add(String.format("%s element aligned not properly. Expected margin should be %s. Actual margin is %s",
-                                direction.afterName(),
-                                condition.getDescription(context, direction),
-                                signedDistance.evaluateIn(context, direction).toStringWithUnits(PIXELS)));
+        Expression<Boolean> assertion = condition.applyTo(signedDistance, direction.afterName() + " element aligned not properly. Expected margin should be %2$s. Actual margin is %4$s");
+        if (!assertion.evaluateIn(context, direction)) {
+            context.add(assertion.getDescription(context, direction));
             context.draw(toBeValidatedSuccessor);
         }
     }
 
+
     public void validateOverlappingWithElement(UIElement element, Context context) {
         if (!overlaps(element, context)) {
             context.add(String.format("Element %s is not overlapped with element %s but should be",

src/main/java/net/itarray/automotion/internal/properties/ConditionedExpression.java

@@ -10,10 +10,16 @@ public class ConditionedExpression<T> implements Expression<Boolean> {
 
     private final Expression<T> toBeConditioned;
     private final Condition<T> toBeApplied;
+    private final String messageFormat;
 
     public ConditionedExpression(Expression<T> toBeConditioned, Condition<T> toBeApplied) {
+        this(toBeConditioned, toBeApplied, "Expected %1$s to be %2$s. Actual %3$s is: %4$s");
+    }
+
+    public ConditionedExpression(Expression<T> toBeConditioned, Condition<T> toBeApplied, String messageFormat) {
         this.toBeConditioned = toBeConditioned;
         this.toBeApplied = toBeApplied;
+        this.messageFormat = messageFormat;
     }
 
     @Override
@@ -24,7 +30,7 @@ public <V extends MetricSpace<V>> Boolean evaluateIn(Context context, ExtendGivi
     @Override
     public <V extends MetricSpace<V>> String getDescription(Context context, ExtendGiving<V> direction) {
         T t = toBeConditioned.evaluateIn(context, direction);
-        return String.format("Expected %s to be %s. Actual %s is: %s",
+        return String.format(messageFormat,
                 toBeConditioned.getDescription(context, direction),
                 toBeApplied.getDescription(context, direction),
                 toBeConditioned.getRepeatedDescription(context, direction),

src/main/java/net/itarray/automotion/validation/properties/Condition.java

@@ -127,5 +127,9 @@ default Expression<Boolean> applyTo(Expression<T> toBeConditioned) {
         return new ConditionedExpression<>(toBeConditioned, this);
     }
 
+    default Expression<Boolean> applyTo(Expression<T> toBeConditioned, String messageFormat) {
+        return new ConditionedExpression<>(toBeConditioned, this, messageFormat);
+    }
+
     <V extends MetricSpace<V>> String getDescription(Context context, ExtendGiving<V> direction);
 }

src/main/java/net/itarray/automotion/validation/properties/Expression.java

@@ -40,16 +40,16 @@ static <V extends MetricSpace<V>> Expression<Boolean> equalTo(Expression<V> left
         return new BinaryExpression<>(
                 left,
                 right,
-                (scalar, other, context) -> scalar.minus(other).norm().isLessOrEqualTo(context.getTolerance()),
+                (vector, other, context) -> vector.minus(other).norm().isLessOrEqualTo(context.getTolerance()),
                 "Expected %1$s to be equal to %2$s.");
     }
 
     static <V extends MetricSpace<V>> Expression<V> signedDistance(Expression<V> left, Expression<V> right, ExtendGiving<V> extendGiving) {
         return new BinaryExpression<>(
                 left,
                 right,
-                (scalar, other, context) -> extendGiving.signedDistance(scalar, other),
-                "Expected %1$s to be equal to %2$s.");
+                (vector, other, context) -> extendGiving.signedDistance(vector, other),
+                "offset of %1$s from %2$s");
     }
 
     <V extends MetricSpace<V>> T evaluateIn(Context context, ExtendGiving<V> direction);