A dependency on a platform is created using the `platform` keyword:

.Getting versions declared in a platform
====
include::sample[dir="snippets/java-platform/recommender/kotlin/consumer",files="build.gradle.kts[tags=get-recommendations]"]
include::sample[dir="snippets/java-platform/recommender/groovy/consumer",files="build.gradle[tags=get-recommendations]"]
====

--

  companion object {
    @Volatile private var platform = findPlatform()

    const val INFO = 4
    const val WARN = 5

    private val logger = Logger.getLogger(OkHttpClient::class.java.name)

    @JvmStatic
    fun get(): Platform = platform

    fun resetForTests(platform: Platform = findPlatform()) {
      this.platform = platform
    }

#include "tensorflow/core/platform/status.h"
#include "tensorflow/core/platform/strcat.h"
#include "tensorflow/core/platform/stringpiece.h"
#include "tsl/platform/status.h"

using tensorflow::StatusFromTF_Status;

namespace stream_executor {
using tensorflow::StringPiece;

// TODO(penporn): Remove OwnedTFStatus.
using OwnedTFStatus = tensorflow::TF_StatusPtr;

namespace {
absl::Status ValidateSPPlatform(const SP_Platform& platform) {

  TF_ASSERT_OK(status);
  absl::StatusOr<Platform*> maybe_platform =
      PlatformManager::PlatformWithName("MY_DEVICE");
  TF_ASSERT_OK(maybe_platform.status());
  Platform* platform = std::move(maybe_platform).value();
  ASSERT_EQ(platform->Name(), test_util::kDeviceName);
  ASSERT_EQ(platform->VisibleDeviceCount(), test_util::kDeviceCount);

  absl::StatusOr<StreamExecutor*> maybe_executor =

            }
        """
    }

    // When publishing a platform, the Gradle metadata will _not_ contain enforced platforms
    // as those are synthetic platforms generated at runtime. This test is here to make sure
    // this is the case
    def "can enforce a published platform"() {
        def platform = mavenHttpRepo.module("org", "platform", "1.0")
            .asGradlePlatform()
            .dependsOn("org", "foo", "1.0")

      parallel=false
    fi
  fi

  if [[ "${parallel}" == "true" ]]; then
    kube::log::status "Building go targets for {${platforms[*]}} in parallel (output will appear in a burst when complete):" "${targets[@]}"
    local platform
    for platform in "${platforms[@]}"; do (
        kube::golang::set_platform_envs "${platform}"

platforms/jvm/testing-junit-platform/       @gradle/bt-jvm @gradle/dv-testing-team
platforms/jvm/testing-jvm/                  @gradle/bt-jvm @gradle/dv-testing-team
platforms/jvm/testing-jvm-infrastructure/   @gradle/bt-jvm @gradle/dv-testing-team

# Software platform
platforms/software/                         @gradle/bt-jvm

# Extensibility
platforms/extensibility/        @gradle/bt-extensibility-maintainers

    "name": "persistent-cache",
    "path": "platforms/core-execution/persistent-cache",
    "unitTests": true,
    "functionalTests": true,
    "crossVersionTests": false
  },
  {
    "name": "platform-base",
    "path": "platforms/software/platform-base",
    "unitTests": true,
    "functionalTests": true,
    "crossVersionTests": false
  },
  {
    "name": "platform-jvm",
    "path": "platforms/jvm/platform-jvm",

              files=".*[/\\]platforms[/\\]jvm[/\\]war[/\\]src[/\\]main[/\\]java[/\\]org[/\\]gradle[/\\]api[/\\]tasks[/\\]bundling[/\\][^/\\]+"/>

    <suppress checks="JavadocPackage"
              files=".*[/\\]platforms[/\\]jvm[/\\]language-jvm[/\\]src[/\\]main[/\\]java[/\\]org[/\\]gradle[/\\]api[/\\]plugins[/\\][^/\\]+"/>
    <suppress checks="JavadocPackage"

  }

  @Test
  fun effectiveOrderInRestrictedJdk11() {
    platform.assumeJdkVersion(11)
    // We are avoiding making guarantees on ordering of secondary Platforms.
    platform.assumeNotConscrypt()
    platform.assumeNotBouncyCastle()

    val platform = Platform.get()
    val platformDefaultCipherSuites =
      platform.newSslSocketFactory(platform.platformTrustManager()).defaultCipherSuites
    val cipherSuites =