// This check ensures we do not. If this is failing, check to ensure the bootstrap config matches
				// the XDS response.
				t.Fatalf("found unexpected secrets, should have only default and ROOTCA: %v", output)
			}
		})
}

func jsonUnmarshallOrFail(t test.Failer, context, s string) any {
	t.Helper()
	var val any

	// this is guarded by prettyPrint

                              }
                            ]
                          },
                          "validation_context_sds_secret_config": {
                            "name": "ROOTCA",
                            "sds_config": {
                              "api_config_source": {
                                "api_type": "GRPC",
                                "grpc_services": [

               {
                "prefix": "spiffe://cluster.local/"
               }
              ]
             },
             "validation_context_sds_secret_config": {
              "name": "ROOTCA",
              "sds_config": {
               "api_config_source": {
                "api_type": "GRPC",
                "grpc_services": [
                 {
                  "envoy_grpc": {

			},
			want: MergedPeerAuthentication{
				Mode: model.MTLSPermissive,
			},
		},
		{
			name: "ignore non-emptypb selector in root namespace",
			configs: []*config.Config{
				{
					Meta: config.Meta{
						Name:      "default",
						Namespace: "root-namespace",
					},
					Spec: &v1beta1.PeerAuthentication{
						Selector: &type_beta.WorkloadSelector{
							MatchLabels: map[string]string{

        name: tls
        number: 9080
        protocol: %s
      tls:
        mode: MUTUAL
        privateKey: "httpbinkey.pem"
        serverCertificate: "httpbin.pem"
        caCertificates: "rootCA.pem"
  workloadSelector:
    labels:
      app: foo
---
`, protocol)
	}
	expectedTLSContext := func(filterChain *listener.FilterChain) error {
		tlsContext := &tls.DownstreamTlsContext{}

        """

        when:
        execute(rootBuild, ':root1:compileJava')

        then:
        result.assertTasksExecuted(':root2:compileJava', ':buildA:compileJava', ':root1:compileJava')

        and:
        canRunFromCache(rootBuild, ':root1:compileJava')
    }

    def "can depend back on root build and back on an included build"() {
        given:

                regularFile("root1/one", 0x1234)
            ]),
            directory("root2", [
                regularFile("root2/one", 0x1234),
                regularFile("root2/two", 0x2345)
            ])
        ) == [added("root2/two")]
    }

    def "deep removal"() {
        expect:
        changes(
            directory("root", [
                regularFile("root/one", 0x1234),

        formatter.node("child2")
        formatter.endChildren()

        then:
        formatter.toString() == toPlatformLineSeparators("""root1:
  - child1
  - child2
root2: child1
root3:
  - child1
  - child2""")
    }

    def "can append to root node"() {
        when:
        formatter.node("Some ")
        formatter.append("thing")
        formatter.append(".")

        then:

    private Object rootId;
    private final TestResultProcessor processor;

    public AttachParentTestResultProcessor(TestResultProcessor processor) {
        this.processor = processor;
    }

    @Override
    public void started(TestDescriptorInternal test, TestStartEvent event) {
        if (rootId == null) {
            assert test.isComposite();
            rootId = test.getId();

}

func buildLogsStats(cstat *cadvisorapiv2.ContainerStats, rootFs *cadvisorapiv2.FsInfo) *statsapi.FsStats {
	fsStats := &statsapi.FsStats{
		Time:           metav1.NewTime(cstat.Timestamp),
		AvailableBytes: &rootFs.Available,
		CapacityBytes:  &rootFs.Capacity,
		InodesFree:     rootFs.InodesFree,
		Inodes:         rootFs.Inodes,
	}

	if rootFs.Inodes != nil && rootFs.InodesFree != nil {