System.arraycopy(validSig, 0, data, SIGNATURE_OFFSET, SIGNATURE_LENGTH);

            boolean validResult = digest.verify(data, 0, data.length, 0, msg);
            assertTrue(validResult, "Valid signature MUST return true - logic was previously inverted!");

            // Test 2: Invalid signature should return false
            byte[] invalidSig = new byte[SIGNATURE_LENGTH];
            Arrays.fill(invalidSig, (byte) 0xBA);

     */
    public void setMaxClientFactorySize(final int maxClientFactorySize) {
        if (maxClientFactorySize <= 0) {
            throw new IllegalArgumentException("maxClientFactorySize must be positive.");
        }
        this.maxClientFactorySize = maxClientFactorySize;
    }

import java.net.Socket;

import jcifs.smb1.Config;
import jcifs.smb1.util.LogStream;

/**
Do not use this class. Writing to the OutputStream of this type of socket
requires leaving a 4 byte prefix for the NBT header. IOW you must call
write( buf, 4, len ). Calling write( buf, 0, len ) will generate an error.
 */

public class NbtSocket extends Socket {

    private static final int SSN_SRVC_PORT = 139;

                 * returned by the Node Status. A new NbtAddress object should not be
                 * created for it because the original is potentially being actively
                 * referenced by other objects. We must populate the existing object's
                 * data explicitly (and carefully).
                 */
                if (!addrFound && queryAddress.hostName.hexCode == hexCode

     * @throws IllegalArgumentException if method is null
     */
    public CurlRequest(final Method method) {
        if (method == null) {
            throw new IllegalArgumentException("method must not be null");
        }
        this.method = method;
    }

    /**
     * Constructs a new CurlRequest with the specified HTTP method and URL.
     *
     * @param method the HTTP method

        bool((must, should, mustNot, filter) -> {
            filteredLambda.callback(must, filter);
        }, opLambda);
    }

    public void not(OperatorCall<DuplicateHostCQ> notLambda) {
        not(notLambda, null);
    }

    public void not(final OperatorCall<DuplicateHostCQ> notLambda, final ConditionOptionCall<BoolQueryBuilder> opLambda) {

        bool((must, should, mustNot, filter) -> {
            filteredLambda.callback(must, filter);
        }, opLambda);
    }

    public void not(OperatorCall<FailureUrlCQ> notLambda) {
        not(notLambda, null);
    }

    public void not(final OperatorCall<FailureUrlCQ> notLambda, final ConditionOptionCall<BoolQueryBuilder> opLambda) {

        dstIndex += 4;

        SMBUtil.writeInt4(leaseFlags, dst, dstIndex); // LeaseFlags (4 bytes)
        dstIndex += 4;

        SMBUtil.writeInt8(0, dst, dstIndex); // LeaseDuration (8 bytes) - reserved, must be zero
        dstIndex += 8;

        return dstIndex - start;
    }

    }

    @Override
    protected int readBytesWireFormat(byte[] buffer, int bufferIndex) throws SMBProtocolDecodingException {
        int start = bufferIndex;

        // StructureSize (2 bytes) - must be 44
        this.structureSize = SMBUtil.readInt2(buffer, bufferIndex);
        if (this.structureSize != 44) {
            throw new SMBProtocolDecodingException("Invalid lease break structure size: " + this.structureSize);

        bool((must, should, mustNot, filter) -> {
            filteredLambda.callback(must, filter);
        }, opLambda);
    }

    public void not(OperatorCall<PathMappingCQ> notLambda) {
        not(notLambda, null);
    }

    public void not(final OperatorCall<PathMappingCQ> notLambda, final ConditionOptionCall<BoolQueryBuilder> opLambda) {