As an alpha feature, Kubernetes v1.22 can use the cgroups v2 API to control memory allocation and isolation. This feature is designed to improve workload and node availability when there is contention for memory resources.

### API changes and improvements for ephemeral containers

import org.gradle.api.tasks.testing.logging.TestExceptionFormat
import org.gradle.api.artifacts.VersionCatalogsExtension
import okhttp3.buildsupport.platform
import okhttp3.buildsupport.testJavaVersion

plugins {
  id("okhttp.base-conventions")
}

val libs = extensions.getByType<VersionCatalogsExtension>().named("libs")

fun library(alias: String) = libs.findLibrary(alias).get().get().let {

      license {
        name.set("The Apache Software License, Version 2.0")
        url.set("https://www.apache.org/licenses/LICENSE-2.0.txt")
        distribution.set("repo")
      }
    }
    scm {
      connection.set("scm:git:https://github.com/square/okhttp.git")
      developerConnection.set("scm:git:ssh://******@****.***/square/okhttp.git")
      url.set("https://github.com/square/okhttp")
    }
    developers {
      developer {

import org.gradle.api.artifacts.VersionCatalogsExtension
import org.gradle.kotlin.dsl.withType
import ru.vyarus.gradle.plugin.animalsniffer.AnimalSniffer

plugins {
  id("okhttp.base-conventions")
  id("checkstyle")
  id("ru.vyarus.animalsniffer")
  id("com.android.lint")
  id("com.diffplug.spotless")
}

val libs = extensions.getByType<VersionCatalogsExtension>().named("libs")

When defining conventions for a property, there are largely three approaches:
1. Do not set a convention at all
2. Set a convention in a plugin
3. Set a convention in a constructor

Most properties should have a convention set, so (1) can be treated as a rare case where a value must be provided by a user.

* **Inconsistent API surface**: Public APIs with mixed spelling conventions appear less professional and polished
* **Harder for non-native speakers**: Contributors and users for whom English is a second language benefit from a single, consistent convention

        project.getExtensions().getExtraProperties().set("elasticLicenseUrl", projectLicenseURL);

        MapProperty<String, String> convention = licensesProperty.convention(
                providerFactory.provider((Callable<Map<? extends String, ? extends String>>) () -> Map.of(

                ),
                checkNoneExists(
                    "Seem like test classes but don't match naming convention",
                    classes.values()
                        .stream()
                        .filter(isStaticClass.negate())
                        .filter(isPublicClass)

## About versions { #about-versions }

Following the Semantic Versioning conventions, any version below `1.0.0` could potentially add breaking changes.

FastAPI also follows the convention that any "PATCH" version change is for bug fixes and non-breaking changes.

/// tip

The "PATCH" is the last number, for example, in `0.2.3`, the PATCH version is `3`.

            }
        }
    }
}

plugins {
    id("com.gradle.develocity")
    id("io.github.gradle.develocity-conventions-plugin")
    id("org.gradle.toolchains.foojay-resolver-convention")