141 lines
4.6 KiB
C++
141 lines
4.6 KiB
C++
#include "commons-test.h"
|
|
#include "core/ParameterIn.h"
|
|
#include "core/ParameterOut.h"
|
|
#include "core/Context.h"
|
|
#include "enums.h"
|
|
|
|
// Test fixture for Parameter tests
|
|
class ParameterTest : public AppTest {};
|
|
|
|
TEST_F(ParameterTest, CreateParameters) {
|
|
ASSERT_NE(m_App, nullptr);
|
|
auto* context = m_App->GetContext();
|
|
ASSERT_NE(context, nullptr);
|
|
|
|
// Create an output parameter
|
|
auto* p_out = context->CreateParameterOut("MyFloatOut", NHP_GUID_FLOAT);
|
|
ASSERT_NE(p_out, nullptr);
|
|
EXPECT_STREQ(p_out->GetName(), "MyFloatOut");
|
|
EXPECT_EQ(p_out->GetClassID(), NHCID_PARAMETEROUT);
|
|
|
|
// Create an input parameter
|
|
auto* p_in = context->CreateParameterIn("MyFloatIn", NHP_GUID_FLOAT);
|
|
ASSERT_NE(p_in, nullptr);
|
|
EXPECT_STREQ(p_in->GetName(), "MyFloatIn");
|
|
EXPECT_EQ(p_in->GetClassID(), NHCID_PARAMETERIN);
|
|
|
|
delete p_out;
|
|
delete p_in;
|
|
}
|
|
|
|
TEST_F(ParameterTest, LinkParametersAndGetValue) {
|
|
ASSERT_NE(m_App, nullptr);
|
|
auto* context = m_App->GetContext();
|
|
ASSERT_NE(context, nullptr);
|
|
|
|
// 1. Create parameters
|
|
auto* p_out = context->CreateParameterOut("SourceFloat", NHP_GUID_FLOAT);
|
|
auto* p_in = context->CreateParameterIn("DestFloat", NHP_GUID_FLOAT);
|
|
|
|
// 2. Set a value on the output parameter
|
|
float out_value = 3.14f;
|
|
p_out->SetValue(&out_value, sizeof(float));
|
|
|
|
// 3. Link the input parameter to the output parameter
|
|
p_in->SetDirectSource(p_out);
|
|
|
|
// 4. Get the value from the input parameter
|
|
float in_value = 0.0f;
|
|
p_in->GetValue(&in_value);
|
|
|
|
// 5. Verify the value is correct
|
|
EXPECT_FLOAT_EQ(in_value, out_value);
|
|
|
|
// 6. Test GetReadDataPtr
|
|
void* data_ptr = p_in->GetReadDataPtr();
|
|
ASSERT_NE(data_ptr, nullptr);
|
|
EXPECT_FLOAT_EQ(*(static_cast<float*>(data_ptr)), out_value);
|
|
|
|
delete p_out;
|
|
delete p_in;
|
|
}
|
|
|
|
TEST_F(ParameterTest, OutputToMultipleInputs) {
|
|
ASSERT_NE(m_App, nullptr);
|
|
auto* context = m_App->GetContext();
|
|
ASSERT_NE(context, nullptr);
|
|
|
|
// 1. Create one output and multiple input parameters
|
|
auto* p_out = context->CreateParameterOut("SourceFloat", NHP_GUID_FLOAT);
|
|
auto* p_in1 = context->CreateParameterIn("DestFloat1", NHP_GUID_FLOAT);
|
|
auto* p_in2 = context->CreateParameterIn("DestFloat2", NHP_GUID_FLOAT);
|
|
auto* p_in3 = context->CreateParameterIn("DestFloat3", NHP_GUID_FLOAT);
|
|
|
|
// 2. Set a value on the output parameter
|
|
float out_value = 42.0f;
|
|
p_out->SetValue(&out_value, sizeof(float));
|
|
|
|
// 3. Link all input parameters to the single output parameter
|
|
p_in1->SetDirectSource(p_out);
|
|
p_in2->SetDirectSource(p_out);
|
|
p_in3->SetDirectSource(p_out);
|
|
|
|
// 4. Verify the value for all inputs
|
|
float in_value1 = 0.0f, in_value2 = 0.0f, in_value3 = 0.0f;
|
|
p_in1->GetValue(&in_value1);
|
|
p_in2->GetValue(&in_value2);
|
|
p_in3->GetValue(&in_value3);
|
|
|
|
EXPECT_FLOAT_EQ(in_value1, out_value);
|
|
EXPECT_FLOAT_EQ(in_value2, out_value);
|
|
EXPECT_FLOAT_EQ(in_value3, out_value);
|
|
|
|
delete p_out;
|
|
delete p_in1;
|
|
delete p_in2;
|
|
delete p_in3;
|
|
}
|
|
|
|
TEST_F(ParameterTest, SingleSourceForInput) {
|
|
ASSERT_NE(m_App, nullptr);
|
|
auto* context = m_App->GetContext();
|
|
ASSERT_NE(context, nullptr);
|
|
|
|
// 1. Create multiple source parameters and inputs
|
|
auto* p_out1 = context->CreateParameterOut("Source1", NHP_GUID_INT);
|
|
auto* p_out2 = context->CreateParameterOut("Source2", NHP_GUID_INT);
|
|
auto* p_in1 = context->CreateParameterIn("Input1", NHP_GUID_INT);
|
|
auto* p_in2 = context->CreateParameterIn("Input2", NHP_GUID_INT);
|
|
|
|
int val1 = 111, val2 = 222;
|
|
p_out1->SetValue(&val1, sizeof(int));
|
|
p_out2->SetValue(&val2, sizeof(int));
|
|
|
|
// 2. Link p_in2 to p_out2
|
|
p_in2->SetDirectSource(p_out2);
|
|
EXPECT_EQ(p_in2->GetRealSource(), p_out2);
|
|
|
|
// 3. Link p_in1 to p_out1 initially
|
|
p_in1->SetDirectSource(p_out1);
|
|
EXPECT_EQ(p_in1->GetRealSource(), p_out1);
|
|
EXPECT_EQ(p_in1->GetSharedSource(), nullptr);
|
|
|
|
// 4. Now, share p_in1 with p_in2. This should override the direct source.
|
|
p_in1->ShareSourceWith(p_in2);
|
|
EXPECT_EQ(p_in1->GetDirectSource(), nullptr);
|
|
EXPECT_EQ(p_in1->GetSharedSource(), p_in2);
|
|
|
|
// 5. The real source of p_in1 should now be p_out2 (through p_in2)
|
|
EXPECT_EQ(p_in1->GetRealSource(), p_out2);
|
|
|
|
// 6. Verify the value comes from the new real source
|
|
int in_value = 0;
|
|
p_in1->GetValue(&in_value);
|
|
EXPECT_EQ(in_value, val2);
|
|
|
|
delete p_out1;
|
|
delete p_out2;
|
|
delete p_in1;
|
|
delete p_in2;
|
|
}
|