Mercurial > repos > IBBoard.WarFoundry.API.Tests
annotate API/Objects/Requirement/UnitRequiresAtLeastNUnitsRequirementTest.cs @ 221:c40cb2048fc3
Re #394:
* Fix UnitRequiresNUnitsForMUnitsRequirementTests unit test so it actually does test the other value
* Add tests to "requires at least N" requirement and factory to test alternatives (Rollcall's "-1,X|Y" notation)
| author | IBBoard <dev@ibboard.co.uk> |
|---|---|
| date | Sat, 24 Mar 2012 20:34:42 +0000 |
| parents | 9bf34e88da89 |
| children |
| rev | line source |
|---|---|
| 214 | 1 // This file (UnitRequiresAtLeastNUnitsRequirementTest.cs) is a part of the IBBoard.WarFoundry.API.Tests project and is copyright 2011 IBBoard |
| 132 | 2 // |
| 3 // The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license. | |
| 4 using System; | |
| 5 using NUnit.Framework; | |
| 6 using IBBoard.WarFoundry.API.Objects.Mock; | |
| 7 using NUnit.Framework.SyntaxHelpers; | |
| 8 | |
| 9 namespace IBBoard.WarFoundry.API.Objects.Requirement | |
| 10 { | |
| 11 [TestFixture()] | |
|
217
9bf34e88da89
Re #379: Fix validation of requirements to check for unit
IBBoard <dev@ibboard.co.uk>
parents:
214
diff
changeset
|
12 public class UnitRequiresAtLeastNUnitsRequirementTest : AbstractUnitTypeUnitRequirementTest<UnitType, UnitRequiresAtLeastNUnitsRequirement> |
| 132 | 13 { |
| 14 [Test()] | |
| 15 public void TestAddingUnitWithNoUnitsAndOneUnitTypeRequired() | |
| 16 { | |
| 17 Army army = new Army(mockRace, "Test", 1000); | |
| 18 UnitRequiresAtLeastNUnitsRequirement req = new UnitRequiresAtLeastNUnitsRequirement(unitType1); | |
| 19 req.AddUnitTypeRequirement(unitType2); | |
| 214 | 20 Assert_That__FailsAdding(req, unitType1, army, "Army must contain: 1 × " + unitType2.Name + " (would have 0)."); |
| 132 | 21 } |
| 22 | |
| 23 [Test()] | |
| 24 public void TestAddingUnitTypeWithOneUnitAndOneUnitTypeRequired() | |
| 25 { | |
| 26 Army army = new Army(mockRace, "Test", 1000); | |
| 27 AddUnitOfTypeToArmy(unitType2, army); | |
| 28 UnitRequiresAtLeastNUnitsRequirement req = new UnitRequiresAtLeastNUnitsRequirement(unitType1); | |
| 29 req.AddUnitTypeRequirement(unitType2); | |
| 214 | 30 Assert_That__PassesAdding(req, unitType1, army); |
| 132 | 31 } |
| 32 | |
| 33 [Test()] | |
| 34 public void TestAddingUnitTypeWithNoUnitsAndTwoUnitTypesRequired() | |
| 35 { | |
| 221 | 36 //Rollcall's "-1,X,-1,Y" requirement - unlimited once you have one of both |
| 132 | 37 Army army = new Army(mockRace, "Test", 1000); |
| 38 UnitRequiresAtLeastNUnitsRequirement req = new UnitRequiresAtLeastNUnitsRequirement(unitType1); | |
| 39 req.AddUnitTypeRequirement(unitType2); | |
| 40 req.AddUnitTypeRequirement(unitType3); | |
| 214 | 41 Assert_That__FailsAdding(req, unitType1, army, "Army must contain: 1 × " + unitType2.Name + " (would have 0); 1 × " + unitType3.Name + " (would have 0)."); |
| 132 | 42 } |
| 43 | |
| 44 [Test()] | |
| 45 public void TestAddingUnitTypeWithOneUnitAndTwoUnitTypesRequired() | |
| 46 { | |
| 221 | 47 //Rollcall's "-1,X,-1,Y" requirement - unlimited once you have one of both |
| 132 | 48 Army army = new Army(mockRace, "Test", 1000); |
| 49 AddUnitOfTypeToArmy(unitType2, army); | |
| 50 UnitRequiresAtLeastNUnitsRequirement req = new UnitRequiresAtLeastNUnitsRequirement(unitType1); | |
| 51 req.AddUnitTypeRequirement(unitType2); | |
| 52 req.AddUnitTypeRequirement(unitType3); | |
| 214 | 53 Assert_That__FailsAdding(req, unitType1, army, "Army must contain: 1 × " + unitType3.Name + " (would have 0)."); |
| 132 | 54 } |
| 55 | |
| 56 [Test()] | |
| 57 public void TestAddingUnitTypeWithOtherOneUnitAndTwoUnitTypesRequired() | |
| 58 { | |
| 221 | 59 //Rollcall's "-1,X,-1,Y" requirement - unlimited once you have one of both |
| 132 | 60 Army army = new Army(mockRace, "Test", 1000); |
| 61 AddUnitOfTypeToArmy(unitType3, army); | |
| 62 UnitRequiresAtLeastNUnitsRequirement req = new UnitRequiresAtLeastNUnitsRequirement(unitType1); | |
| 63 req.AddUnitTypeRequirement(unitType2); | |
| 64 req.AddUnitTypeRequirement(unitType3); | |
| 214 | 65 Assert_That__FailsAdding(req, unitType1, army, "Army must contain: 1 × " + unitType2.Name + " (would have 0)."); |
| 132 | 66 } |
| 67 | |
| 68 [Test()] | |
| 69 public void TestAddingUnitTypeWithBothUnitsAndTwoUnitTypesRequired() | |
| 70 { | |
| 221 | 71 //Rollcall's "-1,X,-1,Y" requirement - unlimited once you have one of both |
| 132 | 72 Army army = new Army(mockRace, "Test", 1000); |
| 73 AddUnitOfTypeToArmy(unitType2, army); | |
| 74 AddUnitOfTypeToArmy(unitType3, army); | |
| 75 UnitRequiresAtLeastNUnitsRequirement req = new UnitRequiresAtLeastNUnitsRequirement(unitType1); | |
| 76 req.AddUnitTypeRequirement(unitType2); | |
| 77 req.AddUnitTypeRequirement(unitType3); | |
| 214 | 78 Assert_That__PassesAdding(req, unitType1, army); |
| 132 | 79 } |
| 80 | |
| 81 [Test()] | |
| 82 public void TestAddingUnitTypeWithOneUnitAndTwoOfOneUnitTypeRequired() | |
| 83 { | |
| 84 Army army = new Army(mockRace, "Test", 1000); | |
| 85 AddUnitOfTypeToArmy(unitType2, army); | |
| 86 UnitRequiresAtLeastNUnitsRequirement req = new UnitRequiresAtLeastNUnitsRequirement(unitType1); | |
| 87 req.AddUnitTypeRequirement(unitType2, 2); | |
| 214 | 88 Assert_That__FailsAdding(req, unitType1, army, "Army must contain: 2 × " + unitType2.Name + " (would have 1)."); |
| 132 | 89 } |
| 90 | |
| 91 [Test()] | |
| 214 | 92 public void TestAddingUnrelatedUnitTypeValidatesAsNotApplicable() |
| 132 | 93 { |
| 94 Army army = new Army(mockRace, "Test", 1000); | |
| 95 UnitRequiresAtLeastNUnitsRequirement req = new UnitRequiresAtLeastNUnitsRequirement(unitType1); | |
| 96 req.AddUnitTypeRequirement(unitType2, 2); | |
| 214 | 97 Assert_That__AddingNotApplicable(req, unitType3, army); |
| 98 } | |
| 99 | |
| 100 [Test()] | |
| 101 public void TestAddingUnrelatedUnitTypeValidatesAsNotApplicableWhenRequirementsNotMet() | |
| 102 { | |
| 103 Army army = new Army(mockRace, "Test", 1000); | |
| 104 AddUnitOfTypeToArmy(unitType1, army); | |
| 105 UnitRequiresAtLeastNUnitsRequirement req = new UnitRequiresAtLeastNUnitsRequirement(unitType1); | |
| 106 req.AddUnitTypeRequirement(unitType2, 2); | |
| 107 Assert_That__AddingNotApplicable(req, unitType3, army); | |
| 132 | 108 } |
| 109 | |
| 110 [Test()] | |
| 111 public void TestAddingUnitTypeWithTwoUnitsAndTwoOfOneUnitTypeRequired() | |
| 112 { | |
| 113 Army army = new Army(mockRace, "Test", 1000); | |
| 114 AddUnitOfTypeToArmy(unitType2, army); | |
| 115 AddUnitOfTypeToArmy(unitType2, army); | |
| 116 UnitRequiresAtLeastNUnitsRequirement req = new UnitRequiresAtLeastNUnitsRequirement(unitType1); | |
| 117 req.AddUnitTypeRequirement(unitType2, 2); | |
| 214 | 118 Assert_That__PassesAdding(req, unitType1, army); |
| 132 | 119 } |
| 120 | |
| 121 [Test()] | |
| 122 public void TestAddingUnitTypeRequirementWithNoNumberDefaultsToHavingOne() | |
| 123 { | |
| 124 Army army = new Army(mockRace, "Test", 1000); | |
| 125 AddUnitOfTypeToArmy(unitType2, army); | |
| 126 UnitRequiresAtLeastNUnitsRequirement req = new UnitRequiresAtLeastNUnitsRequirement(unitType1); | |
| 127 req.AddUnitTypeRequirement(unitType2); | |
| 214 | 128 Assert_That__PassesAdding(req, unitType1, army); |
| 132 | 129 } |
| 130 | |
| 131 [Test()] | |
| 132 public void TestAddingUnitTypeMakesRequirementPass() | |
| 133 { | |
| 134 Army army = new Army(mockRace, "Test", 1000); | |
| 135 AddUnitOfTypeToArmy(unitType2, army); | |
| 136 UnitRequiresAtLeastNUnitsRequirement req = new UnitRequiresAtLeastNUnitsRequirement(unitType1); | |
| 137 req.AddUnitTypeRequirement(unitType2, 2); | |
| 214 | 138 Assert_That__FailsAdding(req, unitType1, army, "Army must contain: 2 × " + unitType2.Name + " (would have 1)."); |
| 132 | 139 AddUnitOfTypeToArmy(unitType2, army); |
| 214 | 140 Assert_That__PassesAdding(req, unitType1, army); |
| 132 | 141 } |
| 142 | |
| 221 | 143 [Test] |
| 144 public void TestAddingRequirementWithOR() | |
| 145 { | |
| 146 //Rollcall's "-1,X|Y" requirement - unlimited for one of either | |
| 147 Army army = new Army(mockRace, "Test", 1000); | |
| 148 UnitRequiresAtLeastNUnitsRequirement req = new UnitRequiresAtLeastNUnitsRequirement(unitType1); | |
| 149 req.AddUnitTypeRequirement(unitType2, unitType3); | |
| 150 Assert_That__FailsAdding(req, unitType1, army, "Army must contain: 1 × " + unitType2.Name + " or " + unitType3.Name + " (would have 0)."); | |
| 151 AddUnitOfTypeToArmy(unitType2, army); | |
| 152 Assert_That__PassesAdding(req, unitType1, army); | |
| 153 } | |
| 154 | |
| 155 [Test] | |
| 156 public void TestAddingRequirementWithORWithOtherUnit() | |
| 157 { | |
| 158 //Rollcall's "-1,X|Y" requirement - unlimited for one of either | |
| 159 Army army = new Army(mockRace, "Test", 1000); | |
| 160 UnitRequiresAtLeastNUnitsRequirement req = new UnitRequiresAtLeastNUnitsRequirement(unitType1); | |
| 161 req.AddUnitTypeRequirement(unitType2, unitType3); | |
| 162 Assert_That__FailsAdding(req, unitType1, army, "Army must contain: 1 × " + unitType2.Name + " or " + unitType3.Name + " (would have 0)."); | |
| 163 AddUnitOfTypeToArmy(unitType3, army); | |
| 164 Assert_That__PassesAdding(req, unitType1, army); | |
| 165 } | |
| 166 | |
| 167 [Test] | |
| 168 public void TestAddingRequirementWithORWithLimit() | |
| 169 { | |
| 170 Army army = new Army(mockRace, "Test", 1000); | |
| 171 UnitRequiresAtLeastNUnitsRequirement req = new UnitRequiresAtLeastNUnitsRequirement(unitType1); | |
| 172 req.AddUnitTypeRequirement(2, unitType2, unitType3); | |
| 173 Assert_That__FailsAdding(req, unitType1, army, "Army must contain: 2 × " + unitType2.Name + " or " + unitType3.Name + " (would have 0)."); | |
| 174 AddUnitOfTypeToArmy(unitType2, army); | |
| 175 Assert_That__FailsAdding(req, unitType1, army, "Army must contain: 2 × " + unitType2.Name + " or " + unitType3.Name + " (would have 1)."); | |
| 176 AddUnitOfTypeToArmy(unitType2, army); | |
| 177 Assert_That__PassesAdding(req, unitType1, army); | |
| 178 } | |
| 179 | |
| 180 [Test] | |
| 181 public void TestAddingRequirementWithORWithLimitWithOtherUnit() | |
| 182 { | |
| 183 Army army = new Army(mockRace, "Test", 1000); | |
| 184 UnitRequiresAtLeastNUnitsRequirement req = new UnitRequiresAtLeastNUnitsRequirement(unitType1); | |
| 185 req.AddUnitTypeRequirement(2, unitType2, unitType3); | |
| 186 Assert_That__FailsAdding(req, unitType1, army, "Army must contain: 2 × " + unitType2.Name + " or " + unitType3.Name + " (would have 0)."); | |
| 187 AddUnitOfTypeToArmy(unitType3, army); | |
| 188 Assert_That__FailsAdding(req, unitType1, army, "Army must contain: 2 × " + unitType2.Name + " or " + unitType3.Name + " (would have 1)."); | |
| 189 AddUnitOfTypeToArmy(unitType3, army); | |
| 190 Assert_That__PassesAdding(req, unitType1, army); | |
| 191 } | |
| 192 | |
| 132 | 193 [Test()] |
| 214 | 194 public void TestValidatingWithNoUnitsAndOneUnitTypeRequired() |
| 132 | 195 { |
| 196 Army army = new Army(mockRace, "Test", 1000); | |
| 197 UnitRequiresAtLeastNUnitsRequirement req = new UnitRequiresAtLeastNUnitsRequirement(unitType1); | |
| 198 req.AddUnitTypeRequirement(unitType2); | |
| 199 AddUnitOfTypeToArmy(unitType1, army); | |
| 214 | 200 Assert_That__ValidationFails(req, army, "Army must contain: 1 × " + unitType2.Name + " (have 0)."); |
| 132 | 201 } |
| 202 | |
| 203 [Test()] | |
| 214 | 204 public void TestValidatingWithOneUnitAndOneUnitTypeRequired() |
| 132 | 205 { |
| 206 Army army = new Army(mockRace, "Test", 1000); | |
| 207 AddUnitOfTypeToArmy(unitType1, army); | |
| 214 | 208 AddUnitOfTypeToArmy(unitType2, army); |
| 132 | 209 UnitRequiresAtLeastNUnitsRequirement req = new UnitRequiresAtLeastNUnitsRequirement(unitType1); |
| 210 req.AddUnitTypeRequirement(unitType2); | |
| 214 | 211 Assert_That__ValidationPasses(req, army); |
| 132 | 212 } |
| 213 | |
| 214 | 214 [Test()] |
| 215 public void TestValidatingWithNoUnitsAndTwoUnitTypesRequired() | |
| 132 | 216 { |
| 217 Army army = new Army(mockRace, "Test", 1000); | |
| 214 | 218 UnitRequiresAtLeastNUnitsRequirement req = new UnitRequiresAtLeastNUnitsRequirement(unitType1); |
| 219 req.AddUnitTypeRequirement(unitType2); | |
| 220 req.AddUnitTypeRequirement(unitType3); | |
| 132 | 221 AddUnitOfTypeToArmy(unitType1, army); |
| 214 | 222 Assert_That__ValidationFails(req, army, "Army must contain: 1 × " + unitType2.Name + " (have 0); 1 × " + unitType3.Name + " (have 0)."); |
| 132 | 223 } |
| 224 | |
| 214 | 225 [Test()] |
| 226 public void TestValidatingWithOneUnitAndTwoUnitTypesRequired() | |
|
142
f36b5e5e51e6
Re #345: Add failure message to requirements
IBBoard <dev@ibboard.co.uk>
parents:
132
diff
changeset
|
227 { |
|
f36b5e5e51e6
Re #345: Add failure message to requirements
IBBoard <dev@ibboard.co.uk>
parents:
132
diff
changeset
|
228 Army army = new Army(mockRace, "Test", 1000); |
|
f36b5e5e51e6
Re #345: Add failure message to requirements
IBBoard <dev@ibboard.co.uk>
parents:
132
diff
changeset
|
229 AddUnitOfTypeToArmy(unitType1, army); |
|
f36b5e5e51e6
Re #345: Add failure message to requirements
IBBoard <dev@ibboard.co.uk>
parents:
132
diff
changeset
|
230 AddUnitOfTypeToArmy(unitType2, army); |
|
208
c323770e61c2
Re #379: Fix validation of requirements to check for unit
IBBoard <dev@ibboard.co.uk>
parents:
207
diff
changeset
|
231 UnitRequiresAtLeastNUnitsRequirement req = new UnitRequiresAtLeastNUnitsRequirement(unitType1); |
|
142
f36b5e5e51e6
Re #345: Add failure message to requirements
IBBoard <dev@ibboard.co.uk>
parents:
132
diff
changeset
|
232 req.AddUnitTypeRequirement(unitType2); |
| 214 | 233 req.AddUnitTypeRequirement(unitType3); |
| 234 Assert_That__ValidationFails(req, army, "Army must contain: 1 × " + unitType3.Name + " (have 0)."); | |
|
142
f36b5e5e51e6
Re #345: Add failure message to requirements
IBBoard <dev@ibboard.co.uk>
parents:
132
diff
changeset
|
235 } |
|
f36b5e5e51e6
Re #345: Add failure message to requirements
IBBoard <dev@ibboard.co.uk>
parents:
132
diff
changeset
|
236 |
| 214 | 237 [Test()] |
| 238 public void TestValidatingWithOtherOneUnitAndTwoUnitTypesRequired() | |
|
142
f36b5e5e51e6
Re #345: Add failure message to requirements
IBBoard <dev@ibboard.co.uk>
parents:
132
diff
changeset
|
239 { |
|
f36b5e5e51e6
Re #345: Add failure message to requirements
IBBoard <dev@ibboard.co.uk>
parents:
132
diff
changeset
|
240 Army army = new Army(mockRace, "Test", 1000); |
|
f36b5e5e51e6
Re #345: Add failure message to requirements
IBBoard <dev@ibboard.co.uk>
parents:
132
diff
changeset
|
241 AddUnitOfTypeToArmy(unitType1, army); |
| 214 | 242 AddUnitOfTypeToArmy(unitType3, army); |
|
208
c323770e61c2
Re #379: Fix validation of requirements to check for unit
IBBoard <dev@ibboard.co.uk>
parents:
207
diff
changeset
|
243 UnitRequiresAtLeastNUnitsRequirement req = new UnitRequiresAtLeastNUnitsRequirement(unitType1); |
|
142
f36b5e5e51e6
Re #345: Add failure message to requirements
IBBoard <dev@ibboard.co.uk>
parents:
132
diff
changeset
|
244 req.AddUnitTypeRequirement(unitType2); |
|
f36b5e5e51e6
Re #345: Add failure message to requirements
IBBoard <dev@ibboard.co.uk>
parents:
132
diff
changeset
|
245 req.AddUnitTypeRequirement(unitType3); |
| 214 | 246 AddUnitOfTypeToArmy(unitType1, army); |
| 247 Assert_That__ValidationFails(req, army, "Army must contain: 1 × " + unitType2.Name + " (have 0)."); | |
|
142
f36b5e5e51e6
Re #345: Add failure message to requirements
IBBoard <dev@ibboard.co.uk>
parents:
132
diff
changeset
|
248 } |
| 132 | 249 |
| 214 | 250 [Test()] |
| 251 public void TestValidatingWithBothUnitsAndTwoUnitTypesRequired() | |
|
146
8c519a44e699
Re #345: Add failure message to requirements
IBBoard <dev@ibboard.co.uk>
parents:
142
diff
changeset
|
252 { |
|
8c519a44e699
Re #345: Add failure message to requirements
IBBoard <dev@ibboard.co.uk>
parents:
142
diff
changeset
|
253 Army army = new Army(mockRace, "Test", 1000); |
|
8c519a44e699
Re #345: Add failure message to requirements
IBBoard <dev@ibboard.co.uk>
parents:
142
diff
changeset
|
254 AddUnitOfTypeToArmy(unitType1, army); |
| 214 | 255 AddUnitOfTypeToArmy(unitType2, army); |
| 256 AddUnitOfTypeToArmy(unitType3, army); | |
|
208
c323770e61c2
Re #379: Fix validation of requirements to check for unit
IBBoard <dev@ibboard.co.uk>
parents:
207
diff
changeset
|
257 UnitRequiresAtLeastNUnitsRequirement req = new UnitRequiresAtLeastNUnitsRequirement(unitType1); |
|
146
8c519a44e699
Re #345: Add failure message to requirements
IBBoard <dev@ibboard.co.uk>
parents:
142
diff
changeset
|
258 req.AddUnitTypeRequirement(unitType2); |
|
8c519a44e699
Re #345: Add failure message to requirements
IBBoard <dev@ibboard.co.uk>
parents:
142
diff
changeset
|
259 req.AddUnitTypeRequirement(unitType3); |
| 214 | 260 Assert_That__ValidationPasses(req, army); |
|
146
8c519a44e699
Re #345: Add failure message to requirements
IBBoard <dev@ibboard.co.uk>
parents:
142
diff
changeset
|
261 } |
|
8c519a44e699
Re #345: Add failure message to requirements
IBBoard <dev@ibboard.co.uk>
parents:
142
diff
changeset
|
262 |
| 214 | 263 [Test()] |
| 264 public void TestValidatingWithOneUnitAndTwoOfOneUnitTypeRequired() | |
|
146
8c519a44e699
Re #345: Add failure message to requirements
IBBoard <dev@ibboard.co.uk>
parents:
142
diff
changeset
|
265 { |
|
8c519a44e699
Re #345: Add failure message to requirements
IBBoard <dev@ibboard.co.uk>
parents:
142
diff
changeset
|
266 Army army = new Army(mockRace, "Test", 1000); |
| 214 | 267 AddUnitOfTypeToArmy(unitType1, army); |
|
146
8c519a44e699
Re #345: Add failure message to requirements
IBBoard <dev@ibboard.co.uk>
parents:
142
diff
changeset
|
268 AddUnitOfTypeToArmy(unitType2, army); |
|
208
c323770e61c2
Re #379: Fix validation of requirements to check for unit
IBBoard <dev@ibboard.co.uk>
parents:
207
diff
changeset
|
269 UnitRequiresAtLeastNUnitsRequirement req = new UnitRequiresAtLeastNUnitsRequirement(unitType1); |
| 214 | 270 req.AddUnitTypeRequirement(unitType2, 2); |
| 271 AddUnitOfTypeToArmy(unitType1, army); | |
| 272 Assert_That__ValidationFails(req, army, "Army must contain: 2 × " + unitType2.Name + " (have 1)."); | |
|
146
8c519a44e699
Re #345: Add failure message to requirements
IBBoard <dev@ibboard.co.uk>
parents:
142
diff
changeset
|
273 } |
|
8c519a44e699
Re #345: Add failure message to requirements
IBBoard <dev@ibboard.co.uk>
parents:
142
diff
changeset
|
274 |
| 214 | 275 [Test()] |
| 276 public void TestValidatingWithUnrelatedUnitTypeValidatesAsNotApplicable() | |
|
146
8c519a44e699
Re #345: Add failure message to requirements
IBBoard <dev@ibboard.co.uk>
parents:
142
diff
changeset
|
277 { |
|
8c519a44e699
Re #345: Add failure message to requirements
IBBoard <dev@ibboard.co.uk>
parents:
142
diff
changeset
|
278 Army army = new Army(mockRace, "Test", 1000); |
|
8c519a44e699
Re #345: Add failure message to requirements
IBBoard <dev@ibboard.co.uk>
parents:
142
diff
changeset
|
279 AddUnitOfTypeToArmy(unitType3, army); |
|
208
c323770e61c2
Re #379: Fix validation of requirements to check for unit
IBBoard <dev@ibboard.co.uk>
parents:
207
diff
changeset
|
280 UnitRequiresAtLeastNUnitsRequirement req = new UnitRequiresAtLeastNUnitsRequirement(unitType1); |
| 214 | 281 req.AddUnitTypeRequirement(unitType2, 2); |
| 282 Assert_That__NotApplicable(req, army); | |
| 283 } | |
| 284 | |
| 285 [Test()] | |
| 286 public void TestValidatingWithTwoUnitsAndTwoOfOneUnitTypeRequired() | |
| 287 { | |
| 288 Army army = new Army(mockRace, "Test", 1000); | |
| 289 AddUnitOfTypeToArmy(unitType1, army); | |
| 290 AddUnitOfTypeToArmy(unitType2, army); | |
| 291 AddUnitOfTypeToArmy(unitType2, army); | |
| 292 UnitRequiresAtLeastNUnitsRequirement req = new UnitRequiresAtLeastNUnitsRequirement(unitType1); | |
| 293 req.AddUnitTypeRequirement(unitType2, 2); | |
| 294 Assert_That__ValidationPasses(req, army); | |
| 295 } | |
| 296 | |
| 297 [Test()] | |
| 298 public void TestValidatingRequirementWithNoNumberDefaultsToHavingOne() | |
| 299 { | |
| 300 Army army = new Army(mockRace, "Test", 1000); | |
| 301 AddUnitOfTypeToArmy(unitType1, army); | |
| 302 AddUnitOfTypeToArmy(unitType2, army); | |
| 303 UnitRequiresAtLeastNUnitsRequirement req = new UnitRequiresAtLeastNUnitsRequirement(unitType1); | |
|
146
8c519a44e699
Re #345: Add failure message to requirements
IBBoard <dev@ibboard.co.uk>
parents:
142
diff
changeset
|
304 req.AddUnitTypeRequirement(unitType2); |
| 214 | 305 Assert_That__ValidationPasses(req, army); |
| 306 } | |
| 307 | |
| 308 [Test()] | |
| 309 public void TestAddingUnitTypeMakesRequirementPassValidating() | |
| 310 { | |
| 311 Army army = new Army(mockRace, "Test", 1000); | |
| 312 AddUnitOfTypeToArmy(unitType1, army); | |
| 313 AddUnitOfTypeToArmy(unitType2, army); | |
| 314 UnitRequiresAtLeastNUnitsRequirement req = new UnitRequiresAtLeastNUnitsRequirement(unitType1); | |
| 315 req.AddUnitTypeRequirement(unitType2, 2); | |
| 316 Assert_That__ValidationFails(req, army, "Army must contain: 2 × " + unitType2.Name + " (have 1)."); | |
| 317 AddUnitOfTypeToArmy(unitType2, army); | |
| 318 Assert_That__ValidationPasses(req, army); | |
|
146
8c519a44e699
Re #345: Add failure message to requirements
IBBoard <dev@ibboard.co.uk>
parents:
142
diff
changeset
|
319 } |
|
217
9bf34e88da89
Re #379: Fix validation of requirements to check for unit
IBBoard <dev@ibboard.co.uk>
parents:
214
diff
changeset
|
320 |
| 221 | 321 [Test] |
| 322 public void TestRequirementWithOR() | |
| 323 { | |
| 324 //Rollcall's "-1,X|Y" requirement - unlimited for one of either | |
| 325 Army army = new Army(mockRace, "Test", 1000); | |
| 326 UnitRequiresAtLeastNUnitsRequirement req = new UnitRequiresAtLeastNUnitsRequirement(unitType1); | |
| 327 req.AddUnitTypeRequirement(unitType2, unitType3); | |
| 328 AddUnitOfTypeToArmy(unitType1, army); | |
| 329 Assert_That__ValidationFails(req, army, "Army must contain: 1 × " + unitType2.Name + " or " + unitType3.Name + " (have 0)."); | |
| 330 AddUnitOfTypeToArmy(unitType2, army); | |
| 331 Assert_That__ValidationPasses(req, army); | |
| 332 } | |
| 333 | |
| 334 [Test] | |
| 335 public void TestRequirementWithORWithOtherUnit() | |
| 336 { | |
| 337 //Rollcall's "-1,X|Y" requirement - unlimited for one of either | |
| 338 Army army = new Army(mockRace, "Test", 1000); | |
| 339 UnitRequiresAtLeastNUnitsRequirement req = new UnitRequiresAtLeastNUnitsRequirement(unitType1); | |
| 340 req.AddUnitTypeRequirement(unitType2, unitType3); | |
| 341 AddUnitOfTypeToArmy(unitType1, army); | |
| 342 Assert_That__ValidationFails(req, army, "Army must contain: 1 × " + unitType2.Name + " or " + unitType3.Name + " (have 0)."); | |
| 343 AddUnitOfTypeToArmy(unitType3, army); | |
| 344 Assert_That__ValidationPasses(req, army); | |
| 345 } | |
| 346 | |
| 347 [Test] | |
| 348 public void TestRequirementWithORWithLimit() | |
| 349 { | |
| 350 Army army = new Army(mockRace, "Test", 1000); | |
| 351 UnitRequiresAtLeastNUnitsRequirement req = new UnitRequiresAtLeastNUnitsRequirement(unitType1); | |
| 352 req.AddUnitTypeRequirement(2, unitType2, unitType3); | |
| 353 AddUnitOfTypeToArmy(unitType1, army); | |
| 354 Assert_That__ValidationFails(req, army, "Army must contain: 2 × " + unitType2.Name + " or " + unitType3.Name + " (have 0)."); | |
| 355 AddUnitOfTypeToArmy(unitType2, army); | |
| 356 Assert_That__ValidationFails(req, army, "Army must contain: 2 × " + unitType2.Name + " or " + unitType3.Name + " (have 1)."); | |
| 357 AddUnitOfTypeToArmy(unitType2, army); | |
| 358 Assert_That__ValidationPasses(req, army); | |
| 359 } | |
| 360 | |
| 361 [Test] | |
| 362 public void TestRequirementWithORWithLimitWithOtherUnit() | |
| 363 { | |
| 364 Army army = new Army(mockRace, "Test", 1000); | |
| 365 UnitRequiresAtLeastNUnitsRequirement req = new UnitRequiresAtLeastNUnitsRequirement(unitType1); | |
| 366 req.AddUnitTypeRequirement(2, unitType2, unitType3); | |
| 367 AddUnitOfTypeToArmy(unitType1, army); | |
| 368 Assert_That__ValidationFails(req, army, "Army must contain: 2 × " + unitType2.Name + " or " + unitType3.Name + " (have 0)."); | |
| 369 AddUnitOfTypeToArmy(unitType3, army); | |
| 370 Assert_That__ValidationFails(req, army, "Army must contain: 2 × " + unitType2.Name + " or " + unitType3.Name + " (have 1)."); | |
| 371 AddUnitOfTypeToArmy(unitType3, army); | |
| 372 Assert_That__ValidationPasses(req, army); | |
| 373 } | |
| 374 | |
|
217
9bf34e88da89
Re #379: Fix validation of requirements to check for unit
IBBoard <dev@ibboard.co.uk>
parents:
214
diff
changeset
|
375 protected override UnitRequiresAtLeastNUnitsRequirement CreateRequirement(UnitType requirementOn) |
|
9bf34e88da89
Re #379: Fix validation of requirements to check for unit
IBBoard <dev@ibboard.co.uk>
parents:
214
diff
changeset
|
376 { |
|
9bf34e88da89
Re #379: Fix validation of requirements to check for unit
IBBoard <dev@ibboard.co.uk>
parents:
214
diff
changeset
|
377 return new UnitRequiresAtLeastNUnitsRequirement(requirementOn); |
|
9bf34e88da89
Re #379: Fix validation of requirements to check for unit
IBBoard <dev@ibboard.co.uk>
parents:
214
diff
changeset
|
378 } |
| 132 | 379 } |
| 380 } | |
| 381 |