verify(logger).debug("Toolchain {} doesn't match required property: {}", toolchain, "name");
    }

    @Test
    void testEquals() {
        ToolchainModel tm1 = new ToolchainModel();
        tm1.setType("jdk");
        tm1.addProvide("version", "1.5");
        tm1.addProvide("vendor", "sun");

@NullUnmarked
public class ClassPathTest extends TestCase {
  private static final Logger log = Logger.getLogger(ClassPathTest.class.getName());
  private static final File FILE = new File(".");

  public void testEquals() {
    new EqualsTester()
        .addEqualityGroup(classInfo(ClassPathTest.class), classInfo(ClassPathTest.class))
        .addEqualityGroup(classInfo(Test.class), classInfo(Test.class, getClass().getClassLoader()))

        .testEquals();
  }

  public void testEquals_otherSetContainsThrows() {
    new EqualsTester()
        .addEqualityGroup(new SetContainsThrows())
        .addEqualityGroup(intersection(singleton(null), singleton(null))) // NPE
        .addEqualityGroup(intersection(singleton(0), singleton(0))) // CCE
        .testEquals();
  }

    // return collection::iterator;
    return new Iterable<T>() {
      @Override
      public Iterator<T> iterator() {
        return collection.iterator();
      }
    };
  }

  public void testEquals() {
    new EqualsTester()
        .addEqualityGroup(ImmutableIntArray.of())
        .addEqualityGroup(
            ImmutableIntArray.of(1, 2),
            reserialize(ImmutableIntArray.of(1, 2)),

   *     or if the hashcodes are different.
   */
  @CanIgnoreReturnValue
  public static <T> T reserializeAndAssert(T object) {
    T copy = reserialize(object);
    new EqualsTester().addEqualityGroup(object, copy).testEquals();
    Assert.assertEquals(object.getClass(), copy.getClass());
    return copy;
  }

    assertEquals(rangeMap.asMapOfRanges(), copy.asMapOfRanges());
  }

  // Overriding testEquals because it seems that we get spurious failures when it things empty
  // should be unequal to empty.
  public void testEquals() {
    TreeRangeMap<Integer, Integer> empty = TreeRangeMap.create();
    TreeRangeMap<Integer, Integer> nonEmpty = TreeRangeMap.create();

    // return collection::iterator;
    return new Iterable<T>() {
      @Override
      public Iterator<T> iterator() {
        return collection.iterator();
      }
    };
  }

  public void testEquals() {
    new EqualsTester()
        .addEqualityGroup(ImmutableDoubleArray.of())
        .addEqualityGroup(
            ImmutableDoubleArray.of(1, 2),
            reserialize(ImmutableDoubleArray.of(1, 2)),

        .addEqualityGroup(parse("softValues"), parse("softValues"))
        .addEqualityGroup(parse("weakValues"), parse("weakValues"))
        .addEqualityGroup(parse("recordStats"), parse("recordStats"))
        .testEquals();
  }

  @SuppressWarnings("ReturnValueIgnored")
  public void testMaximumWeight_withWeigher() {
    CacheBuilder<Object, Object> builder = CacheBuilder.from(parse("maximumWeight=9000"));

    Set<Entry<String, Integer>> entrySet = map.entrySet();
    assertTrue(entrySet instanceof SynchronizedSet);
    assertSame(mutex, ((SynchronizedSet<?>) entrySet).mutex);
  }

  public void testEquals() {
    boolean unused = create().equals(new HashMap<String, Integer>());
  }

  public void testHashCode() {
    int unused = create().hashCode();
  }

  public void testToString() {

        assertEquals("3", false, StringUtil.contains("abc", "d"));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testEquals() throws Exception {
        assertEquals("1", true, StringUtil.equals("a", "a"));
        assertEquals("2", true, StringUtil.equals(null, null));
        assertEquals("3", false, StringUtil.equals("a", null));