}
    }

    @Nested
    @DisplayName("Command Constants Tests")
    class CommandConstantsTests {

        @Test
        @DisplayName("Should have correct command constants")
        void testCommandConstants() {
            assertEquals(0x00, ServerMessageBlock2.SMB2_NEGOTIATE);
            assertEquals(0x01, ServerMessageBlock2.SMB2_SESSION_SETUP);

        assertEquals(SMB_COM_WRITE, write.command, "Command should be SMB_COM_WRITE");
    }

    /**
     * Test writeParameterWordsWireFormat writes correct bytes
     */
    @Test
    public void testWriteParameterWordsWireFormat() {
        // Arrange
        SmbComWrite write = new SmbComWrite();
        write.setParam(0x1234, 0x5678L, 100, new byte[10], 0, 10);

  }

  /*
   * This is somewhat of a weak test; we verify that all of the methods are
   * correct, but not that they're actually forwarding correctly. We also rely
   * on the other tests (e.g., SynchronizedSetTest) to verify that the
   * collection views are synchronized correctly.
   */

  public void testSize() {
    int unused = create().size();
  }

  public void testIsEmpty() {

            // Then: Should parse correctly
            assertNotNull(binding);
            assertEquals(expectedProto, binding.getProto());
            assertEquals(expectedServer, binding.getServer());
            assertEquals(expectedEndpoint, binding.getEndpoint());
        }

        @ParameterizedTest
        @DisplayName("Should handle IPv6 addresses correctly")

    void testGetType() {
        assertEquals(SmbConstants.TYPE_FILESYSTEM, fileBothDirectoryInfo.getType());
    }

    @Test
    @DisplayName("Test getFileIndex returns correct value")
    void testGetFileIndex() throws SMBProtocolDecodingException {
        // Prepare test data
        byte[] buffer = createValidBuffer("file.txt", "FILE~1.TXT", true);
        int expectedFileIndex = 0x12345678;

        assertEquals("0011", Hexdump.toHexString(data4, 2, 4)); // Bug: ignores srcIndex, reads from 0
    }

    @Test
    @DisplayName("Should perform hexdump with correct formatting")
    void testHexdump() {
        // Capture output
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        PrintStream ps = new PrintStream(baos);

        cifsContextWrapper = new CIFSContextWrapper(mockDelegate);
    }

    @Test
    void testConstructor() {
        // Verify that the delegate is correctly set
        assertNotNull(cifsContextWrapper);
    }

    @Test
    void testGetSmbResource() throws CIFSException, MalformedURLException {
        // Test get(String url) method

            int terminationPos = Strings.findUNITermination(bufferWithTermination, 0, bufferWithTermination.length);

            // Then
            assertEquals(stringBytes.length, terminationPos, "Should find termination at correct position");
        }

        @Test
        @DisplayName("findUNITermination should throw exception when termination not found")
        void testFindUNITerminationNotFound() {
            // Given

        }

        @Test
        @DisplayName("Should handle offset correctly")
        void testSignWithOffset() {
            byte[] largeData = new byte[256];
            int offset = 64;
            Arrays.fill(largeData, (byte) 0x00);

            digest.sign(largeData, offset, 128, request, response);

            // Verify signature is placed at correct location

            assertNull(context.getSalt());
        }
    }

    @Nested
    @DisplayName("Context Type Tests")
    class ContextTypeTests {

        @Test
        @DisplayName("Should return correct context type")
        void testGetContextType() {
            PreauthIntegrityNegotiateContext context = new PreauthIntegrityNegotiateContext();