DefaultSerializer serializer = new DefaultSerializer(classLoader)

        Class cl = classLoader.parseClass('package org.gradle.cache; class TestObj implements Serializable { }')
        Object o = cl.newInstance(new Object[0])

        when:
        def r = serialize(o, serializer)

        then:
        cl.isInstance(r)
    }

	sleep 5

	if ! ps -p ${pid} 1>&2 >/dev/null; then
		echo "server1 log:"
		cat "${WORK_DIR}/server1.log"
		echo "FAILED"
		purge "$WORK_DIR"
		exit 1
	fi

	"${WORK_DIR}/mc" stat minio/bucket/testobj

	pkill minio
	sleep 3
}

function main() {
	start_port=$(shuf -i 10000-65000 -n 1)

	start_minio_5drive ${start_port}
}

function purge() {
	rm -rf "$1"
}

(main "$@")
rv=$?

        result[2].arguments == [4, 5] as Object[]
    }

    def "uses provided ClassLoader to locate incoming method invocation"() {
        Class cl = classLoader.parseClass('package org.gradle.test; class TestObj { void doStuff() { } }')
        def method = cl.getMethod("doStuff")
        def invocation = new MethodInvocation(method, [] as Object[])

        when:
        def serialized = serialize(invocation)

		if i := strings.LastIndex(fnName, "."); i != -1 {
			fnName = fnName[i+1:]
		}
		testObj := testCase.obj
		testFn := testCase.fn
		runTestOverPVCRetentionPolicies(
			t,
			fmt.Sprintf("%s/Monotonic", fnName),
			func(t *testing.T, policy *apps.StatefulSetPersistentVolumeClaimRetentionPolicy) {
				set := testObj()
				set.Spec.PersistentVolumeClaimRetentionPolicy = policy
				testFn(t, set, assertMonotonicInvariants)

        buildA.buildFile << """
            dependencies {
                implementation "org.test:b1:1.0"
                implementation "org.test:b2:1.0"
            }
        """

        when:
        checkDependencies()

        then:
        checkGraph {
            edge("org.test:b1:1.0", ":buildB:b1", "org.test:b1:2.0") {
                configuration = "runtimeElements"
                compositeSubstitute()

            dependencies {
                api "org.test:b1:1.0"
            }
            project(':b1') {
                apply plugin: 'java'
                dependencies {
                    api "org.test:b2:1.0"
                }
            }
            project(':b2') {
                apply plugin: 'java'
                dependencies {
                    api "org.test:b1:1.0"
                }
            }
"""

        given:
        def pluginBuild = pluginProjectBuild("pluginD")
        applyPlugin(buildA, "pluginD")
        includeBuild pluginBuild

        dependency 'org.test:b1:1.0'
        dependency(pluginBuild, 'org.test:b2:1.0')

        when:
        execute()

        then:
        events(23)
        loggedOncePerBuild('buildListener.settingsEvaluated', [':', ':buildB', ':buildC', ':pluginD'])

Laura Kassovic <******@****.***> 1701107622 -0800

                    compile project(':a')
                }
            }
        """

        expect:
        succeeds "b:checkDeps"
        resolve.expectGraph {
            root(":b", "test:b:") {
                project(":a", "test:a:") {
                    artifact(name: 'foo', type: '')
                    artifact(name: 'foo', type: 'txt')
                }
            }
        }
    }

            root(":", ":test:") {
                module("test:a:1.2") {
                    artifact(classifier: "debug")
                    configuration("debug")
                    edge("test:b:{prefer 2.0}", "test:b:2.0")
                }
            }
        }

        when:
        run("checkRelease")

        then:
        resolve.expectGraph {
            root(":", ":test:") {