import model.CIBuildModel
import model.Stage

/**
 * Build a Gradle distribution (dogfood-first) and use this distribution to build a distribution again (dogfood-second).
 * Use `dogfood-second` to run `test sanityCheck`.
 */
class Gradleception(
    model: CIBuildModel,
    stage: Stage,
    buildJvm: Jvm,
    jvmDescription: String,
    bundleGroovyMajor: Int? = null,

        List<LogNotificationEvent> first = helper.drainAll();
        assertEquals(1, first.size());
        List<LogNotificationEvent> second = helper.drainAll();
        assertTrue(second.isEmpty());
    }

    @Test
    public void test_offer_bufferCapacity() {
        LogNotificationHelper helper = new LogNotificationHelper();

    public void test_setId_overwriteExisting() {
        final JobLog jobLog = new JobLog();
        jobLog.setId("first-id");
        assertEquals("first-id", jobLog.getId());

        jobLog.setId("second-id");
        assertEquals("second-id", jobLog.getId());
    }

    @Test
    public void test_setId_withUuidFormat() {
        final JobLog jobLog = new JobLog();
        final String uuidNoHyphens = "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6";

        testClient.reindexResult = true;
        testClient.deleteIndexResult = true;
        testClient.documentCount = 10;
        testClient.aliasCount = 2;
        // First createIndex (backup) succeeds, second (new) fails
        testClient.createIndexFailOnNth = 2;

        final boolean result = testClient.reindexConfigIndices(false, allTargetPrefixes());

        assertFalse(result);

        events.add(new LogNotificationEvent(base + 1000, "WARN", "org.test.B", "second", null));
        events.add(new LogNotificationEvent(base + 2000, "ERROR", "org.test.C", "third", null));

        String details = testableJob.testFormatDetails(events);

        int posFirst = details.indexOf("first");
        int posSecond = details.indexOf("second");
        int posThird = details.indexOf("third");

   * ClosingFuture}s. Use {@link #whenAllSucceed(ClosingFuture, ClosingFuture)} to start this
   * combination.
   *
   * @param <V1> the type returned by the first future
   * @param <V2> the type returned by the second future
   */
  public static final class Combiner2<V1 extends @Nullable Object, V2 extends @Nullable Object>
      extends Combiner {

    /**

            byte[] buffer1 = new byte[1024];
            int bytesRead1 = stream1.read(buffer1);
            assertEquals(testContent, new String(buffer1, 0, bytesRead1, "UTF-8"));
        }

        // Second read - should work independently
        try (InputStream stream2 = cache.getInputStream()) {
            byte[] buffer2 = new byte[1024];
            int bytesRead2 = stream2.read(buffer2);

	pcs := [13]uintptr{}
	// skip is caller-path sensitive and should be selected by each public helper.
	len := runtime.Callers(skip, pcs[:])
	frames := runtime.CallersFrames(pcs[:len])
	for i := 0; i < len; i++ {
		// second return value is "more", not "ok"
		frame, _ := frames.Next()
		if (!strings.HasPrefix(frame.File, gormSourceDir) ||
			strings.HasSuffix(frame.File, "_test.go")) && !strings.HasSuffix(frame.File, ".gen.go") {
			return frame

                spec in SmokeTestProject.pullRequestFeedbackSmokeBuilds
            }
        if (smokeBuildTypes.isNotEmpty()) {
            subProject(SmokeTestProject(model, stage, smokeBuildTypes.map { it.second }))
        }
        nonSmokeBuildTypes.forEach { (_, buildType) ->
            buildType(buildType)
        }

        performanceTests =

		{"driver.Valuer equal", ModifyAt{Time: now, Valid: true}, ModifyAt{Time: now, Valid: true}, true},
		{"driver.Valuer not equal", ModifyAt{Time: now, Valid: true}, ModifyAt{Time: now.Add(time.Second), Valid: true}, false},
		{"driver.Valuer equal (ptr to nil ptr)", (*ModifyAt)(nil), &ModifyAt{}, false},
	}
	for _, test := range assertEqualTests {
		t.Run(test.name, func(t *testing.T) {