}

    def "configures boolean option"() {
        when:
        configurer.configureTasks([task], ['--someFlag'])
        then:
        task.someFlag
    }

    def "configures enum option"() {
        when:
        configurer.configureTasks([task], ['--someEnum', "value1"])
        then:
        task.anEnum == TestEnum.value1

        when:

        return new IncludedPluginBuildSpec(rootDir, configurer);
    }

    public static IncludedBuildSpec includedBuild(File rootDir, Action<ConfigurableIncludedBuild> configurer) {
        return new IncludedLibraryBuildSpec(rootDir, configurer);
    }

    private static class IncludedLibraryBuildSpec extends IncludedBuildSpec {

        when:
        configurer.startCapture()
        configurer.setLevel(LogLevel.LIFECYCLE)
        configurer.setLevel(LogLevel.DEBUG)

        then:
        Logger.getLogger("").getLevel() == Level.FINE
    }

    def "Log level can be changed before starting"() {
        when:
        configurer.setLevel(LogLevel.LIFECYCLE)
        configurer.setLevel(LogLevel.DEBUG)

        when:
        configurer.configure(LogLevel.INFO)
        logger.info('message', failure)

        then:
        1 * listener.onOutput({ it.category == 'cat1' && it.message == 'message' && it.logLevel == LogLevel.INFO && it.throwable == failure })
        0 * listener._
    }

    def mapsSlf4jLogLevelsToGradleLogLevels() {
        when:
        configurer.configure(LogLevel.DEBUG)

 */
public class LoggingSystemAdapter implements LoggingSourceSystem {
    private final LoggingConfigurer configurer;
    private boolean enabled;
    private LogLevel logLevel = LogLevel.LIFECYCLE;

    public LoggingSystemAdapter(LoggingConfigurer configurer) {
        this.configurer = configurer;
    }

    @Override
    public Snapshot snapshot() {
        return new SnapshotImpl(enabled, logLevel);
    }

    }

    HttpClientConfigurer configurer = new HttpClientConfigurer(httpSettings)

    def setup() {
        basicAuthentication.addHost(REMOTE_HOST, SOME_PORT)
    }

    def "configures http client with no credentials or proxy"() {
        httpSettings.authenticationSettings >> []
        httpSettings.sslContextFactory >> sslContextFactory

        when:
        configurer.configure(httpClientBuilder)

        then:

        classpathHasher.hash(_ as ClassPath) >> TestHashCodes.hashCodeFrom(123)
    }

    void "configures a target object using script"() {
        given:
        final Object target = new Object()

        when:
        def configurer = factory.create(scriptSource, scriptHandler, targetScope, baseScope, false)
        configurer.apply(target)

        then:
        1 * loggingManagerFactory.create() >> loggingManager

        1 * scriptHandlerFactory.create(_, scriptCompileScope) >> scriptHandler
        1 * scriptPluginFactory.create(_, scriptHandler, scriptCompileScope, parentCompileScope, false) >> configurer
        1 * configurer.apply(target1)
        1 * configurer.apply(target2)
        1 * parentCompileScope.createChild("script-$file", null) >> scriptCompileScope

        then:
        action.from('script')
        action.to(target1)

    private final TaskNameResolver taskNameResolver;
    private final ProjectConfigurer configurer;

    @Inject
    public DefaultTaskSelector(TaskNameResolver taskNameResolver, ProjectConfigurer configurer) {
        this.taskNameResolver = taskNameResolver;
        this.configurer = configurer;
    }

    @Inject
    protected InternalProblems getProblemsService() {

		t.Errorf("expected search \".\", got %+v", options[3].DNSSearch)
	}

	configurer = NewConfigurer(recorder, nodeRef, nil, testClusterDNS, testClusterDNSDomain, defaultResolvConf)
	configurer.getHostDNSConfig = fakeGetHostDNSConfigCustom
	for i, pod := range pods {
		var err error
		dnsConfig, err := configurer.GetPodDNS(pod)
		if err != nil {
			t.Fatalf("failed to generate container options: %v", err)
		}