}

    // ////////////////////////////////////////////////////////////////
    // from InputStream to Writer
    //
    /**
     * Copies from an input stream to a writer using the platform default encoding.
     * <p>
     * Neither the input stream nor the writer is closed.
     * </p>
     *
     * @param in the input stream (must not be {@literal null})

    id("gradlebuild.ci-reporting")
    id("gradlebuild.test-retry")
    id("gradlebuild.private-javadoc")
}

val testLibs = project.versionCatalogs.named("testLibs")

dependencies {
    api(platform("gradlebuild:build-platform"))
    implementation("gradlebuild:gradle-plugin")

    testImplementation(testLibs.findLibrary("junit5Vintage").get())

    testRuntimeOnly(testLibs.findLibrary("junitPlatform").get())
}

  private val serverProviderClass: Class<*>,
) : Platform() {
  override fun configureTlsExtensions(
    sslSocket: SSLSocket,
    hostname: String?,
    protocols: List<Protocol>,
  ) {
    val names = alpnProtocolNames(protocols)

    try {
      val alpnProvider =
        Proxy.newProxyInstance(
          Platform::class.java.classLoader,
          arrayOf(clientProviderClass, serverProviderClass),

import org.bouncycastle.jsse.BCSSLSocket
import org.bouncycastle.jsse.provider.BouncyCastleJsseProvider

/**
 * Platform using BouncyCastle if installed as the first Security Provider.
 *
 * Requires org.bouncycastle:bctls-jdk15on on the classpath.
 */
class BouncyCastlePlatform private constructor() : Platform() {
  private val provider: Provider = BouncyCastleJsseProvider()

   
     * If you have above configuration and using _**Windows**_ platform -
       * Try adding the CUDA, CUPTI, and cuDNN installation directories to the %PATH% environment variable.
       * Refer [windows setup guide](https://www.tensorflow.org/install/gpu#windows_setup).
     * If you have above configuration and using _**Ubuntu/Linux**_ platform -

			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.junit.platform</groupId>
			<artifactId>junit-platform-suite</artifactId>
			<version>1.10.3</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.junit.platform</groupId>
			<artifactId>junit-platform-runner</artifactId>
			<version>1.10.3</version>
			<scope>test</scope>
			<exclusions>

        implementation(projects.okhttpTestingSupport)
        implementation(projects.okhttpTls)
        implementation(projects.okhttpUrlconnection)

        if (platform == "conscrypt") {
          implementation(libs.conscrypt.openjdk)
        } else if (platform == "openjsse") {
          implementation(libs.openjsse)
        }
      }
    }

    if (testJavaVersion >= 17) {
      val androidHostTest by getting {

TF_CAPI_EXPORT extern int TF_OpIsStateful(const char* op_type,
                                          TF_Status* status);

// Platform specific initialization routine. Very few platforms actually require
// this to be called.
TF_CAPI_EXPORT void TF_InitMain(const char* usage, int* argc, char*** argv);

// Platform-specific implementation to return an unused port. (This should used
// in tests only.)

#include "tensorflow/c/eager/c_api_experimental_reader.h"

#include <cstdint>

#include "tensorflow/c/eager/c_api_experimental.h"
#include "tensorflow/core/platform/logging.h"
#include "tensorflow/core/platform/test.h"

namespace tensorflow {
namespace {

TFE_MonitoringCounter0* CreateCounter0(const char* counter_name);
TFE_MonitoringCounter1* CreateCounter1(const char* counter_name,

#      Ex. py312 -- Python 3.12
# 2. Choose the platform, which corresponds to the version of TensorFlow to
#    build. This should also match the system you're using--you cannot build
#    the TF MacOS package from Linux.
#      Ex. linux_x86        -- x86_64 Linux platform
#      Ex. linux_x86_cuda   -- x86_64 Linux platform, with Nvidia CUDA support
#      Ex. macos_arm64      -- arm64 MacOS platform