labels.user_given_name=Nombre de pila
labels.givenName=Nombre (dado)
labels.user_surname=Apellido
labels.surame=Apellido
labels.user_mail=Dirección de correo electrónico
labels.mail=Dirección de correo electrónico
labels.user_employeeNumber=Número de empleado
labels.employeeNumber=Número de empleado
labels.user_telephoneNumber=Número de teléfono
labels.telephoneNumber=Número de teléfono

 *
 * the access check would fail because the direct ACE has an access mask
 * of <code>0x001200A9</code> which doesn't have the
 * <code>FILE_WRITE_DATA</code> bit on (bit <code>0x00000002</code>). Actually, this isn't quite correct. If
 * <code>WNET\alice</code> is in the local <code>Administrators</code> group the access check
 * will succeed because the inherited ACE allows local <code>Administrators</code>

        // Then
        assertNotNull(transCallNamedPipe);
        assertEquals(TEST_PIPE_NAME, transCallNamedPipe.name);
    }

    @Test
    @DisplayName("Test writeSetupWireFormat writes correct bytes")
    void testWriteSetupWireFormat() {
        // Given
        transCallNamedPipe = new TransCallNamedPipe(mockConfig, TEST_PIPE_NAME, TEST_DATA, 0, TEST_DATA.length);
        byte[] dst = new byte[10];

        Future<?> possiblyIgnoredError = executor.submit(task);
      }
      awaitUnchecked(barrier);
      assertThat(future.isDone()).isTrue();
      // inspect state and ensure it is correct!
      // asserts that all get calling threads received the same value
      Object result = Iterables.getOnlyElement(finalResults);
      if (result == CancellationException.class) {
        assertTrue(future.isCancelled());

        // The setup count should be initialized to 0x04 in the constructor
        // We can't directly access it, but we can verify the behavior is correct
        assertNotNull(notifyChange);
    }

    @Test
    @DisplayName("Test combined completion filters")
    void testCombinedCompletionFilters() {
        int combinedFilter =

            assertTrue(cause instanceof SMBProtocolDecodingException, "Actual cause should be SMBProtocolDecodingException");
            assertEquals("Structure size is not 16", cause.getMessage(), "Should have correct error message");
        }

        @Test
        @DisplayName("Should write empty bytes for wire format")
        void testWriteBytesWireFormat() throws Exception {
            // Given

        int encodedLength = request.encode(buffer, offset);

        // Verify encoded length
        assertEquals(request.size(), encodedLength);

        // Verify data at correct offset
        assertEquals(DEFAULT_CAPABILITIES, SMBUtil.readInt4(buffer, offset));
        assertEquals(DEFAULT_SECURITY_MODE, SMBUtil.readInt2(buffer, offset + 20));

        when(standardInfo.getFileInformationLevel()).thenReturn(FileInformation.FILE_STANDARD_INFO);
        when(internalInfo.getFileInformationLevel()).thenReturn(FileInformation.FILE_INTERNAL_INFO);

        // Verify each has correct level
        assertEquals(FileInformation.FILE_BASIC_INFO, basicInfo.getFileInformationLevel());
        assertEquals(FileInformation.FILE_STANDARD_INFO, standardInfo.getFileInformationLevel());

     * hashes (meaning negotiated via NTLM HTTP Authentication) and the other does not they will not be equal. This is
     * technically not correct however the server 8 byte challenge would be required to compute and compare the password
     * hashes but that it not available with this method.
     */
    @Override
    public boolean equals(final Object obj) {

        assertNotNull(info);
        assertTrue(info.toString().contains("endOfFile=" + endOfFile));
    }

    @Test
    @DisplayName("Test getFileInformationLevel returns correct value")
    void testGetFileInformationLevel() {
        assertEquals(FileInformation.FILE_ENDOFFILE_INFO, fileInfo.getFileInformationLevel());

        // Test with parameterized constructor