synchronized (pendingNotifications) {
            while (!pendingNotifications.isEmpty() && batch.size() < batchSize) {
                batch.add(pendingNotifications.poll());
            }
        }
        
        if (!batch.isEmpty()) {
            processNotificationBatch(batch);
        }
    }
    

            val subprojectsInModelButNotInBucketJson = allSubprojectsInModel.toMutableList().apply { removeAll(allSubprojectsInBucketJson) }

            if (subprojectsInModelButNotInBucketJson.isEmpty()) {
                testCoverage to buckets
            } else {
                testCoverage to
                    mergeUnknownSubprojectsIntoFirstAvailableBucket(
                        buckets,

            }

            Map<String, ExtraAttributeDoc> additionalValues = new LinkedHashMap<String, ExtraAttributeDoc>();

            if (!superTypes.isEmpty()) {
                PropertyDoc overriddenProp = props.get(propName);
                if (overriddenProp != null) {
                    for (ExtraAttributeDoc attributeDoc : overriddenProp.getAdditionalValues()) {

    ImmutableValueGraph<String, Integer> graph =
        ValueGraphBuilder.directed().<String, Integer>immutable().addNode("A").build();

    assertThat(graph.nodes()).containsExactly("A");
    assertThat(graph.edges()).isEmpty();
  }

  @Test
  public void immutableValueGraphBuilder_putEdgeFromNodes() {
    ImmutableValueGraph<String, Integer> graph =
        ValueGraphBuilder.directed()
            .<String, Integer>immutable()

    registry.unregister(s1);
    assertEquals(1, registry.getSubscribersForTesting(String.class).size());

    registry.unregister(s2);
    assertTrue(registry.getSubscribersForTesting(String.class).isEmpty());
  }

  public void testUnregister_notRegistered() {
    assertThrows(IllegalArgumentException.class, () -> registry.unregister(new StringSubscriber()));

    StringSubscriber s1 = new StringSubscriber();

    Iterator<Entry<K, V>> iterator = multimap().entries().iterator();
    assertEquals(mapEntry(k0(), v0()), iterator.next());
    iterator.remove();
    assertTrue(multimap().isEmpty());
  }

  @CollectionSize.Require(absent = ZERO)
  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testEntriesRemainValidAfterRemove() {
    Iterator<Entry<K, V>> iterator = multimap().entries().iterator();

        add(problem);
    }

    public ModelBuildingException newModelBuildingException() {
        ModelBuildingResult result = this.result;
        if (result.getModelIds().isEmpty()) {
            DefaultModelBuildingResult tmp = new DefaultModelBuildingResult();
            tmp.setEffectiveModel(result.getEffectiveModel());
            tmp.setProblems(getProblems());

        List<Element> moduleElements = modulesElement.children(MODULE).toList();
        for (Element moduleElement : moduleElements) {
            String moduleName = moduleElement.textContentTrimmed();
            if (moduleName.isEmpty()) {
                continue;
            }

            Path moduleDirectory = baseDirectory.resolve(moduleName);
            Path modulePomPath = moduleDirectory.resolve(POM_XML);

   *
   * @return {@code true} if the iterable contains no elements
   */
  public static boolean isEmpty(Iterable<?> iterable) {
    if (iterable instanceof Collection) {
      return ((Collection<?>) iterable).isEmpty();
    }
    return !iterable.iterator().hasNext();
  }

  /**

    }

    protected void mergeModelBase_Modules(
            ModelBase target, ModelBase source, boolean sourceDominant, Map<Object, Object> context) {
        List<String> src = source.getModules();
        if (!src.isEmpty()) {
            List<String> tgt = target.getModules();
            List<String> merged = new ArrayList<>(tgt.size() + src.size());
            merged.addAll(tgt);
            merged.addAll(src);