mock adapter only supports exact match
195350
function(collection, options, cb) {
    var ids = [];
    var keys = _.isFunction(collection.url) ? collection.url() : collection.url;
    keys += options.keys;
    debug('findKeys', keys);
    this.store().getItem(keys, function(err, data) {
      if (data) ids.push(keys);
      cb(null, ids);
    });
  }
40581
private static Class<?> getArgumentType(ArgumentMatcher<?> argumentMatcher) {
        Method[] methods = argumentMatcher.getClass().getMethods();

        for (Method method : methods) {
            if (isMatchesMethod(method)) {
                return method.getParameterTypes()[0];
            }
        }
        throw new NoSuchMethodError("Method 'matches(T)' not found in ArgumentMatcher: " + argumentMatcher + " !\r\n Please file a bug with this stack trace at: https://github.com/mockito/mockito/issues/new ");
    }
12144
def matchesEachOf(cntxt: Context, T: RDFGraph, expr: ShExJ.EachOf, _: DebugContext) -> bool:
    

    return EachOfEvaluator(cntxt, T, expr).evaluate(cntxt)
1332003
def hook_into test_framework
      adapter = self.class.adapters[test_framework]
      raise ArgumentError.new "No adapter for test framework #{test_framework}" if adapter.nil?
      require adapter
    end
1149420
public char match(ISense source, ISense target) throws MatcherLibraryException {
        List<String> sourceLemmas = source.getLemmas();
        List<String> targetLemmas = target.getLemmas();
        for (String sourceLemma : sourceLemmas) {
            for (String targetLemma : targetLemmas) {
                if (sourceLemma.equals(targetLemma)) {
                    return IMappingElement.EQUIVALENCE;
                }
            }
        }
        return IMappingElement.IDK;
    }
590217
public boolean filterMatches(AbstractItem item)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "filterMatches", item);

    /* Cast the incoming item to a PersistentStoreReferenceStream object. if it is not, an
     * exception will be thrown and the match will fail */

    SIMPReferenceStream rstream;

    if (item instanceof SIMPReferenceStream) {

      rstream = (SIMPReferenceStream) item;
    
      // Check for matching consumer dispatchers
      if (rstream == consumerDispatcher.getReferenceStream())
      {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
          SibTr.exit(tc, "filterMatches", Boolean.TRUE);        
        return true;
      }      
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "filterMatches", Boolean.FALSE);
    return false;

  }
1314584
public ResultMatcher isNotEqualTo(final Object expected) {
        return new AbstractResultMatcher(path, configuration) {
            public void doMatch(Object actual) {
                Diff diff = createDiff(expected, actual);
                if (diff.similar()) {
                    failWithMessage("JSON is equal.");
                }
            }
        };
    }
274494
protected Description matchNewClassOrMethodInvocation(ExpressionTree tree, VisitorState state) {
    Description description = checkClosed(tree, state);
    if (description == NO_MATCH) {
      return NO_MATCH;
    }
    if (AbstractReturnValueIgnored.expectedExceptionTest(tree, state)
        || MOCKITO_MATCHER.matches(state.getPath().getParentPath().getLeaf(), state)) {
      return NO_MATCH;
    }
    return description;
  }
384303
def _assoc_prop_matches(prop, ref_classname,
                            assoc_classes, result_classes, result_role):
        
        assert prop.type == 'reference'

        if assoc_classes and ref_classname not in assoc_classes:
            return False
        if result_classes and prop.reference_class not in result_classes:
            return False
        if result_role and prop.name.lower() != result_role:
            return False
        return True
719668
public final AbstractItem matches(final Filter filter, boolean allowUnavailable) throws SevereMessageStoreException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "matches", new Object[] { filter, Boolean.valueOf(allowUnavailable) });

        AbstractItem foundItem = null;
        if (allowUnavailable || isAvailable())
        {
            if (!isExpired())
            {
                AbstractItem item = getItem();
                if (null == item)
                {
                    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                        SibTr.debug(this, tc, "item does not exist");
                }
                else
                {
                    try
                    {
                        if (null == filter || filter.filterMatches(item))
                        {
                            foundItem = item;
                        }
                    } catch (Exception e)
                    {
                        //No FFDC Code Needed.
                        // assume exception is false return
                    }
                }
            }
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "matches", foundItem);
        return foundItem;
    }
64067
def match(tgt, opts=None):
    '''
    
    '''

    if not opts:
        opts = __opts__
    try:
        if ',' + opts['id'] + ',' in tgt \
                or tgt.startswith(opts['id'] + ',') \
                or tgt.endswith(',' + opts['id']):
            return True
        # tgt is a string, which we know because the if statement above did not
        # cause one of the exceptions being caught. Therefore, look for an
        # exact match. (e.g. salt -L foo test.ping)
        return opts['id'] == tgt
    except (AttributeError, TypeError):
        # tgt is not a string, maybe it's a sequence type?
        try:
            return opts['id'] in tgt
        except Exception:
            # tgt was likely some invalid type
            return False

    # We should never get here based on the return statements in the logic
    # above. If we do, it is because something above changed, and should be
    # considered as a bug. Log a warning to help us catch this.
    log.warning(
        'List matcher unexpectedly did not return, for target %s, '
        'this is probably a bug.', tgt
    )
    return False
830251
private static Object tryHandleEqualsMethod(MockInvocation mockInvocation) {

        // Fix for Issue http://code.google.com/p/powermock/issues/detail?id=88
        // For some reason the method call to equals() on final methods is
        // intercepted and during the further processing in Mockito the same
        // equals() method is called on the same instance. A StackOverflowError
        // is the result. The following fix changes this by checking if the
        // method to be called is a final equals() method. In that case the
        // original method is called by returning PROCEED.

        if (mockInvocation.getMethod().getParameterTypes().length == 1
                    && mockInvocation.getMethod().getParameterTypes()[0] == Object.class
                    && Modifier.isFinal(mockInvocation.getMethod().getModifiers())) {
            return PROCEED;
        }

        if (calledFromMockito()){
            return PROCEED;
        }

        return null;
    }
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' );
	}
1033456
public void expectExactMatch(String name, String anotherName) {
        expectExactMatch(name, anotherName, messages.get(Validation.EXACT_MATCH_KEY.name(), name, anotherName));
    }
1281727
function getMock(config) {
				for (var i = 0; i < mocks.length; i++) {
					if (isMatch(config, mocks[i].config)) {
						return mocks[i];
					}
				}
				return undefined;
			}
830098
def _find_adapter(registry, ob):
    """"""
    types = _always_object(inspect.getmro(getattr(ob, '__class__', type(ob))))
    for t in types:
        if t in registry:
            return registry[t]
730507
function (root, componentType) {
    var all = ReactTestUtils.scryRenderedComponentsWithType(root, componentType);
    if (all.length !== 1) {
      throw new Error('Did not find exactly one match (found: ' + all.length + ') ' + 'for componentType:' + componentType);
    }
    return all[0];
  }