) = add(name, value.toHttpDateString())

    /**
     * Add a header with the specified name and formatted instant. Does validation of header names
     * and value.
     */
    @IgnoreJRERequirement // Only programs that already have Instant will use this.
    fun add(
      name: String,
      value: Instant,
    ) = add(name, Date.from(value))

    /**

    }

    private BuildOperationRecord loadOperation() {
        operations.firstMatchingRegex("Load (configuration cache|instant execution) state")
    }

    private BuildOperationRecord storeOperation() {
        operations.firstMatchingRegex("Store (configuration cache|instant execution) state.*")
    }

	if t == nil {
		return true
	}
	return t.Time.IsZero()
}

// Before reports whether the time instant t is before u.
func (t *MicroTime) Before(u *MicroTime) bool {
	if t != nil && u != nil {
		return t.Time.Before(u.Time)
	}
	return false
}

// Equal reports whether the time instant t is equal to u.
func (t *MicroTime) Equal(u *MicroTime) bool {
	if t == nil && u == nil {
		return true
	}

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.curl.logging

import java.io.PrintWriter
import java.io.StringWriter
import java.time.Instant
import java.time.ZoneOffset
import java.time.format.DateTimeFormatterBuilder
import java.time.temporal.ChronoField.HOUR_OF_DAY
import java.time.temporal.ChronoField.MINUTE_OF_HOUR

    }

    private boolean requiresCleanup() {
        Instant lastCleanupTime;

        File gcFile = getGcFile();
        if (!gcFile.exists()) {
            if (!gcFile.getParentFile().exists()) {
                return false;
            } else {
                lastCleanupTime = null;
            }
        } else {
            lastCleanupTime = Instant.ofEpochMilli(gcFile.lastModified());
        }

import java.text.SimpleDateFormat;
import java.time.Instant;
import java.time.format.DateTimeFormatter;
import java.util.Date;
import java.util.TimeZone;

import static org.gradle.performance.measure.DataSeries.confidenceInDifference;

public class FormatSupport {
    public static String executionTimestamp() {
        return timestamp(Instant.now());
    }

    public static String timestamp(Instant time) {

            request2.release()
        }
        server.stop()

        then:
        instant.aDone > instant.aBlocked
        instant.bDone > instant.bBlocked
    }

    def "can chain expectations"() {
        given:
        server.expectConcurrent("a", "b")
        server.expect("c")
        def handle = server.expectConcurrentAndBlock(2, "d", "e")
        server.expect("f")

	}{
		// These should just work on the first try.
		{[]string{"127.0.0.1"}, []string{}, "", true, instant},
		{[]string{"::1"}, []string{}, "", true, instant},
		{[]string{"127.0.0.1", "::1"}, []string{slowDst6}, "tcp6", true, instant},
		{[]string{"::1", "127.0.0.1"}, []string{slowDst4}, "tcp4", true, instant},
		// Primary is slow; fallback should kick in.
		{[]string{slowDst4}, []string{"::1"}, "", true, fallbackDelay},

            }
        }
    }

    def "cannot look up services while closing"() {
        given:
        def registry = new DefaultServiceRegistry()
        registry.add(Closeable, {
            instant.closing
            thread.blockUntil.lookupDone
        } as Closeable)

        when:
        async {
            start() {
                registry.close()
            }
            start {

// to emit a flow event from, indicating explicitly that this goroutine was unblocked by the system.
func (gs *gState[R]) blockedSyscallEnd(ts trace.Time, stack trace.Stack, ctx *traceContext) {
	name := "exit blocked syscall"
	gs.setStartCause(ts, name, trace.SyscallP, stack)

	// Emit an syscall exit instant event for the "Syscall" lane.
	ctx.Instant(traceviewer.InstantEvent{
		Name:     name,