byte[] buffer = new byte[totalSize + 100]; // Extra space for safety
        int bufferIndex = 0;
        int start = 0;

        // Set converter value first
        setConverter(response, 0);

        // Set number of entries
        setNumEntries(response, 1);

        // Write share name (13 bytes, null padded)

 * href="https://en.wikipedia.org/wiki/Graph_(discrete_mathematics)">graph</a>-structured data.
 *
 * <p>This interface is meant to be used as the type of a parameter to graph algorithms (such as
 * breadth first traversal) that only need a way of accessing the successors of a node in a graph.
 *
 * <h3>Usage</h3>
 *
 * Given an algorithm, for example:
 *
 * {@snippet :

package jcifs.internal.smb1.trans2;

import jcifs.Configuration;
import jcifs.internal.smb1.trans.SmbComTransaction;
import jcifs.internal.util.SMBUtil;
import jcifs.util.Hexdump;

/**
 * SMB1 Trans2 Find First 2 transaction request implementation.
 * Initiates directory enumeration operations in SMB1 protocol, allowing clients
 * to search for files and directories matching specified patterns and criteria.
 *
 * @author mbechler
 */

        // sid (2 bytes)
        buffer[0] = 0x01;
        buffer[1] = 0x00;
        // numEntries (2 bytes)
        buffer[2] = 0x05;
        buffer[3] = 0x00;
        // isEndOfSearch (2 bytes, bit 0 of first byte)
        buffer[4] = 0x01; // end of search = true
        buffer[5] = 0x00;
        // eaErrorOffset (2 bytes)
        buffer[6] = 0x00;
        buffer[7] = 0x00;
        // lastNameOffset (2 bytes)

        // to specify the absolute path to these files in a customized components.xml
        // file. Ideally, we'd do full pattern-evaluation against the sysprops, but this
        // is a first step. There are several replacements below, in order to normalize
        // the path character before we operate on the string as a regex input, and
        // in order to avoid surprises with the File construction...

        int bytesWritten = trans.writeSetupWireFormat(dst, 0);

        // Then
        assertEquals(2, bytesWritten, "Should write 2 bytes.");
        assertEquals(SmbComTransaction.TRANS2_QUERY_PATH_INFORMATION, dst[0], "The first byte should be the subCommand.");
        assertEquals((byte) 0x00, dst[1], "The second byte should be 0.");
    }

    /**
     * Tests the writeParametersWireFormat method.
     */
    @Test

        // When
        String result = Hexdump.toHexString(data, 0, data.length);

        // Then
        assertNotNull(result);
        assertFalse(result.isEmpty());
        // Should contain hex representation of first bytes
        assertTrue(result.startsWith("00010203"));
        assertEquals(64, result.length()); // 32 bytes * 2 chars per byte
    }

    @ParameterizedTest
    @ValueSource(ints = { 1, 16, 32, 64, 128, 256 })

 * priority. If you need to enforce an ordering, you can define custom classes or comparators that
 * use a secondary key to break ties in primary priority values. For example, here is a class that
 * applies first-in-first-out tie-breaking to comparable elements. To use it, you would insert a
 * {@code new FIFOEntry(anEntry)} instead of a plain entry object.
 *
 * <pre>{@code

    for (Type bound : bounds) {
      Type componentType = getComponentType(bound);
      if (componentType != null) {
        // Only the first bound can be a class or array.
        // Bounds after the first can only be interfaces.
        if (componentType instanceof Class) {
          Class<?> componentClass = (Class<?>) componentType;
          if (componentClass.isPrimitive()) {

Here we are declaring a `UserIn` model, it will contain a plaintext password:

{* ../../docs_src/response_model/tutorial002_py310.py hl[7,9] *}

/// info

To use `EmailStr`, first install <a href="https://github.com/JoshData/python-email-validator" class="external-link" target="_blank">`email-validator`</a>.