ProteoWizard
SpectrumListFactoryTest.cpp
Go to the documentation of this file.
1 //
2 // $Id$
3 //
4 //
5 // Original author: Darren Kessner <darren@proteowizard.org>
6 //
7 // Copyright 2008 Spielberg Family Center for Applied Proteomics
8 // Cedars-Sinai Medical Center, Los Angeles, California 90048
9 //
10 // Licensed under the Apache License, Version 2.0 (the "License");
11 // you may not use this file except in compliance with the License.
12 // You may obtain a copy of the License at
13 //
14 // http://www.apache.org/licenses/LICENSE-2.0
15 //
16 // Unless required by applicable law or agreed to in writing, software
17 // distributed under the License is distributed on an "AS IS" BASIS,
18 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
19 // See the License for the specific language governing permissions and
20 // limitations under the License.
21 //
22 
23 
24 #include "SpectrumListFactory.hpp"
27 #include <cstring>
28 
29 
30 using namespace pwiz::analysis;
31 using namespace pwiz::util;
32 using namespace pwiz::cv;
33 using namespace pwiz::msdata;
34 
35 
36 ostream* os_ = 0;
37 
38 
39 void testUsage()
40 {
41  if (os_) *os_ << "SpectrumListFactory::usage():\n" << SpectrumListFactory::usage() << endl;
42 }
43 
44 
45 void testWrap()
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 }
89 
90 
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 }
108 
109 
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 }
128 
129 
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 }
152 
153 
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 }
167 
168 
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 }
194 
195 
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 }
207 
208 
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 }
269 
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 }
312 
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 }
363 
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 }
413 
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 }
450 
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 }
474 
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 }
521 
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 }
604 
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 }
661 
662 
663 void test()
664 {
665  testUsage();
666  testWrap();
670  testWrapMSLevel();
681 }
682 
683 
684 int main(int argc, char* argv[])
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 }
704 
main
int main(int argc, char *argv[])
Definition: SpectrumListFactoryTest.cpp:684
pwiz::util::user_error
Definition: Exception.hpp:40
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
pwiz::cv
Definition: cv.hpp:108
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
pwiz::analysis
Definition: ChromatogramList_Filter.hpp:37
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
pwiz::msdata
Definition: DemuxTypes.hpp:27
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
pwiz::analysis::SpectrumListFactory::wrap
static void wrap(msdata::MSData &msd, const std::string &wrapper, pwiz::util::IterationListenerRegistry *ilr=NULL)
instantiate the SpectrumListWrapper indicated by wrapper
pwiz::util
Definition: almost_equal.hpp:33
TEST_EPILOG
#define TEST_EPILOG
Definition: unit.hpp:183
SpectrumListFactory.hpp
testWrapPolarity
void testWrapPolarity()
Definition: SpectrumListFactoryTest.cpp:364
Std.hpp
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:849
unit.hpp
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
pwiz::analysis::SpectrumListFactory::usage
static std::string usage(bool detailedHelp=true, const char *morehelp_prompt=NULL, int maxLineLength=80)
user-friendly documentation, with option of less or more detail