diff --git a/targets/tests/TestingHULC/Tests/PhiAndNuTest/PhiAndNuTest.cpp b/targets/tests/TestingHULC/Tests/PhiAndNuTest/PhiAndNuTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ef150d30d3408773c6acfe647bec01f86fb92770
--- /dev/null
+++ b/targets/tests/TestingHULC/Tests/PhiAndNuTest/PhiAndNuTest.cpp
@@ -0,0 +1,97 @@
+#include "PhiAndNuTest.h"
+
+#include "Utilities/TestCout/TestCoutImp.h"
+#include "PhiAndNuTest.h"
+
+std::shared_ptr<PhiAndNuTest> PhiAndNuTest::getNewInstance(std::string aTestName, double minOrderOfAccuracy, std::shared_ptr<TestCout> testOut)
+{
+	return std::shared_ptr<PhiAndNuTest>(new PhiAndNuTest(aTestName, minOrderOfAccuracy, testOut));
+}
+
+void PhiAndNuTest::evaluate()
+{
+	orderOfAccuracyNuDiff = calcOrderOfAccuracy(nuDiff);
+	orderOfAccuracyPhiDiff = calcOrderOfAccuracy(phiDiff);
+
+	nuDiffTestPassed = checkTestPassed(orderOfAccuracyNuDiff);
+	phiDiffTestPassed = checkTestPassed(orderOfAccuracyPhiDiff);
+	
+	if (orderOfAccuracyNuDiff.size() > 0 && orderOfAccuracyPhiDiff.size() > 0)
+		makeLastTestOutput();
+}
+
+void PhiAndNuTest::makeFinalOutput()
+{
+	for (int i = 1; i < lx.size(); i++) {
+		testOut->makeTestOutput(nuDiffTestPassed.at(i - 1), testName, lx.at(i - 1), lx.at(i), "NuDiff", "NuDiff", "OrderOfAccuracy", nuDiff.at(i - 1), nuDiff.at(i), orderOfAccuracyNuDiff.at(i - 1));
+		testOut->makeTestOutput(phiDiffTestPassed.at(i - 1), testName, lx.at(i - 1), lx.at(i), "PhiDiff", "PhiDiff", "OrderOfAccuracy", phiDiff.at(i - 1), phiDiff.at(i), orderOfAccuracyPhiDiff.at(i - 1));
+	}
+}
+
+void PhiAndNuTest::add(double phiDiff, double nuDiff, double lx)
+{
+	this->nuDiff.push_back(nuDiff);
+	this->phiDiff.push_back(phiDiff);
+	this->lx.push_back(lx);
+}
+
+std::string PhiAndNuTest::getOutput()
+{
+	std::ostringstream oss;
+	oss << "#################################################" << std::endl;
+	oss << "#" << std::setfill(' ') << std::right << std::setw(24 + testName.length() / 2) << testName << std::setw(24 - testName.length() / 2) << "#" << std::endl;
+	oss << "#################################################" << std::endl;
+
+	oss << "L" << "\t" << std::setfill(' ') << std::left << std::setw(15) << "NuDiff" << "Order of Accuracy" << std::endl;
+	oss << lx.at(0) << "\t" << nuDiff.at(0) << std::endl;
+	for (int i = 0; i < nuDiff.size() - 1; i++) {
+		oss << std::setfill(' ') << std::setw(23) << " " << orderOfAccuracyNuDiff.at(i) << std::endl;
+		oss << lx.at(i + 1) << "\t" << nuDiff.at(i + 1) << std::endl;
+	}
+	oss << std::endl;
+
+	oss << "L" << "\t" << std::setfill(' ') << std::left << std::setw(15) << "PhiDiff" << "Order of Accuracy" << std::endl;
+	oss << lx.at(0) << "\t" << phiDiff.at(0) << std::endl;
+	for (int i = 0; i < phiDiff.size() - 1; i++) {
+		oss << std::setfill(' ') << std::setw(23) << " " << orderOfAccuracyPhiDiff.at(i) << std::endl;
+		oss << lx.at(i + 1) << "\t" << phiDiff.at(i + 1) << std::endl;
+	}
+	oss << std::endl;
+
+	return oss.str();
+}
+
+PhiAndNuTest::PhiAndNuTest(std::string aTestName, double minOrderOfAccuracy, std::shared_ptr<TestCout> testOut) : testName(aTestName), minOrderOfAccuracy(minOrderOfAccuracy), testOut(testOut)
+{
+	phiDiff.resize(0);
+	nuDiff.resize(0);
+	lx.resize(0);
+	orderOfAccuracyPhiDiff.resize(0);
+	orderOfAccuracyNuDiff.resize(0);
+	nuDiffTestPassed.resize(0);
+	phiDiffTestPassed.resize(0);
+}
+
+void PhiAndNuTest::makeLastTestOutput()
+{
+	testOut->makeTestOutput(nuDiffTestPassed.back(), testName, lx.at(lx.size() - 1), lx.back(), "NuDiff", "NuDiff", "OrderOfAccuracy", nuDiff.at(nuDiff.size() - 1), nuDiff.back(), orderOfAccuracyNuDiff.at(orderOfAccuracyNuDiff.size() - 1));
+	testOut->makeTestOutput(phiDiffTestPassed.back(), testName, lx.at(lx.size() - 1), lx.back(), "PhiDiff", "PhiDiff", "OrderOfAccuracy", phiDiff.at(phiDiff.size() - 1), phiDiff.back(), orderOfAccuracyPhiDiff.at(orderOfAccuracyPhiDiff.size() - 1));
+}
+
+std::vector<double> PhiAndNuTest::calcOrderOfAccuracy(std::vector<double> data)
+{
+	std::vector<double> result;
+	for (int i = 1; i < lx.size(); i++) {
+		double ooa = log(data.at(i - 1) / data.at(i)) / log(lx.at(i) / lx.at(i - 1));
+		result.push_back(ooa);
+	}
+	return result;
+}
+
+std::vector<bool> PhiAndNuTest::checkTestPassed(std::vector<double> orderOfAccuracy)
+{
+	std::vector<bool> result;
+	for (int i = 0; i < orderOfAccuracy.size(); i++) 
+		result.push_back(orderOfAccuracy.at(i) > minOrderOfAccuracy);
+	return result;
+}
diff --git a/targets/tests/TestingHULC/Tests/PhiAndNuTest/PhiAndNuTest.h b/targets/tests/TestingHULC/Tests/PhiAndNuTest/PhiAndNuTest.h
new file mode 100644
index 0000000000000000000000000000000000000000..d32e07a03c8dd634ec8a00f20869d0c87037d93d
--- /dev/null
+++ b/targets/tests/TestingHULC/Tests/PhiAndNuTest/PhiAndNuTest.h
@@ -0,0 +1,41 @@
+#ifndef PHI_AND_NU_TEST_RESULTS_H
+#define PHI_AND_NU_TEST_RESULTS_H
+
+#include "Utilities/TestResults/TestResults.h"
+#include "Utilities/LogFileInformation/LogFileInformation.h"
+
+#include <memory>
+#include <vector>
+#include <iostream>
+
+class TestCout;
+
+class PhiAndNuTest : public TestResults, public LogFileInformation
+{
+public:
+	static std::shared_ptr<PhiAndNuTest> getNewInstance(std::string aTestName, double minOrderOfAccuracy, std::shared_ptr<TestCout> testOut);
+	void evaluate();
+	void makeFinalOutput();
+	void add(double phiDiff, double nuDiff, double lx);
+	std::string getOutput();
+
+private:
+	PhiAndNuTest(std::string aTestName, double minOrderOfAccuracy, std::shared_ptr<TestCout> testOut);
+	void makeLastTestOutput();
+	std::vector<double> calcOrderOfAccuracy(std::vector<double> data);
+	std::vector<bool> checkTestPassed(std::vector<double> orderOfAccuracy);
+
+	std::vector<double> phiDiff;
+	std::vector<double> nuDiff;
+	std::vector<double> lx;
+	std::vector<double> orderOfAccuracyPhiDiff;
+	std::vector<double> orderOfAccuracyNuDiff;
+	std::vector<bool> phiDiffTestPassed;
+	std::vector<bool> nuDiffTestPassed;
+		
+	double minOrderOfAccuracy;
+	std::string testName;
+
+	std::shared_ptr<TestCout> testOut;
+};
+#endif
diff --git a/targets/tests/TestingHULC/Tests/PhiAndNuTest/package.include b/targets/tests/TestingHULC/Tests/PhiAndNuTest/package.include
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/targets/tests/TestingHULC/Utilities/Calculator/FFTCalculator/FFTCalculator.cpp b/targets/tests/TestingHULC/Utilities/Calculator/FFTCalculator/FFTCalculator.cpp
index e4fd501abb227adf502b4ab57b698807009f0002..bfefef17bcd768b54198c1c1234832e835b59582 100644
--- a/targets/tests/TestingHULC/Utilities/Calculator/FFTCalculator/FFTCalculator.cpp
+++ b/targets/tests/TestingHULC/Utilities/Calculator/FFTCalculator/FFTCalculator.cpp
@@ -1,7 +1,7 @@
 #include "FFTCalculator.h"
 
 #include "Utilities\Results\Results.h"
-#include "Utilities\TestResults\PhiAndNuTestResults.h"
+#include "Tests/PhiAndNuTest/PhiAndNuTest.h"
 #include "Utilities\EvaluationParameter\EvaluationParameter.h"
 
 #define _USE_MATH_DEFINES
@@ -34,7 +34,7 @@ void FFTCalculator::init()
 	fftCalculated = false;
 }
 
-FFTCalculator::FFTCalculator(double viscosity, std::shared_ptr<PhiAndNuTestResults> testResults) : vis(viscosity), testResults(testResults)
+FFTCalculator::FFTCalculator(double viscosity, std::shared_ptr<PhiAndNuTest> testResults) : vis(viscosity), testResults(testResults)
 {
 
 }
diff --git a/targets/tests/TestingHULC/Utilities/Calculator/FFTCalculator/FFTCalculator.h b/targets/tests/TestingHULC/Utilities/Calculator/FFTCalculator/FFTCalculator.h
index ca9fb39be005f827e8d57950aead017e111ecb51..b71930feff6cc28afde6054167fc5aec8cfccc5b 100644
--- a/targets/tests/TestingHULC/Utilities/Calculator/FFTCalculator/FFTCalculator.h
+++ b/targets/tests/TestingHULC/Utilities/Calculator/FFTCalculator/FFTCalculator.h
@@ -10,7 +10,7 @@
 class Results;
 class EvaluationParameter;
 class TestResults;
-class PhiAndNuTestResults;
+class PhiAndNuTest;
 
 class FFTCalculator : public Calculator
 {
@@ -19,7 +19,7 @@ public:
 	void setSimulationResults(std::shared_ptr<Results> simResults);
 
 protected:
-	FFTCalculator(double viscosity, std::shared_ptr<PhiAndNuTestResults> testResults);
+	FFTCalculator(double viscosity, std::shared_ptr<PhiAndNuTest> testResults);
 	virtual void setVectorToCalc() = 0;
 
 	std::shared_ptr<Results> simResults;
@@ -38,7 +38,7 @@ private:
 	void initDataForFFT(fftw_complex* input, unsigned int timeStep);
 	void setFFTResults(fftw_complex* result, unsigned int timeStep);
 
-	std::shared_ptr<PhiAndNuTestResults> testResults;
+	std::shared_ptr<PhiAndNuTest> testResults;
 	std::vector<std::vector<double>> fftResultsIm;
 	std::vector<std::vector<double>> fftResultsRe;
 	std::vector<double> phi;
diff --git a/targets/tests/TestingHULC/Utilities/Calculator/FFTCalculator/VxFFTCalculator/VxFFTCalculator.cpp b/targets/tests/TestingHULC/Utilities/Calculator/FFTCalculator/VxFFTCalculator/VxFFTCalculator.cpp
index 3c72b021a0048f626a74a3f99297ecc389bd2056..b0c348a594b4e91f423a9901406f73c7f05189ae 100644
--- a/targets/tests/TestingHULC/Utilities/Calculator/FFTCalculator/VxFFTCalculator/VxFFTCalculator.cpp
+++ b/targets/tests/TestingHULC/Utilities/Calculator/FFTCalculator/VxFFTCalculator/VxFFTCalculator.cpp
@@ -2,7 +2,7 @@
 
 #include "Utilities\Results\Results.h"
 
-std::shared_ptr<VxFFTCalculator> VxFFTCalculator::getNewInstance(double viscosity, std::shared_ptr<PhiAndNuTestResults> testResults)
+std::shared_ptr<VxFFTCalculator> VxFFTCalculator::getNewInstance(double viscosity, std::shared_ptr<PhiAndNuTest> testResults)
 {
 	return std::shared_ptr<VxFFTCalculator>(new VxFFTCalculator(viscosity, testResults));
 }
@@ -12,7 +12,7 @@ void VxFFTCalculator::setVectorToCalc()
 	data = simResults->getVx();
 }
 
-VxFFTCalculator::VxFFTCalculator(double viscosity, std::shared_ptr<PhiAndNuTestResults> testResults) : FFTCalculator(viscosity, testResults)
+VxFFTCalculator::VxFFTCalculator(double viscosity, std::shared_ptr<PhiAndNuTest> testResults) : FFTCalculator(viscosity, testResults)
 {
 	
 }
\ No newline at end of file
diff --git a/targets/tests/TestingHULC/Utilities/Calculator/FFTCalculator/VxFFTCalculator/VxFFTCalculator.h b/targets/tests/TestingHULC/Utilities/Calculator/FFTCalculator/VxFFTCalculator/VxFFTCalculator.h
index 5a30a738840c55c0106607de58ff5311840861c3..0ebf89fcb5dfe1f0dbd0b9ba65256621b0db8c1a 100644
--- a/targets/tests/TestingHULC/Utilities/Calculator/FFTCalculator/VxFFTCalculator/VxFFTCalculator.h
+++ b/targets/tests/TestingHULC/Utilities/Calculator/FFTCalculator/VxFFTCalculator/VxFFTCalculator.h
@@ -6,11 +6,11 @@
 class VxFFTCalculator : public FFTCalculator
 {
 public:
-	static std::shared_ptr<VxFFTCalculator> getNewInstance(double viscosity, std::shared_ptr<PhiAndNuTestResults> testResults);
+	static std::shared_ptr<VxFFTCalculator> getNewInstance(double viscosity, std::shared_ptr<PhiAndNuTest> testResults);
 
 protected:
 	void setVectorToCalc();
 private:
-	VxFFTCalculator(double viscosity, std::shared_ptr<PhiAndNuTestResults> testResults);
+	VxFFTCalculator(double viscosity, std::shared_ptr<PhiAndNuTest> testResults);
 };
 #endif 
\ No newline at end of file
diff --git a/targets/tests/TestingHULC/Utilities/Calculator/FFTCalculator/VzFFTCalculator/VzFFTCalculator.cpp b/targets/tests/TestingHULC/Utilities/Calculator/FFTCalculator/VzFFTCalculator/VzFFTCalculator.cpp
index 75d1bb385a4d78900961d777cd9af72ff0b4dd2b..2b1fd85d80f2e60505a2e5cc1ecde270ac856314 100644
--- a/targets/tests/TestingHULC/Utilities/Calculator/FFTCalculator/VzFFTCalculator/VzFFTCalculator.cpp
+++ b/targets/tests/TestingHULC/Utilities/Calculator/FFTCalculator/VzFFTCalculator/VzFFTCalculator.cpp
@@ -3,7 +3,7 @@
 #include "Utilities\Results\Results.h"
 
 
-std::shared_ptr<VzFFTCalculator> VzFFTCalculator::getNewInstance(double viscosity, std::shared_ptr<PhiAndNuTestResults> testResults)
+std::shared_ptr<VzFFTCalculator> VzFFTCalculator::getNewInstance(double viscosity, std::shared_ptr<PhiAndNuTest> testResults)
 {
 	return std::shared_ptr<VzFFTCalculator>(new VzFFTCalculator(viscosity, testResults));
 }
@@ -13,6 +13,6 @@ void VzFFTCalculator::setVectorToCalc()
 	data = simResults->getVz();
 }
 
-VzFFTCalculator::VzFFTCalculator(double viscosity, std::shared_ptr<PhiAndNuTestResults> testResults) : FFTCalculator(viscosity, testResults)
+VzFFTCalculator::VzFFTCalculator(double viscosity, std::shared_ptr<PhiAndNuTest> testResults) : FFTCalculator(viscosity, testResults)
 {
 }
diff --git a/targets/tests/TestingHULC/Utilities/Calculator/FFTCalculator/VzFFTCalculator/VzFFTCalculator.h b/targets/tests/TestingHULC/Utilities/Calculator/FFTCalculator/VzFFTCalculator/VzFFTCalculator.h
index 4a0e112e6038b7e67cce4eb417255b235b26b04c..e0a3a9b455261827b409f215428b2da943427bd1 100644
--- a/targets/tests/TestingHULC/Utilities/Calculator/FFTCalculator/VzFFTCalculator/VzFFTCalculator.h
+++ b/targets/tests/TestingHULC/Utilities/Calculator/FFTCalculator/VzFFTCalculator/VzFFTCalculator.h
@@ -6,11 +6,11 @@
 class VzFFTCalculator : public FFTCalculator
 {
 public:
-	static std::shared_ptr<VzFFTCalculator> getNewInstance(double viscosity, std::shared_ptr<PhiAndNuTestResults> testResults);
+	static std::shared_ptr<VzFFTCalculator> getNewInstance(double viscosity, std::shared_ptr<PhiAndNuTest> testResults);
 
 protected:
 	void setVectorToCalc();
 private:
-	VzFFTCalculator(double viscosity, std::shared_ptr<PhiAndNuTestResults> testResults);
+	VzFFTCalculator(double viscosity, std::shared_ptr<PhiAndNuTest> testResults);
 };
 #endif 
\ No newline at end of file
diff --git a/targets/tests/TestingHULC/Utilities/TestResults/PhiAndNuTestResults.cpp b/targets/tests/TestingHULC/Utilities/TestResults/PhiAndNuTestResults.cpp
deleted file mode 100644
index 1ccce34b28937ce0212ccea57ec2c00bec44e4e3..0000000000000000000000000000000000000000
--- a/targets/tests/TestingHULC/Utilities/TestResults/PhiAndNuTestResults.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-#include "PhiAndNuTestResults.h"
-
-std::shared_ptr<PhiAndNuTestResults> PhiAndNuTestResults::getNewInstance(std::string aTestName)
-{
-	return std::shared_ptr<PhiAndNuTestResults>(new PhiAndNuTestResults(aTestName));
-}
-
-void PhiAndNuTestResults::evaluate()
-{
-	if (nuDiff.size() > 1 && phiDiff.size() > 1) {
-		const int sizeNuDiff = nuDiff.size();
-		double ordOfAccNuDiff = log(nuDiff.end()[-1] / nuDiff.back()) / log(lx.back() / lx.end()[-1]);
-		double ordOfAccPhiDiff = log(phiDiff.end()[-1] / phiDiff.back()) / log(lx.back()/ lx.end()[-1]);
-		orderOfAccuracyNuDiff.push_back(ordOfAccNuDiff);
-		orderOfAccuracyPhiDiff.push_back(ordOfAccPhiDiff);
-		makeLastTestOutput();
-	}
-}
-
-void PhiAndNuTestResults::add(double phiDiff, double nuDiff, double lx)
-{
-	this->nuDiff.push_back(nuDiff);
-	this->phiDiff.push_back(phiDiff);
-	this->lx.push_back(lx);
-}
-
-PhiAndNuTestResults::PhiAndNuTestResults(std::string aTestName) :testName(aTestName)
-{
-	phiDiff.resize(0);
-	nuDiff.resize(0);
-	lx.resize(0);
-	orderOfAccuracyPhiDiff.resize(0);
-	orderOfAccuracyNuDiff.resize(0);
-}
-
-void PhiAndNuTestResults::makeLastTestOutput()
-{
-	for (int i = 0; i < orderOfAccuracyNuDiff.size(); i++) {
-		std::cout << orderOfAccuracyNuDiff.at(i) << std::endl;
-	}
-}
diff --git a/targets/tests/TestingHULC/Utilities/TestResults/PhiAndNuTestResults.h b/targets/tests/TestingHULC/Utilities/TestResults/PhiAndNuTestResults.h
deleted file mode 100644
index 1e48a3deb8096d9986918d81b7c090efdff54130..0000000000000000000000000000000000000000
--- a/targets/tests/TestingHULC/Utilities/TestResults/PhiAndNuTestResults.h
+++ /dev/null
@@ -1,28 +0,0 @@
-#ifndef PHIANDNUTESTRESULTS_H
-#define PHIANDNUTESTRESULTS_H
-
-#include "TestResults.h"
-#include <memory>
-#include <vector>
-#include <iostream>
-
-class PhiAndNuTestResults : public TestResults
-{
-public:
-	static std::shared_ptr<PhiAndNuTestResults> getNewInstance(std::string aTestName);
-	void evaluate();
-	void add(double phiDiff, double nuDiff, double lx);
-
-private:
-	PhiAndNuTestResults(std::string aTestName);
-	void makeLastTestOutput();
-
-	std::vector<double> phiDiff;
-	std::vector<double> nuDiff;
-	std::vector<double> lx;
-	std::vector<double> orderOfAccuracyPhiDiff;
-	std::vector<double> orderOfAccuracyNuDiff;
-
-	std::string testName;
-};
-#endif // !PHIANDNUTESTRESULTS