{ Long.MAX_VALUE, Long.MAX_VALUE, Long.MAX_VALUE, Long.MAX_VALUE }, // Max values
                { 1L, 2L, 3L, 4L }, // Small values
                { -1L, -2L, -3L, -4L } // Negative values (though unusual for file times)
        };

        for (long[] times : timeValues) {
            // Given
            FileBasicInfo info = new FileBasicInfo(times[0], // create time

            assertEquals("share$", result.getShare());
            assertEquals("path", result.getPath());
        }

        @Test
        @DisplayName("Should handle negative expiration times")
        void testNegativeExpiration() {
            when(mockReferral.getTtl()).thenReturn(300);
            when(mockReferral.getRFlags()).thenReturn(0);

            assertTrue(true);
        } catch (Exception e) {
            assertTrue(true);
        }
    }

    public void test_setters_edgeCases() {
        // Test setting negative values
        webFsIndexHelper.setMaxAccessCount(-1L);
        assertEquals(-1L, webFsIndexHelper.maxAccessCount);

        webFsIndexHelper.setCrawlingExecutionInterval(-1000L);

   * @return a new, empty {@code CompactLinkedHashSet} with enough capacity to hold {@code
   *     expectedSize} elements without resizing
   * @throws IllegalArgumentException if {@code expectedSize} is negative
   */
  public static <E extends @Nullable Object> CompactLinkedHashSet<E> createWithExpectedSize(
      int expectedSize) {
    return new CompactLinkedHashSet<>(expectedSize);
  }

        // Out of range offset
        PagingList<CharMappingItem> result4 = charMappingFile.selectList(10, 2);
        assertEquals(0, result4.size());
        assertEquals(3, result4.getAllRecordCount());

        // Negative offset
        PagingList<CharMappingItem> result5 = charMappingFile.selectList(-1, 2);
        assertEquals(0, result5.size());
        assertEquals(3, result5.getAllRecordCount());
    }

         * @param h1 the first hour
         * @param m1 the first minute
         * @param h2 the second hour
         * @param m2 the second minute
         * @return positive if first time is earlier, 0 if equal, negative if later
         */
        protected int compareTime(final int h1, final int m1, final int h2, final int m2) {
            if (h1 < h2) {
                return 1;
            }
            if (h1 == h2) {

        // Test zero version
        EmptySearchLogEvent emptyEvent = new EmptySearchLogEvent();
        assertEquals(Long.valueOf(0L), emptyEvent.getVersionNo());

        // Test negative version
        event.setVersionNo(-1L);
        assertEquals(Long.valueOf(-1L), event.getVersionNo());

        // Test max version
        event.setVersionNo(Long.MAX_VALUE);

        // When
        request.setTid(tid);

        // Then
        verify(request, times(1)).setTid(tid);
    }

    @Test
    @DisplayName("Test setTid with negative value")
    void testSetTidWithNegativeValue() {
        // Given
        int tid = -1;
        doNothing().when(request).setTid(tid);

        // When
        request.setTid(tid);

        // Then

            throw new IllegalArgumentException("Success threshold must be at least 1");
        }
        if (timeoutMillis < 0) {
            throw new IllegalArgumentException("Timeout must be non-negative");
        }
    }

    /**
     * Execute a callable through the circuit breaker
     *
     * @param <T> return type
     * @param callable the callable to execute
     * @return the result

        assertEquals((byte) 0x00, buffer[1]);
        assertEquals((byte) 0x00, buffer[2]);
        assertEquals((byte) 0x00, buffer[3]);
    }

    @Test
    @DisplayName("Should handle negative FID values")
    void testNegativeFid() {
        // Arrange
        int negativeFid = -1;
        transPeekNamedPipe = new TransPeekNamedPipe(mockConfig, TEST_PIPE_NAME, negativeFid);