* Returns the time when the operation started its execution.
     *
     * @return The start time, in milliseconds since the epoch.
     */
    long getStartTime();

    /**
     * Returns the time when the operation finished its execution.
     *
     * @return The end time, in milliseconds since the epoch.
     */
    long getEndTime();

    /**
     * Returns the time when this test started execution.
     *
     * @return The start time, in milliseconds since the epoch.
     */
    long getStartTime();

    /**
     * Returns the time when this test completed execution.
     *
     * @return The end t ime, in milliseconds since the epoch.
     */
    long getEndTime();

    /**

 * @since 8.0
 */
public class TimestampSuppliers {
    /**
     * Returns a supplier that calculates a timestamp exactly the given amount of time
     * prior to the current time, or 0 if the amount of time extends beyond the epoch.
     */
    public static Supplier<Long> inThePast(int value, TimeUnit timeUnit) {
        // This needs to be an anonymous inner class instead of a lambda for configuration cache compatibility

 */

package org.gradle.internal.time

import spock.lang.Specification

import java.util.concurrent.TimeUnit


class TimestampSuppliersTest extends Specification {
    def "timestamps earlier than the epoch evaluate to zero"() {
        expect:
        TimestampSuppliers.inThePast(Integer.MAX_VALUE, TimeUnit.HOURS).get() == 0

        and:
        TimestampSuppliers.daysAgo(Integer.MAX_VALUE).get() == 0
    }

TEXT time·now(SB),NOSPLIT,$0-24
	MOVD	$_INTERRUPT_TIME, R3
	MOVD	time_lo(R3), R0
	MOVD	$100, R1
	MUL	R1, R0
	MOVD	R0, mono+16(FP)

	MOVD	$_SYSTEM_TIME, R3
	MOVD	time_lo(R3), R0
	// convert to Unix epoch (but still 100ns units)
	#define delta 116444736000000000
	SUB	$delta, R0
	// Convert to nSec
	MOVD	$100, R1
	MUL	R1, R0

	// Code stolen from compiler output for:
	//
	//	var x uint64

	MOVL	DX, mono+16(FP)

wall:
	MOVL	(_SYSTEM_TIME+time_hi1), CX
	MOVL	(_SYSTEM_TIME+time_lo), AX
	MOVL	(_SYSTEM_TIME+time_hi2), DX
	CMPL	CX, DX
	JNE	wall

	// w = DX:AX
	// convert to Unix epoch (but still 100ns units)
	#define delta 116444736000000000
	SUBL	$(delta & 0xFFFFFFFF), AX
	SBBL $(delta >> 32), DX

	// nano/100 = DX:AX
	// split into two decimal halves by div 1e9.

    assertThat(builder["e"]).isNull()
  }

  @Test fun builderSetOperator() {
    val builder = Headers.Builder()
    builder["a"] = "b"
    builder["c"] = "d"
    builder["e"] = Date(0L)
    builder["g"] = Instant.EPOCH
    assertThat(builder["a"]).isEqualTo("b")
    assertThat(builder["c"]).isEqualTo("d")
    assertThat(builder["e"]).isEqualTo("Thu, 01 Jan 1970 00:00:00 GMT")

 * task has finished, etc.
 *
 * @since 2.4
 */
public interface ProgressEvent {

    /**
     * Returns the time this event was triggered.
     *
     * @return The event time, in milliseconds since the epoch.
     */
    long getEventTime();

    /**
     * Returns a human consumable short description of the event.
     *
     * @return The short description of the event.
     */
    String getDisplayName();

for builds. `make` itself is **not** hermetic.

The Kubernetes build environment supports the [`SOURCE_DATE_EPOCH` environment
variable](https://reproducible-builds.org/specs/source-date-epoch/) specified by
the Reproducible Builds project, which can be set to a UNIX epoch timestamp.
This will be used for the build timestamps embedded in compiled Go binaries,
and maybe someday also Docker images.

	MOVW	$_SYSTEM_TIME, R3
wall:
	MOVW	time_hi1(R3), R1
	DMB	MB_ISH
	MOVW	time_lo(R3), R0
	DMB	MB_ISH
	MOVW	time_hi2(R3), R2
	CMP	R1, R2
	BNE	wall

	// w = R1:R0 in 100ns untis
	// convert to Unix epoch (but still 100ns units)
	#define delta 116444736000000000
	SUB.S   $(delta & 0xFFFFFFFF), R0
	SBC     $(delta >> 32), R1

	// Convert to nSec
	MOVW    $100, R2
	MULLU   R0, R2, (R4, R3)    // R4:R3 = R1:R0 * R2