props.setProperty("jcifs.smb.client.useRDMA", "invalid");
        props.setProperty("jcifs.smb.client.rdmaReadWriteThreshold", "invalid");
        props.setProperty("jcifs.smb.client.rdmaMaxSendSize", "invalid");
        props.setProperty("jcifs.smb.client.rdmaMaxReceiveSize", "invalid");
        props.setProperty("jcifs.smb.client.rdmaCredits", "invalid");

        PropertyConfiguration config = new PropertyConfiguration(props);

    int NT_STATUS_NOT_IMPLEMENTED = 0xC0000002;
    /** The specified information class is invalid */
    int NT_STATUS_INVALID_INFO_CLASS = 0xC0000003;
    /** Invalid access to memory location */
    int NT_STATUS_ACCESS_VIOLATION = 0xC0000005;
    /** The handle is invalid */
    int NT_STATUS_INVALID_HANDLE = 0xC0000008;
    /** The parameter is incorrect */

            } catch (NumberFormatException e) {
                // Invalid value ignored
            }
        }

        value = props.getProperty("jcifs.smb.client.soTimeout");
        if (value != null) {
            try {
                this.smbSocketTimeout = Integer.parseInt(value);
            } catch (NumberFormatException e) {
                // Invalid value ignored
            }
        }

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.exception;

/**
 * Exception thrown when an invalid access token is encountered.
 * This exception is typically used in authentication and authorization contexts
 * where a provided access token is invalid, expired, or malformed.
 */
public class InvalidAccessTokenException extends FessSystemException {

    /** Serial version UID for serialization */

     */
    @Test
    public void testReleaseBufferValidation() {
        // Given - Various invalid buffers
        byte[] nullBuffer = null;
        byte[] wrongSizeBuffer = new byte[100]; // Wrong size
        byte[] correctBuffer = new byte[SmbComTransaction.TRANSACTION_BUF_SIZE];

        // When/Then - Should handle invalid buffers gracefully
        assertDoesNotThrow(() -> {

            throw new IllegalArgumentException("Username contains invalid characters: " + username);
        }
    }

    /**
     * Validates domain name
     *
     * @param domain the domain to validate
     * @throws IllegalArgumentException if domain is invalid
     */
    public static void validateDomain(String domain) {
        if (domain == null) {

        assertEquals(21, sid.sub_authority[0]);
        assertEquals(1, sid.sub_authority[1]);
    }

    /**
     * Test constructor with an invalid SID string.
     */
    @Test
    void testStringConstructorInvalidFormat() {
        assertThrows(SmbException.class, () -> new SID("invalid-sid"));
        assertThrows(SmbException.class, () -> new SID("S-1"));
    }

    /**
     * Test constructor with a byte array.
     */

    assertFailsToDecode(base64(), "12345", "Invalid input length 5");
    // These have a combination of invalid length, unrecognized characters and wrong padding.
    assertFailsToDecode(base64(), "AB=C", "Unrecognized character: =");
    assertFailsToDecode(base64(), "A=BCD", "Invalid input length 5");
    assertFailsToDecode(base64(), "?", "Invalid input length 1");
  }

  public void testBase64CannotUpperCase() {

        assertTrue(violations.isEmpty());
    }

    // Test validation with invalid cron expressions
    public void test_invalidCronExpressions() {
        TestBean bean = new TestBean();

        // Test invalid cron expression
        bean.setCronExpression("invalid");
        Set<ConstraintViolation<TestBean>> violations = validator.validate(bean);
        assertFalse(violations.isEmpty());

            log.warn("Invalid SMB protocol ID: 0x{}", Integer.toHexString(protocolId));
            throw new SmbException("Invalid SMB protocol identifier");
        }

        // Validate command is in valid range
        if (command < 0 || command > 255) {
            failedValidations.incrementAndGet();
            throw new SmbException("Invalid command code: " + command);
        }
    }