}

    Violation acceptOrReject(JApiCompatibility member, Violation rejection) {
        List<String> changes = member.compatibilityChanges.collect { Violation.describe(it.getType()) }
        return acceptOrReject(member, changes, rejection)
    }

    Violation acceptOrReject(JApiCompatibility member, List<String> changes, Violation rejection) {

                Elements inSectionElements = new Elements(inSection);
                section.html(inSectionElements.outerHtml());
                inSectionElements.remove();

                if (next == null) {
                    break;
                } else {
                    inSection.clear();
                    inSection.add(next);
                    heading = next;
                }

        normalizedPath = noUncValidator.validatePath("////server//share");
        assertEquals("\\server\\share", normalizedPath);

        // To properly test UNC rejection, we would need to fix the normalization logic
        // to preserve the leading double backslash for UNC paths
    }

    @Test
    public void testInvalidUncPath() throws Exception {

 * @since 10.0
 */
@GwtCompatible
public final class UnsignedLongs {
  private UnsignedLongs() {}

  public static final long MAX_VALUE = -1L; // Equivalent to 2^64 - 1

  /**
   * A (self-inverse) bijection which converts the ordering on unsigned longs to the ordering on
   * longs, that is, {@code a <= b} as unsigned longs if and only if {@code flip(a) <= flip(b)} as
   * signed longs.
   */
  private static long flip(long a) {

   * types that contain an embedded IPv4 address.
   *
   * <p>NOTE: ISATAP addresses are explicitly excluded from this method due to their trivial
   * spoofability. With other transition addresses spoofing involves (at least) infection of one's
   * BGP routing table.
   *
   * @param ip {@link Inet6Address} to be examined for embedded IPv4 client address
   * @return {@code true} if there is an embedded IPv4 client address
   * @since 7.0
   */

 * but given that any public suffix may become a host without warning, it is better to err on the
 * side of permissiveness and thus avoid spurious rejection of valid sites. Of course, to actually
 * determine addressability of any host, clients of this class will need to perform their own DNS
 * lookups.
 *
 * <p>During construction, names are normalized in two ways:
 *

   * types that contain an embedded IPv4 address.
   *
   * <p>NOTE: ISATAP addresses are explicitly excluded from this method due to their trivial
   * spoofability. With other transition addresses spoofing involves (at least) infection of one's
   * BGP routing table.
   *
   * @param ip {@link Inet6Address} to be examined for embedded IPv4 client address
   * @return {@code true} if there is an embedded IPv4 client address
   * @since 7.0
   */

    return (ImmutableSet<E>) RegularImmutableSet.EMPTY;
  }

  /**
   * Returns an immutable set containing the given element. Preferred over {@link
   * Collections#singleton} for code consistency, {@code null} rejection, and because the return
   * type conveys the immutability guarantee.
   */
  public static <E> ImmutableSet<E> of(E e1) {
    return new SingletonImmutableSet<>(e1);
  }

  /*

                    throw new RuntimeException(e);
                }
            });
        } catch (SimpleCircuitBreaker.CircuitBreakerOpenException e) {
            // Log circuit breaker rejection
            auditLogger.logSecurityViolation("Circuit breaker open for SMB connection",
                    java.util.Map.of("address", address.getHostAddress(), "port", String.valueOf(port)));

%v", err) } if strings.Contains(t.Name(), "/Path/") { // For path coverage tests, check that we hit all rejection paths. reached := map[string]bool{"z": false, "r0": false, "ct0": false, "h": false} // The ct0 rejection is only reachable for ML-DSA-44. if priv.PublicKey().Parameters() != "ML-DSA-44" { delete(reached, "ct0") } testingOnlyRejection = func(reason string) { t.Log(reason, "rejection") reached[reason] = true } t.Cleanup(func() { testingOnlyRejection = nil }) defer func() { for reason, hit...