def main():
tlbx = Toolbox()
confdict = {
"software_data": {
"version": "1.0",
"name": "Test",
"log": "log_test"
},
"mssql": {
"host": "",
"name": "",
"user": "",
"pass": ""
},
"dropbox": {
"token": ""
}
}
tlbx.loadConfigFromVar(confdict)
#result = tlbx.dropbox_store("C:\\Users\\admin\\Desktop\\dropbox-sdk-python-master\\tox.ini", "/Full_Share/")
# result = tlbx.dropbox_list_files_iter("/Full_Share")
# for row in result:
# print(row.path_display)
result = tlbx.dropbox_delete_outdated("/Full_Share", 30)
def main():
tlbx = Toolbox()
listXLTabs = [{
'report_name':
'Sheet name',
'report_result': [{
'Company Name': 'Amazon',
'Buyer': 'Hair dryer',
'ProductID': 'HAIR23143AM'
}, {
'Company Name': 'Google',
'Buyer': 'AI',
'ProductID': 'AIGOO343'
}, {
'Company Name': 'Alibaba',
'Buyer': 'Cosmatics',
'ProductID': 'POOROY2N4KIT2222'
}],
'indexState': ['Company Name', 'Buyer', 'ProductID']
}, {
'report_name':
'Another Sheet',
'report_result': [{
'Owner': 'Pogo',
'Buyer': 'Disney',
'Show': 'Road Runner'
}, {
'Owner': 'Disney',
'Buyer': 'Cartoon Network',
'Show': 'Naruto'
}, {
'Owner': 'Hungama',
'Buyer': 'Fun',
'Show': 'Dragon Ball Super'
}],
'indexState': ['Owner', 'Buyer', 'Show']
}, {
'report_name':
'Yet another Sheet',
'report_result': [{
'Company Name': 'Amazon',
'Buyer': 'Hair dryer',
'ProductID': 'HAIR23143AM'
}, {
'Company Name': 'Google',
'Buyer': 'AI',
'ProductID': 'AIGOO343'
}, {
'Company Name': 'Alibaba',
'Buyer': 'Cosmatics',
'ProductID': 'POOROY2N4KIT2222'
}],
'indexState': ['Company Name', 'Buyer', 'ProductID']
}]
# Templates Options : BuildHTML, BuildHTMLFancy, buildHTMLFancyResponstable, sortable
htmlresult = tlbx.writeToHTMLMulti(listXLTabs, template='sortable')
print(htmlresult)
def testHumanToolToUse(self):
toolbox = Toolbox()
oneTimeTools = []
self.assertEqual(0, self.human.toolsToUse(3, 2, toolbox, oneTimeTools))
toolbox.upgrade()
self.assertEqual(0, self.human.toolsToUse(3, 7, toolbox, oneTimeTools))
toolbox.upgrade()
self.assertEqual(0, self.human.toolsToUse(3, 9, toolbox, oneTimeTools))
def __init__(self, color, strategy):
self.resources = 12 * [2]
self.huts = []
self.personCount = 5
self.score = 0
self.color = color
self.playerAbr = color[:1].lower()
self.strategy = strategy
self.foodTrack = 0
self.toolbox = Toolbox()
def test_sendMailWithAttachments():
tlbx = Toolbox()
kwargs = {
'mail_from': '',
'mail_from_name': '',
'mail_password': '',
'mail_to': '',
'mail_subject': '',
'mail_body': '',
'attachment_list': [],
'Cc': []
}
tlbx.sendMailWithAttachments(**kwargs)
def go(self, widget, web_view, addressbar=None):
# If called from address bar by pressing enter:
if hasattr(widget, 'get_text'):
address = widget.get_text()
address = Toolbox.add_http_prefix(address)
widget.set_text(address)
print("Opening: " + address)
# If the user clicked a button:
else:
address = addressbar.get_text()
address = Toolbox.add_http_prefix(address)
addressbar.set_text(address)
print("Opening: " + address)
web_view.open(address)
def go(self, widget, web_view, addressbar=None):
# If called from address bar by pressing enter:
if hasattr(widget, 'get_text'):
address = widget.get_text()
address = Toolbox.add_http_prefix(address)
widget.set_text(address)
print("Opening: " + address)
# If the user clicked a button:
else:
address = addressbar.get_text()
address = Toolbox.add_http_prefix(address)
addressbar.set_text(address)
print("Opening: " + address)
web_view.open(address)
def main(): tlbx = Toolbox() sheet_name = "Some title here" csv1 = """Name,Profession Derek,Software Developer Steve,Software Developer Paul,Manager""" csv2 = """Name,Profession Bob,Software Developer Bill,Software Developer Stacy,Manager""" csv3 = """Name,Profession Jennifer,Software Developer Bernard,Software Developer William,Manager""" gsheet = tlbx.gsheet_new_sheet(sheet_name, ['*****@*****.**']) gsheet_id = gsheet.id print(gsheet_id) tlbx.gsheet_upload_csv(gsheet, sheet_name, gsheet_id, csv1)
def main():
tlbx = Toolbox()
sheet_name = "Csv Collection"
workSheetNames = [i.split(".")[0] for i in os.listdir("data")]
gsheet = tlbx.gsheet_new_sheet(sheet_name, workSheetNames, ['*****@*****.**'])
gsheet_id = gsheet.id
print(gsheet_id)
worksheet_list = gsheet.worksheets()
print(worksheet_list)
# for sheet in workSheetNames:
# csvfile = "./files/"+str(sheet)+".csv"
# print(csvfile)
# tlbx.gsheet_upload_and_write_csv(gsheet, sheet, csvfile)
# break
"""
def __init__(self, color, strategy):
self.resources = 12 * [Resource.food]
self.huts = []
self.cards = []
self.person = 5
self.point = 0
self.color = color
self.playerAbr = color.name[:1].lower()
self.colorOS = color.value
self.strategy = strategy
self.foodtrack = 0
self.toolbox = Toolbox()
self.oneTimeTools = []
def testUseTools(self):
toolbox = Toolbox()
toolbox.upgrade()
toolbox.upgrade()
toolbox.upgrade()
toolbox.upgrade()
self.assertEquals([2,1,1], toolbox.getUnused())
toolsToUse = [1]
self.human.useTools(toolbox, toolsToUse)
self.assertEquals([2,1], toolbox.getUnused())
def main():
tlbx = Toolbox()
confdict = {
"software_data": {
"version": "1.0",
"name": "Test",
"log": "log_test"
},
"mssql": {
"host": "108.46.153.144",
"name": "demo",
"user": "******",
"pass": "******"
}
}
tlbx.loadConfigFromVar(confdict)
tlbx.establish_MSSQLDict()
sql_query = """Select 'Test' AS [Data]"""
tlbx.MSSQL_CURDict.execute(sql_query)
result = tlbx.MSSQL_CURDict.fetchall()
print(result)
tlbx.MSSQL_CONNDict.close()
class Player():
'''
classdocs
'''
maxFoodTrack = 10
maxPersonCount = 10
hungerPenalty = -10
def __init__(self, color, strategy):
self.resources = 12 * [2]
self.huts = []
self.personCount = 5
self.score = 0
self.color = color
self.playerAbr = color[:1].lower()
self.strategy = strategy
self.foodTrack = 0
self.toolbox = Toolbox()
def getFoodTrack(self):
return self.foodTrack
def getTools(self):
return self.toolbox.getTools()
def getPersonCount(self):
return self.personCount
def foodMissing(self):
return max(0, (self.personCount - self.foodTrack) - self.resources.count(2))
def feed(self):
if self.foodMissing() > 0 :
self.score += self.hungerPenalty
for person in range((self.personCount - self.foodTrack) - self.foodMissing()):
self.resources.remove(2)
def getNonFood(self):
return sorted([resource for resource in self.resources if resource != 2])
def addResources(self, additionalResources):
while 7 in additionalResources:
self.foodTrack = min(self.maxFoodTrack, self.foodTrack + 1)
additionalResources.remove(7)
while 8 in additionalResources:
self.personCount = min(self.maxPersonCount, self.personCount + 1)
additionalResources.remove(8)
while 9 in additionalResources:
self.toolbox.upgrade()
additionalResources.remove(9)
self.resources.extend(additionalResources)
def removeResources(self, resourcesToRemove):
for resource in resourcesToRemove:
self.resources.remove(resource)
def buyHuts(self, huts):
return self.strategy.buyHuts(self, huts)
def buyHut(self, hut, payment):
self.huts.append(hut)
self.executeHutPayment(payment)
def isPayable(self, hut):
return self.strategy.isPayable(hut, self.resources)
def executeHutPayment(self, payment):
self.removeResources(payment)
self.score += sum(payment)
def personsLeft(self, board):
return self.personCount - board.personCount(self.playerAbr)
def isNewRound(self, board):
return self.personsLeft(board) == self.personCount
def placePersons(self, board):
self.strategy.placePersons(self, board)
def finalScore(self):
return self.score + len(self.resources)
def getColor(self):
return self.color
def getAbr(self):
return self.playerAbr
def toolsToUse(self, resourceValue, eyes):
return self.strategy.toolsToUse(resourceValue, eyes, self.toolbox)
def newRound(self):
self.toolbox.reset()
def getStrategy(self):
return self.strategy
def __str__(self):
return """People: %d, Foodtrack: %d, Food: %d, Tools: %s
Resources: %s
huts: %s
score: %d\n""" % (self.getPersonCount(), self.getFoodTrack(), self.resources.count(2), self.toolbox,
str(sorted(self.getNonFood())),
",".join([str(hut) for hut in self.huts]), self.score)
def __init__(self):
"""
This method has to take care of the following things:
0. Lazy import tab modules
1. Initialize the main UI
2. Setup the database connection and ensure all tables are present
3. Detect all currently attached CAN devices
4. Call the prepareUI()-method of every tab
5. {En, Dis}able GUI elements based on the presence of a CAN device
6. Setup logging
7. Install a global exception hook that will catch all "remaining" exceptions
to log it to the GUI
8. Load the CAN kernel modules
9. Check if superuser privileges are present - exit if not present
10. Install event handlers for GUI elements (assignWidgets())
"""
from SnifferTab import SnifferTab
from SenderTab import SenderTab
from FuzzerTab import FuzzerTab
from FilterTab import FilterTab
from SearcherTab import SearcherTab
from ManagerTab import ManagerTab
from ComparerTab import ComparerTab
from AboutTab import AboutTab
from Toolbox import Toolbox
super(MainWindow, self).__init__()
self.setWindowIcon(QIcon(Settings.ICON_PATH))
Globals.ui = self
# Setup logging
self.logger = Logger(self.__class__.__name__).getLogger()
# Redirect exception logs to the textBrowser
sys.excepthook = globalLoggingHandler
# Check privileges
if not self.checkSU():
self.logger.fatal(Strings.mainTabNoSU)
QMessageBox.critical(None, Strings.messageBoxErrorTitle,
Strings.mainTabMessageBoxNoSUHint,
QMessageBox.Ok)
exit(1)
self.setupUi(self)
atexit.register(MainWindow.cleanup)
# Prepare main ui
Globals.textBrowserLogs = self.textBrowserLogs
sys.stdout.write(Strings.banner)
# init and connect to the db
Globals.db = Database.Database()
# Create the tab instances
Globals.fuzzerTabInstance = FuzzerTab(Globals.ui.tabFuzzer)
Globals.comparerTabInstance = ComparerTab(Globals.ui.tabComparer)
Globals.searcherTabInstance = SearcherTab(Globals.ui.tabSearcher)
Globals.filterTabInstance = FilterTab(Globals.ui.tabFilter)
Globals.managerTabInstance = ManagerTab(Globals.ui.tabManager)
MainTab.MainTab.detectCANInterfaces(updateLabels=False)
MainTab.MainTab.applyLogLevelSetting()
# Let each static tab initialize
SenderTab.prepareUI()
MainTab.MainTab.prepareUI()
SnifferTab.prepareUI()
AboutTab.prepareUI()
Toolbox.toggleDisabledSenderGUIElements()
Toolbox.toggleDisabledProjectGUIElements()
# Set each QTabWidget to the first tab
tabWidgets = Globals.ui.findChildren(QTabWidget)
for tabWidget in tabWidgets:
if tabWidget.count() > 0:
tabWidget.setCurrentIndex(0)
MainTab.MainTab.loadKernelModules()
# Add handlers
self.assignWidgets()
self.show()
class Player():
'''
classdocs
'''
maxFoodTrack = 10
maxPersonCount = 10
hungerPenalty = -10
colorOSnormal = '\x1b[0m'
def __init__(self, color, strategy):
self.resources = 12 * [Resource.food]
self.huts = []
self.cards = []
self.person = 5
self.point = 0
self.color = color
self.playerAbr = color.name[:1].lower()
self.colorOS = color.value
self.strategy = strategy
self.foodtrack = 0
self.toolbox = Toolbox()
self.oneTimeTools = []
def __lt__(self, other):
if self.getScore() != other.getScore():
return self.getScore() < other.getScore()
return self.secondScoreCriteria() < other.secondScoreCriteria()
def __eq__(self, other):
return self is other
def __hash__(self):
return hash("".join([o.__str__() for o in [self.getColor(), self.strategy]]))
def getFoodTrack(self):
return self.foodtrack
def getTools(self):
return self.toolbox.getTools()
def getPersonCount(self):
return self.person
def foodMissing(self):
return max(0, (self.person - self.foodtrack) - self.resources.count(Resource.food))
def feed(self):
if self.foodMissing() > 0 :
self.point += self.hungerPenalty
for person in range((self.person - self.foodtrack) - self.foodMissing()):
self.resources.remove(Resource.food)
def getFood(self):
return [resource for resource in self.resources if resource == Resource.food]
def getNonFood(self):
return sorted([resource for resource in self.resources if resource != Resource.food])
def addResources(self, additionalResources):
while Resource.tool in additionalResources:
self.toolbox.upgrade()
additionalResources.remove(Resource.tool)
while Resource.foodtrack in additionalResources:
self.foodtrack = min(self.maxFoodTrack, self.foodtrack + 1)
additionalResources.remove(Resource.foodtrack)
while Resource.person in additionalResources:
self.person = min(self.maxPersonCount, self.person + 1)
additionalResources.remove(Resource.person)
self.resources.extend(additionalResources)
def addOneTimeTool(self, value):
self.oneTimeTools.append(value)
def removeResources(self, resourcesToRemove):
for resource in resourcesToRemove:
if resource in self.resources:
self.resources.remove(resource)
else:
print("trying to remove resource: %s from resources: %s" % (resource.name, Resource.coloredOutput(self.resources)))
def buyHuts(self, huts):
return self.strategy.buyHuts(self, huts)
def buyHut(self, hut, payment):
self.huts.append(hut)
self.removeResources(payment)
self.point += sum(payment)
def buyCards(self, cards, players, cardPile):
print("player")
return self.strategy.buyCards(self, cards, players, cardPile)
def buyCard(self, card, players, cardPile, payment):
self.addCard(card, players, cardPile)
self.removeResources(payment)
def isPayable(self, hut):
return self.strategy.isPayable(hut, self.resources)
def addCard(self, card, players, cardPile):
self.cards.append(card)
card.execute(players, cardPile)
def getSymbolCardLists(self):
result = {}
for card in [c for c in self.cards if isinstance(c, SymbolCard)]:
if not card.getSymbol().name in result.keys():
result[card.getSymbol().name] = []
result[card.getSymbol().name].append(card)
return result
def getMultiplierCardsBySymbol(self):
return groupby(sorted([c for c in self.cards if isinstance(c, MultiplierCard)]), lambda c : c.getSymbol())
def symbolCardPoints(self):
symbolCardLists = self.getSymbolCardLists()
points1 = pow(len(symbolCardLists.keys()), 2)
points2 = pow(len([lst for lst in symbolCardLists.values() if len(lst) == 2]), 2)
return points1 + points2
def multiplierCardPoints(self):
multiplierPoints = 0
for symbol, cards in self.getMultiplierCardsBySymbol():
factor = sum([c.getMultiplier() for c in cards])
if symbol == CardMultiplier.hutcount:
multiplierPoints += factor * len(self.huts)
elif symbol == CardMultiplier.foodtrack:
multiplierPoints += factor * self.foodtrack
elif symbol == CardMultiplier.toolsum:
multiplierPoints += factor * sum(self.toolbox.getTools())
elif symbol == CardMultiplier.personcount:
multiplierPoints += factor * self.person
return multiplierPoints
def getCardScore(self):
return self.symbolCardPoints() + self.multiplierCardPoints()
def addScore(self, score):
self.point += score
def getScore(self):
return self.point + self.getCardScore() + len(self.getNonFood())
def secondScoreCriteria(self):
return self.foodtrack + sum(self.toolbox.getTools()) + self.person
def personsLeft(self, board):
return self.person - board.person(self)
def isNewRound(self, board):
return self.personsLeft(board) == self.person
def placePersons(self, board):
self.strategy.placePersons(self, board)
def chooseChristmas(self, presents):
return self.strategy.chooseChristmas(self, presents)
def getColor(self):
return self.color
def getOutputColor(self, length = None):
actualLength = length if length else len(self.color.name)
nameString = "%-" + str(actualLength) + "s"
return ("%s" + nameString + "%s") % (self.colorOS, self.color.name, self.colorOSnormal)
def getAbr(self):
return self.playerAbr
def getOutputAbr(self):
return "%s%s%s" % (self.colorOS, self.playerAbr, self.colorOSnormal)
def toolsToUse(self, resource, eyes):
return self.strategy.toolsToUse(resource, eyes, self.toolbox, self.oneTimeTools)
def newRound(self):
self.toolbox.reset()
def getStrategy(self):
return self.strategy
def chooseReapingResource(self, occupiedResources):
return self.strategy.chooseReapingResource(occupiedResources)
def resourcesColoredOutput(self):
return "[%s]" % ",".join([resource.getColoredName() for resource in sorted(self.getNonFood())])
def __str__(self):
symbolstr = ", ".join(["%s" % k for k in sorted(self.getSymbolCardLists().keys())])
secondCollection = ["%s" % k for k, l in sorted(self.getSymbolCardLists().items()) if len(l) > 1]
if secondCollection:
symbolstr += " || " + ", ".join(secondCollection)
multistrs = []
for symbol, cards in self.getMultiplierCardsBySymbol():
factor = sum([c.getMultiplier() for c in cards])
multistrs.append("%d x %s" % (factor, symbol.name))
return """%s%s%s
People: %d, Foodtrack: %d, Food: %d, Tools: %s, One-time tools: %s
Resources: %s
Hutcount: %d
Symbolcards: %s (%d)
Multipliercards: %s (%d)
score (cardscore): %d (%d)\n""" % (self.colorOS, self.color.name, self.colorOSnormal, \
self.getPersonCount(), self.getFoodTrack(), self.resources.count(Resource.food), self.toolbox, self.oneTimeTools,
Resource.coloredOutput(sorted(self.getNonFood())),
len(self.huts), \
symbolstr, self.symbolCardPoints(), \
", ".join(multistrs), self.multiplierCardPoints(),\
self.getScore(), self.getCardScore())
def main():
tlbx = Toolbox()
sheet_title = "Csv Collection"
listXLTabs = [{
'report_name':
'Sheet name',
'report_result': [{
'Company Name': 'Amazon',
'Buyer': 'Hair dryer',
'ProductID': 'HAIR23143AM'
}, {
'Company Name': 'Google',
'Buyer': 'AI',
'ProductID': 'AIGOO343'
}, {
'Company Name': 'Alibaba',
'Buyer': 'Cosmatics',
'ProductID': 'POOROY2N4KIT2222'
}],
'indexState': ['Company Name', 'Buyer', 'ProductID']
}, {
'report_name':
'Another Sheet',
'report_result': [{
'Owner': 'Pogo',
'Buyer': 'Disney',
'Show': 'Road Runner'
}, {
'Owner': 'Disney',
'Buyer': 'Cartoon Network',
'Show': 'Naruto'
}, {
'Owner': 'Hungama',
'Buyer': 'Fun',
'Show': 'Dragon Ball Super'
}],
'indexState': ['Owner', 'Buyer', 'Show']
}, {
'report_name':
'Yet another Sheet',
'report_result': [{
'Company Name': 'Amazon',
'Buyer': 'Hair dryer',
'ProductID': 'HAIR23143AM'
}, {
'Company Name': 'Google',
'Buyer': 'AI',
'ProductID': 'AIGOO343'
}, {
'Company Name': 'Alibaba',
'Buyer': 'Cosmatics',
'ProductID': 'POOROY2N4KIT2222'
}],
'indexState': ['Company Name', 'Buyer', 'ProductID']
}]
# Templates Options : BuildHTML, BuildHTMLFancy, buildHTMLFancyResponstable, sortable
htmlresult = tlbx.writeToGspreadMulti(
sheet_title,
listXLTabs,
gsheet_id='1sLNpKtWlii_F4qa0zKC8KJHlewZcD1vDxQmNJN2K2bs',
sharelist=['*****@*****.**'])
print(htmlresult)
class ToolBoxTest(unittest.TestCase):
def setUp(self):
self.toolBox = Toolbox()
def testToolsAtStart(self):
self.assertEqual([0, 0, 0], self.toolBox.getTools())
def testUpgradesTo2(self):
self.toolBox.upgrade()
self.assertEqual([1, 0, 0], self.toolBox.getTools())
self.toolBox.upgrade()
self.assertEqual([1, 1, 0], self.toolBox.getTools())
self.toolBox.upgrade()
self.assertEqual([1, 1, 1], self.toolBox.getTools())
self.toolBox.upgrade()
self.assertEqual([2, 1, 1], self.toolBox.getTools())
def testUpgradesTo3(self):
self.toolBox.upgrade()
self.toolBox.upgrade()
self.toolBox.upgrade()
self.toolBox.upgrade()
self.assertEqual([2, 1, 1], self.toolBox.getTools())
self.toolBox.upgrade()
self.toolBox.upgrade()
self.assertEqual([2, 2, 2], self.toolBox.getTools())
self.toolBox.upgrade()
self.assertEqual([3, 2, 2], self.toolBox.getTools())
def testUpgradesTo4(self):
self.toolBox.upgrade()
self.toolBox.upgrade()
self.toolBox.upgrade()
self.toolBox.upgrade()
self.toolBox.upgrade()
self.toolBox.upgrade()
self.toolBox.upgrade()
self.assertEqual([3, 2, 2], self.toolBox.getTools())
self.toolBox.upgrade()
self.toolBox.upgrade()
self.assertEqual([3, 3, 3], self.toolBox.getTools())
self.toolBox.upgrade()
self.assertEqual([4, 3, 3], self.toolBox.getTools())
def testNoUpgradesAbove4(self):
self.toolBox.upgrade()
self.toolBox.upgrade()
self.toolBox.upgrade()
self.toolBox.upgrade()
self.toolBox.upgrade()
self.toolBox.upgrade()
self.toolBox.upgrade()
self.toolBox.upgrade()
self.toolBox.upgrade()
self.toolBox.upgrade()
self.toolBox.upgrade()
self.toolBox.upgrade()
self.assertEqual([4, 4, 4], self.toolBox.getTools())
self.toolBox.upgrade()
self.assertEqual([4, 4, 4], self.toolBox.getTools())
self.toolBox.upgrade()
self.assertEqual([4, 4, 4], self.toolBox.getTools())
def testOneToolUsed(self):
self.assertEqual([], self.toolBox.getUnused())
self.toolBox.upgrade()
self.assertEqual([1], self.toolBox.getUnused())
self.toolBox.use(1)
self.assertEqual([], self.toolBox.getUnused())
def testMoreOneToolsUsed(self):
self.toolBox.upgrade()
self.toolBox.upgrade()
self.assertEqual([1, 1], self.toolBox.getUnused())
self.toolBox.use(1)
self.assertEqual([1], self.toolBox.getUnused())
self.toolBox.use(1)
self.assertEqual([], self.toolBox.getUnused())
def testHigherValueToolsUsed(self):
self.toolBox.upgrade()
self.toolBox.upgrade()
self.toolBox.upgrade()
self.toolBox.upgrade()
self.toolBox.upgrade()
self.toolBox.upgrade()
self.toolBox.upgrade()
self.assertEqual([3, 2, 2], self.toolBox.getUnused())
self.toolBox.use(2)
self.assertEqual([3, 2], self.toolBox.getUnused())
self.toolBox.use(3)
self.assertEqual([2], self.toolBox.getUnused())
def testUsingUnavailableTool(self):
self.toolBox.upgrade()
with self.assertRaisesRegex(ToolError, "No unused tool of value 2"):
self.toolBox.use(2)
def testUsingCombinedWithUpgrade(self):
self.toolBox.upgrade()
self.toolBox.upgrade()
self.toolBox.upgrade()
self.toolBox.use(1)
self.toolBox.upgrade()
self.assertEqual([2, 1, 1], self.toolBox.getTools())
self.assertEqual([2, 1], self.toolBox.getUnused())
def testUpgradingTheUnusedTool(self):
self.toolBox.upgrade()
self.toolBox.upgrade()
self.toolBox.upgrade()
self.toolBox.upgrade()
self.toolBox.use(1)
self.toolBox.use(2)
self.toolBox.upgrade()
self.toolBox.use(2)
self.assertEqual([2, 2, 1], self.toolBox.getTools())
self.assertEqual([], self.toolBox.getUnused())
def setUp(self):
self.toolBox = Toolbox()
