import org.gradle.test.fixtures.file.TestFile

class TestDeploymentFixture {
    private File triggerFile
    private File keyFile

    void writeToProject(TestFile projectDir) {
        triggerFile = projectDir.file('triggerFile')
        keyFile = projectDir.file('keyFile')

        triggerFile.text = "0"

        projectDir.file("build.gradle") << """
            import javax.inject.Inject

            fixture.assertDeploymentIsRunning(key)

            waitBeforeModification fixture.triggerFile
            fixture.triggerFile << "\n#a change"
            succeeds()
            fixture.assertDeploymentIsRunning(key)

            waitBeforeModification fixture.triggerFile
            fixture.triggerFile << "\n#another change"
            succeeds()
            fixture.assertDeploymentIsRunning(key)

                    idFile << System.identityHashCode(service) + "\\n"
                }
            }
        """

        when:
        triggerFile << "content"

        then:
        succeeds("captureService")

        when:
        triggerFile << "change"

        then:
        buildTriggeredAndSucceeded()

        and:
        def ids = idFile.readLines()
        ids.size() == 2

        then:
        def key = fixture.keyFile.text
        fixture.assertDeploymentIsRunning(key)

        when:
        def lastBuildTime = single(buildTimes)
        waitBeforeModification fixture.triggerFile
        fixture.triggerFile << "\n#a change"
        buildTriggeredAndSucceeded()

        then:
        fixture.assertDeploymentIsRunning(key)
        lastBuildTime >= single(buildTimes)
    }

        given:
        def targetDir = tmpDir.createDir("target")
        def triggerFile = targetDir.createFile("zzz.txt")
        FileTime.makeOld(targetDir, triggerFile)

        and:
        def newFile = targetDir.file("aaa.txt")
        deleter = FileTime.deleterWithDeletionAction() { file ->
            if (file.canonicalFile == triggerFile.canonicalFile) {
                FileTime.createNewFile(newFile)
            }

		return
	}

	startTime := now
	triggerTime := startTime.Add(minTolerationTime)
	scheduledEviction := tc.taintEvictionQueue.GetWorkerUnsafe(podNamespacedName.String())
	if scheduledEviction != nil {
		startTime = scheduledEviction.CreatedAt
		if startTime.Add(minTolerationTime).Before(triggerTime) {
			return
		}
		tc.cancelWorkWithEvent(logger, podNamespacedName)
	}

				},
				Ports:       ports,
				AddressType: addrType,
				Endpoints:   []discovery.Endpoint{},
			},
		},
		{
			name: "create slice from endpoints with labels and annotations triggertime",
			tweakEndpoint: func(ep *v1.Endpoints) {
				labels := map[string]string{"foo": "bar"}
				ep.Labels = labels
				annotations := map[string]string{
					"foo2":                            "bar2",

  - A description of the technical details of the vulnerabilities.
  - A minimal example of the vulnerability. It is very important to let us know
    how we can reproduce your findings. For memory corruption triggerable in
    TensorFlow models, please demonstrate an exploit against one of Alphabet's
    models in <https://tfhub.dev/>
  - An explanation of who can exploit this vulnerability, and what they gain

)

var alwaysReady = func() bool { return true }
var neverReady = func() bool { return false }
var emptyNodeName string
var triggerTime = time.Date(2018, 01, 01, 0, 0, 0, 0, time.UTC)
var triggerTimeString = triggerTime.Format(time.RFC3339Nano)
var oldTriggerTimeString = triggerTime.Add(-time.Hour).Format(time.RFC3339Nano)

var ipv4only = []v1.IPFamily{v1.IPv4Protocol}
var ipv6only = []v1.IPFamily{v1.IPv6Protocol}

	t3 := t2.Add(time.Second)

	createEndpoints := func(namespace, name string, triggerTime time.Time) *discovery.EndpointSlice {
		return &discovery.EndpointSlice{
			ObjectMeta: metav1.ObjectMeta{
				Name:      name,
				Namespace: namespace,
				Annotations: map[string]string{
					v1.EndpointsLastChangeTriggerTime: triggerTime.Format(time.RFC3339Nano),
				},
				Labels: map[string]string{