assertEquals(8, entries[0].getType()); // TYPE_SHARE

        // Verify printer share
        assertEquals("PrinterShare", entries[1].getName());
        assertEquals(32, entries[1].getType()); // TYPE_PRINTER (0x20)

        // Verify named pipe
        assertEquals("PipeShare", entries[2].getName());
        assertEquals(16, entries[2].getType()); // TYPE_NAMED_PIPE
    }

        // Check first pair (AvFlags)
        assertEquals(AvPair.MsvAvFlags, pairs.get(0).getType(), "First pair should be MsvAvFlags");
        assertTrue(pairs.get(0) instanceof AvFlags, "First pair should be AvFlags instance");

        // Check second pair (AvTimestamp)
        assertEquals(AvPair.MsvAvTimestamp, pairs.get(1).getType(), "Second pair should be MsvAvTimestamp");

        @Test
        @DisplayName("getType should return valid SMB resource type")
        void testGetType() throws CIFSException {
            // Given
            int expectedType = 1; // Assuming TYPE_FILESYSTEM
            when(mockResource.getType()).thenReturn(expectedType);

            // When
            int type = mockResource.getType();

            // Then

        assertEquals(SmbConstants.TYPE_FILESYSTEM, locator("smb://server/share/path").getType());

        // Named pipe for IPC$ root
        assertEquals(SmbConstants.TYPE_NAMED_PIPE, locator("smb://server/IPC$/").getType());

        // Share when share set but no path
        assertEquals(SmbConstants.TYPE_SHARE, locator("smb://server/share/").getType());

        // Workgroup when no authority

        byte[] testHash = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
        AvChannelBindings avChannelBindings = new AvChannelBindings(testHash);

        assertEquals(AvPair.MsvAvChannelBindings, avChannelBindings.getType(), "Type should be MsvAvChannelBindings");
        assertArrayEquals(testHash, avChannelBindings.getRaw(), "Value should match the provided hash");
    }

    /**

            SmbNamedPipe pipe = new SmbNamedPipe(url, SmbPipeResource.PIPE_TYPE_RDWR, ctx());

            // Assert: type is named pipe and pipe type preserved
            assertEquals(SmbConstants.TYPE_NAMED_PIPE, pipe.getType(), "Type should be TYPE_NAMED_PIPE");
            assertEquals(SmbPipeResource.PIPE_TYPE_RDWR, pipe.getPipeType(), "Pipe type should match constructor");
        }

        @ParameterizedTest

            log.trace(String.format("Checksum data %s type %d signature %s", Hexdump.toHexString(checksumData),
                    this.serverSignature.getType(), Hexdump.toHexString(this.serverSignature.getChecksum())));
        }

        byte checksum[] = PacMac.calculateMac(this.serverSignature.getType(), keys, checksumData);
        if (!MessageDigest.isEqual(this.serverSignature.getChecksum(), checksum)) {
            if (log.isDebugEnabled()) {

                final MediaType mediaTypeFromFilename = mimeTypes.detect(null, metadata);
                return mediaTypeFromFilename.getType() + "/" + mediaTypeFromFilename.getSubtype();
            }
            return mediaType.getType() + "/" + mediaType.getSubtype();
        } catch (final IOException e) {
            throw new MimeTypeException("Could not detect a content type.", e);
        }
    }

                "8, Unknown" })
        @DisplayName("getType and getTypeText cover all types")
        void testGetTypeAndText(int type, String text) {
            byte[] ident = new byte[] { 0, 0, 0, 0, 0, 5 };
            SID sid = new SID(buildSidT((byte) 1, ident, 42), type, "DOM", "acct", false);
            assertEquals(type, sid.getType());
            assertEquals(text, sid.getTypeText());
        }

        AvTargetName avTargetName = new AvTargetName(rawBytes);

        // Verify the AvPair type is MsvAvTargetName
        assertEquals(AvPair.MsvAvTargetName, avTargetName.getType(), "AvPair type should be MsvAvTargetName");
        // Verify the raw bytes are correctly stored
        assertArrayEquals(rawBytes, avTargetName.getRaw(), "Raw bytes should match the input");
    }

    /**