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")

				const ticksPerSecond = 1e7    // Windows timestamp resolution
				ts := int64(attrBuf.uint64()) // ModTime since Windows epoch
				secs := ts / ticksPerSecond
				nsecs := (1e9 / ticksPerSecond) * (ts % ticksPerSecond)
				epoch := time.Date(1601, time.January, 1, 0, 0, 0, 0, time.UTC)
				modified = time.Unix(epoch.Unix()+secs, nsecs)
			}
		case unixExtraID, infoZipUnixExtraID:
			if len(fieldBuf) < 8 {
				continue parseExtras

	c.Issuer = issuer
}

// SetAudience sets audience for these claims
func (c *StandardClaims) SetAudience(aud string) {
	c.Audience = aud
}

// SetExpiry sets expiry in unix epoch secs
func (c *StandardClaims) SetExpiry(t time.Time) {
	c.ExpiresAt = t.Unix()
}

// SetAccessKey sets access key as jwt subject and custom
// "accessKey" field.

	}
  ]
}
```

#### Common information available in all requests

- `aws:CurrentTime` - This can be used for conditions that check the date and time.
- `aws:EpochTime` - This is the date in epoch or Unix time, for use with date/time conditions.
- `aws:PrincipalType` - This value indicates whether the principal is an account (Root credential), user (MinIO user), or assumed role (STS)

// the maximum number of bytes allowed for each string field and
// the integer type used to store each numeric field
// (where timestamps are stored as the number of seconds since the Unix epoch).
//
// The table's lower portion shows specialized features of each format,
// such as supported string encodings, support for sub-second timestamps,
// or support for sparse files.
//

    builder = builder.addAll(headersOf())
    builder = builder.add("", Date(0L))
    builder = builder.add("", Instant.EPOCH)
    builder = builder.set("", "")
    builder = builder.set("", Date(0L))
    builder = builder.set("", Instant.EPOCH)
    builder = builder.removeAll("")
    val get: String? = builder[""]
    val headers: Headers = builder.build()
  }

  @Test

//
// +protobuf.options.marshal=false
// +protobuf.as=Timestamp
// +protobuf.options.(gogoproto.goproto_stringer)=false
message MicroTime {
  // Represents seconds of UTC time since Unix epoch
  // 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
  // 9999-12-31T23:59:59Z inclusive.
  optional int64 seconds = 1;

  // Non-negative fractions of a second at nanosecond resolution. Negative

| `minio_system_process_start_time_seconds`          | Start time for MinIO process in seconds since Unix epoch. <br><br>Type: gauge                                                         | `server` |

        return path;
    }

/**
 * Retrieve the time this <code>SmbFile</code> was created. The value
 * returned is suitable for constructing a {@link java.util.Date} object
 * (i.e. seconds since Epoch 1970). Times should be the same as those
 * reported using the properties dialog of the Windows Explorer program.
 *
 * For Win95/98/Me this is actually the last write time. It is currently

		return errors.New("Presign cannot be generated without access and secret keys")
	}

	// FIXME: Remove following portion of code after fixing a bug in minio-go preSignV2.

	d := UTCNow()
	// Find epoch expires when the request will expire.
	epochExpires := d.Unix() + expires

	// Add expires header if not present.
	expiresStr := req.Header.Get("Expires")
	if expiresStr == "" {