* <b>Warning:</b> the funnel provided <b>must</b> behave identically to the one used to populate
   * the original Bloom filter!
   *
   * @throws IOException if the InputStream throws an {@code IOException}, or if its data does not
   *     appear to be a BloomFilter serialized using the {@linkplain #writeTo(OutputStream)} method.
   */

            return OptionalThing.ofNullable(subject, () -> {
                throw new IllegalStateException("Subject not found");
            });
        }

        @Override
        public OptionalThing<String> getSavedPlainText() {
            return OptionalThing.ofNullable(plainText, () -> {
                throw new IllegalStateException("Plain text not found");
            });
        }

    interceptorThrowsRuntimeExceptionSynchronous(true)
  }

  /**
   * When an interceptor throws an unexpected exception, synchronous callers can catch it and deal
   * with it.
   */
  private fun interceptorThrowsRuntimeExceptionSynchronous(network: Boolean) {
    addInterceptor(network) { chain: Interceptor.Chain? -> throw RuntimeException("boom!") }
    val request =
      Request
        .Builder()

     * Verifies that unwrap can throw exceptions when appropriate.
     */
    @Test
    void testUnwrap_throwsException() {
        when(smbTree.unwrap(any())).thenThrow(new ClassCastException("Cannot unwrap to specified type"));

        assertThrows(ClassCastException.class, () -> smbTree.unwrap(CustomSmbTree.class),
                "Should throw ClassCastException when type is incompatible");
    }

                        throw new IORuntimeException(e);
                    }
                } else if (url.contains("plugin/repo2")) {
                    try (InputStream is = ResourceUtil.getResourceAsStream(url)) {
                        return new String(InputStreamUtil.getBytes(is), Constants.UTF_8);
                    } catch (IOException e) {
                        throw new IORuntimeException(e);
                    }

        byte[] result1 = hmac1.engineDigest();
        byte[] result2 = hmac2.engineDigest();

        assertArrayEquals(result1, result2);
    }

    @Test
    void testHMACT64WithKnownTestVector() throws NoSuchAlgorithmException {
        // Test with known test vector
        // Using test vector from RFC 2104 adapted for HMACT64
        byte[] key = new byte[16];
        Arrays.fill(key, (byte) 0x0b);

    assertThat(request.method).isEqualTo("GET")
    assertThat(request.url.toString()).isEqualTo("http://example.com/")
    assertThat(request.body).isNull()
  }

  @Test
  @Throws(IOException::class)
  fun put() {
    val request = fromArgs("-X", "PUT", "-d", "foo", "http://example.com").createRequest()
    assertThat(request.method).isEqualTo("PUT")

 */
@J2ktIncompatible // threads
@GwtIncompatible // threads
@NullUnmarked
public class AtomicLongMapBasherTest extends TestCase {
  private final Random random = new Random(301);

  public void testModify_basher() throws Exception {
    int nTasks = 3000;
    int nThreads = 100;
    int getsPerTask = 1000;
    int deltaRange = 10000;
    String key = "key";

    AtomicLongMap<String> map = AtomicLongMap.create();

    @Override
  Object writeReplace() {
    return new EntrySetSerializedForm<>(map());
  }

  @GwtIncompatible
  @J2ktIncompatible
    private void readObject(ObjectInputStream stream) throws InvalidObjectException {
    throw new InvalidObjectException("Use EntrySetSerializedForm");
  }

  @GwtIncompatible
  @J2ktIncompatible
  private static final class EntrySetSerializedForm<K, V> implements Serializable {

                log.error("Failed to create child URL", e);
                continue;
            }
        }
        return null;
    }

    private SmbResource adapt(final FileEntry e) throws MalformedURLException {
        return new SmbFile(this.parent, e.getName(), false, e.getType(), SmbConstants.ATTR_READONLY | SmbConstants.ATTR_DIRECTORY, 0L, 0L,
                0L, 0L);
    }

    /**