Failure/foul-magics
1
0
Fork 0
forked from External/mage
Code Pull requests Releases Packages Activity Actions

Updated mono colored hybrid mana type

Browse source 
+ “107.4e. Hybrid mana symbols are also colored mana symbols.” I have
added the Type COLORED to each mono hybrid symbol
+ added tests for hybrid mana symbols
This commit is contained in:
poixen 2015-11-20 22:07:24 +01:00
parent f6cc03ec44
commit f34e69308e
2 changed files with 211 additions and 10 deletions
Download patch file Download diff file Expand all files Collapse all files

211
Mage.Tests/src/test/java/mage/ManaSymbolTest.java
View file

@ -34,7 +34,7 @@ public class ManaSymbolTest {
assertTrue(w.isMonocolored());
assertEquals(null, w.getManaSymbol1());
assertEquals(null, w.getManaSymbol1());
assertEquals(null, w.getManaSymbol2());
}
@Test
@ -62,7 +62,7 @@ public class ManaSymbolTest {
assertTrue(u.isMonocolored());
assertEquals(null, u.getManaSymbol1());
assertEquals(null, u.getManaSymbol1());
assertEquals(null, u.getManaSymbol2());
}
@ -91,7 +91,7 @@ public class ManaSymbolTest {
assertTrue(b.isMonocolored());
assertEquals(null, b.getManaSymbol1());
assertEquals(null, b.getManaSymbol1());
assertEquals(null, b.getManaSymbol2());
}
@Test
@ -119,7 +119,7 @@ public class ManaSymbolTest {
assertTrue(r.isMonocolored());
assertEquals(null, r.getManaSymbol1());
assertEquals(null, r.getManaSymbol1());
assertEquals(null, r.getManaSymbol2());
}
@ -148,7 +148,208 @@ public class ManaSymbolTest {
assertTrue(g.isMonocolored());
assertEquals(null, g.getManaSymbol1());
assertEquals(null, g.getManaSymbol1());
assertEquals(null, g.getManaSymbol2());
}
@Test
public void shouldCreateGenericManaSymbol() {
// given
// when
ManaSymbol x = ManaSymbol.X;
// then
assertEquals("{X}", x.toString());
assertFalse(x.isBlue());
assertFalse(x.isWhite());
assertFalse(x.isBlack());
assertFalse(x.isRed());
assertFalse(x.isGreen());
assertFalse(x.isColored());
assertFalse(x.isSnow());
assertFalse(x.isPhyrexian());
assertFalse(x.isHybrid());
assertFalse(x.isPrimary());
assertFalse(x.isMonocolored());
assertTrue(x.isGeneric());
assertTrue(x.isColorless());
assertEquals(null, x.getManaSymbol1());
assertEquals(null, x.getManaSymbol2());
}
@Test
public void shouldCreateNumericManaSymbol() {
// given
// when
ManaSymbol numeric = ManaSymbol.NUMERIC;
// then
assertEquals("{N/A}", numeric.toString());
assertFalse(numeric.isBlue());
assertFalse(numeric.isWhite());
assertFalse(numeric.isBlack());
assertFalse(numeric.isRed());
assertFalse(numeric.isGreen());
assertFalse(numeric.isColored());
assertFalse(numeric.isSnow());
assertFalse(numeric.isPhyrexian());
assertFalse(numeric.isHybrid());
assertFalse(numeric.isPrimary());
assertFalse(numeric.isMonocolored());
assertTrue(numeric.isGeneric());
assertTrue(numeric.isColorless());
assertEquals(null, numeric.getManaSymbol1());
assertEquals(null, numeric.getManaSymbol2());
}
@Test
public void shouldCreateMonoColoredHybridWManaSymbol() {
// given
// when
ManaSymbol monoHybridW = ManaSymbol.MONOCOLORED_HYBRID_W;
// then
assertEquals("{2/W}", monoHybridW.toString());
assertFalse(monoHybridW.isBlue());
assertFalse(monoHybridW.isBlack());
assertFalse(monoHybridW.isRed());
assertFalse(monoHybridW.isGreen());
assertFalse(monoHybridW.isSnow());
assertFalse(monoHybridW.isPhyrexian());
assertFalse(monoHybridW.isPrimary());
assertFalse(monoHybridW.isGeneric());
assertFalse(monoHybridW.isColorless());
assertTrue(monoHybridW.isMonocolored());
assertTrue(monoHybridW.isHybrid());
assertTrue(monoHybridW.isWhite());
assertTrue(monoHybridW.isColored());
assertEquals(ManaSymbol.W, monoHybridW.getManaSymbol1());
assertEquals(null, monoHybridW.getManaSymbol2());
}
@Test
public void shouldCreateMonoColoredHybridUManaSymbol() {
// given
// when
ManaSymbol monoHybridU = ManaSymbol.MONOCOLORED_HYBRID_U;
// then
assertEquals("{2/U}", monoHybridU.toString());
assertFalse(monoHybridU.isWhite());
assertFalse(monoHybridU.isBlack());
assertFalse(monoHybridU.isRed());
assertFalse(monoHybridU.isGreen());
assertFalse(monoHybridU.isSnow());
assertFalse(monoHybridU.isPhyrexian());
assertFalse(monoHybridU.isPrimary());
assertFalse(monoHybridU.isGeneric());
assertFalse(monoHybridU.isColorless());
assertTrue(monoHybridU.isMonocolored());
assertTrue(monoHybridU.isHybrid());
assertTrue(monoHybridU.isBlue());
assertTrue(monoHybridU.isColored());
assertEquals(ManaSymbol.U, monoHybridU.getManaSymbol1());
assertEquals(null, monoHybridU.getManaSymbol2());
}
@Test
public void shouldCreateMonoColoredHybridBManaSymbol() {
// given
// when
ManaSymbol monoHybridB = ManaSymbol.MONOCOLORED_HYBRID_B;
// then
assertEquals("{2/B}", monoHybridB.toString());
assertFalse(monoHybridB.isBlue());
assertFalse(monoHybridB.isWhite());
assertFalse(monoHybridB.isRed());
assertFalse(monoHybridB.isGreen());
assertFalse(monoHybridB.isSnow());
assertFalse(monoHybridB.isPhyrexian());
assertFalse(monoHybridB.isPrimary());
assertFalse(monoHybridB.isGeneric());
assertFalse(monoHybridB.isColorless());
assertTrue(monoHybridB.isMonocolored());
assertTrue(monoHybridB.isHybrid());
assertTrue(monoHybridB.isBlack());
assertTrue(monoHybridB.isColored());
assertEquals(ManaSymbol.B, monoHybridB.getManaSymbol1());
assertEquals(null, monoHybridB.getManaSymbol2());
}
@Test
public void shouldCreateMonoColoredHybridRManaSymbol() {
// given
// when
ManaSymbol monoHybridR = ManaSymbol.MONOCOLORED_HYBRID_R;
// then
assertEquals("{2/R}", monoHybridR.toString());
assertFalse(monoHybridR.isBlack());
assertFalse(monoHybridR.isBlue());
assertFalse(monoHybridR.isWhite());
assertFalse(monoHybridR.isGreen());
assertFalse(monoHybridR.isSnow());
assertFalse(monoHybridR.isPhyrexian());
assertFalse(monoHybridR.isPrimary());
assertFalse(monoHybridR.isGeneric());
assertFalse(monoHybridR.isColorless());
assertTrue(monoHybridR.isMonocolored());
assertTrue(monoHybridR.isHybrid());
assertTrue(monoHybridR.isRed());
assertTrue(monoHybridR.isColored());
assertEquals(ManaSymbol.R, monoHybridR.getManaSymbol1());
assertEquals(null, monoHybridR.getManaSymbol2());
}
@Test
public void shouldCreateMonoColoredHybridGManaSymbol() {
// given
// when
ManaSymbol monoHybridG = ManaSymbol.MONOCOLORED_HYBRID_G;
// then
assertEquals("{2/G}", monoHybridG.toString());
assertFalse(monoHybridG.isBlack());
assertFalse(monoHybridG.isBlue());
assertFalse(monoHybridG.isWhite());
assertFalse(monoHybridG.isRed());
assertFalse(monoHybridG.isSnow());
assertFalse(monoHybridG.isPhyrexian());
assertFalse(monoHybridG.isPrimary());
assertFalse(monoHybridG.isGeneric());
assertFalse(monoHybridG.isColorless());
assertTrue(monoHybridG.isMonocolored());
assertTrue(monoHybridG.isHybrid());
assertTrue(monoHybridG.isGreen());
assertTrue(monoHybridG.isColored());
assertEquals(ManaSymbol.G, monoHybridG.getManaSymbol1());
assertEquals(null, monoHybridG.getManaSymbol2());
}
}

10
Mage/src/mage/ManaSymbol.java
View file

@ -72,11 +72,11 @@ public enum ManaSymbol {
HYBRID_RW("{R/W}", R, W, Type.HYBRID, Type.COLORED),
HYBRID_GW("{G/W}", G, W, Type.HYBRID, Type.COLORED),
HYBRID_GU("{G/U}", G, U, Type.HYBRID, Type.COLORED),
MONOCOLORED_HYBRID_W("{2/W}", W, Type.HYBRID, Type.MONOCOLORED),
MONOCOLORED_HYBRID_U("{2/U}", U, Type.HYBRID, Type.MONOCOLORED),
MONOCOLORED_HYBRID_B("{2/B}", B, Type.HYBRID, Type.MONOCOLORED),
MONOCOLORED_HYBRID_R("{2/R}", R, Type.HYBRID, Type.MONOCOLORED),
MONOCOLORED_HYBRID_G("{2/G}", G, Type.HYBRID, Type.MONOCOLORED),
MONOCOLORED_HYBRID_W("{2/W}", W, Type.HYBRID, Type.MONOCOLORED, Type.COLORED),
MONOCOLORED_HYBRID_U("{2/U}", U, Type.HYBRID, Type.MONOCOLORED, Type.COLORED),
MONOCOLORED_HYBRID_B("{2/B}", B, Type.HYBRID, Type.MONOCOLORED, Type.COLORED),
MONOCOLORED_HYBRID_R("{2/R}", R, Type.HYBRID, Type.MONOCOLORED, Type.COLORED),
MONOCOLORED_HYBRID_G("{2/G}", G, Type.HYBRID, Type.MONOCOLORED, Type.COLORED),
PHYREXIAN_W("{W/P}", W, Type.PHYREXIAN, Type.COLORED),
PHYREXIAN_G("{G/P}", G, Type.PHYREXIAN, Type.COLORED),
PHYREXIAN_R("{R/P}", R, Type.PHYREXIAN, Type.COLORED),