Returns true if the specified exception is a clock skew error.

@param exception The exception to test.
@return True if the exception resulted from a clock skews error message from a service, otherwise false.
487306
public static boolean isClockSkewError(SdkBaseException exception) {
        return isAse(exception) && CLOCK_SKEW_ERROR_CODES.contains(toAse(exception).getErrorCode());
    }
112319
@SuppressWarnings("unchecked")
    private boolean hasExceptionOnStack() {
        try {
            for (int i = 0; i < (stack.getStackDepth() - 1); i++) {
                OpcodeStack.Item item = stack.getStackItem(i);
                String sig = item.getSignature();
                if (sig.startsWith(Values.SIG_QUALIFIED_CLASS_PREFIX)) {
                    String name = SignatureUtils.stripSignature(sig);
                    JavaClass cls = Repository.lookupClass(name);
                    if (cls.instanceOf(throwableClass)) {
                        return true;
                    }
                } else if (sig.startsWith(Values.SIG_ARRAY_PREFIX)) {
                    LOUserValue<Integer> uv = (LOUserValue<Integer>) item.getUserValue();
                    if ((uv != null) && (uv.getType() == LOUserValue.LOType.ARRAY_SIZE)) {
                        Integer sz = uv.getValue();
                        if ((sz != null) && (sz.intValue() < 0)) {
                            return true;
                        }
                    }
                }
            }
            return false;
        } catch (ClassNotFoundException cnfe) {
            bugReporter.reportMissingClass(cnfe);
            return true;
        }
    }
8961
public boolean isExceptionToday() {
        if (daysOfWeek != null && daysOfWeek.length > 0) {
            int dayOfWeekNow = Calendar.getInstance().get(Calendar.DAY_OF_WEEK);
            for (int exceptionDay : daysOfWeek) {
                if (exceptionDay == dayOfWeekNow) {
                    return true;
                }
            }
        }
        return false;
    }
98478
private boolean ackNoException(Channel consumerChannel, boolean msgApplied, final long deliveryTag) {
        try {
            if (msgApplied) {
                //设置multiple为true，经过压测发现有一定几率ack出现ioException的情况，这里顺带把前面的消息一起ack掉
                consumerChannel.basicAck(deliveryTag, true);
            } else {
                consumerChannel.basicNack(deliveryTag, false, true);
            }
            return true;
        } catch (Throwable unknownException) {
            LOG.error(unknownException);
            return false;
        }
    }
942737
public boolean containsExplicitExceptions() {
        for (ThrownExceptionIterator i = iterator(); i.hasNext();) {
            i.next();
            if (i.isExplicit()) {
                return true;
            }
        }
        return false;
    }
780884
private void checkAndPropagateAsyncError() throws Exception {
		if (thrownException != null) {
			String errorMessages = "";
			if (thrownException instanceof UserRecordFailedException) {
				List<Attempt> attempts = ((UserRecordFailedException) thrownException).getResult().getAttempts();
				for (Attempt attempt: attempts) {
					if (attempt.getErrorMessage() != null) {
						errorMessages += attempt.getErrorMessage() + "\n";
					}
				}
			}
			if (failOnError) {
				throw new RuntimeException("An exception was thrown while processing a record: " + errorMessages, thrownException);
			} else {
				LOG.warn("An exception was thrown while processing a record: {}", thrownException, errorMessages);

				// reset, prevent double throwing
				thrownException = null;
			}
		}
	}
57442
public boolean ioError(Throwable throwable) {
    if (throwable instanceof IOException || throwable instanceof IOError) {
      return true;
    }
    return throwable.getCause() != null && ioError(throwable.getCause());
  }
1298425
public boolean isExceptionMatched(AnalyzedToken token) {
    if (exceptionSet) {
      for (PatternToken testException : exceptionList) {
        if (!testException.exceptionValidNext) {
          if (testException.isMatched(token)) {
            return true;
          }
        }
      }
    }
    return false;
  }
436914
@Override
    public void notifyException(Throwable exception)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "notifyException", new Object[] { this, exception });

        // If an asynch consumer is registered we need to let them know something went wrong
        if (_asynchConsumerRegistered)
            _asynchConsumer.notifyExceptionListeners(exception, _consumerSession);

        this.lock();
        try
        {
            if (_waiting)
            {
                // We need to get the exception back to the synchronous consumer
                _notifiedException = exception;
                _waiter.signal();
            }
        } finally
        {
            this.unlock();
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "notifyException");
    }
1361211
public boolean isExceptionAtThisTime() {
        Time now = new Time();
        for (TimeSpan span : timesOfDay) {
            if (span.isWithin(now)) {
                return true;
            }
        }
        return false;
    }
183806
public boolean checkResponseForException() {
    if (!finished && rsp != null) {
      Exception e;
      if ((e = rsp.getException()) != null) {
        setError(e.getMessage());
        setFinished();
        return true;
      }
    }
    return false;
  }
527395
def check_for_message_exception(cls, message_result):
        
        exception = message_result.exception

        if isinstance(exception, BaseException):
            raise exception
980455
public static boolean report(WsRuntimeFwException ex) {
        if (ex.reported) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "previously reported exception", new Exception(ex));
            }
            return false;
        }

        ex.reported = true;
        return true;
    }
1153998
public static boolean hasException(List<TraceEvent> events)
   {
      for (TraceEvent te : events)
      {
         if (te.getType() == TraceEvent.EXCEPTION)
            return true;
      }

      return false;
   }
1286615
@Override
    public boolean canRetry(Throwable exception) {
        if (exception == null) {
            return false;
        }

        Class<? extends Throwable> exceptionClass = exception.getClass();
        if (hasIncludes && !includes.contains(exceptionClass)) {
            return false;
        } else if (hasExcludes && excludes.contains(exceptionClass)) {
            return false;
        } else {
            return this.attemptNumber.incrementAndGet() < (maxAttempts + 1) && ((maxDelay == null) || overallDelay.get() < maxDelay.toMillis());
        }
    }
1161682
private boolean isExceptionEdge(Edge edge) {
        boolean isExceptionEdge = edge.isExceptionEdge();
        if (isExceptionEdge) {
            if (DEBUG) {
                System.out.println("NOT Ignoring " + edge);
            }
            return true; // false
        }
        if (edge.getType() != EdgeTypes.FALL_THROUGH_EDGE) {
            return false;
        }
        InstructionHandle h = edge.getSource().getLastInstruction();
        return h != null
            && h.getInstruction() instanceof IFNONNULL
            && isNullCheck(h, methodGen.getConstantPool());
    }
20099
private int onException(Exception e) throws IOException {
        eofReached = true;
        if (e instanceof IOException) {
            throw (IOException) e;
        } else if (e instanceof RuntimeException) {
            throw (RuntimeException) e;
        } else {
            // Impossible since InputStream throws no other checked exceptions.
            throw Throwables.failure(e);
        }
    }