Identifies if the current VM has a native support for multidex, meaning there is no need for
additional installation by this library.

@return true if the VM handles multidex
763030
private static boolean isVMMultidexCapable() {
        boolean isMultidexCapable = false;
        String vmName = null;

        try {
            if (isYunOS()) {    // YunOS需要特殊判断
                vmName = "'YunOS'";
                isMultidexCapable = Integer.valueOf(System.getProperty("ro.build.version.sdk")) >= 21;
            } else {    // 非YunOS原生Android
                vmName = "'Android'";
                String versionString = System.getProperty("java.vm.version");
                if (versionString != null) {
                    Matcher matcher = Pattern.compile("(\\d+)\\.(\\d+)(\\.\\d+)?").matcher(versionString);
                    if (matcher.matches()) {
                        try {
                            int major = Integer.parseInt(matcher.group(1));
                            int minor = Integer.parseInt(matcher.group(2));
                            isMultidexCapable = (major > VM_WITH_MULTIDEX_VERSION_MAJOR)
                                    || ((major == VM_WITH_MULTIDEX_VERSION_MAJOR)
                                    && (minor >= VM_WITH_MULTIDEX_VERSION_MINOR));
                        } catch (NumberFormatException ignore) {
                            // let isMultidexCapable be false
                        }
                    }
                }
            }
        } catch (Exception ignore) {

        }

        Log.i(Consts.TAG, "VM with name " + vmName + (isMultidexCapable ? " has multidex support" : " does not have multidex support"));
        return isMultidexCapable;
    }
48704
public static boolean JVMSupportsLargeMappedFiles() {
        String arch = System.getProperty("os.arch");
        if(arch==null || !arch.contains("64")) {
            return false;
        }

        if(isWindows())
            return false;

        //TODO better check for 32bit JVM
        return true;
    }
973446
public boolean hasCheckMultiActions() {

        Iterator<CmsListMultiAction> it = m_multiActions.elementList().iterator();
        while (it.hasNext()) {
            CmsListMultiAction action = it.next();
            if (!(action instanceof CmsListRadioMultiAction)) {
                return true;
            }
        }
        return false;
    }
239016
def has_fast_mps_support():
    
    lib = _load_tcmps_lib()
    if lib is None:
        return False

    c_bool = _ctypes.c_bool()
    ret = lib.TCMPSHasHighPowerMetalDevice(_ctypes.byref(c_bool))
    return ret == 0 and c_bool.value
404383
def is_multidex(self):
        
        dexre = re.compile("^classes(\d+)?.dex$")
        return len([instance for instance in self.get_files() if dexre.search(instance)]) > 1
610857
public boolean isLowOnResources()
    {
        int spare=getMaxThreads()-getThreads();
        int lr = _lowResources>0?_lowResources:getMinThreads();
        boolean low = (spare+getIdleThreads())<lr;
        
        if (low && !_isLow)
        {
            log.info("LOW ON THREADS (("+
                      getMaxThreads()+"-"+
                      getThreads()+"+"+
                      getIdleThreads()+")<"+
                      getMinThreads()+") on "+ this);
            _warned=System.currentTimeMillis();
            _isLow=true;
        }
        else if (!low && _isLow)
        {
            if (System.currentTimeMillis()-_warned > 1000)
            {
                _isOut=false;
                _isLow=false;
            }
        }
        return low;
    }
1076252
public boolean isTeiidSupport() {
        String result = properties.getProperty(LocalJcrDriver.TEIID_SUPPORT_PROPERTY_NAME);
        if (result == null) {
            return false;
        }
        return result.equalsIgnoreCase(Boolean.TRUE.toString());
    }
912245
@SuppressWarnings("StringEquality")
    public boolean isUnix() {
        return platform == OS_LINUX || platform == OS_SOLARIS || platform == OS_BSD
                || platform == OS_AIX || platform == OS_HP_UX;
    }
979640
private boolean
findSunJVM() {
	List lserver = new ArrayList(0);
	List lserver_tmp;
	List lsearch = new ArrayList(0);
	List lsearch_tmp;

	try {
		Class [] noClasses = new Class[0];
		Object [] noObjects = new Object[0];
		String resConfName = "sun.net.dns.ResolverConfiguration";
		Class resConfClass = Class.forName(resConfName);
		Object resConf;

		// ResolverConfiguration resConf = ResolverConfiguration.open();
		Method open = resConfClass.getDeclaredMethod("open", noClasses);
		resConf = open.invoke(null, noObjects);

		// lserver_tmp = resConf.nameservers();
		Method nameservers = resConfClass.getMethod("nameservers",
							    noClasses);
		lserver_tmp = (List) nameservers.invoke(resConf, noObjects);

		// lsearch_tmp = resConf.searchlist();
		Method searchlist = resConfClass.getMethod("searchlist",
							    noClasses);
		lsearch_tmp = (List) searchlist.invoke(resConf, noObjects);
	}
	catch (Exception e) {
		return false;
	}

	if (lserver_tmp.size() == 0)
		return false;

	if (lserver_tmp.size() > 0) {
		Iterator it = lserver_tmp.iterator();
		while (it.hasNext())
			addServer((String) it.next(), lserver);
	}

	if (lsearch_tmp.size() > 0) {
		Iterator it = lsearch_tmp.iterator();
		while (it.hasNext())
			addSearch((String) it.next(), lsearch);
	}
	configureFromLists(lserver, lsearch);
	return true;
}
1262718
public static boolean hasMultiPart(ParamConfig[] paramConfigs){
        for(ParamConfig cfg : paramConfigs){
            if(hasMultiPart(cfg.getMetaDatas())) {
                return true;
            }
        }
        return false;
    }
90686
private boolean isMultiplication() {

        return (is(TokenType.STAR, true) || is("div", true) || is("idiv", true) || is("mod", true));

    }
96344
private boolean containsIncompatibleResourceType() {
    if (queryByResourceType && queryByPermission) {
      Resource[] resources = resourcesIntersection.toArray(new Resource[resourcesIntersection.size()]);
      return !ResourceTypeUtil.resourceIsContainedInArray(resourceType, resources);
    }
    return false;
  }
613440
public boolean isPushSupported() {
    String version = android.os.Build.VERSION.RELEASE.substring(0, 3);
    return (Double.valueOf(version) >= MIN_SUPPORTED_ANDRIOD_VERSION);
  }
211025
private boolean distinctVMStates() {

        boolean ok = vms.size() == running.size() + sleeping.size() + ready.size() + killed.size();


        //It is sure there is no solution as a VM cannot have multiple destination state
        Map<VM, VMState> states = new HashMap<>();
        for (VM v : running) {
            states.put(v, VMState.RUNNING);
        }
        for (VM v : ready) {
            VMState prev = states.put(v, VMState.READY);
            if (prev != null) {
                getLogger().debug("multiple destination state for {}: {} and {}", v, prev, VMState.READY);
            }
        }
        for (VM v : sleeping) {
            VMState prev = states.put(v, VMState.SLEEPING);
            if (prev != null) {
                getLogger().debug("multiple destination state for {}: {} and {}", v, prev, VMState.SLEEPING);
            }
        }
        for (VM v : killed) {
            VMState prev = states.put(v, VMState.KILLED);
            if (prev != null) {
                getLogger().debug("multiple destination state for {}: {} and {}", v, prev, VMState.KILLED);
            }
        }
        return ok;
    }
748547
public boolean isSupported(Jid jid) throws SmackException, XMPPException, InterruptedException {
        return ServiceDiscoveryManager.getInstanceFor(connection()).supportsFeature(jid,
                        DeliveryReceipt.NAMESPACE);
    }
1082082
public static function isUnix() : bool
    {
        // Return the cached result if it's already available.
        if (null !== static::$type) {
            return static::$type === self::TYPE_UNIX;
        }

        return static::getType() === self::TYPE_UNIX;
    }
953876
public boolean isSupported(ICalVersion version) {
		for (ICalVersion supportedVersion : supportedVersions) {
			if (supportedVersion == version) {
				return true;
			}
		}
		return false;
	}