• An Unreal Engine project running on 4.22

• It is an example of how to implement the inversion of control (IOC) pattern using Unreal Engine's TTypeContainer

You might want to skip to the "How does it work" section as it's more of an overview, rather than an in detail look at everything.

• The UIOC is declared in a Common.h file that is included in all files that need access to the IOC container.
• The UIOC exposes a static TTypeContainer that is Unreal Engine's helper class for registering interfaces (IPlayerService) to implementations (PlayerService, MockPlayerService).
• The UIOC Container is populated within the UMainGameInstance constructor:

UIOC::Container.RegisterClass<IPlayerService, PlayerService>();

• Because the UIOC is globally accessible and has a static Container property, we access this from within our APlayerPawn
• Inside APlayerPawn 's constructor, this is run:

// Fetch PlayerService from IOC container
PlayerService = UIOC::Container.GetInstance<IPlayerService>();

• Then inside the actual APlayerPawn method TriggerVolumeHitOccured, we can call the PlayerService property which will use the implementation which we registered in the UMainGameInstance constructor and resolved in the pawn's constructor.

// Get the power modifier for player
int powerModifier = PlayerService->GetPowerModifier(this);

// For example purposes, does a simple bit of logic to demonstrate test
// Note: Should be in service, but for brevity:
if (powerModifier >= EnemyPawn->Power)
{
	// Issue damage to enemy
	EnemyPawn->TakeHit();
}

• The test is quite simple and is declared inside the PlayerPawnTests.cpp:

IMPLEMENT_SIMPLE_AUTOMATION_TEST(PlayerPawnTests, "Pawns.PlayerPawnTests", EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)

• It instantiates a little wrapper class PlayerPawnTestsAgent where in the constructor we do something really interesting! If you were to debug this method, you will notice that even though the Container was registered to inside the UMainGameInstance, it is now empty. This is because our Game code is not running the constructor of the UMainGameInstance. Phew, well that's helpful, because now we can register our test specific versions of the IPlayerService:

// Create an instance of the mock player service
TSharedRef<IPlayerService> SharedMockPlayerService = MakeShareable(new MockPlayerService());

// Register the instance to our container
UIOC::Container.RegisterInstance<IPlayerService>(SharedMockPlayerService);

• Then we go ahead and run our tests, and if you debug while doing so, you'll notice that the instance inside the APlayerPawn is our MockPlayerService instead of the PlayerService.

• IOC (Inversion of control) is helpful for testing
• It removes the dependency of an implementation, and instead concerns itself only with the interface which exposes all the operations, without any of the annoying implementation details.
• The above is important because now we can put together specific data to test against. It's easy to know that (See test example) 1 - 1 is 0. But not so easy to know that (for example) x - 1 = 0. Note the enforced value being returned from the method:

// Inherited via IPlayerService
virtual int GetPowerModifier(APlayerPawn * PlayerPawn) override
{
	return 1;
}

• Unreal Engine actually has documentation of this (mentioned in the TTypeContainer write up) under a cpp file. It can be found here.

author: jimmyt1988 23/05/2019