JApiCompatibilityChangeType.METHOD_REMOVED_IN_SUPERCLASS, // the removal of the method will be reported
        JApiCompatibilityChangeType.INTERFACE_REMOVED,            // the removed methods will be reported
        JApiCompatibilityChangeType.INTERFACE_ADDED               // the added methods will be reported
    );

    private static final Set<JApiCompatibilityChangeType> ANNOTATION_RELATED_CHANGES = Set.of(

    /**
     * Kotlin DSL source code to be documented. This should be the "public" Kotlin APIs,
     * including generated code.
     */
    public abstract ConfigurableFileCollection getKotlinDslSource();

    /**
     * The runtime classpath of the source code to be documented.
     */
    public abstract ConfigurableFileCollection getClasspath();

    /**
     * A working directory to be used to stage documentation as its generated.

        assertNotNull(annotation, "Annotation should be present on field");
        assertEquals("Default message should match", "{jakarta.validation.constraints.Size.message}", getDefaultMessage());
        assertEquals("Default groups should be empty", 0, getDefaultGroups().length);
        assertEquals("Default payload should be empty", 0, getDefaultPayload().length);
        assertEquals("Default minKey should be empty", StringUtil.EMPTY, getDefaultMinKey());

        Boolean result = invokeIsValidUploadPath(maliciousFile, baseDir);
        assertFalse("Path traversal with ../ should be blocked", result);
    }

    @Test
    public void test_isValidUploadPath_pathTraversal_encoded() throws Exception {
        // Test path traversal that would be decoded
        File baseDir = new File(tempDir.toFile(), "images");
        baseDir.mkdirs();

        // onclick attribute should be removed
        assertFalse(result.contains("onclick"));
    }

    @Test
    public void test_render_xss_javascriptProtocol() {
        String malicious = "[Click me](javascript:alert('XSS'))";
        String result = markdownRenderer.render(malicious);
        // javascript: protocol should be blocked
        assertFalse(result.contains("javascript:"));
    }

### Migration and Enforcement

* **New code**: All new contributions must use American English
* **Existing code**: British English spellings in existing code should be updated opportunistically when those areas are modified, unless constrained by backward compatibility

Public properties are **stable properties**: they CANNOT be renamed or removed without notice.
While we normally deprecate the feature or behavior itself, changes to the property cannot happen in a minor release.
Public properties must be documented.

**Internal properties** are not part of the Public API.
Internal properties are **unstable properties**: they CAN be renamed or removed without notice.
They are not intended for general use.

 * Elevate words are terms that should be promoted or given higher ranking in search results.
 * This form is used in the admin interface to upload elevate word configuration files.
 */
public class UploadForm {

    /**
     * The multipart file containing the elevate word configurations to be uploaded.
     * This file should contain definitions for words or documents that should be elevated in search results.
     */
    @Required

            // Check return type
            assertEquals("Return type should be String", String.class, method.getReturnType());

            // Check that it's static
            assertTrue("Method should be static", java.lang.reflect.Modifier.isStatic(method.getModifiers()));

            // Check that it's public
            assertTrue("Method should be public", java.lang.reflect.Modifier.isPublic(method.getModifiers()));

 * Validates and optionally fixes the computed target runtimes for projects
 * in the Gradle build.
 *
 * Each project may require a set of "target runtimes" that it must be able to run on.
 * Each target runtime reflects a runtime environment where code is executed. For one
 * project to be able to run in a given runtime, all of its dependencies must also
 * support running in that runtime.
 *