} else if (usage < 0) {
            throw new RuntimeCIFSException("Usage count dropped below zero");
        }
    }

    /**
     * Emergency cleanup method called during finalization to prevent memory leaks
     */
    private void emergencyCleanup() {
        try {
            // Force usage count to zero to trigger cleanup
            this.usageCount.set(0);

            synchronized (this) {

        assertEquals("DOM", s3.getDomainName());
        assertEquals("userX", s3.getAccountName());
    }

    @Test
    @DisplayName("resolveSids(CIFSContext,server,sids,offset,length) with zero length does not resolve")
    void resolveSids_zeroLength_doesNothing() throws Exception {
        CIFSContext ctx = mock(CIFSContext.class);
        SIDCacheImpl cache = Mockito.spy(new SIDCacheImpl(ctx));

            // When & Then
            assertEquals(capacity, allocInfo.getCapacity());
            assertEquals(free, allocInfo.getFree());
        }

        @Test
        @DisplayName("Should handle zero values")
        void shouldHandleZeroValues() {
            // Given
            TestAllocInfo allocInfo = new TestAllocInfo(0L, 0L);

            // When & Then

        assertTrue(rateLimiter.checkAttempt("user1", "192.168.1.9"), "Should still track account");
    }

    @Test
    public void testStatistics() throws Exception {
        // Initially stats should be zero
        AuthenticationRateLimiter.RateLimiterStats stats = rateLimiter.getStats();
        assertEquals(0, stats.getTotalBlocked());
        assertEquals(0, stats.getAccountsLocked());

 * Comparator} or {@link Comparable} type whose comparison behavior is <i>inconsistent with
 * equals</i>. That is, {@code a.compareTo(b)} or {@code comparator.compare(a, b)} should equal zero
 * <i>if and only if</i> {@code a.equals(b)}. If this advice is not followed, the resulting
 * collection will not correctly obey its specification.
 *
 * <p>See the Guava User Guide article on <a href=

	STP	(R26, R27), 700(R2)                              // ERROR "cannot use REGTMP as source"
	MOVK	$0, R10                                          // ERROR "zero shifts cannot be handled correctly"
	MOVK	$(0<<32), R10                                    // ERROR "zero shifts cannot be handled correctly"
	TLBI	PLDL1KEEP                                        // ERROR "illegal argument"

                customBaseDir.delete();
            }
        }
    }

    // Test command timeout edge cases
    public void test_timeout_values() throws Exception {
        // Test zero timeout
        generator.setCommandTimeout(0L);
        assertTrue(true);

        // Test negative timeout
        generator.setCommandTimeout(-1L);
        assertTrue(true);

      )

    parts.close()

    assertFailsWith<IllegalStateException> {
      parts.nextPart()
    }.also { expected ->
      assertThat(expected).hasMessage("closed")
    }
  }

  @Test fun `zero parts`() {
    val multipart =
      """
      |--simple boundary--
      """.trimMargin()
        .replace("\n", "\r\n")

    val parts =
      MultipartReader(
        boundary = "simple boundary",

  }

  /**
   * Returns a new {@code CacheStats} representing the difference between this {@code CacheStats}
   * and {@code other}. Negative values, which aren't supported by {@code CacheStats} will be
   * rounded up to zero.
   */
  public CacheStats minus(CacheStats other) {
    return new CacheStats(
        max(0, saturatedSubtract(hitCount, other.hitCount)),
        max(0, saturatedSubtract(missCount, other.missCount)),

    /**
     * Test setting and getting long field (serverTime)
     */
    @Test
    @DisplayName("Test serverTime field with various long values")
    public void testServerTimeField() {
        // Test with zero
        serverData.serverTime = 0L;
        assertEquals(0L, serverData.serverTime);

        // Test with positive value
        serverData.serverTime = 132514080000000000L; // Windows file time