PeakDataTest.cpp File Reference

#include "PeakData.hpp"
#include "pwiz/utility/misc/unit.hpp"
#include <boost/filesystem/operations.hpp>
#include "pwiz/utility/misc/Std.hpp"

Go to the source code of this file.

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

Variables
ostream *	os_ = 0

---

Function Documentation

PeakFamily initializePeakFamily

(

)

Definition at line 38 of file PeakDataTest.cpp.

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

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

{
    PeakFamily peakFamily;

    peakFamily.mzMonoisotopic = 329.86;
    peakFamily.charge = 3;
    peakFamily.score = 0.11235811;

    Peak peak;
    Peak a;
    Peak boo;

    peak.mz = 329.86;
    a.mz = 109.87;
    boo.mz = 6.022141730;

    peakFamily.peaks.push_back(peak);
    peakFamily.peaks.push_back(a);
    peakFamily.peaks.push_back(boo);
 
    return peakFamily;

}

Scan initializeScan

(

)

Definition at line 62 of file PeakDataTest.cpp.

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

Referenced by initializePeakData(), and testScan().

{
    Scan scan;
    scan.index = 12;
    scan.nativeID = "24";
    scan.scanNumber = 24;
    scan.retentionTime = 12.345;
    scan.observationDuration = 6.78;

    scan.calibrationParameters.A = 987.654;
    scan.calibrationParameters.B = 321.012;
    
    PeakFamily flintstones = initializePeakFamily();
    PeakFamily jetsons = initializePeakFamily();

    scan.peakFamilies.push_back(flintstones);
    scan.peakFamilies.push_back(jetsons);

    return scan;
}

Software initializeSoftware

(

)

Definition at line 83 of file PeakDataTest.cpp.

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

Referenced by initializePeakData(), and testSoftware().

{
    Software software;
    software.name = "World of Warcraft";
    software.version = "Wrath of the Lich King";
    software.source = "Blizzard Entertainment";

    Software::Parameter parameter1("Burke ping","level 70");
    Software::Parameter parameter2("Kate ping", "level 0");

    software.parameters.push_back(parameter1);
    software.parameters.push_back(parameter2);

    return software;

}

PeakData initializePeakData

(

)

Definition at line 100 of file PeakDataTest.cpp.

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

Referenced by testPeakData().

{
    PeakData pd;

    Software software = initializeSoftware();
    pd.software = software;

    Scan scan = initializeScan();

    pd.scans.push_back(scan);
    pd.scans.push_back(scan);

    return pd;

}

PeakelPtr initializePeakel

(

)

Definition at line 116 of file PeakDataTest.cpp.

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

Referenced by testFeature(), and testPeakel().

{
    PeakelPtr pkl(new Peakel);
    pkl->mz = 432.1;
    pkl->retentionTime = 1234.56;
    pkl->maxIntensity = 9876.54;
    pkl->totalIntensity = 32123.45;
    pkl->mzVariance = 6.023;

    PeakFamily peakFamily = initializePeakFamily();
    
    pkl->peaks = peakFamily.peaks;
    
    return pkl;
}

void testPeakEquality

(

)

Definition at line 133 of file PeakDataTest.cpp.

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

Referenced by test().

{
    if (os_) *os_ << "testPeakEquality()" <<endl;

    Peak peak;

    peak.id = 5;
    peak.mz = 1;
    peak.retentionTime = 1.5;
    peak.intensity = 2;
    peak.area = 3;
    peak.error = 4;

    Peak peak2 = peak;

    unit_assert(peak == peak2);
    peak.attributes[Peak::Attribute_Phase] = 4.20;
    unit_assert(peak != peak2);
    peak2.attributes[Peak::Attribute_Phase] = 4.20;
    peak2.attributes[Peak::Attribute_Decay] = 6.66;
    unit_assert(peak != peak2);
    peak.attributes[Peak::Attribute_Decay] = 6.66;
    unit_assert(peak == peak2);
}

void testPeak

(

)

Definition at line 159 of file PeakDataTest.cpp.

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

Referenced by test().

{
    if (os_) *os_ << "testPeak()" <<endl;

    // instantiate a Peak

    Peak peak;

    peak.id = 5;
    peak.mz = 1;
    peak.retentionTime = 1.5;
    peak.intensity = 2;
    peak.area = 3;
    peak.error = 4;

    peak.data.push_back(OrderedPair(1,2));
    peak.data.push_back(OrderedPair(3,4));

    peak.attributes[Peak::Attribute_Frequency] = 5;
    peak.attributes[Peak::Attribute_Phase] = 6;
    peak.attributes[Peak::Attribute_Decay] = 7;

    if (os_) *os_ << peak << endl;

    // write out XML to a stream

    ostringstream oss;
    XMLWriter writer(oss);
    peak.write(writer);

    // allocate a new Peak

    Peak peakIn;
    unit_assert(peak != peakIn);

    // read from stream into new Peak

    istringstream iss(oss.str());
    peakIn.read(iss);
    if (os_) *os_ << peakIn << endl;

    // verify that new Peak is the same as old Peak

    unit_assert(peak == peakIn);
}

void testPeakFamily

(

)

Definition at line 206 of file PeakDataTest.cpp.

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

Referenced by test().

{
    // initialize a PeakFamily
    
    PeakFamily jetsons = initializePeakFamily();

    // write out XML to a stream                                                                                                                                                    

    ostringstream oss;
    XMLWriter writer(oss);


    jetsons.write(writer);

    // instantiate new PeakFamily

    PeakFamily flintstones;

    // read from stream into new PeakFamily                                                                                                                                   
    istringstream iss(oss.str());
    flintstones.read(iss);

    // verify that new PeakFamily is the same as old PeakFamily                                                                 

    unit_assert(flintstones == jetsons);
    if (os_) *os_    << "Testing PeakFamily ... " << endl << oss.str() <<endl;
}

void testScan

(

)

Definition at line 234 of file PeakDataTest.cpp.

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

Referenced by test().

{
    // initialize a new Scan

    Scan scan = initializeScan();

    // write out XML to a stream                                                                                    
    ostringstream oss_scan;
    XMLWriter writer_scan(oss_scan);
    scan.write(writer_scan);

     // instantiate a second Scan
    Scan scan2;

    // read it back in
    istringstream iss_scan(oss_scan.str());
    scan2.read(iss_scan);
    
 

    // assert that the two Scans are equal

    unit_assert(scan == scan2);
    if (os_) *os_    << "Testing Scan ... " << endl << oss_scan.str() << endl;

}

void testSoftware

(

)

Definition at line 261 of file PeakDataTest.cpp.

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

Referenced by test().

{
    // initialize a new Software
    
    Software software = initializeSoftware();

    // write out XML to a stream
    ostringstream oss_soft;
    XMLWriter writer_soft(oss_soft);
    software.write(writer_soft);

    // instantiate another Software
    Software software2;
 
    // read it back in
    istringstream iss_soft(oss_soft.str());
    software2.read(iss_soft);

    // assert that the two Softwares are equal
     
    unit_assert(software == software2);
    if (os_) *os_    << "Testing Software ... " << endl << oss_soft.str() <<endl;

}

void testPeakData

(

)

Definition at line 286 of file PeakDataTest.cpp.

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

Referenced by test().

{
    // initialize a PeakData

    PeakData pd = initializePeakData();

    ostringstream oss_pd;
    XMLWriter writer_pd(oss_pd);
    pd.write(writer_pd);
    
    // instantiate another PeakData

    PeakData pd2;

    // read into it

    istringstream iss_pd(oss_pd.str());
    pd2.read(iss_pd);

    // assert that the two PeakData are equal

    unit_assert(pd == pd2);
    if (os_) *os_    << "Testing PeakData ... " << endl << oss_pd.str()<<endl;

}

void testPeakel

(

)

Definition at line 312 of file PeakDataTest.cpp.

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

Referenced by test().

{
    // initialize a peakel

    PeakelPtr dill = initializePeakel();

    // write it out
    ostringstream oss_pkl;
    XMLWriter writer_pkl(oss_pkl);
    dill->write(writer_pkl);

    // instantiate another Peakel

    Peakel gherkin;
    
    // read into it
    istringstream iss_pkl(oss_pkl.str());
    gherkin.read(iss_pkl);
    
    // assert that the two Peakels are equal

    unit_assert(*dill == gherkin);
    if (os_) *os_ << "Testing Peakel ... " << endl << oss_pkl.str() << endl;
}

void testPeakelAux

(

)

Definition at line 338 of file PeakDataTest.cpp.

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

Referenced by test().

{
    Peakel p;
    p.retentionTime = 420;
    unit_assert(p.retentionTimeMin() == 420);
    unit_assert(p.retentionTimeMax() == 420);

    p.peaks.resize(2);
    p.peaks[0].retentionTime = 666;
    p.peaks[1].retentionTime = 667;
    unit_assert(p.retentionTimeMin() == 666);
    unit_assert(p.retentionTimeMax() == 667);
}

void testPeakelConstruction

(

)

Definition at line 353 of file PeakDataTest.cpp.

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

Referenced by test().

{
    Peak peak(420, 666);
    Peakel peakel(Peak(420,666));
    unit_assert(peakel.mz == 420);
    unit_assert(peakel.retentionTime == 666);
    unit_assert(peakel.peaks.size() == 1);
    unit_assert(peakel.peaks[0] == peak);
}

void testFeature

(

)

Definition at line 364 of file PeakDataTest.cpp.

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

Referenced by test().

{
    //    initialize a new Feature
    
    Feature feature;
    feature.mz = 1863.0101;
    feature.retentionTime = 1492.1012;
    feature.charge = 3;
    feature.totalIntensity = 1776.0704;
    feature.rtVariance = 1969.0720;
    feature.score = 420.0;
    feature.error = 666.0;
    
    PeakelPtr stateFair = initializePeakel();
    PeakelPtr deli = initializePeakel();

    feature.peakels.push_back(stateFair);
    feature.peakels.push_back(deli);

    // write it out
    ostringstream oss_f;
    XMLWriter writer_f(oss_f);
    feature.write(writer_f);

    // instantiate another feature

    Feature feature2;

    // read into it

    istringstream iss(oss_f.str());
    feature2.read(iss);

    // assert that the two Features are equal

    if (os_) 
    {
        *os_ << "Testing Feature ... " << endl << oss_f.str() << endl;
        *os_ << "feature2:\n";
        XMLWriter writer(*os_);
        feature2.write(writer);
    }

    unit_assert(feature == feature2);
}

void testFeatureAux

(

)

Definition at line 411 of file PeakDataTest.cpp.

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

Referenced by test().

{
    Feature feature;
    feature.retentionTime = 420;
    unit_assert(feature.retentionTimeMin() == 420);
    unit_assert(feature.retentionTimeMax() == 420);

    // retention time ranges determined by first two peakels

    PeakelPtr dill(new Peakel);
    dill->peaks.push_back(Peak(666,419));
    dill->peaks.push_back(Peak(666,423));

    PeakelPtr sweet(new Peakel);
    sweet->peaks.push_back(Peak(666,421));
    sweet->peaks.push_back(Peak(666,424));

    PeakelPtr gherkin(new Peakel);
    gherkin->peaks.push_back(Peak(666,418));
    gherkin->peaks.push_back(Peak(666,425));

    feature.peakels.push_back(dill);
    feature.peakels.push_back(sweet);
    feature.peakels.push_back(gherkin);

    unit_assert(feature.retentionTimeMin() == 419);
    unit_assert(feature.retentionTimeMax() == 424);
}

void test

(

)

Definition at line 441 of file PeakDataTest.cpp.

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

{
    testPeakEquality();
    testPeak();

    testPeakFamily();
    testScan();
    testSoftware();
    testPeakData();
    testPeakel();
    testPeakelAux();
    testPeakelConstruction();
    testFeature();
    testFeatureAux();
}

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

Definition at line 458 of file PeakDataTest.cpp.

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

{
    TEST_PROLOG(argc, argv)

    try
    {
        if (argc>1 && !strcmp(argv[1],"-v")) os_ = &cout;
        if (os_) *os_ << "PeakDataTest\n";
         
            test(); 
    }
    catch (exception& e)
    {
        TEST_FAILED(e.what())
    }
    catch (...)
    {
        TEST_FAILED("Caught unknown exception.")
    }

    TEST_EPILOG
}

---

Variable Documentation

ostream* os_ = 0

Definition at line 36 of file PeakDataTest.cpp.