import java.util.AbstractMap;
import java.util.AbstractSet;
import java.util.Iterator;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;

class PropertiesAsMap extends AbstractMap<String, String> {

    private final Map<Object, Object> properties;

    PropertiesAsMap(Map<Object, Object> properties) {
        this.properties = properties;
    }

    @Override

    return fir.valueParameters.map { valueParameter ->
        builder.variableLikeBuilder.buildValueParameterSymbol(valueParameter.symbol)
    }
}

internal fun <D> FirBasedSymbol<D>.createKtTypeParameters(
    builder: KaSymbolByFirBuilder
): List<KaFirTypeParameterSymbol> where D : FirTypeParameterRefsOwner, D : FirDeclaration {
    return fir.typeParameters.map { typeParameter ->

        get() = withValidityAssertion {
            KaFe10JvmTypeMapperContext.getNestedType(fe10Type).allInnerTypes.map { innerType ->
                KaClassTypeQualifier.KaResolvedClassTypeQualifier(
                    innerType.classDescriptor.toKaClassSymbol(analysisContext),
                    innerType.arguments.map { it.toKtTypeProjection(analysisContext) },
                    token
                )
            }
        }

                public Type type() {
                    return null;
                }

                @Override
                public Map<String, PluginContainer> plugins() {
                    if ("JAR".equals(id)) {
                        return Map.of(
                                DEFAULT,
                                PluginContainer.newBuilder()
                                        .plugins(List.of(

            DependencyManagement dependencyManagement = model.getDependencyManagement();
            if (dependencyManagement != null) {
                Map<Object, Dependency> dependencies = new HashMap<>();
                Map<Object, Object> context = Collections.emptyMap();

                for (Dependency dependency : model.getDependencies()) {
                    Object key = getDependencyKey().apply(dependency);

        dependencies.remove(root);
        return map(dependencies, session::getNode);
    }

    private static DependencyFilter getScopeDependencyFilter(PathScope scope) {
        Set<String> scopes =
                scope.dependencyScopes().stream().map(DependencyScope::id).collect(Collectors.toSet());
        return (n, p) -> {

 * @since 4.0.0
 */
class DefaultModelTransformerContext implements ModelTransformerContext {
    final ModelProcessor modelLocator;

    final Map<String, String> userProperties = new ConcurrentHashMap<>();

    final Map<Path, Holder> modelByPath = new ConcurrentHashMap<>();

    final Map<GAKey, Holder> modelByGA = new ConcurrentHashMap<>();

    public static class Holder {
        private volatile boolean set;

    @Mock
    Session session;

    @BeforeEach
    void setup() {
        Map<String, String> map = System.getProperties().entrySet().stream()
                .collect(Collectors.toMap(
                        e -> e.getKey().toString(), e -> e.getValue().toString()));
        //        lenient().when(session.getSystemProperties()).thenReturn(map);
        //        lenient().when(session.getUserProperties()).thenReturn(Collections.emptyMap());

        return element.getDiagnostics(firResolveSession, filter.asLLFilter()).map { it.asKtDiagnostic() }
    }

    override fun collectDiagnosticsForFile(ktFile: KtFile, filter: KaDiagnosticCheckerFilter): Collection<KaDiagnosticWithPsi<*>> =
        ktFile.collectDiagnosticsForFile(firResolveSession, filter.asLLFilter()).map { it.asKtDiagnostic() }


    private fun KaDiagnosticCheckerFilter.asLLFilter() = when (this) {

        return Objects.equals(p, packaging);
    }

    private static Optional<String> getActivationPackaging(Profile profile) {
        return Optional.ofNullable(profile).map(Profile::getActivation).map(Activation::getPackaging);
    }