Thread.currentThread().interrupt();
                } finally {
                    endLatch.countDown();
                }
            }
        });

        thread1.start();
        thread2.start();
        startLatch.countDown();
        endLatch.await(5, TimeUnit.SECONDS);

        assertEquals(2, successCount.get());
    }

    /**

        final int start = bufferIndex;
        final int structureSize = SMBUtil.readInt2(buffer, bufferIndex);
        if (structureSize != 4) {
            throw new SMBProtocolDecodingException("Expected structureSize = 4");
        }
        return bufferIndex - start;
    }

## MinIO KMS Quick Start

MinIO supports two ways of encrypting IAM and configuration data.
You can either use KES - together with an external KMS - or, much simpler,
set the env. variable `MINIO_KMS_SECRET_KEY` and start/restart the MinIO server. For more details about KES and how

        this.container.innerHTML = '';
        for (let line of this.lines) {
            line.style.visibility = 'visible'
        }
        this.start();
    }

    /**
     * Start the animation and rener the lines depending on their data attributes.
     */
    async start() {
        this.addFinish()
        await this._wait(this.startDelay);

        for (let line of this.lines) {

For example, in Visual Studio Code, you can:

* Go to the "Debug" panel.
* "Add configuration...".
* Select "Python"
* Run the debugger with the option "`Python: Current File (Integrated Terminal)`".

It will then start the server with your **FastAPI** code, stop at your breakpoints, etc.

Here's how it might look:

<img src="/img/tutorial/debugging/image01.png">

---

If you use Pycharm, you can:

    // Test default state of not started.
    assertEquals(1, listenerLatch.getCount());
    assertFalse(task.isDone());
    assertFalse(task.isCancelled());

    // Start the task to put it in the RUNNING state.  Have to use a separate
    // thread because the task will block on the task latch after unblocking
    // the run latch.
    exec.execute(task);
    runLatch.await();

        writeInt4(dst, dstIndex, shareAccessHint);
        dstIndex += 4;
        
        return dstIndex - start;
    }
    
    @Override
    protected int readPayload(byte[] buffer, int offset) throws SMBProtocolDecodingException {
        int start = offset;
        
        // StructureSize (2 bytes)
        structureSize = readInt2(buffer, offset);
        offset += 2;
        

        dstIndex++;
        dst[dstIndex++] = (byte) 0x00;
        return 2;
    }

    @Override
    protected int writeParametersWireFormat(final byte[] dst, int dstIndex) {
        final int start = dstIndex;

        SMBUtil.writeInt2(this.searchAttributes, dst, dstIndex);
        dstIndex += 2;
        SMBUtil.writeInt2(this.maxItems, dst, dstIndex);
        dstIndex += 2;

        final int start = bufferIndex;
        final int structureSize = SMBUtil.readInt2(buffer, bufferIndex);
        if (structureSize != 4) {
            throw new SMBProtocolDecodingException("Expected structureSize = 4");
        }
        bufferIndex += 4;

        return bufferIndex - start;
    }

    SmbComNtTransactionResponse() {
    }

    @Override
    int readParameterWordsWireFormat(final byte[] buffer, int bufferIndex) {
        final int start = bufferIndex;

        buffer[bufferIndex] = (byte) 0x00; // Reserved
        bufferIndex++;
        buffer[bufferIndex++] = (byte) 0x00; // Reserved
        buffer[bufferIndex++] = (byte) 0x00; // Reserved