SpectrumListCacheTest.cpp File Reference

#include "pwiz/utility/misc/unit.hpp"
#include "MSDataFile.hpp"
#include "MemoryMRUCache.hpp"
#include "SpectrumListCache.hpp"
#include "pwiz/utility/misc/Std.hpp"
#include "Serializer_MGF.hpp"

Go to the source code of this file.

Functions
ostream &	std::operator<< (ostream &os, SpectrumListCache::CacheType &cache)
void	testMemoryMRUCache ()
SpectrumPtr	makeSpectrumPtr (size_t index, const string &id)
bool	spectrumHasMetadata (const Spectrum &s)
bool	spectrumHasBinaryData (const Spectrum &s)
void	testModeOff ()
void	testModeMetaDataOnly ()
void	testModeBinaryDataOnly ()
void	testModeMetaDataAndBinaryData ()
void	testFileReads (const char *filename)
void	test ()
int	main (int argc, char *argv[])

Variables
ostream *	os_ = 0

---

Function Documentation

void testMemoryMRUCache

(

)

Definition at line 53 of file SpectrumListCacheTest.cpp.

References pwiz::util::mru_list< PtrType, KeyExtractor >::empty(), pwiz::util::mru_list< PtrType, KeyExtractor >::insert(), pwiz::util::mru_list< PtrType, KeyExtractor >::lru(), pwiz::util::mru_list< PtrType, KeyExtractor >::max_size(), MemoryMRUCacheMode_Off, pwiz::util::mru_list< PtrType, KeyExtractor >::mru(), pwiz::util::mru_list< PtrType, KeyExtractor >::size(), unit_assert, and unit_assert_operator_equal.

Referenced by test().

{
    MemoryMRUCache<pair<size_t, SpectrumPtr> > cache(MemoryMRUCacheMode_Off, 2);

    unit_assert_operator_equal(2, cache.max_size());
    unit_assert(cache.empty());
    unit_assert_operator_equal(0, cache.size());

    cache.insert(make_pair(0, SpectrumPtr()));

    unit_assert(!cache.empty());
    unit_assert_operator_equal(1, cache.size());

    cache.insert(make_pair(1, SpectrumPtr()));

    unit_assert_operator_equal(2, cache.size());
    unit_assert_operator_equal(1, cache.mru().first);
    unit_assert_operator_equal(0, cache.lru().first);

    cache.insert(make_pair(0, SpectrumPtr()));

    unit_assert_operator_equal(2, cache.size());
    unit_assert_operator_equal(0, cache.mru().first);
    unit_assert_operator_equal(1, cache.lru().first);

    cache.insert(make_pair(2, SpectrumPtr()));

    unit_assert_operator_equal(2, cache.size());
    unit_assert_operator_equal(2, cache.mru().first);
    unit_assert_operator_equal(0, cache.lru().first);
}

SpectrumPtr makeSpectrumPtr	(	size_t	index,
		const string &	id
	)

Definition at line 86 of file SpectrumListCacheTest.cpp.

References pwiz::msdata::BinaryDataArray::data, MS_ms_level, MS_MSn_spectrum, and MS_number_of_counts.

Referenced by testModeBinaryDataOnly(), testModeMetaDataAndBinaryData(), testModeMetaDataOnly(), and testModeOff().

{
    SpectrumPtr spectrum(new Spectrum);
    spectrum->id = id;
    spectrum->index = index;
    spectrum->set(MS_MSn_spectrum);
    spectrum->set(MS_ms_level, 2);
    spectrum->precursors.push_back(Precursor(123.4));
    spectrum->setMZIntensityArrays(vector<double>(), vector<double>(), MS_number_of_counts);
    BinaryDataArray& mzArray = *spectrum->getMZArray();
    BinaryDataArray& intensityArray = *spectrum->getIntensityArray();
    for (size_t i=0; i < (index+1)*10; ++i)
    {
        mzArray.data.push_back(i);
        intensityArray.data.push_back(i*100);
    }
    spectrum->defaultArrayLength = mzArray.data.size();
    return spectrum;
}

bool spectrumHasMetadata

(

const Spectrum &

s

)

Definition at line 106 of file SpectrumListCacheTest.cpp.

References pwiz::data::ParamContainer::cvParams, pwiz::msdata::Spectrum::dataProcessingPtr, pwiz::msdata::ScanList::empty(), pwiz::data::ParamContainer::paramGroupPtrs, pwiz::msdata::Spectrum::precursors, pwiz::msdata::Spectrum::scanList, pwiz::msdata::Spectrum::sourceFilePtr, and pwiz::data::ParamContainer::userParams.

Referenced by testModeBinaryDataOnly(), testModeMetaDataAndBinaryData(), and testModeMetaDataOnly().

{
    return s.dataProcessingPtr.get() ||
           s.sourceFilePtr.get() ||
           !s.scanList.empty() ||
           !s.precursors.empty() ||
           !s.paramGroupPtrs.empty() ||
           !s.cvParams.empty() ||
           !s.userParams.empty();
}

bool spectrumHasBinaryData

(

const Spectrum &

s

)

Definition at line 117 of file SpectrumListCacheTest.cpp.

References pwiz::msdata::Spectrum::hasBinaryData().

Referenced by testModeBinaryDataOnly(), testModeMetaDataAndBinaryData(), and testModeMetaDataOnly().

{
    return s.hasBinaryData();
}

void testModeOff

(

)

Definition at line 122 of file SpectrumListCacheTest.cpp.

References pwiz::util::mru_list< Item, KeyExtractor >::empty(), makeSpectrumPtr(), MemoryMRUCacheMode_Off, os_, pwiz::msdata::SpectrumListCache::spectrum(), pwiz::msdata::SpectrumListCache::spectrumCache(), and unit_assert.

Referenced by test().

{
    // initialize list
    shared_ptr<SpectrumListSimple> sl(new SpectrumListSimple);
    sl->spectra.push_back(makeSpectrumPtr(0, "S1"));
    sl->spectra.push_back(makeSpectrumPtr(1, "S2"));
    sl->spectra.push_back(makeSpectrumPtr(2, "S3"));
    sl->spectra.push_back(makeSpectrumPtr(3, "S4"));

    // access a series of spectra and make sure the cache behaves appropriately:
    // in off mode, the cache should always be empty

    SpectrumPtr s;

    SpectrumListCache slc(sl, MemoryMRUCacheMode_Off, 2);
    SpectrumListCache::CacheType& cache = slc.spectrumCache();

    unit_assert(cache.empty());

    s = slc.spectrum(0, false);
    s = slc.spectrum(1, true);
    s = slc.spectrum(2, false);
    s = slc.spectrum(3, true);

    if (os_) *os_ << cache << endl;
    unit_assert(cache.empty());
}

void testModeMetaDataOnly

(

)

Definition at line 151 of file SpectrumListCacheTest.cpp.

References pwiz::util::mru_list< Item, KeyExtractor >::empty(), pwiz::util::mru_list< Item, KeyExtractor >::lru(), makeSpectrumPtr(), pwiz::util::mru_list< Item, KeyExtractor >::max_size(), MemoryMRUCacheMode_MetaDataOnly, pwiz::util::mru_list< Item, KeyExtractor >::mru(), os_, pwiz::msdata::Serializer_MGF::read(), pwiz::msdata::MSData::run, pwiz::util::mru_list< Item, KeyExtractor >::size(), pwiz::msdata::SpectrumListCache::spectrum(), pwiz::msdata::SpectrumListCache::spectrumCache(), spectrumHasBinaryData(), spectrumHasMetadata(), pwiz::msdata::Run::spectrumListPtr, unit_assert, unit_assert_operator_equal, and pwiz::msdata::Serializer_MGF::write().

Referenced by test().

{
    // initialize list
    MSData msd;
    shared_ptr<SpectrumListSimple> sl(new SpectrumListSimple);
    sl->spectra.push_back(makeSpectrumPtr(0, "S1"));
    sl->spectra.push_back(makeSpectrumPtr(1, "S2"));
    sl->spectra.push_back(makeSpectrumPtr(2, "S3"));
    sl->spectra.push_back(makeSpectrumPtr(3, "S4"));
    msd.run.spectrumListPtr = sl;

    // SpectrumListSimple returns the same shared_ptrs regardless of caching;
    // serializing to MGF and back will produce different shared_ptrs
    boost::shared_ptr<stringstream> ss(new stringstream);
    Serializer_MGF serializer;
    serializer.write(*ss, msd, 0);
    serializer.read(ss, msd);

    // access a series of spectra and make sure the cache behaves appropriately:
    // in metadata-only mode, entries in the cache should:
    // - always have metadata
    // - never have binary data

    SpectrumPtr s;

    SpectrumListCache slc(msd.run.spectrumListPtr, MemoryMRUCacheMode_MetaDataOnly, 2);
    SpectrumListCache::CacheType& cache = slc.spectrumCache();

    unit_assert(cache.empty());
    unit_assert_operator_equal(2, cache.max_size());

    s = slc.spectrum(0, false);

    // pointers should be equal
    unit_assert_operator_equal(slc.spectrum(0, false), s);

    if (os_) *os_ << cache << endl;
    unit_assert(!cache.empty());
    unit_assert_operator_equal(1, cache.size());
    unit_assert_operator_equal(0, cache.mru().second->index);

    // with-binary-data access should return the binary data, but only cache the metadata
    s = slc.spectrum(1, true);

    if (os_) *os_ << cache << endl;
    unit_assert_operator_equal(2, cache.size());
    unit_assert_operator_equal(1, cache.mru().second->index);
    unit_assert(spectrumHasMetadata(*cache.mru().second));
    unit_assert(!spectrumHasBinaryData(*cache.mru().second));
    unit_assert(spectrumHasMetadata(*cache.lru().second));
    unit_assert_operator_equal(0, cache.lru().second->index);

    s = slc.spectrum(2, false);

    // pointers should be equal
    unit_assert_operator_equal(slc.spectrum(2, false), s);

    if (os_) *os_ << cache << endl;
    unit_assert_operator_equal(2, cache.size());
    unit_assert_operator_equal(2, cache.mru().second->index);
    unit_assert(spectrumHasMetadata(*cache.mru().second));
    unit_assert(!spectrumHasBinaryData(*cache.mru().second));
    unit_assert_operator_equal(1, cache.lru().second->index);

    s = slc.spectrum(3, true);

    if (os_) *os_ << cache << endl;
    unit_assert_operator_equal(2, cache.size());
    unit_assert_operator_equal(3, cache.mru().second->index);
    unit_assert(spectrumHasMetadata(*cache.mru().second));
    unit_assert(!spectrumHasBinaryData(*cache.mru().second));
    unit_assert_operator_equal(2, cache.lru().second->index);
    unit_assert(spectrumHasMetadata(*cache.lru().second));

    s = slc.spectrum(2, true);

    if (os_) *os_ << cache << endl;
    unit_assert_operator_equal(2, cache.size());
    unit_assert_operator_equal(2, cache.mru().second->index);
    unit_assert(spectrumHasMetadata(*cache.mru().second));
    unit_assert(!spectrumHasBinaryData(*cache.mru().second));
    unit_assert_operator_equal(3, cache.lru().second->index);
    unit_assert(spectrumHasMetadata(*cache.lru().second));
}

void testModeBinaryDataOnly

(

)

Definition at line 237 of file SpectrumListCacheTest.cpp.

References pwiz::util::mru_list< Item, KeyExtractor >::empty(), pwiz::util::mru_list< Item, KeyExtractor >::lru(), makeSpectrumPtr(), pwiz::util::mru_list< Item, KeyExtractor >::max_size(), MemoryMRUCacheMode_BinaryDataOnly, pwiz::util::mru_list< Item, KeyExtractor >::mru(), os_, pwiz::msdata::Serializer_MGF::read(), pwiz::msdata::MSData::run, pwiz::util::mru_list< Item, KeyExtractor >::size(), pwiz::msdata::SpectrumListCache::spectrum(), pwiz::msdata::SpectrumListCache::spectrumCache(), spectrumHasBinaryData(), spectrumHasMetadata(), pwiz::msdata::Run::spectrumListPtr, unit_assert, unit_assert_operator_equal, and pwiz::msdata::Serializer_MGF::write().

Referenced by test().

{
    // initialize list
    MSData msd;
    shared_ptr<SpectrumListSimple> sl(new SpectrumListSimple);
    sl->spectra.push_back(makeSpectrumPtr(0, "S1"));
    sl->spectra.push_back(makeSpectrumPtr(1, "S2"));
    sl->spectra.push_back(makeSpectrumPtr(2, "S3"));
    sl->spectra.push_back(makeSpectrumPtr(3, "S4"));
    msd.run.spectrumListPtr = sl;

    // SpectrumListSimple returns the same shared_ptrs regardless of caching;
    // serializing to MGF and back will produce different shared_ptrs
    boost::shared_ptr<stringstream> ss(new stringstream);
    Serializer_MGF serializer;
    serializer.write(*ss, msd, 0);
    serializer.read(ss, msd);

    // access a series of spectra and make sure the cache behaves appropriately:
    // in binary-data-only mode, entries in the cache should:
    // - never have metadata
    // - always have binary data

    SpectrumPtr s;

    SpectrumListCache slc(msd.run.spectrumListPtr, MemoryMRUCacheMode_BinaryDataOnly, 2);
    SpectrumListCache::CacheType& cache = slc.spectrumCache();

    unit_assert(cache.empty());
    unit_assert_operator_equal(2, cache.max_size());

    // metadata-only access should not affect the cache
    s = slc.spectrum(0, false);

    if (os_) *os_ << cache << endl;
    unit_assert(cache.empty());
    unit_assert_operator_equal(0, cache.size());

    // with-binary-data access should be cached without the metadata
    s = slc.spectrum(1, true);

    if (os_) *os_ << cache << endl;
    unit_assert_operator_equal(1, cache.size());
    unit_assert_operator_equal(1, cache.mru().second->index);
    unit_assert(!spectrumHasMetadata(*cache.mru().second));
    unit_assert(spectrumHasBinaryData(*cache.mru().second));

    s = slc.spectrum(2, false);

    if (os_) *os_ << cache << endl;
    unit_assert_operator_equal(1, cache.size());
    unit_assert_operator_equal(1, cache.mru().second->index);
    unit_assert(!spectrumHasMetadata(*cache.mru().second));
    unit_assert(spectrumHasBinaryData(*cache.mru().second));

    s = slc.spectrum(3, true);

    if (os_) *os_ << cache << endl;
    unit_assert_operator_equal(2, cache.size());
    unit_assert_operator_equal(3, cache.mru().second->index);
    unit_assert(!spectrumHasMetadata(*cache.mru().second));
    unit_assert(spectrumHasBinaryData(*cache.mru().second));
    unit_assert_operator_equal(1, cache.lru().second->index);
    unit_assert(!spectrumHasMetadata(*cache.lru().second));
    unit_assert(spectrumHasBinaryData(*cache.lru().second));

    s = slc.spectrum(1, true);

    if (os_) *os_ << cache << endl;
    unit_assert_operator_equal(2, cache.size());
    unit_assert_operator_equal(1, cache.mru().second->index);
    unit_assert(!spectrumHasMetadata(*cache.mru().second));
    unit_assert(spectrumHasBinaryData(*cache.mru().second));
    unit_assert_operator_equal(3, cache.lru().second->index);
    unit_assert(!spectrumHasMetadata(*cache.lru().second));
    unit_assert(spectrumHasBinaryData(*cache.lru().second));
}

void testModeMetaDataAndBinaryData

(

)

Definition at line 316 of file SpectrumListCacheTest.cpp.

References pwiz::util::mru_list< Item, KeyExtractor >::empty(), pwiz::util::mru_list< Item, KeyExtractor >::lru(), makeSpectrumPtr(), pwiz::util::mru_list< Item, KeyExtractor >::max_size(), pwiz::util::mru_list< Item, KeyExtractor >::mru(), os_, pwiz::msdata::Serializer_MGF::read(), pwiz::msdata::MSData::run, pwiz::util::mru_list< Item, KeyExtractor >::size(), pwiz::msdata::SpectrumListCache::spectrum(), pwiz::msdata::SpectrumListCache::spectrumCache(), spectrumHasBinaryData(), spectrumHasMetadata(), pwiz::msdata::Run::spectrumListPtr, unit_assert, unit_assert_operator_equal, and pwiz::msdata::Serializer_MGF::write().

Referenced by test().

{
    // initialize list
    MSData msd;
    shared_ptr<SpectrumListSimple> sl(new SpectrumListSimple);
    sl->spectra.push_back(makeSpectrumPtr(0, "S1"));
    sl->spectra.push_back(makeSpectrumPtr(1, "S2"));
    sl->spectra.push_back(makeSpectrumPtr(2, "S3"));
    sl->spectra.push_back(makeSpectrumPtr(3, "S4"));
    msd.run.spectrumListPtr = sl;

    // SpectrumListSimple returns the same shared_ptrs regardless of caching;
    // serializing to MGF and back will produce different shared_ptrs
    boost::shared_ptr<stringstream> ss(new stringstream);
    Serializer_MGF serializer;
    serializer.write(*ss, msd, 0);
    serializer.read(ss, msd);

    // access a series of spectra and make sure the cache behaves appropriately:
    // in metadata-and-binary-data mode, entries in the cache should:
    // - always have metadata
    // - always have binary data

    SpectrumPtr s;

    SpectrumListCache slc(msd.run.spectrumListPtr, MemoryMRUCacheMode_MetaDataAndBinaryData, 2);
    SpectrumListCache::CacheType& cache = slc.spectrumCache();

    unit_assert(cache.empty());
    unit_assert_operator_equal(2, cache.max_size());

    // metadata-only access should not affect the cache
    s = slc.spectrum(0, false);

    if (os_) *os_ << cache << endl;
    unit_assert(cache.empty());
    unit_assert_operator_equal(0, cache.size());

    s = slc.spectrum(1, true);

    // pointers should be equal
    unit_assert_operator_equal(slc.spectrum(1, true), s);

    if (os_) *os_ << cache << endl;
    unit_assert_operator_equal(1, cache.size());
    unit_assert_operator_equal(1, cache.mru().second->index);
    unit_assert(spectrumHasMetadata(*cache.mru().second));
    unit_assert(spectrumHasBinaryData(*cache.mru().second));

    s = slc.spectrum(2, false);

    if (os_) *os_ << cache << endl;
    unit_assert_operator_equal(1, cache.size());
    unit_assert_operator_equal(1, cache.mru().second->index);
    unit_assert(spectrumHasMetadata(*cache.mru().second));
    unit_assert(spectrumHasBinaryData(*cache.mru().second));

    s = slc.spectrum(3, true);

    // pointers should be equal
    unit_assert_operator_equal(slc.spectrum(3, true), s);

    if (os_) *os_ << cache << endl;
    unit_assert_operator_equal(2, cache.size());
    unit_assert_operator_equal(3, cache.mru().second->index);
    unit_assert(spectrumHasMetadata(*cache.mru().second));
    unit_assert(spectrumHasBinaryData(*cache.mru().second));
    unit_assert_operator_equal(1, cache.lru().second->index);
    unit_assert(spectrumHasMetadata(*cache.lru().second));
    unit_assert(spectrumHasBinaryData(*cache.lru().second));

    s = slc.spectrum(2, true);

    if (os_) *os_ << cache << endl;
    unit_assert_operator_equal(2, cache.size());
    unit_assert_operator_equal(2, cache.mru().second->index);
    unit_assert(spectrumHasMetadata(*cache.mru().second));
    unit_assert(spectrumHasBinaryData(*cache.mru().second));
    unit_assert_operator_equal(3, cache.lru().second->index);
    unit_assert(spectrumHasMetadata(*cache.lru().second));
    unit_assert(spectrumHasBinaryData(*cache.lru().second));
}

void testFileReads

(

const char *

filename

)

Definition at line 399 of file SpectrumListCacheTest.cpp.

References MemoryMRUCacheMode_MetaDataOnly, pwiz::msdata::MSData::run, pwiz::msdata::SpectrumListCache::spectrum(), pwiz::msdata::Run::spectrumListPtr, and unit_assert.

Referenced by test().

                                         {
    std::string srcparent(__FILE__); // locate test data relative to this source file
    // something like \ProteoWizard\pwiz\pwiz\data\msdata\SpectrumListCacheTest.cpp
    size_t pos = srcparent.rfind("pwiz");
    srcparent.resize(pos);
    std::string example_data_dir = srcparent + "example_data/";
    pwiz::msdata::MSDataFile msd1(example_data_dir + filename);
    SpectrumListCache cache(msd1.run.spectrumListPtr, MemoryMRUCacheMode_MetaDataOnly, 2);
    pwiz::msdata::MSDataFile msd2(example_data_dir + filename);
    // test logic for efficient delayed read of binary data - 
    // we try to avoid reparsing the header since we have that cached
    // mzML and mzXML readers can do this, others could probably be made to
    int index = 3;
    SpectrumPtr s=msd2.run.spectrumListPtr->spectrum(index, false);
    SpectrumPtr c=cache.spectrum(index, false);
    unit_assert(*s==*c);
    unit_assert(!s->hasBinaryData());
    unit_assert(!c->hasBinaryData());
    s=msd2.run.spectrumListPtr->spectrum(index, true);
    c=cache.spectrum(index, true);
    unit_assert(*s==*c);
    unit_assert(s->hasBinaryData());
    unit_assert(c->hasBinaryData());
    unit_assert(s->binaryDataArrayPtrs[0]->data[0]==
                c->binaryDataArrayPtrs[0]->data[0]);
    unit_assert(!s->binaryDataArrayPtrs[1]->data.empty());
    unit_assert(!c->binaryDataArrayPtrs[1]->data.empty());
    unit_assert(s->binaryDataArrayPtrs[1]->data[0]==
                c->binaryDataArrayPtrs[1]->data[0]);
}

void test

(

)

Definition at line 431 of file SpectrumListCacheTest.cpp.

References testFileReads(), testMemoryMRUCache(), testModeBinaryDataOnly(), testModeMetaDataAndBinaryData(), testModeMetaDataOnly(), and testModeOff().

{
    testMemoryMRUCache();
    testModeOff();
    testModeMetaDataOnly();
    testModeBinaryDataOnly();
    testModeMetaDataAndBinaryData();
    // check the delayed-binary-read
    // logic for mzML and mzXML readers
    testFileReads("tiny.pwiz.mzXML");
    testFileReads("tiny.pwiz.1.0.mzML");
    testFileReads("tiny.pwiz.1.1.mzML");
}

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

Definition at line 446 of file SpectrumListCacheTest.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;
        test();
    }
    catch (exception& e)
    {
        TEST_FAILED(e.what())
    }
    catch (...)
    {
        TEST_FAILED("Caught unknown exception.")
    }

    TEST_EPILOG
}

---

Variable Documentation

ostream* os_ = 0

Definition at line 37 of file SpectrumListCacheTest.cpp.