// Copyright (c) Meta Platforms, Inc. and affiliates.

#include "Editor.h"
#include "Editor/UnrealEdEngine.h"
#include "MeshActor.h"
#include "Misc/AutomationTest.h"
#include "Misc/EngineVersionComparison.h"
#include "MRUtilityKitAnchor.h"
#include "MRUtilityKitAnchorActorSpawner.h"
#include "MRUtilityKitSubsystem.h"
#include "Tests/AutomationEditorCommon.h"
#include "TestHelper.h"
#include "UnrealEdGlobals.h"

#if UE_VERSION_OLDER_THAN(5, 5, 0)
BEGIN_DEFINE_SPEC(FMRUKSpec, TEXT("MR Utility Kit"), EAutomationTestFlags::ProductFilter | EAutomationTestFlags::ApplicationContextMask)
#else
BEGIN_DEFINE_SPEC(FMRUKSpec, TEXT("MR Utility Kit"), EAutomationTestFlags::ProductFilter | EAutomationTestFlags_ApplicationContextMask)
#endif
UMRUKSubsystem* ToolkitSubsystem;

void SetupMRUKSubsystem();
void LoadSceneFromJson();
void TeardownMRUKSubsystem();
using FAutomationTestBase::TestEqual; // Allows base class function overloads to be accessed
bool TestEqual(const TCHAR* What, const FVector2D Actual, const FVector2D Expected, float Tolerance = UE_KINDA_SMALL_NUMBER);
END_DEFINE_SPEC(FMRUKSpec)

void FMRUKSpec::SetupMRUKSubsystem()
{
	BeforeEach([this]() {
		// Load map and start play in editor
		const auto ContentDir = FPaths::ProjectContentDir();
		FAutomationEditorCommonUtils::LoadMap(ContentDir + "/Common/Maps/TestLevel.umap");
		StartPIE(true);
	});

	BeforeEach(EAsyncExecution::ThreadPool, []() {
		while (!GEditor->IsPlayingSessionInEditor())
		{
			// Wait until play session starts
			FGenericPlatformProcess::Yield();
		}
	});

	BeforeEach([this]() {
		// Get a reference to the subsystem
		const auto World = GEditor->GetPIEWorldContext()->World();
		const auto GameInstance = World->GetGameInstance();
		ToolkitSubsystem = GameInstance->GetSubsystem<UMRUKSubsystem>();
	});
}

void FMRUKSpec::LoadSceneFromJson()
{
	BeforeEach([this]() {
		// Load scene from Json
		ToolkitSubsystem->LoadSceneFromJsonString(ExampleRoomJson);
	});
}

void FMRUKSpec::TeardownMRUKSubsystem()
{
	// Caution: Order of these statements is important

	AfterEach(EAsyncExecution::ThreadPool, []() {
		while (GEditor->IsPlayingSessionInEditor())
		{
			// Wait until play session ends
			FGenericPlatformProcess::Yield();
		}
	});

	AfterEach([]() {
		// Request end of play session
		GUnrealEd->RequestEndPlayMap();
	});
}

// There is no TestEqual for FVector2D in FAutomationTestBase, so implement our own here
bool FMRUKSpec::TestEqual(const TCHAR* What, const FVector2D Actual, const FVector2D Expected, float Tolerance)
{
	if (!Expected.Equals(Actual, Tolerance))
	{
		AddError(FString::Printf(TEXT("Expected '%s' to be %s, but it was %s within tolerance %f."), What, *Expected.ToString(), *Actual.ToString(), Tolerance), 1);
		return false;
	}
	return true;
}

void FMRUKSpec::Define()
{
	Describe(TEXT("Interior spawner"), [this] {
		AMRUKAnchorActorSpawner* InteriorSpawner;

		SetupMRUKSubsystem();

		BeforeEach([this, &InteriorSpawner]() {
			const auto World = GEditor->GetPIEWorldContext()->World();
			FActorSpawnParameters Params{};
			InteriorSpawner = World->SpawnActor<AMRUKAnchorActorSpawner>(Params);

			InteriorSpawner->SpawnGroups[FMRUKLabels::Couch].Actors.Push({ AMeshActor::StaticClass() });
			InteriorSpawner->SpawnGroups[FMRUKLabels::WindowFrame].Actors.Push({ AMeshActor::StaticClass() });
		});

		LoadSceneFromJson();

		It(TEXT("Spawns interior correct"), [this]() {
			const auto World = GEditor->GetPIEWorldContext()->World();
			const auto Subsystem = World->GetGameInstance()->GetSubsystem<UMRUKSubsystem>();

			const auto Room = Subsystem->GetCurrentRoom();
			if (!TestNotNull(TEXT("Current room is set"), Room))
			{
				return;
			}

			const auto WindowAnchor = Subsystem->GetCurrentRoom()->GetFirstAnchorByLabel(FMRUKLabels::WindowFrame);
			if (!TestNotNull(TEXT("Window anchor is set"), WindowAnchor))
			{
				return;
			}

			TArray<AActor*> WindowChildActors;
			WindowAnchor->GetAttachedActors(WindowChildActors);
			if (!TestFalse(TEXT("Window has child actors"), WindowChildActors.IsEmpty()))
			{
				return;
			}

			const auto WindowMeshActor = WindowChildActors[0];
			if (!TestNotNull(TEXT("Window mesh is set"), WindowMeshActor))
			{
				return;
			}

			constexpr double Tolerance = 0.01;
			TestEqual(TEXT("Window mesh location"), WindowMeshActor->GetActorLocation(), FVector(86.993, 160.305, 27.147), Tolerance);
			TestEqual(TEXT("Window mesh rotation"), WindowMeshActor->GetActorRotation(), FRotator(-0.000010, -168.053020, 0.012821), Tolerance);
			TestEqual(TEXT("Window mesh scale"), WindowMeshActor->GetActorScale(), FVector(1.442, 1.154, 1.729), Tolerance);

			const auto CouchAnchor = Subsystem->GetCurrentRoom()->GetFirstAnchorByLabel("COUCH");
			if (!TestNotNull(TEXT("Couch anchor is set"), CouchAnchor))
			{
				return;
			}

			TArray<AActor*> CouchChildActors;
			CouchAnchor->GetAttachedActors(CouchChildActors);
			if (!TestFalse(TEXT("Couch has child actors"), CouchChildActors.IsEmpty()))
			{
				return;
			}

			const auto CouchMeshActor = CouchChildActors[0];
			if (!TestNotNull(TEXT("Couch mesh is set"), CouchMeshActor))
			{
				return;
			}

			TestEqual(TEXT("Couch mesh location"), CouchMeshActor->GetActorLocation(), FVector(-145.872, 107.079, -101.393), Tolerance);
			TestEqual(TEXT("Couch mesh rotation"), CouchMeshActor->GetActorRotation(), FRotator(0.0, -79.625847, 0.0), Tolerance);
			TestEqual(TEXT("Couch mesh scale"), CouchMeshActor->GetActorScale(), FVector(0.902, 2.029, 0.566), Tolerance);
		});

		TeardownMRUKSubsystem();
	});

	Describe(TEXT("Serialization"), [this] {
		SetupMRUKSubsystem();

		It(TEXT("Deserializes correctly"), [this]() {
			ToolkitSubsystem->LoadSceneFromJsonString(ExampleRoomJson);
			auto Rooms = ToolkitSubsystem->Rooms;
			if (!TestEqual(TEXT("Number of rooms"), Rooms.Num(), 1))
			{
				return;
			}
			auto Room = Rooms[0];
			if (!TestNotNull(TEXT("Room"), Room.Get()))
			{
				return;
			}
			TestEqual(TEXT("Number of anchors"), Room->AllAnchors.Num(), 23);
			TestEqual(TEXT("Number of walls"), Room->WallAnchors.Num(), 8);
			if (TestNotNull(TEXT("Floor anchor"), Room->FloorAnchor.Get()))
			{
				if (TestEqual(TEXT("Number of floor semantic classifications"), Room->FloorAnchor->SemanticClassifications.Num(), 1))
				{
					TestEqual(TEXT("Wall semantic classification"), Room->FloorAnchor->SemanticClassifications[0], FMRUKLabels::Floor);
				}
			}
			if (TestNotNull(TEXT("Ceiling anchor"), Room->CeilingAnchor.Get()))
			{
				if (TestEqual(TEXT("Number of ceiling semantic classifications"), Room->CeilingAnchor->SemanticClassifications.Num(), 1))
				{
					TestEqual(TEXT("Wall semantic classification"), Room->CeilingAnchor->SemanticClassifications[0], FMRUKLabels::Ceiling);
				}
			}
			for (auto Wall : Room->WallAnchors)
			{
				if (!TestNotNull(TEXT("Wall anchor"), Wall.Get()))
				{
					break;
				}
				if (!TestEqual(TEXT("Number of wall semantic classifications"), Wall->SemanticClassifications.Num(), 1))
				{
					break;
				}
				TestEqual(TEXT("Wall semantic classification"), Wall->SemanticClassifications[0], FMRUKLabels::WallFace);
			}
		});

		It(TEXT("Serializes correctly"), [this]() {
			ToolkitSubsystem->LoadSceneFromJsonString(ExampleRoomJson);
			auto Serialized = ToolkitSubsystem->SaveSceneToJsonString();
			TArray<FString> SerializedLines;
			TArray<FString> SourceLines;
			Serialized.ParseIntoArrayLines(SerializedLines, true);
			FString(ExampleRoomJson).ParseIntoArrayLines(SourceLines, true);
			if (TestEqual(TEXT("Number of lines"), SerializedLines.Num(), SourceLines.Num()))
			{
				// Go line by line in the JSON string and verify they match
				for (int i = 0; i < SerializedLines.Num(); ++i)
				{
					// When serializing/deserializing Rotations it does some conversion between Euler
					// rotation and quaternion. This results in some precision loss and in some cases
					// the same rotation can be represented in different ways so the numbers are quite
					// different even know they represent the same rotation so it is difficult to compare
					// them textually. For now we will just ignore these lines.
					if (SourceLines[i].Contains(TEXT("\"Rotation\"")))
					{
						continue;
					}
					TestEqual(TEXT("JSON line"), SerializedLines[i], SourceLines[i]);
				}
			}
		});

		TeardownMRUKSubsystem();
	});

	Describe(TEXT("Room Loading"), [this]() {
		SetupMRUKSubsystem();

		It(TEXT("Load invalid string"), [this]() {
			// Load scene from invalid JSON string
			ToolkitSubsystem->LoadSceneFromJsonString(TEXT("[[["));
			TestEqual("Scene load status", ToolkitSubsystem->SceneLoadStatus, EMRUKInitStatus::Failed);
		});

		It(TEXT("Load empty room"), [this]() {
			// Load scene from empty JSON string
			ToolkitSubsystem->LoadSceneFromJsonString(TEXT(R"({"Rooms": []})"));
			TestEqual("Scene load status", ToolkitSubsystem->SceneLoadStatus, EMRUKInitStatus::Failed);
		});

		TeardownMRUKSubsystem();
	});

	Describe(TEXT("Update room"), [this]() {
		SetupMRUKSubsystem();
		LoadSceneFromJson();

		It(TEXT("Change nothing in room"), [this]() {
			auto O = NewObject<URoomAndAnchorObserver>();

			ToolkitSubsystem->OnRoomCreated.AddDynamic(O, &URoomAndAnchorObserver::OnRoomCreated);
			ToolkitSubsystem->OnRoomUpdated.AddDynamic(O, &URoomAndAnchorObserver::OnRoomUpdated);
			ToolkitSubsystem->OnRoomRemoved.AddDynamic(O, &URoomAndAnchorObserver::OnRoomRemoved);

			for (auto Room : ToolkitSubsystem->Rooms)
			{
				Room->OnAnchorCreated.AddDynamic(O, &URoomAndAnchorObserver::OnAnchorCreated);
				Room->OnAnchorUpdated.AddDynamic(O, &URoomAndAnchorObserver::OnAnchorUpdated);
				Room->OnAnchorRemoved.AddDynamic(O, &URoomAndAnchorObserver::OnAnchorRemoved);
			}

			ToolkitSubsystem->LoadSceneFromJsonString(ExampleRoomJson);

			TestEqual(TEXT("No rooms created"), O->RoomsCreated.Num(), 0);
			TestEqual(TEXT("One room updated"), O->RoomsUpdated.Num(), 1);
			TestEqual(TEXT("No rooms removed"), O->RoomsRemoved.Num(), 0);
			TestEqual(TEXT("No anchors created"), O->AnchorsCreated.Num(), 0);
			TestEqual(TEXT("No anchors updated"), O->AnchorsUpdated.Num(), 0);
			TestEqual(TEXT("No anchors removed"), O->AnchorsRemoved.Num(), 0);

			O->MarkAsGarbage();
		});

		It(TEXT("Add, update and remove furniture in room"), [this]() {
			auto O = NewObject<URoomAndAnchorObserver>();

			ToolkitSubsystem->OnRoomCreated.AddDynamic(O, &URoomAndAnchorObserver::OnRoomCreated);
			ToolkitSubsystem->OnRoomUpdated.AddDynamic(O, &URoomAndAnchorObserver::OnRoomUpdated);
			ToolkitSubsystem->OnRoomRemoved.AddDynamic(O, &URoomAndAnchorObserver::OnRoomRemoved);

			for (auto Room : ToolkitSubsystem->Rooms)
			{
				Room->OnAnchorCreated.AddDynamic(O, &URoomAndAnchorObserver::OnAnchorCreated);
				Room->OnAnchorUpdated.AddDynamic(O, &URoomAndAnchorObserver::OnAnchorUpdated);
				Room->OnAnchorRemoved.AddDynamic(O, &URoomAndAnchorObserver::OnAnchorRemoved);
			}

			ToolkitSubsystem->LoadSceneFromJsonString(ExampleRoomFurnitureAddedJson);

			TestEqual(TEXT("No rooms created"), O->RoomsCreated.Num(), 0);
			TestEqual(TEXT("Rooms updated"), O->RoomsUpdated.Num(), 1);
			TestEqual(TEXT("No rooms removed"), O->RoomsRemoved.Num(), 0);
			TestEqual(TEXT("Anchors created"), O->AnchorsCreated.Num(), 2);
			TestEqual(TEXT("No anchors updated"), O->AnchorsUpdated.Num(), 0);
			TestEqual(TEXT("No anchors removed"), O->AnchorsRemoved.Num(), 0);

			O->Clear();

			ToolkitSubsystem->LoadSceneFromJsonString(ExampleRoomMoreFurnitureAddedJson);

			TestEqual(TEXT("No rooms created"), O->RoomsCreated.Num(), 0);
			TestEqual(TEXT("Rooms updated"), O->RoomsUpdated.Num(), 1);
			TestEqual(TEXT("No rooms removed"), O->RoomsRemoved.Num(), 0);
			TestEqual(TEXT("Anchors created"), O->AnchorsCreated.Num(), 1);
			TestEqual(TEXT("No anchors updated"), O->AnchorsUpdated.Num(), 0);
			TestEqual(TEXT("No anchors removed"), O->AnchorsRemoved.Num(), 0);

			O->Clear();

			ToolkitSubsystem->LoadSceneFromJsonString(ExampleRoomFurnitureModifiedJson);

			TestEqual(TEXT("No rooms created"), O->RoomsCreated.Num(), 0);
			TestEqual(TEXT("Rooms updated"), O->RoomsUpdated.Num(), 1);
			TestEqual(TEXT("No rooms removed"), O->RoomsRemoved.Num(), 0);
			TestEqual(TEXT("No anchors created"), O->AnchorsCreated.Num(), 0);
			TestEqual(TEXT("Anchors updated"), O->AnchorsUpdated.Num(), 2);
			TestEqual(TEXT("Anchors removed"), O->AnchorsRemoved.Num(), 1);

			O->Clear();

			ToolkitSubsystem->LoadSceneFromJsonString(ExampleRoomJson);

			TestEqual(TEXT("No rooms created"), O->RoomsCreated.Num(), 0);
			TestEqual(TEXT("Rooms updated"), O->RoomsUpdated.Num(), 1);
			TestEqual(TEXT("No rooms removed"), O->RoomsRemoved.Num(), 0);
			TestEqual(TEXT("No anchors created"), O->AnchorsCreated.Num(), 0);
			TestEqual(TEXT("No anchors updated"), O->AnchorsUpdated.Num(), 0);
			TestEqual(TEXT("Anchors removed"), O->AnchorsRemoved.Num(), 2);

			O->MarkAsGarbage();
		});

		It(TEXT("Add and remove room"), [this]() {
			auto O = NewObject<URoomAndAnchorObserver>();

			ToolkitSubsystem->OnRoomCreated.AddDynamic(O, &URoomAndAnchorObserver::OnRoomCreated);
			ToolkitSubsystem->OnRoomUpdated.AddDynamic(O, &URoomAndAnchorObserver::OnRoomUpdated);
			ToolkitSubsystem->OnRoomRemoved.AddDynamic(O, &URoomAndAnchorObserver::OnRoomRemoved);

			ToolkitSubsystem->LoadSceneFromJsonString(ExampleOtherRoomJson);

			TestEqual(TEXT("Room created"), O->RoomsCreated.Num(), 1);
			TestEqual(TEXT("No rooms updated"), O->RoomsUpdated.Num(), 0);
			TestEqual(TEXT("Rooms removed"), O->RoomsRemoved.Num(), 1);

			O->MarkAsGarbage();
		});

		TeardownMRUKSubsystem();
	});

	Describe("Room", [this]() {
		SetupMRUKSubsystem();
		LoadSceneFromJson();

		It(TEXT("Is initialized"), [this]() {
			TestEqual("Scene load status", ToolkitSubsystem->SceneLoadStatus, EMRUKInitStatus::Complete);
			auto Room = ToolkitSubsystem->GetCurrentRoom();
			if (!TestNotNull(TEXT("Current room"), Room))
			{
				return;
			}
			TestTrue("Room bounds valid", (bool)Room->RoomBounds.IsValid);
		});

		It(TEXT("Compute Centroid"), [this]() {
			TestEqual("Scene load status", ToolkitSubsystem->SceneLoadStatus, EMRUKInitStatus::Complete);
			const auto Room = ToolkitSubsystem->GetCurrentRoom();
			if (!TestNotNull(TEXT("Current room"), Room))
			{
				return;
			}

			const TArray<TPair<double, FVector>> Inputs = {
				{ 0.0, FVector(-63.212, 41.209, -129.629) },
				{ 0.5, FVector(-65.876, 40.507, 1.873) },
				{ 1.0, FVector(-68.540, 39.804, 133.376) },
			};

			for (int32 I = 0; I < Inputs.Num(); ++I)
			{
				const double Z = Inputs[I].Get<0>();
				const FVector& ExpectedCentroid = Inputs[I].Get<1>();

				const FVector Centroid = Room->ComputeCentroid(Z);
				constexpr double Tolerance = 0.001;
				TestEqual(TEXT("Centroid matches"), Centroid, ExpectedCentroid, Tolerance);
			}
		});

		It(TEXT("Does room have"), [this]() {
			auto Room = ToolkitSubsystem->GetCurrentRoom();
			if (!TestNotNull(TEXT("Current room"), Room))
			{
				return;
			}

			TArray<FString> ContainedLabels = { FMRUKLabels::WallFace, FMRUKLabels::Ceiling, FMRUKLabels::Floor };
			TestTrue(TEXT("Room contains all labels"), Room->DoesRoomHave(ContainedLabels));

			TArray<FString> PartlyContainedLabels = { FMRUKLabels::WallFace, "FOO", FMRUKLabels::Floor };
			TestFalse(TEXT("Room contains not all labels"), Room->DoesRoomHave(PartlyContainedLabels));

			TArray<FString> EmptyLabels;
			TestTrue(TEXT("Room contains empty labels"), Room->DoesRoomHave(EmptyLabels));
		});

		It(TEXT("Get forward facing direction"), [this]() {
			auto Room = ToolkitSubsystem->GetCurrentRoom();
			if (!TestNotNull(TEXT("Current room"), Room))
			{
				return;
			}

			const auto Couch = Room->GetFirstAnchorByLabel("COUCH");
			if (!TestNotNull(TEXT("Couch"), Room))
			{
				return;
			}

			const auto ActualFacingDirection = Couch->GetFacingDirection();
			constexpr double Tolerance = 0.001;
			TestEqual(TEXT("Facing direction"), ActualFacingDirection, FVector{ 0.180, -0.984, 0.000 }, Tolerance);
		});

		It(TEXT("Get anchors by label"), [this] {
			auto Room = ToolkitSubsystem->GetCurrentRoom();
			if (!TestNotNull(TEXT("Current room"), Room))
			{
				return;
			}
			const TArray<AMRUKAnchor*>& Anchors = Room->GetAnchorsByLabel(TEXT("WALL_FACE"));
			TestEqual(TEXT("All walls found"), Anchors.Num(), 8);
		});

		It(TEXT("Try get closest seat pose"), [this]() {
			auto Room = ToolkitSubsystem->GetCurrentRoom();
			if (!TestNotNull(TEXT("Current room"), Room))
			{
				return;
			}

			const auto Couch = Room->GetFirstAnchorByLabel("COUCH");
			if (!TestNotNull(TEXT("Couch"), Room))
			{
				return;
			}

			struct TestData
			{
				FVector RayOrigin;
				FVector RayDirection;
				FVector ExpectedLocation;
				FQuat ExpectedRotation;
				FOculusXRUUID ExpectedAnchorUUID;
			};

			TArray<TestData> AllTestData = {
				{ { -119.510, 51.224, -68.187 },
					{ -0.474, 0.815, -0.332 },
					{ -145.872, 107.079, -85.245 },
					{ 0.0, 0.0, -0.640282977, 0.768139121 },
					{ { 0xBE, 0xEE, 0x3C, 0xD7, 0x5B, 0xC0, 0x2A, 0xBF, 0x21, 0x9D, 0x99, 0x89, 0x48, 0x1A, 0xE7, 0x98 } } }
			};

			for (const auto& TestData : AllTestData)
			{
				FTransform ActualSeatTransform{};
				const auto Actor = Room->TryGetClosestSeatPose(TestData.RayOrigin, TestData.RayDirection, ActualSeatTransform);
				if (!TestNotNull(TEXT("Actor is set"), Actor))
				{
					return;
				}

				constexpr double Tolerance = 0.001;
				TestEqual(TEXT("Actor UUID is the same"), Actor->AnchorUUID, TestData.ExpectedAnchorUUID);
				TestEqual(TEXT("Location is the same"), ActualSeatTransform.GetLocation(), TestData.ExpectedLocation, Tolerance);
				TestTrue(TEXT("Rotation is the same"), ActualSeatTransform.GetRotation().Equals(TestData.ExpectedRotation, Tolerance));
			}
		});

		It(TEXT("Try get closest point in room"), [this]() {
			auto Room = ToolkitSubsystem->GetCurrentRoom();
			if (!TestNotNull(TEXT("Current room"), Room))
			{
				return;
			}

			struct TestData
			{
				FVector WorldLocation;
				TOptional<FVector> ExpectedSurfaceLocation;
				TOptional<FOculusXRUUID> ExpectedAnchorUUID;
			};

			TArray<TestData> AllTestData = {
				{
					{ -157.383, -117.528, -50.459 },
					{ { -155.038, -132.843, -50.459 } },
					{ { { 0xB3, 0x69, 0xDA, 0xC9, 0x91, 0x3F, 0x46, 0x53, 0xCF, 0x00, 0x06, 0xD2, 0x92, 0xB4, 0x7E, 0x67 } } },
				},
				{
					{ 70.723, 34.300, -18.577 },
					{ { 80.085, 36.095, -18.577 } },
					{ { { 0x4F, 0x3D, 0x50, 0x69, 0x41, 0xFC, 0xDF, 0x2C, 0xDE, 0x52, 0x9B, 0x77, 0x8F, 0x7E, 0x2C, 0xA0 } } },
				},
				{
					{ -6.787, 178.944, -15.669 },
					{ { -6.787, 178.944, -25.322 } },
					{ { { 0x39, 0x02, 0x15, 0x4E, 0x70, 0x0E, 0x7D, 0xFC, 0xEF, 0xCD, 0xD3, 0x1C, 0x7C, 0xEE, 0xA2, 0x1D } } },
				},
			};

			FMRUKLabelFilter LabelFilter;
			LabelFilter.ExcludedLabels = { FMRUKLabels::Ceiling, FMRUKLabels::Floor };

			for (const auto& TestData : AllTestData)
			{
				FVector ActualSurfaceLocation{};
				const auto ActualAnchor = ToolkitSubsystem->TryGetClosestSurfacePosition(TestData.WorldLocation, ActualSurfaceLocation, LabelFilter);
				if (TestData.ExpectedAnchorUUID.IsSet())
				{
					if (!TestNotNull(TEXT("Anchor is set"), ActualAnchor))
					{
						continue;
					}
					TestEqual(TEXT("Anchor Uuid"), ActualAnchor->AnchorUUID, TestData.ExpectedAnchorUUID.GetValue());
				}
				else
				{
					TestNull(TEXT("Anchor not set"), ActualAnchor);
				}
				if (TestData.ExpectedSurfaceLocation.IsSet())
				{
					constexpr double Tolerance = 0.01;
					TestEqual(TEXT("Surface location"), ActualSurfaceLocation, TestData.ExpectedSurfaceLocation.GetValue(), Tolerance);
				}
			}
		});

		It(TEXT("Get best pose from raycast"), [this]() {
			auto Room = ToolkitSubsystem->GetCurrentRoom();
			if (!TestNotNull(TEXT("Current room"), Room))
			{
				return;
			}

			struct TestData
			{
				FVector RayOrigin;
				FVector RayDirection;
				double MaxDist;
				FVector ExpectedLocation;
				FQuat ExpectedRotation;
				TOptional<FOculusXRUUID> ExpectedAnchorUUID;
				EMRUKPositioningMethod PositioningMethod;
			};

			TArray<TestData> AllTestData = {
				// Desk
				{
					{ -15.428, 52.817, 36.223 },
					{ 0.519, -0.143, -0.842 },
					0.0,
					{ 19.154, 34.502, -51.185 },
					{ 0.0, 0.0, -0.996050404, 0.088789598 },
					{ { { 0x1E, 0x57, 0x8C, 0x3E, 0x9E, 0x7B, 0x49, 0x5E, 0x9F, 0x8B, 0xB0, 0x0A, 0x37, 0x22, 0xB6, 0x19 } } },
					EMRUKPositioningMethod::Edge },
				// Desk
				{
					{ 0.0, 0.0, 0.0 },
					{ 1.0, 0.0, 0.0 },
					0.0,
					{ 121.404, 0.0, 0.0 },
					{ 0.000000072, 0.000000008, -0.994469644, 0.105024412 },
					{ { { 0x61, 0x34, 0x5A, 0x4C, 0xA1, 0xA0, 0x0C, 0x5C, 0x18, 0xC7, 0xAC, 0x34, 0x23, 0x37, 0x69, 0x01 } } },
					EMRUKPositioningMethod::Default },
				// Desk
				{
					{ 0.0, 0.0, 0.0 },
					{ 0.202, -0.725, -0.659 },
					0.0,
					{ 21.056, -75.154, -52.927 },
					{ 0.0, 0.0, 0.767014414, 0.641629869 },
					{ { { 0xB8, 0x82, 0x3B, 0xA2, 0x41, 0xD6, 0x9E, 0x1B, 0x5A, 0x3E, 0x71, 0x6F, 0xDC, 0x16, 0xC0, 0x35 } } },
					EMRUKPositioningMethod::Center },
				// Wall
				{
					{ 7.062, 83.282, -12.268 },
					{ 0.989, 0.146, 0.021 },
					0.0,
					{ 100.662, 97.104, -10.286 },
					{ 0.000000072, 0.000000008, -0.994469644, 0.105024412 },
					{ { { 0x61, 0x34, 0x5A, 0x4C, 0xA1, 0xA0, 0x0C, 0x5C, 0x18, 0xC7, 0xAC, 0x34, 0x23, 0x37, 0x69, 0x01 } } },
					EMRUKPositioningMethod::Default },
				// Floor
				{
					{ -55.000, 14.315, -64.814 },
					{ 0.054, 0.039, -0.998 },
					0.0,
					{ -51.499, 16.821, -129.629 },
					{ -0.000000000, 0.000000000, -0.952129375, 0.305695361 },
					{ { { 0x44, 0x08, 0xBC, 0xA3, 0x0B, 0x3E, 0xA7, 0x79, 0x99, 0x2A, 0x41, 0x33, 0x9E, 0x9B, 0xD1, 0x5E } } },
					EMRUKPositioningMethod::Default },
			};

			for (const auto& TestData : AllTestData)
			{
				FTransform ActualOutPose{};
				const auto Actor = Room->GetBestPoseFromRaycast(TestData.RayOrigin, TestData.RayDirection, TestData.MaxDist, {}, ActualOutPose, TestData.PositioningMethod);
				if (!TestData.ExpectedAnchorUUID.IsSet())
				{
					TestNull(TEXT("Actor is null"), Actor);
				}
				else
				{
					if (!TestNotNull(TEXT("Actor is set"), Actor))
					{
						return;
					}
					constexpr double Tolerance = 0.15;
					TestEqual(TEXT("Actor UUID is the same"), Actor->AnchorUUID, TestData.ExpectedAnchorUUID.GetValue());
					TestEqual(TEXT("Location is the same"), ActualOutPose.GetLocation(), TestData.ExpectedLocation, Tolerance);
					TestTrue(TEXT("Rotation is the same"), ActualOutPose.GetRotation().Equals(TestData.ExpectedRotation, Tolerance));
				}
			}
		});

		It(TEXT("Get key wall"), [this]() {
			auto Room = ToolkitSubsystem->GetCurrentRoom();
			if (!TestNotNull(TEXT("Current room"), Room))
			{
				return;
			}

			const auto KeyWallAnchor = Room->GetKeyWall();
			if (!TestNotNull(TEXT("Key wall anchor is not null"), KeyWallAnchor))
			{
				return;
			}
			TestEqual(TEXT("Key wall anchor UUID is correct"), KeyWallAnchor->AnchorUUID, FOculusXRUUID({ 0x93, 0x4C, 0xE7, 0x5D, 0x63, 0xF0, 0x85, 0x6A, 0x94, 0x38, 0xDA, 0xB3, 0xAD, 0xA9, 0x54, 0x09 }));
		});

		It(TEXT("Get largest surface"), [this]() {
			auto Room = ToolkitSubsystem->GetCurrentRoom();
			if (!TestNotNull(TEXT("Current room"), Room))
			{
				return;
			}

			auto Anchor = Room->GetLargestSurface(FMRUKLabels::WallArt);
			if (!TestNotNull(TEXT("Anchor is not null"), Anchor))
			{
				return;
			}
			TestEqual(TEXT("Anchor UUID is correct"), Anchor->AnchorUUID, FOculusXRUUID({ 0xDE, 0x8D, 0xDD, 0xD9, 0x90, 0xAD, 0x5F, 0xCB, 0x8E, 0x7E, 0x23, 0x7E, 0x93, 0x8C, 0xB0, 0xD3 }));

			Anchor = Room->GetLargestSurface(FMRUKLabels::Screen);
			if (!TestNotNull(TEXT("Anchor is not null"), Anchor))
			{
				return;
			}
			TestEqual(TEXT("Anchor UUID is correct"), Anchor->AnchorUUID, FOculusXRUUID({ 0x4F, 0x3D, 0x50, 0x69, 0x41, 0xFC, 0xDF, 0x2C, 0xDE, 0x52, 0x9B, 0x77, 0x8F, 0x7E, 0x2C, 0xA0 }));
		});

		It(TEXT("Point inside room"), [this]() {
			auto Room = ToolkitSubsystem->GetCurrentRoom();
			if (!TestNotNull(TEXT("Current room"), Room))
			{
				return;
			}
			TArray<FVector> PointsInRoom = {
				{ 95.046, -12.727, 74.243 },
				{ -135.569, 88.847, -64.303 },
				{ -51.55, 69.412, 81.61 },
				{ 38.378, -21.614, -34.768 },
				{ -241.943, 167.824, 55.476 },
				{ 26.605, -72.533, -39.321 },
				{ -234.718, 147.491, 49.483 },
				{ -114.777, -32.589, -86.116 },
				{ -244.759, 113.77, -88.077 },
				{ 38.533, 24.966, -112.239 },
				{ 94.798, 22.833, 42.658 },
				{ -208.202, 86.037, -4.801 },
				{ -111.049, 140.856, -15.237 },
				{ 15.575, 70.207, 100.421 },
				{ -8.435, 186.92, -33.971 },
				{ 83.304, -1.605, 44.165 },
				{ -142.314, 88.862, -48.251 },
				{ 82.577, -21.908, -80.743 },
				{ -238.493, 105.266, -40.407 },
				{ -14.607, 2.971, -12.6 },
				{ -179.35, 191.319, 27.259 },
				{ -86.745, 75.297, 22.939 },
				{ -200.003, 150.154, 63.187 },
				{ 69.257, 137.913, -79.824 },
				{ -217.763, -15.493, 40.155 },
				{ -175.591, 187.332, -77.132 },
			};
			TArray<FVector> PointsOutsideRoom = {
				{ -245.656, 252.788, 115.908 },
				{ 125.832, 197.925, -136.036 },
				{ -257.614, 152.096, 152.655 },
				{ -249.694, -184.363, -59.927 },
				{ 153.152, -12.065, 122.478 },
				{ -61.405, 91.172, 170.071 },
				{ -85.013, 214.58, 165.639 },
				{ 97.861, 122.995, -74.949 },
				{ -67.454, -164.751, 25.332 },
				{ -307.367, 117.743, 58.999 },
				{ -16.464, -96.471, -146.66 },
				{ -163.323, 258.776, 28.556 },
				{ -195.161, 206.385, 85.72 },
				{ -216.943, 235.398, 126.688 },
				{ -288.013, 219.714, -48.284 },
				{ -222.667, -128.603, -173.879 },
				{ 7.732, 271.929, -105.47 },
				{ 68.097, 168.956, -145.375 },
				{ 55.597, -87.261, 141.444 },
				{ 99.099, -97.089, 0.583 },
				{ -228.267, -126.999, -88.321 },
				{ 181.973, -23.026, 129.291 },
				{ -107.073, -43.962, -158.281 },
				{ 172.614, 114.712, -128.513 },
				{ 161.491, 217.493, 140.58 },
				{ 154.978, 216.728, -52.095 },
				{ -280.619, 16.374, 38.726 },
				{ -195.068, -163.147, -70.396 },
				{ 156.432, 181.094, -58.986 },
				{ 67.725, -186.069, -149.307 },
				{ -256.253, 95.056, -20.023 },
				{ 149.64, 88.759, -59.373 },
				{ 25.693, 122.745, 148.911 },
				{ -62.503, -143.933, -103.133 },
				{ 121.933, 51.698, 168.209 },
				{ 72.676, 20.743, -163.189 },
				{ -284.95, 41.311, 111.688 },
				{ 4.034, 105.002, -160.053 },
				{ 6.185, -177.904, -154.869 },
				{ 21.763, 277.166, 179.376 },
				{ -290.38, -65.427, 134.753 },
				{ 161.042, 119.184, -29.429 },
				{ -292.113, -180.332, 161.352 },
				{ -79.784, 192.026, 119.786 },
				{ -295.718, 6.046, 135.894 },
				{ -273.905, 223.437, -26.792 },
				{ 177.765, 139.767, -13.221 },
				{ 133.273, 5.384, -18.993 },
				{ -199.152, -169.606, -87.036 },
				{ 30.782, -84.009, -134.418 },
				{ -73.394, -175.653, 54.978 },
				{ -44.264, 279.844, -118.853 },
				{ 155.457, 66.602, -94.68 },
				{ 164.383, 267.044, -158.237 },
				{ -25.081, 253.362, -175.43 },
				{ -312.178, -141.447, 154.339 },
				{ -82.336, -10.668, -142.827 },
				{ -312.781, 62.6, -70.972 },
				{ -68.104, 245.8, -18.926 },
				{ -116.402, 241.062, -10.163 },
				{ 123.96, 47.02, -20.643 },
				{ 181.741, -122.821, -64.27 },
				{ -68.568, 288.024, 19.715 },
				{ -285.368, 110.666, -93.628 },
				{ 43.468, -93.616, 164.687 },
				{ 171.453, 103.427, 125.081 },
				{ -204.397, -179.14, 174.834 },
				{ 49.192, 14.358, -143.414 },
				{ -136.188, 15.623, 133.944 },
				{ 77.812, 216.154, -108.196 },
				{ 166.967, 0.175, 66.023 },
				{ -282.119, 168.515, 86.119 },
				{ 80.612, -53.231, 175.787 },
				{ 97.66, -146.566, 35.457 }
			};
			for (auto Point : PointsInRoom)
			{
				TestTrue("Point in room", Room->IsPositionInRoom(Point, true));
			}
			for (auto Point : PointsOutsideRoom)
			{
				TestFalse("Point outside room", Room->IsPositionInRoom(Point, true));
			}
		});

		It(TEXT("Generate random position in room"), [this]() {
			auto Room = ToolkitSubsystem->GetCurrentRoom();
			if (!TestNotNull(TEXT("Current room"), Room))
			{
				return;
			}
			// Generate 100 random positions in the room and verify that they are all indeed inside the room and not in scene volumes
			// using different minimum distances to surfaces
			FRandomStream RandomStream;
			TArray<float> MinDistanceToSurfaces = { 0.0f, 30.0f, 100.0f };
			for (float MinDistanceToSurface : MinDistanceToSurfaces)
			{
				AddInfo(FString::Printf(TEXT("Minimum distance to surface: %f"), MinDistanceToSurface));
				for (int i = 0; i < 100; ++i)
				{
					FVector Position;
					if (TestTrue(TEXT("Generated position successfully"), Room->GenerateRandomPositionInRoomFromStream(Position, RandomStream, MinDistanceToSurface, true)))
					{
						TestTrue(TEXT("Position is in room"), Room->IsPositionInRoom(Position));
						TestNull(TEXT("Position is not in a scene volume"), Room->IsPositionInSceneVolume(Position, true, MinDistanceToSurface));
						if (MinDistanceToSurface > 0.0f)
						{
							FVector SurfacePosition;
							double SurfaceDistance;
							TestNull(TEXT("Position is not within min distance of another surface"), Room->TryGetClosestSurfacePosition(Position, SurfacePosition, SurfaceDistance, {}, MinDistanceToSurface));
						}
					}
				}
			}

			// If the MinDistanceToSurface is too large such that there are no valid points, then it should fail to generate a random position in the room
			constexpr float LargeMinDistance = 300.0f;
			FVector Position;
			TestFalse(TEXT("No valid positions"), Room->GenerateRandomPositionInRoomFromStream(Position, RandomStream, LargeMinDistance));
		});

		It(TEXT("Ray cast"), [this]() {
			auto Room = ToolkitSubsystem->GetCurrentRoom();
			if (!TestNotNull(TEXT("Current room"), Room))
			{
				return;
			}
			struct FRecordedRaycast
			{
				// Input
				FVector Position;
				FVector Direction;
				float MaxDist;
				EMRUKComponentType ComponentTypes;
				// Output
				FString Label;
				FVector HitPosition;
				FVector HitNormal;
				float HitDistance;
			};
			TArray<FRecordedRaycast> RecordedRaycasts = {
				// Hits
				{ { 37.393, -14.003, -24.613 }, { 0.990, -0.048, -0.129 }, 0.0f, EMRUKComponentType::All, FMRUKLabels::Screen, { 84.823, -16.322, -30.780 }, { -0.995, 0.100, 0.000 }, 47.885 },
				{ { 37.393, -14.003, -24.613 }, { 0.990, -0.048, -0.129 }, 50.0f, EMRUKComponentType::All, FMRUKLabels::Screen, { 84.823, -16.322, -30.780 }, { -0.995, 0.100, 0.000 }, 47.885 },
				{ { -7.405, 27.794, -12.428 }, { 0.844, 0.003, -0.536 }, 0.0f, EMRUKComponentType::All, FMRUKLabels::Table, { 53.665, 28.008, -51.185 }, { 0.000, 0.000, 1.000 }, 72.33 },
				{ { -22.253, 36.487, 1.660 }, { 0.211, 0.054, -0.976 }, 0.0f, EMRUKComponentType::All, FMRUKLabels::Floor, { 6.171, 43.785, -129.629 }, { 0.000, -0.000, 1.000 }, 134.529 },
				{ { -22.253, 36.487, 1.660 }, { 0.432, 0.270, 0.861 }, 0.0f, EMRUKComponentType::All, FMRUKLabels::Ceiling, { 43.807, 77.766, 133.376 }, { 0.000, -0.000, -1.000 }, 153.026 },
				{ { -77.859, 204.433, -26.619 }, { 0.110, -0.534, -0.839 }, 0.0f, EMRUKComponentType::All, FMRUKLabels::Couch, { -70.131, 166.787, -85.797 }, { -0.180, 0.984, -0.000 }, 70.561 },
				{ { -127.986, 126.202, -94.119 }, { 0.606, -0.593, -0.530 }, 0.0f, EMRUKComponentType::All, FMRUKLabels::Floor, { -87.385, 86.442, -129.629 }, { 0.000, -0.000, 1.000 }, 67.009 },
				{ { -138.228, 108.241, -74.798 }, { -0.950, -0.240, -0.201 }, 0.0f, EMRUKComponentType::All, FMRUKLabels::Couch, { -187.570, 95.756, -85.245 }, { -0.000, 0.000, 1.000 }, 51.958 },
				{ { -298.759, 101.686, -76.521 }, { 0.968, -0.146, -0.204 }, 0.0f, EMRUKComponentType::All, FMRUKLabels::Couch, { -246.590, 93.797, -87.543 }, { -0.984, -0.180, -0.000 }, 53.901 },
				{ { -196.813, 0.663, -71.069 }, { 0.250, 0.908, -0.335 }, 0.0f, EMRUKComponentType::All, FMRUKLabels::Couch, { -181.948, 54.632, -91.002 }, { 0.180, -0.984, 0.000 }, 59.422 },
				{ { -115.905, 47.604, -6.411 }, { -0.199, 0.488, -0.850 }, 0.0f, EMRUKComponentType::All, FMRUKLabels::Couch, { -131.525, 85.882, -73.090 }, { -0.000, 0.000, 1.000 }, 78.456 },
				{ { -127.926, 109.603, 59.458 }, { -0.274, 0.955, -0.115 }, 0.0f, EMRUKComponentType::All, FMRUKLabels::WallArt, { -144.809, 168.482, 52.371 }, { 0.136, -0.991, -0.000 }, 61.66 },
				{ { 17.710, 137.262, 55.542 }, { 0.902, 0.409, -0.139 }, 0.0f, EMRUKComponentType::All, FMRUKLabels::WindowFrame, { 85.375, 167.955, 45.100 }, { -0.978, -0.207, -0.000 }, 75.031 },
				{ { -115.905, 47.604, -6.411 }, { -0.199, 0.488, -0.850 }, 0.0f, EMRUKComponentType::Plane, FMRUKLabels::Couch, { -134.361, 92.864, -85.245 }, { -0.000, 0.000, 1.000 }, 92.758 },
				{ { -115.905, 47.604, -6.411 }, { -0.199, 0.488, -0.850 }, 0.0f, EMRUKComponentType::Volume, FMRUKLabels::Couch, { -131.525, 85.882, -73.090 }, { -0.000, 0.000, 1.000 }, 78.456 },
				// Misses
				{ { -77.859, 204.433, -26.619 }, { 0.000, 0.000, -1.000 }, 0.0f, EMRUKComponentType::All, TEXT(""), { 0.0f, 0.0f, 0.0f }, { 0.0f, 0.0f, 0.0f }, 0.0f },
				{ { 37.393, -14.003, -24.613 }, { 0.990, -0.048, -0.129 }, 40.0f, EMRUKComponentType::All, TEXT(""), { 0.0f, 0.0f, 0.0f }, { 0.0f, 0.0f, 0.0f }, 0.0f },
				{ { -7.405, 27.794, -12.428 }, { 0.844, 0.003, -0.536 }, 70.0f, EMRUKComponentType::All, TEXT(""), { 0.0f, 0.0f, 0.0f }, { 0.0f, 0.0f, 0.0f }, 0.0f },
			};
			for (const auto& Recorded : RecordedRaycasts)
			{
				FMRUKHit Result;
				auto Anchor = Room->Raycast(Recorded.Position, Recorded.Direction, Recorded.MaxDist, { .ComponentTypes = static_cast<int32>(Recorded.ComponentTypes) }, Result);
				// This is a fairly generous tolerance, but necessary because ray pos and direction were only recorded
				// up to 3 decimal places and small changes in direction can result in fairly large differences in hit position
				// over long distances.
				constexpr float Tolerance = 0.1;
				if (Anchor == nullptr)
				{
					TestTrue(TEXT("No hit"), Recorded.Label.IsEmpty());
				}
				else
				{
					TestEqual(TEXT("Hit position"), Result.HitPosition, Recorded.HitPosition, Tolerance);
					TestEqual(TEXT("Hit normal"), Result.HitNormal, Recorded.HitNormal, Tolerance);
					TestEqual(TEXT("Hit distance"), Result.HitDistance, Recorded.HitDistance, Tolerance);
					if (TestTrue(TEXT("Has semantic classification"), Anchor->SemanticClassifications.Num() > 0))
					{
						TestEqual(TEXT("Hit label"), Anchor->SemanticClassifications[0], Recorded.Label);
					}
				}
			}
		});

		It(TEXT("Ray cast all"), [this]() {
			auto Room = ToolkitSubsystem->GetCurrentRoom();
			if (!TestNotNull(TEXT("Current room"), Room))
			{
				return;
			}
			struct FRecordedRaycastHit
			{
				FString Label;
				FVector HitPosition;
				FVector HitNormal;
				float HitDistance;
			};
			struct FRecordedRaycastAll
			{
				// Input
				FVector Position;
				FVector Direction;
				float MaxDist;
				EMRUKComponentType ComponentTypes;
				// Output
				TArray<FRecordedRaycastHit> Hits;
			};
			TArray<FRecordedRaycastAll> RecordedRaycasts = {
				{ { 83.193, 58.82, 11.548 }, { 0.044, -0.904, -0.426 }, 0.0f, EMRUKComponentType::All, {
																										   { FMRUKLabels::WallFace, { 90.736, -95.398, -61.109 }, { -0.151, 0.989, 0 }, 170.643 },
																										   { FMRUKLabels::Table, { 89.705, -74.333, -51.185 }, { 0, 0, 1 }, 147.335 },
																										   { FMRUKLabels::Table, { 89.705, -74.333, -51.185 }, { 0, 0, 1 }, 147.335 },
																										   { FMRUKLabels::Screen, { 84.702, 27.972, -2.986 }, { 0, -0, 1 }, 34.133 },
																										   { FMRUKLabels::Screen, { 86.2, -2.658, -17.416 }, { -0.995, 0.1, 0 }, 68.026 },
																									   } },
				{ { 83.193, 58.82, 11.548 }, { 0.044, -0.904, -0.426 }, 0.0f, EMRUKComponentType::Plane, {
																											 { FMRUKLabels::WallFace, { 90.736, -95.398, -61.109 }, { -0.151, 0.989, 0 }, 170.643 },
																											 { FMRUKLabels::Table, { 89.705, -74.333, -51.185 }, { 0, 0, 1 }, 147.335 },
																										 } },
				{ { 83.193, 58.82, 11.548 }, { 0.044, -0.904, -0.426 }, 0.0f, EMRUKComponentType::Volume, {
																											  { FMRUKLabels::Table, { 89.705, -74.333, -51.185 }, { 0, 0, 1 }, 147.335 },
																											  { FMRUKLabels::Screen, { 84.702, 27.972, -2.986 }, { 0, -0, 1 }, 34.133 },
																											  { FMRUKLabels::Screen, { 86.2, -2.658, -17.416 }, { -0.995, 0.1, 0 }, 68.026 },
																										  } }

			};
			for (const auto& Recorded : RecordedRaycasts)
			{
				TArray<FMRUKHit> Hits;
				TArray<AMRUKAnchor*> Anchors;
				Room->RaycastAll(Recorded.Position, Recorded.Direction, Recorded.MaxDist, { .ComponentTypes = static_cast<int32>(Recorded.ComponentTypes) }, Hits, Anchors);
				// This is a fairly generous tolerance, but necessary because ray pos and direction were only recorded
				// up to 3 decimal places and small changes in direction can result in fairly large differences in hit position
				// over long distances.
				constexpr float Tolerance = 0.2;
				if (!TestEqual("Number of hits", Hits.Num(), Recorded.Hits.Num()))
				{
					continue;
				}
				if (!TestEqual("Number of anchors", Anchors.Num(), Recorded.Hits.Num()))
				{
					continue;
				}
				for (int i = 0; i < Recorded.Hits.Num(); ++i)
				{
					TestEqual(TEXT("Hit position"), Hits[i].HitPosition, Recorded.Hits[i].HitPosition, Tolerance);
					TestEqual(TEXT("Hit normal"), Hits[i].HitNormal, Recorded.Hits[i].HitNormal, Tolerance);
					TestEqual(TEXT("Hit distance"), Hits[i].HitDistance, Recorded.Hits[i].HitDistance, Tolerance);
					if (TestTrue(TEXT("Has semantic classification"), Anchors[i]->SemanticClassifications.Num() > 0))
					{
						TestEqual(TEXT("Hit label"), Anchors[i]->SemanticClassifications[0], Recorded.Hits[i].Label);
					}
				}
			}
		});

		It(TEXT("Parent/child relationship"), [this]() {
			auto Room = ToolkitSubsystem->GetCurrentRoom();
			if (!TestNotNull(TEXT("Current room"), Room))
			{
				return;
			}
			// Verify that child/parent relationship is consistent
			for (const auto& Anchor : Room->AllAnchors)
			{
				for (const auto& ChildAnchor : Anchor->ChildAnchors)
				{
					TestEqual(TEXT("Parent Anchor"), ChildAnchor->ParentAnchor, Anchor);
				}
				if (Anchor->ParentAnchor)
				{
					TestTrue(TEXT("Parent contains anchor in child list"), Anchor->ParentAnchor->ChildAnchors.Contains(Anchor));
				}
			}
			TestEqual(TEXT("Floor has the right number of children"), Room->FloorAnchor->ChildAnchors.Num(), 6);
			for (const auto& Anchor : Room->AllAnchors)
			{
				if (Anchor->SemanticClassifications.IsEmpty())
				{
					continue;
				}
				if (Anchor->SemanticClassifications[0] == FMRUKLabels::Screen)
				{
					if (TestNotNull(TEXT("Screen has parent"), Anchor->ParentAnchor.Get()))
					{
						if (TestTrue(TEXT("Screen parent has label"), !Anchor->ParentAnchor->SemanticClassifications.IsEmpty()))
						{
							TestEqual(TEXT("Screen is on table"), Anchor->ParentAnchor->SemanticClassifications[0], FMRUKLabels::Table);
						}
					}
				}
				if (Anchor->SemanticClassifications[0] == FMRUKLabels::Table)
				{
					TestEqual(TEXT("Table is on the floor"), Anchor->ParentAnchor, Room->FloorAnchor);
				}
				if (Anchor->SemanticClassifications[0] == FMRUKLabels::Storage)
				{
					TestEqual(TEXT("Storage is on the floor"), Anchor->ParentAnchor, Room->FloorAnchor);
				}
				if (Anchor->SemanticClassifications[0] == FMRUKLabels::Couch)
				{
					TestEqual(TEXT("Couch is on the floor"), Anchor->ParentAnchor, Room->FloorAnchor);
				}
				if (Anchor->SemanticClassifications[0] == FMRUKLabels::DoorFrame)
				{
					TestTrue(TEXT("Door frame is on wall"), Room->WallAnchors.Contains(Anchor->ParentAnchor));
				}
				if (Anchor->SemanticClassifications[0] == FMRUKLabels::WindowFrame)
				{
					TestTrue(TEXT("Window frame is on wall"), Room->WallAnchors.Contains(Anchor->ParentAnchor));
				}
				if (Anchor->SemanticClassifications[0] == FMRUKLabels::WallArt)
				{
					TestTrue(TEXT("Wall art is on wall"), Room->WallAnchors.Contains(Anchor->ParentAnchor));
				}
			}
		});

		TeardownMRUKSubsystem();
	});

	Describe(TEXT("Toolkit"), [this] {
		SetupMRUKSubsystem();
		LoadSceneFromJson();

		It(TEXT("IsPositionInSceneVolume"), [this]() {
			struct TestData
			{
				FVector WorldPosition;
				bool TestVerticalBounds;
				double Tolerance;
				TOptional<FOculusXRUUID> ExpectedUUID;
			};

			TArray<TestData> AllTestData = {
				{ { 79.121, -20.291, -70.864 },
					true,
					0.0,
					{ { { 0x1E, 0x57, 0x8C, 0x3E, 0x9E, 0x7B, 0x49, 0x5E, 0x9F, 0x8B, 0xB0, 0x0A, 0x37, 0x22, 0xB6, 0x19 } } } },
				{ { 39.355, 0.683, -51.092 },
					true,
					1.0,
					{ { { 0x1E, 0x57, 0x8C, 0x3E, 0x9E, 0x7B, 0x49, 0x5E, 0x9F, 0x8B, 0xB0, 0x0A, 0x37, 0x22, 0xB6, 0x19 } } } },
				{ { 66.716, 4.072, -15.717 },
					false,
					0.0,
					{ { { 0x1E, 0x57, 0x8C, 0x3E, 0x9E, 0x7B, 0x49, 0x5E, 0x9F, 0x8B, 0xB0, 0x0A, 0x37, 0x22, 0xB6, 0x19 } } } },
				{ { 16.802, 23.632, -5.421 },
					false,
					0.0,
					{} },
			};

			for (const auto& TestData : AllTestData)
			{
				const auto ActualActor = ToolkitSubsystem->IsPositionInSceneVolume(TestData.WorldPosition, TestData.TestVerticalBounds, TestData.Tolerance);
				if (TestData.ExpectedUUID.IsSet())
				{
					TestNotNull(TEXT("Actual actor set"), ActualActor);
					TestEqual(TEXT("Actual actor UUID"), ActualActor->AnchorUUID, TestData.ExpectedUUID.GetValue());
				}
				else
				{
					TestNull(TEXT("Actual actor not set"), ActualActor);
				}
			}
		});

		TeardownMRUKSubsystem();
	});

	Describe(TEXT("Anchor"), [this] {
		SetupMRUKSubsystem();
		LoadSceneFromJson();

		It(TEXT("HasLabel"), [this]() {
			const auto Room = ToolkitSubsystem->GetCurrentRoom();
			if (!TestNotNull(TEXT("Current room"), Room))
			{
				return;
			}

			if (!TestTrue(TEXT("Wall anchors available"), Room->WallAnchors.Num() > 0))
			{
				return;
			}
			for (const auto& WallAnchor : Room->WallAnchors)
			{
				TestTrue(TEXT("Has WALL_FACE label"), WallAnchor->HasLabel(FMRUKLabels::WallFace));
				TestFalse(TEXT("Has not FLOOR label"), WallAnchor->HasLabel(FMRUKLabels::Floor));
				TestFalse(TEXT("Has not CEILING label"), WallAnchor->HasLabel(FMRUKLabels::Ceiling));
			}

			if (!TestNotNull(TEXT("Floor anchor"), Room->FloorAnchor.Get()))
			{
				return;
			}
			TestTrue(TEXT("Has FLOOR label"), Room->FloorAnchor->HasLabel(FMRUKLabels::Floor));
			TestFalse(TEXT("Has not WALL_FACE label"), Room->FloorAnchor->HasLabel(FMRUKLabels::WallFace));
			TestFalse(TEXT("Has not CEILING label"), Room->FloorAnchor->HasLabel(FMRUKLabels::Ceiling));

			if (!TestNotNull(TEXT("Ceiling anchor"), Room->CeilingAnchor.Get()))
			{
				return;
			}
			TestTrue(TEXT("Has CEILING label"), Room->CeilingAnchor->HasLabel(FMRUKLabels::Ceiling));
			TestFalse(TEXT("Has not FLOOR label"), Room->CeilingAnchor->HasLabel(FMRUKLabels::Floor));
			TestFalse(TEXT("Has not WALL_FACE label"), Room->CeilingAnchor->HasLabel(FMRUKLabels::WallFace));
		});

		It(TEXT("ProceduralMesh"), [this]() {
			const auto Room = ToolkitSubsystem->GetCurrentRoom();
			if (!TestNotNull(TEXT("Current room"), Room))
			{
				return;
			}

			if (!TestNotNull(TEXT("Floor anchor"), Room->FloorAnchor.Get()))
			{
				return;
			}
			Room->FloorAnchor->AttachProceduralMesh();
			auto ProceduralMeshComponent = Room->FloorAnchor->ProceduralMeshComponent;
			if (!TestNotNull(TEXT("Has Procedural Mesh Component"), ProceduralMeshComponent.Get()))
			{
				return;
			}
			auto Section = ProceduralMeshComponent->GetProcMeshSection(0);
			if (!TestNotNull(TEXT("Mesh Section"), Section))
			{
				return;
			}
			TestEqual(TEXT("Floor vertices equal to number of walls"), Section->ProcVertexBuffer.Num(), Room->WallAnchors.Num());
			TestEqual(TEXT("Floor triangles equal to number of walls - 2"), Section->ProcIndexBuffer.Num(), 3 * (Room->WallAnchors.Num() - 2));

			// NOTE: There are a number of valid ways to triangulate the mesh, and it doesn't need to be exactly like this but
			// this will at least highlight if we unexpectedly caused the mesh generation to change its output.
			TArray<int32> ExpectedIndexBuffer = { 6, 7, 0, 0, 1, 2, 4, 5, 6, 0, 2, 3, 4, 6, 0, 0, 3, 4 };
			if (TestEqual(TEXT("Triangle index buffer size"), Section->ProcIndexBuffer.Num(), ExpectedIndexBuffer.Num()))
			{
				for (int i = 0; i < ExpectedIndexBuffer.Num(); i++)
				{
					TestEqual(TEXT("Floor triangle index buffer"), Section->ProcIndexBuffer[i], ExpectedIndexBuffer[i]);
				}
			}

			TArray<FMRUKTexCoordModes> WallTextureCoordinateModes{
				{ EMRUKCoordModeU::Stretch, EMRUKCoordModeV::MaintainAspectRatio },
				{ EMRUKCoordModeU::MetricSeamless, EMRUKCoordModeV::MaintainAspectRatio },
				{ EMRUKCoordModeU::MaintainAspectRatio, EMRUKCoordModeV::Stretch },
				{ EMRUKCoordModeU::MaintainAspectRatioSeamless, EMRUKCoordModeV::Metric },
			};
			Room->AttachProceduralMeshToWalls(WallTextureCoordinateModes, {});

			if (TestTrue(TEXT("Has walls"), !Room->WallAnchors.IsEmpty()))
			{
				ProceduralMeshComponent = Room->WallAnchors[0]->ProceduralMeshComponent;
				if (!TestNotNull(TEXT("Has Procedural Mesh Component"), ProceduralMeshComponent.Get()))
				{
					return;
				}
				Section = ProceduralMeshComponent->GetProcMeshSection(0);
				if (!TestNotNull(TEXT("Mesh Section"), Section))
				{
					return;
				}
				if (TestEqual(TEXT("Vertex buffer size"), Section->ProcVertexBuffer.Num(), 4))
				{
					TestEqual(TEXT("Vertex 0 UV 0"), Section->ProcVertexBuffer[0].UV0, FVector2D(0.770758, 0.184412));
					TestEqual(TEXT("Vertex 0 UV 1"), Section->ProcVertexBuffer[0].UV1, FVector2D(10.790611, 2.581766));
					TestEqual(TEXT("Vertex 0 UV 2"), Section->ProcVertexBuffer[0].UV2, FVector2D(4.179547, 1.000000));
					TestEqual(TEXT("Vertex 0 UV 3"), Section->ProcVertexBuffer[0].UV3, FVector2D(10.790611, 2.630046));
					TestEqual(TEXT("Vertex 1 UV 0"), Section->ProcVertexBuffer[1].UV0, FVector2D(1.000000, 0.184412));
					TestEqual(TEXT("Vertex 1 UV 1"), Section->ProcVertexBuffer[1].UV1, FVector2D(14.000000, 2.581766));
					TestEqual(TEXT("Vertex 1 UV 2"), Section->ProcVertexBuffer[1].UV2, FVector2D(5.422645, 1.000000));
					TestEqual(TEXT("Vertex 1 UV 3"), Section->ProcVertexBuffer[1].UV3, FVector2D(14.000000, 2.630046));
					TestEqual(TEXT("Vertex 2 UV 0"), Section->ProcVertexBuffer[2].UV0, FVector2D(1.000000, -0.000000));
					TestEqual(TEXT("Vertex 2 UV 1"), Section->ProcVertexBuffer[2].UV1, FVector2D(14.000000, -0.000000));
					TestEqual(TEXT("Vertex 2 UV 2"), Section->ProcVertexBuffer[2].UV2, FVector2D(5.422645, -0.000000));
					TestEqual(TEXT("Vertex 2 UV 3"), Section->ProcVertexBuffer[2].UV3, FVector2D(14.000000, -0.000000));
					TestEqual(TEXT("Vertex 3 UV 0"), Section->ProcVertexBuffer[3].UV0, FVector2D(0.770758, -0.000000));
					TestEqual(TEXT("Vertex 3 UV 1"), Section->ProcVertexBuffer[3].UV1, FVector2D(10.790611, -0.000000));
					TestEqual(TEXT("Vertex 3 UV 2"), Section->ProcVertexBuffer[3].UV2, FVector2D(4.179547, -0.000000));
					TestEqual(TEXT("Vertex 3 UV 3"), Section->ProcVertexBuffer[3].UV3, FVector2D(10.790611, -0.000000));
				}
			}
		});

		It(TEXT("ProceduralMesh with holes"), [this]() {
			const auto Room = ToolkitSubsystem->GetCurrentRoom();
			if (!TestNotNull(TEXT("Current room"), Room))
			{
				return;
			}

			Room->AttachProceduralMeshToWalls({}, { FMRUKLabels::WindowFrame, FMRUKLabels::DoorFrame });

			if (TestTrue(TEXT("Has walls"), !Room->WallAnchors.IsEmpty()))
			{
				const auto ProceduralMeshComponent = Room->WallAnchors[6]->ProceduralMeshComponent;
				if (!TestNotNull(TEXT("Has Procedural Mesh Component"), ProceduralMeshComponent.Get()))
				{
					return;
				}
				const auto Section = ProceduralMeshComponent->GetProcMeshSection(0);
				if (!TestNotNull(TEXT("Mesh Section"), Section))
				{
					return;
				}
				if (TestEqual(TEXT("Vertex buffer size"), Section->ProcVertexBuffer.Num(), 8))
				{
					constexpr double Tolerance = 0.001;
					TestEqual(TEXT("Vertex 0"), Section->ProcVertexBuffer[0].Position, FVector(0.0, -168.041, -131.505), Tolerance);
					TestEqual(TEXT("Vertex 1"), Section->ProcVertexBuffer[1].Position, FVector(0.0, 168.041, -131.505), Tolerance);
					TestEqual(TEXT("Vertex 2"), Section->ProcVertexBuffer[2].Position, FVector(0.0, 168.041, 131.505), Tolerance);
					TestEqual(TEXT("Vertex 3"), Section->ProcVertexBuffer[3].Position, FVector(0.0, -168.041, 131.505), Tolerance);
					TestEqual(TEXT("Vertex 4"), Section->ProcVertexBuffer[4].Position, FVector(0.0, 28.075, -61.585), Tolerance);
					TestEqual(TEXT("Vertex 5"), Section->ProcVertexBuffer[5].Position, FVector(0.0, 143.493, -61.585), Tolerance);
					TestEqual(TEXT("Vertex 6"), Section->ProcVertexBuffer[6].Position, FVector(0.0, 143.493, 111.358), Tolerance);
					TestEqual(TEXT("Vertex 7"), Section->ProcVertexBuffer[7].Position, FVector(0.0, 28.075, 111.358), Tolerance);
				}

				if (TestEqual(TEXT("Index buffer size"), Section->ProcIndexBuffer.Num(), 24))
				{
					TestEqual(TEXT("Index 0"), Section->ProcIndexBuffer[0], 3);
					TestEqual(TEXT("Index 1"), Section->ProcIndexBuffer[1], 0);
					TestEqual(TEXT("Index 2"), Section->ProcIndexBuffer[2], 4);
					TestEqual(TEXT("Index 3"), Section->ProcIndexBuffer[3], 5);
					TestEqual(TEXT("Index 4"), Section->ProcIndexBuffer[4], 4);
					TestEqual(TEXT("Index 5"), Section->ProcIndexBuffer[5], 0);
					TestEqual(TEXT("Index 6"), Section->ProcIndexBuffer[6], 3);
					TestEqual(TEXT("Index 7"), Section->ProcIndexBuffer[7], 4);
					TestEqual(TEXT("Index 8"), Section->ProcIndexBuffer[8], 7);
					TestEqual(TEXT("Index 9"), Section->ProcIndexBuffer[9], 5);
					TestEqual(TEXT("Index 10"), Section->ProcIndexBuffer[10], 0);
					TestEqual(TEXT("Index 11"), Section->ProcIndexBuffer[11], 1);
					TestEqual(TEXT("Index 12"), Section->ProcIndexBuffer[12], 2);
					TestEqual(TEXT("Index 13"), Section->ProcIndexBuffer[13], 3);
					TestEqual(TEXT("Index 14"), Section->ProcIndexBuffer[14], 7);
					TestEqual(TEXT("Index 15"), Section->ProcIndexBuffer[15], 6);
					TestEqual(TEXT("Index 16"), Section->ProcIndexBuffer[16], 5);
					TestEqual(TEXT("Index 17"), Section->ProcIndexBuffer[17], 1);
					TestEqual(TEXT("Index 18"), Section->ProcIndexBuffer[18], 2);
					TestEqual(TEXT("Index 19"), Section->ProcIndexBuffer[19], 7);
					TestEqual(TEXT("Index 20"), Section->ProcIndexBuffer[20], 6);
					TestEqual(TEXT("Index 21"), Section->ProcIndexBuffer[21], 6);
					TestEqual(TEXT("Index 22"), Section->ProcIndexBuffer[22], 1);
					TestEqual(TEXT("Index 23"), Section->ProcIndexBuffer[23], 2);
				}
			}
		});

		TeardownMRUKSubsystem();
	});

	Describe(TEXT("Utilities"), [this] {
		It(TEXT("Label Filter"), [this]() {
			FMRUKLabelFilter Filter;
			Filter.IncludedLabels.Push("FOO");
			Filter.IncludedLabels.Push("BAR");
			Filter.ExcludedLabels.Push("BAZ");
			Filter.ExcludedLabels.Push("QUX");
			TestTrue(TEXT("BAM, BAR Passes Filter"), Filter.PassesFilter({ { TEXT("BAM"), TEXT("BAR") } }));
			TestFalse(TEXT("BAZ Fails Filter"), Filter.PassesFilter({ { TEXT("BAZ") } }));
			TestFalse(TEXT("BAR, QUX Fails Filter"), Filter.PassesFilter({ { TEXT("BAR"), TEXT("QUX") } }));
			TestFalse(TEXT("BAM Fails Filter"), Filter.PassesFilter({ { TEXT("BAM") } }));

			Filter.IncludedLabels.Empty();
			TestTrue(TEXT("BAM Passes Filter"), Filter.PassesFilter({ { TEXT("BAM") } }));
		});
	});
}