public void extend(MavenExecutionRequest mavenExecutionRequest) {
        Map<String, PropertyContributor> effectivePropertyContributors = lookup.lookupMap(PropertyContributor.class);
        if (!effectivePropertyContributors.isEmpty()) {
            HashMap<String, String> userPropertiesMap = new HashMap<>((Map) mavenExecutionRequest.getUserProperties());
            for (PropertyContributor contributor : effectivePropertyContributors.values()) {

            InternalMavenSession session =
                    InternalMavenSession.from(ee.getSession().getSession());
            Collection<Listener> listeners = session.getListeners();
            if (!listeners.isEmpty()) {
                Event event = new DefaultEvent(session, ee);
                for (Listener listener : listeners) {
                    listener.onEvent(event);
                }
            }
        }
    }

                // ignored
            }
            interpolator.addValueSource(new MapBasedValueSource(System.getProperties()));

            try {
                if (fileString != null && !fileString.isEmpty()) {
                    fileString = interpolator.interpolate(fileString, "").replace("\\", "/");
                    File file = new File(fileString);
                    return file.exists();
                }

        Set<CtMethod> newMethods = collectAllPublicApiMethods(newClass.superclass)

        oldMethods.removeAll(newMethods)

        if (oldMethods.isEmpty()) {
            return null
        }

        List<String> changes = filterChangesToReport(oldClass, oldMethods)
        if (changes.isEmpty()) {
            return null
        }
        return acceptOrReject(c, changes, Violation.error(c, " methods removed in internal super class"))

    }

    public void clearModifiedInfo() {
        __modifiedProperties.clear();
    }

    public boolean hasModification() {
        return !__modifiedProperties.isEmpty();
    }

    protected EntityModifiedProperties newModifiedProperties() {
        return new EntityModifiedProperties();
    }

    protected void registerModifiedProperty(String propertyName) {

    List<Integer> sublist = list.subList(0, 5);
    assertThat(sublist).containsExactly(1, 2, 3, 4, 5).inOrder();

    sublist.clear();
    assertTrue(sublist.isEmpty());
    multimap.put("foo", 6);

    assertThrows(ConcurrentModificationException.class, () -> sublist.isEmpty());
  }

  public void testCreateFromMultimap() {
    Multimap<String, Integer> multimap = create();
    multimap.put("foo", 1);

    @Override
    public Exception getException() {
        return exception;
    }

    @Override
    public String getMessage() {
        String msg = null;

        if (message != null && !message.isEmpty()) {
            msg = message;
        } else if (exception != null) {
            msg = exception.getMessage();
        }

        if (msg == null) {
            msg = "";
        }

      .containsExactlyInAnyOrder(a1, a2)
    assertThat(dispatcher.queuedCalls()).isEmpty()

    // Cancel some calls. That doesn't impact running or queued.
    a2.cancel()
    a3.cancel()
    assertThat(dispatcher.runningCalls())
      .containsExactlyInAnyOrder(a1, a2)
    assertThat(dispatcher.queuedCalls()).isEmpty()

    // Let the calls finish.
    waiting.countDown()
    t1.join()
    t2.join()

    assertThat(TypeToken.of(Types.supertypeOf(String[].class)).getGenericInterfaces()).isEmpty();
  }

  public void testGetGenericInterfaces_wildcard_boundIsClass() {
    assertThat(TypeToken.of(Types.subtypeOf(Object.class)).getGenericInterfaces()).isEmpty();
    assertThat(TypeToken.of(Types.subtypeOf(Object[].class)).getGenericInterfaces()).isEmpty();
  }

        q.add(element);
      } else {
        assertEqualsUsingSeed(seed, control.poll(), q.pollFirst());
      }
    }
    while (!control.isEmpty()) {
      assertEqualsUsingSeed(seed, control.poll(), q.pollFirst());
    }
    assertTrue(q.isEmpty());
  }

  public void testExhaustive_pollAndPush() {
    int size = 5;
    List<Integer> expected = createOrderedList(size);