ConstraintTest.java

/*
 * Copyright (c) 2021 Mārtiņš Avots (Martins Avots) and others
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License 2.0, which is available at
 * http://www.eclipse.org/legal/epl-2.0, or the MIT License,
 * which is available at https://spdx.org/licenses/MIT.html.
 *
 * SPDX-License-Identifier: EPL-2.0 OR MIT
 */
package net.splitcells.gel.constraint;

import net.splitcells.gel.constraint.type.ForAlls;
import org.junit.jupiter.api.Test;

import static net.splitcells.dem.data.set.list.Lists.list;
import static net.splitcells.dem.data.set.list.Lists.toList;
import static net.splitcells.gel.constraint.Constraint.incomingGroupsOfConstraintPath;
import static net.splitcells.gel.constraint.type.ForAlls.forAll;
import static net.splitcells.gel.data.table.attribute.AttributeI.attribute;
import static net.splitcells.gel.solution.SolutionBuilder.defineProblem;
import static net.splitcells.gel.solution.optimization.primitive.LinearInitialization.linearInitialization;
import static org.assertj.core.api.Assertions.assertThat;

public class ConstraintTest {

    @Test
    public void test_incomingGroupsOfConstraintPath() {
        final var attribute = attribute(Integer.class, "a");
        final int valueA = 1;
        final int valueB = 3;
        final var solution = defineProblem()
                .withDemandAttributes(attribute)
                .withDemands
                        (list
                                (list(valueA)
                                        , list(valueB)
                                        , list(valueA)
                                        , list(valueB)))
                .withSupplyAttributes()
                .withEmptySupplies(4)
                .withConstraint
                        (ForAlls.forEach(attribute)
                                .withChildren(ForAlls.forEach(attribute)
                                        , ForAlls.forEach(attribute)
                                                .withChildren(ForAlls.forEach(attribute))))
                .toProblem()
                .asSolution();
        solution.optimize(linearInitialization());
        final var testVerifier = solution.constraint().childrenView().get(1).childrenView().get(0);
        final var allocations = incomingGroupsOfConstraintPath
                (list
                        (solution.constraint()
                                , solution.constraint().childrenView().get(1)
                                , testVerifier))
                .stream()
                .map(e -> testVerifier.complying(e))
                .flatMap(e -> e.stream())
                .collect(toList());
        assertThat(solution.getLines()).hasSize(4);
        assertThat(allocations).containsAll(solution.getLines());
    }

    @Test
    public void testAllocationGroups() {
        final var constraint_1 = forAll();
        final var constraint_2 = forAll();
        final var constraint_3 = forAll();
        final var constraint_4 = forAll();
        final var constraint_5 = forAll();
        @SuppressWarnings("unchecked") final var solution
                = defineProblem()
                .withDemandAttributes()
                .withSupplyAttributes()
                .withConstraint(constraint_1
                        .withChildren(constraint_2)
                        .withChildren(constraint_3
                                .withChildren(constraint_4)
                                .withChildren(constraint_5)))
                .toProblem()
                .asSolution();
        final var testProduct = Constraint.allocationGroups(solution.constraint());
        assertThat(testProduct.get(0)).containsExactly(constraint_1);
        assertThat(testProduct.get(1)).containsExactly(constraint_1, constraint_2);
        assertThat(testProduct.get(2)).containsExactly(constraint_1, constraint_3);
        assertThat(testProduct.get(3)).containsExactly(constraint_1, constraint_3, constraint_4);
        assertThat(testProduct.get(4)).containsExactly(constraint_1, constraint_3, constraint_5);
        assertThat(testProduct).hasSize(5);
    }

    @Test
    public void test_allocation_groups_with_different_attributes() {
        final var A = attribute(Integer.class, "a");
        final var B = attribute(Integer.class, "b");
        final var C = attribute(Integer.class, "c");
        final var D = attribute(Integer.class, "d");
        final var solution = defineProblem()
                .withDemandAttributes(A, B)
                .withSupplyAttributes(C, D)
                .withConstraint(
                        ForAlls.forEach(A)
                                .withChildren(ForAlls.forEach(B)
                                        , ForAlls.forEach(C)
                                                .withChildren(ForAlls.forEach(D))))
                .toProblem()
                .asSolution();
        final var testData = Constraint.allocationGroups(solution.constraint());
        assertThat(testData).hasSize(4);
        assertThat(testData.get(0)).isEqualTo(list(solution.constraint()));
        assertThat(testData.get(1))
                .isEqualTo(list
                        (solution.constraint()
                                , solution.constraint().childrenView().get(0)));
        assertThat(testData.get(2))
                .isEqualTo(list
                        (solution.constraint()
                                , solution.constraint().childrenView().get(1)));
        assertThat(testData.get(3))
                .isEqualTo(list
                        (solution.constraint()
                                , solution.constraint().childrenView().get(1)
                                , solution.constraint().childrenView().get(1)
                                        .childrenView().get(0)));
    }
}