dave/pyfa
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 5 Wiki Activity

Remove tests

Browse Source
This commit is contained in:
DarkPhoenix
2013-06-10 22:14:40 +04:00
parent fd36a0b172
commit d6c67f2564
643 changed files with 0 additions and 82876 deletions
Download Patch File Download Diff File Expand all files Collapse all files

206
eos/tests/__init__.py
View File

@@ -1,206 +0,0 @@
#===============================================================================
# Copyright (C) 2010 Diego Duclos
# 2010 Anton Vorobyov
#
# This file and all other files in this folder (and its subfolders) are part of eos.
#
# eos is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# eos is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with eos. If not, see <http://www.gnu.org/licenses/>.
#===============================================================================
import unittest
from eos import db
from eos.types import Fit, Character, Skill, Ship, Module, Drone, Booster, Fleet, Wing, Squad, State
class TestBase(unittest.TestCase):
def setUp(self):
db.saveddata_meta.create_all()
def tearDown(self):
db.saveddata_meta.drop_all()
db.saveddata_session.expunge_all()
def __addFitItem(self, fit, item, state=None):
# Map textual description to actual states
statemap = {"offline": State.OFFLINE,
"online": State.ONLINE,
"active": State.ACTIVE,
"overheated": State.OVERHEATED}
# Gather some data about item being fitted
item_itm = db.getItem(item)
cat = item_itm.category.name.lower()
grp = item_itm.group.name.lower()
# Append it to proper category
if cat == "drone":
item_inst = Drone(item_itm)
fit.drones.append(item_inst)
elif cat in ("module", "subsystem"):
item_inst = Module(item_itm)
fit.modules.append(item_inst)
if state and state in statemap:
item_inst.state = statemap[state]
elif cat == "charge":
# Use dummy container for any charge
item_inst = Module(db.getItem("Bomb Launcher I"))
item_inst.charge = item_itm
fit.modules.append(item_inst)
elif cat == "implant" and grp == "booster":
item_inst = Booster(item_itm)
fit.boosters.append(item_inst)
# We need item_inst outside of the method
return item_inst
def __detectTupleType(self, tuple):
# Define acceptable textual state descriptions
states = ("offline", "online", "active", "overheated")
# Do not check anything, assume that it's proper item
if len(tuple) == 1:
return "itm"
# Detect if it's item with state or 2 single items
elif len(tuple) == 2:
if tuple[1] in states:
return "itmstt"
else:
return "itms"
elif len(tuple) > 2:
return "itms"
else:
return None
def __fitItems(self, fit, itms):
if isinstance(itms, (tuple, list)):
tt = self.__detectTupleType(itms)
if tt == "itm":
self.__addFitItem(fit, itms)
elif tt == "itmstt":
self.__addFitItem(fit, itms[0], state=itms[1])
elif tt == "itms":
for itm in itms:
if isinstance(itm, (tuple, list)):
tt = self.__detectTupleType(itm)
if tt == "itm":
self.__addFitItem(fit, itm)
elif tt == "itmstt":
self.__addFitItem(fit, itm[0], state=itm[1])
else:
self.__addFitItem(fit, itm)
elif itms:
self.__addFitItem(fit, itms)
def getItemAttr(self, attr, item, skill=None, ship="Rifter", getCharge=False, gang=False, miscitms=None):
# Create a fit which will be tested
fit = Fit()
# Create character for fit and assign it
char = Character("test")
# Assign skills to character only when requested
if not gang and skill:
skill_itm = db.getItem(skill[0])
skill_lvl = skill[1]
char.addSkill(Skill(skill_itm, skill_lvl))
fit.character = char
# Create ship and assign to fit; use default Rifter dummy
# in any case as some items affect ship attributes, they can't
# be tested w/o ship
fit.ship = Ship(db.getItem(ship))
# Create and fit an item which will be tested
item_inst = self.__addFitItem(fit, item)
# Add other modules which can affect ship attributes
if miscitms:
self.__fitItems(fit, miscitms)
# Finish composing of tested fit by calculating its attributes
fit.calculateModifiedAttributes()
# Use special fit as gang booster when requested
if gang:
# Do the same for character which will be
# squad booster
squad_fit = Fit()
squad_char = Character("squad_test")
# Add leadership skill which is required to boost squad members
squad_char.addSkill(Skill(db.getItem("Leadership"), 1))
if skill:
squad_skill_itm = db.getItem(skill[0])
squad_skill_lvl = skill[1]
squad_char.addSkill(Skill(squad_skill_itm, squad_skill_lvl))
squad_fit.character = squad_char
squad_fit.ship = Ship(db.getItem(ship))
squad_fit.calculateModifiedAttributes()
# Create full fleet structure and assign roles
squad = Squad()
squad.leader = squad_fit
squad.members.append(squad_fit)
squad.members.append(fit)
wing = Wing()
wing.squads.append(squad)
fleet = Fleet()
fleet.wings.append(wing)
# Calculate fleet relationships
fleet.calculateModifiedAttributes()
# Use charge as an item when it was requested to be tested,
# and passed item itself in all other cases
cat = db.getItem(item).category.name.lower()
if (cat == "drone" and getCharge) or cat == "charge":
result = item_inst.getModifiedChargeAttr(attr)
else:
result = item_inst.getModifiedItemAttr(attr)
return result
def getShipAttr(self, attr, ship="Rifter", skill=None, gang=False, miscitms=None, unmod=False):
# Create a fit for testing
fit = Fit()
# Create character for fit
char = Character("test")
# Assign skills only when we need to do so
if not gang and skill:
skill_itm = db.getItem(skill[0])
skill_lvl = skill[1]
char.addSkill(Skill(skill_itm, skill_lvl))
fit.character = char
# Create a ship and assign it to the fitting
fit.ship = Ship(db.getItem(ship))
# Add other modules which can affect ship attributes
if miscitms:
self.__fitItems(fit, miscitms)
# We're done, calculate attributes
fit.calculateModifiedAttributes()
# Define a gang booster
if gang:
squad_fit = Fit()
squad_char = Character("squad_test")
# Add leadership skill which is required to boost squad members
squad_char.addSkill(Skill(db.getItem("Leadership"), 1))
if skill:
squad_skill_itm = db.getItem(skill[0])
squad_skill_lvl = skill[1]
squad_char.addSkill(Skill(squad_skill_itm, squad_skill_lvl))
squad_fit.character = squad_char
squad_fit.ship = Ship(db.getItem(ship))
squad_fit.calculateModifiedAttributes()
squad = Squad()
squad.leader = squad_fit
squad.members.append(squad_fit)
squad.members.append(fit)
wing = Wing()
wing.squads.append(squad)
fleet = Fleet()
fleet.wings.append(wing)
fleet.calculateModifiedAttributes()
# Autodetect which attributes group to use
if attr in fit.extraAttributes:
result = fit.extraAttributes[attr]
else:
if unmod:
result = fit.ship.item.attributes[attr].value
else:
result = fit.ship.getModifiedItemAttr(attr)
return result

0
eos/tests/gamedata/__init__.py
View File

13
eos/tests/gamedata/testAttributes.py
View File

@@ -1,13 +0,0 @@
from eos.tests import TestBase
from eos import db
class Test(TestBase):
def test_attributeNamesMatch(self):
i = db.getItem("Gamma L")
for attrName, attr in i.attributes.iteritems():
self.assertEquals(attrName, attr.name)
def test_attributeUnit(self):
a = db.getAttributeInfo("maxVelocity")
self.assertEquals(a.unit.name, "Acceleration")
self.assertEquals(a.unit.displayName, "m/sec")

8
eos/tests/gamedata/testEffectHandlerLoading.py
View File

@@ -1,8 +0,0 @@
from eos.tests import TestBase
from eos import db
import types
class Test(TestBase):
def test_loadEffect(self):
i = db.getItem("Rifter")
self.assertEqual(type(i.effects["shipPDmgBonusMF"].handler), types.FunctionType)

44
eos/tests/gamedata/testGameDataQueries.py
View File

@@ -1,44 +0,0 @@
from eos.tests import TestBase
from eos import db
from eos.types import Item
class Test(TestBase):
def test_getItem(self):
i = db.getItem("Gamma L")
self.assertEqual(i.name, "Gamma L")
self.assertEqual(i.ID, 261)
def test_searchItems(self):
i = db.searchItems("Gamma L",where=Item.published == True)
self.assertEqual(len(i), 7)
def test_searchItemsWhere(self):
i = db.searchItems("Gamma L", where=Item.published == False)
self.assertEqual(len(i), 0)
def test_getVariations(self):
i = db.getItem("Gamma L")
vars = db.getVariations(i)
for var in vars:
self.assertEqual(var.metaGroup.parent, i)
def test_getVariationsMeta(self):
i = db.getItem("Gamma L")
vars = db.getVariations(i, metaGroups=4)
self.assertEquals(len(vars), 5)
def test_getMarketGroup(self):
m = db.getMarketGroup(157)
self.assertEquals(m.name, "Drones")
def test_getGroup(self):
g = db.getGroup(920)
self.assertEquals(g.name, "Effect Beacon")
def test_getCategory(self):
c = db.getCategory(6)
self.assertEquals(c.name, "Ship")
def test_getAttributeInfo(self):
i = db.getAttributeInfo(2)
self.assertEquals(i.name, "isOnline")

37
eos/tests/gamedata/testItem.py
View File

@@ -1,37 +0,0 @@
from eos.tests import TestBase
from eos import db
from eos.types import Skill
class Test(TestBase):
def test_race(self):
i = db.getItem("Dramiel")
self.assertEqual(i.race, "angel")
ii = db.getItem("Punisher")
self.assertEqual(ii.race, "amarr")
def test_requiredSkills(self):
i = db.getItem("Dramiel")
self.assertEquals(len(i.requiredSkills), 2)
skills = ("Minmatar Frigate", "Gallente Frigate")
for skill, level in i.requiredSkills.iteritems():
self.assertTrue(skill.name in skills)
self.assertEquals(level, 3)
def test_requiresSkill(self):
i = db.getItem("Shield Boost Amplifier II")
skill = db.getItem("Shield Management")
self.assertTrue(i.requiresSkill("Shield Management"))
self.assertTrue(i.requiresSkill("Shield Management", 5))
self.assertTrue(i.requiresSkill(skill, 5))
self.assertTrue(i.requiresSkill(skill))
self.assertFalse(i.requiresSkill(1302))
self.assertFalse(i.requiresSkill("Moo Management"), 9000)
self.assertTrue(i.requiresSkill(Skill(skill)))
def test_attrMover(self):
i = db.getItem("Rifter")
self.assertEquals(i.capacity, i.getAttribute("capacity"))
self.assertEquals(i.volume, i.getAttribute("volume"))
self.assertEquals(i.mass, i.getAttribute("mass"))

0
eos/tests/other/__init__.py
View File

62
eos/tests/other/testAttributeModifiers.py
View File

@@ -1,62 +0,0 @@
from eos.tests import TestBase
from eos.types import Drone
from eos import db
class Test(TestBase):
def test_increase(self):
d = Drone(db.getItem("Hobgoblin I"))
originalSpeed = d.itemModifiedAttributes["speed"]
d.increaseItemAttr("speed", 1302)
self.assertEquals(originalSpeed + 1302, d.itemModifiedAttributes["speed"])
def test_multiply(self):
d = Drone(db.getItem("Hobgoblin I"))
originalSpeed = d.itemModifiedAttributes["speed"]
d.multiplyItemAttr("speed", 2.35)
self.assertAlmostEquals(originalSpeed * 2.35, d.itemModifiedAttributes["speed"])
def test_boost(self):
d = Drone(db.getItem("Hobgoblin I"))
originalSpeed = d.itemModifiedAttributes["speed"]
d.boostItemAttr("speed", 20)
self.assertAlmostEquals(originalSpeed * 1.20, d.itemModifiedAttributes["speed"])
def test_stackingPenalizedMultiply(self):
d = Drone(db.getItem("Hobgoblin I"))
originalSpeed = d.itemModifiedAttributes["speed"]
d.multiplyItemAttr("speed", 2.35, stackingPenalties = True) #Should get penalties
d.multiplyItemAttr("speed", 2.6, stackingPenalties = True) #Shouldn't get penalties
d.multiplyItemAttr("speed", 0.4, stackingPenalties = True) #Shouldn't get penalties
d.multiplyItemAttr("speed", 0.6, stackingPenalties = True) #Should get penalties
self.assertAlmostEquals(originalSpeed * (1 + -0.4* 0.86911998) * 0.4 * (1 + 1.35 * 0.86911998) * (1 + 1.6),
d.itemModifiedAttributes["speed"], 2)
def test_stackingPenaltyMultiplyGroups(self):
d = Drone(db.getItem("Hobgoblin I"))
originalSpeed = d.itemModifiedAttributes["speed"]
d.multiplyItemAttr("speed", 2.1, stackingPenalties = True, penaltyGroup = "test1") #Shouldn't get penaltied
d.multiplyItemAttr("speed", 2.5, stackingPenalties = True, penaltyGroup = "test2") #Should get penaltied
d.multiplyItemAttr("speed", 2.7, stackingPenalties = True, penaltyGroup = "test2") #Shouldn't get penaltied
d.multiplyItemAttr("speed", 1.6, stackingPenalties = True, penaltyGroup = "test1") #Should get penaltied
self.assertAlmostEqual(originalSpeed * 2.1 * 2.7 * (1 + 1.5 * 0.86911998) * (1 + 0.6 * 0.86911998),
d.itemModifiedAttributes["speed"], 2)
def test_stackingPenalizedBoost(self):
d = Drone(db.getItem("Hobgoblin I"))
originalSpeed = d.itemModifiedAttributes["speed"]
d.boostItemAttr("speed", 35, stackingPenalties = True) #Should get penalties
d.boostItemAttr("speed", 60, stackingPenalties = True) #Shouldn't get penalties
d.boostItemAttr("speed", -40, stackingPenalties = True) #Should get penalties
d.boostItemAttr("speed", -60, stackingPenalties = True) #Shouldn't get penalties
self.assertAlmostEquals(originalSpeed * (1 + 0.35 * 0.86911998) * 1.6 * (1 - 0.6) * (1 - 0.4 * 0.86911998),
d.itemModifiedAttributes["speed"], 2)
def test_stackingPenaltyBoostGroups(self):
d = Drone(db.getItem("Hobgoblin I"))
originalSpeed = d.itemModifiedAttributes["speed"]
d.boostItemAttr("speed", 10, stackingPenalties = True, penaltyGroup = "test1") #Should get penaltied
d.boostItemAttr("speed", 50, stackingPenalties = True, penaltyGroup = "test2") #Should get penaltied
d.boostItemAttr("speed", 70, stackingPenalties = True, penaltyGroup = "test2") #Shouldn't get penaltied
d.boostItemAttr("speed", 60, stackingPenalties = True, penaltyGroup = "test1") #Shouldn't get penaltied
self.assertAlmostEqual(originalSpeed * (1 + 0.10 * 0.86911998) * (1 + 0.5 * 0.86911998) * 1.7 * 1.6,
d.itemModifiedAttributes["speed"], 2)

7
eos/tests/other/testDump.py
View File

@@ -1,7 +0,0 @@
from eos.tests import TestBase
from eos import db
class Test(TestBase):
def test_unicode(self):
# Deliberatly request something with non-ASCII symbol in it. Will crash if the dump isn't encoded correctly
db.getAttributeInfo(384)

57
eos/tests/other/testModifiedAttributeDict.py
View File

@@ -1,57 +0,0 @@
from eos.tests import TestBase
from eos.modifiedAttributeDict import ModifiedAttributeDict
from eos import db
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.dict = ModifiedAttributeDict()
self.i = db.getItem("125mm Gatling AutoCannon I")
def test_setValidOriginal(self):
self.dict.original = self.i.attributes
def test_originalAttributesMatch(self):
self.dict.original = self.i.attributes
for key,val in self.dict.items():
self.assertEqual(val, self.i.attributes[key].value)
def test_modificationWorks(self):
self.dict.original = self.i.attributes
self.dict["hp"] = 5
self.assertEqual(self.dict["hp"], 5)
def test_overrideAndCalculate(self):
self.dict.original = self.i.attributes
self.dict["hp"] = 5
self.dict.increase("hp", 5)
self.assertEqual(self.dict["hp"], 10)
def test_calculateOverride(self):
self.dict.original = self.i.attributes
self.dict.increase("hp", 10)
self.dict["hp"] = 5
self.assertEqual(self.dict["hp"], 15)
def test_originalNone(self):
self.dict.original = {}
self.assertEquals(self.dict["maeazhtg"], None)
def test_force(self):
self.dict.original = self.i.attributes
self.dict.force("hp", 9000)
self.dict.increase("hp",284)
self.dict.multiply("hp", 2487)
self.dict["hp"] = 1
self.assertEqual(self.dict["hp"], 9000)
def test_newValue(self):
self.dict.original = {}
self.dict["test"] = 3
self.dict.increase("test", 5)
self.assertEqual(self.dict["test"], 8)
def test_increaseInexistent(self):
self.dict.original = {}
self.dict.increase("test", 5)
self.assertEquals(self.dict["test"], 5)

72
eos/tests/runMassEffectTests.py
View File

@@ -1,72 +0,0 @@
#===============================================================================
# This file is part of eos.
#
# eos is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# eos is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with eos. If not, see <http://www.gnu.org/licenses/>.
#===============================================================================
if __name__ == "__main__":
print "starting"
import sys
import os.path
#Add the good path to sys.path
path = os.path.dirname(unicode(__file__, sys.getfilesystemencoding()))
sys.path.append(os.path.realpath(os.path.join(path, "..", "..")))
from eos.types import Effect
from eos.gamedata import effectDummy
print "checking files in effects folder"
list = os.listdir(os.path.join("../effects"))
def validate(fileName):
moduleName, ext = os.path.splitext(fileName)
return moduleName != "__init__" and ext == ".py"
list = filter(validate, list)
size = len(list)
print "found %d effects, starting checks:" % size
i = 0
lastError = -500
errors = 0
errorString = ""
for fileName in list:
moduleName, ext = os.path.splitext(fileName)
i += 1
if i / 50.0 == int(i / 50.0):
sys.stdout.write(".")
sys.stdout.flush()
e = Effect()
e.name = unicode(moduleName)
try:
e.init()
if e.handler == effectDummy:
errors += 1
sys.stdout.write("F")
errorString += "\n%s: No handler" % moduleName
if e.type is None:
errors += 1
sys.stdout.write("F")
errorString += "\n%s: No type" % moduleName
except Exception, exc:
errors += 1
sys.stdout.write("E")
errorString += "\n%s: Exception thrown: %s\n%s\n" % (moduleName, exc.__class__, exc)
sys.stderr.write(errorString)
print ""
print "Done"
print "%d errors with a total of %d effects (%.2f%%)" % (errors, size, float(errors) / size * 100)

64
eos/tests/runTests.py
View File

@@ -1,64 +0,0 @@
#!/usr/bin/env python
#===============================================================================
# This file is part of eos.
#
# eos is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# eos is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with eos. If not, see <http://www.gnu.org/licenses/>.
#===============================================================================
import unittest, os.path, sys
#Add the good path to sys.path
path = os.path.dirname(unicode(__file__, sys.getfilesystemencoding()))
sys.path.append(os.path.realpath(os.path.join(path, "..", "..")))
from eos import config
config.debug = False
config.saveddata_connectionstring = "sqlite:///:memory:"
config.saveddataCache = None
class Loader(unittest.TestLoader):
def loadTestsFromName(self, name, module = None):
if name == "discover":
return iteratedir(os.path.dirname(__file__))
else:
prefix = name.split(".")
fullpath = os.path.join(os.path.dirname(__file__), *prefix)
if os.path.isdir(os.path.join(fullpath)):
return iteratedir(fullpath, prefix)
else:
module = __import__(name, fromlist=True)
return self.loadTestsFromModule(module)
loader = Loader()
def iteratedir(dir, prefix = [], suite = None):
suite = suite if suite is not None else unittest.TestSuite()
for filename in os.listdir(dir or '.'):
moduleName, ext = os.path.splitext(filename)
moduleName = '.'.join(prefix + [moduleName])
if os.path.isdir(os.path.join(dir, filename)):
module = __import__(moduleName + ".__init__", fromlist = True)
subSuite = unittest.TestSuite()
suite.addTest(subSuite)
iteratedir(os.path.join(dir, filename), prefix + [filename], subSuite)
if ext == ".py" and moduleName not in ("__init__", "runTests", "runMassEffectTests"):
module = __import__(moduleName, fromlist = True)
suite.addTest(loader.loadTestsFromModule(module))
return suite
if __name__ == "__main__":
unittest.main(defaultTest="discover", testLoader=loader)

0
eos/tests/saveddata/__init__.py
View File

103
eos/tests/saveddata/testBooster.py
View File

@@ -1,103 +0,0 @@
from eos.tests import TestBase
from eos import db
from eos.types import Booster, Fit, User, Ship
import sqlalchemy.orm
import eos.db.saveddata.queries
from copy import deepcopy
class Test(TestBase):
def test_setInvalidBooster(self):
try:
Booster(db.getItem("Gamma L"))
except ValueError:
return
self.fail("Expected a ValueError when trying to use Gamma L as a booster")
def test_setValidBooster(self):
b = Booster(db.getItem("Strong Drop Booster"))
self.assertEquals(2, b.slot)
i = 0
for _ in b.iterSideEffects():
i+= 1
self.assertEquals(4, i)
def test_testEffectList(self):
b = Booster(db.getItem("Strong Drop Booster"))
i = 0
names = ("boosterTurretFalloffPenalty", "boosterArmorRepairAmountPenalty",
"boosterMaxVelocityPenalty", "boosterShieldCapacityPenalty")
for sideEffect in b.iterSideEffects():
i += 1
if not sideEffect.effect.name in names:
self.fail("Invalid effect " + sideEffect.effect.name)
self.assertEquals(4, i)
def test_clear(self):
b = Booster(db.getItem("Strong Drop Booster"))
orig = b.getModifiedItemAttr("trackingSpeedMultiplier")
b.itemModifiedAttributes["trackingSpeedMultiplier"] = 5
b.clear()
self.assertEquals(b.getModifiedItemAttr("trackingSpeedMultiplier"), orig)
def test_databaseConsistency(self):
oldSession = db.saveddata_session
oldSession.commit()
try:
f = Fit()
f.ship = Ship(db.getItem("Rifter"))
f.owner = User("boostertest", "testy", False)
b = Booster(db.getItem("Strong Drop Booster"))
b.active = True
activate = ("boosterTurretFalloffPenalty", "boosterArmorRepairAmountPenalty")
for sideEffect in b.iterSideEffects():
if sideEffect.effect.name in activate:
sideEffect.active = True
f.boosters.append(b)
db.saveddata_session.add(f)
db.saveddata_session.flush()
fitID = f.ID
f1id = id(f)
b1id = id(b)
#Hack our way through changing the session temporarly
oldSession = eos.db.saveddata.queries.saveddata_session
eos.db.saveddata.queries.saveddata_session = sqlalchemy.orm.sessionmaker(bind=db.saveddata_engine)()
f = db.getFit(fitID)
self.assertNotEquals(f1id, id(f))
i = 0
for b in f.boosters:
i += 1
booster = b
self.assertTrue(b.active)
self.assertNotEquals(b1id, id(booster))
self.assertEquals(i, 1)
for sideEffect in booster.iterSideEffects():
self.assertEquals(sideEffect.effect.name in activate, sideEffect.active)
except:
db.saveddata_session.rollback()
raise
finally:
#Undo our hack as to not fuck up anything
eos.db.saveddata.queries.saveddata_session = oldSession
def test_copy(self):
b = Booster(db.getItem("Strong Drop Booster"))
b.active = False
activate = ("boosterTurretFalloffPenalty", "boosterArmorRepairAmountPenalty")
for sideEffect in b.iterSideEffects():
if sideEffect.effect.name in activate:
sideEffect.active = True
copy = deepcopy(b)
self.assertNotEquals(id(b), id(copy))
self.assertEquals(b.item, copy.item)
self.assertEquals(b.active, copy.active)
for sideEffect in copy.iterSideEffects():
self.assertEquals(sideEffect.effect.name in activate, sideEffect.active)

106
eos/tests/saveddata/testCharacter.py
View File

@@ -1,106 +0,0 @@
from eos.tests import TestBase
from eos.types import Character, User, Fit, Skill, Ship
from eos.saveddata.character import ReadOnlyException
from eos import db
import eos.db.saveddata.queries
import sqlalchemy.orm
from copy import deepcopy
class Test(TestBase):
def test_databaseConsistency(self):
oldSession = db.saveddata_session
oldSession.commit()
try:
f = Fit()
f.ship = Ship(db.getItem("Rifter"))
c = Character("testChar")
f.character = c
u = User("testChar", "moo", False)
f.owner = u
c.owner = u
c.addSkill(Skill(db.getItem("Caldari Frigate"), 3))
c.addSkill(Skill(db.getItem("Gallente Frigate"), 1))
c.addSkill(Skill(db.getItem("Gallente Industrial"), 5))
db.saveddata_session.add(u)
db.saveddata_session.add(c)
db.saveddata_session.add(f)
db.saveddata_session.flush()
#Hack our way through changing the session temporarly
oldSession = eos.db.saveddata.queries.saveddata_session
eos.db.saveddata.queries.saveddata_session = sqlalchemy.orm.sessionmaker(bind=db.saveddata_engine)()
newf = db.getFit(f.ID)
newu = db.getUser(u.ID)
newc = newu.characters[0]
self.assertNotEquals(id(newf), id(f))
self.assertNotEquals(id(newu), id(u))
self.assertNotEquals(id(newc), id(c))
self.assertEquals(len(newu.characters), 1)
self.assertEquals(f.character.ID, newf.character.ID)
skillDict= {"Caldari Frigate" : 3,
"Gallente Frigate" : 1,
"Gallente Industrial" : 5}
for skill in newc.iterSkills():
self.assertTrue(skillDict.has_key(skill.item.name))
self.assertEquals(skillDict[skill.item.name], skill.level)
except:
db.saveddata_session.rollback()
raise
finally:
#Undo our hack as to not fuck up anything
eos.db.saveddata.queries.saveddata_session = oldSession
def test_suppress(self):
s = Skill(db.getItem("Caldari Frigate"))
s.suppress()
self.assertTrue(s.isSuppressed())
s.clear()
self.assertFalse(s.isSuppressed())
def test_getSkill(self):
c = Character("testetyChar")
s1 = Skill(db.getItem("Caldari Frigate"), 3)
c.addSkill(s1)
c.addSkill(Skill(db.getItem("Gallente Frigate"), 1))
c.addSkill(Skill(db.getItem("Gallente Industrial"), 5))
self.assertEquals(c.getSkill(s1.item.name), s1)
self.assertEquals(c.getSkill(s1.item.ID), s1)
self.assertEquals(c.getSkill(s1.item), s1)
def test_readOnly(self):
s = Skill(db.getItem("Caldari Frigate"), 3, True)
try:
s.level = 5
except ReadOnlyException:
return
self.fail("Expected ReadOnlyExcption, didn't get it")
def test_all0(self):
c = Character.getAll0()
for skill in c.iterSkills():
self.assertEquals(skill.level, 0)
def test_all5(self):
c = Character.getAll5()
for skill in c.iterSkills():
self.assertEquals(skill.level, 5)
def test_copy(self):
c = Character("TEST")
s = c.getSkill("Leadership")
s.level = 5
c.apiKey = "FHIGUUHVBIUHYUIGOYHUIORUIUOHYIUGUIERYGIUUYI9U0BGUYYOIIGHIUHIUYGU"
c.apiID = 43636
copy = deepcopy(c)
self.assertNotEquals(id(c), id(copy))
self.assertEquals(c.apiKey, copy.apiKey)
self.assertEquals(c.apiID, copy.apiID)
self.assertEquals("%s copy" % c.name, copy.name)
news = copy.getSkill("Leadership")
self.assertNotEquals(id(s), id(news))
self.assertEquals(s.level, news.level)

69
eos/tests/saveddata/testDamagePattern.py
View File

@@ -1,69 +0,0 @@
from eos.tests import TestBase
from eos import db
from eos.types import Fit, DamagePattern, Ship, Module, State
class Test(TestBase):
def test_rawEhp(self):
f = Fit()
f.ship = Ship(db.getItem("Wolf"))
expected = 0
for type in ("shieldCapacity", "armorHP", "hp"):
expected += f.ship.getModifiedItemAttr(type)
self.assertEquals(expected, sum(f.ehp.values()))
def test_uniformEhp(self):
f = Fit()
f.ship = Ship(db.getItem("Wolf"))
f.damagePattern = DamagePattern(25, 25, 25 ,25)
self.assertAlmostEquals(3094, sum(f.ehp.values()), 0)
def test_passiveRechargeUniform(self):
f = Fit()
f.ship = Ship(db.getItem("Wolf"))
f.damagePattern = DamagePattern(25, 25, 25, 25)
self.assertAlmostEquals(3.86, f.effectiveTank["passiveShield"], 2)
def test_armorRepairUniform(self):
f = Fit()
f.ship = Ship(db.getItem("Wolf"))
f.damagePattern = DamagePattern(25, 25, 25 ,25)
m = Module(db.getItem("Small Armor Repairer I"))
m.state = State.ACTIVE
f.modules.append(m)
f.calculateModifiedAttributes()
self.assertAlmostEquals(19.3, f.effectiveTank["armorRepair"], 1)
def test_shieldBoostUniform(self):
f = Fit()
f.ship = Ship(db.getItem("Wolf"))
f.damagePattern = DamagePattern(25, 25, 25 ,25)
m = Module(db.getItem("Small Shield Booster I"))
m.state = State.ACTIVE
f.modules.append(m)
f.calculateModifiedAttributes()
self.assertAlmostEquals(26.3, f.effectiveTank["shieldRepair"],1)
def test_hullRepairUniform(self):
f = Fit()
f.ship = Ship(db.getItem("Wolf"))
f.damagePattern = DamagePattern(25, 25, 25 ,25)
m = Module(db.getItem("Small Hull Repairer I"))
m.state = State.ACTIVE
f.modules.append(m)
f.calculateModifiedAttributes()
self.assertAlmostEquals(f.extraAttributes["hullRepair"], f.effectiveTank["hullRepair"],1)
def test_importPattern(self):
d = DamagePattern.importPatterns("Test = EM:5, THERM:42, KIN:1302, EXP:6")[0]
self.assertEquals(d.name, "Test")
self.assertEquals(d.emAmount, 5)
self.assertEquals(d.thermalAmount, 42)
self.assertEquals(d.kineticAmount, 1302)
self.assertEquals(d.explosiveAmount, 6)
def test_exportPattern(self):
d = DamagePattern(5, 42, 1302, 6)
d.name = "Test"
self.assertEquals(DamagePattern.exportPatterns(d), "Test = EM:5, Therm:42, Kin:1302, Exp:6")

86
eos/tests/saveddata/testDrone.py
View File

@@ -1,86 +0,0 @@
from eos.tests import TestBase
from eos import db
from eos.types import Drone, Fit, User, Ship
import eos.db.saveddata.queries
import sqlalchemy.orm
from copy import deepcopy
class Test(TestBase):
def test_clear(self):
d = Drone(db.getItem("Hobgoblin I"))
orig = d.getModifiedItemAttr("hp")
d.itemModifiedAttributes["hp"] = 5
d.clear()
self.assertEquals(d.getModifiedItemAttr("hp"), orig)
def test_databaseConsistency(self):
oldSession = db.saveddata_session
oldSession.commit()
try:
f = Fit()
f.owner = User("dronetest", "testy", False)
f.ship = Ship(db.getItem("Rifter"))
i = db.getItem("Hobgoblin I")
d = f.drones.appendItem(i, 5)
d.amountActive = 3
d2 = f.projectedDrones.appendItem(i, 3)
f1id = id(f)
d1id = id(d)
db.saveddata_session.add(f)
db.saveddata_session.add(d)
db.saveddata_session.flush()
fitID = f.ID
#Hack our way through changing the session temporarly
oldSession = eos.db.saveddata.queries.saveddata_session
eos.db.saveddata.queries.saveddata_session = sqlalchemy.orm.sessionmaker(bind=db.saveddata_engine)()
f = db.getFit(fitID)
self.assertNotEquals(id(f), f1id)
c = 0
for d in f.drones:
c += 1
self.assertNotEquals(id(d), d1id)
self.assertEquals(c, 1)
self.assertEquals(d.item.ID, i.ID)
self.assertEquals(d.amount, 5)
self.assertEquals(d.amountActive, 3)
c = 0
for d in f.projectedDrones:
c += 1
self.assertNotEquals(id(d2), id(d))
self.assertEquals(c, 1)
self.assertEquals(d.item.ID, i.ID)
self.assertEquals(d.amount, 3)
except:
db.saveddata_session.rollback()
raise
finally:
#Undo our hack as to not fuck up anything
eos.db.saveddata.queries.saveddata_session = oldSession
def test_copy(self):
d = Drone(db.getItem("Hobgoblin I"))
d.amount = 3
d.amountActive = 1
c = deepcopy(d)
self.assertNotEquals(id(d), id(c))
self.assertEquals(d.item, c.item)
self.assertEquals(d.amount, c.amount)
self.assertEquals(d.amountActive, c.amountActive)
def test_dps(self):
d = Drone(db.getItem("Hobgoblin I"))
d.amount = 3
d.amountActive = 1
self.assertEquals(d.dps, 6)

65
eos/tests/saveddata/testFilteredModifiers.py
View File

@@ -1,65 +0,0 @@
from eos.tests import TestBase
from eos import db
from eos.types import Fit
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.f = Fit()
self.i1 = db.getItem("Cyclops")
self.i2 = db.getItem("Cyclops")
self.charge = db.getItem("Compact Purgatory Torpedo I")
self.f.drones.appendItem(self.i1, 1)
self.f.drones.appendItem(self.i2, 1)
def test_filteredItemIncrease(self):
self.f.drones.filteredItemIncrease(lambda d: d.item.ID == self.i1.ID, "hp", 5)
for d in self.f.drones:
if d.item.ID == self.i1.ID:
self.assertEquals(d.itemModifiedAttributes["hp"], self.i1.getAttribute("hp") + 5)
else:
self.assertEquals(d.itemModifiedAttributes["hp"], self.i2.getAttribute("hp"))
def test_filteredItemMultiply(self):
self.f.drones.filteredItemMultiply(lambda d: d.item.ID == self.i1.ID, "hp", 5)
for d in self.f.drones:
if d.item.ID == self.i1.ID:
self.assertEquals(d.itemModifiedAttributes["hp"], self.i1.getAttribute("hp") * 5)
else:
self.assertEquals(d.itemModifiedAttributes["hp"], self.i2.getAttribute("hp"))
def test_filteredItemBoost(self):
self.f.drones.filteredItemBoost(lambda d: d.item.ID == self.i1.ID, "hp", 5)
for d in self.f.drones:
if d.item.ID == self.i1.ID:
self.assertEquals(d.itemModifiedAttributes["hp"], self.i1.getAttribute("hp") * 1.05)
else:
self.assertEquals(d.itemModifiedAttributes["hp"], self.i2.getAttribute("hp"))
def test_filteredChargeIncrease(self):
self.f.drones.filteredChargeIncrease(lambda d: d.item.ID == self.i1.ID, "hp", 5)
for d in self.f.drones:
if d.item.ID == self.i1.ID:
self.assertEquals(d.chargeModifiedAttributes["hp"], self.charge.getAttribute("hp") + 5)
else:
self.assertEquals(d.chargeModifiedAttributes["hp"], self.charge.getAttribute("hp"))
def test_filteredChargeMultiply(self):
self.f.drones.filteredChargeMultiply(lambda d: d.item.ID == self.i1.ID, "hp", 5)
for d in self.f.drones:
if d.item.ID == self.i1.ID:
self.assertEquals(d.chargeModifiedAttributes["hp"], self.charge.getAttribute("hp") * 5)
else:
self.assertEquals(d.chargeModifiedAttributes["hp"], self.charge.getAttribute("hp"))
def test_filteredChargeBoost(self):
self.f.drones.filteredChargeBoost(lambda d: d.item.ID == self.i1.ID, "hp", 5)
for d in self.f.drones:
if d.item.ID == self.i1.ID:
self.assertEquals(d.chargeModifiedAttributes["hp"], self.charge.getAttribute("hp") * 1.05)
else:
self.assertEquals(d.chargeModifiedAttributes["hp"], self.charge.getAttribute("hp"))

467
eos/tests/saveddata/testFit.py
View File

@@ -1,467 +0,0 @@
from eos.tests import TestBase
from eos.types import Fit, Character, Slot, Module, Ship, User, State, Drone, Implant, Booster, Hardpoint, DamagePattern
from eos import db
import eos.db.saveddata.queries
import sqlalchemy.orm
from copy import deepcopy
from itertools import count
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.m = Module(db.getItem("Heat Sink I"))
def test_tankNumbers(self):
f = Fit()
f.ship = Ship(db.getItem("Erebus"))
f.modules.append(Module(db.getItem("Small Shield Booster II")))
f.modules.append(Module(db.getItem("Small Armor Repairer II")))
f.modules.append(Module(db.getItem("Small Hull Repairer II")))
f.modules.append(Module(db.getItem("Damage Control II")))
f.damagePattern = DamagePattern(25, 25, 25, 25)
for m in f.modules:
m.state = State.ACTIVE
f.calculateModifiedAttributes()
self.assertEquals(len(f.effectiveTank), len(f.tank))
for k in f.effectiveTank.iterkeys():
self.assertGreater(f.effectiveTank[k], f.tank[k])
self.assertEquals(len(f.effectiveSustainableTank), len(f.sustainableTank))
for k in f.effectiveSustainableTank.iterkeys():
self.assertGreater(f.effectiveSustainableTank[k], f.sustainableTank[k])
def test_addDrain(self):
f = Fit()
f.ship = Ship(db.getItem("Rifter"))
f.addDrain(5, 500, 0)
self.assertEquals(f.capUsed, 100000)
def test_setCharacter(self):
f = Fit()
f.character = Character("Testety")
def test_addNotAModule(self):
try:
self.f.addModule(1302)
except:
return
self.fail("Added an invalid module, was expecting a ValueError")
def test_addValidModule(self):
f = Fit()
f.modules.append(self.m)
def test_importEft(self):
f = Fit.importEft('''[Rifter, Test]
Salvager I
Hobgoblin I x4''')
self.assertEquals(f.name, "Test")
self.assertEquals(f.ship.item.name, "Rifter")
self.assertEquals(f.modules[0].item.name, "Salvager I")
self.assertEquals(f.drones[0].amount, 4)
self.assertEquals(f.drones[0].item.name, "Hobgoblin I")
def test_importXml(self):
fits = Fit.importXml('''<?xml version="1.0" ?>
<fittings>
<fitting name="Test">
<description value=""/>
<shipType value="Rifter"/>
<hardware slot="hi slot 0" type="Salvager II"/>
</fitting>
</fittings>''')
f = fits[0]
self.assertEquals(f.name, "Test")
self.assertEquals(f.ship.item.name, "Rifter")
self.assertEquals(f.modules[0].item.name, "Salvager II")
def test_removeModuleNotExists(self):
f = Fit()
self.assertRaises(ValueError, f.modules.remove, self.m)
def test_removeModuleExists(self):
f = Fit()
f.modules.append(self.m)
f.modules.remove(self.m)
def test_removeInvalidModule(self):
f = Fit()
self.assertRaises(ValueError, f.modules.remove, 1302)
def test_setShip(self):
f = Fit()
f.ship = Ship(db.getItem("Rifter"))
def test_extraAttributesClear(self):
f = Fit()
f.extraAttributes["cloaked"] = True
f.clear()
self.assertEqual(f.extraAttributes["cloaked"], False)
def test_databaseConsistency(self):
oldSession = db.saveddata_session
oldSession.commit()
try:
f = Fit()
f.ship = Ship(db.getItem("Rifter"))
f.name = "test fit 1"
u = User("fittest", "testy", False)
f.owner = u
f2 = Fit()
f2.ship = Ship(db.getItem("Thrasher"))
f2.name = "test fit 2"
f2.owner = u
db.saveddata_session.add(f)
db.saveddata_session.add(f2)
db.saveddata_session.flush()
f.projectedFits.append(f2)
#Hack our way through changing the session temporarly
oldSession = eos.db.saveddata.queries.saveddata_session
eos.db.saveddata.queries.saveddata_session = sqlalchemy.orm.sessionmaker(bind=db.saveddata_engine)()
newf = db.getFit(f.ID)
self.assertNotEquals(id(newf), id(f))
self.assertEquals(f.name, newf.name)
for fit in newf.projectedFits:
self.assertNotEqual(id(fit), id(f2))
self.assertEquals(f2.name, fit.name)
except:
db.saveddata_session.rollback()
raise
finally:
#Undo our hack as to not fuck up anything
eos.db.saveddata.queries.saveddata_session = oldSession
def test_projectedFit(self):
f1 = Fit()
f1.ship = Ship(db.getItem("Rifter"))
f2 = Fit()
m1 = Module(db.getItem("Stasis Webifier I"))
m2 = Module(db.getItem("Stasis Webifier I"))
m1.state = State.ACTIVE
m2.state = State.ACTIVE
f2.modules.append(m1)
f2.modules.append(m2)
f1.projectedFits.append(f2)
f1.calculateModifiedAttributes()
self.assertAlmostEquals(99.800, f1.ship.getModifiedItemAttr("maxVelocity"), 3)
def test_projectSelf(self):
f = Fit()
f.ship = Ship(db.getItem("Rifter"))
m1 = Module(db.getItem("Stasis Webifier I"))
m2 = Module(db.getItem("Stasis Webifier I"))
m1.state = State.ACTIVE
m2.state = State.ACTIVE
f.modules.append(m1)
f.modules.append(m2)
f.projectedFits.append(f)
f.calculateModifiedAttributes()
self.assertAlmostEquals(99.800, f.ship.getModifiedItemAttr("maxVelocity"), 3)
def test_capacitorNoMods(self):
f = Fit()
f.ship = Ship(db.getItem("Rifter"))
self.assertEquals(f.capStable, True)
self.assertAlmostEquals(f.capState, 100, 1)
def test_capacitorUnstable(self):
f = Fit()
f.ship = Ship(db.getItem("Rifter"))
m = Module(db.getItem("100MN Afterburner I"))
m.state = State.ACTIVE
f.modules.append(m)
self.assertFalse(f.capStable)
self.assertTrue(f.capState < 15)
def test_capacitorSingleCycleKill(self):
f = Fit()
f.ship = Ship(db.getItem("Rifter"))
for _ in xrange(5):
m = Module(db.getItem("100MN Afterburner I"))
m.state = State.ACTIVE
f.modules.append(m)
self.assertFalse(f.capStable)
self.assertEquals(f.capState, 0)
def test_copy(self):
f = Fit()
f.name = "Testety"
f.character = Character("TEST")
f.owner = User("moo")
testm = Module(db.getItem("Heat Sink I"))
f.modules.append(testm)
tests = Ship(db.getItem("Rifter"))
f.ship = tests
testpm = Module(db.getItem("Stasis Webifier I"))
f.projectedModules.append(testpm)
testd = Drone(db.getItem("Hobgoblin I"))
f.drones.append(testd)
testi = Implant(db.getItem("Halo Omega"))
f.implants.append(testi)
testb = Booster(db.getItem("Strong Drop Booster"))
f.boosters.append(testb)
testpd = Drone(db.getItem("Warrior TP-300"))
f.projectedDrones.append(testpd)
testpf = Fit()
f.ship = Ship(db.getItem("Rifter"))
f.name = "Projected"
f.projectedFits.append(testpf)
newf = deepcopy(f)
self.assertEquals(newf.name, "%s copy" % f.name)
self.assertEquals(newf.character, f.character)
self.assertEquals(newf.owner, f.owner)
newm = newf.modules[0]
self.assertNotEquals(id(newm), id(testm))
self.assertEquals(len(newf.modules), len(f.modules))
newpm = newf.projectedModules[0]
self.assertNotEquals(id(newpm), id(testpm))
self.assertEquals(len(newf.projectedModules), len(f.projectedModules))
newd = newf.drones[0]
self.assertNotEquals(id(newd), id(testd))
self.assertEquals(len(newf.drones), len(f.drones))
newb = newf.boosters[0]
self.assertNotEquals(id(newb), id(testb))
self.assertEquals(len(newf.boosters), len(f.boosters))
newi = newf.implants[0]
self.assertNotEquals(id(newi), id(testi))
self.assertEquals(len(newf.implants), len(f.implants))
newpd = newf.projectedDrones[0]
self.assertNotEquals(id(newpd), id(testpd))
self.assertEquals(len(newf.projectedDrones), len(f.projectedDrones))
newpm = newf.projectedModules[0]
self.assertNotEquals(id(newpm), id(testpm))
self.assertEquals(len(newf.projectedModules), len(f.projectedModules))
newpf = newf.projectedFits[0]
self.assertEquals(id(newpf), id(testpf))
self.assertEquals(len(newf.projectedFits), len(f.projectedFits))
def test_repperSustainability(self):
f = Fit()
f.ship = Ship(db.getItem("Raven"))
m = Module(db.getItem("Small Shield Booster I"))
m.state = State.ACTIVE
f.modules.append(m)
f.calculateModifiedAttributes()
s = f.calculateSustainableTank()
self.assertEquals(s["armorRepair"], f.extraAttributes["armorRepair"])
def test_zeroSustainable(self):
f = Fit()
f.ship = Ship(db.getItem("Rifter"))
for i in count(1):
if i == 5: break
m = Module(db.getItem("Heavy Energy Neutralizer I"))
m.state = State.ACTIVE
f.modules.append(m)
m = Module(db.getItem("Small Shield Booster I"))
m.state = State.ACTIVE
f.modules.append(m)
f.calculateModifiedAttributes()
s = f.calculateSustainableTank()
self.assertEquals(s["armorRepair"], 0)
def test_sustainabilityConsistency(self):
f = Fit()
f.ship = Ship(db.getItem("Rifter"))
for i in count(1):
if i == 3: break
m = Module(db.getItem("Small Shield Booster I"))
m.state = State.ACTIVE
f.modules.append(m)
f.calculateModifiedAttributes()
s = f.sustainableTank
self.assertAlmostEquals(s["shieldRepair"], 3.8, 1)
def test_capCalcs(self):
f = Fit()
f.ship = Ship(db.getItem("Reaper"))
f.ship.itemModifiedAttributes["capacitorCapacity"] = 125.0
f.ship.itemModifiedAttributes["rechargeRate"] = 93250
m = Module(db.getItem("Small Shield Booster I"))
m.state = State.ACTIVE
f.modules.append(m)
self.assertAlmostEquals(f.capState, 14.0, 1)
def test_weaponDPS(self):
f = Fit()
m = Module(db.getItem("Heavy Modulated Energy Beam I"))
m.state = State.ACTIVE
m.charge = db.getItem("Multifrequency M")
f.modules.append(m)
expected = 0
for type in ("emDamage", "thermalDamage", "kineticDamage", "explosiveDamage"):
expected += m.getModifiedChargeAttr(type)
expected *= m.getModifiedItemAttr("damageMultiplier") / (m.getModifiedItemAttr("speed") / 1000.0)
self.assertAlmostEquals(f.weaponDPS, expected)
def test_weaponVolley(self):
f = Fit()
m = Module(db.getItem("Heavy Modulated Energy Beam I"))
m.state = State.ACTIVE
m.charge = db.getItem("Multifrequency M")
f.modules.append(m)
expected = 0
for type in ("emDamage", "thermalDamage", "kineticDamage", "explosiveDamage"):
expected += m.getModifiedChargeAttr(type)
expected *= m.getModifiedItemAttr("damageMultiplier")
self.assertAlmostEquals(f.weaponVolley, expected)
def test_droneDPS(self):
f = Fit()
d = Drone(db.getItem("Hammerhead II"))
d.active = True
d.amount = 3
d.amountActive = 3
f.drones.append(d)
expected = 0
for type in ("emDamage", "thermalDamage", "kineticDamage", "explosiveDamage"):
expected += d.getModifiedItemAttr(type)
expected *= d.getModifiedItemAttr("damageMultiplier") / (d.getModifiedItemAttr("speed") / 1000.0)
self.assertAlmostEquals(f.droneDPS, expected * 3)
def test_missileDroneDPS(self):
f = Fit()
d = Drone(db.getItem("Cyclops"))
d.active = True
d.amount = 2
d.amountActive = 2
f.drones.append(d)
expected = 0
for type in ("emDamage", "thermalDamage", "kineticDamage", "explosiveDamage"):
expected += d.getModifiedChargeAttr(type)
expected /= d.getModifiedItemAttr("missileLaunchDuration") / 1000.0
self.assertAlmostEquals(f.droneDPS, expected * 2)
def test_hardpointCount(self):
f = Fit()
f.modules.append(Module(db.getItem("Heavy Modulated Energy Beam I")))
f.modules.append(Module(db.getItem("Standard Missile Launcher I")))
f.modules.append(Module(db.getItem("Salvager I")))
self.assertEquals(f.getHardpointsUsed(Hardpoint.MISSILE), 1)
self.assertEquals(f.getHardpointsUsed(Hardpoint.TURRET), 1)
def test_fill(self):
f = Fit()
f.ship = Ship(db.getItem("Rifter"))
f.fill()
self.assertEquals(len(f.modules), 13)
def test_fillT3(self):
f = Fit()
f.ship = Ship(db.getItem("Tengu"))
f.modules.append(Module(db.getItem("Tengu Defensive - Adaptive Shielding")))
f.clear()
f.calculateModifiedAttributes()
f.fill()
self.assertEquals(len(f.modules), 10)
def test_fillTooMuchDummies(self):
f = Fit()
f.ship = Ship(db.getItem("Rifter"))
for _ in xrange(5):
f.modules.append(Module.buildEmpty(Slot.LOW))
f.fill()
self.assertEquals(len(f.modules), 13)
def test_fillOrdering(self):
f = Fit()
f.ship = Ship(db.getItem("Rifter"))
f.fill()
for i, mod in enumerate(f.modules):
self.assertEquals(i, mod.position)
def test_getSlotsUsed(self):
f = Fit()
f.ship = Ship(db.getItem("Rifter"))
f.modules.append(Module(db.getItem("Salvager I")))
f.fill()
self.assertEquals(f.getSlotsUsed(Slot.HIGH), 1)
def test_getCalibrationUsed(self):
f = Fit()
f.ship = Ship(db.getItem("Rifter"))
f.modules.append(Module(db.getItem("Large Trimark Armor Pump I")))
self.assertEquals(f.calibrationUsed, 50)
def test_pgUsed(self):
f = Fit()
f.ship = Ship(db.getItem("Rifter"))
f.modules.append(Module(db.getItem("Salvager I")))
self.assertEquals(f.pgUsed, 1)
def test_cpuUsed(self):
f = Fit()
f.ship = Ship(db.getItem("Rifter"))
f.modules.append(Module(db.getItem("Salvager I")))
self.assertEquals(f.cpuUsed, 20)
def test_droneBandwidthUsed(self):
f = Fit()
f.ship = Ship(db.getItem("Rifter"))
d = Drone(db.getItem("Hobgoblin I"))
d.amount = 1
d.amountActive = 1
f.drones.append(d)
self.assertEquals(f.droneBandwidthUsed, 5)
def test_droneBayUsed(self):
f = Fit()
f.ship = Ship(db.getItem("Rifter"))
f.drones.appendItem(db.getItem("Hobgoblin I"))
self.assertEquals(f.droneBayUsed, 5)
def test_addRemoveFit(self):
f = Fit()
rifter = db.getItem("Rifter")
f.ship = Ship(rifter)
f.fill()
db.saveddata_session.add(f)
db.saveddata_session.flush()
db.saveddata_session.delete(f)
db.saveddata_session.flush()
def test_removeDrone(self):
f = Fit()
gob = db.getItem("Hobgoblin I")
f.drones.appendItem(gob)
f.drones.removeItem(gob, 1)
def test_scanStr(self):
f = Fit()
f.ship = Ship(db.getItem("Rifter"))
self.assertEquals("Ladar", f.scanType)

75
eos/tests/saveddata/testFleet.py
View File

@@ -1,75 +0,0 @@
from eos.tests import TestBase
from eos import db
from eos.types import Fleet, Wing, Squad, Ship, Fit, Module, Character
import copy
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
g = Fleet()
w = Wing()
s = Squad()
self.g = g
self.s = s
self.w = w
g.wings.append(w)
w.squads.append(s)
f = Fit()
self.s.members.append(f)
self.s.members.append(Fit())
self.s.leader = f
f.ship = Ship(db.getItem("Rifter"))
f.character = Character("testety")
f.character.getSkill("Leadership").level = 5
def test_copy(self):
c = copy.deepcopy(self.g)
self.assertNotEquals(id(c), id(self.g))
self.assertEquals(len(c.wings), 1)
wing = c.wings[0]
self.assertNotEquals(id(wing), id(self.w))
self.assertEquals(len(wing.squads), 1)
squad = wing.squads[0]
self.assertNotEquals(id(squad), id(self.s))
self.assertEquals(len(squad.members), 2)
def test_skillGang(self):
self.s.leader.character.getSkill("Leadership").level = 5
self.g.calculateModifiedAttributes()
new = self.s.leader.ship.getModifiedItemAttr("scanResolution")
expected = self.s.leader.ship.item.getAttribute("scanResolution") * 1.1
self.assertEquals(expected, new)
def test_gangModGang(self):
self.s.leader.modules.append(Module(db.getItem("Siege Warfare Link - Shield Harmonizing")))
self.g.calculateModifiedAttributes()
expected = self.s.leader.ship.item.getAttribute("shieldKineticDamageResonance") * 0.98
new = self.s.leader.ship.getModifiedItemAttr("shieldKineticDamageResonance")
self.assertEquals(expected, new)
def test_shipGang(self):
self.s.leader.character.getSkill("Gallente Titan").level = 1
self.s.leader.ship = Ship(db.getItem("Erebus"))
self.g.calculateModifiedAttributes()
new = self.s.leader.ship.getModifiedItemAttr("armorHP")
expected = self.s.leader.ship.item.getAttribute("armorHP") * 1.075
self.assertEquals(expected, new)
def test_onlyFC(self):
self.g.leader = Fit()
self.g.leader.ship = Ship(db.getItem("Rifter"))
self.g.leader.character = Character("tootoot")
self.g.leader.character.getSkill("Leadership").level = 5
self.g.calculateModifiedAttributes()
self.assertEquals(self.g.leader.ship.item.getAttribute("scanResolution"), self.g.leader.ship.getModifiedItemAttr("scanResolution"))
self.assertEquals(self.s.leader.ship.item.getAttribute("scanResolution") * 1.1, self.s.leader.ship.getModifiedItemAttr("scanResolution"))
def test_onlyWC(self):
self.w.leader = Fit()
self.w.leader.ship = Ship(db.getItem("Rifter"))
self.w.leader.character = Character("tootoot")
self.w.leader.character.getSkill("Leadership").level = 5
self.w.leader.character.getSkill("Wing Command").level = 5
self.g.calculateModifiedAttributes()
self.assertEquals(self.s.leader.ship.item.getAttribute("scanResolution") * 1.1, self.s.leader.ship.getModifiedItemAttr("scanResolution"))
self.assertEquals(self.w.leader.ship.item.getAttribute("scanResolution") * 1.1, self.w.leader.ship.getModifiedItemAttr("scanResolution"))

91
eos/tests/saveddata/testImplant.py
View File

@@ -1,91 +0,0 @@
from eos.tests import TestBase
from eos.types import Implant, Fit, User, Ship
from eos import db
import eos.db.saveddata.queries
import sqlalchemy.orm
from copy import deepcopy
class Test(TestBase):
def test_invalidImplant(self):
try:
Implant(db.getItem("Gamma L"))
except ValueError:
return
self.fail("Was expected a ValueError when setting Gamma L as implant, didn't get it")
def test_clear(self):
i = Implant(db.getItem("Halo Omega"))
orig = i.getModifiedItemAttr("memoryBonus")
i.itemModifiedAttributes["memoryBonus"] = 5
i.clear()
self.assertEquals(i.getModifiedItemAttr("memoryBonus"), orig)
def test_validImplant(self):
i = Implant(db.getItem("Halo Omega"))
self.assertEquals(i.slot, 6)
def test_databaseConsistency(self):
oldSession = db.saveddata_session
oldSession.commit()
try:
f = Fit()
f.owner = User("implanttest", "testy", False)
f.ship = Ship(db.getItem("Rifter"))
implant = Implant(db.getItem("Halo Omega"))
f.implants.append(implant)
implant.active = False
db.saveddata_session.add(f)
db.saveddata_session.add(implant)
db.saveddata_session.flush()
#Hack our way through changing the session temporarly
oldSession = eos.db.saveddata.queries.saveddata_session
eos.db.saveddata.queries.saveddata_session = sqlalchemy.orm.sessionmaker(bind=db.saveddata_engine)()
newfit = db.getFit(f.ID)
i = 0
for imp in newfit.implants:
newimplant = imp
i += 1
self.assertFalse(implant.active)
self.assertEquals(i, 1)
self.assertNotEquals(id(f), id(newfit))
self.assertNotEquals(id(implant), id(newimplant))
self.assertEquals(implant.item.ID, newimplant.item.ID)
except:
db.saveddata_session.rollback()
raise
finally:
#Undo our hack as to not fuck up anything
eos.db.saveddata.queries.saveddata_session = oldSession
def test_copy(self):
i = Implant(db.getItem("Halo Omega"))
i.active = False
c = deepcopy(i)
self.assertNotAlmostEqual(id(i), id(c))
self.assertEquals(i.item, c.item)
self.assertEquals(i.active, c.active)
def test_duplicateImplant(self):
f = Fit()
f.implants.append(Implant(db.getItem("Halo Omega")))
try:
f.implants.append(Implant(db.getItem("Halo Omega")))
except ValueError:
return
self.fail("Expected ValueError, didn't get it")
def test_freeSlot(self):
f = Fit()
i = Implant(db.getItem("Halo Omega"))
f.implants.append(i)
self.assertEquals(len(f.implants), 1)
f.implants.freeSlot(i)
self.assertEquals(len(f.implants), 0)

246
eos/tests/saveddata/testModule.py
View File

@@ -1,246 +0,0 @@
from eos.tests import TestBase
from eos.types import Module, Fit, User, State, Ship, Slot, Hardpoint
from eos import db
import eos.db.saveddata.queries
import sqlalchemy.orm
from copy import deepcopy
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.i = db.getItem("Heat Sink I")
self.m = Module(self.i)
def test_clear(self):
m = Module(db.getItem("125mm Gatling AutoCannon I"))
m.charge = db.getItem("Phased Plasma S")
orig = m.getModifiedItemAttr("trackingSpeed")
chargeOrig = m.getModifiedChargeAttr("explosiveDamage")
m.itemModifiedAttributes["trackingSpeed"] = 5
m.chargeModifiedAttributes["explosiveDamage"] = 10
m.clear()
self.assertEquals(m.getModifiedItemAttr("trackingSpeed"), orig)
self.assertEquals(m.getModifiedChargeAttr("explosiveDamage"), chargeOrig)
def test_setItem(self):
self.assertEquals(self.m.itemID, self.i.ID)
def test_setPassiveActive(self):
self.assertFalse(self.m.isValidState(State.ACTIVE))
def test_setPassiveOverload(self):
self.assertFalse(self.m.isValidState(State.OVERHEATED))
def test_setActiveOverloadWhenGood(self):
m = Module(db.getItem("Heavy Modulated Energy Beam I"))
m.state = State.ACTIVE
m.state = State.OVERHEATED
def test_setWrongAmmoType(self):
m = Module(db.getItem("125mm Gatling AutoCannon I"))
self.assertFalse(m.isValidCharge(db.getItem("Gamma L")))
def test_setWrongAmmoSize(self):
m = Module(db.getItem("Dual Light Pulse Laser I"))
self.assertFalse(m.isValidCharge(db.getItem("Gamma M")))
def test_setWrongAmmoSubGroup(self):
m = Module(db.getItem("Dual Light Pulse Laser I"))
self.assertFalse(m.isValidCharge(db.getItem("Scorch S")))
def test_setCorrectAmmo(self):
i = db.getItem("Dual Light Pulse Laser I")
m = Module(i)
a = db.getItem("Gamma S")
self.assertTrue(m.isValidCharge(a))
m.charge = a
self.assertEquals(m.numCharges, 1)
self.assertEquals(m.itemID, i.ID)
self.assertEquals(m.chargeID, a.ID)
def test_slotRig(self):
m = Module(db.getItem("Large Capacitor Control Circuit I"))
self.assertEquals(Slot.RIG, m.slot)
def test_slotSubsystem(self):
m = Module(db.getItem("Tengu Offensive - Magnetic Infusion Basin"))
self.assertEquals(Slot.SUBSYSTEM, m.slot)
def test_slotHigh(self):
m = Module(db.getItem("Salvager I"))
self.assertEquals(Slot.HIGH, m.slot)
def test_slotMed(self):
m = Module(db.getItem("Cap Recharger I"))
self.assertEquals(Slot.MED, m.slot)
def test_slotLow(self):
m = Module(db.getItem("Heat Sink I"))
self.assertEquals(Slot.LOW, m.slot)
def test_hardpointTurret(self):
m = Module(db.getItem("Dual Light Pulse Laser I"))
self.assertEquals(m.hardpoint, Hardpoint.TURRET)
def test_hardpointMissile(self):
m = Module(db.getItem("Standard Missile Launcher I"))
self.assertEquals(m.hardpoint, Hardpoint.MISSILE)
def test_hardpointNone(self):
m = Module(db.getItem("Salvager I"))
self.assertEquals(m.hardpoint, Hardpoint.NONE)
def test_databaseConsistency(self):
oldSession = db.saveddata_session
oldSession.commit()
try:
f = Fit()
f.ship = Ship(db.getItem("Rifter"))
f.owner = User("moduletest", "testy", False)
item = db.getItem("Dual Light Pulse Laser I")
item2 = db.getItem("Stasis Webifier I")
projMod = Module(item2)
charge = db.getItem("Gamma S")
mod = Module(item)
emptyDummy = Module.buildEmpty(Slot.LOW)
f.modules.append(emptyDummy)
posMod1 = Module(item)
posMod2 = Module(item)
posMod3 = Module(item)
posMods = [posMod1, posMod2, posMod3]
for m in posMods:
f.modules.append(m)
mod.charge = charge
f.modules.append(mod)
f.projectedModules.append(projMod)
db.saveddata_session.add(f)
db.saveddata_session.flush()
for m in posMods:
f.modules.remove(m)
posMods.reverse()
for m in posMods:
f.modules.append(m)
db.saveddata_session.flush()
#Hack our way through changing the session temporarly
oldSession = eos.db.saveddata.queries.saveddata_session
eos.db.saveddata.queries.saveddata_session = sqlalchemy.orm.sessionmaker(bind=db.saveddata_engine)()
newf = db.getFit(f.ID)
self.assertNotEquals(id(newf), id(f))
newmod = newf.modules[1]
newprojMod = newf.projectedModules[0]
newdummy = newf.modules[0]
i = 0
while i < len(newf.modules):
if i <= 1:
i += 1
continue
else:
self.assertEquals(newf.modules[i].ID, posMods[i-2].ID)
i += 1
self.assertEquals(newprojMod.item.name, "Stasis Webifier I")
self.assertNotEquals(id(newprojMod), id(projMod))
self.assertNotEquals(id(newmod), id(mod))
self.assertEquals(mod.state, newmod.state)
self.assertEquals(mod.charge.ID, newmod.charge.ID)
self.assertEquals(mod.item.ID, newmod.item.ID)
self.assertEquals(newdummy.slot, emptyDummy.slot)
except:
db.saveddata_session.rollback()
raise
finally:
#Undo our hack as to not fuck up anything
eos.db.saveddata.queries.saveddata_session = oldSession
def test_copy(self):
m = Module(db.getItem("Dual Light Pulse Laser I"))
m.charge = db.getItem("Gamma S")
m.state = State.OFFLINE
c = deepcopy(m)
self.assertNotEquals(id(m), id(c))
self.assertEquals(m.item, c.item)
self.assertEquals(m.charge, c.charge)
self.assertEquals(m.state, c.state)
def test_maxRange(self):
m = Module(db.getItem("Remote ECM Burst I"))
self.assertEquals(m.maxRange, m.getModifiedItemAttr("maxRange"))
m2 = Module(db.getItem("ECM Burst I"))
self.assertEquals(m2.maxRange, m2.getModifiedItemAttr("ecmBurstRange"))
m3 = Module(db.getItem("Standard Missile Launcher I"))
m3.charge = db.getItem("Bloodclaw Light Missile")
self.assertEquals(m3.maxRange, 17437.5)
def test_buildDummy(self):
m = Module.buildEmpty(Slot.LOW)
self.assertEquals(m.slot, Slot.LOW)
self.assertEqual(m.hardpoint, Hardpoint.NONE)
def test_fitsShipRestriction(self):
f = Fit()
m = Module(db.getItem("Judgement"))
f.ship = Ship(db.getItem("Rifter"))
self.assertFalse(m.fits(f))
def test_fitsSlotsFull(self):
f = Fit()
f.ship = Ship(db.getItem("Rifter"))
for _ in xrange(8):
f.modules.append(Module(db.getItem("Salvager I")))
self.assertFalse(Module(db.getItem("Salvager I")).fits(f))
def test_fits(self):
f = Fit()
f.ship = Ship(db.getItem("Rifter"))
self.assertTrue(Module(db.getItem("Salvager I")).fits(f))
def test_dummyCalc(self):
m = Module.buildEmpty(Slot.LOW)
m.calculateModifiedAttributes(Fit(), "normal")
def test_fits_maxGroupFitted(self):
f = Fit()
f.modules.append(Module(db.getItem("Salvager I")))
m = Module(db.getItem("Damage Control II"))
f.ship = Ship(db.getItem("Rifter"))
f.fill()
self.assertTrue(m.fits(f))
def test_canHaveState(self):
f = Fit()
ab = Module(db.getItem("1MN Afterburner II"))
ab.state = State.ACTIVE
mwd = Module(db.getItem("1MN MicroWarpdrive II"))
mwd.state = State.ACTIVE
salv = Module(db.getItem("Salvager I"))
salv.state = State.ACTIVE
f.modules.append(salv)
f.modules.append(ab)
f.modules.append(mwd)
self.assertFalse(ab.canHaveState(State.ACTIVE))
self.assertFalse(mwd.canHaveState(State.ACTIVE))
self.assertTrue(salv.canHaveState(State.ACTIVE))
def test_numShots(self):
laser = Module(db.getItem("Dual Giga Pulse Laser I"))
laser.charge = db.getItem("Multifrequency XL")
arty = Module(db.getItem("1200mm Artillery Cannon I"))
arty.charge = db.getItem("Phased Plasma L")
self.assertEquals(laser.numShots, 0)
self.assertGreater(arty.numShots, 0)

18
eos/tests/saveddata/testPrice.py
View File

@@ -1,18 +0,0 @@
from eos.tests import TestBase
from eos.types import Price
import time
class Test(TestBase):
def test_valid(self):
p = Price(1)
p.time = time.time() - Price.VALIDITY + 1000
self.assertTrue(p.isValid)
def test_invalid(self):
p = Price(1)
p.time = time.time() - Price.VALIDITY - 1000
self.assertFalse(p.isValid)
def test_newObjectInvalid(self):
p = Price(1)
self.assertFalse(p.isValid)

59
eos/tests/saveddata/testSavedDataQueries.py
View File

@@ -1,59 +0,0 @@
from eos.tests import TestBase
from eos.types import Fit, Character, User, Ship
from eos import db
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
#Add some test data
u = User("test", "testy", False)
c = Character("TESTY")
c.owner = u
db.saveddata_session.add(u)
db.saveddata_session.add(c)
db.saveddata_session.commit()
db.saveddata_session.flush()
def test_1getCharacter(self):
c = db.getCharacter("TESTY")
self.assertEquals(c.name, "TESTY")
self.assertEquals(c.owner.username, "test")
def test_2getUser(self):
u = db.getUser("test")
self.assertEquals(u.username, "test")
self.assertEqual(len(u.characters), 1)
def test_3addCharacter(self):
u = db.getUser("test")
cc = Character("Testo")
cc.owner = u
for char in u.characters:
if char == cc: return
self.fail("Didn't find the character we just made")
def test_4addFit(self):
u = db.getUser("test")
f = Fit()
f.owner = u
f.shipID = 1 #Set a crap ID so the tests don't fail due to flushing not working due to the not null restriction
for fit in u.fits:
if fit == f:
return
self.fail("Didn't find the fit we just made")
def test_5getFitByShipID(self):
db.saveddata_session.flush()
l = db.getFitsWithShip(1)
self.assertEquals(len(l), 1)
def test_5searchFits(self):
f = Fit()
f.ship = Ship(db.getItem("Rifter"))
f.owner = db.getUser("test")
f.name = "testety5"
db.saveddata_session.add(f)
db.saveddata_session.flush()
self.assertEquals(len(db.searchFits("testety5")), 1)

19
eos/tests/saveddata/testShip.py
View File

@@ -1,19 +0,0 @@
from eos.tests import TestBase
from eos.types import Ship
from eos import db
from copy import deepcopy
class Test(TestBase):
def test_clear(self):
s = Ship(db.getItem("Rifter"))
orig = s.getModifiedItemAttr("hp")
s.itemModifiedAttributes["hp"] = 5
s.clear()
self.assertEqual(s.getModifiedItemAttr("hp"), orig)
def test_copy(self):
s = Ship(db.getItem("Rifter"))
c = deepcopy(s)
self.assertNotEquals(id(s), id(c))
self.assertEquals(s.item, c.item)

9
eos/tests/saveddata/testUser.py
View File

@@ -1,9 +0,0 @@
from eos.tests import TestBase
from eos.types import User
class Test(TestBase):
def testPasswordEncryption(self):
u = User("MOOBAR")
u.encodeAndSetPassword("FOOBAR")
self.assertTrue(u.isPasswordValid("FOOBAR"))
self.assertFalse(u.isPasswordValid("FOOBUR"))

0
eos/tests/typeTests/__init__.py
View File

0
eos/tests/typeTests/boosters/__init__.py
View File

49
eos/tests/typeTests/boosters/drop.py
View File

@@ -1,49 +0,0 @@
from eos.tests import TestBase
from eos import db
from eos.types import Fit, Booster, Character, Ship, Module
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.f = Fit()
self.c = Character("testDrop")
self.f.character = self.c
self.f.ship = Ship(db.getItem("Rifter"))
self.i = db.getItem("Strong Drop Booster")
self.i2 = db.getItem("Heavy Modulated Energy Beam I")
self.i3 = db.getItem("Large Armor Repairer I")
self.turret = Module(self.i2)
self.repper = Module(self.i3)
self.booster = Booster(self.i)
self.f.boosters.append(self.booster)
self.f.modules.append(self.turret)
self.f.modules.append(self.repper)
def test_trackingSpeed(self):
self.f.calculateModifiedAttributes()
original = self.i2.getAttribute("trackingSpeed")
self.assertAlmostEquals(original * 1.375, self.turret.getModifiedItemAttr("trackingSpeed"))
def test_falloffPenalty(self):
self.booster.getSideEffect("boosterTurretFalloffPenalty").active = True
self.f.calculateModifiedAttributes()
original = self.i2.getAttribute("falloff")
self.assertAlmostEquals(original * 0.7, self.turret.getModifiedItemAttr("falloff"))
def test_armorRepairPenalty(self):
self.booster.getSideEffect("boosterArmorRepairAmountPenalty").active = True
self.f.calculateModifiedAttributes()
original = self.i3.getAttribute("armorDamageAmount")
self.assertAlmostEquals(original * 0.7, self.repper.getModifiedItemAttr("armorDamageAmount"))
def test_maxVelocityPenalty(self):
self.booster.getSideEffect("boosterMaxVelocityPenalty").active = True
self.f.calculateModifiedAttributes()
original = self.f.ship.item.getAttribute("maxVelocity")
self.assertAlmostEquals(original * 0.7, self.f.ship.getModifiedItemAttr("maxVelocity"))
def test_shieldCapacity(self):
self.booster.getSideEffect("boosterShieldCapacityPenalty").active = True
self.f.calculateModifiedAttributes()
original = self.f.ship.item.getAttribute("shieldCapacity")
self.assertAlmostEquals(original * 0.7, self.f.ship.getModifiedItemAttr("shieldCapacity"))

0
eos/tests/typeTests/drones/__init__.py
View File

19
eos/tests/typeTests/implants/CR8.py
View File

@@ -1,19 +0,0 @@
from eos.tests import TestBase
from eos import db
from eos.types import Fit, Implant, Character, Ship
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.f = Fit()
self.c = Character("testCR8")
self.f.character = self.c
self.f.ship = Ship(db.getItem("Rifter"))
self.i = db.getItem("Hardwiring - Inherent Implants 'Squire' CR8")
self.implant = Implant(self.i)
self.f.implants.append(self.implant)
self.f.calculateModifiedAttributes()
def test_rechargeTimeBonus(self):
original = self.f.ship.item.getAttribute("rechargeRate")
self.assertAlmostEquals(original * 0.95, self.f.ship.getModifiedItemAttr("rechargeRate"))

0
eos/tests/typeTests/implants/__init__.py
View File

0
eos/tests/typeTests/interactions/__init__.py
View File

42
eos/tests/typeTests/interactions/charge_ship.py
View File

@@ -1,42 +0,0 @@
from eos import db
from eos.tests import TestBase
from eos.types import Fit, Character, Ship, Module, State
class Test(TestBase):
def test_scanResolution_ship(self):
iIngame = 1.0
fIngame = 1.6
fit = Fit()
char = Character("test")
fit.character = char
fit.ship = Ship(db.getItem("Rifter"))
iEos = fit.ship.getModifiedItemAttr("scanResolution")
mod = Module(db.getItem("Sensor Booster II"))
mod.charge = db.getItem("Scan Resolution")
mod.state = State.ACTIVE
fit.modules.append(mod)
fit.calculateModifiedAttributes()
fEos = fit.ship.getModifiedItemAttr("scanResolution")
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_scanResolution_ship_2(self):
iIngame = 1.0
fIngame = 1.6
fit = Fit()
char = Character("test")
fit.character = char
fit.ship = Ship(db.getItem("Rifter"))
fit.calculateModifiedAttributes()
iEos = fit.ship.getModifiedItemAttr("scanResolution")
mod = Module(db.getItem("Sensor Booster II"))
mod.charge = db.getItem("Scan Resolution")
mod.state = State.ACTIVE
fit.modules.append(mod)
fit.clear()
fit.calculateModifiedAttributes()
fEos = fit.ship.getModifiedItemAttr("scanResolution")
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

46
eos/tests/typeTests/interactions/sensorBooster_signalAmplifier.py
View File

@@ -1,46 +0,0 @@
from eos.tests import TestBase
from eos import db
from eos.types import Fit, Ship, Module, State
from eos.modifiedAttributeDict import ModifiedAttributeDict
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.fit = Fit()
self.fit.ship = Ship(db.getItem("Rifter"))
self.testItem1 = db.getItem("Sensor Booster II")
self.testItem2 = db.getItem("Signal Amplifier II")
self.testMod1 = Module(self.testItem1)
self.testMod2 = Module(self.testItem2)
self.testMod1.state = State.ACTIVE
self.fit.modules.append(self.testMod1)
self.fit.modules.append(self.testMod2)
self.fit.calculateModifiedAttributes()
def test_scanResolution(self):
self.buildTested = 171215
bonusAttrName = "scanResolutionBonus"
targetAttrName = "scanResolution"
penalize = True
mod1Bonus = self.testItem1.getAttribute(bonusAttrName)
mod2Bonus = self.testItem2.getAttribute(bonusAttrName)
expected = ModifiedAttributeDict()
expected.original = self.fit.ship.item.attributes
expected.boost(targetAttrName, mod1Bonus, stackingPenalties = penalize)
expected.boost(targetAttrName, mod2Bonus, stackingPenalties = penalize)
actual = self.fit.ship.getModifiedItemAttr(targetAttrName)
self.assertAlmostEquals(expected[targetAttrName], actual)
def test_maxTargetRange(self):
self.buildTested = 174282
bonusAttrName = "maxTargetRangeBonus"
targetAttrName = "maxTargetRange"
penalize = True
mod1Bonus = self.testItem1.getAttribute(bonusAttrName)
mod2Bonus = self.testItem2.getAttribute(bonusAttrName)
expected = ModifiedAttributeDict()
expected.original = self.fit.ship.item.attributes
expected.boost(targetAttrName, mod1Bonus, stackingPenalties = penalize)
expected.boost(targetAttrName, mod2Bonus, stackingPenalties = penalize)
actual = self.fit.ship.getModifiedItemAttr(targetAttrName)
self.assertAlmostEquals(expected[targetAttrName], actual)

49
eos/tests/typeTests/interactions/sensorBooster_targetingSystemSubcontroller.py
View File

@@ -1,49 +0,0 @@
from eos.tests import TestBase
from eos import db
from eos.types import Fit, Ship, Module, State
from eos.modifiedAttributeDict import ModifiedAttributeDict
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.fit = Fit()
self.fit.ship = Ship(db.getItem("Rifter"))
self.sensBoostItem = db.getItem("Sensor Booster II")
self.t1RigItem = db.getItem("Small Targeting System Subcontroller I")
self.t2RigItem = db.getItem("Small Targeting System Subcontroller II")
self.sensBoostMod = Module(self.sensBoostItem)
self.t1RigMod = Module(self.t1RigItem)
self.t2RigMod = Module(self.t2RigItem)
self.sensBoostMod.state = State.ACTIVE
def test_scanResolutionT1(self):
self.buildTested = 171215
self.fit.modules.append(self.sensBoostMod)
self.fit.modules.append(self.t1RigMod)
self.fit.calculateModifiedAttributes()
targetAttrName = "scanResolution"
penalize = False
sensBoostBoost = self.sensBoostItem.getAttribute("scanResolutionBonus")
t1RigMultiplier = self.t1RigItem.getAttribute("scanResolutionMultiplier")
expected = ModifiedAttributeDict()
expected.original = self.fit.ship.item.attributes
expected.boost(targetAttrName, sensBoostBoost, stackingPenalties = penalize)
expected.multiply(targetAttrName, t1RigMultiplier, stackingPenalties = penalize)
actual = self.fit.ship.getModifiedItemAttr(targetAttrName)
self.assertAlmostEquals(expected[targetAttrName], actual)
def test_scanResolutionT2(self):
self.buildTested = 171215
self.fit.modules.append(self.sensBoostMod)
self.fit.modules.append(self.t2RigMod)
self.fit.calculateModifiedAttributes()
targetAttrName = "scanResolution"
penalize = False
sensBoostBoost = self.sensBoostItem.getAttribute("scanResolutionBonus")
t2RigMultiplier = self.t2RigItem.getAttribute("scanResolutionMultiplier")
expected = ModifiedAttributeDict()
expected.original = self.fit.ship.item.attributes
expected.boost(targetAttrName, sensBoostBoost, stackingPenalties = penalize)
expected.multiply(targetAttrName, t2RigMultiplier, stackingPenalties = penalize)
actual = self.fit.ship.getModifiedItemAttr(targetAttrName)
self.assertAlmostEquals(expected[targetAttrName], actual)

48
eos/tests/typeTests/interactions/signalAmplifier_targetingSystemSubcontroller.py
View File

@@ -1,48 +0,0 @@
from eos.tests import TestBase
from eos import db
from eos.types import Fit, Ship, Module
from eos.modifiedAttributeDict import ModifiedAttributeDict
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.fit = Fit()
self.fit.ship = Ship(db.getItem("Rifter"))
self.sigAmpItem = db.getItem("Signal Amplifier II")
self.t1RigItem = db.getItem("Small Targeting System Subcontroller I")
self.t2RigItem = db.getItem("Small Targeting System Subcontroller II")
self.sigAmpMod = Module(self.sigAmpItem)
self.t1RigMod = Module(self.t1RigItem)
self.t2RigMod = Module(self.t2RigItem)
def test_scanResolutionT1(self):
self.buildTested = 171215
self.fit.modules.append(self.sigAmpMod)
self.fit.modules.append(self.t1RigMod)
self.fit.calculateModifiedAttributes()
targetAttrName = "scanResolution"
penalize = False
sigAmpBoost = self.sigAmpItem.getAttribute("scanResolutionBonus")
t1RigMultiplier = self.t1RigItem.getAttribute("scanResolutionMultiplier")
expected = ModifiedAttributeDict()
expected.original = self.fit.ship.item.attributes
expected.boost(targetAttrName, sigAmpBoost, stackingPenalties = penalize)
expected.multiply(targetAttrName, t1RigMultiplier, stackingPenalties = penalize)
actual = self.fit.ship.getModifiedItemAttr(targetAttrName)
self.assertAlmostEquals(expected[targetAttrName], actual)
def test_scanResolutionT2(self):
self.buildTested = 171215
self.fit.modules.append(self.sigAmpMod)
self.fit.modules.append(self.t2RigMod)
self.fit.calculateModifiedAttributes()
targetAttrName = "scanResolution"
penalize = False
sigAmpBoost = self.sigAmpItem.getAttribute("scanResolutionBonus")
t2RigMultiplier = self.t2RigItem.getAttribute("scanResolutionMultiplier")
expected = ModifiedAttributeDict()
expected.original = self.fit.ship.item.attributes
expected.boost(targetAttrName, sigAmpBoost, stackingPenalties = penalize)
expected.multiply(targetAttrName, t2RigMultiplier, stackingPenalties = penalize)
actual = self.fit.ship.getModifiedItemAttr(targetAttrName)
self.assertAlmostEquals(expected[targetAttrName], actual)

0
eos/tests/typeTests/modules/__init__.py
View File

28
eos/tests/typeTests/modules/afterburner.py
View File

@@ -1,28 +0,0 @@
from eos.tests import TestBase
from eos import db
from eos.types import Module, Fit, Ship, State
from eos.modifiedAttributeDict import ModifiedAttributeDict
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.fit = Fit()
self.rifter = db.getItem("Rifter")
self.fit.ship = Ship(self.rifter)
self.afterburner = Module(db.getItem("1MN Afterburner II"))
self.afterburner.state = State.ACTIVE
self.fit.modules.append(self.afterburner)
self.fit.calculateModifiedAttributes()
def test_mass(self):
expected = ModifiedAttributeDict()
expected.original = self.fit.ship.itemModifiedAttributes.original
expected.increase("mass", self.afterburner.getModifiedItemAttr("massAddition"))
self.assertEquals(expected["mass"], self.fit.ship.getModifiedItemAttr("mass"))
def test_speedboost(self):
expected = ModifiedAttributeDict()
expected.original = self.fit.ship.itemModifiedAttributes.original
maxVelBoost = self.afterburner.getModifiedItemAttr("speedFactor") * self.afterburner.getModifiedItemAttr("speedBoostFactor") / self.fit.ship.getModifiedItemAttr("mass")
expected.boost("maxVelocity", maxVelBoost)
self.assertEquals(expected["maxVelocity"], self.fit.ship.getModifiedItemAttr("maxVelocity"))

21
eos/tests/typeTests/modules/armorHardener.py
View File

@@ -1,21 +0,0 @@
from eos.tests import TestBase
from eos import db
from eos.types import Module, Fit, Ship, State
from eos.modifiedAttributeDict import ModifiedAttributeDict
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.fit = Fit()
self.rifter = db.getItem("Rifter")
self.fit.ship = Ship(self.rifter)
self.hardener = Module(db.getItem("Armor EM Hardener II"))
self.hardener.state = State.ACTIVE
self.fit.modules.append(self.hardener)
self.fit.calculateModifiedAttributes()
def test_hardening(self):
expected = ModifiedAttributeDict()
expected.original = self.rifter.attributes
expected.boost("armorEmDamageResonance", self.hardener.getModifiedItemAttr("emDamageResistanceBonus"))
self.assertEquals(expected["armorEmDamageResonance"], self.fit.ship.getModifiedItemAttr("armorEmDamageResonance"))

17
eos/tests/typeTests/modules/capPowerRelay.py
View File

@@ -1,17 +0,0 @@
from eos.tests import TestBase
from eos import db
from eos.types import Module, Fit, Ship
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.fit = Fit()
self.rifter = db.getItem("Rifter")
self.fit.ship = Ship(self.rifter)
self.relay = Module(db.getItem("Capacitor Power Relay I"))
self.fit.modules.append(self.relay)
self.fit.calculateModifiedAttributes()
def test_CalcCrash(self):
# Note, no calculation checking, just testing for a crash here.
pass

16
eos/tests/typeTests/modules/engineeringSubsystem.py
View File

@@ -1,16 +0,0 @@
from eos.tests import TestBase
from eos import db
from eos.types import Module, Fit, Ship
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.fit = Fit()
self.tengu = db.getItem("Tengu")
self.fit.ship = Ship(self.tengu)
self.sub = Module(db.getItem("Tengu Engineering - Augmented Capacitor Reservoir"))
self.fit.modules.append(self.sub)
self.fit.calculateModifiedAttributes()
def test_hardening(self):
self.assertGreater(self.fit.ship.getModifiedItemAttr("powerOutput"), 0)

32
eos/tests/typeTests/modules/heatSink.py
View File

@@ -1,32 +0,0 @@
from eos.tests import TestBase
from eos import db
from eos.types import Module, Fit
from eos.modifiedAttributeDict import ModifiedAttributeDict
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.fit = Fit()
self.hsi = db.getItem("Heat Sink II")
self.eti = db.getItem("Heavy Modulated Energy Beam I")
self.hsm1 = Module(self.hsi)
self.hsm2 = Module(self.hsi)
self.etm = Module(self.eti)
self.fit.modules.append(self.hsm1)
self.fit.modules.append(self.hsm2)
self.fit.modules.append(self.etm)
self.fit.calculateModifiedAttributes()
def test_damageMultiplier(self):
expected = ModifiedAttributeDict()
expected.original = self.etm.item.attributes
expected.multiply("damageMultiplier", self.hsi.getAttribute("damageMultiplier"), stackingPenalties = True)
expected.multiply("damageMultiplier", self.hsi.getAttribute("damageMultiplier"), stackingPenalties = True)
self.assertAlmostEquals(expected["damageMultiplier"], self.etm.getModifiedItemAttr("damageMultiplier"))
def test_speed(self):
expected = ModifiedAttributeDict()
expected.original = self.etm.item.attributes
expected.multiply("speed", self.hsi.getAttribute("speedMultiplier"), stackingPenalties = True)
expected.multiply("speed", self.hsi.getAttribute("speedMultiplier"), stackingPenalties = True)
self.assertAlmostEquals(expected["speed"], self.etm.getModifiedItemAttr("speed"))

34
eos/tests/typeTests/modules/microwarpdrive.py
View File

@@ -1,34 +0,0 @@
from eos.tests import TestBase
from eos import db
from eos.types import Module, Fit, Ship, State
from eos.modifiedAttributeDict import ModifiedAttributeDict
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.fit = Fit()
self.rifter = db.getItem("Rifter")
self.fit.ship = Ship(self.rifter)
self.mwd = Module(db.getItem("1MN MicroWarpdrive II"))
self.mwd.state = State.ACTIVE
self.fit.modules.append(self.mwd)
self.fit.calculateModifiedAttributes()
def test_mass(self):
expected = ModifiedAttributeDict()
expected.original = self.fit.ship.itemModifiedAttributes.original
expected.increase("mass", self.mwd.getModifiedItemAttr("massAddition"))
self.assertEquals(expected["mass"], self.fit.ship.getModifiedItemAttr("mass"))
def test_speedboost(self):
expected = ModifiedAttributeDict()
expected.original = self.fit.ship.itemModifiedAttributes.original
maxVelBoost = self.mwd.getModifiedItemAttr("speedFactor") * self.mwd.getModifiedItemAttr("speedBoostFactor") / self.fit.ship.getModifiedItemAttr("mass")
expected.boost("maxVelocity", maxVelBoost)
self.assertEquals(expected["maxVelocity"], self.fit.ship.getModifiedItemAttr("maxVelocity"))
def test_signature(self):
expected = ModifiedAttributeDict()
expected.original = self.fit.ship.itemModifiedAttributes.original
expected.boost("signatureRadius", self.mwd.getModifiedItemAttr("signatureRadiusBonus"))
self.assertEquals(expected["signatureRadius"], self.fit.ship.getModifiedItemAttr("signatureRadius"))

11
eos/tests/typeTests/modules/probeLauncherHardpoint.py
View File

@@ -1,11 +0,0 @@
from eos.tests import TestBase
from eos import db
from eos.types import Module, Hardpoint
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.m = Module(db.getItem("Scan Probe Launcher II"))
def test_hardpoint(self):
self.assertEquals(self.m.hardpoint, Hardpoint.NONE)

42
eos/tests/typeTests/modules/sensorBooster.py
View File

@@ -1,42 +0,0 @@
from eos.tests import TestBase
from eos import db
from eos.types import Fit, Ship, Module, State
from eos.modifiedAttributeDict import ModifiedAttributeDict
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.fit = Fit()
self.fit.ship = Ship(db.getItem("Rifter"))
self.testItem = db.getItem("Sensor Booster II")
self.testMod1 = Module(self.testItem)
self.testMod2 = Module(self.testItem)
self.testMod1.state = State.ACTIVE
self.testMod2.state = State.ACTIVE
self.fit.modules.append(self.testMod1)
self.fit.modules.append(self.testMod2)
self.fit.calculateModifiedAttributes()
def test_scanResolution(self):
self.buildTested = 171215
targetAttrName = "scanResolution"
penalize = True
modBonus = self.testItem.getAttribute("scanResolutionBonus")
expected = ModifiedAttributeDict()
expected.original = self.fit.ship.item.attributes
expected.boost(targetAttrName, modBonus, stackingPenalties = penalize)
expected.boost(targetAttrName, modBonus, stackingPenalties = penalize)
actual = self.fit.ship.getModifiedItemAttr(targetAttrName)
self.assertAlmostEquals(expected[targetAttrName], actual)
def test_maxTargetRange(self):
self.buildTested = 171215
targetAttrName = "maxTargetRange"
penalize = True
modBonus = self.testItem.getAttribute("maxTargetRangeBonus")
expected = ModifiedAttributeDict()
expected.original = self.fit.ship.item.attributes
expected.boost(targetAttrName, modBonus, stackingPenalties = penalize)
expected.boost(targetAttrName, modBonus, stackingPenalties = penalize)
actual = self.fit.ship.getModifiedItemAttr(targetAttrName)
self.assertAlmostEquals(expected[targetAttrName], actual)

51
eos/tests/typeTests/modules/signalAmplifier.py
View File

@@ -1,51 +0,0 @@
from eos.tests import TestBase
from eos import db
from eos.types import Fit, Ship, Module
from eos.modifiedAttributeDict import ModifiedAttributeDict
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.fit = Fit()
self.fit.ship = Ship(db.getItem("Rifter"))
self.testItem = db.getItem("Signal Amplifier II")
self.testMod1 = Module(self.testItem)
self.testMod2 = Module(self.testItem)
self.fit.modules.append(self.testMod1)
self.fit.modules.append(self.testMod2)
self.fit.calculateModifiedAttributes()
def test_scanResolution(self):
self.buildTested = 171215
targetAttrName = "scanResolution"
penalize = True
modBonus = self.testItem.getAttribute("scanResolutionBonus")
expected = ModifiedAttributeDict()
expected.original = self.fit.ship.item.attributes
expected.boost(targetAttrName, modBonus, stackingPenalties = penalize)
expected.boost(targetAttrName, modBonus, stackingPenalties = penalize)
actual = self.fit.ship.getModifiedItemAttr(targetAttrName)
self.assertAlmostEquals(expected[targetAttrName], actual)
def test_maxTargetRange(self):
self.buildTested = 171215
targetAttrName = "maxTargetRange"
penalize = True
modBonus = self.testItem.getAttribute("maxTargetRangeBonus")
expected = ModifiedAttributeDict()
expected.original = self.fit.ship.item.attributes
expected.boost(targetAttrName, modBonus, stackingPenalties = penalize)
expected.boost(targetAttrName, modBonus, stackingPenalties = penalize)
actual = self.fit.ship.getModifiedItemAttr(targetAttrName)
self.assertAlmostEquals(expected[targetAttrName], actual)
def test_maxLockedTargets(self):
self.buildTested = 171215
targetAttrName = "maxLockedTargets"
modBonus = self.testItem.getAttribute("maxLockedTargetsBonus")
expected = ModifiedAttributeDict()
expected.original = self.fit.ship.item.attributes
expected.increase(targetAttrName, modBonus)
expected.increase(targetAttrName, modBonus)
actual = self.fit.ship.getModifiedItemAttr(targetAttrName)
self.assertAlmostEquals(expected[targetAttrName], actual)

82
eos/tests/typeTests/modules/targetingSystemSubcontroller.py
View File

@@ -1,82 +0,0 @@
from eos.tests import TestBase
from eos import db
from eos.types import Fit, Ship, Module
from eos.modifiedAttributeDict import ModifiedAttributeDict
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.fit = Fit()
self.fit.ship = Ship(db.getItem("Rifter"))
self.testItemT1 = db.getItem("Small Targeting System Subcontroller I")
self.testItemT2 = db.getItem("Small Targeting System Subcontroller II")
self.testModT1_1 = Module(self.testItemT1)
self.testModT1_2 = Module(self.testItemT1)
self.testModT2_1 = Module(self.testItemT2)
self.testModT2_2 = Module(self.testItemT2)
# T1 and T2 rigs have different effects for scanning resolution boost,
# so we have to test them separately
def test_scanResolutionT1(self):
self.buildTested = 171215
self.fit.modules.append(self.testModT1_1)
self.fit.modules.append(self.testModT1_2)
self.fit.calculateModifiedAttributes()
targetAttrName = "scanResolution"
penalize = True
modBonus = self.testItemT1.getAttribute("scanResolutionMultiplier")
expected = ModifiedAttributeDict()
expected.original = self.fit.ship.item.attributes
expected.multiply(targetAttrName, modBonus, stackingPenalties = penalize)
expected.multiply(targetAttrName, modBonus, stackingPenalties = penalize)
actual = self.fit.ship.getModifiedItemAttr(targetAttrName)
self.assertAlmostEquals(expected[targetAttrName], actual)
def test_scanResolutionT2(self):
self.buildTested = 171215
self.fit.modules.append(self.testModT2_1)
self.fit.modules.append(self.testModT2_2)
self.fit.calculateModifiedAttributes()
targetAttrName = "scanResolution"
penalize = True
modBonus = self.testItemT2.getAttribute("scanResolutionMultiplier")
expected = ModifiedAttributeDict()
expected.original = self.fit.ship.item.attributes
expected.multiply(targetAttrName, modBonus, stackingPenalties = penalize)
expected.multiply(targetAttrName, modBonus, stackingPenalties = penalize)
actual = self.fit.ship.getModifiedItemAttr(targetAttrName)
self.assertAlmostEquals(expected[targetAttrName], actual)
def test_scanResolutionT1T2(self):
self.buildTested = 171215
self.fit.modules.append(self.testModT1_1)
self.fit.modules.append(self.testModT2_1)
self.fit.calculateModifiedAttributes()
bonusAttrName = "scanResolutionMultiplier"
targetAttrName = "scanResolution"
penalize = False
mod1Bonus = self.testItemT1.getAttribute(bonusAttrName)
mod2Bonus = self.testItemT2.getAttribute(bonusAttrName)
expected = ModifiedAttributeDict()
expected.original = self.fit.ship.item.attributes
expected.multiply(targetAttrName, mod1Bonus, stackingPenalties = penalize)
expected.multiply(targetAttrName, mod2Bonus, stackingPenalties = penalize)
actual = self.fit.ship.getModifiedItemAttr(targetAttrName)
self.assertAlmostEquals(expected[targetAttrName], actual)
def test_shieldCapacity(self):
self.buildTested = 171215
self.fit.modules.append(self.testModT1_1)
self.fit.modules.append(self.testModT2_1)
self.fit.calculateModifiedAttributes()
bonusAttrName = "drawback"
targetAttrName = "shieldCapacity"
penalize = False
mod1Bonus = self.testItemT1.getAttribute(bonusAttrName)
mod2Bonus = self.testItemT2.getAttribute(bonusAttrName)
expected = ModifiedAttributeDict()
expected.original = self.fit.ship.item.attributes
expected.boost(targetAttrName, mod1Bonus, stackingPenalties = penalize)
expected.boost(targetAttrName, mod2Bonus, stackingPenalties = penalize)
actual = self.fit.ship.getModifiedItemAttr(targetAttrName)
self.assertAlmostEquals(expected[targetAttrName], actual)

19
eos/tests/typeTests/projectedDrones/TargetPaintDrone.py
View File

@@ -1,19 +0,0 @@
from eos.tests import TestBase
from eos import db
from eos.types import Fit, Ship
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.i = db.getItem("Warrior TP-300")
self.f = Fit()
self.f.ship = Ship(db.getItem("Rifter"))
d = self.f.projectedDrones.appendItem(self.i, 2)
d.amountActive = 2
self.f.calculateModifiedAttributes()
def test_speedSlow(self):
original = self.f.ship.item.getAttribute("signatureRadius")
multiplier = 1.04
expected = original * (1 + (multiplier -1) * 0.86911998) * multiplier
self.assertAlmostEquals(expected, self.f.ship.getModifiedItemAttr("signatureRadius"), 3)

0
eos/tests/typeTests/projectedDrones/__init__.py
View File

0
eos/tests/typeTests/projectedModules/__init__.py
View File

23
eos/tests/typeTests/projectedModules/stasisWebifier.py
View File

@@ -1,23 +0,0 @@
from eos.tests import TestBase
from eos import db
from eos.types import Module, Fit, Ship, State
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.i = db.getItem("Stasis Webifier I")
self.f = Fit()
self.f.ship = Ship(db.getItem("Rifter"))
self.m = Module(self.i)
self.m2 = Module(self.i)
self.m.state = State.ACTIVE
self.m2.state = State.ACTIVE
self.f.projectedModules.append(self.m)
self.f.projectedModules.append(self.m2)
self.f.calculateModifiedAttributes()
def test_speedSlow(self):
original = self.f.ship.item.getAttribute("maxVelocity")
multiplier = 0.5
expected = original * (1 + (multiplier -1) * 0.86911998) * multiplier
self.assertAlmostEquals(expected, self.f.ship.getModifiedItemAttr("maxVelocity"), 3)

0
eos/tests/typeTests/ships/__init__.py
View File

0
eos/tests/typeTests/ships/assaultShips/__init__.py
View File

105
eos/tests/typeTests/ships/assaultShips/enyo.py
View File

@@ -1,105 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Enyo"
# Gallente Frigate Skill Bonus:
# 5% bonus to Small Hybrid Turret Damage per level
def test_gallenteFrigate_damageMultiplier_moduleHybridWeaponSmall(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "75mm Gatling Rail I"
skill = "Gallente Frigate"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteFrigate_damageMultiplier_moduleHybridWeaponOther(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Heavy Electron Blaster I"
skill = "Gallente Frigate"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Assault Frigates Skill Bonus:
# 10% bonus to Small Hybrid Turret Optimal Range per level
def test_assaultShips_maxRange_moduleHybridWeaponSmall(self):
self.buildTested = 0
attr = "maxRange"
item = "125mm Railgun I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_maxRange_moduleHybridWeaponOther(self):
self.buildTested = 0
attr = "maxRange"
item = "200mm Railgun I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Assault Frigates Skill Bonus:
# 7.5% bonus to Small Hybrid Turret Tracking Speed per level
def test_assaultShips_trackingSpeed_moduleHybridWeaponSmall(self):
self.buildTested = 0
attr = "trackingSpeed"
item = "Light Electron Blaster I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.075
fLvl = 4
fIngame = 1.3
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_trackingSpeed_moduleHybridWeaponOther(self):
self.buildTested = 0
attr = "trackingSpeed"
item = "Heavy Electron Blaster I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

200
eos/tests/typeTests/ships/assaultShips/freki.py
View File

@@ -1,200 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Freki"
# Minmatar Frigate Skill Bonus:
# 12.5% Small Projectile Turret damage per level
def test_minmatarFrigate_damageMultiplier_moduleProjectileWeaponSmall(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "280mm Howitzer Artillery I"
skill = "Minmatar Frigate"
iLvl = 1
iIngame = 1.125
fLvl = 4
fIngame = 1.5
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_minmatarFrigate_damageMultiplier_moduleProjectileWeaponOther(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "425mm AutoCannon I"
skill = "Minmatar Frigate"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Minmatar Frigate Skill Bonus:
# 30% bonus to Stasis Webifier Range per level
def test_minmatarFrigate_maxRange_moduleStasisWebSkillrqPropjamm(self):
self.buildTested = 0
attr = "maxRange"
item = "Stasis Webifier I"
skill = "Minmatar Frigate"
iLvl = 1
iIngame = 1.3
fLvl = 4
fIngame = 2.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_minmatarFrigate_maxRange_moduleStasisWebNoSkillrq(self):
self.buildTested = 0
attr = "maxRange"
item = "Civilian Stasis Webifier"
skill = "Minmatar Frigate"
iLvl = 1
iIngame = 1.3
fLvl = 4
fIngame = 2.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_minmatarFrigate_maxRange_moduleOtherSkillrqPropjamm(self):
self.buildTested = 0
attr = "maxRange"
item = "Warp Disruptor I"
skill = "Minmatar Frigate"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Special Ability:
# 50% Small Projectile Turret optimal range bonus
def test_static_maxRange_moduleProjectileWeaponSmall(self):
self.buildTested = 0
attr = "maxRange"
item = "250mm Light Artillery Cannon I"
ship_other = "Punisher"
iIngame = 1.0
fIngame = 1.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_maxRange_moduleProjectileWeaponOther(self):
self.buildTested = 0
attr = "maxRange"
item = "650mm Artillery Cannon I"
ship_other = "Punisher"
iIngame = 1.0
fIngame = 1.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Special Ability:
# 50% Small Projectile Turret falloff bonus
def test_static_falloff_moduleProjectileWeaponSmall(self):
self.buildTested = 0
attr = "falloff"
item = "200mm AutoCannon I"
ship_other = "Punisher"
iIngame = 1.0
fIngame = 1.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_falloff_moduleProjectileWeaponOther(self):
self.buildTested = 0
attr = "falloff"
item = "Dual 180mm AutoCannon I"
ship_other = "Punisher"
iIngame = 1.0
fIngame = 1.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Special Ability:
# 75% afterburner and microwarpdrive capacitor consumption bonus
def test_static_capacitorNeed_moduleAfterburnerSkillrqHighSpeedManeuvering(self):
self.buildTested = 0
attr = "capacitorNeed"
item = "1MN MicroWarpdrive I"
ship_other = "Punisher"
iIngame = 1.0
fIngame = 0.25
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_capacitorNeed_moduleAfterburnerSkillrqAfterburner(self):
self.buildTested = 0
attr = "capacitorNeed"
item = "1MN Afterburner I"
ship_other = "Punisher"
iIngame = 1.0
fIngame = 0.25
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_capacitorNeed_moduleAfterburnerNoSkillrq(self):
self.buildTested = 0
attr = "capacitorNeed"
item = "Civilian Afterburner"
ship_other = "Punisher"
iIngame = 1.0
fIngame = 0.25
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_capacitorNeed_moduleOther(self):
self.buildTested = 0
attr = "capacitorNeed"
item = "ECM Burst I"
ship_other = "Punisher"
iIngame = 1.0
fIngame = 1.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

105
eos/tests/typeTests/ships/assaultShips/harpy.py
View File

@@ -1,105 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Harpy"
# Caldari Frigate Skill Bonus:
# 10% bonus to Small Hybrid Turret Optimal range per level
def test_caldariFrigate_maxRange_moduleHybridWeaponSmall(self):
self.buildTested = 0
attr = "maxRange"
item = "150mm Railgun I"
skill = "Caldari Frigate"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariFrigate_maxRange_moduleHybridWeaponOtherl(self):
self.buildTested = 0
attr = "maxRange"
item = "Dual 150mm Railgun I"
skill = "Caldari Frigate"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Assault Frigates Skill Bonus:
# 10% bonus to Small Hybrid Turret Optimal Range per level
def test_assaultShips_maxRange_moduleHybridWeaponSmall(self):
self.buildTested = 0
attr = "maxRange"
item = "Light Neutron Blaster I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_maxRange_moduleHybridWeaponOther(self):
self.buildTested = 0
attr = "maxRange"
item = "Heavy Electron Blaster I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Assault Frigates Skill Bonus:
# 5% bonus to Small Hybrid Turret Damage per level
def test_assaultShips_damageMultiplier_moduleHybridWeaponSmall(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Light Ion Blaster I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_damageMultiplier_moduleHybridWeaponOther(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "250mm Railgun I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

647
eos/tests/typeTests/ships/assaultShips/hawk.py
View File

@@ -1,647 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Hawk"
# Caldari Frigate Skill Bonus:
# 5% bonus to Missile Kinetic Damage per level
# Actually it's 10%, CCP forgot to change description after boost
def test_caldariFrigate_kineticDamage_chargeMissileRocket(self):
self.buildTested = 0
attr = "kineticDamage"
item = "Thorn Rocket"
skill = "Caldari Frigate"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariFrigate_kineticDamage_chargeMissileRocketAdvanced(self):
self.buildTested = 0
attr = "kineticDamage"
item = "Thorn Rage Rocket"
skill = "Caldari Frigate"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariFrigate_kineticDamage_chargeMissileLight(self):
self.buildTested = 0
attr = "kineticDamage"
item = "Bloodclaw Light Missile"
skill = "Caldari Frigate"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariFrigate_kineticDamage_chargeMissileLightAdvanced(self):
self.buildTested = 0
attr = "kineticDamage"
item = "Bloodclaw Precision Light Missile"
skill = "Caldari Frigate"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariFrigate_kineticDamage_chargeMissileLightFof(self):
self.buildTested = 0
attr = "kineticDamage"
item = "Serpent F.O.F. Light Missile I"
skill = "Caldari Frigate"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariFrigate_kineticDamage_chargeMissileAssault(self):
self.buildTested = 0
attr = "kineticDamage"
item = "Terror Assault Missile"
skill = "Caldari Frigate"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariFrigate_kineticDamage_chargeMissileAssaultAdvanced(self):
self.buildTested = 0
attr = "kineticDamage"
item = "Terror Rage Assault Missile"
skill = "Caldari Frigate"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariFrigate_kineticDamage_chargeMissileHeavy(self):
self.buildTested = 0
attr = "kineticDamage"
item = "Scourge Heavy Missile"
skill = "Caldari Frigate"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariFrigate_kineticDamage_chargeMissileHeavyAdvanced(self):
self.buildTested = 0
attr = "kineticDamage"
item = "Scourge Fury Heavy Missile"
skill = "Caldari Frigate"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariFrigate_kineticDamage_chargeMissileHeavyFof(self):
self.buildTested = 0
attr = "kineticDamage"
item = "Hydra F.O.F. Heavy Missile I"
skill = "Caldari Frigate"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariFrigate_kineticDamage_chargeMissileTorpedo(self):
self.buildTested = 0
attr = "kineticDamage"
item = "Juggernaut Torpedo"
skill = "Caldari Frigate"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariFrigate_kineticDamage_chargeMissileTorpedoAdvanced(self):
self.buildTested = 0
attr = "kineticDamage"
item = "Juggernaut Rage Torpedo"
skill = "Caldari Frigate"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariFrigate_kineticDamage_chargeMissileCruise(self):
self.buildTested = 0
attr = "kineticDamage"
item = "Wrath Cruise Missile"
skill = "Caldari Frigate"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariFrigate_kineticDamage_chargeMissileCruiseAdvanced(self):
self.buildTested = 0
attr = "kineticDamage"
item = "Wrath Precision Cruise Missile"
skill = "Caldari Frigate"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariFrigate_kineticDamage_chargeMissileCruiseFof(self):
self.buildTested = 0
attr = "kineticDamage"
item = "Dragon F.O.F. Cruise Missile I"
skill = "Caldari Frigate"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariFrigate_kineticDamage_chargeMissileCitadelTorpedo(self):
self.buildTested = 0
attr = "kineticDamage"
item = "Rift Citadel Torpedo"
skill = "Caldari Frigate"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariFrigate_kineticDamage_chargeMissileCitadelCruise(self):
self.buildTested = 0
attr = "kineticDamage"
item = "Rajas Citadel Cruise Missile"
skill = "Caldari Frigate"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariFrigate_kineticDamage_chargeMissileLightNoSkillrqMissileOp(self):
self.buildTested = 0
attr = "kineticDamage"
item = "Civilian Bloodclaw Light Missile"
skill = "Caldari Frigate"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariFrigate_kineticDamage_chargeOther(self):
self.buildTested = 0
attr = "kineticDamage"
item = "EMP S"
skill = "Caldari Frigate"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Assault Frigates Skill Bonus:
# 10% bonus to Missile Velocity per level
def test_assaultShips_maxVelocity_chargeMissileRocket(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Foxfire Rocket"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_maxVelocity_chargeMissileRocketAdvanced(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Phalanx Javelin Rocket"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_maxVelocity_chargeMissileLight(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Flameburst Light Missile"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_maxVelocity_chargeMissileLightAdvanced(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Piranha Precision Light Missile"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_maxVelocity_chargeMissileLightFof(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Seeker F.O.F. Light Missile I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_maxVelocity_chargeMissileAssault(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Terror Assault Missile"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_maxVelocity_chargeMissileAssaultAdvanced(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Hellfire Rage Assault Missile"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_maxVelocity_chargeMissileHeavy(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Havoc Heavy Missile"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_maxVelocity_chargeMissileHeavyAdvanced(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Thunderbolt Fury Heavy Missile"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_maxVelocity_chargeMissileHeavyFof(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Hellhound F.O.F. Heavy Missile I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_maxVelocity_chargeMissileTorpedo(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Inferno Torpedo"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_maxVelocity_chargeMissileTorpedoAdvanced(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Bane Javelin Torpedo"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_maxVelocity_chargeMissileCruise(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Devastator Cruise Missile"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_maxVelocity_chargeMissileCruiseAdvanced(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Paradise Precision Cruise Missile"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_maxVelocity_chargeMissileCruiseFof(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Exterminator F.O.F. Light Missile I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_maxVelocity_chargeMissileCitadelTorpedo(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Rift Citadel Torpedo"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_maxVelocity_chargeMissileCitadelCruise(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Thunar Citadel Cruise Missile"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_maxVelocity_chargeMissileDefender(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Defender I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_maxVelocity_chargeMissileLightNoSkillrqMissileOp(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Civilian Bloodclaw Light Missile"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Assault Frigates Skill Bonus:
# 7.5% bonus to Shield Boost Amount per level
def test_assaultShips_shieldBonus_moduleShieldBoosterSkillrqShieldop(self):
self.buildTested = 0
attr = "shieldBonus"
item = "Small Shield Booster I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.075
fLvl = 4
fIngame = 1.3
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_shieldBonus_moduleShieldBoosterSkillrqCapitalShieldop(self):
self.buildTested = 0
attr = "shieldBonus"
item = "Capital Shield Booster I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.075
fLvl = 4
fIngame = 1.3
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_shieldBonus_moduleShieldBoosterNoSkillrq(self):
self.buildTested = 0
attr = "shieldBonus"
item = "Civilian Shield Booster I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.075
fLvl = 4
fIngame = 1.3
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_shieldBonus_moduleOther(self):
self.buildTested = 0
attr = "shieldBonus"
item = "Small Shield Transporter I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

89
eos/tests/typeTests/ships/assaultShips/ishkur.py
View File

@@ -1,89 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Ishkur"
# Gallente Frigate Skill Bonus:
# 5% bonus to Small Hybrid Turret damage
def test_gallenteFrigate_damageMultiplier_moduleHybridWeaponSmall(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Light Ion Blaster I"
skill = "Gallente Frigate"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteFrigate_damageMultiplier_moduleHybridWeaponOther(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Heavy Electron Blaster I"
skill = "Gallente Frigate"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Assault Frigates Skill Bonus:
# 10% bonus to Small Hybrid Turret Optimal Range per level
def test_assaultShips_maxRange_moduleHybridWeaponSmall(self):
self.buildTested = 0
attr = "maxRange"
item = "Light Neutron Blaster I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_maxRange_moduleHybridWeaponOther(self):
self.buildTested = 0
attr = "maxRange"
item = "Dual 150mm Railgun I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Assault Frigates Skill Bonus:
# 5m3 Drone Bay Capacity per level
def test_assaultShips_droneCapacity_ship(self):
self.buildTested = 0
attr = "droneCapacity"
skill = "Assault Frigates"
iLvl = 1
iIngame = 30
fLvl = 4
fIngame = 45
iEos = self.getShipAttr(attr, skill=(skill, iLvl), ship=self.ship)
fEos = self.getShipAttr(attr, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame - iIngame
dEos = fEos - iEos
self.assertAlmostEquals(dEos, dIngame)

105
eos/tests/typeTests/ships/assaultShips/jaguar.py
View File

@@ -1,105 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Jaguar"
# Minmatar Frigate Skill Bonus:
# 5% bonus to Small Projectile Turret Damage per level
def test_minmatarFrigate_damageMultiplier_moduleProjectileWeaponSmall(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "150mm Light AutoCannon I"
skill = "Minmatar Frigate"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_minmatarFrigate_damageMultiplier_moduleProjectileWeaponOther(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "220mm Vulcan AutoCannon I"
skill = "Minmatar Frigate"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Assault Frigates Skill Bonus:
# 10% bonus to Small Projectile Turret Optimal Range per level
def test_assaultShips_maxRange_moduleProjectileWeaponSmall(self):
self.buildTested = 0
attr = "maxRange"
item = "280mm Howitzer Artillery I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_maxRange_moduleProjectileWeaponOther(self):
self.buildTested = 0
attr = "maxRange"
item = "720mm Howitzer Artillery I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Assault Frigates Skill Bonus:
# 5% bonus to Small Projectile Damage per level
def test_assaultShips_damageMultiplier_moduleProjectileWeaponSmall(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "125mm Gatling AutoCannon I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_damageMultiplier_moduleProjectileWeaponOther(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "425mm AutoCannon I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

286
eos/tests/typeTests/ships/assaultShips/malice.py
View File

@@ -1,286 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Malice"
# Amarr Frigate Skill Bonus:
# 5% bonus to Armor Resistances per level
# Bonus is bugged, it makes resistances worse
def test_amarrFrigate_armorEmDamageResonance_ship(self):
self.buildTested = 0
attr = "armorEmDamageResonance"
skill = "Amarr Frigate"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getShipAttr(attr, skill=(skill, iLvl), ship=self.ship)
fEos = self.getShipAttr(attr, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrFrigate_armorEmDamageResonance_other(self):
self.buildTested = 0
attr = "armorEmDamageResonance"
item = "Damage Control I"
skill = "Amarr Frigate"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrFrigate_armorExplosiveDamageResonance_ship(self):
self.buildTested = 0
attr = "armorExplosiveDamageResonance"
skill = "Amarr Frigate"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getShipAttr(attr, skill=(skill, iLvl), ship=self.ship)
fEos = self.getShipAttr(attr, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrFrigate_armorExplosiveDamageResonance_other(self):
self.buildTested = 0
attr = "armorExplosiveDamageResonance"
item = "Damage Control I"
skill = "Amarr Frigate"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrFrigate_armorKineticDamageResonance_ship(self):
self.buildTested = 0
attr = "armorKineticDamageResonance"
skill = "Amarr Frigate"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getShipAttr(attr, skill=(skill, iLvl), ship=self.ship)
fEos = self.getShipAttr(attr, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrFrigate_armorKineticDamageResonance_other(self):
self.buildTested = 0
attr = "armorKineticDamageResonance"
item = "Damage Control I"
skill = "Amarr Frigate"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrFrigate_armorThermalDamageResonance_ship(self):
self.buildTested = 0
attr = "armorThermalDamageResonance"
skill = "Amarr Frigate"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getShipAttr(attr, skill=(skill, iLvl), ship=self.ship)
fEos = self.getShipAttr(attr, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrFrigate_armorThermalDamageResonance_other(self):
self.buildTested = 0
attr = "armorThermalDamageResonance"
item = "Damage Control I"
skill = "Amarr Frigate"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Amarr Frigate Skill Bonus:
# 20% bonus to energy vampire transfer amount per level
def test_amarrFrigate_powerTransferAmount_moduleEnergyVampire(self):
self.buildTested = 0
attr = "powerTransferAmount"
item = "Small Nosferatu I"
skill = "Amarr Frigate"
iLvl = 1
iIngame = 1.2
fLvl = 4
fIngame = 1.8
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrFrigate_powerTransferAmount_moduleOther(self):
self.buildTested = 0
attr = "powerTransferAmount"
item = "Small Energy Transfer Array I"
skill = "Amarr Frigate"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Amarr Frigate Skill Bonus:
# 20% bonus to energy vampire range per level
def test_amarrFrigate_powerTransferRange_moduleEnergyVampire(self):
self.buildTested = 0
attr = "powerTransferRange"
item = "Small Nosferatu I"
skill = "Amarr Frigate"
iLvl = 1
iIngame = 1.2
fLvl = 4
fIngame = 1.8
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrFrigate_powerTransferRange_moduleOther(self):
self.buildTested = 0
attr = "powerTransferRange"
item = "Medium Energy Transfer Array I"
skill = "Amarr Frigate"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Amarr Frigate Skill Bonus:
# 20% bonus to energy neutralizer transfer amount per level
def test_amarrFrigate_energyDestabilizationAmount_moduleEnergyDestabilizer(self):
self.buildTested = 0
attr = "energyDestabilizationAmount"
item = "Medium Energy Neutralizer I"
skill = "Amarr Frigate"
iLvl = 1
iIngame = 1.2
fLvl = 4
fIngame = 1.8
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Amarr Frigate Skill Bonus:
# 20% bonus to energy neutralizer range per level
def test_amarrFrigate_energyDestabilizationRange_moduleEnergyDestabilizer(self):
self.buildTested = 0
attr = "energyDestabilizationRange"
item = "Small Energy Neutralizer I"
skill = "Amarr Frigate"
iLvl = 1
iIngame = 1.2
fLvl = 4
fIngame = 1.8
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Role Bonus:
# 100% bonus to Small Energy Turret Damage
def test_static_damageMultiplier_moduleEnergyWeaponSmall(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Medium Pulse Laser I"
ship_other = "Wolf"
iIngame = 1.0
fIngame = 2.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_damageMultiplier_moduleEnergyWeaponOther(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Quad Light Beam Laser I"
ship_other = "Wolf"
iIngame = 1.0
fIngame = 1.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Role Bonus:
# 50% bonus to Small Energy Turret optimal range
def test_static_maxRange_moduleEnergyWeaponSmall(self):
self.buildTested = 0
attr = "maxRange"
item = "Medium Beam Laser I"
ship_other = "Wolf"
iIngame = 1.0
fIngame = 1.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_maxRange_moduleEnergyWeaponOther(self):
self.buildTested = 0
attr = "maxRange"
item = "Heavy Pulse Laser I"
ship_other = "Wolf"
iIngame = 1.0
fIngame = 1.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

105
eos/tests/typeTests/ships/assaultShips/retribution.py
View File

@@ -1,105 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Retribution"
# Amarr Frigate Skill Bonus:
# 10% bonus to Small Energy Turret Cap Use per level
def test_amarrFrigate_capacitorNeed_moduleEnergyWeaponSmall(self):
self.buildTested = 0
attr = "capacitorNeed"
item = "Medium Pulse Laser I"
skill = "Amarr Frigate"
iLvl = 1
iIngame = 0.9
fLvl = 4
fIngame = 0.6
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrFrigate_capacitorNeed_moduleEnergyWeaponOther(self):
self.buildTested = 0
attr = "capacitorNeed"
item = "Focused Medium Pulse Laser I"
skill = "Amarr Frigate"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Assault Frigates Skill Bonus:
# 10% bonus to Small Energy Turret Optimal Range per level
def test_assaultShips_maxRange_moduleEnergyWeaponSmall(self):
self.buildTested = 0
attr = "maxRange"
item = "Medium Beam Laser I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_maxRange_moduleEnergyWeaponOther(self):
self.buildTested = 0
attr = "maxRange"
item = "Heavy Beam Laser I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Assault Frigates Skill Bonus:
# 5% bonus to Small Energy Turret Damage per level
def test_assaultShips_damageMultiplier_moduleEnergyWeaponSmall(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Gatling Pulse Laser I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_damageMultiplier_moduleEnergyWeaponOther(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Focused Medium Pulse Laser I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

484
eos/tests/typeTests/ships/assaultShips/utu.py
View File

@@ -1,484 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Utu"
# Gallente Frigate Skill Bonus:
# 10% bonus to drone damage per skill level
def test_gallenteFrigate_damageMultiplier_droneCombat(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Acolyte I"
skill = "Gallente Frigate"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Gallente Frigate Skill Bonus:
# 10% bonus to Warp Scrambler and Warp Disruptor Range per level.
def test_gallenteFrigate_maxRange_moduleWarpScramblerSkillrqPropJamming(self):
self.buildTested = 0
attr = "maxRange"
item = "Warp Scrambler I"
skill = "Gallente Frigate"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteFrigate_maxRange_moduleWarpScramblerNoSkillrqPropJamming(self):
self.buildTested = 0
attr = "maxRange"
item = "Civilian Warp Disruptor"
skill = "Gallente Frigate"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteFrigate_maxRange_moduleOtherSkillrqPropJamming(self):
self.buildTested = 0
attr = "maxRange"
item = "Stasis Webifier I"
skill = "Gallente Frigate"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Special Ability:
# 50% bonus to Small Hybrid Turret Optimal Range
def test_static_maxRange_moduleHybridWeaponSmall(self):
self.buildTested = 0
attr = "maxRange"
item = "150mm Railgun I"
ship_other = "Rifter"
iIngame = 1.0
fIngame = 1.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_maxRange_moduleHybridWeaponOther(self):
self.buildTested = 0
attr = "maxRange"
item = "Heavy Ion Blaster I"
ship_other = "Rifter"
iIngame = 1.0
fIngame = 1.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Special Ability:
# 50% bonus to Small Hybrid Turret Tracking
def test_static_trackingSpeed_moduleHybridWeaponSmall(self):
self.buildTested = 0
attr = "trackingSpeed"
item = "Light Ion Blaster I"
ship_other = "Rifter"
iIngame = 1.0
fIngame = 1.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_trackingSpeed_moduleHybridWeaponOther(self):
self.buildTested = 0
attr = "trackingSpeed"
item = "200mm Railgun I"
ship_other = "Rifter"
iIngame = 1.0
fIngame = 1.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Special Ability:
# 50% reduction in the amount of heat damage absorbed by modules
def test_static_heatDamage_moduleAfterburner(self):
self.buildTested = 0
attr = "heatDamage"
item = "1MN MicroWarpdrive I"
ship_other = "Rifter"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_heatDamage_moduleArmorHardener(self):
self.buildTested = 0
attr = "heatDamage"
item = "Armor Explosive Hardener I"
ship_other = "Rifter"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_heatDamage_moduleArmorRepairProjector(self):
self.buildTested = 0
attr = "heatDamage"
item = "Small Remote Armor Repair System I"
ship_other = "Rifter"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_heatDamage_moduleArmorRepairer(self):
self.buildTested = 0
attr = "heatDamage"
item = "Small Armor Repairer I"
ship_other = "Rifter"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_heatDamage_moduleCapacitorBooster(self):
self.buildTested = 0
attr = "heatDamage"
item = "Micro Capacitor Booster I"
ship_other = "Rifter"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_heatDamage_moduleECCM(self):
self.buildTested = 0
attr = "heatDamage"
item = "ECCM - Omni I"
ship_other = "Rifter"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_heatDamage_moduleECM(self):
self.buildTested = 0
attr = "heatDamage"
item = "ECM - Phase Inverter I"
ship_other = "Rifter"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_heatDamage_moduleEnergyDestabilizer(self):
self.buildTested = 0
attr = "heatDamage"
item = "Small Energy Neutralizer I"
ship_other = "Rifter"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_heatDamage_moduleEnergyTransferArray(self):
self.buildTested = 0
attr = "heatDamage"
item = "Small Energy Transfer Array I"
ship_other = "Rifter"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_heatDamage_moduleEnergyVampire(self):
self.buildTested = 0
attr = "heatDamage"
item = "Small Nosferatu I"
ship_other = "Rifter"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_heatDamage_moduleEnergyWeapon(self):
self.buildTested = 0
attr = "heatDamage"
item = "Dual Light Beam Laser I"
ship_other = "Rifter"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_heatDamage_moduleHullRepairer(self):
self.buildTested = 0
attr = "heatDamage"
item = "Small Hull Repairer I"
ship_other = "Rifter"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_heatDamage_moduleHybridWeapon(self):
self.buildTested = 0
attr = "heatDamage"
item = "150mm Railgun I"
ship_other = "Rifter"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_heatDamage_moduleMissileLauncherAssault(self):
self.buildTested = 0
attr = "heatDamage"
item = "Assault Missile Launcher I"
ship_other = "Rifter"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_heatDamage_moduleMissileLauncherCitadel(self):
self.buildTested = 0
attr = "heatDamage"
item = "Citadel Cruise Launcher I"
ship_other = "Rifter"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_heatDamage_moduleMissileLauncherCruise(self):
self.buildTested = 0
attr = "heatDamage"
item = "Cruise Missile Launcher I"
ship_other = "Rifter"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_heatDamage_moduleMissileLauncherHeavy(self):
self.buildTested = 0
attr = "heatDamage"
item = "Heavy Missile Launcher I"
ship_other = "Rifter"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_heatDamage_moduleMissileLauncherHeavyAssault(self):
self.buildTested = 0
attr = "heatDamage"
item = "Heavy Assault Missile Launcher I"
ship_other = "Rifter"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_heatDamage_moduleMissileLauncherRocket(self):
self.buildTested = 0
attr = "heatDamage"
item = "Rocket Launcher I"
ship_other = "Rifter"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_heatDamage_moduleMissileLauncherSiege(self):
self.buildTested = 0
attr = "heatDamage"
item = "Siege Missile Launcher I"
ship_other = "Rifter"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_heatDamage_moduleMissileLauncherStandard(self):
self.buildTested = 0
attr = "heatDamage"
item = "Standard Missile Launcher I"
ship_other = "Rifter"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_heatDamage_moduleProjectileWeapon(self):
self.buildTested = 0
attr = "heatDamage"
item = "125mm Gatling AutoCannon I"
ship_other = "Rifter"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_heatDamage_moduleShieldBooster(self):
self.buildTested = 0
attr = "heatDamage"
item = "Small Shield Booster I"
ship_other = "Rifter"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_heatDamage_moduleShieldHardener(self):
self.buildTested = 0
attr = "heatDamage"
item = "Photon Scattering Field I"
ship_other = "Rifter"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_heatDamage_moduleShieldTransporter(self):
self.buildTested = 0
attr = "heatDamage"
item = "Micro Shield Transporter I"
ship_other = "Rifter"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_heatDamage_moduleStasisWeb(self):
self.buildTested = 0
attr = "heatDamage"
item = "Stasis Webifier I"
ship_other = "Rifter"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_heatDamage_moduleWarpScrambler(self):
self.buildTested = 0
attr = "heatDamage"
item = "Warp Scrambler I"
ship_other = "Rifter"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

325
eos/tests/typeTests/ships/assaultShips/vengeance.py
View File

@@ -1,325 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Vengeance"
# Amarr Frigate Skill Bonus:
# 5% bonus to Rocket Damage per level
def test_amarrFrigate_emDamage_chargeRocket(self):
self.buildTested = 0
attr = "emDamage"
item = "Gremlin Rocket"
skill = "Amarr Frigate"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrFrigate_emDamage_chargeRocketAdvanced(self):
self.buildTested = 0
attr = "emDamage"
item = "Gremlin Rage Rocket"
skill = "Amarr Frigate"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrFrigate_emDamage_chargeOther(self):
self.buildTested = 0
attr = "emDamage"
item = "EMP S"
skill = "Amarr Frigate"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrFrigate_explosiveDamage_chargeRocket(self):
self.buildTested = 0
attr = "explosiveDamage"
item = "Phalanx Rocket"
skill = "Amarr Frigate"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrFrigate_explosiveDamage_chargeRocketAdvanced(self):
self.buildTested = 0
attr = "explosiveDamage"
item = "Phalanx Rage Rocket"
skill = "Amarr Frigate"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrFrigate_explosiveDamage_chargeOther(self):
self.buildTested = 0
attr = "explosiveDamage"
item = "Defender I"
skill = "Amarr Frigate"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrFrigate_kineticDamage_chargeRocket(self):
self.buildTested = 0
attr = "kineticDamage"
item = "Thorn Rocket"
skill = "Amarr Frigate"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrFrigate_kineticDamage_chargeRocketAdvanced(self):
self.buildTested = 0
attr = "kineticDamage"
item = "Thorn Javelin Rocket"
skill = "Amarr Frigate"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrFrigate_kineticDamage_chargeOther(self):
self.buildTested = 0
attr = "kineticDamage"
item = "Hail S"
skill = "Amarr Frigate"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrFrigate_thermalDamage_chargeRocket(self):
self.buildTested = 0
attr = "thermalDamage"
item = "Foxfire Rocket"
skill = "Amarr Frigate"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrFrigate_thermalDamage_chargeRocketAdvanced(self):
self.buildTested = 0
attr = "thermalDamage"
item = "Foxfire Rage Rocket"
skill = "Amarr Frigate"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrFrigate_thermalDamage_chargeOther(self):
self.buildTested = 0
attr = "thermalDamage"
item = "Aurora S"
skill = "Amarr Frigate"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Assault Frigates Skill Bonus:
# 5% bonus to Armor Resistances per level
def test_assaultShips_armorEmDamageResonance_ship(self):
self.buildTested = 0
attr = "armorEmDamageResonance"
skill = "Assault Frigates"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getShipAttr(attr, skill=(skill, iLvl), ship=self.ship)
fEos = self.getShipAttr(attr, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_armorEmDamageResonance_other(self):
self.buildTested = 0
attr = "armorEmDamageResonance"
item = "Damage Control I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_armorExplosiveDamageResonance_ship(self):
self.buildTested = 0
attr = "armorExplosiveDamageResonance"
skill = "Assault Frigates"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getShipAttr(attr, skill=(skill, iLvl), ship=self.ship)
fEos = self.getShipAttr(attr, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_armorExplosiveDamageResonance_other(self):
self.buildTested = 0
attr = "armorExplosiveDamageResonance"
item = "Damage Control I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_armorKineticDamageResonance_ship(self):
self.buildTested = 0
attr = "armorKineticDamageResonance"
skill = "Assault Frigates"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getShipAttr(attr, skill=(skill, iLvl), ship=self.ship)
fEos = self.getShipAttr(attr, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_armorKineticDamageResonance_other(self):
self.buildTested = 0
attr = "armorKineticDamageResonance"
item = "Damage Control I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_armorThermalDamageResonance_ship(self):
self.buildTested = 0
attr = "armorThermalDamageResonance"
skill = "Assault Frigates"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getShipAttr(attr, skill=(skill, iLvl), ship=self.ship)
fEos = self.getShipAttr(attr, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_armorThermalDamageResonance_other(self):
self.buildTested = 0
attr = "armorThermalDamageResonance"
item = "Damage Control I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Assault Frigates Skill Bonus:
# 5% bonus to Capacitor Recharge Rate per level
def test_assaultShips_rechargeRate_ship(self):
self.buildTested = 0
attr = "rechargeRate"
skill = "Assault Frigates"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getShipAttr(attr, skill=(skill, iLvl), ship=self.ship)
fEos = self.getShipAttr(attr, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

105
eos/tests/typeTests/ships/assaultShips/wolf.py
View File

@@ -1,105 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Wolf"
# Minmatar Frigate Skill Bonus:
# 5% bonus to Small Projectile Turret Damage per level
def test_minmatarFrigate_damageMultiplier_moduleProjectileWeaponSmall(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "200mm AutoCannon I"
skill = "Minmatar Frigate"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_minmatarFrigate_damageMultiplier_moduleProjectileWeaponOther(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "425mm AutoCannon I"
skill = "Minmatar Frigate"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Assault Frigates Skill Bonus:
# 5% bonus to Small Projectile Turret Damage per level
def test_assaultShips_damageMultiplier_moduleProjectileWeaponSmall(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "280mm Howitzer Artillery I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_damageMultiplier_moduleProjectileWeaponOther(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "650mm Artillery Cannon I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Assault Frigates Skill Bonus:
# 10% bonus to Small Projectile Falloff Range per level
def test_assaultShips_falloff_moduleProjectileWeaponSmall(self):
self.buildTested = 0
attr = "falloff"
item = "150mm Light AutoCannon I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_assaultShips_falloff_moduleProjectileWeaponOther(self):
self.buildTested = 0
attr = "falloff"
item = "220mm Vulcan AutoCannon I"
skill = "Assault Frigates"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

0
eos/tests/typeTests/ships/battlecruisers/__init__.py
View File

130
eos/tests/typeTests/ships/battlecruisers/brutix.py
View File

@@ -1,130 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Brutix"
# Battlecruiser Skill Bonus:
# 5% bonus to Medium Hybrid Turret damage per level
def test_battlecruisers_damageMultiplier_moduleHybridWeaponMedium(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Heavy Neutron Blaster I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_damageMultiplier_moduleHybridWeaponOther(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "150mm Railgun I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Battlecruiser Skill Bonus:
# 7.5% bonus to Armor Repairer effectiveness per level
def test_battlecruisers_armorDamageAmount_moduleArmorRepairer(self):
self.buildTested = 0
attr = "armorDamageAmount"
item = "Small Armor Repairer I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.075
fLvl = 4
fIngame = 1.3
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_armorDamageAmount_moduleArmorRepairerCapital(self):
self.buildTested = 0
attr = "armorDamageAmount"
item = "Capital Armor Repairer I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.075
fLvl = 4
fIngame = 1.3
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_armorDamageAmount_moduleArmorRepairerCivilian(self):
self.buildTested = 0
attr = "armorDamageAmount"
item = "Civilian Armor Repairer"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.075
fLvl = 4
fIngame = 1.3
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_armorDamageAmount_moduleOther(self):
self.buildTested = 0
attr = "armorDamageAmount"
item = "Small Remote Armor Repair System I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# 99% reduction in the CPU need of Warfare Link modules
def test_static_cpu_moduleGangCoordinatorSkillrqLeadership(self):
self.buildTested = 0
attr = "cpu"
item = "Skirmish Warfare Link - Interdiction Maneuvers I"
ship_other = "Abaddon"
iIngame = 1.0
fIngame = 0.01
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_cpu_moduleGangCoordinatorNoSkillrqLeadership(self):
self.buildTested = 0
attr = "cpu"
item = "Command Processor I"
ship_other = "Abaddon"
iIngame = 1.0
fIngame = 1.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

130
eos/tests/typeTests/ships/battlecruisers/cyclone.py
View File

@@ -1,130 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Cyclone"
# Battlecruiser Skill Bonus:
# 5% bonus to Medium Projectile Turret rate of fire per level
def test_battlecruisers_speed_moduleProjectileWeaponMedium(self):
self.buildTested = 0
attr = "speed"
item = "220mm Vulcan AutoCannon I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_speed_moduleProjectileWeaponOther(self):
self.buildTested = 0
attr = "speed"
item = "150mm Light AutoCannon I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Battlecruiser Skill Bonus:
# 7.5% bonus to shield boosting per level
def test_battlecruisers_shieldBonus_moduleShieldBooster(self):
self.buildTested = 0
attr = "shieldBonus"
item = "Large Shield Booster I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.075
fLvl = 4
fIngame = 1.3
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_shieldBonus_moduleShieldBoosterCapital(self):
self.buildTested = 0
attr = "shieldBonus"
item = "Capital Shield Booster I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.075
fLvl = 4
fIngame = 1.3
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_shieldBonus_moduleShieldBoosterCivilian(self):
self.buildTested = 0
attr = "shieldBonus"
item = "Civilian Shield Booster I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.075
fLvl = 4
fIngame = 1.3
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_shieldBonus_moduleOther(self):
self.buildTested = 0
attr = "shieldBonus"
item = "Medium Shield Transporter I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# 99% reduction in the CPU need of Warfare Link modules
def test_static_cpu_moduleGangCoordinatorSkillrqLeadership(self):
self.buildTested = 0
attr = "cpu"
item = "Siege Warfare Link - Shield Efficiency I"
ship_other = "Abaddon"
iIngame = 1.0
fIngame = 0.01
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_cpu_moduleGangCoordinatorNoSkillrqLeadership(self):
self.buildTested = 0
attr = "cpu"
item = "Command Processor I"
ship_other = "Abaddon"
iIngame = 1.0
fIngame = 1.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

246
eos/tests/typeTests/ships/battlecruisers/drake.py
View File

@@ -1,246 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Drake"
# Battlecruiser Skill Bonus:
# 5% shield resistance per level
def test_battlecruisers_shieldEmDamageResonance_ship(self):
self.buildTested = 0
attr = "shieldEmDamageResonance"
skill = "Battlecruisers"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getShipAttr(attr, skill=(skill, iLvl), ship=self.ship)
fEos = self.getShipAttr(attr, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_shieldEmDamageResonance_other(self):
self.buildTested = 0
attr = "shieldEmDamageResonance"
item = "Damage Control I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_shieldExplosiveDamageResonance_ship(self):
self.buildTested = 0
attr = "shieldExplosiveDamageResonance"
skill = "Battlecruisers"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getShipAttr(attr, skill=(skill, iLvl), ship=self.ship)
fEos = self.getShipAttr(attr, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_shieldExplosiveDamageResonance_other(self):
self.buildTested = 0
attr = "shieldExplosiveDamageResonance"
item = "Damage Control I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_shieldKineticDamageResonance_ship(self):
self.buildTested = 0
attr = "shieldKineticDamageResonance"
skill = "Battlecruisers"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getShipAttr(attr, skill=(skill, iLvl), ship=self.ship)
fEos = self.getShipAttr(attr, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_shieldKineticDamageResonance_other(self):
self.buildTested = 0
attr = "shieldKineticDamageResonance"
item = "Damage Control I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_shieldThermalDamageResonance_ship(self):
self.buildTested = 0
attr = "shieldThermalDamageResonance"
skill = "Battlecruisers"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getShipAttr(attr, skill=(skill, iLvl), ship=self.ship)
fEos = self.getShipAttr(attr, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_shieldThermalDamageResonance_other(self):
self.buildTested = 0
attr = "shieldThermalDamageResonance"
item = "Damage Control I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Battlecruiser Skill Bonus:
# 5% bonus kinetic damage of heavy missiles and heavy assault missiles per level
def test_battlecruisers_kineticDamage_chargeMissileAssault(self):
self.buildTested = 0
attr = "kineticDamage"
item = "Terror Assault Missile"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_kineticDamage_chargeMissileAssaultAdvanced(self):
self.buildTested = 0
attr = "kineticDamage"
item = "Terror Rage Assault Missile"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_kineticDamage_chargeMissileHeavy(self):
self.buildTested = 0
attr = "kineticDamage"
item = "Scourge Heavy Missile"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_kineticDamage_chargeMissileHeavyAdvanced(self):
self.buildTested = 0
attr = "kineticDamage"
item = "Scourge Precision Heavy Missile"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_kineticDamage_chargeMissileHeavyFof(self):
self.buildTested = 0
attr = "kineticDamage"
item = "Hydra F.O.F. Heavy Missile I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_kineticDamage_chargeOther(self):
self.buildTested = 0
attr = "kineticDamage"
item = "Bloodclaw Light Missile"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# 99% reduction in the CPU need of Warfare Link modules
def test_static_cpu_moduleGangCoordinatorSkillrqLeadership(self):
self.buildTested = 0
attr = "cpu"
item = "Siege Warfare Link - Active Shielding I"
ship_other = "Abaddon"
iIngame = 1.0
fIngame = 0.01
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_cpu_moduleGangCoordinatorNoSkillrqLeadership(self):
self.buildTested = 0
attr = "cpu"
item = "Command Processor I"
ship_other = "Abaddon"
iIngame = 1.0
fIngame = 1.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

186
eos/tests/typeTests/ships/battlecruisers/ferox.py
View File

@@ -1,186 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Ferox"
# Battlecruiser Skill Bonus:
# 10% bonus to Medium Hybrid Turret optimal range per level
def test_battlecruisers_maxRange_moduleHybridWeaponMedium(self):
self.buildTested = 0
attr = "maxRange"
item = "200mm Railgun I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_maxRange_moduleHybridWeaponOther(self):
self.buildTested = 0
attr = "maxRange"
item = "125mm Railgun I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Battlecruiser Skill Bonus:
# 5% bonus to all Shield resistances per level
def test_battlecruisers_shieldEmDamageResonance_ship(self):
self.buildTested = 0
attr = "shieldEmDamageResonance"
skill = "Battlecruisers"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getShipAttr(attr, skill=(skill, iLvl), ship=self.ship)
fEos = self.getShipAttr(attr, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_shieldEmDamageResonance_other(self):
self.buildTested = 0
attr = "shieldEmDamageResonance"
item = "Damage Control I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_shieldExplosiveDamageResonance_ship(self):
self.buildTested = 0
attr = "shieldExplosiveDamageResonance"
skill = "Battlecruisers"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getShipAttr(attr, skill=(skill, iLvl), ship=self.ship)
fEos = self.getShipAttr(attr, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_shieldExplosiveDamageResonance_other(self):
self.buildTested = 0
attr = "shieldExplosiveDamageResonance"
item = "Damage Control I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_shieldKineticDamageResonance_ship(self):
self.buildTested = 0
attr = "shieldKineticDamageResonance"
skill = "Battlecruisers"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getShipAttr(attr, skill=(skill, iLvl), ship=self.ship)
fEos = self.getShipAttr(attr, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_shieldKineticDamageResonance_other(self):
self.buildTested = 0
attr = "shieldKineticDamageResonance"
item = "Damage Control I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_shieldThermalDamageResonance_ship(self):
self.buildTested = 0
attr = "shieldThermalDamageResonance"
skill = "Battlecruisers"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getShipAttr(attr, skill=(skill, iLvl), ship=self.ship)
fEos = self.getShipAttr(attr, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_shieldThermalDamageResonance_other(self):
self.buildTested = 0
attr = "shieldThermalDamageResonance"
item = "Damage Control I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# 99% reduction in the CPU need of Warfare Link modules
def test_static_cpu_moduleGangCoordinatorSkillrqLeadership(self):
self.buildTested = 0
attr = "cpu"
item = "Mining Foreman Link - Laser Optimization I"
ship_other = "Abaddon"
iIngame = 1.0
fIngame = 0.01
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_cpu_moduleGangCoordinatorNoSkillrqLeadership(self):
self.buildTested = 0
attr = "cpu"
item = "Command Processor I"
ship_other = "Abaddon"
iIngame = 1.0
fIngame = 1.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

160
eos/tests/typeTests/ships/battlecruisers/harbinger.py
View File

@@ -1,160 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Harbinger"
# Battlecruiser Skill Bonus:
# 10% reduction in laser capacitor need per level
def test_battlecruisers_capacitorNeed_moduleEnergyWeaponSmall(self):
self.buildTested = 0
attr = "capacitorNeed"
item = "Gatling Pulse Laser I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 0.9
fLvl = 4
fIngame = 0.6
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_capacitorNeed_moduleEnergyWeaponMedium(self):
self.buildTested = 0
attr = "capacitorNeed"
item = "Heavy Beam Laser I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 0.9
fLvl = 4
fIngame = 0.6
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_capacitorNeed_moduleEnergyWeaponLarge(self):
self.buildTested = 0
attr = "capacitorNeed"
item = "Dual Heavy Pulse Laser I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 0.9
fLvl = 4
fIngame = 0.6
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_capacitorNeed_moduleEnergyWeaponCapital(self):
self.buildTested = 0
attr = "capacitorNeed"
item = "Dual Giga Pulse Laser I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 0.9
fLvl = 4
fIngame = 0.6
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Battlecruiser Skill Bonus:
# 5% bonus to laser damage per level
def test_battlecruisers_damageMultiplier_moduleEnergyWeaponSmall(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Dual Light Beam Laser I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_damageMultiplier_moduleEnergyWeaponMedium(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Quad Light Beam Laser I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_damageMultiplier_moduleEnergyWeaponLarge(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Mega Beam Laser I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_damageMultiplier_moduleEnergyWeaponCapital(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Dual Giga Beam Laser I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# 99% reduction in the CPU need of Warfare Link modules
def test_static_cpu_moduleGangCoordinatorSkillrqLeadership(self):
self.buildTested = 0
attr = "cpu"
item = "Armored Warfare Link - Damage Control I"
ship_other = "Abaddon"
iIngame = 1.0
fIngame = 0.01
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_cpu_moduleGangCoordinatorNoSkillrqLeadership(self):
self.buildTested = 0
attr = "cpu"
item = "Command Processor I"
ship_other = "Abaddon"
iIngame = 1.0
fIngame = 1.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

100
eos/tests/typeTests/ships/battlecruisers/hurricane.py
View File

@@ -1,100 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Hurricane"
# Battlecruiser Skill Bonus:
# 5% increase in projectile weapons damage per level
def test_battlecruisers_damageMultiplier_moduleProjectileWeaponMedium(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Dual 180mm AutoCannon I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_damageMultiplier_moduleProjectileWeaponOther(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "150mm Light AutoCannon I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Battlecruiser Skill Bonus:
# 5% increase in projectile weapons Rate of Fire per level
def test_battlecruisers_speed_moduleProjectileWeaponMedium(self):
self.buildTested = 0
attr = "speed"
item = "425mm AutoCannon I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_speed_moduleProjectileWeaponOther(self):
self.buildTested = 0
attr = "speed"
item = "Dual 425mm AutoCannon I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# 99% reduction in the CPU need of Warfare Link modules
def test_static_cpu_moduleGangCoordinatorSkillrqLeadership(self):
self.buildTested = 0
attr = "cpu"
item = "Mining Foreman Link - Laser Optimization I"
ship_other = "Abaddon"
iIngame = 1.0
fIngame = 0.01
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_cpu_moduleGangCoordinatorNoSkillrqLeadership(self):
self.buildTested = 0
attr = "cpu"
item = "Command Processor I"
ship_other = "Abaddon"
iIngame = 1.0
fIngame = 1.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

241
eos/tests/typeTests/ships/battlecruisers/myrmidon.py
View File

@@ -1,241 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Myrmidon"
# Battlecruiser Skill Bonus:
# 10% increase to drone hitpoints per level
def test_battlecruisers_hp_droneCombat(self):
self.buildTested = 0
item = "Hammerhead I"
skill = "Battlecruisers"
layers = ("shieldCapacity", "armorHP", "hp")
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = 0
fEos = 0
for layer in layers:
iEos += self.getItemAttr(layer, item, skill=(skill, iLvl), ship=self.ship)
fEos += self.getItemAttr(layer, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_hp_droneLogistic(self):
self.buildTested = 0
item = "Medium Armor Maintenance Bot I"
skill = "Battlecruisers"
layers = ("shieldCapacity", "armorHP", "hp")
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = 0
fEos = 0
for layer in layers:
iEos += self.getItemAttr(layer, item, skill=(skill, iLvl), ship=self.ship)
fEos += self.getItemAttr(layer, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_hp_droneEwar(self):
self.buildTested = 0
item = "Praetor TD-900"
skill = "Battlecruisers"
layers = ("shieldCapacity", "armorHP", "hp")
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = 0
fEos = 0
for layer in layers:
iEos += self.getItemAttr(layer, item, skill=(skill, iLvl), ship=self.ship)
fEos += self.getItemAttr(layer, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_hp_droneCapDrain(self):
self.buildTested = 0
item = "Infiltrator EV-600"
skill = "Battlecruisers"
layers = ("shieldCapacity", "armorHP", "hp")
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = 0
fEos = 0
for layer in layers:
iEos += self.getItemAttr(layer, item, skill=(skill, iLvl), ship=self.ship)
fEos += self.getItemAttr(layer, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_hp_droneWeb(self):
self.buildTested = 0
item = "Berserker SW-900"
skill = "Battlecruisers"
layers = ("shieldCapacity", "armorHP", "hp")
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = 0
fEos = 0
for layer in layers:
iEos += self.getItemAttr(layer, item, skill=(skill, iLvl), ship=self.ship)
fEos += self.getItemAttr(layer, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_hp_droneMining(self):
self.buildTested = 0
item = "Harvester Mining Drone"
skill = "Battlecruisers"
layers = ("shieldCapacity", "armorHP", "hp")
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = 0
fEos = 0
for layer in layers:
iEos += self.getItemAttr(layer, item, skill=(skill, iLvl), ship=self.ship)
fEos += self.getItemAttr(layer, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Battlecruiser Skill Bonus:
# 10% increase to damage dealt by drones per level
def test_battlecruisers_damageMultiplier_droneCombat(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Bouncer I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_damageMultiplier_other(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "150mm Light AutoCannon I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Battlecruiser Skill Bonus:
# 7.5% increase to armor repair amount per level
def test_battlecruisers_armorDamageAmount_moduleArmorRepairer(self):
self.buildTested = 0
attr = "armorDamageAmount"
item = "Medium Armor Repairer I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.075
fLvl = 4
fIngame = 1.3
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_armorDamageAmount_moduleArmorRepairerCapital(self):
self.buildTested = 0
attr = "armorDamageAmount"
item = "Capital Armor Repairer I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.075
fLvl = 4
fIngame = 1.3
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_armorDamageAmount_moduleArmorRepairerCivilian(self):
self.buildTested = 0
attr = "armorDamageAmount"
item = "Civilian Armor Repairer"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.075
fLvl = 4
fIngame = 1.3
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_armorDamageAmount_moduleOther(self):
self.buildTested = 0
attr = "armorDamageAmount"
item = "Medium Remote Armor Repair System I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# 99% reduction in the CPU need of Warfare Link modules
def test_static_cpu_moduleGangCoordinatorSkillrqLeadership(self):
self.buildTested = 0
attr = "cpu"
item = "Information Warfare Link - Sensor Integrity I"
ship_other = "Abaddon"
iIngame = 1.0
fIngame = 0.01
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_cpu_moduleGangCoordinatorNoSkillrqLeadership(self):
self.buildTested = 0
attr = "cpu"
item = "Command Processor I"
ship_other = "Abaddon"
iIngame = 1.0
fIngame = 1.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

160
eos/tests/typeTests/ships/battlecruisers/naga.py
View File

@@ -1,160 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Naga"
# Battlecruiser Skill Bonus Per Level:
# 5% bonus to Large Hybrid Turret damage
def test_battlecruisers_damageMultiplier_moduleHybridWeaponLarge(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Electron Blaster Cannon I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_damageMultiplier_moduleHybridWeaponOther(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Light Electron Blaster I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Battlecruiser Skill Bonus Per Level:
# 10% bonus to Large Hybrid Turret optimal range
def test_battlecruisers_maxRange_moduleHybridWeaponLarge(self):
self.buildTested = 0
attr = "maxRange"
item = "425mm Railgun I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_maxRange_moduleHybridWeaponOther(self):
self.buildTested = 0
attr = "maxRange"
item = "200mm Railgun I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Role Bonus:
# 95% reduction in the powergrid need of Large Hybrid Turrets
def test_static_power_moduleHybridWeaponLarge(self):
self.buildTested = 0
attr = "power"
item = "Ion Blaster Cannon I"
ship_other = "Raven"
iIngame = 1.0
fIngame = 0.05
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_power_moduleHybridWeaponOther(self):
self.buildTested = 0
attr = "power"
item = "Dual 150mm Railgun I"
ship_other = "Raven"
iIngame = 1.0
fIngame = 1.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Role Bonus:
# 50% reduction in the CPU need of Large Hybrid Turrets
def test_static_cpu_moduleHybridWeaponLarge(self):
self.buildTested = 0
attr = "cpu"
item = "Neutron Blaster Cannon I"
ship_other = "Raven"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_cpu_moduleHybridWeaponOther(self):
self.buildTested = 0
attr = "cpu"
item = "Light Electron Blaster I"
ship_other = "Raven"
iIngame = 1.0
fIngame = 1.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Role Bonus:
# 50% reduction in the capacitor need of Large Hybrid Turrets
def test_static_capacitorNeed_moduleHybridWeaponLarge(self):
self.buildTested = 0
attr = "capacitorNeed"
item = "Dual 250mm Railgun I"
ship_other = "Raven"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_capacitorNeed_moduleHybridWeaponOther(self):
self.buildTested = 0
attr = "capacitorNeed"
item = "Heavy Ion Blaster I"
ship_other = "Raven"
iIngame = 1.0
fIngame = 1.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

159
eos/tests/typeTests/ships/battlecruisers/oracle.py
View File

@@ -1,159 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Oracle"
# Battlecruiser Skill Bonus Per Level:
# 10% bonus to Large Energy Turret capacitor use
def test_battlecruisers_capacitorNeed_moduleEnergyWeaponLarge(self):
self.buildTested = 0
attr = "capacitorNeed"
item = "Mega Pulse Laser I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 0.9
fLvl = 4
fIngame = 0.6
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_capacitorNeed_moduleEnergyWeaponOther(self):
self.buildTested = 0
attr = "capacitorNeed"
item = "Heavy Beam Laser I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Battlecruiser Skill Bonus Per Level:
# 5% bonus to Large Energy Turret damage
def test_battlecruisers_damageMultiplier_moduleEnergyWeaponLarge(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Tachyon Beam Laser I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_damageMultiplier_moduleEnergyWeaponOther(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Heavy Pulse Laser I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Role Bonus:
# 95% reduction in the powergrid need of Large Energy Turrets
def test_static_power_moduleEnergyWeaponLarge(self):
self.buildTested = 0
attr = "power"
item = "Dual Heavy Pulse Laser I"
ship_other = "Apocalypse"
iIngame = 1.0
fIngame = 0.05
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_power_moduleEnergyWeaponOther(self):
self.buildTested = 0
attr = "power"
item = "Dual Light Beam Laser I"
ship_other = "Apocalypse"
iIngame = 1.0
fIngame = 1.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Role Bonus:
# 50% reduction in the CPU need of Large Energy Turrets
def test_static_cpu_moduleEnergyWeaponLarge(self):
self.buildTested = 0
attr = "cpu"
item = "Mega Beam Laser I"
ship_other = "Apocalypse"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_cpu_moduleEnergyWeaponOther(self):
self.buildTested = 0
attr = "cpu"
item = "Gatling Pulse Laser I"
ship_other = "Apocalypse"
iIngame = 1.0
fIngame = 1.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Role Bonus:
# 50% reduction in the capacitor need of Large Energy Turrets
def test_static_capacitorNeed_moduleEnergyWeaponLarge(self):
self.buildTested = 0
attr = "capacitorNeed"
item = "Tachyon Beam Laser I"
ship_other = "Apocalypse"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_capacitorNeed_moduleEnergyWeaponOther(self):
self.buildTested = 0
attr = "capacitorNeed"
item = "Quad Light Beam Laser I"
ship_other = "Apocalypse"
iIngame = 1.0
fIngame = 1.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

186
eos/tests/typeTests/ships/battlecruisers/prophecy.py
View File

@@ -1,186 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Prophecy"
# Battlecruiser Skill Bonus:
# 10% reduction in Medium Energy Weapon capacitor use per level
def test_battlecruisers_capacitorNeed_moduleEnergyWeaponMedium(self):
self.buildTested = 0
attr = "capacitorNeed"
item = "Heavy Pulse Laser I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 0.9
fLvl = 4
fIngame = 0.6
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_capacitorNeed_moduleEnergyWeaponOther(self):
self.buildTested = 0
attr = "capacitorNeed"
item = "Gatling Pulse Laser I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Battlecruiser Skill Bonus:
# 5% bonus to all armor resistances per level
def test_battlecruisers_armorEmDamageResonance_ship(self):
self.buildTested = 0
attr = "armorEmDamageResonance"
skill = "Battlecruisers"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getShipAttr(attr, skill=(skill, iLvl), ship=self.ship)
fEos = self.getShipAttr(attr, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_armorEmDamageResonance_other(self):
self.buildTested = 0
attr = "armorEmDamageResonance"
item = "Damage Control I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_armorExplosiveDamageResonance_ship(self):
self.buildTested = 0
attr = "armorExplosiveDamageResonance"
skill = "Battlecruisers"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getShipAttr(attr, skill=(skill, iLvl), ship=self.ship)
fEos = self.getShipAttr(attr, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_armorExplosiveDamageResonance_other(self):
self.buildTested = 0
attr = "armorExplosiveDamageResonance"
item = "Damage Control I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_armorKineticDamageResonance_ship(self):
self.buildTested = 0
attr = "armorKineticDamageResonance"
skill = "Battlecruisers"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getShipAttr(attr, skill=(skill, iLvl), ship=self.ship)
fEos = self.getShipAttr(attr, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_armorKineticDamageResonance_other(self):
self.buildTested = 0
attr = "armorKineticDamageResonance"
item = "Damage Control I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_armorThermalDamageResonance_ship(self):
self.buildTested = 0
attr = "armorThermalDamageResonance"
skill = "Battlecruisers"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getShipAttr(attr, skill=(skill, iLvl), ship=self.ship)
fEos = self.getShipAttr(attr, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_armorThermalDamageResonance_other(self):
self.buildTested = 0
attr = "armorThermalDamageResonance"
item = "Damage Control I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# 99% reduction in the CPU need of Warfare Link modules
def test_static_cpu_moduleGangCoordinatorSkillrqLeadership(self):
self.buildTested = 0
attr = "cpu"
item = "Information Warfare Link - Recon Operation I"
ship_other = "Abaddon"
iIngame = 1.0
fIngame = 0.01
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_cpu_moduleGangCoordinatorNoSkillrqLeadership(self):
self.buildTested = 0
attr = "cpu"
item = "Command Processor I"
ship_other = "Abaddon"
iIngame = 1.0
fIngame = 1.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

159
eos/tests/typeTests/ships/battlecruisers/talos.py
View File

@@ -1,159 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Talos"
# Battlecruiser Skill Bonus Per Level:
# 5% bonus to Large Hybrid Turret damage
def test_battlecruisers_damageMultiplier_moduleHybridWeaponLarge(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Neutron Blaster Cannon I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_damageMultiplier_moduleHybridWeaponOther(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Heavy Neutron Blaster I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Battlecruiser Skill Bonus Per Level:
# 7.5% bonus to Large Hybrid Turret tracking speed
def test_battlecruisers_trackingSpeed_moduleHybridWeaponLarge(self):
self.buildTested = 0
attr = "trackingSpeed"
item = "350mm Railgun I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.075
fLvl = 4
fIngame = 1.3
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_trackingSpeed_moduleHybridWeaponOther(self):
self.buildTested = 0
attr = "trackingSpeed"
item = "Light Electron Blaster I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Role Bonus:
# 95% reduction in the powergrid need of Large Hybrid Turrets
def test_static_power_moduleHybridWeaponLarge(self):
self.buildTested = 0
attr = "power"
item = "Electron Blaster Cannon I"
ship_other = "Megathron"
iIngame = 1.0
fIngame = 0.05
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_power_moduleHybridWeaponOther(self):
self.buildTested = 0
attr = "power"
item = "Heavy Neutron Blaster I"
ship_other = "Megathron"
iIngame = 1.0
fIngame = 1.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Role Bonus:
# 50% reduction in the CPU need of Large Hybrid Turrets
def test_static_cpu_moduleHybridWeaponLarge(self):
self.buildTested = 0
attr = "cpu"
item = "Dual 250mm Railgun I"
ship_other = "Megathron"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_cpu_moduleHybridWeaponOther(self):
self.buildTested = 0
attr = "cpu"
item = "Dual 150mm Railgun I"
ship_other = "Megathron"
iIngame = 1.0
fIngame = 1.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Role Bonus:
# 50% reduction in the capacitor need of Large Hybrid Turrets
def test_static_capacitorNeed_moduleHybridWeaponLarge(self):
self.buildTested = 0
attr = "capacitorNeed"
item = "425mm Railgun I"
ship_other = "Megathron"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_capacitorNeed_moduleHybridWeaponOther(self):
self.buildTested = 0
attr = "capacitorNeed"
item = "Heavy Neutron Blaster I"
ship_other = "Megathron"
iIngame = 1.0
fIngame = 1.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

130
eos/tests/typeTests/ships/battlecruisers/tornado.py
View File

@@ -1,130 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Tornado"
# Battlecruiser Skill Bonus Per Level:
# 5% bonus to Large Projectile Turret Rate of Fire
def test_battlecruisers_speed_moduleProjectileWeaponLarge(self):
self.buildTested = 0
attr = "speed"
item = "Dual 425mm AutoCannon I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_speed_moduleProjectileWeaponOther(self):
self.buildTested = 0
attr = "speed"
item = "280mm Howitzer Artillery I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Battlecruiser Skill Bonus Per Level:
# 5% bonus to Large Projectile Turret falloff
def test_battlecruisers_falloff_moduleProjectileWeaponLarge(self):
self.buildTested = 0
attr = "falloff"
item = "800mm Repeating Artillery I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_battlecruisers_falloff_moduleProjectileWeaponOther(self):
self.buildTested = 0
attr = "falloff"
item = "720mm Howitzer Artillery I"
skill = "Battlecruisers"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Role Bonus:
# 95% reduction in the powergrid need of Large Projectile Turrets
def test_static_power_moduleProjectileWeaponLarge(self):
self.buildTested = 0
attr = "power"
item = "1200mm Artillery Cannon I"
ship_other = "Tempest"
iIngame = 1.0
fIngame = 0.05
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_power_moduleProjectileWeaponOther(self):
self.buildTested = 0
attr = "power"
item = "650mm Artillery Cannon I"
ship_other = "Tempest"
iIngame = 1.0
fIngame = 1.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Role Bonus:
# 50% reduction in the CPU need of Large Projectile Turrets
def test_static_cpu_moduleProjectileWeaponLarge(self):
self.buildTested = 0
attr = "cpu"
item = "Dual 650mm Repeating Artillery I"
ship_other = "Tempest"
iIngame = 1.0
fIngame = 0.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_cpu_moduleProjectileWeaponOther(self):
self.buildTested = 0
attr = "cpu"
item = "220mm Vulcan AutoCannon I"
ship_other = "Tempest"
iIngame = 1.0
fIngame = 1.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

0
eos/tests/typeTests/ships/battleships/__init__.py
View File

158
eos/tests/typeTests/ships/battleships/abaddon.py
View File

@@ -1,158 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Abaddon"
# Amarr Battleship Skill Bonus:
# 5% bonus to Large Energy Turret damage per level
def test_amarrBattleship_damageMultiplier_moduleEnergyWeaponLarge(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Dual Heavy Pulse Laser I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrBattleship_damageMultiplier_moduleEnergyWeaponOther(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Heavy Beam Laser I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Amarr Battleship Skill Bonus:
# 5% armor resistance per level
def test_amarrBattleship_armorEmDamageResonance_ship(self):
self.buildTested = 0
attr = "armorEmDamageResonance"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getShipAttr(attr, skill=(skill, iLvl), ship=self.ship)
fEos = self.getShipAttr(attr, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrBattleship_armorEmDamageResonance_other(self):
self.buildTested = 0
attr = "armorEmDamageResonance"
item = "Damage Control I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrBattleship_armorExplosiveDamageResonance_ship(self):
self.buildTested = 0
attr = "armorExplosiveDamageResonance"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getShipAttr(attr, skill=(skill, iLvl), ship=self.ship)
fEos = self.getShipAttr(attr, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrBattleship_armorExplosiveDamageResonance_other(self):
self.buildTested = 0
attr = "armorExplosiveDamageResonance"
item = "Damage Control I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrBattleship_armorKineticDamageResonance_ship(self):
self.buildTested = 0
attr = "armorKineticDamageResonance"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getShipAttr(attr, skill=(skill, iLvl), ship=self.ship)
fEos = self.getShipAttr(attr, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrBattleship_armorKineticDamageResonance_other(self):
self.buildTested = 0
attr = "armorKineticDamageResonance"
item = "Damage Control I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrBattleship_armorThermalDamageResonance_ship(self):
self.buildTested = 0
attr = "armorThermalDamageResonance"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getShipAttr(attr, skill=(skill, iLvl), ship=self.ship)
fEos = self.getShipAttr(attr, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrBattleship_armorThermalDamageResonance_other(self):
self.buildTested = 0
attr = "armorThermalDamageResonance"
item = "Damage Control I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

72
eos/tests/typeTests/ships/battleships/apocalypse.py
View File

@@ -1,72 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Apocalypse"
# Amarr Battleship Skill Bonus:
# 10% bonus to Large Energy Turret capacitor use per level
def test_amarrBattleship_capacitorNeed_moduleEnergyWeaponLarge(self):
self.buildTested = 0
attr = "capacitorNeed"
item = "Tachyon Beam Laser I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 0.9
fLvl = 4
fIngame = 0.6
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrBattleship_capacitorNeed_moduleEnergyWeaponOther(self):
self.buildTested = 0
attr = "capacitorNeed"
item = "Dual Light Beam Laser I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Amarr Battleship Skill Bonus:S
# 7.5% bonus to Large Energy Turret optimal range per level
def test_amarrBattleship_maxRange_moduleEnergyWeaponLarge(self):
self.buildTested = 0
attr = "maxRange"
item = "Mega Pulse Laser I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 1.075
fLvl = 4
fIngame = 1.3
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrBattleship_maxRange_moduleEnergyWeaponOther(self):
self.buildTested = 0
attr = "maxRange"
item = "Heavy Pulse Laser I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

56
eos/tests/typeTests/ships/battleships/apocalypseImperialIssue.py
View File

@@ -1,56 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Apocalypse Imperial Issue"
# Amarr Battleship Skill Bonus:
# 10% bonus to Large Energy Turret capacitor use per level
def test_amarrBattleship_capacitorNeed_moduleEnergyWeaponLarge(self):
self.buildTested = 0
attr = "capacitorNeed"
item = "Dual Heavy Beam Laser I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 0.9
fLvl = 4
fIngame = 0.6
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrBattleship_capacitorNeed_moduleEnergyWeaponOther(self):
self.buildTested = 0
attr = "capacitorNeed"
item = "Gatling Pulse Laser I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Amarr Battleship Skill Bonus:
# 5% maximum Capacitor Capacity per level
def test_amarrBattleship_capacitorCapacity_ship(self):
self.buildTested = 0
attr = "capacitorCapacity"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getShipAttr(attr, skill=(skill, iLvl), ship=self.ship)
fEos = self.getShipAttr(attr, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

72
eos/tests/typeTests/ships/battleships/apocalypseNavyIssue.py
View File

@@ -1,72 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Apocalypse Navy Issue"
# Amarr Battleship Skill Bonus:
# 10% bonus to Large Energy Turret capacitor use per level
def test_amarrBattleship_capacitorNeed_moduleEnergyWeaponLarge(self):
self.buildTested = 0
attr = "capacitorNeed"
item = "Mega Beam Laser I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 0.9
fLvl = 4
fIngame = 0.6
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrBattleship_capacitorNeed_moduleEnergyWeaponOther(self):
self.buildTested = 0
attr = "capacitorNeed"
item = "Dual Light Pulse Laser I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Amarr Battleship Skill Bonus:
# 7.5% bonus to Large Energy Turret optimal range per level
def test_amarrBattleship_maxRange_moduleEnergyWeaponLarge(self):
self.buildTested = 0
attr = "maxRange"
item = "Tachyon Beam Laser I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 1.075
fLvl = 4
fIngame = 1.3
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrBattleship_maxRange_moduleEnergyWeaponOther(self):
self.buildTested = 0
attr = "maxRange"
item = "Medium Beam Laser I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

72
eos/tests/typeTests/ships/battleships/armageddon.py
View File

@@ -1,72 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Armageddon"
# Amarr Battleship Skill Bonus:
# 10% bonus to Large Energy Turret capacitor use per level
def test_amarrBattleship_capacitorNeed_moduleEnergyWeaponLarge(self):
self.buildTested = 0
attr = "capacitorNeed"
item = "Mega Beam Laser I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 0.9
fLvl = 4
fIngame = 0.6
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrBattleship_capacitorNeed_moduleEnergyWeaponOther(self):
self.buildTested = 0
attr = "capacitorNeed"
item = "Quad Light Beam Laser I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Amarr Battleship Skill Bonus:
# 5% Large Energy Turret rate of fire per level
def test_amarrBattleship_speed_moduleEnergyWeaponLarge(self):
self.buildTested = 0
attr = "speed"
item = "Tachyon Beam Laser I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrBattleship_speed_moduleEnergyWeaponOther(self):
self.buildTested = 0
attr = "speed"
item = "Heavy Pulse Laser I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

72
eos/tests/typeTests/ships/battleships/armageddonImperialIssue.py
View File

@@ -1,72 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Armageddon Imperial Issue"
# Amarr Battleship Skill Bonus:
# 10% bonus to Large Energy Turret capacitor use per level
def test_amarrBattleship_capacitorNeed_moduleEnergyWeaponLarge(self):
self.buildTested = 0
attr = "capacitorNeed"
item = "Mega Pulse Laser I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 0.9
fLvl = 4
fIngame = 0.6
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrBattleship_capacitorNeed_moduleEnergyWeaponOther(self):
self.buildTested = 0
attr = "capacitorNeed"
item = "Focused Medium Pulse Laser I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Amarr Battleship Skill Bonus:
# 5% Large Energy Turret rate of fire per level
def test_amarrBattleship_speed_moduleEnergyWeaponLarge(self):
self.buildTested = 0
attr = "speed"
item = "Mega Beam Laser I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrBattleship_speed_moduleEnergyWeaponOther(self):
self.buildTested = 0
attr = "speed"
item = "Dual Light Pulse Laser I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

72
eos/tests/typeTests/ships/battleships/armageddonNavyIssue.py
View File

@@ -1,72 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Armageddon Navy Issue"
# Amarr Battleship Skill Bonus:
# 10% bonus to Large Energy Turret capacitor use per level
def test_amarrBattleship_capacitorNeed_moduleEnergyWeaponLarge(self):
self.buildTested = 0
attr = "capacitorNeed"
item = "Dual Heavy Beam Laser I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 0.9
fLvl = 4
fIngame = 0.6
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrBattleship_capacitorNeed_moduleEnergyWeaponOther(self):
self.buildTested = 0
attr = "capacitorNeed"
item = "Focused Medium Beam Laser I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Amarr Battleship Skill Bonus:
# 5% Large Energy Turret rate of fire per level
def test_amarrBattleship_speed_moduleEnergyWeaponLarge(self):
self.buildTested = 0
attr = "speed"
item = "Dual Heavy Pulse Laser I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrBattleship_speed_moduleEnergyWeaponOther(self):
self.buildTested = 0
attr = "speed"
item = "Medium Pulse Laser I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

149
eos/tests/typeTests/ships/battleships/bhaalgorn.py
View File

@@ -1,149 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Bhaalgorn"
# Amarr Battleship Skill Bonus:
# 15% bonus to Energy Vampire drain amount per level
def test_amarrBattleship_powerTransferAmount_moduleEnergyVampire(self):
self.buildTested = 0
attr = "powerTransferAmount"
item = "Heavy Nosferatu I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 1.15
fLvl = 4
fIngame = 1.6
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrBattleship_powerTransferAmount_moduleOther(self):
self.buildTested = 0
attr = "powerTransferAmount"
item = "Large Energy Transfer Array I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Amarr Battleship Skill Bonus:
# 15% bonus to Energy Neutralizer drain amount per level
def test_amarrBattleship_energyDestabilizationAmount_moduleEnergyDestabilizer(self):
self.buildTested = 0
attr = "energyDestabilizationAmount"
item = "Medium Energy Neutralizer I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 1.15
fLvl = 4
fIngame = 1.6
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrBattleship_energyDestabilizationAmount_other(self):
self.buildTested = 0
attr = "energyDestabilizationAmount"
item = "Praetor EV-900"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Minmatar Battleship Skill Bonus:
# 20% bonus to Stasis Webifier activation range per level
def test_minmatarBattleship_maxRange_moduleStasisWeb(self):
self.buildTested = 0
attr = "maxRange"
item = "Stasis Webifier I"
skill = "Minmatar Battleship"
iLvl = 1
iIngame = 1.2
fLvl = 4
fIngame = 1.8
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_minmatarBattleship_maxRange_moduleStasisCivilian(self):
self.buildTested = 0
attr = "maxRange"
item = "Civilian Stasis Webifier"
skill = "Minmatar Battleship"
iLvl = 1
iIngame = 1.2
fLvl = 4
fIngame = 1.8
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_minmatarBattleship_maxRange_moduleOtherSkillrqPropulsionJamming(self):
self.buildTested = 0
attr = "maxRange"
item = "Warp Disruptor I"
skill = "Minmatar Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Special Ability:
# 100% bonus to Large Energy Turret damage
def test_static_damageMultiplier_moduleEnergyWeaponLarge(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Tachyon Beam Laser I"
ship_other = "Tempest"
iIngame = 1.0
fIngame = 2.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_damageMultiplier_moduleEnergyWeaponOther(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Heavy Pulse Laser I"
ship_other = "Tempest"
iIngame = 1.0
fIngame = 1.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

183
eos/tests/typeTests/ships/battleships/dominix.py
View File

@@ -1,183 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Dominix"
# Gallente Battleship Skill Bonus:
# 5% bonus to Large Hybrid Turret damage per skill level
def test_gallenteBattleship_damageMultiplier_moduleHybridWeaponLarge(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Neutron Blaster Cannon I"
skill = "Gallente Battleship"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteBattleship_damageMultiplier_moduleHybridWeaponOther(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "250mm Railgun I"
skill = "Gallente Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Gallente Battleship Skill Bonus:
# 10% bonus to drone hitpoints per skill level
def test_gallenteBattleship_hp_droneCombat(self):
self.buildTested = 0
item = "Ogre I"
skill = "Gallente Battleship"
layers = ("shieldCapacity", "armorHP", "hp")
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = 0
fEos = 0
for layer in layers:
iEos += self.getItemAttr(layer, item, skill=(skill, iLvl), ship=self.ship)
fEos += self.getItemAttr(layer, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteBattleship_hp_droneLogistic(self):
self.buildTested = 0
item = "Heavy Shield Maintenance Bot I"
skill = "Gallente Battleship"
layers = ("shieldCapacity", "armorHP", "hp")
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = 0
fEos = 0
for layer in layers:
iEos += self.getItemAttr(layer, item, skill=(skill, iLvl), ship=self.ship)
fEos += self.getItemAttr(layer, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteBattleship_hp_droneEwar(self):
self.buildTested = 0
item = "Wasp EC-900"
skill = "Gallente Battleship"
layers = ("shieldCapacity", "armorHP", "hp")
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = 0
fEos = 0
for layer in layers:
iEos += self.getItemAttr(layer, item, skill=(skill, iLvl), ship=self.ship)
fEos += self.getItemAttr(layer, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteBattleship_hp_droneCapDrain(self):
self.buildTested = 0
item = "Praetor EV-900"
skill = "Gallente Battleship"
layers = ("shieldCapacity", "armorHP", "hp")
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = 0
fEos = 0
for layer in layers:
iEos += self.getItemAttr(layer, item, skill=(skill, iLvl), ship=self.ship)
fEos += self.getItemAttr(layer, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteBattleship_hp_droneWeb(self):
self.buildTested = 0
item = "Berserker SW-900"
skill = "Gallente Battleship"
layers = ("shieldCapacity", "armorHP", "hp")
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = 0
fEos = 0
for layer in layers:
iEos += self.getItemAttr(layer, item, skill=(skill, iLvl), ship=self.ship)
fEos += self.getItemAttr(layer, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteBattleship_hp_droneMining(self):
self.buildTested = 0
item = "Mining Drone I"
skill = "Gallente Battleship"
layers = ("shieldCapacity", "armorHP", "hp")
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = 0
fEos = 0
for layer in layers:
iEos += self.getItemAttr(layer, item, skill=(skill, iLvl), ship=self.ship)
fEos += self.getItemAttr(layer, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Gallente Battleship Skill Bonus:
# 10% bonus to drone damage per skill level
def test_gallenteBattleship_damageMultiplier_droneCombat(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Infiltrator I"
skill = "Gallente Battleship"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteBattleship_damageMultiplier_other(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "1200mm Artillery Cannon I"
skill = "Gallente Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

183
eos/tests/typeTests/ships/battleships/dominixNavyIssue.py
View File

@@ -1,183 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Dominix Navy Issue"
# Gallente Battleship Skill Bonus:
# 5% bonus to Large Hybrid Turret damage per skill level
def test_gallenteBattleship_damageMultiplier_moduleHybridWeaponLarge(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "425mm Railgun I"
skill = "Gallente Battleship"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteBattleship_damageMultiplier_moduleHybridWeaponOther(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Heavy Ion Blaster I"
skill = "Gallente Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Gallente Battleship Skill Bonus:
# 10% bonus to drone hitpoints per skill level
def test_gallenteBattleship_hp_droneCombat(self):
self.buildTested = 0
item = "Hobgoblin I"
skill = "Gallente Battleship"
layers = ("shieldCapacity", "armorHP", "hp")
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = 0
fEos = 0
for layer in layers:
iEos += self.getItemAttr(layer, item, skill=(skill, iLvl), ship=self.ship)
fEos += self.getItemAttr(layer, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteBattleship_hp_droneLogistic(self):
self.buildTested = 0
item = "Medium Armor Maintenance Bot I"
skill = "Gallente Battleship"
layers = ("shieldCapacity", "armorHP", "hp")
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = 0
fEos = 0
for layer in layers:
iEos += self.getItemAttr(layer, item, skill=(skill, iLvl), ship=self.ship)
fEos += self.getItemAttr(layer, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteBattleship_hp_droneEwar(self):
self.buildTested = 0
item = "Infiltrator TD-600"
skill = "Gallente Battleship"
layers = ("shieldCapacity", "armorHP", "hp")
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = 0
fEos = 0
for layer in layers:
iEos += self.getItemAttr(layer, item, skill=(skill, iLvl), ship=self.ship)
fEos += self.getItemAttr(layer, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteBattleship_hp_droneCapDrain(self):
self.buildTested = 0
item = "Acolyte EV-300"
skill = "Gallente Battleship"
layers = ("shieldCapacity", "armorHP", "hp")
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = 0
fEos = 0
for layer in layers:
iEos += self.getItemAttr(layer, item, skill=(skill, iLvl), ship=self.ship)
fEos += self.getItemAttr(layer, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteBattleship_hp_droneWeb(self):
self.buildTested = 0
item = "Berserker SW-900"
skill = "Gallente Battleship"
layers = ("shieldCapacity", "armorHP", "hp")
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = 0
fEos = 0
for layer in layers:
iEos += self.getItemAttr(layer, item, skill=(skill, iLvl), ship=self.ship)
fEos += self.getItemAttr(layer, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteBattleship_hp_droneMining(self):
self.buildTested = 0
item = "Harvester Mining Drone"
skill = "Gallente Battleship"
layers = ("shieldCapacity", "armorHP", "hp")
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = 0
fEos = 0
for layer in layers:
iEos += self.getItemAttr(layer, item, skill=(skill, iLvl), ship=self.ship)
fEos += self.getItemAttr(layer, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Gallente Battleship Skill Bonus:
# 10% bonus to drone damage per skill level
def test_gallenteBattleship_damageMultiplier_droneCombat(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Wasp I"
skill = "Gallente Battleship"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteBattleship_damageMultiplier_other(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Heavy Pulse Laser I"
skill = "Gallente Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

102
eos/tests/typeTests/ships/battleships/hyperion.py
View File

@@ -1,102 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Hyperion"
# Gallente Battleship Skill Bonus:
# 5% large hybrid weapon damage per level
def test_gallenteBattleship_damageMultiplier_moduleHybridWeaponLarge(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Electron Blaster Cannon I"
skill = "Gallente Battleship"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteBattleship_damageMultiplier_moduleHybridWeaponOther(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Heavy Neutron Blaster I"
skill = "Gallente Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Gallente Battleship Skill Bonus:
# 7.5% bonus to armor repair amount of armor repair systems per level
def test_gallenteBattleship_armorDamageAmount_moduleArmorRepairer(self):
self.buildTested = 0
attr = "armorDamageAmount"
item = "Large Armor Repairer I"
skill = "Gallente Battleship"
iLvl = 1
iIngame = 1.075
fLvl = 4
fIngame = 1.3
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteBattleship_armorDamageAmount_moduleArmorRepairerCapital(self):
self.buildTested = 0
attr = "armorDamageAmount"
item = "Capital Armor Repairer I"
skill = "Gallente Battleship"
iLvl = 1
iIngame = 1.075
fLvl = 4
fIngame = 1.3
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteBattleship_armorDamageAmount_moduleArmorRepairerCivilian(self):
self.buildTested = 0
attr = "armorDamageAmount"
item = "Civilian Armor Repairer"
skill = "Gallente Battleship"
iLvl = 1
iIngame = 1.075
fLvl = 4
fIngame = 1.3
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteBattleship_armorDamageAmount_moduleOther(self):
self.buildTested = 0
attr = "armorDamageAmount"
item = "Large Remote Armor Repair System I"
skill = "Gallente Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

101
eos/tests/typeTests/ships/battleships/machariel.py
View File

@@ -1,101 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Machariel"
# Minmatar Battleship Skill Bonus:
# 5% bonus to Large Projectile Turret damage per level
def test_minmatarBattleship_damageMultiplier_moduleProjectileWeaponLarge(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "1400mm Howitzer Artillery I"
skill = "Minmatar Battleship"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_minmatarBattleship_damageMultiplier_moduleProjectileWeaponOther(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "220mm Vulcan AutoCannon I"
skill = "Minmatar Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Gallente Battleship Skill Bonus:
# 10% bonus to Large Projectile Turret falloff per level
def test_gallenteBattleship_falloff_moduleProjectileWeaponLarge(self):
self.buildTested = 0
attr = "falloff"
item = "800mm Repeating Artillery I"
skill = "Gallente Battleship"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteBattleship_falloff_moduleProjectileWeaponOther(self):
self.buildTested = 0
attr = "falloff"
item = "425mm AutoCannon I"
skill = "Gallente Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Special Ability:
# 25% bonus to Large Projectile Turret rate of fire
def test_static_speed_moduleProjectileWeaponLarge(self):
self.buildTested = 0
attr = "speed"
item = "Dual 425mm AutoCannon I"
ship_other = "Abaddon"
iIngame = 1.0
fIngame = 0.75
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_speed_moduleProjectileWeaponOther(self):
self.buildTested = 0
attr = "speed"
item = "650mm Artillery Cannon I"
ship_other = "Abaddon"
iIngame = 1.0
fIngame = 1.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

102
eos/tests/typeTests/ships/battleships/maelstrom.py
View File

@@ -1,102 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Maelstrom"
# Minmatar Battleship Skill Bonus:
# 5% bonus to Large Projectile Turret Rate of Fire per level
def test_minmatarBattleship_speed_moduleProjectileWeaponLarge(self):
self.buildTested = 0
attr = "speed"
item = "1200mm Artillery Cannon I"
skill = "Minmatar Battleship"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_minmatarBattleship_speed_moduleProjectileWeaponOther(self):
self.buildTested = 0
attr = "speed"
item = "280mm Howitzer Artillery I"
skill = "Minmatar Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Minmatar Battleship Skill Bonus:
# 7.5% bonus to Shield Boost Amount per level
def test_minmatarBattleship_shieldBonus_moduleShieldBooster(self):
self.buildTested = 0
attr = "shieldBonus"
item = "X-Large Shield Booster I"
skill = "Minmatar Battleship"
iLvl = 1
iIngame = 1.075
fLvl = 4
fIngame = 1.3
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_minmatarBattleship_shieldBonus_moduleShieldBoosterCapital(self):
self.buildTested = 0
attr = "shieldBonus"
item = "Capital Shield Booster I"
skill = "Minmatar Battleship"
iLvl = 1
iIngame = 1.075
fLvl = 4
fIngame = 1.3
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_minmatarBattleship_shieldBonus_moduleShieldBoosterCivilian(self):
self.buildTested = 0
attr = "shieldBonus"
item = "Civilian Shield Booster I"
skill = "Minmatar Battleship"
iLvl = 1
iIngame = 1.075
fLvl = 4
fIngame = 1.3
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_minmatarBattleship_shieldBonus_moduleOther(self):
self.buildTested = 0
attr = "shieldBonus"
item = "Large Shield Transporter I"
skill = "Minmatar Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

72
eos/tests/typeTests/ships/battleships/megathron.py
View File

@@ -1,72 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Megathron"
# Gallente Battleship Skill Bonus:
# 5% bonus to Large Hybrid Turret damage per level
def test_gallenteBattleship_damageMultiplier_moduleHybridWeaponLarge(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "350mm Railgun I"
skill = "Gallente Battleship"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteBattleship_damageMultiplier_moduleHybridWeaponOther(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "75mm Gatling Rail I"
skill = "Gallente Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Gallente Battleship Skill Bonus:
# 7.5% bonus to Large Hybrid Turret tracking speed per level
def test_gallenteBattleship_trackingSpeed_moduleHybridWeaponLarge(self):
self.buildTested = 0
attr = "trackingSpeed"
item = "Ion Blaster Cannon I"
skill = "Gallente Battleship"
iLvl = 1
iIngame = 1.075
fLvl = 4
fIngame = 1.3
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteBattleship_trackingSpeed_moduleHybridWeaponOther(self):
self.buildTested = 0
attr = "trackingSpeed"
item = "Heavy Ion Blaster I"
skill = "Gallente Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

72
eos/tests/typeTests/ships/battleships/megathronFederateIssue.py
View File

@@ -1,72 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Megathron Federate Issue"
# Gallente Battleship Skill Bonus:
# 5% bonus to Large Hybrid Turret damage per level
def test_gallenteBattleship_damageMultiplier_moduleHybridWeaponLarge(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Neutron Blaster Cannon I"
skill = "Gallente Battleship"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteBattleship_damageMultiplier_moduleHybridWeaponOther(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Heavy Neutron Blaster I"
skill = "Gallente Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Gallente Battleship Skill Bonus:
# 7.5% bonus to Large Hybrid Turret tracking speed per level
def test_gallenteBattleship_trackingSpeed_moduleHybridWeaponLarge(self):
self.buildTested = 0
attr = "trackingSpeed"
item = "425mm Railgun I"
skill = "Gallente Battleship"
iLvl = 1
iIngame = 1.075
fLvl = 4
fIngame = 1.3
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteBattleship_trackingSpeed_moduleHybridWeaponOther(self):
self.buildTested = 0
attr = "trackingSpeed"
item = "Dual 150mm Railgun I"
skill = "Gallente Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

72
eos/tests/typeTests/ships/battleships/megathronNavyIssue.py
View File

@@ -1,72 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Megathron Navy Issue"
# Gallente Battleship Skill Bonus:
# 5% bonus to Large Hybrid Turret damage per level
def test_gallenteBattleship_damageMultiplier_moduleHybridWeaponLarge(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Ion Blaster Cannon I"
skill = "Gallente Battleship"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteBattleship_damageMultiplier_moduleHybridWeaponOther(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Dual 150mm Railgun I"
skill = "Gallente Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Gallente Battleship Skill Bonus:
# 7.5% bonus to Large Hybrid Turret tracking speed per level
def test_gallenteBattleship_trackingSpeed_moduleHybridWeaponLarge(self):
self.buildTested = 0
attr = "trackingSpeed"
item = "Ion Blaster Cannon I"
skill = "Gallente Battleship"
iLvl = 1
iIngame = 1.075
fLvl = 4
fIngame = 1.3
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteBattleship_trackingSpeed_moduleHybridWeaponOther(self):
self.buildTested = 0
attr = "trackingSpeed"
item = "Heavy Ion Blaster I"
skill = "Gallente Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

101
eos/tests/typeTests/ships/battleships/nightmare.py
View File

@@ -1,101 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Nightmare"
# Amarr Battleship Skill Bonus:
# 7.5% bonus to Large Energy Turret tracking per level
def test_amarrBattleship_trackingSpeed_moduleEnergyWeaponLarge(self):
self.buildTested = 0
attr = "trackingSpeed"
item = "Mega Pulse Laser I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 1.075
fLvl = 4
fIngame = 1.3
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_amarrBattleship_trackingSpeed_moduleEnergyWeaponOther(self):
self.buildTested = 0
attr = "trackingSpeed"
item = "Focused Medium Pulse Laser I"
skill = "Amarr Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Caldari Battleship Skill Bonus:
# 5% bonus to Large Energy Turret damage per level
def test_caldariBattleship_damageMultiplier_moduleEnergyWeaponLarge(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Mega Beam Laser I"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 1.05
fLvl = 4
fIngame = 1.2
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariBattleship_damageMultiplier_moduleEnergyWeaponOther(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Focused Medium Beam Laser I"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Special Ability:
# 100% bonus to Large Energy Turret damage
def test_static_damageMultiplier_moduleEnergyWeaponLarge(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Dual Heavy Pulse Laser I"
ship_other = "Tempest"
iIngame = 1.0
fIngame = 2.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_damageMultiplier_moduleEnergyWeaponOther(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Quad Light Beam Laser I"
ship_other = "Tempest"
iIngame = 1.0
fIngame = 1.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

353
eos/tests/typeTests/ships/battleships/rattlesnake.py
View File

@@ -1,353 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Rattlesnake"
# Caldari Battleship Skill Bonus:
# 5% shield resistance per level
def test_caldariBattleship_shieldEmDamageResonance_ship(self):
self.buildTested = 0
attr = "shieldEmDamageResonance"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getShipAttr(attr, skill=(skill, iLvl), ship=self.ship)
fEos = self.getShipAttr(attr, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariBattleship_shieldEmDamageResonance_other(self):
self.buildTested = 0
attr = "shieldEmDamageResonance"
item = "Damage Control I"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariBattleship_shieldExplosiveDamageResonance_ship(self):
self.buildTested = 0
attr = "shieldExplosiveDamageResonance"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getShipAttr(attr, skill=(skill, iLvl), ship=self.ship)
fEos = self.getShipAttr(attr, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariBattleship_shieldExplosiveDamageResonance_other(self):
self.buildTested = 0
attr = "shieldExplosiveDamageResonance"
item = "Damage Control I"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariBattleship_shieldKineticDamageResonance_ship(self):
self.buildTested = 0
attr = "shieldKineticDamageResonance"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getShipAttr(attr, skill=(skill, iLvl), ship=self.ship)
fEos = self.getShipAttr(attr, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariBattleship_shieldKineticDamageResonance_other(self):
self.buildTested = 0
attr = "shieldKineticDamageResonance"
item = "Damage Control I"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariBattleship_shieldThermalDamageResonance_ship(self):
self.buildTested = 0
attr = "shieldThermalDamageResonance"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getShipAttr(attr, skill=(skill, iLvl), ship=self.ship)
fEos = self.getShipAttr(attr, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariBattleship_shieldThermalDamageResonance_other(self):
self.buildTested = 0
attr = "shieldThermalDamageResonance"
item = "Damage Control I"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Gallente Battleship Skill Bonus:
# 10% bonus to drone hitpoints per skill level
def test_gallenteBattleship_hp_droneCombat(self):
self.buildTested = 0
item = "Berserker I"
skill = "Gallente Battleship"
layers = ("shieldCapacity", "armorHP", "hp")
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = 0
fEos = 0
for layer in layers:
iEos += self.getItemAttr(layer, item, skill=(skill, iLvl), ship=self.ship)
fEos += self.getItemAttr(layer, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteBattleship_hp_droneLogistic(self):
self.buildTested = 0
item = "Heavy Armor Maintenance Bot I"
skill = "Gallente Battleship"
layers = ("shieldCapacity", "armorHP", "hp")
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = 0
fEos = 0
for layer in layers:
iEos += self.getItemAttr(layer, item, skill=(skill, iLvl), ship=self.ship)
fEos += self.getItemAttr(layer, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteBattleship_hp_droneEwar(self):
self.buildTested = 0
item = "Ogre SD-900"
skill = "Gallente Battleship"
layers = ("shieldCapacity", "armorHP", "hp")
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = 0
fEos = 0
for layer in layers:
iEos += self.getItemAttr(layer, item, skill=(skill, iLvl), ship=self.ship)
fEos += self.getItemAttr(layer, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteBattleship_hp_droneCapDrain(self):
self.buildTested = 0
item = "Acolyte EV-300"
skill = "Gallente Battleship"
layers = ("shieldCapacity", "armorHP", "hp")
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = 0
fEos = 0
for layer in layers:
iEos += self.getItemAttr(layer, item, skill=(skill, iLvl), ship=self.ship)
fEos += self.getItemAttr(layer, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteBattleship_hp_droneWeb(self):
self.buildTested = 0
item = "Berserker SW-900"
skill = "Gallente Battleship"
layers = ("shieldCapacity", "armorHP", "hp")
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = 0
fEos = 0
for layer in layers:
iEos += self.getItemAttr(layer, item, skill=(skill, iLvl), ship=self.ship)
fEos += self.getItemAttr(layer, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteBattleship_hp_droneMining(self):
self.buildTested = 0
item = "Harvester Mining Drone"
skill = "Gallente Battleship"
layers = ("shieldCapacity", "armorHP", "hp")
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = 0
fEos = 0
for layer in layers:
iEos += self.getItemAttr(layer, item, skill=(skill, iLvl), ship=self.ship)
fEos += self.getItemAttr(layer, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Gallente Battleship Skill Bonus:
# 10% bonus to drone damage per skill level
def test_gallenteBattleship_damageMultiplier_droneCombat(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Garde I"
skill = "Gallente Battleship"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_gallenteBattleship_damageMultiplier_other(self):
self.buildTested = 0
attr = "damageMultiplier"
item = "Medium Beam Laser I"
skill = "Gallente Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Special Ability:
# 50% bonus to Torpedo velocity
def test_static_maxVelocity_chargeMissileTorpedo(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Juggernaut Torpedo"
ship_other = "Tempest"
iIngame = 1.0
fIngame = 1.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_maxVelocity_chargeMissileTorpedoAdvanced(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Bane Rage Torpedo"
ship_other = "Tempest"
iIngame = 1.0
fIngame = 1.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Special Ability:
# 50% bonus to Cruise Missile velocity
def test_static_maxVelocity_chargeMissileCruise(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Devastator Cruise Missile"
ship_other = "Tempest"
iIngame = 1.0
fIngame = 1.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_maxVelocity_chargeMissileCruiseAdvanced(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Cataclysm Precision Cruise Missile"
ship_other = "Tempest"
iIngame = 1.0
fIngame = 1.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_maxVelocity_chargeMissileCruiseFof(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Hunter F.O.F. Cruise Missile I"
ship_other = "Tempest"
iIngame = 1.0
fIngame = 1.5
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_static_maxVelocity_chargeMissileOther(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Scourge Heavy Missile"
ship_other = "Tempest"
iIngame = 1.0
fIngame = 1.0
iEos = self.getItemAttr(attr, item, ship=ship_other)
fEos = self.getItemAttr(attr, item, ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

153
eos/tests/typeTests/ships/battleships/raven.py
View File

@@ -1,153 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Raven"
# Caldari Battleship Skill Bonus:
# 5% bonus to Siege Launcher Rate Of Fire per level
def test_caldariBattleship_speed_moduleLauncherMissileSiege(self):
self.buildTested = 0
attr = "speed"
item = "Siege Missile Launcher I"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Caldari Battleship Skill Bonus:
# 5% bonus to Cruise Launcher Rate Of Fire per level
def test_caldariBattleship_speed_moduleLauncherMissileCruise(self):
self.buildTested = 0
attr = "speed"
item = "Cruise Missile Launcher I"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariBattleship_speed_moduleLauncherMissileOther(self):
self.buildTested = 0
attr = "speed"
item = "Heavy Assault Missile Launcher I"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Caldari Battleship Skill Bonus:
# 10% bonus to Torpedo Velocity per level
def test_caldariBattleship_maxVelocity_chargeMissileTorpedo(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Juggernaut Torpedo"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariBattleship_maxVelocity_chargeMissileTorpedoAdvanced(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Inferno Javelin Torpedo"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Caldari Battleship Skill Bonus:
# 10% bonus to Cruise Missile Velocity per level
def test_caldariBattleship_maxVelocity_chargeMissileCruise(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Cataclysm Cruise Missile"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariBattleship_maxVelocity_chargeMissileCruiseAdvanced(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Devastator Precision Cruise Missile"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariBattleship_maxVelocity_chargeMissileCruiseFof(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Phoenix F.O.F. Cruise Missile I"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariBattleship_maxVelocity_chargeMissileOther(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Gremlin Rocket"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

153
eos/tests/typeTests/ships/battleships/ravenNavyIssue.py
View File

@@ -1,153 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Raven Navy Issue"
# Caldari Battleship Skill Bonus:
# 5% bonus to Siege Missile Launcher Rate Of Fire per level of skill
def test_caldariBattleship_speed_moduleLauncherMissileSiege(self):
self.buildTested = 0
attr = "speed"
item = "Siege Missile Launcher I"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Caldari Battleship Skill Bonus:
# 5% bonus to Cruise Missile Launcher Rate Of Fire per level of skill
def test_caldariBattleship_speed_moduleLauncherMissileCruise(self):
self.buildTested = 0
attr = "speed"
item = "Cruise Missile Launcher I"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariBattleship_speed_moduleLauncherMissileOther(self):
self.buildTested = 0
attr = "speed"
item = "Heavy Missile Launcher I"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Caldari Battleship Skill Bonus:
# 10% bonus to Torpedo Velocity per level of skill
def test_caldariBattleship_maxVelocity_chargeMissileTorpedo(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Bane Torpedo"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariBattleship_maxVelocity_chargeMissileTorpedoAdvanced(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Mjolnir Rage Torpedo"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Caldari Battleship Skill Bonus:
# 10% bonus to Cruise Missile Velocity per level of skill
def test_caldariBattleship_maxVelocity_chargeMissileCruise(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Devastator Cruise Missile"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariBattleship_maxVelocity_chargeMissileCruiseAdvanced(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Paradise Fury Cruise Missile"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariBattleship_maxVelocity_chargeMissileCruiseFof(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Hunter F.O.F. Cruise Missile I"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariBattleship_maxVelocity_chargeMissileOther(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Terror Assault Missile"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

153
eos/tests/typeTests/ships/battleships/ravenStateIssue.py
View File

@@ -1,153 +0,0 @@
from eos.tests import TestBase
class Test(TestBase):
def setUp(self):
TestBase.setUp(self)
self.ship = "Raven State Issue"
# Caldari Battleship Skill Bonus:
# 5% bonus to Siege Missile Launcher Rate Of Fire per level of skill
def test_caldariBattleship_speed_moduleLauncherMissileSiege(self):
self.buildTested = 0
attr = "speed"
item = "Siege Missile Launcher I"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Caldari Battleship Skill Bonus:
# 5% bonus to Cruise Missile Launcher Rate Of Fire per level of skill
def test_caldariBattleship_speed_moduleLauncherMissileCruise(self):
self.buildTested = 0
attr = "speed"
item = "Cruise Missile Launcher I"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 0.95
fLvl = 4
fIngame = 0.8
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariBattleship_speed_moduleLauncherMissileOther(self):
self.buildTested = 0
attr = "speed"
item = "Rocket Launcher I"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Caldari Battleship Skill Bonus:
# 10% bonus to Torpedo Velocity per level of skill
def test_caldariBattleship_maxVelocity_chargeMissileTorpedo(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Inferno Torpedo"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariBattleship_maxVelocity_chargeMissileTorpedoAdvanced(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Juggernaut Javelin Torpedo"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
# Caldari Battleship Skill Bonus:
# 10% bonus to Cruise Missile Velocity per level of skill
def test_caldariBattleship_maxVelocity_chargeMissileCruise(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Wrath Cruise Missile"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariBattleship_maxVelocity_chargeMissileCruiseAdvanced(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Devastator Fury Cruise Missile"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariBattleship_maxVelocity_chargeMissileCruiseFof(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Dragon F.O.F. Cruise Missile I"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 1.1
fLvl = 4
fIngame = 1.4
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)
def test_caldariBattleship_maxVelocity_chargeMissileOther(self):
self.buildTested = 0
attr = "maxVelocity"
item = "Thunderbolt Heavy Missile"
skill = "Caldari Battleship"
iLvl = 1
iIngame = 1.0
fLvl = 4
fIngame = 1.0
iEos = self.getItemAttr(attr, item, skill=(skill, iLvl), ship=self.ship)
fEos = self.getItemAttr(attr, item, skill=(skill, fLvl), ship=self.ship)
dIngame = fIngame / iIngame
dEos = fEos / iEos
self.assertAlmostEquals(dEos, dIngame)

Some files were not shown because too many files have changed in this diff Show More