println("[EDITOR_$severity] '$message' ${position?.line ?: ""}")
        reports.add(IdeReport(severity, message, position))
    }

    fun clear() {
        events.clear()
        reports.clear()
    }

    fun assertSuccessScenario() {
        assertThat(
            events.map { it.event },
            hasItems(
                instanceOf<ResolutionRequest>(),

                IsolateOwners.OwnerGradle(gradle)
            )
            clear()
            IsolatedProjectEvaluationListener(gradle, isolate)
        }
    }

    override fun clear() {
        beforeProject.clear()
        afterProject.clear()
    }

    private
    fun isolate(actions: IsolatedProjectActions, owner: IsolateOwner) =

public interface CalculatedValueCache<K, V> {

    /**
     * @see Map#computeIfAbsent(Object, Function)
     */
    V computeIfAbsent(K key, Function<K, V> factory);

    /**
     * @see Map#clear()
     */
    void clear();

    val conventionsMap = mutableMapOf<String, SoftwareTypeConventionResolutionResults>()

    override fun registerConventions(conventionsBySoftwareType: Map<String, SoftwareTypeConventionResolutionResults>) {
        conventionsMap.clear()
        conventionsMap.putAll(conventionsBySoftwareType)
    }

    override fun findConventions(softwareTypeName: String): SoftwareTypeConventionResolutionResults? =
        conventionsMap[softwareTypeName]

        delegate.matching(spec)

    override fun matching(spec: Closure<Any>): NamedDomainObjectSet<T> =
        delegate.matching(spec)

    override fun clear() =
        delegate.clear()

    override fun addRule(rule: Rule): Rule =
        delegate.addRule(rule)

    override fun addRule(description: String, ruleAction: Closure<Any>): Rule =

        for (Object o : collection) {
            listener.onAccess(o);
            listener.onRemove(o);
        }
        return delegate.removeAll(collection);
    }

    @Override
    public void clear() {
        delegate.clear();
        listener.onClear();
    }

    @Override
    public Iterator<E> iterator() {
        reportAggregatingAccess();
        return Iterators.transform(delegate().iterator(), factory::apply);

                    }
                    break;
                }
            }
        }

        @Override
        public void onStartHtmlElement(String name) {
            attributes.clear();
        }

        @Override
        public void onHtmlElementAttribute(String name, String value) {
            attributes.put(name, value);
        }

        @Override

            try {
                unit.close()
            } catch (ex: Exception) {
                errors.add(ex)
            }
        }
        openJavaCompilationUnitsByFile.clear()
        openKotlinCompilationUnitsByRoot.clear()
        if (errors.isNotEmpty()) {
            throw Exception("Sources repository did not close cleanly").apply {
                errors.forEach(this::addSuppressed)
            }
        }

        def producer = provider.producer
        assert producer.known
        def tasks = []
        producer.visitProducerTasks { tasks.add(it) }
        assert tasks == expected
        tasks.clear()
        producer.visitContentProducerTasks { tasks.add(it) }
        assert tasks == expected
    }

        "removeIf(Predicate)" | call(s -> s.removeIf(e -> false))
    }

    def "method clear is reported"() {
        when:
        set.clear()

        then:
        inner.isEmpty()
        1 * listener.onClear()
        0 * listener._
    }

    def "method #methodName is not reported as aggregating"() {