def _expand_test(self, test, expandedSuite): if isinstance(test, test_classes.OnAllDefaultTargetsTest): for target in self.defaultTestTargets: if target.isConnected: #create a copy of test for each target testForOneTarget = copy.deepcopy(test) testForOneTarget.set_target(target) expandedSuite.addTest(testForOneTarget) elif isinstance(test, test_classes.MultipleConnectionsTest) or isinstance(test, test_classes.OnSelectedTargetsTest): if type(test).__name__ in self.config.testToTargetConfig: for targetInfoSet in self.config.testToTargetConfig[type(test).__name__]: targetSet = [self.targets[i] for i in targetInfoSet] if self._checkIfAllTargetsReady(targetSet) and self._checkIfValidConfig(test, targetSet): # create a copy of test for each target set testForOneTargetSet = copy.deepcopy(test) for target in targetSet: if isinstance(test, test_classes.MultipleConnectionsTest): testForOneTargetSet.add_target(target) else: testForOneTargetSet.set_target(target) expandedSuite.addTest(testForOneTargetSet) else: log.error("test '{0}' could not be added to the active tests due to missing target connection or " "invalid src.".format(test.id())) else: log.warning("Missing testToTargetConfig for test {0}".format(test.id())) else: # other kinds of unit tests are executed as usual expandedSuite.addTest(test)
def _take_system_compositor_screenshot(self, screenshotName, renderer): log.info("Make screenshot of screen using system compositor") targetScreenshotPath = self.tmpDir + "/" + screenshotName renderer.send_ramsh_command( "scScreenshot \"{}\" {}".format(targetScreenshotPath, self.main_screen_id), response_message= "SystemCompositorController_Wayland_IVI::screenshot: Saved screenshot for screen" ) startTime = time.time() while time.time() < startTime + SYSTEM_COMPOSITOR_SCREENSHOT_TIMEOUT: (_, _, retCode) = self.execute_on_target("find " + targetScreenshotPath) if retCode == 0: log.info("system_compositor_screenshot: found {}".format( targetScreenshotPath)) return True log.info("system_compositor_screenshot: find result {} since {}s ". format(retCode, time.time() - startTime)) time.sleep(0.1) log.warning( "system_compositor_screenshot: failed to take screenshot {}". format(screenshotName)) return False
def _connect(self): self.sshClient = paramiko.SSHClient() self.sshClient.set_missing_host_key_policy(paramiko.AutoAddPolicy()) log.info("connecting to "+self.name+" hostname: "+self.hostname+" user: "******"Trying to connect to {} port {} for the {} time.".format(self.hostname, self.sshPort, nrAttempts)) self.sshClient.connect(self.hostname, port=self.sshPort, username=self.username, password=self.password, pkey=rsa_key, timeout=self.sshConnectionTimeoutPerAttempt, allow_agent=False, look_for_keys=False, banner_timeout=45) transport = self.sshClient.get_transport() transport.set_keepalive(5) except (socket.error, SSHException) as e: log.warning("Connection could not be established, maybe not ready yet: {0}".format(e)) time.sleep(self.sshConnectionSleepPerAttempt) # server not yet ready except (BadHostKeyException, AuthenticationException) as e: log.error("Connection error: {0}".format(e)) break else: self.isConnected = True if not self.isConnected: log.error("Connection to {0} could not be established".format(self.name)) return log.info("Connection to {0} successfully established".format(self.name))
def setup(self, transfer_binaries=True): # add platform specific dll/so search path if platform.system() == "Windows": self.defaultEnvironment = {'PATH' : os.environ.get('PATH', '') + ";" + os.path.join(self.ramsesInstallDir, 'lib')} elif platform.system() == "Linux": self.defaultEnvironment = {'LD_LIBRARY_PATH' : os.environ.get('LD_LIBRARY_PATH', '') + ":" + os.path.join(self.ramsesInstallDir, 'lib')} else: log.warning("Unknown system {}: There might be shared library load errors".format(platform.system())) return True
def _take_renderer_screenshot(self, screenshotName, renderer, displayNumber): log.info("Make screenshot of renderer") ramshCommand = "screenshot -filename \"{0}\"".format(self.tmpDir+"/"+screenshotName) if displayNumber: ramshCommand += " -displayId {}".format(displayNumber) #waitForRendererConfirmation cannot be used for screenshot creation as screenshots are enqeued at the renderer and taken on the next renderer loop result = renderer.send_ramsh_command(ramshCommand, response_message="screenshot successfully saved to file") if not result: log.warning("Screenshot confirmation not received from the renderer, check renderer application output") #print some debug output renderer.send_ramsh_command("rinfo all -v")
def target_specific_tear_down(self, shutdown=True): try: Target.target_specific_tear_down(self, shutdown=shutdown) if self.isConnected: if shutdown: self._shutdown() self.sshClient.close() except SSHException as e: log.warning( 'Paramiko exception during target_specific_tear_down: ' + str(e))
def impl_test(self): if self.target.systemCompositorControllerSupported: ensureHasContentOnSurface(self.rendererLeft, self.firstSurfaceIviId) ensureHasContentOnSurface(self.rendererRight, self.secondSurfaceIviId) self.rendererLeft.showScene(25) self.rendererRight.showScene(26) ensureSystemCompositorRoundTrip(self.rendererLeft, self.firstSurfaceIviId) self.validateScreenshot(self.rendererLeft, "testClient_multiple_ivi_layers.png", useSystemCompositorForScreenshot=True) else: log.warning("TestMultipleIVILayers skipped as system compositor controller support is not configured for this target")
def impl_test(self): if self.target.systemCompositorControllerSupported: self.rendererLeft.showScene(25) self.rendererRight.showScene(26) self.validateScreenshot(self.rendererLeft, "testClient_multiple_ivi_layers.png", useSystemCompositorForScreenshot=True) else: log.warning( "TestMultipleIVILayers skipped as system compositor controller support is not configured for this target" )
def retrieveCurrentState(self): self.flush() (stdout, _, _) = self.callIVIControl("scene") scene_state = dict() section_name = "" section_id = 0 for line in stdout: try: # check whether the line starts with a whitespace or not # if it does not start with a whitespace we have a new # section ("screen", "layer", etc.) if not re.match(r'\s', line): line_tokens = line.strip().split() if len(line_tokens) != 2: log.warning( "Unexpected line while parsing output from ivi-control: " + line) log.warning( "Expect issues (and errors) while running the test(s)" ) section_name = "" section_id = 0 continue section_name, section_id = line_tokens if section_name not in scene_state: scene_state[section_name] = dict() scene_state[section_name][section_id] = dict() # otherwise we are inside a section, so we add the info # to the section's dictionary else: assert (section_name != "" and section_id != 0) section_dict = scene_state[section_name][section_id] object_parameter = [x.strip() for x in line.split(":")] section_dict[object_parameter[0]] = object_parameter[1] except Exception: log.warning("ivi: Failed while processing line: " + line) log.warning("Full stdout of command:") for line in stdout: log.warning(line) raise return scene_state
def ramses_process_check(target): ramsesProcesses = target.get_process_list("ramses") if len(ramsesProcesses) > 0: log.warning( "RAMSES processes running before test startup on target {}. Process list: {}" .format(target.name, ramsesProcesses))
def wait_for_msg(self, watch_id, msg, timeout=None): """ Blocks until msg found or timeout :return: True if msg found during watch, False otherwise """ # don't wait if no watch_id if watch_id is None: log.error("Cannot wait! No watch_id given!") return False # don't wait if watch not active if not self.is_active(watch_id): log.error( "Cannot wait! Reader has no active watch with given id: {}!". format(watch_id)) return False timer = None if timeout: timer = threading.Timer(timeout, self.remove_watch, [watch_id]) timer.start() if msg is None: log.warning("Msg not given! Will block until timeout") timer.join() return False elif msg: log.warning( "Timeout not given! Will block until message received.\n" "(Note: if msg not found, will block forever.)") else: # don't wait if not timer and no msg given log.error("Cannot wait! Nor timeout or msg given.") return False # check data in buffer that is available until now nextLinePos = self.buffer.get_length() for i in range(self.watchStartPositions[watch_id], nextLinePos): if not self.is_active(watch_id): log.warning( "Timeout ({} seconds) waiting for msg:\'{}\' in reader: {}." .format(str(timeout), msg, self.name)) return False line = self.buffer.get_line(i) if re.search(msg, line): self.remove_watch(watch_id) if timer: timer.cancel() return True # wait for new data while self.is_active(watch_id): bufferSize = self.buffer.get_length() if nextLinePos >= bufferSize: time.sleep(0.1) else: line = self.buffer.get_line(nextLinePos) if re.search(msg, line): self.remove_watch(watch_id) if timer: timer.cancel() return True else: nextLinePos += 1 log.warning("Timeout ({} seconds) waiting for msg:\'{}\'".format( str(timeout), msg)) return False
def hasFileReadingErrors(self, traceOutput): openFileSeekPositions = {} openFileNames = {} openedFileCounter = {} error = False openRegEx = re.compile('fopen\("(.+.ramres)".*, "rb"\) = (0x[\w]+)') seekRegEx = re.compile('fseek\((0x[\w]+), ([\w]+),') closeRegEx = re.compile('fclose\((0x[\w]+)\)') for line in traceOutput: fileOpenMatch = openRegEx.search(line) if fileOpenMatch: fileName = fileOpenMatch.groups()[0] fileHandle = fileOpenMatch.groups()[1] assert (fileHandle not in openFileSeekPositions) openFileSeekPositions[fileHandle] = [] openFileNames[fileHandle] = fileName if fileName not in openedFileCounter: openedFileCounter[fileName] = 1 else: openedFileCounter[fileName] += 1 continue fileSeekMatch = seekRegEx.search(line) if fileSeekMatch: fileHandle = fileSeekMatch.groups()[0] if fileHandle in openFileSeekPositions: seekPostion = int(fileSeekMatch.groups()[1], 0) # positions may also occur in hex openFileSeekPositions[fileHandle].append(seekPostion) continue fileCloseMatch = closeRegEx.search(line) if fileCloseMatch: fileHandle = fileCloseMatch.groups()[0] if fileHandle in openFileSeekPositions: if not self.checkForIncreasingSeekOrder( openFileSeekPositions[fileHandle]): error |= True log.error( "no increasing seek/read actions in file {}: {}". format(openFileNames[fileHandle], openFileSeekPositions[fileHandle])) del openFileNames[fileHandle] del openFileSeekPositions[fileHandle] if len(openedFileCounter) == 0: error |= True log.warning( "no ramses resource file (*.ramres) was opened during the test. Please check your test application." ) else: for fileName, openCount in openedFileCounter.iteritems(): if openCount > 1: error |= True log.error( "file {} was opened/closed {} times (only once is allowed)" .format(fileName, openCount)) else: log.info("file {} was opened only once".format(fileName)) return error