+ this
              + " to reach a terminal state. "
              + "Current state: "
              + state());
    }
  }

  /** Checks that the current state is equal to the expected state. */
  @GuardedBy("monitor")
  private void checkCurrentState(State expected) {
    State actual = state();
    if (actual != expected) {
      if (actual == FAILED) {

      }
    }

    @Override
    public void stopping(State from) {
      ServiceManagerState state = this.state.get();
      if (state != null) {
        state.transitionService(service, from, STOPPING);
      }
    }

    @Override
    public void terminated(State from) {
      ServiceManagerState state = this.state.get();
      if (state != null) {
        if (!(service instanceof NoOpService)) {

    state = STATE_WRITING_REQUEST_BODY
    return ChunkedSink()
  }

  private fun newKnownLengthSink(): Sink {
    check(state == STATE_OPEN_REQUEST_BODY) { "state: $state" }
    state = STATE_WRITING_REQUEST_BODY
    return KnownLengthSink()
  }

  private fun newFixedLengthSource(
    url: HttpUrl,
    length: Long,
  ): Source {
    check(state == STATE_OPEN_RESPONSE_BODY) { "state: $state" }

        // Utility class
    }

    /**
     * Check if state has read caching
     * @param state lease state
     * @return true if read caching is enabled
     */
    public static boolean hasReadCaching(int state) {
        return (state & SMB2_LEASE_READ_CACHING) != 0;
    }

    /**
     * Check if state has handle caching
     * @param state lease state
     * @return true if handle caching is enabled
     */

            // NOTE: Implementation behavior - custom predicate may not prevent all state changes
            // Skipping assertions that assume non-critical errors don't affect circuit state
            // as the actual implementation may handle this differently

            // Reset to ensure clean state for critical error test
            if (customCb.getState() != State.CLOSED) {
                customCb.reset();
            }

      <states>
        <state type="buildAddedToQueue" enabled="false" />
        <state type="buildRemovedFromQueue" enabled="true" />
        <state type="buildStarted" enabled="true" />
        <state type="changesLoaded" enabled="true" />
        <state type="buildInterrupted" enabled="true" />
        <state type="beforeBuildFinish" enabled="false" />
        <state type="buildFinished" enabled="true" />

        AggregateFutureState<?> state, @Nullable Set<Throwable> expect, Set<Throwable> update) {
      synchronized (state) {
        if (state.seenExceptionsField == expect) {
          state.seenExceptionsField = update;
        }
      }
    }

    @Override
    int decrementAndGetRemainingCount(AggregateFutureState<?> state) {
      synchronized (state) {
        return --state.remainingField;
      }

}

func (s *Stack) File() string {
	return s.Base().Filename()
}

func (s *Stack) Base() *src.PosBase {
	return s.tr[len(s.tr)-1].Base()
}

func (s *Stack) SetBase(base *src.PosBase) {
	s.tr[len(s.tr)-1].SetBase(base)
}

func (s *Stack) Line() int {
	return s.tr[len(s.tr)-1].Line()
}

func (s *Stack) Col() int {
	return s.tr[len(s.tr)-1].Col()
}

func (s *Stack) Close() { // Unused.

        State currentState = state.get();

        if (currentState == State.OPEN && shouldAttemptReset()) {
            transitionTo(State.HALF_OPEN);
            currentState = State.HALF_OPEN;
        }

        if (currentState == State.OPEN) {
            throw new CircuitOpenException("Circuit breaker '" + name + "' is open");
        }

    checkState(state != State.FAILED);
    switch (state) {
      case DONE:
        return false;
      case READY:
        return true;
      default:
    }
    return tryToComputeNext();
  }

  private boolean tryToComputeNext() {
    state = State.FAILED; // temporary pessimism
    next = computeNext();
    if (state != State.DONE) {
      state = State.READY;
      return true;
    }