Mercurial > repos > IBDev-IBBoard.WarFoundry.API.Tests

comparison API/Objects/Requirement/UnitRequiresNUnitsForMUnitsRequirementTests.cs @ 211:bc782a0d47bf

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Re #379: Fix validation of requirements to check for unit * Finish off validation tests for "N units for M Units" requirement
author IBBoard <dev@ibboard.co.uk>
date Sat, 25 Feb 2012 17:02:38 +0000
parents 649759343da5
children 325943cb1db0
comparison
equal deleted inserted replaced
210:649759343da5 211:bc782a0d47bf
120 AddUnitOfTypeToArmy(unitType2, army); 120 AddUnitOfTypeToArmy(unitType2, army);
121 Assert_That__PassesAdding(req, unitType1, army); 121 Assert_That__PassesAdding(req, unitType1, army);
122 } 122 }
123 123
124 [Test()] 124 [Test()]
125 public void TestAddingLimitedUnitTriggersFailure()
126 {
127 Army army = new Army(mockRace, "Test", 1000);
128 AddUnitOfTypeToArmy(unitType1, army);
129 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
130 req.AddUnitTypeRequirement(unitType2);
131 Assert_That__PassesAdding(req, unitType2, army);
132 AddUnitOfTypeToArmy(unitType1, army);
133 Assert_That__FailsAdding(req, unitType2, army, "Army must contain: 1 × " + unitType2.Name + " for every 1 × " + unitType1.Name + " (would have 1 for 2).");
134 }
135
136 [Test()]
125 public void TestAddingUnitTypeDefaultsToOne() 137 public void TestAddingUnitTypeDefaultsToOne()
126 { 138 {
127 Army army = new Army(mockRace, "Test", 1000); 139 Army army = new Army(mockRace, "Test", 1000);
128 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1); 140 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
129 req.AddUnitTypeRequirement(unitType2); 141 req.AddUnitTypeRequirement(unitType2);
175 Assert_That__AddingNotApplicable(req, unitType2, army); 187 Assert_That__AddingNotApplicable(req, unitType2, army);
176 AddUnitOfTypeToArmy(unitType1, army); 188 AddUnitOfTypeToArmy(unitType1, army);
177 Assert_That__FailsAdding(req, unitType2, army, "Army must contain: 2 × " + unitType2.Name + " for every 1 × " + unitType1.Name + " (would have 1 for 1)."); 189 Assert_That__FailsAdding(req, unitType2, army, "Army must contain: 2 × " + unitType2.Name + " for every 1 × " + unitType1.Name + " (would have 1 for 1).");
178 } 190 }
179 191
180 [Test()] 192 [Test]
181 public void TestAddingLimitedUnitTriggersFailure() 193 public void TestRequirementFailsWhenLimitedUnitsChange()
182 { 194 {
183 Army army = new Army(mockRace, "Test", 1000); 195 Army army = new Army(mockRace, "Test", 1000);
184 AddUnitOfTypeToArmy(unitType1, army); 196 AddUnitOfTypeToArmy(unitType1, army);
185 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1); 197 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
186 req.AddUnitTypeRequirement(unitType2); 198 req.AddUnitTypeRequirement(unitType2);
188 AddUnitOfTypeToArmy(unitType1, army); 200 AddUnitOfTypeToArmy(unitType1, army);
189 Assert_That__FailsAdding(req, unitType2, army, "Army must contain: 1 × " + unitType2.Name + " for every 1 × " + unitType1.Name + " (would have 1 for 2)."); 201 Assert_That__FailsAdding(req, unitType2, army, "Army must contain: 1 × " + unitType2.Name + " for every 1 × " + unitType1.Name + " (would have 1 for 2).");
190 } 202 }
191 203
192 [Test] 204 [Test]
193 public void TestRequirementFailsWhenLimitedUnitsChange()
194 {
195 Army army = new Army(mockRace, "Test", 1000);
196 AddUnitOfTypeToArmy(unitType1, army);
197 AddUnitOfTypeToArmy(unitType2, army);
198 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
199 req.AddUnitTypeRequirement(unitType2);
200 Assert_That__PassesAdding(req, unitType2, army);
201 AddUnitOfTypeToArmy(unitType1, army);
202 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Failed));
203 }
204
205 [Test]
206 public void TestValidationNotApplicableWithNoLimitedUnit() 205 public void TestValidationNotApplicableWithNoLimitedUnit()
207 { 206 {
208 Army army = new Army(mockRace, "Test", 1000); 207 Army army = new Army(mockRace, "Test", 1000);
209 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1); 208 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
210 req.AddUnitTypeRequirement(unitType2); 209 req.AddUnitTypeRequirement(unitType2);
211 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.NotApplicable)); 210 Assert_That__NotApplicable(req, army);
212 AddUnitOfTypeToArmy(unitType3, army); 211 AddUnitOfTypeToArmy(unitType3, army);
213 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.NotApplicable)); 212 Assert_That__NotApplicable(req, army);
214 AddUnitOfTypeToArmy(unitType2, army); 213 AddUnitOfTypeToArmy(unitType2, army);
215 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.NotApplicable)); 214 Assert_That__NotApplicable(req, army);
216 } 215 }
217 216
218 [Test()] 217 [Test()]
219 public void TestValidationWithNoUnitsAndOneUnitTypeRequiredFails() 218 public void TestValidatingWithNoUnitsAndOneUnitTypeRequiredFails()
220 { 219 {
221 Army army = new Army(mockRace, "Test", 1000); 220 Army army = new Army(mockRace, "Test", 1000);
222 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1); 221 AddUnitOfTypeToArmy(unitType1, army);
223 req.AddUnitTypeRequirement(unitType2); 222 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
224 AddUnitOfTypeToArmy(unitType1, army); 223 req.AddUnitTypeRequirement(unitType2);
225 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Failed)); 224 Assert_That__ValidationFails(req, army, "Army must contain: 1 × " + unitType2.Name + " for every 1 × " + unitType1.Name + " (have 0 for 1).");
226 } 225 }
227 226
228 [Test()] 227 [Test()]
229 public void TestValidationWithOneUnitAndOneUnitTypeRequiredPasses() 228 public void TestValidatingUnitWithOneUnitAndOneUnitTypeRequiredPasses()
230 { 229 {
231 Army army = new Army(mockRace, "Test", 1000); 230 Army army = new Army(mockRace, "Test", 1000);
232 AddUnitOfTypeToArmy(unitType1, army); 231 AddUnitOfTypeToArmy(unitType2, army);
233 AddUnitOfTypeToArmy(unitType2, army); 232 AddUnitOfTypeToArmy(unitType1, army);
234 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1); 233 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
235 req.AddUnitTypeRequirement(unitType2); 234 req.AddUnitTypeRequirement(unitType2);
236 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Passed)); 235 Assert_That__ValidationPasses(req, army);
237 } 236 }
238 237
239 [Test] 238 [Test()]
240 public void TestValidationMessageIsBlankForNotApplicable() 239 public void TestValidatingUnitTypeSetsLimit()
241 { 240 {
242 Army army = new Army(mockRace, "Test", 1000); 241 Army army = new Army(mockRace, "Test", 1000);
243 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1); 242 AddUnitOfTypeToArmy(unitType2, army);
244 req.AddUnitTypeRequirement(unitType2); 243 AddUnitOfTypeToArmy(unitType1, army);
245 Assert.That(req.GetValidationMessage(army), Is.Empty); 244 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
246 } 245 req.AddUnitTypeRequirement(unitType2, 1);
247 246 Assert_That__ValidationPasses(req, army);
248 [Test] 247 }
249 public void TestValidationMessageIsCorrectForFailWithOneUnitRequired() 248
250 { 249 [Test()]
251 Army army = new Army(mockRace, "Test", 1000); 250 public void TestValidatingUnitTypeSetsLimitForFailure()
252 AddUnitOfTypeToArmy(unitType1, army); 251 {
253 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1); 252 Army army = new Army(mockRace, "Test", 1000);
254 req.AddUnitTypeRequirement(unitType2); 253 AddUnitOfTypeToArmy(unitType1, army);
255 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " for every 1 × " + unitType1.Name + " (have 0 for 1).")); 254 AddUnitOfTypeToArmy(unitType1, army);
256 } 255 AddUnitOfTypeToArmy(unitType2, army);
257 256 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
258 [Test] 257 req.AddUnitTypeRequirement(unitType2, 1);
259 public void TestValidationMessageIsCorrectForFailWithTwoOfOneUnitLimit() 258 Assert_That__ValidationFails(req, army, "Army must contain: 1 × " + unitType2.Name + " for every 1 × " + unitType1.Name + " (have 1 for 2).");
260 { 259 }
261 Army army = new Army(mockRace, "Test", 1000); 260
262 AddUnitOfTypeToArmy(unitType1, army); 261 [Test()]
263 AddUnitOfTypeToArmy(unitType1, army); 262 public void TestAddingUnitTriggersValidationPass()
264 AddUnitOfTypeToArmy(unitType1, army); 263 {
265 AddUnitOfTypeToArmy(unitType2, army); 264 Army army = new Army(mockRace, "Test", 1000);
266 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1); 265 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
267 req.AddUnitTypeRequirement(unitType2, 2); 266 req.AddUnitTypeRequirement(unitType2, 1);
268 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " for every 2 × " + unitType1.Name + " (have 1 for 3).")); 267 AddUnitOfTypeToArmy(unitType1, army);
269 } 268 Assert_That__ValidationFails(req, army, "Army must contain: 1 × " + unitType2.Name + " for every 1 × " + unitType1.Name + " (have 0 for 1).");
270 269 AddUnitOfTypeToArmy(unitType2, army);
271 [Test] 270 Assert_That__ValidationPasses(req, army);
272 public void TestValidationMessageIsCorrectForFailWithTwoUnitsRequiredAndOneOfOneUnit() 271 }
273 { 272
274 Army army = new Army(mockRace, "Test", 1000); 273 [Test()]
275 AddUnitOfTypeToArmy(unitType1, army); 274 public void TestAddingLimitedUnitTriggersValidationFailure()
276 AddUnitOfTypeToArmy(unitType2, army); 275 {
277 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1); 276 Army army = new Army(mockRace, "Test", 1000);
278 req.AddUnitTypeRequirement(unitType2); 277 AddUnitOfTypeToArmy(unitType1, army);
279 req.AddUnitTypeRequirement(unitType3); 278 AddUnitOfTypeToArmy(unitType2, army);
280 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 1 × " + unitType3.Name + " for every 1 × " + unitType1.Name + " (have 0 for 1).")); 279 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
281 } 280 req.AddUnitTypeRequirement(unitType2);
282 281 Assert_That__ValidationPasses(req, army);
283 [Test] 282 AddUnitOfTypeToArmy(unitType1, army);
284 public void TestValidationMessageIsCorrectForFailWithTwoUnitsRequiredAndOneOfOtherUnitInArmy() 283 Assert_That__ValidationFails(req, army, "Army must contain: 1 × " + unitType2.Name + " for every 1 × " + unitType1.Name + " (have 1 for 2).");
285 { 284 }
286 Army army = new Army(mockRace, "Test", 1000); 285
287 AddUnitOfTypeToArmy(unitType1, army); 286 [Test()]
287 public void TestValidatingUnitTypeDefaultsToOne()
288 {
289 Army army = new Army(mockRace, "Test", 1000);
290 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
291 req.AddUnitTypeRequirement(unitType2);
292 AddUnitOfTypeToArmy(unitType1, army);
293 Assert_That__ValidationFails(req, army, "Army must contain: 1 × " + unitType2.Name + " for every 1 × " + unitType1.Name + " (have 0 for 1).");
294 AddUnitOfTypeToArmy(unitType2, army);
295 Assert_That__ValidationPasses(req, army);
296 }
297
298 [Test]
299 public void TestValidationRequirementNotApplicableWhenCheckingForNonLimitedUnits()
300 {
301 Army army = new Army(mockRace, "Test", 1000);
302 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
303 req.AddUnitTypeRequirement(unitType2);
288 AddUnitOfTypeToArmy(unitType3, army); 304 AddUnitOfTypeToArmy(unitType3, army);
289 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1); 305 Assert_That__NotApplicable(req, army);
290 req.AddUnitTypeRequirement(unitType2); 306 AddUnitOfTypeToArmy(unitType2, army);
291 req.AddUnitTypeRequirement(unitType3); 307 Assert_That__NotApplicable(req, army);
292 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " for every 1 × " + unitType1.Name + " (have 0 for 1).")); 308 }
293 } 309
294 310 [Test]
295 [Test] 311 public void TestValidationNotApplicableBecomesPassAfterAddingLimitedUnit()
296 public void TestValidationMessageIsCorrectForFailWithTwoRequiredUnitsAndNeitherInArmy() 312 {
297 { 313 Army army = new Army(mockRace, "Test", 1000);
298 Army army = new Army(mockRace, "Test", 1000); 314 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
299 AddUnitOfTypeToArmy(unitType1, army); 315 req.AddUnitTypeRequirement(unitType2);
300 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1); 316 AddUnitOfTypeToArmy(unitType2, army);
301 req.AddUnitTypeRequirement(unitType2); 317 Assert_That__NotApplicable(req, army);
302 req.AddUnitTypeRequirement(unitType3); 318 AddUnitOfTypeToArmy(unitType1, army);
303 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " for every 1 × " + unitType1.Name + " (have 0 for 1); 1 × " + unitType3.Name + " for every 1 × " + unitType1.Name + " (have 0 for 1).")); 319 Assert_That__ValidationPasses(req, army);
304 } 320 }
305 321
306 [Test] 322 [Test]
307 public void TestAllowsAddMessageIsCorrectForFailWithTwoOfOneUnitLimit() 323 public void TestValidationRequirementNotApplicableBecomesFailAfterAddingLimitedUnit()
308 { 324 {
309 Army army = new Army(mockRace, "Test", 1000); 325 Army army = new Army(mockRace, "Test", 1000);
310 AddUnitOfTypeToArmy(unitType1, army); 326 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
311 AddUnitOfTypeToArmy(unitType1, army); 327 req.AddUnitTypeRequirement(unitType2, 2, 1);
312 AddUnitOfTypeToArmy(unitType2, army); 328 AddUnitOfTypeToArmy(unitType2, army);
313 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1); 329 Assert_That__NotApplicable(req, army);
314 req.AddUnitTypeRequirement(unitType2, 2); 330 AddUnitOfTypeToArmy(unitType1, army);
315 Assert.That(req.GetAllowsAddingMessage(unitType1, army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " for every 2 × " + unitType1.Name + " (would have 1 for 3).")); 331 Assert_That__ValidationFails(req, army, "Army must contain: 2 × " + unitType2.Name + " for every 1 × " + unitType1.Name + " (have 1 for 1).");
316 } 332 }
317 333
318 [Test] 334 [Test]
319 public void TestAllowsAddMessageIsCorrectForFailWithTwoUnitsRequired() 335 public void TestValidationRequirementFailsWhenLimitedUnitsChange()
320 { 336 {
321 Army army = new Army(mockRace, "Test", 1000); 337 Army army = new Army(mockRace, "Test", 1000);
322 AddUnitOfTypeToArmy(unitType1, army); 338 AddUnitOfTypeToArmy(unitType1, army);
323 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1); 339 AddUnitOfTypeToArmy(unitType2, army);
324 req.AddUnitTypeRequirement(unitType2); 340 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
325 req.AddUnitTypeRequirement(unitType3); 341 req.AddUnitTypeRequirement(unitType2);
326 Assert.That(req.GetAllowsAddingMessage(unitType2, army), Is.EqualTo("Army must contain: 1 × " + unitType3.Name + " for every 1 × " + unitType1.Name + " (would have 0 for 1).")); 342 Assert_That__ValidationPasses(req, army);
327 } 343 AddUnitOfTypeToArmy(unitType1, army);
328 344 Assert_That__ValidationFails(req, army, "Army must contain: 1 × " + unitType2.Name + " for every 1 × " + unitType1.Name + " (have 1 for 2).");
329 [Test]
330 public void TestAllowsAddMessageIsCorrectForFailWithTwoUnitsRequiredAndOneUnitInArmy()
331 {
332 Army army = new Army(mockRace, "Test", 1000);
333 AddUnitOfTypeToArmy(unitType2, army);
334 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
335 req.AddUnitTypeRequirement(unitType2);
336 req.AddUnitTypeRequirement(unitType3);
337 Assert.That(req.GetAllowsAddingMessage(unitType1, army), Is.EqualTo("Army must contain: 1 × " + unitType3.Name + " for every 1 × " + unitType1.Name + " (would have 0 for 1)."));
338 }
339
340 [Test]
341 public void TestAllowsAddMessageIsCorrectForFailWithTwoUnitsRequiredAndOtherUnitInArmy()
342 {
343 Army army = new Army(mockRace, "Test", 1000);
344 AddUnitOfTypeToArmy(unitType3, army);
345 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
346 req.AddUnitTypeRequirement(unitType2);
347 req.AddUnitTypeRequirement(unitType3);
348 Assert.That(req.GetAllowsAddingMessage(unitType1, army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " for every 1 × " + unitType1.Name + " (would have 0 for 1)."));
349 } 345 }
350 346
351 private static void Assert_That__PassesAdding(UnitRequiresNUnitsForMUnitsRequirement req, UnitType unitType, Army army) 347 private static void Assert_That__PassesAdding(UnitRequiresNUnitsForMUnitsRequirement req, UnitType unitType, Army army)
352 { 348 {
353 Assert.That(req.AllowsAdding(unitType, army), Is.EqualTo(Validation.Passed)); 349 Assert.That(req.AllowsAdding(unitType, army), Is.EqualTo(Validation.Passed));
382 { 378 {
383 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Failed)); 379 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Failed));
384 Assert.That(req.GetAllowsAddingMessage(unit, army), Is.EqualTo(message)); 380 Assert.That(req.GetAllowsAddingMessage(unit, army), Is.EqualTo(message));
385 } 381 }
386 382
383 private static void Assert_That__ValidationPasses(UnitRequiresNUnitsForMUnitsRequirement req, Army army)
384 {
385 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Passed));
386 Assert.That(req.GetValidationMessage(army), Is.Empty);
387 }
388
389 private static void Assert_That__NotApplicable(UnitRequiresNUnitsForMUnitsRequirement req, Army army)
390 {
391 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.NotApplicable));
392 Assert.That(req.GetValidationMessage(army), Is.Empty);
393 }
394
395 private static void Assert_That__ValidationFails(UnitRequiresNUnitsForMUnitsRequirement req, Army army, string message)
396 {
397 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Failed));
398 Assert.That(req.GetValidationMessage(army), Is.EqualTo(message));
399 }
400
387 private static void AddUnitOfTypeToArmy(UnitType unitType, Army army) 401 private static void AddUnitOfTypeToArmy(UnitType unitType, Army army)
388 { 402 {
389 army.AddUnit(CreateUnitOfType(unitType, army)); 403 army.AddUnit(CreateUnitOfType(unitType, army));
390 } 404 }
391 405