* limitations under the License.
 */

package org.gradle.internal.cc.impl

class ConfigurationCacheMultiProjectIntegrationTest extends AbstractConfigurationCacheIntegrationTest {

    def "reuses cache for absolute task invocation from subproject dir across dirs"() {
        given:
        settingsFile << """
            include 'a', 'b'
        """
        buildScript """
            task ok
        """

import org.gradle.integtests.fixtures.longlived.PersistentBuildProcessIntegrationTest

class ConfigurationCacheClassLoaderCachingIntegrationTest extends PersistentBuildProcessIntegrationTest {

    def "reuses cached ClassLoaders"() {

        given: 'a Task that holds some static data'
        File staticDataLib = file("lib/StaticData.jar").tap {
            parentFile.mkdirs()
        }
        jarWithClasses(

import java.time.Instant;

/**
 * Represents when cache cleanup should be triggered.
 *
 * @since 8.0
 */
public interface CleanupFrequency {
    /**
     * Trigger cleanup once every 24 hours.
     */
    CleanupFrequency DAILY = new CleanupFrequency() {
        @Override
        public boolean requiresCleanup(@Nullable Instant lastCleanupTime) {
            if (lastCleanupTime == null) {

        long now = System.currentTimeMillis()
        def cacheEntries = [
            createCacheEntry(now),
            createCacheEntry(now - TimeUnit.MINUTES.toMillis(15)),
            createCacheEntry(now - TimeUnit.HOURS.toMillis(5)),
        ]

        when:
        cleanupAction.clean(cleanableStore, progressMonitor)

        then:
        cacheEntries[0].assertExists()
        cacheEntries[1].assertExists()

    def target = Mock(MultiProcessSafeIndexedCache)
    def asyncCacheAccess = Mock(AsyncCacheAccess)
    def crossProcessCacheAccess = Mock(CrossProcessCacheAccess)

    def "caches result from backing cache and reuses for other instances with the same cache id"() {
        given:
        def cache = cacheFactory.decorator(100, true).decorate("path/fileSnapshots.bin", "fileSnapshots", target, crossProcessCacheAccess, asyncCacheAccess)

        cache.baseDir == tmpDir.testDirectory
        cache.toString().startsWith "<display>"

        cleanup:
        factory.close()
    }

    void "reuses directory backed cache instances"() {
        when:
        def ref1 = factory.open(tmpDir.testDirectory, null, [prop: 'value'], mode(Exclusive), null, null)

        def serialized = originator.serialize(cl)
        def received = receiver.deserialize(serialized)

        then:
        received != cl
        received.name == cl.name
    }

    def "reuses ClassLoaders for multiple invocations"() {
        def cl = isolated(WrapperPayload, CustomPayload, PayloadInterface)
        def wrapperClass = cl.loadClass(WrapperPayload.name)

 in a known location. This would also help with developer setup i.e. getting
 new developers up and running. They could run a maven command and have all
 their source trees set up in the same way as their colleagues.

 here's what I do currently in the netbeans part of the mavenide project to
 find the relevant subprojects/sibling projects. I check if the user has
 defined the maven.multiproject.includes property in any of his properties