if (IMMUTABLE_DAEMON_SYSTEM_PROPERTIES.contains(entry.getKey())) {
                immutableSystemProperties.put(entry.getKey(), entry.getValue());
            }
        }
    }

    public Map<String, Object> getImmutableDaemonProperties() {
        return CollectionUtils.filter(immutableSystemProperties, element ->
            IMMUTABLE_DAEMON_SYSTEM_PROPERTIES.contains(element.getKey())
        );
    }

    @Override

      entryArray[i] = makeImmutable(requireNonNull(entryArray[i]));
      K key = entryArray[i].getKey();
      V value = entryArray[i].getValue();
      V oldValue = delegateMap.put(key, value);
      if (oldValue != null) {
        if (throwIfDuplicateKeys) {
          throw conflictException("key", entryArray[i], entryArray[i].getKey() + "=" + oldValue);
        }
        if (duplicates == null) {
          duplicates = new HashMap<>();

            .anyMatch(entry -> entry.getKey().matches(relativePathSegments.get(), 0));
    }

    @Nullable
    private ResourceEntryFilter matchingFiltersFor(Supplier<String[]> relativePathSegments) {
        List<ResourceEntryFilter> matchingFilters = propertiesFileFilters.entrySet().stream()
            .filter(entry -> entry.getKey().matches(relativePathSegments.get(), 0))

        ObjectListing objectListing = Mock()
        objectListing.getPrefix() >> 'root/'
        S3ObjectSummary objectSummary = Mock()
        objectSummary.getKey() >> '/SNAPSHOT/some.jar'

        S3ObjectSummary objectSummary2 = Mock()
        objectSummary2.getKey() >> '/SNAPSHOT/someOther.jar'
        objectListing.getObjectSummaries() >> [objectSummary, objectSummary2]
        objectListing.getCommonPrefixes() >> ['root/SNAPSHOT']

        }

        analyseForTest(ktFile) {
            val diagnosticsInFile =
                ktFile.collectDiagnosticsForFile(KaDiagnosticCheckerFilter.EXTENDED_AND_COMMON_CHECKERS).map { it.getKey() }.sorted()
            val diagnosticsFromElements = buildList {
                ktFile.accept(object : KtTreeVisitorVoid() {
                    override fun visitKtElement(element: KtElement) {

    private static <T> Map<AccessorKey, T> diff(Map<AccessorKey, T> first, Map<AccessorKey, T> second) {
        return first.entrySet().stream()
            .filter(e -> !second.containsKey(e.getKey()))
            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
    }

            Map.Entry<K, ? extends VP> previousEntry = previousEntries.next();
            while (true) {
                K previousProperty = previousEntry.getKey();
                K currentProperty = currentEntry.getKey();
                int compared = comparator.compare(previousProperty, currentProperty);
                if (compared < 0) {
                    if (!diffListener.removed(previousProperty)) {

        artifacts.add(artifact);
    }

    public Object getKey() {
        return getGroupId() + ':' + getArtifactId() + ':' + getVersion();
    }

    public static Object getKey(Artifact artifact) {
        return artifact.getGroupId() + ':' + artifact.getArtifactId() + ':' + artifact.getBaseVersion();
    }

    protected String getKey(String classifier, String extension) {
        return classifier + ':' + extension;

                if (entry.getValue() == null) {
                    throw new IllegalArgumentException("Null value provided for binding '" + entry.getKey() + "'.");
                }
                wrappedBindings.put(entry.getKey(), new TemplateValue(entry.getValue()));
            }
            return new SimpleTemplateOperation(templateUrl, target, wrappedBindings);
        }
    }

        for (Map.Entry<NamespaceId, String> entry : extraInfo.entrySet()) {
            if (entry.getKey().getName().equals(name)) {
                foundEntries.add(entry);
            }
        }
        if (foundEntries.size() > 1) {
            String allNamespaces = Joiner.on(", ").join(CollectionUtils.collect(foundEntries, original -> original.getKey().getNamespace()));