println("Tests to be included:\n$content")
            IncludeTestClassProvider(readTestClasses(content))
        }
        parameters.excludeTestClasses.get().isNotBlank() -> {
            val content = parameters.repoRoot.file("test-splits/exclude-test-classes.properties").get().asFile.readText()
            println("Tests to be excluded:\n$content")

// Access a file (encryption is transparent - automatically used if server requires it)
try (SmbFile file = new SmbFile("smb://server/share/file.txt", context)) {
    if (file.exists()) {
        System.out.println("File size: " + file.length());
    }
}
```

### With Authentication

```java
import jcifs.CIFSContext;
import jcifs.context.BaseContext;
import jcifs.smb.NtlmPasswordAuthenticator;

Call call = client.newCall(new Request.Builder()
    .url(server.url("/"))
    .build());
Response response = call.execute();
System.out.println(response.handshake().peerPrincipal());
RecordedRequest recordedRequest = server.takeRequest();
System.out.println(recordedRequest.getHandshake().peerPrincipal());
```

This handshake is successful because each party has prearranged to trust the root certificate that

              call: Call,
              connection: Connection,
            ) {
              val sslSocket = connection.socket() as SSLSocket
              println("Requested " + sslSocket.sslParameters.applicationProtocols.joinToString())
              println("Negotiated " + sslSocket.applicationProtocol)
            }
          },
        ).build()

    val request =
      Request
        .Builder()

        writer.print(problems.size());
        writer.print((problems.size() == 1) ? " problem was " : " problems were ");
        writer.print("encountered while building the effective toolchains");
        writer.println();

        for (Problem problem : problems) {
            writer.print("[");
            writer.print(problem.getSeverity());
            writer.print("] ");
            writer.print(problem.getMessage());

      return
    }

    when (message.type) {
      JsseDebugMessage.Type.Setup, JsseDebugMessage.Type.Encrypted, JsseDebugMessage.Type.Plaintext -> {
        println(message.message + " (skipped output)")
      }

      else -> {
        println(message)
      }
    }
  }

  fun enableJsseDebugLogging(debugHandler: (JsseDebugMessage) -> Unit = this::quietDebug): Closeable {

            inputs.files(configurations.expandedDist)
            doLast {
                configurations.expandedDist.files.each {
                    println "expandedRootPath " + (it.absolutePath - project.rootDir.absolutePath)
                    it.eachFile { nested ->
                        println "nested folder " + (nested.absolutePath - project.rootDir.absolutePath)
                    }
                }
            }
        }

}

private fun sendRequest(
  url: String,
  client: OkHttpClient,
) {
  val req = Request.Builder().url(url).build()

  client.newCall(req).execute().use {
    println(it.body.string())
  }

        versionFile.asFile.get().writeText(patchVersion)
        updateReleasedVersionFile(releasedVersionsFile.asFile.get(), previousReleasedVersion)
        println("Updated version.txt: $currentVersion -> $patchVersion")
        println("Updated released-versions.json with $currentVersion (buildTime: ${previousReleasedVersion.buildTime})")
    }

    private

        // ## 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");