bool IsAbsolutePath() const;

 private:
  // Replaces multiple consecutive separators with a single separator.
  // For example, "bar///foo" becomes "bar/foo". Does not eliminate other
  // redundancies that might be in a pathname involving "." or "..".
  //
  // A pathname with multiple consecutive separators may occur either through
  // user error or as a result of some scripts or APIs that generate a pathname

The Gradle team uses ADRs to record architectural decisions that the team has made.

See [Architecture decisions records](standards) for the list of ADRs.
Be aware these are very technical descriptions of the decisions, and you might find the documentation below more useful as an introduction to the internals of Gradle.

## Platform architecture

Gradle is arranged into several coarse-grained components called "platforms".

        fixture.assertStateStored {
            projectConfigured(":")
            modelsCreated(":", 3)
        }

        and:
        (model.left as GradleProject).name == "hello-world"
        (model.right as EclipseProject).gradleProject.name == "hello-world"

        and:
        def streamedModels = listener1.models as List<CustomModel>
        streamedModels.size() == 2
        streamedModels[0].value == 1

    font-size: 240%;
    text-align: right;
}

.chapter > .titlepage h2 {
    font-size: 400%;
    text-align: right;
}

.chapter > .titlepage {
    margin-bottom: 4em;
}

.appendix > .titlepage h1 {
    font-size: 240%;
    text-align: right;
}

.appendix > .titlepage h2 {
    font-size: 400%;
    text-align: right;
}

.appendix > .titlepage {

        @Override
        public int compare(ResolvableSelectorState left, ResolvableSelectorState right) {
            if (right.isProject() == left.isProject()) {
                if (right.isFromLock() == left.isFromLock()) {
                    if (hasLatestSelector(right) == hasLatestSelector(left)) {
                        if (isDynamicSelector(right) == isDynamicSelector(left)) {

            // Empty path, might match when more elements added
            return true;
        }
        if (!step.matches(segments[startIndex])) {
            // Does not match element, will never match when more elements added
            return false;
        }
        if (startIndex +1 == segments.length) {
            // End of path, might match when more elements added
            return true;

public class ModelRuleSourceDetector {

    private static final Comparator<Class<?>> COMPARE_BY_CLASS_NAME = new Comparator<Class<?>>() {
        @Override
        public int compare(Class<?> left, Class<?> right) {
            return left.getName().compareTo(right.getName());
        }
    };

    final LoadingCache<Class<?>, Collection<Reference<Class<? extends RuleSource>>>> cache = CacheBuilder.newBuilder()
            .weakKeys()

        return new Ordering<ModelType<? extends T>>() {
            @Override
            public int compare(ModelType<? extends T> left, ModelType<? extends T> right) {
                return left.getDisplayName().compareTo(right.getDisplayName());
            }
        };
    }

    /**
     * Returns the sorted, unique display names of the given types.
     */

    GRACEFUL_EXPIRE,
    IMMEDIATE_EXPIRE;

    public static DaemonExpirationStatus highestPriorityOf(DaemonExpirationStatus left, DaemonExpirationStatus right) {
        if (left.ordinal() > right.ordinal()) {
            return left;
        } else {
            return right;
        }
    }

import org.gradle.nativeplatform.platform.internal.DefaultNativePlatform

abstract class AbstractNativeLanguageComponentIntegrationTest extends AbstractInstalledToolChainIntegrationSpec {

    def "binaries have the right platform type"() {
        given:
        makeSingleProject()
        buildFile << """
            task verifyBinariesPlatformType {
                doLast {