public void testCompare() {
    for (int x : VALUES) {
      for (int y : VALUES) {
        // note: spec requires only that the sign is the same
        assertWithMessage("%s, %s", 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();

pkg bytes, func ContainsFunc([]uint8, func(int32) bool) bool #54386
pkg bytes, method (*Buffer) AvailableBuffer() []uint8 #53685
pkg bytes, method (*Buffer) Available() int #53685
pkg cmp, func Compare[$0 Ordered]($0, $0) int #59488
pkg cmp, func Less[$0 Ordered]($0, $0) bool #59488
pkg cmp, type Ordered interface {} #59488
pkg context, func AfterFunc(Context, func()) func() bool #57928

 * "The .NET Developer's Guide to Windows Security" (which is also
 * available online).
 * <p>
 * Direct ACEs are evaluated first in order. The SID of the user performing
 * the operation and the desired access bits are compared to the SID
 * and access mask of each ACE. If the SID matches, the allow/deny flags
 * and access mask are considered. If the ACE is a "deny"
 * ACE and <i>any</i> of the desired access bits match bits in the access

Der *Pfad-Parameter* wird ein *<abbr title="Member – Mitglied: Einer der möglichen Werte einer Enumeration">Member</abbr> einer Enumeration* sein.

#### *Enumeration-Member* vergleichen { #compare-enumeration-members }

Sie können ihn mit einem Member Ihrer Enumeration `ModelName` vergleichen:

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

	ctx := context.Background()

	// Create companies
	c1 := Company{Name: "Electronics"}
	c2 := Company{Name: "Books"}
	if err := DB.Create(&c1).Error; err != nil {
		t.Fatalf("create c1: %v", err)
	}
	if err := DB.Create(&c2).Error; err != nil {
		t.Fatalf("create c2: %v", err)
	}

	// Create users with companies
	u1 := User{Name: "John", Age: 25, CompanyID: &c1.ID}

                    return -1;
                }
                final String k2 = o2.getKey();
                if (LANG_KEY.equals(k2)) {
                    return -1;
                }
                return k1.compareTo(k2);
            });
            return new LinkedHashSet<>(list);
        }
        return parent.entrySet();
    }

 * higher space consumption.
 *
 * <p>This class extends {@link Number}, but does not define methods such as {@code
 * equals}, {@code hashCode} and {@code compareTo} because instances are expected to be mutated, and
 * so are not useful as collection keys.
 *
 * <p>jsr166e note: This class is targeted to be placed in java.util.concurrent.atomic.
 *
 * @since 1.8

        return toolchains;
    }

    private boolean hasErrors(List<Problem> problems) {
        if (problems != null) {
            for (Problem problem : problems) {
                if (Problem.Severity.ERROR.compareTo(problem.getSeverity()) >= 0) {
                    return true;
                }
            }
        }

        return false;
    }

and utilities for concurrency, I/O, hashing, primitives, strings, and more! It
is widely used on most Java projects within Google, and widely used by many
other companies as well.



Guava comes in two flavors:

*   The JRE flavor requires JDK 1.8 or higher.
*   If you need support for Android, use
    [the Android flavor](https://github.com/google/guava/wiki/Android). You can

Hay una gran posibilidad de que la lógica para tu *startup* y *shutdown* esté conectada, podrías querer iniciar algo y luego finalizarlo, adquirir un recurso y luego liberarlo, etc.

Hacer eso en funciones separadas que no comparten lógica o variables juntas es más difícil ya que necesitarías almacenar valores en variables globales o trucos similares.

Debido a eso, ahora se recomienda en su lugar usar el `lifespan` como se explicó arriba.