// much activity, or the map gets big and races to insert on
			// the same node are much less likely.
			if newNode == nil {
				newNode = tab.newTraceMapNode(data, size, hash, tab.seq.Add(1))
			}
			if m.CompareAndSwapNoWB(nil, unsafe.Pointer(newNode)) {
				return newNode.id, true
			}
			// Reload n. Because pointers are only stored once,
			// we must have lost the race, and therefore n is not nil

func (b *Builder) VetAction(mode, depMode BuildMode, p *load.Package) *Action {
	a := b.vetAction(mode, depMode, p)
	a.VetxOnly = false
	return a
}

func (b *Builder) vetAction(mode, depMode BuildMode, p *load.Package) *Action {
	// Construct vet action.
	a := b.cacheAction("vet", p, func() *Action {
		a1 := b.CompileAction(mode|ModeVetOnly, depMode, p)

		// vet expects to be able to import "fmt".

			name:  "case-insensitive match treated as unknown field",
			modes: []cbor.DecMode{modes.Decode},
			in:    hex("a1614101"), // {"A": 1}
			into: struct {
				A int `json:"a"`
			}{},
			assertOnError: assertIdenticalError(&cbor.UnknownFieldError{Index: 0}),
		},
		{
			name:  "case-insensitive match ignored in lax mode",
			modes: []cbor.DecMode{modes.DecodeLax},
			in:    hex("a1614101"), // {"A": 1}
			into: struct {

    def "querying the node for non-existent child #vfsSpec.searchedPath yields a missing file (#vfsSpec)"() {
        setupTest(vfsSpec)

        when:
        FileSystemLocationSnapshot foundSnapshot = initialRoot.getNode(searchedPath, CASE_SENSITIVE).get() as FileSystemLocationSnapshot
        then:
        foundSnapshot.type == FileType.Missing
        foundSnapshot.absolutePath == searchedPath.absolutePath

        where:

    }

    @Override
    public ChildMap<T> handleUnrelatedToAnyChild(VfsRelativePath targetPath) {
        String path = targetPath.getAsString();
        T newNode = handler.createChild();
        return withNewChild(path, newNode);
    }

		overlay[from] = &node{actualFilePath: to}

		// Add parent directory nodes to overlay structure.
		childNode := overlay[from]
		for {
			dirNode := overlay[dir]
			if dirNode == nil || dirNode.isDeleted() {
				dirNode = &node{children: make(map[string]*node)}
				overlay[dir] = dirNode
			}
			if childNode.isDeleted() {
				// Only create one parent for a deleted file:
				// the directory only conditionally exists if

		patchedPodNames               sets.Set[string]
		enablePodDisruptionConditions bool
	}{
		{
			name: "nodes present in lister",
			initialInformerNodes: []*v1.Node{
				testutil.NewNode("existing1"),
				testutil.NewNode("existing2"),
			},
			delay: 2 * quarantineTime,
			pods: []*v1.Pod{
				makePod("a", "existing1", v1.PodRunning),
				makePod("b", "existing2", v1.PodFailed),

    public void transform(Node original, File destination) {
        doTransform(original).writeTo(destination);
    }

    public void transform(DomNode original, Writer destination) {
        doTransform(original).writeTo(destination);
    }

    public void transform(DomNode original, OutputStream destination) {
        doTransform(original).writeTo(destination);
    }

}

var allEncModes = []cbor.EncMode{
	modes.Encode,
	modes.EncodeNondeterministic,
}

var decModeNames = map[cbor.DecMode]string{
	modes.Decode:    "Decode",
	modes.DecodeLax: "DecodeLax",
}

var allDecModes = []cbor.DecMode{
	modes.Decode,
	modes.DecodeLax,
}

func assertNilError(t *testing.T, e error) {
	if e != nil {
		t.Errorf("expected nil error, got: %v", e)
	}
}

        }
    }

    RemoteRepository getRemoteRepository(org.eclipse.aether.repository.RemoteRepository repository);

    Node getNode(org.eclipse.aether.graph.DependencyNode node);

    Node getNode(org.eclipse.aether.graph.DependencyNode node, boolean verbose);

    @Nonnull
    Artifact getArtifact(@Nonnull org.eclipse.aether.artifact.Artifact artifact);

    @Nonnull