Mercurial > repos > IBBoard.WarFoundry.API.Tests

comparison API/Objects/Requirement/RequiresAtLeastNUnitsRequirementTest.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 0762766bd3f2
children
comparison
equal deleted inserted replaced
207:27f163bf884a 208:c323770e61c2
10 using IBBoard.WarFoundry.API.Factories; 10 using IBBoard.WarFoundry.API.Factories;
11 11
12 namespace IBBoard.WarFoundry.API.Objects.Requirement 12 namespace IBBoard.WarFoundry.API.Objects.Requirement
13 { 13 {
14 [TestFixture()] 14 [TestFixture()]
15 public class RequiresAtLeastNUnitsRequirementTest : AbstractEqualityTest<RequiresAtLeastNUnitsRequirement> 15 public class RequiresAtLeastNUnitsRequirementTest : AbstractEqualityTest<RequiresAtLeastNUnitsRequirement<UnitType>>
16 { 16 {
17 private MockRace mockRace; 17 private MockRace mockRace;
18 private UnitType allowedUnitType;
18 private UnitType unitType1; 19 private UnitType unitType1;
19 private UnitType unitType2; 20 private UnitType unitType2;
20 private UnitType unitType3; 21 private UnitType unitType3;
21 22
22 [TestFixtureSetUp()] 23 [TestFixtureSetUp()]
23 public void SetupRace() 24 public void SetupRace()
24 { 25 {
25 mockRace = new MockRace(); 26 mockRace = new MockRace();
27 allowedUnitType = new MockUnitType("allowed", "Allowed Type");
28 mockRace.AddUnitType(allowedUnitType);
26 unitType1 = new MockUnitType("type1", "Unit Type 1"); 29 unitType1 = new MockUnitType("type1", "Unit Type 1");
27 mockRace.AddUnitType(unitType1); 30 mockRace.AddUnitType(unitType1);
28 unitType2 = new MockUnitType("type2", "Unit Type 2"); 31 unitType2 = new MockUnitType("type2", "Unit Type 2");
29 mockRace.AddUnitType(unitType2); 32 mockRace.AddUnitType(unitType2);
30 unitType3 = new MockUnitType("type3", "Unit Type 3"); 33 unitType3 = new MockUnitType("type3", "Unit Type 3");
34 [Test()] 37 [Test()]
35 public void TestAddingUnrelatedUnitWithNoUnitsAndOneUnitTypeRequired() 38 public void TestAddingUnrelatedUnitWithNoUnitsAndOneUnitTypeRequired()
36 { 39 {
37 Army army = new Army(mockRace, "Test", 1000); 40 Army army = new Army(mockRace, "Test", 1000);
38 Unit unit = CreateUnitOfType(unitType1, army); 41 Unit unit = CreateUnitOfType(unitType1, army);
39 RequiresAtLeastNUnitsRequirement req = new RequiresAtLeastNUnitsRequirement(unitType2); 42 RequiresAtLeastNUnitsRequirement<UnitType> req = new RequiresAtLeastNUnitsRequirement<UnitType>(allowedUnitType, unitType2);
40 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.NotApplicable)); 43 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.NotApplicable));
41 } 44 }
42 45
43 [Test()] 46 [Test()]
44 public void TestAddingOneUnitWithOneUnitTypeRequired() 47 public void TestAddingOneUnitWithOneUnitTypeRequired()
45 { 48 {
46 Army army = new Army(mockRace, "Test", 1000); 49 Army army = new Army(mockRace, "Test", 1000);
47 Unit unit = CreateUnitOfType(unitType1, army); 50 Unit unit = CreateUnitOfType(unitType1, army);
48 RequiresAtLeastNUnitsRequirement req = new RequiresAtLeastNUnitsRequirement(unitType1); 51 RequiresAtLeastNUnitsRequirement<UnitType> req = new RequiresAtLeastNUnitsRequirement<UnitType>(allowedUnitType, unitType1);
49 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Passed)); 52 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Passed));
50 } 53 }
51 54
52 [Test()] 55 [Test()]
53 public void TestAddingUnitWithOneUnitAndTwoOfUnitTypeRequired() 56 public void TestAddingUnitWithOneUnitAndTwoOfUnitTypeRequired()
54 { 57 {
55 Army army = new Army(mockRace, "Test", 1000); 58 Army army = new Army(mockRace, "Test", 1000);
56 RequiresAtLeastNUnitsRequirement req = new RequiresAtLeastNUnitsRequirement(); 59 RequiresAtLeastNUnitsRequirement<UnitType> req = new RequiresAtLeastNUnitsRequirement<UnitType>(allowedUnitType);
57 req.AddUnitTypeRequirement(unitType1, 2); 60 req.AddUnitTypeRequirement(unitType1, 2);
58 AddUnitOfTypeToArmy(unitType1, army); 61 AddUnitOfTypeToArmy(unitType1, army);
59 Unit unit = CreateUnitOfType(unitType1, army); 62 Unit unit = CreateUnitOfType(unitType1, army);
60 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Passed)); 63 Assert.That(req.AllowsAdding(unit, army), Is.EqualTo(Validation.Passed));
61 } 64 }
62 65
63 [Test()] 66 [Test()]
64 public void TestAddingUnrelatedUnitTypeWithNoUnitsAndOneUnitTypeRequired() 67 public void TestAddingUnrelatedUnitTypeWithNoUnitsAndOneUnitTypeRequired()
65 { 68 {
66 Army army = new Army(mockRace, "Test", 1000); 69 Army army = new Army(mockRace, "Test", 1000);
67 RequiresAtLeastNUnitsRequirement req = new RequiresAtLeastNUnitsRequirement(unitType2); 70 RequiresAtLeastNUnitsRequirement<UnitType> req = new RequiresAtLeastNUnitsRequirement<UnitType>(allowedUnitType, unitType2);
68 Assert.That(req.AllowsAdding(unitType1, army), Is.EqualTo(Validation.NotApplicable)); 71 Assert.That(req.AllowsAdding(unitType1, army), Is.EqualTo(Validation.NotApplicable));
69 } 72 }
70 73
71 [Test()] 74 [Test()]
72 public void TestAddingUnitTypeWithNoUnitsAndOneUnitTypeRequired() 75 public void TestAddingUnitTypeWithNoUnitsAndOneUnitTypeRequired()
73 { 76 {
74 Army army = new Army(mockRace, "Test", 1000); 77 Army army = new Army(mockRace, "Test", 1000);
75 RequiresAtLeastNUnitsRequirement req = new RequiresAtLeastNUnitsRequirement(unitType1); 78 RequiresAtLeastNUnitsRequirement<UnitType> req = new RequiresAtLeastNUnitsRequirement<UnitType>(allowedUnitType, unitType1);
76 Assert.That(req.AllowsAdding(unitType1, army), Is.EqualTo(Validation.Passed)); 79 Assert.That(req.AllowsAdding(unitType1, army), Is.EqualTo(Validation.Passed));
77 } 80 }
78 81
79 [Test()] 82 [Test()]
80 public void TestAddingUnitTypeWithOneUnitAndOneUnitTypeRequired() 83 public void TestAddingUnitTypeWithOneUnitAndOneUnitTypeRequired()
81 { 84 {
82 Army army = new Army(mockRace, "Test", 1000); 85 Army army = new Army(mockRace, "Test", 1000);
83 AddUnitOfTypeToArmy(unitType1, army); 86 AddUnitOfTypeToArmy(unitType1, army);
84 RequiresAtLeastNUnitsRequirement req = new RequiresAtLeastNUnitsRequirement(unitType1); 87 RequiresAtLeastNUnitsRequirement<UnitType> req = new RequiresAtLeastNUnitsRequirement<UnitType>(allowedUnitType, unitType1);
85 Assert.That(req.AllowsAdding(unitType1, army), Is.EqualTo(Validation.Passed)); 88 Assert.That(req.AllowsAdding(unitType1, army), Is.EqualTo(Validation.Passed));
86 } 89 }
87 90
88 [Test()] 91 [Test()]
89 public void TestAddingUnitTypeWithNoUnitsAndTwoUnitTypesRequired() 92 public void TestAddingUnitTypeWithNoUnitsAndTwoUnitTypesRequired()
90 { 93 {
91 Army army = new Army(mockRace, "Test", 1000); 94 Army army = new Army(mockRace, "Test", 1000);
92 RequiresAtLeastNUnitsRequirement req = new RequiresAtLeastNUnitsRequirement(unitType2, unitType3); 95 RequiresAtLeastNUnitsRequirement<UnitType> req = new RequiresAtLeastNUnitsRequirement<UnitType>(allowedUnitType, unitType2, unitType3);
93 Assert.That(req.AllowsAdding(unitType2, army), Is.EqualTo(Validation.Failed)); 96 Assert.That(req.AllowsAdding(unitType2, army), Is.EqualTo(Validation.Failed));
94 } 97 }
95 98
96 [Test()] 99 [Test()]
97 public void TestAddingUnitTypeWithOneUnitAndTwoUnitTypesRequired() 100 public void TestAddingUnitTypeWithOneUnitAndTwoUnitTypesRequired()
98 { 101 {
99 Army army = new Army(mockRace, "Test", 1000); 102 Army army = new Army(mockRace, "Test", 1000);
100 AddUnitOfTypeToArmy(unitType3, army); 103 AddUnitOfTypeToArmy(unitType3, army);
101 RequiresAtLeastNUnitsRequirement req = new RequiresAtLeastNUnitsRequirement(unitType2, unitType3); 104 RequiresAtLeastNUnitsRequirement<UnitType> req = new RequiresAtLeastNUnitsRequirement<UnitType>(allowedUnitType, unitType2, unitType3);
102 Assert.That(req.AllowsAdding(unitType2, army), Is.EqualTo(Validation.Passed)); 105 Assert.That(req.AllowsAdding(unitType2, army), Is.EqualTo(Validation.Passed));
103 } 106 }
104 107
105 [Test()] 108 [Test()]
106 public void TestAddingUnitTypeWithBothUnitsAndTwoUnitTypesRequired() 109 public void TestAddingUnitTypeWithBothUnitsAndTwoUnitTypesRequired()
107 { 110 {
108 Army army = new Army(mockRace, "Test", 1000); 111 Army army = new Army(mockRace, "Test", 1000);
109 AddUnitOfTypeToArmy(unitType2, army); 112 AddUnitOfTypeToArmy(unitType2, army);
110 AddUnitOfTypeToArmy(unitType3, army); 113 AddUnitOfTypeToArmy(unitType3, army);
111 RequiresAtLeastNUnitsRequirement req = new RequiresAtLeastNUnitsRequirement(unitType2, unitType3); 114 RequiresAtLeastNUnitsRequirement<UnitType> req = new RequiresAtLeastNUnitsRequirement<UnitType>(allowedUnitType, unitType2, unitType3);
112 Assert.That(req.AllowsAdding(unitType2, army), Is.EqualTo(Validation.Passed)); 115 Assert.That(req.AllowsAdding(unitType2, army), Is.EqualTo(Validation.Passed));
113 } 116 }
114 117
115 [Test()] 118 [Test()]
116 public void TestAddingOneOfUnitTypeWithTwoOfOneUnitTypeRequired() 119 public void TestAddingOneOfUnitTypeWithTwoOfOneUnitTypeRequired()
117 { 120 {
118 Army army = new Army(mockRace, "Test", 1000); 121 Army army = new Army(mockRace, "Test", 1000);
119 RequiresAtLeastNUnitsRequirement req = new RequiresAtLeastNUnitsRequirement(); 122 RequiresAtLeastNUnitsRequirement<UnitType> req = new RequiresAtLeastNUnitsRequirement<UnitType>(allowedUnitType);
120 req.AddUnitTypeRequirement(unitType1, 2); 123 req.AddUnitTypeRequirement(unitType1, 2);
121 Assert.That(req.AllowsAdding(unitType1, army), Is.EqualTo(Validation.Failed)); 124 Assert.That(req.AllowsAdding(unitType1, army), Is.EqualTo(Validation.Failed));
122 } 125 }
123 126
124 [Test()] 127 [Test()]
125 public void TestAddingOneUnitTypeWithOneUnitAndTwoOfOneUnitTypeRequired() 128 public void TestAddingOneUnitTypeWithOneUnitAndTwoOfOneUnitTypeRequired()
126 { 129 {
127 Army army = new Army(mockRace, "Test", 1000); 130 Army army = new Army(mockRace, "Test", 1000);
128 AddUnitOfTypeToArmy(unitType1, army); 131 AddUnitOfTypeToArmy(unitType1, army);
129 RequiresAtLeastNUnitsRequirement req = new RequiresAtLeastNUnitsRequirement(); 132 RequiresAtLeastNUnitsRequirement<UnitType> req = new RequiresAtLeastNUnitsRequirement<UnitType>(allowedUnitType);
130 req.AddUnitTypeRequirement(unitType1, 2); 133 req.AddUnitTypeRequirement(unitType1, 2);
131 Assert.That(req.AllowsAdding(unitType1, army), Is.EqualTo(Validation.Passed)); 134 Assert.That(req.AllowsAdding(unitType1, army), Is.EqualTo(Validation.Passed));
132 } 135 }
133 136
134 [Test()] 137 [Test()]
135 public void TestAddingUnitTypeRequirementWithNoNumberDefaultsToHavingOne() 138 public void TestAddingUnitTypeRequirementWithNoNumberDefaultsToHavingOne()
136 { 139 {
137 Army army = new Army(mockRace, "Test", 1000); 140 Army army = new Army(mockRace, "Test", 1000);
138 RequiresAtLeastNUnitsRequirement req = new RequiresAtLeastNUnitsRequirement(); 141 RequiresAtLeastNUnitsRequirement<UnitType> req = new RequiresAtLeastNUnitsRequirement<UnitType>(allowedUnitType);
139 req.AddUnitTypeRequirement(unitType1); 142 req.AddUnitTypeRequirement(unitType1);
140 Assert.That(req.AllowsAdding(unitType1, army), Is.EqualTo(Validation.Passed)); 143 Assert.That(req.AllowsAdding(unitType1, army), Is.EqualTo(Validation.Passed));
141 } 144 }
142 145
143 [Test()] 146 [Test()]
144 public void TestValidityOfArmyWithNoUnitsAndOneUnitTypeRequired() 147 public void TestValidityOfArmyWithNoUnitsAndOneUnitTypeRequired()
145 { 148 {
146 Army army = new Army(mockRace, "Test", 1000); 149 Army army = new Army(mockRace, "Test", 1000);
147 RequiresAtLeastNUnitsRequirement req = new RequiresAtLeastNUnitsRequirement(unitType1); 150 RequiresAtLeastNUnitsRequirement<UnitType> req = new RequiresAtLeastNUnitsRequirement<UnitType>(allowedUnitType, unitType1);
148 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Failed)); 151 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Failed));
149 } 152 }
150 153
151 [Test()] 154 [Test()]
152 public void TestValidityOfArmyWithOneUnitAndOneUnitTypeRequired() 155 public void TestValidityOfArmyWithOneUnitAndOneUnitTypeRequired()
153 { 156 {
154 Army army = new Army(mockRace, "Test", 1000); 157 Army army = new Army(mockRace, "Test", 1000);
155 AddUnitOfTypeToArmy(unitType1, army); 158 AddUnitOfTypeToArmy(unitType1, army);
156 RequiresAtLeastNUnitsRequirement req = new RequiresAtLeastNUnitsRequirement(unitType1); 159 RequiresAtLeastNUnitsRequirement<UnitType> req = new RequiresAtLeastNUnitsRequirement<UnitType>(allowedUnitType, unitType1);
157 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Passed)); 160 Assert.That(req.ValidatesArmy(army), Is.EqualTo(Validation.Passed));
158 } 161 }
159 162
160 [Test] 163 [Test]
161 public void TestAddingMinNumberUnitTypePassesRequirement() 164 public void TestAddingMinNumberUnitTypePassesRequirement()
162 { 165 {
163 Army army = new Army(mockRace, "Test", 1000); 166 Army army = new Army(mockRace, "Test", 1000);
164 RequiresAtLeastNUnitsRequirement req = new RequiresAtLeastNUnitsRequirement(); 167 RequiresAtLeastNUnitsRequirement<UnitType> req = new RequiresAtLeastNUnitsRequirement<UnitType>(allowedUnitType);
165 req.AddUnitTypeRequirement(unitType1, 2); 168 req.AddUnitTypeRequirement(unitType1, 2);
166 Assert.That(req.AllowsAdding(unitType1, army), Is.EqualTo(Validation.Failed)); 169 Assert.That(req.AllowsAdding(unitType1, army), Is.EqualTo(Validation.Failed));
167 AddUnitOfTypeToArmy(unitType1, army); 170 AddUnitOfTypeToArmy(unitType1, army);
168 Assert.That(req.AllowsAdding(unitType1, army), Is.EqualTo(Validation.Passed)); 171 Assert.That(req.AllowsAdding(unitType1, army), Is.EqualTo(Validation.Passed));
169 } 172 }
171 [Test] 174 [Test]
172 public void TestValidationMessageIsBlankForPass() 175 public void TestValidationMessageIsBlankForPass()
173 { 176 {
174 Army army = new Army(mockRace, "Test", 1000); 177 Army army = new Army(mockRace, "Test", 1000);
175 AddUnitOfTypeToArmy(unitType1, army); 178 AddUnitOfTypeToArmy(unitType1, army);
176 RequiresAtLeastNUnitsRequirement req = new RequiresAtLeastNUnitsRequirement(unitType1); 179 RequiresAtLeastNUnitsRequirement<UnitType> req = new RequiresAtLeastNUnitsRequirement<UnitType>(allowedUnitType, unitType1);
177 Assert.That(req.GetValidationMessage(army), Is.Empty); 180 Assert.That(req.GetValidationMessage(army), Is.Empty);
178 } 181 }
179 182
180 [Test] 183 [Test]
181 public void TestValidationMessageIsCorrectForFailWithOneUnitRequired() 184 public void TestValidationMessageIsCorrectForFailWithOneUnitRequired()
182 { 185 {
183 Army army = new Army(mockRace, "Test", 1000); 186 Army army = new Army(mockRace, "Test", 1000);
184 RequiresAtLeastNUnitsRequirement req = new RequiresAtLeastNUnitsRequirement(unitType1); 187 RequiresAtLeastNUnitsRequirement<UnitType> req = new RequiresAtLeastNUnitsRequirement<UnitType>(allowedUnitType, unitType1);
185 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 1 × " + unitType1.Name + " (have 0).")); 188 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 1 × " + unitType1.Name + " (have 0)."));
186 } 189 }
187 190
188 [Test] 191 [Test]
189 public void TestValidationMessageIsCorrectForFailWithTwoOfOneUnitRequired() 192 public void TestValidationMessageIsCorrectForFailWithTwoOfOneUnitRequired()
190 { 193 {
191 Army army = new Army(mockRace, "Test", 1000); 194 Army army = new Army(mockRace, "Test", 1000);
192 RequiresAtLeastNUnitsRequirement req = new RequiresAtLeastNUnitsRequirement(); 195 RequiresAtLeastNUnitsRequirement<UnitType> req = new RequiresAtLeastNUnitsRequirement<UnitType>(allowedUnitType);
193 req.AddUnitTypeRequirement(unitType1, 2); 196 req.AddUnitTypeRequirement(unitType1, 2);
194 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 2 × " + unitType1.Name + " (have 0).")); 197 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 2 × " + unitType1.Name + " (have 0)."));
195 } 198 }
196 199
197 [Test] 200 [Test]
198 public void TestValidationMessageIsCorrectForFailWithTwoUnitsRequired() 201 public void TestValidationMessageIsCorrectForFailWithTwoUnitsRequired()
199 { 202 {
200 Army army = new Army(mockRace, "Test", 1000); 203 Army army = new Army(mockRace, "Test", 1000);
201 RequiresAtLeastNUnitsRequirement req = new RequiresAtLeastNUnitsRequirement(); 204 RequiresAtLeastNUnitsRequirement<UnitType> req = new RequiresAtLeastNUnitsRequirement<UnitType>(allowedUnitType);
202 req.AddUnitTypeRequirement(unitType1); 205 req.AddUnitTypeRequirement(unitType1);
203 req.AddUnitTypeRequirement(unitType2); 206 req.AddUnitTypeRequirement(unitType2);
204 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 1 × " + unitType1.Name + " (have 0); 1 × " + unitType2.Name + " (have 0).")); 207 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 1 × " + unitType1.Name + " (have 0); 1 × " + unitType2.Name + " (have 0)."));
205 } 208 }
206 209
207 [Test] 210 [Test]
208 public void TestValidationMessageIsCorrectForFailWithTwoUnitsRequiredWithOneUnit() 211 public void TestValidationMessageIsCorrectForFailWithTwoUnitsRequiredWithOneUnit()
209 { 212 {
210 Army army = new Army(mockRace, "Test", 1000); 213 Army army = new Army(mockRace, "Test", 1000);
211 AddUnitOfTypeToArmy(unitType1, army); 214 AddUnitOfTypeToArmy(unitType1, army);
212 RequiresAtLeastNUnitsRequirement req = new RequiresAtLeastNUnitsRequirement(); 215 RequiresAtLeastNUnitsRequirement<UnitType> req = new RequiresAtLeastNUnitsRequirement<UnitType>(allowedUnitType);
213 req.AddUnitTypeRequirement(unitType1); 216 req.AddUnitTypeRequirement(unitType1);
214 req.AddUnitTypeRequirement(unitType2); 217 req.AddUnitTypeRequirement(unitType2);
215 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " (have 0).")); 218 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " (have 0)."));
216 } 219 }
217 220
218 [Test] 221 [Test]
219 public void TestValidationMessageIsCorrectForFailWithTwoUnitsRequiredWithOtherUnit() 222 public void TestValidationMessageIsCorrectForFailWithTwoUnitsRequiredWithOtherUnit()
220 { 223 {
221 Army army = new Army(mockRace, "Test", 1000); 224 Army army = new Army(mockRace, "Test", 1000);
222 AddUnitOfTypeToArmy(unitType2, army); 225 AddUnitOfTypeToArmy(unitType2, army);
223 RequiresAtLeastNUnitsRequirement req = new RequiresAtLeastNUnitsRequirement(); 226 RequiresAtLeastNUnitsRequirement<UnitType> req = new RequiresAtLeastNUnitsRequirement<UnitType>(allowedUnitType);
224 req.AddUnitTypeRequirement(unitType1); 227 req.AddUnitTypeRequirement(unitType1);
225 req.AddUnitTypeRequirement(unitType2); 228 req.AddUnitTypeRequirement(unitType2);
226 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 1 × " + unitType1.Name + " (have 0).")); 229 Assert.That(req.GetValidationMessage(army), Is.EqualTo("Army must contain: 1 × " + unitType1.Name + " (have 0)."));
227 } 230 }
228 231
229 [Test] 232 [Test]
230 public void TestAllowsAddingMessageIsBlankForPass() 233 public void TestAllowsAddingMessageIsBlankForPass()
231 { 234 {
232 Army army = new Army(mockRace, "Test", 1000); 235 Army army = new Army(mockRace, "Test", 1000);
233 AddUnitOfTypeToArmy(unitType1, army); 236 AddUnitOfTypeToArmy(unitType1, army);
234 RequiresAtLeastNUnitsRequirement req = new RequiresAtLeastNUnitsRequirement(unitType1); 237 RequiresAtLeastNUnitsRequirement<UnitType> req = new RequiresAtLeastNUnitsRequirement<UnitType>(allowedUnitType, unitType1);
235 Assert.That(req.GetAllowsAddingMessage(unitType1, army), Is.Empty); 238 Assert.That(req.GetAllowsAddingMessage(unitType1, army), Is.Empty);
236 } 239 }
237 240
238 [Test] 241 [Test]
239 public void TestAllowsAddingMessageIsCorrectForFailWithTwoOfOneUnitRequired() 242 public void TestAllowsAddingMessageIsCorrectForFailWithTwoOfOneUnitRequired()
240 { 243 {
241 Army army = new Army(mockRace, "Test", 1000); 244 Army army = new Army(mockRace, "Test", 1000);
242 RequiresAtLeastNUnitsRequirement req = new RequiresAtLeastNUnitsRequirement(); 245 RequiresAtLeastNUnitsRequirement<UnitType> req = new RequiresAtLeastNUnitsRequirement<UnitType>(allowedUnitType);
243 req.AddUnitTypeRequirement(unitType1, 2); 246 req.AddUnitTypeRequirement(unitType1, 2);
244 Assert.That(req.GetAllowsAddingMessage(unitType1, army), Is.EqualTo("Army must contain: 2 × " + unitType1.Name + " (would have 1).")); 247 Assert.That(req.GetAllowsAddingMessage(unitType1, army), Is.EqualTo("Army must contain: 2 × " + unitType1.Name + " (would have 1)."));
245 } 248 }
246 249
247 [Test] 250 [Test]
248 public void TestAllowsAddingMessageIsCorrectForFailWithTwoUnitsRequired() 251 public void TestAllowsAddingMessageIsCorrectForFailWithTwoUnitsRequired()
249 { 252 {
250 Army army = new Army(mockRace, "Test", 1000); 253 Army army = new Army(mockRace, "Test", 1000);
251 RequiresAtLeastNUnitsRequirement req = new RequiresAtLeastNUnitsRequirement(); 254 RequiresAtLeastNUnitsRequirement<UnitType> req = new RequiresAtLeastNUnitsRequirement<UnitType>(allowedUnitType);
252 req.AddUnitTypeRequirement(unitType1); 255 req.AddUnitTypeRequirement(unitType1);
253 req.AddUnitTypeRequirement(unitType2); 256 req.AddUnitTypeRequirement(unitType2);
254 Assert.That(req.GetAllowsAddingMessage(unitType1, army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " (would have 0).")); 257 Assert.That(req.GetAllowsAddingMessage(unitType1, army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " (would have 0)."));
255 } 258 }
256 259
257 [Test] 260 [Test]
258 public void TestAllowsAddingMessageIsCorrectForFailWithTwoUnitsRequiredOtherUnit() 261 public void TestAllowsAddingMessageIsCorrectForFailWithTwoUnitsRequiredOtherUnit()
259 { 262 {
260 Army army = new Army(mockRace, "Test", 1000); 263 Army army = new Army(mockRace, "Test", 1000);
261 RequiresAtLeastNUnitsRequirement req = new RequiresAtLeastNUnitsRequirement(); 264 RequiresAtLeastNUnitsRequirement<UnitType> req = new RequiresAtLeastNUnitsRequirement<UnitType>(allowedUnitType);
262 req.AddUnitTypeRequirement(unitType1); 265 req.AddUnitTypeRequirement(unitType1);
263 req.AddUnitTypeRequirement(unitType2); 266 req.AddUnitTypeRequirement(unitType2);
264 Assert.That(req.GetAllowsAddingMessage(unitType2, army), Is.EqualTo("Army must contain: 1 × " + unitType1.Name + " (would have 0).")); 267 Assert.That(req.GetAllowsAddingMessage(unitType2, army), Is.EqualTo("Army must contain: 1 × " + unitType1.Name + " (would have 0)."));
265 } 268 }
266 269
267 [Test] 270 [Test]
268 public void TestAllowsAddingMessageIsCorrectForFailWithTwoUnitsRequiredWithOneUnit() 271 public void TestAllowsAddingMessageIsCorrectForFailWithTwoUnitsRequiredWithOneUnit()
269 { 272 {
270 Army army = new Army(mockRace, "Test", 1000); 273 Army army = new Army(mockRace, "Test", 1000);
271 AddUnitOfTypeToArmy(unitType1, army); 274 AddUnitOfTypeToArmy(unitType1, army);
272 RequiresAtLeastNUnitsRequirement req = new RequiresAtLeastNUnitsRequirement(); 275 RequiresAtLeastNUnitsRequirement<UnitType> req = new RequiresAtLeastNUnitsRequirement<UnitType>(allowedUnitType);
273 req.AddUnitTypeRequirement(unitType1); 276 req.AddUnitTypeRequirement(unitType1);
274 req.AddUnitTypeRequirement(unitType2); 277 req.AddUnitTypeRequirement(unitType2);
275 Assert.That(req.GetAllowsAddingMessage(unitType1, army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " (would have 0).")); 278 Assert.That(req.GetAllowsAddingMessage(unitType1, army), Is.EqualTo("Army must contain: 1 × " + unitType2.Name + " (would have 0)."));
276 } 279 }
277 280
278 [Test] 281 [Test]
279 public void TestAllowsAddingMessageIsCorrectForFailWithTwoUnitsRequiredWithOtherUnit() 282 public void TestAllowsAddingMessageIsCorrectForFailWithTwoUnitsRequiredWithOtherUnit()
280 { 283 {
281 Army army = new Army(mockRace, "Test", 1000); 284 Army army = new Army(mockRace, "Test", 1000);
282 AddUnitOfTypeToArmy(unitType2, army); 285 AddUnitOfTypeToArmy(unitType2, army);
283 RequiresAtLeastNUnitsRequirement req = new RequiresAtLeastNUnitsRequirement(); 286 RequiresAtLeastNUnitsRequirement<UnitType> req = new RequiresAtLeastNUnitsRequirement<UnitType>(allowedUnitType);
284 req.AddUnitTypeRequirement(unitType1); 287 req.AddUnitTypeRequirement(unitType1);
285 req.AddUnitTypeRequirement(unitType2); 288 req.AddUnitTypeRequirement(unitType2);
286 Assert.That(req.GetAllowsAddingMessage(unitType2, army), Is.EqualTo("Army must contain: 1 × " + unitType1.Name + " (would have 0).")); 289 Assert.That(req.GetAllowsAddingMessage(unitType2, army), Is.EqualTo("Army must contain: 1 × " + unitType1.Name + " (would have 0)."));
287 } 290 }
288 291
294 private static Unit CreateUnitOfType(UnitType unitType, Army army) 297 private static Unit CreateUnitOfType(UnitType unitType, Army army)
295 { 298 {
296 return new Unit(unitType, army.GetCategory(unitType.MainCategory)); 299 return new Unit(unitType, army.GetCategory(unitType.MainCategory));
297 } 300 }
298 301
299 public override RequiresAtLeastNUnitsRequirement GetObject () 302 public override RequiresAtLeastNUnitsRequirement<UnitType> GetObject()
300 { 303 {
301 RequiresAtLeastNUnitsRequirement req = new RequiresAtLeastNUnitsRequirement(); 304 RequiresAtLeastNUnitsRequirement<UnitType> req = new RequiresAtLeastNUnitsRequirement<UnitType>(allowedUnitType);
302 req.AddUnitTypeRequirement(unitType1, 2); 305 req.AddUnitTypeRequirement(unitType1, 2);
303 return req; 306 return req;
304 } 307 }
305 308
306 public override RequiresAtLeastNUnitsRequirement GetSameObject () 309 public override RequiresAtLeastNUnitsRequirement<UnitType> GetSameObject()
307 { 310 {
308 RequiresAtLeastNUnitsRequirement req = new RequiresAtLeastNUnitsRequirement(); 311 RequiresAtLeastNUnitsRequirement<UnitType> req = new RequiresAtLeastNUnitsRequirement<UnitType>(allowedUnitType);
309 req.AddUnitTypeRequirement(unitType1, 2); 312 req.AddUnitTypeRequirement(unitType1, 2);
310 return req; 313 return req;
311 } 314 }
312 315
313 public override RequiresAtLeastNUnitsRequirement GetDifferentObject () 316 public override RequiresAtLeastNUnitsRequirement<UnitType> GetDifferentObject()
314 { 317 {
315 RequiresAtLeastNUnitsRequirement req = new RequiresAtLeastNUnitsRequirement(); 318 RequiresAtLeastNUnitsRequirement<UnitType> req = new RequiresAtLeastNUnitsRequirement<UnitType>(allowedUnitType);
316 DummyWarFoundryFactory factory = new DummyWarFoundryFactory(); 319 DummyWarFoundryFactory factory = new DummyWarFoundryFactory();
317 GameSystem gameSystem = new GameSystem("system", "system", factory); 320 GameSystem gameSystem = new GameSystem("system", "system", factory);
318 Race race = new Race("race", "race", gameSystem, factory); 321 Race race = new Race("race", "race", gameSystem, factory);
319 req.AddUnitTypeRequirement(new UnitType("id2", "Type 2", race), 2); 322 req.AddUnitTypeRequirement(new UnitType("id2", "Type 2", race), 2);
320 return req; 323 return req;