}

  /**
   * Returns an immutable list containing the given elements, sorted according to their natural
   * order. The sorting algorithm used is stable, so elements that compare as equal will stay in the
   * order in which they appear in the input.
   *
   * <p>If your data has no duplicates, or you wish to deduplicate elements, use {@code

  public void testCompare() {
    for (int x : VALUES) {
      for (int y : VALUES) {
        // note: spec requires only that the sign is the same
        assertWithMessage(x + ", " + y).that(Ints.compare(x, y)).isEqualTo(Integer.compare(x, y));
      }
    }
  }

  public void testContains() {
    assertThat(Ints.contains(EMPTY, (int) 1)).isFalse();
    assertThat(Ints.contains(ARRAY1, (int) 2)).isFalse();

    return new NullFriendlyComparator<>();
  }

  private static final class NullFriendlyComparator<T> implements Comparator<T>, Serializable {
    @Override
    public int compare(T left, T right) {
      return String.valueOf(left).compareTo(String.valueOf(right));
    }
  }

I love to hear about how **FastAPI** is being used, what you have liked in it, in which project/company are you using it, etc.

## Vote for FastAPI { #vote-for-fastapi }

* <a href="https://www.slant.co/options/34241/~fastapi-review" class="external-link" target="_blank">Vote for **FastAPI** in Slant</a>.

        methods,
        new Comparator<Method>() {
          @Override
          public int compare(Method m1, Method m2) {
            int nameComparison = m1.getName().compareTo(m2.getName());
            if (nameComparison != 0) {
              return nameComparison;
            } else {
              return Integer.compare(m1.getParameterTypes().length, m2.getParameterTypes().length);
            }
          }
        });

     * hashes (meaning negotiated via NTLM HTTP Authentication) and the other does not they will not be equal. This is
     * technically not correct however the server 8 byte challenge would be required to compute and compare the password
     * hashes but that it not available with this method.
     */
    @Override
    public boolean equals(final Object obj) {
        if (super.equals(obj)) {

        verify(treeConnection).getTreeType();
        verify(treeConnection).getConnectedShare();
    }

    @Test
    @DisplayName("isSameTree: different types and delegated compare")
    void isSameTreeCoversBranches() {
        // Covers non-impl (false) and impl path delegating to connection comparison
        // Not an impl -> false
        assertFalse(handle.isSameTree(mock(SmbTreeHandle.class)));

<img src="/img/tutorial/path-params/image03.png">

### Trabalhando com os *enumeration* do Python

O valor do *parâmetro da rota* será um *membro de enumeration*.

#### Compare *membros de enumeration*

Você pode comparar eles com o *membro de enumeration* no enum `ModelName` que você criou:

{* ../../docs_src/path_params/tutorial005.py hl[17] *}

#### Obtenha o *valor de enumerate*

your deployment.

Even though this change is backward compatible we do not expect that it affects
the vast majority of deployments in any negative way.

> Will an upgrade of an existing MinIO cluster impact the SLA of the cluster or will it even cause downtime?

No, an upgrade should not cause any downtime. However, on the first startup -
since MinIO will attempt to migrate any existing IAM data - the boot process may

            }
            
            if (next == 0) break;
            offset += next;
        }
        
        // Sort by score (best interfaces first)
        remoteInterfaces.sort((a, b) -> Integer.compare(b.getScore(), a.getScore()));
    }
    
    private void discoverLocalInterfaces() {
        localInterfaces.clear();
        
        try {