class TestExtensionCalculation(TestCase): def setUp(self): self.assumptions = {'alpha', 'beta', 'gamma', 'delta'} self.language = self.assumptions.union({'phi', 'psi', 'chi'}) self.assumptions_to_contrary_mapping = { 'alpha': 'beta', 'beta': 'phi', 'gamma': 'psi', 'delta': 'chi' } rule_1 = Rule('alpha', 'phi') rule_2 = Rule('gamma', 'beta') rule_3 = Rule('delta', 'chi') rule_4 = Rule('alpha', 'chi') self.rules = {rule_1, rule_2, rule_3, rule_4} self.bipolar_aba_framework = BipolarABA( self.language, self.rules, self.assumptions, self.assumptions_to_contrary_mapping) def test_simple_preferred_extension_calculation(self): preferred_extensions = list( self.bipolar_aba_framework.get_preferred_extensions()) assert {'beta', 'gamma'} in preferred_extensions assert {'alpha'} in preferred_extensions assert len(preferred_extensions) == 2 def test_simple_set_stable_extension_calculation(self): set_stable_extensions = list( self.bipolar_aba_framework.get_set_stable_extensions()) assert {'alpha'} in set_stable_extensions assert len(set_stable_extensions) == 1
def generate_bipolar_aba_framework(input_string): """ :param input_string: A string defining an ABA+ framework :return: A BipolarABA object generated from file """ def format_input_string(string): string = re.sub( re.compile("/\*.*?\*/", re.DOTALL), "", string ) # remove all occurrence of streamed comments (/*COMMENT */) from string string = re.sub( re.compile("\%.*?\n"), "", string ) # remove all occurrence of single line comments (%COMMENT\n ) from string return string.replace('\r', '').replace('\n', '') input = format_input_string(input_string) declarations = input.split(".") assump_declarations = [ decl for decl in declarations if ASSUMP_PREDICATE in decl ] assumption_symbols = generate_assumption_symbols(assump_declarations) contr_declarations = [ decl for decl in declarations if CONTR_PREDICATE in decl ] language, assumption_to_contrary_mapping = generate_language_and_mapping( contr_declarations, assumption_symbols) rule_declarations = [ decl for decl in declarations if RULE_PREDICATE in decl ] rules = generate_rules(rule_declarations) return BipolarABA(language, rules, assumption_symbols, assumption_to_contrary_mapping)
def test_valid_bipolar_aba_framework_creation(self): bipolar_aba_framework = BipolarABA( self.language, self.rules, self.assumptions, self.assumptions_to_contrary_mapping) assert bipolar_aba_framework.language == self.language assert bipolar_aba_framework.rules == self.rules assert bipolar_aba_framework.assumptions == self.assumptions
def test_bipolar_aba_creation(language, rules, assumptions): contrary_symbols = {a.contrary_symbol for a in assumptions} try: bipolar_aba_framework = BipolarABA(language, rules, assumptions) assert bipolar_aba_framework.language == language assert bipolar_aba_framework.rules == rules assert bipolar_aba_framework.assumptions == assumptions assert {c.symbol for c in bipolar_aba_framework.contraries} == contrary_symbols preferred_extensions = list( bipolar_aba_framework.get_preferred_extensions()) for extension in preferred_extensions: assert bipolar_aba_framework.is_closed(extension) assert bipolar_aba_framework.is_conflict_free(extension) assert bipolar_aba_framework.is_admissible_extension(extension) for subset in strict_subsets(extension): assert subset not in preferred_extensions set_stable_extensions = list( bipolar_aba_framework.get_set_stable_extensions()) for extension in set_stable_extensions: assert extension in preferred_extensions assert bipolar_aba_framework.is_closed(extension) assert bipolar_aba_framework.is_conflict_free(extension) assert bipolar_aba_framework.is_admissible_extension(extension) for subset in strict_subsets(extension): assert subset not in set_stable_extensions assert subset not in preferred_extensions except NonBipolarException as e: if e.message == "The head of a rule in a BipolarABA framework must be an assumption or " \ "the contrary of an assumption.": # assert any(r.consequent not in assumptions and r.consequent.symbol not in contrary_symbols for r in rules) pass elif e.message == "The body of a rule in a BipolarABA framework can only contain assumptions.": assert any(a not in assumptions for r in rules for a in r.antecedent) elif e.message == "The body of a rule in a BipolarABA framework can only contain one sentence.": assert any(len(r.antecedent) != 1 for r in rules) elif e.message == "Assumptions in a BipolarABA framework should be part of the language.": assert not assumptions <= language elif e.message == "Contraries in a BipolarABA framework should be part of the language.": symbols = {s.symbol for s in language} assert not contrary_symbols <= symbols else: pytest.fail("Unexpected exception: " + e.message)
def test_mapping_not_total_throws_exception(self): self.assumptions.add('Not in language') with pytest.raises(NonBipolarException) as e: BipolarABA(self.language, self.rules, self.assumptions, self.assumptions_to_contrary_mapping) assert str( e.value ) == "Assumption to contrary mapping must be a total mapping on assumptions."
def setUp(self): self.assumptions = {'alpha', 'beta', 'gamma', 'delta'} self.language = self.assumptions.union({'phi', 'psi', 'chi'}) self.assumptions_to_contrary_mapping = { 'alpha': 'beta', 'beta': 'phi', 'gamma': 'psi', 'delta': 'chi' } rule_1 = Rule('alpha', 'phi') rule_2 = Rule('gamma', 'beta') rule_3 = Rule('delta', 'chi') rule_4 = Rule('alpha', 'chi') self.rules = {rule_1, rule_2, rule_3, rule_4} self.bipolar_aba_framework = BipolarABA( self.language, self.rules, self.assumptions, self.assumptions_to_contrary_mapping)
def test_assumption_not_in_language_throws_exception(self): self.assumptions.add('Not in language') self.assumptions_to_contrary_mapping['Not in language'] = 'beta' with pytest.raises(NonBipolarException) as e: BipolarABA(self.language, self.rules, self.assumptions, self.assumptions_to_contrary_mapping) assert str( e.value ) == "Assumptions and contraries in a BipolarABA framework should be part of the language."
def test_framework_creation_with_invalid_rule_head_throws_exception(self): rule_5 = Rule('alpha', 'psi') self.rules.add(rule_5) with pytest.raises(NonBipolarException) as e: BipolarABA(self.language, self.rules, self.assumptions, self.assumptions_to_contrary_mapping) assert str(e.value) == "The head of a rule in a BipolarABA framework must be an assumption or " \ "the contrary of an assumption."
def test_framework_creation_with_non_assumption_in_rule_body_throws_exception( self): rule_5 = Rule('psi', 'gamma') self.rules.add(rule_5) with pytest.raises(NonBipolarException) as e: BipolarABA(self.language, self.rules, self.assumptions, self.assumptions_to_contrary_mapping) assert str( e.value ) == "The body of a rule in a BipolarABA framework can only contain assumptions."
def map_baf_to_naba_framework(baf_framework): ''' :param baf_framework: A BAF object. :return: A BipolarABA object corresponding to the n-ABA framework of BAF in the spirit of [CST17] ''' assumptions = set() contraries = set() rules = set() assumptions_contrary_mapping = {} for arg in baf_framework.arguments: contraries.add(arg + '_contrary') assumptions.add(arg) assumptions_contrary_mapping[arg] = arg + '_contrary' language = assumptions.union(contraries) for attack in baf_framework.attacks: rules.add(Rule(attack[0], attack[1] + '_contrary')) for support in baf_framework.supports: rules.add(Rule(support[1], support[0])) return BipolarABA(language, rules, assumptions, assumptions_contrary_mapping)