then:
        0 * listener._
    }

    def "method #methodName is reported as aggregating"() {
        when:
        operation.accept(set)

        then:
        (1.._) * listener.onAggregatingAccess()
        0 * listener._

        where:
        methodName            | operation
        "iterator()"          | call(s -> s.iterator())

    }

    @Issue("https://github.com/gradle/gradle/issues/9487")
    def "best effort to capture multi-cause exceptions using adhoc exception type (methodName=#methodName)"() {
        given:
        buildFile << """
            apply plugin: 'java-library'

            ${mavenCentralRepository()}

            dependencies {

    }

    override suspend fun ReadContext.decode(): Method? {
        val declaringClass = readClass()
        val methodName = readString()
        val parameterTypes = readClassArray()
        return declaringClass.getDeclaredMethod(methodName, *parameterTypes)
    }

            this.target = target;
            this.methodName = methodName;
            this.arguments = singletonList(closureArg);
        }

        MethodInvocationExpression(String methodName) {
            this(null, methodName, Collections.emptyList());
        }

        @Override
        public String with(Syntax syntax) {

        "invokeMethod(receiver, methodName, (Object[]) arguments)"            | { instance.metaClass.invokeMethod(instance, "test", [].toArray()) }                           | true        | false

        } finally {
            Thread.currentThread().setContextClassLoader(original);
        }
    }

    protected void doExecute(Task task, String methodName) {
        JavaMethod.of(task, Object.class, methodName).invoke(task);
    }

    @Override
    public ImplementationSnapshot getActionImplementation(ClassLoaderHierarchyHasher hasher) {

            return "@ExtendWith({ ${runOrExtendWithClasses} })"
        }

        @Override
        String maybeParentheses(String methodName) {
            return "${methodName}()"
        }

        @Override
        String getIgnoreOrDisabledAnnotation() {
            return "@Disabled"
        }
    }

        protected void destroy() {
            final BeanDesc beanDesc = BeanDescFactory.getBeanDesc(instance.getClass());
            for (final String methodName : beanDesc.getMethodNames()) {
                final MethodDesc methodDesc = beanDesc.getMethodDescNoException(methodName);
                if (methodDesc != null) {
                    final Method method = methodDesc.getMethod();

    Class<? extends Annotation> getAnnotation() {
        return ComponentType
    }

    def "decent error message for rule declaration problem - #descr"() {
        def ruleMethod = ruleDefinitionForMethod(methodName)
        def ruleDescription = getStringDescription(ruleMethod.method)

        when:
        extract(ruleMethod)

        then:
        def ex = thrown(InvalidModelRuleDeclarationException)

    public static ArchCondition<JavaClass> callMethodWithName(String ownerName, String methodName) {
        return callMethodWhere(JavaCall.Predicates.target(HasOwner.Predicates.With.<JavaClass>owner(name(ownerName)))
            .and(JavaCall.Predicates.target(name(methodName))))
            .as("call method %s.%s", ensureSimpleName(ownerName), methodName);
    }