import spock.lang.Specification

class ReportNodeTest extends Specification {

    def "should create a report node with a child"() {
        setup:
        ReportNode reportNode = new ReportNode('myName')
        def child = new ReportNode('child')
        reportNode.append(child)

        expect:
        reportNode.children().size() == 1
    }

    def "should find the first matching child node"() {

			if !hasError(errs, needle) {
				t.Errorf("missing %q in\n%v", needle, errorsAsString(errs))
			}
		},
	}, {
		name: "duplicates",
		conditions: []metav1.Condition{{
			Type: "First",
		}, {

func CamelCaseWithSeparator(n string, sep string) string {
	p := strings.Split(n, sep)
	for i := 0; i < len(p); i++ {
		p[i] = CamelCase(p[i])
	}
	return strings.Join(p, "")
}

// CamelCaseToKebabCase converts "MyName" to "my-name"
func CamelCaseToKebabCase(s string) string {
	switch s {
	case "HTTPAPISpec":
		return "http-api-spec"
	case "HTTPRoute":
		return "http-route"
	case "HTTPAPISpecBinding":
		return "http-api-spec-binding"

		errs = append(errs, "name part "+EmptyError())
	} else if len(name) > qualifiedNameMaxLength {
		errs = append(errs, "name part "+MaxLenError(qualifiedNameMaxLength))
	}
	if !qualifiedNameRegexp.MatchString(name) {
		errs = append(errs, "name part "+RegexError(qualifiedNameErrMsg, qualifiedNameFmt, "MyName", "my.name", "123-abc"))
	}
	return errs
}

// IsFullyQualifiedName checks if the name is fully qualified. This is similar

		expected string
	}{
		// Test a single row table "WithKind" option, prepends "pod" to name.
		{
			columns: []metav1.TableColumnDefinition{
				{Name: "Name", Type: "string", Format: "name"},
				{Name: "Ready", Type: "string"},
				{Name: "Status", Type: "string"},
				{Name: "Retries", Type: "integer"},
				{Name: "Age", Type: "string"},
			},
			rows: []metav1.TableRow{
				{

    }

    static class SampleRule extends ExternalResource {
        private final String name

        // We add a constructor parameter here, so this class can't be instantiated by the default constructor.
        // This way we can test if the class has been initialized correctly by Spock.
        SampleRule(String name) {
            this.name = name
        }

        @Override
        protected void before() throws Throwable {

[source,groovy]
----
import org.gradle.api.Named

interface MyType : Named {
    // Other properties and methods...
}

class MyTypeImpl(override val name: String) : MyType {
    // Implement other properties and methods...
}

// Usage
val instance = MyTypeImpl("myName")
println(instance.name) // Prints: myName
----

	var conditionReasonRegexp = regexp.MustCompile("^" + conditionReasonFmt + "$")

	if !conditionReasonRegexp.MatchString(value) {
		return []string{validation.RegexError(conditionReasonErrMsg, conditionReasonFmt, "my_name", "MY_NAME", "MyName", "ReasonA,ReasonB", "ReasonA:ReasonB")}
	}
	return nil
}

func checkAndAppendError(allErrs field.ErrorList, fieldPath *field.Path, value string, message string) field.ErrorList {
	if len(value) == 0 {

			name:        "qualifiedName",
			expr:        `format.qualifiedName().validate("contains a space")`,
			expectValue: types.OptionalOf(types.NewStringList(types.DefaultTypeAdapter, []string{`name part must consist of alphanumeric characters, '-', '_' or '.', and must start and end with an alphanumeric character (e.g. 'MyName',  or 'my.name',  or '123-abc', regex used for validation is '([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9]')`})),
		},
		{

				return slice
			}(),
		},
	}

	for name, scenario := range scenarios {
		t.Run(name, func(t *testing.T) {
			errs := ValidateResourceSlice(scenario.slice)
			assert.Equal(t, scenario.wantFailures, errs)
		})
	}
}

func TestValidateResourceSliceUpdate(t *testing.T) {
	name := "valid"
	validResourceSlice := testResourceSlice(name, name, name)

	scenarios := map[string]struct {