} catch (ClassNotFoundException e) {
                throw new RuntimeException(e);
            }
        }

        /**
         * @param interceptorsProviderClass the class providing the Groovy call interceptors.
         * It must have a method that follows the pattern: {@code public static List<CallInterceptor> getCallInterceptors()}
         */
        @SuppressWarnings("unchecked")

 *
 * <p>The implementation provides the following behavior:
 *
 * <ul>
 *     <li>All builds in the tree use the root build's cache configuration, once that configuration is available (ie the root build's settings have been evaluated).</li>

import org.gradle.internal.remote.internal.inet.MultiChoiceAddress;
import org.gradle.process.internal.worker.WorkerProcessContext;

import java.io.Serializable;

/**
 * All configuration options to be transferred to a worker process during worker startup.
 */
public class WorkerConfig {
    private final LogLevel logLevel;
    private final boolean publishJvmMemoryInfo;

import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses;

@AnalyzeClasses(packages = "org.gradle")
public class XmlFactoriesTest {

    private static final String RATIONALE = "for security reasons, all XML factories creation should go through " + XmlFactories.class.getName();

    private static final List<Class<?>> xmlFactoryClasses = Arrays.asList(
        DocumentBuilderFactory.class,
        SAXParserFactory.class,

To stop running Daemon processes, use the following command:

----
$ gradle --stop
----

This terminates all Daemon processes started with the same version of Gradle used to execute the command.

You can also kill Daemons manually with your operating system.
To find the PIDs for all Daemons regardless of Gradle version, see <<gradle_daemon.adoc#find_all_daemons,Find Daemons>>.

[[sec:daemon_jvm_criteria]]

     *
     * <p>If any long running command is currently running, the blocked call to {@link #runCommand} will fail with {@link DaemonStoppedException}.</p>
     *
     * <p>The daemon will stop accepting new work, so that subsequent calls to {@link #runCommand} will failing with {@link DaemonUnavailableException}.

                }
                handlers.clear();
                completed = true;
            }
            if (!failures.isEmpty()) {
                throw new DefaultMultiCauseException("Failed to handle all HTTP requests.", failures);
            }
        } finally {
            lock.unlock();
        }
    }

    @Override
    public void resetExpectations() {
        cancelBlockedRequests();

/**
 * Provides type discovery via functions that return an object or configure an object accepting a lambda as the last parameter
 * (via [org.gradle.api.Action] or a Kotlin function type, see [gradleConfigureLambdas]).
 *
 * All configured or returned types that appear in [isPublicAndRestricted]-matching will be discovered (for now, regardless of actual function semantics).
 */
internal
class TypeDiscoveryFromRestrictedFunctions : AnalysisSchemaComponent {

                assert registry.getFactory(Integer).create() == 12
                assert registry.getFactory(String).create() == "123"
            }
        }
    }

    def "multiple threads can locate all services"() {
        def registry = new DefaultServiceRegistry()
        registry.addProvider(new ServiceRegistrationProvider() {
            @Provides
            String createString(Integer value) {

        // TODO(mlopatkin) figure out a nicer way of handling the presence of agent in the foreground daemon.
        //  Currently it is hard to have a proper "-javaagent:/path/to/jar" in clients that start the daemon, so all code deals with a boolean flag shouldApplyAgent instead.
        //  It is also possible to have the agent attached at runtime, without the flag, so flag checking is preferred.