invalidErrors := []string{
		`[metadata.labels: Invalid value: "x y"`,
		` embedded.kind: Invalid value: "%"`,
		` embedded.metadata.name: Invalid value: ".."`,
		` embeddedNested.kind: Invalid value: "%"`,
		` embeddedNested.metadata.name: Invalid value: ".."`,
		` embeddedNested.embedded.kind: Invalid value: "%"`,
		` embeddedNested.embedded.metadata.name: Invalid value: ".."`,
	}
	for _, s := range invalidErrors {

			add(f.Name, false)
		} else {
			// embedded field
			// spec: "An embedded type must be specified as a type name T or as a
			// pointer to a non-interface type name *T, and T itself may not be a
			// pointer type."
			pos := syntax.StartPos(f.Type) // position of type, for errors
			name := embeddedFieldIdent(f.Type)
			if name == nil {
				check.errorf(pos, InvalidSyntaxTree, "invalid embedded field type %s", f.Type)

// read or write a certificate stored/embedded in a file
type certificateReadWriter interface {
	//Exists return true if the certificate exists
	Exists() (bool, error)

	// Read a certificate stored/embedded in a file
	Read() (*x509.Certificate, error)

	// Write (update) a certificate stored/embedded in a file
	Write(*x509.Certificate, crypto.Signer) error
}

pkg p1, type S2 struct
pkg p1, type S2 struct, Extra bool
pkg p1, type S2 struct, embedded S
pkg p1, type S2 struct, embedded S //deprecated
pkg p1, type SI struct
pkg p1, type SI struct, I int
pkg p1, type T struct
pkg p1, type TPtrExported struct
pkg p1, type TPtrExported struct, embedded *Embedded
pkg p1, type TPtrUnexported struct
pkg p1, type Time struct
pkg p1, type URL struct

// Issue 14729: structs cannot embed unsafe.Pointer per the spec.

package main

import "unsafe"

type s struct { unsafe.Pointer } // ERROR "embedded type cannot be a pointer|embedded type may not be a pointer||embedded field type cannot be unsafe.Pointer"

                                "Embedded Kotlin libraries not found in ${'$'}configuration"
                            })
                        }
                    }
                }
            }

            """
        )

        build("assertions")
    }

    @Test
    fun `all embedded kotlin dependencies are resolvable`() {

        withBuildScript(

    def "supported Gradle version passes check [version = #gradleVersion, embedded = #embedded]"() {
        given:
        BuildResultOutputFeatureCheck featureCheck = new BuildResultOutputFeatureCheck(TestKitFeature.CAPTURE_BUILD_RESULT_OUTPUT_IN_DEBUG.since, embedded)

        when:
        featureCheck.verify()

        then:
        noExceptionThrown()

        where:

                }
            }
        }

        where:
        bundling           | requested         | selected
        Bundling.EMBEDDED | Bundling.EMBEDDED | Bundling.EMBEDDED
        Bundling.EMBEDDED | Bundling.SHADOWED | null
        Bundling.SHADOWED | Bundling.EMBEDDED | Bundling.SHADOWED
        Bundling.SHADOWED | Bundling.SHADOWED | Bundling.SHADOWED
    }

    static Closure<String> defaultStatus() {

    private final boolean embedded;

    public BuildOperationParameters(GradleVersion targetGradleVersion, boolean embedded) {
        this.targetGradleVersion = targetGradleVersion;
        this.embedded = embedded;
    }

    public GradleVersion getTargetGradleVersion() {
        return targetGradleVersion;
    }

    public boolean isEmbedded() {
        return embedded;
    }

// Don't show conflicting methods M embedded via an exported and non-exported
// type.

// T1 has no embedded (level 1) M method due to conflict.
type T4 struct {
	t2
	T2
}

// ----------------------------------------------------------------------------
// Don't show embedded methods of exported anonymous fields unless AllMethods
// is set.

type T4 struct{}