logger.logSecurityViolation("Test violation with stack trace", context);

        logger.setIncludeStackTrace(false);
        logger.logSecurityViolation("Test violation without stack trace", context);

        Map<EventType, Long> stats = logger.getStatistics();
        assertEquals(Long.valueOf(2), stats.get(EventType.SECURITY_VIOLATION), "Should have 2 security violation events");
    }

    @Test

import japicmp.model.JApiClass
import japicmp.model.JApiCompatibility
import javassist.CtClass
import javassist.CtMethod
import javassist.Modifier
import me.champeau.gradle.japicmp.report.Violation

import static japicmp.model.JApiCompatibilityChangeType.METHOD_REMOVED_IN_SUPERCLASS

class MethodsRemovedInInternalSuperClassRule extends AbstractSuperClassChangesRule {

                    void method();
                }
            """

        def rule = withContext(new SinceAnnotationRule([:]))

        then:
        def violation = rule.maybeViolation(jApiType)
        violation.severity == Severity.error
        violation.humanExplanation =~ 'Is not annotated with @since 11.38'

        where:
        apiElement          | jApiTypeName
        'method'            | 'jApiMethod'

        Map<AccessorKey, UpgradedProperty> currentAccessors = context.getUserData(CURRENT_ACCESSORS_OF_UPGRADED_PROPERTIES);
        Map<AccessorKey, ReplacedAccessor> oldRemovedAccessors = context.getUserData(OLD_REMOVED_ACCESSORS_OF_UPGRADED_PROPERTIES);

        if (violation.getHumanExplanation().startsWith(SINCE_ERROR_MESSAGE)) {

            }
        }

        if (!errors.isEmpty()) {
            def changes = errors + warnings
            return acceptOrReject(member, changes, Violation.error(member, changes.join(" ")))
        }
        if (!warnings.isEmpty()) {
            return Violation.warning(member, warnings.join(" "))
        }
        return null
    }

    private static List<Boolean> typeParametersNullabilityOf(CtClass ctClass) {

        returnContextMap(context);
    }

    /**
     * Log a security violation
     *
     * @param violation description of violation
     * @param context additional context
     */
    public void logSecurityViolation(String violation, Map<String, Object> context) {
        String message = "Security violation detected: " + violation;
        logEvent(EventType.SECURITY_VIOLATION, Severity.CRITICAL, message, context);

        // Cyclic Dependency Error

        if (result.hasCircularDependencyExceptions()) {
            throw result.getCircularDependencyException(0);
        }

        // Version Range Violation

        if (result.hasVersionRangeViolations()) {
            throw result.getVersionRangeViolation(0);
        }

        // Transfer Error

        if (result.hasErrorArtifactExceptions()) {

  
  The annotation that informs about audit policy violations changed from `pod-security.kubernetes.io/audit` to `pod-security.kubernetes.io/audit-violation`. ([#105908](https://github.com/kubernetes/kubernetes/pull/105908), [@stlaz](https://github.com/stlaz))

  <name>Maven Model</name>
  <description>Model for Maven POM (Project Object Model)</description>

  <properties>
    <!-- in: ModelMerger -->
    <checkstyle.violation.ignore>FileLength</checkstyle.violation.ignore>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.apache.maven</groupId>
      <artifactId>maven-api-model</artifactId>
    </dependency>
    <dependency>

        ),
      ).assertLogMatch(
        Regex(
          """callFailed: \S+(?:SSLProtocolException|SSLHandshakeException|TlsFatalAlert): .*(?:Unexpected handshake message: client_hello|Handshake message sequence violation, 1|Read error|Handshake failed|unexpected_message\(10\)).*""",
        ),