dependencies {
            snapshotDependencies(functionalTestProject.functionalTests)
        }
    }) {
    val testCoverage: TestCoverage = functionalTestProject.testCoverage

    override val failStage: Boolean
        get() = testCoverage.failStage

import javax.net.ssl.SSLHandshakeException
import javax.net.ssl.SSLPeerUnverifiedException
import okio.IOException

/** Returns true if a TLS connection should be retried after [e]. */
fun retryTlsHandshake(e: IOException): Boolean =
  when {
    // If there was a protocol problem, don't recover.
    e is ProtocolException -> false

    // If there was an interruption or timeout (SocketTimeoutException), don't recover.

    this.comparator = checkNotNull(comparator);
  }

  @Override
  public int compare(@ParametricNullness T a, @ParametricNullness T b) {
    return comparator.compare(a, b);
  }

  @Override
  public boolean equals(@Nullable Object object) {
    if (object == this) {
      return true;
    }
    if (object instanceof ComparatorOrdering) {
      ComparatorOrdering<?> that = (ComparatorOrdering<?>) object;

     * Determines if the given response data matches the rule.
     *
     * @param responseData the response data to be evaluated
     * @return true if the response data matches the rule, false otherwise
     */
    boolean match(ResponseData responseData);

    /**
     * Retrieves the unique identifier for the rule.
     *
     * @return the rule's unique identifier as a String.
     */
    String getRuleId();

    /**

        // Create a custom test response that tracks if readErrorResponse was called
        class TestSmb2ReadResponse extends Smb2ReadResponse {
            boolean errorResponseCalled = false;

            TestSmb2ReadResponse(Configuration config, byte[] outputBuffer, int outputBufferOffset) {
                super(config, outputBuffer, outputBufferOffset);
            }

  override fun contentLength(): Long = delegate.contentLength()

  @Throws(IOException::class)
  override fun writeTo(sink: BufferedSink) {
    delegate.writeTo(sink)
  }

  override fun isDuplex(): Boolean = delegate.isDuplex()

  override fun toString(): String = javaClass.simpleName + "(" + delegate.toString() + ")"

  init {
    requireNotNull(delegate) { "delegate == null" }
    this.delegate = delegate
  }

    }

    /**
     * Retrieve a boolean value. If the property is not found, the value of <code>def</code> is returned.
     *
     * @param key the property key to look up
     * @param def the default value to return if the property is not found
     * @return the property value as a boolean, or the default value
     */

    public static boolean getBoolean(final String key, boolean def) {

        roleQueryHelperImpl.processCookie(request, roleSet);
        return roleSet;
    }

    private Set<String> decodedRoleList(final RoleQueryHelper roleQueryHelperImpl, final String value, final boolean encrypted) {
        Set<String> roleSet = new HashSet<>();
        roleQueryHelperImpl.parseRoleSet(value, encrypted, roleSet);
        return roleSet;
    }

    public void test_buildByParameter() {

     */
    static class TestCreateContextRequest implements CreateContextRequest {
        private byte[] name;
        private byte[] data;
        private int encodedSize;
        private boolean throwOnEncode = false;
        private boolean throwOnSize = false;
        private int sizeCallCount = 0;
        private int encodeCallCount = 0;

        public TestCreateContextRequest(byte[] name) {
            this.name = name;

  public void testGet_primitives() {
    assertNull(ArbitraryInstances.get(void.class));
    assertNull(ArbitraryInstances.get(Void.class));
    assertEquals(Boolean.FALSE, ArbitraryInstances.get(boolean.class));
    assertEquals(Boolean.FALSE, ArbitraryInstances.get(Boolean.class));
    assertEquals(Character.valueOf('\0'), ArbitraryInstances.get(char.class));
    assertEquals(Character.valueOf('\0'), ArbitraryInstances.get(Character.class));