<project name="ant-import-sample" default="package" basedir=".">
    <property name="src.dir" value="src"/>
    <property name="build.dir" value="target"/>
    <property name="classes.dir" value="${build.dir}/classes"/>

    <target name="cleanAll">
        <delete dir="${build.dir}"/>
    </target>

    <target name="prepare">
        <tstamp>
            <format property="now" pattern="yyyy-MM-dd hh:mm:ss"/>
        </tstamp>
    </target>

<project name="ant-import-sample" default="package" basedir=".">
    <property name="src.dir" value="src"/>
    <property name="build.dir" value="target"/>
    <property name="classes.dir" value="${build.dir}/classes"/>

    <target name="cleanAll">
        <delete dir="${build.dir}"/>
    </target>

    <target name="prepare">
        <tstamp>
            <format property="now" pattern="yyyy-MM-dd hh:mm:ss"/>
        </tstamp>
    </target>

	// Get retrieves the cached value if it exists.
	Get(key K) *discovery.Resource
	// Clear removes the cache entries that are dependent on the configs passed.
	Clear(sets.Set[ConfigKey])
	// ClearAll clears the entire cache.
	ClearAll()
	// Keys returns all currently configured keys. This is for testing/debug only
	Keys() []K
	// Snapshot returns a snapshot of all keys and values. This is for testing/debug only

    def "updateFile throws integrity exception when not cleanly unlocked file"() {
        given:
        unlockUncleanly()

        and:
        def lock = createLock(Exclusive)

        when:
        lock.updateFile {}

        then:
        thrown FileIntegrityViolationException
    }

    def "writeFile does not throw integrity exception when not cleanly unlocked file"() {
        given:

/**
 * Indicates the state of the daemon when it stops doing work.
 */
public enum DaemonStopState {
    /**
     * Daemon was stopped cleanly and all work stopped.
     */
    Clean,
    /**
     * Daemon could not be stopped cleanly and some work may still be running.
     */
    Forced

		v := mkv(n)
		time.Sleep(time.Millisecond * time.Duration(rand.Intn(100)))
		req := &model.PushRequest{Start: start}
		c.Add(k, req, v)
	}
	// 5 round of xds push
	for vals := 0; vals < 5; vals++ {
		c.ClearAll()
		n.Inc()
		start := time.Now()
		for i := 0; i < 5; i++ {
			go work(start, n.Load())
		}
		retry.UntilOrFail(t, func() bool {
			val := c.Get(k)

	x.cds.Clear(s)
	// clear all EDS cache for PA change
	if HasConfigsOfKind(s, kind.PeerAuthentication) {
		x.eds.ClearAll()
	} else {
		x.eds.Clear(s)
	}
	x.rds.Clear(s)
	x.sds.Clear(s)
}

func (x XdsCacheImpl) ClearAll() {
	x.cds.ClearAll()
	x.eds.ClearAll()
	x.rds.ClearAll()
	x.sds.ClearAll()
}

func (x XdsCacheImpl) Keys(t string) []any {
	switch t {
	case CDSType:

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Torture test for goroutines.
// Make a lot of goroutines, threaded together, and tear them down cleanly.

package main

import (
	"os"
	"strconv"
)

func f(left, right chan int) {
	left <- <-right
}

func main() {
	var n = 10000
	if len(os.Args) > 1 {
		var err error

            assertTestFailed("normalFailingTest", containsString("AssertionError"))
        }
    }

    def "fails cleanly even if an exception is thrown that doesn't serialize cleanly"() {
        given:
        file('src/test/java/ExceptionTest.java') << """
            ${testFrameworkImports}
            import java.io.*;

            public class ExceptionTest {

// appearsSuccessful reports whether the command appears to have run successfully.
// If the command runs longer than the timeout, it's deemed successful.
// If the command runs within the timeout, it's deemed successful if it exited cleanly.
func appearsSuccessful(cmd *exec.Cmd, timeout time.Duration) bool {
	errc := make(chan error, 1)
	go func() {
		errc <- cmd.Wait()
	}()

	select {
	case <-time.After(timeout):
		return true