def test_expand_alternatives_4(blank_resource_db):
db = blank_resource_db
a = make_single_set(make_req_a(db))
b = make_single_set(make_req_b(db))
expected = RequirementSet([
RequirementList([make_req_a(db)[1]]),
RequirementList([make_req_b(db)[1]])
])
assert a.expand_alternatives(b) == expected
def test_prevent_redundant(blank_game_description):
db = blank_game_description.resource_database
res_a, id_req_a = make_req_a(db)
res_b, id_req_b = make_req_b(db)
the_set = RequirementSet([
RequirementList([id_req_a]),
RequirementList([id_req_a, id_req_b]),
])
assert the_set.alternatives == frozenset([RequirementList([id_req_a])])
def test_requirement_as_set_1(database):
def _req(name: str):
id_req = ResourceRequirement.simple(database.get_item(name))
return id_req
req = RequirementAnd([
_req("A"),
RequirementOr([_req("B"), _req("C")]),
RequirementOr([_req("D"), _req("E")]),
])
assert req.as_set(database) == RequirementSet([
RequirementList([_req("A"), _req("B"), _req("D")]),
RequirementList([_req("A"), _req("B"), _req("E")]),
RequirementList([_req("A"), _req("C"), _req("D")]),
RequirementList([_req("A"), _req("C"), _req("E")]),
])
def test_requirement_list_constructor(echoes_resource_database):
def item(name):
return search.find_resource_info_with_long_name(
echoes_resource_database.item, name)
req_list = RequirementList([
ResourceRequirement.simple(item("Dark Visor")),
ResourceRequirement.create(item("Missile"), 5, False),
ResourceRequirement.simple(item("Seeker Launcher")),
])
extract = [(req.resource.long_name, req.amount)
for req in req_list.values()]
assert sorted(extract) == [
("Dark Visor", 1),
("Missile", 5),
("Seeker Launcher", 1),
]
def test_requirement_template_nested(database):
def _req(name: str):
id_req = ResourceRequirement.simple(database.get_item(name))
return id_req
# Setup
use_a = RequirementTemplate("Use A")
use_b = RequirementTemplate("Use B")
database.requirement_template["Use A"] = _req("A")
database.requirement_template["Use B"] = RequirementOr([use_a, _req("B")])
# Run
as_set = use_b.as_set(database)
# Assert
assert as_set == RequirementSet([
RequirementList([_req("A")]),
RequirementList([_req("B")]),
])
assert hash(use_a) != hash(use_b)
def test_requirement_as_set_3(database):
def _req(name: str):
id_req = ResourceRequirement.simple(database.get_item(name))
return id_req
req = RequirementOr([
Requirement.impossible(),
_req("A"),
])
assert req.as_set(database) == RequirementSet([
RequirementList([_req("A")]),
])
def test_requirement_set_constructor(echoes_resource_database):
item = echoes_resource_database.get_item_by_name
req_set = RequirementSet([
RequirementList([
ResourceRequirement.simple(item("Dark Visor")),
ResourceRequirement.create(item("Missile"), 5, False),
ResourceRequirement.simple(item("Seeker Launcher")),
]),
RequirementList([
ResourceRequirement.simple(item("Screw Attack")),
ResourceRequirement.simple(item("Space Jump Boots")),
]),
RequirementList([
ResourceRequirement.simple(item("Power Bomb")),
ResourceRequirement.simple(item("Boost Ball")),
]),
])
extract = [
sorted((req.resource.long_name, req.amount)
for req in req_list.values())
for req_list in req_set.alternatives
]
assert sorted(extract) == [
[
("Boost Ball", 1),
("Power Bomb", 1),
],
[
("Dark Visor", 1),
("Missile", 5),
("Seeker Launcher", 1),
],
[
("Screw Attack", 1),
("Space Jump Boots", 1),
],
]
def test_list_dangerous_resources(database, input_data, output_data):
# setup
req_list = RequirementList(
(ResourceRequirement.create(database.resource_by_index[item[0]], 1,
item[1]) for item in input_data))
expected_result = {
database.resource_by_index[item]
for item in output_data
}
# run
result = set(req_list.dangerous_resources)
# assert
assert result == expected_result
def test_trivial_merge(blank_game_description):
db = blank_game_description.resource_database
res_a, id_req_a = make_req_a(db)
trivial = RequirementSet.trivial()
impossible = RequirementSet.impossible()
the_set = RequirementSet([
RequirementList([id_req_a]),
])
assert trivial.union(trivial) == trivial
assert trivial.union(the_set) == the_set
assert the_set.union(trivial) == the_set
assert trivial.union(impossible) == impossible
assert impossible.union(the_set) == impossible
assert the_set.union(impossible) == impossible
assert the_set.union(the_set) == the_set
