import java.util.Collection;
import java.util.Collections;
import java.util.Set;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * When describing the features of the collection produced by a given generator (i.e. in a call to
 * {@link
 * com.google.common.collect.testing.FeatureSpecificTestSuiteBuilder#withFeatures(Feature...)}),

                    delete { delete(stateDir) }
                }
            }
        }
    }
}


/**
 * Clean up daemon log files produced in integration tests.
 */
fun FileSystemOperations.removeDaemonLogFiles(dir: Directory) {
    if (dir.asFile.isDirectory) {
        val daemonLogFiles = dir.asFileTree.matching {
            include("**/*.log")

}

func expectRevisionChan(t test.Failer, revisionChan chan string, expected string) {
	select {
	case rev := <-revisionChan:
		if rev != expected {
			t.Fatalf("expected revision %q to be produced on chan, got %q", expected, rev)
		}
	case <-time.After(time.Second * 5):
		t.Fatalf("timed out waiting for value on default revision chan")
	}
}

func TestNoDefaultRevision(t *testing.T) {

import (
	"fmt"
	"text/template/parse"
)

// context describes the state an HTML parser must be in when it reaches the
// portion of HTML produced by evaluating a particular template node.
//
// The zero value of type context is the start context for a template that
// produces an HTML fragment as defined at
// https://www.w3.org/TR/html5/syntax.html#the-end
// where the context element is null.
type context struct {
	state   state

		// responsible for ensuring that all text strings they produce contain valid UTF-8
		// sequences and may use the byte string major type to encode strings that have not
		// been validated.
		UTF8: cbor.UTF8RejectInvalid,

		// Never make a case-insensitive match between a map key and a struct field.
		FieldNameMatching: cbor.FieldNameMatchingCaseSensitive,

		// Produce string concrete values when decoding a CBOR byte string into interface{}.

        return groovyVersionsSupportedByJdk(javaVersion).contains(groovyVersion)
    }

    /**
     * Computes the Java version that corresponds to the Java bytecode version actually produced by the Groovy compiler.
     */
    static JavaVersion getEffectiveTarget(VersionNumber groovyVersion, JavaVersion target) {
        if (groovyVersion.major == 4) {
            return target

import com.google.common.annotations.GwtCompatible;
import javax.annotation.CheckForNull;
import org.checkerframework.checker.nullness.qual.Nullable;

/** A utility method to perform unchecked casts to suppress errors produced by nullness analyses. */
@GwtCompatible
@ElementTypesAreNonnullByDefault
final class NullnessCasts {
  /**
   * Accepts a {@code @Nullable T} and returns a plain {@code T}, without performing any check that

import com.google.common.annotations.GwtCompatible;
import javax.annotation.CheckForNull;
import org.checkerframework.checker.nullness.qual.Nullable;

/** A utility method to perform unchecked casts to suppress errors produced by nullness analyses. */
@GwtCompatible
@ElementTypesAreNonnullByDefault
final class NullnessCasts {
  /**
   * Accepts a {@code @Nullable T} and returns a plain {@code T}, without performing any check that

        when:
        instance.leaveCall(entryBar)
        instance.leaveCall(entryFoo)

        then:
        noExceptionThrown()
    }

    def 'entry points are not interchangeable even if produced by similar calls'() {
        given:
        def entryFoo1 = instance.enterCall("FooCallerClass", "foo", INVOKE_METHOD)
        def entryFoo2 = instance.enterCall("FooCallerClass", "foo", INVOKE_METHOD)

        when:

useful for testing and debugging the tracer in the runtime and more sophisticated
trace parsers.

# Text format specification

The trace text format produced and consumed by this package is a line-oriented
format.

The first line in each text trace is the header line.

	Trace Go1.XX

Following that is a series of event lines. Each event begins with an