drop the requireFailure link. it does not remove the link on the other recognizer.
@param {Recognizer} otherRecognizer
@returns {Recognizer} this
978271
function(otherRecognizer) {
        if (invokeArrayArg(otherRecognizer, 'dropRequireFailure', this)) {
            return this;
        }

        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
        var index = inArray(this.requireFail, otherRecognizer);
        if (index > -1) {
            this.requireFail.splice(index, 1);
        }
        return this;
    }
622993
protected void tryToRemoveAlpnNegotiator(ThirdPartyAlpnNegotiator negotiator, SSLEngine engine, SSLConnectionLink link) {
        // the Java 9 and IBM JSSE ALPN implementations don't use a negotiator object
        if (negotiator == null && isNativeAlpnActive()) {
            getNativeAlpnChoice(engine, link);
        } else if (negotiator == null && isIbmAlpnActive()) {
            getAndRemoveIbmAlpnChoice(engine, link);
        } else if (negotiator != null && isJettyAlpnActive() && negotiator instanceof JettyServerNegotiator) {
            ((JettyServerNegotiator) negotiator).removeEngine();
        } else if (negotiator != null && isGrizzlyAlpnActive() && negotiator instanceof GrizzlyAlpnNegotiator) {
            ((GrizzlyAlpnNegotiator) negotiator).removeServerNegotiatorEngine();
        }
    }
11600
def unlink(self, *others):
        
        if not len(others):
            others = self.links[:]
        for p in self.links[:]:
            if p in others:
                p.teardown()
        return self
937463
function() {
        var i = 0;
        while (i < this.requireFail.length) {
            if (!(this.requireFail[i].state & (STATE_FAILED | STATE_POSSIBLE))) {
                return false;
            }
            i++;
        }
        return true;
    }
382702
void removeMember(MemberImpl member) {
        heartbeatFailureDetector.remove(member);
        if (icmpParallelMode) {
            icmpFailureDetector.remove(member);
        }
    }
1087086
def require_that guard, message, return_guard = false
      if not guard then
        raise ExpectationFailedError.new(message)
      end
      if return_guard == true then
        guard
      elsif return_guard != false then
        return_guard
      end
    end
203555
function WatsonVisualRecognitionV3Node(config) {
    var node = this,
      b = false,
      feature = '';

    RED.nodes.createNode(this, config);
    node.config = config;

    node.on('input', function(msg) {
      var params = {};

      node.status({});

      verifyPayload(msg)
        .then(function() {
          return verifyFeatureMode(node, msg, config);
        })
        .then(function(f) {
          feature = f;
          return checkForStream(msg);
        })
        .then(function() {
          return verifyInputs(feature, msg);
        })
        .then(function() {
          return determineEndpoint(config);
        })
        .then(function() {
          return verifyServiceCredentials(node, msg);
        })
        .then(function() {
          return execute(feature, params, node, msg);
        })
        .then(function() {
          temp.cleanup();
          node.status({});
          node.send(msg);
        })
        .catch(function(err) {
          payloadutils.reportError(node, msg, err);

          msg.result = {};
          msg.result['error'] = err;
          // Note: This node.send forwards the error to the next node,
          // if this isn't desired then this line needs to be removed.
          // Should be ok as the node.error would already have recorded
          // the error in the debug console.
          temp.cleanup();
          node.send(msg);
        });
    });
  }
1250951
function(recognizer) {
        if (recognizer instanceof Recognizer) {
            return recognizer;
        }

        var recognizers = this.recognizers;
        for (var i = 0; i < recognizers.length; i++) {
            if (recognizers[i].options.event == recognizer) {
                return recognizers[i];
            }
        }
        return null;
    }
254087
public AppValidator failsWith(String expectedFailure) {
        stringsToFind.add(expectedFailure);
        stringsToFind.add(APP_FAIL_CODE);
        server.addIgnoredErrors(Collections.singletonList(expectedFailure));
        return this;
    }
1193815
public void unregisterComponent(java.awt.Component c)
    {
        java.awt.dnd.DragGestureRecognizer recognizer = 
            (java.awt.dnd.DragGestureRecognizer)this.hmDragGestureRecognizers.remove(c);
        if (recognizer != null)
            recognizer.setComponent(null);
    }
7659
@Override public void reduce(DeepLearningTask other){
    if (_localmodel != null && other._localmodel != null && other._localmodel.get_processed_local() > 0 //other DLTask was active (its model_info should be used for averaging)
        && other._localmodel != _localmodel) //other DLTask worked on a different model_info
    {
      // avoid adding remote model info to unprocessed local data, still random
      // (this can happen if we have no chunks on the master node)
      if (_localmodel.get_processed_local() == 0) {
        _localmodel = other._localmodel;
        _chunk_node_count = other._chunk_node_count;
      } else {
        _localmodel.add(other._localmodel);
        _chunk_node_count += other._chunk_node_count;
      }
      if (other._localmodel.isUnstable()) _localmodel.setUnstable();
    }
  }
51968
function (channelIdentifier, triggerIdentifier) {
      var path;
      if (channelIdentifier && triggerIdentifier) {
        path = this.constructPath(constants.CHANNELS, channelIdentifier, constants.TRIGGERS, triggerIdentifier);
        return this.Core.DELETE(path);
      } else {
        return this.rejectRequest('Bad Request: A channel identifier and a trigger identifier are required.');
      }
    }
438262
def delete(self, href=None):
        
        if self.is_fake:
            return

        if href is None:
            self.collection.delete()
            return

        item = self.get(href)
        if item is None:
            raise ComponentNotFoundError(href)

        item.etesync_item.delete()
959479
function(otherRecognizer) {
        if (invokeArrayArg(otherRecognizer, 'requireFailure', this)) {
            return this;
        }

        var requireFail = this.requireFail;
        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
        if (inArray(requireFail, otherRecognizer) === -1) {
            requireFail.push(otherRecognizer);
            otherRecognizer.requireFailure(this);
        }
        return this;
    }
1111910
def fail(self, reason, obj, pointer=None):
        
        pointer = pointer_join(pointer)
        err = ValidationError(reason, obj, pointer)
        if self.fail_fast:
            raise err
        else:
            self.errors.append(err)
        return err
1224169
function failWrapper(msg, mode) {
  gT.l.fail(msg);
  if (mode && mode.accName) {
    mode.accName = false; // eslint-disable-line no-param-reassign
  }
}
1003651
function(imageIdentifier, shortUrl, callback) {
        var id = shortUrl instanceof ShortUrl ? shortUrl.getId() : shortUrl,
            url = this.getImageUrl(imageIdentifier).setPath('/shorturls/' + id),
            signed = this.getSignedResourceUrl('DELETE', url);

        request.del(signed, callback);
        return this;
    }