// Test setting zero value
        emptyGenerator.setDirectoryNameLength(0);
        assertEquals(0, emptyGenerator.directoryNameLength);

        // Test setting negative value
        emptyGenerator.setDirectoryNameLength(-1);
        assertEquals(-1, emptyGenerator.directoryNameLength);
    }

    public void test_setMaxRedirectCount() {
        // Initialize without container

    assertThat(bodySource.readUtf8()).isEqualTo("ABC.1")

    corruptor()

    return client.newCall(request).execute()
  }

  /**
   * @param delta the offset from the current date to use. Negative values yield dates in the past;
   *     positive values yield dates in the future.
   */
  private fun formatDate(
    delta: Long,
    timeUnit: TimeUnit,

    static final int SESSION_REQUEST = 0x81;

    /**
     * NetBIOS positive session response packet type.
     */
    public static final int POSITIVE_SESSION_RESPONSE = 0x82;

    /**
     * NetBIOS negative session response packet type.
     */
    public static final int NEGATIVE_SESSION_RESPONSE = 0x83;
    static final int SESSION_RETARGET_RESPONSE = 0x84;
    static final int SESSION_KEEP_ALIVE = 0x85;

import java.util.Arrays;
import java.util.Comparator;

/**
 * Static utility methods pertaining to {@code int} primitives that interpret values as
 * <i>unsigned</i> (that is, any negative value {@code x} is treated as the positive value {@code
 * 2^32 + x}). The methods for which signedness is not an issue are in {@link Ints}, as well as
 * signed versions of methods for which signedness is an issue.
 *

      advance();
      return read(cbuf, off, len);
    }
    return result;
  }

  @Override
  public long skip(long n) throws IOException {
    Preconditions.checkArgument(n >= 0, "n is negative");
    if (n > 0) {
      while (current != null) {
        long result = current.skip(n);
        if (result > 0) {
          return result;
        }
        advance();
      }
    }
    return 0;

   * elements.
   *
   * @param distinctElements the expected number of distinct elements
   * @throws IllegalArgumentException if {@code distinctElements} is negative
   */
  public static <E extends @Nullable Object> HashMultiset<E> create(int distinctElements) {
    return new HashMultiset<>(distinctElements);
  }

  /**

        }
        if (securityBufferOffset < 0) {
            throw new SMBProtocolDecodingException("Invalid security buffer offset: " + securityBufferOffset + " (must be non-negative)");
        }

        final int hdrStart = getHeaderStart();
        if (securityBufferLength > 0) {
            // Validate that security buffer doesn't exceed available data

                assertEquals(expected, buffer[i], "Pattern mismatch at position " + i);
            }
        }

        @Test
        @DisplayName("Should handle chunks with negative values")
        void testChunksWithNegativeValues() {
            // Given
            byte[] sourceKey = new byte[SOURCE_KEY_SIZE];
            SrvCopychunk chunk = new SrvCopychunk(-1L, -100L, -1);

        // Verify - when wire format is 0, readTime returns a negative value due to the 1601-1970 conversion
        assertEquals(0, fileBothDirectoryInfo.getNextEntryOffset());
        assertEquals(0, fileBothDirectoryInfo.getFileIndex());
        // For time fields, 0 in the wire format means Jan 1, 1601, which is negative in Unix epoch
        assertTrue(fileBothDirectoryInfo.createTime() < 0);

    static String getMessageByCode(final int errcode) {
        /* Note there's a signedness error here because 0xC0000000 based values are
         * negative so it with NT_STATUS_SUCCESS (0) the binary search will not be
         * performed properly. The effect is that the code at index 1 is never found
         * (NT_STATUS_UNSUCCESSFUL). So here we factor out NT_STATUS_SUCCESS