BinaryFileTest.h

#ifndef BINARYFILETEST_H_
#define BINARYFILETEST_H_

#include <cxxtest/TestSuite.h>
#include "MantidKernel/BinaryFile.h"
#include "MantidKernel/System.h"
#include "MantidKernel/ConfigService.h"
#include <sys/stat.h>

using namespace Mantid::Kernel;

using std::runtime_error;
using std::size_t;
using std::vector;
using std::cout;
using std::endl;

//==========================================================================================
/// Make the code clearer by having this an explicit type
typedef uint32_t PixelType;
/// Type for the DAS time of flight (data file)
typedef uint32_t DasTofType;
/// Structure that matches the form in the binary event list.
struct DasEvent
{
  /// Time of flight.
  DasTofType tof;
  /// Pixel identifier as published by the DAS/DAE/DAQ.
  PixelType pid;
};


/** Creates a dummy file with so many bytes */
static void MakeDummyFile(std::string filename, size_t num_bytes)
{
  char * buffer;
  buffer = new char[num_bytes];
  for (size_t i=0; i < num_bytes; i++)
  {
    // Put 1,2,3 in 32-bit ints
    if (i%4==0)
      buffer[i]=static_cast<char>(i/4);
    else
      buffer[i]=0;
  }

  std::ofstream myFile (filename.c_str(), std::ios::out | std::ios::binary);
  myFile.write (buffer, num_bytes);
  delete [] buffer;
  myFile.close();
}


//==========================================================================================
class BinaryFileTest: public CxxTest::TestSuite
{
private:
  BinaryFile<DasEvent> file;
  std::string dummy_file;

public:
  static BinaryFileTest *createSuite() { return new BinaryFileTest(); }
  static void destroySuite(BinaryFileTest *suite) { delete suite; }

  BinaryFileTest()
  {
    dummy_file = "dummy.bin";
  }

  void testFileNotFound()
  {
    TS_ASSERT_THROWS( file.open("nonexistentfile.dat"), std::invalid_argument);
  }

 void testFileWrongSize()
 {

   MakeDummyFile(dummy_file, 3);
   TS_ASSERT_THROWS( file.open(dummy_file), std::runtime_error);
   file.close();
   Poco::File(dummy_file).remove();
 }


 void testOpen()
 {
   MakeDummyFile(dummy_file, 20*8);

   // If this throws, then the file does not exist.
   file.open(dummy_file);
   //Right size?
   size_t num = 20;
   TS_ASSERT_EQUALS(file.getNumElements(), num);
   //Get it
   std::vector<DasEvent> * data = 0;
   TS_ASSERT_THROWS_NOTHING( data = file.loadAll() );
   TS_ASSERT_EQUALS(data->size(), num);
   //Check the first event
   TS_ASSERT_EQUALS( data->at(0).tof, 0);
   TS_ASSERT_EQUALS( data->at(0).pid, 1);
   //Check the last event
   TS_ASSERT_EQUALS( data->at(num-1).tof, 38);
   TS_ASSERT_EQUALS( data->at(num-1).pid, 39);

   delete data;
   file.close();
   Poco::File(dummy_file).remove();
 }

 void testLoadAllInto()
 {
   MakeDummyFile(dummy_file, 20*8);
   file.open(dummy_file);

   //Right size?
   size_t num = 20;
   TS_ASSERT_EQUALS(file.getNumElements(), num);
   //Get it
   std::vector<DasEvent> data;
   TS_ASSERT_THROWS_NOTHING( file.loadAllInto(data) );
   TS_ASSERT_EQUALS(data.size(), num);
   //Check the first event
   TS_ASSERT_EQUALS( data.at(0).tof, 0);
   TS_ASSERT_EQUALS( data.at(0).pid, 1);
   //Check the last event
   TS_ASSERT_EQUALS( data.at(num-1).tof, 38);
   TS_ASSERT_EQUALS( data.at(num-1).pid, 39);
   file.close();
   Poco::File(dummy_file).remove();
 }

 void testLoadInBlocks()
 {
   MakeDummyFile(dummy_file, 20*8);
   file.open(dummy_file);

   //Right size?
   size_t num = 20;
   TS_ASSERT_EQUALS(file.getNumElements(), num);
   //Get it
   size_t block_size = 10;
   DasEvent * data = new DasEvent[block_size];
   size_t loaded_size = file.loadBlock(data, block_size);
   //Yes, we loaded that amount
   TS_ASSERT_EQUALS(loaded_size, block_size);

   //Check the first event
   TS_ASSERT_EQUALS( data[0].tof, 0);
   TS_ASSERT_EQUALS( data[0].pid, 1);

   delete [] data;
   //Now try to load a lot more - going past the end
   block_size = 10;
   data = new DasEvent[block_size];
   loaded_size = file.loadBlock(data, block_size);
   TS_ASSERT_EQUALS(loaded_size, 10);

   //Check the last event
   TS_ASSERT_EQUALS( data[ 9].tof, 38);
   TS_ASSERT_EQUALS( data[ 9].pid, 39);
   delete [] data;
   file.close();
   Poco::File(dummy_file).remove();
 }


 void testLoadBlockAt()
 {
   MakeDummyFile(dummy_file, 20*8);
   file.open(dummy_file);

   //Right size?
   size_t num = 20;
   TS_ASSERT_EQUALS(file.getNumElements(), num);
   //Get it
   size_t block_size = 10;
   DasEvent * data = new DasEvent[block_size];
   size_t loaded_size = file.loadBlockAt(data, 5, block_size);
   //Yes, we loaded that amount
   TS_ASSERT_EQUALS(loaded_size, block_size);

   //The first event is at index 5
   TS_ASSERT_EQUALS( data[0].tof, 10);
   TS_ASSERT_EQUALS( data[0].pid, 11);

   delete [] data;
   //Now try to load a lot more - going past the end
   block_size = 10;
   data = new DasEvent[block_size];
   loaded_size = file.loadBlock(data, block_size);
   TS_ASSERT_EQUALS(loaded_size, 5);
   delete [] data;
   file.close();
   Poco::File(dummy_file).remove();
 }


  void testCallingDestructorOnUnitializedObject()
  {
    BinaryFile<DasEvent> file2;
  }

  void testReadingNotOpenFile()
  {
    BinaryFile<DasEvent> file2;
    std::vector<DasEvent> data;
    DasEvent * buffer = NULL;
    TS_ASSERT_EQUALS(file2.getNumElements(), 0);
    TS_ASSERT_THROWS(file2.loadAll(), std::runtime_error );
    TS_ASSERT_THROWS(file2.loadAllInto( data), std::runtime_error );
    TS_ASSERT_THROWS(file2.loadBlock(buffer, 10), std::runtime_error );
  }

};

#endif /*BINARYFILETEST_H_*/