forked from ArchipelagoMW/Archipelago
-
Notifications
You must be signed in to change notification settings - Fork 0
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
The Witness: Add some unit tests (ArchipelagoMW#3328)
* Add hidden early symbol item option, make some unit tests * Add early symbol item false to the arrows test * I guess it's not an issue * more tests * assertEqual * cleanup * add minimum symbols test for all 3 modes * Formatting * Add more minimal beatability tests * one more for the road * I HATE THIS AAAAAAAAAAAHHHHHHHHHHH WHY DID WE GO WITH OPTIONS * loiaqeäsdhgalikSDGHjasDÖKHGASKLDÖGHJASKLJGHJSAÖkfaöslifjasöfASGJÖASDLFGJ'sklgösLGIKsdhJLGÖsdfjälghklDASFJghjladshfgjasdfälkjghasdöLfghasd-kjgjASDLÖGHAESKDLJGJÖsdaLGJHsadöKGjFDSLAkgjölSÄDghbASDFKGjasdLJGhjLÖSDGHLJASKDkgjldafjghjÖLADSFghäasdökgjäsadjlgkjsadkLHGsaDÖLGSADGÖLwSdlgkJLwDSFÄLHBJsaöfdkHweaFGIoeWjvlkdösmVJÄlsafdJKhvjdsJHFGLsdaövhWDsköLV-ksdFJHGVöSEKD * fix imports (within apworld needs to be relative) * Update worlds/witness/options.py Co-authored-by: Exempt-Medic <[email protected]> * Sure * good suggestion * subtest * Add some EP shuffle unit tests, also an explicit event-checking unit test * add more tests yay * oops * mypy * Update worlds/witness/options.py Co-authored-by: black-sliver <[email protected]> * Collapse into one test :( * More efficiency * line length * More collapsing * Cleanup and docstrings --------- Co-authored-by: Exempt-Medic <[email protected]> Co-authored-by: black-sliver <[email protected]>
- Loading branch information
1 parent
bfac100
commit f99ee77
Showing
10 changed files
with
685 additions
and
16 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,161 @@ | ||
from test.bases import WorldTestBase | ||
from test.general import gen_steps, setup_multiworld | ||
from test.multiworld.test_multiworlds import MultiworldTestBase | ||
from typing import Any, ClassVar, Dict, Iterable, List, Mapping, Union, cast | ||
|
||
from BaseClasses import CollectionState, Entrance, Item, Location, Region | ||
|
||
from .. import WitnessWorld | ||
|
||
|
||
class WitnessTestBase(WorldTestBase): | ||
game = "The Witness" | ||
player: ClassVar[int] = 1 | ||
|
||
world: WitnessWorld | ||
|
||
def can_beat_game_with_items(self, items: Iterable[Item]) -> bool: | ||
""" | ||
Check that the items listed are enough to beat the game. | ||
""" | ||
|
||
state = CollectionState(self.multiworld) | ||
for item in items: | ||
state.collect(item) | ||
return state.multiworld.can_beat_game(state) | ||
|
||
def assert_dependency_on_event_item(self, spot: Union[Location, Region, Entrance], item_name: str) -> None: | ||
""" | ||
WorldTestBase.assertAccessDependency, but modified & simplified to work with event items | ||
""" | ||
event_items = [item for item in self.multiworld.get_items() if item.name == item_name] | ||
self.assertTrue(event_items, f"Event item {item_name} does not exist.") | ||
|
||
event_locations = [cast(Location, event_item.location) for event_item in event_items] | ||
|
||
# Checking for an access dependency on an event item requires a bit of extra work, | ||
# as state.remove forces a sweep, which will pick up the event item again right after we tried to remove it. | ||
# So, we temporarily set the access rules of the event locations to be impossible. | ||
original_rules = {event_location.name: event_location.access_rule for event_location in event_locations} | ||
for event_location in event_locations: | ||
event_location.access_rule = lambda _: False | ||
|
||
# We can't use self.assertAccessDependency here, it doesn't work for event items. (As of 2024-06-30) | ||
test_state = self.multiworld.get_all_state(False) | ||
|
||
self.assertFalse(spot.can_reach(test_state), f"{spot.name} is reachable without {item_name}") | ||
|
||
test_state.collect(event_items[0]) | ||
|
||
self.assertTrue(spot.can_reach(test_state), f"{spot.name} is not reachable despite having {item_name}") | ||
|
||
# Restore original access rules. | ||
for event_location in event_locations: | ||
event_location.access_rule = original_rules[event_location.name] | ||
|
||
def assert_location_exists(self, location_name: str, strict_check: bool = True) -> None: | ||
""" | ||
Assert that a location exists in this world. | ||
If strict_check, also make sure that this (non-event) location COULD exist. | ||
""" | ||
|
||
if strict_check: | ||
self.assertIn(location_name, self.world.location_name_to_id, f"Location {location_name} can never exist") | ||
|
||
try: | ||
self.world.get_location(location_name) | ||
except KeyError: | ||
self.fail(f"Location {location_name} does not exist.") | ||
|
||
def assert_location_does_not_exist(self, location_name: str, strict_check: bool = True) -> None: | ||
""" | ||
Assert that a location exists in this world. | ||
If strict_check, be explicit about whether the location could exist in the first place. | ||
""" | ||
|
||
if strict_check: | ||
self.assertIn(location_name, self.world.location_name_to_id, f"Location {location_name} can never exist") | ||
|
||
self.assertRaises( | ||
KeyError, | ||
lambda _: self.world.get_location(location_name), | ||
f"Location {location_name} exists, but is not supposed to.", | ||
) | ||
|
||
def assert_can_beat_with_minimally(self, required_item_counts: Mapping[str, int]) -> None: | ||
""" | ||
Assert that the specified mapping of items is enough to beat the game, | ||
and that having one less of any item would result in the game being unbeatable. | ||
""" | ||
# Find the actual items | ||
found_items = [item for item in self.multiworld.get_items() if item.name in required_item_counts] | ||
actual_items: Dict[str, List[Item]] = {item_name: [] for item_name in required_item_counts} | ||
for item in found_items: | ||
if len(actual_items[item.name]) < required_item_counts[item.name]: | ||
actual_items[item.name].append(item) | ||
|
||
# Assert that enough items exist in the item pool to satisfy the specified required counts | ||
for item_name, item_objects in actual_items.items(): | ||
self.assertEqual( | ||
len(item_objects), | ||
required_item_counts[item_name], | ||
f"Couldn't find {required_item_counts[item_name]} copies of item {item_name} available in the pool, " | ||
f"only found {len(item_objects)}", | ||
) | ||
|
||
# assert that multiworld is beatable with the items specified | ||
self.assertTrue( | ||
self.can_beat_game_with_items(item for items in actual_items.values() for item in items), | ||
f"Could not beat game with items: {required_item_counts}", | ||
) | ||
|
||
# assert that one less copy of any item would result in the multiworld being unbeatable | ||
for item_name, item_objects in actual_items.items(): | ||
with self.subTest(f"Verify cannot beat game with one less copy of {item_name}"): | ||
removed_item = item_objects.pop() | ||
self.assertFalse( | ||
self.can_beat_game_with_items(item for items in actual_items.values() for item in items), | ||
f"Game was beatable despite having {len(item_objects)} copies of {item_name} " | ||
f"instead of the specified {required_item_counts[item_name]}", | ||
) | ||
item_objects.append(removed_item) | ||
|
||
|
||
class WitnessMultiworldTestBase(MultiworldTestBase): | ||
options_per_world: List[Dict[str, Any]] | ||
common_options: Dict[str, Any] = {} | ||
|
||
def setUp(self) -> None: | ||
""" | ||
Set up a multiworld with multiple players, each using different options. | ||
""" | ||
|
||
self.multiworld = setup_multiworld([WitnessWorld] * len(self.options_per_world), ()) | ||
|
||
for world, options in zip(self.multiworld.worlds.values(), self.options_per_world): | ||
for option_name, option_value in {**self.common_options, **options}.items(): | ||
option = getattr(world.options, option_name) | ||
self.assertIsNotNone(option) | ||
|
||
option.value = option.from_any(option_value).value | ||
|
||
self.assertSteps(gen_steps) | ||
|
||
def collect_by_name(self, item_names: Union[str, Iterable[str]], player: int) -> List[Item]: | ||
""" | ||
Collect all copies of a specified item name (or list of item names) for a player in the multiworld item pool. | ||
""" | ||
|
||
items = self.get_items_by_name(item_names, player) | ||
for item in items: | ||
self.multiworld.state.collect(item) | ||
return items | ||
|
||
def get_items_by_name(self, item_names: Union[str, Iterable[str]], player: int) -> List[Item]: | ||
""" | ||
Return all copies of a specified item name (or list of item names) for a player in the multiworld item pool. | ||
""" | ||
|
||
if isinstance(item_names, str): | ||
item_names = (item_names,) | ||
return [item for item in self.multiworld.itempool if item.name in item_names and item.player == player] |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,66 @@ | ||
from ..test import WitnessMultiworldTestBase, WitnessTestBase | ||
|
||
|
||
class TestElevatorsComeToYou(WitnessTestBase): | ||
options = { | ||
"elevators_come_to_you": True, | ||
"shuffle_doors": "mixed", | ||
"shuffle_symbols": False, | ||
} | ||
|
||
def test_bunker_laser(self) -> None: | ||
""" | ||
In elevators_come_to_you, Bunker can be entered from the back. | ||
This means that you can access the laser with just Bunker Elevator Control (Panel). | ||
It also means that you can, for example, access UV Room with the Control and the Elevator Room Entry Door. | ||
""" | ||
|
||
self.assertFalse(self.multiworld.state.can_reach("Bunker Laser Panel", "Location", self.player)) | ||
|
||
self.collect_by_name("Bunker Elevator Control (Panel)") | ||
|
||
self.assertTrue(self.multiworld.state.can_reach("Bunker Laser Panel", "Location", self.player)) | ||
self.assertFalse(self.multiworld.state.can_reach("Bunker UV Room 2", "Location", self.player)) | ||
|
||
self.collect_by_name("Bunker Elevator Room Entry (Door)") | ||
self.collect_by_name("Bunker Drop-Down Door Controls (Panel)") | ||
|
||
self.assertTrue(self.multiworld.state.can_reach("Bunker UV Room 2", "Location", self.player)) | ||
|
||
|
||
class TestElevatorsComeToYouBleed(WitnessMultiworldTestBase): | ||
options_per_world = [ | ||
{ | ||
"elevators_come_to_you": False, | ||
}, | ||
{ | ||
"elevators_come_to_you": True, | ||
}, | ||
{ | ||
"elevators_come_to_you": False, | ||
}, | ||
] | ||
|
||
common_options = { | ||
"shuffle_symbols": False, | ||
"shuffle_doors": "panels", | ||
} | ||
|
||
def test_correct_access_per_player(self) -> None: | ||
""" | ||
Test that in a multiworld with players that alternate the elevators_come_to_you option, | ||
the actual behavior alternates as well and doesn't bleed over from slot to slot. | ||
(This is essentially a "does connection info bleed over" test). | ||
""" | ||
|
||
self.assertFalse(self.multiworld.state.can_reach("Bunker Laser Panel", "Location", 1)) | ||
self.assertFalse(self.multiworld.state.can_reach("Bunker Laser Panel", "Location", 2)) | ||
self.assertFalse(self.multiworld.state.can_reach("Bunker Laser Panel", "Location", 3)) | ||
|
||
self.collect_by_name(["Bunker Elevator Control (Panel)"], 1) | ||
self.collect_by_name(["Bunker Elevator Control (Panel)"], 2) | ||
self.collect_by_name(["Bunker Elevator Control (Panel)"], 3) | ||
|
||
self.assertFalse(self.multiworld.state.can_reach("Bunker Laser Panel", "Location", 1)) | ||
self.assertTrue(self.multiworld.state.can_reach("Bunker Laser Panel", "Location", 2)) | ||
self.assertFalse(self.multiworld.state.can_reach("Bunker Laser Panel", "Location", 3)) |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,37 @@ | ||
from ..rules import _has_lasers | ||
from ..test import WitnessTestBase | ||
|
||
|
||
class TestDisableNonRandomized(WitnessTestBase): | ||
options = { | ||
"disable_non_randomized_puzzles": True, | ||
"shuffle_doors": "panels", | ||
"early_symbol_item": False, | ||
} | ||
|
||
def test_locations_got_disabled_and_alternate_activation_triggers_work(self) -> None: | ||
""" | ||
Test the different behaviors of the disable_non_randomized mode: | ||
1. Unrandomized locations like Orchard Apple Tree 5 are disabled. | ||
2. Certain doors or lasers that would usually be activated by unrandomized panels depend on event items instead. | ||
3. These alternate activations are tied to solving Discarded Panels. | ||
""" | ||
|
||
with self.subTest("Test that unrandomized locations are disabled."): | ||
self.assert_location_does_not_exist("Orchard Apple Tree 5") | ||
|
||
with self.subTest("Test that alternate activation trigger events exist."): | ||
self.assert_dependency_on_event_item( | ||
self.world.get_entrance("Town Tower After Third Door to Town Tower Top"), | ||
"Town Tower 4th Door Opens", | ||
) | ||
|
||
with self.subTest("Test that alternate activation triggers award lasers."): | ||
self.assertFalse(_has_lasers(1, self.world, False)(self.multiworld.state)) | ||
|
||
self.collect_by_name("Triangles") | ||
|
||
# Alternate triggers yield Bunker Laser (Mountainside Discard) and Monastery Laser (Desert Discard) | ||
self.assertTrue(_has_lasers(2, self.world, False)(self.multiworld.state)) | ||
self.assertFalse(_has_lasers(3, self.world, False)(self.multiworld.state)) |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,24 @@ | ||
from ..test import WitnessTestBase | ||
|
||
|
||
class TestIndividualDoors(WitnessTestBase): | ||
options = { | ||
"shuffle_doors": "doors", | ||
"door_groupings": "off", | ||
} | ||
|
||
def test_swamp_laser_shortcut(self) -> None: | ||
""" | ||
Test that Door Shuffle grants early access to Swamp Laser from the back shortcut. | ||
""" | ||
|
||
self.assertTrue(self.get_items_by_name("Swamp Laser Shortcut (Door)")) | ||
|
||
self.assertAccessDependency( | ||
["Swamp Laser Panel"], | ||
[ | ||
["Swamp Laser Shortcut (Door)"], | ||
["Swamp Red Underwater Exit (Door)"], | ||
], | ||
only_check_listed=True, | ||
) |
Oops, something went wrong.