rules, err := r.roleToRuleMapper.GetRoleReferenceRules(clusterRoleBinding.RoleRef, "")
			if err != nil {
				// if we have an error, just keep track of it and keep processing.  Since rules are additive,
				// missing a reference is bad, but we can continue with other rolebindings and still have a list
				// that does not contain any invalid values
				errorlist = append(errorlist, err)
			}

        composite(actions[0]) != composite()
    }

    def "adapting runnables"() {
        given:
        def runnable = Mock(Runnable)
        def arg = Mock(Object)

        when:
        toAction(runnable).execute(arg)

        then:
        0 * arg._(*_)
        1 * runnable.run()
    }

    def "adapting null runnables"() {
        when:
        toAction((Runnable) null).execute("foo")

    }

     /**
     * Adds some source sets to the collection which will be using TestKit.
     *
     * Calling this method multiple times with different source sets is <strong>additive</strong> - this method
     * will add to the existing collection of source sets.
     *
     * @param testSourceSet the test source set to add
     * @since 7.4
     */
    @Incubating

/**
 * This normalizer converts native component paths and environment
 * information to look like macOS because samples output currently shows
 * the output for macOS and is not yet capable of adapting dynamically
 * to different toolchains.
 */
class NativeComponentReportOutputNormalizer implements OutputNormalizer {
    @Override
    String normalize(String commandOutput, ExecutionMetadata executionMetadata) {

	//
	// Thus, a workaround here is to adapt the KubeletConfiguration paths for Windows.
	// Note this is currently bound to KubeletConfiguration v1beta1.
	klog.V(2).Infoln("[componentconfig] Adapting the paths in the KubeletConfiguration for Windows...")

	// Get the drive from where the kubeadm binary was called.
	exe, err := os.Executable()
	if err != nil {

            // Directories are ok to use outside the cache
            return source;
        }
        if (globalCacheLocations.isInsideGlobalCache(source.getAbsolutePath())) {
            // The global caches are additive only, so we can use it directly since it shouldn't be deleted or changed during the build.
            return source;
        }

        // Copy the file into the cache

    }
}
"""
    }

    def setup() {
        repo.module('org.test', 'projectA', '1.0').withStatus("silver").publish().allowAll()
    }

    def "module with custom status can be resolved by adapting status scheme"() {
        buildFile <<
                """
class StatusRule implements ComponentMetadataRule {
    public void execute(ComponentMetadataContext context) {
        assert context.details.status == "silver"

! go list -buildvcs=true .
stderr '^go: missing Git command\. See https://golang\.org/s/gogetcmd\nerror obtaining VCS status: .*\n\tUse -buildvcs=false to disable VCS stamping.'

# Adding the -test flag should be strictly additive — it should not suppress the error.
! go list -buildvcs=true -test .
stderr '^go: missing Git command\. See https://golang\.org/s/gogetcmd\nerror obtaining VCS status: .*\n\tUse -buildvcs=false to disable VCS stamping.'

	// See https://github.com/grpc/grpc-go/blob/bd0b3b2aa2a9c87b323ee812359b0e9cda680dad/keepalive/keepalive.go#L49
	MaxServerConnectionAge time.Duration // default value is infinity
	// MaxServerConnectionAgeGrace is an additive period after MaxServerConnectionAge
	// after which the connection will be forcibly closed by the server.
	MaxServerConnectionAgeGrace time.Duration // default value 10s
}

import org.gradle.internal.service.scopes.ServiceScope;
import org.gradle.internal.time.Clock;

import java.util.HashMap;
import java.util.Map;

/**
 * A single instance is used per build, so may be adapting concurrent test executions.
 * However, this implementation is not thread safe,
 * but is relying on serialisation guarantees provided by ListenerManager.
 */
@ServiceScope(Scope.BuildSession.class)