Fix tests after merging changes from master

alpha-asp · Jul 23, 2024 · aad5520 · aad5520
1 parent 173f664
commit aad5520
Show file tree

Hide file tree

Showing 55 changed files with 427 additions and 807 deletions.
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
@@ -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
@@ -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
@@ -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
@@ -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<Head> newRule(Head head, Set<Literal> body) {
 	}
 
 	public static Rule<Head> newRule(Head head, Literal... body) {
-        Set<Literal> bodyLst = new LinkedHashSet<>(Arrays.asList(body));
+		Set<Literal> bodyLst = new LinkedHashSet<>(Arrays.asList(body));
 		return new BasicRule(head, bodyLst);
 	}
 
@@ -31,7 +32,7 @@ public static NormalRule newNormalRule(NormalHead head, Set<Literal> body) {
 	}
 
 	public static NormalRule newNormalRule(NormalHead head, Literal... body) {
-        Set<Literal> bodyLst = new LinkedHashSet<>(Arrays.asList(body));
+		Set<Literal> bodyLst = new LinkedHashSet<>(Arrays.asList(body));
 		return new NormalRuleImpl(head, bodyLst);
 	}
 
@@ -41,9 +42,9 @@ public static NormalRule toNormalRule(Rule<Head> 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/...mons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/ActionHeadImpl.java b/...mons/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<Term> actionInputTerms;
-    private final VariableTerm actionOutputTerm;
-
-    ActionHeadImpl(BasicAtom atom, String actionName, List<Term> 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<Term> 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<Term> actionInputTerms;
+	private final VariableTerm actionOutputTerm;
+
+	ActionHeadImpl(BasicAtom atom, String actionName, List<Term> 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<Term> 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
@@ -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/.../src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/AbstractActionResultTerm.java b/.../src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/AbstractActionResultTerm.java
@@ -7,20 +7,20 @@
 
 abstract class AbstractActionResultTerm<T extends Term> extends FunctionTermImpl implements ActionResultTerm<T> {
 
-    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/...a-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionErrorTerm.java b/...a-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionErrorTerm.java
@@ -6,19 +6,19 @@
 
 class ActionErrorTerm extends AbstractActionResultTerm<ConstantTerm<String>> {
 
-    private static final Interner<ActionErrorTerm> INTERNER = new Interner<>();
+	private static final Interner<ActionErrorTerm> INTERNER = new Interner<>();
 
-    ActionErrorTerm(ConstantTerm<String> value) {
-        super(ActionResultTerm.ERROR_SYMBOL, value);
-    }
+	ActionErrorTerm(ConstantTerm<String> value) {
+		super(ActionResultTerm.ERROR_SYMBOL, value);
+	}
 
-    public static ActionErrorTerm getInstance(ConstantTerm<String> term) {
-        return INTERNER.intern(new ActionErrorTerm(term));
-    }
+	public static ActionErrorTerm getInstance(ConstantTerm<String> term) {
+		return INTERNER.intern(new ActionErrorTerm(term));
+	}
 
-    @Override
-    public boolean isSuccess() {
-        return false;
-    }
+	@Override
+	public boolean isSuccess() {
+		return false;
+	}
 
 }
diff --git a/...commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionSuccessTerm.java b/...commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionSuccessTerm.java
@@ -6,20 +6,20 @@
 
 class ActionSuccessTerm<T extends Term> extends AbstractActionResultTerm<T> {
 
-    private static final Interner<ActionSuccessTerm<?>> INTERNER = new Interner<>();
+	private static final Interner<ActionSuccessTerm<?>> INTERNER = new Interner<>();
 
-    ActionSuccessTerm(T value) {
-        super(ActionResultTerm.SUCCESS_SYMBOL, value);
-    }
+	ActionSuccessTerm(T value) {
+		super(ActionResultTerm.SUCCESS_SYMBOL, value);
+	}
 
-    @SuppressWarnings("unchecked")
-    public static <T extends Term> ActionSuccessTerm<T> getInstance(T term) {
-        return (ActionSuccessTerm<T>) INTERNER.intern(new ActionSuccessTerm<>(term));
-    }
+	@SuppressWarnings("unchecked")
+	public static <T extends Term> ActionSuccessTerm<T> getInstance(T term) {
+		return (ActionSuccessTerm<T>) INTERNER.intern(new ActionSuccessTerm<>(term));
+	}
 
-    @Override
-    public boolean isSuccess() {
-        return true;
-    }
+	@Override
+	public boolean isSuccess() {
+		return true;
+	}
 
 }
diff --git a/...lpha/commons/atoms/BasicAtomImplTest.java → ...ons/programs/atoms/BasicAtomImplTest.java b/...lpha/commons/atoms/BasicAtomImplTest.java → ...ons/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);
 	}
 
 }