Variability-aware patching of software product-line variants

src/main/java/org/variantsync/diffdetective/experiments/thesis_pm/PatchScenario.java

@@ -0,0 +1,40 @@
+package org.variantsync.diffdetective.experiments.thesis_pm;
+
+import org.variantsync.diffdetective.variation.DiffLinesLabel;
+import org.variantsync.diffdetective.variation.Label;
+import org.variantsync.diffdetective.variation.diff.Time;
+import org.variantsync.diffdetective.variation.diff.VariationDiff;
+import org.variantsync.diffdetective.variation.diff.view.DiffView;
+import org.variantsync.diffdetective.variation.tree.VariationTree;
+import org.variantsync.diffdetective.variation.tree.view.TreeView;
+import org.variantsync.diffdetective.variation.tree.view.relevance.Configure;
+import org.variantsync.diffdetective.variation.tree.view.relevance.ConfigureWithFullConfig;
+import org.variantsync.diffdetective.variation.tree.view.relevance.Unchanged;
+
+public class PatchScenario<L extends Label> {
+	public VariationDiff<L> sourcePatch;
+	public VariationTree<L> targetVariantBefore;
+	public VariationDiff<L> patchGroundTruth;
+	public VariationTree<L> patchedVariantGroundTruth;
+	public ConfigureWithFullConfig sourceVariantConfig;
+	public ConfigureWithFullConfig targetVariantConfig;
+	public VariationTree<DiffLinesLabel> sourceVariantAfterRedToCrossVarFeatures;
+	public Unchanged unchangedAfter;
+	public VariationTree<DiffLinesLabel> targetVariantBeforeRedToUnchanged;
+
+	public PatchScenario(VariationDiff<L> sourcePatch,
+ VariationTree<L> targetVariantBefore, VariationDiff<L> patchGroundTruth,
+ VariationTree<L> patchedVariantGroundTruth, ConfigureWithFullConfig sourceVariantConfig, ConfigureWithFullConfig targetVariantConfig) {
+ this.sourcePatch = sourcePatch;
+ this.targetVariantBefore = targetVariantBefore;
+ this.patchGroundTruth = patchGroundTruth;
+ this.patchedVariantGroundTruth = patchedVariantGroundTruth;
+ this.sourceVariantConfig = sourceVariantConfig;
+ this.targetVariantConfig = targetVariantConfig;
+ this.sourceVariantAfterRedToCrossVarFeatures = (VariationTree<DiffLinesLabel>) TreeView.tree(sourcePatch.project(Time.AFTER), this.targetVariantConfig);
+ VariationDiff<DiffLinesLabel> sourcePatchConfiguredToCrossVarFeatures = (VariationDiff<DiffLinesLabel>) DiffView.optimized(sourcePatch, targetVariantConfig);
+ this.unchangedAfter = new Unchanged((VariationDiff<DiffLinesLabel>) sourcePatchConfiguredToCrossVarFeatures, Time.AFTER); 
+ Unchanged unchangedBefore = new Unchanged((VariationDiff<DiffLinesLabel>) sourcePatchConfiguredToCrossVarFeatures, Time.BEFORE);
+ this.targetVariantBeforeRedToUnchanged = (VariationTree<DiffLinesLabel>) TreeView.tree(this.targetVariantBefore, unchangedBefore);
+	}
+}

src/main/java/org/variantsync/diffdetective/experiments/thesis_pm/Utils.java

@@ -0,0 +1,119 @@
+package org.variantsync.diffdetective.experiments.thesis_pm;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+import org.eclipse.jgit.diff.DiffAlgorithm;
+import org.eclipse.jgit.diff.DiffAlgorithm.SupportedAlgorithm;
+import org.variantsync.diffdetective.diff.result.DiffParseException;
+import org.variantsync.diffdetective.variation.DiffLinesLabel;
+import org.variantsync.diffdetective.variation.Label;
+import org.variantsync.diffdetective.variation.diff.DiffNode;
+import org.variantsync.diffdetective.variation.diff.VariationDiff;
+import org.variantsync.diffdetective.variation.diff.parse.VariationDiffParseOptions;
+import org.variantsync.diffdetective.variation.tree.VariationTree;
+import org.variantsync.diffdetective.variation.tree.view.TreeView;
+import org.variantsync.diffdetective.variation.tree.view.relevance.ConfigureWithFullConfig;
+import org.variantsync.diffdetective.variation.tree.view.relevance.Unchanged;
+import org.variantsync.functjonal.Pair;
+
+public class Utils {
+
+	public static boolean comparePatchedVariantWithExpectedResult(VariationTree<DiffLinesLabel> patchedVariant,
+ VariationTree<DiffLinesLabel> expectedResult) {
+ return Utils.isSameAs(patchedVariant.toCompletelyUnchangedVariationDiff(),
+ expectedResult.toCompletelyUnchangedVariationDiff());
+	}
+
+	public static Pair<Boolean, Boolean> arePatchedVariantsEquivalent(
+ VariationTree<DiffLinesLabel> patchedTargetVariant,
+ VariationTree<DiffLinesLabel> sourceVariantAfterRedToCrossVarFeatures,
+ VariationTree<DiffLinesLabel> targetVariantBeforeRedToUnchanged, ConfigureWithFullConfig configSourceVariant,
+ Unchanged unchangedAfter) {
+
+ VariationTree<DiffLinesLabel> targetVariantAfterRedToCrossVarFeatures = TreeView.tree(patchedTargetVariant,
+ configSourceVariant);
+
+ VariationTree<DiffLinesLabel> patchedTargetVariantRedToUnchanged = TreeView.tree(patchedTargetVariant,
+ unchangedAfter);
+
+	// GameEngine.showAndAwaitAll(Show.tree(patchedTargetVariant, "patched target variant"),
+	// Show.tree(patchedTargetVariantRedToUnchanged, "patched target variant red. to unchanged"),
+	// Show.tree(sourceVariantAfterRedToCrossVarFeatures,
+	// "patched source variant red. to cross variant features"),
+	// Show.tree(targetVariantAfterRedToCrossVarFeatures,
+	// "patched target variant red. to cross variant features"),
+	// Show.tree(targetVariantBeforeRedToUnchanged, "target variant before red. to unchanged"));
+
+ return new Pair<Boolean, Boolean>(
+ sourceVariantAfterRedToCrossVarFeatures.unparse().equals(targetVariantAfterRedToCrossVarFeatures.unparse()),
+ patchedTargetVariantRedToUnchanged.unparse().equals(targetVariantBeforeRedToUnchanged.unparse()));
+
+ }
+
+	public static VariationDiff<DiffLinesLabel> parseVariationDiffFromFiles(String file1, String file2)
+ throws IOException, DiffParseException {
+ Path examplesDir = Path.of("data", "examples");
+ return VariationDiff.fromFiles(examplesDir.resolve(file1), examplesDir.resolve(file2),
+ DiffAlgorithm.SupportedAlgorithm.MYERS, VariationDiffParseOptions.Default);
+	}
+
+	public static VariationTree<DiffLinesLabel> parseVariationTreeFromFile(String file) {
+ Path examplesDir = Path.of("data", "examples");
+ Path path = examplesDir.resolve(file);
+ try {
+ VariationTree<DiffLinesLabel> tree = VariationTree.fromFile(path, VariationDiffParseOptions.Default);
+ return tree;
+ } catch (IOException e) {
+ e.printStackTrace();
+ } catch (DiffParseException e) {
+ e.printStackTrace();
+ }
+ return null;
+	}
+
+	public static VariationDiff<DiffLinesLabel> parseVariationDiffFromFile(String file)
+ throws IOException, DiffParseException {
+ Path examplesDir = Path.of("data", "examples");
+ return VariationDiff.fromFile(examplesDir.resolve(file), VariationDiffParseOptions.Default);
+	}
+
+	public static <L extends Label> boolean isSameAs(VariationDiff<L> diff1, VariationDiff<L> diff2) {
+ return Utils.isSameAs(diff1.getRoot(), diff2.getRoot());
+	}
+
+	public static <L extends Label> boolean isSameAs(DiffNode<L> a, DiffNode<L> b) {
+ return Utils.isSameAs(a, b, new HashSet<>());
+	}
+
+	public static <L extends Label> boolean isSameAs(DiffNode<L> a, DiffNode<L> b, Set<DiffNode<L>> visited) {
+ if (!visited.add(a)) {
+ return true;
+ }
+
+ if (!(a.getNodeType().equals(b.getNodeType()) && hasSameLabel(a.getLabel(), b.getLabel())
+ && (a.getFormula() == null ? b.getFormula() == null : a.getFormula().equals(b.getFormula())))) {
+ return false;
+ }
+
+ Iterator<DiffNode<L>> aIt = a.getAllChildren().iterator();
+ Iterator<DiffNode<L>> bIt = b.getAllChildren().iterator();
+ while (aIt.hasNext() && bIt.hasNext()) {
+ if (!isSameAs(aIt.next(), bIt.next(), visited)) {
+ return false;
+ }
+ }
+
+ return aIt.hasNext() == bIt.hasNext();
+	}
+
+	public static <L extends Label> boolean hasSameLabel(L a, L b) {
+ String labelA = a.toString().replaceAll(" ", "");
+ String labelB = b.toString().replaceAll(" ", "");
+ return labelA.equals(labelB);
+	}
+
+}

src/main/java/org/variantsync/diffdetective/shell/DiffCommand.java

@@ -0,0 +1,55 @@
+package org.variantsync.diffdetective.shell;
+
+import java.util.List;
+
+/** Single executable command with arguments. */
+public class DiffCommand extends ShellCommand {
+ private final String[] parts;
+ private boolean filesDifferent;
+
+ /**
+ * Constructs a single command.
+ * The first argument has to be a path to an executable which will be given all of the
+ * remaining arguments as parameters on execution.
+ *
+ * @param cmd executable path and arguments for the executable
+ */
+ public DiffCommand(final String... cmd) {
+ parts = cmd;
+ }
+
+ @Override
+ public String[] parts() {
+ return parts;
+ }
+
+ /**
+ * Interpret the result/exit code returned from a shell command.
+ * An {@code ShellException} is thrown if the result code is an error.
+ *
+ * @param resultCode the code that is to be parsed
+ * @param output the output of the shell command
+ * @return the output of the shell command
+ * @throws ShellException if {@code resultCode} is an error
+ */
+ @Override
+ public List<String> interpretResult(int resultCode, List<String> output) throws ShellException {
+ // inputs are the same
+ if (resultCode == 0) {
+ filesDifferent = false;
+ return output;
+ }
+ // if inputs are different
+ if (resultCode == 1) {
+ filesDifferent = true;
+ return output;
+ }
+ // everything else: "serious trouble": exit code 2
+ throw new ShellException(output);
+
+ }
+
+	public boolean areFilesDifferent() {
+ return filesDifferent;
+	}
+}

src/main/java/org/variantsync/diffdetective/shell/GnuPatchCommand.java

@@ -0,0 +1,55 @@
+package org.variantsync.diffdetective.shell;
+
+import java.util.List;
+
+/** Single executable command with arguments. */
+public class GnuPatchCommand extends ShellCommand {
+ private final String[] parts;
+ private boolean patchingSuccessful;
+
+ /**
+ * Constructs a single command.
+ * The first argument has to be a path to an executable which will be given all of the
+ * remaining arguments as parameters on execution.
+ *
+ * @param cmd executable path and arguments for the executable
+ */
+ public GnuPatchCommand(final String... cmd) {
+ parts = cmd;
+ }
+
+ @Override
+ public String[] parts() {
+ return parts;
+ }
+
+ /**
+ * Interpret the result/exit code returned from a shell command.
+ * An {@code ShellException} is thrown if the result code is an error.
+ *
+ * @param resultCode the code that is to be parsed
+ * @param output the output of the shell command
+ * @return the output of the shell command
+ * @throws ShellException if {@code resultCode} is an error
+ */
+ @Override
+ public List<String> interpretResult(int resultCode, List<String> output) throws ShellException {
+ // patching was successful
+ if (resultCode == 0) {
+ patchingSuccessful = true;
+ return null;
+ }
+ // some hunks cannot be applied or merge conflicts
+ if (resultCode == 1) {
+ patchingSuccessful = false;
+ return null;
+ }
+ // everything else: "serious trouble": exit code 2
+ throw new ShellException(output);
+
+ }
+
+	public boolean isPatchingSuccessful() {
+ return patchingSuccessful;
+	}
+}

src/main/java/org/variantsync/diffdetective/shell/MPatchCommand.java

@@ -0,0 +1,55 @@
+package org.variantsync.diffdetective.shell;
+
+import java.util.List;
+
+/** Single executable command with arguments. */
+public class MPatchCommand extends ShellCommand {
+ private final String[] parts;
+ private boolean patchingSuccessful;
+
+ /**
+ * Constructs a single command.
+ * The first argument has to be a path to an executable which will be given all of the
+ * remaining arguments as parameters on execution.
+ *
+ * @param cmd executable path and arguments for the executable
+ */
+ public MPatchCommand(final String... cmd) {
+ parts = cmd;
+ }
+
+ @Override
+ public String[] parts() {
+ return parts;
+ }
+
+ /**
+ * Interpret the result/exit code returned from a shell command.
+ * An {@code ShellException} is thrown if the result code is an error.
+ *
+ * @param resultCode the code that is to be parsed
+ * @param output the output of the shell command
+ * @return the output of the shell command
+ * @throws ShellException if {@code resultCode} is an error
+ */
+ @Override
+ public List<String> interpretResult(int resultCode, List<String> output) throws ShellException {
+ // patching was successful ???
+ if (resultCode == 0) {
+ patchingSuccessful = true;
+ return null;
+ }
+ // some hunks cannot be applied or merge conflicts ???
+ if (resultCode == 1) {
+ patchingSuccessful = false;
+ return null;
+ }
+ // everything else: "serious trouble": exit code 2 ???
+ throw new ShellException(output);
+
+ }
+
+	public boolean isPatchingSuccessful() {
+ return patchingSuccessful;
+	}
+}

src/main/java/org/variantsync/diffdetective/util/StringUtils.java

@@ -6,7 +6,7 @@
 /** A collection of useful utilities related to string processing. */
 public class StringUtils {
  /** An operating system independent line break used in almost all internal strings. */
- public final static String LINEBREAK = "\r\n";
+ public final static String LINEBREAK = "\n";
  /** A regex to identify line breaks of any operating system .*/
  public final static Pattern LINEBREAK_REGEX = Pattern.compile("\\r\\n|\\r|\\n");
 

src/main/java/org/variantsync/diffdetective/variation/diff/VariationDiff.java

@@ -378,16 +378,16 @@ public int count(final Predicate<DiffNode<L>> nodesToCount) {
  * This method is deterministic: It will return the feature names always in the same order, assuming the variation diff is not changed inbetween.
  * @return A set of every occuring feature name.
  */
- public LinkedHashSet<String> computeAllFeatureNames() {
- LinkedHashSet<String> features = new LinkedHashSet<>();
+ public LinkedHashSet<Object> computeAllFeatureNames() {
+ LinkedHashSet<Object> features = new LinkedHashSet<>();
  forAll(node -> {
  if (node.isConditionalAnnotation()) {
  features.addAll(node.getFormula().getUniqueContainedFeatures());
  }
  });
  // Since FeatureIDE falsely reports constants "True" and "False" as feature names, we have to remove them from the resulting set.
- features.removeIf(FixTrueFalse::isTrueLiteral);
- features.removeIf(FixTrueFalse::isFalseLiteral);
+ features.removeIf(f -> FixTrueFalse.isTrueLiteral((String) f));
+ features.removeIf(f -> FixTrueFalse.isFalseLiteral((String) f));
  return features;
  }