final SQLRuntimeException sqlRuntimeException = new SQLRuntimeException(sqlException);

        // ## Act ##
        final String message = sqlRuntimeException.getMessage();

        // ## Assert ##
        System.out.println(message);
        assertContains(message, "ErrorCode=7650");
        assertContains(message, "SQLState=fooState");
        assertContains(message, "some reason");
        assertContains(message, "ErrorCode=7660");

    assertThat(cs.hashCode(), cs.toString())
      .isEqualTo(System.identityHashCode(cs))
  }

  @Test
  fun hashCode_usesIdentityHashCode_regularCase() {
    // This one's javaName matches the identifier.
    val cs = CipherSuite.TLS_RSA_WITH_AES_128_CBC_SHA256
    assertThat(cs.hashCode(), cs.toString())
      .isEqualTo(System.identityHashCode(cs))
  }

  @Test
  fun instancesAreInterned() {

        expected[0] = 0x04; // buffer format
        System.arraycopy(dirName.getBytes(), 0, expected, 1, dirName.length());
        expected[dirName.length() + 1] = 0x00; // null terminator

        byte[] dst = new byte[100];
        int len = sdd.writeBytesWireFormat(dst, 0);

        assertEquals(expected.length, len);

        byte[] result = new byte[len];
        System.arraycopy(dst, 0, result, 0, len);

            final String sessionId = crawler.execute();

            // Wait for crawler to start running with polling
            long startTime = System.currentTimeMillis();
            while (crawler.crawlerContext.getStatus() != CrawlerStatus.RUNNING && System.currentTimeMillis() - startTime < 5000) {
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {

      }
    }
  }

  normalization {
    runtimeClasspath {
      metaInf {
        ignoreAttribute("Bnd-LastModified")
      }
    }
  }
}

val platform = System.getProperty("okhttp.platform", "jdk9")
val testJavaVersion = System.getProperty("test.java.version", "21").toInt()

/** Configure building for Java+Kotlin projects. */
subprojects {
  val project = this@subprojects

        byte[] result = cipher.doFinal(data);

        decrypt = new byte[result.length];
        System.arraycopy(result, 0, decrypt, 0, result.length);

        int tempSize = decrypt.length - 24;

        byte[] output = new byte[tempSize];
        System.arraycopy(decrypt, 24, output, 0, tempSize);

        return output;
    }

        }
        if (length < MIN_COMPRESSION_SIZE) {
            log.debug("Data too small for compression ({} bytes), returning uncompressed", length);
            byte[] result = new byte[length];
            System.arraycopy(data, offset, result, 0, length);
            return result;
        }
        if (length > MAX_COMPRESSION_SIZE) {
            throw new CIFSException("Data too large for compression: " + length + " bytes");

  val capturedOut = ByteArrayOutputStream()

  private lateinit var executor: ExecutorService

  private lateinit var client: OkHttpClient

  @BeforeEach
  fun setUp() {
    platform.assumeLoom()
    assertThat(System.getProperty("jdk.tracePinnedThreads")).isNotEmpty()

    client =
      OkHttpClient
        .Builder()
        .trustMockServer()
        .dispatcher(Dispatcher(newVirtualThreadPerTaskExecutor()))
        .build()

      closedRequestBody.writeTo(Buffer())
    }
  }

  @Test
  fun testPathRead() {
    assertOnPath(content = "Hello") { path ->
      val requestBody = path.asRequestBody(FileSystem.SYSTEM)

      val buffer = Buffer()
      requestBody.writeTo(buffer)
      assertThat(buffer.readUtf8()).isEqualTo("Hello")
    }
  }

  @Test
  fun testSha256() {

        // Remove script caches from TestKit integTest temp dir
        // location defined in TempTestKitDirProvider, copied here
        val testKitTmpDir = File(File(System.getProperty("java.io.tmpdir")), ".gradle-test-kit-${System.getProperty("user.name")}")
        fileSystemOperations.removeCachedScripts(File(testKitTmpDir, "caches"))
        fileSystemOperations.removeTransformDir(File(testKitTmpDir, "caches"))