public bool SaveTools() { if (CheckPassTool(PreviouslySelectedIndex)) { // Figure out which tools have been removed and if a directory in the tools folder can be removed. // Check if we can delete any toolDirs based on the tools on the remove list. if (Removelist.Count > 0) { var referencedPaths = ToolList.Where(t => !string.IsNullOrEmpty(t.ToolDirPath)) .Select(t => t.ToolDirPath).ToArray(); foreach (var removeTool in Removelist) { if (!string.IsNullOrEmpty(removeTool.ToolDirPath) && Directory.Exists(removeTool.ToolDirPath) && !referencedPaths.Contains(removeTool.ToolDirPath)) { DirectoryEx.SafeDelete(removeTool.ToolDirPath); } } } Settings.Default.ToolList = Properties.ToolList.CopyTools(ToolList); Unsaved = false; Removelist = new List <ToolDescription>(); return(true); } else { return(false); } }
private void ClearAllTools() { Settings.Default.ToolList.Clear(); string toolsDir = ToolDescriptionHelpers.GetToolsDirectory(); DirectoryEx.SafeDelete(toolsDir); }
/// <summary> /// Generate the list of Existing Reports that would be modified and the list of new reports /// </summary> private static List <ReportOrViewSpec> FindReportConflicts(DirectoryInfo toolInfDir, string tempToolPath, out List <ReportOrViewSpec> newReports) { var existingReports = new List <ReportOrViewSpec>(); newReports = new List <ReportOrViewSpec>(); foreach (FileInfo file in toolInfDir.GetFiles(@"*" + ReportSpecList.EXT_REPORTS)) { List <ReportOrViewSpec> loadedItems; try { using (var stream = File.OpenRead(file.FullName)) { loadedItems = ReportSharing.DeserializeReportList(stream); } } catch (Exception exception) { DirectoryEx.SafeDelete(tempToolPath); throw new IOException( string.Format(Resources.SerializableSettingsList_ImportFile_Failure_loading__0__, file.FullName), exception); } var externalToolReports = Settings.Default.PersistedViews.GetViewSpecList(PersistedViews.ExternalToolsGroup.Id); Dictionary <string, ViewSpec> allExistingReports = new Dictionary <string, ViewSpec>(); if (externalToolReports != null) { foreach (var viewSpec in externalToolReports.ViewSpecs) { allExistingReports[viewSpec.Name] = viewSpec; } } foreach (var reportOrViewSpec in loadedItems) { ViewSpec existingView; if (allExistingReports.TryGetValue(reportOrViewSpec.GetKey(), out existingView)) { if (!ReportSharing.AreEquivalent(reportOrViewSpec, new ReportOrViewSpec(existingView))) { existingReports.Add(reportOrViewSpec); } else { newReports.Add(reportOrViewSpec); } } else { newReports.Add(reportOrViewSpec); } } // We now have the list of Reports that would have a naming conflict. } return(existingReports); }
private static List <ReportOrViewSpec> GetReportsFromFiles(DirectoryInfo toolInfDir, string tempToolPath) { var srmSerialzer = new XmlSerializer(typeof(SrmDocument)); var loadedItems = new List <ReportOrViewSpec>(); var skyrFiles = toolInfDir.GetFiles(@"*" + ReportSpecList.EXT_REPORTS); if (skyrFiles.Length > 0) { foreach (FileInfo file in skyrFiles) { try { using (var stream = File.OpenRead(file.FullName)) { loadedItems.AddRange(ReportSharing.DeserializeReportList(stream)); } } catch (Exception exception) { DirectoryEx.SafeDelete(tempToolPath); throw new IOException( string.Format(Resources.SerializableSettingsList_ImportFile_Failure_loading__0__, file.FullName), exception); } } } else { foreach (FileInfo file in toolInfDir.GetFiles().Where(file => file.Extension.Equals(SrmDocument.EXT))) { SrmDocument document; try { using (var stream = File.OpenRead(file.FullName)) { document = (SrmDocument)srmSerialzer.Deserialize(stream); } } catch (Exception exception) { throw new IOException(string.Format( Resources.SerializableSettingsList_ImportFile_Failure_loading__0__, file.FullName), exception); } var reports = document.Settings.DataSettings.ViewSpecList.ViewSpecLayouts; foreach (ViewSpecLayout report in reports) { loadedItems.Add(new ReportOrViewSpec(report)); } } } return(loadedItems); }
private static void CopyOldTools(string outerToolsFolderPath, ILongWaitBroker broker) { //Copy tools to a different folder then Directory.Move if successful. string tempOuterToolsFolderPath = string.Concat(outerToolsFolderPath, @"_installing"); if (Directory.Exists(tempOuterToolsFolderPath)) { DirectoryEx.SafeDelete(tempOuterToolsFolderPath); // Not sure this is necessay, but just to be safe if (Directory.Exists(tempOuterToolsFolderPath)) { throw new Exception(Resources.Program_CopyOldTools_Error_copying_external_tools_from_previous_installation); } } // Must create the tools directory to avoid ending up here again next time Directory.CreateDirectory(tempOuterToolsFolderPath); ToolList toolList = Settings.Default.ToolList; int numTools = toolList.Count; const int endValue = 100; int progressValue = 0; // ReSharper disable once UselessBinaryOperation (in case we decide to start at progress>0 for display purposes) int increment = (endValue - progressValue) / (numTools + 1); foreach (var tool in toolList) { string toolDirPath = tool.ToolDirPath; if (!string.IsNullOrEmpty(toolDirPath) && Directory.Exists(toolDirPath)) { string foldername = Path.GetFileName(toolDirPath); string newDir = Path.Combine(outerToolsFolderPath, foldername); string tempNewDir = Path.Combine(tempOuterToolsFolderPath, foldername); if (!Directory.Exists(tempNewDir)) { DirectoryEx.DirectoryCopy(toolDirPath, tempNewDir, true); } tool.ToolDirPath = newDir; // Update the tool to point to its new directory. tool.ArgsCollectorDllPath = tool.ArgsCollectorDllPath.Replace(toolDirPath, newDir); } if (broker.IsCanceled) { // Don't leave around a corrupted directory DirectoryEx.SafeDelete(tempOuterToolsFolderPath); return; } progressValue += increment; broker.ProgressValue = progressValue; } Directory.Move(tempOuterToolsFolderPath, outerToolsFolderPath); Settings.Default.ToolList = ToolList.CopyTools(toolList); }
public void Extract(IProgressMonitor progressMonitor) { ProgressMonitor = progressMonitor; ProgressMonitor.UpdateProgress(_progressStatus = new ProgressStatus(DefaultMessage)); var extractDir = ExtractDir(SharedPath); using (ZipFile zip = ZipFile.Read(SharedPath)) { CountEntries = zip.Entries.Count; ExpectedSize = zip.Entries.Select(entry => entry.UncompressedSize).Sum(); zip.ExtractProgress += SrmDocumentSharing_ExtractProgress; string documentName = FindSharedSkylineFile(zip); string parentDir = Path.GetDirectoryName(SharedPath); if (!string.IsNullOrEmpty(parentDir)) { extractDir = Path.Combine(parentDir, extractDir); } extractDir = GetNonExistentDir(extractDir); DocumentPath = Path.Combine(extractDir, documentName); foreach (var entry in zip.Entries) { if (ProgressMonitor.IsCanceled) { break; } try { entry.Extract(extractDir); ExtractedSize += entry.UncompressedSize; } catch (Exception) { if (!ProgressMonitor.IsCanceled) { throw; } } } } if (ProgressMonitor.IsCanceled) { DirectoryEx.SafeDelete(extractDir); } }
/// <summary> /// Removes any old folders in the ToolDir that dont have tools associated with them /// For the case where we have used a dll and couldn't delete it in some past instance of Skyline. /// </summary> public static void CheckToolDirConsistency() { var referencedPaths = Settings.Default.ToolList.Where(t => !string.IsNullOrEmpty(t.ToolDirPath)) .Select(t => t.ToolDirPath).ToArray(); string toolsDir = ToolDescriptionHelpers.GetToolsDirectory(); if (string.IsNullOrEmpty(toolsDir) || !Directory.Exists(toolsDir)) { return; } foreach (var folder in Directory.EnumerateDirectories(toolsDir)) { if (!referencedPaths.Contains(folder)) { DirectoryEx.SafeDelete(folder); } } }
public void Dispose() { if (_spillFiles != null) { string cachePath = null; for (int i = 0; i < _spillFiles.Length; i++) { if (_spillFiles[i].FileName != null) { cachePath = _spillFiles[i].FileName; } _spillFiles[i].CloseStream(); } if (cachePath != null) { DirectoryEx.SafeDelete(Path.GetDirectoryName(cachePath)); } } }
public void Dispose() { if (_spillFiles != null) { string cachePath = null; for (int i = 0; i < _spillFiles.Length; i++) { var stream = _spillFiles[i].Stream; if (stream != null) { cachePath = stream.Name; stream.Dispose(); } } if (cachePath != null) { DirectoryEx.SafeDelete(Path.GetDirectoryName(cachePath)); } } }
private void BrukerTOFMethodTest() { const string brukerOutputMethodFilename = "RetTimeMassListFile.Method"; RunUI(() => SkylineWindow.OpenFile(TestFilesDir.GetTestPath("Bovine_std_curated_seq_small2-trigger.sky"))); string brukerActualMeth = TestFilesDir.GetTestPath("brukermethodexport.m"); string brukerExpectedMeth = TestFilesDir.GetTestPath("BrukerExpected.Method"); string brukerTemplateMeth = TestFilesDir.GetTestPath("Bruker Template Scheduled Precursor List.m"); WaitForDocumentLoaded(); // Export PRM method unscheduled RunDlg <ExportMethodDlg>(() => SkylineWindow.ShowExportMethodDialog(ExportFileType.Method), exportMethodDlg => { exportMethodDlg.InstrumentType = ExportInstrumentType.BRUKER_TOF; exportMethodDlg.ExportStrategy = ExportStrategy.Single; exportMethodDlg.SetTemplateFile(brukerTemplateMeth); exportMethodDlg.MethodType = ExportMethodType.Standard; Assert.IsTrue(exportMethodDlg.IsRunLengthVisible); Assert.IsFalse(exportMethodDlg.IsOptimizeTypeEnabled); exportMethodDlg.RunLength = 20; exportMethodDlg.OkDialog(brukerActualMeth); }); Assert.IsTrue(Directory.Exists(brukerActualMeth)); AssertEx.NoDiff(File.ReadAllText(brukerExpectedMeth), File.ReadAllText(Path.Combine(brukerActualMeth, brukerOutputMethodFilename))); DirectoryEx.SafeDelete(brukerActualMeth); // Export PRM method scheduled RunDlg <ExportMethodDlg>(() => SkylineWindow.ShowExportMethodDialog(ExportFileType.Method), exportMethodDlg => { exportMethodDlg.InstrumentType = ExportInstrumentType.BRUKER_TOF; exportMethodDlg.ExportStrategy = ExportStrategy.Single; exportMethodDlg.SetTemplateFile(brukerTemplateMeth); exportMethodDlg.MethodType = ExportMethodType.Scheduled; Assert.IsFalse(exportMethodDlg.IsRunLengthVisible); Assert.IsFalse(exportMethodDlg.IsOptimizeTypeEnabled); exportMethodDlg.OkDialog(brukerActualMeth); }); Assert.IsTrue(Directory.Exists(brukerActualMeth)); brukerExpectedMeth = TestFilesDir.GetTestPath("BrukerExpectedSched.Method"); AssertEx.NoDiff(File.ReadAllText(brukerExpectedMeth), File.ReadAllText(Path.Combine(brukerActualMeth, brukerOutputMethodFilename))); DirectoryEx.SafeDelete(brukerActualMeth); // Export PRM method scheduled error { RunUI(() => SkylineWindow.ModifyDocument("Remove RT prediction", doc => doc.ChangeSettings(doc.Settings.ChangePeptidePrediction(predict => predict.ChangeRetentionTime(null))))); var exportMethodDlgError = ShowDialog <ExportMethodDlg>(() => SkylineWindow.ShowExportMethodDialog(ExportFileType.Method)); RunUI(() => { exportMethodDlgError.InstrumentType = ExportInstrumentType.BRUKER_TOF; exportMethodDlgError.ExportStrategy = ExportStrategy.Single; exportMethodDlgError.SetTemplateFile(brukerTemplateMeth); }); RunDlg <MessageDlg>(() => exportMethodDlgError.MethodType = ExportMethodType.Scheduled, dlg => dlg.CancelDialog()); OkDialog(exportMethodDlgError, exportMethodDlgError.CancelDialog); } // Export DIA Method { var isoWindows = new IsolationScheme("Prespecified", new[] { new IsolationWindow(500, 521, null, 0.5, 0.5), new IsolationWindow(520, 541, null, 0.5, 0.5), new IsolationWindow(540, 561, null, 0.5, 0.5), }); RunUI(() => SkylineWindow.ModifyDocument("Add isolation window list", doc => doc.ChangeSettings(doc.Settings.ChangeTransitionFullScan(full => full.ChangeAcquisitionMethod(FullScanAcquisitionMethod.DIA, isoWindows))))); var exportMethodDlgDia = ShowDialog <ExportMethodDlg>(() => SkylineWindow.ShowExportMethodDialog(ExportFileType.Method)); RunUI(() => { exportMethodDlgDia.InstrumentType = ExportInstrumentType.BRUKER_TOF; exportMethodDlgDia.ExportStrategy = ExportStrategy.Single; exportMethodDlgDia.SetTemplateFile(brukerTemplateMeth); }); RunDlg <MessageDlg>(() => exportMethodDlgDia.MethodType = ExportMethodType.Scheduled, dlg => { Assert.AreEqual(Resources.ExportMethodDlg_comboTargetType_SelectedIndexChanged_Scheduled_methods_are_not_yet_supported_for_DIA_acquisition, dlg.Message); dlg.CancelDialog(); }); RunUI(() => { Assert.IsTrue(exportMethodDlgDia.IsRunLengthVisible); exportMethodDlgDia.RunLength = 20; }); OkDialog(exportMethodDlgDia, () => exportMethodDlgDia.OkDialog(brukerActualMeth)); Assert.IsTrue(Directory.Exists(brukerActualMeth)); brukerExpectedMeth = TestFilesDir.GetTestPath("BrukerExpectedDIA.Method"); AssertEx.NoDiff(File.ReadAllText(brukerExpectedMeth), File.ReadAllText(Path.Combine(brukerActualMeth, brukerOutputMethodFilename))); } // Export DIA method error not prespecified { var isoResults = new IsolationScheme("Results (20)", 20.0); RunUI(() => SkylineWindow.ModifyDocument("Add results isolation scheme", doc => doc.ChangeSettings(doc.Settings.ChangeTransitionFullScan(full => full.ChangeAcquisitionMethod(FullScanAcquisitionMethod.DIA, isoResults))))); var exportMethodDlgDia = ShowDialog <ExportMethodDlg>(() => SkylineWindow.ShowExportMethodDialog(ExportFileType.Method)); RunUI(() => { exportMethodDlgDia.InstrumentType = ExportInstrumentType.BRUKER_TOF; exportMethodDlgDia.ExportStrategy = ExportStrategy.Single; exportMethodDlgDia.SetTemplateFile(brukerTemplateMeth); }); RunDlg <MessageDlg>(exportMethodDlgDia.OkDialog, dlg => { Assert.AreEqual(Resources.ExportMethodDlg_OkDialog_The_DIA_isolation_list_must_have_prespecified_windows_, dlg.Message); dlg.CancelDialog(); }); OkDialog(exportMethodDlgDia, exportMethodDlgDia.CancelDialog); } }
private void InstallUpdates(ICollection <ToolUpdateInfo> tools) { if (tools != null && tools.Count != 0 && !TestingDownloadOnly) { var failedUpdates = new Dictionary <string, string>(); var successfulUpdates = new Collection <string>(); int installCount = 0; foreach (var tool in tools) { labelOperation.Text = string.Format(Resources.ToolUpdatesDlg_InstallUpdates_Installing_updates_to__0_, tool._packageName); var toolList = ToolList.CopyTools(Settings.Default.ToolList); bool exceptionThrown = false; ToolInstaller.UnzipToolReturnAccumulator result = null; try { result = _updateHelper.UnpackZipTool(tool.FilePath, new ToolInstallUI.InstallZipToolHelper(_parent.InstallProgram)); } catch (ToolExecutionException x) { failedUpdates.Add(tool._packageName, x.Message); exceptionThrown = true; } catch (IOException x) { failedUpdates.Add(tool._packageName, TextUtil.LineSeparate(string.Format(Resources.ConfigureToolsDlg_UnpackZipTool_Failed_attempting_to_extract_the_tool_from__0_, Path.GetFileName(tool.FilePath)), x.Message)); exceptionThrown = true; } progressBar.Value = Convert.ToInt32((((((double)++installCount) / tools.Count) * 100) / 2) + 50); if (result == null) { // user cancelled if (!exceptionThrown) { failedUpdates.Add(tool._packageName, Resources.ToolUpdatesDlg_InstallUpdates_User_cancelled_installation); } // reset tool list Settings.Default.ToolList = toolList; continue; } // tool was successfully updated result.MessagesThrown.ForEach(message => MessageDlg.Show(this, message)); successfulUpdates.Add(tool._packageName); } // clean-up DirectoryEx.SafeDelete(ToolDir.FullName); progressBar.Value = 100; DisplayInstallSummary(successfulUpdates, failedUpdates); } }
/// <summary> /// Function for unpacking zipped External tools. /// </summary> /// <param name="pathToZip">Path to the zipped file that contains the tool and all its assicaited files.</param> /// <param name="unpackSupport"> Interface that implements required functions that are dependent on context.</param> /// <returns></returns> public static UnzipToolReturnAccumulator UnpackZipTool(string pathToZip, IUnpackZipToolSupport unpackSupport) { if (!Directory.Exists(pathToZip) && !File.Exists(pathToZip)) { throw new FileNotFoundException(pathToZip); } //Removes any old folders that dont have Tools associated with them CheckToolDirConsistency(); var retval = new UnzipToolReturnAccumulator(); string name = Path.GetFileNameWithoutExtension(pathToZip); if (name == null) { throw new ToolExecutionException(Resources.ConfigureToolsDlg_unpackZipTool_Invalid_file_selected__No_tools_added_); } // This helps with zipfiles that have spaces in the titles. // Consider: We may want to add quotes around usages of the $(ToolDir) macro incase the Tool directory has spaces in one of its directory names. name = name.Replace(' ', '_'); string outerToolsFolderPath = ToolDescriptionHelpers.GetToolsDirectory(); if (string.IsNullOrEmpty(outerToolsFolderPath)) { throw new ToolExecutionException(Resources.ConfigureToolsDlg_unpackZipTool_Error_unpacking_zipped_tools); } string tempFolderPath = Path.Combine(outerToolsFolderPath, @"Temp"); var toolDir = new DirectoryInfo(tempFolderPath); if (!toolDir.Exists) { toolDir.Create(); } // This naming conflict shouldn't happen. The temp file should be empty. // Consider: Try to delete the existing directory in the temp directory. string tempToolPath = Path.Combine(tempFolderPath, name); if (Directory.Exists(tempToolPath)) { tempToolPath = DirectoryEx.GetUniqueName(tempToolPath); } using (new TemporaryDirectory(tempToolPath)) { if (Directory.Exists(pathToZip)) { DirectoryCopy(pathToZip, tempToolPath); } else { using (var zipFile = new ZipFile(pathToZip)) { try { zipFile.ExtractAll(tempToolPath, ExtractExistingFileAction.OverwriteSilently); } catch (Exception) { throw new ToolExecutionException(Resources.ConfigureToolsDlg_unpackZipTool_There_is_a_naming_conflict_in_unpacking_the_zip__Tool_importing_canceled_); } } } var dirInfo = new DirectoryInfo(tempToolPath); if (!dirInfo.Exists) { // Case where they try to load tools from an empty zipfile then the folder is never created. dirInfo.Create(); } var toolInfDir = new DirectoryInfo(Path.Combine(tempToolPath, TOOL_INF)); if (!toolInfDir.Exists) { throw new ToolExecutionException(TextUtil.LineSeparate( Resources.ToolInstaller_UnpackZipTool_The_selected_zip_file_is_not_an_installable_tool_, string.Format(Resources.ToolInstaller_UnpackZipTool_Error__It_does_not_contain_the_required__0__directory_, TOOL_INF))); } // Handle info.properties var toolInfo = GetToolInfo(toolInfDir, retval); if (!HandleAnnotations(unpackSupport.ShouldOverwriteAnnotations, toolInfDir)) { return(null); } HandleLegacyQuaSAR(toolInfo); var toolsToBeOverwritten = GetToolsToBeOverwritten(toolInfo.PackageIdentifier); List <ReportOrViewSpec> newReports; var existingReports = FindReportConflicts(toolInfDir, tempToolPath, out newReports); bool?overwrite = IsOverwrite(unpackSupport.ShouldOverwrite, toolsToBeOverwritten, existingReports, toolInfo); if (!overwrite.HasValue) { // User canceled installation. return(null); } string DirectoryToRemove = null; if (overwrite.Value) { // Delete the tools and their containing folder if (toolsToBeOverwritten.Count > 0) { foreach (var tool in toolsToBeOverwritten) { Settings.Default.ToolList.Remove(tool); } // The tools are all guarenteed to be from the same directory by GetToolsToBeOverwritten // and all toolDescriptions in a directory come from the same installation DirectoryToRemove = toolsToBeOverwritten.First().ToolDirPath; } // Overwrite all existing reports. foreach (ReportOrViewSpec item in existingReports) { ReportSharing.SaveReport(PersistedViews.ExternalToolsGroup, item); } } // Add all new reports. foreach (ReportOrViewSpec item in newReports) { ReportSharing.SaveReport(PersistedViews.ExternalToolsGroup, item); } var reportRenameMapping = new Dictionary <string, string>(); if (overwrite == false) // Dont overwrite so rename reports. { // Deal with renaming reports! foreach (ReportOrViewSpec item in existingReports) { string oldname = item.GetKey(); string newname = GetUniqueReportName(oldname); reportRenameMapping.Add(oldname, newname); ReportSharing.SaveReportAs(PersistedViews.ExternalToolsGroup, item, newname); } } foreach (FileInfo file in toolInfDir.GetFiles(@"*.properties")) { // We will replace the tool Directory value (null below) later when we know the import is sucessful. AddToolFromProperties(file, retval, toolInfo, null, tempToolPath, reportRenameMapping); } // Check if we need to install a program if (retval.Installations.Count > 0) { foreach (var ppc in retval.Installations.Keys) { string pathToPackageInstallScript = null; if (ppc.ProgramName.Equals(@"R") && retval.Installations[ppc].Count != 0) { pathToPackageInstallScript = Path.Combine(tempToolPath, TOOL_INF, INSTALL_R_PACKAGES); if (!File.Exists(pathToPackageInstallScript)) { throw new ToolExecutionException(TextUtil.LineSeparate(string.Format(Resources.ToolInstaller_UnpackZipTool_Error__There_is_a_file_missing_the__0__zip, name), string.Empty, string.Format(Resources.ToolInstaller_UnpackZipTool_Tool_Uses_R_and_specifies_Packages_without_an__0__file_in_the_tool_inf_directory_, INSTALL_R_PACKAGES))); } } string path = unpackSupport.InstallProgram(ppc, retval.Installations[ppc], pathToPackageInstallScript); if (path == null) { // Cancel installation return(null); } else if (path != string.Empty) { if (Settings.Default.ToolFilePaths.ContainsKey(ppc)) { Settings.Default.ToolFilePaths.Remove(ppc); } Settings.Default.ToolFilePaths.Add(ppc, path); } } } // We don't decide the final toolDirPath until we make it to here. // This will require some fixing of the tooldir and path to dll in each of the tools in retval.validtoolsfound // It also enables us to not delete the tools from the tool list unless we have a sucessful installation. // Decide the permToolPath. if (DirectoryToRemove != null) { DirectoryEx.SafeDelete(DirectoryToRemove); } // Final Directory Location. string permToolPath = DirectoryEx.GetUniqueName(Path.Combine(outerToolsFolderPath, name)); foreach (var tool in retval.ValidToolsFound) { tool.ToolDirPath = permToolPath; if (!string.IsNullOrEmpty(tool.ArgsCollectorDllPath)) { tool.ArgsCollectorDllPath = Path.Combine(permToolPath, tool.ArgsCollectorDllPath); } Settings.Default.ToolList.Add(tool); } if (retval.ValidToolsFound.Count != 0) { Helpers.TryTwice(() => Directory.Move(tempToolPath, permToolPath)); } } return(retval); }
public void WatersMultiReplicateTest() { var testFilesDir = new TestFilesDir(TestContext, ZIP_FILE); string docPath; SrmDocument docOriginal = InitWatersDocument(testFilesDir, out docPath); SrmDocument doc = docOriginal; var listCachePaths = new List <string>(); using (var docContainer = new ResultsTestDocumentContainer(doc, docPath)) { string extRaw = ExtensionTestContext.ExtWatersRaw; string[] replicatePaths = { testFilesDir.GetTestPath("160109_Mix1_calcurve_070.mzML"), testFilesDir.GetTestPath("160109_Mix1_calcurve_073.mzML"), testFilesDir.GetTestPath("160109_Mix1_calcurve_075" + extRaw), testFilesDir.GetTestPath("160109_Mix1_calcurve_078.mzML") }; // Count peaks where higher concentration replicates show less area int outOfOrder = 0; foreach (string path in replicatePaths) { var listChromatograms = new List <ChromatogramSet>(); if (doc.Settings.HasResults) { listChromatograms.AddRange(doc.Settings.MeasuredResults.Chromatograms); } string name = Path.GetFileNameWithoutExtension(path); if (name != null) { name = name.Substring(name.Length - 12); } listChromatograms.Add(new ChromatogramSet(name, new[] { MsDataFileUri.Parse(path) })); int len = listChromatograms.Count; var docResults = doc.ChangeMeasuredResults(doc.Settings.MeasuredResults != null ? doc.Settings.MeasuredResults.ChangeChromatograms(listChromatograms) : new MeasuredResults(listChromatograms)); // Adding unloaded results should add a new null result. foreach (var nodeTran in docResults.PeptideTransitions) { Assert.IsTrue(nodeTran.HasResults); Assert.AreEqual(listChromatograms.Count, nodeTran.Results.Count); Assert.IsTrue(nodeTran.Results[len - 1].IsEmpty); } Assert.IsTrue(docContainer.SetDocument(docResults, doc, true), string.Format("Failed adding results for {0}.", path)); docContainer.AssertComplete(); docResults = docContainer.Document; Assert.IsTrue(docResults.Settings.MeasuredResults.IsLoaded); var transOld = doc.PeptideTransitions.ToArray(); var transNew = docResults.PeptideTransitions.ToArray(); Assert.AreEqual(transOld.Length, transNew.Length); int countPeaks = 0; for (int i = 0; i < transNew.Length; i++) { // Make sure new peak was added to each transition var nodeTranNew = transNew[i]; Assert.IsTrue(nodeTranNew.HasResults); Assert.AreEqual(len, nodeTranNew.Results.Count); var chromInfo = nodeTranNew.Results[len - 1][0]; Assert.IsNotNull(chromInfo); if (!chromInfo.IsEmpty) { countPeaks++; } // Make sure previously loaded peaks did not change for (int j = 0; j < len - 1; j++) { var chromInfoPrevious = transOld[i].Results[j][0]; Assert.AreSame(chromInfoPrevious, nodeTranNew.Results[j][0]); if ((chromInfo.IsEmpty && !chromInfoPrevious.IsEmpty) || (!chromInfo.IsEmpty && chromInfoPrevious.Area >= chromInfo.Area)) { outOfOrder++; } } } // Allow 2 missed peaks Assert.IsTrue(countPeaks >= transNew.Length - (TestSmallMolecules ? 1 : 0) - 2); // Check results calculations for peptides and groups foreach (var nodePep in docResults.Peptides) { Assert.AreEqual(len, nodePep.Results.Count); Assert.IsTrue(nodePep.HasResults); var chromInfo = nodePep.Results[len - 1][0]; Assert.AreEqual(1, nodePep.Children.Count); var nodeGroup = (TransitionGroupDocNode)nodePep.Children[0]; Assert.IsTrue(nodeGroup.HasResults); Assert.AreEqual(len, nodeGroup.Results.Count); var chromInfoGroup = nodeGroup.Results[len - 1][0]; Assert.IsTrue(chromInfoGroup.PeakCountRatio >= 0.5); Assert.IsTrue(chromInfoGroup.RetentionTime.HasValue); Assert.IsTrue(chromInfoGroup.Area.HasValue && chromInfoGroup.Area > 290); Assert.AreEqual(chromInfo.RetentionTime, chromInfoGroup.RetentionTime); Assert.AreEqual(chromInfo.PeakCountRatio, chromInfoGroup.PeakCountRatio); } doc = docResults; } Assert.AreEqual(13, outOfOrder, 1); // Remove the original data foreach (string path in replicatePaths) { if (File.Exists(path)) { FileEx.SafeDelete(path); } else { DirectoryEx.SafeDelete(path); } } FileEx.SafeDelete(docPath); // Save the document string xmlSaved = null; var docPersisted = AssertEx.RoundTrip(doc, ref xmlSaved); Assert.IsTrue(!docPersisted.Settings.MeasuredResults.IsLoaded); // Make sure the persisted document round-trips. // The orginal doesn't because of changing precision in the results info. AssertEx.Serializable(docPersisted, AssertEx.DocumentCloned); // Make sure the loaded document has reasonable results info // before the cache files are loaded for (int i = 0; i < doc.Children.Count; i++) { PeptideGroupDocNode nodePepGroup1 = (PeptideGroupDocNode)doc.Children[i]; if (TestSmallMolecules && nodePepGroup1.Name.Equals(SrmDocument.TestingNonProteomicMoleculeGroupName)) { continue; } PeptideGroupDocNode nodePepGroup2 = (PeptideGroupDocNode)docPersisted.Children[i]; Assert.AreNotSame(nodePepGroup1, nodePepGroup2); for (int j = 0; j < nodePepGroup1.Children.Count; j++) { PeptideDocNode nodePep1 = (PeptideDocNode)nodePepGroup1.Children[j]; PeptideDocNode nodePep2 = (PeptideDocNode)nodePepGroup2.Children[j]; Assert.AreNotSame(nodePep1, nodePep2); Assert.AreEqual(nodePep1.Results.Count, nodePep2.Results.Count); for (int k = 0; k < nodePep1.Results.Count; k++) { Assert.AreEqual(nodePep1.Results[k][0].PeakCountRatio, nodePep2.Results[k][0].PeakCountRatio); } for (int k = 0; k < nodePep1.Children.Count; k++) { TransitionGroupDocNode nodeGroup1 = (TransitionGroupDocNode)nodePep1.Children[k]; TransitionGroupDocNode nodeGroup2 = (TransitionGroupDocNode)nodePep2.Children[k]; Assert.AreNotSame(nodeGroup1, nodeGroup2); Assert.AreEqual(nodeGroup1.Results.Count, nodeGroup2.Results.Count); for (int l = 0; l < nodeGroup1.Results.Count; l++) { Assert.AreEqual(nodeGroup1.Results[l][0].PeakCountRatio, nodeGroup2.Results[l][0].PeakCountRatio); } for (int l = 0; l < nodeGroup1.Children.Count; l++) { TransitionDocNode nodeTran1 = (TransitionDocNode)nodeGroup1.Children[l]; TransitionDocNode nodeTran2 = (TransitionDocNode)nodeGroup2.Children[l]; Assert.AreNotSame(nodeTran1, nodeTran2); Assert.AreEqual(nodeTran1.Results.Count, nodeTran2.Results.Count); for (int m = 0; m < nodeTran1.Results.Count; m++) { if (!nodeTran1.Results[m].IsEmpty && !nodeTran2.Results[m].IsEmpty) { Assert.AreEqual(nodeTran1.Results[m][0].IsEmpty, nodeTran2.Results[m][0].IsEmpty); } else { Assert.AreEqual(nodeTran1.Results[m], nodeTran2.Results[m]); // both null } } } } } } // Reload data from .skyd files Assert.IsTrue(docContainer.SetDocument(docPersisted, doc, true)); docContainer.AssertComplete(); doc = docContainer.Document; var results = doc.Settings.MeasuredResults; const float tolerance = (float)TransitionInstrument.DEFAULT_MZ_MATCH_TOLERANCE; foreach (var pair in doc.PeptidePrecursorPairs) { foreach (var chromSet in results.Chromatograms) { ChromatogramGroupInfo[] chromGroupInfo; Assert.IsTrue(results.TryLoadChromatogram(chromSet, pair.NodePep, pair.NodeGroup, tolerance, true, out chromGroupInfo)); } } // The single final cache path should be open now listCachePaths.AddRange(doc.Settings.MeasuredResults.CachePaths); // Should only have one cache file at this point Assert.AreEqual(1, listCachePaths.Count); foreach (var cachePath in listCachePaths) { // Attempting to delete should throw string path = cachePath; AssertEx.ThrowsException <IOException>(() => FileEx.SafeDelete(path)); } } foreach (var cachePath in listCachePaths) { // Cache files should be closed now, and delete successfully. FileEx.SafeDelete(cachePath); } testFilesDir.Dispose(); }