private static Stream<Arguments> provideNamesForWriteTest() {
        return Stream.of(Arguments.of("SERVER", 0x20, "CLIENT", 0x00), Arguments.of("WORKSTATION", 0x00, "USER", 0x03),
                Arguments.of("DOMAIN", 0x1B, "BROWSER", 0x1D), Arguments.of("A", 0x20, "B", 0x00),
                Arguments.of("VERYLONGNAMETEST", 0x20, "ANOTHERLONGNAME", 0x00));
    }

    @Test

        // Should match with same values
        assertTrue(fileInfo.matches(1024L, 1000L, 0x20));

        // Should not match with different size
        assertFalse(fileInfo.matches(2048L, 1000L, 0x20));

        // Should not match with different last modified
        assertFalse(fileInfo.matches(1024L, 2000L, 0x20));

        }

        return clearText;
    }

    // Tables, permutations, S-boxes, etc.

    private static byte[] bytebit =
            { (byte) 0x80, (byte) 0x40, (byte) 0x20, (byte) 0x10, (byte) 0x08, (byte) 0x04, (byte) 0x02, (byte) 0x01 };
    private static int[] bigbyte = { 0x800000, 0x400000, 0x200000, 0x100000, 0x080000, 0x040000, 0x020000, 0x010000, 0x008000, 0x004000,

        buffer[0] = 0x03;
        buffer[1] = 0x00;
        // isEndOfSearch (2 bytes)
        buffer[2] = 0x00; // end of search = false
        buffer[3] = 0x00;
        // eaErrorOffset (2 bytes)
        buffer[4] = 0x00;
        buffer[5] = 0x00;
        // lastNameOffset (2 bytes)
        buffer[6] = 0x08;
        buffer[7] = 0x00;

    @Test
    @DisplayName("Test LABEL_SECURITY_INFO constant value")
    void testLabelSecurityInfo() {
        assertEquals(0x10, SecurityInfo.LABEL_SECURITY_INFO);
    }

    @Test
    @DisplayName("Test ATTRIBUTE_SECURITY_INFO constant value")
    void testAttributeSecurityInfo() {
        assertEquals(0x20, SecurityInfo.ATTRIBUTE_SECURITY_INFO);
    }

    @Test
    @DisplayName("Test SCOPE_SECURITY_INFO constant value")

        assertEquals(1, NbtAddress.P_NODE);
        assertEquals(2, NbtAddress.M_NODE);
        assertEquals(3, NbtAddress.H_NODE);
        assertArrayEquals(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, NbtAddress.UNKNOWN_MAC_ADDRESS);
    }

        Name name1 = new Name(mockConfig, "TEST", 0x20, "scope");
        Name name2 = new Name(mockConfig, "TEST", 0x20, "scope");

        assertTrue(name1.equals(name2));
    }

    @Test
    void equals_withDifferentName_shouldReturnFalse() {
        Name name1 = new Name(mockConfig, "TEST1", 0x20, "scope");
        Name name2 = new Name(mockConfig, "TEST2", 0x20, "scope");

        assertFalse(name1.equals(name2));

 */
public class NameServiceClientImpl implements Runnable, NameServiceClient {

    private static final int NAME_SERVICE_UDP_PORT = 137;

    static final byte[] UNKNOWN_MAC_ADDRESS = { (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00 };

    private static final Logger log = LoggerFactory.getLogger(NameServiceClientImpl.class);

    private final Object LOCK = new Object();

    private int nbnsIndex = 0;

     */
    @Test
    void testConstructorWithMalformedKerberosToken() throws IOException {
        byte[] malformedToken = createGssApiWrapper(new ASN1ObjectIdentifier(KerberosConstants.KERBEROS_OID), new byte[] { 0x00, 0x00 });
        assertThrows(PACDecodingException.class, () -> new KerberosToken(malformedToken));
    }

    /**
     * Test constructor with missing APPLICATION tag in the token.
     *

        byte[] src = new byte[200];
        // Setup minimal valid header
        src[0] = 0x00;
        src[1] = 0x01; // Transaction ID
        src[2] = 0x00; // Flags
        src[3] = 0x00; // Flags
        src[4] = 0x00;
        src[5] = 0x01; // Question count

        // Act
        int result = nodeStatusRequest.readWireFormat(src, 0);

        // Assert