def WaitForDevicePm(self, wait_time=120): """Waits for targeted device's package manager to be up. Args: wait_time: time in seconds to wait Raises: WaitForResponseTimedOutError if wait_time elapses and pm still does not respond. """ logger.Log("Waiting for device package manager...") self.SendCommand("wait-for-device") # Now the device is there, but may not be running. # Query the package manager with a basic command try: self._WaitForShellCommandContents("pm path android", "package:", wait_time) except errors.WaitForResponseTimedOutError: raise errors.WaitForResponseTimedOutError( "Package manager did not respond after %s seconds" % wait_time)
def GetProductOut(): """Returns the full pathname to the target/product directory. Typically the value of the env variable $ANDROID_PRODUCT_OUT. Assumes build environment has been properly configured by envsetup & lunch/choosecombo. Returns: The absolute file path of the Android product directory. Raises: AbortError: if Android product directory could not be found. """ path = os.getenv("ANDROID_PRODUCT_OUT") if path is None: logger.Log( "Error: ANDROID_PRODUCT_OUT not defined. Please run envsetup.sh") raise errors.AbortError return path
def StartInstrumentationNoResults(self, package_name, runner_name, no_window_animation=False, raw_mode=False, instrumentation_args={}): """Runs instrumentation and dumps output to stdout. Equivalent to StartInstrumentation, but will dump instrumentation 'normal' output to stdout, instead of parsing return results. Command will never timeout. """ adb_command_string = self.PreviewInstrumentationCommand( package_name, runner_name, no_window_animation=no_window_animation, raw_mode=raw_mode, instrumentation_args=instrumentation_args) logger.Log(adb_command_string) run_command.RunCommand(adb_command_string, return_output=False)
def GetHostBin(): """Compute the full pathname to the host binary directory. Typically $ANDROID_BUILD_TOP/out/host/linux-x86/bin. Assumes build environment has been properly configured by envsetup & lunch/choosecombo. Returns: The absolute file path of the Android host binary directory. Raises: AbortError: if Android host binary directory could not be found. """ (_, _, os_arch) = GetHostOsArch() path = os.path.join(GetTop(), "out", "host", os_arch, "bin") if not os.path.exists(path): logger.Log("Error: Host bin path could not be found %s" % path) raise errors.AbortError return path
def GetHostLibraryPath(): """Returns the full pathname to the host java library output directory. Typically $ANDROID_BUILD_TOP/out/host/<host_os>/framework. Assumes build environment has been properly configured by envsetup & lunch/choosecombo. Returns: The absolute file path of the Android host java library directory. Raises: AbortError: if Android host java library directory could not be found. """ (_, _, os_arch) = GetHostOsArch() path = os.path.join(GetTop(), "out", "host", os_arch, "framework") if not os.path.exists(path): logger.Log("Error: Host library path could not be found %s" % path) raise errors.AbortError return path
def launch(): try: gc.disable() log_main: logger.Log = logger.Log() log_main.to_stderr = launcher.DEBUG log_main.info(f"Starting TF2 Rich Presence {launcher.VERSION}") app: TF2RichPresense = TF2RichPresense(log_main) app.run() except SystemExit: raise except Exception: try: gc.enable() log_main.critical(traceback.format_exc()) except NameError: pass # the crash happened in logger.Log().__init__() and so log_main is unassigned raise
def Pull(self, src, dest): """Pulls the file src on the device onto dest on the host. Args: src: absolute file path of file on device to pull dest: destination file path on host Returns: True if success and False otherwise. """ # Create the base dir if it doesn't exist already if not os.path.exists(os.path.dirname(dest)): os.makedirs(os.path.dirname(dest)) if self.DoesFileExist(src): self.SendCommand("pull %s %s" % (src, dest), timeout_time=60) return True else: logger.Log("ADB Pull Failed: Source file %s does not exist." % src) return False
def __init__(self, log: Optional[logger.Log] = None, loc: Optional[localization.Localizer] = None): self.in_menus: bool = True self.tf2_map: str = '' # these have "tf2_" to avoid conflicting with reserved keywords self.tf2_class: str = "unselected" self.map_fancy: str = '' self.server_address: str = '' self.queued_state: str = "Not queued" self.hosting: bool = False self.server_name: str = '' self.player_count: str = '' self.kills: str = '' self.gamemode: str = '' self.gamemode_fancy: str = '' self.custom_map: bool = False self.game_start_time: int = int(time.time()) self.map_change_time: int = int(time.time()) self.map_line: str = '' self.update_rpc: bool = True # don't track whether the GUI needs to be updated, main just always calls its updates and lets it handle whether or not it needs to set elements self.last_server_request_time: float = 0.0 self.last_server_request_data: Dict[str, str] = {} self.last_server_request_address: str = '' self.updated_server_state: bool = False self.force_zero_map_time: bool = False if log: self.log: logger.Log = log else: self.log = logger.Log() self.log.error( f"Initialized GameState without a log, defaulting to one at {self.log.filename}" ) if loc: self.loc: localization.Localizer = loc else: self.loc = localization.Localizer() self.log.error("Initialized GameState without a localizer")
def Run(): if return_output: output_dest = subprocess.PIPE else: # None means direct to stdout output_dest = None pipe = subprocess.Popen(cmd, executable='/bin/bash', stdout=output_dest, stderr=subprocess.STDOUT, shell=True) pid.append(pipe.pid) try: output = pipe.communicate()[0] if output is not None and len(output) > 0: so.append(output) except OSError, e: logger.SilentLog("failed to retrieve stdout from: %s" % cmd) logger.Log(e) so.append("ERROR") error_occurred = True
def generate_predictions_with_id(self, path, examples): if (self.completed == True): best_path = os.path.join(FIXED_PARAMETERS["ckpt_path"], modname) + ".ckpt_best" self.sess = tf.Session() self.sess.run(self.init) self.saver.restore(self.sess, best_path) logger.Log("Model restored from file: %s" % best_path) total_batch = int(len(examples) / self.batch_size) pred_size = 3 logits = np.empty(pred_size) costs = 0 IDs = np.empty(1) for i in tqdm(range(total_batch + 1), ascii = True): if i != total_batch: #make batch here r, premise, hypothesis, premise_def, hypothesis_def ,labels, mask_p, mask_h, mask_p_def, mask_h_def = self.batch_matrix(examples, i * self.batch_size, (i+1) * self.batch_size) else: #make batch here with boundary r, premise, hypothesis, premise_def, hypothesis_def ,labels, mask_p, mask_h, mask_p_def, mask_h_def = self.batch_matrix(examples, i * self.batch_size, len(examples)) feed_dict = {self.model.r_matrix : r, self.model.premise_x : premise, self.model.hypothesis_x : hypothesis, self.model.mask_p : mask_p, self.model.mask_h : mask_h, self.model.premise_def : premise_def, self.model.hypothesis_def : hypothesis_def, self.model.mask_p_def : mask_p_def, self.model.mask_h_def : mask_h_def, self.model.y : labels, self.model.keep_rate_ph: 1.0, self.model.is_train: True } logit = self.sess.run(self.model.logits, feed_dict) IDs = np.concatenate([IDs, pairIDs]) logits = np.vstack([logits, logit]) IDs = IDs[1:] logits = np.argmax(logits[1:], axis=1) save_submission(path, IDs, logits[1:])
def Parse(self, element): """Populates common suite attributes from given suite xml element. Args: element: xml node to parse Raises: ParseError if a required attribute is missing. Returns: parsed test suite or None """ parser = None if element.nodeName == InstrumentationParser.TAG_NAME: parser = InstrumentationParser() elif element.nodeName == NativeParser.TAG_NAME: parser = NativeParser() elif element.nodeName == HostParser.TAG_NAME: parser = HostParser() else: logger.Log('Unrecognized tag %s found' % element.nodeName) return None test_suite = parser.Parse(element) return test_suite
def testLevel(self): """A test setting the debug level up.""" import logger logfilename = 'xyzzy2.log' # start logging at WARN, write some test logs, close log log = logger.Log(logfilename, logger.Log.WARN) log('test') log.debug('DEBUG: test') log.info('INFO: test') log.warn('WARN: test') log.error('ERROR: test') log.critical('CRITICAL: test') del log # check contents of the logfile with open(logfilename, 'r') as fd: lines = fd.readlines() # get last field of each line (ignore first 3 lines) last_field = [] for l in lines[3:]: end_field = l.split('|')[-1] last_field.append(end_field) # build the expected output expected = [ 'Logging level set to 30 (WARN)\n', 'test\n', 'WARN: test\n', 'ERROR: test\n', 'CRITICAL: test\n' ] msg = ('Got error comparing last fields, expected:\n%s\ngot:\n%s' % (''.join(expected), ''.join(last_field))) self.assertEqual(expected, last_field, msg) os.remove(logfilename)
def GetHostOsArch(): """Identify the host os and arch. Returns: The triple (HOST_OS, HOST_ARCH, HOST_OS-HOST_ARCH). Raises: AbortError: If the os and/or arch could not be found. """ command = ("CALLED_FROM_SETUP=true BUILD_SYSTEM=build/core " "make --no-print-directory -C \"%s\" -f build/core/config.mk " "dumpvar-report_config") % GetTop() # Use the shell b/c we set some env variables before the make command. config = subprocess.Popen(command, stdout=subprocess.PIPE, shell=True).communicate()[0] host_os = re.search("HOST_OS=(\w+)", config).group(1) host_arch = re.search("HOST_ARCH=(\w+)", config).group(1) if not (host_os and host_arch): logger.Log("Error: Could not get host's OS and/or ARCH") raise errors.AbortError return (host_os, host_arch, "%s-%s" % (host_os, host_arch))
def __init__(self): # model initialization self.model = model.ExpliLEModel( vectors, PARAMETERS["mlp_lay"], activation=tf.nn.tanh, scope="exp_le", asym_fact=PARAMETERS["asym_fact"], margin_le=PARAMETERS["hinge_margin"], reg_factor_hyp=PARAMETERS["reg_factor_hyp"], reg_factor_sym=PARAMETERS["reg_factor_sym"], learning_rate=PARAMETERS["learning_rate"], margin_sym=PARAMETERS["margin_sym"]) self.asym_fact = PARAMETERS["asym_fact"] self.batch_size = PARAMETERS["batch_size"] self.keep_rate = PARAMETERS["dropout"] self.eval_steps = PARAMETERS["eval_steps"] logger.Log("Initializing variables") self.init = tf.global_variables_initializer() self.sess = None self.saver = tf.train.Saver()
def Run(self, options, adb_interface): """Runs the host test. Results will be displayed on stdout. Assumes 'java' is on system path. Args: options: command line options for running host tests. Expected member fields: host_lib_path: path to directory that contains host library files test_data_path: path to directory that contains test data files preview: if true, do not execute, display commands only adb_interface: reference to device under test Raises: errors.AbortError: if fatal error occurs """ # get the serial number of the device under test, so it can be passed to # hosttestlib. serial_number = adb_interface.GetSerialNumber() self._lib_names.append(self.GetJarName()) # gather all the host jars that are needed to run tests full_lib_paths = [] for lib in self._lib_names: path = os.path.join(options.host_lib_path, lib) # make sure jar file exists on host if not os.path.exists(path): raise errors.AbortError(msg="Could not find jar %s" % path) full_lib_paths.append(path) # java -cp <libs> <runner class> <test suite class> -s <device serial> # -p <test data path> cmd = "java -cp %s %s %s -s %s -p %s" % ( ":".join(full_lib_paths), self._TEST_RUNNER, self.GetClassName(), serial_number, options.test_data_path) logger.Log(cmd) if not options.preview: run_command.RunOnce(cmd, return_output=False)
def __init__(self, config, msg_queue): threading.Thread.__init__(self) conf.verb = 0 self.__init_variable() self.name = config['name'] self.mac = config['mac'] self.iface = config['iface'] self.config = config self.msg = message.Message(msg_queue) self.msg.user = self.name self.msg.msg_templete['attacker'] = 'Unknown' self.msg.msg_templete['victim'] = self.name self.msg.msg_templete['victim_mac'] = self.mac log_file = "./log/%s.log" % self.name self.log = logger.Log(log_file) self.log.set_print_level(3) self.iface_id = in6_mactoifaceid(self.mac).lower() self.link_local_addr = "fe80::" + self.iface_id self.link_local_addr = in6_ptop(self.link_local_addr) #FF02:0:0:0:0:1:FFXX:XXXX self.solicited_node_addr = inet_ntop6( in6_getnsma(inet_pton6(self.link_local_addr))) # When sending packets, it will select one of these addresses as src_addr. self.src_addrs.append(self.link_local_addr) self.src_addrs.append(self.unspecified_addr) # Packets with these dst_addr will destinate to the honeypot. self.dst_addrs.append(self.link_local_addr) self.dst_addrs.append(self.solicited_node_addr) self.dst_addrs.append(self.all_nodes_addr)
def _GetTestsToRun(self): """Get a list of TestSuite objects to run, based on command line args.""" if self._tests_to_run: return self._tests_to_run self._tests_to_run = [] if self._options.all_tests: self._tests_to_run = self._known_tests.GetTests() elif self._options.continuous_tests: self._tests_to_run = self._known_tests.GetContinuousTests() elif self._options.cts_tests: self._tests_to_run = self._known_tests.GetCtsTests() elif self._options.test_path: walker = test_walker.TestWalker() self._tests_to_run = walker.FindTests(self._options.test_path) for name in self._test_args: test = self._known_tests.GetTest(name) if test is None: logger.Log("Error: Could not find test %s" % name) self._DumpTests() raise errors.AbortError self._tests_to_run.append(test) return self._tests_to_run
def _TurnOffVerifier(self, test_list): """Turn off the dalvik verifier if needed by given tests. If one or more tests needs dalvik verifier off, and it is not already off, turns off verifier and reboots device to allow change to take effect. """ # hack to check if these are frameworks/base tests. If so, turn off verifier # to allow framework tests to access package-private framework api framework_test = False for test in test_list: if os.path.commonprefix([test.GetBuildPath(), "frameworks/base"]): framework_test = True if framework_test: # check if verifier is off already - to avoid the reboot if not # necessary output = self._adb.SendShellCommand("cat /data/local.prop") if not self._DALVIK_VERIFIER_OFF_PROP in output: if self._options.preview: logger.Log("adb shell \"echo %s >> /data/local.prop\"" % self._DALVIK_VERIFIER_OFF_PROP) logger.Log("adb shell chmod 644 /data/local.prop") logger.Log("adb reboot") logger.Log("adb wait-for-device") else: logger.Log("Turning off dalvik verifier and rebooting") self._adb.SendShellCommand( "\"echo %s >> /data/local.prop\"" % self._DALVIK_VERIFIER_OFF_PROP) self._ChmodReboot() elif not self._options.preview: # check the permissions on the file permout = self._adb.SendShellCommand("ls -l /data/local.prop") if not "-rw-r--r--" in permout: logger.Log( "Fixing permissions on /data/local.prop and rebooting") self._ChmodReboot()
#!/usr/bin/env python # -*- coding: utf-8 -*- import logger import requests import parsel base_url = 'http://yhxz521.com' log = logger.Log() def get_classify_list(): log.debug("***********开始爬取***********") pase = send_requests(base_url) href_list = pase.xpath( '//div[@class="nav"]/ul/li/a/@href').extract() # 分类list log.debug("分类list为:%s" % href_list) return href_list def send_requests(url): response = requests.get(url) log.debug("请求地址:%s" % url) response.encoding = response.apparent_encoding log.debug("编码为:%s" % response.encoding) html = response.text # response的html parse = parsel.Selector(html) return parse if __name__ == "__main__":
class TestRunner(object): """Command line utility class for running pre-defined Android test(s).""" _TEST_FILE_NAME = "test_defs.xml" # file path to android core platform tests, relative to android build root # TODO move these test data files to another directory _CORE_TEST_PATH = os.path.join("development", "testrunner", _TEST_FILE_NAME) # vendor glob file path patterns to tests, relative to android # build root _VENDOR_TEST_PATH = os.path.join("vendor", "*", "tests", "testinfo", _TEST_FILE_NAME) _RUNTEST_USAGE = ( "usage: runtest.py [options] short-test-name[s]\n\n" "The runtest script works in two ways. You can query it " "for a list of tests, or you can launch one or more tests.") # default value for make -jX _DEFAULT_JOBS = 16 _DALVIK_VERIFIER_PROP = "dalvik.vm.dexopt-flags" _DALVIK_VERIFIER_OFF_VALUE = "v=n" _DALVIK_VERIFIER_OFF_PROP = "%s = %s" % (_DALVIK_VERIFIER_PROP, _DALVIK_VERIFIER_OFF_VALUE) # regular expression to match path to artifacts to install in make output _RE_MAKE_INSTALL = re.compile(r'INSTALL-PATH:\s([^\s]+)\s(.*)$') def __init__(self): # disable logging of timestamp self._root_path = android_build.GetTop() out_base_name = os.path.basename(android_build.GetOutDir()) # regular expression to find remote device path from a file path relative # to build root pattern = r'' + out_base_name + r'\/target\/product\/\w+\/(.+)$' self._re_make_install_path = re.compile(pattern) logger.SetTimestampLogging(False) self._adb = None self._known_tests = None self._options = None self._test_args = None self._tests_to_run = None def _ProcessOptions(self): """Processes command-line options.""" # TODO error messages on once-only or mutually-exclusive options. user_test_default = os.path.join(os.environ.get("HOME"), ".android", self._TEST_FILE_NAME) parser = optparse.OptionParser(usage=self._RUNTEST_USAGE) parser.add_option("-l", "--list-tests", dest="only_list_tests", default=False, action="store_true", help="To view the list of tests") parser.add_option("-b", "--skip-build", dest="skip_build", default=False, action="store_true", help="Skip build - just launch") parser.add_option("-j", "--jobs", dest="make_jobs", metavar="X", default=self._DEFAULT_JOBS, help="Number of make jobs to use when building") parser.add_option("-n", "--skip_execute", dest="preview", default=False, action="store_true", help="Do not execute, just preview commands") parser.add_option( "-i", "--build-install-only", dest="build_install_only", default=False, action="store_true", help="Do not execute, build tests and install to device only") parser.add_option("-r", "--raw-mode", dest="raw_mode", default=False, action="store_true", help="Raw mode (for output to other tools)") parser.add_option("-a", "--suite-assign", dest="suite_assign_mode", default=False, action="store_true", help="Suite assignment (for details & usage see " "InstrumentationTestRunner)") parser.add_option("-v", "--verbose", dest="verbose", default=False, action="store_true", help="Increase verbosity of %s" % sys.argv[0]) parser.add_option("-w", "--wait-for-debugger", dest="wait_for_debugger", default=False, action="store_true", help="Wait for debugger before launching tests") parser.add_option("-c", "--test-class", dest="test_class", help="Restrict test to a specific class") parser.add_option("-m", "--test-method", dest="test_method", help="Restrict test to a specific method") parser.add_option("-p", "--test-package", dest="test_package", help="Restrict test to a specific java package") parser.add_option("-z", "--size", dest="test_size", help="Restrict test to a specific test size") parser.add_option( "--annotation", dest="test_annotation", help="Include only those tests tagged with a specific" " annotation") parser.add_option("--not-annotation", dest="test_not_annotation", help="Exclude any tests tagged with a specific" " annotation") parser.add_option("-u", "--user-tests-file", dest="user_tests_file", metavar="FILE", default=user_test_default, help="Alternate source of user test definitions") parser.add_option("-o", "--coverage", dest="coverage", default=False, action="store_true", help="Generate code coverage metrics for test(s)") parser.add_option( "--coverage-target", dest="coverage_target_path", default=None, help="Path to app to collect code coverage target data for.") parser.add_option( "-k", "--skip-permissions", dest="skip_permissions", default=False, action="store_true", help="Do not grant runtime permissions during test package" " installation.") parser.add_option("-x", "--path", dest="test_path", help="Run test(s) at given file system path") parser.add_option("-t", "--all-tests", dest="all_tests", default=False, action="store_true", help="Run all defined tests") parser.add_option( "--continuous", dest="continuous_tests", default=False, action="store_true", help="Run all tests defined as part of the continuous " "test set") parser.add_option( "--timeout", dest="timeout", default=300, help="Set a timeout limit (in sec) for " "running native tests on a device (default: 300 secs)") parser.add_option("--suite", dest="suite", help="Run all tests defined as part of the " "the given test suite") group = optparse.OptionGroup( parser, "Targets", "Use these options to direct tests to a specific " "Android target") group.add_option("-e", "--emulator", dest="emulator", default=False, action="store_true", help="use emulator") group.add_option("-d", "--device", dest="device", default=False, action="store_true", help="use device") group.add_option("-s", "--serial", dest="serial", help="use specific serial") parser.add_option_group(group) self._options, self._test_args = parser.parse_args() if (not self._options.only_list_tests and not self._options.all_tests and not self._options.continuous_tests and not self._options.suite and not self._options.test_path and len(self._test_args) < 1): parser.print_help() logger.SilentLog("at least one test name must be specified") raise errors.AbortError self._adb = adb_interface.AdbInterface() if self._options.emulator: self._adb.SetEmulatorTarget() elif self._options.device: self._adb.SetDeviceTarget() elif self._options.serial is not None: self._adb.SetTargetSerial(self._options.serial) if self._options.verbose: logger.SetVerbose(True) if self._options.coverage_target_path: self._options.coverage = True self._known_tests = self._ReadTests() self._options.host_lib_path = android_build.GetHostLibraryPath() self._options.test_data_path = android_build.GetTestAppPath() def _ReadTests(self): """Parses the set of test definition data. Returns: A TestDefinitions object that contains the set of parsed tests. Raises: AbortError: If a fatal error occurred when parsing the tests. """ try: known_tests = test_defs.TestDefinitions() # only read tests when not in path mode if not self._options.test_path: core_test_path = os.path.join(self._root_path, self._CORE_TEST_PATH) if os.path.isfile(core_test_path): known_tests.Parse(core_test_path) # read all <android root>/vendor/*/tests/testinfo/test_defs.xml paths vendor_tests_pattern = os.path.join(self._root_path, self._VENDOR_TEST_PATH) test_file_paths = glob.glob(vendor_tests_pattern) for test_file_path in test_file_paths: known_tests.Parse(test_file_path) if os.path.isfile(self._options.user_tests_file): known_tests.Parse(self._options.user_tests_file) return known_tests except errors.ParseError: raise errors.AbortError def _DumpTests(self): """Prints out set of defined tests.""" print "The following tests are currently defined:\n" print "%-25s %-40s %s" % ("name", "build path", "description") print "-" * 80 for test in self._known_tests: print "%-25s %-40s %s" % (test.GetName(), test.GetBuildPath(), test.GetDescription()) print "\nSee %s for more information" % self._TEST_FILE_NAME def _DoBuild(self): logger.SilentLog("Building tests...") tests = self._GetTestsToRun() # Build and install tests that do not get granted permissions self._DoPermissionAwareBuild(tests, False) # Build and install tests that require granted permissions self._DoPermissionAwareBuild(tests, True) def _DoPermissionAwareBuild(self, tests, test_requires_permissions): # turn off dalvik verifier if necessary # TODO: skip turning off verifier for now, since it puts device in bad # state b/14088982 #self._TurnOffVerifier(tests) self._DoFullBuild(tests, test_requires_permissions) target_tree = make_tree.MakeTree() extra_args_set = [] for test_suite in tests: if test_suite.IsGrantedPermissions() == test_requires_permissions: self._AddBuildTarget(test_suite, target_tree, extra_args_set) if not self._options.preview: self._adb.EnableAdbRoot() else: logger.Log("adb root") if not target_tree.IsEmpty(): if self._options.coverage: coverage.EnableCoverageBuild() target_tree.AddPath("external/emma") target_list = target_tree.GetPrunedMakeList() target_dir_list = [ re.sub(r'Android[.]mk$', r'', i) for i in target_list ] target_build_string = " ".join(target_list) target_dir_build_string = " ".join(target_dir_list) extra_args_string = " ".join(extra_args_set) install_path_goals = [] mmma_goals = [] for d in target_dir_list: if d.startswith("./"): d = d[2:] if d.endswith("/"): d = d[:-1] install_path_goals.append("GET-INSTALL-PATH-IN-" + d.replace("/", "-")) mmma_goals.append("MODULES-IN-" + d.replace("/", "-")) # mmm cannot be used from python, so perform a similar operation using # ONE_SHOT_MAKEFILE cmd = 'ONE_SHOT_MAKEFILE="%s" make -j%s -C "%s" %s %s %s' % ( target_build_string, self._options.make_jobs, self._root_path, " ".join(install_path_goals), " ".join(mmma_goals), extra_args_string) # mmma cannot be used from python, so perform a similar operation alt_cmd = 'make -j%s -C "%s" -f build/core/main.mk %s %s' % ( self._options.make_jobs, self._root_path, extra_args_string, " ".join(mmma_goals)) logger.Log(cmd) if not self._options.preview: run_command.SetAbortOnError() try: output = run_command.RunCommand(cmd, return_output=True, timeout_time=600) ## Chances are this failed because it didn't build the dependencies except errors.AbortError: logger.Log( "make failed. Trying to rebuild all dependencies.") logger.Log( "mmma -j%s %s" % (self._options.make_jobs, target_dir_build_string)) # Try again with mma equivalent, which will build the dependencies run_command.RunCommand(alt_cmd, return_output=False, timeout_time=600) # Run mmm again to get the install paths only output = run_command.RunCommand(cmd, return_output=True, timeout_time=600) run_command.SetAbortOnError(False) logger.SilentLog(output) self._DoInstall(output, test_requires_permissions) def _DoInstall(self, make_output, test_requires_permissions): """Install artifacts from build onto device. Looks for 'install:' text from make output to find artifacts to install. Files with the .apk extension get 'adb install'ed, all other files get 'adb push'ed onto the device. Args: make_output: stdout from make command """ for line in make_output.split("\n"): m = self._RE_MAKE_INSTALL.match(line) if m: # strip the 'INSTALL: <name>' from the left hand side # the remaining string is a space-separated list of build-generated files install_paths = m.group(2) for install_path in re.split(r'\s+', install_paths): if install_path.endswith(".apk"): abs_install_path = os.path.join( self._root_path, install_path) extra_flags = "" if test_requires_permissions and not self._options.skip_permissions: extra_flags = "-g" logger.Log("adb install -r %s %s" % (extra_flags, abs_install_path)) logger.Log( self._adb.Install(abs_install_path, extra_flags)) else: self._PushInstallFileToDevice(install_path) def _PushInstallFileToDevice(self, install_path): m = self._re_make_install_path.match(install_path) if m: remote_path = m.group(1) remote_dir = os.path.dirname(remote_path) logger.Log("adb shell mkdir -p %s" % remote_dir) self._adb.SendShellCommand("mkdir -p %s" % remote_dir) abs_install_path = os.path.join(self._root_path, install_path) logger.Log("adb push %s %s" % (abs_install_path, remote_path)) self._adb.Push(abs_install_path, remote_path) else: logger.Log( "Error: Failed to recognize path of file to install %s" % install_path) def _DoFullBuild(self, tests, test_requires_permissions): """If necessary, run a full 'make' command for the tests that need it.""" extra_args_set = Set() for test in tests: if test.IsFullMake() and test.IsGrantedPermissions( ) == test_requires_permissions: if test.GetExtraBuildArgs(): # extra args contains the args to pass to 'make' extra_args_set.add(test.GetExtraBuildArgs()) else: logger.Log( "Warning: test %s needs a full build but does not specify" " extra_build_args" % test.GetName()) # check if there is actually any tests that required a full build if extra_args_set: cmd = ('make -j%s %s' % (self._options.make_jobs, ' '.join(list(extra_args_set)))) logger.Log(cmd) if not self._options.preview: old_dir = os.getcwd() os.chdir(self._root_path) output = run_command.RunCommand(cmd, return_output=True) logger.SilentLog(output) os.chdir(old_dir) self._DoInstall(output, test_requires_permissions) def _AddBuildTarget(self, test_suite, target_tree, extra_args_set): if not test_suite.IsFullMake(): build_dir = test_suite.GetBuildPath() if self._AddBuildTargetPath(build_dir, target_tree): extra_args_set.append(test_suite.GetExtraBuildArgs()) for path in test_suite.GetBuildDependencies(self._options): self._AddBuildTargetPath(path, target_tree) def _AddBuildTargetPath(self, build_dir, target_tree): if build_dir is not None: target_tree.AddPath(build_dir) return True return False def _GetTestsToRun(self): """Get a list of TestSuite objects to run, based on command line args.""" if self._tests_to_run: return self._tests_to_run self._tests_to_run = [] if self._options.all_tests: self._tests_to_run = self._known_tests.GetTests() elif self._options.continuous_tests: self._tests_to_run = self._known_tests.GetContinuousTests() elif self._options.suite: self._tests_to_run = \ self._known_tests.GetTestsInSuite(self._options.suite) elif self._options.test_path: walker = test_walker.TestWalker() self._tests_to_run = walker.FindTests(self._options.test_path) for name in self._test_args: test = self._known_tests.GetTest(name) if test is None: logger.Log("Error: Could not find test %s" % name) self._DumpTests() raise errors.AbortError self._tests_to_run.append(test) return self._tests_to_run def _IsCtsTests(self, test_list): """Check if any cts tests are included in given list of tests to run.""" for test in test_list: if test.GetSuite() == 'cts': return True return False def _TurnOffVerifier(self, test_list): """Turn off the dalvik verifier if needed by given tests. If one or more tests needs dalvik verifier off, and it is not already off, turns off verifier and reboots device to allow change to take effect. """ # hack to check if these are frameworks/base tests. If so, turn off verifier # to allow framework tests to access private/protected/package-private framework api framework_test = False for test in test_list: if os.path.commonprefix([test.GetBuildPath(), "frameworks/base"]): framework_test = True if framework_test: # check if verifier is off already - to avoid the reboot if not # necessary output = self._adb.SendShellCommand("cat /data/local.prop") if not self._DALVIK_VERIFIER_OFF_PROP in output: # Read the existing dalvik verifier flags. old_prop_value = self._adb.SendShellCommand("getprop %s" \ %(self._DALVIK_VERIFIER_PROP)) old_prop_value = old_prop_value.strip( ) if old_prop_value else "" # Append our verifier flags to existing flags new_prop_value = "%s %s" % (self._DALVIK_VERIFIER_OFF_VALUE, old_prop_value) # Update property now, as /data/local.prop is not read until reboot logger.Log("adb shell setprop %s '%s'" \ %(self._DALVIK_VERIFIER_PROP, new_prop_value)) if not self._options.preview: self._adb.SendShellCommand("setprop %s '%s'" \ %(self._DALVIK_VERIFIER_PROP, new_prop_value)) # Write prop to /data/local.prop # Every time device is booted, it will pick up this value new_prop_assignment = "%s = %s" % (self._DALVIK_VERIFIER_PROP, new_prop_value) if self._options.preview: logger.Log("adb shell \"echo %s >> /data/local.prop\"" % new_prop_assignment) logger.Log("adb shell chmod 644 /data/local.prop") else: logger.Log("Turning off dalvik verifier and rebooting") self._adb.SendShellCommand( "\"echo %s >> /data/local.prop\"" % new_prop_assignment) # Reset runtime so that dalvik picks up new verifier flags from prop self._ChmodRuntimeReset() elif not self._options.preview: # check the permissions on the file permout = self._adb.SendShellCommand("ls -l /data/local.prop") if not "-rw-r--r--" in permout: logger.Log( "Fixing permissions on /data/local.prop and rebooting") self._ChmodRuntimeReset() def _ChmodRuntimeReset(self): """Perform a chmod of /data/local.prop and reset the runtime. """ logger.Log("adb shell chmod 644 /data/local.prop ## u+w,a+r") if not self._options.preview: self._adb.SendShellCommand("chmod 644 /data/local.prop") self._adb.RuntimeReset(preview_only=self._options.preview) if not self._options.preview: self._adb.EnableAdbRoot() def RunTests(self): """Main entry method - executes the tests according to command line args.""" try: run_command.SetAbortOnError() self._ProcessOptions() if self._options.only_list_tests: self._DumpTests() return if not self._options.skip_build: self._DoBuild() if self._options.build_install_only: logger.Log( "Skipping test execution (due to --build-install-only flag)" ) return for test_suite in self._GetTestsToRun(): try: test_suite.Run(self._options, self._adb) except errors.WaitForResponseTimedOutError: logger.Log("Timed out waiting for response") except KeyboardInterrupt: logger.Log("Exiting...") except errors.AbortError, error: logger.Log(error.msg) logger.SilentLog("Exiting due to AbortError...") except errors.WaitForResponseTimedOutError: logger.Log("Timed out waiting for response")
def _DoPermissionAwareBuild(self, tests, test_requires_permissions): # turn off dalvik verifier if necessary # TODO: skip turning off verifier for now, since it puts device in bad # state b/14088982 #self._TurnOffVerifier(tests) self._DoFullBuild(tests, test_requires_permissions) target_tree = make_tree.MakeTree() extra_args_set = [] for test_suite in tests: if test_suite.IsGrantedPermissions() == test_requires_permissions: self._AddBuildTarget(test_suite, target_tree, extra_args_set) if not self._options.preview: self._adb.EnableAdbRoot() else: logger.Log("adb root") if not target_tree.IsEmpty(): if self._options.coverage: coverage.EnableCoverageBuild() target_tree.AddPath("external/emma") target_list = target_tree.GetPrunedMakeList() target_dir_list = [ re.sub(r'Android[.]mk$', r'', i) for i in target_list ] target_build_string = " ".join(target_list) target_dir_build_string = " ".join(target_dir_list) extra_args_string = " ".join(extra_args_set) install_path_goals = [] mmma_goals = [] for d in target_dir_list: if d.startswith("./"): d = d[2:] if d.endswith("/"): d = d[:-1] install_path_goals.append("GET-INSTALL-PATH-IN-" + d.replace("/", "-")) mmma_goals.append("MODULES-IN-" + d.replace("/", "-")) # mmm cannot be used from python, so perform a similar operation using # ONE_SHOT_MAKEFILE cmd = 'ONE_SHOT_MAKEFILE="%s" make -j%s -C "%s" %s %s %s' % ( target_build_string, self._options.make_jobs, self._root_path, " ".join(install_path_goals), " ".join(mmma_goals), extra_args_string) # mmma cannot be used from python, so perform a similar operation alt_cmd = 'make -j%s -C "%s" -f build/core/main.mk %s %s' % ( self._options.make_jobs, self._root_path, extra_args_string, " ".join(mmma_goals)) logger.Log(cmd) if not self._options.preview: run_command.SetAbortOnError() try: output = run_command.RunCommand(cmd, return_output=True, timeout_time=600) ## Chances are this failed because it didn't build the dependencies except errors.AbortError: logger.Log( "make failed. Trying to rebuild all dependencies.") logger.Log( "mmma -j%s %s" % (self._options.make_jobs, target_dir_build_string)) # Try again with mma equivalent, which will build the dependencies run_command.RunCommand(alt_cmd, return_output=False, timeout_time=600) # Run mmm again to get the install paths only output = run_command.RunCommand(cmd, return_output=True, timeout_time=600) run_command.SetAbortOnError(False) logger.SilentLog(output) self._DoInstall(output, test_requires_permissions)
## 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. ## ## 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. ## ## 3. The name of the author may not be used to endorse or promote products derived from this software without specific prior written permission from the author. ## ## 4. Products derived from this software may not be called "pyTile" nor may "pyTile" appear in their names without specific prior written permission from the author. ## ## THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. import os, sys import pygame import random import logger debug = logger.Log() # Pre-compute often used multiples p = 64 p2 = p / 2 p4 = p / 4 p4x3 = p4 * 3 p8 = p / 8 p16 = p / 16 #tile height difference ph = 8 class TGrid(object): """Represents a tile's vertex height and can be used to modify that height"""
from bs4 import BeautifulSoup import gspread import json import logger import requests import time import quopri from inbox import Inbox from oauth2client.service_account import ServiceAccountCredentials log = logger.Log(__file__) ############ GSPREAD ############ GAPI_CREDENTIALS = "account_key.json" class SheetsAPI(): def __init__(self): # Use Google Sheets API's credentials.json to access services scope = [ 'https://spreadsheets.google.com/feeds', 'https://www.googleapis.com/auth/drive' ] creds = ServiceAccountCredentials.from_json_keyfile_name( GAPI_CREDENTIALS, scope) client = gspread.authorize(creds) self.sheet = client.open('Finance').worksheet("PetrolSF") # Returns previous mileage (most recent mileage in GSheet logs) def get_prev_mileage(self): last_row = self.next_available_row() - 1
if runtime_restart: self.SendShellCommand("setprop ro.test_harness 1", retry_count=retry_count) # manual rest bootcomplete flag self.SendShellCommand("setprop dev.bootcomplete 0", retry_count=retry_count) self.SendShellCommand("stop", retry_count=retry_count) try: output = self.SendCommand("sync", retry_count=retry_count) except errors.AbortError, e: error = e output = e.msg if "Read-only file system" in output: logger.SilentLog(output) logger.Log("Remounting read-only filesystem") self.SendCommand("remount") output = self.SendCommand("sync", retry_count=retry_count) elif "No space left on device" in output: logger.SilentLog(output) logger.Log("Restarting device runtime") self.SendShellCommand("stop", retry_count=retry_count) output = self.SendCommand("sync", retry_count=retry_count) self.SendShellCommand("start", retry_count=retry_count) elif error is not None: # exception occurred that cannot be recovered from raise error logger.SilentLog(output) if runtime_restart: # start runtime and wait till boot complete flag is set self.SendShellCommand("start", retry_count=retry_count)
#!/usr/bin/env python # -*- coding: utf-8 -*- import commands import logger import os import time log = logger.Log('INFO', os.path.split(__file__)[1]) screen_shot_path = os.path.join(os.getcwd(), 'screenshot') def check_devices(): cmd = commands.getstatusoutput('adb devices') result = cmd[1].split('\n') if len(result) <= 2: log.warn('There is no device connected currently, please check!') return False elif len(result) <= 3: phone_status = cmd[1].split('\n')[1].split('\t')[1] if phone_status != 'device': log.warn('Phone status is {' + phone_status + '}, connection is limited!') log.warn( 'Please replug the cable and confirm the notice of the phone!') return False else: return True else: for info in result: if info: log.info(' ' + info)
def Run(self, options, adb): """Run the provided *native* test suite. The test_suite must contain a build path where the native test files are. Subdirectories are automatically scanned as well. Each test's name must have a .cc or .cpp extension and match one of the following patterns: - test_* - *_test.[cc|cpp] - *_unittest.[cc|cpp] A successful test must return 0. Any other value will be considered as an error. Args: options: command line options adb: adb interface """ # find all test files, convert unicode names to ascii, take the basename # and drop the .cc/.cpp extension. source_list = [] build_path = os.path.join(android_build.GetTop(), self.GetBuildPath()) os.path.walk(build_path, self._CollectTestSources, source_list) logger.SilentLog("Tests source %s" % source_list) # Host tests are under out/host/<os>-<arch>/bin. host_list = self._FilterOutMissing(android_build.GetHostBin(), source_list) logger.SilentLog("Host tests %s" % host_list) # Target tests are under $ANDROID_PRODUCT_OUT/system/bin. target_list = self._FilterOutMissing(android_build.GetTargetSystemBin(), source_list) logger.SilentLog("Target tests %s" % target_list) # Run on the host logger.Log("\nRunning on host") for f in host_list: if run_command.RunHostCommand(f) != 0: logger.Log("%s... failed" % f) else: if run_command.HasValgrind(): if run_command.RunHostCommand(f, valgrind=True) == 0: logger.Log("%s... ok\t\t[valgrind: ok]" % f) else: logger.Log("%s... ok\t\t[valgrind: failed]" % f) else: logger.Log("%s... ok\t\t[valgrind: missing]" % f) # Run on the device logger.Log("\nRunning on target") for f in target_list: full_path = os.path.join(os.sep, "system", "bin", f) # Single quotes are needed to prevent the shell splitting it. output = adb.SendShellCommand("'%s 2>&1;echo -n exit code:$?'" % "(cd /sdcard;%s)" % full_path, int(options.timeout)) success = output.endswith("exit code:0") logger.Log("%s... %s" % (f, success and "ok" or "failed")) # Print the captured output when the test failed. if not success or options.verbose: pos = output.rfind("exit code") output = output[0:pos] logger.Log(output) # Cleanup adb.SendShellCommand("rm %s" % full_path)
def Run(self, options, adb): """Run the provided test suite. Builds up an adb instrument command using provided input arguments. Args: options: command line options to provide to test run adb: adb_interface to device under test Raises: errors.AbortError: if fatal error occurs """ test_class = self.GetClassName() if options.test_class is not None: test_class = options.test_class.lstrip() if test_class.startswith("."): test_class = self.GetPackageName() + test_class if options.test_method is not None: test_class = "%s#%s" % (test_class, options.test_method) test_package = self.GetJavaPackageFilter() if options.test_package: test_package = options.test_package if test_class and test_package: logger.Log( 'Error: both class and java package options are specified') instrumentation_args = {} if test_class is not None: instrumentation_args["class"] = test_class if test_package: instrumentation_args["package"] = test_package if options.test_size: instrumentation_args["size"] = options.test_size if options.wait_for_debugger: instrumentation_args["debug"] = "true" if options.suite_assign_mode: instrumentation_args["suiteAssignment"] = "true" if options.coverage: instrumentation_args["coverage"] = "true" if options.test_annotation: instrumentation_args["annotation"] = options.test_annotation if options.test_not_annotation: instrumentation_args["notAnnotation"] = options.test_not_annotation if options.preview: adb_cmd = adb.PreviewInstrumentationCommand( package_name=self.GetPackageName(), runner_name=self.GetRunnerName(), raw_mode=options.raw_mode, instrumentation_args=instrumentation_args) logger.Log(adb_cmd) elif options.coverage: coverage_gen = coverage.CoverageGenerator(adb) if not coverage_gen.TestDeviceCoverageSupport(): raise errors.AbortError adb.WaitForInstrumentation(self.GetPackageName(), self.GetRunnerName()) # need to parse test output to determine path to coverage file logger.Log("Running in coverage mode, suppressing test output") try: (test_results, status_map) = adb.StartInstrumentationForPackage( package_name=self.GetPackageName(), runner_name=self.GetRunnerName(), timeout_time=60 * 60, instrumentation_args=instrumentation_args) except errors.InstrumentationError, errors.DeviceUnresponsiveError: return self._PrintTestResults(test_results) device_coverage_path = status_map.get("coverageFilePath", None) if device_coverage_path is None: logger.Log("Error: could not find coverage data on device") return coverage_file = coverage_gen.ExtractReport( self, device_coverage_path, test_qualifier=options.test_size) if coverage_file is not None: logger.Log("Coverage report generated at %s" % coverage_file)
if launcher.VERSION == newest_version: self.log.debug(f"Up to date ({launcher.VERSION})") else: # out of date self.log.error( f"Out of date, newest version is {newest_version} (this is {launcher.VERSION})", reportable=False) # save available version for the launcher db: Dict[str, Union[bool, list, str]] = utils.access_db() db['available_version'] = newest_version utils.access_db(db) return newest_version, downloads_url, changelog_formatted def format_changelog(log_text: str) -> str: return f' {log_text}'.replace('## ', '').replace('\r\n', '\n').replace( '\n- ', '\n - ').replace('\n', '\n ') class RateLimitError(Exception): pass if __name__ == '__main__': update_checker = UpdateChecker(logger.Log()) update_checker.initiate_update_check(True, 10.0) while not update_checker.update_check_ready(): time.sleep(0.2) print(update_checker.receive_update_check())
def StartInstrumentation(self, instrumentation_path, timeout_time=60 * 10, no_window_animation=False, profile=False, instrumentation_args={}): """Runs an instrumentation class on the target. Returns a dictionary containing the key value pairs from the instrumentations result bundle and a list of TestResults. Also handles the interpreting of error output from the device and raises the necessary exceptions. Args: instrumentation_path: string. It should be the fully classified package name, and instrumentation test runner, separated by "/" e.g. com.android.globaltimelaunch/.GlobalTimeLaunch timeout_time: Timeout value for the am command. no_window_animation: boolean, Whether you want window animations enabled or disabled profile: If True, profiling will be turned on for the instrumentation. instrumentation_args: Dictionary of key value bundle arguments to pass to instrumentation. Returns: (test_results, inst_finished_bundle) test_results: a list of TestResults inst_finished_bundle (dict): Key/value pairs contained in the bundle that is passed into ActivityManager.finishInstrumentation(). Included in this bundle is the return code of the Instrumentation process, any error codes reported by the activity manager, and any results explicitly added by the instrumentation code. Raises: WaitForResponseTimedOutError: if timeout occurred while waiting for response to adb instrument command DeviceUnresponsiveError: if device system process is not responding InstrumentationError: if instrumentation failed to run """ command_string = self._BuildInstrumentationCommandPath( instrumentation_path, no_window_animation=no_window_animation, profile=profile, raw_mode=True, instrumentation_args=instrumentation_args) logger.Log(command_string) (test_results, inst_finished_bundle) = (am_instrument_parser.ParseAmInstrumentOutput( self.SendShellCommand(command_string, timeout_time=timeout_time, retry_count=2))) if "code" not in inst_finished_bundle: raise errors.InstrumentationError( "no test results... device setup " "correctly?") if inst_finished_bundle["code"] == "0": short_msg_result = "no error message" if "shortMsg" in inst_finished_bundle: short_msg_result = inst_finished_bundle["shortMsg"] logger.Log("Error! Test run failed: %s" % short_msg_result) raise errors.InstrumentationError(short_msg_result) if "INSTRUMENTATION_ABORTED" in inst_finished_bundle: logger.Log("INSTRUMENTATION ABORTED!") raise errors.DeviceUnresponsiveError return (test_results, inst_finished_bundle)
def DownloadData(count, table): #Ranking, Members, MedalRarity payload = {"api_key": c.api_key, "table": table, "count": count} r = requests.post(c.url_down, data=payload) logger.Log("Download " + str(count) + " " + table + ": " + r.text[:100]) return json.loads(r.text)