Key key1 = new Key(1);
      String value1 = key1.toString();
      Key key2 = new Key(2);
      String value2 = key2.toString();
      assertThat(cache.getUnchecked(key1)).isSameInstanceAs(value1);
      assertThat(cache.getUnchecked(key2)).isSameInstanceAs(value2);
      assertThat(cache.asMap().keySet()).isEqualTo(ImmutableSet.of(key1, key2));
      assertThat(cache.asMap().values()).containsExactly(value1, value2);

    assertThat(transpose(transpose)).isSameInstanceAs(directedGraph);
    AbstractGraphTest.validateGraph(transpose);

    for (Integer node : directedGraph.nodes()) {
      assertThat(directedGraph.inDegree(node)).isSameInstanceAs(transpose.outDegree(node));
      assertThat(directedGraph.outDegree(node)).isSameInstanceAs(transpose.inDegree(node));
    }

    assertThat(max(2, 1)).isEqualTo(2);
  }

  public void testMinMaxNatural_equalInstances() {
    Foo a = new Foo(1);
    Foo b = new Foo(1);
    assertThat(min(a, b)).isSameInstanceAs(a);
    assertThat(max(a, b)).isSameInstanceAs(a);
  }

  public void testMinMaxComparator() {
    Comparator<Integer> reverse = reverseOrder();
    assertThat(min(1, 2, reverse)).isEqualTo(2);

          }
        };
    assertEquals(0, service.startUpCalled);
    RuntimeException e =
        assertThrows(RuntimeException.class, () -> service.startAsync().awaitRunning());
    assertThat(e).hasCauseThat().isSameInstanceAs(exception);
    assertEquals(1, service.startUpCalled);
    assertEquals(Service.State.FAILED, service.state());
    assertThat(service.transitionStates).containsExactly(Service.State.STARTING);
  }

    ImmutableLongArray iia3 = ImmutableLongArray.of(5, 25, 125);

    assertThat(iia0.subArray(0, 0)).isSameInstanceAs(ImmutableLongArray.of());
    assertThat(iia1.subArray(0, 0)).isSameInstanceAs(ImmutableLongArray.of());
    assertThat(iia1.subArray(1, 1)).isSameInstanceAs(ImmutableLongArray.of());
    assertThat(iia1.subArray(0, 1).asList()).containsExactly(5L);

    assertThat(expected).hasCauseThat().isEqualTo(cause);

    Object newValue = new Object();
    valueRef.set(newValue);
    assertThat(cache.getUnchecked(new Object())).isSameInstanceAs(newValue);
  }

  public void testGetUnchecked_unchecked() {
    RuntimeException cause = new RuntimeException();
    AtomicReference<Object> valueRef = new AtomicReference<>();

    assertThat(base32().upperCase()).isSameInstanceAs(base32());
  }

  public void testBase32LowerCase() {
    testEncodingWithCasing(base32().lowerCase(), "foobar", "mzxw6ytboi======");
  }

  public void testBase32IgnoreCase() {
    BaseEncoding ignoreCase = base32().ignoreCase();
    assertThat(ignoreCase).isNotSameInstanceAs(base32());
    assertThat(ignoreCase).isSameInstanceAs(base32().ignoreCase());

          }
        };
    assertEquals(0, service.startUpCalled);
    RuntimeException e =
        assertThrows(RuntimeException.class, () -> service.startAsync().awaitRunning());
    assertThat(e).hasCauseThat().isSameInstanceAs(exception);
    assertEquals(1, service.startUpCalled);
    assertEquals(Service.State.FAILED, service.state());
    assertThat(service.transitionStates).containsExactly(Service.State.STARTING);
  }

    assertThat(transformation.inverse().slope()).isWithin(ALLOWED_ERROR).of(xDelta / yDelta);
    assertThat(transformation.inverse()).isSameInstanceAs(transformation.inverse());
    assertThat(transformation.inverse().inverse()).isSameInstanceAs(transformation);
  }

  /**
   * Asserts that {@code transformation} is horizontal with the given value of {@code y}. Includes

    }
  }

  public void testEnsureCapacity() {
    assertThat(Booleans.ensureCapacity(EMPTY, 0, 1)).isSameInstanceAs(EMPTY);
    assertThat(Booleans.ensureCapacity(ARRAY_FALSE, 0, 1)).isSameInstanceAs(ARRAY_FALSE);
    assertThat(Booleans.ensureCapacity(ARRAY_FALSE, 1, 1)).isSameInstanceAs(ARRAY_FALSE);
    assertThat(Booleans.ensureCapacity(new boolean[] {true}, 2, 1))
        .isEqualTo(new boolean[] {true, false, false});