@MockitoSettings(strictness = Strictness.LENIENT)
class Smb2SessionSetupResponseTest extends BaseTest {

    private Smb2SessionSetupResponse newResponse() {
        // Configuration is not used during decode when no signing digest is set
        Configuration cfg = mock(Configuration.class);
        return new Smb2SessionSetupResponse(cfg);
    }

    /**
     * Build a minimal SMB2 header for a response at the given offset.

        // We will return a composite buffer from the test when building the full packet.
        // To keep this helper simple, return base and let the caller append/pad and inject ctx.
        return base;
    }

    /**
     * Build a full SMB2 packet combining header and provided body, optionally injecting context bytes.
     */

this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.

Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.

        sb.append(dm).append(userAgent);
        sb.append(dm).append(virtualHosts);
        if (sb.length() > dm.length()) {
            sb.delete(0, dm.length());
        }
        sb.insert(0, "{").append("}");
        return sb.toString();
    }

    // ===================================================================================

                        badWord.setSuggestWord(targetWord);
                        badWord.setCreatedBy(Constants.SYSTEM_USER);
                        badWord.setCreatedTime(now);
                        badWordBhv.insert(badWord);
                    } else {
                        badWord.setUpdatedBy(Constants.SYSTEM_USER);
                        badWord.setUpdatedTime(now);
                        badWordBhv.update(badWord);

    // ============================================================

    /** Basic authentication type identifier. */
    public static final String BASIC = "BASIC";

    /** Digest authentication type identifier. */
    public static final String DIGEST = "DIGEST";

    /** NTLM authentication type identifier. */
    public static final String NTLM = "NTLM";

    /** Form-based authentication type identifier. */

            transportContextField.setAccessible(true);
            transportContextField.set(ntlmServlet, cifsContext);
        } catch (Exception e) {
            throw new RuntimeException("Failed to inject mock CIFSContext", e);
        }

        when(cifsContext.getTransportPool()).thenReturn(transportPool);
        when(cifsContext.getNameServiceClient()).thenReturn(nameServiceClient);

        }

        return new PagingList<>(protwordsItemList.subList(offset, toIndex), offset, size, protwordsItemList.size());
    }

    @Override
    public synchronized void insert(final ProtwordsItem item) {
        try (ProtwordsUpdater updater = new ProtwordsUpdater(item)) {
            reload(updater);
        }
    }

    @Override

        
        return baos.toByteArray();
    }
    
    private byte[] calculateBindingHash(byte[] bindingInfo) throws IOException {
        try {
            MessageDigest digest = MessageDigest.getInstance("SHA-256");
            return digest.digest(bindingInfo);
        } catch (NoSuchAlgorithmException e) {
            throw new IOException("SHA-256 not available", e);
        }
    }
    

            byte[] hash = md.digest(input);
            System.arraycopy(hash, 0, derived, 0, Math.min(length, hash.length));

            // If we need more bytes, hash again with counter
            int counter = 1;
            while (derived.length > hash.length * counter) {
                md.update(input);
                md.update((byte) counter);
                hash = md.digest();