If the route coverage lookup encounters an error, we will treat it as "not covered".
505501
def routeCoverage(self, msisdn):
        
        content = self.parseRest(self.request('rest/coverage/' + str(msisdn)))

        return {
            'routable': content['routable'],
            'destination': content['destination'].encode('utf-8'),
            'charge': float(content['minimumCharge'])
        }
927068
def record_coverage_zero(self, rule, offset):
        """"""
        self.coverage_lines.append('DA:{},0'.format(rule.source_line + offset))
138619
private void onError(ErrorCode errorCode, String moreDetail) {
    startGoAway(0, errorCode, toGrpcStatus(errorCode).augmentDescription(moreDetail));
  }
595560
def url_should_not_contain(self, url):
    """"""

    if url in world.browser.current_url:
        raise AssertionError(
            "Browser URL expected not to contain {!r}, got {!r}.".format(
                url, world.browser.current_url))
1304772
function unsecuredRoute(seneca, options, context, method, middleware, route) {
  const routeArgs = [route.path].concat(middleware).concat([
    (request, reply, next) => {
      handleRoute(seneca, options, request, reply, route, next)
    }
  ])

  context[method].apply(context, routeArgs)
}
1365354
def _FileFetchFailed(self, index, request_name):
    """"""

    pathspec, request_data = self._RemoveCompletedPathspec(index)

    # Report the request_data for this flow's caller.
    self.FileFetchFailed(pathspec, request_name, request_data=request_data)
1286
function ignoreMatch(ignores, pathName) {
    let result = false;

    ignores.forEach(ignore => {
        if (minimatch(pathName, ignore)) {
            result = true;
        }
    });

    return result;
}
1248544
function _onError (err) {
  if (err.status === 404 || err.statusCode === 404 || err.expose) return

  let msg = err.stack || err.toString()

  console.error(`\n${msg.replace(/^/gm, '   ')}\n`)
}
852744
def can_ignore_error(self, reqhnd=None):
        
        value = sys.exc_info()[1]
        try:
            if isinstance(value, BrokenPipeError) or \
                    isinstance(value, ConnectionResetError):
                return True
        except NameError:
            pass
        if not self.done:
            return False
        if not isinstance(value, socket.error):
            return False
        need_close = value.errno == 9
        if need_close and reqhnd is not None:
            reqhnd.close_connection = 1
        return need_close
844878
protected void onRouteDispatch(Request request, Response response) {
        final String requestPath = request.getPath();
        final String requestMethod = request.getMethod();

        if (shouldIgnorePath(requestPath)) {
            // NOT FOUND (404)
            RouteContext routeContext = routeContextFactory.createRouteContext(application, request, response, noMatches);
            ROUTE_CONTEXT_THREAD_LOCAL.set(routeContext);
            errorHandler.handle(HttpServletResponse.SC_NOT_FOUND, routeContext);
            ROUTE_CONTEXT_THREAD_LOCAL.remove();
            log.debug("Returned status code {} for {} '{}' (IGNORED)", response.getStatus(), requestMethod, requestPath);

            return;
        }

        List<RouteMatch> routeMatches = router.findRoutes(requestMethod, requestPath);
        RouteContext routeContext = routeContextFactory.createRouteContext(application, request, response, routeMatches);
        ROUTE_CONTEXT_THREAD_LOCAL.set(routeContext);

        try {
            if (routeMatches.isEmpty()) {
                if (notFoundRouteHandler != null) {
                    notFoundRouteHandler.handle(routeContext);
                } else {
                    // NOT FOUND (404)
                    errorHandler.handle(HttpConstants.StatusCode.NOT_FOUND, routeContext);
                }
            } else {
                processFlash(routeContext);
            }

            // execute the chain
            routeContext.next();

            if (!response.isCommitted()) {
                if (response.getStatus() == 0) {
                    log.debug("Status code not set for {} '{}'", requestMethod, requestPath);
                    response.notFound();
                }
                log.debug("Auto-committing response for {} '{}'", requestMethod, requestPath);
                if (response.getStatus() >= HttpServletResponse.SC_BAD_REQUEST) {
                    // delegate response to the error handler.
                    // this will generate response content appropriate for the request
                    errorHandler.handle(response.getStatus(), routeContext);
                } else {
                    response.commit();
                }
            }
        } catch (Exception e) {
            errorHandler.handle(e, routeContext);
        } finally {
            routeContext.runFinallyRoutes();
            log.debug("Returned status code {} for {} '{}'", response.getStatus(), requestMethod, requestPath);
            ROUTE_CONTEXT_THREAD_LOCAL.remove();
        }
    }
960322
def _check_response_for_request_errors(self):
        
        if self.response.HighestSeverity == "ERROR":
            for notification in self.response.Notifications:  # pragma: no cover
                if notification.Severity == "ERROR":
                    if "Postal Code Not Found" in notification.Message:
                        raise FedexPostalCodeNotFound(notification.Code,
                                                      notification.Message)

                    elif "Invalid Postal Code Format" in self.response.Notifications:
                        raise FedexInvalidPostalCodeFormat(notification.Code,
                                                           notification.Message)
                    else:
                        raise FedexError(notification.Code,
                                         notification.Message)
523575
function (config) {
        if (typeof config !== 'object') {
            throw new Error('Invalid Route Config');
        }
        if (typeof config.route !== 'string') {
            var name_1 = config.name || '(no name)';
            throw new Error('Invalid Route Config for "' + name_1 + '": You must specify a "route:" pattern.');
        }
        if (!('redirect' in config || config.moduleId || config.navigationStrategy || config.viewPorts)) {
            throw new Error('Invalid Route Config for "' + config.route + '": You must specify a "moduleId:", "redirect:", "navigationStrategy:", or "viewPorts:".');
        }
    }
692377
def notFound(self):
        """"""
        fmt = 'The path <q>%s</q> was not understood by this server.'
        msg = fmt % (self.path,)
        openid_url = self.query.get('openid_identifier')
        self.render(msg, 'error', openid_url, status=404)
624944
def has_error(self):
        
        return next(
            (True for cr in self.component_results
             if cr.has_error()),
            False
        )
932505
function( name, value, match ) {
		var self = this,
			result = munit.isError( value ) ?
				self._errorMatch( value, match ) :
				{ passed: false, extra: "Value is not an Error '" + value + "'" };

		return self.ok( name, result.passed, self.isError, result.extra );
	}
76368
function coverage(data, type) {
  var comparisionFunc;
  var n = 0;

  function isCovered(val) {
    return (val > 0);
  }

  function isMissed(val) {
    return !isCovered(val);
  }

  if (type === 'covered') {
    comparisionFunc = isCovered;
  }
  else if (type === 'missed') {
    comparisionFunc = isMissed;
  }
  else {
    throw new Error('Invalid type: ' + type);
  }

  var len = Object.keys(data.lines).length;

  for (var i = 0; i < len; ++i) {
    if (data.lines[i] !== null && comparisionFunc(data.lines[i])) {
      ++n;
    }
  }

  return n;
}
590175
function onChildRoutes(error, childRoutes) {
      if (error) {
        callback(error);
      } else if (childRoutes) {
        // Check the child routes to see if any of them match.
        matchRoutes(childRoutes, location, function (error, match) {
          if (error) {
            callback(error);
          } else if (match) {
            // A child route matched! Augment the match and pass it up the stack.
            match.routes.unshift(route);
            callback(null, match);
          } else {
            callback();
          }
        }, remainingPathname, paramNames, paramValues);
      } else {
        callback();
      }
    }