allClusterGVKs = helmreconciler.ClusterResources
)

func init() {
	if kubeBuilderInstalled() {
		// TestMode is required to not wait in the go client for resources that will never be created in the test server.
		helmreconciler.TestMode = true
		// Add install and controller to the list of commands to run tests against.
		testedManifestCmds = append(testedManifestCmds, cmdApply, cmdController)
	}

        assertNull(compileOptions.configurationScript)
        assertFalse(compileOptions.javaAnnotationProcessing)
        assertFalse(compileOptions.parameters)
    }

    @Test
    void testFork() {
        compileOptions.fork = false
        assertNull(compileOptions.forkOptions.memoryMaximumSize)

        compileOptions.fork([memoryMaximumSize: '1g'])
        assertTrue(compileOptions.fork)

        file("src/test/java/FooTest.java") << """
            import junit.framework.*;

            public class FooTest extends TestCase {
                public void testPass() {}
                public void testOk() {}
            }
        """.stripIndent()

        when:
        succeeds("test", "--tests", "FooTest.testPass")

        then:
        def result = new DefaultTestExecutionResult(testDirectory)

        1 * processor.started({ it.id == 1 }, { it.parentId == null })
        1 * processor.started({ it.id == 2 && it.name == "testOk" && it.className == AJunit3TestClass.name }, { it.parentId == 1 })
        1 * processor.completed(2, { it.resultType == null })
        1 * processor.started({ it.id == 3 && it.name == "testOk" && it.className == BJunit3TestClass.name }, { it.parentId == 1 })
        1 * processor.completed(3, { it.resultType == null })

    assertEquals(-1, counter.read(new byte[30]));
    assertEquals(20, counter.getCount());
  }

  @SuppressWarnings("CheckReturnValue") // calling read() to skip a byte
  public void testMark() throws Exception {
    assertTrue(counter.markSupported());
    assertEquals(10, counter.read(new byte[10]));
    assertEquals(10, counter.getCount());
    counter.mark(5);
    counter.read();

	{"1.21.0", Version{"1", "21", "0", "", ""}},
	{"1.24", Version{"1", "24", "", "", ""}},
	{"1.24rc3", Version{"1", "24", "", "rc", "3"}},
	{"1.24.0", Version{"1", "24", "0", "", ""}},
	{"1.999testmod", Version{"1", "999", "", "testmod", ""}},
	{"1.99999999999999999", Version{"1", "99999999999999999", "", "", ""}},
}

func TestLang(t *testing.T) { test1(t, langTests, "Lang", Lang) }

var langTests = []testCase1[string, string]{
	{"1.2rc3", "1.2"},

                public class NonStaticInner {
                    @Test public void ok() { }
                }

                public class NonStaticInnerTestCase extends TestCase {
                    public void testOk() { }
                }
            }
        """.stripIndent()
        writeCustomRunnerClass('CustomRunnerOrExtension')
        buildFile << """
            apply plugin: 'java'

		b.Fatalf("Failed to copy %d bytes: %v", n, err)
	}

	run(b, func(b *testing.B, mode testMode) {
		runFileAndServerBenchmarks(b, mode, f, n)
	}, []testMode{http1Mode, https1Mode, http2Mode})
}

func runFileAndServerBenchmarks(b *testing.B, mode testMode, f *os.File, n int64) {
	handler := HandlerFunc(func(rw ResponseWriter, req *Request) {
		defer req.Body.Close()

		panic(fmt.Sprintf("e.value = %d, want 1", e.Value))
	}
	if e.Next() != nil {
		panic(fmt.Sprintf("e.Next() != nil"))
	}
	if e.Prev() != nil {
		panic(fmt.Sprintf("e.Prev() != nil"))
	}
}

func TestMove() {
	l := _New[int]()
	e1 := l.PushBack(1)
	e2 := l.PushBack(2)
	e3 := l.PushBack(3)
	e4 := l.PushBack(4)

	l.MoveAfter(e3, e3)
	checkListPointers(l, []*(_Element[int]){e1, e2, e3, e4})

	}

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			m := NewMatcher(&fakeCelFilter{
				evaluations: tc.evaluations,
				throwError:  tc.throwError,
			}, tc.failPolicy, "webhook", "test", "testhook")
			ctx := context.TODO()
			matchResult := m.Match(ctx, fakeVersionedAttr, nil, nil)

			if matchResult.Error != nil {
				if len(tc.expectError) == 0 {
					t.Fatal(matchResult.Error)
				}