// Read the command.
    val version = fromSource.readByte() and 0xff
    if (version != VERSION_5) throw ProtocolException("unexpected version: $version")

    val command = fromSource.readByte() and 0xff

    val reserved = fromSource.readByte() and 0xff
    if (reserved != 0) throw ProtocolException("unexpected reserved: $reserved")

    val addressType = fromSource.readByte() and 0xff
    val toAddress =

      "pass" -> password = value
      "h" -> host = value
      "port" -> port = value
      "p" -> path = value
      "q" -> query = value
      "f" -> fragment = value
      else -> throw IllegalArgumentException("unexpected attribute: $value")
    }
  }

  override fun toString(): String = format("Parsing: <%s> against <%s>", input!!, base!!)

  companion object {
    fun load(source: BufferedSource): List<WebPlatformUrlTestData> {

        .callTimeout(1_000, TimeUnit.MILLISECONDS)
        .build()
    val call = client.newCall(Request(url))
    assertFailsWith<IOException> {
      call.execute()
    }.also { expected ->
      assertThat(expected).hasMessage("timeout")
    }
  }

  /**
   * This test reproduces a crash where OkHttp attempted to use a deferred connection when the call

        // Wait for completion
        assertTrue(endLatch.await(30, TimeUnit.SECONDS), "All threads should complete");
        executor.shutdown();

        // Then - No unexpected exceptions
        assertTrue(exceptions.isEmpty(), "No unexpected exceptions should occur");
    }

    /**
     * Test that CopyOnWriteArrayList prevents ConcurrentModificationException.
     */
    @Test

            throw new IOException("Unexpected DCERPC PDU header");
        }

        flags = buf[3] & 0xFF;
        // next read is start of new frag
        isStart = (flags & DCERPC_LAST_FRAG) == DCERPC_LAST_FRAG;

        length = Encdec.dec_uint16le(buf, 8);
        if (length > max_recv) {
            throw new IOException("Unexpected fragment length: " + length);
        }

    factory.init(trustStore)
    val result = factory.trustManagers!!
    check(result.size == 1 && result[0] is X509TrustManager) {
      "Unexpected trust managers: ${result.contentToString()}"
    }

    val trustManager = result[0] as X509TrustManager

    return when {
      insecureHosts.isEmpty() -> trustManager

        } catch (Exception e) {
            fail("Unexpected exception: " + e.getMessage());
        }
    }

    public void test_install_blankUrl() {
        PluginHelper testHelper = new PluginHelper();
        Artifact artifact = new Artifact("test", "1.0.0", "");

        try {
            testHelper.install(artifact);
            fail("Expected PluginException");
        } catch (PluginException e) {

    }
    throw new IllegalStateException("Unexpected edge type: " + edgeType);
  }

  private static EdgeType oppositeType(EdgeType edgeType) {
    switch (edgeType) {
      case UNDIRECTED:
        return EdgeType.DIRECTED;
      case DIRECTED:
        return EdgeType.UNDIRECTED;
    }
    throw new IllegalStateException("Unexpected edge type: " + edgeType);
  }

  @Test

    }
    throw new IllegalStateException("Unexpected edge type: " + edgeType);
  }

  private static EdgeType oppositeType(EdgeType edgeType) {
    switch (edgeType) {
      case UNDIRECTED:
        return EdgeType.DIRECTED;
      case DIRECTED:
        return EdgeType.UNDIRECTED;
    }
    throw new IllegalStateException("Unexpected edge type: " + edgeType);
  }

  @Test

        try {
            webApiFilter.doFilter(request, response, chain);
            fail("Expected IOException");
        } catch (IOException e) {
            assertEquals("Test IOException", e.getMessage());
        } catch (ServletException e) {
            fail("Unexpected ServletException: " + e.getMessage());
        }
    }