* a test directory provider as a TestRule causes spock to swallow any test failures and the test directory
 * is cleaned up even for failed tests.  {@link CleanupTestDirectoryExtension} on the other hand, registers
 * an interceptor and listener which cleans up the test directory only when the test passes.
 *

 *  Deserialization, on the other hand, is performed by a {@link org.gradle.internal.serialize.graph.DecodingProvider}.
 *  </p>
 *  <p>Both protocols are highly specialized and, as such, they are specified as Single Abstract Method interfaces.</p>
 *
 *  <h3>Codecs</h3>
 *  <p>A {@link org.gradle.internal.serialize.graph.Codec Codec} is an object that is both an <code>EncodingProvider</code> and a <code>DecodingProvider</code>.</p>

 * ```
 * fun test(l: List<String>) {
 *   l.get(1) // The symbol `get` has type `(Int) -> T` where is the type parameter declared in `List`.
 *            // On the other hand, a `KaCallableSignature` carries instantiated type information `(Int) -> String`.
 * }
 * ```
 *
 * Equality of [KaCallableSignature] is derived from its content.
 */

    }

    /**
     * If this test fails, it means that the snapshot in `released-versions.json` is no longer available.
     * You need to update that entry with a recent snapshot by hand.
     */
    def "locates snapshot versions"() {
        expect:
        urlExist(locator.getDistributionFor(distributions.mostRecentReleaseSnapshot.version))
    }

    void urlExist(URI url) {

			effectiveSc.WindowsOptions = &v1.WindowsSecurityContextOptions{}
		}
		if containerSc.WindowsOptions.GMSACredentialSpecName != nil || containerSc.WindowsOptions.GMSACredentialSpec != nil {
			// both GMSA fields go hand in hand
			effectiveSc.WindowsOptions.GMSACredentialSpecName = containerSc.WindowsOptions.GMSACredentialSpecName
			effectiveSc.WindowsOptions.GMSACredentialSpec = containerSc.WindowsOptions.GMSACredentialSpec
		}

  if (!matmul_op) return failure();

  // Gets the broadcasted output shape for tf.BatchMatMulV2Op. `shape_x` is the
  // shape of op's first/left-hand-side operand and `shape_y` is the shape of
  // op's second/right-hand-side operand.
  const auto get_broadcasted_shape =
      [&](ArrayRef<int64_t> shape_x, ArrayRef<int64_t> shape_y,
          SmallVectorImpl<int64_t>& result_shape) {

     * @param action the configuration action
     */
    <T> void variant(Attribute<T> attribute, T attributeValue, Action<? super VariantVersionMappingStrategy> action);

    /**
     * A short hand method to configure the variants which matches the provided Usage attribute.
     * This is the recommended way to configure the mapping strategy for the general case.
     * @param usage the usage to look for

// +build go1.22

package aliases

import (
	"go/ast"
	"go/parser"
	"go/token"
	"go/types"
)

// Alias is an alias of types.Alias.
type Alias = types.Alias

// Rhs returns the type on the right-hand side of the alias declaration.
func Rhs(alias *Alias) types.Type {
	if alias, ok := any(alias).(interface{ Rhs() types.Type }); ok {
		return alias.Rhs() // go1.23+
	}

	// go1.22's Alias didn't have the Rhs method,

        if (className.startsWith("xsbti.")) {
            // We can't use the loadClass overload with two arguments because it's
            // protected, but we can do the same by hand (the classloader instance
            // from which we call resolveClass does not matter).
            Class<?> c = sbtLoader.loadClass(className);
            if (resolve) {
                resolveClass(c);
            }

 * provides a dynamic view of the functionality of an object and does not provide any decoration or extra functionality.
 * The {@link org.gradle.internal.extensibility.ExtensibleDynamicObject} implementation on the other hand does provide extra functionality.
 */
public interface DynamicObject extends MethodAccess, PropertyAccess {
    /**