* @param di the starting index in the destination array
     * @param enc the time encoding type (e.g., TIME_1970_SEC_32BE)
     * @return the number of bytes written
     */
    public static int enc_time(final Date date, final byte[] dst, final int di, final int enc) {
        long t;

        return switch (enc) {
        case TIME_1970_SEC_32BE -> enc_uint32be((int) (date.getTime() / 1000L), dst, di);

     * @param di the starting index in the destination array
     * @param enc the time encoding type (e.g., TIME_1970_SEC_32BE)
     * @return the number of bytes written
     */
    public static int enc_time(final Date date, final byte[] dst, final int di, final int enc) {
        long t;

        return switch (enc) {
        case TIME_1970_SEC_32BE -> enc_uint32be((int) (date.getTime() / 1000L), dst, di);

      override fun fromDer(reader: DerReader): Long {
        val peekHeader =
          reader.peekHeader()
            ?: throw ProtocolException("expected time but was exhausted at $reader")

        return when {
          peekHeader.tagClass == Adapters.UTC_TIME.tagClass &&

                        long startTime = System.nanoTime();
                        boolean result = correctAuth.equals(wrongAuth);
                        long endTime = System.nanoTime();
                        timings.add(endTime - startTime);
                        assertFalse(result, "Passwords should not be equal");
                    }
                });
            }

    //                                                                         ===========
    protected final ColumnInfo _columnEndTime = cci("endTime", "endTime", null, null, Long.class, "endTime", null, false, false, false,
            "Long", 0, 0, null, null, false, null, null, null, null, null, false);

        },
    )

  /**
   * A timestamp like "191216030210Z" or "191215190210-0800" for 2019-12-15T19:02:10-08:00. The
   * cutoff of the 2-digit year is 1950-01-01T00:00:00Z.
   */
  val UTC_TIME =
    BasicDerAdapter(
      name = "UTC TIME",
      tagClass = DerHeader.TAG_CLASS_UNIVERSAL,
      tag = 23L,
      codec =
        object : BasicDerAdapter.Codec<Long> {

func (m *rateMeasurement) updateExponentialMovingAverage(endTime time.Time) {
	// Calculate aggregate avg bandwidth and exp window avg
	m.lock.Lock()
	defer func() {
		m.startTime = endTime
		m.lock.Unlock()
	}()

	if m.startTime.IsZero() {
		return
	}

	if endTime.Before(m.startTime) {
		return
	}

	duration := endTime.Sub(m.startTime)

                    return "";
                case FessConfig.INDEX_ADMIN_DOUBLE_FIELDS:
                    return "";
                case FessConfig.INDEX_ADMIN_DATE_FIELDS:
                    return "expires,start_time,end_time";
                case FessConfig.INDEX_ADMIN_REQUIRED_FIELDS:
                    return "url,title,role,boost";
                case FessConfig.INDEX_ADMIN_ARRAY_FIELDS:
                    return "alerts,roles";

		case "startTs":
			z.StartTime, err = dc.ReadTime()
			if err != nil {
				err = msgp.WrapError(err, "StartTime")
				return
			}
		case "stopTs":
			z.EndTime, err = dc.ReadTime()
			if err != nil {
				err = msgp.WrapError(err, "EndTime")
				return
			}
		case "status":
			{
				var zb0002 uint8
				zb0002, err = dc.ReadUint8()
				if err != nil {
					err = msgp.WrapError(err, "Status")

    assertThat(Adapters.UTC_TIME.toDer(utcTime)).isEqualTo(bytes)
    assertThat(Adapters.UTC_TIME.fromDer(bytes)).isEqualTo(utcTime)
  }

  @Test fun `cannot decode malformed utc time`() {
    val bytes = "170d3139313231362333303231305a".decodeHex()
    assertFailsWith<ProtocolException> {
      Adapters.UTC_TIME.fromDer(bytes)
    }.also { expected ->