/**
     * Gets the registration state.
     *
     * @return the current registration state
     */
    public WitnessRegistrationState getState() {
        return state;
    }

    /**
     * Sets the registration state.
     *
     * @param state the new registration state
     */
    public void setState(WitnessRegistrationState state) {
        this.state = state;
    }

    /**

            /* This guarantees that we leave in a valid state
             */
            if (state != 0 && state != 3 && state != 4) {
                if (LogStream.level >= 1) {
                    log.println("Invalid state: " + state);
                }
                state = 0;
                thread = null;
            }
        }
    }

    /**
     * Disconnects from the remote endpoint.
     *

     */
    public boolean isDisconnected() {
        return this.state == 4 || this.state == 5 || this.state == 6 || this.state == 0;
    }

    /**
     * Checks if the transport is in a failed state.
     *
     * @return whether the transport is marked failed
     */
    public boolean isFailed() {
        return this.state == 5 || this.state == 6;
    }

    /**

        } catch (Exception e) {
            state = RdmaConnectionState.ERROR;
            throw new IOException("DiSNI RDMA send failed", e);
        }
    }

    @Override
    public ByteBuffer receive(int timeout) throws IOException {
        if (state != RdmaConnectionState.ESTABLISHED && state != RdmaConnectionState.CONNECTED) {

              + 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) {

    assertEquals(Service.State.RUNNING, service.state());

    exitRun.countDown(); // the service will exit voluntarily
    executionThread.join();

    assertTrue(service.shutDownCalled);
    assertEquals(Service.State.TERMINATED, service.state());

    service.stopAsync().awaitTerminated(); // no-op
    assertEquals(Service.State.TERMINATED, service.state());
    assertTrue(service.shutDownCalled);
  }

        assertEquals("success", result);
        assertEquals(SimpleCircuitBreaker.State.CLOSED, circuitBreaker.getState());

        SimpleCircuitBreaker.Statistics stats = circuitBreaker.getStatistics();
        assertEquals(1, stats.totalCalls);
        assertEquals(1, stats.totalSuccesses);
        assertEquals(0, stats.totalFailures);
        assertEquals(1.0, stats.successRate);
    }

    @Test

    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;
    }

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

@DisplayName("Smb2LeaseState Tests")
class Smb2LeaseStateTest {

    @Test
    @DisplayName("Should define correct lease state constants")
    void testLeaseStateConstants() {
        assertEquals(0x00, Smb2LeaseState.SMB2_LEASE_NONE);
        assertEquals(0x01, Smb2LeaseState.SMB2_LEASE_READ_CACHING);

    assertThat(manager.servicesByState().keySet()).containsExactly(Service.State.FAILED);
  }

  private static void assertState(
      ServiceManager manager, Service.State state, Service... services) {
    Collection<Service> managerServices = manager.servicesByState().get(state);
    for (Service service : services) {
      assertEquals(service.toString(), state, service.state());