001: /*
002: * Copyright (C) 1999-2004 <A href="http://www-ist.massey.ac.nz/JBDietrich" target="_top">Jens Dietrich</a>
003: *
004: * This library is free software; you can redistribute it and/or
005: * modify it under the terms of the GNU Lesser General Public
006: * License as published by the Free Software Foundation; either
007: * version 2 of the License, or (at your option) any later version.
008: *
009: * This library is distributed in the hope that it will be useful,
010: * but WITHOUT ANY WARRANTY; without even the implied warranty of
011: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
012: * Lesser General Public License for more details.
013: *
014: * You should have received a copy of the GNU Lesser General Public
015: * License along with this library; if not, write to the Free Software
016: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
017: */
018: package test.org.mandarax.lib.math;
019:
020: import java.util.Iterator;
021:
022: import org.mandarax.kernel.Clause;
023: import org.mandarax.kernel.ComplexTerm;
024: import org.mandarax.kernel.Fact;
025: import org.mandarax.kernel.Function;
026: import org.mandarax.kernel.Goal;
027: import org.mandarax.kernel.LogicFactory;
028: import org.mandarax.kernel.Predicate;
029: import org.mandarax.kernel.Term;
030: import org.mandarax.util.AutoFacts;
031:
032: /**
033: * Superclass for testing predicates and functions from the math package.
034: * All tests work as follows: we build an auto fact set, fetch an iterator and
035: * count the facts generated. The number of facts is compared with the expected number of facts.
036: * Facts are printed out on System.out.
037: * @author <A href="http://www-ist.massey.ac.nz/JBDietrich" target="_top">Jens Dietrich</A>
038: * @version 3.4 <7 March 05>
039: * @since 1.6
040: */
041: public abstract class MathTestCase extends junit.framework.TestCase {
042:
043: protected LogicFactory lfactory = LogicFactory.getDefaultFactory();
044:
045: /**
046: * Constructor.
047: */
048: public MathTestCase() {
049: super ("test");
050: }
051:
052: /**
053: * Convenient method to build a complex term from a function f and one term.
054: * The method <code>toTerm</code> is used to interprete objects as terms.
055: * @return a complex term
056: * @param f a function
057: * @param obj an object defining a term
058: */
059: protected ComplexTerm buildComplexTerm(Function f, Object obj) {
060: Term[] terms = { toTerm(obj) };
061:
062: return lfactory.createComplexTerm(f, terms);
063: }
064:
065: /**
066: * Convenient method to build a complex term from a function f and two terms.
067: * The method <code>toTerm</code> is used to interprete objects as terms.
068: * @return a complex term
069: * @param f a function
070: * @param obj1 an object defining a term
071: * @param obj2 an object defining a term
072: */
073: protected ComplexTerm buildComplexTerm(Function f, Object obj1,
074: Object obj2) {
075: Term[] terms = { toTerm(obj1), toTerm(obj2) };
076:
077: return lfactory.createComplexTerm(f, terms);
078: }
079:
080: /**
081: * Convenient method to build a fact from a predicate p and one term.
082: * The method <code>toTerm</code> is used to interprete objects as terms.
083: * @return a fact
084: * @param p a predicate
085: * @param obj an object defining a term
086: */
087: protected Fact buildFact(Predicate p, Object obj) {
088: Term[] terms = { toTerm(obj) };
089:
090: return lfactory.createFact(p, terms);
091: }
092:
093: /**
094: * Convenient method to build a fact from a predicate p and two terms.
095: * The method <code>toTerm</code> is used to interprete objects as terms.
096: * @return a fact
097: * @param p a predicate
098: * @param obj1 an object defining a term
099: * @param obj2 an object defining a term
100: */
101: protected Fact buildFact(Predicate p, Object obj1, Object obj2) {
102: Term[] terms = { toTerm(obj1), toTerm(obj2) };
103:
104: return lfactory.createFact(p, terms);
105: }
106:
107: /**
108: * Convenient method to build a fact from a predicate p and three terms.
109: * The method <code>toTerm</code> is used to interprete objects as terms.
110: * @return a fact
111:
112: * @param p a predicate
113: * @param obj1 an object defining a term
114: * @param obj2 an object defining a term
115: * @param obj3 an object defining a term
116: */
117: protected Fact buildFact(Predicate p, Object obj1, Object obj2,
118: Object obj3) {
119: Term[] terms = { toTerm(obj1), toTerm(obj2), toTerm(obj3) };
120:
121: return lfactory.createFact(p, terms);
122: }
123:
124: /**
125: * Get the auto facts.
126: * @return an auto facts clause set
127: */
128: protected abstract AutoFacts getAutoFacts();
129:
130: /**
131: * Get the expected number of generated facts.
132: * @return the number of facts expected
133: */
134: protected abstract int getExpected();
135:
136: /**
137: * Get the query fact.
138: * @return a query fact.
139: */
140: protected abstract Fact getQueryFact();
141:
142: /**
143: * Get the type (e.g. Integer.class or Double.class) we want to test.
144: * @return the type to be tested
145: */
146: protected abstract Class getType();
147:
148: /**
149: * Perform the test.
150: */
151: public void test() {
152: AutoFacts af = getAutoFacts();
153: Clause query = new Goal(getQueryFact());
154:
155: System.out.println("PERFORMING TEST " + getClass());
156:
157: int counter = 0;
158:
159: for (Iterator it = af.clauses(query, null); it.hasNext();) {
160: counter = counter + 1;
161:
162: System.out.println("Next generated fact is: " + it.next());
163: }
164:
165: System.out.println();
166: assertTrue(getExpected() == counter);
167: }
168:
169: /**
170: * Convinient method to build terms from objects.
171: * If the object is a string, a variable with this name
172: * is returned.
173: * If it is already a term, we just return this term.
174: * @return a term
175: * @param obj the object to be converted to a term
176: * @param index an index (will be appended to the variable name)
177: */
178: private Term toTerm(Object obj) {
179: if (obj instanceof Term) {
180: return (Term) obj;
181: }
182:
183: if (obj instanceof String) {
184: return lfactory.createVariableTerm(obj.toString(),
185: getType());
186: }
187:
188: throw new IllegalArgumentException(
189: "Cannot build term from object " + obj);
190: }
191: }
|