val classSymbol = getSingleTestTargetSymbolOfType<KaNamedClassOrObjectSymbol>(ktFile, testDataPath)

            val actualText = classSymbol.getSealedClassInheritors().joinToString("\n\n") { inheritor ->
                "${inheritor.classId!!}\n${inheritor.render(KaDeclarationRendererForDebug.WITH_QUALIFIED_NAMES)}"
            }

            testServices.assertions.assertEqualsToTestDataFileSibling(actualText)
        }
    }

        this.contentHash = contentHash;
        this.metadata = metadata;
    }

    @Override
    protected Optional<RegularFileSnapshot> relocateDirectAccess(String targetPath, String name, Interner<String> interner) {
        return Optional.of(new RegularFileSnapshot(targetPath, name, contentHash, metadata));
    }

    @Override
    public FileType getType() {
        return FileType.RegularFile;
    }

 */
package org.gradle.api.internal.catalog.parser;

import com.google.common.collect.Interner;
import org.gradle.api.InvalidUserCodeException;

import javax.annotation.Nullable;

public class StrictVersionParser {
    private final Interner<String> stringInterner;

    public StrictVersionParser(Interner<String> stringInterner) {
        this.stringInterner = stringInterner;
    }

    WeakInternerImpl {
      @Override
      public <E> Interner<E> create(Collection<E> contents) {
        Interner<E> interner = Interners.newWeakInterner();
        for (E e : contents) {
          E unused = interner.intern(e);
        }
        return interner;
      }
    },
    StrongInternerImpl {
      @Override
      public <E> Interner<E> create(Collection<E> contents) {

    private static final Interner<IncludeWithSimpleExpression> INTERNER = Interners.newWeakInterner();

    private final String value;
    private final boolean isImport;
    private final IncludeType type;

    public static IncludeWithSimpleExpression create(String value, boolean isImport, IncludeType type) {
        return INTERNER.intern(new IncludeWithSimpleExpression(value, isImport, type));
    }

    private final Cache<HashCode, ClassAnalysis> classAnalysisCache;

    public UserHomeScopedCompileCaches(GlobalScopedCacheBuilderFactory cacheBuilderFactory, InMemoryCacheDecoratorFactory inMemoryCacheDecoratorFactory, StringInterner interner) {
        cache = cacheBuilderFactory
            .createCacheBuilder("javaCompile")
            .withDisplayName("Java compile cache")
            .withInitialLockMode(FileLockManager.LockMode.OnDemand)

        this.typeFilter = typeFilter;
        this.interner = interner;
        collectRemainingClassDependencies(reader);
    }

    public static ClassAnalysis analyze(String className, ClassReader reader, StringInterner interner) {
        ClassDependenciesVisitor visitor = new ClassDependenciesVisitor(new ClassRelevancyFilter(className), reader, interner);
        reader.accept(visitor, ClassReader.SKIP_FRAMES);

    }

    /**
     * Creates a new exception from the specified interim result and its associated problems.
     *
     * @param result The interim result, may be {@code null}.
     */
    public ModelBuildingException(ModelBuildingResult result) {
        super(toMessage(result));
        this.result = result;
    }

    /**
     * Gets the interim result of the model building up to the point where it failed.
     *

    private final Interner<String> stringInterner;

    public ModuleMetadataStore(PathKeyFileStore metaDataStore,
                               ModuleMetadataSerializer moduleMetadataSerializer,
                               ImmutableModuleIdentifierFactory moduleIdentifierFactory,
                               Interner<String> stringInterner) {
        this.metaDataStore = metaDataStore;

    private final Instantiator instantiator;
    private final Class<T> wantedType;
    private final Interner<String> stringInterner;
    private final StrictVersionParser strictVersionParser;

    public DependencyStringNotationConverter(Instantiator instantiator, Class<T> wantedType, Interner<String> stringInterner) {
        this.instantiator = instantiator;
        this.wantedType = wantedType;