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

    /**
     * Constructs a CIFS unsupported crypto exception with no detail message.
     */
    public CIFSUnsupportedCryptoException() {
    }

    /**
     * Constructs a CIFS unsupported crypto exception with the specified detail message and cause.
     *
     * @param message the detail message

# | LONGVARBINARY | byte[]               | byte[]        |
# | BLOB          | byte[]               | byte[]        |
# | ARRAY         | *Unsupported         | *Unsupported  |
# | UUID          | java.util.UUID       | *Unsupported  |

        largeTestData = generateTestData(8192);
    }

    @Test
    @DisplayName("Test supported algorithms")
    public void testSupportedAlgorithms() {
        int[] supported = compressionService.getSupportedAlgorithms();
        assertNotNull(supported);
        assertTrue(supported.length > 0);

        assertTrue(compressionService.isAlgorithmSupported(CompressionService.COMPRESSION_NONE));

            return new byte[0];
        }
        try {
            return str.getBytes(config.getOemEncoding());
        } catch (final UnsupportedEncodingException e) {
            throw new RuntimeCIFSException("Unsupported OEM encoding " + config.getOemEncoding(), e);
        }
    }

    /**
     * Decodes a string from UTF-16LE (Unicode Little Endian) bytes.
     *

            } else {
                throw new SmbException("Unsupported credential type " + (cred != null ? cred.getClass() : "NULL"));
            }
        } else if (server.security == SmbConstants.SECURITY_SHARE) {
            if (!(cred instanceof final NtlmPasswordAuthenticator a)) {
                throw new SmbException("Unsupported credential type");
            }
            this.lmHash = new byte[0];

    }

    /**
     * Test decrypt with an unsupported encryption type.
     */
    @Test
    void testDecryptUnsupportedType() {
        Key key = new KerberosKey(null, new byte[16], 99, 0);
        byte[] data = new byte[16];
        Exception exception = assertThrows(GeneralSecurityException.class, () -> KerberosEncData.decrypt(data, key, 99));
        assertEquals("Unsupported encryption type 99", exception.getMessage());
    }

                blob = (byte[]) cred;
            } else {
                throw new SmbException("Unsupported credential type");
            }
        } else if (session.transport.server.security == SECURITY_SHARE) {
            if (!(cred instanceof final NtlmPasswordAuthentication auth)) {
                throw new SmbException("Unsupported credential type");
            }
            lmHash = new byte[0];
            ntHash = new byte[0];

    @NullAndEmptySource
    @ValueSource(strings = { "AES encryption not supported", "Missing Bouncy Castle provider", "Invalid key length for AES-128",
            "RC4 cipher not available in this JVM", "DES encryption is deprecated and not supported", "HMAC-SHA256 algorithm not found",
            "RSA key generation failed: key size not supported" })
    void testMessageConstructorWithCryptoMessages(String message) {
        // Given & When

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

/**
 * Exception thrown when an unsupported search operation is requested.
 * This exception indicates that the requested search functionality is not available or supported.
 */
public class UnsupportedSearchException extends FessSystemException {

    private static final long serialVersionUID = 1L;

    /**

        try {
            final ActionResponse actionResponse = ssoManager.getResponse(SsoResponseType.METADATA);
            if (actionResponse == null) {
                throw responseManager.new400("Unsupported request type.");
            }
            return actionResponse;
        } catch (final SsoMessageException e) {
            if (e.getCause() == null) {
                if (logger.isDebugEnabled()) {