assertThat(ImmutableDoubleArray.of().lastIndexOf(21)).isEqualTo(-1);
    assertThat(iia.subArray(1, 5).lastIndexOf(1)).isEqualTo(0);
  }

  public void testContains() {
    ImmutableDoubleArray iia = ImmutableDoubleArray.of(1, 1, 2, 3, 5, 8);
    assertThat(iia.contains(1)).isTrue();
    assertThat(iia.contains(8)).isTrue();
    assertThat(iia.contains(4)).isFalse();

    assertThat(ImmutableLongArray.of().lastIndexOf(21)).isEqualTo(-1);
    assertThat(iia.subArray(1, 5).lastIndexOf(1)).isEqualTo(0);
  }

  public void testContains() {
    ImmutableLongArray iia = ImmutableLongArray.of(1, 1, 2, 3, 5, 8);
    assertThat(iia.contains(1)).isTrue();
    assertThat(iia.contains(8)).isTrue();
    assertThat(iia.contains(4)).isFalse();

    assertThat(ImmutableIntArray.of().lastIndexOf(21)).isEqualTo(-1);
    assertThat(iia.subArray(1, 5).lastIndexOf(1)).isEqualTo(0);
  }

  public void testContains() {
    ImmutableIntArray iia = ImmutableIntArray.of(1, 1, 2, 3, 5, 8);
    assertThat(iia.contains(1)).isTrue();
    assertThat(iia.contains(8)).isTrue();
    assertThat(iia.contains(4)).isFalse();

        assertWithMessage(x + ", " + y)
            .that(Booleans.compare(x, y))
            .isEqualTo(Boolean.valueOf(x).compareTo(y));
      }
    }
  }

  public void testContains() {
    assertThat(Booleans.contains(EMPTY, false)).isFalse();
    assertThat(Booleans.contains(ARRAY_FALSE, true)).isFalse();
    assertThat(Booleans.contains(ARRAY_FALSE, false)).isTrue();

        assertWithMessage(x + ", " + y)
            .that(Booleans.compare(x, y))
            .isEqualTo(Boolean.valueOf(x).compareTo(y));
      }
    }
  }

  public void testContains() {
    assertThat(Booleans.contains(EMPTY, false)).isFalse();
    assertThat(Booleans.contains(ARRAY_FALSE, true)).isFalse();
    assertThat(Booleans.contains(ARRAY_FALSE, false)).isTrue();

  public void testHashCode() {
    for (byte value : VALUES) {
      assertThat(Bytes.hashCode(value)).isEqualTo(((Byte) value).hashCode());
    }
  }

  public void testContains() {
    assertThat(Bytes.contains(EMPTY, (byte) 1)).isFalse();
    assertThat(Bytes.contains(ARRAY1, (byte) 2)).isFalse();
    assertThat(Bytes.contains(ARRAY234, (byte) 1)).isFalse();

    return false;
  }

  @Override
  protected boolean supportsNullValues() {
    return true;
  }

  // Overriding tests of behavior that differs for ArrayTable.

  @Override
  public void testContains() {
    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    assertTrue(table.contains("foo", 1));
    assertTrue(table.contains("bar", 1));
    assertTrue(table.contains("foo", 3));

    return false;
  }

  @Override
  protected boolean supportsNullValues() {
    return true;
  }

  // Overriding tests of behavior that differs for ArrayTable.

  @Override
  public void testContains() {
    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    assertTrue(table.contains("foo", 1));
    assertTrue(table.contains("bar", 1));
    assertTrue(table.contains("foo", 3));

                () -> VersionRange.createFromVersionSpec(version),
                "Version " + version + " should have failed to construct");
    }

    @Test
    void testContains() throws InvalidVersionSpecificationException {
        ArtifactVersion actualVersion = new DefaultArtifactVersion("2.0.5");
        assertTrue(enforceVersion("2.0.5", actualVersion));

          assertWithMessage(x + ", " + y + " (expected: " + expected + ", actual" + actual + ")")
              .that(actual > 0)
              .isTrue();
        }
      }
    }
  }

  public void testContains() {
    assertThat(Shorts.contains(EMPTY, (short) 1)).isFalse();
    assertThat(Shorts.contains(ARRAY1, (short) 2)).isFalse();
    assertThat(Shorts.contains(ARRAY234, (short) 1)).isFalse();