def listener = Mock(OperationCompletionListener)
        def provider = Providers.of(listener)

        when:
        registry.onTaskCompletion(provider)
        registry.onTaskCompletion(provider)

        then:
        registry.subscriptions.size() == 1

        cleanup:
        signalBuildFinished()
    }

                }
            }

            def registry = project.services.get(BuildEventsListenerRegistry)
            registry.onTaskCompletion(gradle.sharedServices.registerIfAbsent('listener1', BlockingListener) {
                parameters.prefix = "handle1_"
            })
            registry.onTaskCompletion(gradle.sharedServices.registerIfAbsent('listener2', BlockingListener) {
                parameters.prefix = "handle2_"
            })

        ProviderInternal<?> providerInternal = Providers.internal(provider);
        if (OperationCompletionListener.class.isAssignableFrom(providerInternal.getType())) {
            onTaskCompletion(Cast.uncheckedCast(provider));
        } else {
            onOperationCompletion(Cast.uncheckedCast(provider));
        }
    }

    @Override

                parameters.monitoredTaskPaths = allTasks.filter(taskFilter).map { if (isInBuildLogic) ":build-logic${it.path}" else it.path }.toSet()
            }
            gradle.serviceOf<BuildEventsListenerRegistry>().onTaskCompletion(buildService)
            gradleRootProject.extensions.extraProperties.set("collectedInfo-${klass.simpleName}-${rootProjectName}", buildService.get().collectedInformation)

                void apply(Settings settings) {
                    def service = settings.gradle.sharedServices.registerIfAbsent("listener", ListenerImpl) { }
                    registry.onTaskCompletion(service)
                }
            }
        """

        when:
        def events = runBuild("compileJava")

        then:
        def operation = events.operation("Task :compileJava")

                        final String projectName = project.getName();
                        final String uniqueServiceName = "listener of " + project.getName();
                        getListenerRegistry().onTaskCompletion(
                            project.getGradle().getSharedServices().registerIfAbsent(
                                uniqueServiceName,
                                ListenerBuildService.class,

                    public void apply(Project project) {
                        Provider<MyService> sp = getSharedServices().registerIfAbsent("myService", MyService.class);

                        getListenerRegistry().onTaskCompletion(sp);
                    }
                }
            """

            file("convention-kotlin-plugin/build.gradle.kts") << """
                plugins {
                    `kotlin-dsl`