public void ProteinListTest()
{
// Too few columns
const char sep = TextUtil.SEPARATOR_TSV;
AssertEx.ThrowsException <LineColNumberedIoException>(() =>
FastaImporter.ToFasta("PROT1\nPROT2\nPROT2", sep));
// Invalid sequence
string invalidSeq = PROTEINLIST_CLIPBOARD_TEXT.Replace("MDAL", "***");
AssertEx.ThrowsException <LineColNumberedIoException>(() =>
FastaImporter.ToFasta(invalidSeq, sep));
string fastaText = FastaImporter.ToFasta(PROTEINLIST_CLIPBOARD_TEXT, sep);
var reader = new StringReader(fastaText);
int countProt = 0;
string line;
while ((line = reader.ReadLine()) != null)
{
if (line.StartsWith(">"))
{
countProt++;
}
else
{
Assert.IsTrue(FastaSequence.IsExSequence(line.Trim('*')));
}
}
Assert.AreEqual(3, countProt);
}
public static bool ValidateRow(object[] columns, IWin32Window parent, int lineNumber, bool postiveTime)
{
if (columns.Length != 2)
{
MessageDlg.Show(parent, string.Format(Resources.PeptideGridViewDriver_ValidateRow_The_pasted_text_must_have_two_columns_));
return(false);
}
string seq = columns[COLUMN_SEQUENCE] as string;
string time = columns[COLUMN_TIME] as string;
string message = null;
if (string.IsNullOrWhiteSpace(seq))
{
message = string.Format(Resources.PeptideGridViewDriver_ValidateRow_Missing_peptide_sequence_on_line__0_, lineNumber);
}
else if (!FastaSequence.IsExSequence(seq))
{
message = string.Format(Resources.PeptideGridViewDriver_ValidateRow_The_text__0__is_not_a_valid_peptide_sequence_on_line__1_, seq, lineNumber);
}
else
{
try
{
columns[COLUMN_SEQUENCE] = SequenceMassCalc.NormalizeModifiedSequence(seq);
}
catch (Exception x)
{
message = x.Message;
}
if (message == null)
{
double dTime;
if (string.IsNullOrWhiteSpace(time))
{
message = string.Format(Resources.PeptideGridViewDriver_ValidateRow_Missing_value_on_line__0_, lineNumber);
}
else if (!double.TryParse(time, out dTime))
{
message = string.Format(Resources.PeptideGridViewDriver_ValidateRow_Invalid_decimal_number_format__0__on_line__1_, time, lineNumber);
}
else if (postiveTime && dTime <= 0)
{
message = string.Format(Resources.PeptideGridViewDriver_ValidateRow_The_time__0__must_be_greater_than_zero_on_line__1_, time, lineNumber);
}
else
{
return(true);
}
}
}
MessageDlg.Show(parent, message);
return(false);
}
public static string ValidateSequence(string sequence)
{
if (sequence == null)
{
return(Resources.ValidatingIonMobilityPeptide_ValidateSequence_A_modified_peptide_sequence_is_required_for_each_entry_);
}
if (!FastaSequence.IsExSequence(sequence))
{
return(string.Format(Resources.ValidatingIonMobilityPeptide_ValidateSequence_The_sequence__0__is_not_a_valid_modified_peptide_sequence_, sequence));
}
return(null);
}
public static string ValidateSequence(Target sequence)
{
if (sequence.IsEmpty || !sequence.IsProteomic)
{
return(Resources.MeasuredPeptide_ValidateSequence_A_modified_peptide_sequence_is_required_for_each_entry);
}
if (!FastaSequence.IsExSequence(sequence.Sequence))
{
return(string.Format(Resources.MeasuredPeptide_ValidateSequence_The_sequence__0__is_not_a_valid_modified_peptide_sequence, sequence));
}
return(null);
}
public static string ValidateSequence(string sequenceText)
{
if (string.IsNullOrWhiteSpace(sequenceText))
{
return(Resources.LibraryGridViewDriver_ValidateSequence_Sequence_cannot_be_empty_);
}
if (!FastaSequence.IsExSequence(Transition.StripChargeIndicators(sequenceText, TransitionGroup.MIN_PRECURSOR_CHARGE, TransitionGroup.MAX_PRECURSOR_CHARGE)))
{
return(string.Format(Resources.EditOptimizationLibraryDlg_ValidateOptimizationList_The_value__0__is_not_a_valid_modified_peptide_sequence_, sequenceText));
}
return(null);
}
private bool ValidatePeptideList(IEnumerable <ValidatingIonMobilityPeptide> peptideList, string tableName)
{
foreach (ValidatingIonMobilityPeptide peptide in peptideList)
{
string seqModified = peptide.PeptideModSeq;
// CONSIDER: Select the peptide row
if (!FastaSequence.IsExSequence(seqModified))
{
MessageDlg.Show(this, string.Format(Resources.EditIonMobilityLibraryDlg_ValidatePeptideList_The_value__0__is_not_a_valid_modified_peptide_sequence_,
seqModified));
return(false);
}
}
return(true);
}
public static string ValidateMeasuredDriftTimeCellValues(string[] values)
{
int tempInt;
double tempDouble;
if (values.Count() < 3)
{
return(Resources.MeasuredDriftTimeTable_ValidateMeasuredDriftTimeCellValues_The_pasted_text_must_have_three_columns_);
}
// Parse sequence
var sequence = values[EditDriftTimePredictorDlg.COLUMN_SEQUENCE];
if (string.IsNullOrEmpty(sequence))
{
return(Resources.MeasuredDriftTimeTable_ValidateMeasuredDriftTimeCellValues_A_modified_peptide_sequence_is_required_for_each_entry_);
}
if (!FastaSequence.IsExSequence(sequence))
{
return(string.Format(Resources.MeasuredDriftTimeTable_ValidateMeasuredDriftTimeCellValues_The_sequence__0__is_not_a_valid_modified_peptide_sequence_, sequence));
}
try
{
values[EditDriftTimePredictorDlg.COLUMN_SEQUENCE] = SequenceMassCalc.NormalizeModifiedSequence(sequence);
}
catch (Exception x)
{
return(x.Message);
}
// Parse charge
if ((!int.TryParse(values[EditDriftTimePredictorDlg.COLUMN_CHARGE].Trim(), out tempInt)) || ValidateCharge(tempInt) != null)
{
return(string.Format(Resources.EditDriftTimePredictorDlg_ValidateCharge_The_entry__0__is_not_a_valid_charge__Precursor_charges_must_be_integer_values_between_1_and__1__,
values[EditDriftTimePredictorDlg.COLUMN_CHARGE].Trim(), TransitionGroup.MAX_PRECURSOR_CHARGE));
}
// Parse drift time
if (!double.TryParse(values[EditDriftTimePredictorDlg.COLUMN_DRIFT_TIME_MSEC].Trim(), out tempDouble))
{
return(string.Format(Resources.MeasuredDriftTimeTable_ValidateMeasuredDriftTimeCellValues_The_value__0__is_not_a_valid_drift_time_, values[EditDriftTimePredictorDlg.COLUMN_DRIFT_TIME_MSEC].Trim()));
}
return(null);
}
private void VerifyReportFile(string fileName, int rowCount, IList <string> columnNames, bool invariantFormat = false)
{
var formatProvider = invariantFormat ? CultureInfo.InvariantCulture : CultureInfo.CurrentCulture;
string[] lines = File.ReadAllLines(fileName);
Assert.AreEqual(rowCount, lines.Length - 1);
string[] columnHeaderNames = lines[0].ParseCsvFields();
Assert.IsTrue(ArrayUtil.EqualsDeep(columnNames, columnHeaderNames));
for (int i = 1; i < lines.Length; i++)
{
string[] values = lines[i].ParseCsvFields();
for (int j = 0; j < columnHeaderNames.Length; j++)
{
string columnName = columnNames[j];
string value = values[j];
if (columnName.Equals("PeptideSequence"))
{
Assert.IsTrue(FastaSequence.IsExSequence(value) || (TestSmallMolecules && value.StartsWith("zzz")));
}
else if (columnName.StartsWith("Cv"))
{
Assert.IsTrue(TestSmallMolecules || invariantFormat || value.EndsWith("%"));
Assert.IsTrue(TestSmallMolecules || double.Parse(value.Substring(0, value.Length - 1), NumberStyles.Float, formatProvider) > 0);
}
else if (!columnName.Equals("ProteinName"))
{
double valueParsed;
if (!double.TryParse(value, NumberStyles.Float, formatProvider, out valueParsed))
{
if (!(TestSmallMolecules && value == TextUtil.EXCEL_NA))
{
Assert.Fail("Failed parsing {0} as a double", value);
}
}
else
{
Assert.IsTrue(valueParsed > 0);
}
}
}
}
}
public static CrosslinkLibraryKey ParseCrosslinkLibraryKey(string str, int charge)
{
List <PeptideLibraryKey> peptideSequences = new List <PeptideLibraryKey>();
List <CrosslinkLibraryKey.Crosslink> crosslinks = new List <CrosslinkLibraryKey.Crosslink>();
bool inCrosslinkers = false;
int ich = 0;
foreach (var token in Tokenize(str))
{
if (token.StartsWith(@"[") && token.EndsWith(@"]"))
{
inCrosslinkers = true;
}
if (inCrosslinkers)
{
crosslinks.Add(ParseCrosslink(token, ich));
}
else
{
string sequence = token;
if (sequence.EndsWith(@"-"))
{
sequence = sequence.Substring(sequence.Length - 1);
}
if (!FastaSequence.IsExSequence(sequence))
{
throw CommonException.Create(new ParseExceptionDetail(Resources.CrosslinkSequenceParser_ParseCrosslinkLibraryKey_Invalid_peptide_sequence, ich));
}
peptideSequences.Add(new PeptideLibraryKey(sequence, 0));
}
ich += token.Length;
}
return(new CrosslinkLibraryKey(peptideSequences, crosslinks, charge));
}
private bool TryMakePeptide(out Peptide peptide)
{
peptide = null;
if (cbxLooplink.Checked)
{
return(true);
}
var messageBoxHelper = new MessageBoxHelper(this);
var peptideSequence = tbxPeptideSequence.Text.Trim();
if (string.IsNullOrEmpty(peptideSequence))
{
messageBoxHelper.ShowTextBoxError(tbxPeptideSequence, Resources.PasteDlg_ListPeptideSequences_The_peptide_sequence_cannot_be_blank);
return(false);
}
if (!FastaSequence.IsExSequence(peptideSequence))
{
messageBoxHelper.ShowTextBoxError(tbxPeptideSequence, Resources.PasteDlg_ListPeptideSequences_This_peptide_sequence_contains_invalid_characters);
return(false);
}
peptide = new Peptide(peptideSequence);
return(true);
}
public void OkDialog()
{
var reader = new StringReader(PeptidesText);
var invalidLines = new List <string>();
var notFoundLines = new List <string>();
var acceptedPeptides = new List <LibraryKey>();
var peptideSequences = GetPeptideSequences();
string line;
while ((line = reader.ReadLine()) != null)
{
line = line.Trim();
if (string.IsNullOrEmpty(line))
{
continue;
}
int foundAt;
var charge = Transition.GetChargeFromIndicator(line,
TransitionGroup.MIN_PRECURSOR_CHARGE, TransitionGroup.MAX_PRECURSOR_CHARGE, out foundAt);
if (!charge.IsEmpty)
{
line = line.Substring(0, foundAt);
}
Target target;
try
{
// CONSIDER(bspratt) small molecule equivalent?
if (!FastaSequence.IsExSequence(line))
{
invalidLines.Add(line);
continue;
}
line = SequenceMassCalc.NormalizeModifiedSequence(line);
target = new Target(line);
}
catch (Exception)
{
invalidLines.Add(line);
continue;
}
if (!peptideSequences.ContainsKey(target))
{
notFoundLines.Add(line);
}
else
{
acceptedPeptides.Add(new LibKey(target, charge).LibraryKey);
}
}
if (invalidLines.Count > 0)
{
if (invalidLines.Count == 1)
{
MessageDlg.Show(this, string.Format(Resources.RefineListDlg_OkDialog_The_sequence__0__is_not_a_valid_peptide, invalidLines[0]));
}
else
{
MessageDlg.Show(this, TextUtil.LineSeparate(Resources.RefineListDlg_OkDialog_The_following_sequences_are_not_valid_peptides, string.Empty, TextUtil.LineSeparate(invalidLines)));
}
return;
}
if (acceptedPeptides.Count == 0)
{
MessageDlg.Show(this, Resources.RefineListDlg_OkDialog_None_of_the_specified_peptides_are_in_the_document);
return;
}
if (notFoundLines.Count > 0)
{
string message;
if (notFoundLines.Count == 1)
{
message = string.Format(Resources.RefineListDlg_OkDialog_The_peptide__0__is_not_in_the_document_Do_you_want_to_continue, notFoundLines[0]);
}
else if (notFoundLines.Count < 15)
{
message = TextUtil.LineSeparate(Resources.RefineListDlg_OkDialog_The_following_peptides_are_not_in_the_document, string.Empty,
TextUtil.LineSeparate(notFoundLines), string.Empty,
Resources.RefineListDlg_OkDialog_Do_you_want_to_continue);
}
else
{
message = string.Format(Resources.RefineListDlg_OkDialog_Of_the_specified__0__peptides__1__are_not_in_the_document_Do_you_want_to_continue,
notFoundLines.Count + acceptedPeptides.Count, notFoundLines.Count);
}
if (MultiButtonMsgDlg.Show(this, message, MultiButtonMsgDlg.BUTTON_OK) != DialogResult.OK)
{
return;
}
}
AcceptedPeptides = acceptedPeptides.ToArray();
DialogResult = DialogResult.OK;
}
public static string ValidateMeasuredDriftTimeCellValues(string[] values)
{
Adduct tempAdduct;
double tempDouble;
if (values.Length < 3)
{
return(Resources.MeasuredDriftTimeTable_ValidateMeasuredDriftTimeCellValues_The_pasted_text_must_have_three_columns_);
}
// Parse sequence
var sequence = values[EditDriftTimePredictorDlg.COLUMN_SEQUENCE];
if (string.IsNullOrEmpty(sequence))
{
return(Resources.MeasuredDriftTimeTable_ValidateMeasuredDriftTimeCellValues_A_modified_peptide_sequence_is_required_for_each_entry_);
}
if (!FastaSequence.IsExSequence(sequence))
{
return(string.Format(Resources.MeasuredDriftTimeTable_ValidateMeasuredDriftTimeCellValues_The_sequence__0__is_not_a_valid_modified_peptide_sequence_, sequence));
}
try
{
values[EditDriftTimePredictorDlg.COLUMN_SEQUENCE] = SequenceMassCalc.NormalizeModifiedSequence(sequence);
}
catch (Exception x)
{
return(x.Message);
}
// Parse charge
if ((!Adduct.TryParse(values[EditDriftTimePredictorDlg.COLUMN_CHARGE].Trim(), out tempAdduct)) || ValidateCharge(tempAdduct) != null)
{
return(string.Format(Resources.EditDriftTimePredictorDlg_ValidateCharge_The_entry__0__is_not_a_valid_charge__Precursor_charges_must_be_integer_values_between_1_and__1__,
values[EditDriftTimePredictorDlg.COLUMN_CHARGE].Trim(), TransitionGroup.MAX_PRECURSOR_CHARGE));
}
// Parse drift time
if (!double.TryParse(values[EditDriftTimePredictorDlg.COLUMN_ION_MOBILITY].Trim(), out tempDouble))
{
return(string.Format(Resources.MeasuredDriftTimeTable_ValidateMeasuredDriftTimeCellValues_The_value__0__is_not_a_valid_drift_time_, values[EditDriftTimePredictorDlg.COLUMN_ION_MOBILITY].Trim()));
}
if (values.Length > EditDriftTimePredictorDlg.COLUMN_CCS)
{
// Parse CCS, if any
if (!string.IsNullOrEmpty(values[EditDriftTimePredictorDlg.COLUMN_CCS]) &&
!double.TryParse(values[EditDriftTimePredictorDlg.COLUMN_CCS].Trim(), out tempDouble))
{
return(string.Format(Resources.MeasuredDriftTimeTable_ValidateMeasuredDriftTimeCellValues_The_value__0__is_not_a_valid_collisional_cross_section_, values[EditDriftTimePredictorDlg.COLUMN_CCS].Trim()));
}
}
if (values.Length > EditDriftTimePredictorDlg.COLUMN_HIGH_ENERGY_OFFSET)
{
// Parse high energy offset, if any
if (!string.IsNullOrEmpty(values[EditDriftTimePredictorDlg.COLUMN_HIGH_ENERGY_OFFSET]) &&
!double.TryParse(values[EditDriftTimePredictorDlg.COLUMN_HIGH_ENERGY_OFFSET].Trim(), out tempDouble))
{
return(string.Format(Resources.MeasuredDriftTimeTable_ValidateMeasuredDriftTimeCellValues_The_value__0__is_not_a_valid_high_energy_offset_, values[EditDriftTimePredictorDlg.COLUMN_HIGH_ENERGY_OFFSET].Trim()));
}
}
return(null);
}
public static string ValidateRow(object[] columns, int lineNumber)
{
if (columns.Length < 2)
{
return(Resources.CollisionalCrossSectionGridViewDriverBase_ValidateRow_The_pasted_text_must_have_at_least_two_columns_);
}
string seq = columns[EditIonMobilityLibraryDlg.COLUMN_SEQUENCE] as string;
string collisionalcrosssection = columns[EditIonMobilityLibraryDlg.COLUMN_COLLISIONAL_CROSS_SECTION] as string;
string highenergydrifttimeoffset = (columns.Length > 2) ? columns[EditIonMobilityLibraryDlg.COLUMN_HIGH_ENERGY_DRIFT_TIME_OFFSET_MSEC] as string : string.Empty;
string message = null;
if (string.IsNullOrWhiteSpace(seq))
{
message = string.Format(Resources.CollisionalCrossSectionGridViewDriverBase_ValidateRow_Missing_peptide_sequence_on_line__0__, lineNumber);
}
else if (!FastaSequence.IsExSequence(seq))
{
message = string.Format(Resources.CollisionalCrossSectionGridViewDriverBase_ValidateRow_The_text__0__is_not_a_valid_peptide_sequence_on_line__1__, seq, lineNumber);
}
else
{
try
{
columns[EditIonMobilityLibraryDlg.COLUMN_SEQUENCE] = SequenceMassCalc.NormalizeModifiedSequence(seq);
}
catch (Exception x)
{
message = x.Message;
}
if (message == null)
{
double dCollisionalCrossSection;
if (string.IsNullOrWhiteSpace(collisionalcrosssection))
{
message = string.Format(Resources.CollisionalCrossSectionGridViewDriverBase_ValidateRow_Missing_collisional_cross_section_value_on_line__0__, lineNumber);
}
else if (!double.TryParse(collisionalcrosssection, out dCollisionalCrossSection))
{
message = string.Format(Resources.CollisionalCrossSectionGridViewDriverBase_ValidateRow_Invalid_number_format__0__for_collisional_cross_section_on_line__1__,
collisionalcrosssection,
lineNumber);
}
else if (dCollisionalCrossSection <= 0)
{
message =
string.Format(Resources.CollisionalCrossSectionGridViewDriverBase_ValidateRow_The_collisional_cross_section__0__must_be_greater_than_zero_on_line__1__,
dCollisionalCrossSection,
lineNumber);
}
}
if (message == null)
{
double dHighEnergyDriftTimeOffsetMsec;
if (!string.IsNullOrWhiteSpace(highenergydrifttimeoffset) && !double.TryParse(highenergydrifttimeoffset, out dHighEnergyDriftTimeOffsetMsec))
{
message = string.Format(Resources.CollisionalCrossSectionGridViewDriverBase_ValidateRow_Invalid_number_format__0__for_high_energy_drift_time_offset_on_line__1__,
highenergydrifttimeoffset,
lineNumber);
}
}
}
return(message);
}
private static void ValidateDecoys(SrmDocument document, SrmDocument decoysDoc, bool modifiesSequences)
{
AssertEx.IsDocumentState(decoysDoc, 1, document.PeptideGroupCount + 1, document.PeptideCount * 2,
document.PeptideTransitionGroupCount * 2, document.PeptideTransitionCount * 2);
// Check for the existence of the Decoys peptide group and that everything under it is marked as a decoy.
var nodePeptideGroupDecoy = decoysDoc.PeptideGroups.Single(nodePeptideGroup => nodePeptideGroup.IsDecoy);
var dictModsToPep = document.Peptides.ToDictionary(nodePep => nodePep.ModifiedSequence);
foreach (var nodePep in nodePeptideGroupDecoy.Peptides)
{
Assert.AreEqual(true, nodePep.IsDecoy);
PeptideDocNode nodePepSource = null;
if (!modifiesSequences)
{
Assert.IsNull(nodePep.SourceKey);
}
else
{
Assert.IsNotNull(nodePep.SourceKey, string.Format("Source key for {0}{1} is null", nodePep.ModifiedSequence,
nodePep.IsDecoy ? " - decoy" : string.Empty));
Assert.IsTrue(FastaSequence.IsExSequence(nodePep.SourceKey.Sequence));
Assert.AreEqual(nodePep.SourceKey.ModifiedSequence,
SequenceMassCalc.NormalizeModifiedSequence(nodePep.SourceKey.ModifiedSequence));
if (nodePep.HasExplicitMods)
{
Assert.IsNotNull(nodePep.SourceKey.ExplicitMods);
}
Assert.IsTrue(dictModsToPep.TryGetValue(nodePep.SourceTextId, out nodePepSource));
var sourceKey = new ModifiedSequenceMods(nodePepSource.Peptide.Sequence, nodePepSource.ExplicitMods);
Assert.AreEqual(sourceKey.ExplicitMods, nodePep.SourceExplicitMods);
}
for (int i = 0; i < nodePep.TransitionGroupCount; i++)
{
var nodeGroup = nodePep.TransitionGroups.ElementAt(i);
Assert.AreEqual(true, nodeGroup.IsDecoy);
TransitionGroupDocNode nodeGroupSource = null;
double shift = SequenceMassCalc.GetPeptideInterval(nodeGroup.TransitionGroup.DecoyMassShift);
if (nodePepSource != null && nodeGroup.TransitionGroup.DecoyMassShift.HasValue)
{
nodeGroupSource = nodePepSource.TransitionGroups.ElementAt(i);
Assert.AreEqual(nodeGroupSource.PrecursorMz + shift, nodeGroup.PrecursorMz, SequenceMassCalc.MassTolerance);
}
for (int j = 0; j < nodeGroup.TransitionCount; j++)
{
var nodeTran = nodeGroup.Transitions.ElementAt(j);
Assert.IsTrue(nodeTran.IsDecoy);
if (nodeTran.Transition.IsPrecursor())
{
Assert.AreEqual(nodeGroup.TransitionGroup.DecoyMassShift, nodeTran.Transition.DecoyMassShift);
if (nodeGroupSource != null)
{
Assert.AreEqual(nodeGroupSource.Transitions.ElementAt(j).Mz + shift, nodeTran.Mz, SequenceMassCalc.MassTolerance);
}
}
}
}
}
// Check that the resulting document persists correctly by passing the SrmDocument to AssertEx.IsSerializable().
AssertEx.Serializable(decoysDoc);
}
