Para el "sincrónico" (contrario al "asíncrono") comúnmente también usan el término "secuencial", porque la computadora / programa sigue todos los pasos en secuencia antes de cambiar a una tarea diferente, incluso si esos pasos implican esperar.

### Concurrencia y Hamburguesas

Para "síncrono" (contrário de "assíncrono") também é utilizado o termo "sequencial", porquê o computador / programa segue todos os passos, em sequência, antes de trocar para uma tarefa diferente, mesmo se alguns passos envolvam esperar.

### Concorrência e hambúrgueres

        void testFileActionRemovedByDelete() {
            assertEquals(0x00000009, FileNotifyInformation.FILE_ACTION_REMOVED_BY_DELETE);
        }

        @Test
        @DisplayName("Verify action constants are sequential and unique")
        void testActionConstantsAreUnique() {
            int[] actions = { FileNotifyInformation.FILE_ACTION_ADDED, FileNotifyInformation.FILE_ACTION_REMOVED,

        assertEquals(999L, item.getId());

        // Verify direct field access
        assertEquals(999L, item.id);
    }

    public void test_sequentialIdAssignment() {
        // Test sequential ID assignment pattern
        TestDictionaryItem[] items = new TestDictionaryItem[5];

        for (int i = 0; i < items.length; i++) {
            items[i] = new TestDictionaryItem();
            items[i].id = i + 1;

        assertNotNull(retrieved);
        assertEquals(engine, retrieved);
    }

    // Test concurrent-like scenario (sequential but simulating concurrent behavior)
    public void test_add_multipleSameNameSequential() {
        TestScriptEngine engine1 = new TestScriptEngine("v1");
        TestScriptEngine engine2 = new TestScriptEngine("v2");

///

## Hashing de contraseñas

"Hacer hashing" significa convertir algún contenido (una contraseña en este caso) en una secuencia de bytes (solo un string) que parece un galimatías.

Siempre que pases exactamente el mismo contenido (exactamente la misma contraseña) obtienes exactamente el mismo galimatías.

        byte[] readFileId = new byte[16];
        System.arraycopy(buffer, 8, readFileId, 0, 16);
        assertArrayEquals(nullFileId, readFileId);
    }

    @Test
    @DisplayName("Should handle sequential operations")
    void testSequentialOperations() {
        // Given
        request.setNotifyFlags(0);
        request.setCompletionFilter(0);

        // When - first write

        assertEquals(SmbComTransaction.TRANS2_SET_FILE_INFORMATION, newResponse.getSubCommand());
    }

    @Test
    @DisplayName("Test multiple sequential calls to read/write methods")
    void testMultipleSequentialCalls() {
        byte[] buffer = new byte[200];

        // Multiple calls should each return 0
        for (int i = 0; i < 10; i++) {

            // Verify reserved section is zero
            assertEquals(0, SMBUtil.readInt4(buffer, 20));
        }

        @Test
        @DisplayName("Should handle multiple sequential encodings")
        void testMultipleSequentialEncodings() {
            // Given
            SrvCopychunk chunk1 = new SrvCopychunk(100, 200, 300);
            SrvCopychunk chunk2 = new SrvCopychunk(400, 500, 600);

    }

    @Test
    @DisplayName("EmptyIterator should behave consistently across multiple calls")
    void testConsistentBehavior() {
        // When & Then - test multiple sequential calls
        for (int i = 0; i < 10; i++) {
            assertFalse(emptyIterator.hasNext(), "hasNext should consistently return false");
            assertNull(emptyIterator.next(), "next should consistently return null");