initial version

22 files changed, 1685 insertions, 0 deletions

diff --git a/test/uk/ac/ox/cs/pagoda/approx/ApproxTester.java b/test/uk/ac/ox/cs/pagoda/approx/ApproxTester.java
new file mode 100644
index 0000000..63fe7b7
--- /dev/null
+++ b/test/uk/ac/ox/cs/pagoda/approx/ApproxTester.java
@@ -0,0 +1,158 @@
+package uk.ac.ox.cs.pagoda.approx;
+
+import java.io.IOException;
+
+import org.semanticweb.owlapi.model.OWLOntology;
+
+import uk.ac.ox.cs.pagoda.approx.KnowledgeBase;
+import uk.ac.ox.cs.pagoda.approx.RLOntology;
+import uk.ac.ox.cs.pagoda.approx.RLPlusOntology;
+import uk.ac.ox.cs.pagoda.constraints.NullaryBottom;
+import uk.ac.ox.cs.pagoda.owl.OWLHelper;
+import uk.ac.ox.cs.pagoda.rules.DisjunctiveProgram;
+import uk.ac.ox.cs.pagoda.rules.ExistentialProgram;
+import uk.ac.ox.cs.pagoda.rules.ExistentialToDisjunctive;
+import uk.ac.ox.cs.pagoda.rules.GeneralProgram;
+import uk.ac.ox.cs.pagoda.rules.LowerDatalogProgram;
+import uk.ac.ox.cs.pagoda.rules.UpperDatalogProgram;
+import uk.ac.ox.cs.pagoda.util.Utility;
+
+public class ApproxTester {
+        
+        private static ApproxType description = ApproxType.DATALOGPMOR; 
+        
+        private static String ontoFile = null;
+        
+        public static void main(String[] args) throws IOException
+        {
+                args = new String[] {
+                                "-tbox", 
+//                              "/home/yzhou/krr-nas-share/Yujiao/ontologies/bio2rdf/chembl/cco-noDPR.ttl", 
+//                              "/home/yzhou/krr-nas-share/Yujiao/ontologies/bio2rdf/reactome/biopax-level3-processed.owl", 
+//                              "/media/krr-nas-share/Yujiao/ontologies/bio2rdf/atlas/gxaterms.owl", 
+//                              "/media/krr-nas-share/Yujiao/ontologies/bio2rdf/uniprot/core-sat-processed.owl",
+//                              PagodaTester.npd_tbox,
+//                              "/users/yzhou/temp/ontologies/core.RLor.rdf",
+                                "datatype.owl", 
+                                "-dest", ApproxType.DATALOGPMOR.toString() 
+                }; 
+
+                long startTime = System.currentTimeMillis();
+                
+                if (args.length > 0) {
+                        if (args.length % 2 != 0) {
+                                System.out.println("arguments error..."); 
+                                return ;
+                        }
+                        for (int i = 0; i < args.length ; i = i + 2) 
+                                if (!setArgument(args[i], args[i + 1])) {
+                                        System.out.println("arguments error..."); 
+                                        return ;
+                                }
+                }
+                
+//              Utility.redirectSystemOut();
+                
+                System.setProperty("entityExpansionLimit", String.valueOf(Integer.MAX_VALUE));
+                
+                String directory = ontoFile.substring(0, ontoFile.lastIndexOf(Utility.FILE_SEPARATOR) + 1); 
+                
+                KnowledgeBase program = null;
+                switch (description) {
+                case OWL2RLPLUS: program = new RLPlusOntology(); break; 
+                case OWL2RL: program = new RLOntology(); break;
+                case DATALOG_UPPER: program = new UpperDatalogProgram(); break; 
+                case DATALOG_LOWER: program = new LowerDatalogProgram(); break; 
+                case EXISTENTIAL: program = new ExistentialProgram(); break;
+                case DISJUNCTIVE: program = new DisjunctiveProgram(); break;  
+                case DATALOGPMOR: program = new GeneralProgram(); break;
+                case EXIST2DISJ: program = new ExistentialToDisjunctive(); break;
+                default: 
+                        System.exit(0);
+                }
+
+                if (program instanceof RLPlusOntology)
+                        ((RLPlusOntology) program).setCorrespondenceFileLoc(directory + "correspondence");
+                OWLOntology ontology = OWLHelper.loadOntology(ontoFile);  
+                program.load(ontology, new NullaryBottom());
+
+                program.transform();
+
+                program.save();
+                
+                System.out.println("Time to transform the rules: " + (System.currentTimeMillis() - startTime) / 1000.);
+                
+                Utility.closeCurrentOut();
+        }
+
+        private static boolean setArgument(String key, String value) {
+                if (key.equalsIgnoreCase("-dest")) 
+                        if (value.equalsIgnoreCase("OWL2RL+")) description = ApproxType.OWL2RLPLUS;
+                        else if (value.equalsIgnoreCase("OWL2RL")) description = ApproxType.OWL2RL; 
+                        else if (value.equalsIgnoreCase("UPPERDATALOG")) description = ApproxType.DATALOG_UPPER;
+                        else if (value.equalsIgnoreCase("LOWERDATALOG")) description = ApproxType.DATALOG_LOWER;
+                        else if (value.equalsIgnoreCase("DATALOGPMOR")) description = ApproxType.DATALOGPMOR;
+                        else if (value.equalsIgnoreCase("EXISTENTIALRULES")) description = ApproxType.EXISTENTIAL;
+                        else if (value.equalsIgnoreCase("DISJUNCTIVE")) description = ApproxType.DISJUNCTIVE;
+                        else if (value.equalsIgnoreCase("EXIST2DISJ")) description = ApproxType.EXIST2DISJ; 
+                        else {
+                                System.out.println("illegal destination argument..."); 
+                                return false;
+                        }
+                else if (key.equalsIgnoreCase("-tbox")) 
+                        ontoFile = value;
+                else {
+                        System.out.println("unrecognisable type of argument..."); 
+                        return false;
+                }
+                
+                return true;
+        }
+        
+        public enum ApproxType {
+                /**
+                 * approx to (RL + self + top being the subClassExp)
+                 */
+                OWL2RLPLUS,     
+                
+                /**
+                 * approx to RL
+                 */
+                OWL2RL,                 
+                
+                /**
+                 * approx to datalog by replacing existential quantified variables 
+                 * by fresh constants and replacing disjunctions by conjunctions
+                 */
+                DATALOG_UPPER,          
+                
+                /**
+                 * approx to datalog by ignoring existential and disjunctive axiom
+                 */
+                DATALOG_LOWER,          
+                
+                /**
+                 * approx to existential rules by replacing disjunctions by 
+                 * conjunctions
+                 */
+                EXISTENTIAL,
+                
+                /**
+                 * approx to disjunctive datalog program by replacing existential 
+                 * quantified variables by fresh constants (DNF)
+                 */
+                DISJUNCTIVE, 
+                
+                /**
+                 * transform into rules, no approximation at all
+                 */
+                DATALOGPMOR,    
+                
+                /**
+                 * approx existential quantifiers by disjunctions
+                 */
+                EXIST2DISJ              
+
+        }; 
+        
+}
diff --git a/test/uk/ac/ox/cs/pagoda/approx/ClauseTester.java b/test/uk/ac/ox/cs/pagoda/approx/ClauseTester.java
new file mode 100644
index 0000000..cff1d1c
--- /dev/null
+++ b/test/uk/ac/ox/cs/pagoda/approx/ClauseTester.java
@@ -0,0 +1,38 @@
+package uk.ac.ox.cs.pagoda.approx;
+
+import org.semanticweb.HermiT.model.DLClause;
+import org.semanticweb.owlapi.model.OWLOntology;
+
+import uk.ac.ox.cs.pagoda.constraints.NullaryBottom;
+import uk.ac.ox.cs.pagoda.owl.OWLHelper;
+import uk.ac.ox.cs.pagoda.rules.GeneralProgram;
+
+public class ClauseTester {
+
+        public static void main(String... args) {
+                args = new String[] {
+//                              "/home/yzhou/krr-nas-share/Yujiao/ontologies/bio2rdf/chembl/cco-noDPR.ttl", 
+                                "/home/yzhou/krr-nas-share/Yujiao/ontologies/bio2rdf/reactome/biopax-level3-processed.owl", 
+//                              "/media/krr-nas-share/Yujiao/ontologies/bio2rdf/atlas/gxaterms.owl", 
+//                              "/media/krr-nas-share/Yujiao/ontologies/bio2rdf/uniprot/core-sat-processed.owl",
+//                              PagodaTester.npd_tbox,
+//                              "/users/yzhou/temp/ontologies/core.RLor.rdf",
+//                              "datatype.owl" 
+                }; 
+                
+                String ontoFile = args[0];   
+                OWLOntology ontology = OWLHelper.loadOntology(ontoFile);  
+                GeneralProgram program = new GeneralProgram();; 
+                program.load(ontology, new NullaryBottom());
+                program.transform();
+                program.save();
+                if (program instanceof GeneralProgram) {
+                        GeneralProgram gp = ((GeneralProgram) program); 
+                        for (DLClause clause: gp.getClauses()) {
+                                System.out.println(clause);
+                                System.out.println(OWLHelper.getOWLAxiom(ontology, clause)); 
+                        }
+                }
+        }
+        
+}
diff --git a/test/uk/ac/ox/cs/pagoda/junit/AllTests.java b/test/uk/ac/ox/cs/pagoda/junit/AllTests.java
new file mode 100644
index 0000000..6884081
--- /dev/null
+++ b/test/uk/ac/ox/cs/pagoda/junit/AllTests.java
@@ -0,0 +1,50 @@
+package uk.ac.ox.cs.pagoda.junit;
+
+import java.io.BufferedWriter;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+import uk.ac.ox.cs.data.WriteIntoTurtle;
+
+@RunWith(Suite.class)
+@SuiteClasses({ WriteIntoTurtle.class, PagodaUOBM.class
+        })
+public class AllTests {
+
+        public static void copy(String source, String dest) {
+            InputStream is = null;
+            OutputStream os = null;
+            try {
+                is = new FileInputStream(source);
+                os = new FileOutputStream(dest);
+                byte[] buffer = new byte[1024];
+                int length;
+                while ((length = is.read(buffer)) > 0) {
+                    os.write(buffer, 0, length);
+                }
+                is.close();
+                os.close();
+                
+                    BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(source))); 
+                    writer.write("");
+                    writer.close();
+            } catch (FileNotFoundException e) {
+                        e.printStackTrace();
+                } catch (IOException e) {
+                        e.printStackTrace();
+                }       
+            
+//          File src = new File(source);
+//          src.delete(); 
+        }
+        
+}
diff --git a/test/uk/ac/ox/cs/pagoda/junit/ClauseTester.java b/test/uk/ac/ox/cs/pagoda/junit/ClauseTester.java
new file mode 100644
index 0000000..d23f186
--- /dev/null
+++ b/test/uk/ac/ox/cs/pagoda/junit/ClauseTester.java
@@ -0,0 +1,165 @@
+package uk.ac.ox.cs.pagoda.junit;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+import org.semanticweb.HermiT.model.Atom;
+import org.semanticweb.HermiT.model.AtomicConcept;
+import org.semanticweb.HermiT.model.AtomicRole;
+import org.semanticweb.HermiT.model.DLClause;
+import org.semanticweb.HermiT.model.Equality;
+import org.semanticweb.HermiT.model.Variable;
+import org.semanticweb.owlapi.apibinding.OWLManager;
+import org.semanticweb.owlapi.model.OWLOntology;
+import org.semanticweb.owlapi.model.OWLOntologyManager;
+
+import uk.ac.ox.cs.pagoda.approx.Clause;
+import uk.ac.ox.cs.pagoda.approx.Clausifier;
+
+public class ClauseTester {
+
+        @Test
+        public void test_simple() {
+                Variable x = Variable.create("X"), y1 = Variable.create("y1"), y2 = Variable.create("y2");
+                AtomicConcept A = AtomicConcept.create("A"); 
+                AtomicRole r = AtomicRole.create("r"); 
+                Atom[] bodyAtoms = new Atom[] {
+                                Atom.create(A, x),
+                                Atom.create(r, x, y1),
+                                Atom.create(r, x, y2)
+                }; 
+                
+                Atom[] headAtoms = new Atom[] {
+                                Atom.create(Equality.INSTANCE, y1, y2) 
+                }; 
+                
+                OWLOntologyManager m = OWLManager.createOWLOntologyManager(); 
+                OWLOntology emptyOntology = null; 
+                try {
+                        emptyOntology = m.createOntology(); 
+                } catch (Exception e) {
+                        e.printStackTrace();
+                        fail("failed to create a new ontology"); 
+                }
+                Clause c = new Clause(Clausifier.getInstance(emptyOntology), DLClause.create(headAtoms, bodyAtoms));
+                System.out.println(c.toString()); 
+        }
+        
+        @Test
+        public void test_more() {
+                Variable x = Variable.create("X"), y1 = Variable.create("y1"), y2 = Variable.create("y2"), y3 = Variable.create("y3");
+                AtomicConcept A = AtomicConcept.create("A"); 
+                AtomicRole r = AtomicRole.create("r"); 
+                Atom[] bodyAtoms = new Atom[] {
+                                Atom.create(A, x),
+                                Atom.create(r, x, y1),
+                                Atom.create(r, x, y2), 
+                                Atom.create(r, x, y3), 
+                }; 
+                
+                Atom[] headAtoms = new Atom[] {
+                                Atom.create(Equality.INSTANCE, y1, y2), 
+                                Atom.create(Equality.INSTANCE, y1, y3), 
+                                Atom.create(Equality.INSTANCE, y2, y3)
+                }; 
+                
+                OWLOntologyManager m = OWLManager.createOWLOntologyManager(); 
+                OWLOntology emptyOntology = null; 
+                try {
+                        emptyOntology = m.createOntology(); 
+                } catch (Exception e) {
+                        e.printStackTrace();
+                        fail("failed to create a new ontology"); 
+                }
+                Clause c = new Clause(Clausifier.getInstance(emptyOntology), DLClause.create(headAtoms, bodyAtoms));
+                System.out.println(c.toString()); 
+        }
+        
+        @Test
+        public void test_inverse() {
+                Variable x = Variable.create("X"), y1 = Variable.create("y1"), y2 = Variable.create("y2");
+                AtomicConcept A = AtomicConcept.create("A"); 
+                AtomicRole r = AtomicRole.create("r"); 
+                Atom[] bodyAtoms = new Atom[] {
+                                Atom.create(A, x),
+                                Atom.create(r, y1, x),
+                                Atom.create(r, y2, x)
+                }; 
+                
+                Atom[] headAtoms = new Atom[] {
+                                Atom.create(Equality.INSTANCE, y1, y2) 
+                }; 
+                
+                OWLOntologyManager m = OWLManager.createOWLOntologyManager(); 
+                OWLOntology emptyOntology = null; 
+                try {
+                        emptyOntology = m.createOntology(); 
+                } catch (Exception e) {
+                        e.printStackTrace();
+                        fail("failed to create a new ontology"); 
+                }
+                Clause c = new Clause(Clausifier.getInstance(emptyOntology), DLClause.create(headAtoms, bodyAtoms));
+                System.out.println(c.toString()); 
+        }
+        
+        @Test
+        public void test_fillter() {
+                Variable x = Variable.create("X"), y1 = Variable.create("y1"), y2 = Variable.create("y2");
+                AtomicConcept A = AtomicConcept.create("A"); 
+                AtomicConcept B = AtomicConcept.create("B"); 
+                AtomicRole r = AtomicRole.create("r"); 
+                Atom[] bodyAtoms = new Atom[] {
+                                Atom.create(A, x),
+                                Atom.create(r, y1, x),
+                                Atom.create(r, y2, x), 
+                                Atom.create(B, y1), 
+                                Atom.create(B, y2) 
+                }; 
+                
+                Atom[] headAtoms = new Atom[] {
+                                Atom.create(Equality.INSTANCE, y1, y2) 
+                }; 
+                
+                OWLOntologyManager m = OWLManager.createOWLOntologyManager(); 
+                OWLOntology emptyOntology = null; 
+                try {
+                        emptyOntology = m.createOntology(); 
+                } catch (Exception e) {
+                        e.printStackTrace();
+                        fail("failed to create a new ontology"); 
+                }
+                Clause c = new Clause(Clausifier.getInstance(emptyOntology), DLClause.create(headAtoms, bodyAtoms));
+                System.out.println(c.toString()); 
+        }
+        
+        @Test
+        public void test_negFillter() {
+                Variable x = Variable.create("X"), y1 = Variable.create("y1"), y2 = Variable.create("y2");
+                AtomicConcept A = AtomicConcept.create("A"); 
+                AtomicConcept B = AtomicConcept.create("B"); 
+                AtomicRole r = AtomicRole.create("r"); 
+                Atom[] bodyAtoms = new Atom[] {
+                                Atom.create(A, x),
+                                Atom.create(r, y1, x),
+                                Atom.create(r, y2, x)
+                }; 
+                
+                Atom[] headAtoms = new Atom[] {
+                                Atom.create(Equality.INSTANCE, y1, y2), 
+                                Atom.create(B, y1), 
+                                Atom.create(B, y2)  
+                }; 
+                
+                OWLOntologyManager m = OWLManager.createOWLOntologyManager(); 
+                OWLOntology emptyOntology = null; 
+                try {
+                        emptyOntology = m.createOntology(); 
+                } catch (Exception e) {
+                        e.printStackTrace();
+                        fail("failed to create a new ontology"); 
+                }
+                Clause c = new Clause(Clausifier.getInstance(emptyOntology), DLClause.create(headAtoms, bodyAtoms));
+                System.out.println(c.toString()); 
+        }
+        
+}
diff --git a/test/uk/ac/ox/cs/pagoda/junit/CostEvaluation.java b/test/uk/ac/ox/cs/pagoda/junit/CostEvaluation.java
new file mode 100644
index 0000000..87b01ed
--- /dev/null
+++ b/test/uk/ac/ox/cs/pagoda/junit/CostEvaluation.java
@@ -0,0 +1,109 @@
+package uk.ac.ox.cs.pagoda.junit;
+
+import org.junit.Test;
+import org.semanticweb.owlapi.model.OWLOntology;
+
+import uk.ac.ox.cs.pagoda.owl.OWLHelper;
+import uk.ac.ox.cs.pagoda.reasoner.QueryReasoner;
+import uk.ac.ox.cs.pagoda.reasoner.QueryReasoner.Type;
+import uk.ac.ox.cs.pagoda.tester.PagodaTester;
+import uk.ac.ox.cs.pagoda.util.Timer;
+import uk.ac.ox.cs.pagoda.util.Utility;
+
+public class CostEvaluation {   
+        
+        @Test
+        public void lubm100() {
+                int number = 1;
+                PagodaTester.main(
+                                PagodaTester.onto_dir + "lubm/univ-bench.owl",
+                                PagodaTester.onto_dir + "lubm/data/lubm" + number + ".ttl",
+                                PagodaTester.onto_dir + "lubm/queries/test_all_pagoda.sparql"
+                ); 
+//              AllTests.copy("output/log4j.log", "results-backup/jair/lubm" + number + ".out"); 
+        }
+        
+        public void lubm1000() {
+                int number = 1000;
+                String[] args = new String[] {
+                                PagodaTester.onto_dir + "lubm/univ-bench.owl",
+                                PagodaTester.onto_dir + "lubm/data/lubm" + number + ".ttl",
+                                PagodaTester.onto_dir + "lubm/queries/test_all_pagoda.sparql" 
+                }; 
+                OWLOntology ontology = OWLHelper.loadOntology(args[0]); 
+                QueryReasoner reasoner = QueryReasoner.getInstance(Type.ELHOU, ontology, true, true); 
+                Timer t = new Timer(); 
+                reasoner.loadOntology(ontology);
+                reasoner.importData(args[1]);
+                if (!reasoner.preprocess())
+                        return ; 
+                Utility.logInfo("Preprocessing Done in " + t.duration() + " seconds.");
+                
+                reasoner.evaluate(reasoner.getQueryManager().collectQueryRecords(args[2]));
+//              AllTests.copy("output/log4j.log", "results-backup/jair/lubm" + number + ".out"); 
+        }
+
+        @Test
+        public void uobm5() {
+                int number = 1;
+                String[] args = new String[] {
+                                PagodaTester.onto_dir + "uobm/univ-bench-dl.owl",
+                                PagodaTester.onto_dir + "uobm/data/uobm" + number + ".ttl",
+                                PagodaTester.onto_dir + "uobm/queries/standard_all_pagoda.sparql" 
+                }; 
+                PagodaTester.main(args);
+//              AllTests.copy("output/log4j.log", "results-backup/jair/uobm" + number + ".out"); 
+        }
+        
+        public void uobm100() {
+                int number = 200;
+                String[] args = new String[] {
+                                PagodaTester.onto_dir + "uobm/univ-bench-dl.owl",
+                                PagodaTester.onto_dir + "uobm/data/uobm" + number + ".ttl",
+                                PagodaTester.onto_dir + "uobm/queries/standard_group3_all.sparql" 
+                }; 
+                PagodaTester.main(args);
+//              AllTests.copy("output/log4j.log", "results-backup/jair/uobm" + number + ".out"); 
+        }
+        
+        public void uobm500() {
+                int number = 500;
+                String[] args = new String[] {
+                                PagodaTester.onto_dir + "uobm/univ-bench-dl.owl",
+                                PagodaTester.onto_dir + "uobm/data/uobm" + number + ".ttl",
+                                PagodaTester.onto_dir + "uobm/queries/standard_all_pagoda.sparql" 
+                }; 
+                
+                OWLOntology ontology = OWLHelper.loadOntology(args[0]); 
+                QueryReasoner reasoner = QueryReasoner.getInstance(Type.ELHOU, ontology, true, true);
+                Timer t = new Timer(); 
+                reasoner.loadOntology(ontology);
+                reasoner.importData(args[1]);
+                if (!reasoner.preprocess())
+                        return ; 
+                Utility.logInfo("Preprocessing Done in " + t.duration() + " seconds.");
+                
+                reasoner.evaluate(reasoner.getQueryManager().collectQueryRecords(args[2]));
+//              AllTests.copy("output/log4j.log", "results-backup/jair/uobm" + number + ".out"); 
+        }
+        
+        
+        public static void main(String... args) {
+                args = new String[] {
+                                PagodaTester.onto_dir + "dbpedia/integratedOntology-all-in-one-minus-datatype.owl", 
+                                PagodaTester.onto_dir + "dbpedia/data/dbpedia-minus-datatype-new.ttl",
+                                PagodaTester.onto_dir + "dbpedia/queries/atomic_ground.sparql"
+                }; 
+                
+                OWLOntology ontology = OWLHelper.loadOntology(args[0]); 
+                QueryReasoner reasoner = QueryReasoner.getInstance(Type.ELHOU, ontology, true, true);
+                Timer t = new Timer(); 
+                reasoner.loadOntology(ontology);
+                reasoner.importData(args[1]);
+                if (!reasoner.preprocess())
+                        return ; 
+                Utility.logInfo("Preprocessing Done in " + t.duration() + " seconds.");
+                
+                reasoner.evaluate(reasoner.getQueryManager().collectQueryRecords(args[2]));
+        }
+}
diff --git a/test/uk/ac/ox/cs/pagoda/junit/FullEvaluation.java b/test/uk/ac/ox/cs/pagoda/junit/FullEvaluation.java
new file mode 100644
index 0000000..3406ed2
--- /dev/null
+++ b/test/uk/ac/ox/cs/pagoda/junit/FullEvaluation.java
@@ -0,0 +1,14 @@
+package uk.ac.ox.cs.pagoda.junit;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({ LightEvaluation.class, 
+        CostEvaluation.class
+        })
+
+public class FullEvaluation {
+        
+}
diff --git a/test/uk/ac/ox/cs/pagoda/junit/JAIR_PAGOdA.java b/test/uk/ac/ox/cs/pagoda/junit/JAIR_PAGOdA.java
new file mode 100644
index 0000000..2a148cc
--- /dev/null
+++ b/test/uk/ac/ox/cs/pagoda/junit/JAIR_PAGOdA.java
@@ -0,0 +1,173 @@
+package uk.ac.ox.cs.pagoda.junit;
+
+import org.junit.Test;
+
+import uk.ac.ox.cs.pagoda.tester.PagodaTester;
+
+public class JAIR_PAGOdA {
+
+        public void lubm1() {
+                String[] args = new String[] {
+                                PagodaTester.onto_dir + "lubm/univ-bench.owl",
+                                PagodaTester.onto_dir + "lubm/data/lubm1.ttl",
+                                PagodaTester.onto_dir + "lubm/queries/test.sparql" 
+                };
+                PagodaTester.main(args);
+                AllTests.copy("output/log4j.log", "/home/yzhou/java-workspace/test-share/results_new/lubm1/pagoda"); 
+        }
+        
+        
+        public void lubm1_conj() {
+                String[] args = new String[] {
+                                PagodaTester.onto_dir + "lubm/univ-bench.owl",
+                                PagodaTester.onto_dir + "lubm/data/lubm1.ttl",
+                                PagodaTester.onto_dir + "lubm/queries/test_pellet.sparql" 
+                };
+                PagodaTester.main(args);
+                AllTests.copy("output/log4j.log", "/home/yzhou/java-workspace/test-share/results_new/lubm1/pagoda_conj"); 
+        }
+        
+        
+        public void lubm1_rolledUp() {
+                String[] args = new String[] {
+                                "/home/yzhou/backup/20141212/univ-bench-queries.owl",
+                                PagodaTester.onto_dir + "lubm/data/lubm1.ttl",
+                                PagodaTester.onto_dir + "lubm/queries/atomic_lubm.sparql" 
+                };
+                PagodaTester.main(args);
+                AllTests.copy("output/log4j.log", "/home/yzhou/java-workspace/test-share/results_new/lubm1/pagoda_rolledUp"); 
+        }
+        
+        
+        public void uobm1() {
+                String[] args = new String[] {
+                                PagodaTester.onto_dir + "uobm/univ-bench-dl.owl",
+                                PagodaTester.onto_dir + "uobm/data/uobm1.ttl",
+                                PagodaTester.onto_dir + "uobm/queries/standard.sparql" 
+                };
+                PagodaTester.main(args);
+                AllTests.copy("output/log4j.log", "/home/yzhou/java-workspace/test-share/results_new/uobm1/pagoda"); 
+        }
+        
+        
+        public void uobm1_conj() {
+                String[] args = new String[] {
+                                PagodaTester.onto_dir + "uobm/univ-bench-dl.owl",
+                                PagodaTester.onto_dir + "uobm/data/uobm1.ttl",
+                                PagodaTester.onto_dir + "uobm/queries/standard_pellet.sparql" 
+                };
+                PagodaTester.main(args);
+                AllTests.copy("output/log4j.log", "/home/yzhou/java-workspace/test-share/results_new/uobm1/pagoda_conj"); 
+        }
+
+        
+        public void uobm1_rolledUp() {
+                String[] args = new String[] {
+                                "/home/yzhou/backup/20141212/univ-bench-dl-queries.owl",
+                                PagodaTester.onto_dir + "uobm/data/uobm1.ttl",
+                                PagodaTester.onto_dir + "uobm/queries/atomic_uobm.sparql" 
+                };
+                PagodaTester.main(args);
+//              AllTests.copy("output/log4j.log", "/home/yzhou/java-workspace/test-share/results_new/uobm1/pagoda_rolledUp"); 
+        }
+        
+        
+        public void fly() {
+                String[] args = new String[] {
+                                PagodaTester.onto_dir + "fly/fly_anatomy_XP_with_GJ_FC_individuals.owl",
+                                null, 
+                                PagodaTester.onto_dir + "fly/queries/fly_pellet.sparql" 
+                };
+                PagodaTester.main(args);
+//              AllTests.copy("output/log4j.log", "/home/yzhou/java-workspace/test-share/results_new/fly/pagoda"); 
+        }
+        
+        @Test
+        public void fly_conj() {
+                String[] args = new String[] {
+                                PagodaTester.onto_dir + "fly/fly_anatomy_XP_with_GJ_FC_individuals.owl",
+                                null, 
+                                PagodaTester.onto_dir + "fly/queries/fly_pellet.sparql" 
+                };
+                PagodaTester.main(args);
+                AllTests.copy("output/log4j.log", "/home/yzhou/java-workspace/test-share/results_new/fly/pagoda_conj"); 
+        }
+        
+        
+        public void fly_rolledUp() {
+                PagodaTester.main(new String[] {
+//                              PagodaTester.onto_dir + "fly/fly_anatomy_XP_with_GJ_FC_individuals.owl",
+                                PagodaTester.onto_dir + "fly/fly-all-in-one_rolledUp.owl",
+                                null, 
+                                PagodaTester.onto_dir + "fly/queries/fly_atomic.sparql" 
+                });
+//              AllTests.copy("output/log4j.log", "/home/yzhou/java-workspace/test-share/results_new/fly/pagoda_rolledUp"); 
+        }
+        
+        public void dbpedia() {
+                PagodaTester.main(
+                                PagodaTester.onto_dir + "dbpedia/integratedOntology-all-in-one-minus-datatype.owl", 
+                                PagodaTester.onto_dir + "dbpedia/data/dbpedia-minus-datatype-new.ttl",
+                                PagodaTester.onto_dir + "dbpedia/queries/atomic_ground.sparql"
+                                , "dbpedia.ans"
+                );
+                
+//              AllTests.copy("output/log4j.log", "/home/yzhou/java-workspace/test-share/results_new/dbpedia/pagoda"); 
+        }
+
+        public void npd() {
+                PagodaTester.main(
+                                PagodaTester.onto_dir + "npd/npd-all-minus-datatype.owl", 
+                                PagodaTester.onto_dir + "npd/data/npd-data-dump-minus-datatype-new.ttl", 
+                                PagodaTester.onto_dir + "npd/queries/atomic_ground.sparql"
+                                , "npd.ans"
+                ); 
+                
+//              AllTests.copy("output/log4j.log", "/home/yzhou/java-workspace/test-share/results_new/npd/pagoda"); 
+        }
+
+        public void reactome() {
+                PagodaTester.main(
+                                PagodaTester.onto_dir + "bio2rdf/reactome/biopax-level3-processed.owl", 
+                                PagodaTester.onto_dir + "bio2rdf/reactome/graph sampling/reactome_sample_10.ttl",
+//                              null, 
+//                              PagodaTester.onto_dir + "bio2rdf/reactome/queries/atomic_ground.sparql"
+                                PagodaTester.onto_dir + "bio2rdf/reactome/queries/example.sparql"
+                                , "pagoda_reactome.ans"
+                );
+                AllTests.copy("log4j.log", "output/jair/pagoda_reactome.example");
+                
+//              AllTests.copy("output/log4j.log", "/home/yzhou/java-workspace/test-share/results_new/reactome/pagoda_10p"); 
+        }
+        
+        public void chembl() {
+                PagodaTester.main(
+                                PagodaTester.onto_dir + "bio2rdf/chembl/cco-noDPR.ttl", 
+                                PagodaTester.onto_dir + "bio2rdf/chembl/graph sampling/sample_1.nt", 
+//                              PagodaTester.onto_dir + "bio2rdf/chembl/queries/atomic_ground.sparql"
+                                PagodaTester.onto_dir + "bio2rdf/chembl/queries/example.sparql"
+                                , "pagoda_chembl.ans"
+                ); 
+                AllTests.copy("log4j.log", "output/jair/pagoda_chembl.example"); 
+//              AllTests.copy("output/log4j.log", "/home/yzhou/java-workspace/test-share/results_new/chembl/pagoda_1p"); 
+        }
+
+        public void uniprot() {
+                PagodaTester.main(
+                                PagodaTester.onto_dir + "bio2rdf/uniprot/core-sat-processed.owl", 
+                                PagodaTester.onto_dir + "bio2rdf/uniprot/graph sampling/sample_1.nt",
+//                              null, 
+//                              PagodaTester.onto_dir + "bio2rdf/uniprot/queries/atomic_ground.sparql"
+                                PagodaTester.onto_dir + "bio2rdf/uniprot/queries/example.sparql"
+                                , "pagoda_uniprot.ans"
+                ); 
+                AllTests.copy("log4j.log", "output/jair/pagoda_uniprot.example"); 
+//              AllTests.copy("output/log4j.log", "/home/yzhou/java-workspace/test-share/results_new/uniprot/pagoda_1p"); 
+        }
+
+        
+        public static void main(String... args) {
+                new JAIR_PAGOdA().fly();
+        }
+
+}
diff --git a/test/uk/ac/ox/cs/pagoda/junit/JAIR_Scalability.java b/test/uk/ac/ox/cs/pagoda/junit/JAIR_Scalability.java
new file mode 100644
index 0000000..5bd3134
--- /dev/null
+++ b/test/uk/ac/ox/cs/pagoda/junit/JAIR_Scalability.java
@@ -0,0 +1,85 @@
+package uk.ac.ox.cs.pagoda.junit;
+
+import org.junit.Test;
+
+import uk.ac.ox.cs.pagoda.tester.PagodaTester;
+
+public class JAIR_Scalability {
+        
+        private static final String date = "_0123"; 
+
+        @Test
+        public void reactome() {
+                testReactome(10, false);
+        }
+        
+        @Test
+        public void chembl() {
+                testChEMBL(1, false);
+        }
+
+        @Test
+        public void uniprot() {
+                testUniProt(1, false);
+        }
+
+        public void testReactome(int percentage, boolean save) {
+                String[] args = new String[] {
+                                PagodaTester.onto_dir + "bio2rdf/reactome/biopax-level3-processed.owl", 
+                                PagodaTester.onto_dir + "bio2rdf/reactome/graph sampling/simplifed_sample_" + percentage + ".ttl", 
+                                PagodaTester.onto_dir + "bio2rdf/reactome/queries/test.sparql"
+                                , "reactome.ans"
+                }; 
+                if (percentage == 10)
+                        args[1] = args[1].replace("simplifed", "reactome");
+                
+                PagodaTester.main(args); 
+                if (save)
+                        AllTests.copy("log4j.log", "/home/yzhou/java-workspace/test-share/results_new/reactome/pagoda_" + percentage + "p" + date); 
+        }
+        
+        public void testChEMBL(int percentage, boolean save) {
+                String[] args = new String[] {
+                                PagodaTester.onto_dir + "bio2rdf/chembl/cco-noDPR.ttl", 
+                                PagodaTester.onto_dir + "bio2rdf/chembl/sample_" + percentage + ".nt",
+//                              PagodaTester.onto_dir + "bio2rdf/chembl/queries/atomic_ground.sparql"
+                                PagodaTester.onto_dir + "bio2rdf/chembl/queries/test.sparql"
+                                , "chembl.ans"
+                }; 
+                if (percentage == 1 || percentage == 10 || percentage == 50)
+                        args[1] = args[1].replace("chembl", "chembl/graph sampling");
+                else 
+                        if (percentage == 100)
+                                args[1] = "/home/yzhou/RDFData/ChEMBL/facts/ChEMBL.ttl"; 
+                
+                PagodaTester.main(args);
+                if (save)
+                AllTests.copy("log4j.log", "/home/yzhou/java-workspace/test-share/results_new/chembl/pagoda_" + percentage + "p" + date); 
+        }
+        
+        public void testUniProt(int percentage, boolean save) {
+                String[] args = new String[] {
+                                PagodaTester.onto_dir + "bio2rdf/uniprot/core-sat-processed.owl", 
+                                PagodaTester.onto_dir + "bio2rdf/uniprot/sample_" + percentage + ".nt",
+//                              PagodaTester.onto_dir + "bio2rdf/uniprot/queries/atomic_ground.sparql"
+                                PagodaTester.onto_dir + "bio2rdf/uniprot/queries/test.sparql"
+                                , "uniprot.ans"
+                }; 
+                
+                if (percentage == 1 || percentage == 10 || percentage == 50)
+                        args[1] = args[1].replace("uniprot", "uniprot/graph sampling");
+                else 
+                        if (percentage == 100)
+                                args[1] = "/home/yzhou/krr-nas-share/Yujiao/ontologies/bio2rdf/uniprot/data/uniprot_cleaned.nt"; 
+                
+                PagodaTester.main(args); 
+                if (save)
+                        AllTests.copy("log4j.log", "/home/yzhou/java-workspace/test-share/results_new/uniprot/pagoda_" + percentage + "p" + date); 
+        }
+        
+        public static void main(String... args) {
+                PagodaTester.ShellMode = true; 
+                new JAIR_Scalability().testUniProt(50, false);
+        }
+
+}
diff --git a/test/uk/ac/ox/cs/pagoda/junit/LightEvaluation.java b/test/uk/ac/ox/cs/pagoda/junit/LightEvaluation.java
new file mode 100644
index 0000000..1ddca15
--- /dev/null
+++ b/test/uk/ac/ox/cs/pagoda/junit/LightEvaluation.java
@@ -0,0 +1,59 @@
+package uk.ac.ox.cs.pagoda.junit;
+
+import org.junit.Test;
+import uk.ac.ox.cs.pagoda.tester.PagodaTester;
+
+public class LightEvaluation {
+
+        @Test
+        public void uobm1() {
+                int number = 1;
+                PagodaTester.main(
+                                PagodaTester.onto_dir + "uobm/univ-bench-dl.owl",
+                                PagodaTester.onto_dir + "uobm/data/uobm" + number + ".ttl",
+                                PagodaTester.onto_dir + "uobm/queries/standard.sparql"
+                ); 
+                AllTests.copy("log4j.log", "output/jair/uobm1.out"); 
+        }
+        
+        @Test
+        public void lubm100() {
+                int number = 100;
+                PagodaTester.main(
+                                PagodaTester.onto_dir + "lubm/univ-bench.owl",
+                                PagodaTester.onto_dir + "lubm/data/lubm" + number + ".ttl",
+                                PagodaTester.onto_dir + "lubm/queries/test.sparql"
+                ); 
+                AllTests.copy("log4j.log", "results-backup/current/lubm100.out"); 
+        }
+        
+        @Test
+        public void fly() {
+                PagodaTester.main(
+                                PagodaTester.onto_dir + "fly/fly_anatomy_XP_with_GJ_FC_individuals.owl",
+                                PagodaTester.onto_dir + "fly/queries/fly.sparql" 
+                ); 
+                AllTests.copy("log4j.log", "results-backup/current/fly.out"); 
+        }
+        
+        @Test 
+        public void dbpedia() {
+                PagodaTester.main(
+                                PagodaTester.onto_dir + "dbpedia/integratedOntology-all-in-one-minus-datatype.owl", 
+                                PagodaTester.onto_dir + "dbpedia/data/dbpedia-minus-datatype-new.ttl",
+                                PagodaTester.onto_dir + "dbpedia/atomic.sparql"
+                );
+                AllTests.copy("log4j.log", "results-backup/current/dbpedia.out"); 
+        }
+        
+        @Test
+        public void npdWithoutDataType() {
+                PagodaTester.main(
+                                PagodaTester.onto_dir + "npd/npd-all-minus-datatype.owl", 
+                                PagodaTester.onto_dir + "npd/data/npd-data-dump-minus-datatype-new.ttl", 
+                                PagodaTester.onto_dir + "npd/queries/atomic.sparql"
+                ); 
+                AllTests.copy("log4j.log", "results-backup/current/npd_minus.out"); 
+        }
+        
+}
diff --git a/test/uk/ac/ox/cs/pagoda/junit/PagodaDBPedia.java b/test/uk/ac/ox/cs/pagoda/junit/PagodaDBPedia.java
new file mode 100644
index 0000000..37ffb44
--- /dev/null
+++ b/test/uk/ac/ox/cs/pagoda/junit/PagodaDBPedia.java
@@ -0,0 +1,27 @@
+package uk.ac.ox.cs.pagoda.junit;
+
+import static org.junit.Assert.fail;
+
+import org.junit.Test;
+
+import uk.ac.ox.cs.pagoda.tester.PagodaTester;
+import uk.ac.ox.cs.pagoda.tester.Statistics;
+
+public class PagodaDBPedia {
+
+        @Test 
+        public void test() {
+                PagodaTester.main(
+                                PagodaTester.onto_dir + "dbpedia/integratedOntology-all-in-one-minus-datatype.owl", 
+                                PagodaTester.onto_dir + "dbpedia/data/dbpedia-minus-datatype-new.ttl",
+                                PagodaTester.onto_dir + "dbpedia/atomic.sparql"
+                );
+                
+                Statistics stat = new Statistics("output/log4j.log");
+                String diff = stat.diff("results-backup/benchmark/dbpedia.out"); 
+                AllTests.copy("output/log4j.log", "results-backup/current/dbpedia.out"); 
+                if (!diff.isEmpty())
+                        fail(diff);
+        }
+
+}
diff --git a/test/uk/ac/ox/cs/pagoda/junit/PagodaELU.java b/test/uk/ac/ox/cs/pagoda/junit/PagodaELU.java
new file mode 100644
index 0000000..d999a6e
--- /dev/null
+++ b/test/uk/ac/ox/cs/pagoda/junit/PagodaELU.java
@@ -0,0 +1,18 @@
+package uk.ac.ox.cs.pagoda.junit;
+
+import org.junit.Test;
+import uk.ac.ox.cs.pagoda.tester.PagodaTester;
+
+public class PagodaELU {
+
+        @Test void test() {
+                int number = 1; 
+                PagodaTester.main(
+                                PagodaTester.onto_dir + "uobm/univ-bench-dl.owl",
+                                PagodaTester.onto_dir + "uobm/data/uobm" + number + ".ttl",
+                                PagodaTester.onto_dir + "uobm/queries/standard.sparql" 
+                ); 
+        }
+        
+        
+}
diff --git a/test/uk/ac/ox/cs/pagoda/junit/PagodaFLY.java b/test/uk/ac/ox/cs/pagoda/junit/PagodaFLY.java
new file mode 100644
index 0000000..4631837
--- /dev/null
+++ b/test/uk/ac/ox/cs/pagoda/junit/PagodaFLY.java
@@ -0,0 +1,24 @@
+package uk.ac.ox.cs.pagoda.junit;
+
+import org.junit.Test;
+
+import uk.ac.ox.cs.pagoda.tester.PagodaTester;
+
+public class PagodaFLY {
+
+        @Test
+        public void test() {
+                PagodaTester.main(
+                                PagodaTester.onto_dir + "fly/fly_anatomy_XP_with_GJ_FC_individuals.owl",
+                                PagodaTester.onto_dir + "fly/queries/fly_pellet.sparql" 
+                ); 
+                
+//              Statistics stat = new Statistics("output/log4j.log");
+//              String diff = stat.diff("results-backup/benchmark/fly.out"); 
+//              AllTests.copy("output/log4j.log", "results-backup/current/fly.out"); 
+//              if (!diff.isEmpty())
+//                      fail(diff);
+        }
+        
+
+}
diff --git a/test/uk/ac/ox/cs/pagoda/junit/PagodaLUBM.java b/test/uk/ac/ox/cs/pagoda/junit/PagodaLUBM.java
new file mode 100644
index 0000000..f8fef0e
--- /dev/null
+++ b/test/uk/ac/ox/cs/pagoda/junit/PagodaLUBM.java
@@ -0,0 +1,38 @@
+package uk.ac.ox.cs.pagoda.junit;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+import uk.ac.ox.cs.pagoda.tester.PagodaTester;
+import uk.ac.ox.cs.pagoda.tester.Statistics;
+
+public class PagodaLUBM {
+
+        public void test_all(int number) {
+                PagodaTester.main(
+                                PagodaTester.onto_dir + "lubm/univ-bench.owl",
+                                PagodaTester.onto_dir + "lubm/data/lubm" + number + ".ttl",
+                                PagodaTester.onto_dir + "lubm/queries/test_all_pagoda.sparql" 
+                ); 
+                
+                AllTests.copy("log4j.log", "output/jair/lubm" + number + ".out"); 
+        }
+        
+        @Test
+        public void test1() { test_all(1); }
+        
+        public void test() {
+                int number = 100;
+                test_all(number); 
+        }
+        
+        public void check(int number) {
+                Statistics stat = new Statistics("output/log4j.log");
+                String diff = stat.diff("results-backup/benchmark/lubm" + number + ".out"); 
+                AllTests.copy("output/log4j.log", "results-backup/current/lubm" + number + ".out"); 
+                if (!diff.isEmpty()) 
+                        fail(diff);
+        }
+        
+}
diff --git a/test/uk/ac/ox/cs/pagoda/junit/PagodaNPD.java b/test/uk/ac/ox/cs/pagoda/junit/PagodaNPD.java
new file mode 100644
index 0000000..96edbb4
--- /dev/null
+++ b/test/uk/ac/ox/cs/pagoda/junit/PagodaNPD.java
@@ -0,0 +1,42 @@
+package uk.ac.ox.cs.pagoda.junit;
+
+import static org.junit.Assert.fail;
+
+import org.junit.Test;
+
+import uk.ac.ox.cs.pagoda.tester.PagodaTester;
+import uk.ac.ox.cs.pagoda.tester.Statistics;
+
+public class PagodaNPD {
+
+        @Test
+        public void testNPDwithoutDataType() {
+                PagodaTester.main(
+                                PagodaTester.onto_dir + "npd/npd-all-minus-datatype.owl", 
+                                PagodaTester.onto_dir + "npd/data/npd-data-dump-minus-datatype-new.ttl", 
+                                PagodaTester.onto_dir + "npd/queries/atomic.sparql"
+                ); 
+                
+                Statistics stat = new Statistics("output/log4j.log");
+                String diff = stat.diff("results-backup/benchmark/npd_minus.out"); 
+                AllTests.copy("output/log4j.log", "results-backup/current/npd_minus.out"); 
+                if (!diff.isEmpty())
+                        fail(diff);
+        }
+        
+        @Test
+        public void testNPD() {
+                PagodaTester.main(
+                                PagodaTester.onto_dir + "npd/npd-all.owl", 
+                                PagodaTester.onto_dir + "npd/data/npd-data-dump-processed.ttl", 
+                                PagodaTester.onto_dir + "npd/queries/atomic.sparql"
+                );
+                
+                Statistics stat = new Statistics("output/log4j.log");
+                String diff = stat.diff("results-backup/benchmark/npd.out"); 
+                AllTests.copy("output/log4j.log", "results-backup/current/npd.out"); 
+                if (!diff.isEmpty())
+                        fail(diff);
+        }
+        
+}
diff --git a/test/uk/ac/ox/cs/pagoda/junit/PagodaNPD_bench.java b/test/uk/ac/ox/cs/pagoda/junit/PagodaNPD_bench.java
new file mode 100644
index 0000000..df1a57d
--- /dev/null
+++ b/test/uk/ac/ox/cs/pagoda/junit/PagodaNPD_bench.java
@@ -0,0 +1,27 @@
+package uk.ac.ox.cs.pagoda.junit;
+
+import static org.junit.Assert.fail;
+
+import org.junit.Test;
+
+import uk.ac.ox.cs.pagoda.tester.PagodaTester;
+import uk.ac.ox.cs.pagoda.tester.Statistics;
+
+public class PagodaNPD_bench {
+        
+        @Test
+        public void test() {
+                PagodaTester.main(
+                                PagodaTester.onto_dir + "npd-benchmark/npd-v2-ql_a.owl", 
+                                PagodaTester.onto_dir + "npd-benchmark/npd-v2-ql_a.ttl", 
+                                PagodaTester.onto_dir + "npd-benchmark/queries/all.sparql"
+                ); 
+                
+                Statistics stat = new Statistics("output/log4j.log");
+                String diff = stat.diff("results-backup/benchmark/npd-bench.out"); 
+                AllTests.copy("output/log4j.log", "results-backup/current/npd-bench.out"); 
+                if (!diff.isEmpty())
+                        fail(diff);
+        }
+        
+}
diff --git a/test/uk/ac/ox/cs/pagoda/junit/PagodaRLU.java b/test/uk/ac/ox/cs/pagoda/junit/PagodaRLU.java
new file mode 100644
index 0000000..5d93302
--- /dev/null
+++ b/test/uk/ac/ox/cs/pagoda/junit/PagodaRLU.java
@@ -0,0 +1,18 @@
+package uk.ac.ox.cs.pagoda.junit;
+
+import org.junit.Test;
+import uk.ac.ox.cs.pagoda.tester.PagodaTester;
+
+public class PagodaRLU {
+
+        @Test 
+        public void testRL() {
+                int number = 1; 
+                PagodaTester.main(
+                                PagodaTester.onto_dir + "uobm/univ-bench-dl.owl",
+                                PagodaTester.onto_dir + "uobm/data/uobm" + number + ".ttl",
+                                PagodaTester.onto_dir + "uobm/queries/standard.sparql" 
+                ); 
+        }
+
+}
diff --git a/test/uk/ac/ox/cs/pagoda/junit/PagodaUOBM.java b/test/uk/ac/ox/cs/pagoda/junit/PagodaUOBM.java
new file mode 100644
index 0000000..5b56c6d
--- /dev/null
+++ b/test/uk/ac/ox/cs/pagoda/junit/PagodaUOBM.java
@@ -0,0 +1,48 @@
+package uk.ac.ox.cs.pagoda.junit;
+
+import org.junit.Test;
+
+import uk.ac.ox.cs.pagoda.tester.PagodaTester;
+import uk.ac.ox.cs.pagoda.tester.Statistics;
+
+public class PagodaUOBM {
+
+        public void test_all(int number ) {
+                PagodaTester.main(
+                                PagodaTester.onto_dir + "uobm/univ-bench-dl.owl",
+                                PagodaTester.onto_dir + "uobm/data/uobm" + number + ".ttl",
+                                PagodaTester.onto_dir + "uobm/queries/standard_all_pagoda.sparql" 
+//                              PagodaTester.onto_dir + "uobm/queries/standard_group3_all_less.sparql;" + 
+//                              PagodaTester.onto_dir + "uobm/queries/G3.sparql;" +
+//                              PagodaTester.onto_dir + "uobm/queries/last.sparql" 
+                ); 
+                
+                AllTests.copy("log4j.log", "output/jair/newuobm/uobm" + number + ".out"); 
+        }
+        
+        public void test_upToSum(int number) {
+                PagodaTester.main(
+                                PagodaTester.onto_dir + "uobm/univ-bench-dl.owl",
+                                PagodaTester.onto_dir + "uobm/data/uobm" + number + ".ttl",
+                                PagodaTester.onto_dir + "uobm/queries/standard_group3_all.sparql" 
+                ); 
+                
+//              AllTests.copy("log4j.log", "output/jair/uobm" + number + ".out"); 
+        }
+        
+        @Test
+        public void test1() {   test_all(1); }
+        
+        public void test500() { test_upToSum(500); }
+        
+        public static void main(String... args) {
+                new PagodaUOBM().test_all(1); 
+        }
+        
+        public void check() {
+                Statistics stat = new Statistics("results-backup/current/uobm1.out"); 
+                String diff = stat.diff("results-backup/benchmark/uobm1.out"); 
+                System.out.println(diff); 
+        }
+        
+}
diff --git a/test/uk/ac/ox/cs/pagoda/summary/SummaryTester.java b/test/uk/ac/ox/cs/pagoda/summary/SummaryTester.java
new file mode 100644
index 0000000..18b6090
--- /dev/null
+++ b/test/uk/ac/ox/cs/pagoda/summary/SummaryTester.java
@@ -0,0 +1,139 @@
+package uk.ac.ox.cs.pagoda.summary;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.Scanner;
+
+import org.semanticweb.HermiT.Reasoner;
+import org.semanticweb.owlapi.model.AxiomType;
+import org.semanticweb.owlapi.model.IRI;
+import org.semanticweb.owlapi.model.OWLClassExpression;
+import org.semanticweb.owlapi.model.OWLDataFactory;
+import org.semanticweb.owlapi.model.OWLOntology;
+import org.semanticweb.owlapi.model.OWLOntologyCreationException;
+import org.semanticweb.owlapi.model.OWLOntologyStorageException;
+
+import uk.ac.ox.cs.pagoda.hermit.DLClauseHelper;
+import uk.ac.ox.cs.pagoda.owl.OWLHelper;
+import uk.ac.ox.cs.pagoda.owl.QueryRoller;
+import uk.ac.ox.cs.pagoda.query.QueryManager;
+import uk.ac.ox.cs.pagoda.query.QueryRecord;
+import uk.ac.ox.cs.pagoda.summary.Summary;
+
+public class SummaryTester {
+
+        static String FILE_BREAK = System.getProperty("file.separator");
+        static String LINE_BREAK = System.getProperty("line.separator");
+        
+        public static void main(String[] args) throws Exception {
+//              String arg = "ontologies/claros/all-in-one-manually.owl"; 
+//              String arg = "ontologies/claros/Claros.owl ontologies/claros/data"; 
+                String arg =  "../uobmGenerator/univ-bench-dl.owl " + 
+                                "../uobmGenerator/uobm1 " + //"a " + 
+                                "ontologies/uobm/queries/uobm_standard_less.sparql"; 
+                                
+                testSummarisedUpperBound(arg.split("\\ ")); 
+        }
+        
+        /**
+         * args[0] ontology file location
+         * args[1] data directory
+         * args[2] sparql query file location
+         * 
+         * @param args 
+         * @throws OWLOntologyCreationException
+         * @throws FileNotFoundException
+         * @throws OWLOntologyStorageException 
+         */
+        public static void testSummarisedUpperBound(String[] args) throws OWLOntologyCreationException, FileNotFoundException, OWLOntologyStorageException {
+                OWLOntology onto = OWLHelper.loadOntology(args[0]); 
+                try {
+                        onto = OWLHelper.getImportedOntology(onto, args[1]); 
+                } catch (IOException e) {
+                        e.printStackTrace();
+                } 
+                 
+                Summary sum = testSummary(onto);
+                System.out.println("Summarisation Done."); 
+                
+                System.out.println(args[2]); 
+                Scanner scanner = new Scanner(new File(args[2])); 
+                OWLOntology summary = sum.getSummary();
+                OWLDataFactory factory = summary.getOWLOntologyManager().getOWLDataFactory(); 
+                QueryRoller r = new QueryRoller(factory);
+                OWLClassExpression summarisedQueryExp;
+                Reasoner reasoner = new Reasoner(summary); 
+                QueryManager queryManager = new QueryManager(); 
+                int upperBoundCounter, queryID = 0;
+                StringBuilder queryText = new StringBuilder();
+                String[] vars; 
+                
+                for (String line; ; ) {
+                        queryText.setLength(0);
+                        while (scanner.hasNextLine() && (line = scanner.nextLine()) != null && !line.startsWith("^[query"));
+                        if (!scanner.hasNextLine()) break; 
+                        
+                        while (scanner.hasNextLine() && (line = scanner.nextLine()) != null && !line.isEmpty())
+                                queryText.append(line).append(LINE_BREAK);
+                        if (!scanner.hasNextLine()) break; 
+                                
+                        System.out.println("------------ starting computing for Query " + ++queryID + "------------"); 
+                        
+                        System.out.println(queryText); 
+                        
+                        QueryRecord record = queryManager.create(queryText.toString(), queryID);
+                        vars = record.getAnswerVariables(); 
+                        if (vars.length > 1) {
+                                System.out.println("The query cannot be processed by HermiT ... More than one answer variable"); 
+                                continue; 
+                        }
+                        
+                        summarisedQueryExp = r.rollUp(DLClauseHelper.getQuery(sum.getSummary(record), null), vars[0]);
+                        
+                        upperBoundCounter = 0; 
+                        for (String representative: sum.getRepresentatives()) 
+                                if (reasoner.isEntailed(factory.getOWLClassAssertionAxiom(summarisedQueryExp, factory.getOWLNamedIndividual(IRI.create(representative))))) {
+                                        upperBoundCounter += sum.getGroup(representative).size(); 
+                                }
+                        
+                        System.out.println("There are " + upperBoundCounter + " individual(s) in the upper bound computed by summary."); 
+                }
+                scanner.close();
+        }
+        
+        public static Summary testSummary(OWLOntology ontology) throws OWLOntologyCreationException, FileNotFoundException {
+                Summary sum = new Summary(ontology);
+                
+                System.out.println("original ontology data: "); 
+                outputStatistics(ontology); 
+                
+                OWLOntology summary = sum.getSummary();
+                
+                System.out.println("summarised ontology data: "); 
+                outputStatistics(summary);
+                
+                try {
+                        FileOutputStream out = new FileOutputStream("summary.owl"); 
+                        summary.getOWLOntologyManager().saveOntology(summary, out);
+                        out.close();
+                } catch (OWLOntologyStorageException e) {
+                        e.printStackTrace();
+                } catch (IOException e) {
+                        // TODO Auto-generated catch block
+                        e.printStackTrace();
+                }
+                
+                return sum; 
+        }
+
+        private static void outputStatistics(OWLOntology onto) {
+                System.out.println("TBox: " + onto.getTBoxAxioms(true).size() +
+                                "\tRBox: " + onto.getRBoxAxioms(true).size() + 
+                                "\tABox: " + onto.getABoxAxioms(true).size());
+                System.out.println("Class Assertions: " + onto.getAxiomCount(AxiomType.CLASS_ASSERTION, true) + 
+                                "\tObject Property Assertions: " + onto.getAxiomCount(AxiomType.OBJECT_PROPERTY_ASSERTION, true)); 
+        }
+
+}
diff --git a/test/uk/ac/ox/cs/pagoda/tester/ORETester.java b/test/uk/ac/ox/cs/pagoda/tester/ORETester.java
new file mode 100644
index 0000000..1092d6f
--- /dev/null
+++ b/test/uk/ac/ox/cs/pagoda/tester/ORETester.java
@@ -0,0 +1,29 @@
+package uk.ac.ox.cs.pagoda.tester;
+
+import org.semanticweb.owlapi.model.OWLOntology;
+
+import uk.ac.ox.cs.pagoda.owl.OWLHelper;
+import uk.ac.ox.cs.pagoda.reasoner.QueryReasoner;
+
+public class ORETester {
+
+        public static void main(String... args) {
+//              args = new String[] { "/home/yzhou/krr-nas-share/Yujiao/ontologies/ORE2014/DL/00a1118a-5420-46f0-b4b2-a2585165b28a_ePizza.owl" };
+//              args = new String[] { "/home/yzhou/krr-nas-share/Yujiao/ontologies/ORE2014/DL/77de15c6-cc39-4960-a38a-e35e487d52b0_owl%2Fcoma" };
+//              args = new String[] { "/home/yzhou/krr-nas-share/Yujiao/ontologies/ORE2014/DL/wine_nodatatype.owl" };
+                
+//              args = new String[] { "/home/yzhou/krr-nas-share/Yujiao/ontologies/ORE2014/EL/b7700fe1-103b-4b32-a21c-f6604a763ba5_t-cell.owl" };
+                args = new String[] { "/home/yzhou/krr-nas-share/Yujiao/ontologies/ORE2014/EL/baa29363-f93c-4285-827e-0e2380c82efc_cations.n3" };
+                
+                
+                OWLOntology ontology = OWLHelper.loadOntology(args[0]);
+                QueryReasoner pagoda = QueryReasoner.getInstance(ontology);
+                System.out.println(pagoda); 
+                pagoda.loadOntology(ontology);
+                if (pagoda.preprocess())
+                        System.out.println("The ontology is consistent!"); 
+                else 
+                        System.out.println("The ontology is inconsistent!"); 
+        }
+        
+}
diff --git a/test/uk/ac/ox/cs/pagoda/tester/OWLTester.java b/test/uk/ac/ox/cs/pagoda/tester/OWLTester.java
new file mode 100644
index 0000000..5bc1a9b
--- /dev/null
+++ b/test/uk/ac/ox/cs/pagoda/tester/OWLTester.java
@@ -0,0 +1,29 @@
+package uk.ac.ox.cs.pagoda.tester;
+
+import org.semanticweb.owlapi.model.OWLOntology;
+import org.semanticweb.owlapi.model.OWLOntologyCreationException;
+import org.semanticweb.owlapi.model.OWLOntologyManager;
+
+import uk.ac.ox.cs.pagoda.owl.OWLHelper;
+
+public class OWLTester {
+
+        public static void main(String[] args) throws OWLOntologyCreationException {
+//              OWLOntology onto = OWLHelper.loadOntology("dbpedia_imported.owl");
+                OWLOntology onto = OWLHelper.loadOntology("reactome_imported.owl");
+                OWLOntologyManager manager = onto.getOWLOntologyManager();
+//              OWLOntology data = manager.loadOntology(IRI.create("file:/media/krr-nas-share/Yujiao/ontologies/bio2rdf/reactome/graph\ sampling/sample_1_new.ttl"));
+//              System.out.println("data: " + data.getAxiomCount() + " " + data.getABoxAxioms(true).size()); 
+                for (OWLOntology t: manager.getOntologies()) {
+                        System.out.println(t.getOntologyID());
+                        System.out.println(t.getAxiomCount() + " " + onto.getABoxAxioms(true).size()); 
+                }
+                System.out.println("In closure: " + onto.getImportsClosure().size()); 
+                for (OWLOntology t: onto.getImportsClosure())
+                        System.out.println(t.getOntologyID());
+                
+                System.out.println(onto.getAxiomCount() + " " + onto.getABoxAxioms(true).size()); 
+        }
+
+}
+
diff --git a/test/uk/ac/ox/cs/pagoda/tester/PagodaTester.java b/test/uk/ac/ox/cs/pagoda/tester/PagodaTester.java
new file mode 100644
index 0000000..e040c18
--- /dev/null
+++ b/test/uk/ac/ox/cs/pagoda/tester/PagodaTester.java
@@ -0,0 +1,336 @@
+package uk.ac.ox.cs.pagoda.tester;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.Scanner;
+
+import org.semanticweb.owlapi.model.OWLOntology;
+
+import uk.ac.ox.cs.pagoda.owl.OWLHelper;
+import uk.ac.ox.cs.pagoda.query.AnswerTuple;
+import uk.ac.ox.cs.pagoda.query.AnswerTuples;
+import uk.ac.ox.cs.pagoda.reasoner.*; 
+import uk.ac.ox.cs.pagoda.reasoner.QueryReasoner.Type; 
+import uk.ac.ox.cs.pagoda.util.Timer;
+import uk.ac.ox.cs.pagoda.util.Utility;
+
+public class PagodaTester {
+
+//      public static final String onto_dir = "/media/RDFData/yzhou/";
+//      public static final String onto_dir = "/users/yzhou/ontologies/";
+//      public static final String onto_dir = "/home/scratch/yzhou/ontologies/";
+        public static final String onto_dir = "/home/yzhou/krr-nas-share/Yujiao/ontologies/"; 
+
+        public static final String fly = onto_dir + "fly/fly_anatomy_XP_with_GJ_FC_individuals.owl";
+        public static final String fly_query = onto_dir + "fly/queries/fly.sparql";
+
+        public static final String test_tbox = onto_dir + "smallExampleFromAna/dummy.owl";
+        public static final String test_abox = onto_dir + "smallExampleFromAna/initialABox.ttl";
+        public static final String test_query = onto_dir + "smallExampleFromAna/queries.dlog";
+
+        public static final int lubm_number = 1;
+        public static final String lubm_tbox = onto_dir + "lubm/univ-bench.owl";
+        public static final String lubm_abox = onto_dir + "lubm/data/lubm" + lubm_number + ".ttl";
+        public static final String lubm_abox_copy = onto_dir + "lubm/data/lubm" + lubm_number + " (copy).ttl";
+        public static final String lubm_query = onto_dir + "lubm/queries/test.sparql";
+        public static final String lubm_query6 = onto_dir + "lubm/queries/test_q6.sparql";
+        public static final String lubm_query20 = onto_dir + "lubm/queries/test_q16.sparql";
+
+        public static final int uobm_number = 1;
+        public static final String uobm_tbox = onto_dir + "uobm/univ-bench-dl.owl";
+        public static final String uobm_abox = onto_dir + "uobm/data/uobm" + uobm_number + ".ttl";
+        public static final String uobm_query = onto_dir + "uobm/queries/standard.sparql";
+        public static final String uobm_query_temp = onto_dir + "uobm/queries/temp.sparql";
+        public static final String uobm_query2 = onto_dir + "uobm/queries/standard_q2.sparql";
+        public static final String uobm_query9 = onto_dir + "uobm/queries/standard_q9.sparql";
+        public static final String uobm_query11 = onto_dir + "uobm/queries/standard_q11.sparql";
+        public static final String uobm_query12 = onto_dir + "uobm/queries/standard_q12.sparql";
+        public static final String uobm_query14 = onto_dir + "uobm/queries/standard_q14.sparql";
+        public static final String uobm_query15 = onto_dir + "uobm/queries/standard_q15.sparql";
+        public static final String uobm_query_multi = onto_dir + "uobm/queries/standard_multi.sparql";
+        public static final String uobm_generated_query1 = onto_dir     + "uobm/queries/generated_q1.sparql";
+        public static final String uobm_query_group3 = onto_dir + "uobm/queries/standard_group3.sparql";
+
+        public static final String npd_tbox = onto_dir + "npd/npd-all-minus-datatype.owl"; 
+                                                                                                // "npd/npd-all.owl";
+                                                                                                // "npd-all-minus-datatype.owl";
+        public static final String npd_abox = onto_dir + "npd/data/npd-data-dump-minus-datatype-new.ttl"; 
+                                                                                                                                // "npd/data/npd-data-dump-processed.ttl";
+                                                                                                                                // "npd-data-dump-minus-datatype-old.ttl";
+        public static final String npd_query = onto_dir + "npd/queries/atomic.sparql";
+
+        public static final String npd_bench_tbox = onto_dir + "npd-benchmark/npd-v2-ql_a.owl"; // npd-all-minus-datatype.owl";
+        public static final String npd_bench_abox = onto_dir + "npd-benchmark/npd-v2-ql_a.ttl"; // npd-data-dump-minus-datatype-old.ttl";
+        public static final String npd_bench_query = onto_dir + "npd-benchmark/queries/all.sparql";
+
+        public static final String dbpedia_tbox = onto_dir + "dbpedia/integratedOntology-all-in-one-minus-datatype.owl";
+        public static final String dbpedia_abox = onto_dir + "dbpedia/data/dbpedia-minus-datatype-new.ttl";
+        public static final String dbpedia_query = onto_dir + "dbpedia/queries/atomic_ground.sparql";
+        public static final String dbpedia_query274 = onto_dir + "dbpedia/atomic_q274.sparql";
+        
+        public static final String dbpedia_latest_tbox = onto_dir + "dbpedia/dbpedia_2014.owl";
+        public static final String travel_tbox = onto_dir + "dbpedia/travel.owl";
+        public static final String dbpedia_tbox_simple = onto_dir + "dbpedia/dbpedia_simple.owl";
+        
+        public static final String bioModels_tbox = onto_dir + "biomodels/biomodels-21.owl"; 
+        public static final String bioModels_abox = onto_dir + "biomodels/data_processed_1.ttl"; 
+        public static final String bioModels_queries = onto_dir + "biomodels/queries/queries.sparql";
+        
+        public static final String chembl_tbox = onto_dir + "bio2rdf/chembl/cco-processed-noDPR-noDPD.ttl";  
+        public static final String chembl_abox = onto_dir + "bio2rdf/chembl/graph sampling old/sample_100.nt";
+        public static final String chembl_queries = onto_dir + "bio2rdf/chembl/queries/problematic.sparql"; //"bio2rdf/chembl/queries/atomic_one_filtered.sparql"; // 
+
+        public static final String reactome_tbox = onto_dir + "bio2rdf/reactome/biopax-level3-processed.owl";  
+        public static final String reactome_abox = onto_dir + "bio2rdf/reactome/graph sampling old/sample.ttl"; //data/data.ttl"; //graph sampling old/reactome_sample_10.ttl"; //
+        public static final String reactome_queries = onto_dir +"bio2rdf/reactome/queries/atomic.sparql";
+
+        public static final String uniprot_tbox = onto_dir + "bio2rdf/uniprot/core-processed.owl"; 
+        public static final String uniprot_abox = onto_dir + "bio2rdf/uniprot/graph sampling/sample_1.nt"; 
+        public static final String uniprot_queries = onto_dir + "bio2rdf/uniprot/queries/atomic_one.sparql"; 
+        
+        public static final String atlas_tbox = onto_dir + "bio2rdf/atlas/gxaterms.owl"; 
+        public static final String atlas_abox = onto_dir + "bio2rdf/atlas/graph sampling/sample_1.nt"; 
+        public static final String atlas_queries = onto_dir + "bio2rdf/atlas/queries/atomic_one.sparql"; 
+        
+        public static boolean ShellMode = false; 
+        
+        public static void main(String... args) {
+                if (args.length == 0) {
+//                      args = new String[] {test_tbox, test_abox, test_query};
+//                      args = new String[] {lubm_tbox, lubm_abox, lubm_query.replace(".sparql", "_all_pagoda.sparql")}; 
+//                      args = new String[] {uobm_tbox, uobm_abox, uobm_query.replace(".sparql", "_all_pagoda.sparql")};
+//                      args = new String[] {fly, "null", fly_query.replace(".sparql", "_pellet.sparql") };
+//                      args = new String[] {dbpedia_tbox, dbpedia_abox, dbpedia_query};
+//                      args = new String[] {travel_tbox, null, dbpedia_query274};
+//                      args = new String[] {fly, null, fly_query};
+//                      args = new String[] {npd_tbox, npd_abox, npd_query};
+//                      args = new String[] {npd_bench_tbox, npd_bench_abox, npd_bench_query};
+//                      args = new String[] {"../SemFacet/WebContent/WEB-INF/data/dbpedia.owl", "../SemFacet/WebContent/WEB-INF/data/dbpediaA.nt", null}; 
+//                      args = new String[] {"../SemFacet/WebContent/WEB-INF/data/isg.owl", "../SemFacet/WebContent/WEB-INF/data/isg.nt", null}; 
+                        args = new String[] {"..\\core\\WebContent\\WEB-INF\\data\\fly.owl", "..\\core\\WebContent\\WEB-INF\\data\\fly-data.nt", null}; 
+//                      args = new String[] {bioModels_tbox, bioModels_abox, bioModels_queries}; 
+//                      args = new String[] {chembl_tbox, chembl_abox, chembl_queries};
+//                      args = new String[] {reactome_tbox, reactome_abox, reactome_queries};
+//                      args = new String[] {reactome_tbox, "/users/yzhou/temp/reactome_debug.ttl", onto_dir +"bio2rdf/reactome/queries/atomic_one_q65.sparql"};
+//                      args = new String[] {uniprot_tbox.replace(".owl", "-noDis.owl"), "/users/yzhou/temp/uniprot_debug/sample_1_string.nt", uniprot_queries};
+//                      args = new String[] {uniprot_tbox.replace(".owl", "-noDis.owl"), uniprot_abox, uniprot_queries};
+//                      args = new String[] {atlas_tbox, atlas_abox, atlas_queries};
+//                      args = new String[] {onto_dir + "test/unsatisfiable.owl", null, onto_dir + "test/unsatisfiable_queries.sparql"}; 
+//                      args = new String[] {onto_dir + "test/jair-example.owl", null, onto_dir + "test/jair-example_query.sparql"}; 
+//                      args[2] = args[2].replace(".sparql", "_all_pagoda.sparql");
+//                      args[2] = args[2].replace(".sparql", "_pellet.sparql");
+                }
+
+                int ontoIndex = 0, dataIndex = 1, queryIndex = 2;
+
+                if (args.length > dataIndex && args[dataIndex] != null && args[dataIndex].endsWith(".sparql")) {
+                        String[] inputArgs = args;
+                        args = new String[inputArgs.length + 1];
+                        for (int i = 0; i < dataIndex; ++i)
+                                args[i] = inputArgs[i];
+                        args[dataIndex] = null;
+                        args[queryIndex] = inputArgs[dataIndex];
+                        for (int i = dataIndex + 1; i < inputArgs.length; ++i)
+                                args[i + 1] = inputArgs[i]; 
+                }
+
+                StringBuilder info = new StringBuilder(); 
+                info.append("System started with \n");
+                for (int i = 0; i < args.length; ++i)
+                        info.append("Arg " + (i + 1) + ": " + args[i] + "\n"); 
+                Utility.logInfo(info);
+
+//              Utility.redirectCurrentOut("temp.out");
+
+                OWLOntology ontology = OWLHelper.loadOntology(args[ontoIndex]);
+                
+                QueryReasoner pagoda = QueryReasoner.getInstance(Type.Full, ontology, true, true); 
+//              QueryReasoner pagoda = QueryReasoner.getInstance(Type.ELHOU, ontology, true, true);
+                
+//              QueryReasoner pagoda = QueryReasoner.getInstanceForSemFacet(ontology);
+//              QueryReasoner pagoda = QueryReasoner.getHermiTReasoner(false); 
+                
+//              PagodaTester tester = new PagodaTester(pagoda);
+                String ansFile = args.length > 3 ? args[3] : null; 
+                try {
+                        Timer t = new Timer();
+                        pagoda.loadOntology(ontology);
+                        pagoda.importData(args[dataIndex]);
+                        if (!pagoda.preprocess())
+                                return;
+                        Utility.logInfo("Preprocessing Done in " + t.duration() + " seconds.");
+//                      tester.printPredicatesWithGap(); 
+//                      tester.testSemFacetQueries();
+//                      tester.testSomeFlyQueries();
+//                      tester.testISGQueries();
+//                      tester.testReactomeQueries(); 
+                        if (args[queryIndex] != null)
+                                for (String queryFile: args[queryIndex].split(";"))
+                                        pagoda.evaluate(pagoda.getQueryManager().collectQueryRecords(queryFile), ansFile);
+
+                        if (ShellMode)
+                                try {
+                                        evaluateConsoleQuery(pagoda);
+                                } catch (IOException e) {
+                                        e.printStackTrace();
+                                } 
+                } finally {
+                        pagoda.dispose();
+                }
+
+                Utility.closeCurrentOut();
+                
+                if (ShellMode) System.exit(0);
+        }
+        
+//      private void printPredicatesWithGap() {
+//              for (String p: ((MyQueryReasoner) pagoda).getPredicatesWithGap()) {
+//                      System.out.println(p); 
+//              }
+//      }
+
+        private static void evaluateConsoleQuery(QueryReasoner pagoda) throws IOException {
+                int ending = (int) '$', symbol;
+                while (true) {
+                        Utility.logInfo("Input your query ending with $"); 
+                        StringBuilder queryBuilder = new StringBuilder(); 
+                        while ((symbol = System.in.read()) != ending) {
+                                queryBuilder.append((char) symbol); 
+                        }
+                        System.in.read(); 
+                        if (queryBuilder.length() == 0) return ; 
+                        pagoda.evaluate_shell(queryBuilder.toString());
+                }
+        }
+
+        void testReactomeQueries() {
+                evaluate("select ?x where { ?x <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.biopax.org/release/biopax-level3.owl#DnaReference> . }");
+                evaluate("select ?y ?z where { <http://identifiers.org/ensembl/ENSG00000157557> ?y ?z . }");
+                evaluate("select ?y where { <http://identifiers.org/ensembl/ENSG00000157557> <http://www.biopax.org/release/biopax-level3.owl#name> ?y . }", true);  
+
+        }
+
+        void testSemFacetQueries() {
+//              try {
+//                      BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("query.line")));
+//                      for (String line; (line = reader.readLine()) != null && !line.isEmpty(); ) 
+//                              evaluate(line, true);
+//                      reader.close();
+//              } catch (FileNotFoundException e) {
+//                      e.printStackTrace();
+//              } catch (IOException e) {
+//                      e.printStackTrace();
+//              }
+                evaluate("select ?x ?z where { ?x <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> ?z }", true);
+                evaluate("select distinct ?y where { ?x ?y ?z }", true);
+                evaluate("select distinct ?z where { ?x <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> ?z }", true);
+                evaluate("select ?y ?z where { <http://www.reactome.org/biopax/46/49633#Protein3885> ?y ?z .}", true); 
+        }
+        
+        void testISGQueries() {
+                evaluate("select ?z where {<http://cs.ox.ac.uk/Evgeny_Kharlamov> <http://cs.ox.ac.uk/lat> ?z .}", false);
+                evaluate("select ?x where {?x <http://cs.ox.ac.uk/type> <http://cs.ox.ac.uk/person> .}", false);
+        }
+
+        void testSomeTravelQueries() {
+                evaluate("select ?y ?z where {<http://www.owl-ontologies.com/travel.owl#BlueMountains> ?y ?z. }", true); 
+                evaluate("select ?x where {?x <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.owl-ontologies.com/travel.owl#RetireeDestination>. }"); 
+                evaluate("select ?x where {?x <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.owl-ontologies.com/travel.owl#BackpackersDestination>. }");
+        }
+
+        void testSomeFlyQueries() {
+                evaluate("select ?x where { ?x <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://purl.obolibrary.org/obo/FBbt_00005106> . }", false);
+                
+                evaluate("select DISTINCT ?z where { ?x <http://purl.obolibrary.org/obo/FBbt#develops_from> ?any . ?any <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> ?z .  ?x <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://purl.obolibrary.org/obo/FBbt_00067123> . } ", true); 
+                
+                evaluate("Select ?x where { ?x <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> "
+                                + "<http://purl.obolibrary.org/obo/FBbt_00067123>. ?x "
+                                + "<http://purl.obolibrary.org/obo/RO_0002131> ?any . ?any "
+                                + "<http://www.w3.org/1999/02/22-rdf-syntax-ns#type> "
+                                + "<http://purl.obolibrary.org/obo/FBbt_00005140> . }", true);
+                
+                evaluate("Select ?x where {?x <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> "
+                                + "<http://purl.obolibrary.org/obo/FBbt_00067363> . ?x "
+                                + "<http://purl.obolibrary.org/obo/RO_0002131> ?any . ?any "
+                                + "<http://www.w3.org/1999/02/22-rdf-syntax-ns#type> "
+                                + "<http://purl.obolibrary.org/obo/FBbt_00005140> . }", true);
+
+//              evaluate("Select ?x where { "
+//                              + "?x <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://purl.obolibrary.org/obo/FBbt_00003660>. "
+//                              + "?x <http://purl.obolibrary.org/obo/FBbt#develops_from> ?any . "
+//                              + "?any <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://purl.obolibrary.org/obo/FBbt_00001446> . }", true);
+
+                evaluate("select DISTINCT ?z where { ?x <http://purl.obolibrary.org/obo/RO_0002110> ?any . "
+                                + "?any <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> ?z . "
+                                + "?x <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://purl.obolibrary.org/obo/FBbt_00007016>  . } ", true);
+
+                evaluate("Select * where {"
+                                + "<http://www.virtualflybrain.org/ontologies/individuals/VFB_00100607> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://purl.obolibrary.org/obo/FBbt_00007364>. "
+                                + "<http://www.virtualflybrain.org/ontologies/individuals/VFB_00100607> <http://www.w3.org/2002/07/owl#sameAs> ?z }", true);
+
+                evaluate("SELECT DISTINCT ?x ?z WHERE {?x <http://www.w3.org/2002/07/owl#sameAs> ?z}", true);
+                evaluate("SELECT DISTINCT ?x ?z WHERE {?x <http://purl.obolibrary.org/obo/BFO_0000051> ?z}", true);
+
+                evaluate("select DISTINCT ?y where { ?x ?y ?z . "
+                                + "?x <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://purl.obolibrary.org/obo/FBbt_00007364>  }", true);
+
+                evaluateQueriesFromFile("/users/yzhou/Downloads/logs(1).log");
+                evaluateQueriesFromFile("/users/yzhou/Downloads/logs.log");
+
+                evaluate("SELECT DISTINCT ?x ?z WHERE {?x <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> ?z}", true);
+                evaluate("SELECT DISTINCT ?x ?z WHERE {?x <http://xmlns.com/foaf/0.1/depicts> ?z}", true);
+
+                evaluate("select ?x ?z where { ?x <http://www.w3.org/2002/07/owl#sameAs> ?z } ", true);
+                evaluate("select ?x ?z where { ?x <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> ?z } ", true);
+        }
+
+        public void evaluateQueriesFromFile(String fileName) {
+                Scanner scanner = null;
+                try {
+                        scanner = new Scanner(new File(fileName));
+                        String line;
+                        while (scanner.hasNextLine()) {
+                                line = scanner.nextLine();
+                                if (line.startsWith("select"))
+                                        evaluate(line, true);
+                        }
+                } catch (FileNotFoundException e) {
+                        e.printStackTrace();
+                } finally {
+                        if (scanner != null)
+                                scanner.close();
+                }
+        }
+
+        QueryReasoner pagoda;
+
+        public PagodaTester(QueryReasoner reasoner) {
+                pagoda = reasoner;
+        }
+
+        Timer timer = new Timer(); 
+        
+        private void evaluate(String query) {
+                evaluate(query, false); 
+        }
+        
+        private void evaluate(String query, boolean tag) {
+                timer.reset(); 
+                AnswerTuples tuples = pagoda.evaluate(query, tag);
+                int arity = tuples.getArity(); 
+                int count = 0; 
+                for (AnswerTuple tuple; tuples.isValid(); tuples.moveNext()) {
+                        tuple = tuples.getTuple();
+                        for (int i = 0; i < arity; ++i)
+                                tuple.getGroundTerm(i).toString();
+//                              System.out.print(tuple.getGroundTerm(i).toString() + "\t");
+//                      System.out.println();
+                        ++count; 
+                }
+                tuples.dispose();
+                Utility.logInfo("The number of answers for this SemFacet query: " +  count);
+                Utility.logInfo("Total time for this SemFacet query: " + timer.duration());
+        }
+
+}
diff --git a/test/uk/ac/ox/cs/pagoda/tester/Statistics.java b/test/uk/ac/ox/cs/pagoda/tester/Statistics.java
new file mode 100644
index 0000000..71f1726
--- /dev/null
+++ b/test/uk/ac/ox/cs/pagoda/tester/Statistics.java
@@ -0,0 +1,59 @@
+package uk.ac.ox.cs.pagoda.tester;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.Scanner;
+
+public class Statistics {
+        
+        double satCheckTime; 
+        double preprocessTime;
+        LinkedList<Integer> number = new LinkedList<Integer>(); 
+        LinkedList<Double> time = new LinkedList<Double>(); 
+        
+        public Statistics(String file) {
+                Scanner scanner = null; 
+                try {
+                        scanner = new Scanner(new File(file));
+                        for (String line; scanner.hasNextLine(); ) {
+                                line = scanner.nextLine(); 
+                                if (line.contains("time for satisfiability checking"))
+                                        satCheckTime = Double.parseDouble(line.substring(line.indexOf(": ") + 2));
+                                else if (line.contains("Preprocessing Done in"))
+                                        preprocessTime = Double.parseDouble(line.substring(line.indexOf("in ") + 3, line.indexOf(" second")));
+                                else if (line.contains("The number of answer tuples:"))
+                                        number.add(Integer.parseInt(line.substring(line.indexOf(": ") + 2))); 
+                                else if (line.contains("Total time to answer this query:")) 
+                                        time.add(Double.parseDouble(line.substring(line.indexOf(": ") + 2))); 
+                        }
+                } catch (FileNotFoundException e) {
+                        e.printStackTrace();
+                } finally {
+                        if (scanner != null)
+                                scanner.close();
+                }
+        }
+        
+        public String diff(String other) {
+                return diff(new Statistics(other)); 
+        }
+        
+        public String diff(Statistics other) {
+                if (other.number.size() != number.size()) 
+                        return "The number of query is different! " + this.number.size() + " v.s. " + other.number.size();  
+                int i = 0; 
+                Iterator<Integer> iter1 = number.iterator(), iter2 = other.number.iterator();
+                StringBuilder diff = new StringBuilder(); 
+                int a, b; 
+                while (iter1.hasNext()) {
+                        ++i; 
+                        if ((a = iter1.next()) != (b = iter2.next())) {
+                                diff.append("Query ").append(i).append(": ").append(a).append(", reference ").append(b).append("\n"); 
+                        }
+                }
+                return diff.toString(); 
+        }
+        
+}