extensionContext: ExtensionContext,
    ) {
      var failed = false
      try {
        invocation.proceed()
      } catch (e: TestAbortedException) {
        throw e
      } catch (e: Throwable) {
        failed = true
        rethrowIfNotExpected(e)
      } finally {
        resetPlatform()
      }
      if (!failed) {
        failIfExpected()
      }
    }

    }

    @Test
    public void test_loadProtocols_invalidPackage() {
        final ProtocolHelper protocolHelper = new ProtocolHelper();

        // Should not throw exception with invalid package
        protocolHelper.loadProtocols("org.invalid.package.does.not.exist");

        // Should have empty arrays initially
        assertEquals(0, protocolHelper.getWebProtocols().length);

      )
      val response = client.newCall(Request(server.url("/"))).execute()
      response.close()
    }
  }

  /**
   * Test that we can't override in a Network Interceptor, which will throw an exception.
   */
  @Test
  fun testOverrideInNetworkInterceptor(
    override: OverrideParam =
      burstValues(
        OverrideParam.Authenticator,
        OverrideParam.Cache,

    // java.lang.reflect.InaccessibleObjectException: Unable to make member of class
    // sun.security.ssl.SSLSocketFactoryImpl accessible:  module java.base does not export
    // sun.security.ssl to unnamed module @xxx
    throw UnsupportedOperationException(
      "clientBuilder.sslSocketFactory(SSLSocketFactory) not supported on JDK 8 (>= 252) or JDK 9+",
    )
  }

  override fun newSSLContext(): SSLContext =
    when {

    assertThat(t3).isCloseTo(1750.0, 250.0)
  }

  @Test fun taskFailsWithUncheckedException() {
    queue.schedule("task", TimeUnit.MILLISECONDS.toNanos(100)) {
      log.put("failing task running")
      throw RuntimeException("boom!")
    }

    queue.schedule("task", TimeUnit.MILLISECONDS.toNanos(200)) {
      log.put("normal task running")
      return@schedule -1L
    }

        });
  }

  private final EdgeType edgeType;

  public DefaultNetworkImplementationsTest(EdgeType edgeType) {
    this.edgeType = edgeType;
  }

  @Before
  public void setUp() throws Exception {
    NetworkBuilder<Object, Object> builder =
        (edgeType == EdgeType.DIRECTED) ? NetworkBuilder.directed() : NetworkBuilder.undirected();

        ? new DenseImmutableTable<R, C, V>(cellList, rowSpace, columnSpace)
        : new SparseImmutableTable<R, C, V>(cellList, rowSpace, columnSpace);
  }

  /**
   * @throws IllegalArgumentException if {@code existingValue} is not null.
   */
  /*
   * We could have declared this method 'static' but the additional compile-time checks achieved by

    private UserAgentHelper userAgentHelper;

    private PathMappingHelper pathMappingHelper;

    private File propertiesFile;

    @Override
    protected void setUp(TestInfo testInfo) throws Exception {
        super.setUp(testInfo);
        propertiesFile = File.createTempFile("test", ".properties");
        FileUtil.writeBytes(propertiesFile.getAbsolutePath(), new byte[0]);
        propertiesFile.deleteOnExit();

   * functions, 4 bytes array length) followed by the bit array data (bitSize / 8 bytes).
   */
  public void testBitSizeMatchesSerializationSize() throws Exception {
    int[] expectedInsertionValues = {1, 10, 100, 1000, 10000};
    double[] fppValues = {0.01, 0.03, 0.1};

    for (int expectedInsertions : expectedInsertionValues) {
      for (double fpp : fppValues) {

        };
    tester.test();
  }

  public void testIteratorTester() throws Exception {
    Random random = new Random(0);
    List<Integer> list = new ArrayList<>();
    for (int i = 0; i < 3; i++) {
      list.add(random.nextInt());
    }
    runIterator(list, 6);
  }

  public void testIteratorTesterLarger() throws Exception {
    runIterator(Lists.newArrayList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10), 5);
  }