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

#include "Misc/AutomationTest.h"

#if WITH_DEV_AUTOMATION_TESTS

#include "Misc/FrameNumber.h"
#include "Misc/FrameTime.h"
#include "Misc/FrameRate.h"
#include "CommonFrameRates.h"

namespace
{
	FFrameTime TestTimes[] = {
		FFrameTime(-10, 0.00f), FFrameTime(-10, 0.1f), FFrameTime(-10, 0.32f), FFrameTime(-10, 0.64f), FFrameTime(-10, 0.99999994f),
		FFrameTime(-6,  0.00f), FFrameTime(-6,  0.1f), FFrameTime(-6,  0.32f), FFrameTime(-6,  0.64f), FFrameTime(-6,  0.99999994f),
		FFrameTime(-5,  0.00f), FFrameTime(-5,  0.1f), FFrameTime(-5,  0.32f), FFrameTime(-5,  0.64f), FFrameTime(-5,  0.99999994f),
		FFrameTime(-3,  0.00f), FFrameTime(-3,  0.1f), FFrameTime(-3,  0.32f), FFrameTime(-3,  0.64f), FFrameTime(-3,  0.99999994f),
		FFrameTime(0,   0.00f), FFrameTime(0,   0.1f), FFrameTime(0,   0.32f), FFrameTime(0,   0.64f), FFrameTime(0,   0.99999994f),
		FFrameTime(3,   0.00f), FFrameTime(3,   0.1f), FFrameTime(3,   0.32f), FFrameTime(3,   0.64f), FFrameTime(3,   0.99999994f),
		FFrameTime(5,   0.00f), FFrameTime(5,   0.1f), FFrameTime(5,   0.32f), FFrameTime(5,   0.64f), FFrameTime(5,   0.99999994f),
		FFrameTime(6,   0.00f), FFrameTime(6,   0.1f), FFrameTime(6,   0.32f), FFrameTime(6,   0.64f), FFrameTime(6,   0.99999994f),
		FFrameTime(10,  0.00f), FFrameTime(10,  0.1f), FFrameTime(10,  0.32f), FFrameTime(10,  0.64f), FFrameTime(10,  0.99999994f),
	};

	bool IsNearlyEqual(FFrameTime Actual, FFrameTime Expected)
	{
		return Actual.FrameNumber == Expected.FrameNumber && FMath::IsNearlyEqual(Actual.GetSubFrame(), Expected.GetSubFrame(), KINDA_SMALL_NUMBER);
	}
}

IMPLEMENT_SIMPLE_AUTOMATION_TEST(FFrameTimeComparisonTest, "System.Core.Time.Comparison", EAutomationTestFlags_ApplicationContextMask | EAutomationTestFlags::SmokeFilter | EAutomationTestFlags::HighPriority)
bool FFrameTimeComparisonTest::RunTest(const FString& Parameters)
{
	const int32 NumFrames = UE_ARRAY_COUNT(TestTimes);

	for (int32 Index = 0; Index < NumFrames; ++Index)
	{
		FFrameTime RHS = TestTimes[Index];

		// Test frame times less than than current
		for (int32 OtherIndex = 0; OtherIndex < Index; ++OtherIndex)
		{
			FFrameTime LHS = TestTimes[OtherIndex];

			ensureAlwaysMsgf(  LHS <  RHS,  TEXT("  %d (+%0.3f) <   %d (+%0.3f)"), LHS.GetFrame().Value, LHS.GetSubFrame(), RHS.GetFrame().Value, RHS.GetSubFrame());
			ensureAlwaysMsgf(  LHS <= RHS,  TEXT("  %d (+%0.3f) <=  %d (+%0.3f)"), LHS.GetFrame().Value, LHS.GetSubFrame(), RHS.GetFrame().Value, RHS.GetSubFrame());
			ensureAlwaysMsgf(!(LHS >  RHS), TEXT("!(%d (+%0.3f) >  %d (+%0.3f))"), LHS.GetFrame().Value, LHS.GetSubFrame(), RHS.GetFrame().Value, RHS.GetSubFrame());
			ensureAlwaysMsgf(!(LHS >= RHS), TEXT("!(%d (+%0.3f) >= %d (+%0.3f))"), LHS.GetFrame().Value, LHS.GetSubFrame(), RHS.GetFrame().Value, RHS.GetSubFrame());
			ensureAlwaysMsgf(  LHS != RHS,  TEXT("  %d (+%0.3f) != %d (+%0.3f)"),  LHS.GetFrame().Value, LHS.GetSubFrame(), RHS.GetFrame().Value, RHS.GetSubFrame());
			ensureAlwaysMsgf(!(LHS == RHS), TEXT("!(%d (+%0.3f) == %d (+%0.3f))"), LHS.GetFrame().Value, LHS.GetSubFrame(), RHS.GetFrame().Value, RHS.GetSubFrame());
		}

		// Test comparing against self
		{
			FFrameTime LHS = TestTimes[Index];
			ensureAlwaysMsgf(!(LHS <  RHS), TEXT("!(%d (+%0.3f) <   %d (+%0.3f))"),LHS.GetFrame().Value, LHS.GetSubFrame(), RHS.GetFrame().Value, RHS.GetSubFrame());
			ensureAlwaysMsgf(  LHS <= RHS,  TEXT("  %d (+%0.3f) <=  %d (+%0.3f)"), LHS.GetFrame().Value, LHS.GetSubFrame(), RHS.GetFrame().Value, RHS.GetSubFrame());
			ensureAlwaysMsgf(!(LHS >  RHS), TEXT("!(%d (+%0.3f) >  %d (+%0.3f))"), LHS.GetFrame().Value, LHS.GetSubFrame(), RHS.GetFrame().Value, RHS.GetSubFrame());
			ensureAlwaysMsgf(  LHS >= RHS,  TEXT("  %d (+%0.3f) >= %d (+%0.3f)"),  LHS.GetFrame().Value, LHS.GetSubFrame(), RHS.GetFrame().Value, RHS.GetSubFrame());
			ensureAlwaysMsgf(!(LHS != RHS), TEXT("!(%d (+%0.3f) != %d (+%0.3f))"), LHS.GetFrame().Value, LHS.GetSubFrame(), RHS.GetFrame().Value, RHS.GetSubFrame());
			ensureAlwaysMsgf(  LHS == RHS,  TEXT("  %d (+%0.3f) == %d (+%0.3f)"),  LHS.GetFrame().Value, LHS.GetSubFrame(), RHS.GetFrame().Value, RHS.GetSubFrame());
		}

		// Test frame times greater than current
		for (int32 OtherIndex = Index + 1; OtherIndex < NumFrames; ++OtherIndex)
		{
			FFrameTime LHS = TestTimes[OtherIndex];

			ensureAlwaysMsgf(!(LHS <  RHS), TEXT("!(%d (+%0.3f) <   %d (+%0.3f))"), LHS.GetFrame().Value, LHS.GetSubFrame(), RHS.GetFrame().Value, RHS.GetSubFrame());
			ensureAlwaysMsgf(!(LHS <= RHS), TEXT("!(%d (+%0.3f) <=  %d (+%0.3f))"), LHS.GetFrame().Value, LHS.GetSubFrame(), RHS.GetFrame().Value, RHS.GetSubFrame());
			ensureAlwaysMsgf(  LHS >  RHS,  TEXT("  %d (+%0.3f) >  %d (+%0.3f)"),   LHS.GetFrame().Value, LHS.GetSubFrame(), RHS.GetFrame().Value, RHS.GetSubFrame());
			ensureAlwaysMsgf(  LHS >= RHS,  TEXT("  %d (+%0.3f) >= %d (+%0.3f)"),   LHS.GetFrame().Value, LHS.GetSubFrame(), RHS.GetFrame().Value, RHS.GetSubFrame());
			ensureAlwaysMsgf(  LHS != RHS,  TEXT("  %d (+%0.3f) != %d (+%0.3f)"),   LHS.GetFrame().Value, LHS.GetSubFrame(), RHS.GetFrame().Value, RHS.GetSubFrame());
			ensureAlwaysMsgf(!(LHS == RHS), TEXT("!(%d (+%0.3f) == %d (+%0.3f))"),  LHS.GetFrame().Value, LHS.GetSubFrame(), RHS.GetFrame().Value, RHS.GetSubFrame());
		}
	}


	return true;
}

IMPLEMENT_SIMPLE_AUTOMATION_TEST(FFrameTimeToSecondsTest, "System.Core.Time.ToSeconds", EAutomationTestFlags_ApplicationContextMask | EAutomationTestFlags::SmokeFilter | EAutomationTestFlags::HighPriority)
bool FFrameTimeToSecondsTest::RunTest(const FString& Parameters)
{
	const int32 NumFrames = UE_ARRAY_COUNT(TestTimes);

	FFrameRate TestRate = FCommonFrameRates::FPS_60();
	double ExpectedSeconds[] = {
		-0.166666666666667 , -0.165             , -0.161333333333333 , -0.156             , -0.150000001       ,
		-0.1               , -0.0983333333333333, -0.0946666666666667, -0.0893333333333333, -0.0833333343333333,
		-0.0833333333333333, -0.0816666666666667, -0.078             , -0.0726666666666667, -0.0666666676666667,
		-0.05              , -0.0483333333333333, -0.0446666666666667, -0.0393333333333333, -0.0333333343333333,
		 0.                ,  0.0016666666666666,  0.0053333333333333,  0.0106666666666667,  0.0166666656666667,
		 0.05              ,  0.0516666666666667,  0.0553333333333333,  0.0606666666666667,  0.0666666656666667,
		 0.0833333333333333,  0.085             ,  0.0886666666666667,  0.094             ,  0.099999999       ,
		 0.1               ,  0.101666666666667 ,  0.105333333333333 ,  0.110666666666667 ,  0.116666665666667 ,
		 0.166666666666667 ,  0.168333333333333 ,  0.172             ,  0.177333333333333 ,  0.183333332333333 ,
	};

	for (int32 Index = 0; Index < NumFrames; ++Index)
	{
		FFrameTime Time     = TestTimes[Index];

		// We test as floats so they round to the same precision as the sub frame
		float     Actual   = float(Time / TestRate);
		float     Expected = float(ExpectedSeconds[Index]);

		ensureAlwaysMsgf(FMath::IsNearlyEqual(Actual, Expected, 6e-6f), TEXT("%d (+%0.3f) @ 60fps: %.9f seconds (actual) == %.9f (expected) seconds"),  Time.GetFrame().Value, Time.GetSubFrame(), Actual, Expected);
	}


	return true;
}

IMPLEMENT_SIMPLE_AUTOMATION_TEST(FFrameTimeAdditionTest, "System.Core.Time.Addition", EAutomationTestFlags_ApplicationContextMask | EAutomationTestFlags::SmokeFilter | EAutomationTestFlags::HighPriority)
bool FFrameTimeAdditionTest::RunTest(const FString& Parameters)
{
	const int32 NumFrames = UE_ARRAY_COUNT(TestTimes);

	// Test adding a positive FrameTime with a small sub frame
	{
		FFrameTime TimeToAdd(10, 0.1f);
		FFrameTime ExpectedTimes[] = {
			FFrameTime(0,  0.1f), FFrameTime(0,  0.2f), FFrameTime(0,  0.42f), FFrameTime(0,  0.74f), FFrameTime(1,  0.099999905f),
			FFrameTime(4,  0.1f), FFrameTime(4,  0.2f), FFrameTime(4,  0.42f), FFrameTime(4,  0.74f), FFrameTime(5,  0.099999905f),
			FFrameTime(5,  0.1f), FFrameTime(5,  0.2f), FFrameTime(5,  0.42f), FFrameTime(5,  0.74f), FFrameTime(6,  0.099999905f),
			FFrameTime(7,  0.1f), FFrameTime(7,  0.2f), FFrameTime(7,  0.42f), FFrameTime(7,  0.74f), FFrameTime(8,  0.099999905f),
			FFrameTime(10, 0.1f), FFrameTime(10, 0.2f), FFrameTime(10, 0.42f), FFrameTime(10, 0.74f), FFrameTime(11, 0.099999905f),
			FFrameTime(13, 0.1f), FFrameTime(13, 0.2f), FFrameTime(13, 0.42f), FFrameTime(13, 0.74f), FFrameTime(14, 0.099999905f),
			FFrameTime(15, 0.1f), FFrameTime(15, 0.2f), FFrameTime(15, 0.42f), FFrameTime(15, 0.74f), FFrameTime(16, 0.099999905f),
			FFrameTime(16, 0.1f), FFrameTime(16, 0.2f), FFrameTime(16, 0.42f), FFrameTime(16, 0.74f), FFrameTime(17, 0.099999905f),
			FFrameTime(20, 0.1f), FFrameTime(20, 0.2f), FFrameTime(20, 0.42f), FFrameTime(20, 0.74f), FFrameTime(21, 0.099999905f),
		};

		for (int32 Index = 0; Index < NumFrames; ++Index)
		{
			FFrameTime Time     = TestTimes[Index];
			FFrameTime Actual   = Time + TimeToAdd;
			FFrameTime Expected = ExpectedTimes[Index];

			ensureAlwaysMsgf(IsNearlyEqual(Actual, Expected), TEXT("%d+%.3f + 10.1: %d+%.3f (actual) == %d+%.3f (expected)"),
				Time.GetFrame().Value,     Time.GetSubFrame(),
				Actual.GetFrame().Value,   Actual.GetSubFrame(),
				Expected.GetFrame().Value, Expected.GetSubFrame()
			);
		}
	}

	// Test adding a positive FrameTime with a large sub frame
	{
		FFrameTime TimeToAdd(10, 0.8f);
		FFrameTime ExpectedTimes[] = {
			FFrameTime(0,  0.8f),  FFrameTime(0,  0.900000036f), FFrameTime(1,  0.120000005f), FFrameTime(1,  0.440000057f), FFrameTime(1,  0.79999997f),
			FFrameTime(4,  0.8f),  FFrameTime(4,  0.900000036f), FFrameTime(5,  0.120000005f), FFrameTime(5,  0.440000057f), FFrameTime(5,  0.79999997f),
			FFrameTime(5,  0.8f),  FFrameTime(5,  0.900000036f), FFrameTime(6,  0.120000005f), FFrameTime(6,  0.440000057f), FFrameTime(6,  0.79999997f),
			FFrameTime(7,  0.8f),  FFrameTime(7,  0.900000036f), FFrameTime(8,  0.120000005f), FFrameTime(8,  0.440000057f), FFrameTime(8,  0.79999997f),
			FFrameTime(10, 0.8f),  FFrameTime(10, 0.900000036f), FFrameTime(11, 0.120000005f), FFrameTime(11, 0.440000057f), FFrameTime(11, 0.79999997f),
			FFrameTime(13, 0.8f),  FFrameTime(13, 0.900000036f), FFrameTime(14, 0.120000005f), FFrameTime(14, 0.440000057f), FFrameTime(14, 0.79999997f),
			FFrameTime(15, 0.8f),  FFrameTime(15, 0.900000036f), FFrameTime(16, 0.120000005f), FFrameTime(16, 0.440000057f), FFrameTime(16, 0.79999997f),
			FFrameTime(16, 0.8f),  FFrameTime(16, 0.900000036f), FFrameTime(17, 0.120000005f), FFrameTime(17, 0.440000057f), FFrameTime(17, 0.79999997f),
			FFrameTime(20, 0.8f),  FFrameTime(20, 0.900000036f), FFrameTime(21, 0.120000005f), FFrameTime(21, 0.440000057f), FFrameTime(21, 0.79999997f),
		};

		for (int32 Index = 0; Index < NumFrames; ++Index)
		{
			FFrameTime Time     = TestTimes[Index];
			FFrameTime Actual   = Time + TimeToAdd;
			FFrameTime Expected = ExpectedTimes[Index];

			ensureAlwaysMsgf(IsNearlyEqual(Actual, Expected), TEXT("%d+%.3f + 10.8: %d+%.3f (actual) == %d+%.3f (expected)"),
				Time.GetFrame().Value,     Time.GetSubFrame(),
				Actual.GetFrame().Value,   Actual.GetSubFrame(),
				Expected.GetFrame().Value, Expected.GetSubFrame()
			);
		}
	}

	// Test adding a negative FrameTime with a tiny sub frame
	{
		FFrameTime TimeToAdd(-13, 0.01f);
		FFrameTime ExpectedTimes[] = {
			FFrameTime(-23, 0.01f), FFrameTime(-23, 0.11f), FFrameTime(-23, 0.329999983f), FFrameTime(-23, 0.65f), FFrameTime(-22, 0.00999999046f),
			FFrameTime(-19, 0.01f), FFrameTime(-19, 0.11f), FFrameTime(-19, 0.329999983f), FFrameTime(-19, 0.65f), FFrameTime(-18, 0.00999999046f),
			FFrameTime(-18, 0.01f), FFrameTime(-18, 0.11f), FFrameTime(-18, 0.329999983f), FFrameTime(-18, 0.65f), FFrameTime(-17, 0.00999999046f),
			FFrameTime(-16, 0.01f), FFrameTime(-16, 0.11f), FFrameTime(-16, 0.329999983f), FFrameTime(-16, 0.65f), FFrameTime(-15, 0.00999999046f),
			FFrameTime(-13, 0.01f), FFrameTime(-13, 0.11f), FFrameTime(-13, 0.329999983f), FFrameTime(-13, 0.65f), FFrameTime(-12, 0.00999999046f),
			FFrameTime(-10, 0.01f), FFrameTime(-10, 0.11f), FFrameTime(-10, 0.329999983f), FFrameTime(-10, 0.65f), FFrameTime(-9,  0.00999999046f),
			FFrameTime(-8,  0.01f), FFrameTime(-8,  0.11f), FFrameTime(-8,  0.329999983f), FFrameTime(-8,  0.65f), FFrameTime(-7,  0.00999999046f),
			FFrameTime(-7,  0.01f), FFrameTime(-7,  0.11f), FFrameTime(-7,  0.329999983f), FFrameTime(-7,  0.65f), FFrameTime(-6,  0.00999999046f),
			FFrameTime(-3,  0.01f), FFrameTime(-3,  0.11f), FFrameTime(-3,  0.329999983f), FFrameTime(-3,  0.65f), FFrameTime(-2,  0.00999999046f),
		};

		for (int32 Index = 0; Index < NumFrames; ++Index)
		{
			FFrameTime Time     = TestTimes[Index];
			FFrameTime Actual   = Time + TimeToAdd;
			FFrameTime Expected = ExpectedTimes[Index];

			ensureAlwaysMsgf(IsNearlyEqual(Actual, Expected), TEXT("%d+%.3f + -13.01: %d+%.3f (actual) == %d+%.3f (expected)"),
				Time.GetFrame().Value,     Time.GetSubFrame(),
				Actual.GetFrame().Value,   Actual.GetSubFrame(),
				Expected.GetFrame().Value, Expected.GetSubFrame()
			);
		}
	}

	// Test adding a negative FrameTime with a large sub frame
	{
		FFrameTime TimeToAdd(-13, 0.9f);
		FFrameTime ExpectedTimes[] = {
			FFrameTime(-23, 0.9f), FFrameTime(-22, 0.f), FFrameTime(-22, 0.220000029f), FFrameTime(-22, 0.539999962f), FFrameTime(-22, 0.899999857f),
			FFrameTime(-19, 0.9f), FFrameTime(-18, 0.f), FFrameTime(-18, 0.220000029f), FFrameTime(-18, 0.539999962f), FFrameTime(-18, 0.899999857f),
			FFrameTime(-18, 0.9f), FFrameTime(-17, 0.f), FFrameTime(-17, 0.220000029f), FFrameTime(-17, 0.539999962f), FFrameTime(-17, 0.899999857f),
			FFrameTime(-16, 0.9f), FFrameTime(-15, 0.f), FFrameTime(-15, 0.220000029f), FFrameTime(-15, 0.539999962f), FFrameTime(-15, 0.899999857f),
			FFrameTime(-13, 0.9f), FFrameTime(-12, 0.f), FFrameTime(-12, 0.220000029f), FFrameTime(-12, 0.539999962f), FFrameTime(-12, 0.899999857f),
			FFrameTime(-10, 0.9f), FFrameTime(-9,  0.f), FFrameTime(-9,  0.220000029f), FFrameTime(-9,  0.539999962f), FFrameTime(-9,  0.899999857f),
			FFrameTime(-8,  0.9f), FFrameTime(-7,  0.f), FFrameTime(-7,  0.220000029f), FFrameTime(-7,  0.539999962f), FFrameTime(-7,  0.899999857f),
			FFrameTime(-7,  0.9f), FFrameTime(-6,  0.f), FFrameTime(-6,  0.220000029f), FFrameTime(-6,  0.539999962f), FFrameTime(-6,  0.899999857f),
			FFrameTime(-3,  0.9f), FFrameTime(-2,  0.f), FFrameTime(-2,  0.220000029f), FFrameTime(-2,  0.539999962f), FFrameTime(-2,  0.899999857f), 
		};

		for (int32 Index = 0; Index < NumFrames; ++Index)
		{
			FFrameTime Time     = TestTimes[Index];
			FFrameTime Actual   = Time + TimeToAdd;
			FFrameTime Expected = ExpectedTimes[Index];

			ensureAlwaysMsgf(IsNearlyEqual(Actual, Expected), TEXT("%d+%.3f + -13.9: %d+%.3f (actual) == %d+%.3f (expected)"),
				Time.GetFrame().Value,     Time.GetSubFrame(),
				Actual.GetFrame().Value,   Actual.GetSubFrame(),
				Expected.GetFrame().Value, Expected.GetSubFrame()
			);
		}
	}
	return true;
}

IMPLEMENT_SIMPLE_AUTOMATION_TEST(FFrameTimeSubtractionTest, "System.Core.Time.Subtraction", EAutomationTestFlags_ApplicationContextMask | EAutomationTestFlags::SmokeFilter | EAutomationTestFlags::HighPriority)
bool FFrameTimeSubtractionTest::RunTest(const FString& Parameters)
{
	const int32 NumFrames = UE_ARRAY_COUNT(TestTimes);

	// Test subtracting a positive FrameTime with a small sub frame
	{
		FFrameTime TimeToSubtract(10, 0.1f);
		FFrameTime ExpectedTimes[] = {
			FFrameTime(-21, 0.9f), FFrameTime(-20, 0.f), FFrameTime(-20, 0.22f), FFrameTime(-20, 0.539999962f), FFrameTime(-20, 0.899999917f),
			FFrameTime(-17, 0.9f), FFrameTime(-16, 0.f), FFrameTime(-16, 0.22f), FFrameTime(-16, 0.539999962f), FFrameTime(-16, 0.899999917f),
			FFrameTime(-16, 0.9f), FFrameTime(-15, 0.f), FFrameTime(-15, 0.22f), FFrameTime(-15, 0.539999962f), FFrameTime(-15, 0.899999917f),
			FFrameTime(-14, 0.9f), FFrameTime(-13, 0.f), FFrameTime(-13, 0.22f), FFrameTime(-13, 0.539999962f), FFrameTime(-13, 0.899999917f),
			FFrameTime(-11, 0.9f), FFrameTime(-10, 0.f), FFrameTime(-10, 0.22f), FFrameTime(-10, 0.539999962f), FFrameTime(-10, 0.899999917f),
			FFrameTime(-8,  0.9f),  FFrameTime(-7, 0.f), FFrameTime(-7,  0.22f), FFrameTime(-7,  0.539999962f), FFrameTime(-7,  0.899999917f),
			FFrameTime(-6,  0.9f),  FFrameTime(-5, 0.f), FFrameTime(-5,  0.22f), FFrameTime(-5,  0.539999962f), FFrameTime(-5,  0.899999917f),
			FFrameTime(-5,  0.9f),  FFrameTime(-4, 0.f), FFrameTime(-4,  0.22f), FFrameTime(-4,  0.539999962f), FFrameTime(-4,  0.899999917f),
			FFrameTime(-1,  0.9f),  FFrameTime(0,  0.f), FFrameTime(0,   0.22f), FFrameTime(0,   0.539999962f), FFrameTime(0,   0.899999917f),
		};

		for (int32 Index = 0; Index < NumFrames; ++Index)
		{
			FFrameTime Time     = TestTimes[Index];
			FFrameTime Actual   = Time - TimeToSubtract;
			FFrameTime Expected = ExpectedTimes[Index];

			ensureAlwaysMsgf(IsNearlyEqual(Actual, Expected), TEXT("%d+%.3f - 10.1: %d+%.3f (actual) == %d+%0.3f (expected)"),
				Time.GetFrame().Value,     Time.GetSubFrame(),
				Actual.GetFrame().Value,   Actual.GetSubFrame(),
				Expected.GetFrame().Value, Expected.GetSubFrame()
			);
		}
	}

	// Test adding a positive FrameTime with a large sub frame
	{
		FFrameTime TimeToSubtract(10, 0.8f);
		FFrameTime ExpectedTimes[] = {
			FFrameTime(-21, 0.199999988f), FFrameTime(-21, 0.3f), FFrameTime(-21, 0.52f), FFrameTime(-21, 0.84f), FFrameTime(-20, 0.19999993f),
			FFrameTime(-17, 0.199999988f), FFrameTime(-17, 0.3f), FFrameTime(-17, 0.52f), FFrameTime(-17, 0.84f), FFrameTime(-16, 0.19999993f),
			FFrameTime(-16, 0.199999988f), FFrameTime(-16, 0.3f), FFrameTime(-16, 0.52f), FFrameTime(-16, 0.84f), FFrameTime(-15, 0.19999993f),
			FFrameTime(-14, 0.199999988f), FFrameTime(-14, 0.3f), FFrameTime(-14, 0.52f), FFrameTime(-14, 0.84f), FFrameTime(-13, 0.19999993f),
			FFrameTime(-11, 0.199999988f), FFrameTime(-11, 0.3f), FFrameTime(-11, 0.52f), FFrameTime(-11, 0.84f), FFrameTime(-10, 0.19999993f), 
			FFrameTime(-8,  0.199999988f), FFrameTime(-8,  0.3f), FFrameTime(-8,  0.52f), FFrameTime(-8,  0.84f), FFrameTime(-7,  0.19999993f),
			FFrameTime(-6,  0.199999988f), FFrameTime(-6,  0.3f), FFrameTime(-6,  0.52f), FFrameTime(-6,  0.84f), FFrameTime(-5,  0.19999993f),
			FFrameTime(-5,  0.199999988f), FFrameTime(-5,  0.3f), FFrameTime(-5,  0.52f), FFrameTime(-5,  0.84f), FFrameTime(-4,  0.19999993f),
			FFrameTime(-1,  0.199999988f), FFrameTime(-1,  0.3f), FFrameTime(-1,  0.52f), FFrameTime(-1,  0.84f), FFrameTime(0,   0.19999993f),
		};

		for (int32 Index = 0; Index < NumFrames; ++Index)
		{
			FFrameTime Time     = TestTimes[Index];
			FFrameTime Actual   = Time - TimeToSubtract;
			FFrameTime Expected = ExpectedTimes[Index];

			ensureAlwaysMsgf(IsNearlyEqual(Actual, Expected), TEXT("%d+%.3f - 10.8: %d+%.3f (actual) == %d+%0.3f (expected)"),
				Time.GetFrame().Value,     Time.GetSubFrame(),
				Actual.GetFrame().Value,   Actual.GetSubFrame(),
				Expected.GetFrame().Value, Expected.GetSubFrame()
			);
		}
	}

	// Test adding a negative FrameTime with a tiny sub frame
	{
		FFrameTime TimeToSubtract(-13, 0.01f);
		FFrameTime ExpectedTimes[] = {
			FFrameTime(2,  0.99f), FFrameTime(3,  0.09f), FFrameTime(3,  0.31f), FFrameTime(3,  0.63f), FFrameTime(3,  0.98999997f),
			FFrameTime(6,  0.99f), FFrameTime(7,  0.09f), FFrameTime(7,  0.31f), FFrameTime(7,  0.63f), FFrameTime(7,  0.98999997f),
			FFrameTime(7,  0.99f), FFrameTime(8,  0.09f), FFrameTime(8,  0.31f), FFrameTime(8,  0.63f), FFrameTime(8,  0.98999997f),
			FFrameTime(9,  0.99f), FFrameTime(10, 0.09f), FFrameTime(10, 0.31f), FFrameTime(10, 0.63f), FFrameTime(10, 0.98999997f),
			FFrameTime(12, 0.99f), FFrameTime(13, 0.09f), FFrameTime(13, 0.31f), FFrameTime(13, 0.63f), FFrameTime(13, 0.98999997f),
			FFrameTime(15, 0.99f), FFrameTime(16, 0.09f), FFrameTime(16, 0.31f), FFrameTime(16, 0.63f), FFrameTime(16, 0.98999997f),
			FFrameTime(17, 0.99f), FFrameTime(18, 0.09f), FFrameTime(18, 0.31f), FFrameTime(18, 0.63f), FFrameTime(18, 0.98999997f),
			FFrameTime(18, 0.99f), FFrameTime(19, 0.09f), FFrameTime(19, 0.31f), FFrameTime(19, 0.63f), FFrameTime(19, 0.98999997f),
			FFrameTime(22, 0.99f), FFrameTime(23, 0.09f), FFrameTime(23, 0.31f), FFrameTime(23, 0.63f), FFrameTime(23, 0.98999997f),
		};

		for (int32 Index = 0; Index < NumFrames; ++Index)
		{
			FFrameTime Time     = TestTimes[Index];
			FFrameTime Actual   = Time - TimeToSubtract;
			FFrameTime Expected = ExpectedTimes[Index];

			ensureAlwaysMsgf(IsNearlyEqual(Actual, Expected), TEXT("%d+%.3f - -13.01: %d+%.3f (actual) == %d+%0.3f (expected)"),
				Time.GetFrame().Value,     Time.GetSubFrame(),
				Actual.GetFrame().Value,   Actual.GetSubFrame(),
				Expected.GetFrame().Value, Expected.GetSubFrame()
			);
		}
	}

	// Test adding a negative FrameTime with a large sub frame
	{
		FFrameTime TimeToSubtract(-13, 0.9f);
		FFrameTime ExpectedTimes[] = {
			FFrameTime(2,  0.100000024f), FFrameTime(2,  0.200000048f), FFrameTime(2,  0.420000017f), FFrameTime(2,  0.74f), FFrameTime(3,  0.0999999642f),
			FFrameTime(6,  0.100000024f), FFrameTime(6,  0.200000048f), FFrameTime(6,  0.420000017f), FFrameTime(6,  0.74f), FFrameTime(7,  0.0999999642f),
			FFrameTime(7,  0.100000024f), FFrameTime(7,  0.200000048f), FFrameTime(7,  0.420000017f), FFrameTime(7,  0.74f), FFrameTime(8,  0.0999999642f),
			FFrameTime(9,  0.100000024f), FFrameTime(9,  0.200000048f), FFrameTime(9,  0.420000017f), FFrameTime(9,  0.74f), FFrameTime(10, 0.0999999642f),
			FFrameTime(12, 0.100000024f), FFrameTime(12, 0.200000048f), FFrameTime(12, 0.420000017f), FFrameTime(12, 0.74f), FFrameTime(13, 0.0999999642f),
			FFrameTime(15, 0.100000024f), FFrameTime(15, 0.200000048f), FFrameTime(15, 0.420000017f), FFrameTime(15, 0.74f), FFrameTime(16, 0.0999999642f),
			FFrameTime(17, 0.100000024f), FFrameTime(17, 0.200000048f), FFrameTime(17, 0.420000017f), FFrameTime(17, 0.74f), FFrameTime(18, 0.0999999642f),
			FFrameTime(18, 0.100000024f), FFrameTime(18, 0.200000048f), FFrameTime(18, 0.420000017f), FFrameTime(18, 0.74f), FFrameTime(19, 0.0999999642f),
			FFrameTime(22, 0.100000024f), FFrameTime(22, 0.200000048f), FFrameTime(22, 0.420000017f), FFrameTime(22, 0.74f), FFrameTime(23, 0.0999999642f),
		};

		for (int32 Index = 0; Index < NumFrames; ++Index)
		{
			FFrameTime Time     = TestTimes[Index];
			FFrameTime Actual   = Time - TimeToSubtract;
			FFrameTime Expected = ExpectedTimes[Index];

			ensureAlwaysMsgf(IsNearlyEqual(Actual, Expected), TEXT("%d+%.3f - -13.9: %d+%.3f (actual) == %d+%0.3f (expected)"),
				Time.GetFrame().Value,     Time.GetSubFrame(),
				Actual.GetFrame().Value,   Actual.GetSubFrame(),
				Expected.GetFrame().Value, Expected.GetSubFrame()
			);
		}
	}
	return true;
}


IMPLEMENT_SIMPLE_AUTOMATION_TEST(FFrameTimeConversionTest, "System.Core.Time.Conversion", EAutomationTestFlags_ApplicationContextMask | EAutomationTestFlags::SmokeFilter | EAutomationTestFlags::HighPriority)
bool FFrameTimeConversionTest::RunTest(const FString& Parameters)
{
	const int32 NumFrames = UE_ARRAY_COUNT(TestTimes);

	{
		FFrameRate SrcRate = FCommonFrameRates::FPS_60();
		FFrameRate DstRate = FCommonFrameRates::FPS_30();

		FFrameTime ExpectedTimes[] = {
			FFrameTime(-5, 0.f),  FFrameTime(-5, 0.05f), FFrameTime(-5, 0.16f), FFrameTime(-5, 0.32f), FFrameTime(-5, 0.499999985f),
			FFrameTime(-3, 0.f),  FFrameTime(-3, 0.05f), FFrameTime(-3, 0.16f), FFrameTime(-3, 0.32f), FFrameTime(-3, 0.499999985f),
			FFrameTime(-3, 0.5f), FFrameTime(-3, 0.55f), FFrameTime(-3, 0.66f), FFrameTime(-3, 0.82f), FFrameTime(-3, FFrameTime::MaxSubframe),
			FFrameTime(-2, 0.5f), FFrameTime(-2, 0.55f), FFrameTime(-2, 0.66f), FFrameTime(-2, 0.82f), FFrameTime(-2, FFrameTime::MaxSubframe),
			FFrameTime(0,  0.f),  FFrameTime(0,  0.05f), FFrameTime(0,  0.16f), FFrameTime(0,  0.32f), FFrameTime(0,  0.499999985f),
			FFrameTime(1,  0.5f), FFrameTime(1,  0.55f), FFrameTime(1,  0.66f), FFrameTime(1,  0.82f), FFrameTime(1,  FFrameTime::MaxSubframe),
			FFrameTime(2,  0.5f), FFrameTime(2,  0.55f), FFrameTime(2,  0.66f), FFrameTime(2,  0.82f), FFrameTime(2,  FFrameTime::MaxSubframe),
			FFrameTime(3,  0.f),  FFrameTime(3,  0.05f), FFrameTime(3,  0.16f), FFrameTime(3,  0.32f), FFrameTime(3,  0.499999985f),
			FFrameTime(5,  0.f),  FFrameTime(5,  0.05f), FFrameTime(5,  0.16f), FFrameTime(5,  0.32f), FFrameTime(5,  0.499999985f),
		};

		for (int32 Index = 0; Index < NumFrames; ++Index)
		{
			FFrameTime Time     = TestTimes[Index];
			FFrameTime Actual   = FFrameRate::TransformTime(Time, SrcRate, DstRate);
			FFrameTime Expected = ExpectedTimes[Index];

			ensureAlwaysMsgf(Actual.GetFrame() == Expected.GetFrame() && FMath::IsNearlyEqual(Actual.GetSubFrame(), Expected.GetSubFrame(), KINDA_SMALL_NUMBER),
				TEXT("%d+%.3f 60fps -> 30fps: %d+%.3f (actual) == %d+%0.3f (expected)"),
				Time.GetFrame().Value,     Time.GetSubFrame(),
				Actual.GetFrame().Value,   Actual.GetSubFrame(),
				Expected.GetFrame().Value, Expected.GetSubFrame()
			);
		}
	}

	{
		FFrameRate SrcRate = FCommonFrameRates::FPS_60();
		FFrameRate DstRate = FCommonFrameRates::NTSC_30();

		FFrameTime ExpectedTimes[] = {
			FFrameTime(-5, 0.004995004995f), FFrameTime(-5, 0.05494505495f),  FFrameTime(-5, 0.1648351648f),   FFrameTime(-5, 0.3246753247f),   FFrameTime(-5, 0.5044954895f),
			FFrameTime(-3, 0.002997002997f), FFrameTime(-3, 0.05294705295f),  FFrameTime(-3, 0.1628371628f),   FFrameTime(-3, 0.3226773227f),   FFrameTime(-3, 0.5024974875f),
			FFrameTime(-3, 0.5024975025f),   FFrameTime(-3, 0.5524475524f),   FFrameTime(-3, 0.6623376623f),   FFrameTime(-3, 0.8221778222f),   FFrameTime(-2, 0.001997987013f),
			FFrameTime(-2, 0.5014985015f),   FFrameTime(-2, 0.5514485514f),   FFrameTime(-2, 0.6613386613f),   FFrameTime(-2, 0.8211788212f),   FFrameTime(-1, 0.000998986014f),
			FFrameTime(0,  0.f),             FFrameTime(0,  0.04995004995f),  FFrameTime(0,  0.1598401598f),   FFrameTime(0,  0.3196803197f),   FFrameTime(0,  0.4995004845f),
			FFrameTime(1,  0.4985014985f),   FFrameTime(1,  0.5484515485f),   FFrameTime(1,  0.6583416583f),   FFrameTime(1,  0.8181818182f),   FFrameTime(1,  0.998001983f),
			FFrameTime(2,  0.4975024975f),   FFrameTime(2,  0.5474525475f),   FFrameTime(2,  0.6573426573f),   FFrameTime(2,  0.8171828172f),   FFrameTime(2,  0.997002982f),
			FFrameTime(2,  0.997002997f),    FFrameTime(3,  0.04695304695f),  FFrameTime(3,  0.1568431568f),   FFrameTime(3,  0.3166833167f),   FFrameTime(3,  0.4965034815f),
			FFrameTime(4,  0.995004995f),    FFrameTime(5,  0.04495504496f),  FFrameTime(5,  0.1548451548f),   FFrameTime(5,  0.3146853147f),   FFrameTime(5,  0.4945054795f),
		};

		for (int32 Index = 0; Index < NumFrames; ++Index)
		{
			FFrameTime Time     = TestTimes[Index];
			FFrameTime Actual   = FFrameRate::TransformTime(Time, SrcRate, DstRate);
			FFrameTime Expected = ExpectedTimes[Index];

			ensureAlwaysMsgf(Actual.GetFrame() == Expected.GetFrame() && FMath::IsNearlyEqual(Actual.GetSubFrame(), Expected.GetSubFrame(), KINDA_SMALL_NUMBER),
				TEXT("%d+%.3f 60fps -> 29.97fps: %d+%.3f (actual) == %d+%0.3f (expected)"),
				Time.GetFrame().Value,     Time.GetSubFrame(),
				Actual.GetFrame().Value,   Actual.GetSubFrame(),
				Expected.GetFrame().Value, Expected.GetSubFrame()
			);
		}
	}

	{
		FFrameRate SrcRate = FCommonFrameRates::FPS_60();
		FFrameRate DstRate = FCommonFrameRates::FPS_60();

		for (int32 Index = 0; Index < NumFrames; ++Index)
		{
			FFrameTime Time     = TestTimes[Index];
			FFrameTime Actual   = FFrameRate::TransformTime(Time, SrcRate, DstRate);
			FFrameTime Expected = TestTimes[Index];

			ensureAlwaysMsgf(IsNearlyEqual(Actual, Expected), TEXT("%d+%.3f 60fps -> 60fps: %d+%.3f (actual) == %d+%0.3f (expected)"),
				Time.GetFrame().Value,     Time.GetSubFrame(),
				Actual.GetFrame().Value,   Actual.GetSubFrame(),
				Expected.GetFrame().Value, Expected.GetSubFrame()
			);
		}
	}

	return true;
}

IMPLEMENT_SIMPLE_AUTOMATION_TEST(FFrameRateMultiplesTest, "System.Core.Time.FrameRateMultiples", EAutomationTestFlags_ApplicationContextMask | EAutomationTestFlags::SmokeFilter | EAutomationTestFlags::HighPriority)
bool FFrameRateMultiplesTest::RunTest(const FString& Parameters)
{
	FFrameRate TestRates[] = {
		FCommonFrameRates::FPS_12(),
		FCommonFrameRates::FPS_15(),
		FCommonFrameRates::FPS_24(),
		FCommonFrameRates::FPS_25(),
		FCommonFrameRates::FPS_30(),
		FCommonFrameRates::FPS_48(),
		FCommonFrameRates::FPS_50(),
		FCommonFrameRates::FPS_60(),
		FCommonFrameRates::FPS_100(),
		FCommonFrameRates::FPS_120(),
		FCommonFrameRates::FPS_240(),
		FCommonFrameRates::NTSC_24(),
		FCommonFrameRates::NTSC_30(),
		FCommonFrameRates::NTSC_60(),
		FFrameRate(24000,1)
	};

	const int32 NumRates = UE_ARRAY_COUNT(TestRates);

	{
		bool IsMultipleOf[] = {
			true,	false,	true,	false,	false,	true,	false,	true,	false,	true,	true,	false,	false,	false,	true,
			false,	true,	false,	false,	true,	false,	false,	true,	false,	true,	true,	false,	false,	false,	true,
			false,	false,	true,	false,	false,	true,	false,	false,	false,	true,	true,	false,	false,	false,	true,
			false,	false,	false,	true,	false,	false,	true,	false,	true,	false,	false,	false,	false,	false,	true,
			false,	false,	false,	false,	true,	false,	false,	true,	false,	true,	true,	false,	false,	false,	true,
			false,	false,	false,	false,	false,	true,	false,	false,	false,	false,	true,	false,	false,	false,	true,
			false,	false,	false,	false,	false,	false,	true,	false,	true,	false,	false,	false,	false,	false,	true,
			false,	false,	false,	false,	false,	false,	false,	true,	false,	true,	true,	false,	false,	false,	true,
			false,	false,	false,	false,	false,	false,	false,	false,	true,	false,	false,	false,	false,	false,	true,
			false,	false,	false,	false,	false,	false,	false,	false,	false,	true,	true,	false,	false,	false,	true,
			false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	true,	false,	false,	false,	true,
			false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	true,	false,	false,	true,
			false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	true,	true,	false,
			false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	true,	false,
			false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	true,
		};


		bool IsFactorOf[] = {
			true,	false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	false,
			false,	true,	false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	false,
			true,	false,	true,	false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	false,
			false,	false,	false,	true,	false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	false,
			false,	true,	false,	false,	true,	false,	false,	false,	false,	false,	false,	false,	false,	false,	false,
			true,	false,	true,	false,	false,	true,	false,	false,	false,	false,	false,	false,	false,	false,	false,
			false,	false,	false,	true,	false,	false,	true,	false,	false,	false,	false,	false,	false,	false,	false,
			true,	true,	false,	false,	true,	false,	false,	true,	false,	false,	false,	false,	false,	false,	false,
			false,	false,	false,	true,	false,	false,	true,	false,	true,	false,	false,	false,	false,	false,	false,
			true,	true,	true,	false,	true,	false,	false,	true,	false,	true,	false,	false,	false,	false,	false,
			true,	true,	true,	false,	true,	true,	false,	true,	false,	true,	true,	false,	false,	false,	false,
			false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	true,	false,	false,	false,
			false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	true,	false,	false,
			false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	false,	true,	true,	false,
			true,	true,	true,	true,	true,	true,	true,	true,	true,	true,	true,	true,	false,	false,	true,
		};

		for (int32 Index = 0; Index < NumRates; ++Index)
		{
			FFrameRate SrcRate = TestRates[Index];

			for (int32 OtherIndex = 0; OtherIndex < NumRates; ++OtherIndex)
			{
				FFrameRate OtherRate = TestRates[OtherIndex];

				int32 TestResult = Index*NumRates + OtherIndex;

				if (IsMultipleOf[TestResult])
				{
					ensureAlwaysMsgf(SrcRate.IsMultipleOf(OtherRate),
						TEXT("Expected %d/%d to be a multiple of %d/%d."),
						SrcRate.Numerator, SrcRate.Denominator,
						OtherRate.Numerator, OtherRate.Denominator
					);
				}
				else
				{
					ensureAlwaysMsgf(!SrcRate.IsMultipleOf(OtherRate),
						TEXT("Did not expect %d/%d be a multiple of %d/%d."),
						SrcRate.Numerator, SrcRate.Denominator,
						OtherRate.Numerator, OtherRate.Denominator
					);
				}

				if (IsFactorOf[TestResult])
				{
					ensureAlwaysMsgf(SrcRate.IsFactorOf(OtherRate),
						TEXT("Expected %d/%d to be a factor of %d/%d."),
						SrcRate.Numerator, SrcRate.Denominator,
						OtherRate.Numerator, OtherRate.Denominator
					);
				}
				else
				{
					ensureAlwaysMsgf(!SrcRate.IsFactorOf(OtherRate),
						TEXT("Did not expect %d/%d to be a factor of %d/%d."),
						SrcRate.Numerator, SrcRate.Denominator,
						OtherRate.Numerator, OtherRate.Denominator
					);
				}
			}
		}
	}

	return true;
}

IMPLEMENT_SIMPLE_AUTOMATION_TEST(FFrameTimeToSecondsConversionTest, "System.Core.Time.FrameConversion", EAutomationTestFlags_ApplicationContextMask | EAutomationTestFlags::EngineFilter | EAutomationTestFlags::HighPriority)
bool FFrameTimeToSecondsConversionTest::RunTest(const FString& Parameters)
{
	FFrameRate TestRates[] = {
		FCommonFrameRates::FPS_12(),
		FCommonFrameRates::FPS_15(),
		FCommonFrameRates::FPS_24(),
		FCommonFrameRates::FPS_25(),
		FCommonFrameRates::FPS_30(),
		FCommonFrameRates::FPS_48(),
		FCommonFrameRates::FPS_50(),
		FCommonFrameRates::FPS_60(),
		FCommonFrameRates::FPS_100(),
		FCommonFrameRates::FPS_120(),
		FCommonFrameRates::FPS_240(),
		FCommonFrameRates::NTSC_24(),
		FCommonFrameRates::NTSC_30(),
		FCommonFrameRates::NTSC_60(),
		FFrameRate(24000,1)
	};
	
	const int32 NumberOfSecondsToTest = 60;
	for (const FFrameRate& FrameRate : TestRates)
	{
		const int32 NumberOfFrames = FrameRate.AsFrameNumber(static_cast<double>(NumberOfSecondsToTest)).Value;
		const double Interval = FrameRate.AsInterval();
		
		for (int32 FrameIndex = 0; FrameIndex < NumberOfFrames; ++FrameIndex)
		{
			// Get seconds representation according to frame-rate
			const double FrameAsSeconds = FrameRate.AsSeconds(FrameIndex);
			const double IntervalSeconds = static_cast<double>(FrameIndex) * Interval;

			// Verify seconds value against interval * FrameIndex
			ensureAlwaysMsgf(FMath::IsNearlyEqual(IntervalSeconds, FrameAsSeconds),
						TEXT("Did not expect value %f ::AsSeconds for input %i (%f)."),
						FrameAsSeconds, FrameIndex, IntervalSeconds
					);
			
			// Convert seconds values to FrameTime/FrameNumber values
			const FFrameTime FrameTime = FrameRate.AsFrameTime(FrameAsSeconds);
			const FFrameNumber FrameNumber = FrameRate.AsFrameNumber(FrameAsSeconds);

			// Verify frame numbers match original FrameIndex value
			ensureAlwaysMsgf(FrameTime.GetFrame() == FrameIndex,
						TEXT("Did not expect frame number %i ::AsFrameTime for input %i (%f)."),
						FrameNumber.Value, FrameIndex, FrameAsSeconds
					);
			
			ensureAlwaysMsgf(FrameNumber.Value == FrameIndex,
						TEXT("Did not expect frame number %i ::AsFrameNumber for input %i (%f)."),
						FrameNumber.Value, FrameIndex, FrameAsSeconds
					);
			
			// Convert FrameTime back to seconds and verify against value used to generate it
			const double ConvertedSeconds = FrameRate.AsSeconds(FrameTime);
			ensureAlwaysMsgf(FMath::IsNearlyEqual(ConvertedSeconds, FrameAsSeconds),
				TEXT("Did not expect value %f ::AsSeconds for input %i (%f) - %s."),
				ConvertedSeconds, FrameIndex, FrameAsSeconds, *LexToString(FrameTime)
			);
		}
	}

	return true;
}

#endif // WITH_DEV_AUTOMATION_TESTS