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

comparison API/Objects/Requirement/UnitRequiresNUnitsForMUnitsRequirementTests.cs @ 210:649759343da5

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 * Tidy up tests to reduce replication and fix copy-and-paste inconsistencies
author IBBoard <dev@ibboard.co.uk>
date Sat, 25 Feb 2012 16:36:20 +0000
parents fc9a90d29ae0
children bc782a0d47bf
comparison
equal deleted inserted replaced
209:fc9a90d29ae0 210:649759343da5
27 unitType3 = new MockUnitType("type3", "Unit Type 3"); 27 unitType3 = new MockUnitType("type3", "Unit Type 3");
28 mockRace.AddUnitType(unitType3); 28 mockRace.AddUnitType(unitType3);
29 } 29 }
30 30
31 [Test()] 31 [Test()]
32 public void TestAddingUnitWithNoUnitsAndOneUnitTypeRequiredIsAllowed() 32 public void TestAddingUnitWithNoUnitsAndOneUnitTypeRequiredFails()
33 { 33 {
34 Army army = new Army(mockRace, "Test", 1000); 34 Army army = new Army(mockRace, "Test", 1000);
35 Unit unit = CreateUnitOfType(unitType1, army); 35 Unit unit = CreateUnitOfType(unitType1, army);
36 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1); 36 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
37 req.AddUnitTypeRequirement(unitType2); 37 req.AddUnitTypeRequirement(unitType2);
38 Assert_That__FailsAdding(req, unit, army, "Army must contain: 1 × " + unitType2.Name + " for every 1 × " + unitType1.Name + " (would have 0 for 1).");
39 }
40
41 [Test()]
42 public void TestAddingUnitTypeWithNoUnitsAndOneUnitTypeRequiredFails()
43 {
44 Army army = new Army(mockRace, "Test", 1000);
45 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
46 req.AddUnitTypeRequirement(unitType2);
47 Assert_That__FailsAdding(req, unitType1, army, "Army must contain: 1 × " + unitType2.Name + " for every 1 × " + unitType1.Name + " (would have 0 for 1).");
48 }
49
50 [Test()]
51 public void TestAddingUnitWithOneUnitAndOneUnitTypeRequiredPasses()
52 {
53 Army army = new Army(mockRace, "Test", 1000);
54 AddUnitOfTypeToArmy(unitType2, army);
55 Unit unit = CreateUnitOfType(unitType1, army);
56 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
57 req.AddUnitTypeRequirement(unitType2);
58 Assert_That__PassesAdding(req, unit, army);
59 }
60
61 [Test()]
62 public void TestAddingUnitTypeWithOneUnitAndOneUnitTypeRequiredPasses()
63 {
64 Army army = new Army(mockRace, "Test", 1000);
65 AddUnitOfTypeToArmy(unitType2, army);
66 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
67 req.AddUnitTypeRequirement(unitType2);
68 Assert_That__PassesAdding(req, unitType1, army);
69 }
70
71 [Test()]
72 public void TestAddingUnitWithOneUnitAndOneUnitTypeRequiredPassesWhenAddingRequiredUnit()
73 {
74 Army army = new Army(mockRace, "Test", 1000);
75 AddUnitOfTypeToArmy(unitType1, army);
76 Unit unit = CreateUnitOfType(unitType2, army);
77 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
78 req.AddUnitTypeRequirement(unitType2);
79 Assert_That__PassesAdding(req, unit, army);
80 }
81
82 [Test()]
83 public void TestAddingUnitTypeWithOneUnitAndOneUnitTypeRequiredPassesWhenAddingRequiredUnitType()
84 {
85 Army army = new Army(mockRace, "Test", 1000);
86 AddUnitOfTypeToArmy(unitType1, army);
87 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
88 req.AddUnitTypeRequirement(unitType2);
89 Assert_That__PassesAdding(req, unitType2, army);
90 }
91
92 [Test()]
93 public void TestAddingUnitTypeSetsLimit()
94 {
95 Army army = new Army(mockRace, "Test", 1000);
96 AddUnitOfTypeToArmy(unitType2, army);
97 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
98 req.AddUnitTypeRequirement(unitType2, 1);
99 Assert_That__PassesAdding(req, unitType1, army);
100 }
101
102 [Test()]
103 public void TestAddingUnitTypeSetsLimitForFailure()
104 {
105 Army army = new Army(mockRace, "Test", 1000);
106 AddUnitOfTypeToArmy(unitType1, army);
107 AddUnitOfTypeToArmy(unitType2, army);
108 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
109 req.AddUnitTypeRequirement(unitType2, 1);
110 Assert_That__FailsAdding(req, unitType1, army, "Army must contain: 1 × " + unitType2.Name + " for every 1 × " + unitType1.Name + " (would have 1 for 2).");
111 }
112
113 [Test()]
114 public void TestAddingUnitTriggersPass()
115 {
116 Army army = new Army(mockRace, "Test", 1000);
117 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
118 req.AddUnitTypeRequirement(unitType2, 1);
119 Assert_That__FailsAdding(req, unitType1, army, "Army must contain: 1 × " + unitType2.Name + " for every 1 × " + unitType1.Name + " (would have 0 for 1).");
120 AddUnitOfTypeToArmy(unitType2, army);
121 Assert_That__PassesAdding(req, unitType1, army);
122 }
123
124 [Test()]
125 public void TestAddingUnitTypeDefaultsToOne()
126 {
127 Army army = new Army(mockRace, "Test", 1000);
128 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
129 req.AddUnitTypeRequirement(unitType2);
130 Assert_That__FailsAdding(req, unitType1, army, "Army must contain: 1 × " + unitType2.Name + " for every 1 × " + unitType1.Name + " (would have 0 for 1).");
131 AddUnitOfTypeToArmy(unitType2, army);
132 Assert_That__PassesAdding(req, unitType1, army);
133 }
134
135 [Test]
136 public void TestRequirementNotApplicableWhenCheckingAddForNonLimitedUnits()
137 {
138 Army army = new Army(mockRace, "Test", 1000);
139 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
140 req.AddUnitTypeRequirement(unitType2);
141 Assert_That__AddingNotApplicable(req, unitType3, army);
142 Assert_That__AddingNotApplicable(req, CreateUnitOfType(unitType3, army), army);
143 Assert_That__AddingNotApplicable(req, unitType2, army);
144 Assert_That__AddingNotApplicable(req, CreateUnitOfType(unitType2, army), army);
145 }
146
147 [Test]
148 public void TestRequirementNotApplicableAfterAddingLimitedUnit()
149 {
150 Army army = new Army(mockRace, "Test", 1000);
151 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
152 req.AddUnitTypeRequirement(unitType2);
153 Assert_That__AddingNotApplicable(req, unitType3, army);
154 AddUnitOfTypeToArmy(unitType1, army);
155 Assert_That__AddingNotApplicable(req, unitType3, army);
156 }
157
158 [Test]
159 public void TestRequirementNotApplicableBecomesPassAfterAddingLimitedUnit()
160 {
161 Army army = new Army(mockRace, "Test", 1000);
162 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
163 req.AddUnitTypeRequirement(unitType2);
164 Assert_That__AddingNotApplicable(req, unitType2, army);
165 AddUnitOfTypeToArmy(unitType1, army);
166 Assert_That__PassesAdding(req, unitType2, army);
167 }
168
169 [Test]
170 public void TestRequirementNotApplicableBecomesFailAfterAddingLimitedUnit()
171 {
172 Army army = new Army(mockRace, "Test", 1000);
173 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
174 req.AddUnitTypeRequirement(unitType2, 2, 1);
175 Assert_That__AddingNotApplicable(req, unitType2, army);
176 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).");
178 }
179
180 [Test()]
181 public void TestAddingLimitedUnitTriggersFailure()
182 {
183 Army army = new Army(mockRace, "Test", 1000);
184 AddUnitOfTypeToArmy(unitType1, army);
185 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
186 req.AddUnitTypeRequirement(unitType2);
187 Assert_That__PassesAdding(req, unitType2, army);
188 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).");
190 }
191
192 [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()
207 {
208 Army army = new Army(mockRace, "Test", 1000);
209 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
210 req.AddUnitTypeRequirement(unitType2);
211 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.NotApplicable));
212 AddUnitOfTypeToArmy(unitType3, army);
213 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.NotApplicable));
214 AddUnitOfTypeToArmy(unitType2, army);
215 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.NotApplicable));
216 }
217
218 [Test()]
219 public void TestValidationWithNoUnitsAndOneUnitTypeRequiredFails()
220 {
221 Army army = new Army(mockRace, "Test", 1000);
222 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
223 req.AddUnitTypeRequirement(unitType2);
224 AddUnitOfTypeToArmy(unitType1, army);
225 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Failed));
226 }
227
228 [Test()]
229 public void TestValidationWithOneUnitAndOneUnitTypeRequiredPasses()
230 {
231 Army army = new Army(mockRace, "Test", 1000);
232 AddUnitOfTypeToArmy(unitType1, army);
233 AddUnitOfTypeToArmy(unitType2, army);
234 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
235 req.AddUnitTypeRequirement(unitType2);
236 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Passed));
237 }
238
239 [Test]
240 public void TestValidationMessageIsBlankForNotApplicable()
241 {
242 Army army = new Army(mockRace, "Test", 1000);
243 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
244 req.AddUnitTypeRequirement(unitType2);
245 Assert.That(req.GetValidationMessage(army), Is.Empty);
246 }
247
248 [Test]
249 public void TestValidationMessageIsCorrectForFailWithOneUnitRequired()
250 {
251 Army army = new Army(mockRace, "Test", 1000);
252 AddUnitOfTypeToArmy(unitType1, army);
253 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
254 req.AddUnitTypeRequirement(unitType2);
255 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " for every 1 × " + unitType1.Name + " (have 0 for 1)."));
256 }
257
258 [Test]
259 public void TestValidationMessageIsCorrectForFailWithTwoOfOneUnitLimit()
260 {
261 Army army = new Army(mockRace, "Test", 1000);
262 AddUnitOfTypeToArmy(unitType1, army);
263 AddUnitOfTypeToArmy(unitType1, army);
264 AddUnitOfTypeToArmy(unitType1, army);
265 AddUnitOfTypeToArmy(unitType2, army);
266 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
267 req.AddUnitTypeRequirement(unitType2, 2);
268 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " for every 2 × " + unitType1.Name + " (have 1 for 3)."));
269 }
270
271 [Test]
272 public void TestValidationMessageIsCorrectForFailWithTwoUnitsRequiredAndOneOfOneUnit()
273 {
274 Army army = new Army(mockRace, "Test", 1000);
275 AddUnitOfTypeToArmy(unitType1, army);
276 AddUnitOfTypeToArmy(unitType2, army);
277 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
278 req.AddUnitTypeRequirement(unitType2);
279 req.AddUnitTypeRequirement(unitType3);
280 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 1 × " + unitType3.Name + " for every 1 × " + unitType1.Name + " (have 0 for 1)."));
281 }
282
283 [Test]
284 public void TestValidationMessageIsCorrectForFailWithTwoUnitsRequiredAndOneOfOtherUnitInArmy()
285 {
286 Army army = new Army(mockRace, "Test", 1000);
287 AddUnitOfTypeToArmy(unitType1, army);
288 AddUnitOfTypeToArmy(unitType3, army);
289 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
290 req.AddUnitTypeRequirement(unitType2);
291 req.AddUnitTypeRequirement(unitType3);
292 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " for every 1 × " + unitType1.Name + " (have 0 for 1)."));
293 }
294
295 [Test]
296 public void TestValidationMessageIsCorrectForFailWithTwoRequiredUnitsAndNeitherInArmy()
297 {
298 Army army = new Army(mockRace, "Test", 1000);
299 AddUnitOfTypeToArmy(unitType1, army);
300 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
301 req.AddUnitTypeRequirement(unitType2);
302 req.AddUnitTypeRequirement(unitType3);
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)."));
304 }
305
306 [Test]
307 public void TestAllowsAddMessageIsCorrectForFailWithTwoOfOneUnitLimit()
308 {
309 Army army = new Army(mockRace, "Test", 1000);
310 AddUnitOfTypeToArmy(unitType1, army);
311 AddUnitOfTypeToArmy(unitType1, army);
312 AddUnitOfTypeToArmy(unitType2, army);
313 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
314 req.AddUnitTypeRequirement(unitType2, 2);
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)."));
316 }
317
318 [Test]
319 public void TestAllowsAddMessageIsCorrectForFailWithTwoUnitsRequired()
320 {
321 Army army = new Army(mockRace, "Test", 1000);
322 AddUnitOfTypeToArmy(unitType1, army);
323 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
324 req.AddUnitTypeRequirement(unitType2);
325 req.AddUnitTypeRequirement(unitType3);
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)."));
327 }
328
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 }
350
351 private static void Assert_That__PassesAdding(UnitRequiresNUnitsForMUnitsRequirement req, UnitType unitType, Army army)
352 {
353 Assert.That(req.AllowsAdding(unitType, army), Is.EqualTo(Validation.Passed));
354 Assert.That(req.GetAllowsAddingMessage(unitType, army), Is.Empty);
355 }
356
357 private static void Assert_That__PassesAdding(UnitRequiresNUnitsForMUnitsRequirement req, Unit unit, Army army)
358 {
38 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Passed)); 359 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Passed));
39 } 360 Assert.That(req.GetAllowsAddingMessage(unit, army), Is.Empty);
40 361 }
41 [Test()] 362
42 public void TestAddingUnitWithOneUnitAndOneUnitTypeRequiredIsNotAllowed() 363 private static void Assert_That__AddingNotApplicable(UnitRequiresNUnitsForMUnitsRequirement req, UnitType unitType, Army army)
43 { 364 {
44 Army army = new Army(mockRace, "Test", 1000); 365 Assert.That(req.AllowsAdding(unitType, army), Is.EqualTo(Validation.NotApplicable));
45 AddUnitOfTypeToArmy(unitType2, army); 366 Assert.That(req.GetAllowsAddingMessage(unitType, army), Is.Empty);
46 Unit unit = CreateUnitOfType(unitType1, army); 367 }
47 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1); 368
48 req.AddUnitTypeRequirement(unitType2); 369 private static void Assert_That__AddingNotApplicable(UnitRequiresNUnitsForMUnitsRequirement req, Unit unit, Army army)
370 {
371 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.NotApplicable));
372 Assert.That(req.GetAllowsAddingMessage(unit, army), Is.Empty);
373 }
374
375 private static void Assert_That__FailsAdding(UnitRequiresNUnitsForMUnitsRequirement req, UnitType unitType, Army army, string message)
376 {
377 Assert.That(req.AllowsAdding(unitType, army), Is.EqualTo(Validation.Failed));
378 Assert.That(req.GetAllowsAddingMessage(unitType, army), Is.EqualTo(message));
379 }
380
381 private static void Assert_That__FailsAdding(UnitRequiresNUnitsForMUnitsRequirement req, Unit unit, Army army, string message)
382 {
49 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Failed)); 383 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Failed));
50 } 384 Assert.That(req.GetAllowsAddingMessage(unit, army), Is.EqualTo(message));
51
52 [Test()]
53 public void TestAddingUnitTypeWithNoUnitsAndOneUnitTypeRequiredIsAllowed()
54 {
55 Army army = new Army(mockRace, "Test", 1000);
56 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
57 req.AddUnitTypeRequirement(unitType2);
58 Assert.That(req.AllowsAdding(unitType1, army), Is.EqualTo(Validation.Passed));
59 }
60
61 [Test()]
62 public void TestAddingUnitTypeWithOneUnitAndOneUnitTypeRequiredIsNotAllowed()
63 {
64 Army army = new Army(mockRace, "Test", 1000);
65 AddUnitOfTypeToArmy(unitType2, army);
66 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
67 req.AddUnitTypeRequirement(unitType2);
68 Assert.That(req.AllowsAdding(unitType1, army), Is.EqualTo(Validation.Failed));
69 }
70
71 [Test()]
72 public void TestAddingUnitTypeSetsLimit()
73 {
74 Army army = new Army(mockRace, "Test", 1000);
75 AddUnitOfTypeToArmy(unitType2, army);
76 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
77 req.AddUnitTypeRequirement(unitType2, 1);
78 Assert.That(req.AllowsAdding(unitType1, army), Is.EqualTo(Validation.Passed));
79 }
80
81 [Test()]
82 public void TestAddingUnitTypeSetsLimitForFailure()
83 {
84 Army army = new Army(mockRace, "Test", 1000);
85 AddUnitOfTypeToArmy(unitType2, army);
86 AddUnitOfTypeToArmy(unitType2, army);
87 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
88 req.AddUnitTypeRequirement(unitType2, 1);
89 Assert.That(req.AllowsAdding(unitType1, army), Is.EqualTo(Validation.Failed));
90 }
91
92 [Test()]
93 public void TestAddingUnitTriggersFailure()
94 {
95 Army army = new Army(mockRace, "Test", 1000);
96 AddUnitOfTypeToArmy(unitType1, army);
97 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
98 req.AddUnitTypeRequirement(unitType2, 1);
99 Assert.That(req.AllowsAdding(unitType1, army), Is.EqualTo(Validation.Failed));
100 AddUnitOfTypeToArmy(unitType2, army);
101 Assert.That(req.AllowsAdding(unitType1, army), Is.EqualTo(Validation.Passed));
102 }
103
104 [Test()]
105 public void TestAddingUnitTypeDefaultsToOne()
106 {
107 Army army = new Army(mockRace, "Test", 1000);
108 AddUnitOfTypeToArmy(unitType1, army);
109 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
110 req.AddUnitTypeRequirement(unitType2);
111 Assert.That(req.AllowsAdding(unitType1, army), Is.EqualTo(Validation.Failed));
112 AddUnitOfTypeToArmy(unitType2, army);
113 Assert.That(req.AllowsAdding(unitType1, army), Is.EqualTo(Validation.Passed));
114 }
115
116 [Test]
117 public void TestRequirementNotApplicableWhenLimitedUnitNotIncluded()
118 {
119 Army army = new Army(mockRace, "Test", 1000);
120 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
121 req.AddUnitTypeRequirement(unitType2);
122 Assert.That(req.AllowsAdding(unitType3, army), Is.EqualTo(Validation.NotApplicable));
123 Assert.That(req.AllowsAdding(unitType2, army), Is.EqualTo(Validation.NotApplicable));
124 }
125
126 [Test]
127 public void TestRequirementBecomesInvalidWhenProhibitedUnitsChange()
128 {
129 Army army = new Army(mockRace, "Test", 1000);
130 AddUnitOfTypeToArmy(unitType1, army);
131 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
132 req.AddUnitTypeRequirement(unitType2);
133 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Passed));
134 AddUnitOfTypeToArmy(unitType2, army);
135 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Failed));
136 }
137
138 [Test()]
139 public void TestAddingLimitedUnitTriggersFailure()
140 {
141 Army army = new Army(mockRace, "Test", 1000);
142 AddUnitOfTypeToArmy(unitType1, army);
143 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
144 req.AddUnitTypeRequirement(unitType2);
145 Assert.That(req.AllowsAdding(unitType2, army), Is.EqualTo(Validation.Passed));
146 }
147
148 [Test]
149 public void TestValidationMessageIsBlankForPass()
150 {
151 Army army = new Army(mockRace, "Test", 1000);
152 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
153 req.AddUnitTypeRequirement(unitType2);
154 Assert.That(req.GetValidationMessage(army), Is.Empty);
155 }
156
157 [Test]
158 public void TestValidationMessageIsCorrectForFailWithOneUnitProhibited()
159 {
160 Army army = new Army(mockRace, "Test", 1000);
161 AddUnitOfTypeToArmy(unitType1, army);
162 AddUnitOfTypeToArmy(unitType2, army);
163 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
164 req.AddUnitTypeRequirement(unitType2);
165 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 0 × " + unitType2.Name + " for every " + unitType1.Name + " (have 1)."));
166 }
167
168 [Test]
169 public void TestValidationMessageIsCorrectForFailWithTwoOfOneUnitLimit()
170 {
171 Army army = new Army(mockRace, "Test", 1000);
172 AddUnitOfTypeToArmy(unitType1, army);
173 AddUnitOfTypeToArmy(unitType2, army);
174 AddUnitOfTypeToArmy(unitType2, army);
175 AddUnitOfTypeToArmy(unitType2, army);
176 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
177 req.AddUnitTypeRequirement(unitType2, 2);
178 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 2 × " + unitType2.Name + " for every " + unitType1.Name + " (have 3)."));
179 }
180
181 [Test]
182 public void TestValidationMessageIsCorrectForFailWithTwoUnitsProhibited()
183 {
184 Army army = new Army(mockRace, "Test", 1000);
185 AddUnitOfTypeToArmy(unitType1, army);
186 AddUnitOfTypeToArmy(unitType2, army);
187 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
188 req.AddUnitTypeRequirement(unitType2);
189 req.AddUnitTypeRequirement(unitType3);
190 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 1 × " + unitType3.Name + " for every 1 × " + unitType1.Name + " (have 0 for 1)."));
191 }
192
193 [Test]
194 public void TestValidationMessageIsCorrectForFailWithTwoUnitsProhibitedAndOtherUnitInArmy()
195 {
196 Army army = new Army(mockRace, "Test", 1000);
197 AddUnitOfTypeToArmy(unitType1, army);
198 AddUnitOfTypeToArmy(unitType3, army);
199 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
200 req.AddUnitTypeRequirement(unitType2);
201 req.AddUnitTypeRequirement(unitType3);
202 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " for every 1 × " + unitType1.Name + " (have 0 for 1)."));
203 }
204
205 [Test]
206 public void TestValidationMessageIsCorrectForFailWithTwoUnitsProhibitedAndBothUnitsInArmy()
207 {
208 Army army = new Army(mockRace, "Test", 1000);
209 AddUnitOfTypeToArmy(unitType1, army);
210 AddUnitOfTypeToArmy(unitType2, army);
211 AddUnitOfTypeToArmy(unitType3, army);
212 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
213 req.AddUnitTypeRequirement(unitType2);
214 req.AddUnitTypeRequirement(unitType3);
215 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 0 × " + unitType2.Name + " for every " + unitType1.Name + " (have 1); 0 × " + unitType3.Name + " for every " + unitType1.Name + " (have 1)."));
216 }
217
218 [Test]
219 public void TestAllowsAddMessageIsBlankForPass()
220 {
221 Army army = new Army(mockRace, "Test", 1000);
222 AddUnitOfTypeToArmy(unitType1, army);
223 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
224 Assert.That(req.GetAllowsAddingMessage(unitType2, army), Is.Empty);
225 }
226
227 [Test]
228 public void TestAllowsAddMessageIsCorrectForFailWithOneUnitProhibited()
229 {
230 Army army = new Army(mockRace, "Test", 1000);
231 AddUnitOfTypeToArmy(unitType1, army);
232 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
233 req.AddUnitTypeRequirement(unitType2);
234 Assert.That(req.GetAllowsAddingMessage(unitType2, army), Is.EqualTo("Army must contain: 0 × " + unitType2.Name + " for every " + unitType1.Name + " (would have 1)."));
235 }
236
237 [Test]
238 public void TestAllowsAddMessageIsCorrectForFailWithTwoOfOneUnitLimit()
239 {
240 Army army = new Army(mockRace, "Test", 1000);
241 AddUnitOfTypeToArmy(unitType1, army);
242 AddUnitOfTypeToArmy(unitType2, army);
243 AddUnitOfTypeToArmy(unitType2, army);
244 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
245 req.AddUnitTypeRequirement(unitType2, 2);
246 Assert.That(req.GetAllowsAddingMessage(unitType2, army), Is.EqualTo("Army must contain: 2 × " + unitType2.Name + " for every " + unitType1.Name + " (would have 3)."));
247 }
248
249 [Test]
250 public void TestAllowsAddMessageIsCorrectForFailWithTwoUnitsProhibited()
251 {
252 Army army = new Army(mockRace, "Test", 1000);
253 AddUnitOfTypeToArmy(unitType1, army);
254 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
255 req.AddUnitTypeRequirement(unitType2);
256 req.AddUnitTypeRequirement(unitType3);
257 Assert.That(req.GetAllowsAddingMessage(unitType2, army), Is.EqualTo("Army must contain: 1 × " + unitType3.Name + " for every 1 × " + unitType1.Name + " (would have 0 for 1)."));
258 }
259
260 [Test]
261 public void TestAllowsAddMessageIsCorrectForFailWithTwoUnitsProhibitedAndOneUnitInArmy()
262 {
263 Army army = new Army(mockRace, "Test", 1000);
264 AddUnitOfTypeToArmy(unitType1, army);
265 AddUnitOfTypeToArmy(unitType2, army);
266 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
267 req.AddUnitTypeRequirement(unitType2);
268 req.AddUnitTypeRequirement(unitType3);
269 Assert.That(req.GetAllowsAddingMessage(unitType3, army), Is.EqualTo("Army must contain: 0 × " + unitType2.Name + " for every " + unitType1.Name + " (would have 1); 0 × " + unitType3.Name + " for every " + unitType1.Name + " (would have 1)."));
270 }
271
272 [Test]
273 public void TestAllowsAddMessageIsCorrectForFailWithTwoUnitsProhibitedAndOtherUnitInArmy()
274 {
275 Army army = new Army(mockRace, "Test", 1000);
276 AddUnitOfTypeToArmy(unitType1, army);
277 AddUnitOfTypeToArmy(unitType3, army);
278 UnitRequiresNUnitsForMUnitsRequirement req = new UnitRequiresNUnitsForMUnitsRequirement(unitType1);
279 req.AddUnitTypeRequirement(unitType2);
280 req.AddUnitTypeRequirement(unitType3);
281 Assert.That(req.GetAllowsAddingMessage(unitType2, army), Is.EqualTo("Army must contain: 0 × " + unitType2.Name + " for every " + unitType1.Name + " (would have 1); 0 × " + unitType3.Name + " for every " + unitType1.Name + " (would have 1)."));
282 } 385 }
283 386
284 private static void AddUnitOfTypeToArmy(UnitType unitType, Army army) 387 private static void AddUnitOfTypeToArmy(UnitType unitType, Army army)
285 { 388 {
286 army.AddUnit(CreateUnitOfType(unitType, army)); 389 army.AddUnit(CreateUnitOfType(unitType, army));