def test_effect_disabled(self):
fit = Fit()
item = ModuleHigh(
self.mktype(
attrs={
AttrId.em_dmg: 52,
AttrId.therm_dmg: 63,
AttrId.kin_dmg: 74,
AttrId.expl_dmg: 85,
self.cycle_attr.id: 5000},
effects=[self.effect],
default_effect=self.effect).id,
state=State.active)
item.set_effect_mode(self.effect.id, EffectMode.force_stop)
fit.modules.high.append(item)
# Verification
volley = item.get_volley()
self.assertAlmostEqual(volley.em, 0)
self.assertAlmostEqual(volley.thermal, 0)
self.assertAlmostEqual(volley.kinetic, 0)
self.assertAlmostEqual(volley.explosive, 0)
self.assertAlmostEqual(volley.total, 0)
# Cleanup
self.assert_solsys_buffers_empty(fit.solar_system)
self.assert_log_entries(0)
def test_item_effect_disabled(self):
fit = Fit()
item = ModuleHigh(
self.mktype(
attrs={
AttrId.dmg_mult: 2.5,
AttrId.capacity: 2.0,
self.cycle_attr.id: 500,
AttrId.charge_rate: 1.0,
AttrId.reload_time: 5000},
effects=[self.effect],
default_effect=self.effect).id,
state=State.active)
item.set_effect_mode(self.effect.id, EffectMode.force_stop)
item.charge = Charge(self.mktype(attrs={
AttrId.volume: 0.2,
AttrId.em_dmg: 5.2,
AttrId.therm_dmg: 6.3,
AttrId.kin_dmg: 7.4,
AttrId.expl_dmg: 8.5}).id)
fit.modules.high.append(item)
# Verification
volley = item.get_volley()
self.assertAlmostEqual(volley.em, 0)
self.assertAlmostEqual(volley.thermal, 0)
self.assertAlmostEqual(volley.kinetic, 0)
self.assertAlmostEqual(volley.explosive, 0)
self.assertAlmostEqual(volley.total, 0)
# Cleanup
self.assert_solsys_buffers_empty(fit.solar_system)
self.assert_log_entries(0)
def test_single_item_not_loaded(self):
effect_id = self.allocate_effect_id()
item = ModuleHigh(self.allocate_type_id())
self.fit.modules.high.append(item)
# Verification
item.set_effect_mode(effect_id, EffectMode.force_stop)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_use_item_effect_disabled(self):
item1 = ModuleHigh(self.mktype(effects=[self.effect]).id)
item2 = ModuleHigh(self.mktype(effects=[self.effect]).id)
item2.set_effect_mode(self.effect.id, EffectMode.force_stop)
self.fit.modules.high.append(item1)
self.fit.modules.high.append(item2)
# Verification
self.assertEqual(self.fit.stats.turret_slots.used, 1)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_status_stopped(self):
effect = self.mkeffect(category_id=EffectCategoryId.passive)
item = ModuleHigh(self.mktype(effects=[effect]).id, state=State.offline)
self.fit.modules.high.append(item)
item.set_effect_mode(effect.id, EffectMode.force_stop)
# Verification
self.assertEqual(len(item.effects), 1)
self.assertIn(effect.id, item.effects)
effect_data = item.effects[effect.id]
self.assertIs(effect_data.status, False)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_pass_item_effect_disabled(self):
self.fit.ship = Ship(self.mktype(
attrs={AttrId.launcher_slots_left: 0}).id)
item = ModuleHigh(self.mktype(effects=[self.effect]).id)
item.set_effect_mode(self.effect.id, EffectMode.force_stop)
self.fit.modules.high.append(item)
# Action
error = self.get_error(item, Restriction.launcher_slot)
# Verification
self.assertIsNone(error)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_pass_item_effect_disabled(self):
self.fit.ship = Ship(self.mktype(attrs={AttrId.power_output: 40}).id)
item = ModuleHigh(
self.mktype(attrs={AttrId.power: 50}, effects=[self.effect]).id,
state=State.online)
item.set_effect_mode(self.effect.id, EffectMode.force_stop)
self.fit.modules.high.append(item)
# Action
error = self.get_error(item, Restriction.powergrid)
# Verification
self.assertIsNone(error)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_use_item_effect_disabled(self):
item1 = ModuleHigh(
self.mktype(attrs={AttrId.cpu: 50}, effects=[self.effect]).id,
state=State.online)
item2 = ModuleHigh(
self.mktype(attrs={AttrId.cpu: 30}, effects=[self.effect]).id,
state=State.online)
item2.set_effect_mode(self.effect.id, EffectMode.force_stop)
self.fit.modules.high.append(item1)
self.fit.modules.high.append(item2)
# Verification
self.assertAlmostEqual(self.fit.stats.cpu.used, 50)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_stopped_on_add(self):
effect = self.mkeffect(
category_id=EffectCategoryId.passive,
modifiers=[self.modifier])
item = ModuleHigh(
self.mktype(
attrs={self.tgt_attr.id: 10, self.src_attr.id: 2},
effects=[effect]).id,
state=State.offline)
item.set_effect_mode(effect.id, EffectMode.force_stop)
# Action
self.fit.modules.high.append(item)
# Verification
self.assertAlmostEqual(item.attrs[self.tgt_attr.id], 10)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_module_high_pass_effect_disabled(self):
# Make sure disabled high slot effect doesn't prevent item from passing
# the check
effect = self.mkeffect(
effect_id=EffectId.hi_power,
category_id=EffectCategoryId.passive)
item = ModuleHigh(self.mktype(
category_id=TypeCategoryId.module,
effects=[effect]).id)
item.set_effect_mode(effect.id, EffectMode.force_stop)
self.fit.modules.high.append(item)
# Action
error = self.get_error(item, Restriction.item_class)
# Verification
self.assertIsNone(error)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_started_on_state_switch(self):
effect = self.mkeffect(
category_id=EffectCategoryId.overload,
modifiers=[self.modifier])
item = ModuleHigh(
self.mktype(
attrs={self.tgt_attr.id: 10, self.src_attr.id: 2},
effects=[effect]).id,
state=State.active)
item.set_effect_mode(effect.id, EffectMode.full_compliance)
self.fit.modules.high.append(item)
self.assertAlmostEqual(item.attrs[self.tgt_attr.id], 10)
# Action
item.state = State.overload
# Verification
self.assertAlmostEqual(item.attrs[self.tgt_attr.id], 12)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_stopped_insufficient_state_on_mode_switch(self):
effect = self.mkeffect(
category_id=EffectCategoryId.active,
modifiers=[self.modifier])
item = ModuleHigh(
self.mktype(
attrs={self.tgt_attr.id: 10, self.src_attr.id: 2},
effects=[effect],
default_effect=effect).id,
state=State.online)
item.set_effect_mode(effect.id, EffectMode.force_run)
self.fit.modules.high.append(item)
self.assertAlmostEqual(item.attrs[self.tgt_attr.id], 12)
# Action
item.set_effect_mode(effect.id, EffectMode.state_compliance)
# Verification
self.assertAlmostEqual(item.attrs[self.tgt_attr.id], 10)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_started_on_state_switch(self):
effect = self.mkeffect(category_id=EffectCategoryId.online,
modifiers=[self.modifier])
online_effect = self.mkeffect(effect_id=EffectId.online,
category_id=EffectCategoryId.online)
item = ModuleHigh(self.mktype(attrs={
self.tgt_attr.id: 10,
self.src_attr.id: 2
},
effects=[effect, online_effect]).id,
state=State.offline)
item.set_effect_mode(effect.id, EffectMode.force_run)
self.fit.modules.high.append(item)
self.assertAlmostEqual(item.attrs[self.tgt_attr.id], 12)
# Action
item.state = State.online
# Verification
self.assertAlmostEqual(item.attrs[self.tgt_attr.id], 12)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_multiple(self):
effect1 = self.mkeffect(category_id=EffectCategoryId.passive)
effect2 = self.mkeffect(category_id=EffectCategoryId.online)
effect3 = self.mkeffect(category_id=EffectCategoryId.active)
item = ModuleHigh(
self.mktype(
effects=(effect1, effect2, effect3),
default_effect=effect3).id,
state=State.online)
self.fit.modules.high.append(item)
item.set_effect_mode(effect1.id, EffectMode.state_compliance)
item.set_effect_mode(effect2.id, EffectMode.full_compliance)
item.set_effect_mode(effect3.id, EffectMode.force_run)
# Verification
self.assertEqual(len(item.effects), 3)
self.assertIn(effect1.id, item.effects)
effect1_data = item.effects[effect1.id]
self.assertIs(effect1_data.effect, effect1)
self.assertEqual(effect1_data.mode, EffectMode.state_compliance)
self.assertIs(effect1_data.status, True)
effect2_data = item.effects[effect2.id]
self.assertIs(effect2_data.effect, effect2)
self.assertEqual(effect2_data.mode, EffectMode.full_compliance)
self.assertIs(effect2_data.status, False)
effect3_data = item.effects[effect3.id]
self.assertIs(effect3_data.effect, effect3)
self.assertEqual(effect3_data.mode, EffectMode.force_run)
self.assertIs(effect3_data.status, True)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_stopped_chance_based(self):
chance_attr = self.mkattr()
effect = self.mkeffect(
category_id=EffectCategoryId.passive,
fitting_usage_chance_attr_id=chance_attr.id,
modifiers=[self.modifier])
item = ModuleHigh(
self.mktype(
attrs={
self.tgt_attr.id: 10,
self.src_attr.id: 2,
chance_attr.id: 1},
effects=[effect]).id,
state=State.offline)
item.set_effect_mode(effect.id, EffectMode.force_stop)
# Action
self.fit.modules.high.append(item)
# Verification
self.assertAlmostEqual(item.attrs[self.tgt_attr.id], 10)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_started_chance_based_on_add(self):
chance_attr = self.mkattr()
effect = self.mkeffect(
category_id=EffectCategoryId.passive,
fitting_usage_chance_attr_id=chance_attr.id,
modifiers=[self.modifier])
item = ModuleHigh(
self.mktype(
attrs={
self.tgt_attr.id: 10,
self.src_attr.id: 2,
chance_attr.id: 1},
effects=[effect]).id,
state=State.offline)
item.set_effect_mode(effect.id, EffectMode.state_compliance)
# Action
self.fit.modules.high.append(item)
# Verification
self.assertAlmostEqual(item.attrs[self.tgt_attr.id], 12)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_effect_disabled(self):
fit = Fit()
item = ModuleHigh(self.mktype(attrs={
AttrId.em_dmg: 52000,
AttrId.therm_dmg: 63000,
AttrId.kin_dmg: 74000,
AttrId.expl_dmg: 85000,
self.cycle_attr.id: 250000
},
effects=[self.effect_amarr],
default_effect=self.effect_amarr).id,
state=State.active)
item.set_effect_mode(self.effect_amarr.id, EffectMode.force_stop)
fit.modules.high.append(item)
# Verification
volley = item.get_volley()
self.assertAlmostEqual(volley.em, 0)
self.assertAlmostEqual(volley.thermal, 0)
self.assertAlmostEqual(volley.kinetic, 0)
self.assertAlmostEqual(volley.explosive, 0)
self.assertAlmostEqual(volley.total, 0)
# Cleanup
self.assert_solsys_buffers_empty(fit.solar_system)
self.assert_log_entries(0)
class TestEffectToggling(CalculatorTestCase):
"""Test effect toggling."""
def setUp(self):
CalculatorTestCase.setUp(self)
self.tgt_attr = self.mkattr(stackable=1)
src_attr1 = self.mkattr()
src_attr2 = self.mkattr()
src_attr3 = self.mkattr()
modifier1 = self.mkmod(affectee_filter=ModAffecteeFilter.item,
affectee_domain=ModDomain.self,
affectee_attr_id=self.tgt_attr.id,
operator=ModOperator.post_mul,
affector_attr_id=src_attr1.id)
modifier2 = self.mkmod(affectee_filter=ModAffecteeFilter.item,
affectee_domain=ModDomain.self,
affectee_attr_id=self.tgt_attr.id,
operator=ModOperator.post_mul,
affector_attr_id=src_attr2.id)
modifier_active = self.mkmod(affectee_filter=ModAffecteeFilter.item,
affectee_domain=ModDomain.self,
affectee_attr_id=self.tgt_attr.id,
operator=ModOperator.post_mul,
affector_attr_id=src_attr3.id)
self.effect1 = self.mkeffect(category_id=EffectCategoryId.passive,
modifiers=[modifier1])
self.effect2 = self.mkeffect(category_id=EffectCategoryId.passive,
modifiers=[modifier2])
self.effect_active = self.mkeffect(category_id=EffectCategoryId.active,
modifiers=[modifier_active])
self.item = ModuleHigh(
self.mktype(attrs={
self.tgt_attr.id: 100,
src_attr1.id: 1.1,
src_attr2.id: 1.3,
src_attr3.id: 2
},
effects=(self.effect1, self.effect2,
self.effect_active),
default_effect=self.effect_active).id)
def test_effect_disabling(self):
# Setup
self.item.state = State.offline
self.fit.modules.high.append(self.item)
# Action
self.item.set_effect_mode(self.effect1.id, EffectMode.force_stop)
# Verification
self.assertAlmostEqual(self.item.attrs[self.tgt_attr.id], 130)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_effect_disabling_multiple(self):
# Setup
self.item.state = State.offline
self.fit.modules.high.append(self.item)
# Action
self.item.set_effect_mode(self.effect1.id, EffectMode.force_stop)
self.item.set_effect_mode(self.effect2.id, EffectMode.force_stop)
self.item.set_effect_mode(self.effect_active.id, EffectMode.force_stop)
# Verification
self.assertAlmostEqual(self.item.attrs[self.tgt_attr.id], 100)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_effect_enabling(self):
# Setup
self.item.state = State.offline
self.item.set_effect_mode(self.effect1.id, EffectMode.force_stop)
self.fit.modules.high.append(self.item)
# Action
self.item.set_effect_mode(self.effect1.id, EffectMode.state_compliance)
# Verification
self.assertAlmostEqual(self.item.attrs[self.tgt_attr.id], 143)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_effect_enabling_multiple(self):
# Setup
self.item.state = State.offline
self.item.set_effect_mode(self.effect1.id, EffectMode.force_stop)
self.item.set_effect_mode(self.effect2.id, EffectMode.force_stop)
self.fit.modules.high.append(self.item)
# Action
self.item.set_effect_mode(self.effect1.id, EffectMode.state_compliance)
self.item.set_effect_mode(self.effect2.id, EffectMode.state_compliance)
self.item.set_effect_mode(self.effect_active.id,
EffectMode.state_compliance)
# Verification
self.assertAlmostEqual(self.item.attrs[self.tgt_attr.id], 143)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
class TestEffectToggling(CalculatorTestCase):
"""Test effect toggling."""
def setUp(self):
CalculatorTestCase.setUp(self)
self.tgt_attr = self.mkattr(stackable=1)
src_attr1 = self.mkattr()
src_attr2 = self.mkattr()
src_attr3 = self.mkattr()
modifier1 = self.mkmod(
affectee_filter=ModAffecteeFilter.item,
affectee_domain=ModDomain.self,
affectee_attr_id=self.tgt_attr.id,
operator=ModOperator.post_mul,
affector_attr_id=src_attr1.id)
modifier2 = self.mkmod(
affectee_filter=ModAffecteeFilter.item,
affectee_domain=ModDomain.self,
affectee_attr_id=self.tgt_attr.id,
operator=ModOperator.post_mul,
affector_attr_id=src_attr2.id)
modifier_active = self.mkmod(
affectee_filter=ModAffecteeFilter.item,
affectee_domain=ModDomain.self,
affectee_attr_id=self.tgt_attr.id,
operator=ModOperator.post_mul,
affector_attr_id=src_attr3.id)
self.effect1 = self.mkeffect(
category_id=EffectCategoryId.passive,
modifiers=[modifier1])
self.effect2 = self.mkeffect(
category_id=EffectCategoryId.passive,
modifiers=[modifier2])
self.effect_active = self.mkeffect(
category_id=EffectCategoryId.active,
modifiers=[modifier_active])
self.item = ModuleHigh(self.mktype(
attrs={
self.tgt_attr.id: 100, src_attr1.id: 1.1,
src_attr2.id: 1.3, src_attr3.id: 2},
effects=(self.effect1, self.effect2, self.effect_active),
default_effect=self.effect_active).id)
def test_effect_disabling(self):
# Setup
self.item.state = State.offline
self.fit.modules.high.append(self.item)
# Action
self.item.set_effect_mode(self.effect1.id, EffectMode.force_stop)
# Verification
self.assertAlmostEqual(self.item.attrs[self.tgt_attr.id], 130)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_effect_disabling_multiple(self):
# Setup
self.item.state = State.offline
self.fit.modules.high.append(self.item)
# Action
self.item.set_effect_mode(self.effect1.id, EffectMode.force_stop)
self.item.set_effect_mode(self.effect2.id, EffectMode.force_stop)
self.item.set_effect_mode(self.effect_active.id, EffectMode.force_stop)
# Verification
self.assertAlmostEqual(self.item.attrs[self.tgt_attr.id], 100)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_effect_enabling(self):
# Setup
self.item.state = State.offline
self.item.set_effect_mode(self.effect1.id, EffectMode.force_stop)
self.fit.modules.high.append(self.item)
# Action
self.item.set_effect_mode(self.effect1.id, EffectMode.state_compliance)
# Verification
self.assertAlmostEqual(self.item.attrs[self.tgt_attr.id], 143)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_effect_enabling_multiple(self):
# Setup
self.item.state = State.offline
self.item.set_effect_mode(self.effect1.id, EffectMode.force_stop)
self.item.set_effect_mode(self.effect2.id, EffectMode.force_stop)
self.fit.modules.high.append(self.item)
# Action
self.item.set_effect_mode(self.effect1.id, EffectMode.state_compliance)
self.item.set_effect_mode(self.effect2.id, EffectMode.state_compliance)
self.item.set_effect_mode(
self.effect_active.id, EffectMode.state_compliance)
# Verification
self.assertAlmostEqual(self.item.attrs[self.tgt_attr.id], 143)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
class TestStateSwitching(CalculatorTestCase):
def setUp(self):
CalculatorTestCase.setUp(self)
self.tgt_attr = self.mkattr(stackable=1)
src_attr1 = self.mkattr()
src_attr2 = self.mkattr()
src_attr3 = self.mkattr()
src_attr4 = self.mkattr()
src_attr5 = self.mkattr()
modifier_off = self.mkmod(affectee_filter=ModAffecteeFilter.item,
affectee_domain=ModDomain.self,
affectee_attr_id=self.tgt_attr.id,
operator=ModOperator.post_mul,
affector_attr_id=src_attr1.id)
modifier_on = self.mkmod(affectee_filter=ModAffecteeFilter.item,
affectee_domain=ModDomain.self,
affectee_attr_id=self.tgt_attr.id,
operator=ModOperator.post_mul,
affector_attr_id=src_attr2.id)
modifier_act = self.mkmod(affectee_filter=ModAffecteeFilter.item,
affectee_domain=ModDomain.self,
affectee_attr_id=self.tgt_attr.id,
operator=ModOperator.post_mul,
affector_attr_id=src_attr3.id)
modifier_over = self.mkmod(affectee_filter=ModAffecteeFilter.item,
affectee_domain=ModDomain.self,
affectee_attr_id=self.tgt_attr.id,
operator=ModOperator.post_mul,
affector_attr_id=src_attr4.id)
modifier_disabled = self.mkmod(affectee_filter=ModAffecteeFilter.item,
affectee_domain=ModDomain.self,
affectee_attr_id=self.tgt_attr.id,
operator=ModOperator.post_mul,
affector_attr_id=src_attr3.id)
effect_cat_offline = self.mkeffect(
category_id=EffectCategoryId.passive, modifiers=[modifier_off])
effect_cat_online = self.mkeffect(category_id=EffectCategoryId.online,
modifiers=[modifier_on])
effect_cat_active = self.mkeffect(category_id=EffectCategoryId.active,
modifiers=[modifier_act])
effect_cat_overload = self.mkeffect(
category_id=EffectCategoryId.overload, modifiers=[modifier_over])
online_effect = self.mkeffect(effect_id=EffectId.online,
category_id=EffectCategoryId.online)
effect_disabled = self.mkeffect(category_id=EffectCategoryId.online,
modifiers=[modifier_disabled])
self.item = ModuleHigh(
self.mktype(attrs={
self.tgt_attr.id: 100,
src_attr1.id: 1.1,
src_attr2.id: 1.3,
src_attr3.id: 1.5,
src_attr4.id: 1.7,
src_attr5.id: 2
},
effects=(effect_cat_offline, effect_cat_online,
effect_cat_active, effect_cat_overload,
online_effect, effect_disabled),
default_effect=effect_cat_active).id)
self.item.set_effect_mode(effect_disabled.id, EffectMode.force_stop)
def test_fit_offline(self):
# Setup
self.item.state = State.offline
# Action
self.fit.modules.high.append(self.item)
# Verification
self.assertAlmostEqual(self.item.attrs[self.tgt_attr.id], 110)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_fit_online(self):
# Setup
self.item.state = State.online
# Action
self.fit.modules.high.append(self.item)
# Verification
self.assertAlmostEqual(self.item.attrs[self.tgt_attr.id], 143)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_fit_active(self):
# Setup
self.item.state = State.active
# Action
self.fit.modules.high.append(self.item)
# Verification
self.assertAlmostEqual(self.item.attrs[self.tgt_attr.id], 214.5)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_fit_overloaded(self):
# Setup
self.item.state = State.overload
# Action
self.fit.modules.high.append(self.item)
# Verification
self.assertAlmostEqual(self.item.attrs[self.tgt_attr.id], 364.65)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_switch_up_single(self):
# Setup
self.item.state = State.offline
self.fit.modules.high.append(self.item)
# Action
self.item.state = State.online
# Verification
self.assertAlmostEqual(self.item.attrs[self.tgt_attr.id], 143)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_switch_up_multiple(self):
# Setup
self.item.state = State.online
self.fit.modules.high.append(self.item)
# Action
self.item.state = State.overload
# Verification
self.assertAlmostEqual(self.item.attrs[self.tgt_attr.id], 364.65)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_switch_down_single(self):
# Setup
self.item.state = State.overload
self.fit.modules.high.append(self.item)
# Action
self.item.state = State.active
# Verification
self.assertAlmostEqual(self.item.attrs[self.tgt_attr.id], 214.5)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_switch_down_multiple(self):
# Setup
self.item.state = State.active
self.fit.modules.high.append(self.item)
# Action
self.item.state = State.offline
# Verification
self.assertAlmostEqual(self.item.attrs[self.tgt_attr.id], 110)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
class TestStateSwitching(CalculatorTestCase):
def setUp(self):
CalculatorTestCase.setUp(self)
self.tgt_attr = self.mkattr(stackable=1)
src_attr1 = self.mkattr()
src_attr2 = self.mkattr()
src_attr3 = self.mkattr()
src_attr4 = self.mkattr()
src_attr5 = self.mkattr()
modifier_off = self.mkmod(
affectee_filter=ModAffecteeFilter.item,
affectee_domain=ModDomain.self,
affectee_attr_id=self.tgt_attr.id,
operator=ModOperator.post_mul,
affector_attr_id=src_attr1.id)
modifier_on = self.mkmod(
affectee_filter=ModAffecteeFilter.item,
affectee_domain=ModDomain.self,
affectee_attr_id=self.tgt_attr.id,
operator=ModOperator.post_mul,
affector_attr_id=src_attr2.id)
modifier_act = self.mkmod(
affectee_filter=ModAffecteeFilter.item,
affectee_domain=ModDomain.self,
affectee_attr_id=self.tgt_attr.id,
operator=ModOperator.post_mul,
affector_attr_id=src_attr3.id)
modifier_over = self.mkmod(
affectee_filter=ModAffecteeFilter.item,
affectee_domain=ModDomain.self,
affectee_attr_id=self.tgt_attr.id,
operator=ModOperator.post_mul,
affector_attr_id=src_attr4.id)
modifier_disabled = self.mkmod(
affectee_filter=ModAffecteeFilter.item,
affectee_domain=ModDomain.self,
affectee_attr_id=self.tgt_attr.id,
operator=ModOperator.post_mul,
affector_attr_id=src_attr3.id)
effect_cat_offline = self.mkeffect(
category_id=EffectCategoryId.passive,
modifiers=[modifier_off])
effect_cat_online = self.mkeffect(
category_id=EffectCategoryId.online,
modifiers=[modifier_on])
effect_cat_active = self.mkeffect(
category_id=EffectCategoryId.active,
modifiers=[modifier_act])
effect_cat_overload = self.mkeffect(
category_id=EffectCategoryId.overload,
modifiers=[modifier_over])
online_effect = self.mkeffect(
effect_id=EffectId.online,
category_id=EffectCategoryId.online)
effect_disabled = self.mkeffect(
category_id=EffectCategoryId.online,
modifiers=[modifier_disabled])
self.item = ModuleHigh(self.mktype(
attrs={
self.tgt_attr.id: 100, src_attr1.id: 1.1, src_attr2.id: 1.3,
src_attr3.id: 1.5, src_attr4.id: 1.7, src_attr5.id: 2},
effects=(
effect_cat_offline, effect_cat_online, effect_cat_active,
effect_cat_overload, online_effect, effect_disabled),
default_effect=effect_cat_active).id)
self.item.set_effect_mode(effect_disabled.id, EffectMode.force_stop)
def test_fit_offline(self):
# Setup
self.item.state = State.offline
# Action
self.fit.modules.high.append(self.item)
# Verification
self.assertAlmostEqual(self.item.attrs[self.tgt_attr.id], 110)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_fit_online(self):
# Setup
self.item.state = State.online
# Action
self.fit.modules.high.append(self.item)
# Verification
self.assertAlmostEqual(self.item.attrs[self.tgt_attr.id], 143)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_fit_active(self):
# Setup
self.item.state = State.active
# Action
self.fit.modules.high.append(self.item)
# Verification
self.assertAlmostEqual(self.item.attrs[self.tgt_attr.id], 214.5)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_fit_overloaded(self):
# Setup
self.item.state = State.overload
# Action
self.fit.modules.high.append(self.item)
# Verification
self.assertAlmostEqual(self.item.attrs[self.tgt_attr.id], 364.65)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_switch_up_single(self):
# Setup
self.item.state = State.offline
self.fit.modules.high.append(self.item)
# Action
self.item.state = State.online
# Verification
self.assertAlmostEqual(self.item.attrs[self.tgt_attr.id], 143)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_switch_up_multiple(self):
# Setup
self.item.state = State.online
self.fit.modules.high.append(self.item)
# Action
self.item.state = State.overload
# Verification
self.assertAlmostEqual(self.item.attrs[self.tgt_attr.id], 364.65)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_switch_down_single(self):
# Setup
self.item.state = State.overload
self.fit.modules.high.append(self.item)
# Action
self.item.state = State.active
# Verification
self.assertAlmostEqual(self.item.attrs[self.tgt_attr.id], 214.5)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_switch_down_multiple(self):
# Setup
self.item.state = State.active
self.fit.modules.high.append(self.item)
# Action
self.item.state = State.offline
# Verification
self.assertAlmostEqual(self.item.attrs[self.tgt_attr.id], 110)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
