import java.io.File;
import java.util.Arrays;
import java.util.Collection;
import java.util.function.Supplier;

import static org.gradle.cache.internal.CacheInitializationAction.NO_INIT_REQUIRED;

public class DefaultPersistentDirectoryStore implements ReferencablePersistentCache {

    public static final int CLEANUP_INTERVAL_IN_HOURS = 24;

    private final File dir;
    private final LockOptions lockOptions;

            def context = Stub(BuildOperationContext)
            operation.run(context)
        }
    }

    @Subject @AutoCleanup
    def store = new DefaultPersistentDirectoryStore(cacheDir, "<display>", mode(OnDemand), cacheCleanup, lockManager, Mock(ExecutorFactory), buildOperationRunner)

    def "has useful toString() implementation"() {
        expect:

        def implementation

        when:
        factory.open(tmpDir.testDirectory, null, [prop: 'value'], mode(Exclusive), null, null)

        then:
        1 * opened.accept(_) >> { DefaultPersistentDirectoryStore s -> implementation = s }
        0 * opened._

        when:
        factory.close()

        then:
        1 * closed.accept(implementation)
        0 * _
    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.caching.local.internal

import org.gradle.cache.internal.DefaultPersistentDirectoryStore
import org.gradle.cache.internal.GradleUserHomeCleanupFixture
import org.gradle.integtests.fixtures.AbstractIntegrationSpec
import org.gradle.integtests.fixtures.BuildOperationsFixture

            operation.run(context)
        }
    }

    @Issue("GRADLE-3206")
    def "can create new caches and access them in parallel"() {
        def store = new DefaultPersistentDirectoryStore(cacheDir, "<display>", mode(OnDemand), null, lockManager, executorFactory, buildOperationRunner)
        store.open()

        when:
        async {
            200.times { index ->
                start {

import java.io.InputStream;
import java.io.UncheckedIOException;
import java.util.Map;
import java.util.Properties;
import java.util.function.Consumer;

public class DefaultPersistentDirectoryCache extends DefaultPersistentDirectoryStore implements ReferencablePersistentCache {

    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultPersistentDirectoryCache.class);

    private final Properties properties = new Properties();

            } else {
                cache = new DefaultPersistentDirectoryStore(cacheDir, displayName, lockOptions, cacheCleanupStrategy, lockManager, executorFactory, buildOperationRunner);
            }
            cache.open();