FileComparisonHelper.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#include "MantidFrameworkTestHelpers/FileComparisonHelper.h"
 
#include "MantidAPI/FileFinder.h"
#include "MantidKernel/Logger.h"
 
#include <fstream>
#include <string>
 
namespace { // Anonymous namespace
// Bring typedef back into anonymous namespace
using streamCharIter = std::istreambuf_iterator<char>;
 
// Returns if the difference was due to EOL and fixes the position of the
// stream if it was due to EOL
bool isEolDifference(streamCharIter &streamOne, streamCharIter &streamTwo) {
 
  // Check which is the Windows file stream (CR in CRLF)
  // and advance it by a character so we are back to LF on both
  if (*streamOne == '\r' && *streamTwo == '\n') {
 
    ++streamOne;
  } else if (*streamOne == '\n' && *streamTwo == '\r') {
    ++streamTwo;
  } else {
    // Was not a different EOL so indicate false to that
    return false;
  }
  // We sorted EOL issues - return that this was the issue
  return true;
}
 
// Checks if two char streams are identical whilst accounting for
// EOL differences
bool checkCharactersAreIdentical(streamCharIter streamOne, streamCharIter streamTwo) {
  const char charOne = *streamOne;
  const char charTwo = *streamTwo;
 
  // Do comparison first so we do the least ops on good path
  if (charOne == charTwo) {
    return true;
  }
 
  // Have the handle EOL differences
  return isEolDifference(streamOne, streamTwo);
}
 
void logDifferenceError(char refChar, char testChar, size_t numNewLines, const std::string &seenChars) {
  const std::string lineNumber = std::to_string(numNewLines);
 
  // Build our output string
  std::string outError;
  (outError += "At line number: ") += lineNumber;
  (outError += ". Character number: ") += std::to_string(seenChars.size() + 1);
  (outError += " expected : '") += refChar;
  (outError += "' found: '") += testChar;
  ((outError += "\nReference output:\n") += seenChars) += refChar;
  ((outError += "\nTest output:\n") += seenChars) += testChar;
 
  Mantid::Kernel::Logger g_log("FileComparisonHelper");
  g_log.error(outError);
}
 
} // End of anonymous namespace
 
namespace FileComparisonHelper {
bool areIteratorsEqual(streamCharIter refStream, streamCharIter testStream, streamCharIter refStreamEnd,
                       streamCharIter testStreamEnd) {
  // Used if we need to display to the user something did not match
  size_t numNewLines = 0;
  std::string seenChars;
 
  while (refStream != refStreamEnd && testStream != testStreamEnd) {
    // Check individual values of iterators
    if (!checkCharactersAreIdentical(refStream, testStream)) {
      logDifferenceError(*refStream, *testStream, numNewLines, seenChars);
      return false;
    }
 
    // Keep track of where the previous EOL is in case we need to log an error
    if (*refStream == '\n') {
      seenChars.clear();
      numNewLines++;
    } else {
      seenChars += *refStream;
    }
    // Move iterators alone to compare next char
    refStream++;
    testStream++;
  }
 
  bool areStreamsEqual = true;
 
  // Lastly check both iterators were the same length as they should both
  // point to the end value
  if (refStream != refStreamEnd || testStream != testStreamEnd) {
    Mantid::Kernel::Logger g_log("FileComparisonHelper");
    g_log.error("Length of both files were not identical");
    areStreamsEqual = false;
  } else if (numNewLines == 0 && seenChars.empty()) {
    Mantid::Kernel::Logger g_log("FileComparisonHelper");
    g_log.error("No characters checked in FileComparisonHelper");
    areStreamsEqual = false;
  }
 
  return areStreamsEqual;
}
 
bool areFilesEqual(const std::string &referenceFileFullPath, const std::string &outFileFullPath) {
  std::ifstream refFileStream(referenceFileFullPath, std::ifstream::binary);
  std::ifstream outFileStream(outFileFullPath, std::ifstream::binary);
 
  if (refFileStream.fail()) {
    throw std::runtime_error("Could not open reference file at specified path");
  }
 
  if (outFileStream.fail()) {
    throw std::runtime_error("Could not open output file at specified path");
  }
 
  return areFileStreamsEqual(refFileStream, outFileStream);
}
 
bool areFileStreamsEqual(std::ifstream &referenceFileStream, std::ifstream &fileToCheck) {
  // Open iterators for function to run on
  streamCharIter refIter(referenceFileStream), checkIter(fileToCheck);
  // Last iterator in istream is equivalent of uninitialized iterator
  streamCharIter end;
 
  return areIteratorsEqual(refIter, checkIter, end, end);
}
 
bool isEqualToReferenceFile(const std::string &referenceFileName, const std::string &outFileFullPath) {
  const std::string referenceFilePath = Mantid::API::FileFinder::Instance().getFullPath(referenceFileName);
 
  if (referenceFilePath.empty()) {
    throw std::invalid_argument("No reference file with the name: " + referenceFileName +
                                " could be found by FileComparisonHelper");
  }
  return areFilesEqual(referenceFilePath, outFileFullPath);
}
 
} // Namespace FileComparisonHelper