.withPathSensitivity(PathSensitivity.NAME_ONLY);

        // Should repositories be able to participate in incremental?
        // At the least, they may be able to express themselves as output files
        // They *might* have input files and other dependencies as well though
        // Inputs: The credentials they need may be expressed in a file
        // Dependencies: Can't think of a case here
    }

    /**

 * </ul>
 * <p>
 * For further details on specific permission for a certain class of user see {@link UserClassFilePermissions}, but in essence
 * each class of users can have the right to READ, WRITE or EXECUTE files.
 * <p>
 * The default permissions used differ between files and directories and are as follows:
 * <ul>

    }

    @Test
    fun `doesn't choke on left being larger than right`() {

        val a = listOf("a", "b", "c", "0", "1", "d")
        val b = listOf("a", "b", "c", "3", "d")

        assertThat(
            commonPrefixOf(listOf(a, b)),
            equalTo(listOf("a", "b", "c"))
        )
    }

    @Test
    fun `doesn't choke on right being larger than left`() {

        val a = listOf("a", "b", "c", "0", "d")

    }

    /**
     * Inherit as little as possible from the parent process' environment.
     *
     * On Unix systems we need to pass a few environment variables to make sure
     * the file system is accessed with the right encoding.
     */
    private static Map<String, Object> sanitizeEnvironment(JavaForkOptions forkOptions) {
        if (!OperatingSystem.current().isUnix()) {
            return ImmutableMap.of();
        }

    }

    private ReservedPortRange reservePortRange() {
        def portRange = getNextPortRange(reservations.size())
        ReservedPortRange range = portRangeFactory.getReservedPortRange(portRange.left, portRange.right)
        reservations.add(range)
        return range
    }

    protected abstract Pair<Integer, Integer> getNextPortRange(int rangeNumber)

    private void releaseRange(ReservedPortRange range) {
        try {

        return !file.isAbsolute() && file.getPath().startsWith(File.separator);
    }

    // We only cache the result of parsing the Maven settings files, but allow this value to be updated in-flight
    // via system properties. This allows the local maven repo to be overridden when publishing to maven
    // (see http://forums.gradle.org/gradle/topics/override_location_of_the_local_maven_repo).

 * some state that tasks use to do their work. A service implementation might hold, for example, an in-memory cache that tasks use
 * to improve performance. Or, as another example, a service implementation might represent a web service that the build starts and
 * uses.
 *

    id("gradlebuild.lifecycle")                  // CI: Add lifecycle tasks to for the CI pipeline (currently needs to be applied early as it might modify global properties)
    id("gradlebuild.generate-subprojects-info")  // CI: Generate subprojects information for the CI testing pipeline fan out

 * limitations under the License.
 */

package org.gradle.internal.logging.events;

import org.gradle.api.logging.LogLevel;

import javax.annotation.Nullable;

/**
 * Notifies output consumers that might be queueing messages to immediately flush their queues.
 */
public class FlushOutputEvent extends OutputEvent implements InteractiveEvent {
    @Nullable
    @Override
    public LogLevel getLogLevel() {

     *
     * @param sourceDescription a description of the source of plugins, where the plugin requested could not be found
     * @param notFoundMessage message on why the plugin couldn't be found (e.g. it might be available by a different version)
     */
    public static PluginResolutionResult notFound(String sourceDescription, String notFoundMessage) {