assertEquals(0, trans2GetDfsReferral.readDataWireFormat(emptyBuffer, 0, 0));
    }

    @Test
    @DisplayName("Test parameter encoding with long filename")
    void testParameterEncodingWithLongFilename() {
        // Given
        StringBuilder longFilename = new StringBuilder("\\\\server\\share");
        for (int i = 0; i < 100; i++) {

     *
     * @return the asyncId
     */
    public final long getAsyncId() {
        return this.asyncId;
    }

    /**
     * Sets the asynchronous identifier for this message.
     *
     * @param asyncId
     *            the asyncId to set
     */
    public final void setAsyncId(final long asyncId) {
        this.asyncId = asyncId;
    }

    /**

  fun value(index: Int): String = encodedValue(index).percentDecode(plusIsSpace = true)

  override fun contentType(): MediaType = CONTENT_TYPE

  override fun contentLength(): Long = writeOrCountBytes(null, true)

  @Throws(IOException::class)
  override fun writeTo(sink: BufferedSink) {
    writeOrCountBytes(sink, false)
  }

  /**

        }
    }

    @Test
    void testTimestampConsistency() {
        long beforeCreation = System.currentTimeMillis();
        WitnessNotification newNotification = new WitnessNotification(WitnessEventType.RESOURCE_CHANGE, "TestResource");
        long afterCreation = System.currentTimeMillis();

        assertTrue(newNotification.getTimestamp() >= beforeCreation);

     * @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);
    }

    /*
     * Padding from 40 into 64 bytes, same size as cache line. Might be beneficial to add a fourth
     * long here, to minimize chance of interference between consecutive locks, but I couldn't
     * observe any benefit from that.
     */
    long unused1;
    long unused2;
    long unused3;

    PaddedLock() {
      super(false);
    }
  }

    String threadName = Finalizer.class.getName();
    Thread thread = null;
    if (bigThreadConstructor != null) {
      try {
        boolean inheritThreadLocals = false;
        long defaultStackSize = 0;
        thread =
            bigThreadConstructor.newInstance(
                (ThreadGroup) null, finalizer, threadName, defaultStackSize, inheritThreadLocals);
      } catch (Throwable t) {

    private String canon; // Initially null; set by getUncPath; dir must end with '/'
    private String share; // Can be null
    private long createTime;
    private long lastModified;
    private int attributes;
    private long attrExpiration;
    private long size;
    private long sizeExpiration;
    private boolean isExists;
    private int shareAccess = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;

                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