def test_error_guessing_redundancies_case_2() -> None:
feature_1 = Feature("A", None, None, True)
feature_2 = Feature("B", None, None, True)
feature_3 = Feature("C", None, None, True)
feature_4 = Feature("D", None, None, True)
relation_1 = Relation(feature_1, [feature_2], 0, 1)
relation_2 = Relation(feature_1, [feature_3], 1, 1)
relation_3 = Relation(feature_1, [feature_4], 1, 1)
feature_1.add_relation(relation_1)
feature_1.add_relation(relation_2)
feature_1.add_relation(relation_3)
node_1 = Node(ASTOperation.REQUIRES)
node_1.left = Node("C")
node_1.right = Node("B")
ast_1 = AST(node_1)
ctc_1 = Constraint("ctc_1", ast_1)
node_2 = Node(ASTOperation.REQUIRES)
node_2.left = Node("D")
node_2.right = Node("B")
ast_2 = AST(node_2)
ctc_2 = Constraint("ctc_2", ast_2)
model = FeatureModel(feature_1, [ctc_1, ctc_2])
path = normalize_path(
"error-guessing/redundancies/case2/r-case2")
run(path, model)
def test_error_guessing_dead_features_case_1() -> None:
feature_1 = Feature("A", None, None, True)
feature_2 = Feature("B", None, None, True)
feature_3 = Feature("C", None, None, True)
feature_4 = Feature("D", None, None, False)
feature_5 = Feature("E", None, None, True)
relation_1 = Relation(feature_1, [feature_2], 1, 1)
relation_2 = Relation(feature_1, [feature_3], 1, 1)
feature_1.add_relation(relation_1)
feature_1.add_relation(relation_2)
relation_3 = Relation(feature_3, [feature_4, feature_5], 1, 1)
feature_3.add_relation(relation_3)
node_1 = Node(ASTOperation.EXCLUDES)
node_1.left = Node("D")
node_1.right = Node("B")
ast_1 = AST(node_1)
ctc_1 = Constraint("ctc_1", ast_1)
model = FeatureModel(feature_1, [ctc_1])
path = normalize_path("error-guessing/dead-features/case1/df-case1")
run(path, model)
def test_relationships_or_alternative() -> None:
feature_1 = Feature("A", None, None, True)
feature_2 = Feature("B", None, None, True)
feature_3 = Feature("C", None, None, True)
feature_4 = Feature("D", None, None, True)
feature_5 = Feature("E", None, None, True)
feature_6 = Feature("F", None, None, True)
feature_7 = Feature("G", None, None, True)
feature_8 = Feature("H", None, None, True)
feature_9 = Feature("I", None, None, True)
relation_1 = Relation(feature_1, [feature_2, feature_3], 1, 1)
relation_2 = Relation(feature_1, [feature_4, feature_5], 1, 2)
feature_1.add_relation(relation_1)
feature_1.add_relation(relation_2)
relation_3 = Relation(feature_2, [feature_6, feature_7], 1, 2)
feature_2.add_relation(relation_3)
relation_4 = Relation(feature_5, [feature_8, feature_9], 1, 1)
feature_5.add_relation(relation_4)
model = FeatureModel(feature_1)
path = normalize_path(
"relationships/or-alternative/or-alternative")
run(path, model)
def test_relationships_requires_excludes() -> None:
feature_1 = Feature("A", None, None, True)
feature_2 = Feature("B", None, None, True)
feature_3 = Feature("C", None, None, True)
relation_1 = Relation(feature_1, [feature_2], 0, 1)
relation_2 = Relation(feature_1, [feature_3], 0, 1)
feature_1.add_relation(relation_1)
feature_1.add_relation(relation_2)
node_1 = Node(ASTOperation.REQUIRES)
node_1.left = Node("B")
node_1.right = Node("C")
ast_1 = AST(node_1)
ctc_1 = Constraint("ctc_1", ast_1)
node_2 = Node(ASTOperation.EXCLUDES)
node_2.left = Node("B")
node_2.right = Node("C")
ast_2 = AST(node_2)
ctc_2 = Constraint("ctc_1", ast_2)
model = FeatureModel(feature_1, [ctc_1, ctc_2])
path = normalize_path(
"relationships/requires-excludes/requires-excludes")
run(path, model)
def test_refinement_alternative_no_parent_last_child() -> None:
feature_1 = Feature("A", None, None, True)
feature_2 = Feature("B", None, None, True)
feature_3 = Feature("C", None, None, True)
feature_4 = Feature("D", None, None, True)
feature_5 = Feature("E", None, None, True)
relation_1 = Relation(feature_1, [feature_2], 0, 1)
relation_2 = Relation(feature_1, [feature_5], 1, 1)
feature_1.add_relation(relation_1)
feature_1.add_relation(relation_2)
relation_3 = Relation(feature_2, [feature_3, feature_4], 1, 1)
feature_2.add_relation(relation_3)
node_1 = Node(ASTOperation.EXCLUDES)
node_1.left = Node("E")
node_1.right = Node("B")
ast_1 = AST(node_1)
ctc_1 = Constraint("ctc_1", ast_1)
node_2 = Node(ASTOperation.REQUIRES)
node_2.left = Node("E")
node_2.right = Node("D")
ast_2 = AST(node_2)
ctc_2 = Constraint("ctc_2", ast_2)
model = FeatureModel(feature_1, [ctc_1, ctc_2])
path = normalize_path(
"refinement/alternative-noParentLastChild/alternative-noParentLastChild")
run(path, model)
def test_relationships_optional_or() -> None:
feature_1 = Feature("A", None, None, True)
feature_2 = Feature("B", None, None, True)
feature_3 = Feature("C", None, None, True)
feature_4 = Feature("D", None, None, True)
feature_5 = Feature("E", None, None, True)
feature_6 = Feature("F", None, None, True)
feature_7 = Feature("G", None, None, True)
relation_1 = Relation(feature_1, [feature_2], 0, 1)
relation_2 = Relation(feature_1, [feature_3, feature_4], 1, 2)
feature_1.add_relation(relation_1)
feature_1.add_relation(relation_2)
relation_3 = Relation(feature_2, [feature_5, feature_6], 1, 2)
feature_2.add_relation(relation_3)
relation_4 = Relation(feature_3, [feature_7], 0, 1)
feature_3.add_relation(relation_4)
model = FeatureModel(feature_1)
path = normalize_path(
"relationships/optional-or/optional-or")
run(path, model)
def test_refinement_df_alternative_excludes() -> None:
feature_1 = Feature("A", None, None, True)
feature_2 = Feature("B", None, None, True)
feature_3 = Feature("C", None, None, True)
feature_4 = Feature("D", None, None, True)
feature_5 = Feature("E", None, None, False)
relation_1 = Relation(feature_1, [feature_2], 1, 1)
relation_2 = Relation(feature_1, [feature_3], 0, 1)
feature_1.add_relation(relation_1)
feature_1.add_relation(relation_2)
relation_3 = Relation(feature_3, [feature_4, feature_5], 1, 1)
feature_3.add_relation(relation_3)
node_1 = Node(ASTOperation.REQUIRES)
node_1.left = Node("B")
node_1.right = Node("D")
ast_1 = AST(node_1)
ctc_1 = Constraint("ctc_1", ast_1)
model = FeatureModel(feature_1, [ctc_1])
path = normalize_path(
"refinement/df-alternative-excludes/df-alternative-excludes")
run(path, model)
def test_relationships_mandatory_optional() -> None:
feature_1 = Feature("A", None, None, True)
feature_2 = Feature("B", None, None, True)
feature_3 = Feature("C", None, None, True)
feature_4 = Feature("D", None, None, True)
feature_5 = Feature("E", None, None, True)
relation_1 = Relation(feature_1, [feature_2], 1, 1)
relation_2 = Relation(feature_1, [feature_3], 0, 1)
feature_1.add_relation(relation_1)
feature_1.add_relation(relation_2)
relation_3 = Relation(feature_2, [feature_4], 0, 1)
feature_2.add_relation(relation_3)
relation_4 = Relation(feature_3, [feature_5], 1, 1)
feature_3.add_relation(relation_4)
model = FeatureModel(feature_1)
path = normalize_path(
"relationships/mandatory-optional/mandatory-optional")
run(path, model)
def test_refinement_or_no_alternative() -> None:
feature_1 = Feature("A", None, None, True)
feature_2 = Feature("B", None, None, True)
feature_3 = Feature("C", None, None, True)
feature_4 = Feature("D", None, None, True)
feature_5 = Feature("E", None, None, False)
relation_1 = Relation(feature_1, [feature_2], 1, 1)
relation_2 = Relation(feature_1, [feature_5], 1, 1)
feature_1.add_relation(relation_1)
feature_1.add_relation(relation_2)
relation_3 = Relation(feature_2, [feature_3, feature_4], 1, 2)
feature_2.add_relation(relation_3)
node_1 = Node(ASTOperation.REQUIRES)
node_1.left = Node("E")
node_1.right = Node("D")
ast_1 = AST(node_1)
ctc_1 = Constraint("ctc_1", ast_1)
node_2 = Node(ASTOperation.REQUIRES)
node_2.left = Node("E")
node_2.right = Node("C")
ast_2 = AST(node_2)
ctc_2 = Constraint("ctc_2", ast_2)
model = FeatureModel(feature_1, [ctc_1, ctc_2])
path = normalize_path(
"refinement/or-noAlternative/or-noAlternative")
run(path, model)
def test_relationships_mandatory_alternative() -> None:
feature_1 = Feature("A", None, None, True)
feature_2 = Feature("B", None, None, True)
feature_3 = Feature("C", None, None, True)
feature_4 = Feature("D", None, None, True)
feature_5 = Feature("E", None, None, True)
feature_6 = Feature("F", None, None, True)
feature_7 = Feature("G", None, None, True)
relation_1 = Relation(feature_1, [feature_2], 1, 1)
relation_2 = Relation(feature_1, [feature_3, feature_4], 1, 1)
feature_1.add_relation(relation_1)
feature_1.add_relation(relation_2)
relation_3 = Relation(feature_2, [feature_5, feature_6], 1, 1)
feature_2.add_relation(relation_3)
relation_4 = Relation(feature_3, [feature_7], 1, 1)
feature_3.add_relation(relation_4)
model = FeatureModel(feature_1)
path = normalize_path(
"relationships/mandatory-alternative/mandatory-alternative")
run(path, model)
def test_error_guessing_dead_features_case_8() -> None:
feature_1 = Feature("A", None, None, True)
feature_2 = Feature("B", None, None, False)
feature_3 = Feature("C", None, None, True)
relation_1 = Relation(feature_1, [feature_2], 0, 1)
relation_2 = Relation(feature_1, [feature_3], 0, 1)
feature_1.add_relation(relation_1)
feature_1.add_relation(relation_2)
node_1 = Node(ASTOperation.EXCLUDES)
node_1.left = Node("B")
node_1.right = Node("C")
ast_1 = AST(node_1)
ctc_1 = Constraint("ctc_1", ast_1)
node_2 = Node(ASTOperation.REQUIRES)
node_2.left = Node("B")
node_2.right = Node("C")
ast_2 = AST(node_2)
ctc_2 = Constraint("ctc_1", ast_2)
model = FeatureModel(feature_1, [ctc_1, ctc_2])
path = normalize_path("error-guessing/dead-features/case8/df-case8")
run(path, model)
def test_error_guessing_false_optional_features_case_3() -> None:
feature_1 = Feature("A", None, None, True)
feature_2 = Feature("B", None, None, True)
feature_3 = Feature("C", None, None, False)
feature_4 = Feature("D", None, None, False)
feature_5 = Feature("E", None, None, True)
relation_1 = Relation(feature_1, [feature_2], 1, 1)
relation_2 = Relation(feature_1, [feature_3], 0, 1)
feature_1.add_relation(relation_1)
feature_1.add_relation(relation_2)
relation_3 = Relation(feature_3, [feature_4, feature_5], 1, 2)
feature_3.add_relation(relation_3)
node_1 = Node(ASTOperation.REQUIRES)
node_1.left = Node("B")
node_1.right = Node("D")
ast_1 = AST(node_1)
ctc_1 = Constraint("ctc_1", ast_1)
model = FeatureModel(feature_1, [ctc_1])
path = normalize_path(
"error-guessing/false-optional-features/case3/fof-case3")
run(path, model)
def parse_relation( # pylint:disable=no-self-use
self,
relation_type: str,
feature_parent: Feature,
c_max: int = None
) -> Relation:
if relation_type in ("Mandatory", "Alternative"):
relation = Relation(parent=feature_parent, children=[], card_min=1, card_max=1)
elif relation_type == "Optional":
relation = Relation(parent=feature_parent, children=[], card_min=0, card_max=1)
elif relation_type == "Or":
relation = Relation(parent=feature_parent, children=[], card_min=1, card_max=c_max)
feature_parent.relations.append(relation)
return relation
def parse_relation(self, relation_type: str,
feature_parent: Feature) -> Relation:
if relation_type in ('Mandatory', 'Alternative/Or'):
relation = Relation(parent=feature_parent,
children=[],
card_min=1,
card_max=1)
elif relation_type == 'Optional':
relation = Relation(parent=feature_parent,
children=[],
card_min=0,
card_max=1)
feature_parent.relations.append(relation)
return relation
def add_or(self, new_feature1, new_feature2) -> None:
self.feature_counter += 1
number = random.randrange(len(self.fm.get_features()))
random_feature = self.fm.get_features()[number]
self.fm.features.append(new_feature1)
self.fm.features.append(new_feature2)
r = Relation(parent=random_feature,
children=[new_feature1, new_feature2],
card_min=1,
card_max=2)
random_feature.relations.append(r)
new_products = []
for product in self.products:
if random_feature.name not in product:
new_products.append(product)
else:
base = [feat for feat in product]
new_product1 = copy.copy(base)
new_product2 = copy.copy(base)
new_product3 = copy.copy(base)
new_product1.append(new_feature1.name)
new_product2.append(new_feature2.name)
new_product3.append(new_feature1.name)
new_product3.append(new_feature2.name)
new_products.append(new_product1)
new_products.append(new_product2)
new_products.append(new_product3)
self.products = new_products
def test_refinement_optional_alternative_valid_p() -> None:
feature_1 = Feature("A", None, None, True)
feature_2 = Feature("B", None, None, True)
feature_3 = Feature("C", None, None, True)
feature_4 = Feature("D", None, None, True)
relation_1 = Relation(feature_1, [feature_2], 0, 1)
feature_1.add_relation(relation_1)
relation_2 = Relation(feature_2, [feature_3, feature_4], 1, 1)
feature_2.add_relation(relation_2)
model = FeatureModel(feature_1)
path = normalize_path(
"refinement/optional-alternativeValidP/optional-alternativeVP")
run(path, model)
def test_error_guessing_core_features_case_6() -> None:
feature_1 = Feature("A", None, None, True)
feature_2 = Feature("B", None, None, True)
feature_3 = Feature("C", None, None, True)
relation_1 = Relation(feature_1, [feature_2], 1, 1)
relation_2 = Relation(feature_1, [feature_3], 1, 1)
feature_1.add_relation(relation_1)
feature_1.add_relation(relation_2)
node_1 = Node(ASTOperation.EXCLUDES)
node_1.left = Node("B")
node_1.right = Node("C")
ast_1 = AST(node_1)
ctc_1 = Constraint("ctc_1", ast_1)
model = FeatureModel(feature_1, [ctc_1])
path = normalize_path("error-guessing/core-features/case6/cf-case6")
run(path, model)
def test_relationships_mandatory_excludes() -> None:
feature_1 = Feature("A", None, None, True)
feature_2 = Feature("B", None, None, True)
feature_3 = Feature("C", None, None, True)
relation_1 = Relation(feature_1, [feature_2], 1, 1)
relation_2 = Relation(feature_1, [feature_3], 1, 1)
feature_1.add_relation(relation_1)
feature_1.add_relation(relation_2)
node_1 = Node(ASTOperation.EXCLUDES)
node_1.left = Node("B")
node_1.right = Node("C")
ast_1 = AST(node_1)
ctc_1 = Constraint("ctc_1", ast_1)
model = FeatureModel(feature_1, [ctc_1])
path = normalize_path(
"relationships/mandatory-excludes/mandatory-excludes")
run(path, model)
def test_relationships_mandatory() -> None:
feature_1 = Feature("A", None, None, True)
feature_2 = Feature("B", None, None, True)
relation_1 = Relation(feature_1, [feature_2], 1, 1)
feature_1.add_relation(relation_1)
model = FeatureModel(feature_1)
path = normalize_path(
"relationships/mandatory/mandatory")
run(path, model)
def test_relationships_optional() -> None:
feature_1 = Feature("A", None, None, True)
feature_2 = Feature("B", None, None, True)
relation_1 = Relation(feature_1, [feature_2], 0, 1)
feature_1.add_relation(relation_1)
model = FeatureModel(feature_1)
path = normalize_path(
"relationships/optional/optional")
run(path, model)
def parse_relation(self, element) -> Relation:
relation = Relation(parent=None, children=[], card_min=0, card_max=0)
if element.tag.casefold() == 'binaryrelation':
num_solitary_features = 0
for child in element:
if child.tag.casefold() == 'solitaryfeature':
num_solitary_features += 1
feature = self.parse_feature(child)
relation.children.append(feature)
elif child.tag.casefold() == 'cardinality':
relation.card_min = int(child.attrib.get('min'))
relation.card_max = int(child.attrib.get('max'))
else:
print("This XML contains non supported elements",
file=sys.stderr)
elif element.tag.casefold() == 'setrelation':
for child in element:
if child.tag.casefold() == 'groupedfeature':
feature = self.parse_feature(child)
relation.children.append(feature)
elif child.tag.casefold() == 'cardinality':
relation.card_min = int(child.attrib.get('min'))
relation.card_max = int(child.attrib.get('max'))
else:
print("This XML contains non supported elements",
file=sys.stderr)
else:
raise RuntimeError("Something is wrong on the xml")
return relation
def test_relationships_alternative() -> None:
feature_1 = Feature("A", None, None, True)
feature_2 = Feature("B", None, None, True)
feature_3 = Feature("C", None, None, True)
relation_1 = Relation(feature_1, [feature_2, feature_3], 1, 1)
feature_1.add_relation(relation_1)
model = FeatureModel(feature_1)
path = normalize_path(
"relationships/alternative/alternative")
run(path, model)
def test_relationships_allrelationships() -> None:
feature_1 = Feature("A", None, None, True)
feature_2 = Feature("B", None, None, True)
feature_3 = Feature("C", None, None, True)
feature_4 = Feature("D", None, None, True)
feature_5 = Feature("E", None, None, True)
feature_6 = Feature("F", None, None, True)
feature_7 = Feature("G", None, None, True)
relation_1 = Relation(feature_1, [feature_2], 1, 1)
relation_2 = Relation(feature_1, [feature_3], 0, 1)
feature_1.add_relation(relation_1)
feature_1.add_relation(relation_2)
relation_3 = Relation(feature_2, [feature_4, feature_5], 1, 1)
feature_2.add_relation(relation_3)
relation_4 = Relation(feature_3, [feature_6, feature_7], 1, 2)
feature_3.add_relation(relation_4)
node_1 = Node(ASTOperation.REQUIRES)
node_1.left = Node("E")
node_1.right = Node("F")
ast_1 = AST(node_1)
ctc_1 = Constraint("ctc_1", ast_1)
node_2 = Node(ASTOperation.EXCLUDES)
node_2.left = Node("D")
node_2.right = Node("G")
ast_2 = AST(node_2)
ctc_2 = Constraint("ctc_2", ast_2)
model = FeatureModel(feature_1, [ctc_1, ctc_2])
path = normalize_path(
"relationships/allrelationships/allrelationships")
run(path, model)
def add_mandatory(self, new_feature) -> None:
number = random.randrange(len(self.fm.get_features()))
random_feature = self.fm.get_features()[number]
self.fm.features.append(new_feature)
r = Relation(parent=random_feature,
children=[new_feature],
card_min=1,
card_max=1)
random_feature.relations.append(r)
for product in self.products:
if random_feature.name in product:
product.append(new_feature.name)
def test_refinement_alternative_odd_children() -> None:
feature_1 = Feature("A", None, None, True)
feature_2 = Feature("B", None, None, True)
feature_3 = Feature("C", None, None, True)
feature_4 = Feature("D", None, None, True)
feature_5 = Feature("E", None, None, True)
feature_6 = Feature("F", None, None, True)
feature_7 = Feature("G", None, None, True)
feature_8 = Feature("H", None, None, True)
relation_1 = Relation(feature_1, [feature_2], 1, 1)
relation_2 = Relation(feature_1, [feature_8], 1, 1)
feature_1.add_relation(relation_1)
feature_1.add_relation(relation_2)
relation_3 = Relation(
feature_2, [feature_3, feature_4, feature_5, feature_6, feature_7], 1, 1)
feature_2.add_relation(relation_3)
node_1 = Node(ASTOperation.REQUIRES)
node_1.left = Node("H")
node_1.right = Node("G")
ast_1 = AST(node_1)
ctc_1 = Constraint("ctc_1", ast_1)
node_2 = Node(ASTOperation.REQUIRES)
node_2.left = Node("H")
node_2.right = Node("E")
ast_2 = AST(node_2)
ctc_2 = Constraint("ctc_2", ast_2)
model = FeatureModel(feature_1, [ctc_1, ctc_2])
path = normalize_path(
"refinement/alternative-oddChildren/alternative-oddChildren")
run(path, model)
def test_error_guessing_core_features_case_2() -> None:
feature_1 = Feature("A", None, None, False)
feature_2 = Feature("B", None, None, False)
relation_1 = Relation(feature_1, [feature_2], 0, 1)
feature_1.add_relation(relation_1)
node_1 = Node(ASTOperation.REQUIRES)
node_1.left = Node("A")
node_1.right = Node("B")
ast_1 = AST(node_1)
ctc_1 = Constraint("ctc_1", ast_1)
model = FeatureModel(feature_1, [ctc_1])
path = normalize_path("error-guessing/core-features/case2/cf-case2")
run(path, model)
def add_optional(self, new_feature) -> None:
number = random.randrange(len(self.fm.get_features()))
random_feature = self.fm.get_features()[number]
self.fm.features.append(new_feature)
r = Relation(parent=random_feature,
children=[new_feature],
card_min=0,
card_max=1)
random_feature.relations.append(r)
new_products = []
for product in self.products:
new_products.append(product)
if random_feature.name in product:
new_product = [feat for feat in product]
new_product.append(new_feature.name)
new_products.append(new_product)
self.products = new_products
def test_relationships_alternative_requires() -> None:
feature_1 = Feature("A", None, None, True)
feature_2 = Feature("B", None, None, True)
feature_3 = Feature("C", None, None, True)
relation_1 = Relation(feature_1, [feature_2, feature_3], 1, 1)
feature_1.add_relation(relation_1)
node_1 = Node(ASTOperation.REQUIRES)
node_1.left = Node("B")
node_1.right = Node("C")
ast_1 = AST(node_1)
ctc_1 = Constraint("ctc_1", ast_1)
model = FeatureModel(feature_1, [ctc_1])
path = normalize_path(
"relationships/alternative-requires/alternative-requires")
run(path, model)