You've already forked UnrealEngineUWP
mirror of
https://github.com/izzy2lost/UnrealEngineUWP.git
synced 2026-03-26 18:15:20 -07:00
1d78b81b52
#jira UE-175097 #rb Charlie.Huguenard #preflight 63d1895f033e457ba8f10cb4 [CL 23863384 by phil popp in ue5-main branch]
606 lines
21 KiB
C++
606 lines
21 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "AudioDevice.h"
|
|
#include "AudioDeviceManager.h"
|
|
#include "AudioMixerDevice.h"
|
|
#include "Containers/Array.h"
|
|
#include "Containers/UnrealString.h"
|
|
#include "Interfaces/MetasoundFrontendSourceInterface.h"
|
|
#include "Math/NumericLimits.h"
|
|
#include "Misc/AutomationTest.h"
|
|
#include "MetasoundAudioBuffer.h"
|
|
#include "MetasoundFrontendDataTypeRegistry.h"
|
|
#include "MetasoundFrontendRegistries.h"
|
|
#include "MetasoundFrontendSearchEngine.h"
|
|
#include "MetasoundLog.h"
|
|
#include "MetasoundPrimitives.h"
|
|
#include "MetasoundVertex.h"
|
|
#include "MetasoundVertexData.h"
|
|
#include "Templates/UniquePtr.h"
|
|
#include "Tests/AutomationCommon.h"
|
|
|
|
#if WITH_DEV_AUTOMATION_TESTS
|
|
|
|
#if WITH_EDITORONLY_DATA
|
|
|
|
namespace Metasound::MetasoundEngineTestPrivate {
|
|
|
|
// Return audio mixer device if one is available
|
|
Audio::FMixerDevice* GetAudioMixerDevice()
|
|
{
|
|
if (FAudioDeviceManager* DeviceManager = FAudioDeviceManager::Get())
|
|
{
|
|
if (FAudioDevice* AudioDevice = DeviceManager->GetMainAudioDeviceRaw())
|
|
{
|
|
if (AudioDevice->IsAudioMixerEnabled())
|
|
{
|
|
return static_cast<Audio::FMixerDevice*>(AudioDevice);
|
|
}
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
// Create an example environment that generally exists for a UMetaSoundSoruce
|
|
FMetasoundEnvironment GetSourceEnvironment()
|
|
{
|
|
using namespace Frontend;
|
|
|
|
FMetasoundEnvironment Environment;
|
|
|
|
Environment.SetValue<uint32>(SourceInterface::Environment::SoundUniqueID, 0);
|
|
Environment.SetValue<bool>(SourceInterface::Environment::IsPreview, false);
|
|
Environment.SetValue<uint64>(SourceInterface::Environment::TransmitterID, 0);
|
|
Environment.SetValue<FString>(SourceInterface::Environment::GraphName, TEXT("ENGINE_TEST_REGISTERED_NODES"));
|
|
|
|
if (Audio::FMixerDevice* MixerDevice = GetAudioMixerDevice())
|
|
{
|
|
Environment.SetValue<Audio::FDeviceId>(SourceInterface::Environment::DeviceID, MixerDevice->DeviceID);
|
|
Environment.SetValue<int32>(SourceInterface::Environment::AudioMixerNumOutputFrames, MixerDevice->GetNumOutputFrames());
|
|
}
|
|
|
|
return Environment;
|
|
}
|
|
|
|
// TTestTypeInfo converts test types to strings
|
|
template<typename DataType>
|
|
struct TTestTypeInfo
|
|
{
|
|
static FString ToString(const DataType& InData)
|
|
{
|
|
return ::LexToString(InData);
|
|
}
|
|
};
|
|
|
|
template<typename ElementType>
|
|
struct TTestTypeInfo<TArray<ElementType>>
|
|
{
|
|
static FString ToString(const TArray<ElementType>& InData)
|
|
{
|
|
return FString::Printf(TEXT("[%s]"), *FString::JoinBy(InData, TEXT(","), &TTestTypeInfo<ElementType>::ToString));
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct TTestTypeInfo<FTime>
|
|
{
|
|
static FString ToString(const FTime& InData)
|
|
{
|
|
return ::LexToString(InData.GetSeconds());
|
|
}
|
|
};
|
|
|
|
// TTestTypeValues should return basic bounds for tested input data types.
|
|
// Similar to TNumericLimits<>
|
|
template<typename DataType>
|
|
struct TTestTypeValues
|
|
{};
|
|
|
|
// TArray specialization to defer to a single element array with array element's values
|
|
template<typename ElementType>
|
|
struct TTestTypeValues<TArray<ElementType>>
|
|
{
|
|
static TArray<ElementType> Min(const FOperatorSettings& InSettings)
|
|
{
|
|
return TArray<ElementType>({TTestTypeValues<ElementType>::Min(InSettings)});
|
|
}
|
|
|
|
static TArray<ElementType> Max(const FOperatorSettings& InSettings)
|
|
{
|
|
return TArray<ElementType>({TTestTypeValues<ElementType>::Max(InSettings)});
|
|
}
|
|
|
|
static TArray<ElementType> Default(const FOperatorSettings& InSettings)
|
|
{
|
|
return TArray<ElementType>({TTestTypeValues<ElementType>::Default(InSettings)});
|
|
}
|
|
|
|
static TArray<ElementType> Random(const FOperatorSettings& InSettings)
|
|
{
|
|
return TArray<ElementType>({TTestTypeValues<ElementType>::Random(InSettings)});
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct TTestTypeValues<bool>
|
|
{
|
|
static bool Min(const FOperatorSettings& InSettings) { return false; }
|
|
static bool Max(const FOperatorSettings& InSettings) { return true; }
|
|
static bool Default(const FOperatorSettings& InSettings) { return true; }
|
|
static bool Random(const FOperatorSettings& InSettings) { return FMath::RandRange(0.f, 1.f) > 0.5; }
|
|
};
|
|
|
|
template<>
|
|
struct TTestTypeValues<int32>
|
|
{
|
|
static int32 Min(const FOperatorSettings& InSettings) { return TNumericLimits<int32>::Min(); }
|
|
static int32 Max(const FOperatorSettings& InSettings) { return TNumericLimits<int32>::Max(); }
|
|
static int32 Default(const FOperatorSettings& InSettings) { return 0; }
|
|
static int32 Random(const FOperatorSettings& InSettings) { return FMath::RandRange(TNumericLimits<int32>::Min(), TNumericLimits<int32>::Max()); }
|
|
};
|
|
|
|
template<>
|
|
struct TTestTypeValues<float>
|
|
{
|
|
static float Min(const FOperatorSettings& InSettings) { return TNumericLimits<float>::Min(); }
|
|
static float Max(const FOperatorSettings& InSettings) { return TNumericLimits<float>::Max(); }
|
|
static float Default(const FOperatorSettings& InSettings) { return 0.f; }
|
|
static float Random(const FOperatorSettings& InSettings) { return FMath::RandRange(TNumericLimits<float>::Min(), TNumericLimits<float>::Max()); }
|
|
};
|
|
|
|
template<>
|
|
struct TTestTypeValues<FTime>
|
|
{
|
|
static FTime Min(const FOperatorSettings& InSettings) { return FTime{TNumericLimits<float>::Min()}; }
|
|
static FTime Max(const FOperatorSettings& InSettings) { return FTime{TNumericLimits<float>::Max()}; }
|
|
static FTime Default(const FOperatorSettings& InSettings) { return FTime{0.f}; }
|
|
static FTime Random(const FOperatorSettings& InSettings) { return FTime{FMath::RandRange(TNumericLimits<float>::Min(), TNumericLimits<float>::Max())}; }
|
|
};
|
|
|
|
template<>
|
|
struct TTestTypeValues<FTrigger>
|
|
{
|
|
static FTrigger Min(const FOperatorSettings& InSettings) { return FTrigger{InSettings, false}; }
|
|
static FTrigger Max(const FOperatorSettings& InSettings)
|
|
{
|
|
FTrigger Trigger{InSettings, false};
|
|
for (int32 i = 0; i < InSettings.GetNumFramesPerBlock(); i++)
|
|
{
|
|
Trigger.TriggerFrame(i);
|
|
}
|
|
return Trigger;
|
|
}
|
|
|
|
static FTrigger Default(const FOperatorSettings& InSettings) { return FTrigger{InSettings, true}; }
|
|
static FTrigger Random(const FOperatorSettings& InSettings)
|
|
{
|
|
FTrigger Trigger{InSettings, false};
|
|
int32 NumTriggers = FMath::RandRange(0, InSettings.GetNumFramesPerBlock());
|
|
while (NumTriggers > 0)
|
|
{
|
|
Trigger.TriggerFrame(FMath::RandRange(0, InSettings.GetNumFramesPerBlock()));
|
|
NumTriggers--;
|
|
}
|
|
return Trigger;
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct TTestTypeValues<FString>
|
|
{
|
|
static FString Min(const FOperatorSettings& InSettings) { return TEXT(""); }
|
|
static FString Max(const FOperatorSettings& InSettings) { return TEXT("THIS IS SUPPOSED TO REPRESENT A MAXIMUM STRING BUT THERE IS NO SUCH THING SO?"); }
|
|
static FString Default(const FOperatorSettings& InSettings) { return TEXT("TestString"); }
|
|
static FString Random(const FOperatorSettings& InSettings) { return TEXT("We should probably implement a random string."); }
|
|
};
|
|
|
|
// Interface for mutating data references
|
|
struct IDataReferenceMutator
|
|
{
|
|
virtual ~IDataReferenceMutator() = default;
|
|
virtual void SetDefault(const FOperatorSettings& InSettings, const FAnyDataReference& InDataRef) const = 0;
|
|
virtual void SetMax(const FOperatorSettings& InSettings, const FAnyDataReference& InDataRef) const = 0;
|
|
virtual void SetMin(const FOperatorSettings& InSettings, const FAnyDataReference& InDataRef) const = 0;
|
|
virtual void SetRandom(const FOperatorSettings& InSettings, const FAnyDataReference& InDataRef) const = 0;
|
|
virtual FString ToString(const FAnyDataReference& InDataRef) const = 0;
|
|
};
|
|
|
|
template<typename DataType>
|
|
struct TDataReferenceMutator : IDataReferenceMutator
|
|
{
|
|
virtual void SetDefault(const FOperatorSettings& InSettings, const FAnyDataReference& InDataRef) const override
|
|
{
|
|
*InDataRef.GetDataWriteReference<DataType>() = TTestTypeValues<DataType>::Default(InSettings);
|
|
}
|
|
|
|
virtual void SetMax(const FOperatorSettings& InSettings, const FAnyDataReference& InDataRef) const override
|
|
{
|
|
*InDataRef.GetDataWriteReference<DataType>() = TTestTypeValues<DataType>::Max(InSettings);
|
|
}
|
|
|
|
virtual void SetMin(const FOperatorSettings& InSettings, const FAnyDataReference& InDataRef) const override
|
|
{
|
|
*InDataRef.GetDataWriteReference<DataType>() = TTestTypeValues<DataType>::Min(InSettings);
|
|
}
|
|
|
|
virtual void SetRandom(const FOperatorSettings& InSettings, const FAnyDataReference& InDataRef) const override
|
|
{
|
|
*InDataRef.GetDataWriteReference<DataType>() = TTestTypeValues<DataType>::Random(InSettings);
|
|
}
|
|
|
|
virtual FString ToString(const FAnyDataReference& InDataRef) const override
|
|
{
|
|
if (const DataType* Data = InDataRef.GetValue<DataType>())
|
|
{
|
|
return FString::Printf(TEXT("%s:%s"), *GetMetasoundDataTypeString<DataType>(), *TTestTypeInfo<DataType>::ToString(*Data));
|
|
}
|
|
else
|
|
{
|
|
// Data references should never be null
|
|
UE_LOG(LogMetaSound, Error, TEXT("Failed to get data type value of type %s"), *GetMetasoundDataTypeString<DataType>());
|
|
return TEXT("");
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
template<typename DataType>
|
|
void AddDataReferenceMutatorEntryToMap(TMap<FName, TSharedPtr<const IDataReferenceMutator>>& InMap)
|
|
{
|
|
InMap.Add(GetMetasoundDataTypeName<DataType>(), MakeShared<TDataReferenceMutator<DataType>>());
|
|
}
|
|
|
|
// Returns map of mutable input types
|
|
const TMap<FName, TSharedPtr<const IDataReferenceMutator>>& GetDataTypeGeneratorMap()
|
|
{
|
|
static TMap<FName, TSharedPtr<const IDataReferenceMutator>> Map;
|
|
|
|
AddDataReferenceMutatorEntryToMap<bool>(Map);
|
|
AddDataReferenceMutatorEntryToMap<int32>(Map);
|
|
AddDataReferenceMutatorEntryToMap<float>(Map);
|
|
AddDataReferenceMutatorEntryToMap<FString>(Map);
|
|
AddDataReferenceMutatorEntryToMap<FTime>(Map);
|
|
AddDataReferenceMutatorEntryToMap<FTrigger>(Map);
|
|
AddDataReferenceMutatorEntryToMap<TArray<bool>>(Map);
|
|
AddDataReferenceMutatorEntryToMap<TArray<int32>>(Map);
|
|
AddDataReferenceMutatorEntryToMap<TArray<float>>(Map);
|
|
AddDataReferenceMutatorEntryToMap<TArray<FString>>(Map);
|
|
AddDataReferenceMutatorEntryToMap<TArray<FTime>>(Map);
|
|
AddDataReferenceMutatorEntryToMap<TArray<FTrigger>>(Map);
|
|
|
|
return Map;
|
|
}
|
|
|
|
// Convenience class for setting node input data reference values to default, min, max or random values.
|
|
struct FInputVertexDataTestController
|
|
{
|
|
struct FMutableInput
|
|
{
|
|
FAnyDataReference DataReference;
|
|
FVertexName VertexName;
|
|
TSharedPtr<const IDataReferenceMutator> DataReferenceMutator;
|
|
};
|
|
|
|
FInputVertexDataTestController(const FOperatorSettings& InSettings, const FInputVertexInterface& InInputInterface, const FInputVertexInterfaceData& InInputData)
|
|
: Settings(InSettings)
|
|
{
|
|
const TMap<FName, TSharedPtr<const IDataReferenceMutator>>& GeneratorMap = GetDataTypeGeneratorMap();
|
|
|
|
for (const FInputDataVertex& Vertex : InInputInterface)
|
|
{
|
|
if (GeneratorMap.Contains(Vertex.DataTypeName))
|
|
{
|
|
if (const FAnyDataReference* Ref = InInputData.FindDataReference(Vertex.VertexName))
|
|
{
|
|
if (EDataReferenceAccessType::Write == Ref->GetAccessType())
|
|
{
|
|
MutableInputs.Add(FMutableInput{*Ref, Vertex.VertexName, GeneratorMap[Vertex.DataTypeName]});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int32 GetNumMutableInputs() const
|
|
{
|
|
return MutableInputs.Num();
|
|
}
|
|
|
|
void SetMutableInputsToMin()
|
|
{
|
|
for (const FMutableInput& MutableInput : MutableInputs)
|
|
{
|
|
MutableInput.DataReferenceMutator->SetMin(Settings, MutableInput.DataReference);
|
|
}
|
|
UE_LOG(LogMetaSound, Verbose, TEXT("Setting operator input values:%s%s"), LINE_TERMINATOR, *FString::Join(GetInputValueStrings(), LINE_TERMINATOR));
|
|
}
|
|
|
|
void SetMutableInputsToMax()
|
|
{
|
|
for (const FMutableInput& MutableInput : MutableInputs)
|
|
{
|
|
MutableInput.DataReferenceMutator->SetMax(Settings, MutableInput.DataReference);
|
|
}
|
|
UE_LOG(LogMetaSound, Verbose, TEXT("Setting operator input values:%s%s"), LINE_TERMINATOR, *FString::Join(GetInputValueStrings(), LINE_TERMINATOR));
|
|
}
|
|
|
|
void SetMutableInputsToDefault()
|
|
{
|
|
for (const FMutableInput& MutableInput : MutableInputs)
|
|
{
|
|
MutableInput.DataReferenceMutator->SetDefault(Settings, MutableInput.DataReference);
|
|
}
|
|
UE_LOG(LogMetaSound, Verbose, TEXT("Setting operator input values:%s%s"), LINE_TERMINATOR, *FString::Join(GetInputValueStrings(), LINE_TERMINATOR));
|
|
}
|
|
|
|
void SetMutableInputsToRandom()
|
|
{
|
|
for (const FMutableInput& MutableInput : MutableInputs)
|
|
{
|
|
MutableInput.DataReferenceMutator->SetRandom(Settings, MutableInput.DataReference);
|
|
}
|
|
UE_LOG(LogMetaSound, Verbose, TEXT("Setting operator input values:%s%s"), LINE_TERMINATOR, *FString::Join(GetInputValueStrings(), LINE_TERMINATOR));
|
|
}
|
|
|
|
TArray<FString> GetInputValueStrings() const
|
|
{
|
|
TArray<FString> ValueStrings;
|
|
for (const FMutableInput& MutableInput : MutableInputs)
|
|
{
|
|
ValueStrings.Add(FString::Printf(TEXT("%s %s"), *MutableInput.VertexName.ToString(), *MutableInput.DataReferenceMutator->ToString(MutableInput.DataReference)));
|
|
}
|
|
return ValueStrings;
|
|
}
|
|
|
|
private:
|
|
|
|
FOperatorSettings Settings;
|
|
TArray<FMutableInput> MutableInputs;
|
|
};
|
|
|
|
static const FLazyName TestNodeName{"TEST_NODE"};
|
|
static const FLazyName TestVertexName{"TEXT_VERTEX"};
|
|
static const FGuid TestNodeID{0xA5A5A5A5, 0xA5A5A5A5, 0xA5A5A5A5, 0xA5A5A5A5};
|
|
|
|
// Create a node from a node registry key
|
|
TUniquePtr<INode> CreateNode(const Frontend::FNodeRegistryKey& InNodeRegistryKey)
|
|
{
|
|
using namespace Frontend;
|
|
|
|
TUniquePtr<INode> Node;
|
|
|
|
FMetasoundFrontendRegistryContainer* NodeRegistry = FMetasoundFrontendRegistryContainer::Get();
|
|
check(nullptr != NodeRegistry);
|
|
IDataTypeRegistry& DataTypeRegistry = IDataTypeRegistry::Get();
|
|
|
|
// Lookup node class metadata to determine how to create this node.
|
|
FMetasoundFrontendClass NodeClass;
|
|
if (!NodeRegistry->FindFrontendClassFromRegistered(InNodeRegistryKey, NodeClass))
|
|
{
|
|
UE_LOG(LogMetaSound, Error, TEXT("Failed to find registered class with registry key %s"), *InNodeRegistryKey);
|
|
return MoveTemp(Node);
|
|
}
|
|
|
|
// Build node differently dependent upon node type
|
|
switch (NodeClass.Metadata.GetType())
|
|
{
|
|
case EMetasoundFrontendClassType::VariableDeferredAccessor:
|
|
case EMetasoundFrontendClassType::VariableAccessor:
|
|
case EMetasoundFrontendClassType::VariableMutator:
|
|
case EMetasoundFrontendClassType::External:
|
|
case EMetasoundFrontendClassType::Graph:
|
|
{
|
|
FNodeInitData NodeInitData{TestNodeName, TestNodeID};
|
|
Node = NodeRegistry->CreateNode(InNodeRegistryKey, NodeInitData);
|
|
}
|
|
break;
|
|
|
|
case EMetasoundFrontendClassType::Input:
|
|
{
|
|
FName DataTypeName = NodeClass.Metadata.GetClassName().Name;
|
|
FInputNodeConstructorParams NodeInitData
|
|
{
|
|
TestNodeName,
|
|
TestNodeID,
|
|
TestVertexName,
|
|
NodeClass.Interface.Inputs[0].DefaultLiteral.ToLiteral(DataTypeName)
|
|
};
|
|
|
|
Node = DataTypeRegistry.CreateInputNode(DataTypeName, MoveTemp(NodeInitData));
|
|
}
|
|
break;
|
|
|
|
case EMetasoundFrontendClassType::Variable:
|
|
{
|
|
FName DataTypeName = NodeClass.Metadata.GetClassName().Name;
|
|
FDefaultLiteralNodeConstructorParams NodeInitData{TestNodeName, TestNodeID, DataTypeRegistry.CreateDefaultLiteral(DataTypeName)};
|
|
Node = DataTypeRegistry.CreateVariableNode(DataTypeName, MoveTemp(NodeInitData));
|
|
}
|
|
break;
|
|
|
|
case EMetasoundFrontendClassType::Literal:
|
|
{
|
|
FName DataTypeName = NodeClass.Metadata.GetClassName().Name;
|
|
FDefaultLiteralNodeConstructorParams NodeInitData{TestNodeName, TestNodeID, DataTypeRegistry.CreateDefaultLiteral(DataTypeName)};
|
|
Node = DataTypeRegistry.CreateLiteralNode(DataTypeName, MoveTemp(NodeInitData));
|
|
}
|
|
break;
|
|
|
|
case EMetasoundFrontendClassType::Output:
|
|
{
|
|
FName DataTypeName = NodeClass.Metadata.GetClassName().Name;
|
|
FDefaultNamedVertexNodeConstructorParams NodeInitData{TestNodeName, TestNodeID, TestVertexName};
|
|
Node = DataTypeRegistry.CreateOutputNode(DataTypeName, MoveTemp(NodeInitData));
|
|
}
|
|
break;
|
|
|
|
case EMetasoundFrontendClassType::Template:
|
|
default:
|
|
static_assert(static_cast<int32>(EMetasoundFrontendClassType::Invalid) == 10, "Possible missed EMetasoundFrontendClassType case coverage");
|
|
}
|
|
|
|
return MoveTemp(Node);
|
|
}
|
|
|
|
// Create input vertex interface data for a node.
|
|
FInputVertexInterfaceData CreateInputVertexInterfaceData(const INode& InNode, const FOperatorSettings& InOperatorSettings)
|
|
{
|
|
Frontend::IDataTypeRegistry& DataTypeRegistry = Frontend::IDataTypeRegistry::Get();
|
|
|
|
// Populate inputs to node.
|
|
FVertexInterface NodeVertexInterface = InNode.GetVertexInterface();
|
|
FInputVertexInterfaceData NodeInputVertexInterfaceData{NodeVertexInterface.GetInputInterface()};
|
|
|
|
for (const FInputDataVertex& InputVertex : NodeVertexInterface.GetInputInterface())
|
|
{
|
|
if (InputVertex.AccessType != EVertexAccessType::Reference)
|
|
{
|
|
// Not testing constructor inputs.
|
|
continue;
|
|
}
|
|
|
|
// input data type must be registered in order to create it.
|
|
if (DataTypeRegistry.IsRegistered(InputVertex.DataTypeName))
|
|
{
|
|
Frontend::FDataTypeRegistryInfo DataTypeInfo;
|
|
ensure(DataTypeRegistry.GetDataTypeInfo(InputVertex.DataTypeName, DataTypeInfo));
|
|
|
|
// Can only create data types that are parsable from a literal
|
|
if (DataTypeInfo.bIsParsable)
|
|
{
|
|
FLiteral DefaultLiteral = DataTypeRegistry.CreateDefaultLiteral(InputVertex.DataTypeName);
|
|
TOptional<FAnyDataReference> DataReference = DataTypeRegistry.CreateDataReference(InputVertex.DataTypeName, EDataReferenceAccessType::Write, DefaultLiteral, InOperatorSettings);
|
|
|
|
if (!DataReference.IsSet())
|
|
{
|
|
UE_LOG(LogMetaSound, Error, TEXT("Failed to create data reference for data type %s "), *InputVertex.DataTypeName.ToString());
|
|
continue;
|
|
}
|
|
|
|
NodeInputVertexInterfaceData.BindVertex(InputVertex.VertexName, *DataReference);
|
|
}
|
|
}
|
|
}
|
|
return NodeInputVertexInterfaceData;
|
|
}
|
|
}
|
|
|
|
IMPLEMENT_COMPLEX_AUTOMATION_TEST(FMetasoundAutomatedNodeTest, "Audio.Metasound.AutomatedNodeTest", EAutomationTestFlags::EditorContext | EAutomationTestFlags::StressFilter)
|
|
void FMetasoundAutomatedNodeTest::GetTests(TArray<FString>& OutBeautifiedNames, TArray <FString>& OutTestCommands) const
|
|
{
|
|
using namespace Metasound;
|
|
|
|
// Get all the classes that have been registered
|
|
Frontend::ISearchEngine& NodeSearchEngine = Frontend::ISearchEngine::Get();
|
|
TArray<FMetasoundFrontendClass> AllClasses = NodeSearchEngine.FindAllClasses(true /* IncludeAllVersions */);
|
|
|
|
FMetasoundFrontendRegistryContainer* NodeRegistry = FMetasoundFrontendRegistryContainer::Get();
|
|
check(nullptr != NodeRegistry);
|
|
|
|
for (const FMetasoundFrontendClass& NodeClass : AllClasses)
|
|
{
|
|
// Exclude template classes because they cannot be created directly from the node registry
|
|
if (NodeClass.Metadata.GetType() == EMetasoundFrontendClassType::Template)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
Frontend::FNodeRegistryKey NodeRegistryKey = NodeRegistry->GetRegistryKey(NodeClass.Metadata);
|
|
|
|
OutBeautifiedNames.Add(FString::Printf(TEXT("%s %s"), *NodeClass.Metadata.GetClassName().ToString(), *NodeClass.Metadata.GetVersion().ToString()));
|
|
// Test commands are node registry keys
|
|
OutTestCommands.Add(NodeRegistryKey);
|
|
}
|
|
|
|
UE_LOG(LogMetaSound, Verbose, TEXT("Found %d metasound nodes to test"), OutTestCommands.Num());
|
|
}
|
|
|
|
bool FMetasoundAutomatedNodeTest::RunTest(const FString& InRegistryKey)
|
|
{
|
|
using namespace Metasound;
|
|
using namespace MetasoundEngineTestPrivate;
|
|
|
|
static const FOperatorSettings OperatorSettings{48000 /* samplerate */, 100.f /* block rate */};
|
|
static const FMetasoundEnvironment SourceEnvironment = GetSourceEnvironment();
|
|
|
|
TUniquePtr<INode> Node = CreateNode(InRegistryKey);
|
|
if (!Node.IsValid())
|
|
{
|
|
AddError(FString::Printf(TEXT("Failed to create node %s from registry"), *InRegistryKey));
|
|
return false;
|
|
}
|
|
|
|
// Populate inputs to node.
|
|
FInputVertexInterfaceData NodeInputVertexInterfaceData = CreateInputVertexInterfaceData(*Node, OperatorSettings);
|
|
FInputVertexInterface InputInterface = Node->GetVertexInterface().GetInputInterface();
|
|
FInputVertexDataTestController InputTester(OperatorSettings, InputInterface, NodeInputVertexInterfaceData);
|
|
|
|
// Create operator
|
|
FBuildOperatorParams BuildParams
|
|
{
|
|
*Node,
|
|
OperatorSettings,
|
|
NodeInputVertexInterfaceData,
|
|
SourceEnvironment
|
|
};
|
|
|
|
// Convenience function for testing entire lifecycle of an individual operator
|
|
// with a variety of inputs.
|
|
auto RunTestIteration = [&]() -> bool
|
|
{
|
|
FBuildResults BuildResults;
|
|
TUniquePtr<IOperator> Operator = Node->GetDefaultOperatorFactory()->CreateOperator(BuildParams, BuildResults);
|
|
|
|
if (!Operator.IsValid())
|
|
{
|
|
AddError(FString::Printf(TEXT("Failed to create operator from node %s."), *InRegistryKey));
|
|
return false;
|
|
}
|
|
|
|
IOperator::FExecuteFunction OpExecFunc = Operator->GetExecuteFunction();
|
|
|
|
if (OpExecFunc)
|
|
{
|
|
OpExecFunc(Operator.Get());
|
|
|
|
if (InputTester.GetNumMutableInputs() > 0)
|
|
{
|
|
InputTester.SetMutableInputsToDefault();
|
|
OpExecFunc(Operator.Get());
|
|
|
|
InputTester.SetMutableInputsToMin();
|
|
OpExecFunc(Operator.Get());
|
|
|
|
InputTester.SetMutableInputsToMax();
|
|
OpExecFunc(Operator.Get());
|
|
|
|
InputTester.SetMutableInputsToRandom();
|
|
OpExecFunc(Operator.Get());
|
|
}
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
bool bSuccess = true;
|
|
// Test entire operator lifecycle with different starting conditions if
|
|
// any of the inputs are mutable
|
|
InputTester.SetMutableInputsToDefault();
|
|
bSuccess &= RunTestIteration();
|
|
if (InputTester.GetNumMutableInputs() > 0)
|
|
{
|
|
InputTester.SetMutableInputsToMin();
|
|
bSuccess &= RunTestIteration();
|
|
InputTester.SetMutableInputsToMax();
|
|
bSuccess &= RunTestIteration();
|
|
InputTester.SetMutableInputsToRandom();
|
|
bSuccess &= RunTestIteration();
|
|
}
|
|
|
|
return bSuccess;
|
|
}
|
|
|
|
#endif // WITH_EDITORONLY_DATA
|
|
|
|
#endif //WITH_DEV_AUTOMATION_TESTS
|