checks for the correct breakpoint against the mediaBreakpoints list
340626
function(width) {

			var foundBrkpt = false;

			// look for existing breakpoint based on width
			for (var i = 0; i < mediaBreakpoints.length; i++) {

				// if registered breakpoint found, break out of loop
				if (width >= mediaBreakpoints[i]['enter'] && width <= mediaBreakpoints[i]['exit']) {
					foundBrkpt = true;

					break;
				}
			}

			// if breakpoint is found and it's not the current one
			if (foundBrkpt && curr !== mediaBreakpoints[i]['label']) {
				prev = curr;
				curr = mediaBreakpoints[i]['label'];

				// run the loop
				cycleThrough();

			// or if no breakpoint applies
			} else if (!foundBrkpt && curr !== '') {
				curr = '';

				// run the loop
				cycleThrough();
			}

		}
1318848
private final static int onBreak(Frame frame) {
        // We always fall back to Debugger.CONTINUE after each onBreak to avoid eternal step-over flag
        //int oldReturn = onBreakReturn;
        //onBreakReturn = Debugger.CONTINUE;
        //return oldReturn;
        if (verbose) {
            logger.info("Continuing with "+(onBreakReturn==Debugger.CONTINUE?"continue":"step-over"));
        }
        return onBreakReturn;
    }
251474
def _check_boundaries(self, fragment):
        
        if not isinstance(fragment, SyncMapFragment):
            raise TypeError(u"fragment is not an instance of SyncMapFragment")
        interval = fragment.interval
        if not isinstance(interval, TimeInterval):
            raise TypeError(u"interval is not an instance of TimeInterval")
        if (self.begin is not None) and (interval.begin < self.begin):
            raise ValueError(u"interval.begin is before self.begin")
        if (self.end is not None) and (interval.end > self.end):
            raise ValueError(u"interval.end is after self.end")
315256
def should_recover(self):
        
        return (self.checkpoint_freq > 0
                and (self.num_failures < self.max_failures
                     or self.max_failures < 0))
594713
def get_breakpoints(self, lineno):
        """"""
        try:
            firstlineno, actual_lno = self.bdb_module.get_actual_bp(lineno)
        except BdbSourceError:
            return []
        if firstlineno not in self:
            return []
        code_bps = self[firstlineno]
        if actual_lno not in code_bps:
            return []
        return [bp for bp in sorted(code_bps[actual_lno],
                    key=attrgetter('number')) if bp.line == lineno]
424874
private boolean checkNeedCircuitBreak(Invoker<?> invoker, Invocation invocation) {
        String interfaceName = invoker.getUrl().getParameter(Constants.INTERFACE_KEY);
        String method = invocation.getMethodName();
        String methodKey = Config.getMethodPropertyName(invoker, invocation).toString();
        int limit = Config.getBreakLimit(invoker, invocation);
        BreakCounter breakCounter = breakCounterMap.get(methodKey);
        if(breakCounter!=null&&breakCounter.isEnable()){
            long currentExceptionCount = breakCounter.getCurrentExceptionCount();
            long currentBreakCount = breakCounter.getCurrentBreakCount();
            logger.info("[{}] check invoke [{}.{}] circuit break,current exception count [{}]  limit [{}]", localHost, interfaceName, method, currentExceptionCount, limit);
            if(limit<=currentExceptionCount){
                if(currentBreakCount>0&&needRetry(invoker, invocation, currentBreakCount)){
                    logger.info("[{}] retry invoke [{}.{}] current break count [{}]",localHost,interfaceName,method,currentBreakCount);
                    breakCounter.incrementRetryTimes();
                    return false;
                }
                return true;
            }
        }
        return false;
    }
307933
private void handleBreakpointHit(StackFrame frame, Context cx) {
        breakFlag = false;
        interrupted(cx, frame, null);
    }
670572
def is_break_tag(self, el):
        """"""

        name = el.name
        return name in self.break_tags or name in self.user_break_tags
681947
public boolean checkItemStatus(String listId, Integer mediaId) throws MovieDbException {
        return tmdbList.checkItemStatus(listId, mediaId);
    }
1332635
void triggerCheckpoint(boolean uncompressed) throws IOException {
    String pref = "Standby: Checkpoint - ";
    LOG.info(pref + "triggering checkpoint manually");

    // check error conditions
    if (uncompressed) {
      throwIOException(pref + " uncompressed option not supported", null);
    }
    if (manualCheckpointLatch.getCount() > 0) {
      throwIOException(pref + "Another manual checkpoint is in progress", null);
    }
    
    // set the manual checkpoint latch
    manualCheckpointLatch = new CountDownLatch(2);
    lastCheckpointTime = delayedScheduledCheckpointTime = 0;
    try {
      manualCheckpointLatch.await();
    } catch (InterruptedException e) {
      throwIOException(pref + "interrupted when performing manual checkpoint",
          e);
    }
    
    // check if checkpoint succeeded
    if (checkpointFailures > 0) {
      throwIOException(pref + "manual checkpoint failed", null);
    }
    LOG.info(pref + "manual checkpoint done");
  }
805830
def update_active_breakpoint_flag(cls):
        
        cls.any_active_breakpoint=any([bp.enabled for bp in cls.breakpoints_by_number if bp])
400874
def at_breakpoint(context, breakpoint)
      @pry.output.print Pry::Helpers::Text.bold("\nBreakpoint #{breakpoint.id}. ")
      @pry.output.puts  (breakpoint.hit_count == 1 ?
                           'First hit.' :
                           "Hit #{breakpoint.hit_count} times." )
      if (expr = breakpoint.expr)
        @pry.output.print Pry::Helpers::Text.bold("Condition: ")
        @pry.output.puts  expr
      end
    end
262036
public boolean isBreakpoint(Message aMessage, boolean isRequest, boolean onlyIfInScope) {
        if (aMessage.isForceIntercept()) {
            // The browser told us to do it Your Honour
            return true;
        }
        
        if (onlyIfInScope && ! aMessage.isInScope()) {
            return false;
        }
        
        if (isBreakOnAllRequests(aMessage, isRequest)) {
            // Break on all requests
            return true;
        } else if (isBreakOnAllResponses(aMessage, isRequest)) {
            // Break on all responses
            return true;
        } else if (isBreakOnStepping(aMessage, isRequest)) {
            // Stopping through all requests and responses
            return true;
        }
        
        return isBreakOnEnabledBreakpoint(aMessage, isRequest, onlyIfInScope);
    }
981545
def get_breaks_lno(self, filename):
        """"""
        return list(
            filter(
                lambda x: x is not None, [
                    getattr(breakpoint, 'line', None)
                    for breakpoint in self.breakpoints
                    if breakpoint.on_file(filename)
                ]
            )
        )
1338188
public function ListBreakpoints(\Google\Cloud\Debugger\V2\ListBreakpointsRequest $argument,
      $metadata = [], $options = []) {
        return $this->_simpleRequest('/google.devtools.clouddebugger.v2.Debugger2/ListBreakpoints',
        $argument,
        ['\Google\Cloud\Debugger\V2\ListBreakpointsResponse', 'decode'],
        $metadata, $options);
    }
1121378
function(elm) {
			var brkpt = elm['breakpoint'];
			var entr = elm['enter'] || undefined;

			// add function to stack
			mediaListeners.push(elm);

			// add corresponding entry to mediaInit
			mediaInit.push(false);

			if (testForCurr(brkpt)) {
				if (entr !== undefined) {
					entr.call(null, {entering : curr, exiting : prev});
				}
				mediaInit[(mediaListeners.length - 1)] = true;
			}
		}
795045
function registerBreakpoints(breakpoints) {
		let register = [];

		Object.keys(breakpoints).forEach(name => {
			register.push('(^' + escRgx(name) + '$)');
		});

		if (! register.length) {
			return false;
		}

		return new RegExp(register.join('|'));
	}