*/
  private static final class LinearCongruentialGenerator {
    private long state;

    LinearCongruentialGenerator(long seed) {
      this.state = seed;
    }

    double nextDouble() {
      state = 2862933555777941757L * state + 1;
      return ((double) ((int) (state >>> 33) + 1)) / 0x1.0p31;
    }
  }

  private Hashing() {}

ue,\"truncate\":100},\"title\":{}}],\"valueAxes\":[{\"id\":\"ValueAxis-1\",\"name\":\"LeftAxis-1\",\"type\":\"value\",\"position\":\"left\",\"show\":true,\"style\":{},\"scale\":{\"type\":\"linear\",\"mode\":\"normal\"},\"labels\":{\"show\":true,\"rotate\":0,\"filter\":false,\"truncate\":100},\"title\":{\"text\":\"Query Count\"}}],\"seriesParams\":[{\"show\":\"true\",\"type\":\"histogram\",\"mode\":\"stacked\",\"data\":{\"label\":\"Query Count\",\"id\":\"1\"},\"valueAxis\":\"ValueAxis-1\",\"drawL...

                                                key="labels.user_state"/></label>
                                        <div class="col-sm-9">
                                            <la:errors property="attributes.state"/>

    // NPE on null listener, so we propagate that contract up into the add method as well.
    checkNotNull(runnable, "Runnable was null.");
    checkNotNull(executor, "Executor was null.");

    // Lock while we check state. We must maintain the lock while adding the new pair so that
    // another thread can't run the list out from under us. We only add to the list if we have not
    // yet started execution.
    synchronized (this) {

        this.scheduler = Executors.newScheduledThreadPool(1, r -> {
            Thread t = new Thread(r, "PersistentHandleManager");
            t.setDaemon(true);
            return t;
        });

        // Create state directory for persistent storage
        String stateDir = System.getProperty("jcifs.smb.client.handleStateDirectory");
        if (stateDir == null) {
            String homeDir = System.getProperty("user.home");

        Smb2LeaseKey key2 = leaseManager.requestLease(path, requestedState);

        assertEquals(key1, key2);
    }

    @Test
    @DisplayName("Should update lease state")
    void testUpdateLease() {
        String path = "/share/file.txt";
        int requestedState = Smb2LeaseState.SMB2_LEASE_FULL;
        int grantedState = Smb2LeaseState.SMB2_LEASE_READ_WRITE;

    void awaitWaiting() {
      while (!isBlocked()) {
        if (getState() == State.TERMINATED) {
          throw new RuntimeException("Thread exited");
        }
        Thread.yield();
      }
    }

    private boolean isBlocked() {
      return getState() == Thread.State.WAITING && LockSupport.getBlocker(this) == future;
    }
  }

  // Lazily initialized the first time we see an exception; not released until all the input futures
  // & this future completes. Released when the future releases the reference to the running state
  private @Nullable Set<Throwable> seenExceptions = null;
  private int remaining;

  AggregateFutureState(int remainingFutures) {
    this.remaining = remainingFutures;
  }

# This script will run inside ubuntu-pod that is located at default namespace in the cluster
# This script will not and should not be executed in the self hosted runner

echo "script failed" >resiliency-initial.log # assume initial state

echo "sleep to wait for MinIO Server to be ready prior mc commands"
# https://github.com/minio/mc/issues/3599

MINIO_SERVER_URL="http://127.0.0.1:9000"
ALIAS_NAME=myminio
BUCKET="test-bucket"
SRC_DIR="/tmp/data"

        char ch;
        int i, j, state, len;
        char[] out;
        byte[] b = new byte[1];

        if (str == null) {
            return null;
        }

        len = str.length();
        out = new char[len];
        state = 0;
        for (i = j = 0; i < len; i++) {
            switch (state) {
            case 0:
                ch = str.charAt(i);