*
 * @author mbechler
 *
 */
public class RuntimeCIFSException extends RuntimeException {

    /**
     *
     */
    private static final long serialVersionUID = -2611196678846438579L;

    /**
     * Constructs a runtime CIFS exception with no detail message.
     */
    public RuntimeCIFSException() {
    }

    /**

/**
 * Test class for RuntimeCIFSException functionality
 */
@DisplayName("RuntimeCIFSException Tests")
class RuntimeCIFSExceptionTest extends BaseTest {

    @Test
    @DisplayName("Should create RuntimeCIFSException with default constructor")
    void testDefaultConstructor() {
        // When
        RuntimeCIFSException exception = new RuntimeCIFSException();

        // Then

package jcifs.util;

import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import jcifs.Configuration;
import jcifs.RuntimeCIFSException;

/**
 * Utility class for string manipulation and conversion operations in the jCIFS library.
 * Provides methods for encoding, decoding, and manipulating strings in SMB operations.
 *
 * @author mbechler
 */

        // Validates usage counting and that an extra release() throws RuntimeCIFSException
        // First close -> usage 1 -> 0, triggers treeConnection.release()
        handle.close();
        verify(treeConnection, times(1)).release();

        // Second release -> usage 0 -> -1 triggers RuntimeCIFSException
        RuntimeCIFSException ex = assertThrows(RuntimeCIFSException.class, () -> handle.release());

        assertNull(exception.getCause(), "Default constructor should have null cause");
        assertTrue(exception instanceof RuntimeCIFSException, "Should extend RuntimeCIFSException");
        assertTrue(exception instanceof RuntimeException, "Should be a RuntimeException");
    }

    @Test
    @DisplayName("Message constructor should create exception with specified message")

        @Test
        @DisplayName("getOEMBytes should throw RuntimeCIFSException for unsupported encoding")
        void testGetOEMBytesWithUnsupportedEncoding() {
            // Given
            Configuration mockConfig = mock(Configuration.class);
            when(mockConfig.getOemEncoding()).thenReturn("INVALID-ENCODING");

            // When & Then
            RuntimeCIFSException exception = assertThrows(RuntimeCIFSException.class, () -> {

 */

package jcifs.internal.smb1.com;

import java.io.ByteArrayOutputStream;
import java.io.IOException;

import jcifs.Configuration;
import jcifs.RuntimeCIFSException;
import jcifs.internal.SmbNegotiationRequest;
import jcifs.internal.smb1.ServerMessageBlock;
import jcifs.util.Strings;

/**
 * SMB1 Negotiate Protocol request message.
 *

        c.release();
        verify(tree, times(1)).release();
    }

    @Test
    @DisplayName("release below zero throws RuntimeCIFSException")
    void release_belowZero_throws() {
        SmbTreeConnection c = newConn();
        RuntimeCIFSException ex = assertThrows(RuntimeCIFSException.class, c::release);
        assertTrue(ex.getMessage().toLowerCase().contains("usage count"));
    }

    @Test

                } catch (final GeneralSecurityException e) {
                    throw new RuntimeCIFSException("Failed to encrypt password", e);
                }
                this.passwordLength = this.password.length;
            } else if (this.ctx.getConfig().isDisablePlainTextPasswords()) {
                throw new RuntimeCIFSException("Plain text passwords are disabled");
            } else {
                // plain text

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

package jcifs.internal.smb1.trans.nt;

import java.io.IOException;

import jcifs.Configuration;
import jcifs.RuntimeCIFSException;
import jcifs.internal.dtyp.SecurityDescriptor;
import jcifs.internal.util.SMBUtil;

/**
 * Response for SMB1 NT Transaction security descriptor query.
 *