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 
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;
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;
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 
pwiz::data::UserParam
Uncontrolled user parameters (essentially allowing free text). Before using these,...
Definition: ParamTypes.hpp:186
testEvidence
void testEvidence()
Definition: DiffTest.cpp:152
pwiz::tradata::Contact
Definition: TraData.hpp:47
pwiz::tradata::Target::id
std::string id
String label for this target.
Definition: TraData.hpp:311
testInstrument
void testInstrument()
Definition: DiffTest.cpp:60
testRetentionTime
void testRetentionTime()
Definition: DiffTest.cpp:173
pwiz::tradata::Target::precursor
Precursor precursor
Precursor (Q1) of the target.
Definition: TraData.hpp:320
pwiz::cv::CV
Information about an ontology or CV source and a short 'lookup' tag to refer to.
Definition: cv.hpp:14916
pwiz::tradata::Transition::precursor
Precursor precursor
Precursor (Q1) of the transition.
Definition: TraData.hpp:285
pwiz::cv
Definition: cv.hpp:108
pwiz::proteome::Protein::id
std::string id
Definition: ProteomeData.hpp:42
pwiz::tradata::Prediction::softwarePtr
SoftwarePtr softwarePtr
Reference to a software package from which this prediction is derived.
Definition: TraData.hpp:105
pwiz::tradata::Compound
Chemical compound other than a peptide for which one or more transitions.
Definition: TraData.hpp:241
pwiz::tradata::Software::id
std::string id
Identifier for the software to be used for referencing within a document.
Definition: TraData.hpp:73
pwiz::tradata::Evidence
Information about empirical mass spectrometer observations of the peptide.
Definition: TraData.hpp:117
main
int main(int argc, char *argv[])
Definition: DiffTest.cpp:1371
pwiz::data::ParamContainer::userParams
std::vector< UserParam > userParams
a collection of uncontrolled user terms
Definition: ParamTypes.hpp:253
pwiz::tradata::Target::peptidePtr
PeptidePtr peptidePtr
Reference to a peptide for which this target is the trigger.
Definition: TraData.hpp:314
pwiz::tradata::Target
A peptide or compound that is to be included or excluded from a target list of precursor m/z values.
Definition: TraData.hpp:309
pwiz::proteome::Modification
represents a post-translational modification (PTM) modification formula or masses must be provided at...
Definition: Modification.hpp:42
testContact
void testContact()
Definition: DiffTest.cpp:1008
pwiz::tradata::Configuration::contactPtr
ContactPtr contactPtr
Reference to a contact person originating this information.
Definition: TraData.hpp:152
pwiz::data
Definition: BinaryIndexStream.hpp:31
pwiz::tradata::TraData::cvs
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
pwiz::tradata::Publication
Definition: TraData.hpp:61
pwiz::proteome::Peptide
represents a peptide or polypeptide (a sequence of amino acids)
Definition: Peptide.hpp:62
testProtein
void testProtein()
Definition: DiffTest.cpp:194
pwiz::tradata::Transition::configurationList
std::vector< Configuration > configurationList
List of insutrument configurations used in the validation or optimization of the transitions.
Definition: TraData.hpp:300
testTarget
void testTarget()
Definition: DiffTest.cpp:311
MS_ionization_type
MS_ionization_type
ionization type: The method by which gas phase ions are generated from the sample.
Definition: cv.hpp:285
pwiz::tradata::Transition::id
std::string id
String label for this transition.
Definition: TraData.hpp:276
pwiz::tradata::TraData::publications
std::vector< Publication > publications
List of publications from which the transitions were collected or wherein they are published.
Definition: TraData.hpp:363
pwiz::tradata::Software::version
std::string version
Version of the software program described.
Definition: TraData.hpp:76
pwiz::tradata::Compound::id
std::string id
Identifier for the compound to be used for referencing within a document.
Definition: TraData.hpp:243
pwiz::data::Diff
Calculate diffs of objects in a ProteoWizard data model hierarchy.
Definition: diff_std.hpp:143
testPeptide
void testPeptide()
Definition: DiffTest.cpp:1133
pwiz::util
Definition: almost_equal.hpp:33
pwiz::tradata::Prediction
Information about a prediction for a suitable transition using some software.
Definition: TraData.hpp:103
pwiz::tradata::TraData
Definition: TraData.hpp:351
TEST_EPILOG
#define TEST_EPILOG
Definition: unit.hpp:183
pwiz::tradata::Instrument
Instrument on which transitions are validated.
Definition: TraData.hpp:133
testModification
void testModification()
Definition: DiffTest.cpp:1121
testConfiguration
void testConfiguration()
Definition: DiffTest.cpp:83
testValidation
void testValidation()
Definition: DiffTest.cpp:131
pwiz::tradata::Compound::retentionTimes
std::vector< RetentionTime > retentionTimes
List of retention time information entries.
Definition: TraData.hpp:246
Std.hpp
diff
void diff(const string &filename1, const string &filename2)
Definition: FrequencyDataTest.cpp:40
testTraData
void testTraData()
Definition: DiffTest.cpp:411
pwiz::tradata::Instrument::id
std::string id
Identifier for the instrument to be used for referencing within a document.
Definition: TraData.hpp:135
pwiz::tradata::Software
Definition: TraData.hpp:71
MS_selected_ion_m_z
MS_selected_ion_m_z
selected ion m/z: Mass-to-charge ratio of an selected ion.
Definition: cv.hpp:2901
pwiz::proteome::Protein
Definition: ProteomeData.hpp:37
os_
ostream * os_
Definition: DiffTest.cpp:40
pwiz::proteome::Peptide::sequence
const std::string & sequence() const
returns the sequence of amino acids making up the peptide
TEST_FAILED
#define TEST_FAILED(x)
Definition: unit.hpp:177
UO_dalton
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
pwiz::data::ParamContainer::set
void set(CVID cvid, const std::string &value="", CVID units=CVID_Unknown)
set/add a CVParam (not recursive)
MS_m_z
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
testPrediction
void testPrediction()
Definition: DiffTest.cpp:108
MS_peak_intensity
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
TEST_PROLOG_EX
#define TEST_PROLOG_EX(argc, argv, suffix)
Definition: unit.hpp:157
pwiz::tradata::Transition::product
Product product
Product (Q3) of the transition.
Definition: TraData.hpp:288
pwiz::tradata::Validation
Information about the state of validation of a transition on a given instrument model.
Definition: TraData.hpp:125
pwiz::tradata::Target::configurationList
std::vector< Configuration > configurationList
List of instrument configurations used in the validation or optimization of the target.
Definition: TraData.hpp:326
Diff.hpp
unit.hpp
unit_assert
#define unit_assert(x)
Definition: unit.hpp:85
testTransition
void testTransition()
Definition: DiffTest.cpp:284
pwiz::tradata::Publication::id
std::string id
Identifier for the publication to be used for referencing within a document.
Definition: TraData.hpp:63
pwiz::tradata::ContactPtr
boost::shared_ptr< Contact > ContactPtr
Definition: TraData.hpp:57
testCompound
void testCompound()
Definition: DiffTest.cpp:262
pwiz::tradata::RetentionTime
Definition: TraData.hpp:92
pwiz::tradata::Configuration
Instrument configuration used in the validation or optimization of the transitions.
Definition: TraData.hpp:148
pwiz::tradata::TraData::softwarePtrs
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
pwiz::tradata
Definition: DefaultReaderList.hpp:32
pwiz::tradata::InstrumentPtr
boost::shared_ptr< Instrument > InstrumentPtr
Definition: TraData.hpp:143
pwiz::tradata::Prediction::contactPtr
ContactPtr contactPtr
Reference to a contact person that generated this prediction.
Definition: TraData.hpp:108
testSoftware
void testSoftware()
Definition: DiffTest.cpp:227
pwiz::tradata::Transition
Definition: TraData.hpp:274
pwiz::tradata::PeptidePtr
boost::shared_ptr< Peptide > PeptidePtr
Definition: TraData.hpp:236
pwiz::tradata::Transition::peptidePtr
PeptidePtr peptidePtr
Reference to a peptide which this transition is intended to identify.
Definition: TraData.hpp:279
test
void test()
Definition: DiffTest.cpp:1319
pwiz::msdata::SoftwarePtr
boost::shared_ptr< Software > SoftwarePtr
Definition: MSData.hpp:198
pwiz::tradata::Configuration::validations
std::vector< Validation > validations
Definition: TraData.hpp:149
pwiz::tradata::Configuration::instrumentPtr
InstrumentPtr instrumentPtr
Reference to an instrument for which this configuration information is appropriate.
Definition: TraData.hpp:155
pwiz::tradata::Contact::id
std::string id
Identifier for the contact to be used for referencing within a document.
Definition: TraData.hpp:49
pwiz::data::ParamContainer::cvParams
std::vector< CVParam > cvParams
a collection of controlled vocabulary terms
Definition: ParamTypes.hpp:250