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.

550{
551 if (os_)
552 {
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);
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);
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}
ostream * os_
MS_intensity_array
intensity array: A data array of intensity values.
Definition cv.hpp:2151
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:2571
MS_ms_level
ms level: Stages of ms achieved in a multi stage mass spectrometry experiment.
Definition cv.hpp:2139
MS_m_z_array
m/z array: A data array of m/z values.
Definition cv.hpp:2148
MS_charge_state
charge state: The charge state of the ion, single or multiple and positive or negatively charged.
Definition cv.hpp:396
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:3180
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:1407
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
MS_base_peak_intensity
base peak intensity: The intensity of the greatest peak in the mass spectrum.
Definition cv.hpp:2121
PWIZ_API_DECL void write(minimxml::XMLWriter &writer, const CV &cv)
boost::shared_ptr< Spectrum > SpectrumPtr
Definition MSData.hpp:573
represents a tag-value pair, where the tag comes from the controlled vocabulary
value_type valueAs() const
templated value access with type conversion
CVParam cvParam(CVID cvid) const
finds cvid in the container:
The method of precursor ion selection and activation.
Definition MSData.hpp:312
std::vector< SelectedIon > selectedIons
this list of precursor ions that were selected.
Definition MSData.hpp:329
IsolationWindow isolationWindow
this element captures the isolation (or 'selection') window configured to isolate one or more precurs...
Definition MSData.hpp:326
#define unit_assert(x)
Definition unit.hpp:85
#define unit_assert_equal(x, y, epsilon)
Definition unit.hpp:99

References pwiz::data::CVParam::cvid, pwiz::data::ParamContainer::cvParam(), pwiz::msdata::Precursor::isolationWindow, 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_, pwiz::msdata::Precursor::selectedIons, unit_assert, unit_assert_equal, pwiz::data::CVParam::value, and pwiz::data::CVParam::valueAs().

◆ test_v3()

void test_v3 ( SpectrumListPtr  sl,
int  msLevel 
)

Definition at line 686 of file SpectrumList_MSn_Test.cpp.

687{
688 if (os_)
689 {
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
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
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_selected_ion_m_z
selected ion m/z: Mass-to-charge ratio of an selected ion.
Definition cv.hpp:2901
MS_accurate_mass_OBSOLETE
accurate mass: An experimentally determined mass that is can be to determine a unique elemental formu...
Definition cv.hpp:996
std::vector< CVParam > cvParams
a collection of controlled vocabulary terms

References pwiz::data::CVParam::cvid, pwiz::data::ParamContainer::cvParam(), pwiz::data::ParamContainer::cvParams, pwiz::msdata::Precursor::isolationWindow, 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_, pwiz::msdata::Precursor::selectedIons, unit_assert, unit_assert_equal, pwiz::data::CVParam::value, and pwiz::data::CVParam::valueAs().

Referenced by main().

◆ main()

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

Definition at line 850 of file SpectrumList_MSn_Test.cpp.

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));
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));
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));
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));
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));
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
const char * testBMS2
const char * testCMS1_v3
const char * testMS1
const char * testMS2_v3
const char * testBMS1
const char * testCMS2_v3
const char * testMS2
void test_v3(SpectrumListPtr sl, int msLevel)
static SpectrumListPtr create(boost::shared_ptr< std::istream > is, const MSData &msd, MSn_Type filetype)
MS_LCQ_Deca
LCQ Deca: ThermoFinnigan LCQ Deca.
Definition cv.hpp:2271
boost::shared_ptr< SpectrumList > SpectrumListPtr
Definition MSData.hpp:711
boost::shared_ptr< InstrumentConfiguration > InstrumentConfigurationPtr
Definition MSData.hpp:250
PWIZ_API_DECL size_t textToBinary(const char *from, size_t charCount, void *to)
text -> binary conversion
PWIZ_API_DECL size_t textToBinarySize(size_t charCount)
Returns sufficient buffer size for text->binary conversion.
Uncontrolled user parameters (essentially allowing free text). Before using these,...
Description of a particular hardware configuration of a mass spectrometer. Each configuration MUST ha...
Definition MSData.hpp:230
This is the root element of ProteoWizard; it represents the mzML element, defined as: intended to cap...
Definition MSData.hpp:850
std::vector< InstrumentConfigurationPtr > instrumentConfigurationPtrs
list and descriptions of instrument configurations.
Definition MSData.hpp:877
#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 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().

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().