def _ExecuteOneAdbShellCommand(self, dut, serial, cmd): """Helper method to execute a shell command and return results. Args: dut: the device under test. cmd: string, command to execute. Returns: stdout result of the command, None if command fails. """ if dut is None: results = cmd_utils.ExecuteShellCommand("adb -s %s shell %s" % (serial, cmd)) if (results[cmd_utils.EXIT_CODE][0]): logging.error("Fail to execute command: %s. error: %s" % (cmd, str(results[cmd_utils.STDERR][0]))) return None else: return results[cmd_utils.STDOUT][0] else: try: return dut.adb.shell(cmd) except AdbError as e: logging.warn("Fail to execute command: %s. error: %s" % (cmd, str(e))) return None
def CheckAllTestCaseExecutables(self, test_cases): """Run a batch job to check executable exists and set permissions. The result will be stored in self._executable_available for use in TestBinaryExists method. Args: test_case: list of TestCase objects. """ executables_generators = (test_case.GetRequiredExecutablePaths( self.ltp_bin_host_path) for test_case in test_cases) executables = list( set(itertools.chain.from_iterable(executables_generators))) # Set all executables executable permission using chmod. logging.info("Setting permissions on device") permission_command = "chmod 775 %s" % path_utils.JoinTargetPath( ltp_configs.LTPBINPATH, '*') permission_result = self.shell.Execute(permission_command) if permission_result[const.EXIT_CODE][0]: logging.error("Permission command '%s' failed.", permission_command) # Check existence of all executables used in test definition. # Some executables needed by test cases but not listed in test # definition will not be checked here executable_exists_commands = [ "ls %s" % executable for executable in executables if executable not in ltp_configs.INTERNAL_BINS ] logging.info("Checking binary existence on host: %s", executable_exists_commands) cmd_results = cmd_utils.ExecuteShellCommand(executable_exists_commands) executable_exists_results = map(operator.not_, cmd_results[cmd_utils.EXIT_CODE]) logging.info("Finished checking binary existence on host: %s", cmd_results) self._executable_available = dict( zip(executables, executable_exists_results)) # Check whether all the internal binaries in path needed exist bin_path_exist_commands = [ "which %s" % bin for bin in ltp_configs.INTERNAL_BINS ] bin_path_results = map( operator.not_, self.shell.Execute(bin_path_exist_commands)[const.EXIT_CODE]) bin_path_results = map( operator.not_, self.shell.Execute(bin_path_exist_commands)[const.EXIT_CODE]) self._executable_available.update( dict(zip(ltp_configs.INTERNAL_BINS, bin_path_results)))
def _GetGcdaDict(self, dut, serial): """Retrieves GCDA files from device and creates a dictionary of files. Find all GCDA files on the target device, copy them to the host using adb, then return a dictionary mapping from the gcda basename to the temp location on the host. Args: dut: the device under test. Returns: A dictionary with gcda basenames as keys and contents as the values. """ logging.debug("Creating gcda dictionary") gcda_dict = {} logging.debug("Storing gcda tmp files to: %s", self.local_coverage_path) self._ExecuteOneAdbShellCommand(dut, serial, _FLUSH_COMMAND) gcda_files = set() if self._hal_names: pids = self._GetHalPids(dut, self._hal_names) pids.add(_SP_COVERAGE_PATH) for pid in pids: path = path_utils.JoinTargetPath(TARGET_COVERAGE_PATH, pid) try: files = dut.adb.shell("find %s -name \"*.gcda\"" % path) gcda_files.update(files.split("\n")) except AdbError as e: logging.info("No gcda files found in path: \"%s\"", path) else: cmd = ("find %s -name \"*.gcda\"" % TARGET_COVERAGE_PATH) result = self._ExecuteOneAdbShellCommand(dut, serial, cmd) if result: gcda_files.update(result.split("\n")) for gcda in gcda_files: if gcda: basename = os.path.basename(gcda.strip()) file_name = os.path.join(self.local_coverage_path, basename) if dut is None: results = cmd_utils.ExecuteShellCommand( "adb -s %s pull %s %s " % (serial, gcda, file_name)) if (results[cmd_utils.EXIT_CODE][0]): logging.error( "Fail to execute command: %s. error: %s" % (cmd, str(results[cmd_utils.STDERR][0]))) else: dut.adb.pull("%s %s" % (gcda, file_name)) gcda_content = open(file_name, "rb").read() gcda_dict[gcda.strip()] = gcda_content self._ClearTargetGcov(dut, serial) return gcda_dict
def testHostBinary(self): """Tests host-side binaries.""" android_build_top = os.getenv("ANDROID_BUILD_TOP", "") asserts.assertTrue( android_build_top, "$ANDROID_BUILD_TOP is not set. Please run lunch <build target>") for binary_test_source in self.binary_test_source: binary_test_source = str(binary_test_source) binary_path = os.path.join(android_build_top, binary_test_source) cmd_result = cmd_utils.ExecuteShellCommand(binary_path) asserts.assertFalse( any(results[cmd_utils.EXIT_CODE]), "Test failed with the following results:\n " "command result: %s" % results)
def GetTraceFiles(self, dut, host_profiling_trace_path=None, trace_file_tool=None): """Pulls the trace file and save it under the profiling trace path. Args: dut: the testing device. host_profiling_trace_path: directory that stores trace files on host. trace_file_tool: tools that used to store the trace file. Returns: Name list of trace files that stored on host. """ if not os.path.exists(LOCAL_PROFILING_TRACE_PATH): os.makedirs(LOCAL_PROFILING_TRACE_PATH) if not host_profiling_trace_path: host_profiling_trace_path = LOCAL_PROFILING_TRACE_PATH dut.shell.InvokeTerminal("profiling_shell") target_trace_file = path_utils.JoinTargetPath( TARGET_PROFILING_TRACE_PATH, "*.vts.trace") results = dut.shell.profiling_shell.Execute("ls " + target_trace_file) asserts.assertTrue(results, "failed to find trace file") stdout_lines = results[const.STDOUT][0].split("\n") logging.info("stdout: %s", stdout_lines) trace_files = [] for line in stdout_lines: if line: temp_file_name = os.path.join(LOCAL_PROFILING_TRACE_PATH, os.path.basename(line.strip())) dut.adb.pull("%s %s" % (line, temp_file_name)) trace_file_name = os.path.join(host_profiling_trace_path, os.path.basename(line.strip())) logging.info("Saving profiling traces: %s" % trace_file_name) if temp_file_name != trace_file_name: file_cmd = "" if trace_file_tool: file_cmd += trace_file_tool file_cmd += " cp " + temp_file_name + " " + trace_file_name results = cmd_utils.ExecuteShellCommand(file_cmd) if results[const.EXIT_CODE][0] != 0: logging.error(results[const.STDERR][0]) logging.error("Fail to execute command: %s" % file_cmd) trace_files.append(temp_file_name) return trace_files
def _ParseTraceData(self, trace_file): """Parses the data stored in trace_file, calculates the avg/max/min latency for each API. Args: trace_file: file that stores the trace data. Returns: VTSProfilingData which contain the list of API names and the avg/max/min latency for each API. """ profiling_data = VTSProfilingData() api_timestamps = {} api_latencies = {} data_file_path = getattr(self, keys.ConfigKeys.IKEY_DATA_FILE_PATH) trace_processor_binary = os.path.join(data_file_path, "host", "bin", "trace_processor") trace_processor_lib = os.path.join(data_file_path, "host", "lib64") trace_processor_cmd = [ "chmod a+x %s" % trace_processor_binary, "LD_LIBRARY_PATH=%s %s -m profiling_trace %s" % (trace_processor_lib, trace_processor_binary, trace_file) ] results = cmd_utils.ExecuteShellCommand(trace_processor_cmd) if any(results[cmd_utils.EXIT_CODE]): logging.error("Fail to execute command: %s" % trace_processor_cmd) return profiling_data stdout_lines = results[const.STDOUT][1].split("\n") first_line = True for line in stdout_lines: if not line: continue if first_line: _, mode = line.split(":") profiling_data.options.add("hidl_hal_mode=%s" % mode) first_line = False else: api, latency = line.split(":") if profiling_data.values.get(api): profiling_data.values[api].append(long(latency)) else: profiling_data.values[api] = [long(latency)] return profiling_data
def ConnectInstanceToAdb(self, ip=None): '''Connect an Acloud instance to adb Args: ip: string, ip address ''' if not ip: ip = self.GetInstanceIP() cmds = [('ssh -i ~/.ssh/acloud_rsa -o UserKnownHostsFile=/dev/null ' '-o StrictHostKeyChecking=no -L 40000:127.0.0.1:6444 -L ' '30000:127.0.0.1:5555 -N -f -l root %s') % ip, 'adb connect 127.0.0.1:30000'] for cmd in cmds: print cmd results = cmd_utils.ExecuteShellCommand(cmd) if any(results[cmd_utils.EXIT_CODE]): logging.error("Fail to execute command: %s\nResult:%s" % (cmd, results)) return print 'Acloud instance created and connected to local port 127.0.0.1:30000'
def _ParseTraceData(self, trace_file, measure_api_coverage): """Parses the data stored in trace_file, calculates the avg/max/min latency for each API. Args: trace_file: file that stores the trace data. measure_api_coverage: whether to measure the api coverage data. Returns: VTSProfilingData which contain the list of API names and the avg/max/min latency for each API. """ profiling_data = VTSProfilingData() api_timestamps = {} api_latencies = {} trace_processor_binary = os.path.join(self.data_file_path, "host", "bin", "trace_processor") trace_processor_lib = os.path.join(self.data_file_path, "host", "lib64") trace_processor_cmd = [ "chmod a+x %s" % trace_processor_binary, "LD_LIBRARY_PATH=%s %s -m profiling_trace %s" % (trace_processor_lib, trace_processor_binary, trace_file) ] results = cmd_utils.ExecuteShellCommand(trace_processor_cmd) if any(results[cmd_utils.EXIT_CODE]): logging.error("Fail to execute command: %s" % trace_processor_cmd) logging.error("stdout: %s" % results[const.STDOUT]) logging.error("stderr: %s" % results[const.STDERR]) return profiling_data stdout_lines = results[const.STDOUT][1].split("\n") first_line = True for line in stdout_lines: if not line: continue if first_line: _, mode = line.split(":") profiling_data.options.add("hidl_hal_mode=%s" % mode) first_line = False else: full_api, latency = line.rsplit(":", 1) full_interface, api_name = full_api.rsplit("::", 1) if profiling_data.values.get(api_name): profiling_data.values[api_name].append(long(latency)) else: profiling_data.values[api_name] = [long(latency)] if measure_api_coverage: package, interface_name = full_interface.split("::") package_name, version = package.split("@") if full_interface in self.api_coverage_data: self.api_coverage_data[ full_interface].covered_apis.add(api_name) else: total_apis = self._GetTotalApis( package_name, version, interface_name) if total_apis: vts_api_coverage = VTSApiCoverageData( package_name, version, interface_name) vts_api_coverage.total_apis = total_apis if api_name in total_apis: vts_api_coverage.covered_apis.add(api_name) else: logging.warning("API %s is not supported by %s", api_name, full_interface) self.api_coverage_data[ full_interface] = vts_api_coverage return profiling_data