FileBasicInfo info = new FileBasicInfo();

        // When & Then
        assertEquals(0, info.getAttributes());
        assertEquals(0L, info.getCreateTime());
        assertEquals(0L, info.getLastWriteTime());
        assertEquals(0L, info.getLastAccessTime());
        assertEquals(0L, info.getSize());
        assertEquals(FileInformation.FILE_BASIC_INFO, info.getFileInformationLevel());
    }

    @Test

    assertThat(max(8L, 6L, 7L, 5L, 3L, 0L, 9L)).isEqualTo(9L);
  }

  public void testMin_noArgs() {
    assertThrows(IllegalArgumentException.class, () -> min());
  }

  public void testMin() {
    assertThat(min(MIN_VALUE)).isEqualTo(MIN_VALUE);
    assertThat(min(MAX_VALUE)).isEqualTo(MAX_VALUE);
    assertThat(min(8L, 6L, 7L, 5L, 3L, 0L, 9L)).isEqualTo(0L);
  }

  public void testConstrainToRange() {

    @MethodSource("nameProvider")
    void name_edgeCases(String name, String caseDesc) {
        // Arrange
        FileEntry e = new TestFileEntry(name, 0, 0, 0L, 0L, 0L, 0L, 0);
        // Act
        String actual = e.getName();
        // Assert
        assertEquals(name, actual);
    }

    // Parameterized tests for numeric getters with edge values

  ) : AbstractSource(url) {
    init {
      if (bytesRemaining == 0L) {
        responseBodyComplete(trailers = Headers.EMPTY)
      }
    }

    override fun read(
      sink: Buffer,
      byteCount: Long,
    ): Long {
      require(byteCount >= 0L) { "byteCount < 0: $byteCount" }
      check(!closed) { "closed" }
      if (bytesRemaining == 0L) return -1

            assertNotNull(basicInfo);
            assertEquals(0L, basicInfo.getCreateTime());
            assertEquals(0L, basicInfo.getLastWriteTime());
            assertEquals(0L, basicInfo.getSize());
            assertEquals(0, basicInfo.getAttributes());
        }

        @Test

        if (progressedSize < 0L) {
            throw new IllegalArgumentException("progressed file size cannot be negative: " + size);
        }
        if (size >= 0 && progressedSize > size) {
            throw new IllegalArgumentException(
                    "progressed file size cannot be greater than size: " + progressedSize + " > " + size);
        }

        if (size >= 0L && progressedSize != size) {

        val servedMillis = servedDate?.time ?: sentRequestMillis
        val delta = servedMillis - lastModified!!.time
        return if (delta > 0L) delta / 10 else 0L
      }

      return 0L
    }

    /**
     * Returns the current age of the response, in milliseconds. The calculation is specified by RFC
     * 7234, 4.2.3 Calculating Age.
     */

    }

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

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

    /**
     * {@inheritDoc}
     *
     * @see jcifs.smb.FileEntry#lastAccess()
     */
    @Override
    public long lastAccess() {
        return 0L;
    }

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

    protected SmbResource adapt(final FileEntry e) throws MalformedURLException {
        return new SmbFile(getParent(), e.getName(), false, e.getType(), SmbConstants.ATTR_READONLY | SmbConstants.ATTR_DIRECTORY, 0L, 0L,
                0L, 0L);
    }

            }

            @Override
            public void commit() {
                // No-op for test
            }
        };

        // Test initial state
        assertEquals(0L, callback.getDocumentSize());
        assertEquals(0L, callback.getExecuteTime());

        // Test store method
        DataStoreParams params = new DataStoreParams();
        Map<String, Object> data = new HashMap<>();