@Test
        @DisplayName("Should encode zero values correctly")
        void testEncodingWithZeroValues() {
            lock = new Smb2Lock(0L, 0L, 0);
            lock.encode(buffer, 0);

            assertEquals(0L, SMBUtil.readInt8(buffer, 0));
            assertEquals(0L, SMBUtil.readInt8(buffer, 8));
            assertEquals(0, SMBUtil.readInt4(buffer, 16));
            assertEquals(0, SMBUtil.readInt4(buffer, 20));

    public int getAttributes() {
        return 0;
    }

    @Override
    public long getCreateTime() {
        return 0L;
    }

    @Override
    public long getLastWriteTime() {
        return 0L;
    }

    @Override
    public long getLastAccessTime() {
        return 0L;
    }

    @Override
    public long getSize() {
        return this.endOfFile;
    }

    /**

        Assertions.assertEquals(size, info.getSize());
    }

    // Supplies a range of normal and edge case values.
    private static Stream<Arguments> valueProvider() {
        return Stream.of(Arguments.of(0, 0L, 0L, 0L, 0L), // all zeros
                Arguments.of(1, 1L, 1L, 1L, 1L), // ones
                Arguments.of(123, 456L, 789L, 101112L, 131415L), // arbitrary positives

        @Override
        public long createTime() {
            return 0L;
        }

        @Override
        public long lastModified() {
            return 0L;
        }

        @Override
        public long lastAccess() {
            return 0L;
        }

        @Override
        public long length() {
            return 0L;
        }

        @Override
        public String toString() {

        final boolean directory = true;
        final long size = 0L;
        final String encodedId = "ZG9jdW1lbnRzLw==";

        final StorageItem item = new StorageItem(name, path, directory, size, null, encodedId);

        assertEquals(name, item.getName());
        assertEquals(path, item.getPath());
        assertTrue(item.isDirectory());
        assertEquals(0L, item.getSize());
        assertNull(item.getLastModified());

        assertEquals(1000L, configHelper.reloadInterval);

        configHelper.setReloadInterval(5000L);
        assertEquals(5000L, configHelper.reloadInterval);

        configHelper.setReloadInterval(0L);
        assertEquals(0L, configHelper.reloadInterval);

        configHelper.setReloadInterval(-1L);
        assertEquals(-1L, configHelper.reloadInterval);
    }

    @Test

package okhttp3.internal.http2.flowcontrol

class WindowCounter(
  val streamId: Int,
) {
  /** The total number of bytes consumed. */
  var total: Long = 0L
    private set

  /** The total number of bytes acknowledged by outgoing `WINDOW_UPDATE` frames. */
  var acknowledged: Long = 0L
    private set

  val unacknowledged: Long
    @Synchronized get() = total - acknowledged

  @Synchronized
  fun update(
    total: Long = 0,

    }

    /**
     * Parameterised test for a selection of edge and typical values.
     */
    @ParameterizedTest(name = "Encode and decode {0}")
    @ValueSource(longs = { 0L, 1L, -1L, Long.MAX_VALUE, Long.MIN_VALUE })
    public void testEncodeWithVariousValues(long val) throws NdrException {
        NdrHyper hyper = new NdrHyper(val);
        // Create buffer with extra space for alignment

      perMessageDeflate = false,
      noContextTakeover = false,
      minimumDeflateSize = 0L,
    )
  private val clientWriter =
    WebSocketWriter(
      isClient = true,
      sink = data,
      random = random,
      perMessageDeflate = false,
      noContextTakeover = false,
      minimumDeflateSize = 0L,
    )

  @Test fun serverTextMessage() {

        void shouldHandleZeroValues() {
            // Given
            TestAllocInfo allocInfo = new TestAllocInfo(0L, 0L);

            // When & Then
            assertEquals(0L, allocInfo.getCapacity());
            assertEquals(0L, allocInfo.getFree());
        }

        @Test
        @DisplayName("Should handle maximum long values")
        void shouldHandleMaximumLongValues() {