}{
		{
			name: "valid",
			b: Builder{
				Kind:         "Empty",
				Plural:       "Empties",
				ProtoPackage: "github.com/gogo/protobuf/types",
				Proto:        "google.protobuf.Empty",
			},
			expectError: false,
		},
		{
			name: "invalid kind",
			b: Builder{
				Kind:         "",
				Plural:       "Empties",
				ProtoPackage: "github.com/gogo/protobuf/types",
				Proto:        "google.protobuf.Empty",

	"istio.io/istio/pkg/config"
	"istio.io/istio/pkg/config/schema/collection"
	"istio.io/istio/pkg/config/schema/resource"
)

var (
	emptyResource = resource.Builder{
		Kind:         "Empty",
		Plural:       "empties",
		ProtoPackage: "google.golang.org/protobuf/types/known/emptypb",
		Proto:        "google.protobuf.Empty",
	}.MustBuild()

	structResource = resource.Builder{
		Kind:         "Struct",
		Plural:       "structs",

import org.gradle.internal.snapshot.TestSnapshotFixture
import spock.lang.Specification

class OutputFileChangesTest extends Specification implements TestSnapshotFixture {

    def "empties"() {
        expect:
        changes(
            FileSystemSnapshot.EMPTY,
            FileSystemSnapshot.EMPTY
        ) == []
    }

    def "equal hash for #current.type"() {
        expect:

	scav := sys.OnesCount64(c.scav & mask)
	c.cache &^= mask // mark in-use bits
	c.scav &^= mask  // clear scavenged bits
	return c.base + uintptr(i*pageSize), uintptr(scav) * pageSize
}

// flush empties out unallocated free pages in the given cache
// into s. Then, it clears the cache, such that empty returns
// true.
//
// p.mheapLock must be held.
//
// Must run on the system stack because p.mheapLock must be held.

	return set.Insert(items...)
}

// Delete removes all items from the set.
func (s Set[T]) Delete(items ...T) Set[T] {
	for _, item := range items {
		delete(s, item)
	}
	return s
}

// Clear empties the set.
// It is preferable to replace the set with a newly constructed set,
// but not all callers can do that (when there are other references to the map).
func (s Set[T]) Clear() Set[T] {
	clear(s)
	return s
}

	// TODO: What is the latency cost of this? Tune this value.
	wbBufEntries = 512

	// Maximum number of entries that we need to ask from the
	// buffer in a single call.
	wbMaxEntriesPerCall = 8
)

// reset empties b by resetting its next and end pointers.
func (b *wbBuf) reset() {
	start := uintptr(unsafe.Pointer(&b.buf[0]))
	b.next = start
	if testSmallBuf {
		// For testing, make the buffer smaller but more than

	metrics.EndpointChangesPending.Set(0)

	return ect.endpointSliceCache.checkoutChanges()
}

// checkoutTriggerTimes applies the locally cached trigger times to a map of
// trigger times that have been passed in and empties the local cache.
func (ect *EndpointsChangeTracker) checkoutTriggerTimes(lastChangeTriggerTimes *map[types.NamespacedName][]time.Time) {
	ect.lock.Lock()
	defer ect.lock.Unlock()

    AddFetchOperandToMain(
        main_graph_op,
        /*fetch_operand=*/noop_wrapper_island_op.getControl());

    symbol_table.erase(init_func_op);
  }

  // Empties the "initializers" attribute from the `SessionInitializerOp` since
  // all ops of the initializer ops are cloned into @main.
  session_init_op.setInitializersAttr(ArrayAttr::get(ctx, {}));
}

}  // namespace

import spock.lang.Issue

class TaskDependencyInferenceIntegrationTest extends AbstractIntegrationSpec implements TasksWithInputsAndOutputs {
    def "dependency declared using task provider implies dependency on task"() {
        buildFile << """
            // verify that eager and lazy providers work
            def providerA = tasks.register("a")
            tasks.create("b")

// all namespaces or none
type Instance string

const (
	// Private implies namespace local config
	Private Instance = "."
	// Public implies config is visible to all
	Public Instance = "*"
	// None implies service is visible to no one. Used for services only
	None Instance = "~"
)