int bufferIndex = 0;

        // Set structure size to 4 (invalid, should be 2)
        SMBUtil.writeInt2(4, buffer, bufferIndex);

        SMBProtocolDecodingException exception =
                assertThrows(SMBProtocolDecodingException.class, () -> response.readBytesWireFormat(buffer, bufferIndex),
                        "Should throw SMBProtocolDecodingException for invalid structure size");

  @MapFeature.Require(SUPPORTS_PUT)
  public void testComputeIfAbsent_supportedAbsent() {
    assertEquals(
        "computeIfAbsent(notPresent, function) should return new value",
        v3(),
        getMap()
            .computeIfAbsent(
                k3(),
                k -> {
                  assertEquals(k3(), k);
                  return v3();

        // Remove should not throw exception even if channel doesn't exist
        assertDoesNotThrow(() -> channelManager.removeChannel(channel));
    }

    @Test
    void testShutdown() {
        assertDoesNotThrow(() -> channelManager.shutdown());

        // Multiple shutdowns should be safe
        assertDoesNotThrow(() -> channelManager.shutdown());
    }

    class ConstantValues {
        @Test
        void successIsZero() {
            assertEquals(0, WinError.ERROR_SUCCESS, "ERROR_SUCCESS should be 0");
        }

        @Test
        void accessDeniedIsFive() {
            assertEquals(5, WinError.ERROR_ACCESS_DENIED, "ERROR_ACCESS_DENIED should be 5");
        }

        @Test
        void knownErrorCodes() {

            latch.countDown();
        });

        // ## Assert ##
        assertTrue("Async execution should complete within 5 seconds", latch.await(5, TimeUnit.SECONDS));
        assertNotNull(threadName.get());
        // The async execution should have run on a ForkJoinPool thread, not the main thread
        assertTrue("Should run on ForkJoinPool thread: " + threadName.get(),

    }

    @Test
    @DisplayName("Should preserve stack trace information")
    void testStackTracePreservation() {
        // When
        SmbException exception = new SmbException("Test exception");

        // Then
        assertNotNull(exception.getStackTrace());
        assertTrue(exception.getStackTrace().length > 0);

        // Should contain this test method in stack trace

        assertNotNull(mappingOption, "Mapping option should not be null");
        OptionalThing<JsonFieldNaming> fieldNamingOpt = mappingOption.getFieldNaming();
        assertTrue("Field naming should be present", fieldNamingOpt.isPresent());
        assertEquals("Field naming should be CAMEL_TO_LOWER_SNAKE", JsonFieldNaming.CAMEL_TO_LOWER_SNAKE, fieldNamingOpt.get());
    }

    @Test
    public void test_instanceCreation() {

        assertEquals(positiveValue, ndrLongPositive.value, "Constructor should correctly initialize with a positive value.");

        // Test case 2: Negative value
        int negativeValue = -54321;
        NdrLong ndrLongNegative = new NdrLong(negativeValue);
        assertEquals(negativeValue, ndrLongNegative.value, "Constructor should correctly initialize with a negative value.");

        // Test case 3: Zero value

  @MapFeature.Require(SUPPORTS_PUT)
  public void testComputeIfAbsent_supportedAbsent() {
    assertEquals(
        "computeIfAbsent(notPresent, function) should return new value",
        v3(),
        getMap()
            .computeIfAbsent(
                k3(),
                k -> {
                  assertEquals(k3(), k);
                  return v3();

	}

	// Decrease reference count by 1.
	if err = rlk.Close(); err != nil {
		t.Fatal(err)
	}

	// Now file should be closed.
	isClosed = rlk.IsClosed()
	if !isClosed {
		t.Fatal("File ref count should be zero")
	}

	// Closing a file again should result in invalid argument.
	if err = rlk.Close(); err != os.ErrInvalid {
		t.Fatal(err)
	}

	_, err = newRLockedFile(nil)