exploded-war-child-copy-spec-example.png...

			name: "cluster-scoped bad child, namespaced good child, missing parent",
			steps: []step{
				// setup
				createObjectInClient("", "v1", "pods", "ns1", makeMetadataObj(pod2ns1, pod1ns1)),     // good child
				createObjectInClient("", "v1", "nodes", "", makeMetadataObj(node1, pod1nonamespace)), // bad child

				// 2,3: observe bad child
				processEvent(makeAddEvent(node1, pod1nonamespace)),

            project's {@code child.project.url.inherit.append.path="false"}</p>
            ]]>
          </description>
          <type>String</type>
        </field>
        <field xml.attribute="true" xml.tagName="child.project.url.inherit.append.path">
          <name>childProjectUrlInheritAppendPath</name>
          <version>4.0.0+</version>

        output.count("files: [dir1.classes.dir, lib1.jar.txt]") == 2

        output.count("Transformed") == 0

        when:
        file("lib/lib1.jar").text = "abc"
        file("lib/dir1.classes").file("child2").createFile()

        succeeds ":util:resolve", ":app:resolve"

        then:
        output.count("files: [dir1.classes.dir, lib1.jar.txt]") == 2

        output.count("Transformed") == 2

			fieldPath:       ".a['bbb.c']",
			pathOfFieldPath: path,
			schema:          &sts,
			validFieldPath:  path.Child("a").Child("bbb.c"),
		},
		{
			name:            "Valid map key",
			fieldPath:       ".foo.subAdd",
			pathOfFieldPath: path,
			schema:          &sts,
			validFieldPath:  path.Child("foo").Key("subAdd"),
		},
		{
			name:            "Valid map key",
			fieldPath:       ".foo['subAdd']",

	}
	defaultIngress := istio.DefaultIngressOrFail(t, t)
	for _, mode := range modes {
		var childs []TrafficCall
		for _, sni := range snis {
			for _, alpn := range alpns {
				alpn, sni, mode := alpn, sni, mode
				al := []string{alpn}
				if alpn == "" {
					al = nil
				}
				childs = append(childs, TrafficCall{
					name: fmt.Sprintf("mode:%v,sni:%v,alpn:%v", mode, sni, alpn),

		expectedChains []string
		expectedErr    string
	}{
		{
			// Build the following graph from RFC 4158, figure 7 (note that in this graph edges represent
			// certificates where the parent is the issuer and the child is the subject.) For the certificate
			// C->B, use an unsupported ExtKeyUsage (in this case ExtKeyUsageCodeSigning) which invalidates
			// the path Trust Anchor -> C -> B -> EE. The remaining valid paths should be:

	"chess_pawn":                           "\u265f\ufe0f",
	"chestnut":                             "\U0001f330",
	"chicken":                              "\U0001f414",
	"child":                                "\U0001f9d2",
	"children_crossing":                    "\U0001f6b8",
	"chile":                                "\U0001f1e8\U0001f1f1",
	"chipmunk":                             "\U0001f43f\ufe0f",
	"chocolate_bar":                        "\U0001f36b",

		assert.Equal(t, span.Parent.SpanID(), rootSpan.SpanContext.SpanID(), fmt.Sprintf("image service span %s %s should be child of root span", span.Name, span.Parent.SpanID()))
	}

	for _, span := range runtimeServiceSpans {
		assert.Equal(t, span.Parent.SpanID(), rootSpan.SpanContext.SpanID(), fmt.Sprintf("runtime service span %s %s should be child of root span", span.Name, span.Parent.SpanID()))
	}

	msigrestore(gp.m.sigmask)

	gp.m.locks--
}

// inForkedChild is true while manipulating signals in the child process.
// This is used to avoid calling libc functions in case we are using vfork.
var inForkedChild bool

// Called from syscall package after fork in child.
// It resets non-sigignored signals to the default handler, and
// restores the signal mask in preparation for the exec.
//