Commit 882bf55d authored by stancakapost's avatar stancakapost
Browse files

improve error handling for purpose detection

parent 86f24beb

tools/STF475Tools/src/TestPurposeGenerator.java

+15 −54
Original line number Diff line number Diff line
@@ -13,9 +13,7 @@ public class TestPurposeGenerator { 
	public static Properties references = new Properties();

	private ArrayList<File> files = new ArrayList<File>();

	private HashMap<String, ArrayList<ClauseEntry>> clauseMapPositiveSemantical = new HashMap<String, ArrayList<ClauseEntry>>();

	private HashMap<String, ArrayList<ClauseEntry>> clauseMapPositiveSyntactical = new HashMap<String, ArrayList<ClauseEntry>>();

	private HashMap<String, ArrayList<ClauseEntry>> clauseMapNegativeSemantical = new HashMap<String, ArrayList<ClauseEntry>>();

	private HashMap<String, ArrayList<ClauseEntry>> clauseMapNegativeSyntactical = new HashMap<String, ArrayList<ClauseEntry>>();

	

	// -----------------------------------------------------------------------------------------------
@@ -54,53 +52,37 @@ public class TestPurposeGenerator { 
		System.out.println("Processing files...");

		for (int i=0; i < files.size(); i++) {

//			File tempFile = new File(config.get("TempPath") + "/" + files.get(i).getName());

			File tempFile = files.get(i);

			File currentFile = files.get(i);

			System.out.println("processing " + currentFile.getName());

//			System.out.println(tempFile.getAbsolutePath());

			T3Purpose purpose = FileUtils.extractPurpose(tempFile);

			T3ExpectedOutput expected = FileUtils.extractExpectedOutput(tempFile);

			T3Purpose purpose = FileUtils.extractPurpose(currentFile);

			

//			System.out.println("processing " + files.get(i).getName());

			if (purpose.getClauseStructured() == null || purpose.getClause() == null) {

				System.err.println("Skipping file: Error processing purpose for file "+currentFile.getAbsolutePath());

				continue;

			}

			

			if (files.get(i).getName().toLowerCase().startsWith("negsync")) {

				ArrayList<ClauseEntry> clauseEntries = clauseMapNegativeSyntactical.get(purpose.getClauseStructured().toString());

				if (clauseEntries == null)

					clauseEntries = new ArrayList<ClauseEntry>();

			T3ExpectedOutput expected = FileUtils.extractExpectedOutput(currentFile);

			

				ClauseEntry clauseEntry = new ClauseEntry();

				clauseEntry.setFile(tempFile);

				clauseEntry.setPurpose(purpose);

				clauseEntry.setExpected(expected);

				clauseEntries.add(clauseEntry);

				clauseMapNegativeSyntactical.put(purpose.getClauseStructured().toString(), clauseEntries);

			} else if (files.get(i).getName().toLowerCase().startsWith("negsem")) {



			if (files.get(i).getName().toLowerCase().startsWith("neg")) {

				ArrayList<ClauseEntry> clauseEntries = clauseMapNegativeSemantical.get(purpose.getClauseStructured().toString());

				if (clauseEntries == null)

					clauseEntries = new ArrayList<ClauseEntry>();

				

				ClauseEntry clauseEntry = new ClauseEntry();

				clauseEntry.setFile(tempFile);

				clauseEntry.setFile(currentFile);

				clauseEntry.setPurpose(purpose);

				clauseEntry.setExpected(expected);

				clauseEntries.add(clauseEntry);

				clauseMapNegativeSemantical.put(purpose.getClauseStructured().toString(), clauseEntries);

			} else if (files.get(i).getName().toLowerCase().startsWith("syn")) {

				ArrayList<ClauseEntry> clauseEntries = clauseMapPositiveSyntactical.get(purpose.getClauseStructured().toString());

				if (clauseEntries == null)

					clauseEntries = new ArrayList<ClauseEntry>();

				

				ClauseEntry clauseEntry = new ClauseEntry();

				clauseEntry.setFile(tempFile);

				clauseEntry.setPurpose(purpose);

				clauseEntry.setExpected(expected);

				clauseEntries.add(clauseEntry);

				clauseMapPositiveSyntactical.put(purpose.getClauseStructured().toString(), clauseEntries);

			} else { // sem

			} else { // pos

				ArrayList<ClauseEntry> clauseEntries = clauseMapPositiveSemantical.get(purpose.getClauseStructured().toString());

				if (clauseEntries == null)

					clauseEntries = new ArrayList<ClauseEntry>();

				

				ClauseEntry clauseEntry = new ClauseEntry();

				clauseEntry.setFile(tempFile);

				clauseEntry.setFile(currentFile);

				clauseEntry.setPurpose(purpose);

				clauseEntry.setExpected(expected);

				clauseEntries.add(clauseEntry);
@@ -121,23 +103,15 @@ public class TestPurposeGenerator { 
			int clauseCounter = 1;

			for (int i=0; i < myList.size(); i++) {

				Clause clause = myList.get(i);

				ArrayList<ClauseEntry> clauseEntriesPositiveSyntactical = null;

				ArrayList<ClauseEntry> clauseEntriesPositiveSemantical = null;

				ArrayList<ClauseEntry> clauseEntriesNegativeSyntactical = null;

				ArrayList<ClauseEntry> clauseEntriesNegativeSemantical = null;

				

				clauseEntriesPositiveSyntactical = clauseMapPositiveSyntactical.get(clause.toString());

				clauseEntriesPositiveSemantical = clauseMapPositiveSemantical.get(clause.toString());

				clauseEntriesNegativeSyntactical = clauseMapNegativeSyntactical.get(clause.toString());

				clauseEntriesNegativeSemantical = clauseMapNegativeSemantical.get(clause.toString());



				int totalEntries = 0;

				if (clauseEntriesPositiveSyntactical != null)

					totalEntries += clauseEntriesPositiveSyntactical.size();

				if (clauseEntriesPositiveSemantical != null)

					totalEntries += clauseEntriesPositiveSemantical.size();

				if (clauseEntriesNegativeSyntactical != null)

					totalEntries += clauseEntriesNegativeSyntactical.size();

				if (clauseEntriesNegativeSemantical != null)

					totalEntries += clauseEntriesNegativeSemantical.size();
@@ -145,13 +119,6 @@ public class TestPurposeGenerator { 
//					result.append(createSection(tpSectionHead, "A.2." + Integer.toString(clauseCounter), references.getProperty(clause.toString()) + " (Clause " + clause.toString() + ")"));

					result.append(createSection(tpSectionHead, "A.2." + Integer.toString(clauseCounter), references.getProperty(clause.toString())));



					if (clauseEntriesPositiveSyntactical != null) {

						for (int j=0; j < clauseEntriesPositiveSyntactical.size(); j++) {

							ClauseEntry clauseEntries = clauseEntriesPositiveSyntactical.get(j);

							createTestPurposeEntry(tpTable, result,

									clauseEntries);

						}

					}

					if (clauseEntriesPositiveSemantical != null) {

						for (int j=0; j < clauseEntriesPositiveSemantical.size(); j++) {

							ClauseEntry clauseEntries = clauseEntriesPositiveSemantical.get(j);
@@ -159,13 +126,7 @@ public class TestPurposeGenerator { 
									clauseEntries);

						}

					}

					if (clauseEntriesNegativeSyntactical != null) {

						for (int j=0; j < clauseEntriesNegativeSyntactical.size(); j++) {

							ClauseEntry clauseEntries = clauseEntriesNegativeSyntactical.get(j);

							createTestPurposeEntry(tpTable, result,

									clauseEntries);

						}

					}

					

					if (clauseEntriesNegativeSemantical != null) {

						for (int j=0; j < clauseEntriesNegativeSemantical.size(); j++) {

							ClauseEntry clauseEntries = clauseEntriesNegativeSemantical.get(j);