Try to transition to (satisfied and !expired) state
@return true if the transition to (satisfied and !expired) was successful
777682
public boolean satisfy(SIMPMessage msg)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "satisfy");

    if (expiryHandle != null)
      expiryHandle.cancel();
    if (!expired)
    {
      satisfied = true;
      this.msg = msg;
      
      if (TraceComponent.isAnyTracingEnabled() && UserTrace.tc_mt.isDebugEnabled())    
        SibTr.debug(UserTrace.tc_mt,       
           nls_mt.getFormattedMessage(
           "REMOTE_REQUEST_SATISFIED_CWSJU0032",
           new Object[] {
             Long.valueOf(tick),
             msg},
           null));
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "satisfy", new Boolean(satisfied));

    return satisfied;
  }
837555
public boolean checkRepeatMove ()
    {
        long now = System.currentTimeMillis();
        if (now - _lastRequestTime < STALE_REQUEST_DURATION) {
            return true;

        } else {
            _lastRequestTime = now;
            return false;
        }
    }
410890
boolean isDeadEnd(Set<NFAState<T>> nfaSet)
    {
        for (Set<Transition<NFAState<T>>> set : transitions.values())
        {
            for (Transition<NFAState<T>> t : set)
            {
                if (!nfaSet.contains(t.getTo()))
                {
                    return false;
                }
            }
        }
        return true;
    }
230983
def handle_lock_expired(
        target_state: TargetTransferState,
        state_change: ReceiveLockExpired,
        channel_state: NettingChannelState,
        block_number: BlockNumber,
) -> TransitionResult[TargetTransferState]:
    """"""
    result = channel.handle_receive_lock_expired(
        channel_state=channel_state,
        state_change=state_change,
        block_number=block_number,
    )
    assert result.new_state, 'handle_receive_lock_expired should not delete the task'

    if not channel.get_lock(result.new_state.partner_state, target_state.transfer.lock.secrethash):
        transfer = target_state.transfer
        unlock_failed = EventUnlockClaimFailed(
            identifier=transfer.payment_identifier,
            secrethash=transfer.lock.secrethash,
            reason='Lock expired',
        )
        result.events.append(unlock_failed)
        return TransitionResult(None, result.events)

    return TransitionResult(target_state, result.events)
583735
public boolean isExpired() {
		if (getTimestamp() == null || getExpiresAfter() == 0) {
			return false;
		}
		long expires = (getExpiresAfter() * 1000);
		long now = Utils.timestamp();
		return (getTimestamp() + expires) <= now;
	}
1218755
@Override
  public boolean isFuture()
  {
    ResultChain<T> result = _result;

    return result.isFuture() && method().isDirect();
  }
843365
@Override
    public ExitStatus afterStep(StepExecution stepExecution) {
        ExitStatus status = stepExecution.getExitStatus();
        List<String> errors = getErrors();
        if (errors.size() > 0) {
            status = status.and(ExitStatus.FAILED);
            for (String error : errors) {
                status = status.addExitDescription(error);
            }

            resetContextState();
            stepExecution.upgradeStatus(BatchStatus.FAILED);
            stepExecution.setTerminateOnly();
            log.error("manifest verification finished: step_execution_id={} " +
                      "job_execution_id={} restore_id={} exit_status=\"{}\"",
                      stepExecution.getId(),
                      stepExecution.getJobExecutionId(),
                      restorationId,
                      status);

        } else {
            log.info("manifest verification finished:step_execution_id={} " +
                     "job_execution_id={} restore_id={} exit_status=\"{}\"",
                     stepExecution.getId(),
                     stepExecution.getJobExecutionId(),
                     restorationId,
                     status);

            status = status.and(ExitStatus.COMPLETED);
        }

        return status;
    }
221268
private boolean jobHasFinishedStatus() {

		final Iterator<ExecutionVertex> it = new ExecutionGraphIterator(this, true);

		while (it.hasNext()) {

			if (it.next().getExecutionState() != ExecutionState.FINISHED) {
				return false;
			}
		}

		return true;
	}
576364
public boolean isFinished() {
    // If we have a HandshakeResult, we are done.
    if (result != null) {
      return true;
    }
    // If we have an error status, we are done.
    if (status != null && status.getCode() != Status.Code.OK.value()) {
      return true;
    }
    return false;
  }
809575
function () {
        var pending = this._pending,
            done = this._done,
            a,
            b;
        while (0 !== pending.length) {
            b = pending.pop();
            a = pending.pop();
            done.push(a, b);
            if (this._areDifferent(a, b)) {
                return false;
            }
        }
        return true;
    }
885787
public final boolean isStarted() {

        String thisMethodName = "isStarted";

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.entry(tc, thisMethodName, this);
        }

        boolean retVal = (_state == STATE_STARTED);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.exit(tc, thisMethodName, Boolean.toString(retVal));
        }

        return retVal;
    }
893907
public synchronized void checkNotExpired() {
        if (Utils.currentTimeSeconds() > getExpiryTime()) {
            stateMachine.transition(State.EXPIRED);
            disconnectFromChannel();
            throw new IllegalStateException("Channel expired");
        }
    }
1249867
public boolean process()
	{
		boolean continueIterate = true;
		boolean found = false;
		String attempt = getCurrentAttempt();
		while (continueIterate)
		{
			if (attempt.equals(toCheckAgainst))
			{
				found = true;
				break;
			}
			attempt = getCurrentAttempt();
			continueIterate = increment();
		}
		return found;
	}
426001
public boolean expired(int expiration) {
        if (null == cliContext) {
            return true;
        }
        if ((daemon || cliContext.inProgress()) && !cliContext.disconnected()) {
            return false;
        }
        long l = expiration * 1000;
        return l < ($.ms() - ts);
    }
133811
protected void verifyStatusTransitionIsValid(JobInstanceEntity instance, BatchStatus toStatus) throws BatchIllegalJobStatusTransitionException {

        switch (instance.getBatchStatus()) {
            case COMPLETED:
                //COMPLETED to ABANDONED is allowed since it's already allowed in released TCK tests.
                if (toStatus == BatchStatus.ABANDONED) {
                    break;
                }
            case ABANDONED:
                throw new BatchIllegalJobStatusTransitionException("Job instance: " + instance.getInstanceId()
                                                                   + " cannot be transitioned from Batch Status: " + instance.getBatchStatus().name()
                                                                   + " to " + toStatus.name());
            case STARTING:
            case STARTED:
            case STOPPING:
            case FAILED:

            default:
        }

    }
956505
private void transitionToFinalBatchStatus() {
        StopLock stopLock = getStopLock(); // Store in local variable to facilitate Ctrl+Shift+G search in Eclipse
        synchronized (stopLock) {

            BatchStatus currentBatchStatus = runtimeWorkUnitExecution.getBatchStatus();
            if (currentBatchStatus.equals(BatchStatus.STARTED)) {
                updateJobBatchStatus(BatchStatus.COMPLETED);
            } else if (currentBatchStatus.equals(BatchStatus.STOPPING)) {
                updateJobBatchStatus(BatchStatus.STOPPED);
            } else if (currentBatchStatus.equals(BatchStatus.FAILED)) {
                updateJobBatchStatus(BatchStatus.FAILED); // Should have already been done but maybe better for possible code refactoring to have it here.
            } else {
                throw new IllegalStateException("Step batch status should not be in a " + currentBatchStatus.name() + " state");
            }
        }
    }
13369
public boolean isTerminated() {
        return this.currentState == COMPLETED || this.currentState == REJECTED || this.currentState == CANCELLED
                || this.currentState == FAILED || this.currentState == REDIRECT;
    }