// Copyright Epic Games, Inc. All Rights Reserved.

#include "CQTest.h"
#include "Assert/NoDiscardAsserter.h"

DECLARE_LOG_CATEGORY_CLASS(AssertionTests, Log, All);

namespace CQTests
{
	static const FString ExpectedError = TEXT("Expected");
	static const TCHAR* AnyError = TEXT("");

	TEST_CLASS(NoDiscardAssert_Errors, "TestFramework.CQTest.Core")
	{
		FNoDiscardAsserter Asserter{ *TestRunner };
		TEST_METHOD(AssertFail_WithMessage_AddsError)
		{
			Assert.ExpectError(AnyError);
			Assert.Fail(AnyError);
		}

		PRAGMA_DISABLE_UNREACHABLE_CODE_WARNINGS
		TEST_METHOD(AssertFail_Macro_AddsErrorAndExits)
		{
			Assert.ExpectError(ExpectedError);
			ASSERT_FAIL(ExpectedError);
			ASSERT_FAIL(TEXT("It should not assert after the first expected assert since it exits"));
		}
		PRAGMA_RESTORE_UNREACHABLE_CODE_WARNINGS

		TEST_METHOD(Assertions_Accept_RawStrings)
		{
			Asserter.ExpectError("Hello World");
			Asserter.Fail("Hello World");
		}

		TEST_METHOD(Assertions_Accept_TCharArrays)
		{
			Asserter.ExpectError(TEXT("Hello World"));
			Asserter.Fail(TEXT("Hello World"));
		}

		TEST_METHOD(Assertions_Accept_FStrings)
		{
			FString message = TEXT("Hello World");
			Asserter.ExpectError(message);
			Asserter.Fail(message);
		}

		TEST_METHOD(AssertExpectError_WithMultipleErrors_Succeeds)
		{
			Asserter.ExpectError(AnyError, 3);
			Asserter.Fail("One");
			Asserter.Fail("Two");
			Asserter.Fail("Three");
		}

		TEST_METHOD(AsserterExpectError_WithZeroExpected_AcceptsAnyNumber)
		{
			Asserter.ExpectError(AnyError, 0);
			Asserter.Fail("One");
			Asserter.Fail("Two");
			Asserter.Fail("Three");
		}

		TEST_METHOD(AssertExpectError_WithMatchingError_Succeeds)
		{
			Asserter.ExpectError("Hello World");
			Asserter.Fail("Hello World");
		}

		TEST_METHOD(AssertExpectError_WithRegexSymbols_EscapesRegex)
		{
			Asserter.ExpectError("[^abc]");
			Asserter.Fail("[^abc]");
		}

		TEST_METHOD(AssertExpectErrorRegex_WithRegex_Succeeds)
		{
			Asserter.ExpectErrorRegex("\\w+");
			Asserter.Fail("abc");
		}
	};

	TEST_CLASS(NoDiscardAssert_Bools, "TestFramework.CQTest.Core")
	{
		TEST_METHOD(AssertTrue_WithTrue_Succeeds)
		{
			ASSERT_THAT(IsTrue(true));
		}
		TEST_METHOD(AssertTrue_WithTrueAndErrorMessage_DoesNotAddErrorMessage)
		{
			ASSERT_THAT(IsTrue(true, "Unexpected"));
		}
		TEST_METHOD(AssertTrue_WithFalse_AddsError)
		{
			Assert.ExpectError(AnyError);
			ASSERT_THAT(IsTrue(false));
		}
		TEST_METHOD(AssertTrue_WithFalseAndError_AddsSpecificError)
		{
			Assert.ExpectError(ExpectedError);
			ASSERT_THAT(IsTrue(false, ExpectedError));
		}

		TEST_METHOD(AssertFalse_WithFalse_Succeeds)
		{
			ASSERT_THAT(IsFalse(false));
		}
		TEST_METHOD(AssertFalse_WithFalseAndErrorMessage_DoesNotAddErrorMessage)
		{
			ASSERT_THAT(IsFalse(false, "Unexpected"));
		}
		TEST_METHOD(AssertFalse_WithTrue_AddsError)
		{
			Assert.ExpectError(AnyError);
			ASSERT_THAT(IsFalse(true));
		}
		TEST_METHOD(AssertFalse_WithTrueAndError_AddsSpecificError)
		{
			Assert.ExpectError(ExpectedError);
			ASSERT_THAT(IsFalse(true, ExpectedError));
		}
	};

	TEST_CLASS(NoDiscardAssert_Numbers, "TestFramework.CQTest.Core")
	{
		TEST_METHOD(AssertEqual_WithSameInts_Succeeds)
		{
			ASSERT_THAT(AreEqual(42, 42));
		}
		TEST_METHOD(AssertEqual_WithSameIntsAndErrorMessage_DoesNotAddErrorMessage)
		{
			ASSERT_THAT(AreEqual(42, 42, "Unexpected"));
		}
		TEST_METHOD(AssertEqual_WithDifferentInts_AddsError)
		{
			Assert.ExpectError(AnyError);
			ASSERT_THAT(AreEqual(42, 0));
		}
		TEST_METHOD(AssertEqual_WithDifferentIntsAndErrorMessage_AddsSpecificError)
		{
			Assert.ExpectError(ExpectedError);
			ASSERT_THAT(AreEqual(42, 0, ExpectedError));
		}

		/* These cases intentionally do not compile to avoid accidental floating point error
		TEST_METHOD(AssertEqual_WithDoubles_CompileError)
		{
			ASSERT_THAT(AreEqual(42.0, 42.0));
		}
		TEST_METHOD(AssertEqual_WithFloats_CompileError)
		{
			ASSERT_THAT(AreEqual(42.f, 42.f));
		}
		TEST_METHOD(AssertEqual_WithMixedFloat_CompileError)
		{
			ASSERT_THAT(AreEqual(42, 42.f));
		}

		TEST_METHOD(AssertNotEqual_WithDoubles_CompileError)
		{
			ASSERT_THAT(AreNotEqual(42.0, 42.0));
		}
		TEST_METHOD(AssertNotEqual_WithFloats_CompileError)
		{
			ASSERT_THAT(AreNotEqual(42.f, 42.f));
		}
		TEST_METHOD(AssertNotEqual_WithMixedFloat_CompileError)
		{
			ASSERT_THAT(AreNotEqual(42, 42.f));
		}
		*/

		TEST_METHOD(AssertNotEqual_WithDifferentInts_Succeeds)
		{
			ASSERT_THAT(AreNotEqual(42, 0));
		}
		TEST_METHOD(AssertNotEqual_WithDifferentAndErrorMessage_DoesNotAddErrorMessage)
		{
			ASSERT_THAT(AreNotEqual(42, 0, "Unexpected"));
		}
		TEST_METHOD(AssertNotEqual_WithSameInts_AddsError)
		{
			Assert.ExpectError(AnyError);
			ASSERT_THAT(AreNotEqual(42, 42));
		}
		TEST_METHOD(AssertNotEqual_WithSameIntsAndErrorMessage_AddsSpecificError)
		{
			Assert.ExpectError(ExpectedError);
			ASSERT_THAT(AreNotEqual(42, 42, ExpectedError));
		}

		TEST_METHOD(AssertNear_WithSameDoubles_Succeeds)
		{
			ASSERT_THAT(IsNear(3.14, 3.14, 0.001));
		}
		TEST_METHOD(AssertNear_WithSameDoublesAndErrorMessage_DoesNotAddErrorMessage)
		{
			ASSERT_THAT(IsNear(3.14, 3.14, 0.001, "Unexpected"));
		}
		TEST_METHOD(AssertNear_WithSimilarDoubles_Succeeds)
		{
			ASSERT_THAT(IsNear(3.0, 3.1, 1.0));
		}
		TEST_METHOD(AssertNear_WithDifferentDoubles_AddsError)
		{
			Assert.ExpectError(AnyError);
			ASSERT_THAT(IsNear(1.0, 2.0, 0.001));
		}
		TEST_METHOD(AssertNear_WithDifferentDoublesAndError_AddsSpecificError)
		{
			Assert.ExpectError(ExpectedError);
			ASSERT_THAT(IsNear(1.0, 2.0, 0.001, ExpectedError));
		}
		TEST_METHOD(AssertNear_WithSimilarDoubleWithinTolerance_Succeeds)
		{
			ASSERT_THAT(IsNear(3.0, 3.001, 0.01));
		}
		TEST_METHOD(AssertNear_WithSimilarDoubleWithinNegativeTolerance_Succeeds)
		{
			ASSERT_THAT(IsNear(3.0, 2.999, 0.01));
		}
		TEST_METHOD(AssertNear_WithSimilarDoubleOutsideTolerance_AddsError)
		{
			Assert.ExpectError(AnyError);
			ASSERT_THAT(IsNear(3.0, 3.1, 0.01));
		}
		TEST_METHOD(AssertNear_WithSimilarDoubleOutsideNegativeTolerance_AddsError)
		{
			Assert.ExpectError(AnyError);
			ASSERT_THAT(IsNear(3.0, 2.9, 0.01));
		}
	};

	TEST_CLASS(NoDiscardAssert_Pointers, "TestFramework.CQTest.Core")
	{
		TEST_METHOD(AssertNull_WithNullPtr_Succeeds)
		{
			int* ptr = nullptr;
			ASSERT_THAT(IsNull(ptr));
		}
		TEST_METHOD(AssertNull_WithNullPtrAndErrorMessage_DoesNotAddError)
		{
			int* ptr = nullptr;
			ASSERT_THAT(IsNull(ptr, "Unexpected"));
		}
		TEST_METHOD(AssertNull_WithNonNull_AddsError)
		{
			int val = 42;
			int* ptr = &val;
			Assert.ExpectError(AnyError);
			ASSERT_THAT(IsNull(ptr));
		}
		TEST_METHOD(AssertNull_WithNonNullAndErrorMessage_AddsSpecificErrorMessage)
		{
			int val = 42;
			int* ptr = &val;
			Assert.ExpectError(ExpectedError);
			ASSERT_THAT(IsNull(ptr, ExpectedError));
		}
		TEST_METHOD(AssertNull_WithInvalidSharedPtr_Succeeds)
		{
			auto ptr = TSharedPtr<int>{};
			ASSERT_THAT(IsNull(ptr));
		}
		TEST_METHOD(AssertNull_WithValidSharedPtr_AddsError)
		{
			TSharedPtr<int> ptr = MakeShared<int>(42);
			Assert.ExpectError(AnyError);
			ASSERT_THAT(IsNull(ptr));
		}
		TEST_METHOD(AssertNull_WithInvalidUniquePtr_Succeeds)
		{
			TUniquePtr<int> ptr;
			ASSERT_THAT(IsNull(ptr));
		}
		TEST_METHOD(AssertNull_WithValidUniquePtr_AddsError)
		{
			TUniquePtr<int> ptr = MakeUnique<int>(42);
			Assert.ExpectError(AnyError);
			ASSERT_THAT(IsNull(ptr));
		}

		TEST_METHOD(AssertNotNull_WithNullPtr_AddsError)
		{
			int* ptr = nullptr;
			Assert.ExpectError(AnyError);
			ASSERT_THAT(IsNotNull(ptr));
		}
		TEST_METHOD(AssertNotNull_WithNullPtrAndError_AddsSpecificError)
		{
			int* ptr = nullptr;
			Assert.ExpectError(ExpectedError);
			ASSERT_THAT(IsNotNull(ptr, ExpectedError));
		}
		TEST_METHOD(AssertNotNull_WithNonNull_Succeeds)
		{
			int val = 42;
			int* ptr = &val;
			ASSERT_THAT(IsNotNull(ptr));
		}
		TEST_METHOD(AssertNotNull_WithNonNullAndErrorMessage_DoesNotAddErrorMessage)
		{
			int val = 42;
			int* ptr = &val;
			ASSERT_THAT(IsNotNull(ptr, "Unexpected"));
		}
		TEST_METHOD(AssertNotNull_WithInvalidSharedPtr_AddsError)
		{
			auto ptr = TSharedPtr<int>{};
			Assert.ExpectError(AnyError);
			ASSERT_THAT(IsNotNull(ptr));
		}
		TEST_METHOD(AssertNotNull_WithValidSharedPtr_Succeeds)
		{
			TSharedPtr<int> ptr = MakeShared<int>(42);
			ASSERT_THAT(IsNotNull(ptr));
		}
		TEST_METHOD(AssertNotNull_WithInvalidUniquePtr_AddsError)
		{
			TUniquePtr<int> ptr;
			Assert.ExpectError(AnyError);
			ASSERT_THAT(IsNotNull(ptr));
		}
		TEST_METHOD(AssertNotNull_WithValidUniquePtr_Succeeds)
		{
			TUniquePtr<int> ptr = MakeUnique<int>(42);
			ASSERT_THAT(IsNotNull(ptr));
		}
	};

	TEST_CLASS(NoDiscardAssert_Strings, "TestFramework.CQTest.Core")
	{
		const TCHAR* SomeText{ TEXT("Hello") };
		const TCHAR* OtherText{ TEXT("World") };

		const TCHAR* UpperText{ TEXT("ONE") };
		const TCHAR* LowerText{ TEXT("one") };

		const FString SomeString{ SomeText };
		const FString OtherString{ OtherText };

		TEST_METHOD(AssertAreEqual_Text_Matching_Succeeds)
		{
			ASSERT_THAT(AreEqual(SomeText, SomeText));
		}
		TEST_METHOD(AssertAreEqual_Text_Mismatch_AddsError)
		{
			Assert.ExpectError(AnyError);
			ASSERT_THAT(AreEqual(SomeText, OtherText));
		}
		TEST_METHOD(AssertAreEqual_Text_DifferentCases_AddsError)
		{
			Assert.ExpectError(AnyError);
			ASSERT_THAT(AreEqual(UpperText, LowerText));
		}
		TEST_METHOD(AssertAreEqual_Text_MismatchAndError_AddsSpecificError)
		{
			Assert.ExpectError(ExpectedError);
			ASSERT_THAT(AreEqual(SomeText, OtherText, ExpectedError));
		}
		TEST_METHOD(AssertAreEqual_FString_Matching_Succeeds)
		{
			ASSERT_THAT(AreEqual(SomeString, SomeString));
		}
		TEST_METHOD(AssertAreEqual_FString_Mismatch_AddsError)
		{
			Assert.ExpectError(AnyError);
			ASSERT_THAT(AreEqual(SomeString, OtherString));
		}
		TEST_METHOD(AssertAreEqual_FString_MismatchAndError_AddsSpecificError)
		{
			Assert.ExpectError(ExpectedError);
			ASSERT_THAT(AreEqual(SomeString, OtherString, ExpectedError));
		}
		TEST_METHOD(AssertAreEqual_FString_DifferentCases_AddsError)
		{
			Assert.ExpectError(AnyError);
			ASSERT_THAT(AreEqual(SomeString.ToLower(), SomeString.ToUpper()));
		}

		TEST_METHOD(AssertAreEqualIgnoreCase_Text_Matching_Succeeds)
		{
			ASSERT_THAT(AreEqualIgnoreCase(SomeText, SomeText));
		}
		TEST_METHOD(AssertAreEqualIgnoreCase_Text_Mismatch_AddsError)
		{
			Assert.ExpectError(AnyError);
			ASSERT_THAT(AreEqualIgnoreCase(SomeText, OtherText));
		}
		TEST_METHOD(AssertAreEqualIgnoreCase_Text_MismatchAndError_AddsSpecificError)
		{
			Assert.ExpectError(ExpectedError);
			ASSERT_THAT(AreEqualIgnoreCase(SomeText, OtherText, ExpectedError));
		}
		TEST_METHOD(AssertAreEqualIgnoreCase_Text_DifferentCases_Succeeds)
		{
			ASSERT_THAT(AreEqualIgnoreCase(UpperText, LowerText));
		}
		TEST_METHOD(AssertAreEqualIgnoreCase_FString_Matching_Succeeds)
		{
			ASSERT_THAT(AreEqualIgnoreCase(SomeString, SomeString));
		}
		TEST_METHOD(AssertAreEqualIgnoreCase_FString_Mismatch_AddsError)
		{
			Assert.ExpectError(AnyError);
			ASSERT_THAT(AreEqualIgnoreCase(SomeString, OtherString));
		}
		TEST_METHOD(AssertAreEqualIgnoreCase_FString_MismatchAndError_AddsSpecificError)
		{
			Assert.ExpectError(ExpectedError);
			ASSERT_THAT(AreEqualIgnoreCase(SomeString, OtherString, ExpectedError));
		}
		TEST_METHOD(AssertAreEqualIgnoreCase_FString_DifferentCases_Succeeds)
		{
			ASSERT_THAT(AreEqualIgnoreCase(SomeString.ToUpper(), SomeString.ToLower()));
		}

		TEST_METHOD(AssertAreNotEqual_Text_Matching_AddsError)
		{
			Assert.ExpectError(AnyError);
			ASSERT_THAT(AreNotEqual(SomeText, SomeText));
		}
		TEST_METHOD(AssertAreNotEqual_Text_MatchingWithError_AddsSpecificError)
		{
			Assert.ExpectError(ExpectedError);
			ASSERT_THAT(AreNotEqual(SomeText, SomeText, ExpectedError));
		}
		TEST_METHOD(AssertAreNotEqual_Text_Mismatch_Succeeds)
		{
			ASSERT_THAT(AreNotEqual(SomeText, OtherText));
		}
		TEST_METHOD(AssertAreNotEqual_Text_MismatchWithError_Succeeds)
		{
			ASSERT_THAT(AreNotEqual(SomeText, OtherText, "Unexpected"));
		}
		TEST_METHOD(AssertAreNotEqual_Text_DifferentCases_Succeeds)
		{
			ASSERT_THAT(AreNotEqual(UpperText, LowerText));
		}
		TEST_METHOD(AssertAreNotEqual_FString_Matching_AddsError)
		{
			Assert.ExpectError(AnyError);
			ASSERT_THAT(AreNotEqual(SomeString, SomeString));
		}
		TEST_METHOD(AssertAreNotEqual_FString_MatchingWithMessage_AddsSpecificError)
		{
			Assert.ExpectError(ExpectedError);
			ASSERT_THAT(AreNotEqual(SomeString, SomeString, ExpectedError));
		}
		TEST_METHOD(AssertAreNotEqual_FString_Mismatch_Succeeds)
		{
			ASSERT_THAT(AreNotEqual(SomeString, OtherString));
		}
		TEST_METHOD(AssertAreNotEqual_FString_MismatchAndError_Succeeds)
		{
			ASSERT_THAT(AreNotEqual(SomeString, OtherString, ExpectedError));
		}
		TEST_METHOD(AssertAreNotEqual_FString_DifferentCases_Succeeds)
		{
			ASSERT_THAT(AreNotEqual(SomeString.ToLower(), SomeString.ToUpper()));
		}

		TEST_METHOD(AssertAreNotEqualIgnoreCase_Text_Matching_AddsError)
		{
			Assert.ExpectError(AnyError);
			ASSERT_THAT(AreNotEqualIgnoreCase(SomeText, SomeText));
		}
		TEST_METHOD(AssertAreNotEqualIgnoreCase_Text_MatchingWithError_AddsSpecificError)
		{
			Assert.ExpectError(ExpectedError);
			ASSERT_THAT(AreNotEqualIgnoreCase(SomeText, SomeText));
		}
		TEST_METHOD(AssertAreNotEqualIgnoreCase_Text_Mismatch_Succeeds)
		{
			ASSERT_THAT(AreNotEqualIgnoreCase(SomeText, OtherText));
		}
		TEST_METHOD(AssertAreNotEqualIgnoreCase_Text_MismatchAndError_Succeeds)
		{
			ASSERT_THAT(AreNotEqualIgnoreCase(SomeText, OtherText, "Unexpected"));
		}
		TEST_METHOD(AssertAreNotEqualIgnoreCase_Text_DifferentCases_AddsError)
		{
			Assert.ExpectError(AnyError);
			ASSERT_THAT(AreNotEqualIgnoreCase(UpperText, LowerText));
		}
		TEST_METHOD(AssertAreNotEqualIgnoreCase_FString_Matching_AddsError)
		{
			Assert.ExpectError(AnyError);
			ASSERT_THAT(AreNotEqualIgnoreCase(SomeString, SomeString));
		}
		TEST_METHOD(AssertAreNotEqualIgnoreCase_FString_MatchingWithError_AddsSpecificError)
		{
			Assert.ExpectError(ExpectedError);
			ASSERT_THAT(AreNotEqualIgnoreCase(SomeString, SomeString, ExpectedError));
		}
		TEST_METHOD(AssertAreNotEqualIgnoreCase_FString_Mismatch_Succeeds)
		{
			ASSERT_THAT(AreNotEqualIgnoreCase(SomeString, OtherString));
		}
		TEST_METHOD(AssertAreNotEqualIgnoreCase_FString_MismatchAndError_Succeeds)
		{
			ASSERT_THAT(AreNotEqualIgnoreCase(SomeString, OtherString, "Unexpected"));
		}
		TEST_METHOD(AssertAreNotEqualIgnoreCase_FString_DifferentCases_AddsError)
		{
			Assert.ExpectError(AnyError);
			ASSERT_THAT(AreNotEqualIgnoreCase(SomeString.ToUpper(), SomeString.ToLower()));
		}
	};
	
} // namespace CQTests

struct FCustomType
{
	FCustomType(const FString& InName)
		: Name(InName)
	{
	}

	FString Name;

	bool operator==(const FCustomType& other) const
	{
		return Name == other.Name;
	}
	bool operator!=(const FCustomType& other) const
	{
		return !(*this == other);
	}
};

template <>
FString CQTestConvert::ToString(const FCustomType& obj)
{
	return obj.Name;
}

TEST_CLASS(AssertMessage, "TestFramework.CQTest.Core")
{
	TEST_METHOD(AssertAreEqual_WithUnequalCustomTypes_PrintObjectNames)
	{
		FCustomType left = { "left" };
		FCustomType right = { "right" };

		Assert.ExpectError("Expected left to equal right");
		ASSERT_THAT(AreEqual(left, right));
	}

	TEST_METHOD(AssertAreNotEqual_WithEqualCustomTypes_PrintObjectNames)
	{
		FCustomType obj = { "Object" };

		Assert.ExpectError("Expected Object to not equal Object");
		ASSERT_THAT(AreNotEqual(obj, obj));
	}
};