Пример #1
0
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

        self.sut = AddingRuleWithElitismStrategy()
Пример #2
0
class TestAddingRuleWithCrowdingStrategyAndElitism(TestAddingRuleStrategyCommon):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

        self.sut = AddingRuleWithElitismStrategy()

    def test_should_know_if_strategy_is_applicable(self):
        assert_that(
            self.sut.is_applicable(AddingRuleStrategyHint.expand_population),
            is_(False))
        assert_that(
            self.sut.is_applicable(AddingRuleStrategyHint.control_population_size),
            is_(False))
        assert_that(
            self.sut.is_applicable(AddingRuleStrategyHint.control_population_size_with_elitism),
            is_(True))

    def fitness_get_keyfunc_dummy(self, _):
        return lambda r: 0 \
            if r == self.mk_rule('A', 'G', 'C') \
            else 1000

    def test_should_be_able_to_apply_strategy_for_non_terminal_production(self):
        # Given:
        rule_not_to_be_replaced = self.mk_rule('T', 'E', 'C')
        rule_to_be_replaced = self.mk_rule('G', 'W', 'C')
        self.rule_population_mock.get_all_non_terminal_rules.return_value = [
            rule_not_to_be_replaced, self.mk_rule('A', 'E', 'W'),
            self.mk_rule('A', 'W', 'H'), self.mk_rule('T', 'B', 'W'), rule_to_be_replaced
        ]
        self.rule_population_mock.get_random_rules_matching_filter.return_value = [
            rule_to_be_replaced
        ]

        self.fitness_mock.get_keyfunc_getter.side_effect = self.fitness_get_keyfunc_dummy

        # When:
        self.sut.generate_elite(self.rule_supervisor_mock, self.statistics_mock,
                                self.rule_population_mock)
        self.sut.apply(self.rule_supervisor_mock, self.statistics_mock, self.rule,
                       self.rule_population_mock)

        # Then:
        assert_that(self.rule_population_mock.get_random_rules_matching_filter.call_count,
                    is_(equal_to(2)))
        self.rule_population_mock.remove_rule.assert_called_once_with(rule_to_be_replaced)
        self.statistics_mock.on_rule_removed.\
            assert_called_once_with(rule_to_be_replaced)
        self.rule_population_mock.add_rule.assert_called_once_with(self.rule, self.randomizer_mock)
        self.statistics_mock.on_added_new_rule.\
            assert_called_once_with(self.rule)

    def test_should_not_add_existing_rule(self):
        # Given:
        self.rule_population_mock.get_all_non_terminal_rules.return_value = [
            self.mk_rule('A', 'E', 'W'),
            self.mk_rule('A', 'W', 'H'), self.mk_rule('T', 'B', 'W')
        ]

        self.fitness_mock.get_keyfunc_getter.side_effect = self.fitness_get_keyfunc_dummy

        self.rule_population_mock.has_rule.return_value = True

        # When:
        self.sut.generate_elite(self.rule_supervisor_mock, self.statistics_mock,
                                self.rule_population_mock)
        self.sut.apply(self.rule_supervisor_mock, self.statistics_mock, self.rule,
                       self.rule_population_mock)

        # Then:
        assert_that(self.rule_population_mock.get_random_rules_matching_filter.call_count,
                    is_(equal_to(0)))
        assert_that(not_(self.rule_population_mock.remove_rule.called))
        assert_that(not_(self.statistics_mock.on_rule_removed.called))
        assert_that(not_(self.rule_population_mock.add_rule.called))
        assert_that(not_(self.statistics_mock.on_added_new_rule.called))