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