ProteoWizard
Functions | Variables
BinaryDataEncoderTest.cpp File Reference
#include "BinaryDataEncoder.hpp"
#include "pwiz/utility/misc/unit.hpp"
#include "boost/filesystem.hpp"
#include "pwiz/utility/misc/Std.hpp"
#include <cstring>

Go to the source code of this file.

Functions

const char * regressionTest (const BinaryDataEncoder::Config &config, bool expectNumpressIgnored)
 
void testConfiguration (const BinaryDataEncoder::Config &config_in)
 
void test ()
 
void testBadFile (const string &filename)
 
int main (int argc, char *argv[])
 

Variables

ostream * os_ = 0
 
double sampleData_ []
 
const int sampleDataSize_ = sizeof(sampleData_)/sizeof(double)
 
const char * sampleEncoded32Big_ = "Q0gADAAAAABDSAAcAAAAAENIACwAAAAAQ0gAPAAAAABDSRtCAAAAAENJG1IAAAAAQ0kbYgAAAABDSRtyAAAAAENJG4JEYyvTQ0kbkkSeSJ5DSRuiRJ1DqkNJG7JEVDLHQ0kbwgAAAABDSRvSAAAAAENJG+IAAAAAQ0gAAAAAAABDlgAAP4AAAEPIAABBIAAAQ/oAAELIAABEFgAARHoAAA=="
 
const char * sampleEncoded32Little_ = "DABIQwAAAAAcAEhDAAAAACwASEMAAAAAPABIQwAAAABCG0lDAAAAAFIbSUMAAAAAYhtJQwAAAAByG0lDAAAAAIIbSUPTK2NEkhtJQ55InkSiG0lDqkOdRLIbSUPHMlREwhtJQwAAAADSG0lDAAAAAOIbSUMAAAAAAABIQwAAAAAAAJZDAACAPwAAyEMAACBBAAD6QwAAyEIAABZEAAB6RA=="
 
const char * sampleEncoded64Little_ = "/xedigEAaUAAAAAAAAAAAIV5fYYDAGlAAAAAAAAAAACkK16CBQBpQAAAAAAAAAAAXy4/fgcAaUAAAAAAAAAAAK4HNjVoI2lAAAAAAAAAAACrvLg2aiNpQAAAAAAAAAAAnMM7OGwjaUAAAAAAAAAAAIIcvzluI2lAAAAAAAAAAABax0I7cCNpQAAAAGB6ZYxAJcTGPHIjaUAAAADAE8mTQOUSSz50I2lAAAAAQHWok0CYs88/diNpQAAAAOBYhopAP6ZUQXgjaUAAAAAAAAAAANvq2UJ6I2lAAAAAAAAAAABpgV9EfCNpQAAAAAAAAAAAAAAAAAAAaUAAAAAAAAAAAAAAAAAAwHJAAAAAAAAA8D8AAAAAAAB5QAAAAAAAACRAAAAAAABAf0AAAAAAAABZQAAAAAAAwIJAAAAAAABAj0A="
 
const char * sampleEncoded64Big_ = "QGkAAYqdF/8AAAAAAAAAAEBpAAOGfXmFAAAAAAAAAABAaQAFgl4rpAAAAAAAAAAAQGkAB34/Ll8AAAAAAAAAAEBpI2g1NgeuAAAAAAAAAABAaSNqNri8qwAAAAAAAAAAQGkjbDg7w5wAAAAAAAAAAEBpI245vxyCAAAAAAAAAABAaSNwO0LHWkCMZXpgAAAAQGkjcjzGxCVAk8kTwAAAAEBpI3Q+SxLlQJOodUAAAABAaSN2P8+zmECKhljgAAAAQGkjeEFUpj8AAAAAAAAAAEBpI3pC2erbAAAAAAAAAABAaSN8RF+BaQAAAAAAAAAAQGkAAAAAAAAAAAAAAAAAAEBywAAAAAAAP/AAAAAAAABAeQAAAAAAAEAkAAAAAAAAQH9AAAAAAABAWQAAAAAAAECCwAAAAAAAQI9AAAAAAAA="
 
const char * sampleEncoded32LittleZlib_ = "eJzjYfBwZgACGSitA6VtoLSTtCeYDoLSSVC6CEo3AenL2skuk4D0PI95LouA9CrnuS6bgPRxoxCXQ1B1l6D0IyjNADWfgWEakG6wZ2A4AaQVHBkYfgHpE04MDGIuDAxVLgB7LB3q"
 
const char * sampleEncoded32BigZlib_ = "eJxz9mDgYQACZw8GGSitA6VtwLSntBOUDoLSSVC6CEo3uSRrXwbSk1zmecwD0otc5jqvAtKbXEKMjgPpQ1B1l6D0I6j5YOA8jYHBvgFIn2BgcFQA0r8YGJyAbBcxIK5iYAAAfLkd6g=="
 
const char * sampleEncoded64LittleZlib_ = "eJz7Lz63i5Eh04EBClora9uYkfhLtOOaWJH48Xr2dexI/HXsZqYZygj+6j07zLKQ+HMOW1vkIPGbZPZb5iHxo447WRdA+AlVqT0OqkeO2RRB+AeET052eCrkbVcC4TuUrpjsMGPzefsyCP9BRFuXg/2yEMcKJPNuv7rpVIXEz2yMd6lB4kNFUfkHiqD8D/YQuhLKV4HQDvVQfiSEPtAEFe93AACmsz1+"
 
const char * sampleEncoded64BigZlib_ = "eJxzyGRg7Jor/p8BChwyGZjbaitbkfisTXHaS5D47HX2evEIvnKGqRn7OiR+ltmOPauR+DkW1ofnIPHzLPfLNCHxC6ydjkc59KRWJUD4RTbHjqg6TD4pfADCL7HzFnrqMHlFqQOEX2Z/fvMMh662iAcQfoVjyDJ7JPOqnG6+uo3Er3GJb8xEcj8KcCg6AKbtP0D5lVBaBUrXO0DoSCi/CaLeoR8iDgC0Qj1+"
 
const char * sampleEncodedNumpressLinear_ = "QS69PAAAAAAu7AEMAAAAAA9J0wgQ61LPfgY70wgQbTLPfg4d0wgQ7hLPfgMM1BgQwGKtfgvq1SgQ4UKtfgjc1SgQIyKtfgXO1SgQRAKtfgKw5SgQ78OG4QNVqQugf3Tmpg+6yRCARe2G9wiYdBGAecaFZgs+qjKwizv8oQVa5SgQS0GtfgJM5SgQjCGtfgwC5BgQApLPfgicxA4Q5MmQzQzK9+kgoDYaDQAvNdQwS+AZrAhzqAY5hKD/kA=="
 
const char * sampleEncodedNumpressLinearZlib_ = "eJxz1NtrwwAEem8YeUA0v+dlDoHXQefr2KyBjFyj83V8skDGO6Hzdcw8VyQEDiStreN+dVVD4KHT2jqOO0CGstLaOtZzQIYL09o6pg1PNQTeH257yBy6kntBfcmzZfy7Tgo0uL5t+84xo0SwofJYaxq33SqjDd3WfxayRgEVezsCdfkAGT2Ka+t4mJ5ICDBNOl/HMecIn8CTkxPO8pz6/lJhgZkUL4O+6RUD7weSaziKV7BZtiz4PwEAkp1KXg=="
 
const char * sampleEncodedNumpressSlof_ = "QMHqAAAAAAACvgAAAr4AAAK+AAACvgAANL4AADS+AAA0vgAANL4AADS+GvQ0vvr/NL6//zS+qfE0vgAANL4AADS+AAACvgAAeszWGMHW6VW73lqlQOWH9w=="
 
const char * sampleEncodedNumpressSlofZlib_ = "eJxzOPiKAQSY9qFiEwws9cVk36//Jvv2A/HKj8hyIPVVZ65JHLz2MnT3vailDk/bvwMAn1ogtQ=="
 
const char * sampleEncodedNumpressPic_ = "aMhoyGjIaMhpyGnIachpyGnF2DacUvRpxa5GnFFTachpyGnIaMhcIXFQkXpU8WRlhSWOMA=="
 
const char * sampleEncodedNumpressPicZlib_ = "eJzLOJEBhpkwePSG2ZygL5lH17nNCQyGiGWciFEsDJhYFfIxJbVVtc8AAAjsG4c="
 
const char * sampleEncodedModified64BigZlib_ = "eJxzyGRg7Jor/r/+/X8wcMhkYG6rrWz9j+CzNsVpL6m/D+ez19nrxf+H85UzTM3Y1zFAAZCfZbZjz2okfo6F9eE5SPw8y/0yTUj8Amun41EOPalVCRB+kc2xI6oOk08KH4DwS+y8hZ46TF5R6gDhl9mf3zzDoast4gGEX+EYssweybwqp5uvbiPxa1ziGzMRfAYU4FB0AEzbf4DyK6G0CpSud4DQkVB+E0S9Qz9EHACREFv+"
 

Function Documentation

◆ regressionTest()

const char* regressionTest ( const BinaryDataEncoder::Config config,
bool  expectNumpressIgnored 
)

Definition at line 85 of file BinaryDataEncoderTest.cpp.

86 {
87  if (expectNumpressIgnored) // when set, expecting numpress not to be used even though it was requested
88  {
90  }
91  else
92  {
93  if (config.numpress == BinaryDataEncoder::Numpress_Linear)
94  return (BinaryDataEncoder::Compression_Zlib==config.compression)?sampleEncodedNumpressLinearZlib_:sampleEncodedNumpressLinear_;
95 
96  if (config.numpress == BinaryDataEncoder::Numpress_Pic)
97  return (BinaryDataEncoder::Compression_Zlib==config.compression)?sampleEncodedNumpressPicZlib_:sampleEncodedNumpressPic_;
98 
99  if (config.numpress == BinaryDataEncoder::Numpress_Slof)
100  return (BinaryDataEncoder::Compression_Zlib==config.compression)?sampleEncodedNumpressSlofZlib_:sampleEncodedNumpressSlof_;
101  }
102  if (config.precision == BinaryDataEncoder::Precision_32 &&
103  config.byteOrder == BinaryDataEncoder::ByteOrder_LittleEndian &&
104  config.compression == BinaryDataEncoder::Compression_None)
105  return sampleEncoded32Little_;
106 
107  if (config.precision == BinaryDataEncoder::Precision_32 &&
108  config.byteOrder == BinaryDataEncoder::ByteOrder_BigEndian &&
109  config.compression == BinaryDataEncoder::Compression_None)
110  return sampleEncoded32Big_;
111 
112  if (config.precision == BinaryDataEncoder::Precision_64 &&
113  config.byteOrder == BinaryDataEncoder::ByteOrder_LittleEndian &&
114  config.compression == BinaryDataEncoder::Compression_None)
115  return sampleEncoded64Little_;
116 
117  if (config.precision == BinaryDataEncoder::Precision_64 &&
118  config.byteOrder == BinaryDataEncoder::ByteOrder_BigEndian &&
119  config.compression == BinaryDataEncoder::Compression_None)
120  return sampleEncoded64Big_;
121 
122  if (config.precision == BinaryDataEncoder::Precision_32 &&
123  config.byteOrder == BinaryDataEncoder::ByteOrder_LittleEndian &&
124  config.compression == BinaryDataEncoder::Compression_Zlib)
126 
127  if (config.precision == BinaryDataEncoder::Precision_32 &&
128  config.byteOrder == BinaryDataEncoder::ByteOrder_BigEndian &&
129  config.compression == BinaryDataEncoder::Compression_Zlib)
131 
132  if (config.precision == BinaryDataEncoder::Precision_64 &&
133  config.byteOrder == BinaryDataEncoder::ByteOrder_LittleEndian &&
134  config.compression == BinaryDataEncoder::Compression_Zlib)
136 
137  if (config.precision == BinaryDataEncoder::Precision_64 &&
138  config.byteOrder == BinaryDataEncoder::ByteOrder_BigEndian &&
139  config.compression == BinaryDataEncoder::Compression_Zlib)
141 
142  throw runtime_error("[BinaryDataEncoderTest::regressionTest()] Untested configuration.");
143 }

References pwiz::msdata::BinaryDataEncoder::Config::byteOrder, pwiz::msdata::BinaryDataEncoder::Config::compression, pwiz::msdata::BinaryDataEncoder::Config::numpress, pwiz::msdata::BinaryDataEncoder::Config::precision, sampleEncoded32Big_, sampleEncoded32BigZlib_, sampleEncoded32Little_, sampleEncoded32LittleZlib_, sampleEncoded64Big_, sampleEncoded64BigZlib_, sampleEncoded64Little_, sampleEncoded64LittleZlib_, sampleEncodedModified64BigZlib_, sampleEncodedNumpressLinear_, sampleEncodedNumpressLinearZlib_, sampleEncodedNumpressPic_, sampleEncodedNumpressPicZlib_, sampleEncodedNumpressSlof_, and sampleEncodedNumpressSlofZlib_.

Referenced by testConfiguration().

◆ testConfiguration()

void testConfiguration ( const BinaryDataEncoder::Config config_in)

Definition at line 146 of file BinaryDataEncoderTest.cpp.

147 {
148  BinaryDataEncoder::Config config(config_in);
149  if (os_)
150  *os_ << "testConfiguration: " << config << endl;
151 
152  // initialize scan data
153 
154  vector<double> binary(sampleDataSize_);
155  copy(sampleData_, sampleData_+sampleDataSize_, binary.begin());
156 
157  bool checkNumpressMaxErrorSupression = (BinaryDataEncoder::Numpress_None != config.numpress)&&(config.numpressLinearErrorTolerance>0);
158  if (checkNumpressMaxErrorSupression)
159  {
160  binary[1] = numeric_limits<double>::max( )-.1; // attempt to blow out the numpress lossiness limiter
161  binary[3] = -binary[1]; // attempt to blow out the numpress lossiness limiter
162  binary[5] = .5*binary[1]; // attempt to blow out the numpress lossiness limiter
163  binary[7] = .5*binary[3]; // attempt to blow out the numpress lossiness limiter
164  }
165 
166  if (os_)
167  {
168  *os_ << "original: " << binary.size() << endl;
169  *os_ << setprecision(20) << fixed;
170  copy(binary.begin(), binary.end(), ostream_iterator<double>(*os_, "\n"));
171  }
172 
173  // instantiate encoder
174 
175  BinaryDataEncoder encoder(config);
176 
177  // encode
178 
179  string encoded;
180  encoder.encode(binary, encoded);
181 
182  if (os_)
183  *os_ << "encoded: " << encoded.size() << endl << encoded << endl;
184 
185  // regression testing for encoding
186 
187  unit_assert(encoded == regressionTest(config,checkNumpressMaxErrorSupression));
188 
189  // decode
190 
191  BinaryData<double> decoded;
192  encoder.decode(encoded, decoded);
193 
194  if (os_)
195  {
196  *os_ << "decoded: " << decoded.size() << endl;
197  copy(decoded.begin(), decoded.end(), ostream_iterator<double>(*os_, "\n"));
198  }
199 
200  // validate by comparing scan data before/after encode/decode
201 
202  unit_assert(binary.size() == decoded.size());
203 
204  const double epsilon = config.precision == BinaryDataEncoder::Precision_64 ? 1e-14 : 1e-5 ;
205 
206  auto jt = decoded.begin();
207  switch (config.numpress)
208  {
209  case BinaryDataEncoder::Numpress_Linear:
210  case BinaryDataEncoder::Numpress_Slof:
211  case BinaryDataEncoder::Numpress_Pic:
212  // lossy compression
213  for (auto it = binary.begin(); it!=binary.end(); ++it, ++jt)
214  {
215  if (0==*it || 0==*jt)
216  unit_assert_equal(*it, *jt, 0.1);
217  else if (*it > *jt)
218  unit_assert((*jt)/(*it) > .999 );
219  else
220  unit_assert((*it)/(*jt) > .999 );
221  }
222  break;
223  default:
224  for (auto it = binary.begin(); it!=binary.end(); ++it, ++jt)
225  {
226  unit_assert_equal(*it, *jt, epsilon);
227  }
228  break;
229  }
230  if (os_) *os_ << "validated with epsilon: " << fixed << setprecision(1) << scientific << epsilon << "\n\n";
231 }

References pwiz::util::BinaryData< T >::begin(), pwiz::msdata::BinaryDataEncoder::decode(), pwiz::msdata::BinaryDataEncoder::encode(), pwiz::util::BinaryData< T >::end(), epsilon, pwiz::msdata::BinaryDataEncoder::Config::numpress, pwiz::msdata::BinaryDataEncoder::Config::numpressLinearErrorTolerance, os_, pwiz::msdata::BinaryDataEncoder::Config::precision, regressionTest(), sampleData_, sampleDataSize_, pwiz::util::BinaryData< T >::size(), unit_assert, and unit_assert_equal.

Referenced by test().

◆ test()

void test ( )

Definition at line 234 of file BinaryDataEncoderTest.cpp.

235 {
237 
238  config.precision = BinaryDataEncoder::Precision_32;
239  config.byteOrder = BinaryDataEncoder::ByteOrder_LittleEndian;
240  testConfiguration(config);
241 
242  config.precision = BinaryDataEncoder::Precision_32;
243  config.byteOrder = BinaryDataEncoder::ByteOrder_BigEndian;
244  testConfiguration(config);
245 
246  config.precision = BinaryDataEncoder::Precision_64;
247  config.byteOrder = BinaryDataEncoder::ByteOrder_LittleEndian;
248  testConfiguration(config);
249 
250  config.precision = BinaryDataEncoder::Precision_64;
251  config.byteOrder = BinaryDataEncoder::ByteOrder_BigEndian;
252  testConfiguration(config);
253 
254  config.precision = BinaryDataEncoder::Precision_32;
255  config.byteOrder = BinaryDataEncoder::ByteOrder_LittleEndian;
256  config.compression = BinaryDataEncoder::Compression_Zlib;
257  testConfiguration(config);
258 
259  config.precision = BinaryDataEncoder::Precision_32;
260  config.byteOrder = BinaryDataEncoder::ByteOrder_BigEndian;
261  config.compression = BinaryDataEncoder::Compression_Zlib;
262  testConfiguration(config);
263 
264  config.precision = BinaryDataEncoder::Precision_64;
265  config.byteOrder = BinaryDataEncoder::ByteOrder_LittleEndian;
266  config.compression = BinaryDataEncoder::Compression_Zlib;
267  testConfiguration(config);
268 
269  config.precision = BinaryDataEncoder::Precision_64;
270  config.byteOrder = BinaryDataEncoder::ByteOrder_BigEndian;
271  config.compression = BinaryDataEncoder::Compression_Zlib;
272  testConfiguration(config);
273 
274  // test the numpress stuff with and without zlib, and to see if it honors error limits
275  config.compression = BinaryDataEncoder::Compression_None;
276  config.numpressLinearErrorTolerance = 0; // means don't do tolerance checks
277  config.numpressSlofErrorTolerance = 0; // means don't do tolerance checks
278  for (int zloop=3;zloop--;)
279  {
280  config.numpress = BinaryDataEncoder::Numpress_Linear;
281  testConfiguration(config);
282 
283  config.numpress = BinaryDataEncoder::Numpress_Slof;
284  testConfiguration(config);
285 
286  config.numpress = BinaryDataEncoder::Numpress_Pic;
287  testConfiguration(config);
288 
289  config.compression = BinaryDataEncoder::Compression_Zlib; // and again with zlib
290  if (1==zloop) // and finally test numpress excessive error avoidance
291  {
292  config.numpressLinearErrorTolerance = .01;
293  config.numpressSlofErrorTolerance = .01;
294  }
295  }
296 
297 }

References pwiz::msdata::BinaryDataEncoder::Config::byteOrder, pwiz::msdata::BinaryDataEncoder::Config::compression, pwiz::msdata::BinaryDataEncoder::Config::numpress, pwiz::msdata::BinaryDataEncoder::Config::numpressLinearErrorTolerance, pwiz::msdata::BinaryDataEncoder::Config::numpressSlofErrorTolerance, pwiz::msdata::BinaryDataEncoder::Config::precision, and testConfiguration().

Referenced by main().

◆ testBadFile()

void testBadFile ( const string &  filename)

Definition at line 300 of file BinaryDataEncoderTest.cpp.

301 {
302  if (os_) *os_ << "testBadFile: " << filename << flush;
303 
304  size_t filesize = 0;
305 
306  try
307  {
308  filesize = (size_t) bfs::file_size(filename);
309  }
310  catch (exception&)
311  {
312  cerr << "\nUnable to find file " << filename << endl;
313  return;
314  }
315 
316  if (os_) *os_ << " (" << filesize << " bytes)\n";
317 
318  unit_assert(filesize%sizeof(double) == 0);
319 
320  // read data from file into memory
321 
322  vector<double> data(filesize/sizeof(double));
323  ifstream is(filename.c_str(), ios::binary);
324  is.read((char*)&data[0], filesize);
325 
326  // set configuration to produce the error
327 
329 
330  if (filename.find("BinaryDataEncoderTest.bad.bin")!=string::npos)
331  {
332  // zlib compression encoding error with this configuration
333  config.precision = BinaryDataEncoder::Precision_32;
334  config.byteOrder = BinaryDataEncoder::ByteOrder_LittleEndian;
335  config.compression = BinaryDataEncoder::Compression_Zlib;
336  }
337 
338  // encode and decode
339 
340  BinaryDataEncoder encoder(config);
341  string encoded;
342  encoder.encode(data, encoded);
343 
344  BinaryData<double> decoded;
345  encoder.decode(encoded, decoded);
346 
347  // verify
348 
349  unit_assert(decoded.size() == data.size());
350  for (size_t i=0; i<decoded.size(); i++)
351  unit_assert(decoded[i] == data[i]);
352 }

References pwiz::msdata::BinaryDataEncoder::Config::byteOrder, pwiz::msdata::BinaryDataEncoder::Config::compression, pwiz::msdata::BinaryDataEncoder::decode(), pwiz::msdata::BinaryDataEncoder::encode(), os_, pwiz::msdata::BinaryDataEncoder::Config::precision, pwiz::util::BinaryData< T >::size(), and unit_assert.

Referenced by main().

◆ main()

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

Definition at line 355 of file BinaryDataEncoderTest.cpp.

356 {
357  TEST_PROLOG(argc, argv)
358 
359  try
360  {
361  vector<string> filenames;
362 
363  for (int i=1; i<argc; i++)
364  {
365  if (!strcmp(argv[i],"-v")) os_ = &cout;
366  else if (bal::starts_with(argv[i], "--")) continue;
367  else filenames.push_back(argv[i]);
368  }
369 
370  if (os_) *os_ << "BinaryDataEncoderTest\n\n";
371  test();
372  for_each(filenames.begin(), filenames.end(), testBadFile);
373 
374  }
375  catch (exception& e)
376  {
377  TEST_FAILED(e.what())
378  }
379  catch (...)
380  {
381  TEST_FAILED("Caught unknown exception.")
382  }
383 
385 }

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

Variable Documentation

◆ os_

ostream* os_ = 0

Definition at line 37 of file BinaryDataEncoderTest.cpp.

Referenced by main(), testBadFile(), and testConfiguration().

◆ sampleData_

double sampleData_[]
Initial value:
=
{
200.00018816645022000000, 0.00000000000000000000,
200.00043034083151000000, 0.00000000000000000000,
200.00067251579924000000, 0.00000000000000000000,
200.00091469135347000000, 0.00000000000000000000,
201.10647068550810000000, 0.00000000000000000000,
201.10671554643099000000, 0.00000000000000000000,
201.10696040795017000000, 0.00000000000000000000,
201.10720527006566000000, 0.00000000000000000000,
201.10745013277739000000, 908.68475341796875000000,
201.10769499608537000000, 1266.26928710937500000000,
201.10793985998967000000, 1258.11450195312500000000,
201.10818472449023000000, 848.79339599609375000000,
201.10842958958708000000, 0.00000000000000000000,
201.10867445528024000000, 0.00000000000000000000,
201.10891932156963000000, 0.0000000000000000000,
200, 0,
300, 1,
400, 10,
500, 100,
600, 1000,
}

Definition at line 40 of file BinaryDataEncoderTest.cpp.

Referenced by testConfiguration(), and testData().

◆ sampleDataSize_

const int sampleDataSize_ = sizeof(sampleData_)/sizeof(double)

Definition at line 65 of file BinaryDataEncoderTest.cpp.

Referenced by testConfiguration().

◆ sampleEncoded32Big_

const char* sampleEncoded32Big_ = "Q0gADAAAAABDSAAcAAAAAENIACwAAAAAQ0gAPAAAAABDSRtCAAAAAENJG1IAAAAAQ0kbYgAAAABDSRtyAAAAAENJG4JEYyvTQ0kbkkSeSJ5DSRuiRJ1DqkNJG7JEVDLHQ0kbwgAAAABDSRvSAAAAAENJG+IAAAAAQ0gAAAAAAABDlgAAP4AAAEPIAABBIAAAQ/oAAELIAABEFgAARHoAAA=="

Definition at line 69 of file BinaryDataEncoderTest.cpp.

Referenced by regressionTest().

◆ sampleEncoded32Little_

const char* sampleEncoded32Little_ = "DABIQwAAAAAcAEhDAAAAACwASEMAAAAAPABIQwAAAABCG0lDAAAAAFIbSUMAAAAAYhtJQwAAAAByG0lDAAAAAIIbSUPTK2NEkhtJQ55InkSiG0lDqkOdRLIbSUPHMlREwhtJQwAAAADSG0lDAAAAAOIbSUMAAAAAAABIQwAAAAAAAJZDAACAPwAAyEMAACBBAAD6QwAAyEIAABZEAAB6RA=="

Definition at line 70 of file BinaryDataEncoderTest.cpp.

Referenced by regressionTest().

◆ sampleEncoded64Little_

const char* sampleEncoded64Little_ = "/xedigEAaUAAAAAAAAAAAIV5fYYDAGlAAAAAAAAAAACkK16CBQBpQAAAAAAAAAAAXy4/fgcAaUAAAAAAAAAAAK4HNjVoI2lAAAAAAAAAAACrvLg2aiNpQAAAAAAAAAAAnMM7OGwjaUAAAAAAAAAAAIIcvzluI2lAAAAAAAAAAABax0I7cCNpQAAAAGB6ZYxAJcTGPHIjaUAAAADAE8mTQOUSSz50I2lAAAAAQHWok0CYs88/diNpQAAAAOBYhopAP6ZUQXgjaUAAAAAAAAAAANvq2UJ6I2lAAAAAAAAAAABpgV9EfCNpQAAAAAAAAAAAAAAAAAAAaUAAAAAAAAAAAAAAAAAAwHJAAAAAAAAA8D8AAAAAAAB5QAAAAAAAACRAAAAAAABAf0AAAAAAAABZQAAAAAAAwIJAAAAAAABAj0A="

Definition at line 71 of file BinaryDataEncoderTest.cpp.

Referenced by regressionTest().

◆ sampleEncoded64Big_

const char* sampleEncoded64Big_ = "QGkAAYqdF/8AAAAAAAAAAEBpAAOGfXmFAAAAAAAAAABAaQAFgl4rpAAAAAAAAAAAQGkAB34/Ll8AAAAAAAAAAEBpI2g1NgeuAAAAAAAAAABAaSNqNri8qwAAAAAAAAAAQGkjbDg7w5wAAAAAAAAAAEBpI245vxyCAAAAAAAAAABAaSNwO0LHWkCMZXpgAAAAQGkjcjzGxCVAk8kTwAAAAEBpI3Q+SxLlQJOodUAAAABAaSN2P8+zmECKhljgAAAAQGkjeEFUpj8AAAAAAAAAAEBpI3pC2erbAAAAAAAAAABAaSN8RF+BaQAAAAAAAAAAQGkAAAAAAAAAAAAAAAAAAEBywAAAAAAAP/AAAAAAAABAeQAAAAAAAEAkAAAAAAAAQH9AAAAAAABAWQAAAAAAAECCwAAAAAAAQI9AAAAAAAA="

Definition at line 72 of file BinaryDataEncoderTest.cpp.

Referenced by regressionTest().

◆ sampleEncoded32LittleZlib_

const char* sampleEncoded32LittleZlib_ = "eJzjYfBwZgACGSitA6VtoLSTtCeYDoLSSVC6CEo3AenL2skuk4D0PI95LouA9CrnuS6bgPRxoxCXQ1B1l6D0IyjNADWfgWEakG6wZ2A4AaQVHBkYfgHpE04MDGIuDAxVLgB7LB3q"

Definition at line 73 of file BinaryDataEncoderTest.cpp.

Referenced by regressionTest().

◆ sampleEncoded32BigZlib_

const char* sampleEncoded32BigZlib_ = "eJxz9mDgYQACZw8GGSitA6VtwLSntBOUDoLSSVC6CEo3uSRrXwbSk1zmecwD0otc5jqvAtKbXEKMjgPpQ1B1l6D0I6j5YOA8jYHBvgFIn2BgcFQA0r8YGJyAbBcxIK5iYAAAfLkd6g=="

Definition at line 74 of file BinaryDataEncoderTest.cpp.

Referenced by regressionTest().

◆ sampleEncoded64LittleZlib_

const char* sampleEncoded64LittleZlib_ = "eJz7Lz63i5Eh04EBClora9uYkfhLtOOaWJH48Xr2dexI/HXsZqYZygj+6j07zLKQ+HMOW1vkIPGbZPZb5iHxo447WRdA+AlVqT0OqkeO2RRB+AeET052eCrkbVcC4TuUrpjsMGPzefsyCP9BRFuXg/2yEMcKJPNuv7rpVIXEz2yMd6lB4kNFUfkHiqD8D/YQuhLKV4HQDvVQfiSEPtAEFe93AACmsz1+"

Definition at line 75 of file BinaryDataEncoderTest.cpp.

Referenced by regressionTest().

◆ sampleEncoded64BigZlib_

const char* sampleEncoded64BigZlib_ = "eJxzyGRg7Jor/p8BChwyGZjbaitbkfisTXHaS5D47HX2evEIvnKGqRn7OiR+ltmOPauR+DkW1ofnIPHzLPfLNCHxC6ydjkc59KRWJUD4RTbHjqg6TD4pfADCL7HzFnrqMHlFqQOEX2Z/fvMMh662iAcQfoVjyDJ7JPOqnG6+uo3Er3GJb8xEcj8KcCg6AKbtP0D5lVBaBUrXO0DoSCi/CaLeoR8iDgC0Qj1+"

Definition at line 76 of file BinaryDataEncoderTest.cpp.

Referenced by regressionTest().

◆ sampleEncodedNumpressLinear_

const char* sampleEncodedNumpressLinear_ = "QS69PAAAAAAu7AEMAAAAAA9J0wgQ61LPfgY70wgQbTLPfg4d0wgQ7hLPfgMM1BgQwGKtfgvq1SgQ4UKtfgjc1SgQIyKtfgXO1SgQRAKtfgKw5SgQ78OG4QNVqQugf3Tmpg+6yRCARe2G9wiYdBGAecaFZgs+qjKwizv8oQVa5SgQS0GtfgJM5SgQjCGtfgwC5BgQApLPfgicxA4Q5MmQzQzK9+kgoDYaDQAvNdQwS+AZrAhzqAY5hKD/kA=="

Definition at line 77 of file BinaryDataEncoderTest.cpp.

Referenced by regressionTest().

◆ sampleEncodedNumpressLinearZlib_

const char* sampleEncodedNumpressLinearZlib_ = "eJxz1NtrwwAEem8YeUA0v+dlDoHXQefr2KyBjFyj83V8skDGO6Hzdcw8VyQEDiStreN+dVVD4KHT2jqOO0CGstLaOtZzQIYL09o6pg1PNQTeH257yBy6kntBfcmzZfy7Tgo0uL5t+84xo0SwofJYaxq33SqjDd3WfxayRgEVezsCdfkAGT2Ka+t4mJ5ICDBNOl/HMecIn8CTkxPO8pz6/lJhgZkUL4O+6RUD7weSaziKV7BZtiz4PwEAkp1KXg=="

Definition at line 78 of file BinaryDataEncoderTest.cpp.

Referenced by regressionTest().

◆ sampleEncodedNumpressSlof_

const char* sampleEncodedNumpressSlof_ = "QMHqAAAAAAACvgAAAr4AAAK+AAACvgAANL4AADS+AAA0vgAANL4AADS+GvQ0vvr/NL6//zS+qfE0vgAANL4AADS+AAACvgAAeszWGMHW6VW73lqlQOWH9w=="

Definition at line 79 of file BinaryDataEncoderTest.cpp.

Referenced by regressionTest().

◆ sampleEncodedNumpressSlofZlib_

const char* sampleEncodedNumpressSlofZlib_ = "eJxzOPiKAQSY9qFiEwws9cVk36//Jvv2A/HKj8hyIPVVZ65JHLz2MnT3vailDk/bvwMAn1ogtQ=="

Definition at line 80 of file BinaryDataEncoderTest.cpp.

Referenced by regressionTest().

◆ sampleEncodedNumpressPic_

const char* sampleEncodedNumpressPic_ = "aMhoyGjIaMhpyGnIachpyGnF2DacUvRpxa5GnFFTachpyGnIaMhcIXFQkXpU8WRlhSWOMA=="

Definition at line 81 of file BinaryDataEncoderTest.cpp.

Referenced by regressionTest().

◆ sampleEncodedNumpressPicZlib_

const char* sampleEncodedNumpressPicZlib_ = "eJzLOJEBhpkwePSG2ZygL5lH17nNCQyGiGWciFEsDJhYFfIxJbVVtc8AAAjsG4c="

Definition at line 82 of file BinaryDataEncoderTest.cpp.

Referenced by regressionTest().

◆ sampleEncodedModified64BigZlib_

const char* sampleEncodedModified64BigZlib_ = "eJxzyGRg7Jor/r/+/X8wcMhkYG6rrWz9j+CzNsVpL6m/D+ez19nrxf+H85UzTM3Y1zFAAZCfZbZjz2okfo6F9eE5SPw8y/0yTUj8Amun41EOPalVCRB+kc2xI6oOk08KH4DwS+y8hZ46TF5R6gDhl9mf3zzDoast4gGEX+EYssweybwqp5uvbiPxa1ziGzMRfAYU4FB0AEzbf4DyK6G0CpSud4DQkVB+E0S9Qz9EHACREFv+"

Definition at line 83 of file BinaryDataEncoderTest.cpp.

Referenced by regressionTest().

os_
ostream * os_
Definition: BinaryDataEncoderTest.cpp:37
sampleEncoded64Little_
const char * sampleEncoded64Little_
Definition: BinaryDataEncoderTest.cpp:71
pwiz::util::BinaryData::begin
iterator begin()
Definition: BinaryData.hpp:171
sampleEncodedModified64BigZlib_
const char * sampleEncodedModified64BigZlib_
Definition: BinaryDataEncoderTest.cpp:83
pwiz::util::BinaryData::end
const_iterator end() const
Definition: BinaryData.hpp:186
unit_assert_equal
#define unit_assert_equal(x, y, epsilon)
Definition: unit.hpp:99
pwiz::util::BinaryData::size
size_t size() const
Definition: BinaryData.hpp:145
sampleEncoded32Big_
const char * sampleEncoded32Big_
Definition: BinaryDataEncoderTest.cpp:69
sampleEncoded64Big_
const char * sampleEncoded64Big_
Definition: BinaryDataEncoderTest.cpp:72
testBadFile
void testBadFile(const string &filename)
Definition: BinaryDataEncoderTest.cpp:300
sampleEncodedNumpressLinear_
const char * sampleEncodedNumpressLinear_
Definition: BinaryDataEncoderTest.cpp:77
sampleEncodedNumpressLinearZlib_
const char * sampleEncodedNumpressLinearZlib_
Definition: BinaryDataEncoderTest.cpp:78
pwiz::msdata::BinaryDataEncoder::Config::numpressSlofErrorTolerance
double numpressSlofErrorTolerance
Definition: BinaryDataEncoder.hpp:63
TEST_EPILOG
#define TEST_EPILOG
Definition: unit.hpp:183
testConfiguration
void testConfiguration(const BinaryDataEncoder::Config &config_in)
Definition: BinaryDataEncoderTest.cpp:146
sampleEncodedNumpressPic_
const char * sampleEncodedNumpressPic_
Definition: BinaryDataEncoderTest.cpp:81
sampleEncodedNumpressSlofZlib_
const char * sampleEncodedNumpressSlofZlib_
Definition: BinaryDataEncoderTest.cpp:80
pwiz::msdata::BinaryDataEncoder::Config::precision
Precision precision
Definition: BinaryDataEncoder.hpp:57
sampleEncodedNumpressPicZlib_
const char * sampleEncodedNumpressPicZlib_
Definition: BinaryDataEncoderTest.cpp:82
sampleEncoded64BigZlib_
const char * sampleEncoded64BigZlib_
Definition: BinaryDataEncoderTest.cpp:76
sampleData_
double sampleData_[]
Definition: BinaryDataEncoderTest.cpp:40
pwiz::msdata::BinaryDataEncoder::Config::byteOrder
ByteOrder byteOrder
Definition: BinaryDataEncoder.hpp:58
pwiz::util::BinaryData< double >
TEST_FAILED
#define TEST_FAILED(x)
Definition: unit.hpp:177
sampleEncoded32BigZlib_
const char * sampleEncoded32BigZlib_
Definition: BinaryDataEncoderTest.cpp:74
TEST_PROLOG
#define TEST_PROLOG(argc, argv)
Definition: unit.hpp:175
sampleEncoded32Little_
const char * sampleEncoded32Little_
Definition: BinaryDataEncoderTest.cpp:70
epsilon
const double epsilon
Definition: DiffTest.cpp:41
regressionTest
const char * regressionTest(const BinaryDataEncoder::Config &config, bool expectNumpressIgnored)
Definition: BinaryDataEncoderTest.cpp:85
pwiz::msdata::BinaryDataEncoder::Config::numpress
Numpress numpress
Definition: BinaryDataEncoder.hpp:60
pwiz::msdata::BinaryDataEncoder
binary-to-text encoding
Definition: BinaryDataEncoder.hpp:45
sampleEncoded32LittleZlib_
const char * sampleEncoded32LittleZlib_
Definition: BinaryDataEncoderTest.cpp:73
pwiz::msdata::BinaryDataEncoder::Config::numpressLinearErrorTolerance
double numpressLinearErrorTolerance
Definition: BinaryDataEncoder.hpp:62
unit_assert
#define unit_assert(x)
Definition: unit.hpp:85
filenames
const char * filenames[]
Definition: ExtendedReadTest.cpp:30
sampleEncoded64LittleZlib_
const char * sampleEncoded64LittleZlib_
Definition: BinaryDataEncoderTest.cpp:75
test
void test()
Definition: BinaryDataEncoderTest.cpp:234
pwiz::msdata::BinaryDataEncoder::Config::compression
Compression compression
Definition: BinaryDataEncoder.hpp:59
sampleDataSize_
const int sampleDataSize_
Definition: BinaryDataEncoderTest.cpp:65
sampleEncodedNumpressSlof_
const char * sampleEncodedNumpressSlof_
Definition: BinaryDataEncoderTest.cpp:79
pwiz::msdata::BinaryDataEncoder::Config
encoding/decoding configuration
Definition: BinaryDataEncoder.hpp:55