adb forward --list
        TODO: not tested
161305
def forward_list(self):
        '''
        
        '''
        version = self.version()
        if int(version[1]) <= 1 and int(version[2]) <= 0 and int(version[3]) < 31:
            raise EnvironmentError("Low adb version.")
        lines = self.run_cmd("forward", "--list").strip().splitlines()
        return [line.strip().split() for line in lines]
1245402
def DbGetDeviceExportedList(self, argin):
        
        self._log.debug("In DbGetDeviceExportedList()")
        argin = replace_wildcard(argin)
        return self.db.get_device_exported_list(argin)
1327213
def history_search_forward(self, e): # ()
        '''
        self.l_buffer=self._history.history_search_forward(self.l_buffer)
1002425
def list_():
    '''
    
    '''

    result = __salt__['cmd.run']('tuned-adm list').splitlines()
    # Remove "Available profiles:"
    result.pop(0)
    # Remove "Current active profile:.*"
    result.pop()
    # Output can be : " - <profile name> - <description>" (v2.7.1)
    # or " - <profile name> " (v2.4.1)
    result = [i.split('- ')[1].strip() for i in result]
    return result
1175189
def is_adb_detectable(self):
        """"""
        serials = list_adb_devices()
        if self.serial in serials:
            self.log.debug('Is now adb detectable.')
            return True
        return False
662618
function tryRunAdbReverse(device) {
  try {
    const adbPath = getAdbPath();
    const adbArgs = ['reverse', 'tcp:8081', 'tcp:8081'];

    // If a device is specified then tell adb to use it
    if (device) {
      adbArgs.unshift('-s', device);
    }

    console.log(chalk.bold(
      `Running ${adbPath} ${adbArgs.join(' ')}`
    ));

    child_process.execFileSync(adbPath, adbArgs, {
      stdio: [process.stdin, process.stdout, process.stderr],
    });
  } catch (e) {
    console.log(chalk.yellow(
      `Could not run adb reverse: ${e.message}`
    ));
  }
}
1130095
def _forward_iterator(self):
        ""
        path = [(self, 0, Bits())]
        while path:
            node, idx, prefix = path.pop()
            if idx==0 and node.value is not None and not node.prune_value:
                yield (self._unpickle_key(prefix), self._unpickle_value(node.value))
            if idx<len(node.children):
                path.append((node, idx+1, prefix))
                link = node.children[idx]
                if not link.pruned:
                    path.append((link.node, 0, prefix + link.prefix))
1242141
def devices(opts=[]):
    
    adb_full_cmd = [v.ADB_COMMAND_PREFIX, v.ADB_COMMAND_DEVICES, _convert_opts(opts)]
    return _exec_command(adb_full_cmd)
392740
def forwards(self, orm):
        ""
        from avocado.core import backup
        backup.safe_load(u'0002_avocado_metadata', backup_path=None,
            using='default')
795041
public String[] getLocalForwardings() {
		String[] r = new String[socketlisteners.size()];
		int index = 0;

		for (Enumeration<String> e = socketlisteners.keys(); e
				.hasMoreElements();) {
			r[index++] = e.nextElement();

		}
		return r;
	}
515916
public DeviceData[] get_command_specific_argument_list(final boolean fwd) throws DevFailed {
	final int al_size = get_size(fwd);
	final DeviceData[] al = new DeviceData[al_size];
	for (int i = 0; i < al_size; i++) {
	    al[i] = new DeviceData();
	}
	return al;
    }
133229
def forward_message(self, *args, **kwargs):
        """"""
        return forward_message(*args, **self._merge_overrides(**kwargs)).run()
902937
def forwards(self, orm):
        ""
        if not db.dry_run:
            for pl in orm['core.Placement'].objects.all():
                pl.listing_set.update(publishable=pl.publishable)
                publishable = pl.publishable
                publishable.publish_from = pl.publish_from
                publishable.static = pl.static
                publishable.publish_to = pl.publish_to
                publishable.save(force_update=True)
823259
def build_cmd(self, *args):
        '''
        '''
        return [self.adb(), "-s", self.serial] + self.adb_host_port_options + list(args)
936885
def adb_cmd(self, command, **kwargs):
        '''
        
        '''
        kwargs['timeout'] = kwargs.get('timeout', self._adb_shell_timeout)
        if isinstance(command, list) or isinstance(command, tuple):
            return self.adb_device.run_cmd(*list(command), **kwargs)
        return self.adb_device.run_cmd(command, **kwargs)
294369
def cmd_fw_list(self, args):
        ''''''
        stuff = self.filtered_rows_from_args(args)
        if stuff is None:
            return
        (filtered, remainder) = stuff
        print("")
        print(" seq platform frame    major.minor.patch releasetype latest git-sha format")
        for row in filtered:
            print("{seq:>5} {platform:<13} {frame:<10} {version:<10} {releasetype:<9} {latest:<6} {git-sha} {format}".format(**row))
1271657
def forwards(self, orm):
        ""
        orm['avocado.DataField'].objects.get_or_create(
            app_name='variants',
            model_name='variantphenotype',
            field_name='hgmd_id',
            defaults={
                'name': 'HGMD',
                'published': True
            })