// and that certificate type is correct.
	checker := ssh.CertChecker{}
	checker.IsUserAuthority = func(k ssh.PublicKey) bool {
		return subtle.ConstantTimeCompare(globalSFTPTrustedCAPubkey.Marshal(), k.Marshal()) == 1
	}

	_, err = checker.Authenticate(c, clientKey)
	return err
}

type sftpLogger struct{}

func (s *sftpLogger) Info(tag xsftp.LogType, msg string) {

   *
   * @param iterator the iterator to copy
   * @param type the type of the elements
   * @return a newly-allocated array into which all the elements of the iterator have been copied
   */
  @GwtIncompatible // Array.newInstance(Class, int)
  public static <T extends @Nullable Object> T[] toArray(
      Iterator<? extends T> iterator, Class<@NonNull T> type) {
    List<T> list = Lists.newArrayList(iterator);

   *
   * @param iterator the iterator to copy
   * @param type the type of the elements
   * @return a newly-allocated array into which all the elements of the iterator have been copied
   */
  @GwtIncompatible // Array.newInstance(Class, int)
  public static <T extends @Nullable Object> T[] toArray(
      Iterator<? extends T> iterator, Class<@NonNull T> type) {
    List<T> list = Lists.newArrayList(iterator);

  }

  @CollectionSize.Require(ZERO)
  public void testEmptyMultisetNearby() {
    for (BoundType type : BoundType.values()) {
      assertNull(sortedMultiset.headMultiset(e0(), type).lastEntry());
      assertNull(sortedMultiset.tailMultiset(e0(), type).firstEntry());
    }
  }

  @CollectionSize.Require(ZERO)
  public void testEmptyMultisetLast() {

    /**
     * {@inheritDoc}
     *
     * @see jcifs.SmbTree#unwrap(java.lang.Class)
     */
    @SuppressWarnings("unchecked")
    @Override
    public <T extends SmbTree> T unwrap(final Class<T> type) {
        if (type.isAssignableFrom(this.getClass())) {
            return (T) this;
        }
        throw new ClassCastException();
    }

    /**
     * @param track

  protected ForwardingObject() {}

  /**
   * Returns the backing delegate instance that methods are forwarded to. Abstract subclasses
   * generally override this method with an abstract method that has a more specific return type,
   * such as {@link ForwardingSet#delegate}. Concrete subclasses override this method to supply the
   * instance being decorated.
   */
  protected abstract Object delegate();

///

## Duplicate headers { #duplicate-headers }

It is possible to receive duplicate headers. That means, the same header with multiple values.

You can define those cases using a list in the type declaration.

You will receive all the values from the duplicate header as a Python `list`.

For example, to declare a header of `X-Token` that can appear more than once, you can write:

O **FastAPI** fará a leitura desses dados no lugar certo em vez de JSON.

/// note | Detalhes Técnicos

Os dados dos formulários são normalmente codificados usando o "media type" `application/x-www-form-urlencoded`.

Mas quando o formulário inclui arquivos, ele é codificado como `multipart/form-data`. Você lerá sobre como lidar com arquivos no próximo capítulo.

**FastAPI** s'assure de lire ces données au bon endroit au lieu de JSON.

/// note | Détails techniques

Les données issues des formulaires sont normalement encodées avec le « type de média » `application/x-www-form-urlencoded`.

Mais lorsque le formulaire inclut des fichiers, il est encodé en `multipart/form-data`. Vous lirez la gestion des fichiers dans le chapitre suivant.

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package cmd

import (
	"context"
	"fmt"
	"io"
)

// Writes to multiple writers
type multiWriter struct {
	writers     []io.Writer
	writeQuorum int
	errs        []error
}

// Write writes data to writers.
func (p *multiWriter) Write(ctx context.Context, blocks [][]byte) error {