# CheckBigEndianBug.cxx

    /*=========================================================================

      Program: GDCM (Grassroots DICOM). A DICOM library
      Module:  $URL$

      Copyright (c) 2006-2010 Mathieu Malaterre
      All rights reserved.
      See Copyright.txt or http://gdcm.sourceforge.net/Copyright.html for details.

         This software is distributed WITHOUT ANY WARRANTY; without even
         the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
         PURPOSE.  See the above copyright notice for more information.

    =========================================================================*/
    /*
     * WARNING: This is a dev tool, do not use !
     *
     * Usage: after a gdcmconv, you would like to know if the conversion process is acceptable
     * sometime a vbindiff is acceptable, sometime it is not. In the case of the famous Philips
     * Little/Big Endian Explicit Transfer Syntax it is not easy to compare two files. However
     * this only impact byte ordering, thus we can compute byte-indenpendant information to still
     * compare the files.
     */

    #include "gdcmImageReader.h"
    #include "gdcmImage.h"
    #include "gdcmWriter.h"
    #include "gdcmAttribute.h"
    #include "gdcmSystem.h"

    #include <iostream>
    #include <fstream>

    int main(int argc, char *argv[])
    {
      if( argc < 3 )
        {
        std::cerr << argv[0] << " input1.dcm input2.dcm" << std::endl;
        return 1;
        }
      const char *filename1 = argv[1];
      const char *filename2 = argv[2];

      gdcm::ImageReader reader1;
      reader1.SetFileName( filename1 );
      if( !reader1.Read() )
        {
        std::cerr << "Could not read: " << filename1 << std::endl;
        return 1;
        }

      gdcm::ImageReader reader2;
      reader2.SetFileName( filename2 );
      if( !reader2.Read() )
        {
        std::cerr << "Could not read: " << filename2 << std::endl;
        return 1;
        }

      // TODO: need a DataSet== operator implementation

      std::cout << "Both files can be read and looks like DICOM" << std::endl;

      size_t s1 = gdcm::System::FileSize(filename1);
      size_t s2 = gdcm::System::FileSize(filename2);

      if( s1 != s2 )
        {
        std::cout << "Size mismatch: " << s1 << " != " << s2 << std::endl;
        return 1;
        }
      else
        {
        std::cout << "Size match: " << s1 << " = " << s2 << std::endl;
        }

      std::ifstream is1( filename1 );
      char *buffer1 = new char[s1];
      is1.read(buffer1, s1);

      std::ifstream is2( filename2 );
      char *buffer2 = new char[s2];
      is2.read(buffer2, s2);

      assert( s1 == s2 );
      if( memcmp(buffer1, buffer2, s1 ) == 0 )
        {
        std::cout << "memcmp succeed ! File are bit identical" << std::endl;
        }
      else
        {
        std::cout << "memcmp failed!" << std::endl;
        }

      // Hum...memcmp failed, for big endian/ little endian inversion the histogram of bytes
      // should still be the same. So let's compute it
      // buffer2[0] = 1; // let's make the test fail
      std::multiset<char> set1( buffer1, buffer1 + s1 );
      std::multiset<char> set2( buffer2, buffer2 + s2 );

      if( set1 == set2 )
        {
        std::cout << "set1 == set2. Byte histogram seems valid" << std::endl;
        }
      else
        {
        std::cout << "set1 != set2" << std::endl;
        }
      delete[] buffer1;
      delete[] buffer2;

      return 0;
    }