@CollectionSize.Require(absent = ZERO)
  public void testContains_yes() {
    assertTrue("containsValue(present) should return true", getMap().containsValue(v0()));
  }

  public void testContains_no() {
    assertFalse("containsValue(notPresent) should return false", getMap().containsValue(v3()));
  }

  @MapFeature.Require(ALLOWS_NULL_VALUE_QUERIES)
  public void testContains_nullNotContainedButAllowed() {

  @CollectionSize.Require(absent = ZERO)
  public void testContains_yes() {
    assertTrue("contains(present) should return true", collection.contains(e0()));
  }

  public void testContains_no() {
    assertFalse("contains(notPresent) should return false", collection.contains(e3()));
  }

  @CollectionFeature.Require(ALLOWS_NULL_QUERIES)
  public void testContains_nullNotContainedButQueriesSupported() {

            }

            assertEquals(expectedValue, rangeMap.get(i));
          }
        }
      }
    }
  }

  public void testSpanEmpty() {
    assertThrows(NoSuchElementException.class, () -> ImmutableRangeMap.of().span());
  }

  public void testSpanSingleRange() {
    for (Range<Integer> range : RANGES) {
      RangeMap<Integer, Integer> rangemap =

    mock.assertLastMethodCalled("shutdownNow");
    assertEquals(ImmutableList.of(), list);
  }

  public void testExecute() {
    MockExecutor mock = new MockExecutor();
    TestExecutor testExecutor = new TestExecutor(mock);
    testExecutor.execute(doNothing());
    mock.assertLastMethodCalled("execute");
  }

  public void testSubmit() throws InterruptedException, ExecutionException {
    {
      MockExecutor mock = new MockExecutor();

  public void testPeekingIteratorBehavesLikeIteratorOnThreeElementIterable() {
    actsLikeIteratorHelper(Lists.newArrayList("A", "B", "C"));
  }

  @GwtIncompatible // works but takes 5 minutes to run
  public void testPeekingIteratorAcceptsNullElements() {
    actsLikeIteratorHelper(Lists.<@Nullable String>newArrayList(null, "A", null));
  }

  public void testPeekOnEmptyList() {

                    String field = "value";
                    void method();
                }
            """
            : """
                public class $TEST_INTERFACE_SIMPLE_NAME {
                    public String field = "value";
                    public void method() { }
                    public $TEST_INTERFACE_SIMPLE_NAME() { }
                }
            """

  }

  @MapFeature.Require(SUPPORTS_PUT)
  public void testPutIfAbsent_supportedAbsent() {
    assertNull("putIfAbsent(notPresent, value) should return null", putIfAbsent(e3()));
    expectAdded(e3());
  }

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testPutIfAbsent_supportedPresent() {
    assertEquals(

    /**
     * Creates a new {@code ProjectModelResolverTest} instance.
     */
    ProjectModelResolverTest() {
        super();
    }

    @Test
    void testResolveParentThrowsUnresolvableModelExceptionWhenNotFound() throws Exception {
        final Parent parent = new Parent();
        parent.setGroupId("org.apache");
        parent.setArtifactId("apache");

/**
 *
 */
class RequirementMatcherFactoryTest {

    /**
     * Test of createExactMatcher method, of class RequirementMatcherFactory.
     */
    @Test
    void testCreateExactMatcher() {
        RequirementMatcher matcher;
        matcher = RequirementMatcherFactory.createExactMatcher("foo");
        assertFalse(matcher.matches("bar"));
        assertFalse(matcher.matches("foobar"));

        this.plexusContainer = requireNonNull(plexusContainer, "plexusContainer");
        this.lookup = new DefaultLookup(plexusContainer);
        updateLogging(context);
    }

    @Override
    public void updateLogging(LookupContext context) {
        plexusContainer.getLoggerManager().setThresholds(toPlexusLoggingLevel(context.loggerLevel));
    }

    @Override
    public Lookup getLookup() {
        return lookup;