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           2 : std::vector<std::string> split(const std::string& s, char delim)
      19             : {
      20           4 :     std::stringstream ss(s);
      21           4 :     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             :     }
      26           4 :     return elems;
      27             : }
      28             : 
      29           5 : TEST_CASE("EDFHandler: Reading and writing data")
      30             : {
      31           7 :     GIVEN("a 1D DataContainer")
      32             :     {
      33           4 :         IndexVector_t numCoeff(1);
      34           2 :         numCoeff << 5;
      35           6 :         DataContainer dc(VolumeDescriptor{numCoeff});
      36           2 :         dc = 0;
      37             : 
      38           4 :         WHEN("Writing it to an edf format")
      39             :         {
      40           4 :             std::stringstream buffer;
      41           2 :             EDF::write(dc, buffer);
      42             : 
      43           3 :             THEN("The header is correct")
      44             :             {
      45           2 :                 auto buffer_string = buffer.str();
      46           2 :                 auto header = buffer_string.substr(0, buffer_string.find('}' + 1));
      47             : 
      48           2 :                 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             :             }
      62             : 
      63           3 :             WHEN("Reading it back in")
      64             :             {
      65           2 :                 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             :             }
      72             :         }
      73             :     }
      74             : 
      75           7 :     GIVEN("a 2D DataContainer")
      76             :     {
      77           4 :         IndexVector_t numCoeff(2);
      78           2 :         numCoeff << 5, 10;
      79           6 :         DataContainer dc(VolumeDescriptor{numCoeff});
      80           2 :         dc = 0;
      81             : 
      82           4 :         WHEN("Writing it to an edf format")
      83             :         {
      84           4 :             std::stringstream buffer;
      85           2 :             EDF::write(dc, buffer);
      86             : 
      87           3 :             THEN("The header is correct")
      88             :             {
      89           2 :                 auto buffer_string = buffer.str();
      90           2 :                 auto header = buffer_string.substr(0, buffer_string.find('}' + 1));
      91             : 
      92           2 :                 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             :             }
     107             : 
     108           3 :             WHEN("Reading it back in")
     109             :             {
     110           2 :                 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             :             }
     117             :         }
     118             :     }
     119             : 
     120           6 :     GIVEN("a DataContainer")
     121             :     {
     122           2 :         IndexVector_t numCoeff(2);
     123           1 :         numCoeff << 11, 17;
     124           2 :         VolumeDescriptor dd(numCoeff);
     125           2 :         DataContainer dc(dd);
     126           1 :         dc = 1;
     127             : 
     128           2 :         WHEN("writing out and reading in this DataContainer")
     129             :         {
     130           2 :             std::stringstream buffer;
     131           1 :             EDF::write(dc, buffer);
     132           2 :             auto dcRead = EDF::read(buffer);
     133             : 
     134           2 :             THEN("the read in DataContainer contains the expected data")
     135             :             {
     136           1 :                 CHECK_EQ(dc.getSize(), dcRead.getSize());
     137           1 :                 CHECK_EQ(dc.getDataDescriptor(), dcRead.getDataDescriptor());
     138             : 
     139           1 :                 CHECK_EQ(dcRead, dc);
     140             :             }
     141             :         }
     142             :     }
     143           5 : }
     144             : 
     145             : TEST_SUITE_END();