}

    def "can substitute a classified dependency with a non classified version"() {
        def v1 = mavenRepo.module("org", "lib", "1.0")
            .artifact(classifier: 'classy')
            .publish()
        // classifier doesn't exist anymore
        def v2 = mavenRepo.module("org", "lib", "1.1").publish()
        def trigger = mavenRepo.module("org", "other", "1.0")

        javaLibrary()
        uncheckedModule("org", "foo", "1.0") {
            artifact(classifier: 'classy')
            withSignature {
                keyring.sign(it)
            }
        }
        buildFile << """
            dependencies {
                implementation "org:foo:1.0:classy"
            }
        """

        expect:
        succeeds ":compileJava"

        when:

        }

        where:
        reserved << [
            "class",
            "my-class",
            "my-class-lib"
        ]
    }

    @VersionCatalogProblemTestFor(
        VersionCatalogProblemId.RESERVED_ALIAS_NAME
    )
    def "disallows aliases for dependency which prefix clash with reserved words"() {

        def configuration = conf().extendsFrom(otherConf)
        configuration.getDependencies().add(configurationDependency)

        then:
        dump(configuration) == """
Configuration:  class='class org.gradle.api.internal.artifacts.configurations.DefaultUnlockedConfiguration'  name='conf'  hashcode='${configuration.hashCode()}'  role='Legacy'
Current Usage:

            Interface12.class,
            Interface1.class,
            Interface2.class,
            Class1.class,
            Object.class);
    makeUnmodifiable(types.interfaces().rawTypes())
        .containsExactly(
            Interface3.class,
            Interface12.class,
            Interface1.class,
            Interface2.class,
            Iterable.class);
    makeUnmodifiable(types.classes().rawTypes())

            Interface12.class,
            Interface1.class,
            Interface2.class,
            Class1.class,
            Object.class);
    makeUnmodifiable(types.interfaces().rawTypes())
        .containsExactly(
            Interface3.class,
            Interface12.class,
            Interface1.class,
            Interface2.class,
            Iterable.class);
    makeUnmodifiable(types.classes().rawTypes())

        }
    }

    private static class ClassInspector {
        private final ConcurrentMap<Class<?>, ClassDetails> classes = new ConcurrentHashMap<Class<?>, ClassDetails>();

        /**
         * Does the given class have the given annotation somewhere in its hierarchy?
         */
        boolean hasAnnotation(Class<?> type, Class<? extends Annotation> annotationType) {

     */
    private static final ImmutableSet<Class<?>> MANAGED_PROPERTY_TYPES = ImmutableSet.of(
        ConfigurableFileCollection.class,
        ConfigurableFileTree.class,
        ListProperty.class,
        SetProperty.class,
        MapProperty.class,
        RegularFileProperty.class,
        DirectoryProperty.class,
        Property.class,
        NamedDomainObjectContainer.class,

import org.junit.jupiter.params.provider.ArgumentsSource

class FileSystemParamProvider : SimpleProvider() {
  override fun arguments() =
    listOf(
      FakeFileSystem().apply { emulateUnix() } to false,
      FileSystem.SYSTEM to TestUtil.windows,
      FakeFileSystem().apply { emulateWindows() } to true,
    )
}

@Timeout(60)
@Tag("Slow")
class DiskLruCacheTest {
  private lateinit var filesystem: FaultyFileSystem

    /**
     * A simplified view of {@link ServiceRegistry}
     */
    interface ParentServices {
        Object get(Class<?> type)

        List<Object> getAll(Class<?> type)

        Factory<?> getFactory(Class<?> type)
    }

    @NonNullApi
    private static class MockServiceWrapper implements Service {
        private final Object instance

        MockServiceWrapper(Object instance) {