def test_swapping_with_unintended_intent(self): """ The intent is questionable. England: A Liverpool - Edinburgh F English Channel Convoys A Liverpool - Edinburgh Germany: A Edinburgh - Liverpool France: F Irish Sea Hold F North Sea Hold Russia: F Norwegian Sea Convoys A Liverpool - Edinburgh F North Atlantic Ocean Convoys A Liverpool - Edinburgh See issue 4.A.3. For choice a, b and c the English army in Liverpool will move by convoy and consequentially the two armies are swapped. For choice d, the 1982/2000 rulebook (which I prefer), the convoy depends on the "intent". England intended to convoy via the French fleets in the Irish Sea and the North Sea. However, the French did not order the convoy. The alternative route with the Russian fleets was unintended. The English fleet in the English Channel (with the convoy order) is not part of this alternative route with the Russian fleets. Since England still "intent" to convoy, the move from Liverpool to Edinburgh should be via convoy and the two armies are swapped. Although, you could argue that this is not really according to the clarification of the 2000 rulebook. When explicit adjacent convoying is used (DPTG, choice e), then the English army did not receive an order to move by convoy. So, it is just a head to head battle and both the army in Edinburgh and Liverpool will not move. """ Army(self.state, 0, Nations.ENGLAND, self.territories.LIVERPOOL), Fleet(self.state, 0, Nations.ENGLAND, self.territories.ENGLISH_CHANNEL), Army(self.state, 0, Nations.GERMANY, self.territories.EDINBURGH), Fleet(self.state, 0, Nations.FRANCE, self.territories.IRISH_SEA), Fleet(self.state, 0, Nations.FRANCE, self.territories.NORTH_SEA), Fleet(self.state, 0, Nations.RUSSIA, self.territories.NORWEGIAN_SEA), Fleet(self.state, 0, Nations.RUSSIA, self.territories.NORTH_ATLANTIC), orders = [ Move(self.state, 0, Nations.ENGLAND, self.territories.LIVERPOOL, self.territories.EDINBURGH), Convoy(self.state, 0, Nations.ENGLAND, self.territories.ENGLISH_CHANNEL, self.territories.LIVERPOOL, self.territories.EDINBURGH), Move(self.state, 0, Nations.GERMANY, self.territories.EDINBURGH, self.territories.LIVERPOOL), Hold(self.state, 0, Nations.FRANCE, self.territories.IRISH_SEA), Hold(self.state, 0, Nations.FRANCE, self.territories.NORTH_SEA), Convoy(self.state, 0, Nations.RUSSIA, self.territories.NORWEGIAN_SEA, self.territories.LIVERPOOL, self.territories.EDINBURGH), Convoy(self.state, 0, Nations.RUSSIA, self.territories.NORTH_ATLANTIC, self.territories.LIVERPOOL, self.territories.EDINBURGH), ] process(self.state) self.assertEqual(orders[0].outcome, Outcomes.FAILS) self.assertEqual(orders[2].outcome, Outcomes.FAILS)
def test_simple_bounce(self): """ Two armies bouncing on each other. Austria: A Vienna - Tyrolia Italy: A Venice - Tyrolia The two units bounce. """ Army(self.state, 0, Nations.AUSTRIA, self.territories.VIENNA), Army(self.state, 0, Nations.ITALY, self.territories.VENICE), army_vienna_move = Move(self.state, 0, Nations.AUSTRIA, self.territories.VIENNA, self.territories.TYROLIA) army_venice_move = Move(self.state, 0, Nations.ITALY, self.territories.VENICE, self.territories.TYROLIA) process(self.state) self.assertTrue(army_venice_move.legal) self.assertTrue(army_vienna_move.legal) self.assertEqual(army_vienna_move.outcome, Outcomes.FAILS) self.assertEqual(army_venice_move.outcome, Outcomes.FAILS)
def test_no_help_in_dislodging_own_unit(self): """ To help a foreign power to dislodge own unit in head to head battle is not possible. Germany: A Berlin - Kiel A Munich Supports F Kiel - Berlin England: F Kiel - Berlin No unit will move. """ pieces = [ Army(0, Nations.GERMANY, self.territories.BERLIN), Army(0, Nations.GERMANY, self.territories.MUNICH), Fleet(0, Nations.ENGLAND, self.territories.KIEL), ] orders = [ Move(0, Nations.GERMANY, self.territories.BERLIN, self.territories.KIEL), Support(0, Nations.GERMANY, self.territories.MUNICH, self.territories.KIEL, self.territories.BERLIN), Move(0, Nations.ENGLAND, self.territories.KIEL, self.territories.BERLIN), ] self.state.register(*pieces, *orders) self.state.post_register_updates() process(self.state) self.assertTrue(orders[0].outcome, Outcomes.FAILS) self.assertTrue(orders[1].outcome, Outcomes.SUCCEEDS) self.assertTrue(orders[2].outcome, Outcomes.FAILS)
def test_disrupted_three_army_circular_movement(self): """ When one of the units bounces, the whole circular movement will hold. Turkey: F Ankara - Constantinople A Constantinople - Smyrna A Smyrna - Ankara A Bulgaria - Constantinople Every unit will keep its place. """ Fleet(self.state, 0, Nations.TURKEY, self.territories.ANKARA), Army(self.state, 0, Nations.TURKEY, self.territories.BULGARIA), Army(self.state, 0, Nations.TURKEY, self.territories.CONSTANTINOPLE), Army(self.state, 0, Nations.TURKEY, self.territories.SMYRNA) orders = [ Move(self.state, 0, Nations.TURKEY, self.territories.ANKARA, self.territories.CONSTANTINOPLE), Move(self.state, 0, Nations.TURKEY, self.territories.CONSTANTINOPLE, self.territories.SMYRNA), Move(self.state, 0, Nations.TURKEY, self.territories.SMYRNA, self.territories.ANKARA), Move(self.state, 0, Nations.TURKEY, self.territories.BULGARIA, self.territories.CONSTANTINOPLE), ] process(self.state) self.assertEqual(orders[0].outcome, Outcomes.FAILS) self.assertEqual(orders[1].outcome, Outcomes.FAILS) self.assertEqual(orders[2].outcome, Outcomes.FAILS) self.assertEqual(orders[3].outcome, Outcomes.FAILS)
def test_three_army_circular_movement_with_support(self): """ Three units can change place, even when one gets support. Turkey: F Ankara - Constantinople A Constantinople - Smyrna A Smyrna - Ankara A Bulgaria Supports F Ankara - Constantinople Of course the three units will move, but knowing how programs are written, this can confuse the adjudicator. """ Fleet(self.state, 0, Nations.TURKEY, self.territories.ANKARA), Army(self.state, 0, Nations.TURKEY, self.territories.BULGARIA), Army(self.state, 0, Nations.TURKEY, self.territories.CONSTANTINOPLE), Army(self.state, 0, Nations.TURKEY, self.territories.SMYRNA) orders = [ Move(self.state, 0, Nations.TURKEY, self.territories.ANKARA, self.territories.CONSTANTINOPLE), Move(self.state, 0, Nations.TURKEY, self.territories.CONSTANTINOPLE, self.territories.SMYRNA), Move(self.state, 0, Nations.TURKEY, self.territories.SMYRNA, self.territories.ANKARA), Support(self.state, 0, Nations.TURKEY, self.territories.BULGARIA, self.territories.ANKARA, self.territories.CONSTANTINOPLE), ] process(self.state) self.assertEqual(orders[0].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[1].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[2].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[3].outcome, Outcomes.SUCCEEDS)
def test_attacked_convoy_is_not_disrupted(self): """ A convoy can only be disrupted by dislodging the fleets. Attacking is not sufficient. England: F North Sea Convoys A London - Holland A London - Holland Germany: F Skagerrak - North Sea The army in London will successfully convoy and end in Holland. """ Fleet(self.state, 0, Nations.ENGLAND, self.territories.NORTH_SEA), Army(self.state, 0, Nations.ENGLAND, self.territories.LONDON), Fleet(self.state, 0, Nations.GERMANY, self.territories.SKAGERRAK) orders = [ Convoy(self.state, 0, Nations.ENGLAND, self.territories.NORTH_SEA, self.territories.LONDON, self.territories.HOLLAND), Move(self.state, 0, Nations.ENGLAND, self.territories.LONDON, self.territories.HOLLAND, via_convoy=True), Move(self.state, 0, Nations.GERMANY, self.territories.SKAGERRAK, self.territories.NORTH_SEA), ] process(self.state) self.assertEqual(orders[1].path_decision(), Outcomes.PATH) self.assertEqual(orders[1].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[2].outcome, Outcomes.FAILS)
def test_three_army_circular_movement(self): """ Three units can change place, even in spring 1901. Turkey: F Ankara - Constantinople A Constantinople - Smyrna A Smyrna - Ankara All three units will move. """ Fleet(self.state, 0, Nations.TURKEY, self.territories.ANKARA), Army(self.state, 0, Nations.TURKEY, self.territories.CONSTANTINOPLE), Army(self.state, 0, Nations.TURKEY, self.territories.SMYRNA) orders = [ Move(self.state, 0, Nations.TURKEY, self.territories.ANKARA, self.territories.CONSTANTINOPLE), Move(self.state, 0, Nations.TURKEY, self.territories.CONSTANTINOPLE, self.territories.SMYRNA), Move(self.state, 0, Nations.TURKEY, self.territories.SMYRNA, self.territories.ANKARA), ] process(self.state) self.assertEqual(orders[0].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[1].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[2].outcome, Outcomes.SUCCEEDS)
def test_bounce_of_three_units(self): """ If three units move to the same place, the adjudicator should not bounce the first two units and then let the third unit go to the now open place. Austria: A Vienna - Tyrolia Germany: A Munich - Tyrolia Italy: A Venice - Tyrolia The three units bounce. """ Army(self.state, 0, Nations.AUSTRIA, self.territories.VIENNA), Army(self.state, 0, Nations.ITALY, self.territories.VENICE), Army(self.state, 0, Nations.GERMANY, self.territories.MUNICH) army_vienna_move = Move(self.state, 0, Nations.AUSTRIA, self.territories.VIENNA, self.territories.TYROLIA) army_venice_move = Move(self.state, 0, Nations.ITALY, self.territories.VENICE, self.territories.TYROLIA) army_munich_move = Move(self.state, 0, Nations.GERMANY, self.territories.MUNICH, self.territories.TYROLIA) process(self.state) self.assertTrue(army_venice_move.legal) self.assertTrue(army_vienna_move.legal) self.assertTrue(army_munich_move.legal) self.assertEqual(army_vienna_move.outcome, Outcomes.FAILS) self.assertEqual(army_venice_move.outcome, Outcomes.FAILS) self.assertEqual(army_munich_move.outcome, Outcomes.FAILS)
def test_simple_bounce(self): """ Two armies bouncing on each other. Austria: A Vienna - Tyrolia Italy: A Venice - Tyrolia The two units bounce. """ pieces = [ Army(Nations.AUSTRIA, self.territories.VIENNA), Army(Nations.ITALY, self.territories.VENICE), ] army_vienna_move = Move(Nations.AUSTRIA, self.territories.VIENNA, self.territories.TYROLIA) army_venice_move = Move(Nations.ITALY, self.territories.VENICE, self.territories.TYROLIA) self.state.register(*pieces, army_venice_move, army_vienna_move) self.state.post_register_updates() process(self.state) self.assertEqual(army_venice_move.legal_decision, Outcomes.LEGAL) self.assertEqual(army_vienna_move.legal_decision, Outcomes.LEGAL) self.assertEqual(army_vienna_move.move_decision, Outcomes.FAILS) self.assertEqual(army_venice_move.move_decision, Outcomes.FAILS)
def test_three_way_beleaguered_garrison(self): """ In a beleaguered garrison from three sides, the adjudicator may not let two attacks fail and then let the third succeed. England: F Edinburgh Supports F Yorkshire - North Sea F Yorkshire - North Sea France: F Belgium - North Sea F English Channel Supports F Belgium - North Sea Germany: F North Sea Hold Russia: F Norwegian Sea - North Sea F Norway Supports F Norwegian Sea - North Sea None of the fleets move. The German fleet in the North Sea is not dislodged. """ pieces = [ Fleet(self.state, 0, Nations.ENGLAND, self.territories.EDINBURGH), Fleet(self.state, 0, Nations.ENGLAND, self.territories.YORKSHIRE), Fleet(self.state, 0, Nations.FRANCE, self.territories.BELGIUM), Fleet(self.state, 0, Nations.FRANCE, self.territories.ENGLISH_CHANNEL), Fleet(self.state, 0, Nations.GERMANY, self.territories.NORTH_SEA), Fleet(self.state, 0, Nations.RUSSIA, self.territories.NORWEGIAN_SEA), Fleet(self.state, 0, Nations.RUSSIA, self.territories.NORWAY), ] orders = [ Support(self.state, 0, Nations.ENGLAND, self.territories.EDINBURGH, self.territories.YORKSHIRE, self.territories.NORTH_SEA), Move(self.state, 0, Nations.ENGLAND, self.territories.YORKSHIRE, self.territories.NORTH_SEA), Move(self.state, 0, Nations.FRANCE, self.territories.BELGIUM, self.territories.NORTH_SEA), Support(self.state, 0, Nations.FRANCE, self.territories.ENGLISH_CHANNEL, self.territories.BELGIUM, self.territories.NORTH_SEA), Hold(self.state, 0, Nations.GERMANY, self.territories.NORTH_SEA), Move(self.state, 0, Nations.RUSSIA, self.territories.NORWEGIAN_SEA, self.territories.NORTH_SEA), Support(self.state, 0, Nations.RUSSIA, self.territories.NORWAY, self.territories.NORWEGIAN_SEA, self.territories.NORTH_SEA), ] process(self.state) self.assertEqual(pieces[4].dislodged_decision, Outcomes.SUSTAINS) self.assertEqual(orders[0].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[1].outcome, Outcomes.FAILS) self.assertEqual(orders[2].outcome, Outcomes.FAILS) self.assertEqual(orders[3].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[5].outcome, Outcomes.FAILS) self.assertEqual(orders[6].outcome, Outcomes.SUCCEEDS)
def test_support_to_unreachable_coast_allowed(self): """ A fleet can give support to a coast where it can not go. France: F Gascony - Spain(nc) F Marseilles Supports F Gascony - Spain(nc) Italy: F Western Mediterranean - Spain(sc) Although the fleet in Marseilles can not go to the north coast it can still support targeting the north coast. So, the support is successful, the move of the fleet in Gascony succeeds and the move of the Italian fleet fails. """ pieces = [ Fleet(Nations.FRANCE, self.territories.GASCONY), Fleet(Nations.FRANCE, self.territories.MARSEILLES), Fleet(Nations.ITALY, self.territories.WESTERN_MEDITERRANEAN) ] fleet_gascony_move = Move(Nations.FRANCE, self.territories.GASCONY, self.territories.SPAIN, self.named_coasts.SPAIN_NC) fleet_marseilles_support = Support(Nations.FRANCE, self.territories.MARSEILLES, self.territories.GASCONY, self.territories.SPAIN) fleet_western_med_move = Move(Nations.ITALY, self.territories.WESTERN_MEDITERRANEAN, self.territories.SPAIN, self.named_coasts.SPAIN_SC) self.state.register(*pieces, fleet_gascony_move, fleet_marseilles_support, fleet_western_med_move) self.state.post_register_updates() process(self.state) self.assertEqual(fleet_gascony_move.move_decision, Outcomes.MOVES) self.assertEqual(fleet_western_med_move.move_decision, Outcomes.FAILS) self.assertEqual(fleet_marseilles_support.support_decision, Outcomes.GIVEN)
def test_no_self_dislodgement_in_head_to_head_battle(self): """ Self dislodgement is not allowed. This also counts for head to head battles. Germany: A Berlin - Kiel F Kiel - Berlin A Munich Supports A Berlin - Kiel No unit will move. """ pieces = [ Army(0, Nations.GERMANY, self.territories.BERLIN), Fleet(0, Nations.GERMANY, self.territories.KIEL), Army(0, Nations.GERMANY, self.territories.MUNICH), ] orders = [ Move(0, Nations.GERMANY, self.territories.BERLIN, self.territories.KIEL), Move(0, Nations.GERMANY, self.territories.KIEL, self.territories.BERLIN), Support(0, Nations.GERMANY, self.territories.MUNICH, self.territories.BERLIN, self.territories.KIEL), ] self.state.register(*pieces, *orders) self.state.post_register_updates() process(self.state) self.assertTrue(orders[0].outcome, Outcomes.FAILS) self.assertTrue(orders[1].outcome, Outcomes.FAILS) self.assertTrue(orders[2].outcome, Outcomes.SUCCEEDS)
def test_disloged_unit_has_not_effect_on_attackers_area(self): """ An army can follow. Germany: A Berlin - Prussia F Kiel - Berlin A Silesia Supports A Berlin - Prussia Russia: A Prussia - Berlin The fleet in Kiel will move to Berlin. """ Army(self.state, 0, Nations.GERMANY, self.territories.BERLIN), Fleet(self.state, 0, Nations.GERMANY, self.territories.KIEL), Army(self.state, 0, Nations.GERMANY, self.territories.SILESIA), Army(self.state, 0, Nations.RUSSIA, self.territories.PRUSSIA), orders = [ Move(self.state, 0, Nations.GERMANY, self.territories.BERLIN, self.territories.PRUSSIA), Move(self.state, 0, Nations.GERMANY, self.territories.KIEL, self.territories.BERLIN), Support(self.state, 0, Nations.GERMANY, self.territories.SILESIA, self.territories.BERLIN, self.territories.PRUSSIA), Move(self.state, 0, Nations.RUSSIA, self.territories.PRUSSIA, self.territories.BERLIN), ] process(self.state) self.assertTrue(orders[0].outcome, Outcomes.SUCCEEDS) self.assertTrue(orders[1].outcome, Outcomes.SUCCEEDS) self.assertTrue(orders[2].outcome, Outcomes.SUCCEEDS)
def test_three_army_circular_movement(self): """ Three units can change place, even in spring 1901. Turkey: F Ankara - Constantinople A Constantinople - Smyrna A Smyrna - Ankara All three units will move. """ pieces = [ Fleet(Nations.TURKEY, self.territories.ANKARA), Army(Nations.TURKEY, self.territories.CONSTANTINOPLE), Army(Nations.TURKEY, self.territories.SMYRNA) ] orders = [ Move(Nations.TURKEY, self.territories.ANKARA, self.territories.CONSTANTINOPLE), Move(Nations.TURKEY, self.territories.CONSTANTINOPLE, self.territories.SMYRNA), Move(Nations.TURKEY, self.territories.SMYRNA, self.territories.ANKARA), ] self.state.register(*pieces, *orders) self.state.post_register_updates() process(self.state) self.assertEqual(orders[0].move_decision, Outcomes.MOVES) self.assertEqual(orders[1].move_decision, Outcomes.MOVES) self.assertEqual(orders[2].move_decision, Outcomes.MOVES)
def test_dislodge_of_multi_route_convoy_with_foreign_fleet(self): """ When the 1971 rulebook is used "unwanted" multi-route convoys are possible. England: F North Sea Convoys A London - Belgium A London - Belgium Germany: F English Channel Convoys A London - Belgium France: F Brest Supports F Mid-Atlantic Ocean - English Channel F Mid-Atlantic Ocean - English Channel If the 1982 or 2000 rulebook is used (which I prefer), it makes no difference that the convoying fleet in the English Channel is German. It will take the convoy via the North Sea anyway and the army in London will end in Belgium. However, when the 1971 rules are used, the German convoy is "unwanted". According to the DPTG the German fleet should be ignored in the English convoy, since there is a convoy path with only English fleets. That means that the convoy is not disrupted and the English army in London will end in Belgium. See also issue 4.A.1. """ pieces = [ Fleet(self.state, 0, Nations.ENGLAND, self.territories.NORTH_SEA), Army(self.state, 0, Nations.ENGLAND, self.territories.LONDON), Fleet(self.state, 0, Nations.GERMANY, self.territories.ENGLISH_CHANNEL), Fleet(self.state, 0, Nations.FRANCE, self.territories.BREST), Fleet(self.state, 0, Nations.FRANCE, self.territories.MID_ATLANTIC), ] orders = [ Convoy(self.state, 0, Nations.ENGLAND, self.territories.NORTH_SEA, self.territories.LONDON, self.territories.BELGIUM), Move(self.state, 0, Nations.ENGLAND, self.territories.LONDON, self.territories.BELGIUM, via_convoy=True), Convoy(self.state, 0, Nations.GERMANY, self.territories.ENGLISH_CHANNEL, self.territories.LONDON, self.territories.BELGIUM), Support(self.state, 0, Nations.FRANCE, self.territories.BREST, self.territories.MID_ATLANTIC, self.territories.ENGLISH_CHANNEL), Move(self.state, 0, Nations.FRANCE, self.territories.MID_ATLANTIC, self.territories.ENGLISH_CHANNEL), ] process(self.state) self.assertEqual(pieces[0].dislodged_decision, Outcomes.SUSTAINS) self.assertEqual(orders[1].path_decision(), Outcomes.PATH) self.assertEqual(orders[1].outcome, Outcomes.SUCCEEDS) self.assertEqual(pieces[2].dislodged_decision, Outcomes.DISLODGED) self.assertEqual(orders[3].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[4].outcome, Outcomes.SUCCEEDS)
def test_two_units_can_swap_places_by_convoy(self): """ The only way to swap two units, is by convoy. England: A Norway - Sweden F Skagerrak Convoys A Norway - Sweden Russia: A Sweden - Norway In most interpretation of the rules, the units in Norway and Sweden will be swapped. However, if explicit adjacent convoying is used (see issue 4.A.3), then it is just a head to head battle. I prefer the 2000 rules, so the units are swapped. """ Army(self.state, 0, Nations.ENGLAND, self.territories.NORWAY), Fleet(self.state, 0, Nations.ENGLAND, self.territories.SKAGERRAK), Army(self.state, 0, Nations.RUSSIA, self.territories.SWEDEN), orders = [ Move(self.state, 0, Nations.ENGLAND, self.territories.NORWAY, self.territories.SWEDEN, via_convoy=True), Convoy(self.state, 0, Nations.ENGLAND, self.territories.SKAGERRAK, self.territories.NORWAY, self.territories.SWEDEN), Move(self.state, 0, Nations.RUSSIA, self.territories.SWEDEN, self.territories.NORWAY), ] process(self.state) self.assertEqual(orders[0].path_decision(), Outcomes.PATH) self.assertEqual(orders[0].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[2].outcome, Outcomes.SUCCEEDS)
def test_coastal_crawl_not_allowed(self): """ If a fleet is leaving a sector from a certain coast while in the opposite direction another fleet is moving to another coast of the sector, it is still a head to head battle. This has been decided in the great revision of the 1961 rules that resulted in the 1971 rules. Turkey: F Bulgaria(sc) - Constantinople F Constantinople - Bulgaria(ec) Both moves fail. """ pieces = [ Fleet(Nations.TURKEY, self.territories.BULGARIA, self.named_coasts.BULGARIA_SC), Fleet(Nations.TURKEY, self.territories.CONSTANTINOPLE), ] orders = [ Move(Nations.TURKEY, self.territories.BULGARIA, self.territories.CONSTANTINOPLE), Move(Nations.TURKEY, self.territories.CONSTANTINOPLE, self.territories.BULGARIA, self.named_coasts.BULGARIA_EC), ] self.state.register(*pieces, *orders) self.state.post_register_updates() process(self.state) self.assertEqual(orders[0].move_decision, Outcomes.FAILS) self.assertEqual(orders[1].move_decision, Outcomes.FAILS)
def test_five_army_circular_movement(self): pieces = [ Fleet(Nations.TURKEY, self.territories.ANKARA), Army(Nations.TURKEY, self.territories.CONSTANTINOPLE), Army(Nations.TURKEY, self.territories.SMYRNA), Army(Nations.TURKEY, self.territories.ARMENIA), Army(Nations.TURKEY, self.territories.SYRIA), ] orders = [ Move(Nations.TURKEY, self.territories.ANKARA, self.territories.CONSTANTINOPLE), Move(Nations.TURKEY, self.territories.CONSTANTINOPLE, self.territories.SMYRNA), Move(Nations.TURKEY, self.territories.SMYRNA, self.territories.SYRIA), Move(Nations.TURKEY, self.territories.SYRIA, self.territories.ARMENIA), Move(Nations.TURKEY, self.territories.ARMENIA, self.territories.ANKARA), ] self.state.register(*pieces, *orders) self.state.post_register_updates() result = find_circular_movements(orders) self.assertEqual(len(result), 1) self.assertTrue(all([o in result[0] for o in orders]))
def test_illegal_head_to_head_battle_can_still_defend(self): """ If in a head to head battle, one of the units makes an illegal move, than that unit has still the possibility to defend against attacks with strength of one. England: A Liverpool - Edinburgh Russia: F Edinburgh - Liverpool The move of the Russian fleet is illegal, but can still prevent the English army to enter Edinburgh. So, none of the units move. """ pieces = [ Army(0, Nations.ENGLAND, self.territories.LIVERPOOL), Fleet(0, Nations.RUSSIA, self.territories.EDINBURGH), ] orders = [ Move(0, Nations.ENGLAND, self.territories.LIVERPOOL, self.territories.EDINBURGH), Move(0, Nations.RUSSIA, self.territories.EDINBURGH, self.territories.LIVERPOOL), ] self.state.register(*pieces, *orders) self.state.post_register_updates() process(self.state) self.assertTrue(orders[1].illegal) self.assertEqual(orders[0].outcome, Outcomes.FAILS) self.assertEqual(orders[1].outcome, Outcomes.FAILS)
def test_bounce_and_dislodge_with_double_convoy(self): """ Similar to test case 6.G.10, but now both units use a convoy and without some support. England: F North Sea Convoys A London - Belgium A Holland Supports A London - Belgium A Yorkshire - London A London - Belgium via Convoy France: F English Channel Convoys A Belgium - London A Belgium - London via Convoy The French army in Belgium is bounced by the army from Yorkshire. The army in London move to Belgium, dislodging the unit there. The final destination of the army in the Yorkshire depends on how issue 4.A.7 is resolved. If choice a is taken, then the army advances to London, but if choice b is taken (which I prefer) the army bounces and stays in Yorkshire. """ pieces = [ Fleet(0, Nations.ENGLAND, self.territories.NORTH_SEA), Army(0, Nations.ENGLAND, self.territories.HOLLAND), Army(0, Nations.ENGLAND, self.territories.YORKSHIRE), Army(0, Nations.ENGLAND, self.territories.LONDON), Fleet(0, Nations.FRANCE, self.territories.ENGLISH_CHANNEL), Army(0, Nations.FRANCE, self.territories.BELGIUM), ] orders = [ Convoy(0, Nations.ENGLAND, self.territories.NORTH_SEA, self.territories.LONDON, self.territories.BELGIUM), Support(0, Nations.ENGLAND, self.territories.HOLLAND, self.territories.LONDON, self.territories.BELGIUM), Move(0, Nations.ENGLAND, self.territories.YORKSHIRE, self.territories.LONDON), Move(0, Nations.ENGLAND, self.territories.LONDON, self.territories.BELGIUM, via_convoy=True), Convoy(0, Nations.FRANCE, self.territories.ENGLISH_CHANNEL, self.territories.BELGIUM, self.territories.LONDON), Move(0, Nations.FRANCE, self.territories.BELGIUM, self.territories.LONDON, via_convoy=True), ] self.state.register(*pieces, *orders) self.state.post_register_updates() process(self.state) self.assertEqual(orders[1].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[2].outcome, Outcomes.FAILS) self.assertEqual(orders[3].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[5].outcome, Outcomes.FAILS) self.assertEqual(pieces[5].dislodged_decision, Outcomes.DISLODGED)
def test_support_cut_on_itself_via_convoy(self): """ If a unit is attacked by a supported unit, it is not possible to prevent dislodgement by trying to cut the support. But what, if a move is attempted via a convoy? Austria: F Adriatic Sea Convoys A Trieste - Venice A Trieste - Venice via Convoy Italy: A Venice Supports F Albania - Trieste F Albania - Trieste First it should be mentioned that if for issue 4.A.3 choice b or c is taken, then the move from Trieste to Venice is just a move over land, because the army in Venice is not moving in opposite direction. In that case, the support of Venice will not be cut as normal. In any other choice for issue 4.A.3, it should be decided whether the Austrian attack is considered to be coming from Trieste or from the Adriatic Sea. If it comes from Trieste, the support in Venice is not cut and the army in Trieste is dislodged by the fleet in Albania. If the Austrian attack is considered to be coming from the Adriatic Sea, then the support is cut and the army in Trieste will not be dislodged. See also issue 4.A.4. First of all, I prefer the 1982/2000 rules for adjacent convoying. This means that I prefer the move from Trieste uses the convoy. Furthermore, I think that the two Italian units are still stronger than the army in Trieste. Therefore, I prefer that the support in Venice is not cut and that the army in Trieste is dislodged by the fleet in Albania. """ pieces = [ Fleet(0, Nations.AUSTRIA, self.territories.ADRIATIC_SEA), Army(0, Nations.AUSTRIA, self.territories.TRIESTE), Army(0, Nations.ITALY, self.territories.VENICE), Fleet(0, Nations.ITALY, self.territories.ALBANIA), ] orders = [ Convoy(0, Nations.AUSTRIA, self.territories.ADRIATIC_SEA, self.territories.TRIESTE, self.territories.VENICE), Move(0, Nations.AUSTRIA, self.territories.TRIESTE, self.territories.VENICE, via_convoy=True), Support(0, Nations.ITALY, self.territories.VENICE, self.territories.ALBANIA, self.territories.TRIESTE), Move(0, Nations.ITALY, self.territories.ALBANIA, self.territories.TRIESTE), ] self.state.register(*pieces, *orders) self.state.post_register_updates() process(self.state) self.assertEqual(pieces[1].dislodged_decision, Outcomes.DISLODGED) self.assertEqual(orders[2].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[3].outcome, Outcomes.SUCCEEDS)
def test_almost_circular_movement_self_dislodgement_with_beleaguered_garrison( self): """ Similar to the previous test case, but now the beleaguered fleet is in circular movement with the weaker attacker. So, the circular movement fails. England: F North Sea - Denmark F Yorkshire Supports F Norway - North Sea Germany: F Holland Supports F Helgoland Bight - North Sea F Helgoland Bight - North Sea F Denmark - Helgoland Bight Russia: F Skagerrak Supports F Norway - North Sea F Norway - North Sea There is no movement of fleets. """ pieces = [ Fleet(0, Nations.ENGLAND, self.territories.NORTH_SEA), Fleet(0, Nations.ENGLAND, self.territories.YORKSHIRE), Fleet(0, Nations.GERMANY, self.territories.HOLLAND), Fleet(0, Nations.GERMANY, self.territories.HELGOLAND_BIGHT), Fleet(0, Nations.GERMANY, self.territories.DENMARK), Fleet(0, Nations.RUSSIA, self.territories.SKAGERRAK), Fleet(0, Nations.RUSSIA, self.territories.NORWAY), ] orders = [ Move(0, Nations.ENGLAND, self.territories.NORTH_SEA, self.territories.DENMARK), Support(0, Nations.ENGLAND, self.territories.YORKSHIRE, self.territories.NORWAY, self.territories.NORTH_SEA), Support(0, Nations.GERMANY, self.territories.HOLLAND, self.territories.HELGOLAND_BIGHT, self.territories.NORTH_SEA), Move(0, Nations.GERMANY, self.territories.HELGOLAND_BIGHT, self.territories.NORTH_SEA), Move(0, Nations.GERMANY, self.territories.DENMARK, self.territories.HELGOLAND_BIGHT), Support(0, Nations.RUSSIA, self.territories.SKAGERRAK, self.territories.NORWAY, self.territories.NORTH_SEA), Move(0, Nations.RUSSIA, self.territories.NORWAY, self.territories.NORTH_SEA), ] self.state.register(*pieces, *orders) self.state.post_register_updates() process(self.state) self.assertEqual(orders[0].outcome, Outcomes.FAILS) self.assertEqual(orders[1].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[2].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[3].outcome, Outcomes.FAILS) self.assertEqual(orders[4].outcome, Outcomes.FAILS) self.assertEqual(orders[5].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[6].outcome, Outcomes.FAILS)
def test_bounce_by_convoy_to_adjacent_place(self): """ Similar to test case 6.G.10, but now the other unit is taking the convoy. England: A Norway - Sweden F Denmark Supports A Norway - Sweden F Finland Supports A Norway - Sweden France: F Norwegian Sea - Norway F North Sea Supports F Norwegian Sea - Norway Germany: F Skagerrak Convoys A Sweden - Norway Russia: A Sweden - Norway via Convoy F Barents Sea Supports A Sweden - Norway Again the army in Sweden is bounced by the fleet in the Norwegian Sea. The army in Norway will move to Sweden and dislodge the Russian army. The final destination of the fleet in the Norwegian Sea depends on how issue 4.A.7 is resolved. If choice a is taken, then the fleet advances to Norway, but if choice b is taken (which I prefer) the fleet bounces and stays in the Norwegian Sea. """ pieces = [ Army(self.state, 0, Nations.ENGLAND, self.territories.NORWAY), Fleet(self.state, 0, Nations.ENGLAND, self.territories.DENMARK), Fleet(self.state, 0, Nations.ENGLAND, self.territories.FINLAND), Fleet(self.state, 0, Nations.FRANCE, self.territories.NORWEGIAN_SEA), Fleet(self.state, 0, Nations.FRANCE, self.territories.NORTH_SEA), Fleet(self.state, 0, Nations.GERMANY, self.territories.SKAGERRAK), Army(self.state, 0, Nations.RUSSIA, self.territories.SWEDEN), Fleet(self.state, 0, Nations.RUSSIA, self.territories.BARRENTS_SEA), ] orders = [ Move(self.state, 0, Nations.ENGLAND, self.territories.NORWAY, self.territories.SWEDEN), Support(self.state, 0, Nations.ENGLAND, self.territories.DENMARK, self.territories.NORWAY, self.territories.SWEDEN), Support(self.state, 0, Nations.ENGLAND, self.territories.FINLAND, self.territories.NORWAY, self.territories.SWEDEN), Move(self.state, 0, Nations.FRANCE, self.territories.NORWEGIAN_SEA, self.territories.NORWAY), Support(self.state, 0, Nations.FRANCE, self.territories.NORTH_SEA, self.territories.NORWEGIAN_SEA, self.territories.NORWAY), Convoy(self.state, 0, Nations.GERMANY, self.territories.SKAGERRAK, self.territories.SWEDEN, self.territories.NORWAY), Move(self.state, 0, Nations.RUSSIA, self.territories.SWEDEN, self.territories.NORWAY, via_convoy=True), Support(self.state, 0, Nations.RUSSIA, self.territories.BARRENTS_SEA, self.territories.SWEDEN, self.territories.NORWAY), ] process(self.state) self.assertEqual(orders[0].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[1].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[2].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[3].outcome, Outcomes.FAILS) self.assertEqual(orders[4].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[6].outcome, Outcomes.FAILS) self.assertEqual(pieces[6].dislodged_decision, Outcomes.DISLODGED) self.assertEqual(orders[7].outcome, Outcomes.SUCCEEDS)
def test_dislodge_convoying_fleet_not_on_route(self): """ When the rule is used that convoys are disrupted when one of the routes is disrupted (see issue 4.A.1), the convoy is not necessarily disrupted when one of the fleets ordered to convoy is dislodged. England: F English Channel Convoys A London - Belgium A London - Belgium F Irish Sea Convoys A London - Belgium France: F North Atlantic Ocean Supports F Mid-Atlantic Ocean - Irish Sea F Mid-Atlantic Ocean - Irish Sea Even when convoys are disrupted when one of the routes is disrupted (see issue 4.A.1), the convoy from London to Belgium will still succeed, since the dislodged fleet in the Irish Sea is not part of any route, although it can be reached from the starting point London. """ pieces = [ Fleet(self.state, 0, Nations.ENGLAND, self.territories.ENGLISH_CHANNEL), Army(self.state, 0, Nations.ENGLAND, self.territories.LONDON), Fleet(self.state, 0, Nations.ENGLAND, self.territories.IRISH_SEA), Fleet(self.state, 0, Nations.FRANCE, self.territories.NORTH_ATLANTIC), Fleet(self.state, 0, Nations.FRANCE, self.territories.MID_ATLANTIC), ] orders = [ Convoy(self.state, 0, Nations.ENGLAND, self.territories.ENGLISH_CHANNEL, self.territories.LONDON, self.territories.BELGIUM), Move(self.state, 0, Nations.ENGLAND, self.territories.LONDON, self.territories.BELGIUM, via_convoy=True), Convoy(self.state, 0, Nations.ENGLAND, self.territories.IRISH_SEA, self.territories.LONDON, self.territories.BELGIUM), Support(self.state, 0, Nations.FRANCE, self.territories.NORTH_ATLANTIC, self.territories.MID_ATLANTIC, self.territories.IRISH_SEA), Move(self.state, 0, Nations.FRANCE, self.territories.MID_ATLANTIC, self.territories.IRISH_SEA), ] process(self.state) self.assertEqual(pieces[0].dislodged_decision, Outcomes.SUSTAINS) self.assertEqual(orders[1].path_decision(), Outcomes.PATH) self.assertEqual(orders[1].outcome, Outcomes.SUCCEEDS) self.assertEqual(pieces[2].dislodged_decision, Outcomes.DISLODGED) self.assertEqual(orders[3].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[4].outcome, Outcomes.SUCCEEDS)
def test_dislodged_multi_route_convoy(self): """ When a fleet of a convoy with multiple routes is dislodged, the result depends on the rulebook that is used. England: F English Channel Convoys A London - Belgium F North Sea Convoys A London - Belgium A London - Belgium France: F Brest Supports F Mid-Atlantic Ocean - English Channel F Mid-Atlantic Ocean - English Channel The French fleet in Mid Atlantic Ocean will dislodge the convoying fleet in the English Channel. If the 1971 rules are used (see issue 4.A.1), this will disrupt the convoy and the army will stay in London. When the 1982 or 2000 rulebook is used (which I prefer) the army can still go via the North Sea and the convoy succeeds and the London army will end in Belgium. """ pieces = [ Fleet(self.state, 0, Nations.ENGLAND, self.territories.ENGLISH_CHANNEL), Fleet(self.state, 0, Nations.ENGLAND, self.territories.NORTH_SEA), Army(self.state, 0, Nations.ENGLAND, self.territories.LONDON), Fleet(self.state, 0, Nations.FRANCE, self.territories.BREST), Fleet(self.state, 0, Nations.FRANCE, self.territories.MID_ATLANTIC), ] orders = [ Convoy(self.state, 0, Nations.ENGLAND, self.territories.ENGLISH_CHANNEL, self.territories.LONDON, self.territories.BELGIUM), Convoy(self.state, 0, Nations.ENGLAND, self.territories.NORTH_SEA, self.territories.LONDON, self.territories.BELGIUM), Move(self.state, 0, Nations.ENGLAND, self.territories.LONDON, self.territories.BELGIUM, via_convoy=True), Support(self.state, 0, Nations.FRANCE, self.territories.BREST, self.territories.MID_ATLANTIC, self.territories.ENGLISH_CHANNEL), Move(self.state, 0, Nations.FRANCE, self.territories.MID_ATLANTIC, self.territories.ENGLISH_CHANNEL), ] process(self.state) self.assertEqual(pieces[0].dislodged_decision, Outcomes.DISLODGED) self.assertEqual(pieces[1].dislodged_decision, Outcomes.SUSTAINS) self.assertEqual(orders[2].path_decision(), Outcomes.PATH) self.assertEqual(orders[2].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[3].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[4].outcome, Outcomes.SUCCEEDS)
def test_two_unit_in_one_area_bug_moving_by_land(self): """ Similar to the previous test case, but now the other unit moves by convoy. England: A Norway - Sweden via Convoy A Denmark Supports A Norway - Sweden F Baltic Sea Supports A Norway - Sweden F Skagerrak Convoys A Norway - Sweden F North Sea - Norway Russia: A Sweden - Norway F Norwegian Sea Supports A Sweden - Norway Sweden and Norway are swapped, while the fleet in the North Sea will bounce. """ pieces = [ Army(0, Nations.ENGLAND, self.territories.NORWAY), Fleet(0, Nations.ENGLAND, self.territories.DENMARK), Fleet(0, Nations.ENGLAND, self.territories.BALTIC_SEA), Fleet(0, Nations.ENGLAND, self.territories.SKAGERRAK), Fleet(0, Nations.ENGLAND, self.territories.NORTH_SEA), Army(0, Nations.RUSSIA, self.territories.SWEDEN), Fleet(0, Nations.RUSSIA, self.territories.NORWEGIAN_SEA), ] orders = [ Move(0, Nations.ENGLAND, self.territories.NORWAY, self.territories.SWEDEN, via_convoy=True), Support(0, Nations.ENGLAND, self.territories.DENMARK, self.territories.NORWAY, self.territories.SWEDEN), Support(0, Nations.ENGLAND, self.territories.BALTIC_SEA, self.territories.NORWAY, self.territories.SWEDEN), Convoy(0, Nations.ENGLAND, self.territories.SKAGERRAK, self.territories.NORWAY, self.territories.SWEDEN), Move(0, Nations.ENGLAND, self.territories.NORTH_SEA, self.territories.NORWAY), Move(0, Nations.RUSSIA, self.territories.SWEDEN, self.territories.NORWAY), Support(0, Nations.RUSSIA, self.territories.NORWEGIAN_SEA, self.territories.SWEDEN, self.territories.NORWAY), ] self.state.register(*pieces, *orders) self.state.post_register_updates() process(self.state) self.assertEqual(orders[0].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[1].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[2].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[5].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[4].outcome, Outcomes.FAILS) self.assertEqual(orders[6].outcome, Outcomes.SUCCEEDS)
def test_swapping_two_units_with_two_convoys(self): """ Of course, two armies can also swap by when they are both convoyed. England: A Liverpool - Edinburgh via Convoy F North Atlantic Ocean Convoys A Liverpool - Edinburgh F Norwegian Sea Convoys A Liverpool - Edinburgh Germany: A Edinburgh - Liverpool via Convoy F North Sea Convoys A Edinburgh - Liverpool F English Channel Convoys A Edinburgh - Liverpool F Irish Sea Convoys A Edinburgh - Liverpool The armies in Liverpool and Edinburgh are swapped. """ pieces = [ Army(0, Nations.ENGLAND, self.territories.LIVERPOOL), Fleet(0, Nations.ENGLAND, self.territories.NORTH_ATLANTIC), Fleet(0, Nations.ENGLAND, self.territories.NORWEGIAN_SEA), Army(0, Nations.GERMANY, self.territories.EDINBURGH), Fleet(0, Nations.GERMANY, self.territories.NORTH_SEA), Fleet(0, Nations.GERMANY, self.territories.ENGLISH_CHANNEL), Fleet(0, Nations.GERMANY, self.territories.IRISH_SEA), ] orders = [ Move(0, Nations.ENGLAND, self.territories.LIVERPOOL, self.territories.EDINBURGH, via_convoy=True), Convoy(0, Nations.ENGLAND, self.territories.NORTH_ATLANTIC, self.territories.LIVERPOOL, self.territories.EDINBURGH), Convoy(0, Nations.ENGLAND, self.territories.NORWEGIAN_SEA, self.territories.LIVERPOOL, self.territories.EDINBURGH), Move(0, Nations.GERMANY, self.territories.EDINBURGH, self.territories.LIVERPOOL, via_convoy=True), Convoy(0, Nations.GERMANY, self.territories.NORTH_SEA, self.territories.EDINBURGH, self.territories.LIVERPOOL), Convoy(0, Nations.GERMANY, self.territories.ENGLISH_CHANNEL, self.territories.EDINBURGH, self.territories.LIVERPOOL), Convoy(0, Nations.GERMANY, self.territories.IRISH_SEA, self.territories.EDINBURGH, self.territories.LIVERPOOL), ] self.state.register(*pieces, *orders) self.state.post_register_updates() process(self.state) self.assertEqual(orders[0].path_decision(), Outcomes.PATH) self.assertEqual(orders[0].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[3].path_decision(), Outcomes.PATH) self.assertEqual(orders[3].outcome, Outcomes.SUCCEEDS)
def test_two_unit_in_one_area_bug_moving_by_convoy(self): """ If the adjudicator is not correctly implemented, this may lead to a resolution where two units end up in the same area. England: A Norway - Sweden A Denmark Supports A Norway - Sweden F Baltic Sea Supports A Norway - Sweden F North Sea - Norway Russia: A Sweden - Norway via Convoy F Skagerrak Convoys A Sweden - Norway F Norwegian Sea Supports A Sweden - Norway See decision details 5.B.6. If the 'PREVENT STRENGTH' is incorrectly implemented, due to the fact that it does not take into account that the 'PREVENT STRENGTH' is only zero when the unit is engaged in a head to head battle, then this goes wrong in this test case. The 'PREVENT STRENGTH' of Sweden would be zero, because the opposing unit in Norway successfully moves. Since, this strength would be zero, the fleet in the North Sea would move to Norway. However, although the 'PREVENT STRENGTH' is zero, the army in Sweden would also move to Norway. So, the final result would contain two units that successfully moved to Norway. Of course, this is incorrect. Norway will indeed successfully move to Sweden while the army in Sweden ends in Norway, because it is stronger then the fleet in the North Sea. This fleet will stay in the North Sea. """ Army(self.state, 0, Nations.ENGLAND, self.territories.NORWAY), Fleet(self.state, 0, Nations.ENGLAND, self.territories.DENMARK), Fleet(self.state, 0, Nations.ENGLAND, self.territories.BALTIC_SEA), Fleet(self.state, 0, Nations.ENGLAND, self.territories.NORTH_SEA), Army(self.state, 0, Nations.RUSSIA, self.territories.SWEDEN), Fleet(self.state, 0, Nations.RUSSIA, self.territories.SKAGERRAK), Fleet(self.state, 0, Nations.RUSSIA, self.territories.NORWEGIAN_SEA), orders = [ Move(self.state, 0, Nations.ENGLAND, self.territories.NORWAY, self.territories.SWEDEN), Support(self.state, 0, Nations.ENGLAND, self.territories.DENMARK, self.territories.NORWAY, self.territories.SWEDEN), Support(self.state, 0, Nations.ENGLAND, self.territories.BALTIC_SEA, self.territories.NORWAY, self.territories.SWEDEN), Move(self.state, 0, Nations.ENGLAND, self.territories.NORTH_SEA, self.territories.NORWAY), Move(self.state, 0, Nations.RUSSIA, self.territories.SWEDEN, self.territories.NORWAY, via_convoy=True), Convoy(self.state, 0, Nations.RUSSIA, self.territories.SKAGERRAK, self.territories.SWEDEN, self.territories.NORWAY), Support(self.state, 0, Nations.RUSSIA, self.territories.NORWEGIAN_SEA, self.territories.SWEDEN, self.territories.NORWAY), ] process(self.state) self.assertEqual(orders[0].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[1].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[2].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[3].outcome, Outcomes.FAILS) self.assertEqual(orders[4].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[6].outcome, Outcomes.SUCCEEDS)
def test_no_self_dislodgement_with_beleauguered_garrison(self): """ An attempt to self dislodge can be combined with a beleaguered garrison. Such self dislodgement is still not possible. England: F North Sea Hold F Yorkshire Supports F Norway - North Sea Germany: F Holland Supports F Helgoland Bight - North Sea F Helgoland Bight - North Sea Russia: F Skagerrak Supports F Norway - North Sea F Norway - North Sea Although the Russians beat the German attack (with the support of Yorkshire) and the two Russian fleets are enough to dislodge the fleet in the North Sea, the fleet in the North Sea is not dislodged, since it would not be dislodged if the English fleet in Yorkshire would not give support. According to the DPTG the fleet in the North Sea would be dislodged. The DPTG is incorrect in this case. """ pieces = [ Fleet(0, Nations.ENGLAND, self.territories.NORTH_SEA), Fleet(0, Nations.ENGLAND, self.territories.YORKSHIRE), Fleet(0, Nations.GERMANY, self.territories.HOLLAND), Fleet(0, Nations.GERMANY, self.territories.HELGOLAND_BIGHT), Fleet(0, Nations.RUSSIA, self.territories.SKAGERRAK), Fleet(0, Nations.RUSSIA, self.territories.NORWAY), ] orders = [ Hold(0, Nations.ENGLAND, self.territories.NORTH_SEA), Support(0, Nations.ENGLAND, self.territories.YORKSHIRE, self.territories.NORWAY, self.territories.NORTH_SEA), Support(0, Nations.GERMANY, self.territories.HOLLAND, self.territories.HELGOLAND_BIGHT, self.territories.NORTH_SEA), Move(0, Nations.GERMANY, self.territories.HELGOLAND_BIGHT, self.territories.NORTH_SEA), Support(0, Nations.RUSSIA, self.territories.SKAGERRAK, self.territories.NORWAY, self.territories.NORTH_SEA), Move(0, Nations.RUSSIA, self.territories.NORWAY, self.territories.NORTH_SEA), ] self.state.register(*pieces, *orders) self.state.post_register_updates() process(self.state) self.assertEqual(pieces[0].dislodged_decision, Outcomes.SUSTAINS) self.assertEqual(orders[2].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[3].outcome, Outcomes.FAILS) self.assertEqual(orders[4].outcome, Outcomes.SUCCEEDS) self.assertEqual(orders[5].outcome, Outcomes.FAILS)
def test_simple_bounce(self): Army(self.state, 0, Nations.FRANCE, self.territories.PICARDY), Army(self.state, 0, Nations.GERMANY, self.territories.BURGUNDY), orders = [ Move(self.state, 0, Nations.FRANCE, self.territories.PICARDY, self.territories.PARIS), Move(self.state, 0, Nations.GERMANY, self.territories.BURGUNDY, self.territories.PARIS), ] process(self.state) self.assertTrue(orders[0].target.bounce_occurred)