ProteoWizard
DiffTest.cpp
Go to the documentation of this file.
1 //
2 // $Id: DiffTest.cpp 4129 2012-11-20 00:05:37Z chambm $
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 
28 using namespace pwiz::util;
29 using namespace pwiz::cv;
30 using namespace pwiz::data;
31 using namespace pwiz::tradata;
32 
33 
34 ostream* 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 
50  unit_assert(!diff);
51 
52  a.id = "bar";
53 
54  diff(a, b);
55  if (os_) *os_ << diff << endl;
56  unit_assert(diff);
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 
73  unit_assert(!diff);
74 
75  a.id = "bar";
76 
77  diff(a, b);
78  if (os_) *os_ << diff << endl;
79  unit_assert(diff);
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 
98  unit_assert(!diff);
99 
100  a.instrumentPtr->id = "different";
101 
102  diff(a, b);
103  if (os_) *os_ << diff << endl;
104  unit_assert(diff);
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 
121  unit_assert(!diff);
122 
123  a.softwarePtr = SoftwarePtr(new Software("different"));
124 
125  diff(a, b);
126  if (os_) *os_ << diff << endl;
127  unit_assert(diff);
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 
142  unit_assert(!diff);
143 
144  b.set(MS_peak_intensity, 42);
145 
146  diff(a, b);
147  if (os_) *os_ << diff << endl;
148  unit_assert(diff);
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 
163  unit_assert(!diff);
164 
165  a.set(MS_peak_intensity, 42);
166 
167  diff(a, b);
168  if (os_) *os_ << diff << endl;
169  unit_assert(diff);
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 
184  unit_assert(!diff);
185 
186  a.set(MS_peak_intensity, 42);
187 
188  diff(a, b);
189  if (os_) *os_ << diff << endl;
190  unit_assert(diff);
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 
207  unit_assert(!diff);
208 
209  a.sequence = "DCBA";
210 
211  diff(a, b);
212  if (os_) *os_ << diff << endl;
213  unit_assert(diff);
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 
227  unit_assert(!diff);
228 
229  a.monoisotopicMassDelta = 84;
230 
231  diff(a, b);
232  if (os_) *os_ << diff << endl;
233  unit_assert(diff);
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 
252  unit_assert(!diff);
253 
254  a.sequence = "DCBA";
255 
256  diff(a, b);
257  if (os_) *os_ << diff << endl;
258  unit_assert(diff);
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 
274  unit_assert(!diff);
275 
276  b.retentionTimes.push_back(RetentionTime());
277 
278  diff(a, b);
279  if (os_) *os_ << diff << endl;
280  unit_assert(diff);
281 }
282 
283 
285 {
286  if (os_) *os_ << "testTransition()\n";
287 
288  Transition a, b;
289  a.id = b.id = "T1";
290  a.precursor.set(MS_selected_ion_m_z, 123.45);
291  b.precursor.set(MS_selected_ion_m_z, 123.45);
292  a.product.set(MS_selected_ion_m_z, 456.78);
293  b.product.set(MS_selected_ion_m_z, 456.78);
294  Validation v; v.set(MS_peak_intensity, 42);
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 
302  unit_assert(!diff);
303 
304  b.peptidePtr->sequence = "different";
305 
306  diff(a, b);
307  if (os_) *os_ << diff << endl;
308  unit_assert(diff);
309 }
310 
312 {
313  if (os_) *os_ << "testTarget()\n";
314 
315  Target a, b;
316  a.id = b.id = "T1";
317  a.precursor.set(MS_selected_ion_m_z, 123.45);
318  b.precursor.set(MS_selected_ion_m_z, 123.45);
319  Validation v; v.set(MS_peak_intensity, 42);
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 
327  unit_assert(!diff);
328 
329  b.peptidePtr->sequence = "different";
330 
331  diff(a, b);
332  if (os_) *os_ << diff << endl;
333  unit_assert(diff);
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 
349  unit_assert(!diff);
350 
351  b.version = "4.21";
352 
353  diff(a, b);
354  if (os_) *os_ << diff << endl;
355  unit_assert(diff);
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 
385 void 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 
418  unit_assert(!diff);
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;
431  unit_assert(diff);
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 
444 void test()
445 {
446  testContact();
447  testInstrument();
448  testSoftware();
450  testPrediction();
451  testValidation();
452  testEvidence();
454  testProtein();
456  testPeptide();
457  testCompound();
458  testTransition();
459  testTarget();
460  //testPrecursor();
461  //testProduct();
462  testTraData();
463 }
464 
465 
466 int 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 testContact()
Definition: DiffTest.cpp:1008
int main(int argc, char *argv[])
Definition: DiffTest.cpp:1371
void testPrediction()
Definition: DiffTest.cpp:108
boost::shared_ptr< Software > SoftwarePtr
Definition: MSData.hpp:197
void testSoftware()
Definition: DiffTest.cpp:227
void testEvidence()
Definition: DiffTest.cpp:152
void test()
Definition: DiffTest.cpp:1319
void testPeptide()
Definition: DiffTest.cpp:1133
Precursor precursor
Precursor (Q1) of the target.
Definition: TraData.hpp:320
Calculate diffs of objects in a ProteoWizard data model hierarchy.
Definition: diff_std.hpp:142
Information about the state of validation of a transition on a given instrument model.
Definition: TraData.hpp:124
#define TEST_EPILOG
Definition: unit.hpp:182
std::string id
Identifier for the compound to be used for referencing within a document.
Definition: TraData.hpp:243
Information about an ontology or CV source and a short &#39;lookup&#39; tag to refer to.
Definition: cv.hpp:13353
Instrument on which transitions are validated.
Definition: TraData.hpp:132
Information about a prediction for a suitable transition using some software.
Definition: TraData.hpp:102
A peptide or compound that is to be included or excluded from a target list of precursor m/z values...
Definition: TraData.hpp:308
Instrument configuration used in the validation or optimization of the transitions.
Definition: TraData.hpp:147
std::string id
String label for this transition.
Definition: TraData.hpp:276
std::string version
Version of the software program described.
Definition: TraData.hpp:76
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
Information about empirical mass spectrometer observations of the peptide.
Definition: TraData.hpp:116
std::string id
Identifier for the software to be used for referencing within a document.
Definition: TraData.hpp:73
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
represents a post-translational modification (PTM) modification formula or masses must be provided at...
void testTransition()
Definition: DiffTest.cpp:284
std::string id
Identifier for the instrument to be used for referencing within a document.
Definition: TraData.hpp:135
void testModification()
Definition: DiffTest.cpp:1121
MS_selected_ion_m_z
selected ion m/z: Mass-to-charge ratio of an selected ion.
Definition: cv.hpp:2749
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:241
SoftwarePtr softwarePtr
Reference to a software package from which this prediction is derived.
Definition: TraData.hpp:105
void diff(const string &filename1, const string &filename2)
Chemical compound other than a peptide for which one or more transitions.
Definition: TraData.hpp:240
represents a peptide or polypeptide (a sequence of amino acids)
Definition: Peptide.hpp:61
ContactPtr contactPtr
Reference to a contact person that generated this prediction.
Definition: TraData.hpp:108
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
InstrumentPtr instrumentPtr
Reference to an instrument for which this configuration information is appropriate.
Definition: TraData.hpp:155
std::vector< UserParam > userParams
a collection of uncontrolled user terms
Definition: ParamTypes.hpp:253
std::vector< Publication > publications
List of publications from which the transitions were collected or wherein they are published...
Definition: TraData.hpp:363
object_result_type b_a
Definition: diff_std.hpp:157
std::string id
Identifier for the contact to be used for referencing within a document.
Definition: TraData.hpp:49
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:223
MS_ionization_type
ionization type: The method by which gas phase ions are generated from the sample.
Definition: cv.hpp:124
ostream * os_
Definition: DiffTest.cpp:40
boost::shared_ptr< Contact > ContactPtr
Definition: TraData.hpp:57
ContactPtr contactPtr
Reference to a contact person originating this information.
Definition: TraData.hpp:152
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< CVParam > cvParams
a collection of controlled vocabulary terms
Definition: ParamTypes.hpp:250
Product product
Product (Q3) of the transition.
Definition: TraData.hpp:288
PeptidePtr peptidePtr
Reference to a peptide which this transition is intended to identify.
Definition: TraData.hpp:279
void testInstrument()
Definition: DiffTest.cpp:60
void testTarget()
Definition: DiffTest.cpp:311
boost::shared_ptr< Peptide > PeptidePtr
Definition: TraData.hpp:236
std::vector< Validation > validations
Definition: TraData.hpp:149
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 testConfiguration()
Definition: DiffTest.cpp:83
void testCompound()
Definition: DiffTest.cpp:262
std::vector< Configuration > configurationList
List of insutrument configurations used in the validation or optimization of the transitions.
Definition: TraData.hpp:300
void testRetentionTime()
Definition: DiffTest.cpp:173
#define TEST_PROLOG_EX(argc, argv, suffix)
Definition: unit.hpp:157
#define TEST_FAILED(x)
Definition: unit.hpp:176
boost::shared_ptr< Instrument > InstrumentPtr
Definition: TraData.hpp:143
void testProtein()
Definition: DiffTest.cpp:194
std::vector< Configuration > configurationList
List of instrument configurations used in the validation or optimization of the target.
Definition: TraData.hpp:326
std::vector< RetentionTime > retentionTimes
List of retention time information entries.
Definition: TraData.hpp:246
void testValidation()
Definition: DiffTest.cpp:131
Precursor precursor
Precursor (Q1) of the transition.
Definition: TraData.hpp:285
void set(CVID cvid, const std::string &value="", CVID units=CVID_Unknown)
set/add a CVParam (not recursive)
object_result_type a_b
Definition: diff_std.hpp:156
#define unit_assert(x)
Definition: unit.hpp:85
std::string id
Identifier for the publication to be used for referencing within a document.
Definition: TraData.hpp:63
void testTraData()
Definition: DiffTest.cpp:411
Definition: cv.hpp:91
const std::string & sequence() const
returns the sequence of amino acids making up the peptide