Add all bundles resolved by bndrun file to system-under-test.

@param runFileSpec bndrun file to be used.

@return this.
518546
public Option fromBndrun(String runFileSpec)  {
        try {
            File runFile = workspace.getFile(runFileSpec);
            Run bndRunInstruction = new Run(workspace, runFile.getParentFile(), runFile);
            return bndToExam(bndRunInstruction);
        } catch (Exception e) {
            throw new RuntimeException("Underlying Bnd Exception: ",e);
        }
    }
183748
@Override
	public BundlePathMapping build(List<String> strPathMappings) {

		BundlePathMapping bundlePathMapping = new BundlePathMapping(bundle);
		for (JoinableResourceBundle child : ((CompositeResourceBundle) bundle).getChildBundles()) {
			if (!child.getInclusionPattern().isIncludeOnlyOnDebug()) {
				bundlePathMapping.getItemPathList().addAll(child.getItemPathList());
				addFilePathMapping(bundlePathMapping, child.getItemPathList());
			}

			if (!child.getInclusionPattern().isExcludeOnDebug()) {
				bundlePathMapping.getItemDebugPathList().addAll(child.getItemDebugPathList());
				addFilePathMapping(bundlePathMapping, child.getItemDebugPathList());
			}
			bundlePathMapping.getLicensesPathList().addAll(child.getLicensesPathList());
			addFilePathMapping(bundlePathMapping, child.getLicensesPathList());
		}
		return bundlePathMapping;
	}
221523
@Nullable
    public boolean addModuleSpec(ModuleSpec moduleSpec) {
        Objects.requireNonNull(moduleSpec, "moduleSpec");
        ModuleIdentifier revisionId = moduleSpec.getModuleIdentifier();
        boolean available = !moduleSpecs.containsKey(revisionId);
        if (available) {
            moduleSpecs.put(revisionId, moduleSpec);
        }
        return available;
    }
1019142
private static void addBundle(final Object bundleWiring, final ClassLoader classLoader,
            final ClasspathOrder classpathOrderOut, final Set<Object> bundles, final ScanSpec scanSpec,
            final LogNode log) {
        // Track the bundles we've processed to prevent loops
        bundles.add(bundleWiring);

        // Get the revision for this wiring
        final Object revision = ReflectionUtils.invokeMethod(bundleWiring, "getRevision", false);
        // Get the contents
        final Object content = ReflectionUtils.invokeMethod(revision, "getContent", false);
        final String location = content != null ? getContentLocation(content) : null;
        if (location != null) {
            // Add the bundle object
            classpathOrderOut.addClasspathEntry(location, classLoader, scanSpec, log);

            // And any embedded content
            final List<?> embeddedContent = (List<?>) ReflectionUtils.invokeMethod(revision, "getContentPath",
                    false);
            if (embeddedContent != null) {
                for (final Object embedded : embeddedContent) {
                    if (embedded != content) {
                        final String embeddedLocation = embedded != null ? getContentLocation(embedded) : null;
                        if (embeddedLocation != null) {
                            classpathOrderOut.addClasspathEntry(embeddedLocation, classLoader, scanSpec, log);
                        }
                    }
                }
            }
        }
    }
214182
protected void addToBuildSpec(String builderID) throws CoreException {
        IProjectDescription description = getProject().getDescription();
        ICommand findBugsCommand = getFindBugsCommand(description);
        if (findBugsCommand == null) {
            // Add a Java command to the build spec
            ICommand newCommand = description.newCommand();
            newCommand.setBuilderName(builderID);
            setFindBugsCommand(description, newCommand);
        }
    }
738387
public void resolveBundles(BundleContext bContext, List<Bundle> bundlesToResolve) {
        if (bundlesToResolve == null || bundlesToResolve.size() == 0) {
            return;
        }

        FrameworkWiring wiring = adaptSystemBundle(bContext, FrameworkWiring.class);
        if (wiring != null) {
            ResolutionReportHelper rrh = null;
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                rrh = new ResolutionReportHelper();
                rrh.startHelper(bContext);
            }
            try {
                wiring.resolveBundles(bundlesToResolve);
            } finally {
                if (rrh != null) {
                    rrh.stopHelper();
                    Tr.debug(this, tc, rrh.getResolutionReportString());
                }
            }
        }
    }
858273
void packageArtifacts(final File compileDir, final MavenProject project, final Set<String> bundles)
        throws IOException, XCodeException
  {

    File mainArtifact = createMainArtifactFile(project);

    attachBundle(compileDir, project, bundles, mainArtifact);

    final File mainArtifactFile = archiveMainArtifact(project, mainArtifact);
    setMainArtifact(project, mainArtifactFile);

  }
1006207
def add_bundled_jars():
    
    # determine lib directory with jars
    rootdir = os.path.split(os.path.dirname(__file__))[0]
    libdir = rootdir + os.sep + "lib"

    # add jars from lib directory
    for l in glob.glob(libdir + os.sep + "*.jar"):
        if l.lower().find("-src.") == -1:
            javabridge.JARS.append(str(l))
861252
public static void populateModuleSpecWithCompilationRoot(ModuleSpec.Builder moduleSpecBuilder, Path compilationRoot) {
        Objects.requireNonNull(moduleSpecBuilder, "moduleSpecBuilder");
        Objects.requireNonNull(compilationRoot, "resourceRoot");
        ResourceLoader resourceLoader = ResourceLoaders.createFileResourceLoader(compilationRoot.toString(), compilationRoot.toFile());
        moduleSpecBuilder.addResourceRoot(ResourceLoaderSpec.createResourceLoaderSpec(resourceLoader));
    }
1073907
public static void populateModuleSpecWithCoreDependencies(ModuleSpec.Builder moduleSpecBuilder, ScriptArchive scriptArchive) throws ModuleLoadException {
        Objects.requireNonNull(moduleSpecBuilder, "moduleSpecBuilder");
        Objects.requireNonNull(scriptArchive, "scriptArchive");

        Set<String> compilerPlugins = scriptArchive.getModuleSpec().getCompilerPluginIds();
        for (String compilerPluginId : compilerPlugins) {
            moduleSpecBuilder.addDependency(DependencySpec.createModuleDependencySpec(getPluginModuleId(compilerPluginId), false));
        }
        moduleSpecBuilder.addDependency(JRE_DEPENDENCY_SPEC);
        // TODO: Why does a module need a dependency on Nicobar itself?
        moduleSpecBuilder.addDependency(NICOBAR_CORE_DEPENDENCY_SPEC);
        moduleSpecBuilder.addDependency(DependencySpec.createLocalDependencySpec());
    }
192717
def bundle(self, app, results_dir):
    
    assert(isinstance(app, BundleCreate.App))

    bundle_dir = self.get_bundle_dir(app.id, results_dir)
    self.context.log.debug('creating {}'.format(os.path.relpath(bundle_dir, get_buildroot())))

    safe_mkdir(bundle_dir, clean=True)

    classpath = OrderedSet()

    # Create symlinks for both internal and external dependencies under `lib_dir`. This is
    # only needed when not creating a deployjar
    lib_dir = os.path.join(bundle_dir, self.LIBS_DIR)
    if not app.deployjar:
      os.mkdir(lib_dir)
      consolidated_classpath = self.context.products.get_data('consolidated_classpath')
      classpath.update(ClasspathProducts.create_canonical_classpath(
        consolidated_classpath,
        app.target.closure(bfs=True, **self._target_closure_kwargs),
        lib_dir,
        internal_classpath_only=False,
        excludes=app.binary.deploy_excludes,
      ))

    bundle_jar = os.path.join(bundle_dir, '{}.jar'.format(app.binary.basename))
    with self.monolithic_jar(app.binary, bundle_jar,
                             manifest_classpath=classpath) as jar:
      self.add_main_manifest_entry(jar, app.binary)

      # Make classpath complete by adding the monolithic jar.
      classpath.update([jar.path])

    if app.binary.shading_rules:
      for jar_path in classpath:
        # In case `jar_path` is a symlink, this is still safe, shaded jar will overwrite jar_path,
        # original file `jar_path` linked to remains untouched.
        # TODO run in parallel to speed up
        self.shade_jar(shading_rules=app.binary.shading_rules, jar_path=jar_path)

    self.symlink_bundles(app, bundle_dir)

    return bundle_dir
1055236
function SpecXUnitFile(runner) {
  var spec = new Spec(runner);
  Base.call(this, runner);
  var stats = this.stats
    , tests = []
    , self = this;
  runner.on('suite', function(suite){
    if(consoleOutput.suite){
      console.log('  ' + suite.title);
    }
  });

  runner.on('test', function(test){
    if(consoleOutput.test){
      console.log('  ◦ ' + test.title);
    }
  });

  runner.on('pass', function(test){
    tests.push(test);
  });

  runner.on('fail', function(test){
    if(consoleOutput.fail){
      console.log('  - ' + test.title);
    }
    tests.push(test);
  });

  runner.on('pending', function(test) {
    tests.push(test);
  });

  runner.on('end', function(){

    var filePath = process.env.XUNIT_FILE || config.file || process.cwd() + "/xunit.xml"
      , fd = fs.openSync(filePath, 'w', 0755)
      ;
    appendLine(fd, writeTag('testsuite', {
      name: 'Mocha Tests'
      , tests: stats.tests
      , failures: stats.failures
      , errors: stats.failures
      , skipped: stats.tests - stats.failures - stats.passes
      , timestamp: (new Date()).toUTCString()
      , time: stats.duration / 1000
    }, false));

    tests.forEach(function(test){
      writeTest(fd, test);

    });
    appendLine(fd, '</testsuite>');
    fs.closeSync(fd);
  });

}
873086
public void createBundles() throws Exception {

		File tempDir = new File(tempDirPath);
		if(!tempDir.exists()){
			tempDir.mkdirs();
		}else{
			FileUtils.cleanDirectory(tempDir);
		}
		File destDir = new File(destDirPath);
		if(!destDir.exists()){
			destDir.mkdirs();
		}else{
			FileUtils.cleanDirectory(destDir);
		}
		
		List<String> servlets = new ArrayList<String>();
		if(servletsToInitialize != null){
			
			String[] servletNames = servletsToInitialize.split(SERVLET_NAME_SEPARATOR);
			for (int i = 0; i < servletNames.length; i++) {
				servlets.add(servletNames[i].trim());
			}
		}
		
		BundleProcessor bundleProcessor = new BundleProcessor();
		bundleProcessor.process(rootPath, tempDirPath, destDirPath, springConfigFiles, servlets, generateCDNFiles, keepUrlMapping, servletAPIversion);
	}
231700
public void add(MultiPath src, boolean bReversePaths) {
		m_impl.add((MultiPathImpl) src._getImpl(), bReversePaths);
	}
435880
public static void addPropertiesToSpec(ModuleSpec.Builder moduleSpecBuilder, Map<String, String> properties) {
        for (Entry<String, String> entry : properties.entrySet()) {
            moduleSpecBuilder.addProperty(entry.getKey(), entry.getValue());
        }
    }
245422
protected void initBundlePrefixes() {
		bundlePrefixes = new CopyOnWriteArrayList<>();
		for (JoinableResourceBundle bundle : globalBundles) {
			if (StringUtils.isNotEmpty(bundle.getBundlePrefix())) {
				bundlePrefixes.add(bundle.getBundlePrefix());
			}
		}
		for (JoinableResourceBundle bundle : contextBundles) {
			if (StringUtils.isNotEmpty(bundle.getBundlePrefix())) {
				bundlePrefixes.add(bundle.getBundlePrefix());
			}
		}
	}
476080
public static Bundle addBundle(final CFMLEngineFactory factory, final BundleContext context, final File bundle, final Log log) throws IOException, BundleException {

	return addBundle(factory, context, bundle.getAbsolutePath(), new FileInputStream(bundle), true, log);
    }