def test_map_define(self):
''' Test the creation of a new map from a simple MDF.'''
mdf = MDF(ENG, FRA)([
(ENG, EDI, LON),
(FRA, BRE, PAR),
([ENG, FRA], BEL, HOL),
(UNO, SPA, NWY),
], [ECH, NTH, PIC])(
(EDI, [AMY, LON], [FLT, NTH]),
(LON, [AMY, EDI], [FLT, NTH, ECH]),
(BRE, [AMY, PAR, PIC, SPA], [FLT, ECH, PIC, (SPA, NCS)]),
(PAR, [AMY, PAR, SPA, PIC]),
(BEL, [AMY, PIC, HOL], [FLT, NTH, ECH, PIC, HOL]),
(HOL, [AMY, BEL], [FLT, NTH]),
(SPA, [AMY, PAR, BRE], [(FLT, NCS), BRE]),
(NWY, [AMY], [FLT, NTH]),
(ECH, [FLT, NTH, BRE, LON, BEL, PIC]),
(NTH, [FLT, ECH, BEL, HOL, LON, NWY, EDI]),
(PIC, [AMY, BRE, PAR, BEL], [FLT, ECH, BRE, BEL]),
)
self.failIf(Validator().validate_server_message(mdf),
'Invalid MDF message')
m = Map(Variant('simplified'))
self.failIf(m.valid, 'Map valid before MDF')
result = m.define(mdf)
self.failIf(result, result)
def test_missing_UNO(self):
# Map can define maps with no non-home center clause in the MDF.
variant = load_variant(
"""
[homes]
ONE=AAA
TWO=BBB
TRE=CCC
[borders]
AAA=AMY BBB CCC DDD
BBB=AMY AAA CCC DDD
CCC=AMY AAA BBB DDD
DDD=AMY AAA BBB CCC
"""
)
ONE = variant.rep["ONE"]
TWO = variant.rep["TWO"]
TRE = variant.rep["TRE"]
AAA = variant.rep["AAA"]
BBB = variant.rep["BBB"]
CCC = variant.rep["CCC"]
DDD = variant.rep["DDD"]
mdf = MDF(ONE, TWO, TRE)(([ONE, AAA], [TWO, BBB], [TRE, CCC]), [DDD])(
(AAA, [AMY, BBB, CCC, DDD]),
(BBB, [AMY, AAA, CCC, DDD]),
(CCC, [AMY, AAA, BBB, DDD]),
(DDD, [AMY, AAA, BBB, CCC]),
)
game_map = Map(variant)
msg = game_map.define(mdf)
self.failIf(msg, msg)
def test_province_names(self):
variant = load_variant('''
[provinces]
TWO=Somewhere
[homes]
ONE=
[borders]
TWO=AMY TRE
TRE=AMY TWO
''')
board = Map(variant)
province = board.spaces[variant.rep["TWO"]]
self.failUnlessEqual(province.name, "Somewhere")
def test_power_names(self):
variant = load_variant('''
[powers]
ONE=Somebody,Someone's
[homes]
ONE=
[borders]
TWO=AMY TRE
TRE=AMY TWO
''')
board = Map(variant)
power = board.powers[variant.rep["ONE"]]
self.failUnlessEqual(power.name, "Somebody")
def collect_orders(self, now, sco, country):
orders = OrderSet()
datc = DatcOptions()
board = Map(self.variant)
if sco:
board.handle_SCO(sco)
if now:
board.handle_NOW(now)
power = board.powers[country]
phase = board.current_turn.phase()
self.start_game(now, sco, country)
for msg in self.replies:
if msg[0] is SUB:
for item in msg.fold()[1:]:
order = createUnitOrder(item, power, board, datc)
note = order.order_note(power, phase, orders)
self.failUnlessEqual(note, MBV)
orders.add(order, country)
elif msg[0] is NOT and msg[2] is SUB:
# Todo: Handle partial unsubmittals correctly.
orders = OrderSet()
return phase, power, orders
def test_island_Pale(self):
"Check that Map can handle island provinces."
variant = load_variant('''
[borders]
ONE=AMY, FLT TWO, FLT TRE
TWO=FLT TRE, FLT ONE
TRE=FLT TWO, FLT ONE
''')
game_map = Map(variant)
prov = variant.rep['ONE']
self.failUnless(prov.category_name().split()[0] == 'Coastal')
coast = game_map.coasts[(AMY, prov, None)]
self.failUnless(coast.is_valid())
self.failUnless(coast.province.is_valid())
def test_missing_homes(self):
# Map can define maps with no home center entry for one of the powers.
variant = load_variant(
"""
[homes]
ONE=AAA
TWO=BBB
TRE=
UNO=CCC
[borders]
AAA=AMY BBB CCC DDD
BBB=AMY AAA CCC DDD
CCC=AMY AAA BBB DDD
DDD=AMY AAA BBB CCC
"""
)
ONE = variant.rep["ONE"]
TWO = variant.rep["TWO"]
TRE = variant.rep["TRE"]
AAA = variant.rep["AAA"]
BBB = variant.rep["BBB"]
CCC = variant.rep["CCC"]
DDD = variant.rep["DDD"]
mdf = MDF(ONE, TWO, TRE)(([ONE, AAA], [TWO, BBB], [UNO, CCC]), [DDD])(
(AAA, [AMY, BBB, CCC, DDD]),
(BBB, [AMY, AAA, CCC, DDD]),
(CCC, [AMY, AAA, BBB, DDD]),
(DDD, [AMY, AAA, BBB, CCC]),
)
game_map = Map(variant)
msg = game_map.define(mdf)
self.failIf(msg, msg)
self.assertContains(game_map.powers, TRE)
self.failUnlessEqual(game_map.powers[TRE].homes, [])
def test_map_define(self):
""" Test the creation of a new map from a simple MDF."""
mdf = MDF(ENG, FRA)(
[(ENG, EDI, LON), (FRA, BRE, PAR), ([ENG, FRA], BEL, HOL), (UNO, SPA, NWY)], [ECH, NTH, PIC]
)(
(EDI, [AMY, LON], [FLT, NTH]),
(LON, [AMY, EDI], [FLT, NTH, ECH]),
(BRE, [AMY, PAR, PIC, SPA], [FLT, ECH, PIC, (SPA, NCS)]),
(PAR, [AMY, PAR, SPA, PIC]),
(BEL, [AMY, PIC, HOL], [FLT, NTH, ECH, PIC, HOL]),
(HOL, [AMY, BEL], [FLT, NTH]),
(SPA, [AMY, PAR, BRE], [(FLT, NCS), BRE]),
(NWY, [AMY], [FLT, NTH]),
(ECH, [FLT, NTH, BRE, LON, BEL, PIC]),
(NTH, [FLT, ECH, BEL, HOL, LON, NWY, EDI]),
(PIC, [AMY, BRE, PAR, BEL], [FLT, ECH, BRE, BEL]),
)
self.failIf(Validator().validate_server_message(mdf), "Invalid MDF message")
m = Map(Variant("simplified"))
self.failIf(m.valid, "Map valid before MDF")
result = m.define(mdf)
self.failIf(result, result)
def test_complete_waives(self):
board = Map(standard)
board.handle_NOW(NOW(WIN, 1901)(RUS, AMY, MOS))
orders = OrderSet()
orders.complete_set(board)
self.failUnlessEqual(len(orders), 21)
def test_infinite_convoy(self):
# Originally notices in the Americas4 variant.
variant = load_variant('''
[borders]
ALA=AMY NCA NWT, FLT BEA BER GOA NCA NPO NWT
ORE=AMY CAL NCA, FLT CAL GOA NCA NPO
NWT=AMY ALA NCA, FLT ALA ARC BEA HUD LAB
CAL=AMY ORE, FLT GSC NPO ORE
NCA=AMY ALA NWT ORE, FLT ALA GOA ORE
ACH=FLT ECB MAO SAR
AGU=FLT CGU HUM SPO
ARC=FLT BEA LAB NAO NWT
APP=FLT FST GOM
BBL=FLT BGR RLP SAO
BEA=FLT ALA ARC BER NWT
BER=FLT ALA BEA NPO
BGR=FLT BBL DRA SAO
BTR=FLT NAO NTH SAR STH
CGU=FLT AGU DRA SPO
CHG=FLT GFO GOG GOP MPO
COB=FLT GBA MAO SAO
COM=FLT GOT MPO SOC
COP=FLT GOG HUM SPO
CPO=FLT MPO NPO SPO
DRA=FLT BGR CGU SAO SPO
ECB=FLT ACH GOU GOV NCB SAR WCB
FST=FLT APP GOM SCH
GBA=FLT COB PBA SAO
GOA=FLT ALA NCA NPO ORE
GOC=FLT GOM
GFO=FLT CHG GOT MPO
GOG=FLT CHG COP GOP SPO
GOH=FLT WCB
GOM=FLT APP FST GOC SOY
GOP=FLT CHG GOG
GOS=FLT LAB NAO
GOT=FLT COM GFO MPO
GOU=FLT ECB GOV MOS WCB
GOV=FLT ECB GOU
GSC=FLT CAL MPO NPO
GSE=FLT MAO MBA
HUD=FLT LAB NWT
HUM=FLT AGU COP SPO
LAB=FLT ARC GOS HUD NAO NWT
MAO=FLT ACH COB GSE MBA NAO SAO SAR
MAS=FLT NAO NTH
MBA=FLT GSE MAO
MOS=FLT GOU WCB
MPO=FLT CHG COM CPO GFO GOT GSC NPO SOC SPO
NAO=FLT ARC BTR GOS LAB MAO MAS NTH SAR
NCB=FLT ECB SCH SOY WCB
NTH=FLT BTR MAS NAO STH
NPO=FLT ALA BER CAL CPO GOA GSC MPO ORE
PBA=FLT GBA RLP SAO
RLP=FLT BBL PBA SAO
SAO=FLT BBL BGR COB DRA GBA MAO PBA RLP
SAR=FLT ACH BTR ECB MAO NAO SCH STH
SCH=FLT FST NCB SAR STH
STH=FLT BTR NTH SAR SCH
SOC=FLT COM MPO
SOY=FLT GOM NCB WCB
SPO=FLT AGU CGU COP CPO DRA GOG HUM MPO
WCB=FLT ECB GOH GOU MOS NCB SOY
''')
board = Map(variant)
Alaska = board.spaces[variant.rep['ALA']]
Oregon = board.coasts[(AMY, variant.rep['ORE'], None)]
start = time.time()
results = Oregon.convoy_routes(Alaska, board)
finish = time.time()
self.failUnlessEqual(results, [])
self.failUnless(finish - start < 1, "convoy_routes() took too long.")
def test_cache_mdf(self):
opts = Variant('testing')
Map(opts).handle_MDF(standard.mdf())
new_map = Map(opts)
self.failUnless(new_map.valid)
def test_empty_UNO(self):
''' Test whether Map can define maps with no non-home supply centers.'''
# Almost Standard...
mdf = '''
MDF (AUS ENG FRA GER ITA RUS TUR)
(((AUS bud tri vie)(ENG edi lon lvp)(FRA bre mar par)
(GER ber kie mun)(ITA nap rom ven)(RUS mos sev stp war)
(TUR ank con smy bel bul den gre hol nwy por rum ser spa swe tun)
(UNO))
(alb apu arm boh bur cly fin gal gas lvn naf pic pie pru ruh sil syr
tus tyr ukr wal yor adr aeg bal bar bla gob eas ech hel ion iri gol
mao nao nth nwg ska tys wes))
((adr(FLT alb apu ven tri ion))
(aeg(FLT gre (bul scs) con smy eas ion))
(alb(AMY tri gre ser)(FLT adr tri gre ion))
(ank(AMY arm con smy)(FLT bla arm con))
(apu(AMY ven nap rom)(FLT ven adr ion nap))
(arm(AMY smy syr ank sev)(FLT ank sev bla))
(bal(FLT lvn pru ber kie den swe gob))
(bar(FLT nwg (stp ncs) nwy))
(bel(AMY hol pic ruh bur)(FLT ech nth hol pic))
(ber(AMY kie pru sil mun)(FLT kie bal pru))
(bla(FLT rum sev arm ank con (bul ecs)))
(boh(AMY mun sil gal vie tyr))
(gob(FLT swe fin (stp scs) lvn bal))
(bre(AMY pic gas par)(FLT mao ech pic gas))
(bud(AMY vie gal rum ser tri))
(bul((FLT ECS) con bla rum)(AMY gre con ser rum)((FLT SCS) gre aeg con))
(bur(AMY mar gas par pic bel ruh mun))
(cly(AMY edi lvp)(FLT edi lvp nao nwg))
(con(AMY bul ank smy)(FLT (bul scs) (bul ecs) bla ank smy aeg))
(den(AMY swe kie)(FLT hel nth swe bal kie ska))
(eas(FLT syr smy aeg ion))
(edi(AMY lvp yor cly)(FLT nth nwg cly yor))
(ech(FLT mao iri wal lon nth bel pic bre))
(fin(AMY swe stp nwy)(FLT swe (stp scs) gob))
(gal(AMY war ukr rum bud vie boh sil))
(gas(AMY par bur mar spa bre)(FLT (spa ncs) mao bre))
(gre(AMY bul alb ser)(FLT (bul scs) aeg ion alb))
(hel(FLT nth den kie hol))
(hol(AMY bel kie ruh)(FLT bel nth hel kie))
(ion(FLT tun tys nap apu adr alb gre aeg eas))
(iri(FLT nao lvp wal ech mao))
(kie(AMY hol den ber mun ruh)(FLT hol hel den bal ber))
(lon(AMY yor wal)(FLT yor nth ech wal))
(lvn(AMY pru stp mos war)(FLT pru bal gob (stp scs)))
(lvp(AMY wal edi yor cly)(FLT wal iri nao cly))
(gol(FLT (spa scs) mar pie tus tys wes))
(mao(FLT nao iri ech bre gas (spa ncs) por (spa scs) naf wes))
(mar(AMY spa pie gas bur)(FLT (spa scs) gol pie))
(mos(AMY stp lvn war ukr sev))
(mun(AMY bur ruh kie ber sil boh tyr))
(naf(AMY tun)(FLT mao wes tun))
(nao(FLT nwg lvp iri mao cly))
(nap(AMY rom apu)(FLT rom tys ion apu))
(nwy(AMY fin stp swe)(FLT ska nth nwg bar (stp ncs) swe))
(nth(FLT yor edi nwg nwy ska den hel hol bel ech lon))
(nwg(FLT nao bar nwy nth cly edi))
(par(AMY bre pic bur gas))
(pic(AMY bur par bre bel)(FLT bre ech bel))
(pie(AMY mar tus ven tyr)(FLT mar gol tus))
(por(AMY spa)(FLT mao (spa ncs) (spa scs)))
(pru(AMY war sil ber lvn)(FLT ber bal lvn))
(rom(AMY tus nap ven apu)(FLT tus tys nap))
(ruh(AMY bur bel hol kie mun))
(rum(AMY ser bud gal ukr sev bul)(FLT sev bla (bul ecs)))
(ser(AMY tri bud rum bul gre alb))
(sev(AMY ukr mos rum arm)(FLT rum bla arm))
(sil(AMY mun ber pru war gal boh))
(ska(FLT nth nwy den swe))
(smy(AMY syr con ank arm)(FLT syr eas aeg con))
(spa(AMY gas por mar)((FLT NCS) gas mao por)((FLT SCS) por wes gol mar mao))
(stp(AMY fin lvn nwy mos)((FLT NCS) bar nwy)((FLT SCS) fin lvn gob))
(swe(AMY fin den nwy)(FLT fin gob bal den ska nwy))
(syr(AMY smy arm)(FLT eas smy))
(tri(AMY tyr vie bud ser alb ven)(FLT alb adr ven))
(tun(AMY naf)(FLT naf wes tys ion))
(tus(AMY rom pie ven)(FLT rom tys gol pie))
(tyr(AMY mun boh vie tri ven pie))
(tys(FLT wes gol tus rom nap ion tun))
(ukr(AMY rum gal war mos sev))
(ven(AMY tyr tus rom pie apu tri)(FLT apu adr tri))
(vie(AMY tyr boh gal bud tri))
(wal(AMY lvp lon yor)(FLT lvp iri ech lon))
(war(AMY sil pru lvn mos ukr gal))
(wes(FLT mao (spa scs) gol tys tun naf))
(yor(AMY edi lon lvp wal)(FLT edi nth lon))
)
'''#'''
options = Variant("testing")
mdf = options.rep.translate(mdf)
game_map = Map(options)
msg = game_map.define(mdf)
self.failIf(msg, msg)
