ExpirationSeconds: ptr.To[int32](77),
				},
			},
			options:       &metav1.UpdateOptions{},
			wantSigner:    "other",
			wantRequested: true,
			wantHonored:   false,
		},
		{
			name:    "kube signer honors duration exactly",
			success: true,
			obj: &certificates.CertificateSigningRequest{
				Status: certificates.CertificateSigningRequestStatus{
					Certificate: createCert(t, time.Hour, caPrivateKey, caCert),
				},

mc admin service restart myminio
```

NOTE: `http://endpoint:port/path` is a placeholder value to indicate the URL format, please change this accordingly as per your configuration.

MinIO also honors environment variable for HTTP target logging as shown below, this setting will override the endpoint settings in the MinIO server config.

```
export MINIO_LOGGER_WEBHOOK_ENABLE_target1="on"

            )
        }
    }

    @Test
    fun `precompiled project script template honors HasImplicitReceiver`() {

        assertHasImplicitReceiverIsHonoredByScriptOf<Project>("my-project-plugin.gradle.kts")
    }

    @Test
    fun `precompiled settings script template honors HasImplicitReceiver`() {

        fails("check")
        then:
        testResult.assertTestClassesExecuted('SomeTest', 'NewTest')
    }

    @ToBeFixedForConfigurationCache(bottomSpecs = "XCTestTestFrameworkIntegrationTest")
    def "honors test case filter from --tests flag"() {
        given:
        createPassingFailingTest()

        when:
        run testTaskName, '--tests', "${testSuite('SomeOtherTest')}.${removeParentheses(passingTestCaseName)}"

        result.assertTasksExecuted(tasks.debug.allToLink, ":assemble")

        sharedLibrary("build/lib/main/debug/hello").assertExists()
    }

    @ToBeFixedForConfigurationCache
    def "honors changes to buildDir"() {
        given:
        settingsFile << "rootProject.name = 'hello'"
        def lib = new CppLib()
        lib.writeToProject(testDirectory)

        and:
        buildFile << """

                }
            }
        }
    }

    @Issue("https://github.com/gradle/gradle/issues/14017")
    @RequiredFeature(feature = GradleMetadataResolveRunner.REPOSITORY_TYPE, value = "maven")
    def "honors upstream excludes with available-at variant"() {
        given:
        mavenHttpRepo.module('org', 'moduleB', '1.0')
            .dependsOn(mavenHttpRepo.module("org", "moduleA", "1.0"))

		return err
	}

	// drop init container annotations so they don't take effect on legacy kubelets.
	// remove this once the oldest supported kubelet no longer honors the annotations over the field.
	out.Annotations = dropInitContainerAnnotations(out.Annotations)

	return nil
}

        then:
        resolve.expectGraph {
            root(":", ":test:") {
                edge("org:foo:{require 1.0; reject 1.1}", "org:foo:1.0")
            }
        }
    }

    void "honors rejection using dynamic versions using dependency notation #notation"() {
        given:
        repository {
            'org:foo:1.0' {
                withModule(IvyModule) {
                    withStatus('release')

                public void start(Stage stage) {
                }
            }
        """

        expect:
        succeeds("compileJava")
    }

    def "honors project level compatibility when using toolchain"() {
        given:
        def lower = getLowerJvm()
        def lowerVersion = lower.javaVersion.getMajorVersion()

        and:
        goodCode()

   Dependency path ':test:unspecified' --> 'org:foo:1.1'
   Dependency path ':test:unspecified' --> 'org:bar:1.0' (runtime) --> 'org:foo:{require 1.0; reject 1.1}'""")
    }

    void "honors multiple rejections #rejects using dynamic versions using dependency notation #rejects"() {
        given:
        repository {
            (0..5).each {
                "org:foo:1.$it"()
            }