<T> void register(Class<T> implementationType, Serializer<T> serializer);

    /**
     * Use Java serialization for the specified type and all subtypes. Should be avoided, but useful when migrating to using serializers or when dealing with
     * arbitrary user types.
     */
    <T> void useJavaSerialization(Class<T> implementationType);

    /**
     * Returns true when this registry can serialize objects of the given type.
     */

    - [Container Images](#container-images-10)
  - [Changelog since v1.23.6](#changelog-since-v1236)
  - [Changes by Kind](#changes-by-kind-10)
    - [API Change](#api-change-2)
    - [Feature](#feature-5)
    - [Failing Test](#failing-test)
    - [Bug or Regression](#bug-or-regression-10)
  - [Dependencies](#dependencies-10)
    - [Added](#added-10)
    - [Changed](#changed-10)
    - [Removed](#removed-10)
- [v1.23.6](#v1236)

This is called _dependency locking_.

It enables, amongst others, the following scenarios:

* Companies dealing with multi repositories no longer need to rely on `-SNAPSHOT` or changing dependencies,
which sometimes result in cascading failures when a dependency introduces a bug or incompatibility.

 * limitations under the License.
 */

package org.gradle.test.fixtures.maven

import org.gradle.test.fixtures.file.TestFile

/**
 * A fixture for dealing with file Maven repositories.
 */
class MavenFileRepository implements MavenRepository {
    final TestFile rootDir

    MavenFileRepository(TestFile rootDir) {
        this.rootDir = rootDir
    }

 * limitations under the License.
 */

package org.gradle.test.fixtures.maven

import org.gradle.test.fixtures.file.TestFile

/**
 * A fixture for dealing with the Maven Local cache.
 */
class MavenLocalRepository implements MavenRepository {

    final TestFile rootDir

    MavenLocalRepository(TestFile rootDir) {
        this.rootDir = rootDir
    }

rootProject.name = "disabling-verification"...

     *
     * This value defaults to {@code false}.
     *
     * When enabled, whether or not a store request would succeed is checked with the server before attempting.
     * This is particularly useful when potentially dealing with large artifacts that may be rejected by the server with a {@literal 413 Payload Too Large} response,
     * as it avoids the overhead of transmitting the large file just to have it rejected.

rootProject.name = "disabling-transitive-dependency-resolution"...

        final Closure matcher
        final boolean failing
        final boolean missing

        SftpExpectOne(int type, String notMetMessage, boolean failing = false, boolean missing = false) {
            this.expectedType = type
            this.notMetMessage = "Expected SFTP command not received: $notMetMessage"
            this.matcher = matcher
            this.failing = failing
            this.missing = missing
        }

      failing: map(select(.policies | map(.fail) | any)) | length,
      testnames: map(select(.policies | map(.fail) | any) | .testname),
    }
  }
  # if a policy has no failing tests, change its log output to PASS
  | with_entries(.value += { log: (if (.value.failing == 0) then "PASS" else .value.level end) })
  # sort by policies with the most failing tests first