)
    }
  }

  private fun assertData(hex: String) {
    assertData(hex.decodeHex())
  }

  private fun assertData(expected: ByteString) {
    val actual = data.readByteString(Math.min(expected.size.toLong(), data.size))
    assertThat(actual).isEqualTo(expected)
  }

  companion object {
    private fun binaryData(length: Int): ByteString {
      val junk = ByteArray(length)

                holder.resourceType);

        if (holder.allocationStackTrace != null) {
            StringBuilder sb = new StringBuilder("Allocation stack trace:\n");
            for (int i = 0; i < Math.min(10, holder.allocationStackTrace.length); i++) {
                sb.append("\tat ").append(holder.allocationStackTrace[i]).append("\n");
            }
            log.error(sb.toString());
        }
    }

    /**

                TimeUnit.MILLISECONDS);

        log.info("Authentication rate limiter initialized: maxAccount={}, maxIp={}, maxGlobal={}/min", maxAttemptsPerAccount,
                maxAttemptsPerIp, maxGlobalAttemptsPerMinute);
    }

    /**
     * Check if authentication attempt is allowed
     *

echo "done"

if [ ! -f ./mc ]; then
	echo -n "Downloading MinIO client ..."
	wget -O mc https://dl.min.io/client/mc/release/linux-amd64/mc &&
		chmod +x mc
	echo "done"
fi

export MC_HOST_minio1=https://minio:minio123@localhost:9001
export MC_HOST_minio2=https://minio:minio123@localhost:9002

    if (other.isEmpty()) {
      return other;
    } else {
      C lowerEndpoint = Ordering.<C>natural().max(this.first(), other.first());
      C upperEndpoint = Ordering.<C>natural().min(this.last(), other.last());
      return (lowerEndpoint.compareTo(upperEndpoint) <= 0)
          ? ContiguousSet.create(Range.closed(lowerEndpoint, upperEndpoint), domain)
          : new EmptyContiguousSet<C>(domain);
    }

            }

            long delay = initialDelayMs;
            for (int i = 1; i < attemptNumber; i++) {
                delay = (long) (delay * backoffMultiplier);
            }

            return Math.min(delay, maxDelayMs);
        }

        public int getMaxAttempts() {
            return maxAttempts;
        }

        public long getInitialDelayMs() {
            return initialDelayMs;
        }

        byte[] ipad = new byte[64];
        byte[] opad = new byte[64];

        // HMACT64 specific: truncate key to 64 bytes if needed
        int keyLen = Math.min(key.length, 64);
        for (int i = 0; i < keyLen; i++) {
            ipad[i] = (byte) (key[i] ^ 0x36);
            opad[i] = (byte) (key[i] ^ 0x5c);
        }
        for (int i = keyLen; i < 64; i++) {

      return origin.add(BigInteger.valueOf(distance));
    }

    @Override
    public long distance(BigInteger start, BigInteger end) {
      return end.subtract(start).max(MIN_LONG).min(MAX_LONG).longValue();
    }

    private Object readResolve() {
      return INSTANCE;
    }

    @Override
    public String toString() {
      return "DiscreteDomain.bigIntegers()";
    }

            if (text == null || text.isEmpty()) {
                return Collections.emptyList();
            }

            List<String> readings = new ArrayList<>();
            int limit = Math.min(langs.length, getMaxReadingNum());

            for (int i = 0; i < limit; i++) {
                readings.add(text.toUpperCase() + "_" + langs[i]);
            }

            return readings;
        }

        } else {
            flags2 &= 0xFFFF ^ SmbConstants.FLAGS2_SECURITY_SIGNATURES;
        }
        maxMpxCount = Math.min(maxMpxCount, server.maxMpxCount);
        if (maxMpxCount < 1) {
            maxMpxCount = 1;
        }
        snd_buf_size = Math.min(snd_buf_size, server.maxBufferSize);
        capabilities &= server.capabilities;