974 lines
41 KiB
Java
974 lines
41 KiB
Java
//This file is part of SECONDO.
|
|
|
|
//Copyright (C) 2004, University in Hagen, Department of Computer Science,
|
|
//Database Systems for New Applications.
|
|
|
|
//SECONDO is free software; you can redistribute it and/or modify
|
|
//it under the terms of the GNU General Public License as published by
|
|
//the Free Software Foundation; either version 2 of the License, or
|
|
//(at your option) any later version.
|
|
|
|
//SECONDO is distributed in the hope that it will be useful,
|
|
//but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
//GNU General Public License for more details.
|
|
|
|
//You should have received a copy of the GNU General Public License
|
|
//along with SECONDO; if not, write to the Free Software
|
|
//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
import java.io.*;
|
|
import java.net.*;
|
|
import java.util.*;
|
|
|
|
import jpl.JPL;
|
|
import jpl.Atom;
|
|
import jpl.Query;
|
|
import jpl.Term;
|
|
import jpl.Variable;
|
|
import jpl.fli.*;
|
|
import jpl.Compound;
|
|
import jpl.Util;
|
|
import java.nio.charset.Charset;
|
|
import java.util.SortedMap;
|
|
|
|
public class OptTest {
|
|
|
|
static {
|
|
System.loadLibrary("jpl");
|
|
System.loadLibrary("regOptTest");
|
|
}
|
|
|
|
public static native int registerSecondo();
|
|
|
|
private String openedDatabase = "";
|
|
private String OS_pl_encoding = null;
|
|
|
|
static final int UNDEFINED = 0;
|
|
static final int SETUP = 1;
|
|
static final int TESTCASE = 2;
|
|
static final int TEARDOWN = 3;
|
|
|
|
// multiline commands
|
|
static final int APPENDTOCOMMAND = 4;
|
|
|
|
// special states for testcases
|
|
static final int AWAITINGYIELD = 1;
|
|
static final int AWAITINGCOMMAND = 2;
|
|
|
|
static final int NEXTCOMMAND = 5;
|
|
|
|
// flags for result comparison
|
|
static final int NOCOMPARE = 2;
|
|
static final int STRINGCOMPARE = 3;
|
|
static final int SQLRESULTCOMPARE = 4;
|
|
static final int OPTCOMPARE = 5;
|
|
|
|
String resultfilename = "result.log";
|
|
String auxiliarydest = "../../Optimizer/auxiliary";
|
|
String calloptimizerdest = "../../Optimizer/calloptimizer";
|
|
|
|
// globale Variables to have mutliple returnvalues
|
|
String Solution = "";
|
|
Hashtable[] solutions;
|
|
String summary = "\n\nThe result of the testfile : ";
|
|
|
|
/*
|
|
~parseTestfile~ takes a filename String which should be a testfile. It is opened
|
|
and processes it line
|
|
by line.
|
|
|
|
*/
|
|
|
|
private boolean parseTestfile(String testfilename) {
|
|
summary += testfilename;
|
|
summary += "\nThe following checks failed : \n";
|
|
String testresults = "";
|
|
String yield = "";
|
|
String testfile = readTestfile(testfilename);
|
|
if (testfile.isEmpty()) {
|
|
System.out
|
|
.println("Error : Testfile " + testfilename + " is empty");
|
|
return false;
|
|
}
|
|
|
|
// split does remove emptylines
|
|
String linebuffer[] = testfile.split("[\\r\\n]+");
|
|
int numberoflines = linebuffer.length;
|
|
|
|
System.out.println("Parsing " + numberoflines + " lines");
|
|
int state = UNDEFINED;
|
|
int testcasestate = UNDEFINED;
|
|
int setupstate = UNDEFINED;
|
|
String currentline = "";
|
|
String optcommand = "";
|
|
String testcasename = "";
|
|
int yieldflag = 0;
|
|
|
|
for (int lineno = 0; lineno < numberoflines; lineno++) {
|
|
currentline = linebuffer[lineno];
|
|
// filter out comments
|
|
if (currentline.startsWith("# ") || currentline.equals("#")
|
|
|| currentline.trim().isEmpty()) {
|
|
// System.out.println("ignoring Comment");
|
|
} else {
|
|
switch (state) {
|
|
case UNDEFINED:
|
|
if (currentline.startsWith("#setup")) {
|
|
state = SETUP;
|
|
if (currentline.trim().length() > 6) {
|
|
String testfilecomment = currentline.substring(6);
|
|
if (testfilecomment.length() > 0) {
|
|
System.out.println("Testfile name : "
|
|
+ testfilename);
|
|
System.out.println("Testfile description : "
|
|
+ testfilecomment.trim().substring(
|
|
testfilecomment.indexOf(" ")));
|
|
}
|
|
}
|
|
} else {
|
|
System.out
|
|
.println("Error: Expected #setup directive here");
|
|
return false;
|
|
}
|
|
break;
|
|
case SETUP:
|
|
if (currentline.startsWith("#testcase")) {
|
|
//System.out.println("INFO : changing state to TESTCASE");
|
|
state = TESTCASE;
|
|
testcasestate = AWAITINGYIELD;
|
|
System.out.println("Testcasename : "
|
|
+ currentline.trim().substring(
|
|
currentline.indexOf(" ")));
|
|
testcasename = currentline.substring(currentline
|
|
.indexOf(" "));
|
|
} else {
|
|
if (currentline.startsWith("#setup")) {
|
|
System.out
|
|
.println("Error : Already in SETUP state in line : "
|
|
+ (lineno + 1));
|
|
return false;
|
|
}
|
|
if (currentline.startsWith("#teardown")) {
|
|
System.out
|
|
.println("Error : Testfile changing from SETUP state to TEARDOWN is useless in line :"
|
|
+ (lineno + 1) + ".");
|
|
return false;
|
|
}
|
|
switch (setupstate) {
|
|
case UNDEFINED:
|
|
if (currentline.endsWith(";")) {
|
|
optcommand += currentline.substring(0,
|
|
currentline.length() - 1);
|
|
if (!execute(optcommand)) {
|
|
System.out
|
|
.println("Error: setup failed while executing :\n"
|
|
+ optcommand);
|
|
return false;
|
|
}
|
|
// reset optcommand
|
|
optcommand = "";
|
|
} else {
|
|
optcommand += currentline + " ";
|
|
//System.out.println("INFO : changing state to APPENDTOCOMMAND");
|
|
setupstate = APPENDTOCOMMAND;
|
|
}
|
|
break;
|
|
case APPENDTOCOMMAND:
|
|
if (currentline.endsWith(";")) {
|
|
optcommand += currentline;
|
|
if (!execute(optcommand)) {
|
|
System.out
|
|
.println("Error: setup failed while executing :\n"
|
|
+ optcommand);
|
|
return false;
|
|
}
|
|
optcommand = "";
|
|
break;
|
|
} else {
|
|
optcommand += currentline + " ";
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case TESTCASE:
|
|
/*
|
|
* example testcase:
|
|
* #testcase <testcasename>
|
|
* #yields <compareflag> <answer>|@filename
|
|
* <optimizer command>
|
|
*/
|
|
|
|
// catch statechange errors first
|
|
if (currentline.startsWith("#setup")) {
|
|
System.out
|
|
.println("Error : Testfile changing from TESTCASE state to SETUP which is not allowed in line : "
|
|
+ (lineno + 1) + ".");
|
|
return false;
|
|
}
|
|
// again statebased
|
|
switch (testcasestate) {
|
|
case UNDEFINED:
|
|
System.out
|
|
.println("Error : testcasestate cannot be undefined in line "
|
|
+ (lineno + 1) + ".");
|
|
return false;
|
|
case AWAITINGYIELD:
|
|
if (currentline.startsWith("#yields")) {
|
|
if (currentline.trim().length() > 7) {
|
|
// gets yieldflag
|
|
yield = currentline.substring(7).trim();
|
|
if (yield.indexOf(" ") != -1) {
|
|
yieldflag = Integer.parseInt(yield
|
|
.substring(0, yield.indexOf(" ")));
|
|
yield = yield.substring(yield.indexOf(" "),
|
|
yield.length()).trim();
|
|
// if there is yield make checks else pass
|
|
if (yield.length() > 0) {
|
|
if (yield.startsWith("@")) {
|
|
String yieldfilename = yield
|
|
.substring(1);
|
|
System.out.println("Reading file "
|
|
+ yieldfilename);
|
|
yield = readTestfile(yieldfilename);
|
|
}
|
|
}
|
|
} else {
|
|
yieldflag = STRINGCOMPARE;
|
|
}
|
|
|
|
} else {
|
|
yieldflag = NOCOMPARE;
|
|
yield = "";
|
|
}
|
|
//System.out.println("INFO : changing teststate to AWAITINGCOMMAND");
|
|
testcasestate = AWAITINGCOMMAND;
|
|
} else {
|
|
System.out
|
|
.println("Error : Missing #yields directive in line : "
|
|
+ (lineno + 1) + ".");
|
|
return false;
|
|
}
|
|
break;
|
|
case AWAITINGCOMMAND:
|
|
if (currentline.startsWith("#")) {
|
|
System.out
|
|
.println("Error : Directives not allowed, awaiting optimizer command: "
|
|
+ yield
|
|
+ " in line :"
|
|
+ (lineno + 1) + ".");
|
|
}
|
|
if (currentline.endsWith(";")) {
|
|
optcommand += currentline.substring(0,
|
|
currentline.length() - 1);
|
|
if (!executeTest(optcommand, yield, yieldflag)) {
|
|
System.out
|
|
.println("Error: Testcasecommand failed while executing :\n"
|
|
+ optcommand);
|
|
return false;
|
|
}
|
|
optcommand = "";
|
|
//System.out.println("INFO : changing teststate to NEXTCOMMAND");
|
|
testcasestate = NEXTCOMMAND;
|
|
} else {
|
|
optcommand = currentline + " ";
|
|
//System.out.println("INFO : changing teststate to APPENDTOCOMMAND");
|
|
testcasestate = APPENDTOCOMMAND;
|
|
}
|
|
break;
|
|
case APPENDTOCOMMAND:
|
|
if (currentline.startsWith("#")) {
|
|
System.out
|
|
.println("Error : Directives or comments are not allowed, was awaiting something to append to "
|
|
+ optcommand
|
|
+ " in line :"
|
|
+ (lineno + 1) + ".");
|
|
}
|
|
if (currentline.endsWith(";")) {
|
|
optcommand += currentline.substring(0,
|
|
currentline.length() - 1);
|
|
if (!executeTest(optcommand, yield, yieldflag)) {
|
|
System.out
|
|
.println("Error: Testcasecommand failed while executing :\n"
|
|
+ optcommand);
|
|
return false;
|
|
}
|
|
optcommand = "";
|
|
//System.out.println("INFO : changing teststate to NEXTCOMMAND");
|
|
testcasestate = NEXTCOMMAND;
|
|
} else {
|
|
optcommand += currentline + " ";
|
|
//System.out.println("INFO : changing teststate to APPENDTOCOMMAND");
|
|
testcasestate = APPENDTOCOMMAND;
|
|
}
|
|
|
|
break;
|
|
case NEXTCOMMAND:
|
|
optcommand = "";
|
|
if (currentline.startsWith("#testcase")) {
|
|
testcasename = currentline.substring(currentline
|
|
.indexOf(" "));
|
|
//System.out.println("Info : Changing state to TESTCASE.");
|
|
testcasestate = AWAITINGYIELD;
|
|
System.out.println();
|
|
System.out.println("Testcasename : "
|
|
+ currentline.trim().substring(
|
|
currentline.indexOf(" ")));
|
|
} else {
|
|
if (currentline.startsWith("#setup")) {
|
|
System.out
|
|
.println("Error : Already in SETUP state in line : "
|
|
+ (lineno + 1));
|
|
return false;
|
|
}
|
|
if (currentline.startsWith("#teardown")) {
|
|
//System.out.println("INFO : changing state to TEARDOWN");
|
|
state = TEARDOWN;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
case TEARDOWN:
|
|
if (currentline.startsWith("#setup")) {
|
|
System.out
|
|
.println("Error : Testfile changing from TEARDOWN state to SETUP which is not allowed in line : "
|
|
+ lineno + ".");
|
|
return false;
|
|
}
|
|
if (currentline.startsWith("#testcase")) {
|
|
System.out
|
|
.println("Error : Testfile changing from TEARDOWN state to TESTCASE which is not allowed in line : "
|
|
+ lineno + ".");
|
|
return false;
|
|
}
|
|
if (currentline.endsWith(";")) {
|
|
optcommand += currentline.substring(0,
|
|
currentline.length() - 1);
|
|
if (!execute(optcommand)) {
|
|
System.out
|
|
.println("Error: setup failed while executing :\n"
|
|
+ optcommand);
|
|
return false;
|
|
}
|
|
optcommand = "";
|
|
} else {
|
|
optcommand += currentline + " ";
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
System.out.println(summary);
|
|
if (state == TESTCASE || state == TEARDOWN)
|
|
return true;
|
|
else {
|
|
switch (state) {
|
|
case SETUP:
|
|
System.out
|
|
.println("testfile execution ended in illegal state SETUP");
|
|
return false;
|
|
case UNDEFINED:
|
|
System.out
|
|
.println("testfile execution ended in illegal state UNDEFINED");
|
|
return false;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
* yield from testfile or @resultfile
|
|
*
|
|
*/
|
|
private boolean executeTest(String optcommand, String yield, int flag) {
|
|
String result = "";
|
|
if (execute(optcommand)) {
|
|
if (solutions.length >= 0) {
|
|
for (int i = 0; i < solutions.length; i++) {
|
|
Hashtable sol = solutions[i];
|
|
if (sol.size() <= 0) {
|
|
} else {
|
|
Enumeration vars = solutions[i].keys();
|
|
int varnum = 0;
|
|
while (vars.hasMoreElements()) {
|
|
Object v = vars.nextElement();
|
|
result += (v + " = " + solutions[i].get(v));
|
|
}
|
|
result += "\n";
|
|
}
|
|
}
|
|
// if solution is "" then compare to Solution
|
|
if (result.equals("")) {
|
|
//System.out.println("SOLUTION WRITE OUTPUT:" + Solution);
|
|
if (!compareResult(Solution, yield, flag)) {
|
|
summary += "Results from " + optcommand
|
|
+ " did not match!!!\n";
|
|
}
|
|
} else {
|
|
//System.out.println("SOLUTION UNIFIED VARS:" + result);
|
|
if (!compareResult(result, yield, flag)) {
|
|
summary += "Results from " + optcommand
|
|
+ " did not match!!!\n";
|
|
}
|
|
}
|
|
} else {
|
|
// compare to false
|
|
if (compareResult("false", yield, flag)) {
|
|
summary += "Results from " + optcommand
|
|
+ " did not match!!!\n";
|
|
}
|
|
return true;
|
|
}
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private String readTestfile(String filename) {
|
|
String line;
|
|
try {
|
|
// Open the file that is the first
|
|
// command line parameter
|
|
FileInputStream fstream = new FileInputStream(filename);
|
|
DataInputStream in = new DataInputStream(fstream);
|
|
BufferedReader br = new BufferedReader(new InputStreamReader(in));
|
|
|
|
// read file
|
|
String file = "";
|
|
while ((line = br.readLine()) != null) {
|
|
// Print the content on the console
|
|
// System.out.println(line);
|
|
file += line + "\n";
|
|
}
|
|
// close file
|
|
in.close();
|
|
// parsing the input as a whole takes place in a separate method
|
|
return file;
|
|
} catch (Exception e) {
|
|
System.out.println("could not open or read testfile : " + filename);
|
|
e.printStackTrace();
|
|
return "";
|
|
}
|
|
}
|
|
|
|
private boolean compareResult(String result, String yield, int flag) {
|
|
/*
|
|
System.out.println("CompareResult flag : " + flag);
|
|
System.out.println("___________________________________________");
|
|
System.out.println("Comparing result:\n" + result);
|
|
System.out.println("___________________________________________");
|
|
System.out.println("Comparing yield:\n" + yield);
|
|
System.out.println("++++++++++++++++++++++++++++++++++++++++++++");
|
|
*/
|
|
|
|
//force default heavior if none was set
|
|
if (flag == UNDEFINED) {
|
|
flag = STRINGCOMPARE;
|
|
}
|
|
switch (flag) {
|
|
case NOCOMPARE:
|
|
return true;
|
|
// compare incoming results char by char
|
|
case STRINGCOMPARE:
|
|
if (result.trim().contentEquals(yield.trim())) {
|
|
System.out.println("Info : results do match");
|
|
return true;
|
|
} else {
|
|
summary += "\n-------------- result : ---------------------\n";
|
|
summary += result;
|
|
summary += "\n-------------- given yield : ---------------------\n";
|
|
summary += yield;
|
|
System.out.println("Error : results do NOT match");
|
|
return false;
|
|
}
|
|
/* in SQLRESULTCOMPARE yield is compared starting from
|
|
"Command succeeded, result:"*/
|
|
case SQLRESULTCOMPARE:
|
|
if (result.length() > 0 && yield.length() > 0) {
|
|
if (result.indexOf("Command succeeded, result:") != -1) {
|
|
result = result.trim().substring(
|
|
result.indexOf("Command succeeded, result:"));
|
|
}
|
|
if (yield.indexOf("Command succeeded, result:") != -1) {
|
|
yield = yield.trim().substring(
|
|
yield.indexOf("Command succeeded, result:"));
|
|
}
|
|
if (result.trim().contentEquals(yield.trim())) {
|
|
System.out.println("Info : results do match");
|
|
return true;
|
|
} else {
|
|
System.out.println("Error : results do NOT match");
|
|
summary += "\n-------------- result : ---------------------\n";
|
|
summary += result;
|
|
summary += "\n-------------- given yield : ---------------------\n";
|
|
summary += yield;
|
|
return false;
|
|
}
|
|
} else {
|
|
System.out.println("Error : results do NOT match");
|
|
return false;
|
|
}
|
|
|
|
// in OPTCOMPARE all the selectivities are being removed
|
|
case OPTCOMPARE:
|
|
String pattern = "\\{.*\\}";
|
|
result = result.replaceAll(pattern, "");
|
|
yield = result.replaceAll(pattern, "");
|
|
if (result.trim().contentEquals(yield.trim())) {
|
|
System.out.println("Info : results do match");
|
|
return true;
|
|
} else {
|
|
System.out.println("Error : results do NOT match");
|
|
summary += "\n-------------- result : ---------------------\n";
|
|
summary += result;
|
|
summary += "\n-------------- given yield : ---------------------\n";
|
|
summary += yield;
|
|
summary += "\n-----------------------------------------------------------\n";
|
|
return false;
|
|
}
|
|
}
|
|
System.out.print("Error check failed somehow");
|
|
return false;
|
|
}
|
|
|
|
private boolean createTestfile(String filename) {
|
|
String commandlist = readTestfile(filename);
|
|
if (commandlist.isEmpty()) {
|
|
System.out.println("Error : Testfile " + commandlist + " is empty");
|
|
return false;
|
|
}
|
|
// split does remove emptylines
|
|
String linebuffer[] = commandlist.split("[\\r\\n]+");
|
|
int numberoflines = linebuffer.length;
|
|
String currentline = "";
|
|
int state = SETUP;
|
|
|
|
System.out.println("analyzing " + numberoflines + " lines from "
|
|
+ filename);
|
|
|
|
String resultfile = "";
|
|
String testname = "";
|
|
if (filename.indexOf(".") != -1) {
|
|
testname = filename.substring(0, filename.indexOf("."));
|
|
} else {
|
|
testname = filename;
|
|
}
|
|
String testfile = "# This is a by OptTest automatically generated testfile.\n"
|
|
+ "# It was generated from file: "
|
|
+ filename
|
|
+ "\n"
|
|
+ "#setup " + testname + "\n";
|
|
|
|
int testno = 0;
|
|
String optcommand = "";
|
|
String description = "";
|
|
for (int lineno = 0; lineno < numberoflines; lineno++) {
|
|
currentline = linebuffer[lineno];
|
|
if (currentline.startsWith("# ") || currentline.equals("#")
|
|
|| currentline.trim().isEmpty()) {
|
|
// System.out.println("ignoring Comment");
|
|
} else {
|
|
switch (state) {
|
|
case SETUP:
|
|
if (currentline.trim().startsWith("#testcase")) {
|
|
state = TESTCASE;
|
|
//System.out.println("changing state to TESTCASE");
|
|
} else {
|
|
if (currentline.endsWith(";")) {
|
|
optcommand += currentline.substring(0,
|
|
currentline.length() - 1);
|
|
if (execute(optcommand)) {
|
|
//DisplaySolutions();
|
|
testfile += optcommand + ";\n";
|
|
optcommand = "";
|
|
} else {
|
|
System.out
|
|
.println("Error : setup section failed due to error ");
|
|
return false;
|
|
}
|
|
} else {
|
|
optcommand += currentline + " ";
|
|
}
|
|
}
|
|
break;
|
|
case TESTCASE:
|
|
if (currentline.startsWith("#teardown")) {
|
|
testfile += "#teardown\n";
|
|
state = TEARDOWN;
|
|
} else {
|
|
if (currentline.endsWith(";")) {
|
|
optcommand += currentline.substring(0,
|
|
currentline.length() - 1)
|
|
+ "\n";
|
|
if (execute(optcommand)) {
|
|
resultfile = "";
|
|
testno++;
|
|
testfile += "#testcase No" + testno + " "
|
|
+ description + "\n";
|
|
|
|
String result = "";
|
|
if (solutions.length > 0) {
|
|
for (int i = 0; i < solutions.length; i++) {
|
|
Hashtable sol = solutions[i];
|
|
if (sol.size() <= 0) {
|
|
|
|
} else {
|
|
Enumeration vars = solutions[i]
|
|
.keys();
|
|
int varnum = 0;
|
|
while (vars.hasMoreElements()) {
|
|
Object v = vars.nextElement();
|
|
result += (v + " = " + solutions[i]
|
|
.get(v));
|
|
}
|
|
result += "\n";
|
|
}
|
|
|
|
}
|
|
if (result.equals("")) {
|
|
result = Solution;
|
|
} else {
|
|
System.out.println("solutions : "
|
|
+ result);
|
|
}
|
|
|
|
int comparemode = STRINGCOMPARE;
|
|
if (optcommand.trim().startsWith("sql select")) {
|
|
comparemode = SQLRESULTCOMPARE;
|
|
}
|
|
if (optcommand.trim()
|
|
.startsWith("optimize")) {
|
|
comparemode = OPTCOMPARE;
|
|
}
|
|
if (result.length() > 70) {
|
|
resultfile = result;
|
|
String rfilename = testname + "_No"
|
|
+ testno + ".result";
|
|
// testcase distinction
|
|
|
|
testfile += "#yields " + comparemode
|
|
+ " @" + rfilename + "\n";
|
|
try {
|
|
FileWriter rstream = new FileWriter(
|
|
rfilename);
|
|
BufferedWriter rout = new BufferedWriter(
|
|
rstream);
|
|
rout.write(resultfile);
|
|
//Close the output stream
|
|
rout.close();
|
|
} catch (IOException e) {
|
|
|
|
}
|
|
|
|
} else {
|
|
testfile += "#yields " + comparemode
|
|
+ " " + result;
|
|
}
|
|
|
|
} else {
|
|
testfile += "#yields false\n";
|
|
}
|
|
testfile += optcommand.substring(0,
|
|
optcommand.length() - 1)
|
|
+ ";\n\n";
|
|
optcommand = "";
|
|
description = "";
|
|
|
|
} else {
|
|
System.out
|
|
.println("Error : creating testfile failed while executing : "
|
|
+ optcommand);
|
|
return false;
|
|
}
|
|
|
|
} else {
|
|
if (currentline.startsWith("% ")
|
|
|| currentline.startsWith("# ")) {
|
|
testfile += "# "
|
|
+ currentline.substring(1).trim()
|
|
+ "\n";
|
|
} else {
|
|
optcommand += currentline + "\n";
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case TEARDOWN:
|
|
if (currentline.endsWith(";")) {
|
|
optcommand += currentline.substring(0,
|
|
currentline.length() - 1);
|
|
if (execute(optcommand)) {
|
|
//DisplaySolutions();
|
|
testfile += optcommand + ";\n";
|
|
optcommand = "";
|
|
} else {
|
|
System.out
|
|
.println("Error : setup section failed due to error ");
|
|
return false;
|
|
}
|
|
} else {
|
|
optcommand += currentline + " ";
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
try {
|
|
String tfilename = filename.substring(0, filename.indexOf("."))
|
|
+ ".test";
|
|
FileWriter tstream = new FileWriter(tfilename);
|
|
|
|
BufferedWriter tout = new BufferedWriter(tstream);
|
|
tout.write(testfile);
|
|
//Close the output stream
|
|
tout.close();
|
|
return true;
|
|
} catch (IOException e) {
|
|
System.out.println(e.getMessage());
|
|
return false;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* init prolog register the secondo predicate loads the optimizer prolog
|
|
* code
|
|
*/
|
|
private boolean initialize() {
|
|
// later here is to invoke the init function which
|
|
// registers the Secondo(command,Result) predicate to prolog
|
|
if (registerSecondo() != 0) {
|
|
System.err.println("error in registering the secondo predicate ");
|
|
return false;
|
|
}
|
|
// cout.println("registerSecondo successful");
|
|
try {
|
|
|
|
String[] plargs = { "-L256M", "-G256M" };
|
|
boolean ok = JPL.init(plargs);
|
|
|
|
// VTA - 18.09.2006
|
|
// I added this piece of code in order to run with newer versions
|
|
// of prolog. Without this code, the libraries (e.g. lists.pl) are
|
|
// not automatically loaded. It seems that something in our code
|
|
// (auxiliary.pl and calloptimizer.pl) prevents them to be
|
|
// automatically loaded. In order to solve this problem I added
|
|
// a call to 'member(x, [x]).' so that the libraries are loaded
|
|
// before running our scripts.
|
|
Term[] args = new Term[2];
|
|
args[0] = new Atom("x");
|
|
args[1] = jpl.Util.termArrayToList(new Term[] { new Atom("x") });
|
|
Query q = new Query("member", args);
|
|
if (!q.hasSolution()) {
|
|
System.out.println("error in the member call'");
|
|
return false;
|
|
}
|
|
|
|
args = new Term[1];
|
|
args[0] = new Atom(auxiliarydest);
|
|
q = new Query("consult", args);
|
|
if (!q.hasSolution()) {
|
|
System.out.println("error in loading 'auxiliary.pl'");
|
|
return false;
|
|
}
|
|
|
|
args = new Term[1];
|
|
args[0] = new Atom(calloptimizerdest);
|
|
q = new Query("consult", args);
|
|
if (!q.hasSolution()) {
|
|
System.out.println("error in loading 'calloptimizer.pl'");
|
|
return false;
|
|
}
|
|
|
|
q = new Query("set_prolog_flag(debug_on_error, false)");
|
|
if (!q.hasSolution()) {
|
|
System.out.println("error setting debug_on_error to false");
|
|
return false;
|
|
}
|
|
return true;
|
|
} catch (Exception e) {
|
|
System.out.println("Exception in initialization " + e);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* analyzed the given string and extract the command and the argumentlist <br>
|
|
* then the given command is executed all Solutions are stored into the
|
|
* Vector Solution
|
|
*/
|
|
private boolean execute(String command) {
|
|
if (Solution != "") {
|
|
Solution = "";
|
|
}
|
|
if (solutions != null) {
|
|
solutions = null;
|
|
}
|
|
command = command.trim();
|
|
System.out.println("Optimizer command: " + command);
|
|
command = "tell('" + resultfilename + "')," + command + ",told";
|
|
command = encode(command);
|
|
//System.out.println("Command to execute : " + command);
|
|
try {
|
|
Query pl_query = new Query(command);
|
|
if (pl_query == null) {
|
|
System.out.println("Error : error in parsing command: ");
|
|
return false;
|
|
}
|
|
solutions = pl_query.allSolutions();
|
|
/* debug */
|
|
//System.out.println("Number of solutions : " + solutions.length);
|
|
//System.out.println("");
|
|
/* end debug */
|
|
if (solutions.length > 0) {
|
|
Solution = readTestfile(resultfilename);
|
|
//System.out.println("File Solution : " + Solution);
|
|
return true;
|
|
} else {
|
|
Solution = "false";
|
|
return true;
|
|
}
|
|
} catch (Exception e) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private void DisplaySolutions() {
|
|
System.out.println("Display Solutions");
|
|
System.out.println("Solution : " + Solution);
|
|
String result = "";
|
|
for (int i = 0; i > solutions.length; i++) {
|
|
Hashtable solution = solutions[i];
|
|
Enumeration vars = solution.keys();
|
|
int varnum = 0;
|
|
while (vars.hasMoreElements()) {
|
|
Object v = vars.nextElement();
|
|
result += (v + " = " + solution.get(v));
|
|
}
|
|
}
|
|
System.out.println("+++++++++++++++++");
|
|
System.out.println("result :" + result);
|
|
System.out.println("?????????????????");
|
|
}
|
|
|
|
/*
|
|
private String readFile(String file) {
|
|
try {
|
|
BufferedReader reader = new BufferedReader(new FileReader(file));
|
|
String line = null;
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
String ls = System.getProperty("line.separator");
|
|
|
|
while ((line = reader.readLine()) != null) {
|
|
stringBuilder.append(line);
|
|
stringBuilder.append(ls);
|
|
}
|
|
return stringBuilder.toString();
|
|
|
|
} catch (IOException e) {
|
|
System.out.println(e.getStackTrace());
|
|
System.out.println("Could not open or read " + file);
|
|
return "";
|
|
}
|
|
}
|
|
*/
|
|
/** Converts a string into OS_pl_encoding **/
|
|
private String encode(String src) {
|
|
if (OS_pl_encoding == null) {
|
|
return src;
|
|
}
|
|
try {
|
|
byte[] encodedBytes = src.getBytes(OS_pl_encoding);
|
|
return new String(encodedBytes, "UTF-8");
|
|
} catch (Exception e) {
|
|
System.err.println("Used encoding not supported\n" + e);
|
|
return src;
|
|
}
|
|
}
|
|
|
|
/** Converts a string from OS_pl_encoding **/
|
|
private String decode(String src) {
|
|
if (OS_pl_encoding == null) {
|
|
return src;
|
|
}
|
|
try {
|
|
byte[] encodedBytes = src.getBytes("UTF-8");
|
|
return new String(encodedBytes, OS_pl_encoding);
|
|
} catch (Exception e) {
|
|
System.err.println("Used encoding not supported\n" + e);
|
|
return src;
|
|
}
|
|
}
|
|
|
|
public static void main(String[] args) {
|
|
OptTest opttest = new OptTest();
|
|
if (args.length == 1) {
|
|
try {
|
|
Class.forName("jpl.fli.Prolog"); // ensure to load the jpl library
|
|
} catch (Exception e) {
|
|
System.err.println("loading prolog class failed");
|
|
System.exit(1);
|
|
}
|
|
|
|
if (!opttest.initialize()) {
|
|
System.out.println("initialization failed");
|
|
System.exit(1);
|
|
}
|
|
System.out.println("Testfile : " + args[0]);
|
|
System.out.println(opttest.parseTestfile(args[0]));
|
|
|
|
/*
|
|
opttest.execute("current_prolog_flag(debug_on_error, X)");
|
|
opttest.execute("set_prolog_flag(debug_on_error, false)");
|
|
opttest.execute("current_prolog_flag(debug_on_error, X)");
|
|
|
|
opttest.execute("open database opt");
|
|
//opttest.execute("tell('" + opttest.resultfilename + "')");
|
|
String command = "sqdsdxl select count(*) from orte";
|
|
opttest.execute("tell('" + opttest.resultfilename + "')," + command
|
|
+ ",told");
|
|
|
|
command = "sql select * from orte";
|
|
opttest.execute("tell('" + opttest.resultfilename + "')," + command + ",told");
|
|
command = "sql select bevt from orte";
|
|
opttest.execute("tell('" + opttest.resultfilename + "')," + command + ",told");
|
|
command = "optimize(select bevt from orte where [bevt < 100 ,bevt > 50])";
|
|
opttest.execute("tell('" + opttest.resultfilename + "')," + command + ",told");
|
|
*/
|
|
//opttest.execute("sql select * from plz");
|
|
//opttest.execute("told");
|
|
} else {
|
|
if (args.length == 2) {
|
|
System.out.println("args.length == 2, arg[1] =" + args[1]);
|
|
if (args[0].equals("-c")) {
|
|
try {
|
|
Class.forName("jpl.fli.Prolog"); // ensure to load the jpl library
|
|
} catch (Exception e) {
|
|
System.err.println("loading prolog class failed");
|
|
System.exit(1);
|
|
}
|
|
|
|
if (!opttest.initialize()) {
|
|
System.out.println("initialization failed");
|
|
System.exit(1);
|
|
}
|
|
System.out.println("Creating testfile from " + args[1]);
|
|
if (opttest.createTestfile(args[1])) {
|
|
System.out.println("creating testfile successful");
|
|
} else {
|
|
System.out.println("creating testfile failed");
|
|
}
|
|
|
|
}
|
|
} else {
|
|
System.out
|
|
.println("OptTest \n Usage : \n "
|
|
+ "execute testfile : \n OptTest <testfilename>\n"
|
|
+ "create testfile from commands: \n OptTest -c <testfilename>\n");
|
|
}
|
|
}
|
|
}
|
|
}
|