}

    /**
     * Creates a security descriptor by decoding from a byte buffer.
     *
     * @param buffer the byte buffer containing the security descriptor data
     * @param bufferIndex the starting offset in the buffer
     * @param len the length of data to decode
     * @throws IOException if an I/O error occurs during decoding
     */

    private static final long serialVersionUID = 1L;

    /**
     * Constructs a new PAC decoding exception with no detail message.
     */
    public PACDecodingException() {
        this(null, null);
    }

    /**
     * Constructs a new PAC decoding exception with the specified detail message.
     * @param message the detail message
     */

 */
package jcifs.internal;

import jcifs.util.transport.Message;

/**
 * Common interface for all SMB message blocks in the jCIFS protocol implementation.
 * Provides core functionality for encoding/decoding SMB messages, handling message signing,
 * and managing message metadata such as IDs, commands, and authentication information.
 *
 * @author mbechler
 */
public interface CommonServerMessageBlock extends Message {

        // Close the static mock
        mockedStaticAuthData.close();
    }

    /**
     * Test constructor with a valid ASN.1 token.
     *
     * @throws IOException if ASN.1 encoding fails.
     * @throws PACDecodingException if PAC decoding fails.
     */
    @Test
    void testConstructor_ValidToken() throws IOException, PACDecodingException {
        // 1. GIVEN

            Encdec.dec_uint32le(smallBuffer, 0);
        });
    }

    @Test
    @DisplayName("Should handle time encoding/decoding")
    void testTimeOperations() {
        // Given
        Date currentDate = new Date();
        byte[] buffer = new byte[8];

        // When - Use direct encoding methods since time constants are private
        Encdec.enc_uint64le(currentDate.getTime(), buffer, 0);

     * Applies URL decoding with the specified character encoding.
     *
     * @param queryString the query string to parse
     * @param enc the character encoding to use for URL decoding
     * @return a map of parameter names to their decoded values
     * @throws IOException if an error occurs during URL decoding
     */

import org.junit.jupiter.params.provider.ValueSource;
import org.mockito.junit.jupiter.MockitoExtension;

/**
 * Unit tests for {@link NdrShort}.  The tests cover construction,
 * encoding and decoding logic, masking behaviour, alignment handling and
 * interaction with {@link NdrBuffer}.  All public behaviour is exercised.
 */
@ExtendWith(MockitoExtension.class)
class NdrShortTest {

    /**

 * Provides methods for encoding, decoding, and manipulating sets of AV pairs.
 *
 * @author mbechler
 */
public final class AvPairs {

    private AvPairs() {
    }

    /**
     * Decode a list of AvPairs
     *
     * @param data the encoded AV pairs data
     * @return individual pairs
     * @throws CIFSException if decoding fails
     */

            }
            // Simulate some encoding activity on the buffer
            dst.enc_ndr_long(123);
        }

        @Override
        public void decode(NdrBuffer src) throws NdrException {
            if (throwOnDecode) {
                throw new NdrException("Failed to decode");
            }
            // Simulate some decoding activity on the buffer
            src.dec_ndr_long();
        }

    if (c == '%' || c == '+' && plusIsSpace) {
      // Slow path: the character at i requires decoding!
      val out = Buffer()
      out.writeUtf8(this, pos, i)
      out.writePercentDecoded(this, pos = i, limit = limit, plusIsSpace = plusIsSpace)
      return out.readUtf8()
    }
  }

  // Fast path: no characters in [pos..limit) required decoding.
  return substring(pos, limit)
}

internal fun String.isPercentEncoded(