repositories {
    ivy {
        url "http://repo.mycompany.com/repo"
        resolve.dynamicMode = true
    }
}

// Can use a rule instead to enable (or disable) dynamic resolve mode for all repositories
repositories.withType(IvyArtifactRepository) {
    resolve.dynamicMode = true
}

        <title>Properties</title>
        <table>
            <thead>
                <tr>
                    <td>Name</td>
                </tr>
            </thead>
            <tr>
                <td>dynamicMode</td>
            </tr>
        </table>
    </section>
    <section>
        <title>Methods</title>
        <table>
            <thead>
                <tr>
                    <td>Name</td>

                repositories {
                    ivy {
                        url "${server.remoteIvyRepo.uri}"
                        $server.validCredentials
                        resolve.dynamicMode = project.hasProperty('useDynamicResolve')
                    }
                }
                compile 'org:projectA:1.2'
            }
            task retrieve(type: Sync) {

        given:
        buildFile << """
configurations {
    compile
}
dependencies {
    repositories {
        ivy {
            url "${ivyRepo.uri}"
            resolve.dynamicMode = project.hasProperty('useDynamicResolve')
        }
    }
    compile 'org:projectA:1.2'
}
task retrieve(type: Sync) {
  from configurations.compile
  into 'libs'
}
"""

    final DefaultIvyArtifactRepository repository = newRepo()

    def "default values"() {
        expect:
        repository.url == null
        !repository.resolve.dynamicMode
    }

    def "creates a resolver for HTTP patterns"() {
        repository.name = 'name'
        repository.artifactPattern 'https://host/[organisation]/[artifact]-[revision].[ext]'

	"k8s.io/apimachinery/pkg/runtime/serializer"
	"k8s.io/client-go/kubernetes/scheme"
	"k8s.io/client-go/rest"
)

// dynamicCodec is a codec that wraps the standard unstructured codec
// with special handling for Status objects.
// Deprecated only used by test code and its wrong
type dynamicCodec struct{}

func (dynamicCodec) Decode(data []byte, gvk *schema.GroupVersionKind, obj runtime.Object) (runtime.Object, *schema.GroupVersionKind, error) {

    }

    @TargetGradleVersion(">=8.8")
    def "reports display names for dynamic tests"() {
        file("src/test/java/org/example/DynamicTests.java") << """package org.example;

import org.junit.jupiter.api.DynamicNode;
import org.junit.jupiter.api.TestFactory;

import java.util.stream.Stream;

import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.DynamicContainer.dynamicContainer;

		},
	}

	for _, test := range testcases {
		t.Run(test.name, func(t *testing.T) {
			obj, gvk, err := dynamicCodec{}.Decode(test.data, test.gvk, test.obj)
			if (err == nil) != (test.expectErr == "") {
				t.Fatalf("expected err=%v, got %v", test.expectErr, err)
			}
			if err != nil && !strings.Contains(err.Error(), test.expectErr) {

build:android_x86_64 --cpu=x86_64
build:android_x86_64 --fat_apk_cpu=x86_64

# Build everything statically for Android since all static libs are later
# bundled together into a single .so for deployment.
build:android --dynamic_mode=off

# Sets the default Apple platform to macOS.
build:macos --apple_platform_type=macos

# gRPC on MacOS requires this #define
build:macos --copt=-DGRPC_BAZEL_BUILD