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

comparison API/Objects/Requirement/RequiresNUnitsForMObjectsRequirementTest.cs @ 208:c323770e61c2

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 * Rename classes in tests to match API changes * Alter tests to match new API (all classes require at least one UnitType that they're relevant to now)
author IBBoard <dev@ibboard.co.uk>
date Wed, 22 Feb 2012 20:48:40 +0000
parents
children
comparison
equal deleted inserted replaced
207:27f163bf884a 208:c323770e61c2
1 // This file (UnitRequiresNUnitsForMObjectsRequirement.cs) is a part of the IBBoard.WarFoundry.API.Tests project and is copyright 2011 IBBoard
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 using System.Reflection;
9 using IBBoard.NUnit;
10 using IBBoard.WarFoundry.API.Factories;
11
12 namespace IBBoard.WarFoundry.API.Objects.Requirement
13 {
14 public abstract class RequiresNUnitsForMObjectsRequirementTest : AbstractEqualityTest<RequiresNUnitsForMObjectsRequirement<UnitType>>
15 {
16 private MockRace mockRace;
17 private UnitType unitType1;
18 private UnitType unitType2;
19 private UnitType unitType3;
20 private UnitType unitType4;
21
22 [TestFixtureSetUp()]
23 public void SetupRace()
24 {
25 mockRace = MockRace.GetMockRace();
26 unitType1 = new MockUnitType("type1", "Unit Type 1");
27 mockRace.AddUnitType(unitType1);
28 unitType2 = new MockUnitType("type2", "Unit Type 2");
29 mockRace.AddUnitType(unitType2);
30 unitType3 = new MockUnitType("type3", "Unit Type 3");
31 mockRace.AddUnitType(unitType3);
32 unitType4 = new MockUnitType("type4", "Unit Type 4");
33 mockRace.AddUnitType(unitType4);
34 }
35
36 [Test()]
37 public void TestAddingUnrelatedUnitWithNoUnitsAndOneUnitTypeRequiredIsNA()
38 {
39 Army army = new Army(mockRace, "Test", 1000);
40 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1, unitType2);
41 Unit unit = CreateUnitOfType(unitType3, army);
42 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.NotApplicable));
43 Assert.That(req.GetAllowsAddingMessage(unit.UnitType, army), Is.Empty);
44 }
45
46 [Test()]
47 public void TestAddingOneUnitWithOneUnitTypeRequiredAndOneUnitOfTypePasses()
48 {
49 Army army = new Army(mockRace, "Test", 1000);
50 AddUnitOfTypeToArmy(unitType2, army);
51 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1, unitType2);
52 Unit unit = CreateUnitOfType(unitType1, army);
53 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Passed));
54 Assert.That(req.GetAllowsAddingMessage(unit.UnitType, army), Is.Empty);
55 }
56
57 [Test()]
58 public void TestAddingOneUnitWithOneUnitTypeRequiredAndNoUnitOfTypeFails()
59 {
60 Army army = new Army(mockRace, "Test", 1000);
61 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1, unitType2);
62 Unit unit = CreateUnitOfType(unitType1, army);
63 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Failed));
64 Assert.That(req.GetAllowsAddingMessage(unit.UnitType, army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " for every 1 × " + unitType1.Name + " (would have 0 for 1)."));
65 }
66
67 [Test()]
68 public void TestAddingOneUnitWithTwoDifferentUnitTypesRequiredAndNoUnitOfOneTypeFails()
69 {
70 Army army = new Army(mockRace, "Test", 1000);
71 AddUnitOfTypeToArmy(unitType2, army);
72 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
73 req.AddUnitTypeRequirement(unitType2);
74 req.AddUnitTypeRequirement(unitType3);
75 Unit unit = CreateUnitOfType(unitType1, army);
76 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Failed));
77 Assert.That(req.GetAllowsAddingMessage(unit.UnitType, army), Is.EqualTo("Army must contain: 1 × " + unitType3.Name + " for every 1 × " + unitType1.Name + " (would have 0 for 1)."));
78 }
79
80 [Test()]
81 public void TestAddingTwoUnitsWithOneUnitTypeRequiredAndOneUnitOfTypeFails()
82 {
83 Army army = new Army(mockRace, "Test", 1000);
84 AddUnitOfTypeToArmy(unitType2, army);
85 AddUnitOfTypeToArmy(unitType1, army);
86 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1, unitType2);
87 Unit unit = CreateUnitOfType(unitType1, army);
88 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Failed));
89 Assert.That(req.GetAllowsAddingMessage(unit.UnitType, army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " for every 1 × " + unitType1.Name + " (would have 1 for 2)."));
90 }
91
92 [Test()]
93 public void TestAddingTwoUnitsWithTwoOfUnitTypeAllowedForOneUnitTypeRequiredAndOneUnitOfTypePasses()
94 {
95 Army army = new Army(mockRace, "Test", 1000);
96 AddUnitOfTypeToArmy(unitType2, army);
97 AddUnitOfTypeToArmy(unitType1, army);
98 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
99 req.AddUnitTypeRequirement(unitType2, 1, 2);
100 Unit unit = CreateUnitOfType(unitType1, army);
101 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Passed));
102 Assert.That(req.GetAllowsAddingMessage(unit.UnitType, army), Is.Empty);
103 }
104
105 [Test()]
106 public void TestAddingTwoUnitsWithTwoAllowedAndOneAllowedForDifferentTypesFails()
107 {
108 Army army = new Army(mockRace, "Test", 1000);
109 AddUnitOfTypeToArmy(unitType2, army);
110 AddUnitOfTypeToArmy(unitType3, army);
111 AddUnitOfTypeToArmy(unitType1, army);
112 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
113 req.AddUnitTypeRequirement(unitType2, 1, 2);
114 req.AddUnitTypeRequirement(unitType3, 1, 1);
115 Unit unit = CreateUnitOfType(unitType1, army);
116 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Failed));
117 Assert.That(req.GetAllowsAddingMessage(unit.UnitType, army), Is.EqualTo("Army must contain: 1 × " + unitType3.Name + " for every 1 × " + unitType1.Name + " (would have 1 for 2)."));
118 }
119
120 [Test()]
121 public void TestAddingSecondUnitsWithOneAllowedForTwoTypesFails()
122 {
123 Army army = new Army(mockRace, "Test", 1000);
124 AddUnitOfTypeToArmy(unitType2, army);
125 AddUnitOfTypeToArmy(unitType3, army);
126 AddUnitOfTypeToArmy(unitType1, army);
127 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
128 req.AddUnitTypeRequirement(unitType2, 1, 1);
129 req.AddUnitTypeRequirement(unitType3, 1, 1);
130 Unit unit = CreateUnitOfType(unitType1, army);
131 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Failed));
132 Assert.That(req.GetAllowsAddingMessage(unit.UnitType, army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " for every 1 × " + unitType1.Name + " (would have 1 for 2); 1 × " + unitType3.Name + " for every 1 × " + unitType1.Name + " (would have 1 for 2)."));
133 }
134
135 [Test()]
136 public void TestAddingSecondUnitsWithOneAllowedForTwoTypesFails_ShorthandMethod()
137 {
138 Army army = new Army(mockRace, "Test", 1000);
139 AddUnitOfTypeToArmy(unitType2, army);
140 AddUnitOfTypeToArmy(unitType3, army);
141 AddUnitOfTypeToArmy(unitType1, army);
142 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1, unitType2, unitType3);
143 Unit unit = CreateUnitOfType(unitType1, army);
144 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Failed));
145 Assert.That(req.GetAllowsAddingMessage(unit.UnitType, army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " for every 1 × " + unitType1.Name + " (would have 1 for 2); 1 × " + unitType3.Name + " for every 1 × " + unitType1.Name + " (would have 1 for 2)."));
146 }
147
148 [Test()]
149 public void TestAddingThreeUnitsWithTwoOfUnitTypeAllowedForOneUnitTypeRequiredAndOneUnitOfTypeFails()
150 {
151 Army army = new Army(mockRace, "Test", 1000);
152 AddUnitOfTypeToArmy(unitType2, army);
153 AddUnitOfTypeToArmy(unitType1, army);
154 AddUnitOfTypeToArmy(unitType1, army);
155 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
156 req.AddUnitTypeRequirement(unitType2, 1, 2);
157 Unit unit = CreateUnitOfType(unitType1, army);
158 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Failed));
159 Assert.That(req.GetAllowsAddingMessage(unit.UnitType, army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " for every 2 × " + unitType1.Name + " (would have 1 for 3)."));
160 }
161
162 [Test()]
163 public void TestAddingOneUnitWithThreeOfUnitTypeAllowedForTwoOfUnitTypeRequiredAndOneUnitOfTypeFails()
164 {
165 Army army = new Army(mockRace, "Test", 1000);
166 AddUnitOfTypeToArmy(unitType2, army);
167 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
168 req.AddUnitTypeRequirement(unitType2, 2, 3);
169 Unit unit = CreateUnitOfType(unitType1, army);
170 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Failed));
171 Assert.That(req.GetAllowsAddingMessage(unit.UnitType, army), Is.EqualTo("Army must contain: 2 × " + unitType2.Name + " for every 3 × " + unitType1.Name + " (would have 1 for 1)."));
172 }
173
174 [Test()]
175 public void TestAddingSecondUnitWithThreeOfUnitTypeAllowedForTwoOfUnitTypeRequiredAndOneUnitOfTypeFails()
176 {
177 Army army = new Army(mockRace, "Test", 1000);
178 AddUnitOfTypeToArmy(unitType2, army);
179 AddUnitOfTypeToArmy(unitType1, army);
180 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
181 req.AddUnitTypeRequirement(unitType2, 2, 3);
182 Unit unit = CreateUnitOfType(unitType1, army);
183 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Failed));
184 Assert.That(req.GetAllowsAddingMessage(unit.UnitType, army), Is.EqualTo("Army must contain: 2 × " + unitType2.Name + " for every 3 × " + unitType1.Name + " (would have 1 for 2)."));
185 }
186
187 [Test()]
188 public void TestAddingFourthUnitWithThreeOfUnitTypeAllowedForTwoOfUnitTypeRequiredAndThreeUnitsOfTypeFails()
189 {
190 Army army = new Army(mockRace, "Test", 1000);
191 AddUnitsOfTypeToArmy(3, unitType2, army);
192 AddUnitsOfTypeToArmy(3, unitType1, army);
193 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
194 req.AddUnitTypeRequirement(unitType2, 2, 3);
195 Unit unit = CreateUnitOfType(unitType1, army);
196 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Failed));
197 Assert.That(req.GetAllowsAddingMessage(unit.UnitType, army), Is.EqualTo("Army must contain: 2 × " + unitType2.Name + " for every 3 × " + unitType1.Name + " (would have 3 for 4)."));
198 }
199
200 [Test()]
201 public void TestAddingUnrelatedUnitWithNoUnitsAndTwoCombinedUnitTypesRequiredIsNA()
202 {
203 Army army = new Army(mockRace, "Test", 1000);
204 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
205 req.AddUnitTypeRequirement(unitType2, unitType3);
206 Unit unit = CreateUnitOfType(unitType4, army);
207 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.NotApplicable));
208 Assert.That(req.GetAllowsAddingMessage(unit.UnitType, army), Is.Empty);
209 }
210
211 [Test()]
212 public void TestAddingOneUnitWithTwoUnitTypeComboRequiredAndUnitOfOneTypePasses()
213 {
214 Army army = new Army(mockRace, "Test", 1000);
215 AddUnitOfTypeToArmy(unitType2, army);
216 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
217 req.AddUnitTypeRequirement(unitType2, unitType3);
218 Unit unit = CreateUnitOfType(unitType1, army);
219 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Passed));
220 Assert.That(req.GetAllowsAddingMessage(unit.UnitType, army), Is.Empty);
221 }
222
223 [Test()]
224 public void TestAddingOneUnitWithTwoUnitTypeComboRequiredAndUnitOfOtherTypePasses()
225 {
226 Army army = new Army(mockRace, "Test", 1000);
227 AddUnitOfTypeToArmy(unitType3, army);
228 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
229 req.AddUnitTypeRequirement(unitType2, unitType3);
230 Unit unit = CreateUnitOfType(unitType1, army);
231 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Passed));
232 Assert.That(req.GetAllowsAddingMessage(unit.UnitType, army), Is.Empty);
233 }
234
235 [Test()]
236 public void TestAddingTwoUnitsWithTwoUnitTypeComboRequiredAndOneUnitOfBothTypesPasses()
237 {
238 Army army = new Army(mockRace, "Test", 1000);
239 AddUnitOfTypeToArmy(unitType3, army);
240 AddUnitOfTypeToArmy(unitType2, army);
241 AddUnitOfTypeToArmy(unitType1, army);
242 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
243 req.AddUnitTypeRequirement(unitType2, unitType3);
244 Unit unit = CreateUnitOfType(unitType1, army);
245 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Passed));
246 Assert.That(req.GetAllowsAddingMessage(unit.UnitType, army), Is.Empty);
247 }
248
249 [Test()]
250 public void TestAddingTwoUnitsWithTwoUnitTypeComboRequiredAndTwoUnitsOfOneTypePasses()
251 {
252 Army army = new Army(mockRace, "Test", 1000);
253 AddUnitOfTypeToArmy(unitType3, army);
254 AddUnitOfTypeToArmy(unitType3, army);
255 AddUnitOfTypeToArmy(unitType1, army);
256 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
257 req.AddUnitTypeRequirement(unitType2, unitType3);
258 Unit unit = CreateUnitOfType(unitType1, army);
259 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Passed));
260 Assert.That(req.GetAllowsAddingMessage(unit.UnitType, army), Is.Empty);
261 }
262
263 [Test()]
264 public void TestAddingTwoUnitsWithTwoUnitTypeComboRequiredAndTwoUnitsOfOtherTypePasses()
265 {
266 Army army = new Army(mockRace, "Test", 1000);
267 AddUnitOfTypeToArmy(unitType2, army);
268 AddUnitOfTypeToArmy(unitType2, army);
269 AddUnitOfTypeToArmy(unitType1, army);
270 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
271 req.AddUnitTypeRequirement(unitType2, unitType3);
272 Unit unit = CreateUnitOfType(unitType1, army);
273 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Passed));
274 Assert.That(req.GetAllowsAddingMessage(unit.UnitType, army), Is.Empty);
275 }
276
277 [Test()]
278 public void TestAddingThreeUnitsWithTwoUnitTypeComboRequiredAndOneUnitOfBothTypesFails()
279 {
280 Army army = new Army(mockRace, "Test", 1000);
281 AddUnitOfTypeToArmy(unitType3, army);
282 AddUnitOfTypeToArmy(unitType2, army);
283 AddUnitOfTypeToArmy(unitType1, army);
284 AddUnitOfTypeToArmy(unitType1, army);
285 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
286 req.AddUnitTypeRequirement(unitType2, unitType3);
287 Unit unit = CreateUnitOfType(unitType1, army);
288 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Failed));
289 Assert.That(req.GetAllowsAddingMessage(unit.UnitType, army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " or " + unitType3.Name + " for every 1 × " + unitType1.Name + " (would have 2 for 3)."));
290 }
291
292 [Test()]
293 public void TestAddingThreeUnitsWithTwoUnitTypeComboRequiredAndTwoUnitsOfOneTypeFails()
294 {
295 Army army = new Army(mockRace, "Test", 1000);
296 AddUnitOfTypeToArmy(unitType3, army);
297 AddUnitOfTypeToArmy(unitType3, army);
298 AddUnitOfTypeToArmy(unitType1, army);
299 AddUnitOfTypeToArmy(unitType1, army);
300 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
301 req.AddUnitTypeRequirement(unitType2, unitType3);
302 Unit unit = CreateUnitOfType(unitType1, army);
303 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Failed));
304 Assert.That(req.GetAllowsAddingMessage(unit.UnitType, army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " or " + unitType3.Name + " for every 1 × " + unitType1.Name + " (would have 2 for 3)."));
305 }
306
307 [Test()]
308 public void TestAddingThreeUnitsWithTwoUnitTypeComboRequiredAndTwoUnitsOfOtherTypeFails()
309 {
310 Army army = new Army(mockRace, "Test", 1000);
311 AddUnitOfTypeToArmy(unitType2, army);
312 AddUnitOfTypeToArmy(unitType2, army);
313 AddUnitOfTypeToArmy(unitType1, army);
314 AddUnitOfTypeToArmy(unitType1, army);
315 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
316 req.AddUnitTypeRequirement(unitType2, unitType3);
317 Unit unit = CreateUnitOfType(unitType1, army);
318 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Failed));
319 Assert.That(req.GetAllowsAddingMessage(unit.UnitType, army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " or " + unitType3.Name + " for every 1 × " + unitType1.Name + " (would have 2 for 3)."));
320 }
321
322 [Test()]
323 public void TestAddingUnrelatedUnitWithNoUnitsAndThreeForEachTwoCombinedUnitTypesRequiredIsNA()
324 {
325 Army army = new Army(mockRace, "Test", 1000);
326 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
327 req.AddUnitTypeRequirement(3, unitType2, unitType3);
328 Unit unit = CreateUnitOfType(unitType4, army);
329 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.NotApplicable));
330 Assert.That(req.GetAllowsAddingMessage(unit.UnitType, army), Is.Empty);
331 }
332
333 [Test()]
334 public void TestAddingThirdUnitWithThreeForEachTwoUnitTypeComboRequiredAndUnitOfOneTypePasses()
335 {
336 Army army = new Army(mockRace, "Test", 1000);
337 AddUnitOfTypeToArmy(unitType2, army);
338 AddUnitsOfTypeToArmy(2, unitType1, army);
339 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
340 req.AddUnitTypeRequirement(3, unitType2, unitType3);
341 Unit unit = CreateUnitOfType(unitType1, army);
342 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Passed));
343 Assert.That(req.GetAllowsAddingMessage(unit.UnitType, army), Is.Empty);
344 }
345
346 [Test()]
347 public void TestAddingThirdUnitWithThreeForEachTwoUnitTypeComboRequiredAndUnitOfOtherTypePasses()
348 {
349 Army army = new Army(mockRace, "Test", 1000);
350 AddUnitOfTypeToArmy(unitType3, army);
351 AddUnitsOfTypeToArmy(2, unitType1, army);
352 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
353 req.AddUnitTypeRequirement(3, unitType2, unitType3);
354 Unit unit = CreateUnitOfType(unitType1, army);
355 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Passed));
356 Assert.That(req.GetAllowsAddingMessage(unit.UnitType, army), Is.Empty);
357 }
358
359 [Test()]
360 public void TestAddingSixthUnitWithThreeForEachTwoUnitTypeComboRequiredAndOneUnitOfBothTypesPasses()
361 {
362 Army army = new Army(mockRace, "Test", 1000);
363 AddUnitOfTypeToArmy(unitType3, army);
364 AddUnitOfTypeToArmy(unitType2, army);
365 AddUnitsOfTypeToArmy(5, unitType1, army);
366 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
367 req.AddUnitTypeRequirement(3, unitType2, unitType3);
368 Unit unit = CreateUnitOfType(unitType1, army);
369 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Passed));
370 Assert.That(req.GetAllowsAddingMessage(unit.UnitType, army), Is.Empty);
371 }
372
373 [Test()]
374 public void TestAddingSixthUnitWithThreeForEachTwoUnitTypeComboRequiredAndTwoUnitsOfOneTypePasses()
375 {
376 Army army = new Army(mockRace, "Test", 1000);
377 AddUnitsOfTypeToArmy(2, unitType3, army);
378 AddUnitsOfTypeToArmy(5, unitType1, army);
379 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
380 req.AddUnitTypeRequirement(3, unitType2, unitType3);
381 Unit unit = CreateUnitOfType(unitType1, army);
382 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Passed));
383 Assert.That(req.GetAllowsAddingMessage(unit.UnitType, army), Is.Empty);
384 }
385
386 [Test()]
387 public void TestAddingSixthUnitWithThreeForEachTwoUnitTypeComboRequiredAndTwoUnitsOfOtherTypePasses()
388 {
389 Army army = new Army(mockRace, "Test", 1000);
390 AddUnitsOfTypeToArmy(2, unitType2, army);
391 AddUnitsOfTypeToArmy(5, unitType1, army);
392 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
393 req.AddUnitTypeRequirement(3, unitType2, unitType3);
394 Unit unit = CreateUnitOfType(unitType1, army);
395 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Passed));
396 Assert.That(req.GetAllowsAddingMessage(unit.UnitType, army), Is.Empty);
397 }
398
399 [Test()]
400 public void TestAddingSevenUnitsWithThreeForEachTwoUnitTypeComboRequiredAndOneUnitOfBothTypesFails()
401 {
402 Army army = new Army(mockRace, "Test", 1000);
403 AddUnitOfTypeToArmy(unitType3, army);
404 AddUnitOfTypeToArmy(unitType2, army);
405 AddUnitsOfTypeToArmy(6, unitType1, army);
406 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
407 req.AddUnitTypeRequirement(3, unitType2, unitType3);
408 Unit unit = CreateUnitOfType(unitType1, army);
409 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Failed));
410 Assert.That(req.GetAllowsAddingMessage(unit.UnitType, army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " or " + unitType3.Name + " for every 3 × " + unitType1.Name + " (would have 2 for 7)."));
411 }
412
413 [Test()]
414 public void TestAddingSevenUnitsWithThreeForEachTwoUnitTypeComboRequiredAndTwoUnitsOfOneTypeFails()
415 {
416 Army army = new Army(mockRace, "Test", 1000);
417 AddUnitsOfTypeToArmy(2, unitType3, army);
418 AddUnitsOfTypeToArmy(6, unitType1, army);
419 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
420 req.AddUnitTypeRequirement(3, unitType2, unitType3);
421 Unit unit = CreateUnitOfType(unitType1, army);
422 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Failed));
423 Assert.That(req.GetAllowsAddingMessage(unit.UnitType, army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " or " + unitType3.Name + " for every 3 × " + unitType1.Name + " (would have 2 for 7)."));
424 }
425
426 [Test()]
427 public void TestAddingSevenUnitsWithThreeForEachTwoUnitTypeComboRequiredAndTwoUnitsOfOtherTypeFails()
428 {
429 Army army = new Army(mockRace, "Test", 1000);
430 AddUnitsOfTypeToArmy(2, unitType2, army);
431 AddUnitsOfTypeToArmy(6, unitType1, army);
432 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
433 req.AddUnitTypeRequirement(3, unitType2, unitType3);
434 Unit unit = CreateUnitOfType(unitType1, army);
435 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Failed));
436 Assert.That(req.GetAllowsAddingMessage(unit.UnitType, army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " or " + unitType3.Name + " for every 3 × " + unitType1.Name + " (would have 2 for 7)."));
437 }
438
439 [Test()]
440 public void TestValidatingArmyWithNoUnitsAndOneUnitTypeRequiredIsNA()
441 {
442 Army army = new Army(mockRace, "Test", 1000);
443 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1, unitType2);
444 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.NotApplicable));
445 Assert.That(req.GetValidationMessage(army), Is.Empty);
446 }
447
448 [Test()]
449 public void TestValidatingArmyWithOneUnitTypeRequiredAndOneUnitOfTypePasses()
450 {
451 Army army = new Army(mockRace, "Test", 1000);
452 AddUnitOfTypeToArmy(unitType2, army);
453 AddUnitOfTypeToArmy(unitType1, army);
454 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1, unitType2);
455 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Passed));
456 Assert.That(req.GetValidationMessage(army), Is.Empty);
457 }
458
459 [Test()]
460 public void TestValidatingArmyWithOneUnitTypeRequiredAndNoUnitOfTypeFails()
461 {
462 Army army = new Army(mockRace, "Test", 1000);
463 AddUnitOfTypeToArmy(unitType1, army);
464 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1, unitType2);
465 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Failed));
466 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " for every 1 × " + unitType1.Name + " (have 0 for 1)."));
467 }
468
469 [Test()]
470 public void TestValidatingArmyWithTwoDifferentUnitTypesRequiredAndNoUnitOfOneTypeFails()
471 {
472 Army army = new Army(mockRace, "Test", 1000);
473 AddUnitOfTypeToArmy(unitType2, army);
474 AddUnitOfTypeToArmy(unitType1, army);
475 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
476 req.AddUnitTypeRequirement(unitType2);
477 req.AddUnitTypeRequirement(unitType3);
478 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Failed));
479 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 1 × " + unitType3.Name + " for every 1 × " + unitType1.Name + " (have 0 for 1)."));
480 }
481
482 [Test()]
483 public void TestValidatingArmyWithTwoUnitsAndOneUnitTypeRequiredAndOneUnitOfTypeFails()
484 {
485 Army army = new Army(mockRace, "Test", 1000);
486 AddUnitOfTypeToArmy(unitType2, army);
487 AddUnitOfTypeToArmy(unitType1, army);
488 AddUnitOfTypeToArmy(unitType1, army);
489 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1, unitType2);
490 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Failed));
491 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " for every 1 × " + unitType1.Name + " (have 1 for 2)."));
492 }
493
494 [Test()]
495 public void TestValidatingArmyWithTwoUnitsAndTwoOfUnitTypeAllowedForOneUnitTypeRequiredAndOneUnitOfTypePasses()
496 {
497 Army army = new Army(mockRace, "Test", 1000);
498 AddUnitOfTypeToArmy(unitType2, army);
499 AddUnitOfTypeToArmy(unitType1, army);
500 AddUnitOfTypeToArmy(unitType1, army);
501 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
502 req.AddUnitTypeRequirement(unitType2, 1, 2);
503 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Passed));
504 Assert.That(req.GetValidationMessage(army), Is.Empty);
505 }
506
507 [Test()]
508 public void TestValidatingArmyWithTwoUnitsWithTwoAllowedAndOneAllowedForDifferentTypesFails()
509 {
510 Army army = new Army(mockRace, "Test", 1000);
511 AddUnitOfTypeToArmy(unitType2, army);
512 AddUnitOfTypeToArmy(unitType3, army);
513 AddUnitOfTypeToArmy(unitType1, army);
514 AddUnitOfTypeToArmy(unitType1, army);
515 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
516 req.AddUnitTypeRequirement(unitType2, 1, 2);
517 req.AddUnitTypeRequirement(unitType3, 1, 1);
518 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Failed));
519 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 1 × " + unitType3.Name + " for every 1 × " + unitType1.Name + " (have 1 for 2)."));
520 }
521
522 [Test()]
523 public void TestValidatingArmyWithTwoUnitsWithOneAllowedForTwoTypesFails()
524 {
525 Army army = new Army(mockRace, "Test", 1000);
526 AddUnitOfTypeToArmy(unitType2, army);
527 AddUnitOfTypeToArmy(unitType3, army);
528 AddUnitOfTypeToArmy(unitType1, army);
529 AddUnitOfTypeToArmy(unitType1, army);
530 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
531 req.AddUnitTypeRequirement(unitType2, 1, 1);
532 req.AddUnitTypeRequirement(unitType3, 1, 1);
533 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Failed));
534 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " for every 1 × " + unitType1.Name + " (have 1 for 2); 1 × " + unitType3.Name + " for every 1 × " + unitType1.Name + " (have 1 for 2)."));
535 }
536
537 [Test()]
538 public void TestValidatingArmyWithTwoUnitsWithOneAllowedForTwoTypesFails_ShorthandMethod()
539 {
540 Army army = new Army(mockRace, "Test", 1000);
541 AddUnitOfTypeToArmy(unitType2, army);
542 AddUnitOfTypeToArmy(unitType3, army);
543 AddUnitOfTypeToArmy(unitType1, army);
544 AddUnitOfTypeToArmy(unitType1, army);
545 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1, unitType2, unitType3);
546 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Failed));
547 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " for every 1 × " + unitType1.Name + " (have 1 for 2); 1 × " + unitType3.Name + " for every 1 × " + unitType1.Name + " (have 1 for 2)."));
548 }
549
550 [Test()]
551 public void TestValidatingArmyWithOneUnitWithThreeOfUnitTypeAllowedForTwoOfUnitTypeRequiredAndOneUnitOfTypeFails()
552 {
553 Army army = new Army(mockRace, "Test", 1000);
554 AddUnitOfTypeToArmy(unitType2, army);
555 AddUnitOfTypeToArmy(unitType1, army);
556 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
557 req.AddUnitTypeRequirement(unitType2, 2, 3);
558 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Failed));
559 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 2 × " + unitType2.Name + " for every 3 × " + unitType1.Name + " (have 1 for 1)."));
560 }
561
562 [Test()]
563 public void TestValidatingArmyWithTwoUnitsWithThreeOfUnitTypeAllowedForTwoOfUnitTypeRequiredAndOneUnitOfTypeFails()
564 {
565 Army army = new Army(mockRace, "Test", 1000);
566 AddUnitOfTypeToArmy(unitType2, army);
567 AddUnitsOfTypeToArmy(2, unitType1, army);
568 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
569 req.AddUnitTypeRequirement(unitType2, 2, 3);
570 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Failed));
571 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 2 × " + unitType2.Name + " for every 3 × " + unitType1.Name + " (have 1 for 2)."));
572 }
573
574 [Test()]
575 public void TestValidatingArmyWithFourUnitsWithThreeOfUnitTypeAllowedForTwoOfUnitTypeRequiredAndThreeUnitsOfTypeFails()
576 {
577 Army army = new Army(mockRace, "Test", 1000);
578 AddUnitsOfTypeToArmy(3, unitType2, army);
579 AddUnitsOfTypeToArmy(4, unitType1, army);
580 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
581 req.AddUnitTypeRequirement(unitType2, 2, 3);
582 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Failed));
583 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 2 × " + unitType2.Name + " for every 3 × " + unitType1.Name + " (have 3 for 4)."));
584 }
585
586 [Test()]
587 public void TestValidatingArmyWithThreeUnitsAndTwoOfUnitTypeAllowedForOneUnitTypeRequiredAndOneUnitOfTypeFails()
588 {
589 Army army = new Army(mockRace, "Test", 1000);
590 AddUnitOfTypeToArmy(unitType2, army);
591 AddUnitOfTypeToArmy(unitType1, army);
592 AddUnitOfTypeToArmy(unitType1, army);
593 AddUnitOfTypeToArmy(unitType1, army);
594 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
595 req.AddUnitTypeRequirement(unitType2, 1, 2);
596 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Failed));
597 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " for every 2 × " + unitType1.Name + " (have 1 for 3)."));
598 }
599
600 [Test()]
601 public void TestValidatingArmyWithNoUnitsAndThreeForEachTwoCombinedUnitTypesRequiredIsNA()
602 {
603 Army army = new Army(mockRace, "Test", 1000);
604 AddUnitOfTypeToArmy(unitType4, army);
605 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
606 req.AddUnitTypeRequirement(3, unitType2, unitType3);
607 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.NotApplicable));
608 Assert.That(req.GetValidationMessage(army), Is.Empty);
609 }
610
611 [Test()]
612 public void TestValidatingArmyWithThreeUnitsWithThreeForEachTwoUnitTypeComboRequiredAndUnitOfOneTypePasses()
613 {
614 Army army = new Army(mockRace, "Test", 1000);
615 AddUnitOfTypeToArmy(unitType2, army);
616 AddUnitsOfTypeToArmy(3, unitType1, army);
617 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
618 req.AddUnitTypeRequirement(3, unitType2, unitType3);
619 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Passed));
620 Assert.That(req.GetValidationMessage(army), Is.Empty);
621 }
622
623 [Test()]
624 public void TestValidatingArmyWithThreeUnitsWithThreeForEachTwoUnitTypeComboRequiredAndUnitOfOtherTypePasses()
625 {
626 Army army = new Army(mockRace, "Test", 1000);
627 AddUnitOfTypeToArmy(unitType3, army);
628 AddUnitsOfTypeToArmy(3, unitType1, army);
629 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
630 req.AddUnitTypeRequirement(3, unitType2, unitType3);
631 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Passed));
632 Assert.That(req.GetValidationMessage(army), Is.Empty);
633 }
634
635 [Test()]
636 public void TestValidatingArmyWithSixUnitsWithThreeForEachTwoUnitTypeComboRequiredAndOneUnitOfBothTypesPasses()
637 {
638 Army army = new Army(mockRace, "Test", 1000);
639 AddUnitOfTypeToArmy(unitType3, army);
640 AddUnitOfTypeToArmy(unitType2, army);
641 AddUnitsOfTypeToArmy(6, unitType1, army);
642 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
643 req.AddUnitTypeRequirement(3, unitType2, unitType3);
644 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Passed));
645 Assert.That(req.GetValidationMessage(army), Is.Empty);
646 }
647
648 [Test()]
649 public void TestValidatingArmyWithSixUnitsWithThreeForEachTwoUnitTypeComboRequiredAndTwoUnitsOfOneTypePasses()
650 {
651 Army army = new Army(mockRace, "Test", 1000);
652 AddUnitsOfTypeToArmy(2, unitType3, army);
653 AddUnitsOfTypeToArmy(6, unitType1, army);
654 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
655 req.AddUnitTypeRequirement(3, unitType2, unitType3);
656 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Passed));
657 Assert.That(req.GetValidationMessage(army), Is.Empty);
658 }
659
660 [Test()]
661 public void TestValidatingArmyWithSixUnitsWithThreeForEachTwoUnitTypeComboRequiredAndTwoUnitsOfOtherTypePasses()
662 {
663 Army army = new Army(mockRace, "Test", 1000);
664 AddUnitsOfTypeToArmy(2, unitType2, army);
665 AddUnitsOfTypeToArmy(6, unitType1, army);
666 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
667 req.AddUnitTypeRequirement(3, unitType2, unitType3);
668 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Passed));
669 Assert.That(req.GetValidationMessage(army), Is.Empty);
670 }
671
672 [Test()]
673 public void TestValidatingArmyWithSevenUnitsWithThreeForEachTwoUnitTypeComboRequiredAndOneUnitOfBothTypesFails()
674 {
675 Army army = new Army(mockRace, "Test", 1000);
676 AddUnitOfTypeToArmy(unitType3, army);
677 AddUnitOfTypeToArmy(unitType2, army);
678 AddUnitsOfTypeToArmy(7, unitType1, army);
679 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
680 req.AddUnitTypeRequirement(3, unitType2, unitType3);
681 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Failed));
682 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " or " + unitType3.Name + " for every 3 × " + unitType1.Name + " (have 2 for 7)."));
683 }
684
685 [Test()]
686 public void TestValidatingArmyWithSevenUnitsWithThreeForEachTwoUnitTypeComboRequiredAndTwoUnitsOfOneTypeFails()
687 {
688 Army army = new Army(mockRace, "Test", 1000);
689 AddUnitsOfTypeToArmy(2, unitType3, army);
690 AddUnitsOfTypeToArmy(7, unitType1, army);
691 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
692 req.AddUnitTypeRequirement(3, unitType2, unitType3);
693 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Failed));
694 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " or " + unitType3.Name + " for every 3 × " + unitType1.Name + " (have 2 for 7)."));
695 }
696
697 [Test()]
698 public void TestValidatingArmyWithSevenUnitsWithThreeForEachTwoUnitTypeComboRequiredAndTwoUnitsOfOtherTypeFails()
699 {
700 Army army = new Army(mockRace, "Test", 1000);
701 AddUnitsOfTypeToArmy(2, unitType2, army);
702 AddUnitsOfTypeToArmy(7, unitType1, army);
703 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType1);
704 req.AddUnitTypeRequirement(3, unitType2, unitType3);
705 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Failed));
706 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " or " + unitType3.Name + " for every 3 × " + unitType1.Name + " (have 2 for 7)."));
707 }
708
709 private static void AddUnitsOfTypeToArmy(int count, UnitType unitType, Army army)
710 {
711 for (int i = 0; i < count; i++)
712 {
713 AddUnitOfTypeToArmy(unitType, army);
714 }
715 }
716
717 private static void AddUnitOfTypeToArmy(UnitType unitType, Army army)
718 {
719 army.AddUnit(CreateUnitOfType(unitType, army));
720 }
721
722 private static Unit CreateUnitOfType(UnitType unitType, Army army)
723 {
724 return new Unit(unitType, army.GetCategory(unitType.MainCategory));
725 }
726
727 public override RequiresNUnitsForMObjectsRequirement<UnitType> GetObject()
728 {
729 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType3);
730 req.AddUnitTypeRequirement(unitType1, 2, 3);
731 return req;
732 }
733
734 public override RequiresNUnitsForMObjectsRequirement<UnitType> GetSameObject()
735 {
736 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType3);
737 req.AddUnitTypeRequirement(unitType1, 2, 3);
738 return req;
739 }
740
741 public override RequiresNUnitsForMObjectsRequirement<UnitType> GetDifferentObject()
742 {
743 RequiresNUnitsForMObjectsRequirement<UnitType> req = CreateRequirement(unitType3);
744 DummyWarFoundryFactory factory = new DummyWarFoundryFactory();
745 GameSystem gameSystem = new GameSystem("system", "system", factory);
746 Race race = new Race("race", "race", gameSystem, factory);
747 req.AddUnitTypeRequirement(new UnitType("id2", "Type 2", race), 2, 3);
748 return req;
749 }
750
751 protected abstract RequiresNUnitsForMObjectsRequirement<UnitType> CreateRequirement(UnitType allowedType, params UnitType[] requiredUnitTypes);
752 }
753 }
754