Line data    Source code

       1             : /**
       2             :  * @file test_EDFHandler.cpp
       3             :  *
       4             :  * @brief Tests for the EDFHandler class
       5             :  *
       6             :  * @author Tobias Lasser - initial code
       7             :  */
       8             : 
       9             : #include "doctest/doctest.h"
      10             : #include "EDFHandler.h"
      11             : #include "VolumeDescriptor.h"
      12             : 
      13             : using namespace elsa;
      14             : using namespace doctest;
      15             : 
      16             : TEST_SUITE_BEGIN("io");
      17             : 
      18             : std::vector<std::string> split(const std::string& s, char delim)
      19           2 : {
      20           2 :     std::stringstream ss(s);
      21           2 :     std::string item;
      22           2 :     std::vector<std::string> elems;
      23          25 :     while (std::getline(ss, item, delim)) {
      24          23 :         elems.push_back(std::move(item));
      25          23 :     }
      26           2 :     return elems;
      27           2 : }
      28             : 
      29             : TEST_CASE("EDFHandler: Reading and writing data")
      30           5 : {
      31           5 :     GIVEN("a 1D DataContainer")
      32           5 :     {
      33           2 :         IndexVector_t numCoeff(1);
      34           2 :         numCoeff << 5;
      35           2 :         DataContainer dc(VolumeDescriptor{numCoeff});
      36           2 :         dc = 0;
      37             : 
      38           2 :         WHEN("Writing it to an edf format")
      39           2 :         {
      40           2 :             std::stringstream buffer;
      41           2 :             EDF::write(dc, buffer);
      42             : 
      43           2 :             THEN("The header is correct")
      44           2 :             {
      45           1 :                 auto buffer_string = buffer.str();
      46           1 :                 auto header = buffer_string.substr(0, buffer_string.find('}' + 1));
      47             : 
      48           1 :                 auto parts = split(header, '\n');
      49           1 :                 parts.erase(std::begin(parts)); // remove the '{'
      50           1 :                 parts.pop_back();               // remove empty newline
      51           1 :                 parts.pop_back();               // remove closing '}'
      52           1 :                 parts.pop_back();               // remove filling spaces
      53             : 
      54           1 :                 CHECK_EQ(parts[0], "HeaderID = EH:000001:000000:000000;");
      55           1 :                 CHECK_EQ(parts[1], "Image = 1;");
      56           1 :                 CHECK_EQ(parts[2], "ByteOrder = LowByteFirst;");
      57           1 :                 CHECK_EQ(parts[3], "DataType = FloatValue;");
      58           1 :                 CHECK_EQ(parts[4], "Dim_1 = 5;");   // dim
      59           1 :                 CHECK_EQ(parts[5], "Size = 20;");   // dim * sizeof(float)
      60           1 :                 CHECK_EQ(parts[6], "Spacing = 1;"); // default 1D spacing
      61           1 :             }
      62             : 
      63           2 :             WHEN("Reading it back in")
      64           2 :             {
      65           1 :                 auto read = EDF::read(buffer);
      66             : 
      67           1 :                 CHECK_EQ(dc.getSize(), read.getSize());
      68           1 :                 CHECK_EQ(dc.getDataDescriptor(), read.getDataDescriptor());
      69             : 
      70           1 :                 CHECK_EQ(dc, read);
      71           1 :             }
      72           2 :         }
      73           2 :     }
      74             : 
      75           5 :     GIVEN("a 2D DataContainer")
      76           5 :     {
      77           2 :         IndexVector_t numCoeff(2);
      78           2 :         numCoeff << 5, 10;
      79           2 :         DataContainer dc(VolumeDescriptor{numCoeff});
      80           2 :         dc = 0;
      81             : 
      82           2 :         WHEN("Writing it to an edf format")
      83           2 :         {
      84           2 :             std::stringstream buffer;
      85           2 :             EDF::write(dc, buffer);
      86             : 
      87           2 :             THEN("The header is correct")
      88           2 :             {
      89           1 :                 auto buffer_string = buffer.str();
      90           1 :                 auto header = buffer_string.substr(0, buffer_string.find('}' + 1));
      91             : 
      92           1 :                 auto parts = split(header, '\n');
      93           1 :                 parts.erase(std::begin(parts)); // remove the '{'
      94           1 :                 parts.pop_back();               // remove empty newline
      95           1 :                 parts.pop_back();               // remove closing '}'
      96           1 :                 parts.pop_back();               // remove filling spaces
      97             : 
      98           1 :                 CHECK_EQ(parts[0], "HeaderID = EH:000001:000000:000000;");
      99           1 :                 CHECK_EQ(parts[1], "Image = 1;");
     100           1 :                 CHECK_EQ(parts[2], "ByteOrder = LowByteFirst;");
     101           1 :                 CHECK_EQ(parts[3], "DataType = FloatValue;");
     102           1 :                 CHECK_EQ(parts[4], "Dim_1 = 5;");     // dim 1
     103           1 :                 CHECK_EQ(parts[5], "Dim_2 = 10;");    // dim 2
     104           1 :                 CHECK_EQ(parts[6], "Size = 200;");    // dim 1 * dim 2 * sizeof(float)
     105           1 :                 CHECK_EQ(parts[7], "Spacing = 1 1;"); // default 2D spacing
     106           1 :             }
     107             : 
     108           2 :             WHEN("Reading it back in")
     109           2 :             {
     110           1 :                 auto read = EDF::read(buffer);
     111             : 
     112           1 :                 CHECK_EQ(dc.getSize(), read.getSize());
     113           1 :                 CHECK_EQ(dc.getDataDescriptor(), read.getDataDescriptor());
     114             : 
     115           1 :                 CHECK_EQ(dc, read);
     116           1 :             }
     117           2 :         }
     118           2 :     }
     119             : 
     120           5 :     GIVEN("a DataContainer")
     121           5 :     {
     122           1 :         IndexVector_t numCoeff(2);
     123           1 :         numCoeff << 11, 17;
     124           1 :         VolumeDescriptor dd(numCoeff);
     125           1 :         DataContainer dc(dd);
     126           1 :         dc = 1;
     127             : 
     128           1 :         WHEN("writing out and reading in this DataContainer")
     129           1 :         {
     130           1 :             std::stringstream buffer;
     131           1 :             EDF::write(dc, buffer);
     132           1 :             auto dcRead = EDF::read(buffer);
     133             : 
     134           1 :             THEN("the read in DataContainer contains the expected data")
     135           1 :             {
     136           1 :                 CHECK_EQ(dc.getSize(), dcRead.getSize());
     137           1 :                 CHECK_EQ(dc.getDataDescriptor(), dcRead.getDataDescriptor());
     138             : 
     139           1 :                 CHECK_EQ(dcRead, dc);
     140           1 :             }
     141           1 :         }
     142           1 :     }
     143           5 : }
     144             : 
     145             : TEST_SUITE_END();