}.also { expected ->
      assertThat(expected.message!!).contains("closed")
    }
  }

  private fun binaryData(length: Int): ByteString {
    val junk = ByteArray(length)
    random.nextBytes(junk)
    return junk.toByteString()
  }

    byte[] bytes = newPreFilledByteArray(1024);

    // Setup
    File file = createTempFile();
    Files.write(bytes, file);

    Random random = new Random();
    random.nextBytes(expectedBytes);

    // Test
    MappedByteBuffer map = Files.map(file, MapMode.READ_WRITE);
    map.put(expectedBytes);

    // Verify
    byte[] actualBytes = Files.toByteArray(file);

    private final byte[] key;  // 16-byte lease key
    private static final SecureRandom random = new SecureRandom();
    
    public Smb2LeaseKey() {
        this.key = new byte[16];
        random.nextBytes(this.key);
    }
    
    public Smb2LeaseKey(byte[] key) {
        if (key.length != 16) {
            throw new IllegalArgumentException("Lease key must be 16 bytes");
        }

    // total overkill, but, it takes 0.1 sec so why not...
    for (int i = 0; i < 10000; i++) {
      int num = r.nextInt();
      assertThat(Ints.fromByteArray(Ints.toByteArray(num))).isEqualTo(num);

      r.nextBytes(b);
      assertThat(Ints.toByteArray(Ints.fromByteArray(b))).isEqualTo(b);
    }
  }

  public void testEnsureCapacity() {
    assertThat(Ints.ensureCapacity(EMPTY, 0, 1)).isSameInstanceAs(EMPTY);

  private var awaitingPong = false

  init {
    require("GET" == originalRequest.method) {
      "Request must be GET: ${originalRequest.method}"
    }

    this.key = ByteArray(16).apply { random.nextBytes(this) }.toByteString().base64()
  }

  override fun request(): Request = originalRequest

  @Synchronized override fun queueSize(): Long = queueSize

  override fun cancel() {
    call!!.cancel()
  }

    byte[] bytes = newPreFilledByteArray(1024);

    // Setup
    File file = createTempFile();
    Files.write(bytes, file);

    Random random = new Random();
    random.nextBytes(expectedBytes);

    // Test
    MappedByteBuffer map = Files.map(file, MapMode.READ_WRITE);
    map.put(expectedBytes);

    // Verify
    byte[] actualBytes = Files.toByteArray(file);

     * @return random key bytes
     */
    public byte[] generateRandomKey(int length) {
        checkNotClosed();

        byte[] key = new byte[length];
        secureRandom.nextBytes(key);
        return key;
    }

    /**
     * Clear all stored keys
     */
    public void clearAllKeys() {
        checkNotClosed();

        log.info("Clearing all stored keys");

    byte[] b = new byte[Longs.BYTES];

    for (int i = 0; i < 1000; i++) {
      long num = r.nextLong();
      assertThat(Longs.fromByteArray(Longs.toByteArray(num))).isEqualTo(num);

      r.nextBytes(b);
      long value = Longs.fromByteArray(b);
      assertWithMessage("" + value).that(Arrays.equals(b, Longs.toByteArray(value))).isTrue();
    }
  }

  public void testEnsureCapacity() {

    for (int i = 0; i < 10000; i++) {
      short num = (short) r.nextInt();
      assertThat(Shorts.fromByteArray(Shorts.toByteArray(num))).isEqualTo(num);

      r.nextBytes(b);
      assertThat(Shorts.toByteArray(Shorts.fromByteArray(b))).isEqualTo(b);
    }
  }

  public void testEnsureCapacity() {
    assertThat(Shorts.ensureCapacity(EMPTY, 0, 1)).isSameInstanceAs(EMPTY);

        this.localTimeZone = TimeZone.getDefault();
        this.random = new SecureRandom();

        if (this.machineId == null) {
            final byte[] mid = new byte[32];
            this.random.nextBytes(mid);
            this.machineId = mid;
        }

        if (this.nativeOs == null) {
            this.nativeOs = System.getProperty("os.name");
        }

        if (this.flags2 == 0) {