|
18
|
1 // This file (UnitEquipmentItemUtilTest.cs) is a part of the IBBoard.WarFoundry.API.Tests project and is copyright 2009 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
|
|
|
5 using System;
|
|
|
6 using NUnit.Framework;
|
|
|
7 using IBBoard.Limits;
|
|
|
8 using IBBoard.WarFoundry.API.Objects;
|
|
|
9 using IBBoard.WarFoundry.API.Objects.Mock;
|
|
|
10
|
|
|
11 namespace IBBoard.WarFoundry.API.Util
|
|
|
12 {
|
|
|
13 [TestFixture()]
|
|
|
14 public class UnitEquipmentUtilTest
|
|
|
15 {
|
|
26
|
16 private const string SLOT_NAME = "slot";
|
|
|
17
|
|
18
|
18 [Test()]
|
|
24
|
19 public void TestGetEquipmentCountsForFixedLimitItemOnDefaultSlot()
|
|
18
|
20 {
|
|
26
|
21 UnitEquipmentItem equip = new MockNumericAmountUnitEquipmentItem(4);
|
|
18
|
22 UnitType unitType = equip.EquipmentForUnit;
|
|
19
|
23 Unit unit = GetUnit (unitType);
|
|
26
|
24 Assert.AreEqual(4, UnitEquipmentUtil.GetMaxEquipmentCount(unit, equip));
|
|
|
25 Assert.AreEqual(4, UnitEquipmentUtil.GetMinEquipmentCount(unit, equip));
|
|
|
26 Assert.AreEqual(4.0/15*100, UnitEquipmentUtil.GetMaxEquipmentPercentage(unit, equip));
|
|
27
|
27 Assert.AreEqual(4.0/15*100, UnitEquipmentUtil.GetMinEquipmentPercentage(unit, equip));
|
|
18
|
28 }
|
|
|
29
|
|
|
30 [Test()]
|
|
24
|
31 public void TestGetEquipmentCountsForFixedLimitItemOnDefaultSlotWithDifferentMinLimit()
|
|
|
32 {
|
|
26
|
33 UnitEquipmentItem equip = new MockNumericAmountUnitEquipmentItem(1,4);
|
|
24
|
34 UnitType unitType = equip.EquipmentForUnit;
|
|
|
35 Unit unit = GetUnit (unitType);
|
|
26
|
36 Assert.AreEqual(4, UnitEquipmentUtil.GetMaxEquipmentCount(unit, equip));
|
|
24
|
37 Assert.AreEqual(1, UnitEquipmentUtil.GetMinEquipmentCount(unit, equip));
|
|
26
|
38 Assert.AreEqual(4.0/15*100, UnitEquipmentUtil.GetMaxEquipmentPercentage(unit, equip));
|
|
27
|
39 Assert.AreEqual(1.0/15*100, UnitEquipmentUtil.GetMinEquipmentPercentage(unit, equip));
|
|
24
|
40 }
|
|
|
41
|
|
|
42 [Test()]
|
|
|
43 public void TestGetEquipmentCountsForFixedLimitItemOnNumberLimitedSlot()
|
|
18
|
44 {
|
|
26
|
45 UnitEquipmentItem equip = new MockNumericAmountUnitEquipmentItem(3);
|
|
|
46 equip.SlotName = SLOT_NAME;
|
|
18
|
47 UnitType unitType = equip.EquipmentForUnit;
|
|
26
|
48 unitType.AddEquipmentSlot(SLOT_NAME, new AbsoluteNumericLimit(2));
|
|
19
|
49 Unit unit = GetUnit(unitType);
|
|
18
|
50 Assert.AreEqual(2, UnitEquipmentUtil.GetMaxEquipmentCount(unit, equip));
|
|
24
|
51 Assert.AreEqual(2, UnitEquipmentUtil.GetMinEquipmentCount(unit, equip));
|
|
26
|
52 Assert.AreEqual(2.0/15*100, UnitEquipmentUtil.GetMaxEquipmentPercentage(unit, equip));
|
|
27
|
53 Assert.AreEqual(2.0/15*100, UnitEquipmentUtil.GetMinEquipmentPercentage(unit, equip));
|
|
26
|
54 }
|
|
|
55
|
|
|
56 [Test()]
|
|
|
57 public void TestGetEquipmentCountsForFixedLimitItemOnNumberLimitedSlotWithDifferentMinLimit()
|
|
|
58 {
|
|
|
59 UnitEquipmentItem equip = new MockNumericAmountUnitEquipmentItem(1, 3);
|
|
|
60 equip.SlotName = SLOT_NAME;
|
|
|
61 UnitType unitType = equip.EquipmentForUnit;
|
|
|
62 unitType.AddEquipmentSlot(SLOT_NAME, new AbsoluteNumericLimit(2));
|
|
|
63 Unit unit = GetUnit(unitType);
|
|
|
64 Assert.AreEqual(2, UnitEquipmentUtil.GetMaxEquipmentCount(unit, equip));
|
|
|
65 Assert.AreEqual(1, UnitEquipmentUtil.GetMinEquipmentCount(unit, equip));
|
|
|
66 Assert.AreEqual(2.0/15*100, UnitEquipmentUtil.GetMaxEquipmentPercentage(unit, equip));
|
|
27
|
67 Assert.AreEqual(1.0/15*100, UnitEquipmentUtil.GetMinEquipmentPercentage(unit, equip));
|
|
26
|
68 }
|
|
|
69
|
|
|
70 [Test()]
|
|
|
71 public void TestGetEquipmentCountsForFixedLimitItemOnNumberLimitedSlotWithMaxBelowSlotLimit()
|
|
|
72 {
|
|
|
73 UnitEquipmentItem equip = new MockNumericAmountUnitEquipmentItem(3);
|
|
|
74 equip.SlotName = SLOT_NAME;
|
|
|
75 UnitType unitType = equip.EquipmentForUnit;
|
|
|
76 unitType.AddEquipmentSlot(SLOT_NAME, new AbsoluteNumericLimit(5));
|
|
|
77 Unit unit = GetUnit(unitType);
|
|
|
78 Assert.AreEqual(3, UnitEquipmentUtil.GetMaxEquipmentCount(unit, equip));
|
|
|
79 Assert.AreEqual(3, UnitEquipmentUtil.GetMinEquipmentCount(unit, equip));
|
|
|
80 Assert.AreEqual(3.0/15*100, UnitEquipmentUtil.GetMaxEquipmentPercentage(unit, equip));
|
|
27
|
81 Assert.AreEqual(3.0/15*100, UnitEquipmentUtil.GetMinEquipmentPercentage(unit, equip));
|
|
18
|
82 }
|
|
19
|
83
|
|
|
84 [Test()]
|
|
26
|
85 public void TestGetEquipmentCountsForFixedLimitItemOnNumberLimitedSlotWithMaxBelowSlotLimitWithDifferentMinLimit()
|
|
|
86 {
|
|
|
87 UnitEquipmentItem equip = new MockNumericAmountUnitEquipmentItem(1, 3);
|
|
|
88 equip.SlotName = SLOT_NAME;
|
|
|
89 UnitType unitType = equip.EquipmentForUnit;
|
|
|
90 unitType.AddEquipmentSlot(SLOT_NAME, new AbsoluteNumericLimit(5));
|
|
|
91 Unit unit = GetUnit(unitType);
|
|
|
92 Assert.AreEqual(3, UnitEquipmentUtil.GetMaxEquipmentCount(unit, equip));
|
|
|
93 Assert.AreEqual(1, UnitEquipmentUtil.GetMinEquipmentCount(unit, equip));
|
|
|
94 Assert.AreEqual(3.0/15*100, UnitEquipmentUtil.GetMaxEquipmentPercentage(unit, equip));
|
|
27
|
95 Assert.AreEqual(1.0/15*100, UnitEquipmentUtil.GetMinEquipmentPercentage(unit, equip));
|
|
26
|
96 }
|
|
|
97
|
|
|
98 [Test()]
|
|
24
|
99 public void TestGetEquipmentCountsForFixedLimitItemOnPercentageLimitedSlot()
|
|
19
|
100 {
|
|
26
|
101 UnitEquipmentItem equip = new MockNumericAmountUnitEquipmentItem(10);
|
|
|
102 equip.SlotName = SLOT_NAME;
|
|
19
|
103 UnitType unitType = equip.EquipmentForUnit;
|
|
26
|
104 unitType.AddEquipmentSlot(SLOT_NAME, new SimpleRoundedPercentageLimit(50, false));
|
|
19
|
105 Unit unit = GetUnit(unitType);
|
|
26
|
106 Assert.AreEqual(7, UnitEquipmentUtil.GetMaxEquipmentCount(unit, equip));
|
|
|
107 Assert.AreEqual(7, UnitEquipmentUtil.GetMinEquipmentCount(unit, equip));
|
|
|
108 Assert.AreEqual(50, UnitEquipmentUtil.GetMaxEquipmentPercentage(unit, equip));
|
|
27
|
109 Assert.AreEqual(50, UnitEquipmentUtil.GetMinEquipmentPercentage(unit, equip));
|
|
26
|
110 }
|
|
|
111
|
|
|
112 [Test()]
|
|
|
113 public void TestGetEquipmentCountsForFixedLimitItemOnPercentageLimitedSlotWithDifferentMinLimit()
|
|
|
114 {
|
|
|
115 UnitEquipmentItem equip = new MockNumericAmountUnitEquipmentItem(5, 10);
|
|
|
116 equip.SlotName = SLOT_NAME;
|
|
|
117 UnitType unitType = equip.EquipmentForUnit;
|
|
|
118 unitType.AddEquipmentSlot(SLOT_NAME, new SimpleRoundedPercentageLimit(50, false));
|
|
|
119 Unit unit = GetUnit(unitType);
|
|
|
120 Assert.AreEqual(7, UnitEquipmentUtil.GetMaxEquipmentCount(unit, equip));
|
|
24
|
121 Assert.AreEqual(5, UnitEquipmentUtil.GetMinEquipmentCount(unit, equip));
|
|
26
|
122 Assert.AreEqual(50, UnitEquipmentUtil.GetMaxEquipmentPercentage(unit, equip));
|
|
27
|
123 Assert.AreEqual(5.0/15*100, UnitEquipmentUtil.GetMinEquipmentPercentage(unit, equip));
|
|
19
|
124 }
|
|
|
125
|
|
|
126 [Test()]
|
|
24
|
127 public void TestGetEquipmentCountsForFixedLimitItemOnNumberLimitedSlotWithExistingEquipment()
|
|
19
|
128 {
|
|
26
|
129 UnitEquipmentItem equip = new MockNumericAmountUnitEquipmentItem(3);
|
|
|
130 equip.SlotName = SLOT_NAME;
|
|
19
|
131 UnitType unitType = equip.EquipmentForUnit;
|
|
26
|
132 unitType.AddEquipmentSlot(SLOT_NAME, new AbsoluteNumericLimit(6));
|
|
19
|
133 Unit unit =GetUnit(unitType);
|
|
|
134 UnitEquipmentItem equip2 = new MockPercentageAmountUnitEquipmentItem(new MockEquipmentItem("equip2"), unitType);
|
|
26
|
135 equip2.SlotName = SLOT_NAME;
|
|
19
|
136 unit.SetEquipmentAmount(equip2, 5);
|
|
|
137 Assert.AreEqual(1, UnitEquipmentUtil.GetMaxEquipmentCount(unit, equip));
|
|
24
|
138 Assert.AreEqual(1, UnitEquipmentUtil.GetMinEquipmentCount(unit, equip));
|
|
26
|
139 Assert.AreEqual(1.0/15*100, UnitEquipmentUtil.GetMaxEquipmentPercentage(unit, equip));
|
|
27
|
140 Assert.AreEqual(1.0/15*100, UnitEquipmentUtil.GetMinEquipmentPercentage(unit, equip));
|
|
26
|
141 }
|
|
|
142
|
|
|
143 [Test()]
|
|
|
144 public void TestGetEquipmentCountsForFixedLimitItemOnNumberLimitedSlotWithExistingEquipmentDifferentMinLimit()
|
|
|
145 {
|
|
|
146 UnitEquipmentItem equip = new MockNumericAmountUnitEquipmentItem(1, 3);
|
|
|
147 equip.SlotName = SLOT_NAME;
|
|
|
148 UnitType unitType = equip.EquipmentForUnit;
|
|
|
149 unitType.AddEquipmentSlot(SLOT_NAME, new AbsoluteNumericLimit(7));
|
|
|
150 Unit unit =GetUnit(unitType);
|
|
|
151 UnitEquipmentItem equip2 = new MockPercentageAmountUnitEquipmentItem(new MockEquipmentItem("equip2"), unitType);
|
|
|
152 equip2.SlotName = SLOT_NAME;
|
|
|
153 unit.SetEquipmentAmount(equip2, 5);
|
|
|
154 Assert.AreEqual(2, UnitEquipmentUtil.GetMaxEquipmentCount(unit, equip));
|
|
|
155 Assert.AreEqual(1, UnitEquipmentUtil.GetMinEquipmentCount(unit, equip));
|
|
|
156 Assert.AreEqual(2.0/15*100, UnitEquipmentUtil.GetMaxEquipmentPercentage(unit, equip));
|
|
27
|
157 Assert.AreEqual(1.0/15*100, UnitEquipmentUtil.GetMinEquipmentPercentage(unit, equip));
|
|
19
|
158 }
|
|
|
159
|
|
|
160 [Test()]
|
|
24
|
161 public void TestGetEquipmentCountsForPercentageLimitItemOnDefaultSlot()
|
|
19
|
162 {
|
|
26
|
163 UnitEquipmentItem equip = new MockPercentageAmountUnitEquipmentItem(50);
|
|
19
|
164 UnitType unitType = equip.EquipmentForUnit;
|
|
|
165 Unit unit = GetUnit(unitType);
|
|
26
|
166 Assert.AreEqual(7, UnitEquipmentUtil.GetMaxEquipmentCount(unit, equip));
|
|
|
167 Assert.AreEqual(7, UnitEquipmentUtil.GetMinEquipmentCount(unit, equip));
|
|
|
168 Assert.AreEqual(50, UnitEquipmentUtil.GetMaxEquipmentPercentage(unit, equip));
|
|
27
|
169 Assert.AreEqual(50, UnitEquipmentUtil.GetMinEquipmentPercentage(unit, equip));
|
|
26
|
170 }
|
|
|
171
|
|
|
172 [Test()]
|
|
|
173 public void TestGetEquipmentCountsForPercentageLimitItemOnDefaultSlotWithDifferentMinLimit()
|
|
|
174 {
|
|
|
175 UnitEquipmentItem equip = new MockPercentageAmountUnitEquipmentItem(25, 50);
|
|
|
176 UnitType unitType = equip.EquipmentForUnit;
|
|
|
177 Unit unit = GetUnit(unitType);
|
|
|
178 Assert.AreEqual(7, UnitEquipmentUtil.GetMaxEquipmentCount(unit, equip));
|
|
|
179 Assert.AreEqual(3, UnitEquipmentUtil.GetMinEquipmentCount(unit, equip));
|
|
|
180 Assert.AreEqual(50, UnitEquipmentUtil.GetMaxEquipmentPercentage(unit, equip));
|
|
27
|
181 Assert.AreEqual(25, UnitEquipmentUtil.GetMinEquipmentPercentage(unit, equip));
|
|
19
|
182 }
|
|
|
183
|
|
|
184 [Test()]
|
|
24
|
185 public void TestGetEquipmentCountsForPercentageLimitItemOnNumberLimitedSlot()
|
|
19
|
186 {
|
|
26
|
187 UnitEquipmentItem equip = new MockPercentageAmountUnitEquipmentItem(50);
|
|
|
188 equip.SlotName = SLOT_NAME;
|
|
19
|
189 UnitType unitType = equip.EquipmentForUnit;
|
|
26
|
190 unitType.AddEquipmentSlot(SLOT_NAME, new AbsoluteNumericLimit(2));
|
|
19
|
191 Unit unit = GetUnit(unitType);
|
|
|
192 Assert.AreEqual(2, UnitEquipmentUtil.GetMaxEquipmentCount(unit, equip));
|
|
24
|
193 Assert.AreEqual(2, UnitEquipmentUtil.GetMinEquipmentCount(unit, equip));
|
|
26
|
194 Assert.AreEqual(2.0/15*100, UnitEquipmentUtil.GetMaxEquipmentPercentage(unit, equip));
|
|
|
195 }
|
|
|
196
|
|
|
197 [Test()]
|
|
|
198 public void TestGetEquipmentCountsForPercentageLimitItemOnNumberLimitedSlotWithDifferentMinLimit()
|
|
|
199 {
|
|
|
200 UnitEquipmentItem equip = new MockPercentageAmountUnitEquipmentItem(10, 50);
|
|
|
201 equip.SlotName = SLOT_NAME;
|
|
|
202 UnitType unitType = equip.EquipmentForUnit;
|
|
|
203 unitType.AddEquipmentSlot(SLOT_NAME, new AbsoluteNumericLimit(2));
|
|
|
204 Unit unit = GetUnit(unitType);
|
|
|
205 Assert.AreEqual(2, UnitEquipmentUtil.GetMaxEquipmentCount(unit, equip));
|
|
|
206 Assert.AreEqual(1, UnitEquipmentUtil.GetMinEquipmentCount(unit, equip));
|
|
|
207 Assert.AreEqual(2.0/15*100, UnitEquipmentUtil.GetMaxEquipmentPercentage(unit, equip));
|
|
27
|
208 Assert.AreEqual(1.0/15*100, UnitEquipmentUtil.GetMinEquipmentPercentage(unit, equip));
|
|
19
|
209 }
|
|
|
210
|
|
|
211 [Test()]
|
|
24
|
212 public void TestGetEquipmentCountsForPercentageLimitItemOnPercentageLimitedSlot()
|
|
19
|
213 {
|
|
26
|
214 UnitEquipmentItem equip = new MockPercentageAmountUnitEquipmentItem(50);
|
|
|
215 equip.SlotName = SLOT_NAME;
|
|
|
216 UnitType unitType = equip.EquipmentForUnit;
|
|
|
217 unitType.AddEquipmentSlot(SLOT_NAME, new SimpleRoundedPercentageLimit(25, false));
|
|
|
218 Unit unit = GetUnit(unitType);
|
|
|
219 Assert.AreEqual(3, UnitEquipmentUtil.GetMaxEquipmentCount(unit, equip));
|
|
|
220 Assert.AreEqual(3, UnitEquipmentUtil.GetMinEquipmentCount(unit, equip));
|
|
|
221 Assert.AreEqual(25, UnitEquipmentUtil.GetMaxEquipmentPercentage(unit, equip));
|
|
27
|
222 Assert.AreEqual(25, UnitEquipmentUtil.GetMinEquipmentPercentage(unit, equip));
|
|
26
|
223 }
|
|
|
224
|
|
|
225 [Test()]
|
|
|
226 public void TestGetEquipmentCountsForPercentageLimitItemOnPercentageLimitedSlotWithDifferentMinLimit()
|
|
|
227 {
|
|
|
228 UnitEquipmentItem equip = new MockPercentageAmountUnitEquipmentItem(10, 50);
|
|
|
229 equip.SlotName = SLOT_NAME;
|
|
19
|
230 UnitType unitType = equip.EquipmentForUnit;
|
|
26
|
231 unitType.AddEquipmentSlot(SLOT_NAME, new SimpleRoundedPercentageLimit(25, false));
|
|
|
232 Unit unit = GetUnit(unitType);
|
|
|
233 Assert.AreEqual(3, UnitEquipmentUtil.GetMaxEquipmentCount(unit, equip));
|
|
|
234 Assert.AreEqual(1, UnitEquipmentUtil.GetMinEquipmentCount(unit, equip));
|
|
|
235 Assert.AreEqual(25, UnitEquipmentUtil.GetMaxEquipmentPercentage(unit, equip));
|
|
27
|
236 Assert.AreEqual(10, UnitEquipmentUtil.GetMinEquipmentPercentage(unit, equip));
|
|
26
|
237 }
|
|
|
238
|
|
|
239 [Test()]
|
|
|
240 public void TestGetEquipmentCountsForPercentageLimitItemOnPercentageLimitedSlotWithMaxBelowSlotLimit()
|
|
|
241 {
|
|
|
242 UnitEquipmentItem equip = new MockPercentageAmountUnitEquipmentItem(50);
|
|
|
243 equip.SlotName = SLOT_NAME;
|
|
|
244 UnitType unitType = equip.EquipmentForUnit;
|
|
|
245 unitType.AddEquipmentSlot(SLOT_NAME, new SimpleRoundedPercentageLimit(75, false));
|
|
19
|
246 Unit unit = GetUnit(unitType);
|
|
26
|
247 Assert.AreEqual(7, UnitEquipmentUtil.GetMaxEquipmentCount(unit, equip));
|
|
|
248 Assert.AreEqual(7, UnitEquipmentUtil.GetMinEquipmentCount(unit, equip));
|
|
|
249 Assert.AreEqual(50, UnitEquipmentUtil.GetMaxEquipmentPercentage(unit, equip));
|
|
27
|
250 Assert.AreEqual(50, UnitEquipmentUtil.GetMinEquipmentPercentage(unit, equip));
|
|
26
|
251 }
|
|
|
252
|
|
|
253 [Test()]
|
|
|
254 public void TestGetEquipmentCountsForPercentageLimitItemOnPercentageLimitedSlotWithMaxBelowSlotLimitWithDifferentMinLimit()
|
|
|
255 {
|
|
|
256 UnitEquipmentItem equip = new MockPercentageAmountUnitEquipmentItem(25, 50);
|
|
|
257 equip.SlotName = SLOT_NAME;
|
|
|
258 UnitType unitType = equip.EquipmentForUnit;
|
|
|
259 unitType.AddEquipmentSlot(SLOT_NAME, new SimpleRoundedPercentageLimit(75, false));
|
|
|
260 Unit unit = GetUnit(unitType);
|
|
|
261 Assert.AreEqual(7, UnitEquipmentUtil.GetMaxEquipmentCount(unit, equip));
|
|
|
262 Assert.AreEqual(3, UnitEquipmentUtil.GetMinEquipmentCount(unit, equip));
|
|
|
263 Assert.AreEqual(50, UnitEquipmentUtil.GetMaxEquipmentPercentage(unit, equip));
|
|
27
|
264 Assert.AreEqual(25, UnitEquipmentUtil.GetMinEquipmentPercentage(unit, equip));
|
|
19
|
265 }
|
|
|
266
|
|
|
267 [Test()]
|
|
24
|
268 public void TestGetEquipmentCountsForPercentageLimitItemOnNumberLimitedSlotWithExistingEquipment()
|
|
19
|
269 {
|
|
26
|
270 UnitEquipmentItem equip = new MockPercentageAmountUnitEquipmentItem(50);
|
|
|
271 equip.SlotName = SLOT_NAME;
|
|
19
|
272 UnitType unitType = equip.EquipmentForUnit;
|
|
26
|
273 unitType.AddEquipmentSlot(SLOT_NAME, new AbsoluteNumericLimit(7));
|
|
|
274 Unit unit = GetUnit(unitType);
|
|
|
275 UnitEquipmentItem equip2 = new MockPercentageAmountUnitEquipmentItem(new MockEquipmentItem("equip2"), unitType);
|
|
|
276 equip2.SlotName = SLOT_NAME;
|
|
|
277 unit.SetEquipmentAmount(equip2, 5);
|
|
|
278 Assert.AreEqual(2, UnitEquipmentUtil.GetMaxEquipmentCount(unit, equip));
|
|
|
279 Assert.AreEqual(2, UnitEquipmentUtil.GetMinEquipmentCount(unit, equip));
|
|
|
280 Assert.AreEqual(2.0/15*100, UnitEquipmentUtil.GetMaxEquipmentPercentage(unit, equip));
|
|
27
|
281 Assert.AreEqual(2.0/15*100, UnitEquipmentUtil.GetMinEquipmentPercentage(unit, equip));
|
|
26
|
282 }
|
|
|
283
|
|
|
284 [Test()]
|
|
|
285 public void TestGetEquipmentCountsForPercentageLimitItemOnPercentageLimitedSlotWithExistingEquipment()
|
|
|
286 {
|
|
|
287 UnitEquipmentItem equip = new MockPercentageAmountUnitEquipmentItem(50);
|
|
|
288 equip.SlotName = SLOT_NAME;
|
|
|
289 UnitType unitType = equip.EquipmentForUnit;
|
|
|
290 unitType.AddEquipmentSlot(SLOT_NAME, new SimpleRoundedPercentageLimit(50, true));
|
|
19
|
291 Unit unit = GetUnit(unitType);
|
|
|
292 UnitEquipmentItem equip2 = new MockPercentageAmountUnitEquipmentItem(new MockEquipmentItem("equip2"), unitType);
|
|
26
|
293 equip2.SlotName = SLOT_NAME;
|
|
19
|
294 unit.SetEquipmentAmount(equip2, 5);
|
|
26
|
295 Assert.AreEqual(3, UnitEquipmentUtil.GetMaxEquipmentCount(unit, equip));
|
|
|
296 Assert.AreEqual(3, UnitEquipmentUtil.GetMinEquipmentCount(unit, equip));
|
|
|
297 Assert.AreEqual(3.0/15*100, UnitEquipmentUtil.GetMaxEquipmentPercentage(unit, equip));
|
|
27
|
298 Assert.AreEqual(3.0/15*100, UnitEquipmentUtil.GetMinEquipmentPercentage(unit, equip));
|
|
26
|
299 }
|
|
|
300
|
|
|
301 [Test()]
|
|
|
302 public void TestGetEquipmentCountsForPercentageLimitItemOnPercentageLimitedSlotWithExistingEquipmentWithDifferentMinimum()
|
|
|
303 {
|
|
|
304 UnitEquipmentItem equip = new MockPercentageAmountUnitEquipmentItem(10, 50);
|
|
|
305 equip.SlotName = SLOT_NAME;
|
|
|
306 UnitType unitType = equip.EquipmentForUnit;
|
|
|
307 unitType.AddEquipmentSlot(SLOT_NAME, new SimpleRoundedPercentageLimit(50, true));
|
|
|
308 Unit unit = GetUnit(unitType);
|
|
|
309 UnitEquipmentItem equip2 = new MockPercentageAmountUnitEquipmentItem(new MockEquipmentItem("equip2"), unitType);
|
|
|
310 equip2.SlotName = SLOT_NAME;
|
|
|
311 unit.SetEquipmentAmount(equip2, 5);
|
|
|
312 Assert.AreEqual(3, UnitEquipmentUtil.GetMaxEquipmentCount(unit, equip));
|
|
21
|
313 Assert.AreEqual(1, UnitEquipmentUtil.GetMinEquipmentCount(unit, equip));
|
|
26
|
314 Assert.AreEqual(3.0/15*100, UnitEquipmentUtil.GetMaxEquipmentPercentage(unit, equip));
|
|
27
|
315 Assert.AreEqual(1.0/15*100, UnitEquipmentUtil.GetMinEquipmentPercentage(unit, equip));
|
|
21
|
316 }
|
|
22
|
317
|
|
|
318 [Test()]
|
|
|
319 public void TestIsEquipmentRatioLimitsWithRatioLimitedEquipmentAndUnlimitedSlot()
|
|
|
320 {
|
|
23
|
321 UnitEquipmentItem equip = new MockPercentageAmountUnitEquipmentItem();
|
|
26
|
322 equip.SlotName = SLOT_NAME;
|
|
22
|
323 UnitType unitType = equip.EquipmentForUnit;
|
|
26
|
324 unitType.AddEquipmentSlot(SLOT_NAME, new UnlimitedLimit());
|
|
22
|
325 Unit unit = GetUnit(unitType);
|
|
|
326 Assert.IsTrue(UnitEquipmentUtil.IsEquipmentRatioLimited(unit, equip));
|
|
|
327 }
|
|
|
328
|
|
|
329 [Test()]
|
|
|
330 public void TestIsEquipmentRatioLimitsWithRatioLimitedEquipmentAndRatioSlot()
|
|
|
331 {
|
|
|
332 UnitEquipmentItem equip = new MockPercentageAmountUnitEquipmentItem();
|
|
26
|
333 equip.SlotName = SLOT_NAME;
|
|
22
|
334 UnitType unitType = equip.EquipmentForUnit;
|
|
26
|
335 unitType.AddEquipmentSlot(SLOT_NAME, new SimpleRoundedPercentageLimit(50, true));
|
|
22
|
336 Unit unit = GetUnit(unitType);
|
|
|
337 Assert.IsTrue(UnitEquipmentUtil.IsEquipmentRatioLimited(unit, equip));
|
|
|
338 }
|
|
|
339
|
|
|
340 [Test()]
|
|
|
341 public void TestIsEquipmentRatioLimitsWithRatioLimitedEquipmentAndAbsoluteSlot()
|
|
|
342 {
|
|
|
343 UnitEquipmentItem equip = new MockPercentageAmountUnitEquipmentItem();
|
|
26
|
344 equip.SlotName = SLOT_NAME;
|
|
22
|
345 UnitType unitType = equip.EquipmentForUnit;
|
|
26
|
346 unitType.AddEquipmentSlot(SLOT_NAME, new AbsoluteNumericLimit(5));
|
|
22
|
347 Unit unit = GetUnit(unitType);
|
|
|
348 Assert.IsFalse(UnitEquipmentUtil.IsEquipmentRatioLimited(unit, equip));
|
|
|
349 }
|
|
23
|
350
|
|
|
351 [Test()]
|
|
|
352 public void TestIsEquipmentRatioLimitsWithAbsoluteLimitedEquipmentAndAbsoluteSlot()
|
|
|
353 {
|
|
24
|
354 UnitEquipmentItem equip = new MockNumericAmountUnitEquipmentItem();
|
|
26
|
355 equip.SlotName = SLOT_NAME;
|
|
23
|
356 UnitType unitType = equip.EquipmentForUnit;
|
|
26
|
357 unitType.AddEquipmentSlot(SLOT_NAME, new AbsoluteNumericLimit(5));
|
|
23
|
358 Unit unit = GetUnit(unitType);
|
|
|
359 Assert.IsFalse(UnitEquipmentUtil.IsEquipmentRatioLimited(unit, equip));
|
|
|
360 }
|
|
|
361
|
|
|
362 [Test()]
|
|
|
363 public void TestIsEquipmentRatioLimitsWithAbsoluteLimitedEquipmentAndUnlimitedSlot()
|
|
|
364 {
|
|
24
|
365 UnitEquipmentItem equip = new MockNumericAmountUnitEquipmentItem();
|
|
26
|
366 equip.SlotName = SLOT_NAME;
|
|
23
|
367 UnitType unitType = equip.EquipmentForUnit;
|
|
26
|
368 unitType.AddEquipmentSlot(SLOT_NAME, new UnlimitedLimit());
|
|
23
|
369 Unit unit = GetUnit(unitType);
|
|
|
370 Assert.IsFalse(UnitEquipmentUtil.IsEquipmentRatioLimited(unit, equip));
|
|
|
371 }
|
|
|
372
|
|
|
373 [Test()]
|
|
|
374 public void TestIsEquipmentRatioLimitsWithAbsoluteLimitedEquipmentAndRatioSlot()
|
|
|
375 {
|
|
24
|
376 UnitEquipmentItem equip = new MockNumericAmountUnitEquipmentItem();
|
|
26
|
377 equip.SlotName = SLOT_NAME;
|
|
23
|
378 UnitType unitType = equip.EquipmentForUnit;
|
|
26
|
379 unitType.AddEquipmentSlot(SLOT_NAME, new SimpleRoundedPercentageLimit(50, true));
|
|
23
|
380 Unit unit = GetUnit(unitType);
|
|
|
381 Assert.IsFalse(UnitEquipmentUtil.IsEquipmentRatioLimited(unit, equip));
|
|
|
382 }
|
|
24
|
383
|
|
|
384 private Unit GetUnit (UnitType unitType)
|
|
19
|
385 {
|
|
26
|
386 return new Unit ("unit", "Test Unit", 15, unitType, new MockArmyCategory (unitType.MainCategory));
|
|
19
|
387 }
|
|
18
|
388 }
|
|
|
389 }
|
