try (InputStream is = urls.nextElement().openStream()) {
                    ExtensionDescriptor descriptor = BUILDER.build(is);
                    artifacts.addAll(descriptor.getExportedArtifacts());
                    packages.addAll(descriptor.getExportedPackages());
                }
            }
        } catch (IOException ignored) {
            // exports descriptors are entirely optional
        }

            addAll(this.classNames, classNames);
            addAll(this.packageNames, packageNames);
            addAll(this.packagePrefixes, packagePrefixes);
            addAll(this.resourcePrefixes, resourcePrefixes);
            addAll(this.resourceNames, resourceNames);
            addAll(this.disallowedClassNames, disallowedClassNames);

                    }
                }
            }

            addAll(collectGeneratedTopLevelClassifiers(packageFqName, analysisSession.useSiteSession))
        }
    }

    internal fun getTopLevelCallableNamesInPackageProvider(packageFqName: FqName, analysisSession: KaFirSession): Set<Name> {
        return buildSet {
            addAll(

            tasksToRun.addAll(queryTestTasks(context, testTaskPath));
        }

        for (InternalTaskSpec taskSpec : testExecutionRequest.getTaskSpecs()) {
            if (taskSpec instanceof InternalTestSpec) {
                tasksToRun.addAll(queryTestTasks(context, taskSpec.getTaskPath()));
            } else {
                tasksToRun.addAll(queryTasks(context, taskSpec.getTaskPath()));
            }

        }

        if (!caseInsensitiveMatches.isEmpty()) {
            matches.addAll(caseInsensitiveMatches);
        } else if (!caseSensitiveCamelCaseMatches.isEmpty()) {
            matches.addAll(caseSensitiveCamelCaseMatches);
        } else if (kebabCaseMatches.isEmpty() && kebabCasePrefixMatches.isEmpty()) {
            matches.addAll(caseInsensitiveCamelCaseMatches);
        }

        if (!kebabCaseMatches.isEmpty()) {

        def list = registry.realize(collectionPath, collectionType)
        list == ['bar', 'foo']

    }

    def "can addAll a collection which contains a same element types"() {
        when:
        mutate {
            add 'foo'
            addAll(['bar', 'baz'])
            addAll(1, ['one', 'two'])
        }


        then:
        def list = registry.realize(collectionPath, collectionType)

        target.clear();
        target.addAll(source);
    }

    public JUnitOptions includeCategories(String... includeCategories) {
        this.includeCategories.addAll(Arrays.asList(includeCategories));
        return this;
    }

    public JUnitOptions excludeCategories(String... excludeCategories) {
        this.excludeCategories.addAll(Arrays.asList(excludeCategories));
        return this;
    }

  }

  /**
   * A sensible definition of {@link #addAll} in terms of {@link #add}. If you override {@link
   * #add}, you may wish to override {@link #addAll} to forward to this implementation.
   *
   * @since 7.0
   */
  protected boolean standardAddAll(Collection<? extends E> collection) {
    return Iterators.addAll(this, collection.iterator());
  }

  /**

  }

  /**
   * A sensible definition of {@link #addAll} in terms of {@link #add}. If you override {@link
   * #add}, you may wish to override {@link #addAll} to forward to this implementation.
   *
   * @since 7.0
   */
  protected boolean standardAddAll(Collection<? extends E> collection) {
    return Iterators.addAll(this, collection.iterator());
  }

  /**

        );
        builder.addAll(moduleIdExcludes);
        builder.addAll(groupExcludes);
        builder.addAll(moduleExcludes);
        builder.addAll(moduleIdSetsExcludes);
        builder.addAll(groupSetExcludes);
        builder.addAll(moduleSetExcludes);
        builder.addAll(other);
        Set<ExcludeSpec> elements = builder.build();