Matches both the subject and action, not necessarily the conditions.
180956
def is_relevant(self, action, subject):
        
        return self.matches_action(action) and self.matches_subject(subject)
70929
def is_within(self, query, subject):
        """"""
        if self.pt_within(query[0], subject) and self.pt_within(query[1], subject):
            return True

        return False
376527
public static <S> boolean the(S subject, Matcher<? super S> criteria) {
        return criteria.matches(subject);
    }
1030351
def is_required(action):
    '''
    
    '''
    return not isinstance(action, _SubParsersAction) and (
    action.required == True and action.nargs not in ['*', '?'])
687135
function(fact) {
        if ((this.explicit != fact.explicit) ||
            (this.subject != fact.subject) ||
            (this.predicate != fact.predicate) ||
            (this.object != fact.object)) {
            return false;
        }
        return true;
    }
881404
def valid(a, b):
    """"""
    return ~(np.isnan(a) | np.isinf(a) | np.isnan(b) | np.isinf(b))
895988
public boolean matches(T other) {
    if (matchAny) {
      return true;
    } else if (other == null) {
      return negation ? value != null : value == null;
    } else {
      if (value instanceof byte[]) {
        boolean equal = Arrays.equals((byte[]) value, (byte[]) other);
        return negation ? !equal : equal;
      }
      return negation ? !Objects.equals(value, other) : Objects.equals(value, other);
    }
267465
def matches(self, request):
        
        return (
            partial_path_match(request.path_info, self.path) and
            request.method == self.method
        )
102771
def action(self, target, message, formatted=True, tags=None):
        """"""
        if formatted:
            message = unescape(message)

        self.ctcp(target, 'ACTION', message)
186962
def is_not(self, other):
        
        self._run(unittest_case.assertIsNot, (self._subject, other))
        return ChainInspector(self._subject)
342204
def matches(self, other):
        
        return self.interaction == other.interaction and \
            self.direction != other.direction and \
            self.call_duration == other.call_duration and \
            abs((self.datetime - other.datetime).total_seconds()) < 30
1086952
function( name, actual, expected ) {
		var self = this, passed = true;

		try {
			self._objectMatch( actual, expected );
			passed = false;
		}
		catch ( e ) {
		}
		
		return self.ok( name, passed, self.notDeepEqual, 'Objects are not supposed to match' );
	}
568460
def match(self, dom, act):
        
        return self.match_domain(dom) and self.match_action(act)
957224
public <S,V> void when(S subject, Feature<? super S, V> feature, Ticker ticker, Matcher<? super V> criteria, Action<? super S> action) {
        waitUntil(subject, feature, ticker, criteria);
        action.actOn(subject);
    }
915229
def logical_and(self, other):
        """"""
        return self.operation(other, lambda x, y: int(x and y))
707273
def match_head(subject, pattern):
    """"""
    if isinstance(pattern, Pattern):
        pattern = pattern.expression
    pattern_head = get_head(pattern)
    if pattern_head is None:
        return True
    if issubclass(pattern_head, OneIdentityOperation):
        return True
    subject_head = get_head(subject)
    assert subject_head is not None
    return issubclass(subject_head, pattern_head)
1309231
private Decision evaluate(
            Map<String, String> resource, Subject subject,
            String action, Set<Attribute> environment, List<AclRule> matchedRules
    )
    {

        Decision decision = internalEvaluate(resource, subject, action, environment, matchedRules);
        if(decision.isAuthorized()) {
            logger.info(MessageFormat.format("Evaluating {0} ({1}ms)", decision, decision.evaluationDuration()));
        }else{
            logger.warn(MessageFormat.format("Evaluating {0} ({1}ms)", decision, decision.evaluationDuration()));
        }
        return decision;
    }