Returns true if this condition is compatible with the given test case properties.
A condition is <em>"compatible"</em> with these properties if it is already satisfied
or if it could be satisfied with the addition of more properties.
180113
public boolean compatible( PropertySet properties)
    {
    boolean isCompatible;
    Iterator<ICondition> conditions;
    
    for( conditions = getConditions(),
           isCompatible = !conditions.hasNext();

         !isCompatible
           && conditions.hasNext();

         isCompatible = conditions.next().compatible( properties));
    
    return isCompatible;
    }
446725
def _is_type_compatible(a, b):
    """"""
    is_ts_compat = lambda x: isinstance(x, (Timestamp, DateOffset))
    is_td_compat = lambda x: isinstance(x, (Timedelta, DateOffset))
    return ((is_number(a) and is_number(b)) or
            (is_ts_compat(a) and is_ts_compat(b)) or
            (is_td_compat(a) and is_td_compat(b)) or
            com._any_none(a, b))
765077
def _is_compatible_with(self, other):
        

        title = self._compare_title(other)
        suffix = self._compare_suffix(other)

        return title and suffix
829202
private boolean containsIgnoreCase(List<String> stringlist, String match) {
		for (String s : stringlist) {
			if (s.equalsIgnoreCase(match)) {
				return true;
			}
		}
		return false;
	}
717596
private static boolean isEqualWithMatching(final Object option, final Object data) {
		return Util.equals(option, data) || isOptionCodeMatch(option, data) || isLegacyMatch(option,
				data);
	}
1259822
public boolean isSupported(TypeDesc propertyType) {
        if (propertyType.toPrimitiveType() != null) {
            return true;
        }
        if (propertyType == TypeDesc.STRING || propertyType == TypeDesc.forClass(byte[].class)) {
            return true;
        }
        Class clazz = propertyType.toClass();
        if (clazz != null) {
            return Lob.class.isAssignableFrom(clazz) ||
                BigInteger.class.isAssignableFrom(clazz) ||
                BigDecimal.class.isAssignableFrom(clazz);
        }
        return false;
    }
1220390
public boolean isMultiInstance() {
    Boolean isMultiInstance = (Boolean) getProperty(BpmnParse.PROPERTYNAME_IS_MULTI_INSTANCE);
    return Boolean.TRUE.equals(isMultiInstance);
  }
488968
public static boolean satisfiesSome( IConjunct condition, PropertySet properties)
    {
    boolean satisfies;
    Iterator<IDisjunct> disjuncts;
    for( disjuncts = condition.getDisjuncts(),
           satisfies = !disjuncts.hasNext();
         
         !satisfies
           && disjuncts.hasNext();

         satisfies = disjuncts.next().satisfied( properties));

    return satisfies;
    }
372814
@Override
	public boolean satisfies(Match match, int... ind)
	{
		return generate(match, ind).contains(match.get(ind[ind.length - 1]));
	}
1193092
@Override
	public boolean satisfies(Match match, int... ind)
	{
		assertIndLength(ind);

		return con.generate(match, ind).isEmpty();
	}
546025
protected boolean checkCondition(TestContext context) {
        if (conditionExpression != null) {
            return conditionExpression.evaluate(index, context);
        }

        // replace dynamic content with each iteration
        String conditionString = condition;
        if (conditionString.indexOf(Citrus.VARIABLE_PREFIX + indexName + Citrus.VARIABLE_SUFFIX) != -1) {
            Properties props = new Properties();
            props.put(indexName, String.valueOf(index));
            conditionString = new PropertyPlaceholderHelper(Citrus.VARIABLE_PREFIX, Citrus.VARIABLE_SUFFIX).replacePlaceholders(conditionString, props);
        }

        conditionString = context.replaceDynamicContentInString(conditionString);

        if (ValidationMatcherUtils.isValidationMatcherExpression(conditionString)) {
            try {
                ValidationMatcherUtils.resolveValidationMatcher("iteratingCondition", String.valueOf(index), conditionString, context);
                return true;
            } catch (AssertionError e) {
                return false;
            }
        }

        if (conditionString.indexOf(indexName) != -1) {
            conditionString = conditionString.replaceAll(indexName, String.valueOf(index));
        }

        return BooleanExpressionParser.evaluate(conditionString);
    }
1035374
private boolean shouldIgnoreCase(final Part part) {
		final Class<?> propertyClass = part.getProperty().getLeafProperty().getType();
		final boolean isLowerable = String.class.isAssignableFrom(propertyClass);
		final boolean shouldIgnoreCase = part.shouldIgnoreCase() != Part.IgnoreCaseType.NEVER && isLowerable
				&& !UNSUPPORTED_IGNORE_CASE.contains(part.getType());
		if (part.shouldIgnoreCase() == Part.IgnoreCaseType.ALWAYS
				&& (!isLowerable || UNSUPPORTED_IGNORE_CASE.contains(part.getType()))) {
			LOGGER.debug("Ignoring case for \"{}\" type is meaningless", propertyClass);
		}
		return shouldIgnoreCase;
	}
569412
@Override
    public boolean isCapabilitySatisfied(Collection<ProvisioningFeatureDefinition> featureDefinitionsToCheck) {
        // If it isn't an autofeature, it's satisfied.
        if (!iAttr.isAutoFeature)
            return true;

        if (mfDetails == null)
            throw new IllegalStateException("Method called outside of provisioining operation or without a registered service");

        boolean isCapabilitySatisfied = true;

        Iterator<Filter> iter = mfDetails.getCapabilityFilters().iterator();
        Set<ProvisioningFeatureDefinition> satisfiedFeatureDefs = new HashSet<ProvisioningFeatureDefinition>();

        // Now we need to iterate over each of the filters, until we find we don't have a match.
        while (iter.hasNext() && isCapabilitySatisfied) {
            Filter checkFilter = iter.next();
            Iterator<ProvisioningFeatureDefinition> featureDefIter = featureDefinitionsToCheck.iterator();

            // Now for each filter, iterate over each of the FeatureDefinition headers, checking to see if we have a match.
            boolean featureMatch = false;
            while (featureDefIter.hasNext() && !featureMatch) {
                ProvisioningFeatureDefinition featureDef = featureDefIter.next();

                // If we've already satisfied a capability with this FeatureDefinition, we don't need to use it again
                if (!satisfiedFeatureDefs.contains(featureDef)) {

                    // We have a mismatch between the key the filter is using to look up the feature name and the property containing the name in the
                    // headers. So we need to add a new property for osgi.identity (filter key) that contains the value of the 
                    // Subsystem-SymbolicName (manifest header).
                    // We also have to do this for the Subsystem-Type(manifest header) and the type (filter key).
                    Map<String, String> filterProps = new HashMap<String, String>();

                    filterProps.put(FeatureDefinitionUtils.FILTER_FEATURE_KEY, featureDef.getSymbolicName());
                    try {
                        filterProps.put(FeatureDefinitionUtils.FILTER_TYPE_KEY,
                                        mfDetails.getMainAttributeValue(FeatureDefinitionUtils.TYPE));
                    } catch (IOException e) {
                        // We should be well beyond any IOException issues.. 
                        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                            Tr.debug(tc, "IOException reading manifest attribute from {0}: {1}", iAttr.featureFile, e);
                        }
                        continue;
                    }

                    if (checkFilter.matches(filterProps)) {
                        satisfiedFeatureDefs.add(featureDef);
                        featureMatch = true;
                    }
                }
            }
            // Once we've checked all the FeatureDefinitions, apply the result to the isCapabilitySatisfied boolean, 
            // so we stop processing as soon as we know we don't have a match.
            isCapabilitySatisfied = featureMatch;
        }

        return isCapabilitySatisfied;
    }
289628
def is_compatible(self):
        """"""
        for pattern in OPTIONS['compatible_patterns']:
            if fnmatch(self.package.lower(), pattern):
                return True
        return False
322506
public synchronized boolean compatible(List<PType> to, List<PType> from)
	{
		done.clear();
		return allCompatible(to, from, false) == Result.Yes;
	}
419972
public boolean compatible( PropertySet properties)
    {
    boolean isCompatible;
    Iterator<IDisjunct> disjuncts;
    
    for( disjuncts = getDisjuncts(),
           isCompatible = true;
           

         isCompatible
           && disjuncts.hasNext();

         isCompatible = disjuncts.next().compatible( properties));
    
    return isCompatible;
    }
1212477
public boolean satisfied( PropertySet properties)
    {
    boolean isSatisfied;
    Iterator<ICondition> conditions;
    
    for( conditions = getConditions(),
           isSatisfied = true;
           

         isSatisfied
           && conditions.hasNext();

         isSatisfied = !conditions.next().satisfied( properties));
    
    return isSatisfied;
    }