diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/AbstractRule.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/AbstractRule.java index 5b8e4454e..c243d840b 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/AbstractRule.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/AbstractRule.java @@ -1,17 +1,15 @@ package at.ac.tuwien.kr.alpha.commons.programs.rules; -import java.util.Collections; -import java.util.LinkedHashSet; -import java.util.List; -import java.util.Objects; -import java.util.Set; - -import org.apache.commons.collections4.SetUtils; - import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; import at.ac.tuwien.kr.alpha.commons.util.Util; +import org.apache.commons.collections4.SetUtils; + +import java.util.Collections; +import java.util.LinkedHashSet; +import java.util.Objects; +import java.util.Set; /** * An abstract representation of a rule with a specific type of @{link Head} (type parameter H) diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/BasicRule.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/BasicRule.java index 13b991506..77aac0ea3 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/BasicRule.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/BasicRule.java @@ -27,12 +27,11 @@ */ package at.ac.tuwien.kr.alpha.commons.programs.rules; -import java.util.List; -import java.util.Set; - import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; +import java.util.Set; + /** * Represents a non-ground rule or a constraint. A {@link BasicRule} has a general {@link Head}, meaning both choice heads and disjunctive * heads are permissible. diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/NormalRuleImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/NormalRuleImpl.java index 80225ef71..acd5ee0d5 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/NormalRuleImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/NormalRuleImpl.java @@ -1,12 +1,11 @@ package at.ac.tuwien.kr.alpha.commons.programs.rules; -import java.util.List; -import java.util.Set; - import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.api.programs.rules.NormalRule; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; +import java.util.Set; + /** * A rule that has a normal head, i.e. just one head atom, no disjunction or choice heads allowed. * Currently, any constructs such as aggregates, intervals, etc. in the rule body are allowed. diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/Rules.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/Rules.java index f0456caba..9a19b54bc 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/Rules.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/Rules.java @@ -1,16 +1,17 @@ package at.ac.tuwien.kr.alpha.commons.programs.rules; -import java.util.*; - import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.api.programs.rules.NormalRule; import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; -import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.util.Util; +import java.util.Arrays; +import java.util.LinkedHashSet; +import java.util.Set; + public final class Rules { private Rules() { @@ -22,7 +23,7 @@ public static Rule newRule(Head head, Set body) { } public static Rule newRule(Head head, Literal... body) { - Set bodyLst = new LinkedHashSet<>(Arrays.asList(body)); + Set bodyLst = new LinkedHashSet<>(Arrays.asList(body)); return new BasicRule(head, bodyLst); } @@ -31,7 +32,7 @@ public static NormalRule newNormalRule(NormalHead head, Set body) { } public static NormalRule newNormalRule(NormalHead head, Literal... body) { - Set bodyLst = new LinkedHashSet<>(Arrays.asList(body)); + Set bodyLst = new LinkedHashSet<>(Arrays.asList(body)); return new NormalRuleImpl(head, bodyLst); } @@ -41,9 +42,9 @@ public static NormalRule toNormalRule(Rule rule) { if (!(rule.getHead() instanceof NormalHead)) { throw Util.oops("Trying to construct a NormalRule from rule with non-normal head! Head type is: " + rule.getHead().getClass().getSimpleName()); } - headAtom = ((NormalHead) rule.getHead()).getAtom(); + } - return new NormalRuleImpl(headAtom != null ? Heads.newNormalHead(headAtom) : null, new LinkedHashSet<>(rule.getBody())); + return newNormalRule(rule.isConstraint() ? null : (NormalHead) rule.getHead(), new LinkedHashSet<>(rule.getBody())); } } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/ActionHeadImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/ActionHeadImpl.java index 46a598442..4d41d044a 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/ActionHeadImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/ActionHeadImpl.java @@ -13,51 +13,51 @@ class ActionHeadImpl implements ActionHead { - private final BasicAtom atom; - private final String actionName; - private final List actionInputTerms; - private final VariableTerm actionOutputTerm; - - ActionHeadImpl(BasicAtom atom, String actionName, List actionInputTerms, VariableTerm actionOutputTerm) { - this.atom = atom; - this.actionName = actionName; - this.actionInputTerms = Collections.unmodifiableList(actionInputTerms); - this.actionOutputTerm = actionOutputTerm; - } - - @Override - public BasicAtom getAtom() { - return atom; - } - - @Override - public boolean isGround() { - // TODO: an action head is conceptually a basic one with an (interpreted) function term - return false; - } - - @Override - public BasicAtom instantiate(RuleInstantiator instantiator, Substitution substitution) { - return instantiator.instantiate(this, substitution); - } - - @Override - public String getActionName() { - return actionName; - } - - @Override - public List getActionInputTerms() { - return actionInputTerms; - } - - @Override - public VariableTerm getActionOutputTerm() { - return actionOutputTerm; - } - - public String toString() { - return atom.toString() + " : @" + actionName + "(" + StringUtils.join(actionInputTerms, ", ") + ") = " + actionOutputTerm; - } + private final BasicAtom atom; + private final String actionName; + private final List actionInputTerms; + private final VariableTerm actionOutputTerm; + + ActionHeadImpl(BasicAtom atom, String actionName, List actionInputTerms, VariableTerm actionOutputTerm) { + this.atom = atom; + this.actionName = actionName; + this.actionInputTerms = Collections.unmodifiableList(actionInputTerms); + this.actionOutputTerm = actionOutputTerm; + } + + @Override + public BasicAtom getAtom() { + return atom; + } + + @Override + public boolean isGround() { + // TODO: an action head is conceptually a basic one with an (interpreted) function term + return false; + } + + @Override + public BasicAtom instantiate(RuleInstantiator instantiator, Substitution substitution) { + return instantiator.instantiate(this, substitution); + } + + @Override + public String getActionName() { + return actionName; + } + + @Override + public List getActionInputTerms() { + return actionInputTerms; + } + + @Override + public VariableTerm getActionOutputTerm() { + return actionOutputTerm; + } + + public String toString() { + return atom.toString() + " : @" + actionName + "(" + StringUtils.join(actionInputTerms, ", ") + ") = " + actionOutputTerm; + } } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/Heads.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/Heads.java index 3ebf81b63..d2d271258 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/Heads.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/Heads.java @@ -1,18 +1,18 @@ package at.ac.tuwien.kr.alpha.commons.programs.rules.heads; -import java.util.List; - import at.ac.tuwien.kr.alpha.api.ComparisonOperator; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ActionHead; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ChoiceHead; -import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ChoiceHead.ChoiceElement; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.ChoiceHeadImpl.ChoiceElementImpl; +import java.util.List; + public final class Heads { private Heads() { diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/AbstractActionResultTerm.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/AbstractActionResultTerm.java index 9a94e942d..1eacea528 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/AbstractActionResultTerm.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/AbstractActionResultTerm.java @@ -7,20 +7,20 @@ abstract class AbstractActionResultTerm extends FunctionTermImpl implements ActionResultTerm { - AbstractActionResultTerm(String symbol, T value) { - super(symbol, Collections.singletonList(value)); - } + AbstractActionResultTerm(String symbol, T value) { + super(symbol, Collections.singletonList(value)); + } - public abstract boolean isSuccess(); + public abstract boolean isSuccess(); - public boolean isError() { - return !isSuccess(); - } + public boolean isError() { + return !isSuccess(); + } - // Note: Unchecked cast is ok, we permit only instances of T as constructor arguments. - @SuppressWarnings("unchecked") - public T getValue() { - return (T) getTerms().get(0); - } + // Note: Unchecked cast is ok, we permit only instances of T as constructor arguments. + @SuppressWarnings("unchecked") + public T getValue() { + return (T) getTerms().get(0); + } } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionErrorTerm.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionErrorTerm.java index 683b640c1..40815fe80 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionErrorTerm.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionErrorTerm.java @@ -6,19 +6,19 @@ class ActionErrorTerm extends AbstractActionResultTerm> { - private static final Interner INTERNER = new Interner<>(); + private static final Interner INTERNER = new Interner<>(); - ActionErrorTerm(ConstantTerm value) { - super(ActionResultTerm.ERROR_SYMBOL, value); - } + ActionErrorTerm(ConstantTerm value) { + super(ActionResultTerm.ERROR_SYMBOL, value); + } - public static ActionErrorTerm getInstance(ConstantTerm term) { - return INTERNER.intern(new ActionErrorTerm(term)); - } + public static ActionErrorTerm getInstance(ConstantTerm term) { + return INTERNER.intern(new ActionErrorTerm(term)); + } - @Override - public boolean isSuccess() { - return false; - } + @Override + public boolean isSuccess() { + return false; + } } \ No newline at end of file diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionSuccessTerm.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionSuccessTerm.java index 2c4d7ddfd..c5a2fde14 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionSuccessTerm.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionSuccessTerm.java @@ -6,20 +6,20 @@ class ActionSuccessTerm extends AbstractActionResultTerm { - private static final Interner> INTERNER = new Interner<>(); + private static final Interner> INTERNER = new Interner<>(); - ActionSuccessTerm(T value) { - super(ActionResultTerm.SUCCESS_SYMBOL, value); - } + ActionSuccessTerm(T value) { + super(ActionResultTerm.SUCCESS_SYMBOL, value); + } - @SuppressWarnings("unchecked") - public static ActionSuccessTerm getInstance(T term) { - return (ActionSuccessTerm) INTERNER.intern(new ActionSuccessTerm<>(term)); - } + @SuppressWarnings("unchecked") + public static ActionSuccessTerm getInstance(T term) { + return (ActionSuccessTerm) INTERNER.intern(new ActionSuccessTerm<>(term)); + } - @Override - public boolean isSuccess() { - return true; - } + @Override + public boolean isSuccess() { + return true; + } } diff --git a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/atoms/BasicAtomImplTest.java b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/BasicAtomImplTest.java similarity index 85% rename from alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/atoms/BasicAtomImplTest.java rename to alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/BasicAtomImplTest.java index 275aa413e..a500b850a 100644 --- a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/atoms/BasicAtomImplTest.java +++ b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/BasicAtomImplTest.java @@ -1,14 +1,11 @@ -package at.ac.tuwien.kr.alpha.commons.atoms; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import org.junit.jupiter.api.Test; +package at.ac.tuwien.kr.alpha.commons.programs.atoms; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; /** * Test for basic functionality of various implementations of {@link Atom}. @@ -56,12 +53,12 @@ public void testAreBasicAtomsEqual() { Terms.newFunctionTerm("r", Terms.newConstant("bla"), Terms.newVariable("BLUBB"))); assertEquals(a7, a8); - assertFalse(a1.equals(a3)); - assertFalse(a3.equals(a1)); - assertFalse(a1.equals(a5)); - assertFalse(a5.equals(a1)); - assertFalse(a1.equals(a7)); - assertFalse(a7.equals(a1)); + assertNotEquals(a1, a3); + assertNotEquals(a3, a1); + assertNotEquals(a1, a5); + assertNotEquals(a5, a1); + assertNotEquals(a1, a7); + assertNotEquals(a7, a1); } } diff --git a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/atoms/ExternalAtomImplTest.java b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/ExternalAtomImplTest.java similarity index 82% rename from alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/atoms/ExternalAtomImplTest.java rename to alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/ExternalAtomImplTest.java index d762709b5..9365625f6 100644 --- a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/atoms/ExternalAtomImplTest.java +++ b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/atoms/ExternalAtomImplTest.java @@ -1,27 +1,18 @@ -package at.ac.tuwien.kr.alpha.commons.atoms; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import java.util.ArrayList; -import java.util.Collections; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Set; - -import org.junit.jupiter.api.Test; +package at.ac.tuwien.kr.alpha.commons.programs.atoms; import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; import at.ac.tuwien.kr.alpha.api.externals.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.ExternalAtom; -import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.externals.Externals; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; +import org.junit.jupiter.api.Test; + +import java.util.*; + +import static org.junit.jupiter.api.Assertions.*; public class ExternalAtomImplTest { @@ -83,9 +74,9 @@ public void testAreExternalAtomsEqual() { assertEquals(ext1, ext2); assertEquals(ext2, ext1); - assertFalse(ext1.equals(null)); - assertFalse(ext1.equals("bla")); - assertTrue(ext1.hashCode() == ext2.hashCode()); + assertNotEquals(null, ext1); + assertNotEquals("bla", ext1); + assertEquals(ext1.hashCode(), ext2.hashCode()); } @Test diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/LiteralBindingNonBindingVariablesTest.java b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/literals/LiteralBindingNonBindingVariablesTest.java similarity index 82% rename from alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/LiteralBindingNonBindingVariablesTest.java rename to alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/literals/LiteralBindingNonBindingVariablesTest.java index 388cfff0b..8bd512135 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/LiteralBindingNonBindingVariablesTest.java +++ b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/literals/LiteralBindingNonBindingVariablesTest.java @@ -23,39 +23,25 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -<<<<<<<< HEAD:alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/literals/LiteralBindingNonBindingVariablesTest.java -package at.ac.tuwien.kr.alpha.commons.literals; -======== -package at.ac.tuwien.kr.alpha.core.programs.atoms; ->>>>>>>> master:alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/LiteralBindingNonBindingVariablesTest.java - -import static org.junit.jupiter.api.Assertions.assertEquals; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.List; -import java.util.Set; -import java.util.stream.Collectors; +package at.ac.tuwien.kr.alpha.commons.programs.literals; -import org.junit.jupiter.api.Disabled; -import org.junit.jupiter.api.Test; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -<<<<<<<< HEAD:alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/literals/LiteralBindingNonBindingVariablesTest.java -import at.ac.tuwien.kr.alpha.api.terms.Term; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; -import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; -======== -import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; -import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; ->>>>>>>> master:alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/LiteralBindingNonBindingVariablesTest.java +import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; import at.ac.tuwien.kr.alpha.commons.externals.IntPredicateInterpretation; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; + +import java.util.*; +import java.util.stream.Collectors; + +import static org.junit.jupiter.api.Assertions.*; /** * Tests the behaviour of {@link Literal#getBindingVariables()} and {@link Literal#getNonBindingVariables()} @@ -68,7 +54,7 @@ public class LiteralBindingNonBindingVariablesTest { public void testPositiveBasicLiteral() { // literal := q(X, Y) Literal literal = Literals.fromAtom(Atoms.newBasicAtom(Predicates.getPredicate("q", 2), Terms.newVariable("X"), Terms.newVariable("Y")), true); - assertEquals(false, literal.isNegated()); + assertFalse(literal.isNegated()); expectVariables(literal.getBindingVariables(), "X", "Y"); expectVariables(literal.getNonBindingVariables()); } @@ -77,7 +63,7 @@ public void testPositiveBasicLiteral() { public void testNegativeBasicLiteral() { // literal := not r(X, Y) Literal literal = Literals.fromAtom(Atoms.newBasicAtom(Predicates.getPredicate("r", 2), Terms.newVariable("X"), Terms.newVariable("Y")), false); - assertEquals(true, literal.isNegated()); + assertTrue(literal.isNegated()); expectVariables(literal.getBindingVariables()); expectVariables(literal.getNonBindingVariables(), "X", "Y"); } @@ -86,7 +72,7 @@ public void testNegativeBasicLiteral() { public void testPositiveComparisonLiteral_EQ_LeftAssigning() { // literal := Y = 5 Literal literal = Literals.fromAtom(Atoms.newComparisonAtom(Terms.newVariable("Y"), Terms.newConstant(5), ComparisonOperators.EQ), true); - assertEquals(false, literal.isNegated()); + assertFalse(literal.isNegated()); expectVariables(literal.getBindingVariables(), "Y"); expectVariables(literal.getNonBindingVariables()); } @@ -95,7 +81,7 @@ public void testPositiveComparisonLiteral_EQ_LeftAssigning() { public void testNegativeComparisonLiteral_EQ_LeftAssigning() { // literal := not Y = 5 Literal literal = Literals.fromAtom(Atoms.newComparisonAtom(Terms.newVariable("Y"), Terms.newConstant(5), ComparisonOperators.EQ), false); - assertEquals(true, literal.isNegated()); + assertTrue(literal.isNegated()); expectVariables(literal.getBindingVariables()); expectVariables(literal.getNonBindingVariables(), "Y"); } @@ -104,7 +90,7 @@ public void testNegativeComparisonLiteral_EQ_LeftAssigning() { public void testPositiveComparisonLiteral_EQ_RightAssigning() { // literal := 5 = Y Literal literal = Literals.fromAtom(Atoms.newComparisonAtom(Terms.newConstant(5), Terms.newVariable("Y"), ComparisonOperators.EQ), true); - assertEquals(false, literal.isNegated()); + assertFalse(literal.isNegated()); expectVariables(literal.getBindingVariables(), "Y"); expectVariables(literal.getNonBindingVariables()); } @@ -113,7 +99,7 @@ public void testPositiveComparisonLiteral_EQ_RightAssigning() { public void testNegativeComparisonLiteral_EQ_RightAssigning() { // literal := 5 = Y Literal literal = Literals.fromAtom(Atoms.newComparisonAtom(Terms.newConstant(5), Terms.newVariable("Y"), ComparisonOperators.EQ), false); - assertEquals(true, literal.isNegated()); + assertTrue(literal.isNegated()); expectVariables(literal.getBindingVariables()); expectVariables(literal.getNonBindingVariables(), "Y"); } @@ -122,7 +108,7 @@ public void testNegativeComparisonLiteral_EQ_RightAssigning() { public void testNegativeComparisonLiteral_EQ_Bidirectional() { // literal := not X = Y Literal literal = Literals.fromAtom(Atoms.newComparisonAtom(Terms.newVariable("X"), Terms.newVariable("Y"), ComparisonOperators.EQ), false); - assertEquals(true, literal.isNegated()); + assertTrue(literal.isNegated()); expectVariables(literal.getBindingVariables()); expectVariables(literal.getNonBindingVariables(), "X", "Y"); } @@ -131,7 +117,7 @@ public void testNegativeComparisonLiteral_EQ_Bidirectional() { public void testPositiveComparisonLiteral_NEQ_LeftAssigning() { // literal := Y != 5 Literal literal = Literals.fromAtom(Atoms.newComparisonAtom(Terms.newVariable("Y"), Terms.newConstant(5), ComparisonOperators.NE), true); - assertEquals(false, literal.isNegated()); + assertFalse(literal.isNegated()); expectVariables(literal.getBindingVariables()); expectVariables(literal.getNonBindingVariables(), "Y"); } @@ -140,7 +126,7 @@ public void testPositiveComparisonLiteral_NEQ_LeftAssigning() { public void testNegativeComparisonLiteral_NEQ_LeftAssigning() { // literal := not Y != 5 Literal literal = Literals.fromAtom(Atoms.newComparisonAtom(Terms.newVariable("Y"), Terms.newConstant(5), ComparisonOperators.NE), false); - assertEquals(true, literal.isNegated()); + assertTrue(literal.isNegated()); expectVariables(literal.getBindingVariables(), "Y"); expectVariables(literal.getNonBindingVariables()); } @@ -149,7 +135,7 @@ public void testNegativeComparisonLiteral_NEQ_LeftAssigning() { public void testPositiveComparisonLiteral_NEQ_RightAssigning() { // literal := 5 != Y Literal literal = Literals.fromAtom(Atoms.newComparisonAtom(Terms.newConstant(5), Terms.newVariable("Y"), ComparisonOperators.NE), true); - assertEquals(false, literal.isNegated()); + assertFalse(literal.isNegated()); expectVariables(literal.getBindingVariables()); expectVariables(literal.getNonBindingVariables(), "Y"); } @@ -158,7 +144,7 @@ public void testPositiveComparisonLiteral_NEQ_RightAssigning() { public void testNegativeComparisonLiteral_NEQ_RightAssigning() { // literal := not 5 != Y Literal literal = Literals.fromAtom(Atoms.newComparisonAtom(Terms.newConstant(5), Terms.newVariable("Y"), ComparisonOperators.NE), false); - assertEquals(true, literal.isNegated()); + assertTrue(literal.isNegated()); expectVariables(literal.getBindingVariables(), "Y"); expectVariables(literal.getNonBindingVariables()); } @@ -167,7 +153,7 @@ public void testNegativeComparisonLiteral_NEQ_RightAssigning() { public void testPositiveComparisonLiteral_NEQ_Bidirectional() { // literal := X != Y Literal literal = Literals.fromAtom(Atoms.newComparisonAtom(Terms.newVariable("X"), Terms.newVariable("Y"), ComparisonOperators.NE), true); - assertEquals(false, literal.isNegated()); + assertFalse(literal.isNegated()); expectVariables(literal.getBindingVariables()); expectVariables(literal.getNonBindingVariables(), "X", "Y"); } @@ -177,7 +163,7 @@ public void testPositiveComparisonLiteral_NEQ_Bidirectional() { public void testNegativeComparisonLiteral_NEQ_Bidirectional() { // literal := not X != Y Literal literal = Literals.fromAtom(Atoms.newComparisonAtom(Terms.newVariable("X"), Terms.newVariable("Y"), ComparisonOperators.NE), false); - assertEquals(true, literal.isNegated()); + assertTrue(literal.isNegated()); expectVariables(literal.getBindingVariables(), "X", "Y"); expectVariables(literal.getNonBindingVariables()); } @@ -190,7 +176,7 @@ public void testPositiveExternalLiteral() { extInput.add(Terms.newVariable("Y")); extOutput.add(Terms.newVariable("X")); Literal literal = Literals.fromAtom(Atoms.newExternalAtom(Predicates.getPredicate("ext", 2), new IntPredicateInterpretation(i -> i > 0), extInput, extOutput), true); - assertEquals(false, literal.isNegated()); + assertFalse(literal.isNegated()); expectVariables(literal.getBindingVariables(), "X"); expectVariables(literal.getNonBindingVariables(), "Y"); } @@ -203,7 +189,7 @@ public void testNegativeExternalLiteral() { extInput.add(Terms.newVariable("Y")); extOutput.add(Terms.newVariable("X")); Literal literal = Literals.fromAtom(Atoms.newExternalAtom(Predicates.getPredicate("ext", 2), new IntPredicateInterpretation(i -> i > 0), extInput, extOutput), false); - assertEquals(true, literal.isNegated()); + assertTrue(literal.isNegated()); expectVariables(literal.getBindingVariables()); expectVariables(literal.getNonBindingVariables(), "X", "Y"); } diff --git a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/terms/TermsTest.java b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/terms/TermsTest.java index b6700d2e2..50e5afb51 100644 --- a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/terms/TermsTest.java +++ b/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/programs/terms/TermsTest.java @@ -4,10 +4,10 @@ import java.util.List; -import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm; import org.junit.jupiter.api.Test; import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; public class TermsTest { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java index 610df11ad..6bdb979cf 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ParseTreeVisitor.java @@ -222,11 +222,15 @@ public Head visitDisjunction(ASPCore2Parser.DisjunctionContext ctx) { @Override public Head visitHead(ASPCore2Parser.HeadContext ctx) { - // head : disjunction | choice; + // head : disjunction | choice | action; if (ctx.choice() != null) { return visitChoice(ctx.choice()); + } else if (ctx.action() != null) { + return visitAction(ctx.action()); + } else if (ctx.disjunction() != null) { + return visitDisjunction(ctx.disjunction()); } - return visitDisjunction(ctx.disjunction()); + throw notSupported(ctx); } @Override diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java index 1bc31f104..c6bbf7239 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java @@ -103,7 +103,7 @@ public static void resetIdGenerator() { } public static CompiledRule fromNormalRule(Rule rule) { - return new InternalRule(rule.isConstraint() ? null : Heads.newNormalHead(rule.getHead().getAtom()), new LinkedHashSet<>(rule.getBody())); + return new InternalRule(rule.isConstraint() ? null : rule.getHead(), new LinkedHashSet<>(rule.getBody())); } /** diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java index 9b1c69143..ef73eec08 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/IntervalTermToIntervalAtom.java @@ -75,6 +75,7 @@ private static NormalRule rewriteIntervalSpecifications(NormalRule rule) { } // Note that this cast is safe: NormalHead can only have a BasicAtom, so literalizing and getting back the Atom destroys type information, // but should never yield anything other than a BasicAtom + // TODO handle action headS! NormalHead rewrittenHead = rule.isConstraint() ? null : Heads.newNormalHead((BasicAtom) rewriteLiteral(rule.getHead().getAtom().toLiteral(), intervalReplacements).getAtom()); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java index d33962805..5095da814 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/PredicateInternalizer.java @@ -16,9 +16,7 @@ import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; -import java.util.ArrayList; import java.util.LinkedHashSet; -import java.util.List; import java.util.Set; /** diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java index a08aac2e2..1ca5eb985 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/VariableEqualityRemoval.java @@ -34,6 +34,7 @@ import at.ac.tuwien.kr.alpha.api.programs.literals.ComparisonLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ActionHead; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.DisjunctiveHead; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; @@ -108,7 +109,16 @@ private Rule findAndReplaceVariableEquality(Rule rule) { if (!rule.isConstraint() && rule.getHead() instanceof DisjunctiveHead) { throw new UnsupportedOperationException("VariableEqualityRemoval cannot be applied to rule with DisjunctiveHead, yet."); } - NormalHead rewrittenHead = rule.isConstraint() ? null : Heads.newNormalHead(((NormalHead)rule.getHead()).getAtom()); + // TODO can this be done nicer? + NormalHead rewrittenHead = null; + if (!rule.isConstraint()) { + if (rule.getHead() instanceof ActionHead) { + ActionHead actHead = (ActionHead) rule.getHead(); + rewrittenHead = Heads.newActionHead(actHead.getAtom(), actHead.getActionName(), actHead.getActionInputTerms(), actHead.getActionOutputTerm()); + } else { + rewrittenHead = Heads.newNormalHead(((NormalHead) rule.getHead()).getAtom()); + } + } // Use substitution for actual replacement. Unifier replacementSubstitution = new Unifier(); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AggregateEncoders.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AggregateEncoders.java index 686fed1f6..a22ecb65e 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AggregateEncoders.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/AggregateEncoders.java @@ -1,6 +1,5 @@ package at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders; -import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateFunctionSymbol; public final class AggregateEncoders { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/CountEncoder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/CountEncoder.java index 44a10a5a3..dceca1dcf 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/CountEncoder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/CountEncoder.java @@ -1,13 +1,11 @@ package at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders; -import org.stringtemplate.v4.ST; -import org.stringtemplate.v4.STGroup; - import at.ac.tuwien.kr.alpha.api.ComparisonOperator; -import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateFunctionSymbol; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; import at.ac.tuwien.kr.alpha.commons.util.Util; +import org.stringtemplate.v4.ST; +import org.stringtemplate.v4.STGroup; public final class CountEncoder extends StringtemplateBasedAggregateEncoder { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java index 242fc7719..0f8b5d9da 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/MinMaxEncoder.java @@ -1,13 +1,5 @@ package at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders; -import java.util.ArrayList; -import java.util.LinkedHashSet; -import java.util.List; -import java.util.Set; - -import org.apache.commons.collections4.SetUtils; -import org.stringtemplate.v4.ST; - import at.ac.tuwien.kr.alpha.api.ComparisonOperator; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.Predicate; @@ -35,6 +27,11 @@ import at.ac.tuwien.kr.alpha.commons.util.Util; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewritingContext.AggregateInfo; +import org.apache.commons.collections4.SetUtils; +import org.stringtemplate.v4.ST; + +import java.util.LinkedHashSet; +import java.util.Set; public class MinMaxEncoder extends AbstractAggregateEncoder { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java index a7eeb9fab..94fa889c8 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/StringtemplateBasedAggregateEncoder.java @@ -20,7 +20,6 @@ import org.apache.commons.collections4.ListUtils; import org.stringtemplate.v4.ST; -import java.util.ArrayList; import java.util.Collections; import java.util.LinkedHashSet; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/SumEncoder.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/SumEncoder.java index 0dc4a0358..c184d2dce 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/SumEncoder.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/encoders/SumEncoder.java @@ -1,21 +1,19 @@ package at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.encoders; -import org.stringtemplate.v4.ST; -import org.stringtemplate.v4.STGroup; - import at.ac.tuwien.kr.alpha.api.ComparisonOperator; import at.ac.tuwien.kr.alpha.api.programs.Predicate; -import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateElement; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateFunctionSymbol; +import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; import at.ac.tuwien.kr.alpha.api.programs.terms.Term; -import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.util.Util; +import org.stringtemplate.v4.ST; +import org.stringtemplate.v4.STGroup; /** * Aggregate encoder handling sum aggregates. diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/common/ProgramTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/common/ProgramTest.java index b102d6fd3..71b6aef05 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/common/ProgramTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/common/ProgramTest.java @@ -25,45 +25,24 @@ */ package at.ac.tuwien.kr.alpha.core.common; -import static org.junit.jupiter.api.Assertions.assertEquals; - -import java.util.ArrayList; -import java.util.List; - +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; +import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; import org.junit.jupiter.api.Test; -import at.ac.tuwien.kr.alpha.api.programs.InputProgram; -import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; -import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; -import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.literals.Literals; -import at.ac.tuwien.kr.alpha.commons.rules.Rules; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; -import at.ac.tuwien.kr.alpha.core.programs.InputProgramImpl; +import static org.junit.jupiter.api.Assertions.assertEquals; public class ProgramTest { @Test public void testToString() { - InputProgram program; - // rule := q(X) :- p(X). - List body = new ArrayList<>(); - body.add(Literals.fromAtom(Atoms.newBasicAtom(Predicates.getPredicate("p", 1), Terms.newVariable("X")), true)); - Rule rule = Rules.newRule( - Atoms.newBasicAtom(Predicates.getPredicate("q", 1), Terms.newVariable("X")), - Atoms.newBasicAtom(Predicates.getPredicate("p", 1), Terms.newVariable("X")).toLiteral()); - List facts = new ArrayList<>(); - facts.add(Atoms.newBasicAtom(Predicates.getPredicate("p", 1), Terms.newSymbolicConstant("a"))); - facts.add(Atoms.newBasicAtom(Predicates.getPredicate("p", 1), Terms.newSymbolicConstant("b"))); - // program := p(a). p(b). q(X) :- p(X). - program = InputProgramImpl.builder().addFacts(facts).addRule(rule).build(); + InputProgram parsedProgram = new ProgramParserImpl().parse( + "p(a)." + System.lineSeparator() + + "q(X) :- p(X)." + System.lineSeparator() + + "p(b)."); assertEquals( "p(a)." + System.lineSeparator() + "p(b)." + System.lineSeparator() + "q(X) :- p(X)." + System.lineSeparator(), - program.toString()); + parsedProgram.toString()); } } diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/GrounderMockWithBasicProgram.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/GrounderMockWithBasicProgram.java index fe2cb6f8c..a298cb6eb 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/GrounderMockWithBasicProgram.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/GrounderMockWithBasicProgram.java @@ -1,19 +1,19 @@ /** * Copyright (c) 2016-2019, the Alpha Team. * All rights reserved. - * + * * Additional changes made by Siemens. - * + * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: - * + * * 1) Redistributions of source code must retain the above copyright notice, this * list of conditions and the following disclaimer. - * + * * 2) Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. - * + * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE @@ -44,6 +44,9 @@ import java.util.TreeSet; import java.util.stream.Stream; +import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; +import at.ac.tuwien.kr.alpha.core.programs.atoms.RuleAtom; +import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; import org.apache.commons.lang3.tuple.ImmutablePair; import org.apache.commons.lang3.tuple.Pair; @@ -51,43 +54,38 @@ import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; -import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; -import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; import at.ac.tuwien.kr.alpha.commons.AnswerSetBuilder; import at.ac.tuwien.kr.alpha.commons.AnswerSets; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; -import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; import at.ac.tuwien.kr.alpha.core.common.Assignment; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.IntIterator; import at.ac.tuwien.kr.alpha.core.common.NoGood; -import at.ac.tuwien.kr.alpha.core.programs.atoms.RuleAtom; -import at.ac.tuwien.kr.alpha.core.programs.rules.InternalRule; +import at.ac.tuwien.kr.alpha.core.rules.CompiledRules; /** * Represents a small ASP program {@code { c :- a, b. a. b. }}. * * Copyright (c) 2016, the Alpha Team. */ -public class DummyGrounder implements Grounder { +public class GrounderMockWithBasicProgram implements Grounder { public static final Set EXPECTED = new HashSet<>(singletonList(new AnswerSetBuilder() - .predicate("a") - .predicate("b") - .predicate("c") - .build() + .predicate("a") + .predicate("b") + .predicate("c") + .build() )); private static final int FACT_A = 11; // { -a } private static final int FACT_B = 12; // { -b } private static final int RULE_B = 13; // { -_br1, a, b } private static final int RULE_H = 14; // { -c, _br1 } private static final Map NOGOODS = Stream.of( - entry(FACT_A, headFirst(fromOldLiterals(-1))), - entry(FACT_B, headFirst(fromOldLiterals(-2))), - entry(RULE_B, headFirst(fromOldLiterals(-3, 1, 2))), - entry(RULE_H, headFirst(fromOldLiterals(-4, 3))) + entry(FACT_A, headFirst(fromOldLiterals(-1))), + entry(FACT_B, headFirst(fromOldLiterals(-2))), + entry(RULE_B, headFirst(fromOldLiterals(-3, 1, 2))), + entry(RULE_H, headFirst(fromOldLiterals(-4, 3))) ).collect(entriesToMap()); private final AtomStore atomStore; private final java.util.function.Predicate filter; @@ -95,15 +93,15 @@ public class DummyGrounder implements Grounder { private static Atom atomAA = Atoms.newBasicAtom(Predicates.getPredicate("a", 0)); private static Atom atomBB = Atoms.newBasicAtom(Predicates.getPredicate("b", 0)); private static BasicAtom atomCC = Atoms.newBasicAtom(Predicates.getPredicate("c", 0)); - private static Rule ruleABC = Rules.newRule(Heads.newNormalHead(atomCC), Arrays.asList(atomAA.toLiteral(), atomBB.toLiteral())); - private static Atom rule1 = new RuleAtom(InternalRule.fromNormalRule(Rules.toNormalRule(ruleABC)), new BasicSubstitution()); + private static CompiledRule ruleABC = CompiledRules.newCompiledRule(Heads.newNormalHead(atomCC), atomAA.toLiteral(), atomBB.toLiteral()); + private static Atom rule1 = new RuleAtom(ruleABC, new BasicSubstitution()); private Set returnedNogoods = new HashSet<>(); - public DummyGrounder(AtomStore atomStore) { + public GrounderMockWithBasicProgram(AtomStore atomStore) { this(atomStore, p -> true); } - public DummyGrounder(AtomStore atomStore, java.util.function.Predicate filter) { + public GrounderMockWithBasicProgram(AtomStore atomStore, java.util.function.Predicate filter) { this.atomStore = atomStore; this.filter = filter; Arrays.asList(atomAA, atomBB, rule1, atomCC).forEach(atomStore::putIfAbsent); @@ -172,7 +170,7 @@ public Map getNoGoods(Assignment assignment) { public Pair, Map> getChoiceAtoms() { return new ImmutablePair<>(new HashMap<>(), new HashMap<>()); } - + @Override public Map> getHeadsToBodies() { return Collections.emptyMap(); @@ -191,4 +189,5 @@ private void addNoGoodIfNotAlreadyReturned(Map integerNoGoodMap returnedNogoods.add(idNoGood); } } -} + +} \ No newline at end of file diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/GrounderMockWithChoice.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/GrounderMockWithChoice.java index 530d54944..d2d22c212 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/GrounderMockWithChoice.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/GrounderMockWithChoice.java @@ -1,19 +1,19 @@ /** * Copyright (c) 2016-2019, the Alpha Team. * All rights reserved. - * + * * Additional changes made by Siemens. - * + * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: - * + * * 1) Redistributions of source code must retain the above copyright notice, this * list of conditions and the following disclaimer. - * + * * 2) Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. - * + * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE @@ -32,6 +32,7 @@ import static at.ac.tuwien.kr.alpha.core.common.NoGood.headFirst; import static at.ac.tuwien.kr.alpha.core.common.NoGoodTest.fromOldLiterals; import static java.util.Arrays.asList; +import static java.util.Collections.singleton; import java.util.Arrays; import java.util.Collections; @@ -43,6 +44,9 @@ import java.util.TreeSet; import java.util.stream.Stream; +import at.ac.tuwien.kr.alpha.core.programs.atoms.ChoiceAtom; +import at.ac.tuwien.kr.alpha.core.programs.atoms.RuleAtom; +import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; import org.apache.commons.lang3.tuple.ImmutablePair; import org.apache.commons.lang3.tuple.Pair; @@ -50,34 +54,30 @@ import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; -import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; -import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; import at.ac.tuwien.kr.alpha.commons.AnswerSetBuilder; import at.ac.tuwien.kr.alpha.commons.AnswerSets; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; import at.ac.tuwien.kr.alpha.core.common.Assignment; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.IntIterator; import at.ac.tuwien.kr.alpha.core.common.NoGood; -import at.ac.tuwien.kr.alpha.core.programs.atoms.ChoiceAtom; -import at.ac.tuwien.kr.alpha.core.programs.atoms.RuleAtom; -import at.ac.tuwien.kr.alpha.core.programs.rules.InternalRule; +import at.ac.tuwien.kr.alpha.core.rules.CompiledRules; /** - * Represents a small ASP program with choices {@code { aa :- not bb. bb :- not aa. }}. + * Represents a small ASP program with choices {@code { aa :- not bb. bb :- not aa. }}. */ -public class ChoiceGrounder implements Grounder { +public class GrounderMockWithChoice implements Grounder { public static final Set EXPECTED = new HashSet<>(asList( new AnswerSetBuilder() .predicate("aa") .build(), new AnswerSetBuilder() .predicate("bb") - .build())); + .build() + )); private static final int ATOM_AA = 1; private static final int ATOM_BB = 2; @@ -93,7 +93,7 @@ public class ChoiceGrounder implements Grounder { private static final int BRULE_BB = 14; // { -_br2, -aa } private static final int CHOICE_EN_BR1 = 15; // { -_en_br1 } private static final int CHOICE_EN_BR2 = 16; // { -_en_br2 } - private static final int CHOICE_DIS_BR1 = 17; // { -_dis_br1, bb} + private static final int CHOICE_DIS_BR1 = 17; // { -_dis_br1, bb} private static final int CHOICE_DIS_BR2 = 18; // { -dis_br2, aa } private static final Map NOGOODS = Stream.of( entry(RULE_AA, headFirst(fromOldLiterals(-ATOM_AA, ATOM_BR1))), @@ -103,21 +103,22 @@ public class ChoiceGrounder implements Grounder { entry(CHOICE_EN_BR1, headFirst(fromOldLiterals(-ATOM_EN_BR1))), entry(CHOICE_EN_BR2, headFirst(fromOldLiterals(-ATOM_EN_BR2))), entry(CHOICE_DIS_BR1, headFirst(fromOldLiterals(-ATOM_DIS_BR1, ATOM_BB))), - entry(CHOICE_DIS_BR2, headFirst(fromOldLiterals(-ATOM_DIS_BR2, ATOM_AA)))).collect(entriesToMap()); + entry(CHOICE_DIS_BR2, headFirst(fromOldLiterals(-ATOM_DIS_BR2, ATOM_AA))) + ).collect(entriesToMap()); private static final Map CHOICE_ENABLE = Stream.of( entry(ATOM_BR1, ATOM_EN_BR1), - entry(ATOM_BR2, ATOM_EN_BR2)).collect(entriesToMap()); + entry(ATOM_BR2, ATOM_EN_BR2) + ).collect(entriesToMap()); private static final Map CHOICE_DISABLE = Stream.of( entry(ATOM_BR1, ATOM_DIS_BR1), - entry(ATOM_BR2, ATOM_DIS_BR2)).collect(entriesToMap()); + entry(ATOM_BR2, ATOM_DIS_BR2) + ).collect(entriesToMap()); private static BasicAtom atomAA = Atoms.newBasicAtom(Predicates.getPredicate("aa", 0)); private static BasicAtom atomBB = Atoms.newBasicAtom(Predicates.getPredicate("bb", 0)); - private static Rule ruleAA = Rules.newRule(Heads.newNormalHead(atomAA), - Collections.singletonList(Atoms.newBasicAtom(Predicates.getPredicate("bb", 0)).toLiteral(false))); - private static Rule ruleBB = Rules.newRule(Heads.newNormalHead(atomBB), - Collections.singletonList(Atoms.newBasicAtom(Predicates.getPredicate("aa", 0)).toLiteral(false))); - private static Atom rule1 = new RuleAtom(InternalRule.fromNormalRule(Rules.toNormalRule(ruleAA)), new BasicSubstitution()); - private static Atom rule2 = new RuleAtom(InternalRule.fromNormalRule(Rules.toNormalRule(ruleBB)), new BasicSubstitution()); + private static CompiledRule ruleAA = CompiledRules.newCompiledRule(Heads.newNormalHead(atomAA), Atoms.newBasicAtom(Predicates.getPredicate("bb", 0)).toLiteral(false)); + private static CompiledRule ruleBB = CompiledRules.newCompiledRule(Heads.newNormalHead(atomBB), Atoms.newBasicAtom(Predicates.getPredicate("aa", 0)).toLiteral(false)); + private static Atom rule1 = new RuleAtom(ruleAA, new BasicSubstitution()); + private static Atom rule2 = new RuleAtom(ruleBB, new BasicSubstitution()); private static Atom atomEnBR1 = ChoiceAtom.on(1); private static Atom atomEnBR2 = ChoiceAtom.on(2); private static Atom atomDisBR1 = ChoiceAtom.off(3); @@ -127,11 +128,11 @@ public class ChoiceGrounder implements Grounder { private final java.util.function.Predicate filter; - public ChoiceGrounder(AtomStore atomStore) { + public GrounderMockWithChoice(AtomStore atomStore) { this(atomStore, p -> true); } - public ChoiceGrounder(AtomStore atomStore, java.util.function.Predicate filter) { + public GrounderMockWithChoice(AtomStore atomStore, java.util.function.Predicate filter) { this.atomStore = atomStore; this.filter = filter; Arrays.asList(atomAA, atomBB, rule1, rule2, atomEnBR1, atomEnBR2, atomDisBR1, atomDisBR2).forEach(atomStore::putIfAbsent); @@ -155,11 +156,11 @@ public AnswerSet assignmentToAnswerSet(Iterable trueAtoms) { Map> predicateInstances = new HashMap<>(); for (Predicate trueAtomPredicate : trueAtomPredicates) { BasicAtom basicAtom = Atoms.newBasicAtom(trueAtomPredicate); - predicateInstances.put(trueAtomPredicate, new TreeSet<>(Collections.singleton(basicAtom))); + predicateInstances.put(trueAtomPredicate, new TreeSet<>(singleton(basicAtom))); } // Note: This grounder only deals with 0-ary predicates, i.e., every atom is a predicate and there is - // only one predicate instance representing 0 terms. + // only one predicate instance representing 0 terms. return AnswerSets.newAnswerSet(trueAtomPredicates, predicateInstances); } @@ -209,4 +210,5 @@ public int register(NoGood noGood) { } return solverDerivedNoGoods.get(noGood); } -} + +} \ No newline at end of file diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/NaiveGrounderTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/NaiveGrounderTest.java index cdee89727..74ce484f3 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/NaiveGrounderTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/NaiveGrounderTest.java @@ -25,7 +25,6 @@ */ package at.ac.tuwien.kr.alpha.core.grounder; -import static at.ac.tuwien.kr.alpha.core.test.util.TestUtils.atom; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertTrue; import static org.junit.jupiter.api.Assertions.fail; @@ -36,6 +35,10 @@ import java.util.List; import java.util.Map; +import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.commons.Predicates; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; @@ -104,10 +107,10 @@ public void groundRuleAlreadyGround() { + "b :- not a. " + "c :- b."); NormalProgram normal = NORMALIZE_TRANSFORM.apply(program); - CompiledProgram prog = new StratifiedEvaluation().apply(AnalyzedProgram.analyzeNormalProgram(normal)); + CompiledProgram prog = new StratifiedEvaluation(null, false).apply(AnalyzedProgram.analyzeNormalProgram(normal)); AtomStore atomStore = new AtomStoreImpl(); - Grounder grounder = GrounderFactory.getInstance("naive", prog, atomStore, true); + Grounder grounder = new GrounderFactory(new GrounderHeuristicsConfiguration(), true).createGrounder(prog, atomStore); Map noGoods = grounder.getNoGoods(new TrailAssignment(atomStore)); int litCNeg = Literals.atomToLiteral(atomStore.get(PROGRAM_PART_PARSER.parseBasicAtom("c")), false); int litB = Literals.atomToLiteral(atomStore.get(PROGRAM_PART_PARSER.parseBasicAtom("b"))); @@ -126,10 +129,10 @@ public void groundRuleWithLongerBodyAlreadyGround() { + "c :- b. " + "d :- b, c. "); NormalProgram normal = NORMALIZE_TRANSFORM.apply(program); - InternalProgram prog = new StratifiedEvaluation().apply(AnalyzedProgram.analyzeNormalProgram(normal)); + InternalProgram prog = new StratifiedEvaluation(null, false).apply(AnalyzedProgram.analyzeNormalProgram(normal)); AtomStore atomStore = new AtomStoreImpl(); - Grounder grounder = GrounderFactory.getInstance("naive", prog, atomStore, true); + Grounder grounder = new GrounderFactory(new GrounderHeuristicsConfiguration(), true).createGrounder(prog, atomStore); Map noGoods = grounder.getNoGoods(new TrailAssignment(atomStore)); int litANeg = Literals.atomToLiteral(atomStore.get(PROGRAM_PART_PARSER.parseBasicAtom("a")), false); int litBNeg = Literals.atomToLiteral(atomStore.get(PROGRAM_PART_PARSER.parseBasicAtom("b")), false); @@ -151,10 +154,10 @@ public void groundConstraintAlreadyGround() { + "b :- not a. " + ":- b."); NormalProgram normal = NORMALIZE_TRANSFORM.apply(program); - InternalProgram prog = new StratifiedEvaluation().apply(AnalyzedProgram.analyzeNormalProgram(normal)); + InternalProgram prog = new StratifiedEvaluation(null, false).apply(AnalyzedProgram.analyzeNormalProgram(normal)); AtomStore atomStore = new AtomStoreImpl(); - Grounder grounder = GrounderFactory.getInstance("naive", prog, atomStore, true); + Grounder grounder = new GrounderFactory(new GrounderHeuristicsConfiguration(), true).createGrounder(prog, atomStore); Map noGoods = grounder.getNoGoods(new TrailAssignment(atomStore)); int litB = Literals.atomToLiteral(atomStore.get(PROGRAM_PART_PARSER.parseBasicAtom("b"))); assertTrue(noGoods.containsValue(NoGood.fromConstraint(Collections.singletonList(litB), Collections.emptyList()))); @@ -189,7 +192,7 @@ public void noDeadEndWithPermissiveGrounderHeuristicForQ1() { } /** - * Tests the method {@link NaiveGrounder#getGroundInstantiations(InternalRule, RuleGroundingOrder, Substitution, Assignment)} on a + * Tests the method {@link NaiveGrounder#getGroundInstantiations)} on a * predefined program: * * p1(1). q1(1).
@@ -218,8 +221,7 @@ private void testDeadEnd(String predicateNameOfStartingLiteral, RuleGroundingOrd PROGRAM_PARSER.parse(aspStr))); AtomStore atomStore = new AtomStoreImpl(); - NaiveGrounder grounder = (NaiveGrounder) GrounderFactory.getInstance("naive", program, atomStore, p -> true, - GrounderHeuristicsConfiguration.permissive(), true); + NaiveGrounder grounder = (NaiveGrounder) new GrounderFactory(GrounderHeuristicsConfiguration.permissive(), true).createGrounder(program, atomStore, p -> true); CompiledRule nonGroundRule = grounder.getNonGroundRule(0); String strLiteral = "p1".equals(predicateNameOfStartingLiteral) ? "p1(X)" : "p1(Y)"; @@ -270,7 +272,7 @@ public void testGroundingOfRuleNotSwitchedOffByFalseNegativeBody() { } /** - * Tests if {@link NaiveGrounder#getGroundInstantiations(InternalRule, RuleGroundingOrder, Substitution, Assignment)} + * Tests if {@link NaiveGrounder#getGroundInstantiations(CompiledRule, RuleGroundingOrder, Substitution, Assignment)} * produces ground instantiations for the rule with ID {@code ruleID} in {@code program} when {@code startingLiteral} * unified with the numeric instance {@code startingInstance} is used as starting literal and {@code b(1)} is assigned * {@code bTruth}. @@ -281,10 +283,9 @@ private void testIfGrounderGroundsRule(InputProgram program, int ruleID, Literal CompiledProgram internalPrg = InternalProgram.fromNormalProgram(NORMALIZE_TRANSFORM.apply(program)); AtomStore atomStore = new AtomStoreImpl(); TrailAssignment currentAssignment = new TrailAssignment(atomStore); - NaiveGrounder grounder = (NaiveGrounder) GrounderFactory.getInstance("naive", internalPrg, atomStore, p -> true, - GrounderHeuristicsConfiguration.permissive(), true); + NaiveGrounder grounder = (NaiveGrounder) new GrounderFactory(GrounderHeuristicsConfiguration.permissive(), true).createGrounder(internalPrg, atomStore, p -> true); - int b = atomStore.putIfAbsent(atom("b", 1)); + int b = atomStore.putIfAbsent(Atoms.newBasicAtom(Predicates.getPredicate("b", 1), Terms.newConstant(1))); currentAssignment.growForMaxAtomId(); currentAssignment.assign(b, bTruth); @@ -369,7 +370,7 @@ private void testPermissiveGrounderHeuristicTolerance(InputProgram program, int } /** - * Tests if {@link NaiveGrounder#getGroundInstantiations(InternalRule, RuleGroundingOrder, Substitution, Assignment)} + * Tests if {@link NaiveGrounder#getGroundInstantiations(CompiledRule, RuleGroundingOrder, Substitution, Assignment)} * produces ground instantiations for the rule with ID {@code ruleID} in {@code program} when {@code startingLiteral} * unified with the numeric instance {@code startingInstance} is used as starting literal and the following * additional conditions are established: @@ -392,7 +393,7 @@ private void testPermissiveGrounderHeuristicTolerance(InputProgram program, int AtomStore atomStore = new AtomStoreImpl(); TrailAssignment currentAssignment = new TrailAssignment(atomStore); GrounderHeuristicsConfiguration heuristicConfiguration = GrounderHeuristicsConfiguration.getInstance(tolerance, tolerance); - NaiveGrounder grounder = (NaiveGrounder) GrounderFactory.getInstance("naive", internalPrg, atomStore, p -> true, heuristicConfiguration, true); + NaiveGrounder grounder = (NaiveGrounder) new GrounderFactory(heuristicConfiguration, true).createGrounder(internalPrg, atomStore, p -> true); int[] bAtomIDs = new int[truthsOfB.length]; for (int i = 0; i < truthsOfB.length; i++) { @@ -457,4 +458,12 @@ private void assertExistsNoGoodContaining(Collection noGoods, int litera fail("No NoGood exists that contains literal " + literal); } + private static Atom atom(String predicateName, int... termInts) { + Term[] terms = new Term[termInts.length]; + for (int i = 0; i < termInts.length; i++) { + terms[i] = Terms.newConstant(termInts[i]); + } + return Atoms.newBasicAtom(Predicates.getPredicate(predicateName, terms.length), terms); + } + } diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/NoGoodGeneratorTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/NoGoodGeneratorTest.java index ef42a9eb7..eb0a06392 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/NoGoodGeneratorTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/grounder/NoGoodGeneratorTest.java @@ -25,12 +25,7 @@ */ package at.ac.tuwien.kr.alpha.core.grounder; -import static org.junit.jupiter.api.Assertions.assertEquals; - -import java.util.List; - -import org.junit.jupiter.api.Test; - +import at.ac.tuwien.kr.alpha.api.config.GrounderHeuristicsConfiguration; import at.ac.tuwien.kr.alpha.api.config.SystemConfig; import at.ac.tuwien.kr.alpha.api.grounder.Substitution; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; @@ -47,8 +42,12 @@ import at.ac.tuwien.kr.alpha.core.programs.InternalProgram; import at.ac.tuwien.kr.alpha.core.programs.atoms.Literals; import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; -import at.ac.tuwien.kr.alpha.core.programs.rules.InternalRule; import at.ac.tuwien.kr.alpha.core.programs.transformation.NormalizeProgramTransformation; +import org.junit.jupiter.api.Test; + +import java.util.List; + +import static org.junit.jupiter.api.Assertions.assertEquals; /** * Tests {@link NoGoodGenerator} @@ -66,7 +65,7 @@ public class NoGoodGeneratorTest { private static final VariableTerm Y = Terms.newVariable("Y"); /** - * Calls {@link NoGoodGenerator#collectNegLiterals(InternalRule, Substitution)}, which puts the atom occurring + * Calls {@link NoGoodGenerator#collectNegLiterals(CompiledRule, Substitution)}, which puts the atom occurring * negatively in a rule into the atom store. It is then checked whether the atom in the atom store is positive. */ @Test @@ -79,7 +78,7 @@ public void collectNeg_ContainsOnlyPositiveLiterals() { CompiledRule rule = program.getRules().get(1); AtomStore atomStore = new AtomStoreImpl(); - Grounder grounder = GrounderFactory.getInstance("naive", program, atomStore, true); + Grounder grounder = new GrounderFactory(new GrounderHeuristicsConfiguration(), true).createGrounder(program, atomStore); NoGoodGenerator noGoodGenerator = ((NaiveGrounder) grounder).noGoodGenerator; Substitution substitution = new BasicSubstitution(); substitution.put(X, A); diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/AspCore2ParserTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/AspCore2ParserTest.java deleted file mode 100644 index 7b96f4f92..000000000 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/AspCore2ParserTest.java +++ /dev/null @@ -1,11 +0,0 @@ -package at.ac.tuwien.kr.alpha.core.parser; - -import at.ac.tuwien.kr.alpha.core.parser.aspcore2.InputProgramParser; - -public class AspCore2ParserTest extends ParserTest { - - protected AspCore2ParserTest() { - super(new InputProgramParser()); - } - -} diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/EvologParserTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/EvologParserTest.java deleted file mode 100644 index 69e7eb0b7..000000000 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/parser/EvologParserTest.java +++ /dev/null @@ -1,14 +0,0 @@ -package at.ac.tuwien.kr.alpha.core.parser; - -import at.ac.tuwien.kr.alpha.core.actions.DefaultActionImplementationProvider; -import at.ac.tuwien.kr.alpha.core.parser.evolog.EvologProgramParser; - -public class EvologParserTest extends ParserTest { - - protected EvologParserTest() { - super(new EvologProgramParser(new DefaultActionImplementationProvider())); - } - - - -} diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/AtomsTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/AtomsTest.java index d202e579c..ac961bebe 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/AtomsTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/AtomsTest.java @@ -1,9 +1,5 @@ package at.ac.tuwien.kr.alpha.core.programs.atoms; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertTrue; - import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; @@ -22,9 +18,11 @@ import at.ac.tuwien.kr.alpha.api.programs.atoms.ExternalAtom; import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; -import at.ac.tuwien.kr.alpha.core.externals.Externals; +import at.ac.tuwien.kr.alpha.commons.externals.Externals; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; +import static org.junit.jupiter.api.Assertions.*; + /** * Test for basic functionality of various implementations of {@link Atom}. * @@ -91,12 +89,12 @@ public void testAreBasicAtomsEqual() { Atom a8 = p4.getFacts().get(1); assertEquals(a7, a8); - assertFalse(a1.equals(a3)); - assertFalse(a3.equals(a1)); - assertFalse(a1.equals(a5)); - assertFalse(a5.equals(a1)); - assertFalse(a1.equals(a7)); - assertFalse(a7.equals(a1)); + assertNotEquals(a1, a3); + assertNotEquals(a3, a1); + assertNotEquals(a1, a5); + assertNotEquals(a5, a1); + assertNotEquals(a1, a7); + assertNotEquals(a7, a1); } @Test @@ -122,9 +120,9 @@ public void testAreExternalAtomsEqual() { assertEquals(ext1, ext2); assertEquals(ext2, ext1); - assertFalse(ext1.equals(null)); - assertFalse(ext1.equals("bla")); - assertTrue(ext1.hashCode() == ext2.hashCode()); + assertNotEquals(null, ext1); + assertNotEquals("bla", ext1); + assertEquals(ext1.hashCode(), ext2.hashCode()); } @Test diff --git a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/literals/RuleAtomTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/RuleAtomTest.java similarity index 97% rename from alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/literals/RuleAtomTest.java rename to alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/RuleAtomTest.java index 56e64c4ef..e89317207 100644 --- a/alpha-commons/src/test/java/at/ac/tuwien/kr/alpha/commons/literals/RuleAtomTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/atoms/RuleAtomTest.java @@ -1,7 +1,10 @@ -package at.ac.tuwien.kr.alpha.core.atoms; +package at.ac.tuwien.kr.alpha.core.programs.atoms; import static org.junit.jupiter.api.Assertions.assertEquals; +import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; +import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; +import at.ac.tuwien.kr.alpha.core.programs.rules.InternalRule; import org.junit.jupiter.api.Test; import at.ac.tuwien.kr.alpha.api.grounder.Substitution; @@ -18,17 +21,13 @@ import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution; import at.ac.tuwien.kr.alpha.commons.substitutions.Instance; -import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; -import at.ac.tuwien.kr.alpha.core.programs.atoms.RuleAtom; -import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; -import at.ac.tuwien.kr.alpha.core.programs.rules.InternalRule; /** * Copyright (c) 2022, the Alpha Team. */ public class RuleAtomTest { - private static final ProgramParser PARSER = new ProgramParserImpl(); + private static final ProgramParser PARSER = new ProgramParserImpl(); private static final VariableTerm X = Terms.newVariable("X"); private static final VariableTerm Y = Terms.newVariable("Y"); private static final Predicate PREDICATE = Predicates.getPredicate("p", 1); diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformationTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformationTest.java index 79ae8be23..345cc41bb 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformationTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ProgramTransformationTest.java @@ -16,7 +16,7 @@ import at.ac.tuwien.kr.alpha.api.programs.Program; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.commons.programs.Programs; -import at.ac.tuwien.kr.alpha.core.externals.Externals; +import at.ac.tuwien.kr.alpha.commons.externals.Externals; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; public class ProgramTransformationTest { diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluationRegressionTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluationRegressionTest.java deleted file mode 100644 index 383cf8ac0..000000000 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/StratifiedEvaluationRegressionTest.java +++ /dev/null @@ -1,262 +0,0 @@ -package at.ac.tuwien.kr.alpha.core.programs.transformation; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import java.util.ArrayList; -import java.util.List; -import java.util.Set; -import java.util.function.Consumer; - -import org.apache.commons.lang3.tuple.ImmutablePair; -import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.Arguments; -import org.junit.jupiter.params.provider.MethodSource; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -import at.ac.tuwien.kr.alpha.api.AnswerSet; -import at.ac.tuwien.kr.alpha.api.Solver; -import at.ac.tuwien.kr.alpha.api.config.SystemConfig; -import at.ac.tuwien.kr.alpha.api.programs.InputProgram; -import at.ac.tuwien.kr.alpha.api.programs.Predicate; -import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; -import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; -import at.ac.tuwien.kr.alpha.core.common.AtomStore; -import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; -import at.ac.tuwien.kr.alpha.core.grounder.Grounder; -import at.ac.tuwien.kr.alpha.core.grounder.GrounderFactory; -import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; -import at.ac.tuwien.kr.alpha.core.programs.AnalyzedProgram; -import at.ac.tuwien.kr.alpha.core.programs.CompiledProgram; -import at.ac.tuwien.kr.alpha.core.solver.SolverFactory; -import at.ac.tuwien.kr.alpha.core.test.util.TestUtils; - -public class StratifiedEvaluationRegressionTest { - - private static final Logger LOGGER = LoggerFactory.getLogger(StratifiedEvaluationRegressionTest.class); - - private static final String STRATIFIED_NEG_ASP = "base(X) :- req(X), not incomp(X).\n" - + "depend_base(X, Y) :- base(X), base(Y).\n" - + "dep_b_hlp(X) :- depend_base(X, _).\n" - + "fallback_base(X) :- base(X), not dep_b_hlp(X).\n" - + "depend_further(X) :- depend_base(_, X).\n" - + "depend_further(X) :- fallback_base(X)."; - - private static final String BASIC_TEST_ASP = "a. b:- a."; - private static final String BASIC_MULTI_INSTANCE_ASP = "p(a). p(b). q(X) :- p(X)."; - private static final String BASIC_NEGATION_ASP = "p(a). q(b). p(c). q(d). r(c). s(X, Y) :- p(X), q(Y), not r(X)."; - private static final String PART_STRATIFIED_ASP = "p(a). q(a). p(b). m(c). n(d).\n" + "r(X) :- p(X), q(X).\n" + "s(X, Y, Z) :- r(X), m(Y), n(Z).\n" - + "t(X, Y) :- p(X), q(X), p(Y), not q(Y).\n" + "either(X) :- t(X, _), not or(X).\n" + "or(X) :- t(X, _), not either(X)."; - private static final String POSITIVE_RECURSION_ASP = "num(0).\n" + "max_num(10).\n" + "num(S) :- num(N), S = N + 1, S <= M, max_num(M)."; - private static final String EMPTY_PROG_ASP = ""; - private static final String FACTS_ONLY_ASP = "a. b. c. p(a). q(b, c). r(c, c, a). s(b)."; - private static final String STRATIFIED_NO_FACTS_ASP = STRATIFIED_NEG_ASP; - private static final String STRATIFIED_W_FACTS_ASP = "req(a). req(b). incomp(b).\n" + STRATIFIED_NEG_ASP; - private static final String EQUALITY_ASP = "equal :- 1 = 1."; - private static final String EQUALITY_WITH_VAR_ASP = "a(1). a(2). a(3). b(X) :- a(X), X = 1. c(X) :- a(X), X = 2. d(X) :- X = 3, a(X)."; - - private static final ImmutablePair, Consumer>> BASIC_VERIFIERS = new ImmutablePair<>( - StratifiedEvaluationRegressionTest::verifyProgramBasic, StratifiedEvaluationRegressionTest::verifyAnswerSetsBasic); - private static final ImmutablePair, Consumer>> BASIC_MULTI_INSTANCE_VERIFIERS = new ImmutablePair<>( - StratifiedEvaluationRegressionTest::verifyProgramBasicMultiInstance, StratifiedEvaluationRegressionTest::verifyAnswerSetsBasicMultiInstance); - private static final ImmutablePair, Consumer>> BASIC_NEGATION_VERIFIERS = new ImmutablePair<>( - StratifiedEvaluationRegressionTest::verifyProgramBasicNegation, StratifiedEvaluationRegressionTest::verifyAnswerSetsBasicNegation); - private static final ImmutablePair, Consumer>> PART_STRATIFIED_VERIFIERS = new ImmutablePair<>( - StratifiedEvaluationRegressionTest::verifyProgramPartStratified, StratifiedEvaluationRegressionTest::verifyAnswerSetsPartStratified); - private static final ImmutablePair, Consumer>> POSITIVE_RECURSIVE_VERIFIERS = new ImmutablePair<>( - StratifiedEvaluationRegressionTest::verifyProgramPositiveRecursive, StratifiedEvaluationRegressionTest::verifyAnswerSetsPositiveRecursive); - private static final ImmutablePair, Consumer>> EMPTY_PROG_VERIFIERS = new ImmutablePair<>( - StratifiedEvaluationRegressionTest::verifyProgramEmptyProg, StratifiedEvaluationRegressionTest::verifyAnswerSetsEmptyProg); - private static final ImmutablePair, Consumer>> FACTS_ONLY_VERIFIERS = new ImmutablePair<>( - StratifiedEvaluationRegressionTest::verifyProgramFactsOnly, StratifiedEvaluationRegressionTest::verifyAnswerSetsFactsOnly); - private static final ImmutablePair, Consumer>> STRATIFIED_NO_FACTS_VERIFIERS = new ImmutablePair<>( - StratifiedEvaluationRegressionTest::verifyProgramStratNoFacts, StratifiedEvaluationRegressionTest::verifyAnswerSetsStratNoFacts); - private static final ImmutablePair, Consumer>> STRATIFIED_W_FACTS_VERIFIERS = new ImmutablePair<>( - StratifiedEvaluationRegressionTest::verifyProgramStratWithFacts, StratifiedEvaluationRegressionTest::verifyAnswerSetsStratWithFacts); - private static final ImmutablePair, Consumer>> EQUALITY_VERIFIERS = new ImmutablePair<>( - StratifiedEvaluationRegressionTest::verifyProgramEquality, StratifiedEvaluationRegressionTest::verifyAnswerSetsEquality); - private static final ImmutablePair, Consumer>> EQUALITY_WITH_VAR_VERIFIERS = new ImmutablePair<>( - StratifiedEvaluationRegressionTest::verifyProgramEqualityWithVar, StratifiedEvaluationRegressionTest::verifyAnswerSetsEqualityWithVar); - - public static List params() { - List, Consumer>>>> testCases = new ArrayList<>(); - List paramList = new ArrayList<>(); - testCases.add(new ImmutablePair<>(BASIC_TEST_ASP, BASIC_VERIFIERS)); - testCases.add(new ImmutablePair<>(BASIC_MULTI_INSTANCE_ASP, BASIC_MULTI_INSTANCE_VERIFIERS)); - testCases.add(new ImmutablePair<>(BASIC_NEGATION_ASP, BASIC_NEGATION_VERIFIERS)); - testCases.add(new ImmutablePair<>(PART_STRATIFIED_ASP, PART_STRATIFIED_VERIFIERS)); - testCases.add(new ImmutablePair<>(POSITIVE_RECURSION_ASP, POSITIVE_RECURSIVE_VERIFIERS)); - testCases.add(new ImmutablePair<>(EMPTY_PROG_ASP, EMPTY_PROG_VERIFIERS)); - testCases.add(new ImmutablePair<>(FACTS_ONLY_ASP, FACTS_ONLY_VERIFIERS)); - testCases.add(new ImmutablePair<>(STRATIFIED_NO_FACTS_ASP, STRATIFIED_NO_FACTS_VERIFIERS)); - testCases.add(new ImmutablePair<>(STRATIFIED_W_FACTS_ASP, STRATIFIED_W_FACTS_VERIFIERS)); - testCases.add(new ImmutablePair<>(EQUALITY_ASP, EQUALITY_VERIFIERS)); - testCases.add(new ImmutablePair<>(EQUALITY_WITH_VAR_ASP, EQUALITY_WITH_VAR_VERIFIERS)); - - testCases.forEach((pair) -> paramList.add(Arguments.of(pair.left, pair.right.left, pair.right.right))); - return paramList; - } - - @ParameterizedTest - @MethodSource("at.ac.tuwien.kr.alpha.core.programs.transformation.StratifiedEvaluationRegressionTest#params") - public void runTest(String aspString, Consumer programVerifier, Consumer> resultVerifier) { - // Parse and pre-evaulate program - ProgramParser parser = new ProgramParserImpl(); - InputProgram prog = parser.parse(aspString); - AnalyzedProgram analyzed = AnalyzedProgram - .analyzeNormalProgram(new NormalizeProgramTransformation(SystemConfig.DEFAULT_AGGREGATE_REWRITING_CONFIG).apply(prog)); - CompiledProgram evaluated = new StratifiedEvaluation().apply(analyzed); - // Verify stratified evaluation result - programVerifier.accept(evaluated); - // Solve remaining program - AtomStore atomStore = new AtomStoreImpl(); - Grounder grounder = GrounderFactory.getInstance("naive", evaluated, atomStore, false); - Solver solver = SolverFactory.getInstance(new SystemConfig(), atomStore, grounder); - Set answerSets = solver.collectSet(); - resultVerifier.accept(answerSets); - } - - private static void verifyProgramBasic(CompiledProgram evaluated) { - TestUtils.assertFactsContainedInProgram(evaluated, TestUtils.basicAtomWithSymbolicTerms("a"), TestUtils.basicAtomWithSymbolicTerms("b")); - assertEquals(2, evaluated.getFacts().size()); - assertTrue(evaluated.getRules().size() == 0); - } - - private static void verifyAnswerSetsBasic(Set answerSets) { - TestUtils.assertAnswerSetsEqual("a, b", answerSets); - } - - private static void verifyProgramBasicMultiInstance(CompiledProgram evaluated) { - TestUtils.assertFactsContainedInProgram(evaluated, TestUtils.basicAtomWithSymbolicTerms("q", "a"), TestUtils.basicAtomWithSymbolicTerms("q", "b")); - assertTrue(evaluated.getRules().size() == 0); - } - - private static void verifyAnswerSetsBasicMultiInstance(Set answerSets) { - TestUtils.assertAnswerSetsEqual("p(a), p(b), q(a), q(b)", answerSets); - } - - private static void verifyProgramBasicNegation(CompiledProgram evaluated) { - TestUtils.assertFactsContainedInProgram(evaluated, TestUtils.basicAtomWithSymbolicTerms("s", "a", "b"), - TestUtils.basicAtomWithSymbolicTerms("s", "a", "d")); - assertEquals(7, evaluated.getFacts().size()); - assertEquals(0, evaluated.getRules().size()); - } - - private static void verifyAnswerSetsBasicNegation(Set answerSets) { - TestUtils.assertAnswerSetsEqual("p(a), q(b), p(c), q(d), r(c), s(a,b), s(a,d)", answerSets); - } - - private static void verifyProgramPartStratified(CompiledProgram evaluated) { - TestUtils.assertFactsContainedInProgram(evaluated, TestUtils.basicAtomWithSymbolicTerms("p", "a"), TestUtils.basicAtomWithSymbolicTerms("q", "a"), - TestUtils.basicAtomWithSymbolicTerms("p", "b"), - TestUtils.basicAtomWithSymbolicTerms("m", "c"), TestUtils.basicAtomWithSymbolicTerms("n", "d"), TestUtils.basicAtomWithSymbolicTerms("r", "a"), - TestUtils.basicAtomWithSymbolicTerms("s", "a", "c", "d"), - TestUtils.basicAtomWithSymbolicTerms("t", "a", "b")); - LOGGER.debug("part stratified evaluated prog is:\n{}", evaluated.toString()); - assertEquals(2, evaluated.getRules().size()); - } - - private static void verifyAnswerSetsPartStratified(Set answerSets) { - TestUtils.assertAnswerSetsEqual(new String[] {"p(a), q(a), p(b), m(c), n(d), r(a), s(a,c,d), t(a,b), either(a)", - "p(a), q(a), p(b), m(c), n(d), r(a), s(a,c,d), t(a,b), or(a)" }, answerSets); - } - - private static void verifyProgramPositiveRecursive(CompiledProgram evaluated) { - Predicate num = Predicates.getPredicate("num", 1); - TestUtils.assertFactsContainedInProgram(evaluated, Atoms.newBasicAtom(Predicates.getPredicate("max_num", 1), Terms.newConstant(10)), - Atoms.newBasicAtom(num, Terms.newConstant(0)), - Atoms.newBasicAtom(num, Terms.newConstant(1)), Atoms.newBasicAtom(num, Terms.newConstant(2)), - Atoms.newBasicAtom(num, Terms.newConstant(3)), Atoms.newBasicAtom(num, Terms.newConstant(4)), - Atoms.newBasicAtom(num, Terms.newConstant(5)), Atoms.newBasicAtom(num, Terms.newConstant(6)), - Atoms.newBasicAtom(num, Terms.newConstant(7)), Atoms.newBasicAtom(num, Terms.newConstant(8)), - Atoms.newBasicAtom(num, Terms.newConstant(9)), Atoms.newBasicAtom(num, Terms.newConstant(10))); - LOGGER.debug("Recursive program evaluated is:\n{}", evaluated.toString()); - assertEquals(0, evaluated.getRules().size()); - } - - private static void verifyAnswerSetsPositiveRecursive(Set answerSets) { - TestUtils.assertAnswerSetsEqual("max_num(10), num(0), num(1), num(2), num(3), num(4), num(5), num(6), num(7), num(8), num(9), num(10)", answerSets); - } - - private static void verifyProgramEmptyProg(CompiledProgram evaluated) { - assertTrue(evaluated.getRules().isEmpty()); - assertTrue(evaluated.getRulesById().isEmpty()); - assertTrue(evaluated.getPredicateDefiningRules().isEmpty()); - assertTrue(evaluated.getFacts().isEmpty()); - assertTrue(evaluated.getFactsByPredicate().isEmpty()); - } - - private static void verifyAnswerSetsEmptyProg(Set answerSets) { - assertEquals(1, answerSets.size()); - assertTrue(answerSets.iterator().next().isEmpty()); - } - - private static void verifyProgramFactsOnly(CompiledProgram evaluated) { - assertTrue(evaluated.getFacts().contains(TestUtils.basicAtomWithSymbolicTerms("a"))); - assertTrue(evaluated.getFacts().contains(TestUtils.basicAtomWithSymbolicTerms("b"))); - assertTrue(evaluated.getFacts().contains(TestUtils.basicAtomWithSymbolicTerms("c"))); - assertTrue(evaluated.getFacts().contains(TestUtils.basicAtomWithSymbolicTerms("p", "a"))); - assertTrue(evaluated.getFacts().contains(TestUtils.basicAtomWithSymbolicTerms("q", "b", "c"))); - assertTrue(evaluated.getFacts().contains(TestUtils.basicAtomWithSymbolicTerms("r", "c", "c", "a"))); - assertTrue(evaluated.getFacts().contains(TestUtils.basicAtomWithSymbolicTerms("s", "b"))); - } - - private static void verifyAnswerSetsFactsOnly(Set answerSets) { - TestUtils.assertAnswerSetsEqual("a, b, c, p(a), q(b,c), r(c,c,a), s(b)", answerSets); - } - - private static void verifyProgramStratNoFacts(CompiledProgram evaluated) { - assertTrue(evaluated.getFacts().isEmpty()); - } - - private static void verifyAnswerSetsStratNoFacts(Set answerSets) { - assertEquals(1, answerSets.size()); - assertTrue(answerSets.iterator().next().isEmpty()); - } - - private static void verifyProgramStratWithFacts(CompiledProgram evaluated) { - // rules should all be taken care of at this point - assertTrue(evaluated.getRules().isEmpty()); - assertTrue(evaluated.getRulesById().isEmpty()); - assertTrue(evaluated.getPredicateDefiningRules().isEmpty()); - - // facts should be the full answer set - assertTrue(evaluated.getFacts().contains(TestUtils.basicAtomWithSymbolicTerms("req", "a"))); - assertTrue(evaluated.getFacts().contains(TestUtils.basicAtomWithSymbolicTerms("req", "b"))); - assertTrue(evaluated.getFacts().contains(TestUtils.basicAtomWithSymbolicTerms("incomp", "b"))); - - // below facts from stratified evaluation - assertTrue(evaluated.getFacts().contains(TestUtils.basicAtomWithSymbolicTerms("base", "a"))); - assertTrue(evaluated.getFacts().contains(TestUtils.basicAtomWithSymbolicTerms("depend_base", "a", "a"))); - assertTrue(evaluated.getFacts().contains(TestUtils.basicAtomWithSymbolicTerms("dep_b_hlp", "a"))); - assertTrue(evaluated.getFacts().contains(TestUtils.basicAtomWithSymbolicTerms("depend_further", "a"))); - } - - private static void verifyAnswerSetsStratWithFacts(Set answerSets) { - TestUtils.assertAnswerSetsEqual("req(a), req(b), incomp(b), base(a), depend_base(a,a), dep_b_hlp(a), depend_further(a)", answerSets); - } - - private static void verifyProgramEquality(CompiledProgram evaluated) { - assertEquals(0, evaluated.getRules().size()); - assertTrue(evaluated.getFacts().contains(TestUtils.basicAtomWithSymbolicTerms("equal"))); - } - - private static void verifyAnswerSetsEquality(Set answerSets) { - TestUtils.assertAnswerSetsEqual("equal", answerSets); - } - - private static void verifyProgramEqualityWithVar(CompiledProgram evaluated) { - assertEquals(0, evaluated.getRules().size()); - assertTrue(evaluated.getFacts().contains(Atoms.newBasicAtom(Predicates.getPredicate("a", 1), Terms.newConstant(1)))); - assertTrue(evaluated.getFacts().contains(Atoms.newBasicAtom(Predicates.getPredicate("c", 1), Terms.newConstant(2)))); - assertTrue(evaluated.getFacts().contains(Atoms.newBasicAtom(Predicates.getPredicate("d", 1), Terms.newConstant(3)))); - } - - private static void verifyAnswerSetsEqualityWithVar(Set answerSets) { - TestUtils.assertAnswerSetsEqual("a(1), a(2), a(3), b(1), c(2), d(3)", answerSets); - } - -} diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingRuleAnalysisTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingRuleAnalysisTest.java index 96a4c6e11..f4ec2ce48 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingRuleAnalysisTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/programs/transformation/aggregates/AggregateRewritingRuleAnalysisTest.java @@ -10,6 +10,7 @@ import java.util.Map; import java.util.Set; +import at.ac.tuwien.kr.alpha.test.RuleParser; import org.junit.jupiter.api.Test; import at.ac.tuwien.kr.alpha.api.programs.atoms.AggregateAtom.AggregateElement; @@ -24,7 +25,6 @@ import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.literals.Literals; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; -import at.ac.tuwien.kr.alpha.core.test.util.RuleParser; public class AggregateRewritingRuleAnalysisTest { diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/rules/RuleGroundingInfoTest.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/rules/RuleGroundingInfoTest.java index 32df51f6f..6edbd02ed 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/rules/RuleGroundingInfoTest.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/rules/RuleGroundingInfoTest.java @@ -32,15 +32,16 @@ import static org.junit.jupiter.api.Assertions.assertTrue; import static org.junit.jupiter.api.Assertions.fail; +import at.ac.tuwien.kr.alpha.api.programs.terms.ArithmeticOperator; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; +import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; +import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; import org.junit.jupiter.api.Test; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -import at.ac.tuwien.kr.alpha.api.terms.ArithmeticOperator; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; -import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; -import at.ac.tuwien.kr.alpha.commons.terms.Terms; import at.ac.tuwien.kr.alpha.core.grounder.RuleGroundingInfo; import at.ac.tuwien.kr.alpha.core.grounder.RuleGroundingInfoImpl; diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/AtomCounterTests.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/AtomCounterTests.java index 96d0e0626..b5d69b652 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/AtomCounterTests.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/AtomCounterTests.java @@ -124,7 +124,7 @@ private void createChoiceAtom() { private void createRuleAtom() { BasicAtom atomAA = Atoms.newBasicAtom(Predicates.getPredicate("aa", 0)); CompiledRule ruleAA = new InternalRule(Heads.newNormalHead(atomAA), - Collections.singletonList(Atoms.newBasicAtom(Predicates.getPredicate("bb", 0)).toLiteral(false))); + Collections.singleton(Atoms.newBasicAtom(Predicates.getPredicate("bb", 0)).toLiteral(false))); atomStore.putIfAbsent(new RuleAtom(ruleAA, new BasicSubstitution())); } diff --git a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/AlphaHeuristicTestAssumptions.java b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/AlphaHeuristicTestAssumptions.java index 9edb1fe89..faa380f8e 100644 --- a/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/AlphaHeuristicTestAssumptions.java +++ b/alpha-core/src/test/java/at/ac/tuwien/kr/alpha/core/solver/heuristics/AlphaHeuristicTestAssumptions.java @@ -35,13 +35,14 @@ import java.util.function.Predicate; import java.util.stream.Collectors; +import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; +import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; +import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.commons.Predicates; -import at.ac.tuwien.kr.alpha.commons.atoms.Atoms; -import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; import at.ac.tuwien.kr.alpha.core.common.AtomStore; import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; import at.ac.tuwien.kr.alpha.core.common.NoGood; @@ -49,7 +50,6 @@ import at.ac.tuwien.kr.alpha.core.grounder.NaiveGrounder; import at.ac.tuwien.kr.alpha.core.programs.CompiledProgram; import at.ac.tuwien.kr.alpha.core.programs.InternalProgram; -import at.ac.tuwien.kr.alpha.core.rules.CompiledRule; import at.ac.tuwien.kr.alpha.core.rules.CompiledRules; import at.ac.tuwien.kr.alpha.core.solver.ChoiceManager; import at.ac.tuwien.kr.alpha.core.solver.NaiveNoGoodStore; diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleParser.java b/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/RuleParser.java similarity index 94% rename from alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleParser.java rename to alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/RuleParser.java index ee00c7c4b..d66576a44 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleParser.java +++ b/alpha-core/src/testFixtures/java/at/ac/tuwien/kr/alpha/test/RuleParser.java @@ -1,4 +1,4 @@ -package at.ac.tuwien.kr.alpha.core.test.util; +package at.ac.tuwien.kr.alpha.test; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java index dcc85fdec..9905d39f5 100644 --- a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaFactory.java @@ -65,7 +65,7 @@ protected ActionImplementationProvider newActionImplementationProvider() { return new DefaultActionImplementationProvider(); } - protected Alpha buildInstance(SystemConfig cfg) { + public Alpha buildInstance(SystemConfig cfg) { ActionImplementationProvider actionImplementationProvider = newActionImplementationProvider(); ProgramParser parser = new ProgramParserImpl(actionImplementationProvider, Collections.emptyMap()); ProgramTransformation programNormalizer = new NormalizeProgramTransformation(cfg.getAggregateRewritingConfig()); diff --git a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java index 78631d11b..f24c9df63 100644 --- a/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java +++ b/alpha-solver/src/main/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImpl.java @@ -1,19 +1,19 @@ /** * Copyright (c) 2017-2019, the Alpha Team. * All rights reserved. - * + *

* Additional changes made by Siemens. - * + *

* Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: - * + *

* 1) Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * + * list of conditions and the following disclaimer. + *

* 2) Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following disclaimer in the documentation - * and/or other materials provided with the distribution. - * + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + *

* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE @@ -79,9 +79,7 @@ public class AlphaImpl implements Alpha { private static final Logger LOGGER = LoggerFactory.getLogger(AlphaImpl.class); private final ProgramParser parser; - private final ProgramTransformation programNormalization; - private final Supplier stratifiedEvaluationFactory; private final GrounderFactory grounderFactory; private final SolverFactory solverFactory; @@ -90,11 +88,11 @@ public class AlphaImpl implements Alpha { private final boolean sortAnswerSets; AlphaImpl(ProgramParser parser, ProgramTransformation programNormalization, - Supplier stratifiedEvaluationFactory, - GrounderFactory grounderFactory, - SolverFactory solverFactory, - Reifier reifier, - boolean sortAnswerSets) { + Supplier stratifiedEvaluationFactory, + GrounderFactory grounderFactory, + SolverFactory solverFactory, + Reifier reifier, + boolean sortAnswerSets) { this.parser = parser; this.programNormalization = programNormalization; this.stratifiedEvaluationFactory = stratifiedEvaluationFactory; @@ -122,7 +120,7 @@ public InputProgram readProgram(InputConfig cfg) throws IOException { @Override public InputProgram readProgramFiles(boolean literate, Map externals, List paths) throws IOException { - return readProgramFiles(literate, externals, paths.stream().map(Paths::get).collect(Collectors.toList()).toArray(new Path[] {})); + return readProgramFiles(literate, externals, paths.stream().map(Paths::get).collect(Collectors.toList()).toArray(new Path[]{})); } @Override @@ -213,7 +211,7 @@ public Stream solve(NormalProgram program, java.util.function.Predica /** * Solves the given program and filters answer sets based on the passed predicate. - * + * * @param program an {@link InternalProgram} to solve * @param filter {@link Predicate} filtering {@link at.ac.tuwien.kr.alpha.api.programs.Predicate}s in the returned answer sets * @return a Stream of answer sets representing stable models of the given program @@ -226,7 +224,7 @@ private Stream solve(CompiledProgram program, java.util.function.Pred /** * Prepares a solver (and accompanying grounder) instance pre-loaded with the given program. Use this if the * solver is needed after reading answer sets (e.g. for obtaining statistics). - * + * * @param program the program to solve. * @param filter a (java util) predicate that filters (asp-)predicates which should be contained in the answer * set stream from the solver. diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java index b52ab8273..c954bfb46 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ActionsTest.java @@ -3,7 +3,6 @@ import at.ac.tuwien.kr.alpha.api.Alpha; import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.config.SystemConfig; -import at.ac.tuwien.kr.alpha.api.impl.AlphaFactory; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; @@ -46,7 +45,7 @@ public class ActionsTest { @Test public void helloWorld() { MockedActionsAlphaFactory alphaFactory = new MockedActionsAlphaFactory(); - Alpha alpha = AlphaFactory.newAlpha(); + Alpha alpha = alphaFactory.buildInstance(new SystemConfig()); InputProgram program = alpha.readProgramString(HELLO_WORLD); alpha.solve(program); assertEquals("Hello World!", alphaFactory.getActionImplementationMock().getStdoutContent()); @@ -62,7 +61,7 @@ public void writeToFile() { MockedActionsAlphaFactory alphaFactory = new MockedActionsAlphaFactory(); alphaFactory.getActionImplementationMock().setMockedFileOutputs(mockedFileOutputs); ActionImplementationProvider actionProvider = alphaFactory.getActionImplementationMock(); - Alpha alpha = AlphaFactory.newAlpha(); + Alpha alpha = alphaFactory.buildInstance(new SystemConfig()); InputProgram program = alpha.readProgramString(WRITE_TO_FILE); Set answerSets = alpha.solve(program).collect(Collectors.toSet()); LOGGER.debug("Got answer sets: {}", answerSets); @@ -70,7 +69,7 @@ public void writeToFile() { AnswerSet answerSet = answerSets.stream().findFirst().get(); /* * Note: We have to check answer set content here because we have no way of constructing an equal instance for - * the outputStreamHandle that is constructed when execution the "fileOutputStream" action. * + * the outputStreamHandle that is constructed when executing the "fileOutputStream" action. * */ assertEquals(1, answerSet.query(Atoms.query(Predicates.getPredicate("outfile_open_result", 2)) .withFilter(0, term -> term instanceof ConstantTerm && ((ConstantTerm) term).getObject().endsWith("dummy.file")) diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateLiteralSplittingTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateLiteralSplittingTest.java index 13df2386e..9481ebc5f 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateLiteralSplittingTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateLiteralSplittingTest.java @@ -1,15 +1,15 @@ -package at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates; +package at.ac.tuwien.kr.alpha; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertTrue; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; +import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateLiteralSplitting; +import at.ac.tuwien.kr.alpha.test.RuleParser; +import org.junit.jupiter.api.Test; import java.util.List; -import org.junit.jupiter.api.Test; - -import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; -import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; -import at.ac.tuwien.kr.alpha.core.test.util.RuleParser; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; public class AggregateLiteralSplittingTest { diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateOperatorNormalizationTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateOperatorNormalizationTest.java index 3b8870c04..72ecd207b 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateOperatorNormalizationTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateOperatorNormalizationTest.java @@ -1,10 +1,4 @@ -package at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import org.junit.jupiter.api.Test; +package at.ac.tuwien.kr.alpha; import at.ac.tuwien.kr.alpha.api.ComparisonOperator; import at.ac.tuwien.kr.alpha.api.programs.literals.AggregateLiteral; @@ -17,7 +11,11 @@ import at.ac.tuwien.kr.alpha.api.programs.terms.Term; import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; -import at.ac.tuwien.kr.alpha.core.test.util.RuleParser; +import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateOperatorNormalization; +import at.ac.tuwien.kr.alpha.test.RuleParser; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; public class AggregateOperatorNormalizationTest { diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingContextTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingContextTest.java index a4805b8b3..e872f081e 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingContextTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingContextTest.java @@ -1,14 +1,4 @@ -package at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import java.util.Map; -import java.util.Set; -import java.util.function.Predicate; - -import org.apache.commons.lang3.tuple.ImmutablePair; -import org.junit.jupiter.api.Test; +package at.ac.tuwien.kr.alpha; import at.ac.tuwien.kr.alpha.api.ComparisonOperator; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; @@ -19,7 +9,17 @@ import at.ac.tuwien.kr.alpha.commons.comparisons.ComparisonOperators; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; +import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewritingContext; import at.ac.tuwien.kr.alpha.core.programs.transformation.aggregates.AggregateRewritingContext.AggregateInfo; +import org.apache.commons.lang3.tuple.ImmutablePair; +import org.junit.jupiter.api.Test; + +import java.util.Map; +import java.util.Set; +import java.util.function.Predicate; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; public class AggregateRewritingContextTest { diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingTest.java index e4ca8acf3..245304cc5 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/AggregateRewritingTest.java @@ -1,36 +1,22 @@ package at.ac.tuwien.kr.alpha; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import java.util.List; -import java.util.function.Function; -import java.util.stream.Collectors; - import at.ac.tuwien.kr.alpha.api.Alpha; -import at.ac.tuwien.kr.alpha.api.impl.AlphaFactory; -import org.junit.jupiter.api.Disabled; -import org.junit.jupiter.api.Test; - import at.ac.tuwien.kr.alpha.api.AnswerSet; -import at.ac.tuwien.kr.alpha.api.Solver; -import at.ac.tuwien.kr.alpha.api.config.SystemConfig; +import at.ac.tuwien.kr.alpha.api.impl.AlphaFactory; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; -import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.Predicate; -import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.commons.Predicates; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; -import at.ac.tuwien.kr.alpha.core.common.AtomStore; -import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; -import at.ac.tuwien.kr.alpha.core.grounder.Grounder; -import at.ac.tuwien.kr.alpha.core.grounder.GrounderFactory; -import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; -import at.ac.tuwien.kr.alpha.core.programs.CompiledProgram; -import at.ac.tuwien.kr.alpha.core.programs.InternalProgram; -import at.ac.tuwien.kr.alpha.core.programs.transformation.NormalizeProgramTransformation; -import at.ac.tuwien.kr.alpha.core.solver.SolverFactory; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; + +import java.util.List; +import java.util.function.Function; +import java.util.stream.Collectors; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; public class AggregateRewritingTest { diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ArithmeticTermsRewritingTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ArithmeticTermsRewritingTest.java index bbcb22734..3c6e195de 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ArithmeticTermsRewritingTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/ArithmeticTermsRewritingTest.java @@ -1,17 +1,5 @@ package at.ac.tuwien.kr.alpha; -import static java.util.stream.Collectors.toList; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import java.util.Collections; -import java.util.List; -import java.util.Map; -import java.util.Set; - -import at.ac.tuwien.kr.alpha.core.programs.transformation.ArithmeticTermsRewriting; -import org.junit.jupiter.api.Test; - import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; import at.ac.tuwien.kr.alpha.api.externals.Predicate; import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; @@ -22,10 +10,21 @@ import at.ac.tuwien.kr.alpha.api.programs.rules.NormalRule; import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.commons.externals.Externals; import at.ac.tuwien.kr.alpha.commons.programs.Programs; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; -import at.ac.tuwien.kr.alpha.commons.externals.Externals; import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; +import at.ac.tuwien.kr.alpha.core.programs.transformation.ArithmeticTermsRewriting; +import org.junit.jupiter.api.Test; + +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import static java.util.stream.Collectors.toList; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; /** * Copyright (c) 2021, the Alpha Team. diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/FixedInterpretationLiteralsTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/FixedInterpretationLiteralsTest.java index 9915ef7b0..530040d78 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/FixedInterpretationLiteralsTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/FixedInterpretationLiteralsTest.java @@ -1,31 +1,22 @@ package at.ac.tuwien.kr.alpha; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import java.util.ArrayList; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.Set; - -import at.ac.tuwien.kr.alpha.api.impl.AlphaFactory; -import org.junit.jupiter.api.Test; - import at.ac.tuwien.kr.alpha.api.Alpha; import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; +import at.ac.tuwien.kr.alpha.api.impl.AlphaFactory; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; import at.ac.tuwien.kr.alpha.commons.Predicates; +import at.ac.tuwien.kr.alpha.commons.externals.AspStandardLibrary; +import at.ac.tuwien.kr.alpha.commons.externals.Externals; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; -import at.ac.tuwien.kr.alpha.commons.externals.Externals; -import at.ac.tuwien.kr.alpha.commons.externals.AspStandardLibrary; +import org.junit.jupiter.api.Test; + +import java.util.*; + +import static org.junit.jupiter.api.Assertions.*; public class FixedInterpretationLiteralsTest { diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleToStringTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleToStringTest.java index 7b075979e..f099fb724 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleToStringTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/RuleToStringTest.java @@ -23,13 +23,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package at.ac.tuwien.kr.alpha.core.grounder; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -import java.util.List; - -import org.junit.jupiter.api.Test; +package at.ac.tuwien.kr.alpha; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; @@ -39,10 +33,12 @@ import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; import at.ac.tuwien.kr.alpha.core.programs.rules.CompiledRule; import at.ac.tuwien.kr.alpha.core.programs.rules.InternalRule; +import org.junit.jupiter.api.Test; + +import java.util.List; + +import static org.junit.jupiter.api.Assertions.assertEquals; -/** - * Tests {@link BasicRule#toString()} and {@link InternalRule#toString()}. - */ public class RuleToStringTest { private final ProgramParser parser = new ProgramParserImpl(); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/StratifiedEvaluationTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/StratifiedEvaluationTest.java index 19ec176cb..7c6c5fdae 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/StratifiedEvaluationTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/StratifiedEvaluationTest.java @@ -27,49 +27,32 @@ */ package at.ac.tuwien.kr.alpha; -import static at.ac.tuwien.kr.alpha.test.AlphaAssertions.assertAnswerSetsEqual; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import java.io.IOException; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.function.Function; -import java.util.stream.Collectors; - import at.ac.tuwien.kr.alpha.api.Alpha; -import at.ac.tuwien.kr.alpha.api.DebugSolvingContext; -import at.ac.tuwien.kr.alpha.api.impl.AlphaFactory; -import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; -import at.ac.tuwien.kr.alpha.core.programs.transformation.NormalizeProgramTransformation; -import at.ac.tuwien.kr.alpha.core.programs.transformation.StratifiedEvaluation; -import org.junit.jupiter.api.Test; - import at.ac.tuwien.kr.alpha.api.AnswerSet; -import at.ac.tuwien.kr.alpha.api.Solver; +import at.ac.tuwien.kr.alpha.api.DebugSolvingContext; import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; -import at.ac.tuwien.kr.alpha.api.config.SystemConfig; +import at.ac.tuwien.kr.alpha.api.impl.AlphaFactory; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; +import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.Predicate; -import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.commons.Predicates; +import at.ac.tuwien.kr.alpha.commons.externals.Externals; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; -import at.ac.tuwien.kr.alpha.commons.substitutions.Instance; -import at.ac.tuwien.kr.alpha.core.common.AtomStore; -import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; -import at.ac.tuwien.kr.alpha.commons.externals.Externals; -import at.ac.tuwien.kr.alpha.core.grounder.Grounder; -import at.ac.tuwien.kr.alpha.core.grounder.GrounderFactory; -import at.ac.tuwien.kr.alpha.core.parser.ProgramParserImpl; -import at.ac.tuwien.kr.alpha.core.programs.AnalyzedProgram; -import at.ac.tuwien.kr.alpha.core.programs.CompiledProgram; -import at.ac.tuwien.kr.alpha.core.programs.InternalProgram; -import at.ac.tuwien.kr.alpha.core.solver.SolverFactory; +import org.junit.jupiter.api.Test; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.stream.Collectors; + +import static at.ac.tuwien.kr.alpha.test.AlphaAssertions.assertAnswerSetsEqual; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; public class StratifiedEvaluationTest { diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java index c26b6c66d..9b25373ec 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/api/impl/AlphaImplTest.java @@ -163,7 +163,7 @@ public void addsFacts() { List things = asList(a, b); InputProgram program = Programs.builder().addFacts(Externals.asFacts(Thingy.class, things)).build(); Set actual = system.solve(program).collect(Collectors.toSet()); - Set expected = new HashSet<>(singletonList(new AnswerSetBuilder().predicate("thingy").instance(a).instance(b).build())); + Set expected = Set.of(new AnswerSetBuilder().predicate("thingy").instance(a).instance(b).build()); assertEquals(expected, actual); } @@ -678,6 +678,7 @@ private void problematicRun(String program, long seed, int limit) throws IOExcep // Detailed reproduction test-case for github issue #239. @Test + @Disabled("This test relies on stratified evaluation being disabled, which is not supported anymore.") public void testLearnedUnaryNoGoodCausingOutOfOrderLiteralsConflict() throws IOException { final ProgramParser parser = new ProgramParserImpl(); InputProgramBuilder bld = Programs.builder(); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/SolverTests.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/SolverTests.java index c992ae820..65556fc3e 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/SolverTests.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/SolverTests.java @@ -27,16 +27,6 @@ */ package at.ac.tuwien.kr.alpha.regressiontests; -import static at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTestUtils.*; -import static java.util.Collections.singleton; -import static org.junit.jupiter.api.Assertions.*; - -import java.util.Collections; -import java.util.HashSet; -import java.util.List; -import java.util.Set; -import java.util.SortedSet; - import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.Solver; import at.ac.tuwien.kr.alpha.api.config.SystemConfig; @@ -49,11 +39,15 @@ import at.ac.tuwien.kr.alpha.commons.programs.Programs; import at.ac.tuwien.kr.alpha.commons.programs.atoms.Atoms; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; -import at.ac.tuwien.kr.alpha.core.common.AtomStore; -import at.ac.tuwien.kr.alpha.core.common.AtomStoreImpl; import at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTest; import at.ac.tuwien.kr.alpha.test.AnswerSetsParser; +import java.util.*; + +import static at.ac.tuwien.kr.alpha.regressiontests.util.RegressionTestUtils.*; +import static java.util.Collections.singleton; +import static org.junit.jupiter.api.Assertions.*; + public class SolverTests { private static class Thingy implements Comparable { diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/StratifiedEvaluationRegressionTest.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/StratifiedEvaluationRegressionTest.java index db0f40009..ada29162d 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/StratifiedEvaluationRegressionTest.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/StratifiedEvaluationRegressionTest.java @@ -113,7 +113,7 @@ public void runTest(String aspString, Consumer programVerifier, LOGGER.debug("Testing ASP String {}", aspString); // Parse and pre-evaluate program // Alpha instance with default config, stratified evaluation enabled - Alpha alpha =AlphaFactory.newAlpha(); + Alpha alpha = AlphaFactory.newAlpha(); InputProgram input = alpha.readProgramString(aspString); DebugSolvingContext dbgInfo = alpha.prepareDebugSolve(input); NormalProgram evaluated = dbgInfo.getPreprocessedProgram(); diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/util/RegressionTestUtils.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/util/RegressionTestUtils.java index 0629c8be1..c4301385b 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/util/RegressionTestUtils.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/regressiontests/util/RegressionTestUtils.java @@ -1,16 +1,5 @@ package at.ac.tuwien.kr.alpha.regressiontests.util; -import static at.ac.tuwien.kr.alpha.test.AlphaAssertions.assertAnswerSetsEqual; -import static at.ac.tuwien.kr.alpha.test.AlphaAssertions.assertAnswerSetsEqualWithBase; -import static org.junit.jupiter.api.Assertions.assertTimeoutPreemptively; - -import java.time.Duration; -import java.util.Set; -import java.util.stream.Collectors; - -import org.junit.jupiter.api.Assumptions; -import org.junit.jupiter.api.function.Executable; - import at.ac.tuwien.kr.alpha.api.Alpha; import at.ac.tuwien.kr.alpha.api.AnswerSet; import at.ac.tuwien.kr.alpha.api.Solver; @@ -19,6 +8,16 @@ import at.ac.tuwien.kr.alpha.api.config.SystemConfig; import at.ac.tuwien.kr.alpha.api.impl.AlphaFactory; import at.ac.tuwien.kr.alpha.api.programs.InputProgram; +import org.junit.jupiter.api.Assumptions; +import org.junit.jupiter.api.function.Executable; + +import java.time.Duration; +import java.util.Set; +import java.util.stream.Collectors; + +import static at.ac.tuwien.kr.alpha.test.AlphaAssertions.assertAnswerSetsEqual; +import static at.ac.tuwien.kr.alpha.test.AlphaAssertions.assertAnswerSetsEqualWithBase; +import static org.junit.jupiter.api.Assertions.assertTimeoutPreemptively; public final class RegressionTestUtils { @@ -38,7 +37,7 @@ public static Solver buildSolverForRegressionTest(String programString, SystemCo } public static Solver buildSolverForRegressionTest(InputProgram program, SystemConfig cfg) { - Alpha alpha =AlphaFactory.newAlpha(cfg); + Alpha alpha = AlphaFactory.newAlpha(cfg); return alpha.prepareSolverFor(program, InputConfig.DEFAULT_FILTER); } diff --git a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/test/util/MockedActionsAlphaFactory.java b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/test/util/MockedActionsAlphaFactory.java index 82d6863d0..fffd0cd20 100644 --- a/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/test/util/MockedActionsAlphaFactory.java +++ b/alpha-solver/src/test/java/at/ac/tuwien/kr/alpha/test/util/MockedActionsAlphaFactory.java @@ -8,6 +8,7 @@ public class MockedActionsAlphaFactory extends AlphaFactory { private MockActionImplementationProvider actionImplementationMock = new MockActionImplementationProvider(""); + public MockActionImplementationProvider getActionImplementationMock() { return actionImplementationMock; } @@ -16,6 +17,7 @@ public void setActionImplementationMock(MockActionImplementationProvider actionI this.actionImplementationMock = actionImplementationMock; } + @Override protected ActionImplementationProvider newActionImplementationProvider() { return actionImplementationMock; }