def test_symbol_sentence_init(self): symbol1 = Symbol("I") symbol2 = Symbol(" ") symbol3 = Symbol("l") symbol4 = Symbol("i") symbol5 = Symbol("k") symbol6 = Symbol("e") symbols = [symbol1, symbol2, symbol3, symbol4, symbol5, symbol6] sentence = "I like you" grammar = Grammar() grammar.nonTerminalSymbols = symbols self.cyk_base = CYKBase() self.cyk_base.grammar = grammar self.cyk_base.symbols = symbols self.cyk_base._init_symbol_sequence(sentence) sequence = self.cyk_base.sequence self.assertEqual(symbol1, sequence[0]) self.assertEqual(symbol2, sequence[1]) self.assertEqual(symbol3, sequence[2]) self.assertEqual(symbol4, sequence[3]) self.assertEqual(symbol5, sequence[4]) self.assertEqual(symbol6, sequence[5]) self.assertEqual(symbol2, sequence[6]) self.assertEqual(None, sequence[7]) self.assertEqual(None, sequence[8]) self.assertEqual(None, sequence[9]) pass
def __restore_previous_state(self, grammar: Grammar) -> None: to_remove = set(grammar.get_rules()) for rule in to_remove: grammar.remove_rule(rule) self.iteration.remove_crowding_rule(rule) for rule in self.__last_rules: grammar.add_rule(rule) self.iteration.add_rule(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 test_count_symbols_statistics(self): grammar = Grammar() grammar.get_rules = MagicMock(return_value=self.rules) result = self.covering.count_symbols_statistics(grammar) expected = { self.symbol_B: 2, self.symbol_C: 3, self.symbol_D: 1, self.symbol_E: 1 } self.assertEqual(result, expected)
def __replace_all_symbols_in_rules(self, replacement: Symbol, replaced: Symbol, grammar: Grammar) -> None: rules: Set[Rule] = grammar.get_rules() rules_copy = set(rules) for rule in rules_copy: if self.__rule_contains_replaced_symbol(rule, replaced): new_rule = self.__replace_symbols_in_rule( replacement, replaced, rule) grammar.remove_rule(rule) grammar.add_rule(new_rule)
def calculate_number_of_rules_to_add(self, grammar: Grammar): grammar_size = len(grammar.get_non_terminal_rules()) round_to_even = lambda x: round((x - 0.5) / 2) * 2 if self.new_rules_number_percent_unit: if self.new_rules_number >= 100: return round_to_even(grammar_size) else: return round((grammar_size * self.new_rules_number) / 200) * 2 else: if self.new_rules_number >= len(grammar.get_non_terminal_rules()): return round_to_even(grammar_size) else: return round_to_even(self.new_rules_number)
def initialize_rules(self): self.crowding.is_non_terminal_type = MagicMock(return_value=True) self.crowding.filter_non_terminal_to_terminal_terminal_rule = MagicMock() grammar = Grammar() grammar.get_non_terminal_rules = MagicMock(return_value=self.rules) rule = self.__create_rule(["x", "y", "z"]) self.crowding.initialize_rules(rule, grammar) self.crowding.filter_non_terminal_to_terminal_terminal_rule.assert_called_once_with(self.rules) self.crowding.is_non_terminal_type = MagicMock(return_value=False) result = self.crowding.initialize_rules(rule, grammar) self.assertEqual(result, self.rules)
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 get_ga_probability(self, grammar: Grammar) -> float: if self.dynamic_ga_probability_enabled: metrics = grammar.calc_metrics() ga_prob = math.exp(-2 * metrics['F1']) # print("MCC = {}, GA probability = {}".format(metrics['MCC'], ga_prob)) return ga_prob else: return self.const_ga_probability
def setUp(self): iteration = Iteration() self.covering = StartCoveringPlus() 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 = sRule.from_symbols(0.5, self.left_symbol, self.first_right_symbol)
def test_add_new_rule(self): grammar: Grammar = Grammar() self.covering.produce_rule = MagicMock(return_value=self.rule_1) self.covering.crowding.add_rule = MagicMock() result = self.covering.add_new_rule(grammar, self.symbol_C) self.assertEqual(self.rule_1, result) self.covering.crowding.add_rule.assert_called_once_with( grammar, self.rule_1)
def test_is_non_terminal_type(self): self.crowding.aaa_rules_handling_type = AaaRulesHandlingType.NON_TERMINALS self.crowding.non_terminal_productions_number = 20 rule = self.__create_rule(["x", "y", "z"]) rule.is_non_terminal_to_terminal_terminal_rule = MagicMock(return_value=False) grammar = Grammar() grammar.count_Aaa_rules = MagicMock(return_value=10) self.assertTrue(self.crowding.is_non_terminal_type(rule, grammar)) rule.is_non_terminal_to_terminal_terminal_rule = MagicMock(return_value=True) self.assertFalse(self.crowding.is_non_terminal_type(rule, grammar)) self.crowding.aaa_rules_handling_type = 'TERMINALS' self.assertFalse(self.crowding.is_non_terminal_type(rule, grammar)) self.crowding.non_terminal_productions_number = 5 self.assertFalse(self.crowding.is_non_terminal_type(rule, grammar))
def test_get_random_nonterminal_symbol_from(self): grammar = Grammar() symbol_1 = Symbol('a', SymbolType.ST_TERMINAL) symbol_2 = Symbol('b', SymbolType.ST_TERMINAL) grammar.nonTerminalSymbols = [symbol_1, symbol_2] result = RandomUtils.get_random_nonterminal_symbol_from(grammar) self.assertIsNotNone(result) self.assertEqual(2, len(grammar.nonTerminalSymbols)) grammar.nonTerminalSymbols = [] result = RandomUtils.get_random_nonterminal_symbol_from(grammar) self.assertIsNone(result) grammar.nonTerminalSymbols = [symbol_1, symbol_2] random.choice = MagicMock(return_value=symbol_1) result = RandomUtils.get_random_nonterminal_symbol_from(grammar) self.assertEqual(result, symbol_1)
def __get_non_terminals_in_use(self, grammar: Grammar) -> Set[Symbol]: rules = grammar.get_rules() symbols_in_use = set() for rule in rules: symbols_in_use.add(rule.left) symbols_in_use.add(rule.right1) if rule.right2 is not None: symbols_in_use.add(rule.right2) return set( filter(lambda symbol: symbol.is_non_terminal(), symbols_in_use))
def test_produce_rule(self): grammar = Grammar() RandomUtils.get_random_nonterminal_symbol_from = MagicMock( return_value=self.symbol_D) RandomUtils.get_random_probability = MagicMock(return_value=0.7) result = self.covering.produce_rule(grammar, self.symbol_C) expected = sRule.from_symbols(0.7, self.symbol_D, self.symbol_C) self.assertEqual(result, expected)
def test_get_left_symbol_condition_true(self): grammar = Grammar() self.covering.find_left_symbol_wisely = MagicMock() RandomUtils.get_random_nonterminal_symbol_from = MagicMock() RandomUtils.make_random_decision_with_probability = MagicMock( return_value=True) self.covering.get_left_symbol(grammar) self.covering.find_left_symbol_wisely.assert_called_once_with(grammar) RandomUtils.get_random_nonterminal_symbol_from.assert_not_called()
def __grammar_is_worse_than_previously(self, grammar: Grammar) -> bool: print("[heuristic] grammar fitness = {}".format( self.__count_grammar_fitness(grammar))) print("[heuristic] last grammar fitness = {}".format( self.__last_grammar_fitness)) if len(grammar.get_rules()) > 5 * int( self.settings.get_value('general', 'non_terminal_productions_number')): return True return self.__count_grammar_fitness( grammar) < self.__last_grammar_fitness
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_find_left_symbol_wisely_condition_true(self): grammar = Grammar() self.covering.count_symbols_statistics = MagicMock(return_value={}) RandomUtils.get_random_nonterminal_symbol_from = MagicMock() self.covering.find_the_best_symbols = MagicMock() self.covering.roulette_selection.select = MagicMock() self.covering.find_left_symbol_wisely(grammar) RandomUtils.get_random_nonterminal_symbol_from.assert_called_once_with( grammar) self.covering.find_the_best_symbols.assert_not_called() self.covering.roulette_selection.select.assert_not_called()
def setUp(self): iteration = Iteration() self.crowding = Crowding() self.crowding.set_iteration(iteration) self.covering = FinalCoveringPlus(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 = sRule.from_symbols(0.5, self.left_symbol, self.first_right_symbol, self.second_right_symbol)
def run(self, grammar: Grammar) -> None: if self.__run_counter != 0: self.save_grammar_state(grammar) if len(grammar.get_non_terminal_rules()) > 2 * int( self.settings.get_value( 'general', 'non_terminal_productions_number')): self.merge(grammar) else: if self.__run_counter % 2 == 1: self.split(grammar) else: self.merge(grammar) self.__run_counter += 1
def test_add_new_rule_when_rule_effective(self): grammar = Grammar() self.covering.produce_rule = MagicMock(return_value=self.rule_1) self.covering.rule_is_effective = MagicMock(return_value=False) self.covering.make_rule_effective = MagicMock() self.covering.crowding.add_rule = MagicMock() result = self.covering.add_new_rule(grammar, self.symbol_A) self.assertEqual(self.rule_1, result) self.covering.rule_is_effective.assert_called_once_with( grammar, self.rule_1.left) self.covering.make_rule_effective.assert_called_once_with( grammar, self.rule_1) self.covering.crowding.add_rule.assert_not_called()
def test_make_rule_effective(self): grammar = Grammar() self.covering.rule_is_effective = MagicMock(side_effect=4 * [False] + [True]) self.covering.produce_rule_based_on_random_decision = MagicMock( side_effect=[self.rule_1, self.rule_2, self.rule_3, self.rule_4]) self.covering.crowding.add_rule = MagicMock() self.covering.crowding.add_rules = MagicMock() self.covering.make_rule_effective(grammar, self.rule_1) self.assertEqual(self.covering.rule_is_effective.call_count, 5) self.assertEqual( self.covering.produce_rule_based_on_random_decision.call_count, 4) self.assertEqual(self.covering.crowding.add_rule.call_count, 4) self.covering.crowding.add_rules.assert_called_once()
def test_find_left_symbol_wisely_condition_false(self): grammar = Grammar() self.covering.count_symbols_statistics = MagicMock(return_value=self.statistics) RandomUtils.get_random_nonterminal_symbol_from = MagicMock() self.covering.find_the_best_symbols = MagicMock() self.covering.roulette_selection.select = MagicMock(return_value=self.symbol_D) self.covering.purify_statistics_based_on_tabu = MagicMock() self.covering.add_to_tabu = MagicMock() self.covering.find_left_symbol_wisely(grammar) RandomUtils.get_random_nonterminal_symbol_from.assert_not_called() self.covering.find_the_best_symbols.assert_called_once_with(self.statistics, number_of_symbols=5) self.covering.roulette_selection.select.assert_called_once() self.covering.purify_statistics_based_on_tabu.assert_called_once_with(self.statistics) self.covering.add_to_tabu.assert_called_once_with(self.symbol_D)
def setUp(self): self.genetic_algorithm = GeneticAlgorithm(Crowding(), None) self.grammar = Grammar() 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 = sRule.from_symbols(0.1, self.symbol_A, self.symbol_B, self.symbol_C) self.rule_2 = sRule.from_symbols(0.5, self.symbol_B, self.symbol_x, self.symbol_C) self.rule_3 = sRule.from_symbols(0.4, self.symbol_C, self.symbol_B, self.symbol_y) self.rule_4 = sRule.from_symbols(0.9, self.symbol_D, self.symbol_D, self.symbol_C) self.rule_5 = sRule.from_symbols(0.2, 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 ] self.grammar.get_non_terminal_rules = MagicMock( return_value=self.rules) self.random_decision = RandomUtils.make_random_decision_with_probability self.random_non_terminal = RandomUtils.get_random_nonterminal_symbol_from
def test_produce_rule_based_on_random_decision(self): grammar = Grammar() RandomUtils.get_random_probability = MagicMock(return_value=0.9) RandomUtils.get_random_nonterminal_symbol_from = MagicMock( return_value=self.symbol_A) RandomUtils.make_random_decision_with_probability = MagicMock( return_value=True) result: sRule = self.covering.produce_rule_based_on_random_decision( grammar, self.symbol_x) expected: sRule = sRule.from_symbols(0.9, self.symbol_A, self.symbol_x, self.symbol_A) self.assertEqual(expected, result) RandomUtils.make_random_decision_with_probability = MagicMock( return_value=False) result: sRule = self.covering.produce_rule_based_on_random_decision( grammar, self.symbol_x) expected: sRule = sRule.from_symbols(0.9, self.symbol_A, self.symbol_A, self.symbol_x) self.assertEqual(expected, result)
def setUp(self): self.grammar = Grammar() self.grammar.terminalSymbols = self.__create_terminal_symbols__() self.grammar.nonTerminalSymbols = self.__create_non_terminal_symbols()
class GrammarTest(TestCase): def setUp(self): self.grammar = Grammar() self.grammar.terminalSymbols = self.__create_terminal_symbols__() self.grammar.nonTerminalSymbols = self.__create_non_terminal_symbols() def test_should_not_find_symbol_index(self): symbol = Symbol("d") symbol_idx = self.grammar.symbol_index(symbol) self.assertEqual(symbol_idx, -1) def test_should_find_first_terminal_symbol(self): symbol = Symbol("o") symbol_idx = self.grammar.symbol_index(symbol) self.assertEqual(symbol_idx, 0) def test_should_find_second_terminal_symbol(self): symbol = Symbol("t") symbol_idx = self.grammar.symbol_index(symbol) self.assertEqual(symbol_idx, 1) def test_should_find_third_terminal_symbol(self): symbol = Symbol("s") symbol_idx = self.grammar.symbol_index(symbol) self.assertEqual(symbol_idx, 2) def test_should_find_first_non_terminal_symbol(self): symbol = Symbol("a") symbol_idx = self.grammar.symbol_index(symbol) self.assertEqual(symbol_idx, 3) def test_should_find_second_non_terminal_symbol(self): symbol = Symbol("b") symbol_idx = self.grammar.symbol_index(symbol) self.assertEqual(symbol_idx, 4) def test_should_find_third_non_terminal_symbol(self): symbol = Symbol("c") symbol_idx = self.grammar.symbol_index(symbol) self.assertEqual(symbol_idx, 5) def test_should_find_symbol_by_index(self): index = 0 symbol = self.grammar.find_symbol_by_given_index(index) self.assertEqual(symbol, Symbol("o", SymbolType.ST_TERMINAL)) def test_should_find_symbol_by_index_1(self): index = 1 symbol = self.grammar.find_symbol_by_given_index(index) self.assertEqual(symbol, Symbol("t", SymbolType.ST_TERMINAL)) def test_should_find_symbol_by_index_5(self): index = 5 symbol = self.grammar.find_symbol_by_given_index(index) self.assertEqual(symbol, Symbol("c", SymbolType.ST_NON_TERMINAL)) def test_should_not_find_symbol(self): index = -1 index2 = 100000000000 symbol = self.grammar.find_symbol_by_given_index(index) symbol2 = self.grammar.find_symbol_by_given_index(index2) self.assertEqual(symbol, None) self.assertEqual(symbol2, None) def test_should_find_non_terminal_symbol_index(self): symbol = Symbol("a", SymbolType.ST_NON_TERMINAL) index = self.grammar.find_non_terminal_symbol_index(symbol) self.assertEqual(index, 0) def test_should_find_non_terminal_symbol_index_2(self): symbol = Symbol("b", SymbolType.ST_NON_TERMINAL) index = self.grammar.find_non_terminal_symbol_index(symbol) self.assertEqual(index, 1) def test_should_find_non_terminal_symbol_index_3(self): symbol = Symbol("c", SymbolType.ST_NON_TERMINAL) index = self.grammar.find_non_terminal_symbol_index(symbol) self.assertEqual(index, 2) def test_should_not_find_non_terminal_symbol_index(self): symbol = Symbol("d", SymbolType.ST_NON_TERMINAL) index = self.grammar.find_non_terminal_symbol_index(symbol) self.assertEqual(index, -1) def test_find_symbol_by_value(self): value = 'c' symbol = self.grammar.find_symbol_by_value(value) self.assertEqual(symbol, Symbol("c", SymbolType.ST_NON_TERMINAL)) def test_should_not_find_symbol_by_value(self): value = 'z' symbol = self.grammar.find_symbol_by_value(value) self.assertEqual(symbol, None) def test_should_calculate_grammar_fitness(self): self.grammar.trueNegative = 3 self.grammar.truePositive = 5 all_examples = 8 fitness = self.grammar.calculate_grammar_fitness(all_examples) self.assertEqual(fitness, 1) def test_should_calculate_grammar_fitness_2(self): self.grammar.trueNegative = 3 self.grammar.truePositive = 5 all_examples = 16 fitness = self.grammar.calculate_grammar_fitness(all_examples) self.assertEqual(fitness, 0.5) def test_should_calculate_grammar_fitness_3(self): self.grammar.trueNegative = 3 self.grammar.truePositive = 5 all_examples = 32 fitness = self.grammar.calculate_grammar_fitness(all_examples) self.assertEqual(fitness, 0.25) def test_should_calculate_grammar_fitness_4(self): self.grammar.trueNegative = 3 self.grammar.truePositive = 5 all_examples = 64 fitness = self.grammar.calculate_grammar_fitness(all_examples) self.assertEqual(fitness, 0.125) def test_should_calculate_grammar_fitness_no_examples(self): all_examples = 0 fitness = self.grammar.calculate_grammar_fitness(all_examples) self.assertEqual(fitness, 0) def test_should_calculate_grammar_sensitivity_no_positive_and_negative( self): sensitivity = self.grammar.calculate_sensitivity() self.assertEqual(sensitivity, 0) def test_should_calculate_grammar_sensitivity(self): self.grammar.falseNegative = 3 self.grammar.truePositive = 5 sensitivity = self.grammar.calculate_sensitivity() self.assertEqual(sensitivity, 0.625) def test_should_calculate_grammar_sensitivity_2(self): self.grammar.falseNegative = 4 self.grammar.truePositive = 4 sensitivity = self.grammar.calculate_sensitivity() self.assertEqual(sensitivity, 0.5) def test_should_calculate_grammar_sensitivity_3(self): self.grammar.falseNegative = 9 self.grammar.truePositive = 1 sensitivity = self.grammar.calculate_sensitivity() self.assertEqual(sensitivity, 0.1) def test_should_calculate_precision_no_positives(self): precision = self.grammar.calculate_precision() self.assertEqual(precision, 0) def test_should_calculate_precision(self): self.grammar.truePositive = 2 self.grammar.falsePositive = 8 precision = self.grammar.calculate_precision() self.assertEqual(precision, 0.2) def test_should_calculate_precision_2(self): self.grammar.truePositive = 1 self.grammar.falsePositive = 7 precision = self.grammar.calculate_precision() self.assertEqual(precision, 0.125) def test_should_calculate_precision_3(self): self.grammar.truePositive = 3 self.grammar.falsePositive = 5 precision = self.grammar.calculate_precision() self.assertEqual(precision, 0.375) def test_should_calculate_precision_4(self): self.grammar.truePositive = 3 self.grammar.falsePositive = 0 precision = self.grammar.calculate_precision() self.assertEqual(precision, 1.00) def test_should_calculate_specificity_no_data(self): specificity = self.grammar.calculate_specificity() self.assertEqual(specificity, 0) def test_should_calculate_specificity(self): self.grammar.trueNegative = 3 self.grammar.falsePositive = 7 specificity = self.grammar.calculate_specificity() self.assertEqual(specificity, 0.3) def test_should_calculate_specificity_2(self): self.grammar.trueNegative = 1 self.grammar.falsePositive = 9 specificity = self.grammar.calculate_specificity() self.assertEqual(specificity, 0.1) def test_should_calculate_specificity_3(self): self.grammar.trueNegative = 0 self.grammar.falsePositive = 10 specificity = self.grammar.calculate_specificity() self.assertEqual(specificity, 0) def test_should_calculate_specificity_4(self): self.grammar.trueNegative = 10 self.grammar.falsePositive = 0 specificity = self.grammar.calculate_specificity() self.assertEqual(specificity, 1.0) def test_should_calculate_specificity_5(self): self.grammar.trueNegative = 3 self.grammar.falsePositive = 5 specificity = self.grammar.calculate_specificity() self.assertEqual(specificity, 0.375) def test_should_calculate_f1(self): self.grammar.truePositive = 2 self.grammar.falseNegative = 2 self.grammar.falsePositive = 2 f1 = self.grammar.calculate_f1() self.assertEqual(f1, 0.5) def test_should_calculate_f1_2(self): self.grammar.truePositive = 2 self.grammar.falseNegative = 4 self.grammar.falsePositive = 4 f1 = self.grammar.calculate_f1() self.assertEqual(f1, 1 / 3) def test_grammar_should_be_perfectly_fit(self): self.grammar.trueNegative = 2 self.grammar.truePositive = 2 all_examples = 4 is_perfectly_fit = self.grammar.is_grammar_perfectly_fit(all_examples) self.assertTrue(is_perfectly_fit) def test_grammar_should_not_be_perfectly_fit(self): self.grammar.trueNegative = 2 self.grammar.truePositive = 2 all_examples = 5 is_perfectly_fit = self.grammar.is_grammar_perfectly_fit(all_examples) self.assertFalse(is_perfectly_fit) def __create_terminal_symbols__(self): terminal_symbols = [] symbol_one = Symbol("o", SymbolType.ST_TERMINAL) symbol_two = Symbol("t", SymbolType.ST_TERMINAL) symbol_three = Symbol("s", SymbolType.ST_TERMINAL) terminal_symbols.append(symbol_one) terminal_symbols.append(symbol_two) terminal_symbols.append(symbol_three) return terminal_symbols def __create_non_terminal_symbols(self): non_terminal_symbols = [] symbol_one = Symbol("a", SymbolType.ST_NON_TERMINAL) symbol_two = Symbol("b", SymbolType.ST_NON_TERMINAL) symbol_three = Symbol("c", SymbolType.ST_NON_TERMINAL) non_terminal_symbols.append(symbol_one) non_terminal_symbols.append(symbol_two) non_terminal_symbols.append(symbol_three) return non_terminal_symbols
def setUp(self): settings = MagicMock() settings.get_value = MagicMock( side_effect=["TERMINALS", 0.5, 1.0, 1.0, 1.0, 1.0]) self.grammar = Grammar(settings) self.symbol_a = Symbol('a', SymbolType.ST_TERMINAL) self.symbol_S = Symbol('S', SymbolType.ST_NON_TERMINAL) self.symbol_A = Symbol('A', SymbolType.ST_NON_TERMINAL) self.symbol_B = Symbol('B', SymbolType.ST_NON_TERMINAL) self.symbol_C = Symbol('A', SymbolType.ST_NON_TERMINAL) self.symbol_A1 = Symbol('A1', SymbolType.ST_NON_TERMINAL) self.symbol_A2 = Symbol('A2', SymbolType.ST_NON_TERMINAL) self.rule_1 = sRule.from_symbols(0.1, self.symbol_S, self.symbol_A, self.symbol_B) self.rule_2 = sRule.from_symbols(0.5, self.symbol_A, self.symbol_A, self.symbol_B) self.rule_3 = sRule.from_symbols(0.4, self.symbol_A, self.symbol_a) self.rule_4 = sRule.from_symbols(0.9, self.symbol_B, self.symbol_B, self.symbol_B) self.rule_5 = sRule.from_symbols(0.2, self.symbol_B, self.symbol_a) self.rules = { self.rule_1, self.rule_2, self.rule_3, self.rule_4, self.rule_5 } self.non_terminal_rules = {self.rule_1, self.rule_2, self.rule_4} self.terminal_rules = {self.rule_3, self.rule_5} self.grammar.rulesContainer.terminal_rules = self.terminal_rules self.grammar.rulesContainer.non_terminal_rules = self.non_terminal_rules self.grammar.rulesContainer.rules = self.rules self.grammar.get_rules = MagicMock(return_value=self.rules) self.grammar.get_non_terminal_rules = MagicMock( return_value=self.non_terminal_rules) settings.get_value = MagicMock( side_effect=['RANDOM', 'False', 0.5, 20]) self.split_and_merge = SplitAndMerge(settings) self.split_and_merge.iteration.add_rule = MagicMock() self.split_and_merge.iteration.remove_crowding_rule = MagicMock() self.merge_result = { sRule.from_symbols(0.1, self.symbol_S, self.symbol_A, self.symbol_A), sRule.from_symbols(0.1, self.symbol_A, self.symbol_A, self.symbol_A), sRule.from_symbols(0.1, self.symbol_A, self.symbol_a) } self.split_result = { sRule.from_symbols(0.1, self.symbol_S, self.symbol_A1, self.symbol_B), sRule.from_symbols(0.1, self.symbol_S, self.symbol_A2, self.symbol_B), sRule.from_symbols(0.1, self.symbol_A1, self.symbol_A1, self.symbol_B), sRule.from_symbols(0.1, self.symbol_A1, self.symbol_A2, self.symbol_B), sRule.from_symbols(0.1, self.symbol_A2, self.symbol_A2, self.symbol_B), sRule.from_symbols(0.1, self.symbol_A2, self.symbol_A1, self.symbol_B), sRule.from_symbols(0.1, self.symbol_A1, self.symbol_a), sRule.from_symbols(0.1, self.symbol_A2, self.symbol_a), sRule.from_symbols(0.1, self.symbol_B, self.symbol_a), sRule.from_symbols(0.1, self.symbol_B, self.symbol_B, self.symbol_B), }