parameters.waitTimeMillis.set(${waitTimeMillis}L)
            }
            gradle.services.get(${BuildEventListenerRegistryInternal.name}).onOperationCompletion(endOfBuildWait)
        """.stripIndent()
    }

    /**
     * Generates build logic to ensure builds last for a given minimum time.
     *

        initScript << """
            def listener = gradle.sharedServices.registerIfAbsent("listener", LoggingListener) { }
            def registry = services.get(BuildEventsListenerRegistry)
            registry.onOperationCompletion(listener)
        """

        buildFile << """
            task a
            task b
        """
        executer.beforeExecute {
            usingInitScript(initScript)
        }

    /**
     * Subscribes the given listener to build operation completion events. Note that no start events are forwarded to the listener.
     */
    void onOperationCompletion(Provider<? extends BuildOperationListener> provider);

    void subscribe(Provider<?> provider);

    List<Provider<?>> getSubscriptions();

            onTaskCompletion(Cast.uncheckedCast(provider));
        } else {
            onOperationCompletion(Cast.uncheckedCast(provider));
        }
    }

    @Override
    public void onOperationCompletion(Provider<? extends BuildOperationListener> listenerProvider) {
        if (subscriptions.containsKey(listenerProvider)) {
            return;
        }

                    parameters.buildCacheKeyJson.fileValue(new File("${TextUtil.normaliseFileSeparators(file.absolutePath)}"))
                }
                gradle.services.get(${BuildEventListenerRegistryInternal.name}).onOperationCompletion(collector)
            }
        """
    }

    @Override
    void afterBuild() {
        def rawBuildCacheKeys = (Map<String, List<Integer>>) new JsonSlurper().parse(file)
        buildCacheKeys.clear()

                    parameters.originJson.fileValue(new File("${TextUtil.normaliseFileSeparators(file.absolutePath)}"))
                }
                gradle.services.get(${BuildEventListenerRegistryInternal.name}).onOperationCompletion(collector)
            }
        """
    }

    @Override
    void afterBuild() {
        def rawOrigins = (Map<String, Map<String, String>>) new JsonSlurper().parse(file)
        origins.clear()

                }

                // forces the service to be initialized immediately when configuration cache loads its cache
                gradle.services.get(BuildEventListenerRegistryInternal).onOperationCompletion(outputProgress)

                // forces the service to be initialized immediately
                outputProgress.get()
            }
       """
    }

    @Override
    void afterBuild() {

        def descriptor = descriptor()
        def finishEvent = operationFinishEvent()
        def broadcaster = buildOperationListenerManager.broadcaster

        when:
        registry.onOperationCompletion(provider)

        then:
        registry.subscriptions.size() == 1
        0 * listener._

        when:
        async {
            broadcaster.started(descriptor, startOperationEvent())

            }

            def listener = gradle.sharedServices.registerIfAbsent("listener", ListenerService) { }
            def registry = services.get(BuildEventsListenerRegistry)
            registry.onOperationCompletion(listener)
        """
        def configurationCache = newConfigurationCacheFixture()

        when:
        configurationCacheRun()

        then: 'finish event is dispatched but start and progress are not'

                    }
                }
            }

            def listener = gradle.sharedServices.registerIfAbsent("listener", LoggingListener) { }
            services.get(BuildEventsListenerRegistry).onOperationCompletion(listener)
        """
    }

    def setupExternalDependency(TestFile buildFile = getBuildFile()) {
        def m1 = mavenRepo.module("test", "test", "4.2").publish()