* certificate is signed by the certificate that follows, and the last certificate is a trusted CA
 * certificate.
 *
 * Use of the chain cleaner is necessary to omit unexpected certificates that aren't relevant to
 * the TLS handshake and to extract the trusted CA certificate for the benefit of certificate
 * pinning.
 */
abstract class CertificateChainCleaner {

					continue
				}
				if tok == ':' {
					// Labels.
					p.pendingLabels = append(p.pendingLabels, word)
					goto next
				}
			}
			if tok == scanner.EOF {
				p.errorf("unexpected EOF")
				return "", "", nil, false
			}
			// Split operands on comma. Also, the old syntax on x86 for a "register pair"
			// was AX:DX, for which the new syntax is DX, AX. Note the reordering.

 * under the License.
 */
package org.apache.maven;

import java.util.Set;

/**
 * @deprecated use {@code META-INF/maven/extension.xml} to define artifacts exported by Maven core extensions.
 */
@Deprecated
public interface ArtifactFilterManagerDelegate {

    void addExcludes(Set<String> excludes);

    void addCoreExcludes(Set<String> excludes);

        VERSION_1 != version ||
        appVersion.toString() != appVersionString ||
        valueCount.toString() != valueCountString ||
        blank.isNotEmpty()
      ) {
        throw IOException(
          "unexpected journal header: [$magic, $version, $valueCountString, $blank]",
        )
      }

      var lineCount = 0
      while (true) {
        try {
          readJournalLine(readUtf8LineStrict())

                if ( e.getException() instanceof SmbException ) {
                    throw (SmbException) e.getException();
                }
                throw new SmbException("Unexpected exception during context initialization", e);
            }
        }
        return ctx.initSecContext(token, 0, token == null ? 0 : token.length);
    }


    /**
     * @param trans

) : CertificateChainCleaner() {
  /**
   * Returns a cleaned chain for [chain].
   *
   * This method throws if the complete chain to a trusted CA certificate cannot be constructed.
   * This is unexpected unless the trust root index in this class has a different trust manager than
   * what was used to establish [chain].
   */
  @Throws(SSLPeerUnverifiedException::class)
  override fun clean(
    chain: List<Certificate>,

        SPDY_3.protocol -> SPDY_3
        QUIC.protocol -> QUIC
        else -> {
          // Support HTTP3 draft like h3-29
          if (protocol.startsWith(HTTP_3.protocol)) HTTP_3 else throw IOException("Unexpected protocol: $protocol")
        }
      }
    }
  }

    assertFailsWith<IllegalArgumentException> {
      Headers.Builder()
        .addUnsafeNonAscii("héader1", "value1")
        .build()
    }.also { expected ->
      assertThat(expected.message).isEqualTo("Unexpected char 0xe9 at 1 in header name: héader1")
    }
  }

  @Test fun addUnsafeNonAsciiAcceptsUnicodeValue() {
    val headers =
      Headers.Builder()
        .addUnsafeNonAscii("header1", "valué1")

 * to the methods of the delegate. For example, overriding {@link #add} alone <b>will not</b> change
 * the behaviour of {@link #offer} which can lead to unexpected behaviour. In this case, you should
 * override {@code offer} as well, either providing your own implementation, or delegating to the
 * provided {@code standardOffer} method.
 *

    public void decode ( NdrBuffer buf ) throws NdrException {
        decode_header(buf);

        if ( this.ptype != 12 && this.ptype != 2 && this.ptype != 3 && this.ptype != 13 )
            throw new NdrException("Unexpected ptype: " + this.ptype);

        if ( this.ptype == 2 || this.ptype == 3 ) { /* Response or Fault */
            this.alloc_hint = buf.dec_ndr_long();
            buf.dec_ndr_short(); /* context id */