@Test
    void "caches compiled build script"() {
        createLargeBuildScript()
        testBuild("hello1", "Hello 1")
        TestFile.Snapshot classFileSnapshot = classFile.snapshot()

        testBuild("hello2", "Hello 2")
        classFile.assertHasNotChangedSince(classFileSnapshot)

        modifyLargeBuildScript()
        testBuild("newTask", "I am new")
        classFile.assertHasChangedSince(classFileSnapshot)
    }

/**
 * Tests {@code Model}.
 *
 */
class ModelTest {

    @Test
    void testHashCodeNullSafe() {
        new Model().hashCode();
    }

    @Test
    void testBuild() {
        Model model = new Model();
        Build build = new Build();
        build.setOutputDirectory("myOutputDirectory");
        model.setBuild(build);
        Build build2 = model.getBuild();

			g := NewWithT(t)

			err := c.b.BuildNoValidate().Validate()
			if c.expectError {
				g.Expect(err).ToNot(BeNil())
			} else {
				g.Expect(err).To(BeNil())
			}
		})
	}
}

func TestBuild(t *testing.T) {
	cases := []struct {
		name        string
		b           Builder
		expectError bool
	}{
		{
			name: "valid",
			b: Builder{
				Kind:         "Empty",
				Plural:       "Empties",

	for i, testCase := range testCases {
		if sipHashElement := hashKey("SIPMOD", testCase.objectName, 200, testUUID); sipHashElement != testCase.sipHash {
			t.Errorf("Test case %d: Expected \"%v\" but failed \"%v\"", i+1, testCase.sipHash, sipHashElement)
		}
	}

	if sipHashElement := hashKey("SIPMOD", "This will fail", -1, testUUID); sipHashElement != -1 {
		t.Errorf("Test: Expected \"-1\" but got \"%v\"", sipHashElement)
	}

	}
}

func TestUpsertPodCache(t *testing.T) {
	counter.Store(0)

	p := newPodNetnsCache(openNsTestOverrideWithInodes(1, 1))

	pod := &corev1.Pod{ObjectMeta: metav1.ObjectMeta{UID: "testUID"}}
	nspath1 := "/path/to/netns/1"
	nspath2 := "/path/to/netns/2"

	netns1, err := p.UpsertPodCache(pod, nspath1)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

}

func Example_test() {
	// This test will not be run, it has no "Output:" comment.
}
-- test_test.go --
package pkg

import (
	"os"
	"testing"
)

func TestBuilt(t *testing.T) {
	os.Stdout.Write([]byte("A normal test was executed.\n"))

	}
	if err := privesc("chmod", "u+s", bin); err != nil {
		t.Skipf("unable to set permissions on test binary, likely no passwordless sudo/su: %s", err)
	}
}

func TestSUID(t *testing.T) {
	// This test is relatively simple, we build a test program which opens a
	// file passed via the TEST_OUTPUT envvar, prints the value of the

				assert.Equal(t, podName, name, "pod name")
				assert.Equal(t, podNamespace, namespace, "pod namespace")
				if test.uid {
					assert.Equal(t, testUID, string(uid), "uid")
				}
			}

			ss.fakeRuntime.portForwardFunc = func(podSandboxID string, port int32, stream io.ReadWriteCloser) error {
				defer close(portForwardFuncDone)