"runtime/trace"
	"time"
)

type node struct {
	children [4]*node
	data     [128]byte
}

func makeTree(depth int) *node {
	if depth == 0 {
		return new(node)
	}
	return &node{
		children: [4]*node{
			makeTree(depth - 1),
			makeTree(depth - 1),
			makeTree(depth - 1),
			makeTree(depth - 1),
		},
	}
}

var trees [16]*node
var ballast *[16]*[1024]*node
var sink [][]byte

			te.Errorf("Wrong t.Size() %v, expected %v for %v", t.Size(), k, t.DebugString())
			return
		}
	}
	return
}

func applicInsert(te *testing.T, x []int32) {
	makeTree(te, x, true)
}

func applicFind(te *testing.T, x []int32) {
	t, _, _, _ := makeTree(te, x, false)

	for _, d := range x {
		d = d + d // double everything for Glb/Lub testing.
		s := fmt.Sprintf("%v", d)
		f := t.Find(d)

		// data

			0,
		},
	},
	0,
}

func walkTree(n *Node, path string, f func(path string, n *Node)) {
	f(path, n)
	for _, e := range n.entries {
		walkTree(e, pathpkg.Join(path, e.name), f)
	}
}

func makeTree() FS {
	fsys := fstest.MapFS{}
	walkTree(tree, tree.name, func(path string, n *Node) {
		if n.entries == nil {
			fsys[path] = &fstest.MapFile{}
		} else {
			fsys[path] = &fstest.MapFile{Mode: ModeDir}
		}
	})

		xtree = makeTree(18)
		// Give the GC time to start scanning stacks.
		time.Sleep(time.Millisecond)
		panic(1)
	})
	_ = xtree
}

type xtreeNode struct {
	l, r *xtreeNode
}

func makeTree(d int) *xtreeNode {
	if d == 0 {
		return new(xtreeNode)
	}
	return &xtreeNode{makeTree(d - 1), makeTree(d - 1)}
}

// use about n KB of stack and call f

	f(path, n)
	for _, e := range n.entries {
		walkTree(e, filepath.Join(path, e.name), f)
	}
}

func makeTree(t *testing.T) {
	walkTree(tree, tree.name, func(path string, n *Node) {
		if n.entries == nil {
			fd, err := os.Create(path)
			if err != nil {
				t.Errorf("makeTree: %v", err)
				return
			}
			fd.Close()
		} else {
			os.Mkdir(path, 0770)
		}
	})
}

    /**
     * Each project produces a 'blue' variant, and has a `resolve` task that resolves the 'green' variant and a 'MakeGreen' transform that converts 'blue' to 'green'.
     * By default the variant will contain a single file,  this can be configured using the supplied {@link Builder}.
     * Caller will need to provide an implementation of 'MakeGreen' transform configuration and use {@link TransformBuilder#params(java.lang.String)} to specify the configuration to

            transformActionClass: "MakeGreen",
            transformerName: "MakeGreen",
            subjectName: "producer.out1.jar (project :producer)",
        ])
        checkExecutePlannedStepOperation(executePlannedStepOps, expectedTransformId2, [
            transformActionClass: "MakeGreen",
            transformerName: "MakeGreen",
            subjectName: "producer.out2.jar (project :producer)",

        setupBuildWithColorTransform {
            params("""
                someFiles.from { project.inputFiles }
            """)
        }
        buildFile << """
            abstract class MakeGreen implements TransformAction<Parameters> {
                interface Parameters extends TransformParameters{
                    $inputAnnotations
                    ConfigurableFileCollection getSomeFiles()
                }

        failure.assertThatCause(matchesRegexp('Could not isolate parameters MakeGreen\\$Parameters_Decorated@.* of artifact transform MakeGreen'))
        failure.assertHasCause('Some problems were found with the configuration of the artifact transform parameter MakeGreen.Parameters.')
        failure.assertHasCause(invalidUseOfCacheableAnnotation {
            type('MakeGreen.Parameters').invalidAnnotation('CacheableTask').onlyMakesSenseOn('Task').includeLink()

	defer server.Close()

	makeReq(t, server.URL, constants.LivenessEndpoint, http.StatusOK)
	makeReq(t, server.URL, constants.ReadinessEndpoint, http.StatusServiceUnavailable)

	installReady.Store(true)
	watchReady.Store(true)
	assert.Equal(t, installReady.Load(), true)
	assert.Equal(t, watchReady.Load(), true)

	makeReq(t, server.URL, constants.LivenessEndpoint, http.StatusOK)