ProteoWizard
IOTest.cpp
Go to the documentation of this file.
1 //
2 // $Id: IOTest.cpp 5759 2014-02-19 22:26:29Z chambm $
3 //
4 //
5 // Original author: Robert Burke <robert.burke@proteowizard.org>
6 //
7 // Copyright 2009 Spielberg Family Center for Applied Proteomics
8 // University of Southern California, Los Angeles, California 90033
9 //
10 // Licensed under the Apache License, Version 2.0 (the "License");
11 // you may not use this file except in compliance with the License.
12 // You may obtain a copy of the License at
13 //
14 // http://www.apache.org/licenses/LICENSE-2.0
15 //
16 // Unless required by applicable law or agreed to in writing, software
17 // distributed under the License is distributed on an "AS IS" BASIS,
18 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
19 // See the License for the specific language governing permissions and
20 // limitations under the License.
21 //
22 
23 
24 #include "IO.hpp"
25 #include "Diff.hpp"
26 #include "TextWriter.hpp"
27 #include "examples.hpp"
30 
31 using namespace pwiz::util;
32 using namespace pwiz::minimxml;
33 using namespace pwiz::cv;
34 using namespace pwiz::identdata;
35 namespace proteome = pwiz::proteome;
36 using boost::iostreams::stream_offset;
37 
38 ostream* os_ = 0;
39 
40 template <typename object_type>
41 void testObject(const object_type& a)
42 {
43  if (os_) *os_ << "testObject(): " << typeid(a).name() << endl;
44 
45  // write 'a' out to a stream
46 
47  ostringstream oss;
48  XMLWriter writer(oss);
49  IO::write(writer, a);
50  if (os_) *os_ << oss.str() << endl;
51 
52  // read 'b' in from stream
53 
54  object_type b;
55  istringstream iss(oss.str());
56  IO::read(iss, b);
57 
58  // compare 'a' and 'b'
59 
61  if (diff && os_) *os_ << "diff:\n" << diff_string<TextWriter>(diff) << endl;
62  unit_assert(!diff);
63 }
64 
65 
67 {
68  if (os_) *os_ << "testIdentifiable\n" ;
69 
70  Identifiable a;
71  a.id = "id";
72  a.name = "name";
73 
74  testObject(a);
75 }
76 
77 
79 {
80  if (os_) *os_ << "testIdentifiableParamContainer\n" ;
81 
83  a.id = "id";
84  a.name = "name";
85 
86  a.set(MS_TIC, 123);
87  a.userParams.push_back(UserParam("abc", "123", "!@#"));
88 
89  testObject(a);
90 }
91 
92 
93 void testCV()
94 {
95  if (os_) *os_ << "testCV\n" ;
96 
97  CV a;
98  a.URI = "abcd";
99  a.id = "efgh";
100  a.fullName = "ijkl";
101  a.version = "mnop";
102 
103  testObject(a);
104 }
105 
106 
108 {
109  if (os_) *os_ << "testBibliographicReference\n" ;
110 
112 
113  br.id = "id";
114  br.authors = "abcd";
115  br.publication = "efg";
116  br.publisher = "hijk";
117  br.editor = "lmnop";
118  br.year = 1984;
119  br.volume = "qrs";
120  br.issue = "tuv";
121  br.pages = "wx";
122  br.title = "yz";
123 
124  testObject(br);
125 }
126 
127 
129 {
130  if (os_) *os_ << "testPerson\n" ;
131 
132  Person a;
133 
134  a.set(MS_contact_address, "123 abc");
135  a.set(MS_contact_phone_number, "456");
136  a.set(MS_contact_email, "efg@hijk.op");
137  a.set(MS_contact_fax_number, "789");
138  a.set(MS_contact_toll_free_phone_number, "012-345-678");
139 
140  a.lastName = "tuv";
141  a.firstName = "wx";
142  a.midInitials = "yz";
143 
144  a.affiliations.push_back(OrganizationPtr(new Organization("ref")));
145 
146  testObject(a);
147 }
148 
149 
151 {
152  if (os_) *os_ << "testOrganization\n" ;
153 
154  Organization a;
155 
156  a.set(MS_contact_address, "123 abc");
157  a.set(MS_contact_phone_number, "456");
158  a.set(MS_contact_email, "efg@hijk.op");
159  a.set(MS_contact_fax_number, "789");
160  a.set(MS_contact_toll_free_phone_number, "012-345-678");
161 
162  a.parent = OrganizationPtr(new Organization("ref"));
163 
164  testObject(a);
165 }
166 
167 
169 {
170  if (os_) *os_ << "testContactRole\n" ;
171 
172  ContactRole a;
173  a.contactPtr = ContactPtr(new Contact("ref"));
175 
176  testObject(a);
177 }
178 
179 
181 {
182  if (os_) *os_ << "testProvider\n" ;
183 
184  Provider a;
185 
186  // Reduced to a previously tested object.
187  a.contactRolePtr.reset(new ContactRole(MS_role_type, ContactPtr(new Contact("abc"))));
188 
189  testObject(a);
190 }
191 
192 
194 {
195  if (os_) *os_ << "testSample\n" ;
196 
197  Sample a;
198 
199  // Reduced to a previously tested object.
200  a.contactRole.push_back(ContactRolePtr(new ContactRole(MS_software_vendor, ContactPtr(new Contact("abc")))));
201  a.contactRole.push_back(ContactRolePtr(new ContactRole(MS_programmer, ContactPtr(new Contact("def")))));
202  a.set(MS_septum);
203 
204  a.subSamples.push_back(SamplePtr(new Sample("subSample_ref")));
205 
206  testObject(a);
207 }
208 
209 
211 {
212  if (os_) *os_ << "testAnalysisSoftware\n" ;
213 
215  a.version = "abcd";
216  a.URI = "efg";
217  a.customizations = "hijk";
218  ContactRolePtr cont = ContactRolePtr(new ContactRole());
219  cont->contactPtr = ContactPtr(new Contact("ref"));
220  cont->cvid = MS_software_vendor;
221  a.contactRolePtr = cont;
223 
224  testObject(a);
225 }
226 
227 
229 {
230  if (os_) *os_ << "testAnalysisSampleCollection\n" ;
231 
233  SamplePtr b(new Sample());
234  b->subSamples.push_back(SamplePtr(new Sample("ref")));
235 
236  testObject(a);
237 }
238 
239 
241 {
242  DBSequence a;
243 
244  a.id = "id";
245  a.name = "name";
246  a.length = 3;
247  a.accession = "abc";
248  a.searchDatabasePtr = SearchDatabasePtr(new SearchDatabase("def"));
249  a.seq = "ghi";
250  a.set(MS_protein_description, "blahbitty blah blah");
251 
252  testObject(a);
253 }
254 
255 
257 {
258  Modification a;
259 
260  a.location = 1;
261  a.avgMassDelta = 1.001001;
262  a.residues.push_back('A');
263  a.residues.push_back('C');
264  a.monoisotopicMassDelta = 100.1001;
265 
267 
268  testObject(a);
269 }
270 
271 
273 {
275 
276  a.originalResidue = 'L';
277  a.replacementResidue = 'V';
278  a.location = 1;
279  a.avgMassDelta = 2.;
280  a.monoisotopicMassDelta = 3.;
281 
282  testObject(a);
283 }
284 
285 
287 {
288  Peptide a;
289 
290  a.id = "id";
291  a.name = "name";
292  a.peptideSequence = "abc";
293 
294  ModificationPtr mod(new Modification);
295  mod->location = 1;
296  a.modification.push_back(mod);
297 
298  SubstitutionModificationPtr sub(new SubstitutionModification);
299  sub->location = 2;
300  a.substitutionModification.push_back(sub);
301 
302  a.set(MS_peptide);
303 
304  testObject(a);
305 }
306 
307 
309 {
311 
312  a.dbSequences.push_back(DBSequencePtr(new DBSequence("db_id")));
313  a.peptides.push_back(PeptidePtr(new Peptide("pep_id")));
314  a.peptideEvidence.push_back(PeptideEvidencePtr(new PeptideEvidence("pe1")));
315 
316  testObject(a);
317 }
318 
319 
321 {
322  if (os_) *os_ << "testSpectrumIdentification\n" ;
323 
326  SpectrumIdentificationProtocolPtr( new SpectrumIdentificationProtocol("sip"));
328  SpectrumIdentificationListPtr(new SpectrumIdentificationList("sil"));
329  a.activityDate = "123";
330  a.inputSpectra.push_back(SpectraDataPtr(new SpectraData("is_sd")));
331  a.searchDatabase.push_back(SearchDatabasePtr(new SearchDatabase("sd_sd")));
332 
333  testObject(a);
334 }
335 
336 
338 {
339  if (os_) *os_ << "testProteinDetection\n" ;
340 
342 
343  a.id = "id";
344  a.name = "name";
345  a.proteinDetectionProtocolPtr = ProteinDetectionProtocolPtr(new ProteinDetectionProtocol("abc"));
346  a.proteinDetectionListPtr = ProteinDetectionListPtr(new ProteinDetectionList("def"));
347  a.activityDate = "ghi";
348 
349  testObject(a);
350 }
351 
352 
354 {
355  if (os_) *os_ << "testAnalysisCollection\n" ;
356 
358 
359  SpectrumIdentificationPtr b(new SpectrumIdentification());
360  b->activityDate = "abc";
361  a.spectrumIdentification.push_back(b);
362  a.proteinDetection.activityDate = "def";
363 
364  testObject(a);
365 }
366 
367 
369 {
370  if (os_) *os_ << "testSearchModification\n" ;
371 
373 
374  a.fixedMod = true;
375  a.massDelta = 3.14;
376  a.residues.push_back('Q');
377  a.residues.push_back('E');
380 
381  testObject(a);
382 }
383 
384 
386 {
387  if (os_) *os_ << "testEnzyme\n" ;
388 
389  Enzyme a;
390 
391  a.id = "id";
392  a.nTermGain = "n";
393  a.cTermGain = "c";
395  a.missedCleavages = 1;
396  a.minDistance = 2;
397 
398  a.siteRegexp = "tyrannosaurus regex";
400 
401  testObject(a);
402 }
403 
404 
406 {
407  if (os_) *os_ << "testEnzymes\n" ;
408 
409  Enzymes a;
410 
411  a.independent = "yes";
412  a.enzymes.push_back(EnzymePtr(new Enzyme()));
413  a.enzymes.back()->siteRegexp = "pxegeRetiS";
414 
415  testObject(a);
416 }
417 
418 
420 {
421  if (os_) *os_ << "testResidue\n" ;
422 
423  Residue a;
424 
425  a.code = 'A';
426  a.mass = 2;
427 
428  testObject(a);
429 }
430 
431 
433 {
434  if (os_) *os_ << "testAmbiguousResidue\n" ;
435 
437 
438  a.code = 'B';
440 
441  testObject(a);
442 }
443 
444 
446 {
447  MassTable a;
448 
449  a.id = "id";
450  a.msLevel.push_back(1);
451 
452  ResiduePtr b(new Residue());
453  b->code = 'B';
454  a.residues.push_back(b);
455 
456  AmbiguousResiduePtr c(new AmbiguousResidue());
457  c->code = 'C';
458  a.ambiguousResidue.push_back(c);
459 
460  testObject(a);
461 }
462 
463 
465 {
466  Filter a;
467 
471 
472  testObject(a);
473 }
474 
475 
477 {
479 
480  a.id = "id";
481 
482  a.analysisSoftwarePtr = AnalysisSoftwarePtr(new AnalysisSoftware("ref"));
483 
486  a.modificationParams.push_back(SearchModificationPtr(new SearchModification()));
487  a.enzymes.independent = "no";
488  a.massTable.push_back(MassTablePtr(new MassTable("MT_1")));
489  a.massTable.back()->msLevel.push_back(1);
490  a.massTable.back()->msLevel.push_back(2);
494 
495  FilterPtr b(new Filter());
496  b->filterType.set(MS_DB_filter_taxonomy);
497  a.databaseFilters.push_back(b);
498 
499  testObject(a);
500 }
501 
502 
504 {
506 
507  a.id = "id";
508  a.id="PDP_MascotParser_1";
509  a.analysisSoftwarePtr = AnalysisSoftwarePtr(new AnalysisSoftware("ref"));
512 
513  testObject(a);
514 }
515 
516 
518 {
520 
521  SpectrumIdentificationProtocolPtr b(new SpectrumIdentificationProtocol());
522  b->analysisSoftwarePtr = AnalysisSoftwarePtr(new AnalysisSoftware("ref"));
523  a.spectrumIdentificationProtocol.push_back(b);
524 
525  ProteinDetectionProtocolPtr c(new ProteinDetectionProtocol());
526  c->analysisSoftwarePtr = AnalysisSoftwarePtr(new AnalysisSoftware("ref"));
527  a.proteinDetectionProtocol.push_back(c);
528 
529  testObject(a);
530 }
531 
532 
534 {
535  SpectraData a;
536 
537  a.id = "id";
538 
539  a.location = "here";
540  a.externalFormatDocumentation.push_back("there");
542 
543  testObject(a);
544 }
545 
546 
548 {
549  SearchDatabase a;
550 
551  a.id = "id";
552  a.location = "here";
553 
554  a.version = "1.01a";
555  a.releaseDate="now";
556  a.numDatabaseSequences = 1;
557  a.numResidues = 2;
558 
560  a.databaseName.userParams.push_back(UserParam("5peptideMix_20090515.fasta"));
561 
562  testObject(a);
563 }
564 
565 
567 {
568  SourceFile a;
569 
570  a.id = "id";
571 
572  a.location = "there";
574  a.externalFormatDocumentation.push_back("somewhere else");
576 
577  testObject(a);
578 }
579 
580 
582 {
583  Inputs a;
584 
585  SourceFilePtr b(new SourceFile());
586  b->location = "blah";
587  a.sourceFile.push_back(b);
588 
589  SearchDatabasePtr c(new SearchDatabase());
590  c->version = "1.0b";
591  a.searchDatabase.push_back(c);
592 
593  SpectraDataPtr d(new SpectraData());
594  d->location = "bleh";
595  a.spectraData.push_back(d);
596 
597  testObject(a);
598 }
599 
600 
602 {
603  Measure a;
604 
605  a.id = "id";
607 
608  testObject(a);
609 }
610 
611 
613 {
614  FragmentArray a;
615 
616  a.values.push_back(1.);
617  a.values.push_back(2.);
618  a.values.push_back(3.);
619  a.values.push_back(4.);
620  a.measurePtr = MeasurePtr(new Measure("ref"));
621 
622  testObject(a);
623 }
624 
625 
627 {
628  IonType a;
629 
630  a.index.push_back(0);
631  a.index.push_back(1);
632  a.index.push_back(2);
633  a.index.push_back(3);
634  a.charge = 2;
635 
636  a.cvid = MS_frag__a_ion;
637  FragmentArrayPtr b(new FragmentArray());
638  a.fragmentArray.push_back(b);
639 
640  testObject(a);
641 }
642 
643 
645 {
646  PeptideEvidence a;
647 
648  a.id = "id";
649  a.dbSequencePtr = DBSequencePtr(new DBSequence("dbs_ref"));
650  a.start = 1;
651  a.end = 2;
652  a.pre = 'A';
653  a.post = 'C';
654  a.translationTablePtr = TranslationTablePtr(new TranslationTable("tranny_ref"));
655  a.frame = 3;
656  a.isDecoy = true;
657 
658  a.set(MS_Mascot_score, "15.71");
659 
660  testObject(a);
661 }
662 
663 
665 {
667 
668  a.id = "id";
669 
670  a.chargeState = 1;
671  a.experimentalMassToCharge = 1.1;
672  a.calculatedMassToCharge = 2.2;
673  a.calculatedPI = 3.3;
674  a.peptidePtr = PeptidePtr(new Peptide("pep_ref"));
675  a.rank = 4;
676  a.passThreshold = true;
677  a.massTablePtr = MassTablePtr(new MassTable("mt_ref"));
678  a.samplePtr = SamplePtr(new Sample("s_ref"));
679  a.peptideEvidencePtr.push_back(PeptideEvidencePtr(new PeptideEvidence("pe_ref")));
680 
681  IonTypePtr c(new IonType());
682  c->charge = 5;
683  a.fragmentation.push_back(c);
684 
685  a.set(MS_Mascot_score, "15.71");
686 
687  testObject(a);
688 }
689 
690 
692 {
694 
695  a.id = "id";
696 
697  a.spectrumID = "sid";
698  a.spectraDataPtr = SpectraDataPtr(new SpectraData("sd_ref"));
699 
700  SpectrumIdentificationItemPtr b(new SpectrumIdentificationItem());
701  b->chargeState = 1;
702  a.spectrumIdentificationItem.push_back(b);
703 
704  a.set(MS_Mascot_score, "15.71");
705 
706  testObject(a);
707 }
708 
709 
711 {
713 
714  a.peptideEvidencePtr.reset(new PeptideEvidence("pe1"));
715  a.spectrumIdentificationItemPtr.push_back(SpectrumIdentificationItemPtr(new SpectrumIdentificationItem("sii1")));
716 
717  testObject(a);
718  return a;
719 }
720 
721 
723 {
725 
726  a.id = "id";
727  a.dbSequencePtr = DBSequencePtr(new DBSequence("dbs_ref"));
728  a.passThreshold = "pt";
730  a.set(MS_Mascot_score, "164.4");
731 
732  testObject(a);
733 }
734 
735 
737 {
739 
740  a.id = "id";
741  ProteinDetectionHypothesisPtr b(new ProteinDetectionHypothesis());
742  b->dbSequencePtr = DBSequencePtr(new DBSequence("dbs_ref"));
743  a.proteinDetectionHypothesis.push_back(b);
744  a.set(MS_Mascot_score, "164.4");
745 
746  testObject(a);
747 }
748 
749 
751 {
753 
754  a.id = "id";
755  a.numSequencesSearched = 1;
756 
757  MeasurePtr b(new Measure());
758  b->set(MS_Mascot_score, "164.4");
759  a.fragmentationTable.push_back(b);
760 
761  SpectrumIdentificationResultPtr c(new SpectrumIdentificationResult());
762  c->id = "sid";
763  c->spectrumID = "sID";
764  a.spectrumIdentificationResult.push_back(c);
765 
766  testObject(a);
767 }
768 
769 
771 {
773 
774  a.id = "id";
775  ProteinAmbiguityGroupPtr b(new ProteinAmbiguityGroup());
776  a.proteinAmbiguityGroup.push_back(b);
777 
778  a.set(MS_Mascot_score, "164.4");
779 
780  testObject(a);
781 }
782 
783 
785 {
786  AnalysisData a;
787 
788  SpectrumIdentificationListPtr b(new SpectrumIdentificationList());
789  b->id = "id";
790  b->numSequencesSearched = 5;
791  a.spectrumIdentificationList.push_back(b);
792 
793  a.proteinDetectionListPtr = ProteinDetectionListPtr(new ProteinDetectionList("id2"));
794  a.proteinDetectionListPtr->set(MS_Mascot_score, "164.4");
795 
796  testObject(a);
797 }
798 
799 
801 {
802  DataCollection a;
803 
804  SourceFilePtr b(new SourceFile());
805  a.inputs.sourceFile.push_back(b);
806 
807  SpectrumIdentificationListPtr c(new SpectrumIdentificationList());
808  c->id = "SIL_1";
809  c->numSequencesSearched = 5;
811 
812  testObject(a);
813 }
814 
815 
817 {
818  IdentData a;
819 
821 
822  testObject(a);
823 
824  // test ignoring sequence collection and analysis data
825  {
826  // write 'a' out to a stream
827 
828  ostringstream oss;
829  XMLWriter writer(oss);
830  IO::write(writer, a);
831  if (os_) *os_ << oss.str() << endl;
832 
833  // read 'b' in from stream
834 
835  IdentData b;
836  istringstream iss(oss.str());
838 
839  // clear the original SequenceCollection
841  a.sequenceCollection.peptides.clear();
843 
844  // clear the original analysis data
845  BOOST_FOREACH(SpectrumIdentificationPtr& si, a.analysisCollection.spectrumIdentification)
846  si->spectrumIdentificationListPtr.reset();
850 
851  // compare 'a' and 'b'
852 
854  if (diff && os_) *os_ << "diff:\n" << diff << endl;
855  unit_assert(!diff);
856  }
857 }
858 
859 
860 void test()
861 {
862  testCV();
866  testPerson();
868  testContactRole();
869  testProvider();
870  testSample();
872  testDBSequence();
875  testPeptide();
881  testEnzyme();
882  testEnzymes();
883  testResidue();
885  testMassTable();
886  testFilter();
890  testSpectraData();
892  testSourceFile();
893  testInputs();
894  testMeasure();
896  testIonType();
906  testIdentData();
907 }
908 
909 
910 int main(int argc, char* argv[])
911 {
912  TEST_PROLOG_EX(argc, argv, "_IdentData")
913 
914  try
915  {
916  if (argc>1 && !strcmp(argv[1],"-v")) os_ = &cout;
917  test();
918  if (os_) *os_ << "ok\n";
919  }
920  catch (exception& e)
921  {
922  TEST_FAILED(e.what())
923  }
924  catch (...)
925  {
926  TEST_FAILED("Caught unknown exception.")
927  }
928 
930 }
931 
MS_contact_address
contact address: Postal address of the contact person or organization.
Definition: cv.hpp:2260
std::string id
the short label to be used as a reference tag with which to refer to this particular Controlled Vocab...
Definition: cv.hpp:13356
SpectrumIdentificationProtocolPtr spectrumIdentificationProtocolPtr
Definition: IdentData.hpp:769
void testAmbiguousResidue()
Definition: IOTest.cpp:432
void testObject(const object_type &a)
Definition: IOTest.cpp:41
MS_TIC
TIC (total ion current): The sum of all the separate ion currents carried by the ions of different m/...
Definition: cv.hpp:1258
std::vector< OrganizationPtr > affiliations
Definition: IdentData.hpp:161
void testContactRole()
Definition: IOTest.cpp:168
void testPeptide()
Definition: IOTest.cpp:286
void testSample()
Definition: IOTest.cpp:193
void testSpectraData()
Definition: IOTest.cpp:533
Implementation of ContactType from mzIdentML.
Definition: IdentData.hpp:117
void testIonType()
Definition: IOTest.cpp:626
std::vector< SpectrumIdentificationItemPtr > spectrumIdentificationItemPtr
Definition: IdentData.hpp:809
The XMLWriter class provides simple, tag-level XML syntax writing.
Definition: XMLWriter.hpp:47
void testProteinDetectionHypothesis()
Definition: IOTest.cpp:722
MS_peptide
peptide: A compound of low molecular weight that is composed of two or more amino acids...
Definition: cv.hpp:3124
boost::logic::tribool independent
Definition: IdentData.hpp:433
Implementation of AnalysisCollectionType from the mzIdentML schema.
Definition: IdentData.hpp:895
Implementation of AnalysisSampleCollectionType from mzIdentML schema.
Definition: IdentData.hpp:258
MS_DB_MW_filter
DB MW filter: Filtering applied specifically by protein molecular weight, specified as either a range...
Definition: cv.hpp:3412
void testMeasure()
Definition: IOTest.cpp:601
std::vector< PeptideEvidencePtr > peptideEvidence
Definition: IdentData.hpp:656
ParamContainer exclude
Definition: IdentData.hpp:505
MS_contact_phone_number
contact phone number: Phone number of the contact person or organization.
Definition: cv.hpp:5521
Implementation of PeptideEvidenceType from the mzIdentML schema.
Definition: IdentData.hpp:626
MS_parent_mass_type_mono
parent mass type mono: Mass type setting for parent mass was monoisotopic.
Definition: cv.hpp:3910
Implementation of MeasureType from the mzIdentML schema.
Definition: IdentData.hpp:573
Implementation of TranslationTableType from the mzIdentML schema.
Definition: IdentData.hpp:517
SearchDatabasePtr searchDatabasePtr
Definition: IdentData.hpp:303
MS_alternate_single_letter_codes
alternate single letter codes: List of standard residue one letter codes which are used to replace a ...
Definition: cv.hpp:4330
std::vector< PeptideEvidencePtr > peptideEvidencePtr
Definition: IdentData.hpp:684
void testAnalysisCollection()
Definition: IOTest.cpp:353
MS_software_vendor
software vendor: Software vendor role.
Definition: cv.hpp:4069
AnalysisCollection analysisCollection
Definition: IdentData.hpp:1016
void testSpectrumIdentification()
Definition: IOTest.cpp:320
void testFilter()
Definition: IOTest.cpp:464
Implementation of EnzymeType from the mzIdentML schema.
Definition: IdentData.hpp:408
Implementation of AmbiguousResidueType from the mzIdentML schema.
Definition: IdentData.hpp:463
Implementation of SpectraDataType from the mzIdentML schema.
Definition: IdentData.hpp:697
void testSubstitutionModification()
Definition: IOTest.cpp:272
MS_mzML_format
mzML format: Proteomics Standards Inititative mzML file format.
Definition: cv.hpp:2251
MS_Trypsin
Trypsin: Enzyme trypsin.
Definition: cv.hpp:4027
std::vector< SpectrumIdentificationResultPtr > spectrumIdentificationResult
Definition: IdentData.hpp:751
void testResidue()
Definition: IOTest.cpp:419
Parent class representing extensions of the IdentifiableType from the mzIdentML schema.
Definition: IdentData.hpp:64
Implementation of PersonType from the mzIdentML schema.
Definition: IdentData.hpp:152
Calculate diffs of objects in a ProteoWizard data model hierarchy.
Definition: diff_std.hpp:142
std::vector< SpectrumIdentificationListPtr > spectrumIdentificationList
Definition: IdentData.hpp:962
std::string peptideSequence
Definition: IdentData.hpp:373
MS_Mascot_score
Mascot:score: The Mascot result &#39;Score&#39;.
Definition: cv.hpp:3820
#define TEST_EPILOG
Definition: unit.hpp:182
std::vector< IonTypePtr > fragmentation
Definition: IdentData.hpp:685
Implementation of the InputsType from the mzIdentML schema.
Definition: IdentData.hpp:943
Implementation of SpectrumIdentificationResultType from the mzIdentML schema.
Definition: IdentData.hpp:722
Implementation of ProteinDetectionHypothesisType from the mzIdentML schema.
Definition: IdentData.hpp:819
MS_contact_fax_number
contact fax number: Fax number for the contact person or organization.
Definition: cv.hpp:5524
std::vector< SpectrumIdentificationProtocolPtr > spectrumIdentificationProtocol
Definition: IdentData.hpp:911
Information about an ontology or CV source and a short &#39;lookup&#39; tag to refer to.
Definition: cv.hpp:13353
void testAnalysisData()
Definition: IOTest.cpp:784
std::vector< PeptideHypothesis > peptideHypothesis
Definition: IdentData.hpp:826
MS_contact_toll_free_phone_number
contact toll-free phone number: Toll-free phone number of the contact person or organization.
Definition: cv.hpp:5527
std::vector< ProteinDetectionProtocolPtr > proteinDetectionProtocol
Definition: IdentData.hpp:912
Implementation of ProteinDetectionProtocolType from the mzIdentML schema.
Definition: IdentData.hpp:786
ParamContainer filterType
Definition: IdentData.hpp:503
std::vector< ResiduePtr > residues
Definition: IdentData.hpp:487
std::vector< SpectraDataPtr > inputSpectra
Definition: IdentData.hpp:773
Implementation of FilterType from the mzIdentML schema.
Definition: IdentData.hpp:501
Implementation of PeptideType from the mzIdentML schema.
Definition: IdentData.hpp:368
void testSpectrumIdentificationItem()
Definition: IOTest.cpp:664
MS_contact_email
contact email: Email address of the contact person or organization.
Definition: cv.hpp:2266
void testIdentifiableParamContainer()
Definition: IOTest.cpp:78
Implementation of AnalysisDataType from the mzIdentML schema.
Definition: IdentData.hpp:960
DataCollection dataCollection
Definition: IdentData.hpp:1020
std::vector< EnzymePtr > enzymes
Definition: IdentData.hpp:435
TranslationTablePtr translationTablePtr
Definition: IdentData.hpp:637
std::vector< double > values
Definition: IdentData.hpp:591
void diff(const string &filename1, const string &filename2)
MS_protein_description
protein description: The protein description line from the sequence entry in the source database FAST...
Definition: cv.hpp:3571
boost::shared_ptr< Organization > parent
Definition: IdentData.hpp:140
std::string fullName
the usual name for the resource (e.g. The PSI-MS Controlled Vocabulary).
Definition: cv.hpp:13362
ParamContainer include
Definition: IdentData.hpp:504
std::vector< SearchDatabasePtr > searchDatabase
Definition: IdentData.hpp:774
Implementation of ProviderType from the mzIdentML schema.
Definition: IdentData.hpp:234
std::vector< PeptidePtr > peptides
Definition: IdentData.hpp:655
Uncontrolled user parameters (essentially allowing free text). Before using these, one should verify whether there is an appropriate CV term available, and if so, use the CV term instead.
Definition: ParamTypes.hpp:185
MS_frag__a_ion
frag: a ion: Fragmentation information, type of product: a ion.
Definition: cv.hpp:3967
void testPeptideEvidence()
Definition: IOTest.cpp:644
Implementation of ProteinAmbiguityGroupType from the mzIdentML schema.
Definition: IdentData.hpp:839
void testCV()
Definition: IOTest.cpp:93
void testAnalysisSampleCollection()
Definition: IOTest.cpp:228
void testDBSequence()
Definition: IOTest.cpp:240
void testBibliographicReference()
Definition: IOTest.cpp:107
SemiSpecific
neither termini must match digestion motif(s)
Definition: Digestion.hpp:120
void testEnzyme()
Definition: IOTest.cpp:385
std::vector< UserParam > userParams
a collection of uncontrolled user terms
Definition: ParamTypes.hpp:253
std::vector< SubstitutionModificationPtr > substitutionModification
Definition: IdentData.hpp:375
void testIdentifiable()
Definition: IOTest.cpp:66
Implementation of MassTableType from the mzIdentML schema.
Definition: IdentData.hpp:480
std::vector< std::string > externalFormatDocumentation
Definition: IdentData.hpp:928
void testAnalysisProtocolCollection()
Definition: IOTest.cpp:517
std::vector< boost::shared_ptr< Sample > > subSamples
Definition: IdentData.hpp:201
void testSearchDatabase()
Definition: IOTest.cpp:547
PWIZ_API_DECL void write(minimxml::XMLWriter &writer, const CV &cv)
Implementation of SequenceCollectionType from the mzIdentML schema.
Definition: IdentData.hpp:652
boost::shared_ptr< Contact > ContactPtr
Definition: TraData.hpp:57
std::string URI
the URI for the resource.
Definition: cv.hpp:13359
Implementation of the MzIdentMLType from the mzIdentML schema.
Definition: IdentData.hpp:993
std::vector< int > msLevel
Definition: IdentData.hpp:485
Implementation of EnzymesType from the mzIdentML schema.
Definition: IdentData.hpp:431
Implementation of ProteinDetectionListType from the mzIdentML schema.
Definition: IdentData.hpp:855
MS_FASTA_format
FASTA format: The sequence database was stored in the FASTA format.
Definition: cv.hpp:4294
boost::shared_ptr< Peptide > PeptidePtr
Definition: TraData.hpp:236
void testSpectrumIdentificationList()
Definition: IOTest.cpp:750
std::vector< SearchModificationPtr > modificationParams
Definition: IdentData.hpp:554
void testIdentData()
Definition: IOTest.cpp:816
IgnoreSequenceCollection
Definition: IO.hpp:255
IgnoreAnalysisData
Definition: IO.hpp:211
UO_dalton
dalton: An independently to the base SI units defined mass unit which is equal to one twelfth of the ...
Definition: cv.hpp:13153
void testInputs()
Definition: IOTest.cpp:581
Implementation of IonTypeType from the mzIdentML schema.
Definition: IdentData.hpp:607
std::vector< int > index
Definition: IdentData.hpp:611
MS_search_tolerance_plus_value
search tolerance plus value:
Definition: cv.hpp:4477
ParamContainer enzymeName
Definition: IdentData.hpp:420
Implementation of SearchModificationType from the mzIdentML schema.
Definition: IdentData.hpp:388
Implementation of the SampleType from the mzIdentML schema.
Definition: IdentData.hpp:195
void testProteinDetectionList()
Definition: IOTest.cpp:770
MS_DB_filter_taxonomy
DB filter taxonomy: A taxonomy filter was to the database search.
Definition: cv.hpp:3406
proteome::Digestion::Specificity terminalSpecificity
Definition: IdentData.hpp:415
void testProvider()
Definition: IOTest.cpp:180
std::vector< SourceFilePtr > sourceFile
Definition: IdentData.hpp:946
Implementation of PeptideHypothesisType from the mzIdentML schema.
Definition: IdentData.hpp:806
std::vector< SpectrumIdentificationPtr > spectrumIdentification
Definition: IdentData.hpp:897
Implementation of AbstractOrganizationType from the mzIdentML schema.
Definition: IdentData.hpp:135
MS_septum
septum: A disc composed of a flexible material that seals the entrance to the reservoir. Can also be entrance to the vacuum chamber.
Definition: cv.hpp:322
MS_Mascot_DAT_format
Mascot DAT format: Source file for this mzIdentML was in Mascot DAT file format.
Definition: cv.hpp:3880
void testProteinAmbiguityGroup()
Definition: IOTest.cpp:736
std::vector< MeasurePtr > fragmentationTable
Definition: IdentData.hpp:750
Implementation of DataCollectionType from the mzIdentML schema.
Definition: IdentData.hpp:974
Implementation of SourceFileType from the mzIdentML schema.
Definition: IdentData.hpp:923
#define TEST_PROLOG_EX(argc, argv, suffix)
Definition: unit.hpp:157
PWIZ_API_DECL void read(std::istream &is, CV &cv)
MS_programmer
programmer: Programmer role.
Definition: cv.hpp:4072
std::vector< char > residues
Definition: IdentData.hpp:334
Implementation of SpectrumIdentificationProtocolType from the mzIdentML schema.
Definition: IdentData.hpp:545
void testPerson()
Definition: IOTest.cpp:128
#define TEST_FAILED(x)
Definition: unit.hpp:176
std::vector< DBSequencePtr > dbSequences
Definition: IdentData.hpp:654
PWIZ_API_DECL void initializeTiny(IdentData &mzid)
MS_Mascot
Mascot: The name of the Mascot search engine.
Definition: cv.hpp:3898
Implementation of FragmentArrayType from the mzIdentML schema.
Definition: IdentData.hpp:589
void testFragmentArray()
Definition: IOTest.cpp:612
MS_modification_specificity_peptide_N_term
modification specificity peptide N-term: As parameter for search engine: apply the modification only ...
Definition: cv.hpp:3850
SequenceCollection sequenceCollection
Definition: IdentData.hpp:1014
void testProteinDetection()
Definition: IOTest.cpp:337
Implementation of SubstitutionModificationType from the mzIdentML schema.
Definition: IdentData.hpp:349
CVID_Unknown
Definition: cv.hpp:97
ostream * os_
Definition: IOTest.cpp:38
void test()
Definition: IOTest.cpp:860
MS_role_type
role type: Role of a Person or Organization.
Definition: cv.hpp:4066
std::vector< std::string > externalFormatDocumentation
Definition: IdentData.hpp:704
MS_ms_ms_search
ms-ms search: An MS2 search (with fragment ions).
Definition: cv.hpp:3556
std::vector< ModificationPtr > modification
Definition: IdentData.hpp:374
Implementation of ModificationType from the mzIdentML schema.
Definition: IdentData.hpp:329
void testSourceFile()
Definition: IOTest.cpp:566
ProteinDetectionProtocolPtr proteinDetectionProtocolPtr
Definition: IdentData.hpp:877
void set(CVID cvid, const std::string &value="", CVID units=CVID_Unknown)
set/add a CVParam (not recursive)
MS_product_ion_m_z
product ion m/z: The m/z of the product ion.
Definition: cv.hpp:3949
Implementation of SearchDatabaseType from the mzIdentML schema.
Definition: IdentData.hpp:270
ContactRolePtr contactRolePtr
Definition: IdentData.hpp:239
void testSpectrumIdentificationResult()
Definition: IOTest.cpp:691
UNIMOD_Gln__pyro_Glu
Gln->pyro-Glu: Pyro-glu from Q.
Definition: cv.hpp:8485
void testProteinDetectionProtocol()
Definition: IOTest.cpp:503
void testModification()
Definition: IOTest.cpp:256
MS_DB_filter_on_accession_numbers
DB filter on accession numbers: Filtering applied specifically by accession number pattern...
Definition: cv.hpp:3409
Implementation of AnalysisSoftwareType from the mzIdentML schema.
Definition: IdentData.hpp:211
int main(int argc, char *argv[])
Definition: IOTest.cpp:910
PeptideEvidencePtr peptideEvidencePtr
Definition: IdentData.hpp:808
Implementation of SpectrumIdentificationType from the mzIdentML schema.
Definition: IdentData.hpp:764
Implementation of ResidueType from the mzIdentML schema.
Definition: IdentData.hpp:445
std::vector< SpectraDataPtr > spectraData
Definition: IdentData.hpp:948
void testSequenceCollection()
Definition: IOTest.cpp:308
std::vector< ProteinDetectionHypothesisPtr > proteinDetectionHypothesis
Definition: IdentData.hpp:844
boost::shared_ptr< Sample > SamplePtr
Definition: MSData.hpp:117
std::string version
the version of the CV from which the referred-to terms are drawn.
Definition: cv.hpp:13365
Implementation of AnalysisProtocolCollectionType from the mzIdentML schema.
Definition: IdentData.hpp:909
std::vector< ProteinAmbiguityGroupPtr > proteinAmbiguityGroup
Definition: IdentData.hpp:860
std::vector< SearchDatabasePtr > searchDatabase
Definition: IdentData.hpp:947
Implementation of DBSequenceType from the mzIdentML schema.
Definition: IdentData.hpp:296
Implementation for the BibliographicReferenceType tag in the mzIdentML schema.
Definition: IdentData.hpp:95
Implementation of ContactRoleType from the mzIdentML schema.
Definition: IdentData.hpp:175
std::vector< FragmentArrayPtr > fragmentArray
Definition: IdentData.hpp:613
void testSearchModification()
Definition: IOTest.cpp:368
void testEnzymes()
Definition: IOTest.cpp:405
SpectrumIdentificationListPtr spectrumIdentificationListPtr
Definition: IdentData.hpp:770
ProteinDetectionListPtr proteinDetectionListPtr
Definition: IdentData.hpp:963
#define unit_assert(x)
Definition: unit.hpp:85
void testMassTable()
Definition: IOTest.cpp:445
Implementation of SpectrumIdentificationItemType from the mzIdentML schema.
Definition: IdentData.hpp:669
std::vector< AmbiguousResiduePtr > ambiguousResidue
Definition: IdentData.hpp:488
ProteinDetectionListPtr proteinDetectionListPtr
Definition: IdentData.hpp:878
void testAnalysisSoftware()
Definition: IOTest.cpp:210
Implementation of SpectrumIdentificationListType from the mzIdentML schema.
Definition: IdentData.hpp:743
void testDataCollection()
Definition: IOTest.cpp:800
MS_Mascot_SigThreshold
Mascot:SigThreshold: Significance threshold below which the p-value of a peptide match must lie to be...
Definition: cv.hpp:4201
Parent class of all Identifiable objects that have ParamGroups.
Definition: IdentData.hpp:79
void testOrganization()
Definition: IOTest.cpp:150
std::vector< SpectrumIdentificationItemPtr > spectrumIdentificationItem
Definition: IdentData.hpp:730
Definition: cv.hpp:91
void testSpectrumIdentificationProtocol()
Definition: IOTest.cpp:476
std::vector< ContactRolePtr > contactRole
Definition: IdentData.hpp:200
PeptideHypothesis testPeptideHypothesis()
Definition: IOTest.cpp:710
boost::shared_ptr< SourceFile > SourceFilePtr
Description of the source file, including location and type.
Definition: MSData.hpp:75
Implementation of ProteinDetectionType from the mzIdentML schema.
Definition: IdentData.hpp:872