Index: /ModelTranslator/resources/testdata/input/testModel_ChoicesDependOnChoices.rsf =================================================================== --- /ModelTranslator/resources/testdata/input/testModel_ChoicesDependOnChoices.rsf (revision 216) +++ /ModelTranslator/resources/testdata/input/testModel_ChoicesDependOnChoices.rsf (revision 216) @@ -0,0 +1,16 @@ +#startchoice +Choice CHOICE required boolean +#choice value +ChoiceItem A CHOICE +Item A boolean +#choice value +ChoiceItem B CHOICE +Item B boolean +#choice value +ChoiceItem C CHOICE +Item C boolean +#choice value +ChoiceItem D CHOICE +Item D boolean +Depends D "A" +#endchoice Index: /ModelTranslator/src/de/uni_hildesheim/sse/trans/in/rsf/RSFChoice.java =================================================================== --- /ModelTranslator/src/de/uni_hildesheim/sse/trans/in/rsf/RSFChoice.java (revision 215) +++ /ModelTranslator/src/de/uni_hildesheim/sse/trans/in/rsf/RSFChoice.java (revision 216) @@ -2,5 +2,7 @@ import java.util.ArrayList; +import java.util.HashMap; import java.util.List; +import java.util.Map; import de.uni_hildesheim.sse.model.cst.ConstraintSyntaxTree; @@ -23,7 +25,10 @@ private RSFItem choiceItem; - private List choiceItems; - - private List choiceItemConditions; + + /** + * Stores all choice items and their depends conditions. + */ + private Map> choiceItems; + private String choiceCondition; @@ -34,6 +39,5 @@ RSFChoice(RSFItem choiceItem) { this.choiceItem = choiceItem; - choiceItems = new ArrayList(); - choiceItemConditions = new ArrayList(); + choiceItems = new HashMap>(); } @@ -43,12 +47,16 @@ */ void addChoiceItem(RSFItem item) { - choiceItems.add(item); + if (!choiceItems.containsKey(item)) { + choiceItems.put(item, new ArrayList()); + } } /** * Adds a constraint of a choice item of this choice. + * + * @param item The choice item. * @param condition The condition as read from a depends line in the .rsf file. */ - void addChoiceItemDepends(String condition) { + void addChoiceItemDepends(RSFItem item, String condition) { // TODO error handling if only one is true? if (condition.startsWith("\"") && condition.endsWith("\"")) { @@ -56,5 +64,12 @@ } - choiceItemConditions.add(condition); + List constraints = choiceItems.get(choiceItem); + if (constraints != null) { + constraints.add(condition); + } else { + constraints = new ArrayList(); + constraints.add(condition); + choiceItems.put(item, constraints); + } } @@ -83,4 +98,9 @@ RSFDependsCondition getAdditionalDependsCondition() { RSFDependsCondition result = null; + + List choiceItemConditions = new ArrayList(); + for (List conditions : choiceItems.values()) { + choiceItemConditions.addAll(conditions); + } if (choiceItemConditions.size() > 0) { @@ -126,17 +146,31 @@ ConstraintSyntaxTree allItemsTree = notChoiceVar; + RSFItem[] choiceItemsArray = choiceItems.keySet().toArray(new RSFItem[] {}); + // And for each unique combination of choiceItems: - for (int i = 0; i < choiceItems.size(); i++) { - ConstraintSyntaxTree var1 = getSelectedVariable(choiceItems.get(i), reader); - ConstraintSyntaxTree notVar1 = getUnselectedVariable(choiceItems.get(i), reader); - - for (int j = i + 1; j < choiceItems.size(); j++) { - // Add the 2 variables negated and OR'd together: (to make sure that only one or less vars are selected) - ConstraintSyntaxTree notVar2 = getUnselectedVariable(choiceItems.get(j), reader); + for (int i = 0; i < choiceItemsArray.length; i++) { + ConstraintSyntaxTree var1 = getSelectedVariable(choiceItemsArray[i], reader); + ConstraintSyntaxTree notVar1 = getUnselectedVariable(choiceItemsArray[i], reader); + + // Only include choice items in the XOR, which do not depend on other choice items + if (!dependsOnOtherChoiceItems(choiceItemsArray[i])) { + + for (int j = i + 1; j < choiceItemsArray.length; j++) { + // Only include choice items in the XOR, which do not depend on other choice items + if (!dependsOnOtherChoiceItems(choiceItemsArray[j])) { + + // Add the 2 variables negated and OR'd together: + // (to make sure that only one or less vars are selected) + ConstraintSyntaxTree notVar2 = getUnselectedVariable( + choiceItemsArray[j], reader); + + trees.add(new OCLFeatureCall(notVar1, OclKeyWords.OR, notVar2)); + + } + } - trees.add(new OCLFeatureCall(notVar1, OclKeyWords.OR, notVar2)); - } - - allItemsTree = new OCLFeatureCall(allItemsTree, OclKeyWords.OR, var1); + allItemsTree = new OCLFeatureCall(allItemsTree, OclKeyWords.OR, var1); + + } // Add choiceVar or not var1 (to make sure that no variables are selected if choiceVar is false) @@ -151,4 +185,53 @@ return trees; + } + + /** + * Checks whether the given choice item depends on any other choice item. + * + * @param item The choice item that may depend on other choice items. + * @return true if the given choice item depends on other choice items. + */ + private boolean dependsOnOtherChoiceItems(RSFItem item) { + List constraints = choiceItems.get(item); + + boolean depends = false; + + if (constraints == null) { + LOGGER.error("dependsOnOtherChoiceItems() called with non-choice item"); + } else { + for (String constraint : constraints) { + if (containsChoiceItems(constraint, item.getName())) { + depends = true; + break; + } + } + } + + return depends; + } + + /** + * Checks whether the given constraint contains any choice item. + * + * @param constraint The constraint to be checked. + * @param exclude A choice item name to exclude from the list of choice items. + * @return true if the constraint contains any choice item. + */ + private boolean containsChoiceItems(String constraint, String exclude) { + boolean contains = false; + + for (RSFItem item : choiceItems.keySet()) { + String name = item.getName(); + if (name.equals(exclude)) { + continue; + } + if (constraint.contains(name)) { // TODO + contains = true; + break; + } + } + + return contains; } @@ -168,7 +251,5 @@ // for each choiceItem - for (int i = 0; i < choiceItems.size(); i++) { - RSFItem currentItem = choiceItems.get(i); - + for (RSFItem currentItem : choiceItems.keySet()) { if (!currentItem.getDatatype().equals(Datatype.TRISTATE)) { LOGGER.error("tristate choice (" + choiceItem.getName() + ") has non-tristate ChoiceItems"); Index: /ModelTranslator/src/de/uni_hildesheim/sse/trans/in/rsf/RSFReader.java =================================================================== --- /ModelTranslator/src/de/uni_hildesheim/sse/trans/in/rsf/RSFReader.java (revision 215) +++ /ModelTranslator/src/de/uni_hildesheim/sse/trans/in/rsf/RSFReader.java (revision 216) @@ -346,5 +346,5 @@ RSFChoice choice = choices.get(choiceParent); if (choice != null) { - choice.addChoiceItemDepends(columns[2]); + choice.addChoiceItemDepends(item, columns[2]); } else { // TODO Index: /ModelTranslator/test/de/uni_hildesheim/sse/trans/scenario/RsfToDimacsTranslationTest.java =================================================================== --- /ModelTranslator/test/de/uni_hildesheim/sse/trans/scenario/RsfToDimacsTranslationTest.java (revision 215) +++ /ModelTranslator/test/de/uni_hildesheim/sse/trans/scenario/RsfToDimacsTranslationTest.java (revision 216) @@ -118,9 +118,9 @@ * Test whether following constraints are included: * - Depends constraints: - * ° EXTRA_FIRMWARE depends FW_LOADER - * ° EXTRA_FIRMWARE_DIR depends EXTRA_FIRMWARE!='' + * � EXTRA_FIRMWARE depends FW_LOADER + * � EXTRA_FIRMWARE_DIR depends EXTRA_FIRMWARE!='' * - Translated DIMACS constraints - * ° FW_LOADER OR NOT(EXTRA_FIRMWARE) - * ° EXTRA_FIRMWARE OR NOT(EXTRA_FIRMWARE_DIRs) + * � FW_LOADER OR NOT(EXTRA_FIRMWARE) + * � EXTRA_FIRMWARE OR NOT(EXTRA_FIRMWARE_DIRs) */ Assert.assertTrue("Error: Expected Constraint not included.", @@ -318,4 +318,79 @@ Assert.assertTrue("Error: Missing constraint", DimacsTestUtils.containsConstraint(result, -choice12, a, b, c, d)); + } + + /** + * Tests whether choices that contain choice items that depend on each other + * are translated correctly into CNF constraints. + */ + @Test + public void testChoicesDependOnChoices() { + File input = new File(AllTests.INPUT_FOLDER, "testModel_ChoicesDependOnChoices.rsf"); + OptimizationParameter noOptimization = new OptimizationParameter(); + // Test precondition + Assert.assertFalse(noOptimization.hasAtLeastOneOption()); + // Translation + String result = DimacsTestUtils.loadModel(input, noOptimization, true); + + int choice = DimacsTestUtils.getNumberOfVariable(result, "CHOICE"); + int a = DimacsTestUtils.getNumberOfVariable(result, "A"); + int b = DimacsTestUtils.getNumberOfVariable(result, "B"); + int c = DimacsTestUtils.getNumberOfVariable(result, "C"); + int d = DimacsTestUtils.getNumberOfVariable(result, "D"); + + /* + * Test whether the following constraints are included: + * NOT(A) OR NOT(B) + * NOT(A) OR NOT(C) + * NOT(B) OR NOT(C) + * + * NOT(CHOICE) or A OR B or C + * + * CHOICE or NOT(A) + * CHOICE or NOT(B) + * CHOICE or NOT(C) + * CHOICE or NOT(D) + * + * NOT(D) or A + */ + Assert.assertTrue("Error: Missing choice constraint", + DimacsTestUtils.containsConstraint(result, -a, -b)); + Assert.assertTrue("Error: Missing choice constraint", + DimacsTestUtils.containsConstraint(result, -a, -c)); + Assert.assertTrue("Error: Missing choice constraint", + DimacsTestUtils.containsConstraint(result, -b, -c)); + + Assert.assertTrue("Error: Missing choice constraint", + DimacsTestUtils.containsConstraint(result, -choice, a, b, c)); + + Assert.assertTrue("Error: Missing choice constraint", + DimacsTestUtils.containsConstraint(result, choice, -a)); + Assert.assertTrue("Error: Missing choice constraint", + DimacsTestUtils.containsConstraint(result, choice, -b)); + Assert.assertTrue("Error: Missing choice constraint", + DimacsTestUtils.containsConstraint(result, choice, -c)); + Assert.assertTrue("Error: Missing choice constraint", + DimacsTestUtils.containsConstraint(result, choice, -d)); + + Assert.assertTrue("Error: Missing choice constraint", + DimacsTestUtils.containsConstraint(result, -d, a)); + + /* + * Test whether the following constraints are NOT included: + * NOT(A) or NOT(D) + * NOT(B) or NOT(D) + * NOT(C) or NOT(D) + * + * NOT(CHOICE) or A or B or C or D + */ + Assert.assertFalse("Error: Unwanted choice constraint included", + DimacsTestUtils.containsConstraint(result, -a, -d)); + Assert.assertFalse("Error: Unwanted choice constraint included", + DimacsTestUtils.containsConstraint(result, -b, -d)); + Assert.assertFalse("Error: Unwanted choice constraint included", + DimacsTestUtils.containsConstraint(result, -c, -d)); + + Assert.assertFalse("Error: Unwanted choice constraint included", + DimacsTestUtils.containsConstraint(result, -choice, a, b, c, d)); }