// Test boundary values
        byte[] data = { (byte) 0x00, // min value
                (byte) 0xFF, // max value (-1 as signed byte)
                (byte) 0x7F, // max positive
                (byte) 0x80 // min negative
        };

        String result = Hexdump.toHexString(data);
        assertEquals("00FF7F80", result);
    }

    @Test
    @DisplayName("Should handle large byte arrays efficiently")

        setupCountField.setAccessible(true);
        assertEquals(255, setupCountField.get(response));
    }

    @Test
    @DisplayName("Test negative values handling (as unsigned)")
    void testNegativeValuesAsUnsigned() throws Exception {
        byte[] buffer = new byte[100];
        int bufferIndex = 0;

        // Reserved bytes

        // Act/Assert
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> req.writeBytesWireFormat(tiny, 0));
    }

    @Test
    @DisplayName("writeBytesWireFormat throws with negative index")
    void writeBytesWireFormat_throwsIfNegativeIndex() {
        // Arrange
        Smb2LogoffRequest req = newRequest();
        byte[] buf = new byte[4];

        // Act/Assert

			if ch, ok := val.(chan struct{}); ok && ch != nil {
				// Close previous non-nil channel.
				xioutil.SafeClose(ch)
			}
		}
		globalServiceFreezeCnt = 0 // Don't risk going negative.
	}
	globalServiceFreezeMu.Unlock()

        assertEquals(0.0f, elevateWord.getBoost(), 0.001f);
    }

    @Test
    public void testConstructorWithNegativeBoost() {
        // Test constructor with negative boost
        String word = "negative boost";
        float boost = -1.5f;
        List<String> readings = Arrays.asList("reading1");
        List<String> fields = Arrays.asList("field1");
        List<String> tags = Arrays.asList("tag1");

			input:    []int{1, 2, 3},
			trimLen:  1,
			expected: []int{1, 2},
		},
		{
			name:     "Empty slice",
			input:    []int{},
			trimLen:  2,
			expected: []int{},
		},
		{
			name:     "Negative trim length (should be treated as zero)",
			input:    []int{1, 2, 3},
			trimLen:  -1,
			expected: []int{1, 2, 3},
		},
	}

	for _, testcase := range tests {
		t.Run(testcase.name, func(t *testing.T) {

            readParams.setAccessible(true);
            assertEquals(0, readParams.invoke(cancel, emptyArray, 0));
        }

        @Test
        @DisplayName("Should handle negative MID values")
        void testWithNegativeMid() throws Exception {
            // Given
            Configuration config = mock(Configuration.class);
            when(config.getPid()).thenReturn(12345);

        assertSame(purgeThumbnailJob, result);
        // Test value was not changed
        assertEquals(originalExpiry, purgeThumbnailJob.getExpiry());
    }

    // Test expiry setter with negative value (should not change)
    public void test_expiry_negativeValue() {
        long originalExpiry = purgeThumbnailJob.getExpiry();
        PurgeThumbnailJob result = purgeThumbnailJob.expiry(-1000L);

    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;

    void messagesOutOfBoundsThrows() {
        // Arrange
        String[] msgs = DosError.DOS_ERROR_MESSAGES;

        // Act & Assert: negative index
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> {
            @SuppressWarnings("unused")
            String s = msgs[-1];
        });

        // Act & Assert: index equal to length