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_beleaguered_convoy_is_not_disrupted(self):
"""
Even when a convoy is in a beleaguered garrison it is not disrupted.
England:
F North Sea Convoys A London - Holland
A London - Holland
France:
F English Channel - North Sea
F Belgium Supports F English Channel - North Sea
Germany:
F Skagerrak - North Sea
F Denmark Supports F Skagerrak - North Sea
The army in London will successfully convoy and end in Holland.
"""
pieces = [
Fleet(0, Nations.ENGLAND, self.territories.NORTH_SEA),
Army(0, Nations.ENGLAND, self.territories.LONDON),
Fleet(0, Nations.FRANCE, self.territories.ENGLISH_CHANNEL),
Fleet(0, Nations.FRANCE, self.territories.BELGIUM),
Fleet(0, Nations.GERMANY, self.territories.SKAGERRAK),
Fleet(0, Nations.GERMANY, self.territories.DENMARK)
]
orders = [
Convoy(0, Nations.ENGLAND, self.territories.NORTH_SEA,
self.territories.LONDON, self.territories.HOLLAND),
Move(0,
Nations.ENGLAND,
self.territories.LONDON,
self.territories.HOLLAND,
via_convoy=True),
Move(0, Nations.FRANCE, self.territories.ENGLISH_CHANNEL,
self.territories.NORTH_SEA),
Support(0, Nations.FRANCE, self.territories.BELGIUM,
self.territories.ENGLISH_CHANNEL,
self.territories.NORTH_SEA),
Move(0, Nations.GERMANY, self.territories.SKAGERRAK,
self.territories.NORTH_SEA),
Support(0, Nations.GERMANY, self.territories.DENMARK,
self.territories.SKAGERRAK, self.territories.NORTH_SEA),
]
self.state.register(*pieces, *orders)
self.state.post_register_updates()
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)
self.assertEqual(orders[3].outcome, Outcomes.SUCCEEDS)
self.assertEqual(orders[4].outcome, Outcomes.FAILS)
self.assertEqual(orders[5].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(0, Nations.ENGLAND, self.territories.ENGLISH_CHANNEL),
Fleet(0, Nations.ENGLAND, self.territories.NORTH_SEA),
Army(0, Nations.ENGLAND, self.territories.LONDON),
Fleet(0, Nations.FRANCE, self.territories.BREST),
Fleet(0, Nations.FRANCE, self.territories.MID_ATLANTIC),
]
orders = [
Convoy(0, Nations.ENGLAND, self.territories.ENGLISH_CHANNEL,
self.territories.LONDON, self.territories.BELGIUM),
Convoy(0, Nations.ENGLAND, self.territories.NORTH_SEA,
self.territories.LONDON, self.territories.BELGIUM),
Move(0,
Nations.ENGLAND,
self.territories.LONDON,
self.territories.BELGIUM,
via_convoy=True),
Support(0, Nations.FRANCE, self.territories.BREST,
self.territories.MID_ATLANTIC,
self.territories.ENGLISH_CHANNEL),
Move(0, Nations.FRANCE, self.territories.MID_ATLANTIC,
self.territories.ENGLISH_CHANNEL),
]
self.state.register(*pieces, *orders)
self.state.post_register_updates()
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_fleet_all_neighbouring_seas_occupied(self):
retreating_fleet = Fleet(0, Nations.FRANCE,
self.territories.BARRENTS_SEA)
stp_army = Army(0, Nations.RUSSIA, self.territories.ST_PETERSBURG)
norway_army = Army(0, Nations.RUSSIA, self.territories.NORWAY)
norwegian_sea_fleet = Fleet(0, Nations.RUSSIA,
self.territories.NORWEGIAN_SEA)
self.state.register(retreating_fleet, stp_army, norway_army,
norwegian_sea_fleet)
self.state.post_register_updates()
self.assertFalse(retreating_fleet.can_retreat())
def test_kidnapping_with_a_disrupted_convoy(self):
"""
When kidnapping of armies is allowed, a move can be sabotaged by a
fleet that is almost certainly dislodged.
France:
F Brest - English Channel
A Picardy - Belgium
A Burgundy Supports A Picardy - Belgium
F Mid-Atlantic Ocean Supports F Brest - English Channel
England:
F English Channel Convoys A Picardy - Belgium
See issue 4.A.3. If a convoy always takes precedence over a land route
(choice a), the move from Picardy to Belgium fails. It tries to convoy
and the convoy is disrupted.
For choice b and c, there is no unit moving in opposite direction for
the move of the army in Picardy. For this reason, the move for the army
in Picardy is not by convoy and succeeds over land.
When the 1982 or 2000 rules are used (choice d), then it is not the
"intent" of the French army in Picardy to convoy. The move from Picardy
to Belgium is just a successful move over land.
When explicit adjacent convoying is used (DPTG, choice e), the order of
the French army in Picardy is not a convoy order. So, it just ordered
over land, and that move succeeds.
This is an excellent example why the convoy route should not
automatically have priority over the land route. It would just be
annoying for the attacker and this situation is without fun. I prefer
the 1982 rule with the 2000 clarification. According to these rules the
move from Picardy succeeds.
"""
Fleet(self.state, 0, Nations.FRANCE, self.territories.BREST),
Army(self.state, 0, Nations.FRANCE, self.territories.PICARDY),
Army(self.state, 0, Nations.FRANCE, self.territories.BURGUNDY),
Fleet(self.state, 0, Nations.FRANCE, self.territories.MID_ATLANTIC),
Fleet(self.state, 0, Nations.ENGLAND, self.territories.ENGLISH_CHANNEL),
orders = [
Move(self.state, 0, Nations.FRANCE, self.territories.BREST, self.territories.ENGLISH_CHANNEL),
Move(self.state, 0, Nations.FRANCE, self.territories.PICARDY, self.territories.BELGIUM),
Support(self.state, 0, Nations.FRANCE, self.territories.BURGUNDY, self.territories.PICARDY, self.territories.BELGIUM),
Support(self.state, 0, Nations.FRANCE, self.territories.MID_ATLANTIC, self.territories.BREST, self.territories.ENGLISH_CHANNEL),
Convoy(self.state, 0, Nations.ENGLAND, self.territories.ENGLISH_CHANNEL, self.territories.PICARDY, self.territories.BELGIUM),
]
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_support_can_be_cut_with_other_coast(self):
"""
Support can be cut from the other coast.
England:
F Irish Sea Supports F North Atlantic Ocean - Mid-Atlantic Ocean
F North Atlantic Ocean - Mid-Atlantic Ocean
France:
F Spain(nc) Supports F Mid-Atlantic Ocean
F Mid-Atlantic Ocean Hold
Italy:
F Gulf of Lyon - Spain(sc)
The Italian fleet in the Gulf of Lyon will cut the support in Spain.
That means that the French fleet in the Mid Atlantic Ocean will be
dislodged by the English fleet in the North Atlantic Ocean.
"""
pieces = [
Fleet(self.state, 0, Nations.ENGLAND,
self.territories.NORTH_ATLANTIC),
Fleet(self.state, 0, Nations.ENGLAND, self.territories.IRISH_SEA),
Fleet(self.state,
0,
Nations.FRANCE,
self.territories.SPAIN,
named_coast=self.named_coasts.SPAIN_NC),
Fleet(self.state, 0, Nations.FRANCE,
self.territories.MID_ATLANTIC),
Fleet(self.state, 0, Nations.ITALY, self.territories.GULF_OF_LYON),
]
orders = [
Move(self.state, 0, Nations.ENGLAND,
self.territories.NORTH_ATLANTIC,
self.territories.MID_ATLANTIC),
Support(self.state, 0, Nations.ENGLAND, self.territories.IRISH_SEA,
self.territories.NORTH_ATLANTIC,
self.territories.MID_ATLANTIC),
Support(self.state, 0, Nations.FRANCE, self.territories.SPAIN,
self.territories.MID_ATLANTIC,
self.territories.MID_ATLANTIC),
Hold(self.state, 0, Nations.FRANCE, self.territories.MID_ATLANTIC),
Move(self.state, 0, Nations.ITALY, self.territories.GULF_OF_LYON,
self.territories.SPAIN, self.named_coasts.SPAIN_SC),
]
process(self.state)
self.assertEqual(orders[0].outcome, Outcomes.SUCCEEDS)
self.assertEqual(orders[1].outcome, Outcomes.SUCCEEDS)
self.assertEqual(orders[2].outcome, Outcomes.FAILS)
self.assertEqual(orders[4].outcome, Outcomes.FAILS)
self.assertEqual(pieces[3].dislodged_decision, Outcomes.DISLODGED)
def test_swapped_or_dislodged(self):
"""
The 1982 rulebook says that whether the move is over land or via convoy
depends on the "intent" as shown by the totality of the orders written
by the player governing the army (see issue 4.A.3). In this test case
the English army in Norway will end in all cases in Sweden. But whether
it is convoyed or not has effect on the Russian army. In case of convoy
the Russian army ends in Norway and in case of a land route the Russian
army is dislodged.
England:
A Norway - Sweden
F Skagerrak Convoys A Norway - Sweden
F Finland Supports A Norway - Sweden
Russia:
A Sweden - Norway
See issue 4.A.3.
For choice a, b and c the move of the army in Norway is by convoy and
the armies in Norway and Sweden are swapped.
If the 1982 rulebook is used with the clarification of the 2000
rulebook (choice d, which I prefer), the intent of the English player
is to convoy, since it ordered the fleet in Skagerrak to convoy.
Therefore, the armies in Norway and Sweden are swapped.
When explicit adjacent convoying is used (DTPG, choice e), then the
unit in Norway did not receive an order to move by convoy and the land
route should be considered. The Russian army in Sweden is dislodged.
"""
pieces = [
Army(0, Nations.ENGLAND, self.territories.NORWAY),
Fleet(0, Nations.ENGLAND, self.territories.SKAGERRAK),
Fleet(0, Nations.ENGLAND, self.territories.FINLAND),
Army(0, Nations.RUSSIA, self.territories.SWEDEN),
]
orders = [
Move(0, Nations.ENGLAND, self.territories.NORWAY,
self.territories.SWEDEN),
Convoy(0, Nations.ENGLAND, self.territories.SKAGERRAK,
self.territories.NORWAY, self.territories.SWEDEN),
Support(0, Nations.ENGLAND, self.territories.FINLAND,
self.territories.NORWAY, self.territories.SWEDEN),
Move(0, Nations.RUSSIA, 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[2].outcome, Outcomes.SUCCEEDS)
self.assertEqual(pieces[3].dislodged_decision, Outcomes.DISLODGED)
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(Nations.ENGLAND, self.territories.LIVERPOOL),
Fleet(Nations.ENGLAND, self.territories.NORTH_ATLANTIC),
Fleet(Nations.ENGLAND, self.territories.NORWEGIAN_SEA),
Army(Nations.GERMANY, self.territories.EDINBURGH),
Fleet(Nations.GERMANY, self.territories.NORTH_SEA),
Fleet(Nations.GERMANY, self.territories.ENGLISH_CHANNEL),
Fleet(Nations.GERMANY, self.territories.IRISH_SEA),
]
orders = [
Move(Nations.ENGLAND,
self.territories.LIVERPOOL,
self.territories.EDINBURGH,
via_convoy=True),
Convoy(Nations.ENGLAND, self.territories.NORTH_ATLANTIC,
self.territories.LIVERPOOL, self.territories.EDINBURGH),
Convoy(Nations.ENGLAND, self.territories.NORWEGIAN_SEA,
self.territories.LIVERPOOL, self.territories.EDINBURGH),
Move(Nations.GERMANY,
self.territories.EDINBURGH,
self.territories.LIVERPOOL,
via_convoy=True),
Convoy(Nations.GERMANY, self.territories.NORTH_SEA,
self.territories.EDINBURGH, self.territories.LIVERPOOL),
Convoy(Nations.GERMANY, self.territories.ENGLISH_CHANNEL,
self.territories.EDINBURGH, self.territories.LIVERPOOL),
Convoy(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].move_decision, Outcomes.MOVES)
self.assertEqual(orders[3].path_decision(), Outcomes.PATH)
self.assertEqual(orders[3].move_decision, Outcomes.MOVES)
def test_supporting_with_unspecified_coast_when_only_one_coast_is_possible(
self):
"""
Some hardliners require a coast in a support order even when only one
coast is possible.
France:
F Portugal Supports F Gascony - Spain
F Gascony - Spain(nc)
Italy:
F Gulf of Lyon Supports F Western Mediterranean - Spain(sc)
F Western Mediterranean - Spain(sc)
See issue 4.B.4. If coasts are not required in support orders, then the
support of Portugal is successful. This means that the Italian fleet in
the Western Mediterranean bounces. Some adjudicators may not accept a
support order without coast (the support will fail or a default coast
is taken). In that case the support order of Portugal fails
(in case of a default coast the coast will probably the south coast)
and the Italian fleet in the Western Mediterranean will successfully
move.
I prefer that supporting without coasts should be allowed. So I prefer
that the support of Portugal is successful and that the Italian fleet
in the Western Mediterranean bounces.
"""
pieces = [
Fleet(0, Nations.FRANCE, self.territories.PORTUGAL),
Fleet(0, Nations.FRANCE, self.territories.GASCONY),
Fleet(0, Nations.ITALY, self.territories.GULF_OF_LYON),
Fleet(0, Nations.ITALY, self.territories.WESTERN_MEDITERRANEAN),
]
orders = [
Support(0, Nations.FRANCE, self.territories.PORTUGAL,
self.territories.GASCONY, self.territories.SPAIN),
Move(0, Nations.FRANCE, self.territories.GASCONY,
self.territories.SPAIN, self.named_coasts.SPAIN_NC),
Support(0, Nations.ITALY, self.territories.GULF_OF_LYON,
self.territories.WESTERN_MEDITERRANEAN,
self.territories.SPAIN),
Move(0, Nations.ITALY, self.territories.WESTERN_MEDITERRANEAN,
self.territories.SPAIN, self.named_coasts.SPAIN_SC),
]
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.FAILS)
self.assertEqual(orders[2].outcome, Outcomes.SUCCEEDS)
self.assertEqual(orders[3].outcome, Outcomes.FAILS)
def test_convoy_to_an_adjacent_place_with_paradox(self):
"""
In this case the convoy route is available when the land route is
chosen and the convoy route is not available when the convoy route is
chosen.
England:
F Norway Supports F North Sea - Skagerrak
F North Sea - Skagerrak
Russia:
A Sweden - Norway
F Skagerrak Convoys A Sweden - Norway
F Barents Sea Supports A Sweden - Norway
See issue 4.A.2 and 4.A.3.
If for issue 4.A.3, choice b, c or e has been taken, then the move from
Sweden to Norway is not a convoy and the English fleet in Norway is
dislodged and the fleet in Skagerrak will not be dislodged.
If choice a or d (1982/2000 rule) has been taken for issue 4.A.3, then
the move from Sweden to Norway must be treated as a convoy. At that
moment the situation becomes paradoxical. When the 'All Hold' rule is
used, both the army in Sweden as the fleet in the North Sea will not
advance. In all other paradox rules the English fleet in the North Sea
will dislodge the Russian fleet in Skagerrak and the army in Sweden
will not advance.
I prefer the 1982 rule with the 2000 rulebook clarification concerning
the convoy to adjacent places and I prefer the Szykman rule for paradox
resolving. That means that according to these preferences the fleet in
the North Sea will dislodge the Russian fleet in Skagerrak and the army
in Sweden will not advance.
"""
Fleet(self.state, 0, Nations.ENGLAND, self.territories.NORWAY),
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.BARRENTS_SEA),
orders = [
Support(self.state, 0, Nations.ENGLAND, self.territories.NORWAY, self.territories.NORTH_SEA, self.territories.SKAGERRAK),
Move(self.state, 0, Nations.ENGLAND, self.territories.NORTH_SEA, self.territories.SKAGERRAK),
Move(self.state, 0, Nations.RUSSIA, self.territories.SWEDEN, self.territories.NORWAY),
Convoy(self.state, 0, Nations.RUSSIA, self.territories.SKAGERRAK, self.territories.SWEDEN, self.territories.NORWAY),
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.FAILS)
self.assertEqual(orders[4].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(0, Nations.ENGLAND, self.territories.ENGLISH_CHANNEL),
Army(0, Nations.ENGLAND, self.territories.LONDON),
Fleet(0, Nations.ENGLAND, self.territories.IRISH_SEA),
Fleet(0, Nations.FRANCE, self.territories.NORTH_ATLANTIC),
Fleet(0, Nations.FRANCE, self.territories.MID_ATLANTIC),
]
orders = [
Convoy(0, Nations.ENGLAND, self.territories.ENGLISH_CHANNEL,
self.territories.LONDON, self.territories.BELGIUM),
Move(0,
Nations.ENGLAND,
self.territories.LONDON,
self.territories.BELGIUM,
via_convoy=True),
Convoy(0, Nations.ENGLAND, self.territories.IRISH_SEA,
self.territories.LONDON, self.territories.BELGIUM),
Support(0, Nations.FRANCE, self.territories.NORTH_ATLANTIC,
self.territories.MID_ATLANTIC, self.territories.IRISH_SEA),
Move(0, Nations.FRANCE, self.territories.MID_ATLANTIC,
self.territories.IRISH_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[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_move_to_own_sector_with_convoy(self):
"""
Moving to the same sector is still illegal with convoy (2000 rulebook,
page 4, "Note: An Army can move across water provinces from one coastal
province to another...").
England:
F North Sea Convoys A Yorkshire - Yorkshire
A Yorkshire - Yorkshire
A Liverpool Supports A Yorkshire - Yorkshire
Germany:
F London - Yorkshire
A Wales Supports F London - Yorkshire
The move of the army in Yorkshire is illegal. This makes the support of
Liverpool also illegal and without the support, the Germans have a
stronger force. The fleet in London dislodges the army in Yorkshire.
"""
pieces = [
Fleet(Nations.ENGLAND, self.territories.NORTH_SEA),
Army(Nations.ENGLAND, self.territories.YORKSHIRE),
Army(Nations.ENGLAND, self.territories.LIVERPOOL),
Fleet(Nations.ENGLAND, self.territories.LONDON),
Army(Nations.ENGLAND, self.territories.WALES),
]
fleet_north_sea_convoy = Convoy(Nations.ENGLAND,
self.territories.NORTH_SEA,
self.territories.YORKSHIRE,
self.territories.YORKSHIRE)
army_yorkshire_move = Move(Nations.ENGLAND, self.territories.YORKSHIRE,
self.territories.YORKSHIRE)
army_liverpool_support = Support(Nations.ENGLAND,
self.territories.LIVERPOOL,
self.territories.YORKSHIRE,
self.territories.YORKSHIRE)
fleet_london_move = Move(Nations.GERMANY, self.territories.LONDON,
self.territories.YORKSHIRE)
army_wales_support = Support(Nations.GERMANY, self.territories.WALES,
self.territories.LONDON,
self.territories.YORKSHIRE)
self.state.register(*pieces, fleet_north_sea_convoy,
army_yorkshire_move, army_liverpool_support,
fleet_london_move, army_wales_support)
self.state.post_register_updates()
process(self.state)
self.assertEqual(army_yorkshire_move.legal_decision, Outcomes.ILLEGAL)
self.assertEqual(army_yorkshire_move.illegal_message,
illegal_messages.M002)
def test_swapping_with_illegal_intent(self):
"""
Can the intent made clear with an impossible order?
England:
F Skagerrak Convoys A Sweden - Norway
F Norway - Sweden
Russia:
A Sweden - Norway
F Gulf of Bothnia Convoys A Sweden - Norway
See issue 4.A.3 and 4.E.1.
If for issue 4.A.3 choice a, b or c has been taken, then the army in
weden moves by convoy and swaps places with the fleet in Norway.
However, if for issue 4.A.3 the 1982/2000 has been chosen (choice d),
then the "intent" is important. The question is whether the fleet in
the Gulf of Bothnia can express the intent. If the order for this fleet
is considered illegal (see issue 4.E.1), then this order must be
ignored and there is no intent to swap. In that case none of the units
move.
If explicit convoying is used (DPTG, choice e of issue 4.A.3) then the
army in Sweden will take the land route and none of the units move.
I prefer the 1982/2000 rule and that any orders that can't be valid are
illegal. So, the order of the fleet in the Gulf of Bothnia is ignored
and can not show the intent. There is no convoy, so no unit will move.
"""
pieces = [
Fleet(0, Nations.ENGLAND, self.territories.SKAGERRAK),
Fleet(0, Nations.ENGLAND, self.territories.NORWAY),
Army(0, Nations.RUSSIA, self.territories.SWEDEN),
Fleet(0, Nations.RUSSIA, self.territories.GULF_OF_BOTHNIA),
]
orders = [
Convoy(0, Nations.ENGLAND, self.territories.SKAGERRAK,
self.territories.SWEDEN, self.territories.NORWAY),
Move(0, Nations.ENGLAND, self.territories.NORWAY,
self.territories.SWEDEN),
Move(0, Nations.RUSSIA, self.territories.SWEDEN,
self.territories.NORWAY),
Convoy(0, Nations.RUSSIA, self.territories.GULF_OF_BOTHNIA,
self.territories.SWEDEN, self.territories.NORWAY),
]
self.state.register(*pieces, *orders)
self.state.post_register_updates()
process(self.state)
self.assertEqual(orders[1].outcome, Outcomes.FAILS)
self.assertEqual(orders[2].outcome, Outcomes.FAILS)
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(self.state, 0, Nations.AUSTRIA, self.territories.ADRIATIC_SEA),
Army(self.state, 0, Nations.AUSTRIA, self.territories.TRIESTE),
Army(self.state, 0, Nations.ITALY, self.territories.VENICE),
Fleet(self.state, 0, Nations.ITALY, self.territories.ALBANIA),
]
orders = [
Convoy(self.state, 0, Nations.AUSTRIA, self.territories.ADRIATIC_SEA, self.territories.TRIESTE, self.territories.VENICE),
Move(self.state, 0, Nations.AUSTRIA, self.territories.TRIESTE, self.territories.VENICE, via_convoy=True),
Support(self.state, 0, Nations.ITALY, self.territories.VENICE, self.territories.ALBANIA, self.territories.TRIESTE),
Move(self.state, 0, Nations.ITALY, self.territories.ALBANIA, self.territories.TRIESTE),
]
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_simple_convoy_paradox(self):
"""
The most common paradox is when the attacked unit supports an attack on
one of the convoying fleets.
England:
F London Supports F Wales - English Channel
F Wales - English Channel
France:
A Brest - London
F English Channel Convoys A Brest - London
This situation depends on how paradoxes are handled (see issue (4.A.2).
In case of the 'All Hold' rule (fully applied, not just as "backup"
rule), both the movement of the English fleet in Wales as the France
convoy in Brest are part of the paradox and fail. In all other rules of
paradoxical convoys (including the Szykman rule which I prefer), the
support of London is not cut. That means that the fleet in the English
Channel is dislodged.
"""
pieces = [
Fleet(self.state, 0, Nations.ENGLAND, self.territories.LONDON),
Fleet(self.state, 0, Nations.ENGLAND, self.territories.WALES),
Army(self.state, 0, Nations.FRANCE, self.territories.BREST),
Fleet(self.state, 0, Nations.FRANCE,
self.territories.ENGLISH_CHANNEL),
]
orders = [
Support(self.state, 0, Nations.ENGLAND, self.territories.LONDON,
self.territories.WALES, self.territories.ENGLISH_CHANNEL),
Move(self.state, 0, Nations.ENGLAND, self.territories.WALES,
self.territories.ENGLISH_CHANNEL),
Move(self.state,
0,
Nations.FRANCE,
self.territories.BREST,
self.territories.LONDON,
via_convoy=True),
Convoy(self.state, 0, Nations.FRANCE,
self.territories.ENGLISH_CHANNEL, self.territories.BREST,
self.territories.LONDON),
]
process(self.state)
self.assertEqual(orders[0].outcome, Outcomes.SUCCEEDS)
self.assertEqual(orders[1].outcome, Outcomes.SUCCEEDS)
self.assertEqual(orders[2].path_decision(), Outcomes.NO_PATH)
self.assertEqual(orders[2].outcome, Outcomes.FAILS)
self.assertEqual(pieces[3].dislodged_decision, Outcomes.DISLODGED)
def test_dislodged_convoy_does_not_cause_a_bounce(self):
"""
When a fleet of a convoy is dislodged, then there will be no bounce in
the landing area.
England:
F North Sea Convoys A London - Holland
A London - Holland
Germany:
F Helgoland Bight Supports F Skagerrak - North Sea
F Skagerrak - North Sea
A Belgium - Holland
The army in Belgium will not bounce and move to Holland.
"""
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.HELGOLAND_BIGHT),
Fleet(self.state, 0, Nations.GERMANY, self.territories.SKAGERRAK),
Army(self.state, 0, Nations.GERMANY, self.territories.BELGIUM),
]
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),
Support(self.state, 0, Nations.GERMANY,
self.territories.HELGOLAND_BIGHT,
self.territories.SKAGERRAK, self.territories.NORTH_SEA),
Move(self.state, 0, Nations.GERMANY, self.territories.SKAGERRAK,
self.territories.NORTH_SEA),
Move(self.state, 0, Nations.GERMANY, self.territories.BELGIUM,
self.territories.HOLLAND),
]
process(self.state)
self.assertEqual(pieces[0].dislodged_decision, Outcomes.DISLODGED)
self.assertEqual(orders[1].path_decision(), Outcomes.NO_PATH)
self.assertEqual(orders[1].outcome, Outcomes.FAILS)
self.assertEqual(orders[2].outcome, Outcomes.SUCCEEDS)
self.assertEqual(orders[3].outcome, Outcomes.SUCCEEDS)
self.assertEqual(orders[4].outcome, Outcomes.SUCCEEDS)
def test_supporting_with_unspecified_coast(self):
"""
Most house rules accept support orders without coast specification.
France:
F Portugal Supports F Mid-Atlantic Ocean - Spain
F Mid-Atlantic Ocean - Spain(nc)
Italy:
F Gulf of Lyon Supports F Western Mediterranean - Spain(sc)
F Western Mediterranean - Spain(sc)
See issue 4.B.4. If coasts are not required in support orders, then the
support of Portugal is successful. This means that the Italian fleet in
the Western Mediterranean bounces. Some adjudicators may not accept a
support order without coast (the support will fail or a default coast
is taken). In that case the support order of Portugal fails (in case of
a default coast the coast will probably the south coast) and the
Italian fleet in the Western Mediterranean will successfully move.
I prefer that the support succeeds and the Italian fleet in the Western
Mediterranean bounces.
"""
pieces = [
Fleet(0, Nations.FRANCE, self.territories.PORTUGAL),
Fleet(0, Nations.FRANCE, self.territories.MID_ATLANTIC),
Fleet(0, Nations.ITALY, self.territories.GULF_OF_LYON),
Fleet(0, Nations.ITALY, self.territories.WESTERN_MEDITERRANEAN),
]
orders = [
Support(0, Nations.FRANCE, self.territories.PORTUGAL,
self.territories.MID_ATLANTIC, self.territories.SPAIN),
Move(0, Nations.FRANCE, self.territories.MID_ATLANTIC,
self.territories.SPAIN, self.named_coasts.SPAIN_NC),
Support(0, Nations.ITALY, self.territories.GULF_OF_LYON,
self.territories.WESTERN_MEDITERRANEAN,
self.territories.SPAIN),
Move(0, Nations.ITALY, self.territories.WESTERN_MEDITERRANEAN,
self.territories.SPAIN, self.named_coasts.SPAIN_SC),
]
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.FAILS)
self.assertEqual(orders[2].outcome, Outcomes.SUCCEEDS)
self.assertEqual(orders[3].outcome, Outcomes.FAILS)
def test_disrupted_unit_swap(self):
"""
If in a swap one of the unit bounces, then the swap fails.
England:
F North Sea Convoys A London - Belgium
A London - Belgium
France:
F English Channel Convoys A Belgium - London
A Belgium - London
A Burgundy - Belgium
None of the units will succeed to move.
"""
pieces = [
Fleet(0, Nations.ENGLAND, self.territories.NORTH_SEA),
Army(0, Nations.ENGLAND, self.territories.LONDON),
Fleet(0, Nations.FRANCE, self.territories.ENGLISH_CHANNEL),
Army(0, Nations.FRANCE, self.territories.BELGIUM),
Army(0, Nations.FRANCE, self.territories.BURGUNDY),
]
orders = [
Convoy(0, Nations.ENGLAND, self.territories.NORTH_SEA,
self.territories.LONDON, self.territories.BELGIUM),
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),
Move(0, Nations.FRANCE, self.territories.BURGUNDY,
self.territories.BELGIUM),
]
self.state.register(*pieces, *orders)
self.state.post_register_updates()
process(self.state)
self.assertEqual(orders[1].outcome, Outcomes.FAILS)
self.assertEqual(orders[3].outcome, Outcomes.FAILS)
self.assertEqual(orders[4].outcome, Outcomes.FAILS)
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_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_support_on_unreachable_destination_not_possible(self):
"""
The destination of the move that is supported must be reachable by the
supporting unit.
Austria:
A Venice Hold
Italy:
F Rome Supports A Apulia - Venice
A Apulia - Venice
The support of Rome is illegal, because Venice can not be reached from
Rome by a fleet. Venice is not dislodged.
"""
Army(self.state, 0, Nations.AUSTRIA, self.territories.VENICE),
Fleet(self.state, 0, Nations.ITALY, self.territories.ROME),
Army(self.state, 0, Nations.ITALY, self.territories.APULIA)
# TODO finish
Hold(self.state, 0, Nations.AUSTRIA, self.territories.VENICE)
fleet_rome_support = Support(self.state, 0, Nations.ITALY, self.territories.ROME, self.territories.APULIA, self.territories.VENICE)
Move(self.state, 0, Nations.ITALY, self.territories.APULIA, self.territories.VENICE)
process(self.state)
self.assertTrue(fleet_rome_support.illegal)
self.assertEqual(fleet_rome_support.illegal_code, '010')
self.assertEqual(
fleet_rome_support.illegal_verbose,
'Piece cannot reach that territory.'
)
def test_both_coasts_must_be_empty_for_building(self):
"""
If a sector is occupied on one coast, the other coast can not be used
for building.
Russia may build a unit and has a fleet in St Petersburg(sc). Russia
orders the following:
Russia:
Build A St Petersburg(nc)
Build fails.
"""
pieces = [
Fleet(0, Nations.RUSSIA, self.territories.ST_PETERSBURG,
self.named_coasts.ST_PETERSBURG_NC),
]
orders = [
Build(0, Nations.RUSSIA, self.territories.ST_PETERSBURG,
PieceTypes.FLEET, self.named_coasts.ST_PETERSBURG_SC),
]
self.state.register(*pieces, *orders)
self.state.post_register_updates()
process(self.state)
self.assertTrue(orders[0].illegal)
self.assertEqual(orders[0].illegal_code, '011')
self.assertEqual(orders[0].illegal_verbose,
'Source is already occupied by a piece.')
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_two_separate_circular_movements(self):
pieces = [
Fleet(Nations.TURKEY, self.territories.ANKARA),
Army(Nations.TURKEY, self.territories.CONSTANTINOPLE),
Army(Nations.TURKEY, self.territories.SMYRNA),
Army(Nations.FRANCE, self.territories.BREST),
Army(Nations.FRANCE, self.territories.PICARDY),
Army(Nations.FRANCE, self.territories.PARIS),
]
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),
Move(Nations.FRANCE, self.territories.BREST,
self.territories.PICARDY),
Move(Nations.FRANCE, self.territories.PICARDY,
self.territories.PARIS),
Move(Nations.FRANCE, self.territories.PARIS,
self.territories.BREST),
]
self.state.register(*pieces, *orders)
self.state.post_register_updates()
result = find_circular_movements(orders)
self.assertEqual(len(result), 2)
self.assertTrue(all([o in result[0] for o in orders[:3]]))
self.assertTrue(all([o in result[1] for o in orders[3:]]))
def test_coast_cannot_be_ordered_to_change(self):
"""
The coast can not change by just ordering the other coast.
France has a fleet on the north coast of Spain and orders:
France:
F Spain(sc) - Gulf of Lyon
The move fails.
"""
# Not really relevant because can't specify source coast
Fleet(self.state,
0,
Nations.FRANCE,
self.territories.SPAIN,
named_coast=self.named_coasts.SPAIN_NC)
move = Move(self.state, 0, Nations.FRANCE, self.territories.SPAIN,
self.territories.SPAIN, self.named_coasts.SPAIN_SC)
process(self.state)
self.assertTrue(move.illegal)
self.assertEqual(move.illegal_verbose,
'Source and target cannot be the same territory.')
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_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_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_support_to_hold_yourself_not_possible(self):
"""
An army can not get an additional hold power by supporting itself.
Italy:
A Venice - Trieste
A Tyrolia Supports A Venice - Trieste
Austria:
F Trieste Supports F Trieste
The fleet in Trieste should be dislodged.
"""
Army(self.state, 0, Nations.ITALY, self.territories.VENICE),
Army(self.state, 0, Nations.ITALY, self.territories.TYROLIA),
Fleet(self.state, 0, Nations.AUSTRIA, self.territories.TRIESTE)
Move(self.state, 0, Nations.ITALY, self.territories.VENICE, self.territories.TRIESTE)
Support(self.state, 0, Nations.ITALY, self.territories.TYROLIA, self.territories.VENICE, self.territories.TRIESTE)
fleet_trieste_support = Support(self.state, 0, Nations.AUSTRIA, self.territories.TRIESTE, self.territories.TRIESTE, self.territories.TRIESTE)
process(self.state)
self.assertTrue(fleet_trieste_support.illegal)
self.assertEqual(
fleet_trieste_support.illegal_verbose,
'Source and target cannot be the same territory.'
)