ProteoWizard
Functions | Variables
SpectrumList_MSn_Test.cpp File Reference
#include "SpectrumList_MSn.hpp"
#include "Serializer_MSn.hpp"
#include "TextWriter.hpp"
#include "pwiz/utility/minimxml/XMLWriter.hpp"
#include "pwiz/utility/misc/unit.hpp"
#include "pwiz/utility/misc/Std.hpp"
#include "pwiz/utility/misc/Base64.hpp"
#include <iostream>
#include <iterator>
#include <cstring>

Go to the source code of this file.

Functions

void test (SpectrumListPtr sl, int msLevel)
 
void test_v3 (SpectrumListPtr sl, int msLevel)
 
int main (int argc, char *argv[])
 

Variables

ostream * os_ = 0
 
const char * testMS1
 
const char * testBMS1
 
const char * testCMS1_v3
 
const char * testMS2
 
const char * testBMS2
 
const char * testCMS2
 
const char * testMS2_v3
 
const char * testCMS2_v3
 

Function Documentation

§ test()

void test ( SpectrumListPtr  sl,
int  msLevel 
)

Definition at line 549 of file SpectrumList_MSn_Test.cpp.

References pwiz::data::CVParam::cvid, MS_base_peak_intensity, MS_charge_state, MS_intensity_array, MS_isolation_window_target_m_z, MS_m_z_array, MS_ms_level, MS_possible_charge_state, MS_scan_start_time, MS_total_ion_current, os_, unit_assert, unit_assert_equal, pwiz::data::CVParam::value, and pwiz::identdata::IO::write().

Referenced by main().

550 {
551  if (os_)
552  {
553  TextWriter write(*os_);
554  write(*sl);
555  *os_ << endl;
556  }
557 
558  // check easy functions
559 
560  unit_assert(sl.get());
561  unit_assert(sl->size() == 2);
562  unit_assert(sl->find("scan=116") == 0);
563  unit_assert(sl->find("scan=118") == 1);
564 
565  // check scan 0
566 
567  unit_assert(sl->spectrumIdentity(0).index == 0);
568  unit_assert(sl->spectrumIdentity(0).id == "scan=116");
569  unit_assert(sl->spectrumIdentity(0).sourceFilePosition != -1);
570 
571  SpectrumPtr s = sl->spectrum(0, false);
572 
573  unit_assert(s.get());
574  unit_assert(s->id == "scan=116");
575  unit_assert(s->index == 0);
576  unit_assert(s->sourceFilePosition != -1);
577  unit_assert(s->cvParam(MS_ms_level).valueAs<int>() == msLevel);
578  unit_assert_equal(s->cvParam(MS_total_ion_current).valueAs<double>(), 385.4, 5e-1);
579  unit_assert_equal(s->cvParam(MS_base_peak_intensity).valueAs<double>(), 65.0, 5e-1);
580 
581  if (msLevel == 1)
582  {
583  unit_assert(s->precursors.size() == 0);
584  }
585  else
586  {
587  unit_assert(s->precursors.size() == 1);
588  Precursor& precursor0 = s->precursors[0];
589  unit_assert(precursor0.selectedIons.size() == 1);
590  unit_assert_equal(precursor0.isolationWindow.cvParam(MS_isolation_window_target_m_z).valueAs<double>(), 536.39, 5e-2);
591 
592  // This test spectrum only has possible charge states (2 total, values 2,3)
593  unit_assert(precursor0.selectedIons[0].cvParam(MS_charge_state).value.empty());
594  vector<string> charges;
595  BOOST_FOREACH(CVParam& param, precursor0.selectedIons[0].cvParams)
596  {
597  if (param.cvid == MS_possible_charge_state)
598  {
599  charges.push_back(param.value);
600  }
601  }
602  unit_assert(charges.size() == 2);
603  vector<string>::const_iterator charge_it = charges.begin();
604  unit_assert(*charge_it == "2");
605  unit_assert(*(++charge_it) == "3");
606  }
607 
608  unit_assert(s->defaultArrayLength == 106);
609  unit_assert(s->binaryDataArrayPtrs.size() == 2);
610  unit_assert(s->binaryDataArrayPtrs[0]->hasCVParam(MS_m_z_array));
611  unit_assert(s->binaryDataArrayPtrs[1]->hasCVParam(MS_intensity_array));
612  unit_assert(s->binaryDataArrayPtrs[0]->data.empty() && s->binaryDataArrayPtrs[1]->data.empty());
613 
614  s = sl->spectrum(0, true);
615  unit_assert(s->defaultArrayLength == 106);
616  unit_assert(s->binaryDataArrayPtrs.size() == 2);
617  unit_assert(!s->binaryDataArrayPtrs[0]->data.empty() && !s->binaryDataArrayPtrs[1]->data.empty());
618 
619  vector<MZIntensityPair> pairs;
620  s->getMZIntensityPairs(pairs);
621 
622  if (os_)
623  {
624  *os_ << "scan 0:\n";
625  copy(pairs.begin(), pairs.end(), ostream_iterator<MZIntensityPair>(*os_, "\n"));
626  *os_ << endl;
627  }
628 
629 
630  // check scan 1
631 
632  unit_assert(sl->spectrumIdentity(1).index == 1);
633  unit_assert(sl->spectrumIdentity(1).id == "scan=118");
634 
635  s = sl->spectrum(1, true);
636  unit_assert(s.get());
637  unit_assert(s->id == "scan=118");
638  unit_assert(s->index == 1);
639  unit_assert(s->sourceFilePosition != -1);
640  unit_assert(s->cvParam(MS_ms_level).valueAs<int>() == msLevel);
641  unit_assert(s->scanList.scans.size() == 1);
642  unit_assert_equal(s->scanList.scans[0].cvParam(MS_scan_start_time).timeInSeconds(), 0.4573*60, 5e-4);
643 
644  if (msLevel == 1)
645  {
646  unit_assert(s->precursors.size() == 0);
647  }
648  else
649  {
650  unit_assert(s->precursors.size() == 1);
651  Precursor& precursor1 = s->precursors[0];
652  unit_assert(precursor1.selectedIons.size() == 1);
653  unit_assert_equal(precursor1.isolationWindow.cvParam(MS_isolation_window_target_m_z).valueAs<double>(), 464.98, 1e-5);
654 
655  // This test spectrum only has possible charge states (2 total, values 2,3)
656  unit_assert(precursor1.selectedIons[0].cvParam(MS_charge_state).value.empty());
657  vector<string> charges;
658  BOOST_FOREACH(CVParam& param, precursor1.selectedIons[0].cvParams)
659  {
660  if (param.cvid == MS_possible_charge_state)
661  {
662  charges.push_back(param.value);
663  }
664  }
665  unit_assert(charges.size() == 2);
666  vector<string>::const_iterator charge_it = charges.begin();
667  unit_assert(*charge_it == "2");
668  unit_assert(*(++charge_it) == "3");
669  }
670 
671  unit_assert(s->defaultArrayLength == 85);
672 
673  pairs.clear();
674  s->getMZIntensityPairs(pairs);
675 
676  unit_assert(s->defaultArrayLength == pairs.size());
677 
678  if (os_)
679  {
680  *os_ << "scan 1:\n";
681  copy(pairs.begin(), pairs.end(), ostream_iterator<MZIntensityPair>(*os_, "\n"));
682  *os_ << endl;
683  }
684 }
MS_charge_state
charge state: The charge state of the ion, single or multiple and positive or negatively charged...
Definition: cv.hpp:235
std::string value
Definition: ParamTypes.hpp:47
MS_base_peak_intensity
base peak intensity: The intensity of the greatest peak in the mass spectrum.
Definition: cv.hpp:1969
The method of precursor ion selection and activation.
Definition: MSData.hpp:310
boost::shared_ptr< Spectrum > SpectrumPtr
Definition: MSData.hpp:569
MS_total_ion_current
total ion current: The sum of all the separate ion currents carried by the ions of different m/z cont...
Definition: cv.hpp:1255
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:148
#define unit_assert_equal(x, y, epsilon)
Definition: unit.hpp:99
MS_ms_level
ms level: Stages of ms achieved in a multi stage mass spectrometry experiment.
Definition: cv.hpp:1987
MS_intensity_array
intensity array: A data array of intensity values.
Definition: cv.hpp:1999
MS_m_z_array
m/z array: A data array of m/z values.
Definition: cv.hpp:1996
PWIZ_API_DECL void write(minimxml::XMLWriter &writer, const CV &cv)
MS_isolation_window_target_m_z
isolation window target m/z: The primary or reference m/z about which the isolation window is defined...
Definition: cv.hpp:3028
ostream * os_
MS_possible_charge_state
possible charge state: A possible charge state of the ion in a situation where the charge of an ion i...
Definition: cv.hpp:2419
#define unit_assert(x)
Definition: unit.hpp:85
represents a tag-value pair, where the tag comes from the controlled vocabulary
Definition: ParamTypes.hpp:44

§ test_v3()

void test_v3 ( SpectrumListPtr  sl,
int  msLevel 
)

Definition at line 686 of file SpectrumList_MSn_Test.cpp.

References pwiz::data::CVParam::cvid, pwiz::data::ParamContainer::cvParams, MS_accurate_mass_OBSOLETE, MS_base_peak_intensity, MS_charge_state, MS_intensity_array, MS_isolation_window_target_m_z, MS_m_z_array, MS_ms_level, MS_possible_charge_state, MS_scan_start_time, MS_selected_ion_m_z, MS_total_ion_current, os_, unit_assert, unit_assert_equal, pwiz::data::CVParam::value, and pwiz::identdata::IO::write().

Referenced by main().

687 {
688  if (os_)
689  {
690  TextWriter write(*os_);
691  write(*sl);
692  *os_ << endl;
693  }
694 
695  // check easy functions
696 
697  unit_assert(sl.get());
698  unit_assert(sl->size() == 2);
699  unit_assert(sl->find("scan=36") == 0);
700  unit_assert(sl->find("scan=508") == 1);
701 
702  // check scan 0
703 
704  unit_assert(sl->spectrumIdentity(0).index == 0);
705  unit_assert(sl->spectrumIdentity(0).id == "scan=36");
706  unit_assert(sl->spectrumIdentity(0).sourceFilePosition != -1);
707 
708  SpectrumPtr s = sl->spectrum(0, false);
709 
710  unit_assert(s.get());
711  unit_assert(s->id == "scan=36");
712  unit_assert(s->index == 0);
713  unit_assert(s->sourceFilePosition != -1);
714  unit_assert(s->cvParam(MS_ms_level).valueAs<int>() == msLevel);
715  unit_assert_equal(s->cvParam(MS_total_ion_current).valueAs<double>(), 296.2, 5e-1);
716  unit_assert_equal(s->cvParam(MS_base_peak_intensity).valueAs<double>(), 109.3, 5e-1);
717 
718  if (msLevel == 1)
719  {
720  unit_assert(s->precursors.size() == 0);
721  }
722  else
723  {
724  unit_assert(s->precursors.size() == 1);
725  Precursor& precursor0 = s->precursors[0];
726  unit_assert(precursor0.selectedIons.size() == 1);
727  // isolated precursor m/z on S line
728  unit_assert_equal(precursor0.isolationWindow.cvParam(MS_isolation_window_target_m_z).valueAs<double>(), 612.19, 5e-2);
729  // m/z of calculated accurate mass
730  unit_assert_equal(precursor0.selectedIons[0].cvParam(MS_selected_ion_m_z).valueAs<double>(), 611.1855, 5e-2);
731 
732  // This test spectrum one charge state, so no possible charge states
733  unit_assert(precursor0.selectedIons[0].cvParam(MS_possible_charge_state).value.empty());
734  vector<string> charges;
735  vector<double> masses;
736  BOOST_FOREACH(CVParam& param, precursor0.selectedIons[0].cvParams)
737  {
738  if (param.cvid == MS_charge_state)
739  {
740  charges.push_back(param.value);
741  }
742  if (param.cvid == MS_accurate_mass_OBSOLETE)
743  {
744  masses.push_back(lexical_cast<double>(param.value));
745  }
746  }
747  unit_assert(charges.size() == 1);
748  vector<string>::const_iterator charge_it = charges.begin();
749  unit_assert(*charge_it == "1");
750 
751  unit_assert(masses.size() == 1);
752  vector<double>::const_iterator mass_it = masses.begin();
753  unit_assert_equal(*mass_it, 611.1855, 5e-4);
754  }
755 
756  unit_assert(s->defaultArrayLength == 25);
757  unit_assert(s->binaryDataArrayPtrs.size() == 2);
758  unit_assert(s->binaryDataArrayPtrs[0]->hasCVParam(MS_m_z_array));
759  unit_assert(s->binaryDataArrayPtrs[1]->hasCVParam(MS_intensity_array));
760  unit_assert(s->binaryDataArrayPtrs[0]->data.empty() && s->binaryDataArrayPtrs[1]->data.empty());
761 
762  s = sl->spectrum(0, true);
763  unit_assert(s->defaultArrayLength == 25);
764  unit_assert(s->binaryDataArrayPtrs.size() == 2);
765  unit_assert(!s->binaryDataArrayPtrs[0]->data.empty() && !s->binaryDataArrayPtrs[1]->data.empty());
766 
767  vector<MZIntensityPair> pairs;
768  s->getMZIntensityPairs(pairs);
769 
770  if (os_)
771  {
772  *os_ << "scan 0:\n";
773  copy(pairs.begin(), pairs.end(), ostream_iterator<MZIntensityPair>(*os_, "\n"));
774  *os_ << endl;
775  }
776 
777 
778  // check scan 1
779 
780  unit_assert(sl->spectrumIdentity(1).index == 1);
781  unit_assert(sl->spectrumIdentity(1).id == "scan=508");
782 
783  s = sl->spectrum(1, true);
784  unit_assert(s.get());
785  unit_assert(s->id == "scan=508");
786  unit_assert(s->index == 1);
787  unit_assert(s->sourceFilePosition != -1);
788  unit_assert(s->cvParam(MS_ms_level).valueAs<int>() == msLevel);
789  unit_assert(s->scanList.scans.size() == 1);
790  unit_assert_equal(s->scanList.scans[0].cvParam(MS_scan_start_time).timeInSeconds()/60, 6.2752, 5e-4);
791 
792  if (msLevel == 1)
793  {
794  unit_assert(s->precursors.size() == 0);
795  }
796  else
797  {
798  unit_assert(s->precursors.size() == 1);
799  Precursor& precursor1 = s->precursors[0];
800  unit_assert(precursor1.selectedIons.size() == 2);
801  // precursor m/z on S line
802  unit_assert_equal(precursor1.isolationWindow.cvParam(MS_isolation_window_target_m_z).valueAs<double>(), 441.23, 5e-2);
803  // m/z computed from accurate mass on Z line
804  unit_assert_equal(precursor1.selectedIons[0].cvParam(MS_selected_ion_m_z).valueAs<double>(), 440.2471843, 1e-4);
805 
806  // This test spectrum has two charge states, both known so no possible charges
807  unit_assert(precursor1.selectedIons[0].cvParam(MS_possible_charge_state).value.empty());
808  vector<string> charges;
809  vector<double> masses;
810  BOOST_FOREACH(SelectedIon& si, precursor1.selectedIons)
811  {
812  BOOST_FOREACH(CVParam& param, si.cvParams)
813  {
814  if (param.cvid == MS_charge_state)
815  {
816  charges.push_back(param.value);
817  }
818  if (param.cvid == MS_accurate_mass_OBSOLETE)
819  {
820  masses.push_back(lexical_cast<double>(param.value));
821  }
822  }
823  }
824  unit_assert(charges.size() == 2);
825  vector<string>::const_iterator charge_it = charges.begin();
826  unit_assert(*charge_it == "3");
827  unit_assert(*(++charge_it) == "2");
828 
829  unit_assert(masses.size() == 2);
830  vector<double>::const_iterator mass_it = masses.begin();
831  unit_assert_equal(*mass_it, 1318.7270, 5e-4);
832  unit_assert_equal(*(++mass_it), 880.4527, 5e-4);
833  }
834 
835  unit_assert(s->defaultArrayLength == 28);
836 
837  pairs.clear();
838  s->getMZIntensityPairs(pairs);
839 
840  unit_assert(s->defaultArrayLength == pairs.size());
841 
842  if (os_)
843  {
844  *os_ << "scan 1:\n";
845  copy(pairs.begin(), pairs.end(), ostream_iterator<MZIntensityPair>(*os_, "\n"));
846  *os_ << endl;
847  }
848 }
MS_charge_state
charge state: The charge state of the ion, single or multiple and positive or negatively charged...
Definition: cv.hpp:235
std::string value
Definition: ParamTypes.hpp:47
MS_base_peak_intensity
base peak intensity: The intensity of the greatest peak in the mass spectrum.
Definition: cv.hpp:1969
The method of precursor ion selection and activation.
Definition: MSData.hpp:310
boost::shared_ptr< Spectrum > SpectrumPtr
Definition: MSData.hpp:569
MS_total_ion_current
total ion current: The sum of all the separate ion currents carried by the ions of different m/z cont...
Definition: cv.hpp:1255
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:148
#define unit_assert_equal(x, y, epsilon)
Definition: unit.hpp:99
MS_ms_level
ms level: Stages of ms achieved in a multi stage mass spectrometry experiment.
Definition: cv.hpp:1987
MS_selected_ion_m_z
selected ion m/z: Mass-to-charge ratio of an selected ion.
Definition: cv.hpp:2749
MS_intensity_array
intensity array: A data array of intensity values.
Definition: cv.hpp:1999
MS_m_z_array
m/z array: A data array of m/z values.
Definition: cv.hpp:1996
PWIZ_API_DECL void write(minimxml::XMLWriter &writer, const CV &cv)
std::vector< CVParam > cvParams
a collection of controlled vocabulary terms
Definition: ParamTypes.hpp:250
MS_isolation_window_target_m_z
isolation window target m/z: The primary or reference m/z about which the isolation window is defined...
Definition: cv.hpp:3028
ostream * os_
MS_possible_charge_state
possible charge state: A possible charge state of the ion in a situation where the charge of an ion i...
Definition: cv.hpp:2419
MS_accurate_mass_OBSOLETE
accurate mass: An experimentally determined mass that is can be to determine a unique elemental formu...
Definition: cv.hpp:838
#define unit_assert(x)
Definition: unit.hpp:85
represents a tag-value pair, where the tag comes from the controlled vocabulary
Definition: ParamTypes.hpp:44

§ main()

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

Definition at line 850 of file SpectrumList_MSn_Test.cpp.

References pwiz::msdata::SpectrumList_MSn::create(), pwiz::msdata::MSData::instrumentConfigurationPtrs, MS_LCQ_Deca, pwiz::msdata::MSn_Type_BMS1, pwiz::msdata::MSn_Type_BMS2, pwiz::msdata::MSn_Type_CMS1, pwiz::msdata::MSn_Type_CMS2, pwiz::msdata::MSn_Type_MS1, pwiz::msdata::MSn_Type_MS2, os_, test(), TEST_EPILOG, TEST_FAILED, TEST_PROLOG, test_v3(), testBMS1, testBMS2, testCMS1_v3, testCMS2, testCMS2_v3, testMS1, testMS2, testMS2_v3, pwiz::util::Base64::textToBinary(), and pwiz::util::Base64::textToBinarySize().

851 {
852  TEST_PROLOG(argc, argv)
853 
854  try
855  {
856  if (argc>1 && !strcmp(argv[1],"-v")) os_ = &cout;
857 
858  // dummy would normally be read in from file
859  MSData dummy;
861  dummy.instrumentConfigurationPtrs.back()->cvParams.push_back(MS_LCQ_Deca);
862  dummy.instrumentConfigurationPtrs.back()->userParams.push_back(UserParam("doobie", "420"));
863 
864  if (os_)
865  {
866  *os_ << "test()\n";
867  *os_ << "ms1:\n" << testMS1 << endl;
868  *os_ << "ms2:\n" << testMS2 << endl;
869  }
870 
871  // TEST MS1 TEXT FORMAT
872  shared_ptr<istream> isMS1(new istringstream(testMS1));
873  SpectrumListPtr slMS1 = SpectrumList_MSn::create(isMS1, dummy, MSn_Type_MS1);
874  test(slMS1, 1);
875 
876  // TEST BMS1 BINARY FORMAT
877  const string& testBMS1Base64Str = testBMS1;
878  vector<char> binaryBufferBMS1;
879  binaryBufferBMS1.resize(Base64::textToBinarySize(testBMS1Base64Str.size()) + 1, '\0');
880  Base64::textToBinary(testBMS1Base64Str.c_str(), testBMS1Base64Str.size(), &binaryBufferBMS1[0]);
881  string binaryStringBMS1;
882  for (size_t i = 0; i < binaryBufferBMS1.size(); i++)
883  {
884  binaryStringBMS1 += binaryBufferBMS1[i];
885  }
886 
887  shared_ptr<istream> isBMS1(new istringstream(binaryStringBMS1));
888  SpectrumListPtr slBMS1 = SpectrumList_MSn::create(isBMS1, dummy, MSn_Type_BMS1);
889  test(slBMS1, 1);
890 
891  // TEST CMS1 COMPRESSED BINARY FORMAT (version 3)
892  const string& testCMS1_v3Base64Str = testCMS1_v3;
893  vector<char> binaryBufferCMS1_v3;
894  binaryBufferCMS1_v3.resize(Base64::textToBinarySize(testCMS1_v3Base64Str.size()) + 1, '\0');
895  Base64::textToBinary(testCMS1_v3Base64Str.c_str(), testCMS1_v3Base64Str.size(), &binaryBufferCMS1_v3[0]);
896  string binaryStringCMS1_v3;
897  for (size_t i = 0; i < binaryBufferCMS1_v3.size(); i++)
898  {
899  binaryStringCMS1_v3 += binaryBufferCMS1_v3[i];
900  }
901 
902  shared_ptr<istream> isCMS1_v3(new istringstream(binaryStringCMS1_v3));
903  SpectrumListPtr slCMS1_v3 = SpectrumList_MSn::create(isCMS1_v3, dummy, MSn_Type_CMS1);
904  test_v3(slCMS1_v3, 1);
905 
906  // TEST MS2 TEXT FORMAT
907  shared_ptr<istream> isMS2(new istringstream(testMS2));
908  SpectrumListPtr slMS2 = SpectrumList_MSn::create(isMS2, dummy, MSn_Type_MS2);
909  test(slMS2, 2);
910 
911  // TEST BMS2 BINARY FORMAT
912  const string& testBMS2Base64Str = testBMS2;
913  vector<char> binaryBufferBMS2;
914  binaryBufferBMS2.resize(Base64::textToBinarySize(testBMS2Base64Str.size()) + 1, '\0');
915  Base64::textToBinary(testBMS2Base64Str.c_str(), testBMS2Base64Str.size(), &binaryBufferBMS2[0]);
916  string binaryStringBMS2;
917  for (size_t i = 0; i < binaryBufferBMS2.size(); i++)
918  {
919  binaryStringBMS2 += binaryBufferBMS2[i];
920  }
921 
922  shared_ptr<istream> isBMS2(new istringstream(binaryStringBMS2));
923  SpectrumListPtr slBMS2 = SpectrumList_MSn::create(isBMS2, dummy, MSn_Type_BMS2);
924  test(slBMS2, 2);
925 
926  // TEST CMS2 COMPRESSED BINARY FORMAT (version 2)
927  const string& testCMS2Base64Str = testCMS2;
928  vector<char> binaryBufferCMS2;
929  binaryBufferCMS2.resize(Base64::textToBinarySize(testCMS2Base64Str.size()) + 1, '\0');
930  Base64::textToBinary(testCMS2Base64Str.c_str(), testCMS2Base64Str.size(), &binaryBufferCMS2[0]);
931  string binaryStringCMS2;
932  for (size_t i = 0; i < binaryBufferCMS2.size(); i++)
933  {
934  binaryStringCMS2 += binaryBufferCMS2[i];
935  }
936 
937  shared_ptr<istream> isCMS2(new istringstream(binaryStringCMS2));
938  SpectrumListPtr slCMS2 = SpectrumList_MSn::create(isCMS2, dummy, MSn_Type_CMS2);
939  test(slCMS2, 2);
940 
941  // TEST MS2 TEXT FORMAT WITH EZ LINES (version 3)
942  shared_ptr<istream> isMS2_v3(new istringstream(testMS2_v3));
943  SpectrumListPtr slMS2_v3 = SpectrumList_MSn::create(isMS2_v3, dummy, MSn_Type_MS2);
944  test_v3(slMS2_v3, 2);
945 
946  // TEST CMS2 COMPRESSED BINARY FORMAT (version 3)
947  const string& testCMS2_v3Base64Str = testCMS2_v3;
948  vector<char> binaryBufferCMS2_v3;
949  binaryBufferCMS2_v3.resize(Base64::textToBinarySize(testCMS2_v3Base64Str.size()) + 1, '\0');
950  Base64::textToBinary(testCMS2_v3Base64Str.c_str(), testCMS2_v3Base64Str.size(), &binaryBufferCMS2_v3[0]);
951  string binaryStringCMS2_v3;
952  for (size_t i = 0; i < binaryBufferCMS2_v3.size(); i++)
953  {
954  binaryStringCMS2_v3 += binaryBufferCMS2_v3[i];
955  }
956 
957  shared_ptr<istream> isCMS2_v3(new istringstream(binaryStringCMS2_v3));
958  SpectrumListPtr slCMS2_v3 = SpectrumList_MSn::create(isCMS2_v3, dummy, MSn_Type_CMS2);
959  test_v3(slCMS2_v3, 2);
960 
961  }
962  catch (exception& e)
963  {
964  TEST_FAILED(e.what())
965  }
966  catch (...)
967  {
968  TEST_FAILED("Caught unknown exception.")
969  }
970 
972 }
const char * testCMS2
std::vector< InstrumentConfigurationPtr > instrumentConfigurationPtrs
list and descriptions of instrument configurations.
Definition: MSData.hpp:873
const char * testMS2_v3
PWIZ_API_DECL size_t textToBinarySize(size_t charCount)
Returns sufficient buffer size for text->binary conversion.
const char * testMS2
const char * testBMS1
#define TEST_EPILOG
Definition: unit.hpp:182
void test_v3(SpectrumListPtr sl, int msLevel)
MS_LCQ_Deca
LCQ Deca: ThermoFinnigan LCQ Deca.
Definition: cv.hpp:2119
const char * testMS1
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
boost::shared_ptr< SpectrumList > SpectrumListPtr
Definition: MSData.hpp:707
ostream * os_
void test(SpectrumListPtr sl, int msLevel)
Description of a particular hardware configuration of a mass spectrometer. Each configuration MUST ha...
Definition: MSData.hpp:228
boost::shared_ptr< InstrumentConfiguration > InstrumentConfigurationPtr
Definition: MSData.hpp:249
#define TEST_FAILED(x)
Definition: unit.hpp:176
PWIZ_API_DECL size_t textToBinary(const char *from, size_t charCount, void *to)
text -> binary conversion
const char * testCMS2_v3
const char * testCMS1_v3
#define TEST_PROLOG(argc, argv)
Definition: unit.hpp:174
This is the root element of ProteoWizard; it represents the mzML element, defined as: intended to cap...
Definition: MSData.hpp:845
const char * testBMS2

Variable Documentation

§ os_

ostream* os_ = 0

Definition at line 41 of file SpectrumList_MSn_Test.cpp.

Referenced by main(), test(), and test_v3().

§ testMS1

const char* testMS1

Definition at line 43 of file SpectrumList_MSn_Test.cpp.

Referenced by main().

§ testBMS1

const char* testBMS1
Initial value:
=
"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"

Definition at line 246 of file SpectrumList_MSn_Test.cpp.

Referenced by main().

§ testCMS1_v3

const char* testCMS1_v3
Initial value:
=
"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"

Definition at line 250 of file SpectrumList_MSn_Test.cpp.

Referenced by main().

§ testMS2

const char* testMS2

Definition at line 253 of file SpectrumList_MSn_Test.cpp.

Referenced by main().

§ testBMS2

const char* testBMS2
Initial value:
=
"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"

Definition at line 460 of file SpectrumList_MSn_Test.cpp.

Referenced by main().

§ testCMS2

const char* testCMS2
Initial value:
=
"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"

Definition at line 464 of file SpectrumList_MSn_Test.cpp.

Referenced by main().

§ testMS2_v3

const char* testMS2_v3

Definition at line 467 of file SpectrumList_MSn_Test.cpp.

Referenced by main().

§ testCMS2_v3

const char* testCMS2_v3
Initial value:
=
"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"

Definition at line 546 of file SpectrumList_MSn_Test.cpp.

Referenced by main().