// Then - Verify encrypted message structure
        assertNotNull(encrypted, "Encrypted message should not be null");
        assertTrue(encrypted.length > plaintext.length, "Encrypted message should be larger than plaintext");

        // Verify transform header is present (first 52 bytes)
        assertTrue(encrypted.length >= 52, "Encrypted message should include transform header");

        // When - Decrypt

     *
     * @return the command (human) name
     */
    @Nonnull
    String commandName();

    /**
     * Returns the logger to be used during the parsing process.
     *
     * @return the logger instance
     */
    @Nonnull
    Logger logger();

    /**
     * Returns the factory for creating message builders.
     *

        }

        @Test
        @DisplayName("Should create exception with message")
        void testConstructorWithMessage() {
            String message = "Test error message";
            TransportException exception = new TransportException(message);

            assertNotNull(exception);
            assertEquals(message, exception.getMessage());
            assertNull(exception.getRootCause());
        }

     * Maximum transmit buffer size for DCERPC messages
     */
    protected int max_xmit = 4280;
    /**
     * Maximum receive buffer size for DCERPC messages
     */
    protected int max_recv = max_xmit;
    /**
     * The current state of the DCERPC connection
     */
    protected int state = 0;
    /**
     * The security provider for authentication and message protection
     */

                logger.debug("WildcardQuery: query={}, boost={}", query, boost);
            }
            return convertWildcardQuery(context, wildcardQuery, boost);
        }
        throw new InvalidQueryException(messages -> messages.addErrorsInvalidQueryUnknown(UserMessages.GLOBAL_PROPERTY_KEY),
                "Unknown q: " + query.getClass() + " => " + query);
    }

    /**

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs.internal;

import jcifs.util.transport.Response;

/**
 * Interface for SMB response messages received from server.
 * Extends the common SMB message block with response-specific functionality including
 * asynchronous response handling and response chaining capabilities.
 *
 * @author mbechler
 */

import jcifs.smb1.dcerpc.ndr.NdrObject;

/**
 * Abstract base class for DCERPC messages.
 * This class provides common functionality for all DCE/RPC message types in SMB1 protocol.
 */
public abstract class DcerpcMessage extends NdrObject implements DcerpcConstants {

    /**
     * Default constructor for DcerpcMessage.
     * Initializes the DCE/RPC message structure for SMB1 protocol.
     */
    protected DcerpcMessage() {

                                    if (values.length != 2) {
                                        throw new InvalidQueryException(
                                                messages -> messages.addErrorsInvalidQueryUnknown(UserMessages.GLOBAL_PROPERTY_KEY),
                                                "Invalid geo point: " + pt);
                                    }
                                    try {

import org.junit.jupiter.api.extension.ExtensionContext
import org.junit.rules.TestRule
import org.junit.runner.Description
import org.junit.runners.model.Statement

/**
 * A log handler that records which log messages were published so that a calling test can make
 * assertions about them.
 */
class TestLogHandler(
  private val logger: Logger,
) : TestRule,
  BeforeEachCallback,
  AfterEachCallback {

                logger.debug("FuzzyQuery: query={}, boost={}", query, boost);
            }
            return convertFuzzyQuery(context, fuzzyQuery, boost);
        }
        throw new InvalidQueryException(messages -> messages.addErrorsInvalidQueryUnknown(UserMessages.GLOBAL_PROPERTY_KEY),
                "Unknown q: " + query.getClass() + " => " + query);
    }

    /**