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,

     */
    Set<String> getClassesToProcess();

    void setClassesToCompile(Set<String> classes);

    /**
     * Classes to compile are all classes that we know from Java sources that will be compiled.
     * These classes are deleted before a compilation and are not passed to Java compiler (their sources are passed to a compiler).

     *
     * <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}.

/**
 * 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.

import spock.lang.Specification

import java.util.function.BiConsumer

class BuildOperationFiringBuildWorkPreparerTest extends Specification {

    def "build operation provides execution plan when queries with all node types"() {
        def ti1 = TestTaskIdentities.create("t1", Task, Stub(ProjectInternal) {
            projectPath(_) >> { args -> Path.path(":" + args[0]) }
        })
        def t = Stub(LocalTaskNode) {

                .collect { (it as Requires).value() }
                .flatten() as List<Class>
        }

        PredicatesFile.checkValidCombinations(predicateClassNames, acceptedCombinations)
        // If all preconditions are met, we DON'T skip the tests
        specOfFeature.skipped |= !TestPrecondition.allSatisfied(annotation.value())
    }

            throw new ClassNotFoundException(
                "A pending instrumentation exception prevented loading a class " + className + " in " + classLoaderName, lastError);
        }
    }

    /**
     * Call this when an error occurs during class loading.
     * This method only records the error but doesn't throw any exceptions.

Gradle supports single and multi-project builds.

- For single-project builds, the settings file is optional.
- For multi-project builds, the settings file is mandatory and declares all subprojects.

[[sec:settings_file_script]]
== Settings script

The settings file is a script.
It is either a `settings.gradle` file written in Groovy or a `settings.gradle.kts` file in Kotlin.