/// <summary> /// Creates bitmaps for the texture /// </summary> private static Bitmap[] CreateTextureBitmaps( IProgressMonitor progressMonitor, ISpherePlanet planet ) { Bitmap[] faceBitmaps = new Bitmap[ 6 ]; int width = 256; int height = 256; progressMonitor.UpdateProgress( 0 ); ISpherePlanetTerrainRenderer renderer = planet.Renderer.GetRenderer<ISpherePlanetTerrainRenderer>( ); if ( renderer == null ) { throw new InvalidOperationException( "Expected a valid ISpherePlanetTerrainRenderer to be available" ); } faceBitmaps[ ( int )CubeMapFace.PositiveX ] = renderer.CreateMarbleTextureFace( CubeMapFace.PositiveX, width, height ); progressMonitor.UpdateProgress( 1 / 6.0f ); faceBitmaps[ ( int )CubeMapFace.NegativeX ] = renderer.CreateMarbleTextureFace( CubeMapFace.NegativeX, width, height ); progressMonitor.UpdateProgress( 2 / 6.0f ); faceBitmaps[ ( int )CubeMapFace.PositiveY ] = renderer.CreateMarbleTextureFace( CubeMapFace.PositiveY, width, height ); progressMonitor.UpdateProgress( 3 / 6.0f ); faceBitmaps[ ( int )CubeMapFace.NegativeY ] = renderer.CreateMarbleTextureFace( CubeMapFace.NegativeY, width, height ); progressMonitor.UpdateProgress( 4 / 6.0f ); faceBitmaps[ ( int )CubeMapFace.PositiveZ ] = renderer.CreateMarbleTextureFace( CubeMapFace.PositiveZ, width, height ); progressMonitor.UpdateProgress( 5 / 6.0f ); faceBitmaps[ ( int )CubeMapFace.NegativeZ ] = renderer.CreateMarbleTextureFace( CubeMapFace.NegativeZ, width, height ); progressMonitor.UpdateProgress( 1 ); foreach ( object cubeMapFace in Enum.GetValues( typeof( CubeMapFace ) ) ) { faceBitmaps[ ( int )cubeMapFace ].Save( "PlanetCubeMap" + cubeMapFace + ".png" ); } return faceBitmaps; }
protected override SolutionEntityItem LoadSolutionItem (IProgressMonitor monitor, string fileName) { SolutionEntityItem entry = base.LoadSolutionItem (monitor, fileName); if (entry == null) return null; Project project = entry as Project; if (project == null) return entry; //Project MakefileData data = entry.ExtendedProperties ["MonoDevelop.Autotools.MakefileInfo"] as MakefileData; if (data == null) return entry; monitor.BeginTask (GettextCatalog.GetString ("Updating project from Makefile"), 1); try { data.OwnerProject = project; if (data.SupportsIntegration) data.UpdateProject (monitor, false); monitor.Step (1); } catch (Exception e) { monitor.ReportError (GettextCatalog.GetString ( "Error loading Makefile for project {0}", project.Name), e); } finally { monitor.EndTask (); } entry.SetNeedsBuilding (false); return entry; }
protected override void LoadProject (IProgressMonitor monitor, MSBuildProject msproject) { var doc = msproject.Document; projitemsFile = null; foreach (var no in doc.DocumentElement.ChildNodes) { var im = no as XmlElement; if (im != null && im.LocalName == "Import" && im.GetAttribute ("Label") == "Shared") { projitemsFile = im.GetAttribute ("Project"); break; } } if (projitemsFile == null) return; // TODO: load the type from msbuild ((SharedAssetsProject)EntityItem).LanguageName = "C#"; projitemsFile = Path.Combine (Path.GetDirectoryName (msproject.FileName), projitemsFile); MSBuildProject p = new MSBuildProject (); p.Load (projitemsFile); MSBuildSerializer ser = CreateSerializer (); ser.SerializationContext.BaseFile = EntityItem.FileName; ser.SerializationContext.ProgressMonitor = monitor; Item.SetItemHandler (this); var cp = p.PropertyGroups.FirstOrDefault (g => g.Label == "Configuration"); if (cp != null) ((SharedAssetsProject)EntityItem).DefaultNamespace = cp.GetPropertyValue ("Import_RootNamespace"); LoadProjectItems (p, ser, ProjectItemFlags.None); }
public object ReadFile(string file, IProgressMonitor monitor) { XmlTextReader reader = new XmlTextReader (new StreamReader (file)); reader.MoveToContent (); string version = reader.GetAttribute ("version"); if (version == null) version = reader.GetAttribute ("fileversion"); DataSerializer serializer = new DataSerializer (Runtime.ProjectService.DataContext, file); ICombineReader combineReader = null; if (version == "1.0" || version == "1") { combineReader = new CombineReaderV1 (serializer, monitor); monitor.ReportWarning (string.Format (GettextCatalog.GetString ("The file '{0}' is using an old combine file format. It will be automatically converted to the current format."), file)); } else if (version == "2.0") combineReader = new CombineReaderV2 (serializer, monitor); try { if (combineReader != null) return combineReader.ReadCombine (reader); else throw new UnknownProjectVersionException (file, version); } finally { reader.Close (); } }
protected internal override TestResult RunImpl(ITestCommand rootTestCommand, Model.Tree.TestStep parentTestStep, TestExecutionOptions options, IProgressMonitor progressMonitor) { using (progressMonitor.BeginTask("Running tests.", rootTestCommand.TestCount)) { // Note: We do not check options.SkipTestExecution here because we want to build up // the tree of data-driven test steps. So we actually check it later on in the // PatternTestExecutor. This is different from framework adapters // at this time (because they do not generally support dynamically generated data-driven tests). Sandbox sandbox = new Sandbox(); EventHandler canceledHandler = delegate { sandbox.Abort(TestOutcome.Canceled, "The user canceled the test run."); }; try { progressMonitor.Canceled += canceledHandler; TestAssemblyExecutionParameters.Reset(); PatternTestExecutor executor = new PatternTestExecutor(options, progressMonitor, formatter, converter, environmentManager); // Inlined to minimize stack depth. var action = executor.CreateActionToRunTest(rootTestCommand, parentTestStep, sandbox, null); action.Run(); return action.Result; } finally { progressMonitor.Canceled -= canceledHandler; sandbox.Dispose(); } } }
public static IDocumentIterator CreateDocumentIterator(DocumentIteratorType type, IProgressMonitor monitor) { switch (type) { case DocumentIteratorType.CurrentDocument: case DocumentIteratorType.CurrentSelection: return new CurrentDocumentIterator(); case DocumentIteratorType.Directory: try { if (!Directory.Exists(SearchOptions.LookIn)) { if (monitor != null) monitor.ShowingDialog = true; MessageService.ShowMessageFormatted("${res:Dialog.NewProject.SearchReplace.SearchStringNotFound.Title}", "${res:Dialog.NewProject.SearchReplace.LookIn.DirectoryNotFound}", FileUtility.NormalizePath(SearchOptions.LookIn)); if (monitor != null) monitor.ShowingDialog = false; return new DummyDocumentIterator(); } } catch (Exception ex) { if (monitor != null) monitor.ShowingDialog = true; MessageService.ShowMessage(ex.Message); if (monitor != null) monitor.ShowingDialog = false; return new DummyDocumentIterator(); } return new DirectoryDocumentIterator(SearchOptions.LookIn, SearchOptions.LookInFiletypes, SearchOptions.IncludeSubdirectories); case DocumentIteratorType.AllOpenFiles: return new AllOpenDocumentIterator(); case DocumentIteratorType.WholeProject: return new WholeProjectDocumentIterator(); case DocumentIteratorType.WholeSolution: return new WholeSolutionDocumentIterator(); default: throw new System.NotImplementedException("CreateDocumentIterator for type " + type); } }
public void WriteFile (string file, object obj, MSBuildFileFormat format, bool saveProjects, IProgressMonitor monitor) { Solution sol = (Solution) obj; string tmpfilename = String.Empty; try { monitor.BeginTask (GettextCatalog.GetString ("Saving solution: {0}", file), 1); try { if (File.Exists (file)) tmpfilename = Path.GetTempFileName (); } catch (IOException) { } string baseDir = Path.GetDirectoryName (file); if (tmpfilename == String.Empty) { WriteFileInternal (file, sol, baseDir, format, saveProjects, monitor); } else { WriteFileInternal (tmpfilename, sol, baseDir, format, saveProjects, monitor); FileService.SystemRename (tmpfilename, file); } } catch (Exception ex) { monitor.ReportError (GettextCatalog.GetString ("Could not save solution: {0}", file), ex); LoggingService.LogError (GettextCatalog.GetString ("Could not save solution: {0}", file), ex); if (!String.IsNullOrEmpty (tmpfilename) && File.Exists (tmpfilename)) File.Delete (tmpfilename); throw; } finally { monitor.EndTask (); } }
public static BuildResult CompileXibFiles (IProgressMonitor monitor, IEnumerable<ProjectFile> files, FilePath outputRoot) { var result = new BuildResult (); var ibfiles = GetIBFilePairs (files, outputRoot).Where (NeedsBuilding).ToList (); if (ibfiles.Count > 0) { monitor.BeginTask (GettextCatalog.GetString ("Compiling interface definitions"), 0); foreach (var file in ibfiles) { file.EnsureOutputDirectory (); var args = new ProcessArgumentBuilder (); args.AddQuoted (file.Input); args.Add ("--compile"); args.AddQuoted (file.Output); var psi = new ProcessStartInfo ("ibtool", args.ToString ()); monitor.Log.WriteLine (psi.FileName + " " + psi.Arguments); psi.WorkingDirectory = outputRoot; string errorOutput; int code; try { code = ExecuteCommand (monitor, psi, out errorOutput); } catch (System.ComponentModel.Win32Exception ex) { LoggingService.LogError ("Error running ibtool", ex); result.AddError (null, 0, 0, null, "ibtool not found. Please ensure the Apple SDK is installed."); return result; } if (code != 0) { //FIXME: parse the plist that ibtool returns result.AddError (null, 0, 0, null, "ibtool returned error code " + code); } } monitor.EndTask (); } return result; }
internal void Initialize1(IProgressMonitor progressMonitor) { ICollection<ProjectItem> items = project.Items; ProjectService.ProjectItemAdded += OnProjectItemAdded; ProjectService.ProjectItemRemoved += OnProjectItemRemoved; UpdateDefaultImports(items); // TODO: Translate me // progressMonitor.TaskName = "Resolving references for " + project.Name + "..."; AbstractProject abstractProject = project as AbstractProject; if (abstractProject != null) { foreach (var reference in abstractProject.ResolveAssemblyReferences(progressMonitor.CancellationToken)) { if (!initializing) return; // abort initialization AddReference(reference, false, progressMonitor.CancellationToken); } } else { project.ResolveAssemblyReferences(); AddReferencedContent(AssemblyParserService.DefaultProjectContentRegistry.Mscorlib); foreach (ProjectItem item in items) { if (!initializing) return; // abort initialization progressMonitor.CancellationToken.ThrowIfCancellationRequested(); if (ItemType.ReferenceItemTypes.Contains(item.ItemType)) { ReferenceProjectItem reference = item as ReferenceProjectItem; if (reference != null) { AddReference(reference, false, progressMonitor.CancellationToken); } } } } UpdateReferenceInterDependencies(); OnReferencedContentsChanged(EventArgs.Empty); }
protected internal override TestResult RunImpl(ITestCommand rootTestCommand, TestStep parentTestStep, TestExecutionOptions options, IProgressMonitor progressMonitor) { using (progressMonitor.BeginTask("Running tests.", rootTestCommand.TestCount)) { return RunTest(rootTestCommand, parentTestStep, options, progressMonitor); } }
public override IEnumerable<MemberReference> FindReferences (MonoDevelop.Projects.Project project, IProjectContent content, IEnumerable<FilePath> files, IProgressMonitor monitor, IEnumerable<object> searchedMembers) { // TODO: Type system conversion. yield break; // var editor = TextFileProvider.Instance.GetTextEditorData (fileName); // AspNetAppProject project = dom.Project as AspNetAppProject; // if (project == null) // yield break; // // var unit = AspNetParserService.GetCompileUnit (project, fileName, true); // if (unit == null) // yield break; // var refman = new DocumentReferenceManager (project); // // var parsedAspDocument = (AspNetParsedDocument)new AspNetParser ().Parse (dom, fileName, editor.Text); // refman.Doc = parsedAspDocument; // // var usings = refman.GetUsings (); // var documentInfo = new DocumentInfo (dom, unit, usings, refman.GetDoms ()); // // var builder = new AspLanguageBuilder (); // // // var buildDocument = new Mono.TextEditor.TextDocument (); // var offsetInfos = new List<LocalDocumentInfo.OffsetInfo> (); // buildDocument.Text = builder.BuildDocumentString (documentInfo, editor, offsetInfos, true); // var parsedDocument = AspLanguageBuilder.Parse (dom, fileName, buildDocument.Text); // foreach (var member in searchedMembers) { // foreach (var reference in SearchMember (member, dom, fileName, editor, buildDocument, offsetInfos, parsedDocument)) { // yield return reference; // } // } }
public override void LoadProject (IProgressMonitor monitor, SolutionEntityItem item, MSBuildProject msproject) { base.LoadProject (monitor, item, msproject); var dnp = item as DotNetProject; if (dnp == null) return; // Convert .projitems imports into project references foreach (var sp in msproject.Imports.Where (im => im.Label == "Shared" && im.Project.EndsWith (".projitems"))) { var projitemsFile = sp.Project; if (!string.IsNullOrEmpty (projitemsFile)) { projitemsFile = MSBuildProjectService.FromMSBuildPath (item.ItemDirectory, projitemsFile); projitemsFile = Path.Combine (Path.GetDirectoryName (msproject.FileName), projitemsFile); if (File.Exists (projitemsFile)) { MSBuildSerializer iser = Handler.CreateSerializer (); iser.SerializationContext.BaseFile = projitemsFile; iser.SerializationContext.ProgressMonitor = monitor; MSBuildProject p = new MSBuildProject (); p.Load (projitemsFile); Handler.LoadProjectItems (p, iser, ProjectItemFlags.Hidden | ProjectItemFlags.DontPersist); var r = new ProjectReference (ReferenceType.Project, Path.GetFileNameWithoutExtension (projitemsFile)); r.Flags = ProjectItemFlags.DontPersist; r.SetItemsProjectPath (projitemsFile); dnp.References.Add (r); } } } }
/// <summary> /// Finds all references to the specified entity. /// The results are reported using the callback. /// FindReferences may internally use parallelism, and may invoke the callback on multiple /// threads in parallel. /// </summary> public static async Task FindReferencesAsync(IEntity entity, IProgressMonitor progressMonitor, Action<SearchedFile> callback) { if (entity == null) throw new ArgumentNullException("entity"); if (progressMonitor == null) throw new ArgumentNullException("progressMonitor"); if (callback == null) throw new ArgumentNullException("callback"); SD.MainThread.VerifyAccess(); if (SD.ParserService.LoadSolutionProjectsThread.IsRunning) { progressMonitor.ShowingDialog = true; MessageService.ShowMessage("${res:SharpDevelop.Refactoring.LoadSolutionProjectsThreadRunning}"); progressMonitor.ShowingDialog = false; return; } double totalWorkAmount; List<ISymbolSearch> symbolSearches = PrepareSymbolSearch(entity, progressMonitor.CancellationToken, out totalWorkAmount); double workDone = 0; ParseableFileContentFinder parseableFileContentFinder = new ParseableFileContentFinder(); foreach (ISymbolSearch s in symbolSearches) { progressMonitor.CancellationToken.ThrowIfCancellationRequested(); using (var childProgressMonitor = progressMonitor.CreateSubTask(s.WorkAmount / totalWorkAmount)) { await s.FindReferencesAsync(new SymbolSearchArgs(childProgressMonitor, parseableFileContentFinder), callback); } workDone += s.WorkAmount; progressMonitor.Progress = workDone / totalWorkAmount; } }
public Dictionary<string, List<NSObjectTypeInfo>> GetTypeUpdates (IProgressMonitor monitor, CodeDomProvider provider, out Dictionary<string, NSObjectTypeInfo> newTypes, out Dictionary<string, ProjectFile> newFiles) { Dictionary<string, List<NSObjectTypeInfo>> designerFiles = new Dictionary<string, List<NSObjectTypeInfo>> (); string defaultNamespace; // First, we need to name any new user-defined types. foreach (var job in TypeSyncJobs) { if (!job.IsFreshlyAdded) { monitor.Log.WriteLine ("Found updated class: {0}", job.Type.CliName); continue; } defaultNamespace = Project.GetDefaultNamespace (job.RelativePath); job.Type.CliName = defaultNamespace + "." + provider.CreateValidIdentifier (job.Type.ObjCName); monitor.Log.WriteLine ("Found newly-added class: {0}", job.Type.CliName); ProjectInfo.InsertUpdatedType (job.Type); } // Next we can resolve base-types, outlet types, and action parameter types for each of our user-defined types. foreach (var job in TypeSyncJobs) { defaultNamespace = Project.GetDefaultNamespace (job.RelativePath); ProjectInfo.ResolveObjcToCli (monitor, job.Type, provider, defaultNamespace); } AggregateTypeUpdates (monitor, provider, designerFiles, out newTypes, out newFiles); MergeExistingTypes (designerFiles); return designerFiles; }
public CustomToolContext(IProject project, IProgressMonitor progressMonitor) { if (project == null) throw new ArgumentNullException("project"); this.project = project; this.ProgressMonitor = progressMonitor; }
private void SetTestPackage(IProgressMonitor progressMonitor) { using (progressMonitor.CreateSubProgressMonitor(10)) { testController.SetTestPackage(projectController.TestPackage); } }
public SearchProgressMonitor (Pad pad) { outputPad = (SearchResultPad) pad.Content; outputPad.AsyncOperation = AsyncOperation; outputPad.BeginProgress (pad.Title); statusMonitor = IdeApp.Workbench.ProgressMonitors.GetStatusProgressMonitor (GettextCatalog.GetString ("Searching..."), Stock.StatusSearch, false, true, false, pad); }
public static bool ReplaceNextInSelection(IProgressMonitor monitor) { if (lastResult != null && WorkbenchSingleton.Workbench.ActiveWorkbenchWindow != null) { ITextEditorControlProvider provider = WorkbenchSingleton.Workbench.ActiveWorkbenchWindow.ViewContent as ITextEditorControlProvider; if (provider != null) { TextEditorControl textarea = provider.TextEditorControl; SelectionManager selectionManager = textarea.ActiveTextAreaControl.TextArea.SelectionManager; if (selectionManager.SelectionCollection.Count == 1 && selectionManager.SelectionCollection[0].Offset == lastResult.Offset && selectionManager.SelectionCollection[0].Length == lastResult.Length && lastResult.FileName == textarea.FileName) { string replacePattern = lastResult.TransformReplacePattern(SearchOptions.ReplacePattern); textarea.BeginUpdate(); selectionManager.ClearSelection(); textarea.Document.Replace(lastResult.Offset, lastResult.Length, replacePattern); textarea.ActiveTextAreaControl.Caret.Position = textarea.Document.OffsetToPosition(lastResult.Offset + replacePattern.Length); textarea.EndUpdate(); textSelection.Length -= lastResult.Length - replacePattern.Length; } } } return FindNextInSelection(monitor); }
private void ExploreTests(IProgressMonitor progressMonitor) { using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(90)) { testController.Explore(subProgressMonitor, projectController.TestRunnerExtensionSpecifications); } }
public static BuildResult BuildProject(DubProject prj, IProgressMonitor mon, ConfigurationSelector sel) { var br = new BuildResult(); // Skip building sourceLibraries string targetType = null; var cfg = prj.GetConfiguration (sel) as DubProjectConfiguration; if (cfg != null){ cfg.BuildSettings.TryGetTargetTypeProperty (prj, sel, ref targetType); if(string.IsNullOrWhiteSpace(targetType)) prj.CommonBuildSettings.TryGetTargetTypeProperty (prj, sel, ref targetType); if (targetType != null && targetType.ToLower ().Contains("sourcelibrary")) { br.BuildCount = 1; return br; } } var args = new StringBuilder("build"); BuildCommonArgAppendix(args, prj, sel); string output; string errDump; int status = ProjectBuilder.ExecuteCommand(DubSettings.Instance.DubCommand, args.ToString(), prj.BaseDirectory, mon, out errDump, out output); br.CompilerOutput = output; ErrorExtracting.HandleReturnCode (mon, br, status); ErrorExtracting.HandleCompilerOutput(prj, br, output); ErrorExtracting.HandleCompilerOutput(prj, br, errDump); return br; }
public override void Install(IProgressMonitor progressMonitor) { using (progressMonitor.BeginTask("Installing TestDriven.Net Runner", testFrameworkManager.TestFrameworkHandles.Count + 2)) { // Remove old registrations. RemoveExistingRegistryKeys(progressMonitor); progressMonitor.Worked(1); // Register Icarus string icarusPath = FindIcarusPath(); if (icarusPath != null) InstallRegistryKeysForIcarus(icarusPath, progressMonitor); progressMonitor.Worked(1); // Register frameworks foreach (ComponentHandle<ITestFramework, TestFrameworkTraits> testFrameworkHandle in testFrameworkManager.TestFrameworkHandles) { TestFrameworkTraits testFrameworkTraits = testFrameworkHandle.GetTraits(); TDNetRunnerInstallationMode installationMode = preferenceManager.GetInstallationModeForFramework(testFrameworkHandle.Id); if (installationMode != TDNetRunnerInstallationMode.Disabled) { int priority = installationMode == TDNetRunnerInstallationMode.Default ? 25 : 5; foreach (AssemblySignature frameworkAssembly in testFrameworkTraits.FrameworkAssemblies) { InstallRegistryKeysForFramework(testFrameworkTraits.Name, frameworkAssembly, priority, progressMonitor); } } progressMonitor.Worked(1); } } }
static void GenerateInternal (IProgressMonitor monitor, ProjectFile file, SingleFileCustomToolResult result) { if (file.Project.SupportedLanguages.All (l => l != "C#")) { const string msg = "Razor templates are only supported in C# projects"; result.Errors.Add (new CompilerError (file.Name, -1, -1, null, msg)); monitor.Log.WriteLine (msg); return; } var host = new PreprocessedRazorHost (file.FilePath); var defaultOutputName = file.FilePath.ChangeExtension (".cs"); var ns = CustomToolService.GetFileNamespace (file, defaultOutputName); host.DefaultNamespace = ns; CompilerErrorCollection errors; var code = host.GenerateCode (out errors); result.Errors.AddRange (errors); var writer = new MonoDevelop.DesignerSupport.CodeBehindWriter (); writer.WriteFile (defaultOutputName, code); writer.WriteOpenFiles (); result.GeneratedFilePath = defaultOutputName; foreach (var err in result.Errors) { monitor.Log.WriteLine (err); } }
public override void ApplyPendingSettingsChanges(IElevationContext elevationContext, IProgressMonitor progressMonitor) { base.ApplyPendingSettingsChanges(elevationContext, progressMonitor); optionsController.AutoSaveProject = autoSave.Checked; optionsController.Save(); }
void OnCancel(IProgressMonitor m) { lock (list) { foreach (IAsyncOperation operation in list) operation.Cancel (); } }
public void SetUp() { testController = MockRepository.GenerateStub<ITestController>(); projectController = MockRepository.GenerateStub<IProjectController>(); loadPackageCommand = new LoadPackageCommand(testController, projectController); progressMonitor = MockProgressMonitor.Instance; }
private static bool InstallOrUninstallWithElevationContext(IEnumerable<ComponentHandle<IInstaller, InstallerTraits>> installerHandles, IElevationContext elevationContext, IProgressMonitor progressMonitor, InstallerOperation operation) { foreach (var installerHandle in installerHandles) { if (progressMonitor.IsCanceled) return false; IProgressMonitor subProgressMonitor = progressMonitor.CreateSubProgressMonitor(1); if (elevationContext != null && installerHandle.GetTraits().RequiresElevation) { elevationContext.Execute(InstallerElevatedCommand.ElevatedCommandId, new InstallerElevatedCommand.Arguments(installerHandle.Id, operation), subProgressMonitor); } else { IInstaller installer = installerHandle.GetComponent(); if (operation == InstallerOperation.Install) installer.Install(progressMonitor.CreateSubProgressMonitor(1)); else installer.Uninstall(progressMonitor.CreateSubProgressMonitor(1)); } } return true; }
protected override void Execute(IntPtr bridgeFunc, IProgressMonitor subMonitor) { using (subMonitor.BeginTask("Exploring " + File.Name, 100)) { BoostTestExploreDelegate bridge = (BoostTestExploreDelegate)Marshal.GetDelegateForFunctionPointer( bridgeFunc, typeof(BoostTestExploreDelegate) ); VisitorDelegate visitTestCase = new VisitorDelegate(VisitTestCase); VisitorDelegate beginVisitTestSuite = new VisitorDelegate(BeginVisitTestSuite); VisitorDelegate endVisitTestSuite = new VisitorDelegate(EndVisitTestSuite); ErrorReporterDelegate errorReporter = new ErrorReporterDelegate((text) => Logger.Log(LogSeverity.Error, text)); bridge( File.FullName, visitTestCase, beginVisitTestSuite, endVisitTestSuite, errorReporter ); TestModelSerializer.PublishTestModel(TestModel, MessageSink); } }
/// <inheritdoc /> protected override TestResult RunImpl(ITestCommand rootTestCommand, TestStep parentTestStep, TestExecutionOptions options, IProgressMonitor progressMonitor) { ThrowIfDisposed(); using (progressMonitor.BeginTask(Resources.MbUnit2TestController_RunningMbUnitTests, 1)) { if (progressMonitor.IsCanceled) return new TestResult(TestOutcome.Canceled); if (options.SkipTestExecution) { return SkipAll(rootTestCommand, parentTestStep); } else { IList<ITestCommand> testCommands = rootTestCommand.GetAllCommands(); using (InstrumentedFixtureRunner fixtureRunner = new InstrumentedFixtureRunner(fixtureExplorer, testCommands, progressMonitor, parentTestStep)) { return fixtureRunner.Run(); } } } }
protected override TestResult RunImpl( ITestCommand rootTestCommand, TestStep parentTestStep, TestExecutionOptions options, IProgressMonitor progressMonitor ) { using(progressMonitor.BeginTask( "Verifying Specifications", rootTestCommand.TestCount ) ) { if( options.SkipTestExecution ) { return SkipAll( rootTestCommand, parentTestStep ); } else { ITestContext rootContext = rootTestCommand.StartPrimaryChildStep( parentTestStep ); TestStep rootStep = rootContext.TestStep; TestOutcome outcome = TestOutcome.Passed; foreach( ITestCommand command in rootTestCommand.Children ) { NSpecAssemblyTest assemblyTest = command.Test as NSpecAssemblyTest; if( assemblyTest == null ) continue; var assemblyResult = this.RunAssembly( command, rootStep ); outcome = outcome.CombineWith( assemblyResult.Outcome ); } return rootContext.FinishStep( outcome, null ); } } }
protected override BuildResult Build (IProgressMonitor monitor, SolutionEntityItem entry, ConfigurationSelector configuration) { BuildResult res = base.Build (monitor, entry, configuration); if (res.ErrorCount > 0 || !(entry is DotNetProject)) return res; DotNetProject project = (DotNetProject) entry; AddinData data = AddinData.GetAddinData (project); if (data == null) return res; monitor.Log.WriteLine (AddinManager.CurrentLocalizer.GetString ("Verifying add-in description...")); string fileName = data.AddinManifestFileName; ProjectFile file = data.Project.Files.GetFile (fileName); if (file == null) return res; string addinFile; if (file.BuildAction == BuildAction.EmbeddedResource) addinFile = project.GetOutputFileName (ConfigurationSelector.Default); else addinFile = file.FilePath; AddinDescription desc = data.AddinRegistry.GetAddinDescription (new ProgressStatusMonitor (monitor), addinFile); StringCollection errors = desc.Verify (); foreach (string err in errors) { res.AddError (data.AddinManifestFileName, 0, 0, "", err); monitor.Log.WriteLine ("ERROR: " + err); } return res; }
public void RevertToRevision(FilePath localPath, Revision revision, IProgressMonitor monitor) { ClearCachedVersionInfo(localPath); OnRevertToRevision(localPath, revision, monitor); }
// Adds a file or directory to the repository public void Add(FilePath localPath, bool recurse, IProgressMonitor monitor) { Add(new FilePath[] { localPath }, recurse, monitor); }
protected virtual void OnMoveDirectory(FilePath localSrcPath, FilePath localDestPath, bool force, IProgressMonitor monitor) { FileService.SystemDirectoryRename(localSrcPath, localDestPath); }
// Moves a directory. This method may be called for versioned and unversioned // files. The default implementetions performs a system file move. public void MoveDirectory(FilePath localSrcPath, FilePath localDestPath, bool force, IProgressMonitor monitor) { ClearCachedVersionInfo(localSrcPath, localDestPath); OnMoveDirectory(localSrcPath, localDestPath, force, monitor); }
protected virtual void OnMoveFile(FilePath localSrcPath, FilePath localDestPath, bool force, IProgressMonitor monitor) { File.Move(localSrcPath, localDestPath); }
protected abstract void OnAdd(FilePath[] localPaths, bool recurse, IProgressMonitor monitor);
public void Add(FilePath[] localPaths, bool recurse, IProgressMonitor monitor) { OnAdd(localPaths, recurse, monitor); ClearCachedVersionInfo(localPaths); }
public void Revert(FilePath[] localPaths, bool recurse, IProgressMonitor monitor) { ClearCachedVersionInfo(localPaths); OnRevert(localPaths, recurse, monitor); }
protected abstract void OnRevertToRevision(FilePath localPath, Revision revision, IProgressMonitor monitor);
public void Checkout(FilePath targetLocalPath, Revision rev, bool recurse, IProgressMonitor monitor) { ClearCachedVersionInfo(targetLocalPath); OnCheckout(targetLocalPath, rev, recurse, monitor); }
public void Revert(FilePath localPath, bool recurse, IProgressMonitor monitor) { Revert(new FilePath[] { localPath }, recurse, monitor); }
protected abstract void OnCommit(ChangeSet changeSet, IProgressMonitor monitor);
protected abstract void OnCheckout(FilePath targetLocalPath, Revision rev, bool recurse, IProgressMonitor monitor);
// Updates a local file or directory from the repository // Returns a list of updated files public void Update(FilePath localPath, bool recurse, IProgressMonitor monitor) { Update(new FilePath[] { localPath }, recurse, monitor); }
// Gets the contents of this repositories into the specified local path public void Checkout(FilePath targetLocalPath, bool recurse, IProgressMonitor monitor) { Checkout(targetLocalPath, null, recurse, monitor); }
// Imports a directory into the repository. 'serverPath' is the relative path in the repository. // 'localPath' is the local directory to publish. 'files' is the list of files to add to the new // repository directory (must use absolute local paths). public Repository Publish(string serverPath, FilePath localPath, FilePath[] files, string message, IProgressMonitor monitor) { var res = OnPublish(serverPath, localPath, files, message, monitor); ClearCachedVersionInfo(localPath); return(res); }
// Commits changes in a set of files or directories into the repository public void Commit(ChangeSet changeSet, IProgressMonitor monitor) { ClearCachedVersionInfo(changeSet.BaseLocalPath); OnCommit(changeSet, monitor); }
protected override BuildResult OnBuild(IProgressMonitor monitor, ConfigurationSelector configuration) { return(null); }
protected abstract Repository OnPublish(string serverPath, FilePath localPath, FilePath[] files, string message, IProgressMonitor monitor);
public override void Clean(ProjectFileCollection projectFiles, CProjectConfiguration configuration, IProgressMonitor monitor) { //clean up object files foreach (string oFile in ObjectFiles(projectFiles, configuration, false)) { if (File.Exists(oFile)) { File.Delete(oFile); } string dFile = Path.ChangeExtension(oFile, ".d"); if (File.Exists(dFile)) { File.Delete(dFile); } } CleanPrecompiledHeaders(configuration); }
protected override void OnExecute(IProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration) { }
public override BuildResult Compile( Project project, ProjectFileCollection projectFiles, ProjectPackageCollection packages, CProjectConfiguration configuration, IProgressMonitor monitor) { if (!appsChecked) { appsChecked = true; compilerFound = CheckApp(compilerCommand); linkerFound = CheckApp(linkerCommand); } if (!compilerFound) { BuildResult cres = new BuildResult(); cres.AddError("Compiler not found: " + compilerCommand); return(cres); } if (!linkerFound) { BuildResult cres = new BuildResult(); cres.AddError("Linker not found: " + linkerCommand); return(cres); } CompilerResults cr = new CompilerResults(new TempFileCollection()); bool success = true; string compilerArgs = GetCompilerFlags(project, configuration) + " " + GeneratePkgCompilerArgs(packages); string outputName = Path.Combine(configuration.OutputDirectory, configuration.CompiledOutputName); // Precompile header files and place them in .prec/<config_name>/ if (configuration.PrecompileHeaders) { string precDir = Path.Combine(configuration.SourceDirectory, ".prec"); string precConfigDir = Path.Combine(precDir, configuration.Id); if (!Directory.Exists(precDir)) { Directory.CreateDirectory(precDir); } if (!Directory.Exists(precConfigDir)) { Directory.CreateDirectory(precConfigDir); } if (!PrecompileHeaders(projectFiles, configuration, compilerArgs, monitor, cr)) { success = false; } } else { //old headers could interfere with the build CleanPrecompiledHeaders(configuration); } //compile source to object files monitor.BeginTask(GettextCatalog.GetString("Compiling source to object files"), 1); foreach (ProjectFile f in projectFiles) { if (!success) { break; } if (f.Subtype == Subtype.Directory || f.BuildAction != BuildAction.Compile || CProject.IsHeaderFile(f.FilePath)) { continue; } if (configuration.UseCcache || NeedsCompiling(f, configuration)) { success = DoCompilation(f, configuration, compilerArgs, monitor, cr, configuration.UseCcache); } } if (success) { monitor.Step(1); } monitor.EndTask(); if (success) { switch (configuration.CompileTarget) { case CBinding.CompileTarget.Bin: MakeBin(project, projectFiles, configuration, packages, cr, monitor, outputName); break; case CBinding.CompileTarget.StaticLibrary: MakeStaticLibrary(project, projectFiles, configuration, packages, cr, monitor, outputName); break; case CBinding.CompileTarget.SharedLibrary: MakeSharedLibrary(project, projectFiles, configuration, packages, cr, monitor, outputName); break; } } return(new BuildResult(cr, "")); }
protected override void OnClean(IProgressMonitor monitor, ConfigurationSelector configuration) { }
public static void ReplaceFirstInSelection(int offset, int length, IProgressMonitor monitor) { SetSearchOptions(monitor); FindFirstInSelection(offset, length, monitor); }
private void MakeSharedLibrary(Project project, ProjectFileCollection projectFiles, CProjectConfiguration configuration, ProjectPackageCollection packages, CompilerResults cr, IProgressMonitor monitor, string outputName) { if (!NeedsUpdate(projectFiles, configuration, outputName)) { return; } string objectFiles = string.Join(" ", ObjectFiles(projectFiles, configuration, true)); string pkgargs = GeneratePkgLinkerArgs(packages); StringBuilder args = new StringBuilder(); if (configuration.ExtraLinkerArguments != null && configuration.ExtraLinkerArguments.Length > 0) { string extraLinkerArgs = ExpandBacktickedParameters(configuration.ExtraLinkerArguments.Replace('\n', ' ')); args.Append(extraLinkerArgs + " "); } if (configuration.LibPaths != null) { foreach (string libpath in configuration.LibPaths) { args.Append("-L\"" + StringParserService.Parse(libpath, GetStringTags(project)) + "\" "); } } if (configuration.Libs != null) { foreach (string lib in configuration.Libs) { string directory = Path.GetDirectoryName(lib); string library = Path.GetFileName(lib); // Is this a 'standard' (as in, uses an orthodox naming convention) library..? string link_lib = String.Empty; if (IsStandardLibrary(configuration, directory, library, ref link_lib)) { args.Append("-l\"" + link_lib + "\" "); } // If not, reference the library by it's full pathname. else { args.Append("\"" + lib + "\" "); } } } string linker_args = string.Format("-shared -o \"{0}\" {1} {2} {3}", outputName, objectFiles, pkgargs, args.ToString()); monitor.BeginTask(GettextCatalog.GetString("Generating shared object \"{0}\" from object files", Path.GetFileName(outputName)), 1); string errorOutput; int exitCode = ExecuteCommand(linkerCommand, linker_args, Path.GetDirectoryName(outputName), monitor, out errorOutput); if (exitCode == 0) { monitor.Step(1); } monitor.EndTask(); ParseCompilerOutput(errorOutput, cr); ParseLinkerOutput(errorOutput, cr); CheckReturnCode(exitCode, cr); }
static void SetSearchOptions(IProgressMonitor monitor) { find.SearchStrategy = SearchReplaceUtilities.CreateSearchStrategy(SearchOptions.SearchStrategyType); find.DocumentIterator = SearchReplaceUtilities.CreateDocumentIterator(SearchOptions.DocumentIteratorType, monitor); }
private bool DoPrecompileHeader(ProjectFile file, string output, string args, IProgressMonitor monitor, CompilerResults cr) { string completeArgs = String.Format("\"{0}\" {1} -o {2}", file.Name, args, output); string errorOutput; int exitCode = ExecuteCommand(compilerCommand, completeArgs, Path.GetDirectoryName(output), monitor, out errorOutput); ParseCompilerOutput(errorOutput, cr); return(exitCode == 0); }