*/
    @Size(max = 1000)
    public String updatedBy;

    /**
     * The timestamp when this role was last updated.
     * Stored as a long value representing milliseconds since epoch.
     * Used for audit trail and concurrency control.
     */
    @ValidateTypeFailure
    public Long updatedTime;

    /**
     * The version number of the role for optimistic locking.

    @Size(max = 1000)
    public String updatedBy;

    /**
     * The timestamp when this label type was last updated.
     * Stored as a long value representing milliseconds since epoch.
     * Used for audit trail and concurrency control.
     */
    @ValidateTypeFailure
    public Long updatedTime;

    /**
     * The version number of the label type for optimistic locking.

      object : Source {
        var closed = false

        override fun close() {
          closed = true
        }

        override fun read(
          sink: Buffer,
          byteCount: Long,
        ): Long {
          check(!closed)
          return data.read(sink, byteCount)
        }

        override fun timeout(): Timeout = Timeout.NONE
      }
    return source.buffer().asResponseBody(null, -1)
  }

      } else if (type == short.class) {
        return (T) Short.valueOf((short) 0);
      } else if (type == int.class) {
        return (T) Integer.valueOf(0);
      } else if (type == long.class) {
        return (T) Long.valueOf(0L);
      } else if (type == float.class) {
        return (T) FLOAT_DEFAULT;
      } else if (type == double.class) {
        return (T) DOUBLE_DEFAULT;
      }
    }
    return null;

		if resp.IsError() {
			return fmt.Errorf("Create index err: %v", res)
		}
		return nil
	}
	return nil
}

func (c *esClientV7) ping(ctx context.Context, _ ElasticsearchArgs) (bool, error) {
	resp, err := c.Ping(
		c.Ping.WithContext(ctx),
	)
	if err != nil {
		return false, store.ErrNotConnected
	}
	xhttp.DrainBody(resp.Body)
	return !resp.IsError(), nil
}

        assertTrue(channelInfo.isHealthy());

        channelInfo.setState(ChannelState.FAILED);
        assertFalse(channelInfo.isHealthy());
    }

    @Test
    void testActivityTracking() {
        long initialTime = channelInfo.getLastActivityTime();

        // Wait a bit and update activity
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {

                byte[] dst = new byte[buffer.size()];
                buffer.encode(dst, 0);

                // Verify SMBUtil.writeInt2 was called for referral level (with long parameter)
                mockedSMBUtil.verify(() -> SMBUtil.writeInt2(eq((long) maxReferralLevel), any(byte[].class), eq(0)));
                // Verify SMBUtil.writeInt2 was called for null terminator

    private static final int TEST_FID = 0x1234;
    private static final int TEST_ATTRIBUTES = 0x20; // FILE_ATTRIBUTE_ARCHIVE
    private static final long TEST_CREATE_TIME = 131234567890000L;
    private static final long TEST_LAST_WRITE_TIME = 131234567900000L;
    private static final long TEST_LAST_ACCESS_TIME = 131234567880000L;

    @BeforeEach
    void setUp() throws Exception {
        MockitoAnnotations.openMocks(this);

     * @param unit the time unit of the initialDelay and delay parameters
     */
    @SuppressWarnings("GoodTime") // should accept a java.time.Duration
    public static Scheduler newFixedDelaySchedule(long initialDelay, long delay, TimeUnit unit) {
      checkNotNull(unit);
      checkArgument(delay > 0, "delay must be > 0, found %s", delay);
      return new Scheduler() {
        @Override
        public Cancellable schedule(

    for (short value : VALUES) {
      assertThat(Shorts.checkedCast((long) value)).isEqualTo(value);
    }
    assertCastFails(GREATEST + 1L);
    assertCastFails(LEAST - 1L);
    assertCastFails(Long.MAX_VALUE);
    assertCastFails(Long.MIN_VALUE);
  }

  public void testSaturatedCast() {
    for (short value : VALUES) {
      assertThat(Shorts.saturatedCast((long) value)).isEqualTo(value);
    }