ProteoWizard
Functions | Variables
PeakDataTest.cpp File Reference
#include "PeakData.hpp"
#include "pwiz/utility/misc/unit.hpp"
#include <boost/filesystem/operations.hpp>
#include "pwiz/utility/misc/Std.hpp"

Go to the source code of this file.

Functions

PeakFamily initializePeakFamily ()
 
Scan initializeScan ()
 
Software initializeSoftware ()
 
PeakData initializePeakData ()
 
PeakelPtr initializePeakel ()
 
void testPeakEquality ()
 
void testPeak ()
 
void testPeakFamily ()
 
void testScan ()
 
void testSoftware ()
 
void testPeakData ()
 
void testPeakel ()
 
void testPeakelAux ()
 
void testPeakelConstruction ()
 
void testFeature ()
 
void testFeatureAux ()
 
void test ()
 
int main (int argc, char *argv[])
 

Variables

ostream * os_ = 0
 

Function Documentation

◆ initializePeakFamily()

PeakFamily initializePeakFamily ( )

Definition at line 38 of file PeakDataTest.cpp.

39{
40 PeakFamily peakFamily;
41
42 peakFamily.mzMonoisotopic = 329.86;
43 peakFamily.charge = 3;
44 peakFamily.score = 0.11235811;
45
46 Peak peak;
47 Peak a;
48 Peak boo;
49
50 peak.mz = 329.86;
51 a.mz = 109.87;
52 boo.mz = 6.022141730;
53
54 peakFamily.peaks.push_back(peak);
55 peakFamily.peaks.push_back(a);
56 peakFamily.peaks.push_back(boo);
57
58 return peakFamily;
59
60}

References pwiz::data::peakdata::PeakFamily::charge, pwiz::data::peakdata::Peak::mz, pwiz::data::peakdata::PeakFamily::mzMonoisotopic, pwiz::data::peakdata::PeakFamily::peaks, and pwiz::data::peakdata::PeakFamily::score.

Referenced by initializePeakel(), initializeScan(), and testPeakFamily().

◆ initializeScan()

Scan initializeScan ( )

Definition at line 62 of file PeakDataTest.cpp.

63{
64 Scan scan;
65 scan.index = 12;
66 scan.nativeID = "24";
67 scan.scanNumber = 24;
68 scan.retentionTime = 12.345;
69 scan.observationDuration = 6.78;
70
71 scan.calibrationParameters.A = 987.654;
72 scan.calibrationParameters.B = 321.012;
73
74 PeakFamily flintstones = initializePeakFamily();
76
77 scan.peakFamilies.push_back(flintstones);
78 scan.peakFamilies.push_back(jetsons);
79
80 return scan;
81}
PeakFamily initializePeakFamily()
CalibrationParameters calibrationParameters
Definition PeakData.hpp:141
std::vector< PeakFamily > peakFamilies
Definition PeakData.hpp:142

References pwiz::data::CalibrationParameters::A, pwiz::data::CalibrationParameters::B, pwiz::data::peakdata::Scan::calibrationParameters, pwiz::data::peakdata::Scan::index, initializePeakFamily(), pwiz::data::peakdata::Scan::nativeID, pwiz::data::peakdata::Scan::observationDuration, pwiz::data::peakdata::Scan::peakFamilies, pwiz::data::peakdata::Scan::retentionTime, and pwiz::data::peakdata::Scan::scanNumber.

Referenced by initializePeakData(), and testScan().

◆ initializeSoftware()

Software initializeSoftware ( )

Definition at line 83 of file PeakDataTest.cpp.

84{
85 Software software;
86 software.name = "World of Warcraft";
87 software.version = "Wrath of the Lich King";
88 software.source = "Blizzard Entertainment";
89
90 Software::Parameter parameter1("Burke ping","level 70");
91 Software::Parameter parameter2("Kate ping", "level 0");
92
93 software.parameters.push_back(parameter1);
94 software.parameters.push_back(parameter2);
95
96 return software;
97
98}
std::vector< Parameter > parameters
Definition PeakData.hpp:179

References pwiz::data::peakdata::Software::name, pwiz::data::peakdata::Software::parameters, pwiz::data::peakdata::Software::source, and pwiz::data::peakdata::Software::version.

Referenced by initializePeakData(), and testSoftware().

◆ initializePeakData()

PeakData initializePeakData ( )

Definition at line 100 of file PeakDataTest.cpp.

101{
102 PeakData pd;
103
104 Software software = initializeSoftware();
105 pd.software = software;
106
107 Scan scan = initializeScan();
108
109 pd.scans.push_back(scan);
110 pd.scans.push_back(scan);
111
112 return pd;
113
114}
Scan initializeScan()
Software initializeSoftware()
std::vector< Scan > scans
Definition PeakData.hpp:194

References initializeScan(), initializeSoftware(), pwiz::data::peakdata::PeakData::scans, and pwiz::data::peakdata::PeakData::software.

Referenced by testPeakData().

◆ initializePeakel()

PeakelPtr initializePeakel ( )

Definition at line 116 of file PeakDataTest.cpp.

117{
118 PeakelPtr pkl(new Peakel);
119 pkl->mz = 432.1;
120 pkl->retentionTime = 1234.56;
121 pkl->maxIntensity = 9876.54;
122 pkl->totalIntensity = 32123.45;
123 pkl->mzVariance = 6.023;
124
125 PeakFamily peakFamily = initializePeakFamily();
126
127 pkl->peaks = peakFamily.peaks;
128
129 return pkl;
130}
boost::shared_ptr< Peakel > PeakelPtr
Definition PeakData.hpp:242
struct for an eluted peak (PEAK ELution)
Definition PeakData.hpp:212

References initializePeakFamily(), and pwiz::data::peakdata::PeakFamily::peaks.

Referenced by testFeature(), and testPeakel().

◆ testPeakEquality()

void testPeakEquality ( )

Definition at line 133 of file PeakDataTest.cpp.

134{
135 if (os_) *os_ << "testPeakEquality()" <<endl;
136
137 Peak peak;
138
139 peak.id = 5;
140 peak.mz = 1;
141 peak.retentionTime = 1.5;
142 peak.intensity = 2;
143 peak.area = 3;
144 peak.error = 4;
145
146 Peak peak2 = peak;
147
148 unit_assert(peak == peak2);
150 unit_assert(peak != peak2);
151 peak2.attributes[Peak::Attribute_Phase] = 4.20;
152 peak2.attributes[Peak::Attribute_Decay] = 6.66;
153 unit_assert(peak != peak2);
155 unit_assert(peak == peak2);
156}
ostream * os_
#define unit_assert(x)
Definition unit.hpp:85

References pwiz::data::peakdata::Peak::area, pwiz::data::peakdata::Peak::Attribute_Decay, pwiz::data::peakdata::Peak::Attribute_Phase, pwiz::data::peakdata::Peak::attributes, pwiz::data::peakdata::Peak::error, pwiz::data::peakdata::Peak::id, pwiz::data::peakdata::Peak::intensity, pwiz::data::peakdata::Peak::mz, os_, pwiz::data::peakdata::Peak::retentionTime, and unit_assert.

Referenced by test().

◆ testPeak()

void testPeak ( )

Definition at line 159 of file PeakDataTest.cpp.

160{
161 if (os_) *os_ << "testPeak()" <<endl;
162
163 // instantiate a Peak
164
165 Peak peak;
166
167 peak.id = 5;
168 peak.mz = 1;
169 peak.retentionTime = 1.5;
170 peak.intensity = 2;
171 peak.area = 3;
172 peak.error = 4;
173
174 peak.data.push_back(OrderedPair(1,2));
175 peak.data.push_back(OrderedPair(3,4));
176
180
181 if (os_) *os_ << peak << endl;
182
183 // write out XML to a stream
184
185 ostringstream oss;
186 XMLWriter writer(oss);
187 peak.write(writer);
188
189 // allocate a new Peak
190
191 Peak peakIn;
192 unit_assert(peak != peakIn);
193
194 // read from stream into new Peak
195
196 istringstream iss(oss.str());
197 peakIn.read(iss);
198 if (os_) *os_ << peakIn << endl;
199
200 // verify that new Peak is the same as old Peak
201
202 unit_assert(peak == peakIn);
203}
The XMLWriter class provides simple, tag-level XML syntax writing.
Definition XMLWriter.hpp:48
void write(minimxml::XMLWriter &writer) const
void read(std::istream &is)
std::vector< pwiz::math::OrderedPair > data
Definition PeakData.hpp:63

References pwiz::data::peakdata::Peak::area, pwiz::data::peakdata::Peak::Attribute_Decay, pwiz::data::peakdata::Peak::Attribute_Frequency, pwiz::data::peakdata::Peak::Attribute_Phase, pwiz::data::peakdata::Peak::attributes, pwiz::data::peakdata::Peak::data, pwiz::data::peakdata::Peak::error, pwiz::data::peakdata::Peak::id, pwiz::data::peakdata::Peak::intensity, pwiz::data::peakdata::Peak::mz, os_, pwiz::data::peakdata::Peak::read(), pwiz::data::peakdata::Peak::retentionTime, unit_assert, and pwiz::data::peakdata::Peak::write().

Referenced by test().

◆ testPeakFamily()

void testPeakFamily ( )

Definition at line 206 of file PeakDataTest.cpp.

207{
208 // initialize a PeakFamily
209
211
212 // write out XML to a stream
213
214 ostringstream oss;
215 XMLWriter writer(oss);
216
217
218 jetsons.write(writer);
219
220 // instantiate new PeakFamily
221
222 PeakFamily flintstones;
223
224 // read from stream into new PeakFamily
225 istringstream iss(oss.str());
226 flintstones.read(iss);
227
228 // verify that new PeakFamily is the same as old PeakFamily
229
230 unit_assert(flintstones == jetsons);
231 if (os_) *os_ << "Testing PeakFamily ... " << endl << oss.str() <<endl;
232}
void write(minimxml::XMLWriter &writer) const
void read(std::istream &is)

References initializePeakFamily(), os_, pwiz::data::peakdata::PeakFamily::read(), unit_assert, and pwiz::data::peakdata::PeakFamily::write().

Referenced by test().

◆ testScan()

void testScan ( )

Definition at line 234 of file PeakDataTest.cpp.

235{
236 // initialize a new Scan
237
238 Scan scan = initializeScan();
239
240 // write out XML to a stream
241 ostringstream oss_scan;
242 XMLWriter writer_scan(oss_scan);
243 scan.write(writer_scan);
244
245 // instantiate a second Scan
246 Scan scan2;
247
248 // read it back in
249 istringstream iss_scan(oss_scan.str());
250 scan2.read(iss_scan);
251
252
253
254 // assert that the two Scans are equal
255
256 unit_assert(scan == scan2);
257 if (os_) *os_ << "Testing Scan ... " << endl << oss_scan.str() << endl;
258
259}
void write(minimxml::XMLWriter &writer) const
void read(std::istream &is)

References initializeScan(), os_, pwiz::data::peakdata::Scan::read(), unit_assert, and pwiz::data::peakdata::Scan::write().

Referenced by test().

◆ testSoftware()

void testSoftware ( )

Definition at line 261 of file PeakDataTest.cpp.

262{
263 // initialize a new Software
264
265 Software software = initializeSoftware();
266
267 // write out XML to a stream
268 ostringstream oss_soft;
269 XMLWriter writer_soft(oss_soft);
270 software.write(writer_soft);
271
272 // instantiate another Software
273 Software software2;
274
275 // read it back in
276 istringstream iss_soft(oss_soft.str());
277 software2.read(iss_soft);
278
279 // assert that the two Softwares are equal
280
281 unit_assert(software == software2);
282 if (os_) *os_ << "Testing Software ... " << endl << oss_soft.str() <<endl;
283
284}
void write(minimxml::XMLWriter &xmlWriter) const
void read(std::istream &is)

References initializeSoftware(), os_, pwiz::data::peakdata::Software::read(), unit_assert, and pwiz::data::peakdata::Software::write().

Referenced by test().

◆ testPeakData()

void testPeakData ( )

Definition at line 286 of file PeakDataTest.cpp.

287{
288 // initialize a PeakData
289
291
292 ostringstream oss_pd;
293 XMLWriter writer_pd(oss_pd);
294 pd.write(writer_pd);
295
296 // instantiate another PeakData
297
298 PeakData pd2;
299
300 // read into it
301
302 istringstream iss_pd(oss_pd.str());
303 pd2.read(iss_pd);
304
305 // assert that the two PeakData are equal
306
307 unit_assert(pd == pd2);
308 if (os_) *os_ << "Testing PeakData ... " << endl << oss_pd.str()<<endl;
309
310}
PeakData initializePeakData()
void write(pwiz::minimxml::XMLWriter &xmlWriter) const
void read(std::istream &is)

References initializePeakData(), os_, pwiz::data::peakdata::PeakData::read(), unit_assert, and pwiz::data::peakdata::PeakData::write().

Referenced by test().

◆ testPeakel()

void testPeakel ( )

Definition at line 312 of file PeakDataTest.cpp.

313{
314 // initialize a peakel
315
317
318 // write it out
319 ostringstream oss_pkl;
320 XMLWriter writer_pkl(oss_pkl);
321 dill->write(writer_pkl);
322
323 // instantiate another Peakel
324
325 Peakel gherkin;
326
327 // read into it
328 istringstream iss_pkl(oss_pkl.str());
329 gherkin.read(iss_pkl);
330
331 // assert that the two Peakels are equal
332
333 unit_assert(*dill == gherkin);
334 if (os_) *os_ << "Testing Peakel ... " << endl << oss_pkl.str() << endl;
335}
PeakelPtr initializePeakel()
void read(std::istream &is)

References initializePeakel(), os_, pwiz::data::peakdata::Peakel::read(), and unit_assert.

Referenced by test().

◆ testPeakelAux()

void testPeakelAux ( )

Definition at line 338 of file PeakDataTest.cpp.

339{
340 Peakel p;
341 p.retentionTime = 420;
342 unit_assert(p.retentionTimeMin() == 420);
343 unit_assert(p.retentionTimeMax() == 420);
344
345 p.peaks.resize(2);
346 p.peaks[0].retentionTime = 666;
347 p.peaks[1].retentionTime = 667;
348 unit_assert(p.retentionTimeMin() == 666);
349 unit_assert(p.retentionTimeMax() == 667);
350}
double retentionTimeMin() const
std::vector< Peak > peaks
Definition PeakData.hpp:221
double retentionTimeMax() const

References pwiz::data::peakdata::Peakel::peaks, pwiz::data::peakdata::Peakel::retentionTime, pwiz::data::peakdata::Peakel::retentionTimeMax(), pwiz::data::peakdata::Peakel::retentionTimeMin(), and unit_assert.

Referenced by test().

◆ testPeakelConstruction()

void testPeakelConstruction ( )

Definition at line 353 of file PeakDataTest.cpp.

354{
355 Peak peak(420, 666);
356 Peakel peakel(Peak(420,666));
357 unit_assert(peakel.mz == 420);
358 unit_assert(peakel.retentionTime == 666);
359 unit_assert(peakel.peaks.size() == 1);
360 unit_assert(peakel.peaks[0] == peak);
361}

References pwiz::data::peakdata::Peakel::mz, pwiz::data::peakdata::Peakel::peaks, pwiz::data::peakdata::Peakel::retentionTime, and unit_assert.

Referenced by test().

◆ testFeature()

void testFeature ( )

Definition at line 364 of file PeakDataTest.cpp.

365{
366 // initialize a new Feature
367
368 Feature feature;
369 feature.mz = 1863.0101;
370 feature.retentionTime = 1492.1012;
371 feature.charge = 3;
372 feature.totalIntensity = 1776.0704;
373 feature.rtVariance = 1969.0720;
374 feature.score = 420.0;
375 feature.error = 666.0;
376
377 PeakelPtr stateFair = initializePeakel();
379
380 feature.peakels.push_back(stateFair);
381 feature.peakels.push_back(deli);
382
383 // write it out
384 ostringstream oss_f;
385 XMLWriter writer_f(oss_f);
386 feature.write(writer_f);
387
388 // instantiate another feature
389
390 Feature feature2;
391
392 // read into it
393
394 istringstream iss(oss_f.str());
395 feature2.read(iss);
396
397 // assert that the two Features are equal
398
399 if (os_)
400 {
401 *os_ << "Testing Feature ... " << endl << oss_f.str() << endl;
402 *os_ << "feature2:\n";
403 XMLWriter writer(*os_);
404 feature2.write(writer);
405 }
406
407 unit_assert(feature == feature2);
408}
void read(std::istream &is)
std::vector< PeakelPtr > peakels
Definition PeakData.hpp:274
void write(pwiz::minimxml::XMLWriter &xmlWriter) const

References pwiz::data::peakdata::Feature::charge, pwiz::data::peakdata::Feature::error, initializePeakel(), pwiz::data::peakdata::Feature::mz, os_, pwiz::data::peakdata::Feature::peakels, pwiz::data::peakdata::Feature::read(), pwiz::data::peakdata::Feature::retentionTime, pwiz::data::peakdata::Feature::rtVariance, pwiz::data::peakdata::Feature::score, pwiz::data::peakdata::Feature::totalIntensity, unit_assert, and pwiz::data::peakdata::Feature::write().

Referenced by test().

◆ testFeatureAux()

void testFeatureAux ( )

Definition at line 411 of file PeakDataTest.cpp.

412{
413 Feature feature;
414 feature.retentionTime = 420;
415 unit_assert(feature.retentionTimeMin() == 420);
416 unit_assert(feature.retentionTimeMax() == 420);
417
418 // retention time ranges determined by first two peakels
419
420 PeakelPtr dill(new Peakel);
421 dill->peaks.push_back(Peak(666,419));
422 dill->peaks.push_back(Peak(666,423));
423
424 PeakelPtr sweet(new Peakel);
425 sweet->peaks.push_back(Peak(666,421));
426 sweet->peaks.push_back(Peak(666,424));
427
428 PeakelPtr gherkin(new Peakel);
429 gherkin->peaks.push_back(Peak(666,418));
430 gherkin->peaks.push_back(Peak(666,425));
431
432 feature.peakels.push_back(dill);
433 feature.peakels.push_back(sweet);
434 feature.peakels.push_back(gherkin);
435
436 unit_assert(feature.retentionTimeMin() == 419);
437 unit_assert(feature.retentionTimeMax() == 424);
438}

References pwiz::data::peakdata::Feature::peakels, pwiz::data::peakdata::Feature::retentionTime, pwiz::data::peakdata::Feature::retentionTimeMax(), pwiz::data::peakdata::Feature::retentionTimeMin(), and unit_assert.

Referenced by test().

◆ test()

void test ( )

Definition at line 441 of file PeakDataTest.cpp.

442{
444 testPeak();
445
447 testScan();
448 testSoftware();
449 testPeakData();
450 testPeakel();
453 testFeature();
455}
void testFeatureAux()
void testPeakData()
void testPeakelConstruction()
void testScan()
void testPeakEquality()
void testPeakFamily()
void testPeakelAux()
void testPeakel()
void testPeak()
void testFeature()
void testSoftware()

References testFeature(), testFeatureAux(), testPeak(), testPeakData(), testPeakel(), testPeakelAux(), testPeakelConstruction(), testPeakEquality(), testPeakFamily(), testScan(), and testSoftware().

Referenced by main().

◆ main()

int main ( int  argc,
char *  argv[] 
)

Definition at line 458 of file PeakDataTest.cpp.

459{
460 TEST_PROLOG(argc, argv)
461
462 try
463 {
464 if (argc>1 && !strcmp(argv[1],"-v")) os_ = &cout;
465 if (os_) *os_ << "PeakDataTest\n";
466
467 test();
468 }
469 catch (exception& e)
470 {
471 TEST_FAILED(e.what())
472 }
473 catch (...)
474 {
475 TEST_FAILED("Caught unknown exception.")
476 }
477
479}
void test()
#define TEST_EPILOG
Definition unit.hpp:183
#define TEST_FAILED(x)
Definition unit.hpp:177
#define TEST_PROLOG(argc, argv)
Definition unit.hpp:175

References os_, test(), TEST_EPILOG, TEST_FAILED, and TEST_PROLOG.

Variable Documentation

◆ os_

ostream* os_ = 0