def match_result(self, other):
return MatchResult([
MatchVariant([
Isomorphic(target=self.concrete_element(),
pattern=other.concrete_element()),
Isomorphic(target=self.concrete_visitor(),
pattern=other.concrete_visitor()),
Isomorphic(target=self.element(), pattern=other.element()),
Isomorphic(target=self.visitor(), pattern=other.visitor()),
Isomorphic(target=self.visitor_visit(),
pattern=other.visitor_visit()),
Isomorphic(target=self.concrete_visitor_visit(),
pattern=other.concrete_visitor_visit()),
Isomorphic(target=self.element_accept(),
pattern=other.element_accept()),
Isomorphic(target=self.concrete_element_accept(),
pattern=other.concrete_element_accept()),
Isomorphic(target=self.visitor_type(),
pattern=other.visitor_type()),
Isomorphic(target=self.concrete_element_type(),
pattern=other.concrete_element_type()),
Isomorphic(target=self.visitor_visit_concrete_element(),
pattern=other.visitor_visit_concrete_element()),
Isomorphic(
target=self.concrete_visitor_visit_concrete_element(),
pattern=other.concrete_visitor_visit_concrete_element(),
),
Isomorphic(target=self.element_accept_visitor(),
pattern=other.element_accept_visitor()),
Isomorphic(target=self.concrete_element_accept_visitor(),
pattern=other.concrete_element_accept_visitor()),
])
])
def test_make_not_empty_should_succeed(self):
match_result = MatchResult([
MatchVariant([Isomorphic(Class('A'), Class('B'))]),
MatchVariant([
Isomorphic(Class('C'), Class('D')),
Isomorphic(Class('E'), Class('F')),
]),
])
assert_that(
str(match_result),
equal_to('class A === class B\n'
'\n'
'class C === class D\n'
'class E === class F'))
assert_that(
repr(match_result),
equal_to("MatchResult([\n"
"MatchVariant([\n"
"Isomorphic(Class('A'), Class('B'))\n"
"]),\n"
"MatchVariant([\n"
"Isomorphic(Class('C'), Class('D')),\n"
"Isomorphic(Class('E'), Class('F'))\n"
"])\n"
"])"))
assert_that(len(match_result), equal_to(2))
def match_result(self, other):
return MatchResult([
MatchVariant([
Isomorphic(target=self.abstract_factory(),
pattern=other.abstract_factory()),
Isomorphic(target=self.concrete_factory(),
pattern=other.concrete_factory()),
Isomorphic(target=self.abstract_product(),
pattern=other.abstract_product()),
Isomorphic(target=self.concrete_product(),
pattern=other.concrete_product()),
Isomorphic(target=self.abstract_factory_create(),
pattern=other.abstract_factory_create()),
Isomorphic(target=self.concrete_factory_create(),
pattern=other.concrete_factory_create()),
Isomorphic(target=self.abstract_product_type(),
pattern=other.abstract_product_type()),
])
])
def test_match_abstract_factory_pattern_in_bukkit_example(self):
t = BukkitExample()
p = AbstractFactory()
expected_match_result = MatchResult([
MatchVariant([
Isomorphic(t.command(), p.abstract_factory()),
Isomorphic(t.command_sender(), p.abstract_product()),
Isomorphic(t.console_command_sender(), p.concrete_product()),
Isomorphic(t.plugin_command(), p.concrete_factory()),
Isomorphic(t.command_create(), p.abstract_factory_create()),
Isomorphic(t.plugin_command_create(),
p.concrete_factory_create()),
Isomorphic(t.command_sender_type(), p.abstract_product_type())
]),
MatchVariant([
Isomorphic(t.command(), p.abstract_factory()),
Isomorphic(t.command_sender(), p.abstract_product()),
Isomorphic(t.console_command_sender(), p.concrete_product()),
Isomorphic(t.formatted_command_alias(), p.concrete_factory()),
Isomorphic(t.command_create(), p.abstract_factory_create()),
Isomorphic(t.formatted_command_alias_create(),
p.concrete_factory_create()),
Isomorphic(t.command_sender_type(), p.abstract_product_type())
]),
])
assert_that(t.command().equiv_pattern(p.abstract_factory()))
assert_that(t.command_create().equiv_pattern(
p.abstract_factory_create()))
assert_that(t.command_sender().equiv_pattern(p.abstract_product()))
assert_that(t.command_sender_type().equiv_pattern(
p.abstract_product_type()))
assert_that(t.console_command_sender().equiv_pattern(
p.concrete_product()))
assert_that(t.formatted_command_alias().equiv_pattern(
p.concrete_factory()))
assert_that(t.formatted_command_alias_create().equiv_pattern(
p.concrete_factory_create()))
assert_that(t.plugin_command().equiv_pattern(p.concrete_factory()))
assert_that(t.plugin_command_create().equiv_pattern(
p.concrete_factory_create()))
match_result = t.create().match(p.create())
assert_that(match_result, equal_to(expected_match_result))
def test_match_decorator_pattern_in_burgers_limit_one(self):
t = Burgers()
p = Decorator()
expected_match_result = MatchResult([
MatchVariant([
Isomorphic(t.burger(), p.component()),
Isomorphic(t.burger_with(), p.decorator()),
Isomorphic(t.cheese(), p.concrete_decorator()),
Isomorphic(t.cheeseburger(), p.concrete_component()),
Isomorphic(t.burger_with_burger(), p.decorator_component()),
Isomorphic(t.burger_price(), p.component_operation()),
Isomorphic(t.burger_with_price(), p.decorator_operation()),
Isomorphic(t.cheese_price(), p.concrete_decorator_operation()),
Isomorphic(t.cheeseburger_price(),
p.concrete_component_operation()),
Isomorphic(t.burger_type(), p.component_type()),
]),
])
match_result = t.create().match(p.create(), 1)
assert_that(match_result, equal_to(expected_match_result))
def match_result(self, other):
return MatchResult([
MatchVariant([
Isomorphic(target=self.component(), pattern=other.component()),
Isomorphic(target=self.concrete_component(),
pattern=other.concrete_component()),
Isomorphic(target=self.decorator(), pattern=other.decorator()),
Isomorphic(target=self.concrete_decorator(),
pattern=other.concrete_decorator()),
Isomorphic(target=self.decorator_component(),
pattern=other.decorator_component()),
Isomorphic(target=self.component_operation(),
pattern=other.component_operation()),
Isomorphic(target=self.decorator_operation(),
pattern=other.decorator_operation()),
Isomorphic(target=self.concrete_component_operation(),
pattern=other.concrete_component_operation()),
Isomorphic(target=self.concrete_component_operation(),
pattern=other.concrete_component_operation()),
Isomorphic(target=self.component_type(),
pattern=other.component_type()),
])
])
def test_match_empty_should_has_empty_match_result(self):
assert_that(Model().match(Model()), equal_to(MatchResult()))
def test_make_empty_should_succeed(self):
match_result = MatchResult()
assert_that(str(match_result), equal_to(''))
assert_that(repr(match_result), equal_to('MatchResult()'))
assert_that(len(match_result), equal_to(0))