ProteoWizard
DiffTest.cpp
Go to the documentation of this file.
1//
2// $Id$
3//
4//
5// Original author: Matt Chambers <matt.chambers .@. vanderbilt.edu>
6//
7// Copyright 2009 Vanderbilt University - Nashville, TN 37232
8//
9// Licensed under the Apache License, Version 2.0 (the "License");
10// you may not use this file except in compliance with the License.
11// You may obtain a copy of the License at
12//
13// http://www.apache.org/licenses/LICENSE-2.0
14//
15// Unless required by applicable law or agreed to in writing, software
16// distributed under the License is distributed on an "AS IS" BASIS,
17// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18// See the License for the specific language governing permissions and
19// limitations under the License.
20//
21
22#include "Diff.hpp"
25#include <cstring>
26
27
28using namespace pwiz::util;
29using namespace pwiz::cv;
30using namespace pwiz::data;
31using namespace pwiz::tradata;
32
33
34ostream* os_ = 0;
35
36
38{
39 if (os_) *os_ << "testContact()\n";
40
41 Contact a, b;
42 a.userParams.push_back(UserParam("common"));
43 b.userParams.push_back(UserParam("common"));
44 a.cvParams.push_back(MS_m_z);
45 b.cvParams.push_back(MS_m_z);
46
47 a.id = b.id = "foo";
48
51
52 a.id = "bar";
53
54 diff(a, b);
55 if (os_) *os_ << diff << endl;
57}
58
59
61{
62 if (os_) *os_ << "testInstrument()\n";
63
64 Instrument a, b;
65 a.userParams.push_back(UserParam("common"));
66 b.userParams.push_back(UserParam("common"));
67 a.cvParams.push_back(MS_m_z);
68 b.cvParams.push_back(MS_m_z);
69
70 a.id = b.id = "foo";
71
74
75 a.id = "bar";
76
77 diff(a, b);
78 if (os_) *os_ << diff << endl;
80}
81
82
84{
85 if (os_) *os_ << "testConfiguration()\n";
86
87 Configuration a, b;
88 a.userParams.push_back(UserParam("common"));
89 b.userParams.push_back(UserParam("common"));
90 a.cvParams.push_back(MS_m_z);
91 b.cvParams.push_back(MS_m_z);
92 a.instrumentPtr = InstrumentPtr(new Instrument("common"));
93 b.instrumentPtr = InstrumentPtr(new Instrument("common"));
94 a.contactPtr = ContactPtr(new Contact("common"));
95 b.contactPtr = ContactPtr(new Contact("common"));
96
99
100 a.instrumentPtr->id = "different";
101
102 diff(a, b);
103 if (os_) *os_ << diff << endl;
105}
106
107
109{
110 if (os_) *os_ << "testPrediction()\n";
111
112 Prediction a, b;
113 a.userParams.push_back(UserParam("common"));
114 b.userParams.push_back(UserParam("common"));
115 a.cvParams.push_back(MS_m_z);
116 b.cvParams.push_back(MS_m_z);
117 a.contactPtr = ContactPtr(new Contact("common"));
118 b.contactPtr = ContactPtr(new Contact("common"));
119
122
123 a.softwarePtr = SoftwarePtr(new Software("different"));
124
125 diff(a, b);
126 if (os_) *os_ << diff << endl;
128}
129
130
132{
133 if (os_) *os_ << "testValidation()\n";
134
135 Validation a, b;
136 a.userParams.push_back(UserParam("common"));
137 b.userParams.push_back(UserParam("common"));
138 a.cvParams.push_back(MS_m_z);
139 b.cvParams.push_back(MS_m_z);
140
143
144 b.set(MS_peak_intensity, 42);
145
146 diff(a, b);
147 if (os_) *os_ << diff << endl;
149}
150
151
153{
154 if (os_) *os_ << "testEvidence()\n";
155
156 Evidence a, b;
157 a.userParams.push_back(UserParam("common"));
158 b.userParams.push_back(UserParam("common"));
159 a.cvParams.push_back(MS_m_z);
160 b.cvParams.push_back(MS_m_z);
161
164
165 a.set(MS_peak_intensity, 42);
166
167 diff(a, b);
168 if (os_) *os_ << diff << endl;
170}
171
172
174{
175 if (os_) *os_ << "testRetentionTime()\n";
176
177 RetentionTime a, b;
178 a.userParams.push_back(UserParam("common"));
179 b.userParams.push_back(UserParam("common"));
180 a.cvParams.push_back(MS_m_z);
181 b.cvParams.push_back(MS_m_z);
182
185
186 a.set(MS_peak_intensity, 42);
187
188 diff(a, b);
189 if (os_) *os_ << diff << endl;
191}
192
193
195{
196 if (os_) *os_ << "testProtein()\n";
197
198 Protein a, b;
199 a.userParams.push_back(UserParam("common"));
200 b.userParams.push_back(UserParam("common"));
201 a.cvParams.push_back(MS_m_z);
202 b.cvParams.push_back(MS_m_z);
203 a.sequence = b.sequence = "ABCD";
204 a.id = b.id = "foo";
205
208
209 a.sequence = "DCBA";
210
211 diff(a, b);
212 if (os_) *os_ << diff << endl;
214}
215
216
218{
219 if (os_) *os_ << "testModification()\n";
220
221 Modification a, b;
222 a.location = b.location = 7;
223 a.monoisotopicMassDelta = b.monoisotopicMassDelta = 42;
224 a.averageMassDelta = b.averageMassDelta = 42;
225
228
229 a.monoisotopicMassDelta = 84;
230
231 diff(a, b);
232 if (os_) *os_ << diff << endl;
234}
235
236
238{
239 if (os_) *os_ << "testPeptide()\n";
240
241 Peptide a, b;
242 a.userParams.push_back(UserParam("common"));
243 b.userParams.push_back(UserParam("common"));
244 a.cvParams.push_back(MS_m_z);
245 b.cvParams.push_back(MS_m_z);
246 a.evidence.set(MS_peak_intensity, 42);
247 b.evidence.set(MS_peak_intensity, 42);
248 a.sequence = b.sequence = "ABCD";
249 a.id = b.id = "foo";
250
253
254 a.sequence = "DCBA";
255
256 diff(a, b);
257 if (os_) *os_ << diff << endl;
259}
260
261
263{
264 if (os_) *os_ << "testCompound()\n";
265
266 Compound a, b;
267 a.userParams.push_back(UserParam("common"));
268 b.userParams.push_back(UserParam("common"));
269 a.cvParams.push_back(MS_m_z);
270 b.cvParams.push_back(MS_m_z);
271 a.id = b.id = "foo";
272
275
276 b.retentionTimes.push_back(RetentionTime());
277
278 diff(a, b);
279 if (os_) *os_ << diff << endl;
281}
282
283
285{
286 if (os_) *os_ << "testTransition()\n";
287
288 Transition a, b;
289 a.id = b.id = "T1";
295 Configuration c; c.validations.push_back(v);
296 a.configurationList.push_back(c);
297 b.configurationList.push_back(c);
298 a.peptidePtr = PeptidePtr(new Peptide("common"));
299 b.peptidePtr = PeptidePtr(new Peptide("common"));
300
303
304 b.peptidePtr->sequence = "different";
305
306 diff(a, b);
307 if (os_) *os_ << diff << endl;
309}
310
312{
313 if (os_) *os_ << "testTarget()\n";
314
315 Target a, b;
316 a.id = b.id = "T1";
320 Configuration c; c.validations.push_back(v);
321 a.configurationList.push_back(c);
322 b.configurationList.push_back(c);
323 a.peptidePtr = PeptidePtr(new Peptide("common"));
324 b.peptidePtr = PeptidePtr(new Peptide("common"));
325
328
329 b.peptidePtr->sequence = "different";
330
331 diff(a, b);
332 if (os_) *os_ << diff << endl;
334}
335
336
338{
339 if (os_) *os_ << "testSoftware()\n";
340
341 Software a, b;
342
343 a.id = "msdata";
344 a.version = "4.20";
346 b = a;
347
350
351 b.version = "4.21";
352
353 diff(a, b);
354 if (os_) *os_ << diff << endl;
356}
357
358
359/*void testPrecursor()
360{
361 if (os_) *os_ << "testPrecursor()\n";
362
363 Precursor a, b;
364
365 a.mz = 420;
366 a.charge = 2;
367 b = a;
368
369 Diff<Precursor> diff(a, b);
370 unit_assert(!diff);
371
372 b.charge = 3;
373
374 diff(a, b);
375
376 if (os_) *os_ << diff << endl;
377 unit_assert(diff);
378 unit_assert(diff.a_b.mz == 0);
379 unit_assert(diff.a_b.charge == -1);
380 unit_assert(diff.b_a.mz == 0);
381 unit_assert(diff.b_a.charge == 1);
382}
383
384
385void testProduct()
386{
387 if (os_) *os_ << "testProduct()\n";
388
389 Product a, b;
390
391 a.mz = 420;
392 a.charge = 2;
393 b = a;
394
395 Diff<Product> diff(a, b);
396 unit_assert(!diff);
397
398 b.charge = 3;
399
400 diff(a, b);
401
402 if (os_) *os_ << diff << endl;
403 unit_assert(diff);
404 unit_assert(diff.a_b.mz == 0);
405 unit_assert(diff.a_b.charge == -1);
406 unit_assert(diff.b_a.mz == 0);
407 unit_assert(diff.b_a.charge == 1);
408}*/
409
410
412{
413 if (os_) *os_ << "testTraData()\n";
414
415 TraData a, b;
416
419
420 a.cvs.push_back(CV());
421 b.softwarePtrs.push_back(SoftwarePtr(new Software("software")));
422
423 Publication pub;
424 pub.id = "PUBMED1";
425 pub.set(UO_dalton, 123);
426 a.publications.push_back(pub);
427 b.publications.push_back(pub);
428
429 diff(a, b);
430 if (os_) *os_ << diff << endl;
432
433 unit_assert(diff.a_b.cvs.size() == 1);
434 unit_assert(diff.b_a.cvs.empty());
435
436 unit_assert(diff.a_b.softwarePtrs.empty());
437 unit_assert(!diff.b_a.softwarePtrs.empty());
438
439 unit_assert(diff.a_b.publications.empty());
440 unit_assert(diff.b_a.publications.empty());
441}
442
443
444void test()
445{
446 testContact();
448 testSoftware();
452 testEvidence();
454 testProtein();
456 testPeptide();
457 testCompound();
459 testTarget();
460 //testPrecursor();
461 //testProduct();
462 testTraData();
463}
464
465
466int main(int argc, char* argv[])
467{
468 TEST_PROLOG_EX(argc, argv, "_TraData")
469
470 try
471 {
472 if (argc>1 && !strcmp(argv[1],"-v")) os_ = &cout;
473 test();
474 }
475 catch (exception& e)
476 {
477 TEST_FAILED(e.what())
478 }
479 catch (...)
480 {
481 TEST_FAILED("Caught unknown exception.")
482 }
483
485}
486
void diff(const string &filename1, const string &filename2)
represents a post-translational modification (PTM) modification formula or masses must be provided at...
represents a peptide or polypeptide (a sequence of amino acids)
Definition Peptide.hpp:62
const std::string & sequence() const
returns the sequence of amino acids making up the peptide
MS_m_z
m/z: Three-character symbol m/z is used to denote the quantity formed by dividing the mass of an ion ...
Definition cv.hpp:384
UO_dalton
dalton: An independently to the base SI units defined mass unit which is equal to one twelfth of the ...
Definition cv.hpp:14460
MS_selected_ion_m_z
selected ion m/z: Mass-to-charge ratio of an selected ion.
Definition cv.hpp:2901
MS_ionization_type
ionization type: The method by which gas phase ions are generated from the sample.
Definition cv.hpp:285
MS_peak_intensity
peak intensity: Intensity of ions as measured by the height or area of a peak in a mass spectrum.
Definition cv.hpp:402
void testProtein()
Definition DiffTest.cpp:194
int main(int argc, char *argv[])
Definition DiffTest.cpp:466
void testPeptide()
Definition DiffTest.cpp:237
void testValidation()
Definition DiffTest.cpp:131
void testConfiguration()
Definition DiffTest.cpp:83
void testRetentionTime()
Definition DiffTest.cpp:173
void testCompound()
Definition DiffTest.cpp:262
void testPrediction()
Definition DiffTest.cpp:108
void testTraData()
Definition DiffTest.cpp:411
ostream * os_
Definition DiffTest.cpp:34
void testModification()
Definition DiffTest.cpp:217
void testTransition()
Definition DiffTest.cpp:284
void testEvidence()
Definition DiffTest.cpp:152
void test()
Definition DiffTest.cpp:444
void testSoftware()
Definition DiffTest.cpp:337
void testInstrument()
Definition DiffTest.cpp:60
void testTarget()
Definition DiffTest.cpp:311
void testContact()
Definition DiffTest.cpp:37
boost::shared_ptr< Contact > ContactPtr
Definition TraData.hpp:57
boost::shared_ptr< Software > SoftwarePtr
Definition TraData.hpp:88
boost::shared_ptr< Instrument > InstrumentPtr
Definition TraData.hpp:143
boost::shared_ptr< Peptide > PeptidePtr
Definition TraData.hpp:236
Information about an ontology or CV source and a short 'lookup' tag to refer to.
Definition cv.hpp:14916
Calculate diffs of objects in a ProteoWizard data model hierarchy.
Definition diff_std.hpp:143
void set(CVID cvid, const std::string &value="", CVID units=CVID_Unknown)
set/add a CVParam (not recursive)
std::vector< CVParam > cvParams
a collection of controlled vocabulary terms
std::vector< UserParam > userParams
a collection of uncontrolled user terms
Uncontrolled user parameters (essentially allowing free text). Before using these,...
Chemical compound other than a peptide for which one or more transitions.
Definition TraData.hpp:241
std::vector< RetentionTime > retentionTimes
List of retention time information entries.
Definition TraData.hpp:246
std::string id
Identifier for the compound to be used for referencing within a document.
Definition TraData.hpp:243
Instrument configuration used in the validation or optimization of the transitions.
Definition TraData.hpp:148
std::vector< Validation > validations
Definition TraData.hpp:149
InstrumentPtr instrumentPtr
Reference to an instrument for which this configuration information is appropriate.
Definition TraData.hpp:155
ContactPtr contactPtr
Reference to a contact person originating this information.
Definition TraData.hpp:152
std::string id
Identifier for the contact to be used for referencing within a document.
Definition TraData.hpp:49
Information about empirical mass spectrometer observations of the peptide.
Definition TraData.hpp:117
Instrument on which transitions are validated.
Definition TraData.hpp:133
std::string id
Identifier for the instrument to be used for referencing within a document.
Definition TraData.hpp:135
Information about a prediction for a suitable transition using some software.
Definition TraData.hpp:103
SoftwarePtr softwarePtr
Reference to a software package from which this prediction is derived.
Definition TraData.hpp:105
ContactPtr contactPtr
Reference to a contact person that generated this prediction.
Definition TraData.hpp:108
std::string id
Identifier for the publication to be used for referencing within a document.
Definition TraData.hpp:63
std::string id
Identifier for the software to be used for referencing within a document.
Definition TraData.hpp:73
std::string version
Version of the software program described.
Definition TraData.hpp:76
A peptide or compound that is to be included or excluded from a target list of precursor m/z values.
Definition TraData.hpp:309
PeptidePtr peptidePtr
Reference to a peptide for which this target is the trigger.
Definition TraData.hpp:314
std::string id
String label for this target.
Definition TraData.hpp:311
Precursor precursor
Precursor (Q1) of the target.
Definition TraData.hpp:320
std::vector< Configuration > configurationList
List of instrument configurations used in the validation or optimization of the target.
Definition TraData.hpp:326
std::vector< CV > cvs
List of controlled vocabularies used in a TraML document note: one of the <cv> elements in this list ...
Definition TraData.hpp:357
std::vector< Publication > publications
List of publications from which the transitions were collected or wherein they are published.
Definition TraData.hpp:363
std::vector< SoftwarePtr > softwarePtrs
List of software packages used in the generation of one of more transitions described in the document...
Definition TraData.hpp:369
PeptidePtr peptidePtr
Reference to a peptide which this transition is intended to identify.
Definition TraData.hpp:279
Product product
Product (Q3) of the transition.
Definition TraData.hpp:288
Precursor precursor
Precursor (Q1) of the transition.
Definition TraData.hpp:285
std::string id
String label for this transition.
Definition TraData.hpp:276
std::vector< Configuration > configurationList
List of insutrument configurations used in the validation or optimization of the transitions.
Definition TraData.hpp:300
Information about the state of validation of a transition on a given instrument model.
Definition TraData.hpp:125
#define unit_assert(x)
Definition unit.hpp:85
#define TEST_PROLOG_EX(argc, argv, suffix)
Definition unit.hpp:157
#define TEST_EPILOG
Definition unit.hpp:183
#define TEST_FAILED(x)
Definition unit.hpp:177