def test_uniform(self): fit = Fit() item = Ship(self.mktype(attrs={ AttrId.hp: 1, AttrId.em_dmg_resonance: 0.8, AttrId.therm_dmg_resonance: 0.8, AttrId.kin_dmg_resonance: 0.8, AttrId.expl_dmg_resonance: 0.8, AttrId.armor_hp: 10, AttrId.armor_em_dmg_resonance: 0.4, AttrId.armor_therm_dmg_resonance: 0.4, AttrId.armor_kin_dmg_resonance: 0.4, AttrId.armor_expl_dmg_resonance: 0.4, AttrId.shield_capacity: 100, AttrId.shield_em_dmg_resonance: 0.2, AttrId.shield_therm_dmg_resonance: 0.2, AttrId.shield_kin_dmg_resonance: 0.2, AttrId.shield_expl_dmg_resonance: 0.2}).id) fit.ship = item # Verification results = item.get_ehp(DmgProfile(1, 1, 1, 1)) self.assertAlmostEqual(results.hull, 1.25) self.assertAlmostEqual(results.armor, 25) self.assertAlmostEqual(results.shield, 500) self.assertAlmostEqual(results.total, 526.25) # Cleanup self.assert_solsys_buffers_empty(fit.solar_system) self.assert_log_entries(0)
def test_non_uniform(self): fit = Fit() item = Ship(self.mktype(attrs={ AttrId.hp: 10, AttrId.em_dmg_resonance: 0.9, AttrId.therm_dmg_resonance: 0.8, AttrId.kin_dmg_resonance: 0.7, AttrId.expl_dmg_resonance: 0.6, AttrId.armor_hp: 50, AttrId.armor_em_dmg_resonance: 0.4, AttrId.armor_therm_dmg_resonance: 0.6, AttrId.armor_kin_dmg_resonance: 0.8, AttrId.armor_expl_dmg_resonance: 0.9, AttrId.shield_capacity: 600, AttrId.shield_em_dmg_resonance: 1.0, AttrId.shield_therm_dmg_resonance: 0.8, AttrId.shield_kin_dmg_resonance: 0.6, AttrId.shield_expl_dmg_resonance: 0.5}).id) fit.ship = item # Verification results = item.get_ehp(DmgProfile(25, 6, 8.333, 1)) self.assertAlmostEqual(results.hull, 11.957, places=3) self.assertAlmostEqual(results.armor, 95.276, places=3) self.assertAlmostEqual(results.shield, 685.551, places=3) self.assertAlmostEqual(results.total, 792.783, places=3) # Cleanup self.assert_solsys_buffers_empty(fit.solar_system) self.assert_log_entries(0)
def test_item_attr_hp_all_absent(self): fit = Fit() item = Ship(self.mktype(attrs={ AttrId.em_dmg_resonance: 0.9, AttrId.therm_dmg_resonance: 0.8, AttrId.kin_dmg_resonance: 0.7, AttrId.expl_dmg_resonance: 0.6, AttrId.armor_em_dmg_resonance: 0.4, AttrId.armor_therm_dmg_resonance: 0.6, AttrId.armor_kin_dmg_resonance: 0.8, AttrId.armor_expl_dmg_resonance: 0.9, AttrId.shield_em_dmg_resonance: 1.0, AttrId.shield_therm_dmg_resonance: 0.8, AttrId.shield_kin_dmg_resonance: 0.6, AttrId.shield_expl_dmg_resonance: 0.5}).id) fit.ship = item # Verification results = item.get_ehp(DmgProfile(25, 6, 8.333, 1)) self.assertAlmostEqual(results.hull, 0) self.assertAlmostEqual(results.armor, 0) self.assertAlmostEqual(results.shield, 0) self.assertAlmostEqual(results.total, 0) # Cleanup self.assert_solsys_buffers_empty(fit.solar_system) self.assert_log_entries(0)
def test_item_not_loaded(self): fit = Fit() item = Ship(self.allocate_type_id()) fit.ship = item # Verification results = item.get_ehp(DmgProfile(1, 1, 1, 1)) self.assertAlmostEqual(results.hull, 0) self.assertAlmostEqual(results.armor, 0) self.assertAlmostEqual(results.shield, 0) self.assertAlmostEqual(results.total, 0) # Cleanup self.assert_solsys_buffers_empty(fit.solar_system) self.assert_log_entries(0)
def test_output_ship_attr_absent(self): self.fit.ship = Ship(self.mktype().id) # Verification self.assertEqual(self.fit.stats.fighter_squads_light.total, 0) # Cleanup self.assert_solsys_buffers_empty(self.fit.solar_system) self.assert_log_entries(0)
def test_fail_modified(self): # Make sure modified powergrid values are taken self.fit.ship = Ship(self.mktype(attrs={AttrId.power_output: 50}).id) src_attr = self.mkattr() modifier = self.mkmod( affectee_filter=ModAffecteeFilter.item, affectee_domain=ModDomain.self, affectee_attr_id=AttrId.power, operator=ModOperator.post_mul, affector_attr_id=src_attr.id) mod_effect = self.mkeffect( category_id=EffectCategoryId.passive, modifiers=[modifier]) item = ModuleHigh( self.mktype( attrs={AttrId.power: 50, src_attr.id: 2}, effects=(self.effect, mod_effect)).id, state=State.online) self.fit.modules.high.append(item) # Action error = self.get_error(item, Restriction.powergrid) # Verification self.assertIsNotNone(error) self.assertEqual(error.output, 50) self.assertEqual(error.total_use, 100) self.assertEqual(error.item_use, 100) # Cleanup self.assert_solsys_buffers_empty(self.fit.solar_system) self.assert_log_entries(0)
def test_mix_usage_zero(self): # If some item has zero usage and powergrid error is still raised, check # it's not raised for item with zero usage self.fit.ship = Ship(self.mktype(attrs={AttrId.power_output: 50}).id) item1 = ModuleHigh( self.mktype(attrs={AttrId.power: 100}, effects=[self.effect]).id, state=State.online) self.fit.modules.high.append(item1) item2 = ModuleHigh( self.mktype(attrs={AttrId.power: 0}, effects=[self.effect]).id, state=State.online) self.fit.modules.high.append(item2) # Action error1 = self.get_error(item1, Restriction.powergrid) # Verification self.assertIsNotNone(error1) self.assertEqual(error1.output, 50) self.assertEqual(error1.total_use, 100) self.assertEqual(error1.item_use, 100) # Action error2 = self.get_error(item2, Restriction.powergrid) # Verification self.assertIsNone(error2) # Cleanup self.assert_solsys_buffers_empty(self.fit.solar_system) self.assert_log_entries(0)
def test_item_attr_hp_all_absent(self): fit = Fit() item = Ship( self.mktype( attrs={ AttrId.em_dmg_resonance: 0.8, AttrId.therm_dmg_resonance: 0.8, AttrId.kin_dmg_resonance: 0.8, AttrId.expl_dmg_resonance: 0.8, AttrId.armor_em_dmg_resonance: 0.4, AttrId.armor_therm_dmg_resonance: 0.4, AttrId.armor_kin_dmg_resonance: 0.4, AttrId.armor_expl_dmg_resonance: 0.4, AttrId.shield_em_dmg_resonance: 0.2, AttrId.shield_therm_dmg_resonance: 0.2, AttrId.shield_kin_dmg_resonance: 0.2, AttrId.shield_expl_dmg_resonance: 0.2 }).id) fit.ship = item # Verification self.assertAlmostEqual(item.worst_case_ehp.hull, 0) self.assertAlmostEqual(item.worst_case_ehp.armor, 0) self.assertAlmostEqual(item.worst_case_ehp.shield, 0) self.assertAlmostEqual(item.worst_case_ehp.total, 0) # Cleanup self.assert_solsys_buffers_empty(fit.solar_system) self.assert_log_entries(0)
def test_output_ship_attr_absent(self): self.fit.ship = Ship(self.mktype().id) # Verification self.assertAlmostEqual(self.fit.stats.cpu.output, 0) # Cleanup self.assert_solsys_buffers_empty(self.fit.solar_system) self.assert_log_entries(0)
def test_fail_multiple(self): # Check that error works for multiple items self.fit.ship = Ship( self.mktype(attrs={ AttrId.launcher_slots_left: 1 }).id) item_type = self.mktype(effects=[self.effect]) item1 = ModuleHigh(item_type.id) item2 = ModuleHigh(item_type.id) self.fit.modules.high.append(item1) self.fit.modules.high.append(item2) # Action error1 = self.get_error(item1, Restriction.launcher_slot) # Verification self.assertIsNotNone(error1) self.assertEqual(error1.used, 2) self.assertEqual(error1.total, 1) # Action error2 = self.get_error(item2, Restriction.launcher_slot) # Verification self.assertIsNotNone(error2) self.assertEqual(error2.used, 2) self.assertEqual(error2.total, 1) # Cleanup self.assert_solsys_buffers_empty(self.fit.solar_system) self.assert_log_entries(0)
def test_pass(self): # When total consumption is less than output, no errors should be raised self.fit.ship = Ship( self.mktype(attrs={ AttrId.upgrade_capacity: 50 }).id) item1 = Rig( self.mktype(attrs={ AttrId.upgrade_cost: 25 }, effects=[self.effect]).id) self.fit.rigs.add(item1) item2 = Rig( self.mktype(attrs={ AttrId.upgrade_cost: 20 }, effects=[self.effect]).id) self.fit.rigs.add(item2) # Action error1 = self.get_error(item1, Restriction.calibration) # Verification self.assertIsNone(error1) # Action error2 = self.get_error(item2, Restriction.calibration) # Verification self.assertIsNone(error2) # Cleanup self.assert_solsys_buffers_empty(self.fit.solar_system) self.assert_log_entries(0)
def test_fail_multiple(self): # Check that error works for multiple items self.fit.ship = Ship( self.mktype(attrs={ AttrId.fighter_light_slots: 1 }).id) item_type = self.mktype(attrs={AttrId.fighter_squadron_is_light: 1}) item1 = FighterSquad(item_type.id) item2 = FighterSquad(item_type.id) self.fit.fighters.add(item1) self.fit.fighters.add(item2) # Action error1 = self.get_error(item1, Restriction.fighter_squad_light) # Verification self.assertIsNotNone(error1) self.assertEqual(error1.used, 2) self.assertEqual(error1.total, 1) # Action error2 = self.get_error(item2, Restriction.fighter_squad_light) # Verification self.assertIsNotNone(error2) self.assertEqual(error2.used, 2) self.assertEqual(error2.total, 1) # Cleanup self.assert_solsys_buffers_empty(self.fit.solar_system) self.assert_log_entries(0)
def test_double_run_unsynced(self): # Setup ship = Ship(self.make_ship_type((0.5, 0.65, 0.75, 0.9)).id) self.fit.ship = ship rah_type = self.make_rah_type((0.85, 0.85, 0.85, 0.85), 6, 1000) rah1 = ModuleLow(rah_type.id, state=State.active) rah2 = ModuleLow(rah_type.id, state=State.overload) self.fit.modules.low.equip(rah1) self.fit.modules.low.equip(rah2) # Verification self.assertAlmostEqual(rah1.attrs[self.armor_em.id], 0.975, places=3) self.assertAlmostEqual(rah1.attrs[self.armor_therm.id], 0.835, places=3) self.assertAlmostEqual(rah1.attrs[self.armor_kin.id], 0.83, places=3) self.assertAlmostEqual(rah1.attrs[self.armor_expl.id], 0.76, places=3) self.assertAlmostEqual(rah2.attrs[self.armor_em.id], 0.979, places=3) self.assertAlmostEqual(rah2.attrs[self.armor_therm.id], 0.91, places=3) self.assertAlmostEqual(rah2.attrs[self.armor_kin.id], 0.796, places=3) self.assertAlmostEqual(rah2.attrs[self.armor_expl.id], 0.715, places=3) self.assertAlmostEqual(ship.attrs[self.armor_em.id], 0.479, places=3) self.assertAlmostEqual(ship.attrs[self.armor_therm.id], 0.5, places=3) self.assertAlmostEqual(ship.attrs[self.armor_kin.id], 0.509, places=3) self.assertAlmostEqual(ship.attrs[self.armor_expl.id], 0.509, places=3) # Cleanup self.assert_solsys_buffers_empty(self.fit.solar_system) self.assert_log_entries(0)
def test_unexpected_exception(self): # Setup ship = Ship(self.make_ship_type((0.5, 0.65, 0.75, 0.9)).id) self.fit.ship = ship # Set cycle time to zero to force exception rah = ModuleLow(self.make_rah_type((0.85, 0.85, 0.85, 0.85), 6, 0).id, state=State.active) self.fit.modules.low.equip(rah) # Verification self.assertAlmostEqual(rah.attrs[self.armor_em.id], 0.85) self.assertAlmostEqual(rah.attrs[self.armor_therm.id], 0.85) self.assertAlmostEqual(rah.attrs[self.armor_kin.id], 0.85) self.assertAlmostEqual(rah.attrs[self.armor_expl.id], 0.85) self.assertAlmostEqual(ship.attrs[self.armor_em.id], 0.425) self.assertAlmostEqual(ship.attrs[self.armor_therm.id], 0.5525) self.assertAlmostEqual(ship.attrs[self.armor_kin.id], 0.6375) self.assertAlmostEqual(ship.attrs[self.armor_expl.id], 0.765) self.assert_log_entries(1) log_record = self.log[0] self.assertEqual(log_record.name, 'eos.sim.reactive_armor_hardener') self.assertEqual(log_record.levelno, logging.WARNING) self.assertEqual( log_record.msg, 'unexpected exception, setting unsimulated resonances') # Cleanup self.assert_solsys_buffers_empty(self.fit.solar_system)
def test_no_loop_half_history(self): # Setup ship = Ship(self.make_ship_type((0.5, 0.65, 0.75, 0.9)).id) self.fit.ship = ship rah_type = self.make_rah_type((0.85, 0.85, 0.85, 0.85), 6, 1000) rah1 = ModuleLow(rah_type.id, state=State.active) rah2 = ModuleLow(rah_type.id, state=State.overload) self.fit.modules.low.equip(rah1) self.fit.modules.low.equip(rah2) # Verification # Same as previous test, but here whole history is just 5 ticks, and we # cannot ignore all of them - here we should ignore just 2 first ticks self.assertAlmostEqual(rah1.attrs[self.armor_em.id], 0.94, places=3) self.assertAlmostEqual(rah1.attrs[self.armor_therm.id], 0.88, places=3) self.assertAlmostEqual(rah1.attrs[self.armor_kin.id], 0.82, places=3) self.assertAlmostEqual(rah1.attrs[self.armor_expl.id], 0.76, places=3) self.assertAlmostEqual(rah2.attrs[self.armor_em.id], 0.97, places=3) self.assertAlmostEqual(rah2.attrs[self.armor_therm.id], 0.85, places=3) self.assertAlmostEqual(rah2.attrs[self.armor_kin.id], 0.85, places=3) self.assertAlmostEqual(rah2.attrs[self.armor_expl.id], 0.73, places=3) self.assertAlmostEqual(ship.attrs[self.armor_em.id], 0.458, places=3) self.assertAlmostEqual(ship.attrs[self.armor_therm.id], 0.495, places=3) self.assertAlmostEqual(ship.attrs[self.armor_kin.id], 0.535, places=3) self.assertAlmostEqual(ship.attrs[self.armor_expl.id], 0.52, places=3) # Cleanup self.assert_solsys_buffers_empty(self.fit.solar_system) self.assert_log_entries(0)
def test_fail_multiple_with_nones(self): # Make sure Nones are processed properly self.fit.ship = Ship(self.mktype(attrs={AttrId.med_slots: 3}).id) item_type = self.mktype() item1 = ModuleMid(item_type.id) item2 = ModuleMid(item_type.id) item3 = ModuleMid(item_type.id) self.fit.modules.mid.place(1, item1) self.fit.modules.mid.place(4, item2) self.fit.modules.mid.place(6, item3) # Action error1 = self.get_error(item1, Restriction.mid_slot) # Verification self.assertIsNone(error1) # Action error2 = self.get_error(item2, Restriction.mid_slot) # Verification self.assertIsNotNone(error2) self.assertEqual(error2.used, 7) self.assertEqual(error2.total, 3) # Action error3 = self.get_error(item2, Restriction.mid_slot) # Verification self.assertIsNotNone(error3) self.assertEqual(error3.used, 7) self.assertEqual(error3.total, 3) # Cleanup self.assert_solsys_buffers_empty(self.fit.solar_system) self.assert_log_entries(0)
def test_order_em_therm_kin(self): # Setup self.fit.rah_incoming_dmg = DmgProfile(1, 1, 1, 0) ship = Ship(self.make_ship_type((0.675, 0.675, 0.675, 0.675)).id) self.fit.ship = ship rah = ModuleLow(self.make_rah_type((0.85, 0.85, 0.85, 0.85), 6, 1000).id, state=State.active) self.fit.modules.low.equip(rah) # Verification # From real tests, gecko vs gnosis with 2 explosive hardeners # 0 0.850 0.850 0.850 0.850 # 1 0.910 0.790 0.790 0.910 (kin therm > em) # 2 0.850 0.730 0.850 0.970 (therm > kin) # ---loop--- # 3 0.805 0.790 0.805 1.000 # 4 0.775 0.850 0.775 1.000 # 5 0.835 0.820 0.745 1.000 (kin > em) self.assertAlmostEqual(rah.attrs[self.armor_em.id], 0.805) self.assertAlmostEqual(rah.attrs[self.armor_therm.id], 0.82) self.assertAlmostEqual(rah.attrs[self.armor_kin.id], 0.775) self.assertAlmostEqual(rah.attrs[self.armor_expl.id], 1) self.assertAlmostEqual(ship.attrs[self.armor_em.id], 0.543, places=3) self.assertAlmostEqual(ship.attrs[self.armor_therm.id], 0.553, places=3) self.assertAlmostEqual(ship.attrs[self.armor_kin.id], 0.523, places=3) self.assertAlmostEqual(ship.attrs[self.armor_expl.id], 0.675, places=3) # Cleanup self.assert_solsys_buffers_empty(self.fit.solar_system) self.assert_log_entries(0)
def test_relay(self): # Check that stats service relays wcehp stats properly self.fit.ship = Ship( self.mktype( attrs={ AttrId.hp: 10, AttrId.em_dmg_resonance: 0.8, AttrId.therm_dmg_resonance: 0.5, AttrId.kin_dmg_resonance: 0.5, AttrId.expl_dmg_resonance: 0.5, AttrId.armor_hp: 15, AttrId.armor_em_dmg_resonance: 0.5, AttrId.armor_therm_dmg_resonance: 0.8, AttrId.armor_kin_dmg_resonance: 0.5, AttrId.armor_expl_dmg_resonance: 0.5, AttrId.shield_capacity: 20, AttrId.shield_em_dmg_resonance: 0.5, AttrId.shield_therm_dmg_resonance: 0.5, AttrId.shield_kin_dmg_resonance: 0.65, AttrId.shield_expl_dmg_resonance: 0.8 }).id) # Action worst_ehp_stats = self.fit.stats.worst_case_ehp # Verification self.assertAlmostEqual(worst_ehp_stats.hull, 12.5) self.assertAlmostEqual(worst_ehp_stats.armor, 18.75) self.assertAlmostEqual(worst_ehp_stats.shield, 25) self.assertAlmostEqual(worst_ehp_stats.total, 56.25) # Cleanup self.assert_solsys_buffers_empty(self.fit.solar_system) self.assert_log_entries(0)
def test_fail_multiple(self): # When multiple consumers require less than calibration output alone, # but in sum want more than total output, it should be erroneous # situation self.fit.ship = Ship( self.mktype(attrs={ AttrId.upgrade_capacity: 40 }).id) item1 = Rig( self.mktype(attrs={ AttrId.upgrade_cost: 25 }, effects=[self.effect]).id) self.fit.rigs.add(item1) item2 = Rig( self.mktype(attrs={ AttrId.upgrade_cost: 20 }, effects=[self.effect]).id) self.fit.rigs.add(item2) # Action error1 = self.get_error(item1, Restriction.calibration) # Verification self.assertIsNotNone(error1) self.assertEqual(error1.output, 40) self.assertEqual(error1.total_use, 45) self.assertEqual(error1.item_use, 25) # Action error2 = self.get_error(item2, Restriction.calibration) # Verification self.assertIsNotNone(error2) self.assertEqual(error2.output, 40) self.assertEqual(error2.total_use, 45) self.assertEqual(error2.item_use, 20) # Cleanup self.assert_solsys_buffers_empty(self.fit.solar_system) self.assert_log_entries(0)
def test_influence_single_item_running(self): # Autocharge should be able to modify container when effect, which # defines autocharge, is running autocharge_modifier = self.mkmod_filter_item(ModDomain.ship) autocharge_effect = self.mkeffect(category_id=EffectCategoryId.passive, modifiers=[autocharge_modifier]) autocharge_type = self.mktype(attrs={self.src_attr.id: 50}, effects=[autocharge_effect]) container_effect = self.mkeffect(effect_id=EffectId.target_attack, category_id=EffectCategoryId.target) container = ModuleHigh(self.mktype(attrs={ self.autocharge_attr_id: autocharge_type.id }, effects=[container_effect]).id, state=State.active) influence_tgt = Ship(self.mktype(attrs={self.tgt_attr.id: 10}).id) self.fit.ship = influence_tgt # Action self.fit.modules.high.append(container) # Verification self.assertAlmostEqual(influence_tgt.attrs[self.tgt_attr.id], 15) # Cleanup self.assert_solsys_buffers_empty(self.fit.solar_system) self.assert_log_entries(0)
def test_output_ship_not_loaded(self): self.fit.ship = Ship(self.allocate_type_id()) # Verification self.assertAlmostEqual(self.fit.stats.powergrid.output, 0) # Cleanup self.assert_solsys_buffers_empty(self.fit.solar_system) self.assert_log_entries(0)
def test_output(self): self.fit.ship = Ship(self.mktype(attrs={AttrId.max_subsystems: 3}).id) # Verification self.assertEqual(self.fit.stats.subsystem_slots.total, 3) # Cleanup self.assert_solsys_buffers_empty(self.fit.solar_system) self.assert_log_entries(0)
def test_override_priority(self): # Setup ship = Ship(self.make_ship_type((0.5, 0.65, 0.75, 0.9)).id) self.fit.ship = ship rah = ModuleLow( self.make_rah_type((0.85, 0.85, 0.85, 0.85), 6, 1000).id, state=State.online) self.fit.modules.low.equip(rah) # Calculate modified values self.assertAlmostEqual(rah.attrs[self.armor_em.id], 0.85) self.assertAlmostEqual(rah.attrs[self.armor_therm.id], 0.85) self.assertAlmostEqual(rah.attrs[self.armor_kin.id], 0.85) self.assertAlmostEqual(rah.attrs[self.armor_expl.id], 0.85) self.assertAlmostEqual(ship.attrs[self.armor_em.id], 0.5) self.assertAlmostEqual(ship.attrs[self.armor_therm.id], 0.65) self.assertAlmostEqual(ship.attrs[self.armor_kin.id], 0.75) self.assertAlmostEqual(ship.attrs[self.armor_expl.id], 0.9) # Action rah.state = State.active # Verification # Make sure override values are returned, even when modified values were # stored self.assertAlmostEqual(rah.attrs[self.armor_em.id], 1) self.assertAlmostEqual(rah.attrs[self.armor_therm.id], 0.925) self.assertAlmostEqual(rah.attrs[self.armor_kin.id], 0.82) self.assertAlmostEqual(rah.attrs[self.armor_expl.id], 0.655) self.assertAlmostEqual(ship.attrs[self.armor_em.id], 0.5) self.assertAlmostEqual(ship.attrs[self.armor_therm.id], 0.60125) self.assertAlmostEqual(ship.attrs[self.armor_kin.id], 0.615) self.assertAlmostEqual(ship.attrs[self.armor_expl.id], 0.5895) # Cleanup self.assert_solsys_buffers_empty(self.fit.solar_system) self.assert_log_entries(0)
def test_same_item(self): # Real scenario - capital ships boost their agility via proxy attrs # Setup tgt_attr = self.mkattr() src_attr1 = self.mkattr() src_attr2 = self.mkattr() modifier1 = self.make_modifier(src_attr1, tgt_attr) modifier2 = self.make_modifier(src_attr2, tgt_attr) effect1 = self.mkeffect(category_id=EffectCategoryId.passive, modifiers=[modifier1]) effect2 = self.mkeffect(category_id=EffectCategoryId.passive, modifiers=[modifier2]) item = Ship( self.mktype(attrs={ src_attr1.id: 20, src_attr2.id: 20, tgt_attr.id: 100 }, effects=(effect1, effect2)).id) # Action self.fit.ship = item # Verification self.assertAlmostEqual(item.attrs[tgt_attr.id], 144) # Cleanup self.assert_solsys_buffers_empty(self.fit.solar_system) self.assert_log_entries(0)
def test_worst_em(self): fit = Fit() item = Ship( self.mktype( attrs={ AttrId.hp: 1, AttrId.em_dmg_resonance: 0.8, AttrId.therm_dmg_resonance: 0.7, AttrId.kin_dmg_resonance: 0.7, AttrId.expl_dmg_resonance: 0.7, AttrId.armor_hp: 10, AttrId.armor_em_dmg_resonance: 0.4, AttrId.armor_therm_dmg_resonance: 0.3, AttrId.armor_kin_dmg_resonance: 0.3, AttrId.armor_expl_dmg_resonance: 0.3, AttrId.shield_capacity: 100, AttrId.shield_em_dmg_resonance: 0.2, AttrId.shield_therm_dmg_resonance: 0.1, AttrId.shield_kin_dmg_resonance: 0.1, AttrId.shield_expl_dmg_resonance: 0.1 }).id) fit.ship = item # Verification self.assertAlmostEqual(item.worst_case_ehp.hull, 1.25) self.assertAlmostEqual(item.worst_case_ehp.armor, 25) self.assertAlmostEqual(item.worst_case_ehp.shield, 500) self.assertAlmostEqual(item.worst_case_ehp.total, 526.25) # Cleanup self.assert_solsys_buffers_empty(fit.solar_system) self.assert_log_entries(0)
def test_combination(self): tgt_attr = self.mkattr() src_attr = self.mkattr() invalid_modifier = self.mkmod(affectee_filter=ModAffecteeFilter.item, affectee_domain=1972, affectee_attr_id=tgt_attr.id, operator=ModOperator.post_percent, affector_attr_id=src_attr.id) valid_modifier = self.mkmod(affectee_filter=ModAffecteeFilter.item, affectee_domain=ModDomain.self, affectee_attr_id=tgt_attr.id, operator=ModOperator.post_percent, affector_attr_id=src_attr.id) effect = self.mkeffect(category_id=EffectCategoryId.passive, modifiers=(invalid_modifier, valid_modifier)) item_type = self.mktype(attrs={ src_attr.id: 20, tgt_attr.id: 100 }, effects=[effect]) item = Ship(item_type.id) # Action self.fit.ship = item # Verification self.assertAlmostEqual(item.attrs[tgt_attr.id], 120) self.assert_log_entries(2) for log_record in self.log: self.assertEqual(log_record.name, 'eos.calculator.affection') self.assertEqual(log_record.levelno, logging.WARNING) self.assertEqual( log_record.msg, 'malformed modifier on item type {}: ' 'unsupported affectee domain 1972'.format(item_type.id)) # Cleanup self.assert_solsys_buffers_empty(self.fit.solar_system)
def test_fail_multiple(self): # When multiple consumers require less than powergrid output alone, but # in sum want more than total output, it should be erroneous situation self.fit.ship = Ship(self.mktype(attrs={AttrId.power_output: 40}).id) item1 = ModuleHigh( self.mktype(attrs={AttrId.power: 25}, effects=[self.effect]).id, state=State.online) self.fit.modules.high.append(item1) item2 = ModuleHigh( self.mktype(attrs={AttrId.power: 20}, effects=[self.effect]).id, state=State.online) self.fit.modules.high.append(item2) # Action error1 = self.get_error(item1, Restriction.powergrid) # Verification self.assertIsNotNone(error1) self.assertEqual(error1.output, 40) self.assertEqual(error1.total_use, 45) self.assertEqual(error1.item_use, 25) # Action error2 = self.get_error(item2, Restriction.powergrid) # Verification self.assertIsNotNone(error2) self.assertEqual(error2.output, 40) self.assertEqual(error2.total_use, 45) self.assertEqual(error2.item_use, 20) # Cleanup self.assert_solsys_buffers_empty(self.fit.solar_system) self.assert_log_entries(0)
def test_generic(self): fit = Fit() item = Ship(self.mktype(attrs={ AttrId.em_dmg_resonance: 0.01, AttrId.therm_dmg_resonance: 0.02, AttrId.kin_dmg_resonance: 0.03, AttrId.expl_dmg_resonance: 0.04, AttrId.armor_em_dmg_resonance: 0.05, AttrId.armor_therm_dmg_resonance: 0.06, AttrId.armor_kin_dmg_resonance: 0.07, AttrId.armor_expl_dmg_resonance: 0.08, AttrId.shield_em_dmg_resonance: 0.09, AttrId.shield_therm_dmg_resonance: 0.1, AttrId.shield_kin_dmg_resonance: 0.11, AttrId.shield_expl_dmg_resonance: 0.12}).id) fit.ship = item # Verification self.assertAlmostEqual(item.resists.hull.em, 0.99) self.assertAlmostEqual(item.resists.hull.thermal, 0.98) self.assertAlmostEqual(item.resists.hull.kinetic, 0.97) self.assertAlmostEqual(item.resists.hull.explosive, 0.96) self.assertAlmostEqual(item.resists.armor.em, 0.95) self.assertAlmostEqual(item.resists.armor.thermal, 0.94) self.assertAlmostEqual(item.resists.armor.kinetic, 0.93) self.assertAlmostEqual(item.resists.armor.explosive, 0.92) self.assertAlmostEqual(item.resists.shield.em, 0.91) self.assertAlmostEqual(item.resists.shield.thermal, 0.9) self.assertAlmostEqual(item.resists.shield.kinetic, 0.89) self.assertAlmostEqual(item.resists.shield.explosive, 0.88) # Cleanup self.assert_solsys_buffers_empty(fit.solar_system) self.assert_log_entries(0)
def test_fail_multiple(self): # When multiple consumers require less than dronebay volume output # alone, but in sum want more than total output, it should be erroneous # situation self.fit.ship = Ship(self.mktype(attrs={AttrId.drone_capacity: 40}).id) item1 = Drone(self.mktype(attrs={AttrId.volume: 25}).id) self.fit.drones.add(item1) item2 = Drone(self.mktype(attrs={AttrId.volume: 20}).id) self.fit.drones.add(item2) # Action error1 = self.get_error(item1, Restriction.dronebay_volume) # Verification self.assertIsNotNone(error1) self.assertEqual(error1.output, 40) self.assertEqual(error1.total_use, 45) self.assertEqual(error1.item_use, 25) # Action error2 = self.get_error(item2, Restriction.dronebay_volume) # Verification self.assertIsNotNone(error2) self.assertEqual(error2.output, 40) self.assertEqual(error2.total_use, 45) self.assertEqual(error2.item_use, 20) # Cleanup self.assert_solsys_buffers_empty(self.fit.solar_system) self.assert_log_entries(0)
def test_fail_modified(self): # Make sure modified calibration values are taken self.fit.ship = Ship( self.mktype(attrs={ AttrId.upgrade_capacity: 50 }).id) src_attr = self.mkattr() modifier = self.mkmod(affectee_filter=ModAffecteeFilter.item, affectee_domain=ModDomain.self, affectee_attr_id=AttrId.upgrade_cost, operator=ModOperator.post_mul, affector_attr_id=src_attr.id) mod_effect = self.mkeffect(category_id=EffectCategoryId.passive, modifiers=[modifier]) item = Rig( self.mktype(attrs={ AttrId.upgrade_cost: 50, src_attr.id: 2 }, effects=(self.effect, mod_effect)).id) self.fit.rigs.add(item) # Action error = self.get_error(item, Restriction.calibration) # Verification self.assertIsNotNone(error) self.assertEqual(error.output, 50) self.assertEqual(error.total_use, 100) self.assertEqual(error.item_use, 100) # Cleanup self.assert_solsys_buffers_empty(self.fit.solar_system) self.assert_log_entries(0)
def test_output_ship_not_loaded(self): self.fit.ship = Ship(self.allocate_type_id()) # Verification self.assertEqual(self.fit.stats.fighter_squads_light.total, 0) # Cleanup self.assert_solsys_buffers_empty(self.fit.solar_system) self.assert_log_entries(0)
def test_mix_usage_zero(self): # If some item has zero usage and calibration error is still raised, # check it's not raised for item with zero usage self.fit.ship = Ship( self.mktype(attrs={ AttrId.upgrade_capacity: 50 }).id) item1 = Rig( self.mktype(attrs={ AttrId.upgrade_cost: 100 }, effects=[self.effect]).id) self.fit.rigs.add(item1) item2 = Rig( self.mktype(attrs={ AttrId.upgrade_cost: 0 }, effects=[self.effect]).id) self.fit.rigs.add(item2) # Action error1 = self.get_error(item1, Restriction.calibration) # Verification self.assertIsNotNone(error1) self.assertEqual(error1.output, 50) self.assertEqual(error1.total_use, 100) self.assertEqual(error1.item_use, 100) # Action error2 = self.get_error(item2, Restriction.calibration) # Verification self.assertIsNone(error2) # Cleanup self.assert_solsys_buffers_empty(self.fit.solar_system) self.assert_log_entries(0)
def test_order_multi(self): # Setup ship = Ship(self.make_ship_type((0.675, 0.675, 0.675, 0.675)).id) self.fit.ship = ship rah = ModuleLow(self.make_rah_type((0.85, 0.85, 0.85, 0.85), 6, 1000).id, state=State.active) self.fit.modules.low.equip(rah) # Verification # From real tests, gecko vs gnosis # ---loop--- # 0 0.850 0.850 0.850 0.850 # 1 0.910 0.790 0.790 0.910 (kin therm > em expl) self.assertAlmostEqual(rah.attrs[self.armor_em.id], 0.88) self.assertAlmostEqual(rah.attrs[self.armor_therm.id], 0.82) self.assertAlmostEqual(rah.attrs[self.armor_kin.id], 0.82) self.assertAlmostEqual(rah.attrs[self.armor_expl.id], 0.88) self.assertAlmostEqual(ship.attrs[self.armor_em.id], 0.594, places=3) self.assertAlmostEqual(ship.attrs[self.armor_therm.id], 0.554, places=3) self.assertAlmostEqual(ship.attrs[self.armor_kin.id], 0.554, places=3) self.assertAlmostEqual(ship.attrs[self.armor_expl.id], 0.594, places=3) # Cleanup self.assert_solsys_buffers_empty(self.fit.solar_system) self.assert_log_entries(0)
def test_relay(self): # Check that stats service relays resistance stats properly self.fit.ship = Ship(self.mktype(attrs={ AttrId.em_dmg_resonance: 0.05, AttrId.therm_dmg_resonance: 0.06, AttrId.kin_dmg_resonance: 0.07, AttrId.expl_dmg_resonance: 0.08, AttrId.armor_em_dmg_resonance: 0.09, AttrId.armor_therm_dmg_resonance: 0.1, AttrId.armor_kin_dmg_resonance: 0.11, AttrId.armor_expl_dmg_resonance: 0.12, AttrId.shield_em_dmg_resonance: 0.13, AttrId.shield_therm_dmg_resonance: 0.14, AttrId.shield_kin_dmg_resonance: 0.15, AttrId.shield_expl_dmg_resonance: 0.16}).id) # Action res_stats = self.fit.stats.resists # Verification self.assertAlmostEqual(res_stats.hull.em, 0.95) self.assertAlmostEqual(res_stats.hull.thermal, 0.94) self.assertAlmostEqual(res_stats.hull.kinetic, 0.93) self.assertAlmostEqual(res_stats.hull.explosive, 0.92) self.assertAlmostEqual(res_stats.armor.em, 0.91) self.assertAlmostEqual(res_stats.armor.thermal, 0.9) self.assertAlmostEqual(res_stats.armor.kinetic, 0.89) self.assertAlmostEqual(res_stats.armor.explosive, 0.88) self.assertAlmostEqual(res_stats.shield.em, 0.87) self.assertAlmostEqual(res_stats.shield.thermal, 0.86) self.assertAlmostEqual(res_stats.shield.kinetic, 0.85) self.assertAlmostEqual(res_stats.shield.explosive, 0.84) # Cleanup self.assert_solsys_buffers_empty(self.fit.solar_system) self.assert_log_entries(0)