/** Given a line from an input file, generates appropriate check or add command. */
private static void generateCheckOrAddCommand(String command, int lineNumber) {
// remove the command
String args = command.substring(command.indexOf(":") + 1);
StringTokenizer tokens = new StringTokenizer(args, argDivider);
if (tokens.countTokens() != types.length) {
throw new RuntimeException(
"Number of arguments to generate an add command on line: "
+ lineNumber
+ " is: "
+ tokens.countTokens()
+ " but should be: "
+ types.length);
}
Object[] params = getParams(tokens);
assert !tokens.hasMoreTokens();
InvariantStatus goalStatus = null;
if (isCheckCommand(command)) {
goalStatus = getCheckStatus(params);
} else {
goalStatus = getAddStatus(params);
}
String invariantFormat = getInvariantFormat();
results.append(
command
+ argDivider
+ " "
+ goalStatus.toString()
+ argDivider
+ " "
+ invariantFormat
+ lineSep);
}
/**
* This function performs an individual formatting test after the input and output streams have
* been created.
*
* @param commands the input that decides which tests to perform
* @return a String holding the error messages for any failed tests or null if no tests are
* failed.
*/
private static /*@Nullable*/ String performTest(LineNumberReader commands) {
StringBuffer output = new StringBuffer();
// List invariantTestCases = new Vector();
boolean noTestFailed = true;
while (true) {
// Create a new test case
// FormatTestCase currentCase = FormatTestCase.instantiate(commands, generateGoals);
// if (currentCase == null)
// break;
// else {
// invariantTestCases.add(currentCase);
String results = AddAndCheckTestCase.runTest(commands);
if (results == null) break;
if (!(results.length() == 0)) {
// output.print(currentCase.getDiffString());
output.append(results);
noTestFailed = false;
}
}
if (noTestFailed) {
return null;
} else {
return output.toString();
}
}
/**
* Initializes the fields of this class based on the first two lines of a case which include the
* class name and parameter types.
*
* @return true is end of file is reached.
*/
private static boolean initFields(LineNumberReader commands, boolean generatingCommands) {
results = new StringBuffer();
String className = getNextRealLine(commands);
// End of file reached
if (className == null) return true;
// Load the class from file
Class<? extends Invariant> classToTest = asInvClass(getClass(className));
try {
classToTest.getField("dkconfig_enabled"); // Enable if needs to be done
InvariantAddAndCheckTester.config.apply(className + ".enabled", "true");
} catch (NoSuchFieldException e) { // Otherwise do nothing
}
if (generatingCommands) {
results.append(className + lineSep);
}
// Instantiate variables to be used as the names in the
// invariants, variables are labeled a,b,c and so on as they
// appear
String typeString = getNextRealLine(commands);
types = getTypes(typeString);
VarInfo[] vars = getVarInfos(classToTest, types);
PptSlice sl = createSlice(vars, daikon.test.Common.makePptTopLevel("Test:::OBJECT", vars));
// Create an actual instance of the class
invariantToTest = instantiateClass(classToTest, sl);
addModified = getAddModified(invariantToTest.getClass());
checkModified = getCheckModified(invariantToTest.getClass());
outputProducer = getOutputProducer(invariantToTest.getClass());
assert getArity(invariantToTest.getClass()) == types.length;
if (generatingCommands) {
results.append(typeString + lineSep);
}
return false;
}
private static String generateCommands(LineNumberReader input) {
StringBuffer output = new StringBuffer();
while (true) {
String commands = AddAndCheckTestCase.generateTest(input);
if (commands == null) break;
output.append(commands);
}
return output.toString();
}
/**
* @return a String containing the proper add and check commands for this input lines of this
* test case.
*/
public static String generateTest(LineNumberReader commands) {
boolean endOfFile = initFields(commands, true);
if (endOfFile) return null;
while (true) {
String commandLine = getNextLine(commands).trim();
int lineNumber = commands.getLineNumber();
if (InvariantAddAndCheckTester.isComment(commandLine)) {
results.append(commandLine + lineSep);
} else if (isTestTerminator(commandLine)) {
results.append(commandLine + lineSep + lineSep);
break;
} else if (isAddCommand(commandLine) || isCheckCommand(commandLine)) {
generateCheckOrAddCommand(commandLine, lineNumber);
} else if (isCompareCommand(commandLine)) {
// generateCompareCommand(commandLine);
} else {
throw new RuntimeException("unrecognized command");
}
}
return results.toString();
}
static String combineDummy(String inv, String daikonStr, String esc, String simplify) {
StringBuffer combined = new StringBuffer(inv);
combined.append(lineSep + "\tDAIKON_FORMAT ");
combined.append(daikonStr);
combined.append(lineSep + "\tESC_FORMAT ");
combined.append(esc);
combined.append(lineSep + "\tSIMPLIFY_FORMAT ");
combined.append(simplify);
return combined.toString();
}
private String format_simplify() {
if (intersect == null || intersect.length == 0) {
return "(AND)";
}
String[] name = var().simplifyNameAndBounds();
if (name == null) {
return format_unimplemented(OutputFormat.SIMPLIFY);
}
String idx;
if (!name[0].equals("|i|")) {
idx = "i";
} else {
idx = "j";
}
StringBuffer pre_buf = new StringBuffer("");
StringBuffer end_buf = new StringBuffer("");
for (int i = 0; i < intersect.length; i++) {
pre_buf.append("(EXISTS (" + idx + i + ") (AND ");
pre_buf.append("(>= " + idx + i + " " + name[1] + ") ");
pre_buf.append("(<= " + idx + i + " " + name[2] + ") ");
// Based on the class name, I originally wrote this method as if
// the invariant represented a common subsequence between two
// sequences (i.e. where the match was required to be in
// order). In case an invariant like that is added in the
// future, use the following:
// if (i == 0)
// pre_buf.append("(>= "+idx+i + " 0) ");
// else if (i > 0)
// pre_buf.append("(> "+idx+i + " "+idx+(i-1) +") ");
// if (i == intersect.length - 1)
// pre_buf.append("(< "+idx+i + " (select arrayLength " + name[0] + ")) ");
pre_buf.append(
"(EQ (select (select elems "
+ name[0]
+ ") "
+ idx
+ i
+ ") "
+ simplify_format_double(intersect[i])
+ ")");
if (i == intersect.length - 1) pre_buf.append(" ");
end_buf.append("))");
}
pre_buf.append(end_buf);
return pre_buf.toString();
}
/**
* Given a line from a command file, generates executes the appropriate check or add command and
* checks the results against the goal. If the results and goal do not match, a message is added
* to the results string buffer.
*/
private static void exicuteCheckOrAddCommand(String command, int lineNumber) {
// remove the command
String args = command.substring(command.indexOf(":") + 1);
StringTokenizer tokens = new StringTokenizer(args, argDivider);
if (tokens.countTokens() != types.length + 2) {
throw new RuntimeException(
"Number of arguments to add command on line "
+ lineNumber
+ " is: "
+ tokens.countTokens()
+ " but should be: "
+ (types.length + 2));
}
Object[] params = getParams(tokens);
InvariantStatus goalStatus = parseStatus(tokens.nextToken().trim());
tokens.nextToken(); // executed for side effect
assert !tokens.hasMoreTokens();
InvariantStatus resultStatus = null;
if (isCheckCommand(command)) {
resultStatus = getCheckStatus(params);
} else {
resultStatus = getAddStatus(params);
}
if (resultStatus != goalStatus) {
results.append(
"Error on line "
+ lineNumber
+ ":"
+ lineSep
+ "Expected InvariantStatus: "
+ goalStatus
+ lineSep
+ "Found InvariantStatus: "
+ resultStatus
+ lineSep);
}
}
public static void extract_consequent(PptMap ppts) {
// Retrieve Ppt objects in sorted order.
// Use a custom comparator for a specific ordering
Comparator<PptTopLevel> comparator = new Ppt.NameComparator();
TreeSet<PptTopLevel> ppts_sorted = new TreeSet<PptTopLevel>(comparator);
ppts_sorted.addAll(ppts.asCollection());
for (PptTopLevel ppt : ppts_sorted) {
extract_consequent_maybe(ppt, ppts);
}
PrintWriter pw = new PrintWriter(System.out, true);
// All conditions at a program point. A TreeSet to enable
// deterministic output.
TreeSet<String> allConds = new TreeSet<String>();
for (String pptname : pptname_to_conditions.keySet()) {
Map<String, Map<String, HashedConsequent>> cluster_to_conditions =
pptname_to_conditions.get(pptname);
for (Map.Entry</*@KeyFor("cluster_to_conditions")*/ String, Map<String, HashedConsequent>>
entry : cluster_to_conditions.entrySet()) {
String predicate = entry.getKey();
Map<String, HashedConsequent> conditions = entry.getValue();
StringBuffer conjunctionJava = new StringBuffer();
StringBuffer conjunctionDaikon = new StringBuffer();
StringBuffer conjunctionESC = new StringBuffer();
StringBuffer conjunctionSimplify = new StringBuffer("(AND ");
int count = 0;
for (Map.Entry</*@KeyFor("conditions")*/ String, HashedConsequent> entry2 :
conditions.entrySet()) {
count++;
String condIndex = entry2.getKey();
HashedConsequent cond = entry2.getValue();
if (cond.fakeFor != null) {
count--;
continue;
}
String javaStr = cond.inv.format_using(OutputFormat.JAVA);
String daikonStr = cond.inv.format_using(OutputFormat.DAIKON);
String escStr = cond.inv.format_using(OutputFormat.ESCJAVA);
String simplifyStr = cond.inv.format_using(OutputFormat.SIMPLIFY);
allConds.add(combineDummy(condIndex, "<dummy> " + daikonStr, escStr, simplifyStr));
// allConds.add(condIndex);
if (count > 0) {
conjunctionJava.append(" && ");
conjunctionDaikon.append(" and ");
conjunctionESC.append(" && ");
conjunctionSimplify.append(" ");
}
conjunctionJava.append(javaStr);
conjunctionDaikon.append(daikonStr);
conjunctionESC.append(escStr);
conjunctionSimplify.append(simplifyStr);
}
conjunctionSimplify.append(")");
String conj = conjunctionJava.toString();
// Avoid inserting self-contradictory conditions such as "x == 1 &&
// x == 2", or conjunctions of only a single condition.
if (count < 2
|| contradict_inv_pattern.matcher(conj).find()
|| useless_inv_pattern_1.matcher(conj).find()
|| useless_inv_pattern_2.matcher(conj).find()) {
// System.out.println("Suppressing: " + conj);
} else {
allConds.add(
combineDummy(
conjunctionJava.toString(),
conjunctionDaikon.toString(),
conjunctionESC.toString(),
conjunctionSimplify.toString()));
}
}
if (allConds.size() > 0) {
pw.println();
pw.println("PPT_NAME " + pptname);
for (String s : allConds) {
pw.println(s);
}
}
allConds.clear();
}
pw.flush();
}