ITestInterface::Execute_TestInterfaceFunction(Actor);

Cast<ITestInterface>(Actor)->TestInterfaceFunction();

class ITestInterface
{
	GENERATED_BODY()

public:

	UFUNCTION(BlueprintNativeEvent, Category = "Test Interface")
	void TestInterfaceFunction();
	
};

// TestInterface.h
#pragma once

#include "CoreMinimal.h"
#include "UObject/Interface.h"
#include "TestInterface.generated.h"

UINTERFACE(MinimalAPI, BlueprintType)
class UTestInterface : public UInterface
{
	GENERATED_BODY()
};

class ITestInterface
{
	GENERATED_BODY()

public:

	UFUNCTION(BlueprintNativeEvent, Category = "Test Interface")
	void TestInterfaceFunction();
	
};

// TestGameMode.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/GameModeBase.h"
#include "TestGameMode.generated.h"

UCLASS()
class ATestGameMode : public AGameModeBase
{
	GENERATED_BODY()
	
public:

	UFUNCTION(BlueprintCallable, Category = Test)
	void TestInterfaceOnActor(AActor* Actor);
	
};

// TestGameMode.cpp
#include "TestGameMode.h"
#include "TestInterface.h"


void ATestGameMode::TestInterfaceOnActor(AActor* Actor)
{
	// in this example:
	// interface function is called twice for C++ classes that extended the interface, once for blueprint

	if (ITestInterface* iface = Cast<ITestInterface>(Actor)) // iface is null if actor was a blueprint that extended the interface
	{
		iface->TestInterfaceFunction();
	}
	ITestInterface::Execute_TestInterfaceFunction(Actor); // works for both C++ and blueprint classes that extend the interface
}

UINTERFACE(MinimalAPI, BlueprintType)
class UTestInterface : public UInterface
{
	GENERATED_BODY()
};

class ITestInterface
{
	GENERATED_BODY()

public:

	UFUNCTION(BlueprintNativeEvent, Category = "Test Interface")
	void TestInterfaceFunction();

	UFUNCTION(BlueprintNativeEvent, Category = "Test Interface")
	void AnotherInterfaceFunction();

	UFUNCTION(BlueprintImplementableEvent, Category = "Test Interface")
	void BlueprintOnlyFunction();
};

// Skip a bit

void ATestGameMode::TestInterfaceOnActor(AActor* Actor)
{
	// Valid call, and you want this generated function name in the interface member listbox
	ITestInterface::Execute_TestInterfaceFunction(Actor);
	
	// Valid call, and you want this generated function name in the interface member listbox
	ITestInterface::Execute_AnotherInterfaceFunction(Actor);

	// INVALID call, so don't generate this method name
	ITestInterface::Execute_BlueprintOnlyFunction(Actor);
}

// TestInterface.h
class ITestInterface
{
	GENERATED_BODY()

public:

	UFUNCTION(BlueprintNativeEvent, Category = "Test Interface")
	void TestInterfaceFunction(bool bInBool, const FString& InString); // const and & were required for this to compile with FString for some reason

	UFUNCTION(BlueprintImplementableEvent, Category = "Test Interface")
	void TestInterfaceFunction2(bool bInBool, int32 InInt);
	
	UFUNCTION()
	virtual void TestInterfaceFunction3();
};

// TestGameMode.cpp
void ATestGameMode::TestInterfaceOnActor(AActor* Actor)
{
	ITestInterface::Execute_TestInterfaceFunction(Actor, true, TEXT("Won't compile without this arg"));
	ITestInterface::Execute_TestInterfaceFunction2(Actor, false, 42);
	ITestInterface::Execute_TestInterfaceFunction3(Actor);  // error: Execute_TestInterfaceFunction3 not found
}

// TestInterface.gen.cpp
	IMPLEMENT_CLASS(UTestInterface, 2529688523);
	static FCompiledInDefer Z_CompiledInDefer_UClass_UTestInterface(Z_Construct_UClass_UTestInterface, &UTestInterface::StaticClass, TEXT("/Script/Blackbird"), TEXT("UTestInterface"), false, nullptr, nullptr, nullptr);
	DEFINE_VTABLE_PTR_HELPER_CTOR(UTestInterface);
	static FName NAME_UTestInterface_TestInterfaceFunction = FName(TEXT("TestInterfaceFunction"));
	void ITestInterface::Execute_TestInterfaceFunction(UObject* O, bool bInBool, const FString& InString)
	{
		check(O != NULL);
		check(O->GetClass()->ImplementsInterface(UTestInterface::StaticClass()));
		TestInterface_eventTestInterfaceFunction_Parms Parms;
		UFunction* const Func = O->FindFunction(NAME_UTestInterface_TestInterfaceFunction);
		if (Func)
		{
			Parms.bInBool=bInBool;
			Parms.InString=InString;
			O->ProcessEvent(Func, &Parms);
		}
		else if (auto I = (ITestInterface*)(O->GetNativeInterfaceAddress(UTestInterface::StaticClass())))
		{
			I->TestInterfaceFunction_Implementation(bInBool,InString);
		}
	}
	static FName NAME_UTestInterface_TestInterfaceFunction2 = FName(TEXT("TestInterfaceFunction2"));
	void ITestInterface::Execute_TestInterfaceFunction2(UObject* O, bool bInBool, int32 InInt)
	{
		check(O != NULL);
		check(O->GetClass()->ImplementsInterface(UTestInterface::StaticClass()));
		TestInterface_eventTestInterfaceFunction2_Parms Parms;
		UFunction* const Func = O->FindFunction(NAME_UTestInterface_TestInterfaceFunction2);
		if (Func)
		{
			Parms.bInBool=bInBool;
			Parms.InInt=InInt;
			O->ProcessEvent(Func, &Parms);
		}
	}

#include "CoreMinimal.h"
#include "UObject/Interface.h"
#include "TestInterface.generated.h"

UINTERFACE(MinimalAPI, BlueprintType)
class UTestInterface : public UInterface
{
	GENERATED_BODY()

public:
    // an extra Execute_ function will be created for this function
    UFUNCTION(BlueprintNativeEvent, Category = "Test Interface")
    void TestInterfaceFunction(bool bInBool, const FString& InString);
   
    // an extra Execute_ function will be created for this function
    UFUNCTION(BlueprintImplementableEvent, Category = "Test Interface")
    void TestInterfaceFunction2(bool bInBool, int32 InInt);
};

/**
 * 
 */
class UE4_TESTING_API ITestInterface
{
	GENERATED_BODY()

public:
    void TestInterfaceFunction(bool bInBool, const FString& InString);
    void TestInterfaceFunction2(bool bInBool, int32 InInt);
};

void simplyCallExecuteFunctions()
{
    AActor *pActorHere = 0;
    ITestInterface *pInterface;
    // this line does NOT compile
    // VA DOES suggest the function however
    // and Alt-G on this function name takes me to the file "TestInterface.gen.cpp"
    pInterface->Execute_TestInterfaceFunction(pActorHere, true, "Calling this function directly");
}