def setUp(self):
self.genetic_selection = _GeneticSelection()
self.symbol_v = Symbol('x', SymbolType.ST_TERMINAL)
self.symbol_w = Symbol('w', SymbolType.ST_TERMINAL)
self.symbol_x = Symbol('x', SymbolType.ST_TERMINAL)
self.symbol_y = Symbol('y', SymbolType.ST_TERMINAL)
self.symbol_z = Symbol('z', SymbolType.ST_TERMINAL)
self.symbol_A = Symbol('A', SymbolType.ST_NON_TERMINAL)
self.symbol_B = Symbol('B', SymbolType.ST_NON_TERMINAL)
self.symbol_C = Symbol('C', SymbolType.ST_NON_TERMINAL)
self.symbol_D = Symbol('D', SymbolType.ST_NON_TERMINAL)
self.symbol_E = Symbol('E', SymbolType.ST_NON_TERMINAL)
self.rule_1 = Rule([self.symbol_A, self.symbol_B, self.symbol_C])
self.rule_2 = Rule([self.symbol_B, self.symbol_x, self.symbol_C])
self.rule_3 = Rule([self.symbol_C, self.symbol_B, self.symbol_y])
self.rule_4 = Rule([self.symbol_D, self.symbol_D, self.symbol_C])
self.rule_5 = Rule([self.symbol_E, self.symbol_w])
self.rule_1.fitness = 9
self.rule_2.fitness = 12
self.rule_3.fitness = 15
self.rule_4.fitness = 6
self.rule_5.fitness = 3
self.rules = {self.rule_1, self.rule_2, self.rule_3, self.rule_4, self.rule_5}
self.rules_list = [self.rule_1, self.rule_2, self.rule_3, self.rule_4, self.rule_5]
def __create_rule(symbols, fitness: float = None) -> Rule:
symbols = [Symbol(symbols[0], SymbolType.ST_NON_TERMINAL),
Symbol(symbols[1], SymbolType.ST_TERMINAL),
Symbol(symbols[2], SymbolType.ST_TERMINAL)]
rule = Rule(symbols)
if fitness:
rule.fitness = fitness
return rule
def add_rule(self, rule: Rule):
if (self.aaa_rules_handling_type is not AaaRulesHandlingType.NO_AAA_RULES
or not rule.is_non_terminal_to_terminal_terminal_rule()) and \
rule not in self.forbidden_rules:
self.rules.add(rule)
if rule.is_terminal(self.aaa_rules_handling_type):
self.terminal_rules.add(rule)
else:
self.non_terminal_rules.add(rule)
def add_new_rule(self,
grammar: Grammar,
first_symbol: Symbol,
second_symbol: Symbol = None) -> Rule:
new_rule = Rule([grammar.get_start_symbol(), first_symbol])
new_rule.origin = RuleOrigin.COVERING
grammar.add_rule(new_rule)
self.iteration.add_covering_rule(new_rule)
return new_rule
def test_rule_is_effective(self):
grammar = Grammar()
grammar.get_rules = MagicMock(return_value=self.rules)
rule = Rule([self.symbol_C, self.symbol_B, self.symbol_x])
result = self.covering.rule_is_effective(grammar, rule.left)
self.assertTrue(result)
rule = Rule([self.symbol_E, self.symbol_B, self.symbol_x])
result = self.covering.rule_is_effective(grammar, rule.left)
self.assertFalse(result)
def add_new_rule(self,
grammar: Grammar,
first_symbol: Symbol,
second_symbol: Symbol = None) -> Rule:
new_rule = Rule([
RandomUtils.get_random_nonterminal_symbol_from(grammar),
first_symbol, second_symbol
])
new_rule.origin = RuleOrigin.COVERING
self.crowding.add_rule(grammar, new_rule)
self.iteration.add_covering_rule(new_rule)
return new_rule
def setUp(self):
iteration = Iteration()
self.covering = StartStandardCovering()
self.covering.set_iteration(iteration)
self.grammar = Grammar()
self.first_right_symbol = Symbol('a', SymbolType.ST_TERMINAL)
self.left_symbol = Symbol('x', SymbolType.ST_TERMINAL)
self.rule = Rule([self.left_symbol, self.first_right_symbol])
def mutate(self, rule: Rule, grammar: Grammar) -> 'MutationReport':
report = MutationReport()
left = self.mutate_symbol(rule.left, grammar)
report.was_left_symbol_mutated = (left == rule.left)
right1 = self.mutate_symbol(rule.right1, grammar)
report.was_first_right_symbol_mutated = (right1 == rule.right1)
right2 = self.mutate_symbol(rule.right2, grammar)
report.was_second_right_symbol_mutated = (right2 == rule.right2)
rule.left, rule.right1, rule.right2 = left, right1, right2
return report
def test_filter_non_terminal_to_terminal_terminal_rule(self):
symbols = [Symbol('x', SymbolType.ST_TERMINAL),
Symbol('y', SymbolType.ST_NON_TERMINAL),
Symbol('z', SymbolType.ST_NON_TERMINAL)]
rule = Rule(symbols)
result = self.crowding.filter_non_terminal_to_terminal_terminal_rule(self.rules)
self.assertEqual(result, set())
result = self.crowding.filter_non_terminal_to_terminal_terminal_rule(self.rules + [rule])
self.assertEqual(result, {rule})
def setUp(self):
iteration = Iteration()
self.crowding = StandardCrowding()
self.crowding.set_iteration(iteration)
self.covering = AggressiveNakamuraCovering(self.crowding)
self.covering.set_iteration(iteration)
self.symbol_A = Symbol('A', SymbolType.ST_NON_TERMINAL)
self.symbol_B = Symbol('B', SymbolType.ST_NON_TERMINAL)
self.symbol_C = Symbol('C', SymbolType.ST_NON_TERMINAL)
self.rule_1 = Rule([self.symbol_A, self.symbol_B, self.symbol_C])
def setUp(self):
iteration = Iteration()
self.crowding = StandardCrowding()
self.crowding.set_iteration(iteration)
self.covering = NakamuraCovering(self.crowding)
self.covering.set_iteration(iteration)
self.symbol_v = Symbol('x', SymbolType.ST_TERMINAL)
self.symbol_w = Symbol('w', SymbolType.ST_TERMINAL)
self.symbol_x = Symbol('x', SymbolType.ST_TERMINAL)
self.symbol_y = Symbol('y', SymbolType.ST_TERMINAL)
self.symbol_z = Symbol('z', SymbolType.ST_TERMINAL)
self.symbol_A = Symbol('A', SymbolType.ST_NON_TERMINAL)
self.symbol_B = Symbol('B', SymbolType.ST_NON_TERMINAL)
self.symbol_C = Symbol('C', SymbolType.ST_NON_TERMINAL)
self.symbol_D = Symbol('D', SymbolType.ST_NON_TERMINAL)
self.symbol_E = Symbol('E', SymbolType.ST_NON_TERMINAL)
self.rule_1 = Rule([self.symbol_A, self.symbol_B, self.symbol_C])
self.rule_2 = Rule([self.symbol_B, self.symbol_x, self.symbol_C])
self.rule_3 = Rule([self.symbol_C, self.symbol_B, self.symbol_y])
self.rule_4 = Rule([self.symbol_D, self.symbol_D, self.symbol_C])
self.rule_5 = Rule([self.symbol_E, self.symbol_w])
self.rule_6 = Rule([self.symbol_E, self.symbol_D])
self.rules = [
self.rule_1, self.rule_2, self.rule_3, self.rule_4, self.rule_5,
self.rule_6
]
def setUp(self):
iteration = Iteration()
self.crowding = Crowding()
self.crowding.set_iteration(iteration)
self.covering = AggressiveStandardCovering(self.crowding)
self.covering.set_iteration(iteration)
self.grammar = Grammar()
self.first_right_symbol = Symbol('a', SymbolType.ST_TERMINAL)
self.second_right_symbol = Symbol('b', SymbolType.ST_TERMINAL)
self.left_symbol = Symbol('x', SymbolType.ST_TERMINAL)
self.rule = Rule([
self.left_symbol, self.first_right_symbol, self.second_right_symbol
])
def test_descriptions_generation(self):
rule = Rule([self.left, self.rightTerminal])
rule.fitness = 1
rule.profit = 2
rule.usages_in_invalid_parsing = 3
rule.usages_in_proper_parsing = 4
rule.debt = 5
rule.age = 6
descriptions = RulesService.get_description_string_for_rule(rule)
self.assertEqual(descriptions[0], "fitness (f): 1")
self.assertEqual(descriptions[1], "proper usages (u_p): 4")
self.assertEqual(descriptions[2], "invalid usages (u_n): 3")
self.assertEqual(descriptions[3], "profit (p): 2")
self.assertEqual(descriptions[4], "debt (d): 5")
self.assertEqual(descriptions[5], "age: 6")
def test_count_group_similarity(self):
RulesService.similarities_between_rules = MagicMock(side_effect=[32, 16, 64, 8, 4])
result = self.crowding.count_group_similarity(Rule(), self.rules)
self.assertEqual(result, 124)
def test_rule_equality(self):
rule = Rule([self.left, self.rightTerminal])
rule2 = Rule([self.left, self.rightTerminal])
self.assertEqual(rule, rule2)
def test_rule_not_equal_different_types(self):
rule = Rule([self.left, self.rightTerminal])
rule2 = Rule([self.left, self.rightNonTerminal])
self.assertNotEqual(rule, rule2)
def test_is_non_terminal_to_terminal_terminal_rule(self):
rule = Rule([self.left, self.rightTerminal, self.rightTerminal])
self.assertTrue(rule.is_non_terminal_to_terminal_terminal_rule())
def test_is_non_terminal_to_terminal_terminal_rule_failure(self):
rule = Rule([self.left, self.rightTerminal])
self.assertFalse(rule.is_non_terminal_to_terminal_terminal_rule())
def test_is_non_terminal_two_right_symbols(self):
rule = Rule([self.left, self.leftNonTerminal, self.rightNonTerminal])
self.assertTrue(rule.is_non_terminal())
def test_is_start(self):
rule = Rule([self.left, self.rightTerminal])
self.assertTrue(rule.is_start())
def test_rules_similar_three_points(self):
rule = Rule([self.left, self.rightNonTerminal, self.rightTerminal])
rule2 = Rule([self.left, self.rightNonTerminal, self.rightTerminal])
similarities = RulesService.similarities_between_rules(rule, rule2)
self.assertEqual(similarities, 3)
def invert_rule(self, rule: Rule) -> None:
if rule.right2:
rule.right1, rule.right2 = rule.right2, rule.right1
def test_sort_rules_used_in_invalid_parsing(self):
rules_container = RulesContainer()
rule1 = Rule()
rule1.usages_in_invalid_parsing = 1
rule1.fitness = 0.3
rule2 = Rule()
rule2.usages_in_invalid_parsing = 2
rule2.fitness = 0.29
rule3 = Rule()
rule3.usages_in_invalid_parsing = 3
rule3.fitness = 0.28
rule4 = Rule()
rule4.usages_in_invalid_parsing = 4
rule4.fitness = 0.27
rule5 = Rule()
rule5.usages_in_invalid_parsing = 5
rule5.fitness = 0.26
rule6 = Rule()
rule6.usages_in_invalid_parsing = 6
rule6.fitness = 0.25
invalid_parsing_rules = [rule1, rule2, rule3, rule4, rule5, rule6]
sorted_rules = rules_container.sort_rules_used_in_invalid_parsing(
invalid_parsing_rules)
self.assertEqual(sorted_rules[0].fitness, rule6.fitness)
self.assertEqual(sorted_rules[1].fitness, rule5.fitness)
self.assertEqual(sorted_rules[2].fitness, rule4.fitness)
self.assertEqual(sorted_rules[3].fitness, rule3.fitness)
self.assertEqual(sorted_rules[4].fitness, rule2.fitness)
self.assertEqual(sorted_rules[5].fitness, rule1.fitness)
def get_rule_rand_non_terminal_rule(left: Symbol, right1: Symbol, right2: Symbol):
return Rule([left, right1, right2])
def test_select_rules_not_used_in_parsing(self):
rules_container = RulesContainer()
rule1 = Rule()
rule1.usages_in_invalid_parsing = 1
rule2 = Rule()
rule2.usages_in_invalid_parsing = 0
rule3 = Rule()
rule3.usages_in_invalid_parsing = 0
rule4 = Rule()
rule4.usages_in_invalid_parsing = 0
rule5 = Rule()
rule5.usages_in_invalid_parsing = 2
rule6 = Rule()
rule6.usages_in_invalid_parsing = 3
non_terminal_rules = [rule1, rule2, rule3, rule4, rule5, rule6]
rules_container.non_terminal_rules = non_terminal_rules
invalid_usages_rules = rules_container.select_rules_used_in_invalid_parsing(
)
self.assertEqual(len(invalid_usages_rules), 3)
self.assertEqual(invalid_usages_rules[0].usages_in_invalid_parsing,
rule1.usages_in_invalid_parsing)
self.assertEqual(invalid_usages_rules[1].usages_in_invalid_parsing,
rule5.usages_in_invalid_parsing)
self.assertEqual(invalid_usages_rules[2].usages_in_invalid_parsing,
rule6.usages_in_invalid_parsing)
