def test_twelve(self): order = {'apple': 15, 'banana': 15, 'cherry': 15} warehouses = [ Warehouse('w1', { 'apple': 100, 'banana': 14, 'duck': 4 }), Warehouse('w2', { 'banana': 100, 'cherry': 100 }) ] expected_value = [ Warehouse('w1', { 'apple': 15, 'banana': 14 }), Warehouse('w2', { 'banana': 1, 'cherry': 15 }) ] result = InventoryAllocator(order, warehouses).complete_order() self.assertEqual(expected_value, result)
def test_eighteen(self): order = {'apple': 100, 'banana': 200, 'cherry': 300} warehouses = [ Warehouse('w1', { 'apple': 50, 'banana': 50, 'cherry': 50 }), Warehouse('w2', { 'apple': 300, 'banana': 300, 'cherry': 300 }), Warehouse('w2', { 'apple': 50, 'banana': 50, 'cherry': 50 }) ] expected_value = [ Warehouse('w1', { 'apple': 50, 'banana': 50, 'cherry': 50 }), Warehouse('w2', { 'apple': 50, 'banana': 150, 'cherry': 250 }) ] result = InventoryAllocator(order, warehouses).complete_order() self.assertEqual(expected_value, result)
def test_private_not_enough_inventory(self): order = {"chair": 100, "couch": 50, "bed": 30} warehouses = [] warehouses.append(Warehouse("w1", {"chair": 30, "couch": 30})) warehouses.append(Warehouse("w2", {"chair": 30, "bed": 30})) warehouses.append(Warehouse("w3", {"chair": 30, "couch": 20})) ia = InventoryAllocator(order, warehouses) expected_output = [] # not enough chairs to complete order self.assertEqual(ia.generate_shipment(), expected_output)
def __init__(self): self.warehouses = [[]] * 5 self.warehouses[0] = Warehouse("1", 5, 10) self.warehouses[1] = Warehouse("2", 5, 10) self.warehouses[2] = Warehouse("3", 5, 10) self.warehouses[3] = Warehouse("4", 7, 5) self.warehouses[4] = Warehouse("5", 20, 20) self.belt = Belt() self.robot = Robot() self.input = InputCommand(self)
def test_five(self): order = {'apple': 10} warehouses = [ Warehouse('owd', {'apple': 8}), Warehouse('dm', {'apple': 5}) ] expected_value = [ Warehouse('owd', {'apple': 8}), Warehouse('dm', {'apple': 2}) ] result = InventoryAllocator(order, warehouses).complete_order() self.assertEqual(expected_value, result)
def test_eleven(self): order = {'apple': 15, 'cherry': 15} warehouses = [ Warehouse('w1', { 'apple': 15, 'banana': 15, 'cherry': 15 }) ] expected_value = [Warehouse('w1', {'apple': 15, 'cherry': 15})] result = InventoryAllocator(order, warehouses).complete_order() self.assertEqual(expected_value, result)
def test_public_2(self): order = {"apple": 10} warehouses = [ Warehouse("owd", {"apple": 5}), Warehouse("dm", {"apple": 5}) ] ia = InventoryAllocator(order, warehouses) expected_output = [ Warehouse("owd", {"apple": 5}), Warehouse("dm", {"apple": 5}) ] self.assertEqual(ia.generate_shipment(), expected_output)
def test_private_base(self): order = {"playstation": 1000} warehouses = [] for i in range(600): warehouses.append( Warehouse(f"w-{i}", { "playstation": 2, "xbox": 1 })) ia = InventoryAllocator(order, warehouses) expected_output = [] for i in range(500): expected_output.append(Warehouse(f"w-{i}", {"playstation": 2})) self.assertEqual(ia.generate_shipment(), expected_output)
def test_eight(self): order = {'apple': 10, 'banana': 10} warehouses = [ Warehouse('owd', { 'apple': 9, 'banana': 8 }), Warehouse('dm', { 'apple': 3, 'banana': 1 }) ] expected_value = [] result = InventoryAllocator(order, warehouses).complete_order() self.assertEqual(expected_value, result)
def parse(file): file = open(file) lines = [line.rstrip('\r\n') for line in file.readlines()] variables = lines[0].split(' ') r, c, drones, deadline, max_load = variables products_count = int(lines[1]) products = [ Product(index, int(lines[2].split(' ')[index])) for index in range(len(lines[2].split(' '))) ] warehouse_count = int(lines[3]) # this used to have for warehouse_no in range(warehouse_count*2-1) # - what was the *2-1 for? It makes us 19 warehouses rather than 10 warehouses = [ Warehouse(convert_coord(lines[warehouse_no + 4]), convert_products(lines[warehouse_no + 5], products), warehouse_no) for warehouse_no in range(warehouse_count) ] orders_offset = 4 + warehouse_count * 2 orders_count = int(lines[orders_offset]) orders = [ Order(convert_coord(lines[order_no + orders_offset]), lines[order_no + orders_offset + 2], order_no) for order_no in range(orders_count * 3 - 1) ] return {'orders': orders, 'warehouses': warehouses, 'variables': variables}
def test_private_inv_left_over_2(self): order = {"a": 5, "b": 6} warehouses = [ Warehouse("w1", { "a": 6, "b": 2 }), Warehouse("w2", {"b": 4}) ] ia = InventoryAllocator(order, warehouses) expected_output = [ Warehouse("w1", { "a": 5, "b": 2 }), Warehouse("w2", {"b": 4}) ] self.assertEqual(ia.generate_shipment(), expected_output)
def __init__(self, order: Dict[str, int], warehouses: List[Dict[str, Any]]): self._order = order self._warehouses = [] #Fill the _warehouses attribute with Warehouse objects for warehouse_dict in warehouses: self._warehouses.append(Warehouse(warehouse_dict))
def __init__(self, filename): self.eventRouter = EventRouter() emit_method = self.eventRouter.get_emitter() super().__init__() self.player = Player(emit_method) self.zoo = Zoo(filename, self.player.char, emit_method) self.commandHandler = CommandHandler(self.zoo, self.player, Warehouse(self.zoo.in_warehouse, self.player), emit_method) self.eventRouter.add_listener(self.player, Event.AffecteesType.PLAYER) self.eventRouter.add_listener(self.zoo, Event.AffecteesType.ZOO) self.eventRouter.add_listener(self, Event.AffecteesType.PLAYER) self.eventRouter.add_listener(self, Event.AffecteesType.NONE)
def test_private_extra_warehouse(self): order = {"a": 15} warehouses = [ Warehouse("w1", { "a": 5, "b": 2, "c": 1 }), Warehouse("w2", { "a": 10, "b": 4 }), Warehouse("w3", { "a": 4, "c": 3 }) ] ia = InventoryAllocator(order, warehouses) expected_output = [ Warehouse("w1", {"a": 5}), Warehouse("w2", {"a": 10}) ] self.assertEqual(ia.generate_shipment(), expected_output)
def complete_order(self): """ Calculates best method of shipping items in order. Function searches through each Warehouse in warehouses (which are in cost order), determines if any items from the order are in that Warehouse, and if they are, adds that Warehouse to the list of Warehouses being returned with the items and quantities it should ship. :return: List of Warehouses ret containing items they need to ship based on the order """ ret = [] # Loops through each Warehouse in warehouses for w in self.warehouses: shared_items = [] # Loops through each item in the order for item in self.order.keys(): # If there is an item in both the Warehouse and the order of a quantity greater than 0 for each # then it is added to the list of shared items if self.order[item] > 0 and item in w.inventory.keys( ) and w.inventory[item] > 0: shared_items.append(item) # If there are any shared items between the order and the Warehouse if len(shared_items) > 0: # This is the Warehouse with shared items, however, it is undetermined how much of which items this # Warehouse will ship ret_w = Warehouse(w.name, {}) # Loops over each shared item for item in shared_items: # If there is more of this item (or an equal amount) in the Warehouse than in the order, # the Warehouse should ship the amount remaining in the order # and this item is removed from the order if self.order[item] <= w.inventory[item]: ret_w.inventory[item] = self.order[item] self.order.pop(item) # If there is more of this item in the order than in the Warehouse, # the Warehouse should ship the entirety of its stock of this item # and the quantity of this item in the order is decreased by the quantity possessed by the Warehouse else: ret_w.inventory[item] = w.inventory[item] self.order[item] = self.order[item] - w.inventory[item] # Add Warehouse to the list of Warehouses being returned ret.append(ret_w) # Checks whether order was complete and returns empty list if it was not if len(self.order.keys()) > 0: return [] # Returns list of Warehouses return ret
def test_private_each_warehouse(self): order = {"a": 5, "b": 5, "c": 5} warehouses = [] warehouses.append(Warehouse("w1", {"a": 5, "d": 1})) warehouses.append(Warehouse("w2", {"b": 5, "d": 2})) warehouses.append(Warehouse("w3", {"c": 5, "d": 2})) ia = InventoryAllocator(order, warehouses) expected_output = [] expected_output.append(Warehouse("w1", {"a": 5})) expected_output.append(Warehouse("w2", {"b": 5})) expected_output.append(Warehouse("w3", {"c": 5})) self.assertEqual(ia.generate_shipment(), expected_output)
def __init__(self, params, solver): self.cols = params['y'] self.rows = params['x'] self.nbTurns = params['turns'] self.weights = params['weights'] self.warehouses = [] for place, invent_dict in params['warehouses']: self.warehouses.append(Warehouse(place, invent_dict)) self.orders = [] for place, invent_dict in params['orders']: self.orders.append(Order(place, invent_dict)) self.drones = [] for e in params['nb_drones']: self.drones.append( Drone(params['payload'], self.warehouses[0].location, self.weights)) self.score = 0.0 self.solver = solver
def add_warehouses(self): """ Aim: Processes the warehouses given in a raw format Input: self - instance of the Main driver class. Output: List[Warehouse] - a list of warehouses (instances of the Warehouse class) """ warehouses = [] for index in range(len(self.raw_warehouses)): warehouse = self.raw_warehouses[index] # Instance of a Warehouse is created with index + 1 as its cost. new_warehouse = Warehouse(warehouse['name'], warehouse['inventory'], index + 1) warehouses.append(new_warehouse) return warehouses
def load_parameters(self): # Settings and number of products self.inputfile.readline() self.inputfile.readline() productweights = self.inputfile.readline() products = dict(enumerate([int(i) for i in productweights.split(' ')])) # Warehouses wareamount = int(self.inputfile.readline()) warehouses = [] for i in range(wareamount): # Warehouse coordinates coords = [int(i) for i in self.inputfile.readline().split(' ')] # Warehouse contains (dictionary) contents = dict( enumerate( [int(i) for i in self.inputfile.readline().split(' ')])) thiswarehouse = Warehouse(contents, coords) warehouses.append(thiswarehouse) # Orders orderamount = int(self.inputfile.readline()) orders = [] for i in range(orderamount): # Customer coordinates coords = [int(i) for i in self.inputfile.readline().split(' ')] # Order item amount self.inputfile.readline() # Item product ids items = {} for i in self.inputfile.readline().split(' '): if not int(i) in items: items[int(i)] = 1 else: items[int(i)] += 1 thisorder = Order(coords, items) orders.append(thisorder) return (products, warehouses, orders)
n_rows = int(input()) n_cols = int(input()) n_drones = int(input()) deadline = int(input()) drone_maxload = int(input()) n_products = int(input()) products_weights = input().split(" ") products_weights = [int(i) for i in products_weights] n_warehouses = int(input()) warehouses = [] for i in range(n_warehouses): a, b = input().split(" ") products = input().split(" ") w = Warehouse(i, n_products, [int(j) for j in products], (int(a), int(b))) warehouses.append(w) n_orders = int(input()) orders = [] for i in range(n_orders): a, b = input().split(" ") n_ordered = int(input()) order_list = input().split(" ") order_list = [int(j) for j in order_list] o = Order(i, (int(a), int(b)), order_list, n_ordered, n_products) orders.append(o) total_commands = 0 drones = []
def test_three(self): order = {'apple': 1} warehouses = [Warehouse('owd', {'apple': 0})] expected_value = [] result = InventoryAllocator(order, warehouses).complete_order() self.assertEqual(expected_value, result)
def test_nineteen(self): order = { 'apple': 1000, 'banana': 1000, 'cherry': 1000, 'duck': 1000, 'eggs': 10000 } warehouses = [ Warehouse('w1', { 'car': 500, 'apple': 100 }), Warehouse('w2', { 'banana': 1000, 'duck': 500, 'cherry': 800 }), Warehouse('w3', { 'apple': 900, 'banana': 1999, 'turkey': 100000, 'eggs': 5000 }), Warehouse('w4', {'cherry': 250}), Warehouse('w5', { 'chicken': 5500, 'duck': 1000, 'apple': 14, 'ketchup': 16 }), Warehouse('w6', { 'eggs': 5500, 'banana': 5, 'cherry': 100, 'chicken': 8 }) ] expected_value = [ Warehouse('w1', {'apple': 100}), Warehouse('w2', { 'banana': 1000, 'cherry': 800, 'duck': 500 }), Warehouse('w3', { 'apple': 900, 'eggs': 5000 }), Warehouse('w4', {'cherry': 200}), Warehouse('w5', {'duck': 500}), Warehouse('w6', {'eggs': 5000}) ] result = InventoryAllocator(order, warehouses).complete_order() self.assertEqual(expected_value, result)
def test_private_extra_warehouse_item(self): order = {"a": 1} warehouses = [Warehouse("w1", {"a": 1, "b": 1})] ia = InventoryAllocator(order, warehouses) expected_output = [Warehouse("w1", {"a": 1})] self.assertEqual(ia.generate_shipment(), expected_output)
def test_fifteen(self): order = {'apple': 0} warehouses = [Warehouse('w1', {'apple': 100, 'banana': 19})] expected_value = [] result = InventoryAllocator(order, warehouses).complete_order() self.assertEqual(expected_value, result)
from DB import LoadFile, InputSneakersInfo from Warehouse import Warehouse warehouse = Warehouse() data = LoadFile('products.txt') warehouse.add(data) def PrintMenuStartInfo(): print(f'Добро пожаловать в систему учета для складских остатков\n' f'Введите один из вариантов в меню и нажмите Enter\n' f'1. Добавить товар\n' f'2. Загрузить товары с файла\n' f'3. Удалить товар\n' f'2. Список всех товаров\n' f'4. Статистика по категориям\n') while True: PrintMenuStartInfo() option = int(input()) if option == 1: sneakers = list() sneakers.append(InputSneakersInfo()) warehouse.add(sneakers) elif option == 2: data = LoadFile('products.txt') warehouse.add(data) elif option == 3: warehouse.displayAllSneakers() sneakers = InputSneakersInfo()
def test_private_empty_order(self): order = {} warehouses = [Warehouse("w1", {"a": 1})] ia = InventoryAllocator(order, warehouses) expected_output = [] self.assertEqual(ia.generate_shipment(), expected_output)
def get_packages(): with open('venv\Data\Packages1.csv', 'r', encoding='utf-8-sig') as csvfile: read_csv1 = csv.reader(csvfile, skipinitialspace=True, delimiter=',') warehouse_obj = Warehouse(read_csv1) return warehouse_obj
def processPBSResults(self): # If batch file exists, check the contents for pending tests. if os.path.exists(self.options.pbs): # Build a list of launched jobs batch_file = open(self.options.pbs) batch_list = [y.split(':') for y in [x for x in batch_file.read().split('\n')]] batch_file.close() del batch_list[-1:] # Loop through launched jobs and match the TEST_NAME to determin correct stdout (Output_Path) for job in batch_list: file = '/'.join(job[2].split('/')[:-2]) + '/' + job[3] # Build a Warehouse to hold the MooseObjects warehouse = Warehouse() # Build a Parser to parse the objects parser = Parser(self.factory, warehouse) # Parse it parser.parse(file) # Retrieve the tests from the warehouse testers = warehouse.getAllObjects() for tester in testers: self.augmentParameters(file, tester) for tester in testers: # Build the requested Tester object if job[1] == tester.parameters()['test_name']: # Create Test Type # test = self.factory.create(tester.parameters()['type'], tester) # Get job status via qstat qstat = ['qstat', '-f', '-x', str(job[0])] qstat_command = subprocess.Popen(qstat, stdout=subprocess.PIPE, stderr=subprocess.PIPE) qstat_stdout = qstat_command.communicate()[0] if qstat_stdout != None: output_value = re.search(r'job_state = (\w+)', qstat_stdout).group(1) else: return ('QSTAT NOT FOUND', '') # Report the current status of JOB_ID if output_value == 'F': # F = Finished. Get the exit code reported by qstat exit_code = int(re.search(r'Exit_status = (-?\d+)', qstat_stdout).group(1)) # Read the stdout file if os.path.exists(job[2]): output_file = open(job[2], 'r') # Not sure I am doing this right: I have to change the TEST_DIR to match the temporary cluster_launcher TEST_DIR location, thus violating the tester.specs... tester.parameters()['test_dir'] = '/'.join(job[2].split('/')[:-1]) outfile = output_file.read() output_file.close() self.testOutputAndFinish(tester, exit_code, outfile) else: # I ran into this scenario when the cluster went down, but launched/completed my job :) self.handleTestResult(tester.specs, '', 'FAILED (NO STDOUT FILE)', 0, 0, True) elif output_value == 'R': # Job is currently running self.handleTestResult(tester.specs, '', 'RUNNING', 0, 0, True) elif output_value == 'E': # Job is exiting self.handleTestResult(tester.specs, '', 'EXITING', 0, 0, True) elif output_value == 'Q': # Job is currently queued self.handleTestResult(tester.specs, '', 'QUEUED', 0, 0, True) else: return ('BATCH FILE NOT FOUND', '')
def __init__(self, argv, app_name, moose_dir): self.factory = Factory() # Build a Warehouse to hold the MooseObjects self.warehouse = Warehouse() # Get dependant applications and load dynamic tester plugins # If applications have new testers, we expect to find them in <app_dir>/scripts/TestHarness/testers dirs = [os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))] sys.path.append(os.path.join(moose_dir, 'framework', 'scripts')) # For find_dep_apps.py # Use the find_dep_apps script to get the dependant applications for an app import find_dep_apps depend_app_dirs = find_dep_apps.findDepApps(app_name) dirs.extend([os.path.join(my_dir, 'scripts', 'TestHarness') for my_dir in depend_app_dirs.split('\n')]) # Finally load the plugins! self.factory.loadPlugins(dirs, 'testers', Tester) self.test_table = [] self.num_passed = 0 self.num_failed = 0 self.num_skipped = 0 self.num_pending = 0 self.host_name = gethostname() self.moose_dir = moose_dir self.base_dir = os.getcwd() self.run_tests_dir = os.path.abspath('.') self.code = '2d2d6769726c2d6d6f6465' self.error_code = 0x0 # Assume libmesh is a peer directory to MOOSE if not defined if os.environ.has_key("LIBMESH_DIR"): self.libmesh_dir = os.environ['LIBMESH_DIR'] else: self.libmesh_dir = os.path.join(self.moose_dir, 'libmesh', 'installed') self.file = None # Parse arguments self.parseCLArgs(argv) self.checks = {} self.checks['platform'] = getPlatforms() self.checks['submodules'] = getInitializedSubmodules(self.run_tests_dir) # The TestHarness doesn't strictly require the existence of libMesh in order to run. Here we allow the user # to select whether they want to probe for libMesh configuration options. if self.options.skip_config_checks: self.checks['compiler'] = set(['ALL']) self.checks['petsc_version'] = 'N/A' self.checks['library_mode'] = set(['ALL']) self.checks['mesh_mode'] = set(['ALL']) self.checks['dtk'] = set(['ALL']) self.checks['unique_ids'] = set(['ALL']) self.checks['vtk'] = set(['ALL']) self.checks['tecplot'] = set(['ALL']) self.checks['dof_id_bytes'] = set(['ALL']) self.checks['petsc_debug'] = set(['ALL']) self.checks['curl'] = set(['ALL']) self.checks['tbb'] = set(['ALL']) self.checks['superlu'] = set(['ALL']) self.checks['unique_id'] = set(['ALL']) self.checks['cxx11'] = set(['ALL']) self.checks['asio'] = set(['ALL']) else: self.checks['compiler'] = getCompilers(self.libmesh_dir) self.checks['petsc_version'] = getPetscVersion(self.libmesh_dir) self.checks['library_mode'] = getSharedOption(self.libmesh_dir) self.checks['mesh_mode'] = getLibMeshConfigOption(self.libmesh_dir, 'mesh_mode') self.checks['dtk'] = getLibMeshConfigOption(self.libmesh_dir, 'dtk') self.checks['unique_ids'] = getLibMeshConfigOption(self.libmesh_dir, 'unique_ids') self.checks['vtk'] = getLibMeshConfigOption(self.libmesh_dir, 'vtk') self.checks['tecplot'] = getLibMeshConfigOption(self.libmesh_dir, 'tecplot') self.checks['dof_id_bytes'] = getLibMeshConfigOption(self.libmesh_dir, 'dof_id_bytes') self.checks['petsc_debug'] = getLibMeshConfigOption(self.libmesh_dir, 'petsc_debug') self.checks['curl'] = getLibMeshConfigOption(self.libmesh_dir, 'curl') self.checks['tbb'] = getLibMeshConfigOption(self.libmesh_dir, 'tbb') self.checks['superlu'] = getLibMeshConfigOption(self.libmesh_dir, 'superlu') self.checks['unique_id'] = getLibMeshConfigOption(self.libmesh_dir, 'unique_id') self.checks['cxx11'] = getLibMeshConfigOption(self.libmesh_dir, 'cxx11') self.checks['asio'] = getIfAsioExists(self.moose_dir) # Override the MESH_MODE option if using the '--distributed-mesh' # or (deprecated) '--parallel-mesh' option. if (self.options.parallel_mesh == True or self.options.distributed_mesh == True) or \ (self.options.cli_args != None and \ (self.options.cli_args.find('--parallel-mesh') != -1 or self.options.cli_args.find('--distributed-mesh') != -1)): option_set = set(['ALL', 'PARALLEL']) self.checks['mesh_mode'] = option_set method = set(['ALL', self.options.method.upper()]) self.checks['method'] = method self.initialize(argv, app_name)
def findAndRunTests(self): self.error_code = 0x0 self.preRun() self.start_time = clock() # PBS STUFF if self.options.pbs and os.path.exists(self.options.pbs): self.options.processingPBS = True self.processPBSResults() else: self.options.processingPBS = False for dirpath, dirnames, filenames in os.walk(os.getcwd(), followlinks=True): # Prune submdule paths when searching for tests if '.git' in filenames: dirnames[:] = [] # Look for test directories that aren't in contrib folders if (self.test_match.search(dirpath) and "contrib" not in os.path.relpath(dirpath, os.getcwd())): for file in filenames: # set cluster_handle to be None initially (happens for each test) self.options.cluster_handle = None # See if there were other arguments (test names) passed on the command line if file == self.options.input_file_name: #and self.test_match.search(file): saved_cwd = os.getcwd() sys.path.append(os.path.abspath(dirpath)) os.chdir(dirpath) if self.prunePath(file): continue # Build a Warehouse to hold the MooseObjects warehouse = Warehouse() # Build a Parser to parse the objects parser = Parser(self.factory, warehouse) # Parse it self.error_code = self.error_code | parser.parse(file) # Retrieve the tests from the warehouse testers = warehouse.getAllObjects() # Augment the Testers with additional information directly from the TestHarness for tester in testers: self.augmentParameters(file, tester) if self.options.enable_recover: testers = self.appendRecoverableTests(testers) # Go through the Testers and run them for tester in testers: # Double the alloted time for tests when running with the valgrind option tester.setValgrindMode(self.options.valgrind_mode) # When running in valgrind mode, we end up with a ton of output for each failed # test. Therefore, we limit the number of fails... if self.options.valgrind_mode and self.num_failed > self.options.valgrind_max_fails: (should_run, reason) = (False, 'Max Fails Exceeded') elif self.num_failed > self.options.max_fails: (should_run, reason) = (False, 'Max Fails Exceeded') else: (should_run, reason) = tester.checkRunnableBase(self.options, self.checks) if should_run: # Create the cluster launcher input file if self.options.pbs and self.options.cluster_handle == None: self.options.cluster_handle = open(dirpath + '/tests.cluster', 'a') self.options.cluster_handle.write('[Jobs]\n') command = tester.getCommand(self.options) # This method spawns another process and allows this loop to continue looking for tests # RunParallel will call self.testOutputAndFinish when the test has completed running # This method will block when the maximum allowed parallel processes are running self.runner.run(tester, command) else: # This job is skipped - notify the runner if (reason != ''): self.handleTestResult(tester.parameters(), '', reason) self.runner.jobSkipped(tester.parameters()['test_name']) if self.options.cluster_handle != None: self.options.cluster_handle.write('[]\n') self.options.cluster_handle.close() self.options.cluster_handle = None os.chdir(saved_cwd) sys.path.pop() self.runner.join() # Wait for all tests to finish if self.options.pbs and self.options.processingPBS == False: print '\n< checking batch status >\n' self.options.processingPBS = True self.processPBSResults() self.cleanup() if self.num_failed: self.error_code = self.error_code | 0x10 sys.exit(self.error_code)