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)