Commit: 9a57fefe6b476ca5bdcda3dac3b8f02b3fc272f5 - cit_bach (git)

Testcase generation tool for combinatorial interaction testing

Commit MetaInfo

• Revisão: 9a57fefe6b476ca5bdcda3dac3b8f02b3fc272f5 (tree)
• Hora: 2018-07-27 13:39:53
• Autor: Tatsuhiro Tsuchiya <t-tutiya@ist....>
• Commiter: Tatsuhiro Tsuchiya

Mensagem de Log

find forbidden pairs

Mudança Sumário

• add: inputsamples/hiddenFTB
• add: src/fbt/Main.java
• add: src/v1/InputFileData.java
• add: src/v1/PList.java
• add: src/v1/Testcase.java

Diff

--- /dev/null
+++ b/inputsamples/hiddenFTB
@@ -0,0 +1,7 @@
+P1 (A1 A2 A3)
+P2 (B1 B2 B3)
+P3 (C1 C2 C3)
+
+(if (== [P1] A1) (== [P2] B1))
+
+(if (== [P2] B1) (== [P3] C1))

--- /dev/null
+++ b/src/fbt/Main.java
@@ -0,0 +1,224 @@
+package fbt;
+import v1.*;
+import v1.Error;
+
+import java.util.List;
+import java.util.TreeSet;
+
+public class Main {
+	static int randomSeed = -1;
+	static String modelFile;
+	static int numOfIterations = 1;
+	static String seedFile;
+	static String outputFile;
+	static int strength = 2; // default strength
+
+	static final int MAX_LEVEL = 63;
+
+	static final int MAX_ITERATIONS = 100000;
+	static final int MAX_STRENGTH = 5;	
+	static final int Max_RandomSeed = 65535;
+	// static final int Max_RandomSeed = 10;
+
+	static boolean debugMode = false;
+
+	enum Language {
+		JP, EN
+	};
+
+	static Language language = Language.JP;
+
+	// Start the whole process
+	public static void main(String[] args) {
+
+		long start = System.currentTimeMillis();
+
+		try {
+			// ƒRƒ}ƒ“ƒhˆø”ˆ—
+			String errorMessage = processCommandArgument(args);
+
+			// ƒGƒ‰[o—͐æÝ’è
+			Error.setOutputFile(outputFile);
+
+			// ƒRƒ}ƒ“ƒhˆø”‚ł̃Gƒ‰[o—Í
+			if (errorMessage != null)
+				Error.printError(errorMessage);
+
+			// ƒ‚ƒfƒ‹“ǂݍž‚Ý
+			// System.err.println("starting reading model");
+			InputFileData inputfiledata = Inputer.readModel(modelFile);
+
+			// §–ñˆ— BDDì¬
+			ConstraintHandler conhndl = new ConstraintHandler(
+					inputfiledata.parameterList, inputfiledata.constraintList, inputfiledata.constrainedParameters);
+
+			//
+			ParameterModel parametermodel = new ParameterModel(inputfiledata.parameterList);
+
+			checkAllTuples(parametermodel, conhndl, inputfiledata);
+			
+		} catch (OutOfMemoryError e) {
+			Error.printError(Main.language == Main.Language.JP ? "ƒƒ‚ƒŠ•s‘«‚Å‚·D"
+					: "Out of memory");
+		} catch (Exception e) {
+			Error.printError(Main.language == Main.Language.JP ? "ƒvƒƒOƒ‰ƒ€‚ªˆÙíI—¹‚µ‚Ü‚µ‚½D"
+					: "Abnormal termination");
+		}
+
+		//		long end = System.currentTimeMillis();
+		//		System.err.println("time: " + (end - start) + "ms");
+	}
+
+	// ƒRƒ}ƒ“ƒhˆø”ˆ—
+	private static String processCommandArgument(String[] args) {
+		if (args.length == 0) {
+			Error.printError("usage: java -jar Program.jar [-i input] [-o output] [-policy] ...");
+		}
+
+		// policy‚Ì•\Ž¦
+		if (args.length == 1 && args[0].equals("-policy")) {
+			System.out
+			.println("This software (CIT-BACH 1.1) is distributed under the zlib license.\n"
+					+ "The software contains Java classes from JDD, a Java BDD library "
+					+ "developed by Arash Vahidi.\n"
+					+ "JDD is free software distributed under the zlib license.\n"
+					+ "\n"
+					+ "Copyright (c) 2015, Tatsuhiro Tsuchiya\n"
+					+ "This software is provided 'as-is', without any express or implied \n"
+					+ "warranty. In no event will the authors be held liable for any damages \n"
+					+ "arising from the use of this software. \n"
+					+ "\n"
+					+ "Permission is granted to anyone to use this software for any purpose, \n"
+					+ "including commercial applications, and to alter it and redistribute it \n"
+					+ "freely, subject to the following restrictions: \n"
+					+ " \n"
+					+ "   1. The origin of this software must not be misrepresented; you must not \n"
+					+ "   claim that you wrote the original software. If you use this software \n"
+					+ "   in a product, an acknowledgment in the product documentation would be \n"
+					+ "   appreciated but is not required. \n"
+					+ "   \n"
+					+ "   2. Altered source versions must be plainly marked as such, and must not be \n"
+					+ "   misrepresented as being the original software. \n"
+					+ "   \n"
+					+ "   3. This notice may not be removed or altered from any source \n"
+					+ "   distribution. \n");
+			System.exit(0);
+		}
+
+		// ƒGƒ‰[•\Ž¦‚ðo—̓tƒ@ƒCƒ‹‚ªŽw’肳‚ê‚é‚Ü‚Å’x‚点‚é
+		String errorMessage = null;
+
+		for (int i = 0; i + 1 < args.length; i += 2) {
+			String option = args[i];
+			String str = args[i + 1];
+			if (option.equals("-i")) {
+				modelFile = str;
+			} else if (option.equals("-o")) {
+				outputFile = str;
+			} else if (option.equals("-random")) {
+				try {
+					randomSeed = Integer.parseInt(str);
+				} catch (NumberFormatException e) {
+					// Error.printError("invalid number");
+					errorMessage = Main.language == Main.Language.JP ? "ƒ‰ƒ“ƒ_ƒ€ƒV[ƒh‚É–³Œø‚È’l‚ªŽw’肳‚ê‚Ä‚¢‚Ü‚·D"
+							: "Invalid random seed";
+					continue;
+				}
+				randomSeed = Math.abs(randomSeed) % (Max_RandomSeed + 1);
+			} else if (option.equals("-c")) {
+				if (str.equals("all")) {
+					// ‘S–Ô—…
+					strength = -1;
+				} else {
+					try {
+						strength = Integer.parseInt(str);
+					} catch (NumberFormatException e) {
+						// Error.printError("invalid number");
+						errorMessage = Main.language == Main.Language.JP ? "–Ô—…“x‚É–³Œø‚È’l‚ªŽw’肳‚ê‚Ä‚¢‚Ü‚·D"
+								: "Invalid strength";
+						continue;
+					}
+					if (strength < 2 || MAX_STRENGTH < strength) {
+						// Error.printError("invalid strength");
+						errorMessage = Main.language == Main.Language.JP ? "–Ô—…“x‚É–³Œø‚È’l‚ªŽw’肳‚ê‚Ä‚¢‚Ü‚·D"
+								: "Invalid strength";
+						continue;
+					}
+				}
+			}
+			// ŒJ‚è•Ô‚µ”
+			else if (option.equals("-repeat")) {
+				try {
+					numOfIterations = Integer.parseInt(str);
+				} catch (NumberFormatException e) {
+					// Error.printError("invalid repeating number");
+					errorMessage = Main.language == Main.Language.JP ? "‚­‚è•Ô‚µ”‚É–³Œø‚È’l‚ªŽw’肳‚ê‚Ä‚¢‚Ü‚·D"
+							: "Invalid number of repetition times";
+					continue;
+				}
+				if (numOfIterations <= 0 || numOfIterations > MAX_ITERATIONS) {
+					// Error.printError("invalid repeating number");
+					errorMessage = Main.language == Main.Language.JP ? "‚­‚è•Ô‚µ”‚É–³Œø‚È’l‚ªŽw’肳‚ê‚Ä‚¢‚Ü‚·D"
+							: "Invalid number of repetition times";
+					continue;
+				}
+			} else if (option.equals("-s")) {
+				seedFile = str;
+			} else if (option.equals("-debug")) {
+				debugMode = true;
+				// ŽŸ‚̈ø”‚̓_ƒ~[
+			} else if (option.equals("-lang")) {
+				if (str.matches("JP|jp")) {
+					Main.language = Main.Language.JP;
+				} else if (str.matches("EN|en")) {
+					Main.language = Main.Language.EN;
+				} else {
+					errorMessage = "–³Œø‚ÈŒ¾Œê‚ªŽw’肳‚ê‚Ä‚¢‚Ü‚· (Invalid Language)";
+					continue;
+				}
+			} else {
+				// Error.printError("Invalid option");
+				errorMessage = Main.language == Main.Language.JP ? "–³Œø‚ȃIƒvƒVƒ‡ƒ“‚ªŽw’肳‚ê‚Ä‚¢‚Ü‚·D"
+						: "Invalid option";
+				continue;
+			}
+		}
+
+		if (randomSeed == -1) {
+			randomSeed = (int) Math.floor(Math.random() * (Max_RandomSeed + 1));
+		}
+
+		return errorMessage;
+	}
+
+	private static void checkAllTuples(ParameterModel parametermodel, ConstraintHandler conhndl,
+			InputFileData inputfiledata) {
+		// strength = 2
+		int numOfParameters = parametermodel.size;
+		for (int i = 0; i < numOfParameters - 1; i++) {
+			for (int j = i + 1; j < numOfParameters; j++) {
+				for (byte v1 = 0; v1 < parametermodel.range[i]; v1++) {
+					for (byte v2 = 0; v2 < parametermodel.range[j]; v2++) {
+						// pair‚̐¶¬
+						Testcase pair = new Testcase(numOfParameters);
+						pair.quantify();
+						pair.set(i, v1);
+						pair.set(j, v2);
+						// pair‚̃`ƒFƒbƒN
+						// ‹Ö‘¥ˆá”½‚È‚çset
+						if (conhndl.isPossible(pair) == false) {
+//							System.out.println("[" + i + ", " + v1 + "]" + ", " +
+	//								"[" + j + ", " + v2 + "]]");
+							String para1 = inputfiledata.parameterList.get(i).name;
+							String str1 = inputfiledata.parameterList.get(i).value_name.get(v1);
+							String para2 = inputfiledata.parameterList.get(i).name;
+							String str2 = inputfiledata.parameterList.get(j).value_name.get(v2);
+							System.out.println("[" + para1 + ", " + str1 + "]" + ", " +
+									"[" + para2 + ", " + str2 + "]");						
+						}
+					}
+				}
+			}
+		}
+	}
+}

--- /dev/null
+++ b/src/v1/InputFileData.java
@@ -0,0 +1,19 @@
+package v1;
+
+import java.util.List;
+import java.util.TreeSet;
+
+public class InputFileData {
+	public PList parameterList;
+	public GList groupList;
+	public List<Node> constraintList;
+	public TreeSet<Integer> constrainedParameters;
+
+	InputFileData(PList parameterList, GList groupList,
+			List<Node> constraintList, TreeSet<Integer> constrainedParameters) {
+		this.parameterList = parameterList;
+		this.groupList = groupList;
+		this.constraintList = constraintList;
+		this.constrainedParameters = constrainedParameters;
+	}
+}

--- /dev/null
+++ b/src/v1/PList.java
@@ -0,0 +1,45 @@
+package v1;
+
+import java.util.LinkedList;
+import java.util.TreeSet;
+
+public class PList extends LinkedList<Parameter> {
+
+	private static final long serialVersionUID = 1L;
+
+	boolean checkNameDuplication() {
+		for (int i = 0; i < this.size() - 1; i++)
+			for (int j = i + 1; j < this.size(); j++) {
+				if (this.get(i).name.equals(this.get(j).name)) {
+					return true;
+				}
+			}
+		return false;
+	}
+
+	int getID(String str) throws NoParameterNameException {
+		for (int i = 0; i < this.size(); i++) {
+			if (this.get(i).name.equals(str))
+				return i;
+		}
+		throw new NoParameterNameException();
+	}
+	
+	// useless?
+	int getRestrictedID(String str, TreeSet<Integer> RestrictedParameters) 
+		throws NoParameterNameException {
+		try {
+			int parameter = this.getID(str);
+			int num = 0;
+			for (Integer i: RestrictedParameters) {
+				if (i == parameter)
+					return num;
+				num++;
+			}
+		} catch (NoParameterNameException e) {
+			throw e;
+		}
+		// if the parameter is not a relevant one
+		throw new NoParameterNameException();
+	}
+}

--- /dev/null
+++ b/src/v1/Testcase.java
@@ -0,0 +1,91 @@
+package v1;
+
+import java.io.BufferedWriter;
+import java.io.IOException;
+
+public class Testcase {
+	byte[] value; // 0..level-1, or <0 (wildcard)
+
+	// ‚±‚ê‚𑼂©‚ç“Ç‚ñ‚Å‚é‚Æ‚Ü‚¸‚¢‚©‚àH
+	public Testcase(int n) {
+		this.value = new byte[n];
+	}
+
+	public void set(int parameter, byte value) {
+		this.value[parameter] = value;
+	}
+
+	void setWildCard(int parameter) {
+		this.value[parameter] = -1;
+	}
+
+	byte get(int parameter) {
+		return value[parameter];
+	}
+
+	int getint(int parameter) {
+		return (int) value[parameter];
+	}
+
+	public void quantify() {
+		for (int i = 0; i < this.value.length; i++)
+			this.value[i] = -1;
+	}
+
+	Testcase makeClone() {
+		Testcase newtest = new Testcase(this.value.length);
+		for (int i = 0; i < newtest.value.length; i++) {
+			newtest.value[i] = this.value[i];
+		}
+		return newtest;
+	}
+
+	void print() {
+		for (int i = 0; i < value.length; i++)
+			System.err.print(value[i] + ",");
+		System.err.println();
+	}
+
+	// TODO Outputer.java ‚Ɉړ®
+	void print(BufferedWriter writer, InputFileData inputfiledata)
+			throws IOException {
+		for (int i = 0; i < value.length; i++)
+			writer.write((i == 0 ? "" : ",")
+					+ inputfiledata.parameterList.get(i).value_name
+							.get(value[i]));
+		writer.write("\n");
+	}
+
+	// tuple‚ðd‚Ë‚é
+	// return true if a tuple is superimposed
+	// d‚Ë‚½Žž‚É‹Ö‘¥‚Ɉᔽ‚·‚邱‚Æ‚ ‚è->ƒ`ƒFƒbƒN‚·‚é
+	boolean superimpose(Testcase tuple, ConstraintHandler h) {
+		Testcase tmp = this.makeClone();
+		if (tmp.superimpose(tuple) == false)
+			return false;
+		if (h.isPossible(tmp) == false)
+			return false;
+		return this.superimpose(tuple);
+		// must be true;
+	}
+
+	// tuple‚ðd‚Ë‚é
+	// return true if a tuple is superimposed
+	// d‚Ë‚½Žž‚É‹Ö‘¥‚Ɉᔽ‚·‚邱‚Æ‚ ‚è->ƒ`ƒFƒbƒN‚µ‚È‚¢
+	private boolean superimpose(Testcase tuple) {
+		// TODO Auto-generated method stu
+		for (int i = 0; i < value.length; i++) {
+			if (value[i] < 0 || tuple.value[i] < 0)
+				continue;
+			if (value[i] == tuple.value[i])
+				continue;
+			return false;
+		}
+
+		for (int i = 0; i < value.length; i++) {
+			if (value[i] < 0)
+				this.set(i, tuple.get(i));
+		}
+		return true;
+	}
+}