ProteoWizard
Functions | Variables
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

§ operator<<()

ostream& std::operator<< ( ostream &  os,
SpectrumListCache::CacheType cache 
)

Definition at line 42 of file SpectrumListCacheTest.cpp.

References pwiz::util::mru_list< Item, KeyExtractor >::begin(), and pwiz::util::mru_list< Item, KeyExtractor >::end().

43 {
44  os << "Spectrum cache indices (from MRU to LRU):";
45  for (SpectrumListCache::CacheType::iterator itr = cache.begin(); itr != cache.end(); ++itr)
46  os << " " << itr->spectrum->index;
47  return os;
48 }
iterator begin()
Definition: mru_list.hpp:99

§ testMemoryMRUCache()

void testMemoryMRUCache ( )

Definition at line 53 of file SpectrumListCacheTest.cpp.

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

Referenced by test().

54 {
56 
57  unit_assert_operator_equal(2, cache.max_size());
58  unit_assert(cache.empty());
59  unit_assert_operator_equal(0, cache.size());
60 
61  cache.insert(SpectrumListCache::CacheEntry(0, SpectrumPtr()));
62 
63  unit_assert(!cache.empty());
64  unit_assert_operator_equal(1, cache.size());
65 
66  cache.insert(SpectrumListCache::CacheEntry(1, SpectrumPtr()));
67 
68  unit_assert_operator_equal(2, cache.size());
69  unit_assert_operator_equal(1, cache.mru().index);
70  unit_assert_operator_equal(0, cache.lru().index);
71 
72  cache.insert(SpectrumListCache::CacheEntry(0, SpectrumPtr()));
73 
74  unit_assert_operator_equal(2, cache.size());
75  unit_assert_operator_equal(0, cache.mru().index);
76  unit_assert_operator_equal(1, cache.lru().index);
77 
78  cache.insert(SpectrumListCache::CacheEntry(2, SpectrumPtr()));
79 
80  unit_assert_operator_equal(2, cache.size());
81  unit_assert_operator_equal(2, cache.mru().index);
82  unit_assert_operator_equal(0, cache.lru().index);
83 }
boost::shared_ptr< Spectrum > SpectrumPtr
Definition: MSData.hpp:569
MemoryMRUCacheMode_Off
#define unit_assert_operator_equal(expected, actual)
Definition: unit.hpp:92
a cache mapping spectrum indices to SpectrumPtrs
#define unit_assert(x)
Definition: unit.hpp:85

§ makeSpectrumPtr()

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_detector_counts.

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

87 {
88  SpectrumPtr spectrum(new Spectrum);
89  spectrum->id = id;
90  spectrum->index = index;
91  spectrum->set(MS_MSn_spectrum);
92  spectrum->set(MS_ms_level, 2);
93  spectrum->precursors.push_back(Precursor(123.4));
94  spectrum->setMZIntensityArrays(vector<double>(), vector<double>(), MS_number_of_detector_counts);
95  BinaryDataArray& mzArray = *spectrum->getMZArray();
96  BinaryDataArray& intensityArray = *spectrum->getIntensityArray();
97  for (size_t i=0; i < (index+1)*10; ++i)
98  {
99  mzArray.data.push_back(i);
100  intensityArray.data.push_back(i*100);
101  }
102  spectrum->defaultArrayLength = mzArray.data.size();
103  return spectrum;
104 }
MS_MSn_spectrum
MSn spectrum: MSn refers to multi-stage MS2 experiments designed to record product ion spectra where ...
Definition: cv.hpp:2212
The method of precursor ion selection and activation.
Definition: MSData.hpp:310
boost::shared_ptr< Spectrum > SpectrumPtr
Definition: MSData.hpp:569
MS_ms_level
ms level: Stages of ms achieved in a multi stage mass spectrometry experiment.
Definition: cv.hpp:1987
std::vector< double > data
the binary data.
Definition: MSData.hpp:409
The structure into which encoded binary data goes. Byte ordering is always little endian (Intel style...
Definition: MSData.hpp:403
MS_number_of_detector_counts
number of detector counts: The number of counted events observed in one or a group of elements of a d...
Definition: cv.hpp:580
The structure that captures the generation of a peak list (including the underlying acquisitions) ...
Definition: MSData.hpp:504

§ spectrumHasMetadata()

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

107 {
108  return s.dataProcessingPtr.get() ||
109  s.sourceFilePtr.get() ||
110  !s.scanList.empty() ||
111  !s.precursors.empty() ||
112  !s.paramGroupPtrs.empty() ||
113  !s.cvParams.empty() ||
114  !s.userParams.empty();
115 }
ScanList scanList
list of scans
Definition: MSData.hpp:516
std::vector< Precursor > precursors
list and descriptions of precursors to the spectrum currently being described.
Definition: MSData.hpp:519
std::vector< UserParam > userParams
a collection of uncontrolled user terms
Definition: ParamTypes.hpp:253
std::vector< CVParam > cvParams
a collection of controlled vocabulary terms
Definition: ParamTypes.hpp:250
std::vector< ParamGroupPtr > paramGroupPtrs
a collection of references to ParamGroups
Definition: ParamTypes.hpp:247
SourceFilePtr sourceFilePtr
this attribute can optionally reference the &#39;id&#39; of the appropriate sourceFile.
Definition: MSData.hpp:513
DataProcessingPtr dataProcessingPtr
this attribute can optionally reference the &#39;id&#39; of the appropriate dataProcessing.
Definition: MSData.hpp:510

§ spectrumHasBinaryData()

bool spectrumHasBinaryData ( const Spectrum s)

Definition at line 117 of file SpectrumListCacheTest.cpp.

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

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

118 {
119  return s.hasBinaryData();
120 }
bool hasBinaryData() const
returns true iff has nonnull and nonempty BinaryDataArrayPtr
Definition: MSData.hpp:534

§ testModeOff()

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

123 {
124  // initialize list
125  shared_ptr<SpectrumListSimple> sl(new SpectrumListSimple);
126  sl->spectra.push_back(makeSpectrumPtr(0, "S1"));
127  sl->spectra.push_back(makeSpectrumPtr(1, "S2"));
128  sl->spectra.push_back(makeSpectrumPtr(2, "S3"));
129  sl->spectra.push_back(makeSpectrumPtr(3, "S4"));
130 
131  // access a series of spectra and make sure the cache behaves appropriately:
132  // in off mode, the cache should always be empty
133 
134  SpectrumPtr s;
135 
137  SpectrumListCache::CacheType& cache = slc.spectrumCache();
138 
139  unit_assert(cache.empty());
140 
141  s = slc.spectrum(0, false);
142  s = slc.spectrum(1, true);
143  s = slc.spectrum(2, false);
144  s = slc.spectrum(3, true);
145 
146  if (os_) *os_ << cache << endl;
147  unit_assert(cache.empty());
148 }
ostream * os_
boost::shared_ptr< Spectrum > SpectrumPtr
Definition: MSData.hpp:569
MemoryMRUCacheMode_Off
adds a level of flexible MRU caching to a SpectrumList processor chain
bool empty() const
Definition: mru_list.hpp:91
SpectrumPtr makeSpectrumPtr(size_t index, const string &id)
Simple writeable in-memory implementation of SpectrumList.
Definition: MSData.hpp:712
#define unit_assert(x)
Definition: unit.hpp:85

§ testModeMetaDataOnly()

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

152 {
153  // initialize list
154  MSData msd;
155  shared_ptr<SpectrumListSimple> sl(new SpectrumListSimple);
156  sl->spectra.push_back(makeSpectrumPtr(0, "S1"));
157  sl->spectra.push_back(makeSpectrumPtr(1, "S2"));
158  sl->spectra.push_back(makeSpectrumPtr(2, "S3"));
159  sl->spectra.push_back(makeSpectrumPtr(3, "S4"));
160  msd.run.spectrumListPtr = sl;
161 
162  // SpectrumListSimple returns the same shared_ptrs regardless of caching;
163  // serializing to MGF and back will produce different shared_ptrs
164  boost::shared_ptr<stringstream> ss(new stringstream);
165  Serializer_MGF serializer;
166  serializer.write(*ss, msd, 0);
167  serializer.read(ss, msd);
168 
169  // access a series of spectra and make sure the cache behaves appropriately:
170  // in metadata-only mode, entries in the cache should:
171  // - always have metadata
172  // - never have binary data
173 
174  SpectrumPtr s;
175 
177  SpectrumListCache::CacheType& cache = slc.spectrumCache();
178 
179  unit_assert(cache.empty());
181 
182  s = slc.spectrum(0, false);
183 
184  // pointers should be equal
185  unit_assert_operator_equal(slc.spectrum(0, false), s);
186 
187  if (os_) *os_ << cache << endl;
188  unit_assert(!cache.empty());
189  unit_assert_operator_equal(1, cache.size());
190  unit_assert_operator_equal(0, cache.mru().spectrum->index);
191 
192  // with-binary-data access should return the binary data, but only cache the metadata
193  s = slc.spectrum(1, true);
194 
195  if (os_) *os_ << cache << endl;
196  unit_assert_operator_equal(2, cache.size());
197  unit_assert_operator_equal(1, cache.mru().spectrum->index);
198  unit_assert(spectrumHasMetadata(*cache.mru().spectrum));
199  unit_assert(!spectrumHasBinaryData(*cache.mru().spectrum));
200  unit_assert(spectrumHasMetadata(*cache.lru().spectrum));
201  unit_assert_operator_equal(0, cache.lru().spectrum->index);
202 
203  s = slc.spectrum(2, false);
204 
205  // pointers should be equal
206  unit_assert_operator_equal(slc.spectrum(2, false), s);
207 
208  if (os_) *os_ << cache << endl;
209  unit_assert_operator_equal(2, cache.size());
210  unit_assert_operator_equal(2, cache.mru().spectrum->index);
211  unit_assert(spectrumHasMetadata(*cache.mru().spectrum));
212  unit_assert(!spectrumHasBinaryData(*cache.mru().spectrum));
213  unit_assert_operator_equal(1, cache.lru().spectrum->index);
214 
215  s = slc.spectrum(3, true);
216 
217  if (os_) *os_ << cache << endl;
218  unit_assert_operator_equal(2, cache.size());
219  unit_assert_operator_equal(3, cache.mru().spectrum->index);
220  unit_assert(spectrumHasMetadata(*cache.mru().spectrum));
221  unit_assert(!spectrumHasBinaryData(*cache.mru().spectrum));
222  unit_assert_operator_equal(2, cache.lru().spectrum->index);
223  unit_assert(spectrumHasMetadata(*cache.lru().spectrum));
224 
225  s = slc.spectrum(2, true);
226 
227  if (os_) *os_ << cache << endl;
228  unit_assert_operator_equal(2, cache.size());
229  unit_assert_operator_equal(2, cache.mru().spectrum->index);
230  unit_assert(spectrumHasMetadata(*cache.mru().spectrum));
231  unit_assert(!spectrumHasBinaryData(*cache.mru().spectrum));
232  unit_assert_operator_equal(3, cache.lru().spectrum->index);
233  unit_assert(spectrumHasMetadata(*cache.lru().spectrum));
234 }
void read(boost::shared_ptr< std::istream > is, MSData &msd) const
read in MSData object from an MGF istream note: istream may be managed by MSData&#39;s SpectrumList...
ostream * os_
boost::shared_ptr< Spectrum > SpectrumPtr
Definition: MSData.hpp:569
void write(std::ostream &os, const MSData &msd, const pwiz::util::IterationListenerRegistry *iterationListenerRegistry=0) const
write MSData object to ostream as MGF; iterationListenerRegistry may be used to receive progress upda...
bool spectrumHasBinaryData(const Spectrum &s)
const item_type & lru() const
Definition: mru_list.hpp:97
#define unit_assert_operator_equal(expected, actual)
Definition: unit.hpp:92
Run run
a run in mzML should correspond to a single, consecutive and coherent set of scans on an instrument...
Definition: MSData.hpp:882
adds a level of flexible MRU caching to a SpectrumList processor chain
std::size_t max_size() const
Definition: mru_list.hpp:93
std::size_t size() const
Definition: mru_list.hpp:92
MemoryMRUCacheMode_MetaDataOnly
bool empty() const
Definition: mru_list.hpp:91
MSData <-> MGF stream serialization.
SpectrumPtr makeSpectrumPtr(size_t index, const string &id)
SpectrumListPtr spectrumListPtr
all mass spectra and the acquisitions underlying them are described and attached here. Subsidiary data arrays are also both described and attached here.
Definition: MSData.hpp:823
const item_type & mru() const
Definition: mru_list.hpp:96
bool spectrumHasMetadata(const Spectrum &s)
This is the root element of ProteoWizard; it represents the mzML element, defined as: intended to cap...
Definition: MSData.hpp:845
Simple writeable in-memory implementation of SpectrumList.
Definition: MSData.hpp:712
#define unit_assert(x)
Definition: unit.hpp:85

§ testModeBinaryDataOnly()

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

238 {
239  // initialize list
240  MSData msd;
241  shared_ptr<SpectrumListSimple> sl(new SpectrumListSimple);
242  sl->spectra.push_back(makeSpectrumPtr(0, "S1"));
243  sl->spectra.push_back(makeSpectrumPtr(1, "S2"));
244  sl->spectra.push_back(makeSpectrumPtr(2, "S3"));
245  sl->spectra.push_back(makeSpectrumPtr(3, "S4"));
246  msd.run.spectrumListPtr = sl;
247 
248  // SpectrumListSimple returns the same shared_ptrs regardless of caching;
249  // serializing to MGF and back will produce different shared_ptrs
250  boost::shared_ptr<stringstream> ss(new stringstream);
251  Serializer_MGF serializer;
252  serializer.write(*ss, msd, 0);
253  serializer.read(ss, msd);
254 
255  // access a series of spectra and make sure the cache behaves appropriately:
256  // in binary-data-only mode, entries in the cache should:
257  // - never have metadata
258  // - always have binary data
259 
260  SpectrumPtr s;
261 
263  SpectrumListCache::CacheType& cache = slc.spectrumCache();
264 
265  unit_assert(cache.empty());
267 
268  // metadata-only access should not affect the cache
269  s = slc.spectrum(0, false);
270 
271  if (os_) *os_ << cache << endl;
272  unit_assert(cache.empty());
273  unit_assert_operator_equal(0, cache.size());
274 
275  // with-binary-data access should be cached without the metadata
276  s = slc.spectrum(1, true);
277 
278  if (os_) *os_ << cache << endl;
279  unit_assert_operator_equal(1, cache.size());
280  unit_assert_operator_equal(1, cache.mru().spectrum->index);
281  unit_assert(!spectrumHasMetadata(*cache.mru().spectrum));
282  unit_assert(spectrumHasBinaryData(*cache.mru().spectrum));
283 
284  s = slc.spectrum(2, false);
285 
286  if (os_) *os_ << cache << endl;
287  unit_assert_operator_equal(1, cache.size());
288  unit_assert_operator_equal(1, cache.mru().spectrum->index);
289  unit_assert(!spectrumHasMetadata(*cache.mru().spectrum));
290  unit_assert(spectrumHasBinaryData(*cache.mru().spectrum));
291 
292  s = slc.spectrum(3, true);
293 
294  if (os_) *os_ << cache << endl;
295  unit_assert_operator_equal(2, cache.size());
296  unit_assert_operator_equal(3, cache.mru().spectrum->index);
297  unit_assert(!spectrumHasMetadata(*cache.mru().spectrum));
298  unit_assert(spectrumHasBinaryData(*cache.mru().spectrum));
299  unit_assert_operator_equal(1, cache.lru().spectrum->index);
300  unit_assert(!spectrumHasMetadata(*cache.lru().spectrum));
301  unit_assert(spectrumHasBinaryData(*cache.lru().spectrum));
302 
303  s = slc.spectrum(1, true);
304 
305  if (os_) *os_ << cache << endl;
306  unit_assert_operator_equal(2, cache.size());
307  unit_assert_operator_equal(1, cache.mru().spectrum->index);
308  unit_assert(!spectrumHasMetadata(*cache.mru().spectrum));
309  unit_assert(spectrumHasBinaryData(*cache.mru().spectrum));
310  unit_assert_operator_equal(3, cache.lru().spectrum->index);
311  unit_assert(!spectrumHasMetadata(*cache.lru().spectrum));
312  unit_assert(spectrumHasBinaryData(*cache.lru().spectrum));
313 }
void read(boost::shared_ptr< std::istream > is, MSData &msd) const
read in MSData object from an MGF istream note: istream may be managed by MSData&#39;s SpectrumList...
ostream * os_
boost::shared_ptr< Spectrum > SpectrumPtr
Definition: MSData.hpp:569
void write(std::ostream &os, const MSData &msd, const pwiz::util::IterationListenerRegistry *iterationListenerRegistry=0) const
write MSData object to ostream as MGF; iterationListenerRegistry may be used to receive progress upda...
bool spectrumHasBinaryData(const Spectrum &s)
const item_type & lru() const
Definition: mru_list.hpp:97
#define unit_assert_operator_equal(expected, actual)
Definition: unit.hpp:92
Run run
a run in mzML should correspond to a single, consecutive and coherent set of scans on an instrument...
Definition: MSData.hpp:882
adds a level of flexible MRU caching to a SpectrumList processor chain
std::size_t max_size() const
Definition: mru_list.hpp:93
std::size_t size() const
Definition: mru_list.hpp:92
bool empty() const
Definition: mru_list.hpp:91
MSData <-> MGF stream serialization.
MemoryMRUCacheMode_BinaryDataOnly
SpectrumPtr makeSpectrumPtr(size_t index, const string &id)
SpectrumListPtr spectrumListPtr
all mass spectra and the acquisitions underlying them are described and attached here. Subsidiary data arrays are also both described and attached here.
Definition: MSData.hpp:823
const item_type & mru() const
Definition: mru_list.hpp:96
bool spectrumHasMetadata(const Spectrum &s)
This is the root element of ProteoWizard; it represents the mzML element, defined as: intended to cap...
Definition: MSData.hpp:845
Simple writeable in-memory implementation of SpectrumList.
Definition: MSData.hpp:712
#define unit_assert(x)
Definition: unit.hpp:85

§ testModeMetaDataAndBinaryData()

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

317 {
318  // initialize list
319  MSData msd;
320  shared_ptr<SpectrumListSimple> sl(new SpectrumListSimple);
321  sl->spectra.push_back(makeSpectrumPtr(0, "S1"));
322  sl->spectra.push_back(makeSpectrumPtr(1, "S2"));
323  sl->spectra.push_back(makeSpectrumPtr(2, "S3"));
324  sl->spectra.push_back(makeSpectrumPtr(3, "S4"));
325  msd.run.spectrumListPtr = sl;
326 
327  // SpectrumListSimple returns the same shared_ptrs regardless of caching;
328  // serializing to MGF and back will produce different shared_ptrs
329  boost::shared_ptr<stringstream> ss(new stringstream);
330  Serializer_MGF serializer;
331  serializer.write(*ss, msd, 0);
332  serializer.read(ss, msd);
333 
334  // access a series of spectra and make sure the cache behaves appropriately:
335  // in metadata-and-binary-data mode, entries in the cache should:
336  // - always have metadata
337  // - always have binary data
338 
339  SpectrumPtr s;
340 
341  SpectrumListCache slc(msd.run.spectrumListPtr, MemoryMRUCacheMode_MetaDataAndBinaryData, 2);
342  SpectrumListCache::CacheType& cache = slc.spectrumCache();
343 
344  unit_assert(cache.empty());
346 
347  // metadata-only access should not affect the cache
348  s = slc.spectrum(0, false);
349 
350  if (os_) *os_ << cache << endl;
351  unit_assert(cache.empty());
352  unit_assert_operator_equal(0, cache.size());
353 
354  s = slc.spectrum(1, true);
355 
356  // pointers should be equal
357  unit_assert_operator_equal(slc.spectrum(1, true), s);
358 
359  if (os_) *os_ << cache << endl;
360  unit_assert_operator_equal(1, cache.size());
361  unit_assert_operator_equal(1, cache.mru().spectrum->index);
362  unit_assert(spectrumHasMetadata(*cache.mru().spectrum));
363  unit_assert(spectrumHasBinaryData(*cache.mru().spectrum));
364 
365  s = slc.spectrum(2, false);
366 
367  if (os_) *os_ << cache << endl;
368  unit_assert_operator_equal(1, cache.size());
369  unit_assert_operator_equal(1, cache.mru().spectrum->index);
370  unit_assert(spectrumHasMetadata(*cache.mru().spectrum));
371  unit_assert(spectrumHasBinaryData(*cache.mru().spectrum));
372 
373  s = slc.spectrum(3, true);
374 
375  // pointers should be equal
376  unit_assert_operator_equal(slc.spectrum(3, true), s);
377 
378  if (os_) *os_ << cache << endl;
379  unit_assert_operator_equal(2, cache.size());
380  unit_assert_operator_equal(3, cache.mru().spectrum->index);
381  unit_assert(spectrumHasMetadata(*cache.mru().spectrum));
382  unit_assert(spectrumHasBinaryData(*cache.mru().spectrum));
383  unit_assert_operator_equal(1, cache.lru().spectrum->index);
384  unit_assert(spectrumHasMetadata(*cache.lru().spectrum));
385  unit_assert(spectrumHasBinaryData(*cache.lru().spectrum));
386 
387  s = slc.spectrum(2, true);
388 
389  if (os_) *os_ << cache << endl;
390  unit_assert_operator_equal(2, cache.size());
391  unit_assert_operator_equal(2, cache.mru().spectrum->index);
392  unit_assert(spectrumHasMetadata(*cache.mru().spectrum));
393  unit_assert(spectrumHasBinaryData(*cache.mru().spectrum));
394  unit_assert_operator_equal(3, cache.lru().spectrum->index);
395  unit_assert(spectrumHasMetadata(*cache.lru().spectrum));
396  unit_assert(spectrumHasBinaryData(*cache.lru().spectrum));
397 }
void read(boost::shared_ptr< std::istream > is, MSData &msd) const
read in MSData object from an MGF istream note: istream may be managed by MSData&#39;s SpectrumList...
ostream * os_
boost::shared_ptr< Spectrum > SpectrumPtr
Definition: MSData.hpp:569
void write(std::ostream &os, const MSData &msd, const pwiz::util::IterationListenerRegistry *iterationListenerRegistry=0) const
write MSData object to ostream as MGF; iterationListenerRegistry may be used to receive progress upda...
bool spectrumHasBinaryData(const Spectrum &s)
const item_type & lru() const
Definition: mru_list.hpp:97
#define unit_assert_operator_equal(expected, actual)
Definition: unit.hpp:92
Run run
a run in mzML should correspond to a single, consecutive and coherent set of scans on an instrument...
Definition: MSData.hpp:882
adds a level of flexible MRU caching to a SpectrumList processor chain
std::size_t max_size() const
Definition: mru_list.hpp:93
std::size_t size() const
Definition: mru_list.hpp:92
bool empty() const
Definition: mru_list.hpp:91
MSData <-> MGF stream serialization.
SpectrumPtr makeSpectrumPtr(size_t index, const string &id)
SpectrumListPtr spectrumListPtr
all mass spectra and the acquisitions underlying them are described and attached here. Subsidiary data arrays are also both described and attached here.
Definition: MSData.hpp:823
const item_type & mru() const
Definition: mru_list.hpp:96
bool spectrumHasMetadata(const Spectrum &s)
This is the root element of ProteoWizard; it represents the mzML element, defined as: intended to cap...
Definition: MSData.hpp:845
Simple writeable in-memory implementation of SpectrumList.
Definition: MSData.hpp:712
#define unit_assert(x)
Definition: unit.hpp:85

§ testFileReads()

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

399  {
400  std::string srcparent(__FILE__); // locate test data relative to this source file
401  // something like \ProteoWizard\pwiz\pwiz\data\msdata\SpectrumListCacheTest.cpp
402  size_t pos = srcparent.rfind("pwiz");
403  srcparent.resize(pos);
404  std::string example_data_dir = srcparent + "example_data/";
405  pwiz::msdata::MSDataFile msd1(example_data_dir + filename);
406  SpectrumListCache cache(msd1.run.spectrumListPtr, MemoryMRUCacheMode_MetaDataOnly, 2);
407  pwiz::msdata::MSDataFile msd2(example_data_dir + filename);
408  // test logic for efficient delayed read of binary data -
409  // we try to avoid reparsing the header since we have that cached
410  // mzML and mzXML readers can do this, others could probably be made to
411  int index = 3;
412  SpectrumPtr s=msd2.run.spectrumListPtr->spectrum(index, false);
413  SpectrumPtr c=cache.spectrum(index, false);
414  unit_assert(*s==*c);
415  unit_assert(!s->hasBinaryData());
416  unit_assert(!c->hasBinaryData());
417  s=msd2.run.spectrumListPtr->spectrum(index, true);
418  c=cache.spectrum(index, true);
419  unit_assert(*s==*c);
420  unit_assert(s->hasBinaryData());
421  unit_assert(c->hasBinaryData());
422  unit_assert(s->binaryDataArrayPtrs[0]->data[0]==
423  c->binaryDataArrayPtrs[0]->data[0]);
424  unit_assert(!s->binaryDataArrayPtrs[1]->data.empty());
425  unit_assert(!c->binaryDataArrayPtrs[1]->data.empty());
426  unit_assert(s->binaryDataArrayPtrs[1]->data[0]==
427  c->binaryDataArrayPtrs[1]->data[0]);
428 }
boost::shared_ptr< Spectrum > SpectrumPtr
Definition: MSData.hpp:569
adds a level of flexible MRU caching to a SpectrumList processor chain
MemoryMRUCacheMode_MetaDataOnly
MSData object plus file I/O.
Definition: MSDataFile.hpp:40
#define unit_assert(x)
Definition: unit.hpp:85

§ test()

void test ( )

Definition at line 431 of file SpectrumListCacheTest.cpp.

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

Referenced by main().

432 {
434  testModeOff();
438  // check the delayed-binary-read
439  // logic for mzML and mzXML readers
440  testFileReads("tiny.pwiz.mzXML");
441  testFileReads("tiny.pwiz.1.0.mzML");
442  testFileReads("tiny.pwiz.1.1.mzML");
443 }
void testFileReads(const char *filename)
void testMemoryMRUCache()
void testModeMetaDataOnly()
void testModeMetaDataAndBinaryData()
void testModeBinaryDataOnly()
void testModeOff()

§ main()

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

Definition at line 446 of file SpectrumListCacheTest.cpp.

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

447 {
448  TEST_PROLOG(argc, argv)
449 
450  try
451  {
452  if (argc>1 && !strcmp(argv[1],"-v")) os_ = &cout;
453  test();
454  }
455  catch (exception& e)
456  {
457  TEST_FAILED(e.what())
458  }
459  catch (...)
460  {
461  TEST_FAILED("Caught unknown exception.")
462  }
463 
465 }
ostream * os_
#define TEST_EPILOG
Definition: unit.hpp:182
#define TEST_FAILED(x)
Definition: unit.hpp:176
void test()
#define TEST_PROLOG(argc, argv)
Definition: unit.hpp:174

Variable Documentation

§ os_

ostream* os_ = 0