ProteoWizard
Functions | Variables
SpectrumListFactoryTest.cpp File Reference
#include "SpectrumListFactory.hpp"
#include "pwiz/utility/misc/unit.hpp"
#include "pwiz/utility/misc/Std.hpp"
#include <cstring>

Go to the source code of this file.

Functions

void testUsage ()
 
void testWrap ()
 
void testWrapScanTimeRange ()
 
void testWrapSortScanTime ()
 
void testWrapMZWindow ()
 
void testWrapMSLevel ()
 
void testWrapChargeState ()
 
void testWrapChargeStatePredictor ()
 
void testWrapDefaultArrayLength ()
 
void testWrapActivation ()
 
void testWrapMassAnalyzer ()
 
void testWrapPolarity ()
 
void testWrapTitleMaker ()
 
void intializeTinyWithThermoFilter (MSData &msd)
 
void testWrapThermoScanFilter ()
 
void testWrapPrecursorMzSet ()
 
void testWrapMZPresent ()
 
void test ()
 
int main (int argc, char *argv[])
 

Variables

ostream * os_ = 0
 

Function Documentation

◆ testUsage()

void testUsage ( )

Definition at line 39 of file SpectrumListFactoryTest.cpp.

40 {
41  if (os_) *os_ << "SpectrumListFactory::usage():\n" << SpectrumListFactory::usage() << endl;
42 }

References os_, and pwiz::analysis::SpectrumListFactory::usage().

Referenced by test().

◆ testWrap()

void testWrap ( )

Definition at line 45 of file SpectrumListFactoryTest.cpp.

46 {
47  MSData msd;
49 
51 
52  unit_assert(sl.get());
53  unit_assert(sl->size() > 2);
54 
55  // CompassXtract and pwiz data processing
57  unit_assert_operator_equal(1, msd.allDataProcessingPtrs()[1]->processingMethods.size());
58 
59  SpectrumListFactory::wrap(msd, "scanNumber [19,20]");
60  unit_assert(sl->size() == 2);
61 
62  // make sure we can handle config file lines copied from commandline
63  // with quotes intact
64  SpectrumListFactory::wrap(msd, "'index [1,1]'");
65  unit_assert(sl->size() == 1);
66  unit_assert(sl->spectrumIdentity(0).id == "scan=20");
67 
68  vector<double> profileData(sl->spectrum(0)->getMZArray()->data);
69  unit_assert(profileData.size() == 10);
70  unit_assert(profileData[0] == 0);
71  unit_assert(profileData[9] == 18);
72 
74  unit_assert_operator_equal(1, msd.allDataProcessingPtrs()[1]->processingMethods.size());
75 
76  SpectrumListFactory::wrap(msd, "peakPicking true [1,6]"); // backwards compatible syntax
77  SpectrumListFactory::wrap(msd, "peakPicking false"); // backwards compatible syntax
78  SpectrumListFactory::wrap(msd, "peakPicking cwt msLevel=[1,6]");
79  SpectrumListFactory::wrap(msd, "peakPicking cwt snr=1.2 msLevel=2-");
80  SpectrumListFactory::wrap(msd, "peakPicking cwt peakSpace=0.05");
81 
82  vector<double> peakData(sl->spectrum(0)->getMZArray()->data);
83  unit_assert(peakData.size() == 1);
84  unit_assert(peakData[0] == 0);
85 
87  unit_assert_operator_equal(6, msd.allDataProcessingPtrs()[1]->processingMethods.size());
88 }

References pwiz::msdata::MSData::allDataProcessingPtrs(), pwiz::identdata::examples::initializeTiny(), pwiz::msdata::MSData::run, pwiz::msdata::Run::spectrumListPtr, unit_assert, unit_assert_operator_equal, and pwiz::analysis::SpectrumListFactory::wrap().

Referenced by test().

◆ testWrapScanTimeRange()

void testWrapScanTimeRange ( )

Definition at line 91 of file SpectrumListFactoryTest.cpp.

92 {
93  MSData msd;
95 
97  unit_assert(sl.get());
98  unit_assert(sl->size() > 2);
99 
100  double timeHighInSeconds = 5.9 * 60; // between first and second scan
101  ostringstream oss;
102  oss << "scanTime [0," << timeHighInSeconds << "]";
103  SpectrumListFactory::wrap(msd, oss.str());
104  unit_assert(sl->size() == 2);
105  unit_assert(sl->spectrumIdentity(0).id == "scan=19");
106  unit_assert(sl->spectrumIdentity(1).id == "sample=1 period=1 cycle=23 experiment=1"); // not in scan time order (42 seconds)
107 }

References pwiz::identdata::examples::initializeTiny(), pwiz::msdata::MSData::run, pwiz::msdata::Run::spectrumListPtr, unit_assert, and pwiz::analysis::SpectrumListFactory::wrap().

Referenced by test().

◆ testWrapSortScanTime()

void testWrapSortScanTime ( )

Definition at line 110 of file SpectrumListFactoryTest.cpp.

111 {
112  MSData msd;
114 
116  unit_assert(sl.get());
117  unit_assert(sl->size() == 5);
118 
119  sl->spectrum(0)->scanList.scans[0].set(MS_scan_start_time, 35, UO_second);
120  sl->spectrum(2)->scanList.scans[0].set(MS_scan_start_time, 0.5, UO_minute);
121 
122  SpectrumListFactory::wrap(msd, "sortByScanTime");
123  unit_assert(sl->size() == 5);
124  unit_assert(sl->spectrumIdentity(0).id == "scan=21");
125  unit_assert(sl->spectrumIdentity(1).id == "scan=19");
126  unit_assert(sl->spectrumIdentity(2).id == "sample=1 period=1 cycle=23 experiment=1");
127 }

References pwiz::identdata::examples::initializeTiny(), MS_scan_start_time, pwiz::msdata::MSData::run, pwiz::msdata::Run::spectrumListPtr, unit_assert, UO_minute, UO_second, and pwiz::analysis::SpectrumListFactory::wrap().

Referenced by test().

◆ testWrapMZWindow()

void testWrapMZWindow ( )

Definition at line 130 of file SpectrumListFactoryTest.cpp.

131 {
132  MSData msd;
134 
136  unit_assert(sl.get() && sl->size()>2);
137  SpectrumPtr spectrum = sl->spectrum(0, true);
138  vector<MZIntensityPair> data;
139  spectrum->getMZIntensityPairs(data);
140  unit_assert(data.size() == 15);
141 
142  SpectrumListFactory::wrap(msd, "mzWindow [9.5,15]");
143 
144  spectrum = sl->spectrum(0, true);
145  spectrum->getMZIntensityPairs(data);
146  unit_assert(data.size() == 5);
147 
148  spectrum = sl->spectrum(1, true);
149  spectrum->getMZIntensityPairs(data);
150  unit_assert(data.size() == 3);
151 }

References pwiz::identdata::examples::initializeTiny(), pwiz::msdata::MSData::run, pwiz::msdata::Run::spectrumListPtr, unit_assert, and pwiz::analysis::SpectrumListFactory::wrap().

Referenced by test().

◆ testWrapMSLevel()

void testWrapMSLevel ( )

Definition at line 154 of file SpectrumListFactoryTest.cpp.

155 {
156  MSData msd;
158 
160  unit_assert(sl.get());
161  unit_assert_operator_equal(5, sl->size());
162 
163  SpectrumListFactory::wrap(msd, "msLevel 2");
164  unit_assert_operator_equal(2, sl->size());
165  unit_assert_operator_equal("scan=20", sl->spectrumIdentity(0).id);
166 }

References pwiz::identdata::examples::initializeTiny(), pwiz::msdata::MSData::run, pwiz::msdata::Run::spectrumListPtr, unit_assert, unit_assert_operator_equal, and pwiz::analysis::SpectrumListFactory::wrap().

Referenced by test().

◆ testWrapChargeState()

void testWrapChargeState ( )

Definition at line 169 of file SpectrumListFactoryTest.cpp.

170 {
171  {
172  MSData msd;
175 
176  SpectrumListFactory::wrap(msd, "chargeState 2");
177  unit_assert_operator_equal(2, sl->size());
178  unit_assert_operator_equal("scan=20", sl->spectrumIdentity(0).id);
179 
180  SpectrumListFactory::wrap(msd, "chargeState 1");
181  unit_assert_operator_equal(0, sl->size());
182  }
183 
184  {
185  MSData msd;
188 
189  SpectrumListFactory::wrap(msd, "chargeState 0-2");
190  unit_assert_operator_equal(2, sl->size());
191  unit_assert_operator_equal("scan=20", sl->spectrumIdentity(0).id);
192  }
193 }

References pwiz::identdata::examples::initializeTiny(), pwiz::msdata::MSData::run, pwiz::msdata::Run::spectrumListPtr, unit_assert_operator_equal, and pwiz::analysis::SpectrumListFactory::wrap().

Referenced by test().

◆ testWrapChargeStatePredictor()

void testWrapChargeStatePredictor ( )

Definition at line 196 of file SpectrumListFactoryTest.cpp.

197 {
198  {
199  MSData msd;
202 
203  SpectrumListFactory::wrap(msd, "chargeStatePredictor overrideExistingCharge=false maxMultipleCharge=3 minMultipleCharge=2 singleChargeFractionTIC=0.9 maxKnownCharge=4 makeMS2=true");
204  unit_assert_operator_equal(5, sl->size());
205  }
206 }

References pwiz::identdata::examples::initializeTiny(), pwiz::msdata::MSData::run, pwiz::msdata::Run::spectrumListPtr, unit_assert_operator_equal, and pwiz::analysis::SpectrumListFactory::wrap().

Referenced by test().

◆ testWrapDefaultArrayLength()

void testWrapDefaultArrayLength ( )

Definition at line 209 of file SpectrumListFactoryTest.cpp.

210 {
211  // test that the minimum length is 1 (due to 0 being the "unset" value)
212  {
213  MSData msd;
215 
217  unit_assert(sl.get());
218  unit_assert(sl->size() == 5);
219 
220  SpectrumListFactory::wrap(msd, "defaultArrayLength 0-");
221  unit_assert(sl->size() == 4);
222  unit_assert(sl->find("scan=21") == sl->size());
223  }
224 
225  // test filtering out all spectra
226  {
227  MSData msd;
230 
231  SpectrumListFactory::wrap(msd, "defaultArrayLength 100-");
232  unit_assert(sl->size() == 0);
233  }
234 
235  // test filtering out empty spectra
236  {
237  MSData msd;
240 
241  SpectrumListFactory::wrap(msd, "defaultArrayLength 1-");
242  unit_assert(sl->size() == 4);
243  unit_assert(sl->find("scan=21") == sl->size());
244  }
245 
246  // test filtering out spectra with defaultArrayLength > 14
247  {
248  MSData msd;
251 
252  SpectrumListFactory::wrap(msd, "defaultArrayLength 15-");
253  unit_assert(sl->size() == 2);
254  unit_assert(sl->find("scan=20") == sl->size());
255  unit_assert(sl->find("scan=21") == sl->size());
256  }
257 
258  // test filtering out spectra with 0 < defaultArrayLength < 15
259  {
260  MSData msd;
263 
264  SpectrumListFactory::wrap(msd, "defaultArrayLength 1-14");
265  unit_assert(sl->size() == 2);
266  unit_assert(sl->find("scan=20") == 0);
267  }
268 }

References pwiz::identdata::examples::initializeTiny(), pwiz::msdata::MSData::run, pwiz::msdata::Run::spectrumListPtr, unit_assert, and pwiz::analysis::SpectrumListFactory::wrap().

Referenced by test().

◆ testWrapActivation()

void testWrapActivation ( )

Definition at line 270 of file SpectrumListFactoryTest.cpp.

271 {
272  // test filter by CID activation
273  {
274  MSData msd;
276  SpectrumListFactory::wrap(msd, "msLevel 2-");
277  SpectrumListFactory::wrap(msd, "activation CID");
278  unit_assert(msd.run.spectrumListPtr->size() == 1);
279  }
280  // test filter by ETD activation
281  {
282  MSData msd;
284  SpectrumListFactory::wrap(msd, "msLevel 2-");
285  SpectrumListFactory::wrap(msd, "activation ETD");
286  unit_assert(msd.run.spectrumListPtr->size() == 1);
287  }
288  // test filter by HCD activation
289  {
290  MSData msd;
292  SpectrumListFactory::wrap(msd, "msLevel 2-");
293  SpectrumListFactory::wrap(msd, "activation HCD");
294  unit_assert(msd.run.spectrumListPtr->size() == 0);
295  }
296  // test filter by IRMPD activation
297  {
298  MSData msd;
300  SpectrumListFactory::wrap(msd, "msLevel 2-");
301  SpectrumListFactory::wrap(msd, "activation IRMPD");
302  unit_assert(msd.run.spectrumListPtr->size() == 0);
303  }
304  // test invalid argument
305  {
306  MSData msd;
308 
309  unit_assert_throws(SpectrumListFactory::wrap(msd, "activation UNEXPECTED_INPUT"), runtime_error);
310  }
311 }

References pwiz::identdata::examples::initializeTiny(), pwiz::msdata::MSData::run, pwiz::msdata::Run::spectrumListPtr, unit_assert, unit_assert_throws, and pwiz::analysis::SpectrumListFactory::wrap().

Referenced by test().

◆ testWrapMassAnalyzer()

void testWrapMassAnalyzer ( )

Definition at line 313 of file SpectrumListFactoryTest.cpp.

314 {
315  // test filter by ITMS analyzer type
316  {
317  MSData msd;
319 
320  SpectrumListFactory::wrap(msd, "analyzerType ITMS");
321  unit_assert(msd.run.spectrumListPtr->size() == 5);
322  }
323  // test filter by ITMS analyzer type (new syntax)
324  {
325  MSData msd;
327 
328  SpectrumListFactory::wrap(msd, "analyzerType it");
329  unit_assert(msd.run.spectrumListPtr->size() == 5);
330  }
331  // test filter by FTMS analyzer type
332  {
333  MSData msd;
335 
336  SpectrumListFactory::wrap(msd, "analyzer FTMS");
337  unit_assert(msd.run.spectrumListPtr->size() == 0);
338  }
339  // test filter by Orbi analyzer type
340  {
341  MSData msd;
343 
344  SpectrumListFactory::wrap(msd, "analyzer Orbi");
345  unit_assert(msd.run.spectrumListPtr->size() == 0);
346  }
347  // test filter by TOF analyzer type
348  {
349  MSData msd;
351 
352  SpectrumListFactory::wrap(msd, "analyzer TOF");
353  unit_assert(msd.run.spectrumListPtr->size() == 0);
354  }
355  // test invalid argument
356  {
357  MSData msd;
359 
360  unit_assert_throws(SpectrumListFactory::wrap(msd, "analyzer UNEXPECTED_INPUT"), runtime_error)
361  }
362 }

References pwiz::identdata::examples::initializeTiny(), pwiz::msdata::MSData::run, pwiz::msdata::Run::spectrumListPtr, unit_assert, unit_assert_throws, and pwiz::analysis::SpectrumListFactory::wrap().

Referenced by test().

◆ testWrapPolarity()

void testWrapPolarity ( )

Definition at line 364 of file SpectrumListFactoryTest.cpp.

365 {
366  // test filter by positive polarity
367  {
368  MSData msd;
370 
372  unit_assert(sl.get());
373  unit_assert(sl->size() == 5);
374 
375  SpectrumListFactory::wrap(msd, "polarity positive");
376  unit_assert(sl->size() == 3);
377  }
378  // test filter by + polarity
379  {
380  MSData msd;
382 
384  unit_assert(sl.get());
385  unit_assert(sl->size() == 5);
386 
387  SpectrumListFactory::wrap(msd, "polarity +");
388  unit_assert(sl->size() == 3);
389  }
390  // test filter by negative polarity
391  {
392  MSData msd;
394 
396  unit_assert(sl.get());
397  unit_assert(sl->size() == 5);
398 
399  SpectrumListFactory::wrap(msd, "polarity -");
400  unit_assert(sl->size() == 2);
401  }
402  // test invalid argument
403  {
404  MSData msd;
406 
408  unit_assert(sl.get());
409  unit_assert(sl->size() == 5);
410  unit_assert_throws(SpectrumListFactory::wrap(msd, "polarity UNEXPECTED_INPUT"), runtime_error)
411  }
412 }

References pwiz::identdata::examples::initializeTiny(), pwiz::msdata::MSData::run, pwiz::msdata::Run::spectrumListPtr, unit_assert, unit_assert_throws, and pwiz::analysis::SpectrumListFactory::wrap().

Referenced by test().

◆ testWrapTitleMaker()

void testWrapTitleMaker ( )

Definition at line 414 of file SpectrumListFactoryTest.cpp.

415 {
416  MSData msd;
418 
419  {
420  SpectrumListFactory::wrap(msd, "titleMaker <Id>");
422  unit_assert_operator_equal("scan=19", sl->spectrum(0)->cvParam(MS_spectrum_title).value);
423  unit_assert_operator_equal("scan=20", sl->spectrum(1)->cvParam(MS_spectrum_title).value);
424  unit_assert_operator_equal("scan=21", sl->spectrum(2)->cvParam(MS_spectrum_title).value);
425  unit_assert_operator_equal("scan=22", sl->spectrum(3)->cvParam(MS_spectrum_title).value);
426  unit_assert_operator_equal("sample=1 period=1 cycle=23 experiment=1", sl->spectrum(4)->cvParam(MS_spectrum_title).value);
427  }
428 
429  {
430  // the outer titleMaker overrides the inner one
431  SpectrumListFactory::wrap(msd, "titleMaker <Index>; <SpectrumType>, <MsLevel>");
433  unit_assert_operator_equal("0; MS1 spectrum, 1", sl->spectrum(0)->cvParam(MS_spectrum_title).value);
434  unit_assert_operator_equal("1; MSn spectrum, 2", sl->spectrum(1)->cvParam(MS_spectrum_title).value);
435  unit_assert_operator_equal("2; MS1 spectrum, 1", sl->spectrum(2)->cvParam(MS_spectrum_title).value);
436  unit_assert_operator_equal("3; MSn spectrum, 2", sl->spectrum(3)->cvParam(MS_spectrum_title).value);
437  unit_assert_operator_equal("4; MS1 spectrum, 1", sl->spectrum(4)->cvParam(MS_spectrum_title).value);
438  }
439 
440  {
441  SpectrumListFactory::wrap(msd, "titleMaker <ScanNumber> <MsLevel> <ActivationType> <ChargeState> <PrecursorSpectrumId>");
443  unit_assert_operator_equal("19 1 ", sl->spectrum(0)->cvParam(MS_spectrum_title).value);
444  unit_assert_operator_equal("20 2 CID 2 scan=19", sl->spectrum(1)->cvParam(MS_spectrum_title).value);
445  unit_assert_operator_equal("21 1 ", sl->spectrum(2)->cvParam(MS_spectrum_title).value);
446  unit_assert_operator_equal("22 2 ETD/CID 2 scan=19", sl->spectrum(3)->cvParam(MS_spectrum_title).value);
447  unit_assert_operator_equal("5 1 ", sl->spectrum(4)->cvParam(MS_spectrum_title).value);
448  }
449 }

References pwiz::identdata::examples::initializeTiny(), MS_spectrum_title, pwiz::msdata::MSData::run, pwiz::msdata::Run::spectrumListPtr, unit_assert_operator_equal, and pwiz::analysis::SpectrumListFactory::wrap().

Referenced by test().

◆ intializeTinyWithThermoFilter()

void intializeTinyWithThermoFilter ( MSData msd)

Definition at line 451 of file SpectrumListFactoryTest.cpp.

452 {
454  // add some filter data on top of the tiny scan example.
456  for (size_t i=0; i<5; ++i)
457  {
458  SpectrumPtr spectrum = sl->spectrum(i);
459  ostringstream filterLine;
460 
461  if (i == 0) // scan=19
462  filterLine << "FTMS + p NSI SIM ms [595.0000-655.0000]";
463  else if (i == 1) // scan=20
464  filterLine << "FTMS + c NSI Full ms2 " << (i + 4) * 100 << ".0000@etd30.00 [100.0000-2000.0000]";
465  else if (i == 2) // scan=21
466  filterLine << "ITMS + c NSI Full ms2 " << (i + 4) * 100 << ".0000@cid30.00 [100.0000-2000.0000]";
467  else if (i == 3) // scan=22
468  filterLine << "FTMS + p NSI SIM ms [395.0000-1005.0000]";
469  else if (i == 4) // sample=1 period=1 cycle=23 experiment=1
470  filterLine << "ITMS + c NSI Full ms2 " << (i + 4) * 100 << ".0000@hcd30.00 [100.0000-2000.0000]";
471  spectrum->scanList.scans[0].set(MS_filter_string, filterLine.str());
472  }
473 }

References pwiz::identdata::examples::initializeTiny(), MS_filter_string, pwiz::msdata::MSData::run, and pwiz::msdata::Run::spectrumListPtr.

Referenced by testWrapThermoScanFilter().

◆ testWrapThermoScanFilter()

void testWrapThermoScanFilter ( )

Definition at line 475 of file SpectrumListFactoryTest.cpp.

476 {
477  MSData msd;
479  auto originalSL = msd.run.spectrumListPtr;
480 
481  {
482  SpectrumListFactory::wrap(msd, "thermoScanFilter contains include 395.0000-1005.0000");
484  unit_assert(sl->size() == 1);
485  unit_assert(sl->spectrumIdentity(0).id == "scan=22");
486  }
487 
488  {
489  msd.run.spectrumListPtr = originalSL;
490  SpectrumListFactory::wrap(msd, "thermoScanFilter contains exclude 395.0000-1005.0000");
492  cout << sl->size()<<endl;
493  unit_assert(sl->size() == 4);
494  unit_assert(sl->spectrumIdentity(0).id == "scan=19");
495  unit_assert(sl->spectrumIdentity(1).id == "scan=20");
496  unit_assert(sl->spectrumIdentity(2).id == "scan=21");
497  unit_assert(sl->spectrumIdentity(3).id == "sample=1 period=1 cycle=23 experiment=1");
498  }
499 
500  {
501  msd.run.spectrumListPtr = originalSL;
502  SpectrumListFactory::wrap(msd, "thermoScanFilter exact include FTMS + p NSI SIM ms [395.0000-1005.0000]");
504  unit_assert(sl->size() == 1);
505  unit_assert(sl->spectrumIdentity(0).id == "scan=22");
506  }
507 
508  {
509  msd.run.spectrumListPtr = originalSL;
510  SpectrumListFactory::wrap(msd, "thermoScanFilter exact exclude TMS + p NSI SIM ms [395.0000-1005.0000]");
511  // should not exclude anything
513  unit_assert(sl->size() == 5);
514  unit_assert(sl->spectrumIdentity(0).id == "scan=19");
515  unit_assert(sl->spectrumIdentity(1).id == "scan=20");
516  unit_assert(sl->spectrumIdentity(2).id == "scan=21");
517  unit_assert(sl->spectrumIdentity(3).id == "scan=22");
518  unit_assert(sl->spectrumIdentity(4).id == "sample=1 period=1 cycle=23 experiment=1");
519  }
520 }

References intializeTinyWithThermoFilter(), pwiz::msdata::MSData::run, pwiz::msdata::Run::spectrumListPtr, unit_assert, and pwiz::analysis::SpectrumListFactory::wrap().

Referenced by test().

◆ testWrapPrecursorMzSet()

void testWrapPrecursorMzSet ( )

Definition at line 522 of file SpectrumListFactoryTest.cpp.

523 {
524  MSData msd;
526  auto originalSL = msd.run.spectrumListPtr;
527 
528  {
529  SpectrumListFactory::wrap(msd, "mzPrecursors [445]"); // default tolerance does not match to 445.34
531  unit_assert_operator_equal(0, sl->size());
532  }
533 
534  {
535  msd.run.spectrumListPtr = originalSL;
536  SpectrumListFactory::wrap(msd, "mzPrecursors [445] mzTol=1mz");
538  unit_assert_operator_equal(1, sl->size());
539  unit_assert_operator_equal("scan=20", sl->spectrumIdentity(0).id);
540  }
541 
542  {
543  msd.run.spectrumListPtr = originalSL;
544  SpectrumListFactory::wrap(msd, "mzPrecursors [445] mzTol=1.0 mz"); // mzTol should still parse correctly with a space
546  unit_assert_operator_equal(1, sl->size());
547  unit_assert_operator_equal("scan=20", sl->spectrumIdentity(0).id);
548  }
549 
550  {
551  msd.run.spectrumListPtr = originalSL;
552  SpectrumListFactory::wrap(msd, "mzPrecursors [445.34] mode=exclude"); // only 1 MS2 left, but MS1s aren't excluded now
554  unit_assert_operator_equal(4, sl->size());
555  unit_assert_operator_equal("scan=19", sl->spectrumIdentity(0).id);
556  unit_assert_operator_equal("scan=21", sl->spectrumIdentity(1).id);
557  unit_assert_operator_equal("scan=22", sl->spectrumIdentity(2).id);
558  unit_assert_operator_equal("sample=1 period=1 cycle=23 experiment=1", sl->spectrumIdentity(3).id);
559  }
560 
561  {
562  msd.run.spectrumListPtr = originalSL;
563  SpectrumListFactory::wrap(msd, "mzPrecursors [0,445.34]"); // bring back the MS1s explicitly
565  unit_assert_operator_equal(4, sl->size());
566  unit_assert_operator_equal("scan=19", sl->spectrumIdentity(0).id);
567  unit_assert_operator_equal("scan=20", sl->spectrumIdentity(1).id);
568  unit_assert_operator_equal("scan=21", sl->spectrumIdentity(2).id);
569  unit_assert_operator_equal("sample=1 period=1 cycle=23 experiment=1", sl->spectrumIdentity(3).id);
570  }
571 
572  {
573  msd.run.spectrumListPtr = originalSL;
574  SpectrumListFactory::wrap(msd, "mzPrecursors [0,445.34] target=selected");
576  unit_assert_operator_equal(4, sl->size());
577  unit_assert_operator_equal("scan=19", sl->spectrumIdentity(0).id);
578  unit_assert_operator_equal("scan=20", sl->spectrumIdentity(1).id);
579  unit_assert_operator_equal("scan=21", sl->spectrumIdentity(2).id);
580  unit_assert_operator_equal("sample=1 period=1 cycle=23 experiment=1", sl->spectrumIdentity(3).id);
581  }
582 
583  {
584  msd.run.spectrumListPtr = originalSL;
585  SpectrumListFactory::wrap(msd, "mzPrecursors [445.3] target=isolated");
587  unit_assert_operator_equal(1, sl->size());
588  unit_assert_operator_equal("scan=20", sl->spectrumIdentity(0).id);
589  }
590 
591  {
592  msd.run.spectrumListPtr = originalSL;
593  SpectrumListFactory::wrap(msd, "mzPrecursors [445.34] target=isolated"); // tolerance too tight to match to 445.3
595  unit_assert_operator_equal(0, sl->size());
596  }
597 
598  msd.run.spectrumListPtr = originalSL;
599  unit_assert_throws_what(SpectrumListFactory::wrap(msd, "mzPrecursors mode=include"), user_error, "[SpectrumListFactory::filterCreator_mzPrecursors()] expected a list of m/z values formatted like \"[123.4,567.8,789.0]\"");
600 
601  msd.run.spectrumListPtr = originalSL;
602  unit_assert_throws_what(SpectrumListFactory::wrap(msd, "mzPrecursors [0,445.34] target=42"), user_error, "[SpectrumListFactory::filterCreator_mzPrecursors()] invalid value for 'target' parameter: 42");
603 }

References pwiz::identdata::examples::initializeTiny(), pwiz::msdata::MSData::run, pwiz::msdata::Run::spectrumListPtr, unit_assert_operator_equal, unit_assert_throws_what, and pwiz::analysis::SpectrumListFactory::wrap().

Referenced by test().

◆ testWrapMZPresent()

void testWrapMZPresent ( )

Definition at line 605 of file SpectrumListFactoryTest.cpp.

606 {
607  MSData msd;
609  auto originalSL = msd.run.spectrumListPtr;
610 
611  // tiny spectra have simple m/z lists:
612  // s19: 0,1,2,...,15 15,14,13,...,0
613  // s20: 0,2,4,6,...,20 20,18,16,...,0
614  // s21: no data points
615  // s22: 0,2,4,6,...,20 20,18,16,...,0
616  // s23: 0,1,2,...,15 15,14,13,...,0
617 
618  {
619  SpectrumListFactory::wrap(msd, "mzPresent [1.6] type=count threshold=100 orientation=most-intense");
621  unit_assert_operator_equal(4, sl->size());
622  unit_assert_operator_equal("scan=19", sl->spectrumIdentity(0).id);
623  unit_assert_operator_equal("scan=20", sl->spectrumIdentity(1).id);;
624  unit_assert_operator_equal("scan=22", sl->spectrumIdentity(2).id);
625  unit_assert_operator_equal("sample=1 period=1 cycle=23 experiment=1", sl->spectrumIdentity(3).id);
626  }
627 
628  {
629  msd.run.spectrumListPtr = originalSL;
630  SpectrumListFactory::wrap(msd, "mzPresent [1.6] mzTol=1 ppm"); // mzTol should still parse correctly with a space; with this tight tolereance no spectra will match
632  unit_assert_operator_equal(0, sl->size());
633  }
634 
635  {
636  msd.run.spectrumListPtr = originalSL;
637  SpectrumListFactory::wrap(msd, "mzPresent [0]");
639  unit_assert_operator_equal(4, sl->size());
640  }
641 
642  {
643  msd.run.spectrumListPtr = originalSL;
644  SpectrumListFactory::wrap(msd, "mzPresent [0] type=absolute threshold=17 orientation=most-intense mode=include");
646  unit_assert_operator_equal(2, sl->size());
647  unit_assert_operator_equal("scan=20", sl->spectrumIdentity(0).id);
648  unit_assert_operator_equal("scan=22", sl->spectrumIdentity(1).id);
649  }
650 
651  {
652  msd.run.spectrumListPtr = originalSL;
653  SpectrumListFactory::wrap(msd, "mzPresent [0] type=absolute threshold=17 orientation=most-intense mode=exclude");
655  unit_assert_operator_equal(3, sl->size());
656  unit_assert_operator_equal("scan=19", sl->spectrumIdentity(0).id);
657  unit_assert_operator_equal("scan=21", sl->spectrumIdentity(1).id);
658  unit_assert_operator_equal("sample=1 period=1 cycle=23 experiment=1", sl->spectrumIdentity(2).id);
659  }
660 }

References pwiz::identdata::examples::initializeTiny(), pwiz::msdata::MSData::run, pwiz::msdata::Run::spectrumListPtr, unit_assert_operator_equal, and pwiz::analysis::SpectrumListFactory::wrap().

Referenced by test().

◆ test()

void test ( )

◆ main()

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

Definition at line 684 of file SpectrumListFactoryTest.cpp.

685 {
686  TEST_PROLOG(argc, argv)
687 
688  try
689  {
690  if (argc>1 && !strcmp(argv[1],"-v")) os_ = &cout;
691  test();
692  }
693  catch (exception& e)
694  {
695  TEST_FAILED(e.what())
696  }
697  catch (...)
698  {
699  TEST_FAILED("Caught unknown exception.")
700  }
701 
703 }

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

Variable Documentation

◆ os_

ostream* os_ = 0

Definition at line 36 of file SpectrumListFactoryTest.cpp.

Referenced by main(), and testUsage().

pwiz::util::user_error
Definition: Exception.hpp:41
pwiz::msdata::SpectrumListPtr
boost::shared_ptr< SpectrumList > SpectrumListPtr
Definition: MSData.hpp:711
testWrapActivation
void testWrapActivation()
Definition: SpectrumListFactoryTest.cpp:270
unit_assert_throws_what
#define unit_assert_throws_what(x, exception, whatStr)
Definition: unit.hpp:119
unit_assert_throws
#define unit_assert_throws(x, exception)
Definition: unit.hpp:106
testWrapSortScanTime
void testWrapSortScanTime()
Definition: SpectrumListFactoryTest.cpp:110
MS_scan_start_time
MS_scan_start_time
scan start time: The time that an analyzer started a scan, relative to the start of the MS run.
Definition: cv.hpp:309
testWrapScanTimeRange
void testWrapScanTimeRange()
Definition: SpectrumListFactoryTest.cpp:91
pwiz::msdata::MSData::run
Run run
a run in mzML should correspond to a single, consecutive and coherent set of scans on an instrument.
Definition: MSData.hpp:886
testWrapMZWindow
void testWrapMZWindow()
Definition: SpectrumListFactoryTest.cpp:130
testWrapMSLevel
void testWrapMSLevel()
Definition: SpectrumListFactoryTest.cpp:154
UO_second
UO_second
second: A time unit which is equal to the duration of 9 192 631 770 periods of the radiation correspo...
Definition: cv.hpp:13833
unit_assert_operator_equal
#define unit_assert_operator_equal(expected, actual)
Definition: unit.hpp:92
TEST_EPILOG
#define TEST_EPILOG
Definition: unit.hpp:183
testWrapPolarity
void testWrapPolarity()
Definition: SpectrumListFactoryTest.cpp:364
testWrap
void testWrap()
Definition: SpectrumListFactoryTest.cpp:45
testUsage
void testUsage()
Definition: SpectrumListFactoryTest.cpp:39
pwiz::identdata::examples::initializeTiny
PWIZ_API_DECL void initializeTiny(IdentData &mzid)
pwiz::msdata::SpectrumPtr
boost::shared_ptr< Spectrum > SpectrumPtr
Definition: MSData.hpp:573
testWrapPrecursorMzSet
void testWrapPrecursorMzSet()
Definition: SpectrumListFactoryTest.cpp:522
MS_filter_string
MS_filter_string
filter string: A string unique to Thermo instrument describing instrument settings for the scan.
Definition: cv.hpp:2142
testWrapThermoScanFilter
void testWrapThermoScanFilter()
Definition: SpectrumListFactoryTest.cpp:475
pwiz::msdata::Run::spectrumListPtr
SpectrumListPtr spectrumListPtr
all mass spectra and the acquisitions underlying them are described and attached here....
Definition: MSData.hpp:827
TEST_FAILED
#define TEST_FAILED(x)
Definition: unit.hpp:177
TEST_PROLOG
#define TEST_PROLOG(argc, argv)
Definition: unit.hpp:175
pwiz::msdata::MSData::allDataProcessingPtrs
std::vector< DataProcessingPtr > allDataProcessingPtrs() const
return dataProcessingPtrs augmented by the dataProcessingPtr() set in SpectrumList and/or Chromatogra...
testWrapChargeStatePredictor
void testWrapChargeStatePredictor()
Definition: SpectrumListFactoryTest.cpp:196
testWrapTitleMaker
void testWrapTitleMaker()
Definition: SpectrumListFactoryTest.cpp:414
testWrapChargeState
void testWrapChargeState()
Definition: SpectrumListFactoryTest.cpp:169
pwiz::msdata::MSData
This is the root element of ProteoWizard; it represents the mzML element, defined as: intended to cap...
Definition: MSData.hpp:850
unit_assert
#define unit_assert(x)
Definition: unit.hpp:85
intializeTinyWithThermoFilter
void intializeTinyWithThermoFilter(MSData &msd)
Definition: SpectrumListFactoryTest.cpp:451
testWrapMassAnalyzer
void testWrapMassAnalyzer()
Definition: SpectrumListFactoryTest.cpp:313
UO_minute
UO_minute
minute: A time unit which is equal to 60 seconds.
Definition: cv.hpp:13896
test
void test()
Definition: SpectrumListFactoryTest.cpp:663
os_
ostream * os_
Definition: SpectrumListFactoryTest.cpp:36
testWrapMZPresent
void testWrapMZPresent()
Definition: SpectrumListFactoryTest.cpp:605
MS_spectrum_title
MS_spectrum_title
spectrum title: A free-form text title describing a spectrum.
Definition: cv.hpp:3075
testWrapDefaultArrayLength
void testWrapDefaultArrayLength()
Definition: SpectrumListFactoryTest.cpp:209