assertEquals("3", true, StringUtil.isNotBlank("a"));
        assertEquals("4", true, StringUtil.isNotBlank(" a "));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testContains() throws Exception {
        assertEquals("1", true, StringUtil.contains("a", 'a'));
        assertEquals("2", true, StringUtil.contains("abc", 'b'));
        assertEquals("3", false, StringUtil.contains("abc", 'd'));

    assertEquals(
        Integer.MAX_VALUE,
        ContiguousSet.create(Range.<Integer>all(), integers()).last().intValue());
  }

  public void testContains() {
    ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), integers());
    assertFalse(set.contains(0));
    assertTrue(set.contains(1));
    assertTrue(set.contains(2));

        assertWithMessage(x + ", " + y)
            .that(Math.signum(Chars.compare(x, y)))
            .isEqualTo(Math.signum(Character.valueOf(x).compareTo(y)));
      }
    }
  }

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

          assertEquals(
              contents.contains(toRemove) && EVEN.apply(toRemove),
              filter(createUnfiltered(contents), EVEN).remove(toRemove));
        }
      }
    }

    public void testContains() {
      for (List<Integer> contents : SAMPLE_INPUTS) {
        for (int i = 0; i < 10; i++) {
          assertEquals(
              EVEN.apply(i) && contents.contains(i),

  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();

    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();

                () -> 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)
            .that(Doubles.compare(x, y))
            .isEqualTo(Double.valueOf(x).compareTo(y));
      }
    }
  }

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

    mmHeap.removeAll(Lists.newArrayList(2, 3));
    assertEquals(3, mmHeap.size());
    assertTrue("Heap is not intact after removeAll()", mmHeap.isIntact());
  }

  public void testContains() {
    MinMaxPriorityQueue<Integer> mmHeap = MinMaxPriorityQueue.create();
    mmHeap.addAll(Lists.newArrayList(1, 1, 2));
    assertEquals(3, mmHeap.size());

    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();