adapter4testcases_2_0.java

Mandarax是一个规则引擎的纯Java实现。它支持多类型的事实和基于反映的规则

package org.mandarax.zkb.framework;

/**
 *  Copyright (C) 1999-2004  Jens Dietrich (mailto:[e-mail])
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2 of the License, or (at your option) any later version.
 *
 *  This library 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
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

import java.util.*;
import org.mandarax.kernel.validation.*;
import org.jdom.Element;
import org.mandarax.kernel.*;
import org.mandarax.zkb.ObjectPersistencyService;
import org.mandarax.zkb.ZKBException;
/**
 * An adapter class for test cases.
 * @author <A href="http://www-ist.massey.ac.nz/JBDietrich" target="_top">Jens Dietrich</A>
 * @version 3.4 <7 March 05>
 * @since 3.4
 */

public class Adapter4TestCases_2_0 extends AbstractAdapter {

/**
 * Export an object, i.e., convert it to an element in the DOM.
 * @param obj an object
 * @param driver the generic driver
 * @param ops the object persistency service
 * @exception a ZKBException is thrown if export fails
 */
public Element exportObject(Object obj,GenericDriver driver,ObjectPersistencyService ops) throws  ZKBException {
      check(obj,TestCase.class);

      TestCase tc = (TestCase)obj;
      Element e = new Element(TESTCASE);
      
      // query
      Element eQ = this.exportObject(tc.getQuery(),QUERY,driver,ops);
      e.addContent(eQ);
      

	  // assumptions
	  Element eAss = new Element(ASSUMPTIONS);
	  eAss.setAttribute(POLICY_TO_ADD_ASSUMPTIONS_TO_KB,String.valueOf(tc.getPolicyToAddAssumptionsToKB()));
	  e.addContent(eAss);
	  ClauseSet[] assumptions = tc.getAssumptions();
	  for (int i=0;i<assumptions.length;i++) {
	      ClauseSet cs = assumptions[i];
	      String kindOfObject = getClauseSetType(cs);
	      if (kindOfObject==null) throw new ZKBException("Unknown clause set type inj test case assumptions " + cs);
	      else {
		      Element el = exportObject(cs,kindOfObject,driver,ops);
		      eAss.addContent(el);
	      }
	  }
	  
	  // expected number of results
	  Element eNR = new Element(EXPECTED_NUMBER_OF_RESULTS);
	  eNR.addContent(String.valueOf(tc.getExpectedNumberOfResults()));
	  e.addContent(eNR);
	  
	  // expected outcome for ground queries
	  Element eGQ = new Element(EXPECTED_RESULT);
	  eGQ.addContent(String.valueOf(tc.isMustBeTrue()));
	  e.addContent(eGQ);
	  
	  // expected variable substitutions for non ground queries 
	  java.util.Map[] expectedReplacements = tc.getExpectedReplacements();
	  Element eRes = new Element(EXPECTED_REPLACEMENTS);
	  if (expectedReplacements!=null) {
	  	for (int i=0;i<expectedReplacements.length;i++) {
	  		java.util.Map expectedReplacement = expectedReplacements[i];
	  		Element eR = new Element(EXPECTED_RESULT2);
	  		eRes.addContent(eR);
	  		for (Iterator iter = expectedReplacement.keySet().iterator();iter.hasNext();) {
	  			Element eRe = new Element(EXPECTED_REPLACEMENT);
	  			VariableTerm var = (VariableTerm)iter.next();
	  			Object expected = expectedReplacement.get(var);
	  			Element eVar = this.exportObject(var,VARIABLE_TERM,driver,ops);
	  			Element eObj = new Element(EXPECTED_OBJECT);
	  			this.assignURI(eObj,ops,expected);
	  			eRe.addContent(eVar);
	  			eRe.addContent(eObj);
	  			eR.addContent(eRe);
	  		}
	  	}
	  }
	  e.addContent(eRes);
	   
	  //  additional properties
	  exportProperties(e,tc);
	  
      return e;
}
/**
 * Build an object from an XML element.
 * @param e an element
 * @param driver the generic driver
 * @param ops the object persistency service
 * @param lfactory the logic factory used to create objects
 * @exception a ZKBException is thrown if import fails
 */
public Object importObject(Element e,GenericDriver driver,ObjectPersistencyService ops,LogicFactory lfactory) throws ZKBException {
	
	  // query 
	  Query query = (Query)this.importChild(e,QUERY,driver,ops,lfactory);
	  
      // get  assumptions
      Element eAss = e.getChild(ASSUMPTIONS);
      int policy2addAssumptions = TestCase.AT_BOTTOM;
      try {
      	policy2addAssumptions = Integer.parseInt(eAss.getAttributeValue(POLICY_TO_ADD_ASSUMPTIONS_TO_KB));
      }
      catch (Exception x) {
      	throw new ZKBException("Cannot read policy to add assumptions to kb",x);
      }
      List children = eAss.getChildren();
      ClauseSet[] assumptions = new ClauseSet[children.size()];
      for (int i=0;i<children.size();i++) {
              Element ea = (Element)children.get(i);
              Adapter adapter = driver.getAdapter(ea.getName());
              Object obj = adapter.importObject(ea,driver,ops,lfactory);
              if (obj==null) throw new ZKBException("null assumption found in test case");
              if (!(obj instanceof ClauseSet)) throw new ZKBException("assumptions in test cases must be instances of ClauseSet, but object found is " + obj);
              assumptions[i] = (ClauseSet)obj;
      }

      // expected number of results
      int expectedNumberOfResults = -1;
      String value = e.getChild(EXPECTED_NUMBER_OF_RESULTS).getTextTrim();
      try {
      		expectedNumberOfResults = Integer.parseInt(value);
      }
      catch (Exception x) {
      		throw new ZKBException("Cannot read expected number of results",x);
      }
      
	  // expected outcome for ground queries
      boolean expectedResult4GroundQueries = true;
      value = e.getChild(EXPECTED_RESULT).getTextTrim();
      try {
      	expectedResult4GroundQueries = new Boolean(value).booleanValue();
      }
      catch (Exception x) {
      		throw new ZKBException("Cannot read expected result for ground queries",x);
      }

	  // expected variable substitutions for non ground queries 
	  Map[] expectedReplacements = null;
	  Element eRes = e.getChild(EXPECTED_REPLACEMENTS);
	  if (eRes!=null) {
	  	List eResultList = eRes.getChildren(EXPECTED_RESULT2);
	  	expectedReplacements = new Map[eResultList.size()];
	  	for (int i=0;i<eResultList.size();i++) {
	  		expectedReplacements[i] = new Hashtable(); // TODO map class is hard coded here , should we store it (as attribute)?
	  		Element eResult = (Element)eResultList.get(i);
	  		List eReplacements = eResult.getChildren(EXPECTED_REPLACEMENT);
	  		for (int j=0;j<eReplacements.size();j++) {
	  			Element eRe = (Element)eReplacements.get(j);
	  			Element eObj = eRe.getChild(EXPECTED_OBJECT);
	  			VariableTerm var = (VariableTerm)this.importChild(eRe,VARIABLE_TERM,driver,ops,lfactory);
	  			Object expectedObject = getObjectByURI(eObj,ops);	
	  			expectedReplacements[i].put(var,expectedObject);
	  		}
	  	}
	  }
	  
      // build test case
	  TestCase tc = lfactory.createTestCase(query,assumptions,policy2addAssumptions,expectedNumberOfResults,expectedResult4GroundQueries,expectedReplacements); 
	  importProperties(e,tc);
	  return tc;
}
/**
 * Get the name of the associated tag (element).
 * @return a string
 */
public String getTagName() {
      return TESTCASE;
}
/**
 * Print the DTD associated with this adapter on a string buffer.
 * @param out the buffer to print on. 
 */
public void printDTD(StringBuffer out) {
	
	// warning : properties are declared in the rule adapter, not here
	out.append("<!ELEMENT testcase (query,assumptions,expected_number_of_results,expected_result,expected_replacements?,properties?)>\n");
	out.append("<!ELEMENT assumptions (atom|rule|sql_clause_set|custom_clause_set)* >\n");
	out.append("<!ELEMENT expected_number_of_results (#PCDATA) >\n"); // int
	out.append("<!ELEMENT expected_result (#PCDATA) >\n"); // boolean
	out.append("<!ELEMENT expected_replacements (result)* >\n");
	out.append("<!ELEMENT result (var,expected_object) >\n");
	out.append("<!ELEMENT expected_object (#PCDATA)>\n");
	out.append("<!ATTLIST assumptions add2kb_policy (0 | 1) \"0\">\n"); // hard coded - there are only two possible values defined in TestCase

}

}