ue-mcp 1.2.4 → 1.3.0

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/Tests/LevelInstanceProjectionTests.cpp

@@ -0,0 +1,265 @@
+// Native coverage for snap_instances_to_surface. All mutation coverage uses a
+// transient test world and transient actors, never project packages or maps.
+
+#if WITH_DEV_AUTOMATION_TESTS
+
+#include "HandlerRegistry.h"
+#include "Handlers/LevelHandlers.h"
+#include "Handlers/LevelHandlers_InstanceProjection_Internal.h"
+#include "Components/BoxComponent.h"
+#include "Components/InstancedStaticMeshComponent.h"
+#include "Engine/Engine.h"
+#include "Engine/EngineBaseTypes.h"
+#include "Engine/World.h"
+#include "EngineUtils.h"
+#include "GameFramework/Actor.h"
+#include "Misc/AutomationTest.h"
+
+namespace
+{
+	class FScopedProjectionTestWorld
+	{
+	public:
+		FScopedProjectionTestWorld()
+		{
+			check(GEngine);
+			const FName WorldName = MakeUniqueObjectName(
+				nullptr,
+				UWorld::StaticClass(),
+				TEXT("UEMCPInstanceProjectionTestWorld"),
+				EUniqueObjectNameOptions::GloballyUnique);
+			FWorldContext& Context = GEngine->CreateNewWorldContext(EWorldType::Game);
+			World = UWorld::CreateWorld(EWorldType::Game, false, WorldName, GetTransientPackage());
+			check(World);
+			World->AddToRoot();
+			Context.SetCurrentWorld(World);
+			World->InitializeActorsForPlay(FURL());
+			check(World->GetPhysicsScene());
+		}
+
+		~FScopedProjectionTestWorld()
+		{
+			if (!World) return;
+			if (World->AreActorsInitialized())
+			{
+				for (AActor* Actor : FActorRange(World))
+				{
+					if (Actor) Actor->RouteEndPlay(EEndPlayReason::LevelTransition);
+				}
+			}
+			GEngine->ShutdownWorldNetDriver(World);
+			World->DestroyWorld(true);
+			World->SetPhysicsScene(nullptr);
+			GEngine->DestroyWorldContext(World);
+			World->RemoveFromRoot();
+			World = nullptr;
+		}
+
+		UWorld* Get() const { return World; }
+
+	private:
+		UWorld* World = nullptr;
+	};
+
+	AActor* SpawnInstanceProjectionTestActor(UWorld* World, const FString& Label)
+	{
+		FActorSpawnParameters SpawnParameters;
+		SpawnParameters.Name = MakeUniqueObjectName(
+			World->PersistentLevel,
+			AActor::StaticClass(),
+			FName(*Label));
+		SpawnParameters.ObjectFlags |= RF_Transient;
+		AActor* Actor = World->SpawnActor<AActor>(
+			AActor::StaticClass(),
+			FTransform::Identity,
+			SpawnParameters);
+		if (Actor) Actor->SetActorLabel(Label, false);
+		return Actor;
+	}
+
+	UInstancedStaticMeshComponent* AddInstanceComponent(
+		AActor* Actor,
+		const TArray<FTransform>& WorldTransforms)
+	{
+		UInstancedStaticMeshComponent* Instances = NewObject<UInstancedStaticMeshComponent>(
+			Actor,
+			TEXT("ProjectedInstances"),
+			RF_Transient | RF_Transactional);
+		Actor->SetRootComponent(Instances);
+		Actor->AddInstanceComponent(Instances);
+		Instances->SetMobility(EComponentMobility::Movable);
+		Instances->SetCollisionEnabled(ECollisionEnabled::NoCollision);
+		Instances->RegisterComponent();
+		for (const FTransform& Transform : WorldTransforms)
+		{
+			Instances->AddInstance(Transform, true);
+		}
+		return Instances;
+	}
+
+	UBoxComponent* AddSurfaceBox(AActor* Actor, const FVector& Extent)
+	{
+		UBoxComponent* Box = NewObject<UBoxComponent>(
+			Actor,
+			TEXT("ProjectionSurface"),
+			RF_Transient);
+		Actor->SetRootComponent(Box);
+		Actor->AddInstanceComponent(Box);
+		Box->SetBoxExtent(Extent, false);
+		Box->SetCollisionEnabled(ECollisionEnabled::QueryOnly);
+		Box->SetCollisionObjectType(ECC_WorldStatic);
+		Box->SetCollisionResponseToAllChannels(ECR_Ignore);
+		Box->SetCollisionResponseToChannel(ECC_Visibility, ECR_Block);
+		Box->RegisterComponent();
+		return Box;
+	}
+
+	TSharedPtr<FJsonObject> MakeProjectionRequest(
+		const FString& ActorLabel,
+		const FString& SurfaceLabel)
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetStringField(TEXT("actorLabel"), ActorLabel);
+		Request->SetStringField(TEXT("componentName"), TEXT("ProjectedInstances"));
+		Request->SetArrayField(
+			TEXT("surfaceActorLabels"),
+			{ MakeShared<FJsonValueString>(SurfaceLabel) });
+		Request->SetNumberField(TEXT("surfaceOffset"), 10.0);
+		return Request;
+	}
+
+	bool ReadWorldTransform(
+		UInstancedStaticMeshComponent* Instances,
+		int32 Index,
+		FTransform& OutTransform)
+	{
+		return Instances && Instances->GetInstanceTransform(Index, OutTransform, true);
+	}
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FLevelInstanceProjectionRegistrationTest,
+	"UE.MCP.Level.InstanceProjection.RegistrationAndPureValidation",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FLevelInstanceProjectionRegistrationTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FLevelHandlers::RegisterHandlers(Registry);
+	TestTrue(
+		TEXT("native projection handler is registered"),
+		Registry.HasHandler(TEXT("snap_instances_to_surface")));
+	TestTrue(
+		TEXT("bounded batch handler has an explicit timeout"),
+		Registry.GetHandlerTimeout(TEXT("snap_instances_to_surface")) >= 300.0f);
+
+	using namespace UEMCPInstanceProjection;
+	EMissPolicy Policy = EMissPolicy::Error;
+	TestTrue(TEXT("miss policy is case insensitive"), ParseMissPolicy(TEXT(" SKIP "), Policy));
+	TestTrue(TEXT("skip policy is selected"), Policy == EMissPolicy::Skip);
+	TestFalse(TEXT("unknown miss policy is rejected"), ParseMissPolicy(TEXT("continue"), Policy));
+	TestTrue(
+		TEXT("surface offset follows the normalized impact normal"),
+		ApplySurfaceOffset(FVector(1.0, 2.0, 3.0), FVector(0.0, 0.0, 4.0), 7.0)
+			.Equals(FVector(1.0, 2.0, 10.0)));
+	return true;
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FLevelInstanceProjectionDryRunAndCommitTest,
+	"UE.MCP.Level.InstanceProjection.DryRunBoundsAndAtomicCommit",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FLevelInstanceProjectionDryRunAndCommitTest::RunTest(const FString& Parameters)
+{
+	FScopedProjectionTestWorld TestWorld;
+	const FString TargetLabel = TEXT("UEMCP_ProjectionTarget");
+	const FString SurfaceLabel = TEXT("UEMCP_ProjectionSurface");
+	const FString BlockerLabel = TEXT("UEMCP_ProjectionBlocker");
+	AActor* Target = SpawnInstanceProjectionTestActor(TestWorld.Get(), TargetLabel);
+	AActor* Surface = SpawnInstanceProjectionTestActor(TestWorld.Get(), SurfaceLabel);
+	AActor* Blocker = SpawnInstanceProjectionTestActor(TestWorld.Get(), BlockerLabel);
+	TestNotNull(TEXT("target actor exists"), Target);
+	TestNotNull(TEXT("surface actor exists"), Surface);
+	TestNotNull(TEXT("non-matching blocker exists"), Blocker);
+	if (!Target || !Surface || !Blocker) return false;
+
+	const FQuat OriginalRotation = FRotator(0.0, 37.0, 0.0).Quaternion();
+	const FVector OriginalScale(1.2, 0.8, 1.5);
+	const TArray<FTransform> OriginalTransforms = {
+		FTransform(OriginalRotation, FVector(0.0, 0.0, 500.0), OriginalScale),
+		FTransform(FQuat::Identity, FVector(1000.0, 0.0, 500.0), FVector::OneVector),
+	};
+	UInstancedStaticMeshComponent* Instances = AddInstanceComponent(Target, OriginalTransforms);
+	UBoxComponent* SurfaceBox = AddSurfaceBox(Surface, FVector(150.0, 150.0, 100.0));
+	UBoxComponent* BlockerBox = AddSurfaceBox(Blocker, FVector(150.0, 150.0, 50.0));
+	TestNotNull(TEXT("instance component exists"), Instances);
+	TestNotNull(TEXT("surface collision exists"), SurfaceBox);
+	TestNotNull(TEXT("blocker collision exists"), BlockerBox);
+	if (!Instances || !SurfaceBox || !BlockerBox) return false;
+	BlockerBox->SetWorldLocation(FVector(0.0, 0.0, 250.0));
+
+	TSharedPtr<FJsonObject> DryRunRequest = MakeProjectionRequest(TargetLabel, SurfaceLabel);
+	DryRunRequest->SetArrayField(TEXT("instanceIndices"), { MakeShared<FJsonValueNumber>(0) });
+	const TSharedPtr<FJsonValue> DryRunResponse =
+		UEMCPInstanceProjection::SnapInstancesToSurfaceInWorld(TestWorld.Get(), DryRunRequest);
+	TestTrue(TEXT("dry run returns an object"), DryRunResponse.IsValid() && DryRunResponse->Type == EJson::Object);
+	if (!DryRunResponse.IsValid() || DryRunResponse->Type != EJson::Object) return false;
+	const TSharedPtr<FJsonObject> DryRunResult = DryRunResponse->AsObject();
+	TestTrue(TEXT("dry run succeeds"), DryRunResult->GetBoolField(TEXT("success")));
+	TestTrue(TEXT("dry run is the default"), DryRunResult->GetBoolField(TEXT("dryRun")));
+	TestTrue(TEXT("dry-run preflight passes"), DryRunResult->GetBoolField(TEXT("preflightPassed")));
+	TestFalse(TEXT("dry run performs no mutation"), DryRunResult->GetBoolField(TEXT("mutationPerformed")));
+	TestEqual(TEXT("dry run reaches the filtered surface behind a blocker"), DryRunResult->GetIntegerField(TEXT("hitCount")), 1);
+
+	FTransform AfterDryRun;
+	TestTrue(TEXT("instance remains readable after dry run"), ReadWorldTransform(Instances, 0, AfterDryRun));
+	TestTrue(TEXT("dry run preserves the original transform"), AfterDryRun.Equals(OriginalTransforms[0], 0.01));
+
+	TSharedPtr<FJsonObject> BoundedRequest = MakeProjectionRequest(TargetLabel, SurfaceLabel);
+	BoundedRequest->SetNumberField(TEXT("maxInstances"), 1);
+	const TSharedPtr<FJsonValue> BoundedResponse =
+		UEMCPInstanceProjection::SnapInstancesToSurfaceInWorld(TestWorld.Get(), BoundedRequest);
+	TestFalse(TEXT("oversized request is rejected"), BoundedResponse->AsObject()->GetBoolField(TEXT("success")));
+	TestTrue(
+		TEXT("oversized rejection reports the bound"),
+		BoundedResponse->AsObject()->GetStringField(TEXT("error")).Contains(TEXT("maxInstances")));
+
+	TSharedPtr<FJsonObject> AtomicRequest = MakeProjectionRequest(TargetLabel, SurfaceLabel);
+	AtomicRequest->SetBoolField(TEXT("dryRun"), false);
+	AtomicRequest->SetStringField(TEXT("onMiss"), TEXT("error"));
+	const TSharedPtr<FJsonValue> AtomicResponse =
+		UEMCPInstanceProjection::SnapInstancesToSurfaceInWorld(TestWorld.Get(), AtomicRequest);
+	const TSharedPtr<FJsonObject> AtomicResult = AtomicResponse->AsObject();
+	TestFalse(TEXT("a preflight miss rejects the commit"), AtomicResult->GetBoolField(TEXT("success")));
+	TestFalse(TEXT("failed preflight reports no mutation"), AtomicResult->GetBoolField(TEXT("mutationPerformed")));
+	TestEqual(TEXT("one instance misses"), AtomicResult->GetIntegerField(TEXT("missCount")), 1);
+
+	FTransform AfterAtomicFailure;
+	TestTrue(TEXT("instance remains readable after rejected commit"), ReadWorldTransform(Instances, 0, AfterAtomicFailure));
+	TestTrue(
+		TEXT("onMiss=error leaves every instance unchanged"),
+		AfterAtomicFailure.Equals(OriginalTransforms[0], 0.01));
+
+	TSharedPtr<FJsonObject> CommitRequest = MakeProjectionRequest(TargetLabel, SurfaceLabel);
+	CommitRequest->SetBoolField(TEXT("dryRun"), false);
+	CommitRequest->SetStringField(TEXT("onMiss"), TEXT("skip"));
+	const TSharedPtr<FJsonValue> CommitResponse =
+		UEMCPInstanceProjection::SnapInstancesToSurfaceInWorld(TestWorld.Get(), CommitRequest);
+	const TSharedPtr<FJsonObject> CommitResult = CommitResponse->AsObject();
+	TestTrue(TEXT("skip commit succeeds"), CommitResult->GetBoolField(TEXT("success")));
+	TestTrue(TEXT("commit performs a mutation"), CommitResult->GetBoolField(TEXT("mutationPerformed")));
+	TestEqual(TEXT("commit updates one instance"), CommitResult->GetIntegerField(TEXT("updatedCount")), 1);
+
+	FTransform UpdatedHit;
+	FTransform UnchangedMiss;
+	TestTrue(TEXT("updated instance remains readable"), ReadWorldTransform(Instances, 0, UpdatedHit));
+	TestTrue(TEXT("skipped instance remains readable"), ReadWorldTransform(Instances, 1, UnchangedMiss));
+	TestTrue(TEXT("projected location uses the surface offset"), FMath::IsNearlyEqual(UpdatedHit.GetLocation().Z, 110.0, 0.1));
+	TestTrue(TEXT("projection preserves rotation"), UpdatedHit.GetRotation().Equals(OriginalRotation, 0.001));
+	TestTrue(TEXT("projection preserves scale"), UpdatedHit.GetScale3D().Equals(OriginalScale, 0.001));
+	TestTrue(TEXT("onMiss=skip leaves the miss unchanged"), UnchangedMiss.Equals(OriginalTransforms[1], 0.01));
+	return true;
+}
+
+#endif

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/Tests/LevelPostProcessOverrideTests.cpp

@@ -0,0 +1,258 @@
+// Coverage for post-process settings and their override flags (#950).
+//
+// The bug this guards is silent by construction: a value written into
+// FPostProcessSettings without its bOverride_<Name> bit reads back exactly as
+// requested and is ignored by the renderer. So the assertion that matters is
+// not "the value was written" but "the bit was turned on with it", and it is
+// checked by reading the struct back through the reader rather than by trusting
+// the writer's own report.
+//
+// The round trip runs against a transient verification actor, which cannot be
+// saved into the map and is destroyed at the end.
+
+#if WITH_DEV_AUTOMATION_TESTS
+
+#include "Engine/Scene.h"
+#include "HandlerRegistry.h"
+#include "Handlers/LevelHandlers.h"
+#include "Misc/AutomationTest.h"
+#include "UObject/UnrealType.h"
+
+namespace
+{
+	TSharedPtr<FJsonObject> MCPPostProcessTestRun(
+		FMCPHandlerRegistry& Registry,
+		const TCHAR* Method,
+		const TSharedPtr<FJsonObject>& Request)
+	{
+		const TSharedPtr<FJsonValue> Response = Registry.ExecuteHandler(Method, Request);
+		if (!Response.IsValid() || Response->Type != EJson::Object)
+		{
+			return nullptr;
+		}
+		return Response->AsObject();
+	}
+
+	/** The row for one setting in a get_post_process_settings response. */
+	TSharedPtr<FJsonObject> MCPPostProcessTestFindRow(
+		const TSharedPtr<FJsonObject>& Response,
+		const TCHAR* SettingName)
+	{
+		if (!Response.IsValid()) return nullptr;
+		const TArray<TSharedPtr<FJsonValue>>* Rows = nullptr;
+		if (!Response->TryGetArrayField(TEXT("settings"), Rows) || !Rows) return nullptr;
+		for (const TSharedPtr<FJsonValue>& Value : *Rows)
+		{
+			const TSharedPtr<FJsonObject> Row = Value.IsValid() ? Value->AsObject() : nullptr;
+			if (!Row.IsValid()) continue;
+			if (Row->GetStringField(TEXT("name")).Equals(SettingName, ESearchCase::IgnoreCase)) return Row;
+		}
+		return nullptr;
+	}
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FLevelPostProcessOverridePairingTest,
+	"UE.MCP.Level.PostProcess.EveryExposureValueHasAnOverrideBit",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FLevelPostProcessOverridePairingTest::RunTest(const FString& Parameters)
+{
+	// The whole feature rests on one naming convention: the bit that gates the
+	// value `Foo` is called `bOverride_Foo`. If the engine ever renames one of
+	// these, working generically off the reflected fields would silently stop
+	// enabling anything, so the convention is asserted rather than assumed.
+	UScriptStruct* Struct = FPostProcessSettings::StaticStruct();
+	TestNotNull(TEXT("FPostProcessSettings is reflected"), Struct);
+	if (!Struct) return true;
+
+	for (const TCHAR* ValueField : {
+		TEXT("AutoExposureMinBrightness"),
+		TEXT("AutoExposureMaxBrightness"),
+		TEXT("AutoExposureBias"),
+		TEXT("AutoExposureMethod"),
+		TEXT("BloomIntensity") })
+	{
+		FProperty* Value = Struct->FindPropertyByName(FName(ValueField));
+		TestNotNull(FString::Printf(TEXT("%s exists"), ValueField), Value);
+
+		const FString FlagName = FString(TEXT("bOverride_")) + ValueField;
+		FBoolProperty* Flag = CastField<FBoolProperty>(Struct->FindPropertyByName(FName(*FlagName)));
+		TestNotNull(FString::Printf(TEXT("%s exists and is a bool"), *FlagName), Flag);
+	}
+
+	return true;
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FLevelPostProcessSettingsRoundTripTest,
+	"UE.MCP.Level.PostProcess.SettingWritesTheOverrideBitToo",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FLevelPostProcessSettingsRoundTripTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FLevelHandlers::RegisterHandlers(Registry);
+
+	for (const TCHAR* Method : {
+		TEXT("set_post_process_settings"),
+		TEXT("get_post_process_settings"),
+		TEXT("set_fixed_exposure") })
+	{
+		TestTrue(FString::Printf(TEXT("%s is registered"), Method), Registry.HasHandler(Method));
+	}
+
+	// A settings map is required: an empty write is a request that means
+	// nothing, and answering it with success would be a lie.
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetStringField(TEXT("actorLabel"), TEXT("UEMCP_NoSuchPostProcessVolume"));
+		const TSharedPtr<FJsonObject> Response =
+			MCPPostProcessTestRun(Registry, TEXT("set_post_process_settings"), Request);
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("a write with no settings fails"), Response->GetBoolField(TEXT("success")));
+		}
+	}
+
+	// The round trip needs a subject. A transient verification actor is one
+	// that cannot end up committed to source control.
+	TSharedPtr<FJsonObject> SpawnRequest = MakeShared<FJsonObject>();
+	SpawnRequest->SetStringField(TEXT("actorClass"), TEXT("PostProcessVolume"));
+	SpawnRequest->SetStringField(TEXT("label"), TEXT("UEMCP_PostProcessOverrideTest"));
+	const TSharedPtr<FJsonObject> SpawnResponse =
+		MCPPostProcessTestRun(Registry, TEXT("spawn_transient_actor"), SpawnRequest);
+	if (!SpawnResponse.IsValid() || !SpawnResponse->GetBoolField(TEXT("success")))
+	{
+		// No editor world in this context, and this test may not open a map.
+		return true;
+	}
+	const TSharedPtr<FJsonObject> SpawnedActor = SpawnResponse->GetObjectField(TEXT("actor"));
+	const FString ActorPath = SpawnedActor.IsValid() ? SpawnedActor->GetStringField(TEXT("actorPath")) : FString();
+	const FString ActorLabel = TEXT("UEMCP_PostProcessOverrideTest");
+
+	// An unknown key fails the WHOLE call rather than writing the keys around
+	// it, so a typo cannot leave a volume half-configured.
+	{
+		TSharedPtr<FJsonObject> Settings = MakeShared<FJsonObject>();
+		Settings->SetNumberField(TEXT("AutoExposureMinBrightness"), 2.0);
+		Settings->SetNumberField(TEXT("NotARealPostProcessSetting"), 1.0);
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetStringField(TEXT("actorLabel"), ActorLabel);
+		Request->SetObjectField(TEXT("settings"), Settings);
+		const TSharedPtr<FJsonObject> Response =
+			MCPPostProcessTestRun(Registry, TEXT("set_post_process_settings"), Request);
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("an unknown setting name fails the call"), Response->GetBoolField(TEXT("success")));
+			TestTrue(TEXT("and says nothing was written"),
+				Response->GetStringField(TEXT("error")).Contains(TEXT("Nothing was written")));
+		}
+	}
+
+	// The assertion the issue is about: writing the value also turns the bit on.
+	{
+		TSharedPtr<FJsonObject> Settings = MakeShared<FJsonObject>();
+		Settings->SetNumberField(TEXT("AutoExposureMinBrightness"), 1.5);
+		Settings->SetNumberField(TEXT("AutoExposureMaxBrightness"), 1.5);
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetStringField(TEXT("actorLabel"), ActorLabel);
+		Request->SetObjectField(TEXT("settings"), Settings);
+		const TSharedPtr<FJsonObject> Response =
+			MCPPostProcessTestRun(Registry, TEXT("set_post_process_settings"), Request);
+		TestTrue(TEXT("the write succeeds"),
+			Response.IsValid() && Response->GetBoolField(TEXT("success")));
+	}
+
+	// Read it back through the reader rather than trusting the writer's report.
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetStringField(TEXT("actorLabel"), ActorLabel);
+		Request->SetBoolField(TEXT("onlyOverridden"), true);
+		const TSharedPtr<FJsonObject> Response =
+			MCPPostProcessTestRun(Registry, TEXT("get_post_process_settings"), Request);
+		TestTrue(TEXT("the read succeeds"),
+			Response.IsValid() && Response->GetBoolField(TEXT("success")));
+
+		const TSharedPtr<FJsonObject> MinRow =
+			MCPPostProcessTestFindRow(Response, TEXT("AutoExposureMinBrightness"));
+		TestNotNull(TEXT("min brightness is reported as overridden"), MinRow.Get());
+		if (MinRow.IsValid())
+		{
+			TestTrue(TEXT("and its override bit really is on"), MinRow->GetBoolField(TEXT("overridden")));
+		}
+
+		const TSharedPtr<FJsonObject> MaxRow =
+			MCPPostProcessTestFindRow(Response, TEXT("AutoExposureMaxBrightness"));
+		TestNotNull(TEXT("max brightness is reported as overridden"), MaxRow.Get());
+	}
+
+	// enableOverrides=false is the explicit opt out, and it must NOT turn the
+	// bit on, or the opt out would be a lie in the other direction.
+	{
+		TSharedPtr<FJsonObject> Settings = MakeShared<FJsonObject>();
+		Settings->SetNumberField(TEXT("BloomIntensity"), 0.25);
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetStringField(TEXT("actorLabel"), ActorLabel);
+		Request->SetObjectField(TEXT("settings"), Settings);
+		Request->SetBoolField(TEXT("enableOverrides"), false);
+		const TSharedPtr<FJsonObject> Response =
+			MCPPostProcessTestRun(Registry, TEXT("set_post_process_settings"), Request);
+		if (Response.IsValid() && Response->GetBoolField(TEXT("success")))
+		{
+			TSharedPtr<FJsonObject> ReadRequest = MakeShared<FJsonObject>();
+			ReadRequest->SetStringField(TEXT("actorLabel"), ActorLabel);
+			TArray<TSharedPtr<FJsonValue>> Names;
+			Names.Add(MakeShared<FJsonValueString>(TEXT("BloomIntensity")));
+			ReadRequest->SetArrayField(TEXT("names"), Names);
+			const TSharedPtr<FJsonObject> ReadResponse =
+				MCPPostProcessTestRun(Registry, TEXT("get_post_process_settings"), ReadRequest);
+			const TSharedPtr<FJsonObject> Row =
+				MCPPostProcessTestFindRow(ReadResponse, TEXT("BloomIntensity"));
+			if (Row.IsValid())
+			{
+				TestFalse(TEXT("enableOverrides=false leaves the bit off"), Row->GetBoolField(TEXT("overridden")));
+			}
+		}
+	}
+
+	// set_fixed_exposure is the same mechanism with the two writes chosen for
+	// you, so it has to leave both bits on as well.
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetStringField(TEXT("actorLabel"), ActorLabel);
+		Request->SetNumberField(TEXT("exposure"), 3.0);
+		const TSharedPtr<FJsonObject> Response =
+			MCPPostProcessTestRun(Registry, TEXT("set_fixed_exposure"), Request);
+		TestTrue(TEXT("set_fixed_exposure succeeds"),
+			Response.IsValid() && Response->GetBoolField(TEXT("success")));
+
+		TSharedPtr<FJsonObject> ReadRequest = MakeShared<FJsonObject>();
+		ReadRequest->SetStringField(TEXT("actorLabel"), ActorLabel);
+		ReadRequest->SetBoolField(TEXT("onlyOverridden"), true);
+		const TSharedPtr<FJsonObject> ReadResponse =
+			MCPPostProcessTestRun(Registry, TEXT("get_post_process_settings"), ReadRequest);
+		const TSharedPtr<FJsonObject> MinRow =
+			MCPPostProcessTestFindRow(ReadResponse, TEXT("AutoExposureMinBrightness"));
+		const TSharedPtr<FJsonObject> MaxRow =
+			MCPPostProcessTestFindRow(ReadResponse, TEXT("AutoExposureMaxBrightness"));
+		TestNotNull(TEXT("fixed exposure overrode min brightness"), MinRow.Get());
+		TestNotNull(TEXT("fixed exposure overrode max brightness"), MaxRow.Get());
+	}
+
+	// Clean up the subject, since a test about not leaving state behind that
+	// left an actor behind would be absurd.
+	if (!ActorPath.IsEmpty())
+	{
+		TSharedPtr<FJsonObject> DestroyRequest = MakeShared<FJsonObject>();
+		DestroyRequest->SetStringField(TEXT("actorPath"), ActorPath);
+		const TSharedPtr<FJsonObject> DestroyResponse =
+			MCPPostProcessTestRun(Registry, TEXT("destroy_transient_actor"), DestroyRequest);
+		TestTrue(TEXT("the verification volume is destroyed"),
+			DestroyResponse.IsValid() && DestroyResponse->GetBoolField(TEXT("success")));
+	}
+
+	return true;
+}
+
+#endif // WITH_DEV_AUTOMATION_TESTS