assertTrue(result.contains("secretkey={cipher}"));
        assertFalse(result.contains("secretkey=unencrypted"));

        // Test with keys that don't match pattern
        value = "normalfield=value\npassword=secret";
        result = ParameterUtil.encrypt(value);
        assertTrue("Result should contain normalfield=value, but was: " + result, result.contains("normalfield=value"));

        getPathMapping(form).ifPresent(entity -> {
            try {
                pathMappingService.store(entity);
                saveInfo(messages -> messages.addSuccessCrudCreateCrudTable(GLOBAL));
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationError(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)),

    }

    /**
     * Encode the JSP content.
     * @param value The value.
     * @return The encoded value.
     */
    public static String encodeJsp(final String value) {
        return value.replace("<% try{ %>", TRY_STATEMENT)

/**
 * Kotlin 2.2 produces bridge methods for invoke operator functions compiled as JVM default methods.
 */
class KotlinInvokeDefaultBridgeFilter implements BehaviorFilter {
    @Override
    boolean matches(CtBehavior ctBehavior) {
        return ctBehavior.name.startsWith("access\$invoke\$jd")
    }

        try {
            throw new CommandExecutionException(expectedMessage);
        } catch (CommandExecutionException e) {
            assertEquals(expectedMessage, e.getMessage());
            assertNull(e.getCause());
        } catch (Exception e) {
            fail("Should have caught CommandExecutionException");
        }
    }

    @Test

    public OptionalEntity<UserInfo> getUserInfo(final String userCode) {
        if (StringUtil.isNotBlank(userCode)) {
            try {
                return OptionalEntity.of(userInfoCache.get(userCode));
            } catch (final ExecutionException e) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Failed to access UserInfo cache.", e);
                }
            }
        }

 */
class BridgeForBytecodeUpgradeAdapterClassFilter implements ClassFilter {

    private static final BRIDGE_CLASS_PREFIX = "\$\$BridgeFor\$\$"

    @Override
    boolean matches(CtClass ctClass) {
        return ctClass.name.contains(BRIDGE_CLASS_PREFIX) && ctClass.hasAnnotation(Generated.class)
    }

        getDataConfig(form).ifPresent(entity -> {
            try {
                dataConfigService.store(entity);
                saveInfo(messages -> messages.addSuccessCrudCreateCrudTable(GLOBAL));
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationError(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)),

            // clear url filter
            urlFilterService.delete(sid);
        } catch (final Exception e) {
            logger.warn("Failed to delete UrlFilter: sessionId={}", sid, e);
        }

        try {
            // clear queue
            urlQueueService.clearCache();
            urlQueueService.delete(sid);
        } catch (final Exception e) {

        paramMap.put("url_exclude_pattern", ".*");

        try {
            indexUpdateCallback.isUrlCrawlable(paramMap, null);
            fail("Expected NullPointerException for null URL");
        } catch (NullPointerException e) {
            // Expected behavior - the method doesn't handle null URLs
        }
    }

    @Test
    public void test_isUrlCrawlable_nullUrlWithoutPattern() {