introduced Interval to find grids

Author: Torsten-Mumme

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

@@ -90,7 +90,18 @@ public ChunkUIElementValidator areAlignedAsGridCells() {
 
     public void validateAlignedAsGridCells(List<UIElement> rootElements) {
         if (this.rootElements.size() == 2) {
-            errors.add("banane");
+            for (int firstIndex = 0; firstIndex < rootElements.size(); firstIndex++) {
+                UIElement first = rootElements.get(firstIndex);
+                for (int secondIndex = firstIndex+1; secondIndex < rootElements.size(); secondIndex++) {
+                    UIElement second = rootElements.get(secondIndex);
+                    if (first.hasRightElement(second) && first.hasBelowElement(second)) {
+
+                    }else{
+                        errors.add("banane");
+                    }
+                }
+
+            }
         }
     }
 

src/main/java/net/itarray/automotion/internal/geometry/Interval.java

@@ -0,0 +1,47 @@
+package net.itarray.automotion.internal.geometry;
+
+import java.util.Objects;
+
+import static java.lang.String.format;
+
+public class Interval {
+    private final Scalar begin;
+    private final Scalar end;
+
+    public Interval(Scalar begin, Scalar end) {
+        this.begin = begin;
+        this.end = end;
+    }
+
+    @Override
+    public String toString() {
+        return format("[%s, %s[", begin, end);
+    }
+
+    @Override
+    public boolean equals(Object object) {
+        if (!(object instanceof Interval)) {
+            return false;
+        }
+        Interval other = (Interval) object;
+        if (isEmpty()) {
+            return other.isEmpty();
+        }
+        return begin.equals(other.begin) && end.equals(other.end);
+    }
+
+    @Override
+    public int hashCode() {
+        return isEmpty()? 0 : Objects.hash(begin, end);
+    }
+
+    public boolean isEmpty() {
+        return end.isLessOrEqualTo(begin);
+    }
+
+    public Interval intersect(Interval interval) {
+        return new Interval(
+                begin.isLessOrEqualTo(interval.begin) ? interval.begin : begin,
+                end.isLessOrEqualTo(interval.end) ? end : interval.end);
+    }
+}

src/main/java/net/itarray/automotion/validation/ChunkUIElementValidator.java

@@ -15,6 +15,21 @@
                 @Element({10, 20, 30, 35}),
                 @Element({15, 25, 35, 50}),
         }),
+        @Chunk(id = "two_horizontally_overlapping",
+                description = "two elements which horizontally projections overlap", elements ={
+                @Element({10, 20, 30, 35}),
+                @Element({15, 40, 35, 50}),
+        }),
+        @Chunk(id = "two_vertically_overlapping",
+                description = "two elements which vertically projections overlap", elements ={
+                @Element({10, 20, 30, 35}),
+                @Element({40, 25, 60, 50}),
+        }),
+        @Chunk(id = "two_not_overlapping_in_any_direction",
+                description = "two elements which horizontal and vertical projections don not overlap", elements ={
+                @Element({10, 20, 30, 35}),
+                @Element({40, 40, 60, 60}),
+        }),
         @Chunk(id = "three",
                 description ="three elements with different sizes in a row with different gutters", elements ={
                 @Element({100, 50,  300, 60}),
@@ -64,10 +79,13 @@ public interface ChunkUIElementValidator {
             @Scenario(chunk = "empty"),
             @Scenario(chunk = "one"),
             @Scenario(chunk = "seven"),
+            @Scenario(chunk = "two_not_overlapping_in_any_direction"),
     })
     @NotValid({
             @Scenario(chunk = "empty", oneOrMore = true),
             @Scenario(chunk = "two_overlapping"),
+            @Scenario(chunk = "two_horizontally_overlapping"),
+            @Scenario(chunk = "two_vertically_overlapping"),
     })
     ChunkUIElementValidator areAlignedAsGridCells();
 

src/test/java/net/itarray/automotion/tests/geometry/EmptyIntervalTest.java

@@ -0,0 +1,39 @@
+package net.itarray.automotion.tests.geometry;
+
+import net.itarray.automotion.internal.geometry.Interval;
+import net.itarray.automotion.internal.geometry.Scalar;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class EmptyIntervalTest {
+
+    private Scalar begin;
+    private Scalar end;
+    private Interval interval;
+
+    @Before
+    public void setUp() {
+        begin = new Scalar(17);
+        end = new Scalar(10);
+        interval = new Interval(begin, end);
+    }
+
+    @Test
+    public void isEmpty() {
+        assertThat(interval.isEmpty()).isTrue();
+    }
+
+    @Test
+    public void isEqualToIntervalsOtherEmptyIntervals() {
+        assertThat(interval).isEqualTo(new Interval(new Scalar(100), new Scalar(99)));
+        assertThat(interval.hashCode()).isEqualTo(new Interval(new Scalar(100), new Scalar(99)).hashCode());
+    }
+
+    @Test
+    public void isNotEqualToNonEmptyIntervals() {
+        assertThat(interval).isNotEqualTo(new Interval(new Scalar(10), new Scalar(20)));
+    }
+
+}

src/test/java/net/itarray/automotion/tests/geometry/IntervalTest.java

@@ -0,0 +1,87 @@
+package net.itarray.automotion.tests.geometry;
+
+import net.itarray.automotion.internal.geometry.Interval;
+import net.itarray.automotion.internal.geometry.Scalar;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class IntervalTest {
+
+    private Scalar begin;
+    private Scalar end;
+    private Interval interval;
+
+    @Before
+    public void setUp() {
+        begin = new Scalar(10);
+        end = new Scalar(17);
+        interval = new Interval(begin, end);
+    }
+
+    @Test
+    public void isEqualToIntervalsWithEqualBeginAndEnd() {
+        assertThat(interval).isEqualTo(new Interval(begin, end));
+        assertThat(interval.hashCode()).isEqualTo(new Interval(begin, end).hashCode());
+    }
+
+    @Test
+    public void isNotEqualToIntervalsWithDifferentBegin() {
+        assertThat(interval).isNotEqualTo(new Interval(begin.plus(1), end));
+    }
+
+    @Test
+    public void isNotEqualToIntervalsWithDifferentEnd() {
+        assertThat(interval).isNotEqualTo(new Interval(begin, end.plus(1)));
+    }
+
+    @Test
+    public void isNotEmpty() {
+        assertThat(interval.isEmpty()).isFalse();
+    }
+
+    @Test
+    public void isNotEqualToEmptyIntervals() {
+        assertThat(interval).isNotEqualTo(new Interval(begin, begin));
+    }
+
+    @Test
+    public void intersectionWithIntervalBeforeIsEmpty() {
+        Interval intersection = interval.intersect(new Interval(begin.minus(10), begin.minus(5)));
+        assertThat(intersection.isEmpty()).isTrue();
+    }
+
+    @Test
+    public void intersectionWithIntervalBeforeButTouchingIsEmpty() {
+        Interval intersection = interval.intersect(new Interval(begin.minus(10), begin));
+        assertThat(intersection.isEmpty()).isTrue();
+    }
+
+    @Test
+    public void intersectionWithIntervalContainingBeginIsNotEmpty() {
+        Interval intersection = interval.intersect(new Interval(begin.minus(10), begin.plus(1)));
+        assertThat(intersection.isEmpty()).isFalse();
+        assertThat(intersection).isEqualTo(new Interval(begin, begin.plus(1)));
+    }
+
+    @Test
+    public void intersectionWithIntervalContainingAPointJustBeforeEndIsNotEmpty() {
+        Interval intersection = interval.intersect(new Interval(end.minus(1), end.plus(10)));
+        assertThat(intersection.isEmpty()).isFalse();
+        assertThat(intersection).isEqualTo(new Interval(end.minus(1), end));
+    }
+
+    @Test
+    public void intersectionWithIntervalAfterIsEmpty() {
+        Interval intersection = interval.intersect(new Interval(end.plus(5), end.plus(10)));
+        assertThat(intersection.isEmpty()).isTrue();
+    }
+
+    @Test
+    public void intersectionWithIntervalAfterButTouchingIsEmpty() {
+        Interval intersection = interval.intersect(new Interval(end, end.plus(10)));
+        assertThat(intersection.isEmpty()).isTrue();
+    }
+
+}