Commit: 8a4cc78799d484f5c73c4f6cb5d1305c515616fc - cit_bach (git)

Testcase generation tool for combinatorial interaction testing

Commit MetaInfo

• Révision: 8a4cc78799d484f5c73c4f6cb5d1305c515616fc (tree)
• l'heure: 2015-10-16 11:48:47
• Auteur: t-tutiya <tatsuhiro@ieee...>
• Commiter: t-tutiya

Message de Log

Support of arithmetic comparison, including < > <= >= ===.

Change Summary

• modified: src/v1/ConstraintHandler.java
• modified: src/v1/Generator.java
• modified: src/v1/Parameter.java
• modified: src/v1/Parse.java

Modification

--- a/src/v1/ConstraintHandler.java
+++ b/src/v1/ConstraintHandler.java
@@ -17,7 +17,7 @@ class ConstraintHandler {
 
 	ConstraintHandler(PList parameterList, List<Node> constraintList) {
 		bdd = new BDD(sizeOfNodetable, sizeOfCache);
-		// bdd = new jdd.bdd.debug.DebugBDD(1000,1000);
+		bdd = new jdd.bdd.debug.DebugBDD(1000,1000);
 
 		// parameter‚̃ŠƒXƒg
 		parameters = setBDDforParameter(parameterList);
@@ -142,6 +142,49 @@ class ConstraintHandler {
 		return f;
 	}
 
+	
+	private int setBddConstraintNewBuggy(List<Node> constraintList) {
+		int f = bdd.getOne();
+		bdd.ref(f);
+
+		// §–ñŽ®‚̘_—Ï‚ð‚Æ‚é
+		for (Node n : constraintList) {
+			int g = n.evaluate(bdd, parameters);
+			int tmp = bdd.ref(bdd.and(f, g));
+			bdd.deref(f);
+			bdd.deref(g);
+			f = tmp;
+		}
+
+		// ƒpƒ‰ƒ[ƒ^‚ł‚©‚í‚È‚¢—̈æ‚ðfalse‚É‚·‚é
+		int fordebug = 0;
+		for (VariableAndBDD vb : parameters) {
+			int cube = vb.var[0];
+			bdd.ref(cube);
+			for (int i = 1; i < vb.var.length; i++) {
+				int tmp = bdd.ref(bdd.and(cube, vb.var[i]));
+				bdd.deref(cube);
+				cube = tmp;
+			}
+			int tmp = bdd.ref(bdd.exists(f, cube));
+			// §–ñ‚ÉŠÖŒW‚·‚éê‡‚Ì‚Ý
+			if (tmp != f) {
+				fordebug++;
+				int tmp1 = bdd.ref(bdd.and(f, vb.constraint));
+				bdd.deref(f);
+				f = tmp1;
+			}
+			bdd.deref(cube);
+			bdd.deref(tmp);
+		}
+		System.out.println(fordebug);
+		// *‚ð•t‰Á
+		f = extendBddConstraint(f);
+
+		return f;
+	}
+
+	
 	private int extendBddConstraint(int constraint) {
 		int f = constraint;
 		for (VariableAndBDD p : parameters) {

--- a/src/v1/Generator.java
+++ b/src/v1/Generator.java
@@ -132,7 +132,8 @@ class Generator2 extends Generator {
 	 * Random(randomseed); }
 	 */
 
-	final int NumOfIterationForEachTest = 20;
+//	final int NumOfIterationForEachTest = 20;
+	final int NumOfIterationForEachTest = 1;
 
 	Generator2(ParameterModel parametermodel, GList groupList,
 			ConstraintHandler constrainthandler, List<Testcase> seed,

--- a/src/v1/Parameter.java
+++ b/src/v1/Parameter.java
@@ -49,6 +49,36 @@ public class Parameter {
 			return ids;
 	}
 
+	// number‚ÆŽZp“I‚É“¯‚¶…€‚Ìid‚ð‚Ƃ肾‚·¨‚‚©‚Á‚Ä‚È‚¢
+	List<Integer> getID(double number) {
+		List<Integer> ids = new ArrayList<Integer>();
+		for (int i = 0; i < value_name.size(); i++) {
+			double level;
+			try {
+				level = Double.parseDouble(value_name.get(i));
+				if (level == number)
+					ids.add(i);
+			} catch (NumberFormatException e) {}
+		}
+		return ids;
+	}
+	
+	// number‚ÆŽZp“I‚ÉŠÖŒW‚Ì‚ ‚鐅€‚Ìid‚ð‚Ƃ肾‚·
+	// level ` number
+	List<Integer> getID(double number, RelationOverDoublePair com) {
+		List<Integer> ids = new ArrayList<Integer>();
+		for (int i = 0; i < value_name.size(); i++) {
+			double level;
+			try {
+				level = Double.parseDouble(value_name.get(i));
+				if (com.hasRelation(level, number))
+					ids.add(i);
+			} catch (NumberFormatException e) {}
+		}
+		return ids;
+	}
+
+	
 }
 
 class PList extends LinkedList<Parameter> {

--- a/src/v1/Parse.java
+++ b/src/v1/Parse.java
@@ -13,13 +13,13 @@ public class Parse {
 	}
 
 	public Node parseExpression() {
-		String token = t.peepToken();
+		String nextToken = t.peepToken();
 		try {
-			if (token == null) {
+			if (nextToken == null) {
 				Error.printError(Main.language == Main.Language.JP ? "§–ñŽ®‚ÉŒë‚肪‚ ‚è‚Ü‚·"
 						: "Invalid constraints");
 				return null;
-			} else if (token.equals("("))
+			} else if (nextToken.equals("("))
 				return expressionWithParentheses();
 			else {
 				// error
@@ -66,10 +66,10 @@ public class Parse {
 		// ‰‰ŽZŽq‚ÌŽŸ‚̃g[ƒNƒ“‚ª ( ‚© ‚Ç‚¤‚©‚Å”»’f
 		// case 1: ( <> (
 		// case 2: ( <> [ foo, ( <> foo
-		String token = t.peepNextToken();
-		if (token == null)
+		String nextNextToken = t.peepNextToken();
+		if (nextNextToken == null)
 			throw new OutOfTokenStreamException();
-		if (token.equals("("))
+		if (nextNextToken.equals("("))
 			return boolExpression();
 		else
 			return atomExpression();
@@ -99,6 +99,7 @@ public class Parse {
 		return null; // unreachable
 	}
 
+
 	private Node notExpression() throws OutOfTokenStreamException {
 		BooleanUnaryOperator res = new NotOperator();
 		t.getToken();
@@ -176,6 +177,16 @@ public class Parse {
 			return equalityAtomExpression();
 		else if (token.equals("<>"))
 			return inequalityAtomExpression();
+		else if (token.equals("==="))
+			return artithmeticEqualityAtomExpression(new EqualTo(), new EqualTo());
+		else if (token.equals("<"))
+			return artithmeticEqualityAtomExpression(new LessThan(), new GreaterThan());
+		else if (token.equals(">"))
+			return artithmeticEqualityAtomExpression(new GreaterThan(), new LessThan());
+		else if (token.equals("<="))
+			return artithmeticEqualityAtomExpression(new LTE(), new GTE());
+		else if (token.equals(">="))
+			return artithmeticEqualityAtomExpression(new GTE(), new LTE());
 		else
 			Error.printError(Main.language == Main.Language.JP ? "§–ñŽ®‚É == ‚© <> ‚ª•K—v‚Å‚·"
 					: "== or <> expected in constraints");
@@ -188,6 +199,69 @@ public class Parse {
 		return res;
 	}
 
+	private Node artithmeticEqualityAtomExpression(RelationOverDoublePair com1, RelationOverDoublePair com2)
+			throws OutOfTokenStreamException {
+		// case 1 val1 val2        com1
+		// case 2 val1 [para1]     com2
+		// case 3 [para1] val1     com1
+		// case 4 [para1] [para2]  com1
+		String val1, val2, para1, para2;
+		String token1, token2;
+
+		token1 = t.peepToken();
+		token2 = t.peepNextToken();
+
+		if (token1 == null || token2 == null)
+			throw new OutOfTokenStreamException();
+
+		// case 1
+		if ((token1.equals("[") == false) && (token2.equals("[") == false)) {
+			val1 = t.getToken();
+			val2 = t.getToken();
+			return compareArithmeticValueAndValue(val1, val2, com1);
+		}
+
+		// case 2 
+		if ((token1.equals("[") == false) && (token2.equals("[") == true)) {
+			val1 = t.getToken();
+			t.getToken(); // must be [
+			para1 = t.getToken();
+			if (t.getToken().equals("]") == false) {
+				Error.printError(Main.language == Main.Language.JP ? "§–ñŽ®‚É]‚ª•K—v‚Å‚·"
+						: "] expected in constraints");
+			}
+			return compareArithmeticParameterAndValue(para1, val1, com2);
+		}
+
+		// case 3, 4 
+		t.getToken(); // must be "["
+		para1 = t.getToken();
+		if (t.getToken().equals("]") == false) {
+			Error.printError(Main.language == Main.Language.JP ? "§–ñŽ®‚É]‚ª•K—v‚Å‚·"
+					: "] expected in constraints");
+		}
+		token1 = t.peepToken();
+		if (token1 == null)
+			throw new OutOfTokenStreamException();
+
+		// case 3
+		if (token1.equals("[") == false) {
+			val1 = t.getToken();
+			return compareArithmeticParameterAndValue(para1, val1, com1);
+		}
+
+		// case 4 
+		t.getToken(); // must be [
+		para2 = t.getToken();
+		if (t.getToken().equals("]") == false) {
+			Error.printError(Main.language == Main.Language.JP ? "§–ñŽ®‚É]‚ª•K—v‚Å‚·"
+					: "] expected in constraints");
+		}
+		return compareArithmeticParameterAndParameter(para1, para2, com1);
+	}
+
+
+
 	private Node equalityAtomExpression() throws OutOfTokenStreamException {
 		// case 1 val1 val2
 		// case 2 val1 [para1]
@@ -255,6 +329,21 @@ public class Parse {
 			return new FalseValue();
 	}
 
+	private Node compareArithmeticValueAndValue(String val1, String val2, RelationOverDoublePair com) {
+		double d1 = 0, d2 = 0;
+		try {
+			d1 = Double.parseDouble(val1);
+			d2 = Double.parseDouble(val2);
+		} catch (NumberFormatException e) {
+			Error.printError(Main.language == Main.Language.JP ? "”‚Å‚È‚¢•¶Žš—ñ‚ðŽZp”äŠr‚µ‚Ä‚¢‚Ü‚·"
+					: "String that cannot be parsed as a number");			
+		}
+		if (com.hasRelation(d1, d2))
+			return new TrueValue();
+		else 
+			return new FalseValue();
+	}
+	
 	private Node compareParameterAndValue(String para, String val) {
 		int parameterID = 0;
 		Parameter p;
@@ -298,6 +387,58 @@ public class Parse {
 		}
 	}
 
+	private Node compareArithmeticParameterAndValue(String para, String val, RelationOverDoublePair com) {
+		int parameterID = 0;
+		Parameter p;
+		// int value = 0;
+		List<Integer> valueIDs = null;
+
+		// ˆöŽq–¼‚ª³‚µ‚¢‚©ƒ`ƒFƒbƒN
+		try {
+			parameterID = parameterList.getID(para);
+		} catch (NoParameterNameException e) {
+			Error.printError(Main.language == Main.Language.JP ? "§–ñ’†‚̈öŽq–¼‚ÉŒë‚肪‚ ‚è‚Ü‚·"
+					: "Invalid parameter name in constraints");
+		}
+		p = parameterList.get(parameterID);
+
+		// ’l–¼‚ª” number ‚Æ‚È‚é‚©ƒ`ƒFƒbƒN
+		double number = 0;
+		try {
+			number = Double.parseDouble(val);
+		} catch (NumberFormatException e) {
+			Error.printError(Main.language == Main.Language.JP ? "”‚Å‚È‚¢•¶Žš—ñ‚ðŽZp”äŠr‚µ‚Ä‚¢‚Ü‚·"
+					: "String that cannot be parsed as a number");		
+		}
+
+		// number‚ÆŽZp“I‚Ɉê’v‚·‚élevel‚ð‚·‚×‚ÄƒŠƒXƒg‚É‚¢‚ê‚é
+		// -> level ŠÖŒW number ‚Æ‚È‚élevel‚ð‚·‚×‚ÄƒŠƒXƒg‚É
+		valueIDs = p.getID(number, com);
+		
+		// ‚Ç‚ê‚àˆê’v‚¹‚¸
+		if (valueIDs.size() == 0) {
+			return new FalseValue();
+		}
+		// ’l–¼‚ɏd•¡‚È‚µ
+		if (valueIDs.size() == 1) {
+			ComparisonOfParameterAndValue res = new EqualityOfParameterAndValue();
+			res.p = parameterID;
+			res.v = valueIDs.get(0);
+			return res;
+		}
+		// ’l–¼‚ɏd•¡‚ ‚è
+		else {
+			BooleanMultinaryOperator res = new OrOperator();
+			for (Integer vid : valueIDs) {
+				ComparisonOfParameterAndValue child = new EqualityOfParameterAndValue();
+				child.p = parameterID;
+				child.v = vid;
+				res.ChildList.add(child);
+			}
+			return res;
+		}
+	}
+	
 	private Node compareParameterAndParameter(String para1, String para2) {
 		int parameterID1 = 0;
 		int parameterID2 = 0;
@@ -353,7 +494,7 @@ public class Parse {
 			}
 		}
 
-		// case 3: ’l–¼‚Å“¯‚¶‚à‚Ì‚ª2ŒÂˆÈã
+		// case 3: ’l–¼‚Å“¯‚¶‚à‚Ì‚ª2ŒÂˆÈã  —vdebug ‰½‚Å case 2‚Ý‚½‚¢‚É‚µ‚Ä‚È‚¢‚́H
 		BooleanMultinaryOperator res = new OrOperator();
 		for (int vid1 = 0; vid1 < p1.value_name.size(); vid1++) {
 			for (int vid2 = 0; vid2 < p2.value_name.size(); vid2++) {
@@ -374,8 +515,125 @@ public class Parse {
 		return res;
 	}
 
+	private Node compareArithmeticParameterAndParameter(String para1, String para2, RelationOverDoublePair com) {
+		int parameterID1 = 0;
+		int parameterID2 = 0;
+		Parameter p1, p2;
+		// ˆöŽq–¼‚ª³‚µ‚¢‚©ƒ`ƒFƒbƒN
+		try {
+			parameterID1 = parameterList.getID(para1);
+			parameterID2 = parameterList.getID(para2);
+		} catch (NoParameterNameException e) {
+			Error.printError(Main.language == Main.Language.JP ? "§–ñ’†‚̈öŽq–¼‚ÉŒë‚肪‚ ‚è‚Ü‚·"
+					: "Invalid parameter name in constraints");
+		}
+		p1 = parameterList.get(parameterID1);
+		p2 = parameterList.get(parameterID2);
+
+		// ƒ_ƒuƒ‹‚Å‚Ì’l‚ªŠÖŒW‚ð‚à‚ƒyƒA‚𐔂¦‚é
+		int count = 0;
+		for (String valName1 : p1.value_name) {
+			for (String valName2 : p2.value_name) {
+				try {
+					double num1 = Double.parseDouble(valName1);
+					double num2 = Double.parseDouble(valName2);
+					if (com.hasRelation(num1, num2))
+						count++;
+				} catch (NumberFormatException e) {
+				}
+			}
+		}
+		
+		// case 1: ˆê’v‚·‚é’l–¼‚ª‚È‚¢
+		if (count == 0)
+			return new FalseValue();
+
+		// case 2: ˆê’v‚·‚é‚àƒyƒA‚ª‚ЂƂÂ
+		if (count == 1) {
+			for (String valName1 : p1.value_name) {
+				for (String valName2 : p2.value_name) {
+					try {
+						double num1 = Double.parseDouble(valName1);
+						double num2 = Double.parseDouble(valName2);
+						if (com.hasRelation(num1, num2)) {
+							BooleanMultinaryOperator res = new AndOperator();
+							ComparisonOfParameterAndValue sub1 = new EqualityOfParameterAndValue();
+							ComparisonOfParameterAndValue sub2 = new EqualityOfParameterAndValue();
+							try {
+								sub1.p = parameterID1;
+								sub1.v = p1.getID(valName1).get(0).byteValue(); 
+								sub2.p = parameterID2;
+								sub2.v = p2.getID(valName2).get(0).byteValue();
+							} catch (NoValueNameException e) {
+								Error.printError("Inner error");
+							}
+							res.ChildList.add(sub1);
+							res.ChildList.add(sub2);
+							return res;
+						}
+					} catch (NumberFormatException e) {}
+				} // inner for 
+			} // outer for
+		}
+
+		// case 3: ’l–¼‚Å“¯‚¶‚à‚Ì‚ª2ŒÂˆÈã
+		BooleanMultinaryOperator res = new OrOperator();
+		for (int vid1 = 0; vid1 < p1.value_name.size(); vid1++) {
+			for (int vid2 = 0; vid2 < p2.value_name.size(); vid2++) {
+				try {
+					double num1 = Double.parseDouble(p1.value_name.get(vid1));
+					double num2 = Double.parseDouble(p2.value_name.get(vid2));
+					if (com.hasRelation(num1, num2)) {
+						BooleanMultinaryOperator child = new AndOperator();
+						ComparisonOfParameterAndValue sub1 = new EqualityOfParameterAndValue();
+						ComparisonOfParameterAndValue sub2 = new EqualityOfParameterAndValue();
+						sub1.p = parameterID1;
+						sub1.v = vid1;
+						sub2.p = parameterID2;
+						sub2.v = vid2;
+						child.ChildList.add(sub1);
+						child.ChildList.add(sub2);
+						res.ChildList.add(child);
+					}
+				} catch (NumberFormatException e) {}
+			}
+		}
+		return res;
+	}
+}
+
+abstract class RelationOverDoublePair {
+	abstract boolean hasRelation(double leftval, double rightvalue);
+}
+
+class EqualTo extends RelationOverDoublePair {
+	boolean hasRelation(double leftval, double rightvalue) {
+		return leftval == rightvalue ? true : false;
+	}
+}
+class LessThan extends RelationOverDoublePair {
+	boolean hasRelation(double leftval, double rightvalue) {
+		return leftval < rightvalue ? true : false;
+	}
 }
 
+class GreaterThan extends RelationOverDoublePair {
+	boolean hasRelation(double leftval, double rightvalue) {
+		return leftval > rightvalue ? true : false;
+	}
+}
+
+class LTE extends RelationOverDoublePair {
+	boolean hasRelation(double leftval, double rightvalue) {
+		return leftval <= rightvalue ? true : false;
+	}
+}
+
+class GTE extends RelationOverDoublePair {
+	boolean hasRelation(double leftval, double rightvalue) {
+		return leftval >= rightvalue ? true : false;
+	}
+}
 /*
  * old one public class Parse { private TokenHandler t; private PList
  * parameterList; Parse(TokenHandler t, PList parameterList) { this.t = t;