}

    def "jar issues correct warnings if built jar contains multiple bad descriptors" (String descriptorContents, String warningMessage, int messageCount) {
        given:
        buildFile()
        badPluginDescriptor('bad-plugin1', descriptorContents)
        badPluginDescriptor('bad-plugin2', descriptorContents)
        goodPlugin()

        expect:
        succeeds "jar"

					absentOwnerCache: []objectReference{pod2ns1}, // cached absence of bad parent
				}),
			},
		},
		// child that is cluster-scoped with owner reference to namespaced type in namespace B
		// * should not be deleted
		// * event should be logged in namespace kube-system with involvedObject of bad-child indicating the error
		{
			name: "bad cluster-scoped child -> owner in ns1 (child first)",
			steps: []step{

		return nil, nil, fmt.Errorf("malformed test %s: bad filename %s", testPath, ar.Files[0].Name)
	}
	if ar.Files[1].Name != "trace" {
		return nil, nil, fmt.Errorf("malformed test %s: bad filename %s", testPath, ar.Files[1].Name)
	}
	tr, err := raw.NewTextReader(bytes.NewReader(ar.Files[1].Data))
	if err != nil {
		return nil, nil, fmt.Errorf("malformed test %s: bad trace file: %v", testPath, err)
	}
	var buf bytes.Buffer

	tests := []struct {
		name    string
		config  string
		want    []string
		wantErr string
	}{
		{
			name: "bad namespace",
			config: `
include:
  - bad*
  - ns1`,
			want: ns1,
		},
		{
			name: "bad deployments",
			config: `
include:
  - ns1/bad*
  - ns1/d1`,
			want: d1,
		},
		{
			name: "container multiple",
			config: `
include:
  - /*/*/*/*/c1

	}
	obj := &networking.ServiceCIDR{Spec: networking.ServiceCIDRSpec{CIDRs: []string{"bad cidr"}}}

	errors := Strategy.Validate(context.TODO(), obj)
	if len(errors) != 2 {
		t.Errorf("Expected 2 validation errors for invalid object, got %d", len(errors))
	}

	oldObj := newServiceCIDR()
	newObj := oldObj.DeepCopy()
	newObj.Spec.CIDRs = []string{"bad cidr"}
	errors = Strategy.ValidateUpdate(context.TODO(), newObj, oldObj)

import "testing"

func TestA(t *testing.T) {
	if AFunc() != 42 {
		t.Fatalf("bad!")
	}
}
-- b/b.go --
package b

func init() {
	println("package 'b' init: release the kraken")
}

func BFunc() int {
	return -42
}
-- b/b_test.go --
package b

import "testing"

func TestB(t *testing.T) {
	if BFunc() != -42 {
		t.Fatalf("bad!")
	}
}
-- f/f.go --
package f

func Id() int {

        given:
        def output = """
FAILURE: Build completed with 2 failures.

* Where: build file 'build.gradle' line: 123

* What went wrong:
something bad

* Try:
fixing

* What went wrong:
something else bad

* Try:
fixing
"""
        when:
        def failure = OutputScrapingExecutionFailure.from(output, "")

        then:
        failure.assertHasFailures(2)

	if unsafe.Sizeof(a) != 1 {
		throw("bad a")
	}
	if unsafe.Sizeof(b) != 1 {
		throw("bad b")
	}
	if unsafe.Sizeof(c) != 2 {
		throw("bad c")
	}
	if unsafe.Sizeof(d) != 2 {
		throw("bad d")
	}
	if unsafe.Sizeof(e) != 4 {
		throw("bad e")
	}
	if unsafe.Sizeof(f) != 4 {
		throw("bad f")
	}
	if unsafe.Sizeof(g) != 8 {
		throw("bad g")
	}
	if unsafe.Sizeof(h) != 8 {

	if got := ctxt.update("", nullaryP, []Type{Typ[Int]}, inst); got != inst {
		t.Error("bad")
	}

	// unaryP is not identical to nullaryP, so we should not get inst when
	// instantiated with identical type arguments.
	if got := ctxt.lookup("", unaryP, []Type{Typ[Int]}); got != nil {
		t.Error("bad")
	}

	// nullaryQ is identical to nullaryP, so we *should* get inst when

		if !ok {
			break
		}
		if v != 5 {
			return fmt.Errorf("bad iterator: wanted value %d, got %d", 5, v)
		}
	}
	return nil
}

func callerExhaustLocked(i iter.Seq[int]) error {
	runtime.LockOSThread()
	next, _ := iter.Pull(i)
	for {
		v, ok := next()
		if !ok {
			break
		}
		if v != 5 {
			return fmt.Errorf("bad iterator: wanted value %d, got %d", 5, v)
		}
	}
	runtime.UnlockOSThread()