TermFinderFacadeBeanTest.java from Texai at Krugle
Show TermFinderFacadeBeanTest.java syntax highlighted
/*
* TermFinderFacadeBeanTest.java
* JUnit based test
*
* initialize the database kb_test using source /home/reed/svn/KnowledgeBase/KnowledgeBase-ejb/data/kb-schema.sql
*
* Created on October 19, 2006, 2:56 PM
*
* Copyright (C) 2006 Stephen L. Reed.
*
* This program is free software; you can redistribute it and/or modify it under the terms
* of the GNU General Public License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with this program;
* if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
package org.texai.kb.ejb.session;
import java.sql.Connection;
import java.sql.Date;
import java.sql.SQLException;
import javax.sql.rowset.serial.SerialException;
import junit.framework.*;
import java.sql.DriverManager;
import java.sql.Statement;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;
import javax.sql.rowset.serial.SerialBlob;
import javax.sql.rowset.serial.SerialClob;
import org.texai.kb.Constants;
import org.texai.kb.ejb.entity.AbstractTerm;
import org.texai.kb.ejb.entity.AtomicTerm;
import org.texai.kb.ejb.entity.BinaryGAF;
import org.texai.kb.ejb.entity.Formula;
import org.texai.kb.ejb.entity.NonAtomicTerm;
import org.texai.kb.ejb.entity.PBlob;
import org.texai.kb.ejb.entity.PCharacter;
import org.texai.kb.ejb.entity.PClob;
import org.texai.kb.ejb.entity.PDate;
import org.texai.kb.ejb.entity.PDouble;
import org.texai.kb.ejb.entity.PLong;
import org.texai.kb.ejb.entity.PString;
import org.texai.kb.ejb.entity.PVariable;
import org.texai.kb.ejb.entity.QuaternaryGAF;
import org.texai.kb.ejb.entity.QuintaryGAF;
import org.texai.kb.ejb.entity.Rule;
import org.texai.kb.ejb.entity.Symbol;
import org.texai.kb.ejb.entity.TernaryGAF;
import org.texai.kb.ejb.entity.TimePoint;
import org.texai.kb.ejb.entity.UnaryGAF;
import org.texai.kb.ejb.session.shared.TermFinderFacadeBean;
/**
*
* @author reed
*/
public class TermFinderFacadeBeanTest extends TestCase {
/** the JDBC connection */
private static Connection connection = null;
/** the one time setup indicator */
private static boolean isFirstTime = true;
/** the entity manager factory */
private static EntityManagerFactory entityManagerFactory;
/** the entity manager */
private static EntityManager entityManager;
public TermFinderFacadeBeanTest(String testName) {
super(testName);
}
protected void setUp() throws Exception {
if (isFirstTime) {
isFirstTime = false;
System.out.println("oneTimeSetup");
try {
getClass().getClassLoader().setDefaultAssertionStatus(true);
System.out.println("setUp: creating EntityManager");
entityManagerFactory = Persistence.createEntityManagerFactory(Constants.TEST_PERSISTENCE_UNIT_NAME);
entityManager = entityManagerFactory.createEntityManager();
System.out.println("entityManager created");
} catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
if (entityManager.getTransaction().isActive()) {
entityManager.getTransaction().rollback();
}
try {
} catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
protected void tearDown() throws Exception {
}
/**
* Test of findSymbolByNameValue method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindSymbolByNameValue() {
System.out.println("findSymbolByNameValue");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
String nameValue = ":NIL";
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
Symbol expResult = new Symbol(nameValue);
entityManager.persist(expResult);
Symbol result = instance.findSymbolByNameValue(nameValue);
assertEquals(expResult, result);
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findSymbolByNameValue OK");
}
/**
* Test of findPVariableByNameValue method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindPVariableByNameValue() {
System.out.println("findPVariableByNameValue");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
String nameValue = "?X";
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
PVariable expResult = new PVariable(nameValue);;
entityManager.persist(expResult);
PVariable result = instance.findPVariableByNameValue(nameValue);
assertEquals(expResult, result);
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findPVariableByNameValue OK");
}
/**
* Test of findPLongByLongValue method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindPLongByLongValue() {
System.out.println("findPLongByLongValue");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
Long longValue = Long.valueOf(12345L);
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
PLong expResult = new PLong(longValue);
entityManager.persist(expResult);
PLong result = instance.findPLongByLongValue(longValue);
assertEquals(expResult, result);
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findPLongByLongValue OK");
}
/**
* Test of findPDoubleByDoubleValue method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindPDoubleByDoubleValue() {
System.out.println("findPDoubleByDoubleValue");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
Double doubleValue = 123.45D;
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
PDouble expResult = new PDouble(doubleValue);
entityManager.persist(expResult);
PDouble result = instance.findPDoubleByDoubleValue(doubleValue);
assertEquals(expResult, result);
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findPDoubleByDoubleValue OK");
}
/**
* Test of findPStringByStringValue method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindPStringByStringValue() {
System.out.println("findPStringByStringValue");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
String stringValue = "ABC";
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
PString expResult = new PString(stringValue);
entityManager.persist(expResult);
PString result = instance.findPStringByStringValue(stringValue);
assertEquals(expResult, result);
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findPStringByStringValue OK");
}
/**
* Test of findPCharacterByCharacterValue method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindPCharacterByCharacterValue() {
System.out.println("findPCharacterByCharacterValue");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
Character characterValue = '%';
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
PCharacter expResult = new PCharacter(characterValue);
entityManager.persist(expResult);
PCharacter result = instance.findPCharacterByCharacterValue(characterValue);
assertEquals(expResult, result);
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findPCharacterByCharacterValue OK");
}
/**
* Test of findPDateByDateValue method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindPDateByDateValue() {
System.out.println("findPDateByDateValue");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
java.util.Date today = new java.util.Date();
java.sql.Date dateValue = new java.sql.Date(today.getTime());
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
PDate expResult = new PDate(dateValue);
entityManager.persist(expResult);
PDate result = instance.findPDateByDateValue(dateValue);
assertEquals(expResult, result);
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findPDateByDateValue OK");
}
/**
* Test of findTimePointByTimePointValue method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindTimePointByTimePointValue() {
System.out.println("findTimePointByTimePointValue");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
java.util.Date today = new java.util.Date();
Timestamp timePointValue = new Timestamp(today.getTime());
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
TimePoint expResult = new TimePoint(timePointValue);
entityManager.persist(expResult);
TimePoint result = instance.findTimePointByTimePointValue(timePointValue);
assertEquals(expResult, result);
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findTimePointByTimePointValue OK");
}
/**
* Test of findPClobByClobValue method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindPClobByClobValue() {
System.out.println("findPClobByClobValue");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
char[] chars = new char[1000];
for (int i = 0; i < chars.length; i++) {
chars[i] = 'a';
}
SerialClob clobValue = null;
try {
clobValue = new SerialClob(chars);
} catch (SerialException ex) {
ex.printStackTrace();
fail();
} catch (SQLException ex) {
ex.printStackTrace();
fail();
}
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
PClob expResult = new PClob(clobValue);
entityManager.persist(expResult);
PClob result = instance.findPClobByClobValue(clobValue);
assertEquals(expResult.toString(), result.toString());
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findPClobByClobValue OK");
}
/**
* Test of findPBlobByBlobValue method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindPBlobByBlobValue() {
System.out.println("findPBlobByBlobValue");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
byte[] bytes = new byte[1000];
for (int i = 0; i < bytes.length; i++) {
bytes[i] = 1;
}
SerialBlob blobValue = null;
try {
blobValue = new SerialBlob(bytes);
} catch (SerialException ex) {
ex.printStackTrace();
fail();
} catch (SQLException ex) {
ex.printStackTrace();
fail();
}
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
PBlob expResult = new PBlob(blobValue);
entityManager.persist(expResult);
PBlob result = instance.findPBlobByBlobValue(blobValue);
assertNotNull(result.toString());
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findPBlobByBlobValue OK");
}
/**
* Test of findAtomicTermByTermName method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindAtomicTermByTermName() {
System.out.println("findAtomicTermByTermName");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
String termName = "MyTerm-" + UUID.randomUUID().toString();
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
String prettyName = "my term";
String uuid = UUID.randomUUID().toString();
AtomicTerm creator = instance.findAtomicTermByTermName(Constants.TERM_NAME_SOME_CYCLIST);
AtomicTerm creationPurpose = instance.findAtomicTermByTermName(Constants.TERM_NAME_OPEN_CYC_PROJECT);
AtomicTerm expResult = new AtomicTerm(termName, prettyName, uuid, creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(expResult);
AtomicTerm result = instance.findAtomicTermByTermName(termName);
assertEquals(expResult, result);
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findAtomicTermByTermName OK");
}
/**
* Test of findNonAtomicTermByTermName method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindNonAtomicTermByTermName() {
System.out.println("findNonAtomicTermByTermName");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
List<AbstractTerm> termList = new ArrayList<AbstractTerm>();
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
AtomicTerm creator = instance.findAtomicTermByTermName(Constants.TERM_NAME_SOME_CYCLIST);
AtomicTerm creationPurpose = instance.findAtomicTermByTermName(Constants.TERM_NAME_OPEN_CYC_PROJECT);
String listFn = "ListFn-" + UUID.randomUUID().toString();
AtomicTerm functor = new AtomicTerm(listFn, "list of", creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(functor);
termList.add(functor);
String appleTree = "AppleTree-" + UUID.randomUUID().toString();
AtomicTerm arg1 = new AtomicTerm(appleTree, "apple trees", creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(arg1);
termList.add(arg1);
PLong arg2 = new PLong(1L);
entityManager.persist(arg2);
termList.add(arg2);
String termName = listFn + "_" + appleTree + "__1_";
termName = termName.replace('-', '_');
Formula formula = new Formula(termList, creator, creationPurpose, instance.getTimePointNow());
assertEquals(termList, formula.getTermList());
entityManager.persist(formula);
assertTrue(formula.toString().startsWith("ListFn-"));
assertTrue(formula.toString().endsWith(", 1)"));
NonAtomicTerm expResult = new NonAtomicTerm("apple fruit", formula, creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(expResult);
assertTrue(expResult.toString().startsWith("ListFn-"));
assertTrue(expResult.toString().endsWith(", 1)"));
NonAtomicTerm result = instance.findNonAtomicTermByTermName(termName);
assertEquals(expResult, result);
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findNonAtomicTermByTermName OK");
}
/**
* Test of findFormulaByFormulaString method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindFormulaByFormulaString() {
System.out.println("findFormulaByFormulaString");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
List<AbstractTerm> termList = new ArrayList<AbstractTerm>();
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
AtomicTerm creator = instance.findAtomicTermByTermName(Constants.TERM_NAME_SOME_CYCLIST);
AtomicTerm creationPurpose = instance.findAtomicTermByTermName(Constants.TERM_NAME_OPEN_CYC_PROJECT);
String fruitFn = "FruitFn-" + UUID.randomUUID().toString();
AtomicTerm functor = new AtomicTerm(fruitFn, "fruit of", creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(functor);
termList.add(functor);
String pearTree = "PearTree-" + UUID.randomUUID().toString();
AtomicTerm arg1 = new AtomicTerm(pearTree, "pear trees", creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(arg1);
termList.add(arg1);
Formula formula = new Formula(termList, creator, creationPurpose, instance.getTimePointNow());
assertTrue(formula.toString().startsWith("FruitFn-"));
entityManager.persist(formula);
String formulaString = fruitFn + "(" + pearTree + ")";
Formula result = instance.findFormulaByFormulaString(formulaString);
assertEquals(formula, result);
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findFormulaByFormulaString OK");
}
/**
* Test of findRuleByFormula method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindRuleByFormula() {
System.out.println("findRuleByFormula");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
// (implies
// (and
// (genls ?X ?Y)
// (genls ?Y ?Z))
// (genls ?X ?Z))
PVariable x = new PVariable("?X");
entityManager.persist(x);
PVariable y = new PVariable("?Y");
entityManager.persist(y);
PVariable z = new PVariable("?Z");
entityManager.persist(z);
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
AtomicTerm creator = instance.findAtomicTermByTermName(Constants.TERM_NAME_SOME_CYCLIST);
AtomicTerm creationPurpose = instance.findAtomicTermByTermName(Constants.TERM_NAME_OPEN_CYC_PROJECT);
AtomicTerm implies = new AtomicTerm("implies-" + UUID.randomUUID().toString(), "implies", creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(implies);
AtomicTerm and = new AtomicTerm("and-" + UUID.randomUUID().toString(), "and", creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(and);
AtomicTerm genls = new AtomicTerm("genls-" + UUID.randomUUID().toString(), "generalization of", creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(genls);
List<AbstractTerm> termList1 = new ArrayList<AbstractTerm>(0);
termList1.add(genls);
termList1.add(x);
termList1.add(y);
List<AbstractTerm> termList2 = new ArrayList<AbstractTerm>(0);
termList2.add(genls);
termList2.add(y);
termList2.add(z);
List<AbstractTerm> termList3 = new ArrayList<AbstractTerm>(0);
termList3.add(genls);
termList3.add(x);
termList3.add(z);
List<AbstractTerm> termList4 = new ArrayList<AbstractTerm>(0);
termList4.add(and);
Formula formual1 = new Formula(termList1, creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(formual1);
termList4.add(formual1);
Formula formual2 = new Formula(termList2, creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(formual2);
termList4.add(formual2);
List<AbstractTerm> termList5 = new ArrayList<AbstractTerm>(0);
termList5.add(implies);
Formula formula4 = new Formula(termList4, creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(formula4);
termList5.add(formula4);
Formula formula3 = new Formula(termList3, creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(formula3);
termList5.add(formula3);
Formula formula = new Formula(termList5, creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(formula);
System.out.println(formula.toString());
assertTrue(formula.toString().startsWith("implies-"));
assertTrue(formula.toString().endsWith("(?X, ?Z))"));
AtomicTerm context = new AtomicTerm("BaseKB-" + UUID.randomUUID().toString(), "base context", creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(context);
Double strength = Constants.STRENGTH_MONOTONIC;
assertEquals(termList5, formula.getTermList());
Rule expResult = new Rule(formula, context, strength, creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(expResult);
Rule result = instance.findRuleByFormula(formula, creator, creationPurpose);
assertNotNull(result);
assertEquals(termList5, result.getFormula().getTermList());
assertEquals(expResult.getFormula().getTermList(), result.getFormula().getTermList());
assertEquals(expResult.getFormula(), result.getFormula());
assertEquals(expResult, result);
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findRuleByFormula OK");
}
/**
* Test of findUnaryGAFByConstituents method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindUnaryGAFByConstituents() {
System.out.println("findUnaryGAFByConstituents");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
AtomicTerm creator = instance.findAtomicTermByTermName(Constants.TERM_NAME_SOME_CYCLIST);
AtomicTerm creationPurpose = instance.findAtomicTermByTermName(Constants.TERM_NAME_OPEN_CYC_PROJECT);
AtomicTerm predicate = new AtomicTerm("MyUnaryPredicate-" + UUID.randomUUID().toString(), "my unary predicate", creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(predicate);
List<AbstractTerm> args = new ArrayList<AbstractTerm>();
AbstractTerm arg1 = new PString("abc");
entityManager.persist(arg1);
args.add(arg1);
AtomicTerm context = instance.findAtomicTermByTermName("BaseKB");
UnaryGAF expResult = new UnaryGAF(predicate, args, context, Constants.STRENGTH_DEFAULT, null, creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(expResult);
UnaryGAF result = instance.findUnaryGAFByConstituents(predicate, args, context);
assertEquals(expResult, result);
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findUnaryGAFByConstituents OK");
}
/**
* Test of findBinaryGAFByConstituents method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindBinaryGAFByConstituents() {
System.out.println("findBinaryGAFByConstituents");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
AtomicTerm creator = instance.findAtomicTermByTermName(Constants.TERM_NAME_SOME_CYCLIST);
AtomicTerm creationPurpose = instance.findAtomicTermByTermName(Constants.TERM_NAME_OPEN_CYC_PROJECT);
AtomicTerm predicate = new AtomicTerm("MyBinaryPredicate-" + UUID.randomUUID().toString(), "my unary predicate", creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(predicate);
List<AbstractTerm> args = new ArrayList<AbstractTerm>();
AbstractTerm arg1 = new PString("abc");
entityManager.persist(arg1);
args.add(arg1);
AbstractTerm arg2 = new PLong(123L);
entityManager.persist(arg2);
args.add(arg2);
AtomicTerm context = instance.findAtomicTermByTermName("BaseKB");
BinaryGAF expResult = new BinaryGAF(predicate, args, context, Constants.STRENGTH_DEFAULT, null, creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(expResult);
BinaryGAF result = instance.findBinaryGAFByConstituents(predicate, args, context);
assertEquals(expResult, result);
final List results =
entityManager.createNamedQuery("BinaryGAF.findArg2")
.setParameter("predicate", predicate)
.setParameter("arg1", arg1)
.setParameter("context", context)
.getResultList();
assertTrue(!results.isEmpty());
Object obj = results.get(0);
assertEquals(arg2, obj);
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findBinaryGAFByConstituents OK");
}
/**
* Test of findTernaryGAFByConstituents method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindTernaryGAFByConstituents() {
System.out.println("findTernaryGAFByConstituents");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
AtomicTerm creator = instance.findAtomicTermByTermName(Constants.TERM_NAME_SOME_CYCLIST);
AtomicTerm creationPurpose = instance.findAtomicTermByTermName(Constants.TERM_NAME_OPEN_CYC_PROJECT);
AtomicTerm predicate = new AtomicTerm("MyTernaryPredicate-" + UUID.randomUUID().toString(), "my unary predicate", creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(predicate);
List<AbstractTerm> args = new ArrayList<AbstractTerm>();
AbstractTerm arg1 = new PString("abc");
entityManager.persist(arg1);
args.add(arg1);
AbstractTerm arg2 = new PLong(123L);
entityManager.persist(arg2);
args.add(arg2);
AbstractTerm arg3 = new AtomicTerm("MyTerm1-" + UUID.randomUUID().toString(), "my term 1", creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(arg3);
args.add(arg3);
AtomicTerm context = instance.findAtomicTermByTermName("BaseKB");
TernaryGAF expResult = new TernaryGAF(predicate, args, context, Constants.STRENGTH_DEFAULT, null, creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(expResult);
TernaryGAF result = instance.findTernaryGAFByConstituents(predicate, args, context);
assertEquals(expResult, result);
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findTernaryGAFByConstituents OK");
}
/**
* Test of findQuaternaryGAFByConstituents method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindQuaternaryGAFByConstituents() {
System.out.println("findQuaternaryGAFByConstituents");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
AtomicTerm creator = instance.findAtomicTermByTermName(Constants.TERM_NAME_SOME_CYCLIST);
AtomicTerm creationPurpose = instance.findAtomicTermByTermName(Constants.TERM_NAME_OPEN_CYC_PROJECT);
AtomicTerm predicate = new AtomicTerm("MyQuaternaryPredicate-" + UUID.randomUUID().toString(), "my unary predicate", creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(predicate);
List<AbstractTerm> args = new ArrayList<AbstractTerm>();
AbstractTerm arg1 = new PString("abc");
entityManager.persist(arg1);
args.add(arg1);
AbstractTerm arg2 = new PLong(123L);
entityManager.persist(arg2);
args.add(arg2);
AbstractTerm arg3 = new AtomicTerm("MyTerm 2-" + UUID.randomUUID().toString(), "my term 2", creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(arg3);
args.add(arg3);
AbstractTerm arg4 = new Symbol(":NIL");
entityManager.persist(arg4);
args.add(arg4);
AtomicTerm context = instance.findAtomicTermByTermName("BaseKB");
QuaternaryGAF expResult = new QuaternaryGAF(predicate, args, context, Constants.STRENGTH_DEFAULT, null, creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(expResult);
QuaternaryGAF result = instance.findQuaternaryGAFByConstituents(predicate, args, context);
assertEquals(expResult, result);
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findQuaternaryGAFByConstituents OK");
}
/**
* Test of findQuintaryGAFByConstituents method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindQuintaryGAFByConstituents() {
System.out.println("findQuintaryGAFByConstituents");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
AtomicTerm creator = instance.findAtomicTermByTermName(Constants.TERM_NAME_SOME_CYCLIST);
AtomicTerm creationPurpose = instance.findAtomicTermByTermName(Constants.TERM_NAME_OPEN_CYC_PROJECT);
AtomicTerm predicate = new AtomicTerm("MyQunintaryPredicate-" + UUID.randomUUID().toString(), "my unary predicate", creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(predicate);
List<AbstractTerm> args = new ArrayList<AbstractTerm>();
AbstractTerm arg1 = new PString("abc");
entityManager.persist(arg1);
args.add(arg1);
AbstractTerm arg2 = new PLong(123L);
entityManager.persist(arg2);
args.add(arg2);
AbstractTerm arg3 = new AtomicTerm("MyTerm4-" + UUID.randomUUID().toString(), "my term 4", creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(arg3);
args.add(arg3);
AbstractTerm arg4 = new Symbol(":NIL");
entityManager.persist(arg4);
args.add(arg4);
AbstractTerm arg5 = new PDouble(123.4D);
entityManager.persist(arg5);
args.add(arg5);
AtomicTerm context = instance.findAtomicTermByTermName("BaseKB");
QuintaryGAF expResult = new QuintaryGAF(predicate, args, context, Constants.STRENGTH_DEFAULT, null, creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(expResult);
QuintaryGAF result = instance.findQuintaryGAFByConstituents(predicate, args, context);
assertEquals(expResult, result);
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findQuintaryGAFByConstituents OK");
}
/**
* Test of findOrCreateSymbolByNameValue method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindOrCreateSymbolByNameValue() {
System.out.println("findOrCreateSymbolByNameValue");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
String nameValue = ":NIL";
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
Symbol expResult = new Symbol(":NIL");
Symbol result = instance.findOrCreateSymbolByNameValue(nameValue);
assertEquals(expResult, result);
assertNotNull(result.getTermId());
assertTrue(entityManager.contains(result));
Symbol result2 = entityManager.find(Symbol.class, result.getTermId());
assertNotNull(result2);
assertEquals(result.getTermId(), result2.getTermId());
Symbol result3 = instance.findOrCreateSymbolByNameValue(nameValue);
assertEquals(expResult, result3);
assertNotNull(result.getTermId());
assertEquals(result, result3);
assertEquals(result.getTermId(), result3.getTermId());
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findOrCreateSymbolByNameValue OK");
}
/**
* Test of findOrCreatePVariableByNameValue method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindOrCreatePVariableByNameValue() {
System.out.println("findOrCreatePVariableByNameValue");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
String nameValue = "?X";
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
PVariable expResult = new PVariable("?X");
PVariable result = instance.findOrCreatePVariableByNameValue(nameValue);
assertEquals(expResult, result);
assertNotNull(result.getTermId());
PVariable result2 = instance.findOrCreatePVariableByNameValue(nameValue);
assertNotNull(result2);
assertNotNull(result2.getTermId());
assertEquals(result, result2);
assertEquals(result.getTermId(), result2.getTermId());
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findOrCreatePVariableByNameValue OK");
}
/**
* Test of findOrCreatePLongByLongValue method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindOrCreatePLongByLongValue() {
System.out.println("findOrCreatePLongByLongValue");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
Long longValue = 12345L;
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
PLong result = instance.findOrCreatePLongByLongValue(longValue);
assertNotNull(result);
assertNotNull(result.getTermId());
assertEquals("12345", result.toString());
PLong result2 = instance.findOrCreatePLongByLongValue(longValue);
assertNotNull(result2);
assertNotNull(result2.getTermId());
assertEquals(result, result2);
assertEquals(result.getTermId(), result2.getTermId());
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findOrCreatePLongByLongValue OK");
}
/**
* Test of findOrCreatePDoubleByDoubleValue method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindOrCreatePDoubleByDoubleValue() {
System.out.println("findOrCreatePDoubleByDoubleValue");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
Double doubleValue = 1234.567D;
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
PDouble result = instance.findOrCreatePDoubleByDoubleValue(doubleValue);
assertNotNull(result);
assertNotNull(result.getTermId());
assertEquals("1234.567", result.toString());
PDouble result2 = instance.findOrCreatePDoubleByDoubleValue(doubleValue);
assertNotNull(result2);
assertNotNull(result2.getTermId());
assertEquals(result, result2);
assertEquals(result.getTermId(), result2.getTermId());
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findOrCreatePDoubleByDoubleValue OK");
}
/**
* Test of findOrCreatePStringByStringValue method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindOrCreatePStringByStringValue() {
System.out.println("findOrCreatePStringByStringValue");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
String stringValue = "def";
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
PString result = instance.findOrCreatePStringByStringValue(stringValue);
assertNotNull(result);
assertNotNull(result.getTermId());
assertEquals("\"def\"", result.toString());
PString result2 = instance.findOrCreatePStringByStringValue(stringValue);
assertNotNull(result2);
assertNotNull(result2.getTermId());
assertEquals(result, result2);
assertEquals(result.getTermId(), result2.getTermId());
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findOrCreatePStringByStringValue OK");
}
/**
* Test of findOrCreatePCharacterByCharacterValue method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindOrCreatePCharacterByCharacterValue() {
System.out.println("findOrCreatePCharacterByCharacterValue");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
Character characterValue = new Character('$');
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
PCharacter result = instance.findOrCreatePCharacterByCharacterValue(characterValue);
assertNotNull(result);
assertNotNull(result.getTermId());
assertEquals("$", result.toString());
PCharacter result2 = instance.findOrCreatePCharacterByCharacterValue(characterValue);
assertNotNull(result2);
assertNotNull(result2.getTermId());
assertEquals(result, result2);
assertEquals(result.getTermId(), result2.getTermId());
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findOrCreatePCharacterByCharacterValue OK");
}
/**
* Test of findOrCreatePDateByDateValue method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindOrCreatePDateByDateValue() {
System.out.println("findOrCreatePDateByDateValue");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
Date dateValue = new Date((new java.util.Date()).getTime());
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
PDate result = instance.findOrCreatePDateByDateValue(dateValue);
assertNotNull(result);
assertNotNull(result.getTermId());
String expResult = "\"" + dateValue.toString() + "\"";
assertEquals(expResult, result.toString());
PDate result2 = instance.findOrCreatePDateByDateValue(dateValue);
assertNotNull(result2);
assertNotNull(result2.getTermId());
assertEquals(result, result2);
assertEquals(result.getTermId(), result2.getTermId());
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findOrCreatePDateByDateValue OK");
}
/**
* Test of findOrCreateTimePointByTimePointValue method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindOrCreateTimePointByTimePointValue() {
System.out.println("findOrCreateTimePointByTimePointValue");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
Timestamp timePointValue = new Timestamp((new java.util.Date()).getTime());
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
TimePoint result = instance.findOrCreateTimePointByTimePointValue(timePointValue);
assertNotNull(result);
assertNotNull(result.getTermId());
String expResult = "\"" + timePointValue.toString() + "\"";
if (! expResult.equals(result.toString())) {
System.out.println("expResult: " + expResult.toString());
System.out.println("result: " + result.toString());
}
assertEquals(expResult.substring(0, 19), result.toString().substring(0, 19));
TimePoint result2 = instance.findOrCreateTimePointByTimePointValue(timePointValue);
assertNotNull(result2);
assertNotNull(result2.getTermId());
assertEquals(result, result2);
assertEquals(result.getTermId(), result2.getTermId());
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findOrCreateTimePointByTimePointValue OK");
}
/**
* Test of findOrCreatePClobByClobValue method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindOrCreatePClobByClobValue() {
System.out.println("findOrCreatePClobByClobValue");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
char[] chars = new char[1000];
for (int i = 0; i < chars.length; i++) {
chars[i] = 'b';
}
SerialClob clobValue = null;
try {
clobValue = new SerialClob(chars);
} catch (SerialException ex) {
ex.printStackTrace();
fail();
} catch (SQLException ex) {
ex.printStackTrace();
fail();
}
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
PClob result = instance.findOrCreatePClobByClobValue(clobValue);
assertNotNull(result);
assertNotNull(result.getTermId());
assertEquals("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
result.toString());
PClob result2 = instance.findOrCreatePClobByClobValue(clobValue);
assertNotNull(result2);
assertNotNull(result2.getTermId());
assertEquals(result, result2);
assertEquals(result.getTermId(), result2.getTermId());
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findOrCreatePClobByClobValue OK");
}
/**
* Test of findOrCreatePBlobByBlobValue method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindOrCreatePBlobByBlobValue() {
System.out.println("findOrCreatePBlobByBlobValue");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
byte[] bytes = new byte[1000];
for (int i = 0; i < bytes.length; i++) {
bytes[i] = 2;
}
SerialBlob blobValue = null;
try {
blobValue = new SerialBlob(bytes);
} catch (SerialException ex) {
ex.printStackTrace();
fail();
} catch (SQLException ex) {
ex.printStackTrace();
fail();
}
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
PBlob result = instance.findOrCreatePBlobByBlobValue(blobValue);
assertNotNull(result);
assertNotNull(result.getTermId());
assertTrue(result.toString().startsWith("javax.sql.rowset.serial.SerialBlob@"));
PBlob result2 = instance.findOrCreatePBlobByBlobValue(blobValue);
assertNotNull(result2);
assertNotNull(result2.getTermId());
assertEquals(result, result2);
assertEquals(result.getTermId(), result2.getTermId());
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findOrCreatePBlobByBlobValue OK");
}
/**
* Test of findOrCreateAtomicTermByTermName method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindOrCreateAtomicTermByTermName() {
System.out.println("findOrCreateAtomicTermByTermName");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
String termName = "MyTestTerm";
String prettyName = "my test term";
String uuid = UUID.randomUUID().toString();
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
AtomicTerm creator = instance.findAtomicTermByTermName(Constants.TERM_NAME_SOME_CYCLIST);
AtomicTerm creationPurpose = instance.findAtomicTermByTermName(Constants.TERM_NAME_OPEN_CYC_PROJECT);
AtomicTerm result = instance.findOrCreateAtomicTermByTermName(termName, prettyName, uuid, creator, creationPurpose);
assertNotNull(result);
assertNotNull(result.getTermId());
assertEquals("MyTestTerm", result.toString());
AtomicTerm result2 = instance.findOrCreateAtomicTermByTermName(termName, prettyName, uuid, creator, creationPurpose);
assertNotNull(result2);
assertNotNull(result2.getTermId());
assertEquals(result, result2);
assertEquals(result.getTermId(), result2.getTermId());
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findOrCreateAtomicTermByTermName OK");
}
/**
* Test of findOrCreateNonAtomicTermByTermName method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindOrCreateNonAtomicTermByTermName() {
System.out.println("findOrCreateNonAtomicTermByTermName");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
String termName = "ListFn_1__2_";
String uuid = UUID.randomUUID().toString();
List<AbstractTerm> termList = new ArrayList<AbstractTerm>();
AtomicTerm creator = instance.findAtomicTermByTermName(Constants.TERM_NAME_SOME_CYCLIST);
AtomicTerm creationPurpose = instance.findAtomicTermByTermName(Constants.TERM_NAME_OPEN_CYC_PROJECT);
termList.add(instance.findOrCreateAtomicTermByTermName("ListFn", "list of", null, creator, creationPurpose));
termList.add(instance.findOrCreatePLongByLongValue(1L));
termList.add(instance.findOrCreatePLongByLongValue(2L));
Formula formula = new Formula(termList, creator, creationPurpose, instance.getTimePointNow());
NonAtomicTerm result = instance.findOrCreateNonAtomicTermByTermName(termName, null, uuid, formula, creator, creationPurpose);
assertNotNull(result);
assertNotNull(result.getTermId());
assertEquals("ListFn(1, 2)", result.toString());
NonAtomicTerm result2 = instance.findOrCreateNonAtomicTermByTermName(termName, null, uuid, formula, creator, creationPurpose);
assertNotNull(result2);
assertNotNull(result2.getTermId());
assertEquals(result, result2);
assertEquals(result.getTermId(), result2.getTermId());
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findOrCreateNonAtomicTermByTermName OK");
}
/**
* Test of findOrCreateFormulaByFormulaString method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindOrCreateFormulaByFormulaString() {
System.out.println("findOrCreateFormulaByFormulaString");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
String formulaString = "!(P || Q)";
List<AbstractTerm> termList1 = new ArrayList<AbstractTerm>();
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
AtomicTerm creator = instance.findAtomicTermByTermName(Constants.TERM_NAME_SOME_CYCLIST);
AtomicTerm creationPurpose = instance.findAtomicTermByTermName(Constants.TERM_NAME_OPEN_CYC_PROJECT);
termList1.add(new AtomicTerm("or", "or", creator, creationPurpose, instance.getTimePointNow()));
termList1.add(new AtomicTerm("P", "P", creator, creationPurpose, instance.getTimePointNow()));
termList1.add(new AtomicTerm("Q", "Q", creator, creationPurpose, instance.getTimePointNow()));
List<AbstractTerm> termList2 = new ArrayList<AbstractTerm>();
termList2.add(new AtomicTerm("not", "not", creator, creationPurpose, instance.getTimePointNow()));
termList2.add(new Formula(termList1, creator, creationPurpose, instance.getTimePointNow()));
Formula result = instance.findOrCreateFormulaByFormulaString(formulaString, termList2, creator, creationPurpose);
assertNotNull(result);
assertNotNull(result.getTermId());
assertEquals("!(P || Q)", result.toString());
Formula result2 = instance.findOrCreateFormulaByFormulaString(formulaString, termList2, creator, creationPurpose);
assertNotNull(result2);
assertNotNull(result2.getTermId());
assertEquals(result, result2);
assertEquals(result.getTermId(), result2.getTermId());
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findOrCreateFormulaByFormulaString OK");
}
/**
* Test of findOrCreateRuleByFormula method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindOrCreateRuleByFormula() {
System.out.println("findOrCreateRuleByFormula");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
// (implies
// (and
// (genls ? ?Y)
// (genls ?Y ?W))
// (genls ?X ?W))
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
PVariable x = instance.findOrCreatePVariableByNameValue("?X");
PVariable y = instance.findOrCreatePVariableByNameValue("?Y");
PVariable w = instance.findOrCreatePVariableByNameValue("?W");
AtomicTerm creator = instance.findAtomicTermByTermName(Constants.TERM_NAME_SOME_CYCLIST);
AtomicTerm creationPurpose = instance.findAtomicTermByTermName(Constants.TERM_NAME_OPEN_CYC_PROJECT);
AtomicTerm implies = instance.findOrCreateAtomicTermByTermName("implies", "implies", null, creator, creationPurpose);
AtomicTerm and = instance.findOrCreateAtomicTermByTermName("and", "and", null, creator, creationPurpose);
AtomicTerm genls = instance.findOrCreateAtomicTermByTermName("genls", "generalization of", null, creator, creationPurpose);
List<AbstractTerm> termList1 = new ArrayList<AbstractTerm>(0);
termList1.add(genls);
termList1.add(x);
termList1.add(y);
List<AbstractTerm> termList2 = new ArrayList<AbstractTerm>(0);
termList2.add(genls);
termList2.add(y);
termList2.add(w);
List<AbstractTerm> termList3 = new ArrayList<AbstractTerm>(0);
termList3.add(genls);
termList3.add(x);
termList3.add(w);
List<AbstractTerm> termList4 = new ArrayList<AbstractTerm>(0);
termList4.add(and);
termList4.add(new Formula(termList1, creator, creationPurpose, instance.getTimePointNow()));
termList4.add(new Formula(termList2, creator, creationPurpose, instance.getTimePointNow()));
List<AbstractTerm> termList5 = new ArrayList<AbstractTerm>(0);
termList5.add(implies);
termList5.add(new Formula(termList4, creator, creationPurpose, instance.getTimePointNow()));
termList5.add(new Formula(termList3, creator, creationPurpose, instance.getTimePointNow()));
Formula formula = new Formula(termList5, creator, creationPurpose, instance.getTimePointNow());
Double strength = Constants.STRENGTH_MONOTONIC;
AtomicTerm context = instance.findAtomicTermByTermName("BaseKB");
Rule result = instance.findOrCreateRuleByFormula(formula, context, strength, creator, creationPurpose);
assertNotNull(result);
assertNotNull(result.getTermId());
assertEquals("(genls(?X, ?Y) && genls(?Y, ?W)) -> genls(?X, ?W)", result.toString());
Rule result2 = instance.findOrCreateRuleByFormula(formula, context, strength, creator, creationPurpose);
assertNotNull(result2);
assertNotNull(result2.getTermId());
assertEquals(result, result2);
assertEquals(result.getTermId(), result2.getTermId());
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findOrCreateRuleByFormula OK");
}
/**
* Test of findOrCreateUnaryGAFByConstituents method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindOrCreateUnaryGAFByConstituents() {
System.out.println("findOrCreateUnaryGAFByConstituents");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
AtomicTerm creator = instance.findAtomicTermByTermName(Constants.TERM_NAME_SOME_CYCLIST);
AtomicTerm creationPurpose = instance.findAtomicTermByTermName(Constants.TERM_NAME_OPEN_CYC_PROJECT);
String predicateName = "MyUnaryPredicate1-" + UUID.randomUUID().toString();
AtomicTerm predicate = new AtomicTerm(predicateName, "my unary predicate 1", creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(predicate);
List<AbstractTerm> args = new ArrayList<AbstractTerm>();
final AbstractTerm arg1 = new PString("hij");
entityManager.persist(arg1);
args.add(arg1);
Double strength = Constants.STRENGTH_MONOTONIC;
AtomicTerm context = instance.findAtomicTermByTermName("BaseKB");
UnaryGAF result = instance.findOrCreateUnaryGAFByConstituents(predicate, args, context, strength, null, creator, creationPurpose);
assertNotNull(result);
assertNotNull(result.getTermId());
assertEquals(predicateName + "(\"hij\")", result.toString());
UnaryGAF result2 = instance.findOrCreateUnaryGAFByConstituents(predicate, args, context, strength, null, creator, creationPurpose);
assertNotNull(result2);
assertNotNull(result2.getTermId());
assertEquals(result, result2);
assertEquals(result.getTermId(), result2.getTermId());
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findOrCreateUnaryGAFByConstituents OK");
}
/**
* Test of findOrCreateBinaryGAFByConstituents method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindOrCreateBinaryGAFByConstituents() {
System.out.println("findOrCreateBinaryGAFByConstituents");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
AtomicTerm creator = instance.findAtomicTermByTermName(Constants.TERM_NAME_SOME_CYCLIST);
AtomicTerm creationPurpose = instance.findAtomicTermByTermName(Constants.TERM_NAME_OPEN_CYC_PROJECT);
String predicateName = "MyBinaryPredicate2-" + UUID.randomUUID().toString();
AtomicTerm predicate = new AtomicTerm(predicateName, "my binary predicate 2", creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(predicate);
List<AbstractTerm> args = new ArrayList<AbstractTerm>();
final AbstractTerm arg1 = new PString("hij");
entityManager.persist(arg1);
args.add(arg1);
final AbstractTerm arg2 = new PLong(2L);
entityManager.persist(arg2);
args.add(arg2);
Double strength = Constants.STRENGTH_MONOTONIC;
AtomicTerm context = instance.findAtomicTermByTermName("BaseKB");
BinaryGAF result = instance.findOrCreateBinaryGAFByConstituents(predicate, args, context, strength, null, false, creator, creationPurpose);
assertNotNull(result);
assertNotNull(result.getTermId());
assertEquals(predicateName + "(\"hij\", 2)", result.toString());
BinaryGAF result2 = instance.findOrCreateBinaryGAFByConstituents(predicate, args, context, strength, null, false, creator, creationPurpose);
assertNotNull(result2);
assertNotNull(result2.getTermId());
assertEquals(result, result2);
assertEquals(result.getTermId(), result2.getTermId());
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findOrCreateBinaryGAFByConstituents OK");
}
/**
* Test of findOrCreateTernaryGAFByConstituents method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindOrCreateTernaryGAFByConstituents() {
System.out.println("findOrCreateTernaryGAFByConstituents");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
AtomicTerm creator = instance.findAtomicTermByTermName(Constants.TERM_NAME_SOME_CYCLIST);
AtomicTerm creationPurpose = instance.findAtomicTermByTermName(Constants.TERM_NAME_OPEN_CYC_PROJECT);
String predicateName = "MyTernaryPredicate3-" + UUID.randomUUID().toString();
AtomicTerm predicate = new AtomicTerm(predicateName, "my ternary predicate 3", creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(predicate);
List<AbstractTerm> args = new ArrayList<AbstractTerm>();
final AbstractTerm arg1 = new PString("hij");
entityManager.persist(arg1);
args.add(arg1);
final AbstractTerm arg2 = new PLong(2L);
entityManager.persist(arg2);
args.add(arg2);
final AbstractTerm arg3 = new PLong(3L);
entityManager.persist(arg3);
args.add(arg3);
Double strength = Constants.STRENGTH_MONOTONIC;
AtomicTerm context = instance.findAtomicTermByTermName("BaseKB");
TernaryGAF expResult = null;
TernaryGAF result = instance.findOrCreateTernaryGAFByConstituents(predicate, args, context, strength, null, creator, creationPurpose);
assertNotNull(result);
assertNotNull(result.getTermId());
assertEquals(predicateName + "(\"hij\", 2, 3)", result.toString());
assertEquals(result, instance.findOrCreateTernaryGAFByConstituents(predicate, args, context, strength, null, creator, creationPurpose));
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findOrCreateTernaryGAFByConstituents OK");
}
/**
* Test of findOrCreateQuaternaryGAFByConstituents method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindOrCreateQuaternaryGAFByConstituents() {
System.out.println("findOrCreateQuaternaryGAFByConstituents");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
AtomicTerm creator = instance.findAtomicTermByTermName(Constants.TERM_NAME_SOME_CYCLIST);
AtomicTerm creationPurpose = instance.findAtomicTermByTermName(Constants.TERM_NAME_OPEN_CYC_PROJECT);
String predicateName = "MyQuaternaryPredicate4-" + UUID.randomUUID().toString();
AtomicTerm predicate = new AtomicTerm(predicateName, "my quaternary predicate 4", creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(predicate);
List<AbstractTerm> args = new ArrayList<AbstractTerm>();
final AbstractTerm arg1 = new PString("hij");
entityManager.persist(arg1);
args.add(arg1);
final AbstractTerm arg2 = new PLong(2L);
entityManager.persist(arg2);
args.add(arg2);
final AbstractTerm arg3 = new PLong(3L);
entityManager.persist(arg3);
args.add(arg3);
final AbstractTerm arg4 = new PLong(4L);
entityManager.persist(arg4);
args.add(arg4);
Double strength = Constants.STRENGTH_MONOTONIC;
AtomicTerm context = instance.findAtomicTermByTermName("BaseKB");
QuaternaryGAF expResult = null;
QuaternaryGAF result = instance.findOrCreateQuaternaryGAFByConstituents(predicate, args, context, strength, null, creator, creationPurpose);
assertNotNull(result);
assertNotNull(result.getTermId());
assertEquals(predicateName + "(\"hij\", 2, 3, 4)", result.toString());
assertEquals(result, instance.findOrCreateQuaternaryGAFByConstituents(predicate, args, context, strength, null, creator, creationPurpose));
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" testFindOrCreateQuaternaryGAFByConstituents OK");
}
/**
* Test of findOrCreateQuintaryGAFByConstituents method, of class org.texai.kb.ejb.session.TermFinderFacadeBean.
*/
public void testFindOrCreateQuintaryGAFByConstituents() {
System.out.println("findOrCreateQuintaryGAFByConstituents");
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
assertTrue(entityTransaction.isActive());
TermFinderFacadeBean instance = new TermFinderFacadeBean();
instance.setEntityManager(entityManager);
AtomicTerm creator = instance.findAtomicTermByTermName(Constants.TERM_NAME_SOME_CYCLIST);
AtomicTerm creationPurpose = instance.findAtomicTermByTermName(Constants.TERM_NAME_OPEN_CYC_PROJECT);
String predicateName = "MyQuintaryPredicate-" + UUID.randomUUID().toString();
AtomicTerm predicate = new AtomicTerm(predicateName, "my quintary predicate", creator, creationPurpose, instance.getTimePointNow());
entityManager.persist(predicate);
List<AbstractTerm> args = new ArrayList<AbstractTerm>();
final AbstractTerm arg1 = new PString("hij");
entityManager.persist(arg1);
args.add(arg1);
final AbstractTerm arg2 = new PLong(2L);
entityManager.persist(arg2);
args.add(arg2);
final AbstractTerm arg3 = new PLong(3L);
entityManager.persist(arg3);
args.add(arg3);
final AbstractTerm arg4 = new PLong(4L);
entityManager.persist(arg4);
args.add(arg4);
final AbstractTerm arg5 = new PLong(5L);
entityManager.persist(arg5);
args.add(arg5);
Double strength = Constants.STRENGTH_MONOTONIC;
AtomicTerm context = instance.findAtomicTermByTermName("BaseKB");
QuintaryGAF result = instance.findOrCreateQuintaryGAFByConstituents(predicate, args, context, strength, null, creator, creationPurpose);
assertNotNull(result);
assertNotNull(result.getTermId());
assertEquals(predicateName + "(\"hij\", 2, 3, 4, 5)", result.toString());
assertEquals(result, instance.findOrCreateQuintaryGAFByConstituents(predicate, args, context, strength, null, creator, creationPurpose));
entityTransaction.commit();
assertTrue(!entityTransaction.isActive());
System.out.println(" findOrCreateQuintaryGAFByConstituents OK");
}
/** Performs one time tear down of test harness. This must be the last test method. */
public void testOneTimeTearDown() {
System.out.println("oneTimeTearDown");
entityManager.close();
entityManagerFactory.close();
}
}
See more files for this project here