Spec spec = specFrom(provider);
            exportedClasses.addAll(spec.getExportedClasses());
            exportedPackages.addAll(spec.getExportedPackages());
            exportedResources.addAll(spec.getExportedResources());
            exportedResourcePrefixes.addAll(spec.getExportedResourcePrefixes());
        }

        List<File> modulePath = new ArrayList<>();

        if (runAsModule) {
            modulePath.addAll(workerMainClassPath);
        } else {
            classpath.addAll(workerMainClassPath);
        }
        modulePath.addAll(applicationModulePath);
        classpath.addAll(applicationClasspath);

        if (!modulePath.isEmpty() && implementationModulePath != null && !implementationModulePath.isEmpty()) {

                return new DefaultInternalJvmTestRequest(testClass, null, null);
            }
        });
        internalJvmTestRequests.addAll(newRequests);
        testClassNames.addAll(CollectionUtils.toList(testClasses));
        return this;
    }

    @Override
    public TestLauncher withJvmTestMethods(String testClass, String... methods) {

        this.instantiator = instantiator;
        this.fileCollectionFactory = fileCollectionFactory;
        this.allPlatforms.addAll(allPlatforms);
        this.allPlatforms.addAll(nativePlatforms.defaultPlatformDefinitions());
        this.allBuildTypes.addAll(allBuildTypes);
        this.allFlavors.addAll(allFlavors);
    }

    @Override
    public void execute(PrebuiltLibrary prebuiltLibrary) {

        resourcesToGenerate.addAll(resources);
    }

    public Collection<GeneratedResource> getResourcesToGenerate() {
        return Collections.unmodifiableCollection(resourcesToGenerate);
    }

    public void addSourcePath(String sourcePath) {
        sourcePaths.add(sourcePath);
    }

    public void addSourcePaths(Set<String> sourcePath) {
        sourcePaths.addAll(sourcePath);
    }

  }

  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testAddAll_emptySet() {
    assertFalse(getMultiset().addAll(Collections.<E>emptySet()));
    expectUnchanged();
  }

  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testAddAll_emptyMultiset() {
    assertFalse(getMultiset().addAll(getSubjectGenerator().create()));
    expectUnchanged();
  }

  @CollectionFeature.Require(SUPPORTS_ADD)

      super.addAll(elements);
      return this;
    }

    @CanIgnoreReturnValue
    Builder<E> combine(Builder<E> builder) {
      contents.addAll(builder.contents);
      return this;
    }

    @Override
    public ImmutableSet<E> build() {
      return copyOf(contents.iterator());
    }
  }

        }
        finishFailures.addAll(finishResult.getFailures());
        boolean failed = reportableFailure != null;

        // These should run concurrently
        buildStateRegistry.visitBuilds(buildState -> {
            ExecutionResult<Void> result = buildState.beforeModelDiscarded(failed);
            finishFailures.addAll(result.getFailures());
        });

        this.packages.addAll(packages);
        return this;
    }

    @Override
    public TestSpec includeClass(String cls) {
        return includeClasses(Collections.singletonList(cls));
    }

    @Override
    public TestSpec includeClasses(Collection<String> classes) {
        this.classes.addAll(classes);
        return this;
    }

    @Override

                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
        }