events.operations.pop().result.class.getSimpleName() == DefaultFileDownloadSuccessResult.class.getSimpleName()
    }

    private validateOperations(ProgressEvents events, MavenHttpModule projectFModuleMissing, MavenHttpModule projectF2) {
        events.trees == events.operations
        events.operation("Download ${projectFModuleMissing.pom.uri}").assertIsDownload(projectFModuleMissing.pom)

        given:
        def events = []

        when:
        config.add { events << "a" }
        config.add { events << "b" }

        and:
        config.fire()

        then:
        events == ["a", "b"]
    }

    def "fire is idempotent"() {
        given:
        def events = []

        when:
        config.add { events << "a" }
        config.add { events << "b" }

import org.gradle.tooling.events.FailureResult
import org.gradle.tooling.events.OperationType
import org.gradle.tooling.events.ProgressEvent
import org.gradle.tooling.events.SuccessResult
import org.gradle.tooling.events.lifecycle.BuildPhaseFinishEvent
import org.gradle.tooling.events.lifecycle.BuildPhaseOperationDescriptor
import org.gradle.tooling.events.lifecycle.BuildPhaseStartEvent

@ToolingApiVersion('>=7.6')

        def resolveCompileFiles = events.operation(resolveConfigurationFiles(":compileClasspath"), resolveConfigurationFiles(":compileClasspath"))
        def resolveB = events.operation("Resolve group:projectB:1.0")
        def resolveD = events.operation("Resolve group:projectD:2.0-SNAPSHOT")
        def resolveArtifactB = events.operation("Resolve projectB-1.0.jar (group:projectB:1.0)")

	"k8s.io/apimachinery/pkg/watch"
	"k8s.io/client-go/tools/cache"
)

func intervalFromEvents(events []*watchCacheEvent) *watchCacheInterval {
	startIndex, endIndex, locker := 0, len(events), &sync.Mutex{}
	indexer := func(i int) *watchCacheEvent {
		if len(events) == 0 {
			return nil
		}
		return events[i]
	}
	indexValidator := func(_ int) bool { return true }

				// the loop execution will continue.
				defer runtime.HandleCrash()

				events := b.collectEvents(timer, wait.NeverStop)
				b.processEvents(events)
				return len(events) == 0
			}()
		}
	}()
	return b.delegateBackend.Run(stopCh)
}

// Shutdown blocks until stopCh passed to the Run method is closed and all
// events added prior to that moment are batched and sent to the delegate backend.

    def "receives distribution download progress events"() {
        given:
        server.expect(server.get("/custom-dist.zip").sendFile(distribution.binDistribution))

        and:
        def distUri = URI.create("http://localhost:${server.port}/custom-dist.zip")
        toolingApi.withConnector {
            it.useDistribution(distUri)
        }

        when:
        def events = ProgressEvents.create()

import org.gradle.tooling.events.BinaryPluginIdentifier
import org.gradle.tooling.events.OperationType
import org.gradle.tooling.events.ProgressListener
import org.gradle.tooling.events.ScriptPluginIdentifier
import org.gradle.tooling.events.configuration.ProjectConfigurationFailureResult
import org.gradle.tooling.events.configuration.ProjectConfigurationFinishEvent
import org.gradle.tooling.events.configuration.ProjectConfigurationStartEvent

        handler.featureUsed(deprecatedFeatureUsage('feature2'))

        then:
        def events = outputEventListener.events
        events.size() == 2

        and:
        events[0].message == 'feature1 removal'
        events[1].message == 'feature2 removal'
    }

    def 'deprecations are logged at WARN level'() {
        given:
        useStackTrace()

import org.gradle.integtests.tooling.fixture.WithOldConfigurationsSupport
import org.gradle.tooling.ProjectConnection
import org.gradle.tooling.events.test.Destination
import org.gradle.tooling.events.test.JvmTestOperationDescriptor
import org.gradle.tooling.events.test.TestFinishEvent
import org.gradle.tooling.events.test.TestOutputEvent

@TargetGradleVersion('>=6.0')