1516 lines
62 KiB
C++
1516 lines
62 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "TestObjectReferences.h"
|
|
#include "Iris/Core/NetObjectReference.h"
|
|
#include "Tests/ReplicationSystem/ReplicationSystemServerClientTestFixture.h"
|
|
#include "Tests/ReplicationSystem/TestObjectReferences.h"
|
|
#include "Iris/Serialization/NetReferenceCollector.h"
|
|
#include "Iris/ReplicationSystem/ReplicationSystem.h"
|
|
#include "Iris/ReplicationSystem/ReplicationOperationsInternal.h"
|
|
#include "Iris/ReplicationSystem/ReplicationSystemInternal.h"
|
|
#include "Iris/ReplicationSystem/ReplicationFragmentUtil.h"
|
|
#include "Net/UnrealNetwork.h"
|
|
#include "Iris/ReplicationSystem/Filtering/NetObjectFilter.h"
|
|
#include "Iris/Core/IrisDebugging.h"
|
|
|
|
class UObject;
|
|
|
|
void UTestObjectReferences_TestClassWithReferences::RegisterReplicationFragments(UE::Net::FFragmentRegistrationContext& Context, UE::Net::EFragmentRegistrationFlags RegistrationFlags)
|
|
{
|
|
UE::Net::FReplicationFragmentUtil::CreateAndRegisterFragmentsForObject(this, Context, RegistrationFlags);
|
|
}
|
|
|
|
void UTestObjectReferences_TestClassWithReferences::GetLifetimeReplicatedProps(TArray< class FLifetimeProperty > & OutLifetimeProps) const
|
|
{
|
|
DOREPLIFETIME_CONDITION(UTestObjectReferences_TestClassWithReferences, ObjectRef, COND_InitialOnly);
|
|
DOREPLIFETIME(UTestObjectReferences_TestClassWithReferences, StructWithRef);
|
|
DOREPLIFETIME(UTestObjectReferences_TestClassWithReferences, StructWithRefCArray);
|
|
DOREPLIFETIME(UTestObjectReferences_TestClassWithReferences, StructWithRefTArray);
|
|
DOREPLIFETIME(UTestObjectReferences_TestClassWithReferences, Ref_CArray);
|
|
DOREPLIFETIME(UTestObjectReferences_TestClassWithReferences, Ref_TArray);
|
|
DOREPLIFETIME(UTestObjectReferences_TestClassWithReferences, StructWithRef_CArray);
|
|
DOREPLIFETIME(UTestObjectReferences_TestClassWithReferences, StructWithRef_TArray);
|
|
DOREPLIFETIME(UTestObjectReferences_TestClassWithReferences, TestStructWithNestedRefTArray_TArray);
|
|
DOREPLIFETIME(UTestObjectReferences_TestClassWithReferences, TestStructWithNestedRefCArray_CArray);
|
|
DOREPLIFETIME(UTestObjectReferences_TestClassWithReferences, Ref_FastArray);
|
|
DOREPLIFETIME(UTestObjectReferences_TestClassWithReferences, Ref_NativeFastArray);
|
|
}
|
|
|
|
UTestObjectReferences_TestClassWithDefaultSubObject::UTestObjectReferences_TestClassWithDefaultSubObject()
|
|
: UReplicatedTestObject()
|
|
{
|
|
CreatedSubObjectRef = CreateDefaultSubobject<UTestReplicatedIrisObject>("TestDefaultSubObjectRef");
|
|
}
|
|
|
|
void UTestObjectReferences_TestClassWithDefaultSubObject::RegisterReplicationFragments(UE::Net::FFragmentRegistrationContext& Context, UE::Net::EFragmentRegistrationFlags RegistrationFlags)
|
|
{
|
|
UE::Net::FReplicationFragmentUtil::CreateAndRegisterFragmentsForObject(this, Context, RegistrationFlags);
|
|
|
|
// Include subobject as well in the protocol
|
|
if (CreatedSubObjectRef)
|
|
{
|
|
static_cast<UTestReplicatedIrisObject*>(CreatedSubObjectRef)->RegisterReplicationFragments(Context, RegistrationFlags);
|
|
}
|
|
}
|
|
|
|
void UTestObjectReferences_TestClassWithDefaultSubObject::GetLifetimeReplicatedProps(TArray< class FLifetimeProperty > & OutLifetimeProps) const
|
|
{
|
|
DOREPLIFETIME(UTestObjectReferences_TestClassWithDefaultSubObject, ObjectRef);
|
|
}
|
|
|
|
namespace UE::Net::Private
|
|
{
|
|
|
|
class FTestObjectReferencesFixture : public FReplicationSystemServerClientTestFixture
|
|
{
|
|
public:
|
|
struct FReferenceCollector
|
|
{
|
|
void Reset() { References.Reset(); }
|
|
|
|
bool bCollectAll = true;
|
|
TArray<FNetObjectReference> References;
|
|
};
|
|
|
|
struct FCollectValidReferenceCollector
|
|
{
|
|
FCollectValidReferenceCollector(bool bInIncludeInitOnly, const FNetBitArrayView& InChangeMask)
|
|
: ChangeMask(InChangeMask)
|
|
, bIncludeInitOnly(bInIncludeInitOnly)
|
|
{
|
|
BitArray.Init(InChangeMask.GetNumBits());
|
|
}
|
|
|
|
void Reset()
|
|
{
|
|
BitArray.ClearAllBits();
|
|
References.Reset();
|
|
}
|
|
const FNetBitArrayView* GetChangeMask() const { return &ChangeMask; }
|
|
const bool IncludeInitOnly() const { return bIncludeInitOnly; }
|
|
|
|
FNetBitArray BitArray;
|
|
TArray<FNetObjectReference> References;
|
|
const FNetBitArrayView& ChangeMask;
|
|
const bool bIncludeInitOnly;
|
|
};
|
|
|
|
void VisitReferences(const uint8* RESTRICT SrcInternalBuffer, const FReplicationProtocol* Protocol, FReferenceCollector& ReferenceCollector)
|
|
{
|
|
FNetSerializationContext Context;
|
|
Context.SetIsInitState(true);
|
|
|
|
FNetReferenceCollector Collector(ReferenceCollector.bCollectAll ? ENetReferenceCollectorTraits::IncludeInvalidReferences : ENetReferenceCollectorTraits::None);
|
|
FReplicationProtocolOperationsInternal::CollectReferences(Context, Collector, SrcInternalBuffer, Protocol);
|
|
|
|
for (const FNetReferenceCollector::FReferenceInfo& Info : MakeArrayView(Collector.GetCollectedReferences()))
|
|
{
|
|
ReferenceCollector.References.Add(Info.Reference);
|
|
}
|
|
}
|
|
|
|
void VisitReferences(const uint8* RESTRICT SrcInternalBuffer, const FReplicationProtocol* Protocol, FCollectValidReferenceCollector& ReferenceCollector)
|
|
{
|
|
FNetSerializationContext Context;
|
|
Context.SetChangeMask(&ReferenceCollector.ChangeMask);
|
|
Context.SetIsInitState(ReferenceCollector.bIncludeInitOnly);
|
|
|
|
FNetReferenceCollector Collector;
|
|
FReplicationProtocolOperationsInternal::CollectReferences(Context, Collector, SrcInternalBuffer, Protocol);
|
|
|
|
for (const FNetReferenceCollector::FReferenceInfo& Info : MakeArrayView(Collector.GetCollectedReferences()))
|
|
{
|
|
ReferenceCollector.References.Add(Info.Reference);
|
|
if (Info.ChangeMaskInfo.BitCount)
|
|
{
|
|
ReferenceCollector.BitArray.SetBit(Info.ChangeMaskInfo.BitOffset);
|
|
}
|
|
}
|
|
}
|
|
|
|
void SetMemberDirty(FNetBitArrayView ChangeMask, uint32 MemberIndex)
|
|
{
|
|
const FReplicationStateDescriptor* Descriptor = TestObjectProtocol->ReplicationStateDescriptors[1];
|
|
const FReplicationStateMemberChangeMaskDescriptor& ChangeMaskDesciptor = Descriptor->MemberChangeMaskDescriptors[MemberIndex];
|
|
ChangeMask.SetBits(ChangeMaskDesciptor.BitOffset, ChangeMaskDesciptor.BitCount);
|
|
}
|
|
|
|
FReferenceCollector CollectAllCollector;
|
|
FReferenceCollector CollectOnlyValidCollector;
|
|
|
|
TArray<UTestObjectReferences_TestClassWithReferences*> TestReferences;
|
|
UTestObjectReferences_TestClassWithReferences* TestObject;
|
|
uint8* TestObjectStateBuffer;
|
|
const FReplicationProtocol* TestObjectProtocol;
|
|
|
|
virtual void SetUp() override
|
|
{
|
|
FReplicationSystemServerClientTestFixture::SetUp();
|
|
|
|
// Create objects
|
|
const uint32 ObjectCount = 30;
|
|
for (uint32 It = 0; It < ObjectCount; ++It)
|
|
{
|
|
TestReferences.Push(Server->CreateObject<UTestObjectReferences_TestClassWithReferences>());
|
|
}
|
|
|
|
// Create test object
|
|
TestObject = Server->CreateObject<UTestObjectReferences_TestClassWithReferences>();
|
|
|
|
uint32 ObjectIndex = Server->GetReplicationSystem()->GetReplicationSystemInternal()->GetNetRefHandleManager().GetInternalIndex(TestObject->NetRefHandle);
|
|
TestObjectStateBuffer = Server->GetReplicationSystem()->GetReplicationSystemInternal()->GetNetRefHandleManager().GetReplicatedObjectStateBufferNoCheck(ObjectIndex);
|
|
TestObjectProtocol = Server->GetReplicationSystem()->GetReplicationProtocol(TestObject->NetRefHandle);
|
|
|
|
// InitCollectors
|
|
CollectOnlyValidCollector.bCollectAll = false;
|
|
CollectAllCollector.bCollectAll = true;
|
|
|
|
// To trigger copy of data so we have valid data in buffers
|
|
Server->NetUpdate();
|
|
Server->PostSendUpdate();
|
|
}
|
|
};
|
|
|
|
UE_NET_TEST_FIXTURE(FTestObjectReferencesFixture, TestReferenceVisitor_NoRef)
|
|
{
|
|
// To trigger copy of data
|
|
Server->NetUpdate();
|
|
Server->PostSendUpdate();
|
|
|
|
FNetSerializationContext Context;
|
|
|
|
// Collect
|
|
FReferenceCollector& Collector = CollectAllCollector;
|
|
FTestObjectReferencesFixture::VisitReferences(TestObjectStateBuffer, TestObjectProtocol, Collector);
|
|
|
|
UE_NET_ASSERT_EQ(Collector.References.Num(), 38);
|
|
|
|
for (const FNetObjectReference& Ref : Collector.References)
|
|
{
|
|
UE_NET_ASSERT_FALSE(Ref.GetRefHandle().IsValid());
|
|
}
|
|
}
|
|
|
|
|
|
UE_NET_TEST_FIXTURE(FTestObjectReferencesFixture, TestReferenceVisitor_SingleRef)
|
|
{
|
|
// Setup references
|
|
TestObject->ObjectRef = TestReferences[0];
|
|
|
|
// To trigger copy of data
|
|
Server->NetUpdate();
|
|
Server->PostSendUpdate();
|
|
|
|
FReferenceCollector& Collector = CollectOnlyValidCollector;
|
|
|
|
// Collect
|
|
VisitReferences(TestObjectStateBuffer, TestObjectProtocol, Collector);
|
|
|
|
UE_NET_ASSERT_EQ(Collector.References.Num(), 1);
|
|
UE_NET_ASSERT_TRUE(Collector.References[0].GetRefHandle() == TestReferences[0]->NetRefHandle);
|
|
}
|
|
|
|
UE_NET_TEST_FIXTURE(FTestObjectReferencesFixture, TestReferenceVisitor_ObjectRef)
|
|
{
|
|
// Setup references
|
|
TestObject->ObjectRef = TestReferences[0];
|
|
|
|
// To trigger copy of data
|
|
Server->NetUpdate();
|
|
Server->PostSendUpdate();
|
|
|
|
FReferenceCollector& Collector = CollectOnlyValidCollector;
|
|
|
|
// Collect
|
|
VisitReferences(TestObjectStateBuffer, TestObjectProtocol, Collector);
|
|
|
|
UE_NET_ASSERT_EQ(Collector.References.Num(), 1);
|
|
UE_NET_ASSERT_TRUE(Collector.References[0].GetRefHandle() == TestReferences[0]->NetRefHandle);
|
|
}
|
|
|
|
UE_NET_TEST_FIXTURE(FTestObjectReferencesFixture, TestReferenceVisitor_StructWithRef)
|
|
{
|
|
// Setup references
|
|
TestObject->StructWithRef.ObjectRef = TestReferences[0];
|
|
|
|
// To trigger copy of data
|
|
Server->NetUpdate();
|
|
Server->PostSendUpdate();
|
|
|
|
FReferenceCollector& Collector = CollectOnlyValidCollector;
|
|
|
|
// Collect
|
|
VisitReferences(TestObjectStateBuffer, TestObjectProtocol, Collector);
|
|
|
|
UE_NET_ASSERT_EQ(Collector.References.Num(), 1);
|
|
UE_NET_ASSERT_TRUE(Collector.References[0].GetRefHandle() == TestReferences[0]->NetRefHandle);
|
|
}
|
|
|
|
UE_NET_TEST_FIXTURE(FTestObjectReferencesFixture, TestReferenceVisitor_StructWithRefCArray)
|
|
{
|
|
// Setup references
|
|
TestObject->StructWithRefCArray.Ref_CArray[0] = TestReferences[0];
|
|
|
|
// To trigger copy of data
|
|
Server->NetUpdate();
|
|
Server->PostSendUpdate();
|
|
|
|
FReferenceCollector& Collector = CollectOnlyValidCollector;
|
|
|
|
// Collect
|
|
VisitReferences(TestObjectStateBuffer, TestObjectProtocol, Collector);
|
|
|
|
UE_NET_ASSERT_EQ(Collector.References.Num(), 1);
|
|
UE_NET_ASSERT_TRUE(Collector.References[0].GetRefHandle() == TestReferences[0]->NetRefHandle);
|
|
}
|
|
|
|
UE_NET_TEST_FIXTURE(FTestObjectReferencesFixture, TestReferenceVisitor_StructWithRefCArrayMulti)
|
|
{
|
|
// Setup references
|
|
TestObject->StructWithRefCArray.Ref_CArray[0] = TestReferences[0];
|
|
TestObject->StructWithRefCArray.Ref_CArray[1] = TestReferences[1];
|
|
TestObject->StructWithRefCArray.Ref_CArray[2] = TestReferences[2];
|
|
|
|
// To trigger copy of data
|
|
Server->NetUpdate();
|
|
Server->PostSendUpdate();
|
|
|
|
FReferenceCollector& Collector = CollectOnlyValidCollector;
|
|
|
|
// Collect
|
|
VisitReferences(TestObjectStateBuffer, TestObjectProtocol, Collector);
|
|
|
|
UE_NET_ASSERT_EQ(Collector.References.Num(), 3);
|
|
UE_NET_ASSERT_TRUE(Collector.References[0].GetRefHandle() == TestReferences[0]->NetRefHandle);
|
|
UE_NET_ASSERT_TRUE(Collector.References[1].GetRefHandle() == TestReferences[1]->NetRefHandle);
|
|
UE_NET_ASSERT_TRUE(Collector.References[2].GetRefHandle() == TestReferences[2]->NetRefHandle);
|
|
}
|
|
|
|
UE_NET_TEST_FIXTURE(FTestObjectReferencesFixture, TestReferenceVisitor_StructWithRefTArray)
|
|
{
|
|
// Setup references
|
|
TestObject->StructWithRefTArray.Ref_TArray.Push(TestReferences[0]);
|
|
|
|
// To trigger copy of data
|
|
Server->NetUpdate();
|
|
Server->PostSendUpdate();
|
|
|
|
FReferenceCollector& Collector = CollectOnlyValidCollector;
|
|
|
|
// Collect
|
|
VisitReferences(TestObjectStateBuffer, TestObjectProtocol, Collector);
|
|
|
|
UE_NET_ASSERT_EQ(Collector.References.Num(), 1);
|
|
UE_NET_ASSERT_TRUE(Collector.References[0].GetRefHandle() == TestReferences[0]->NetRefHandle);
|
|
}
|
|
|
|
UE_NET_TEST_FIXTURE(FTestObjectReferencesFixture, TestReferenceVisitor_StructWithRefTArrayMulti)
|
|
{
|
|
// Setup references
|
|
TestObject->StructWithRefTArray.Ref_TArray.Push(TestReferences[0]);
|
|
TestObject->StructWithRefTArray.Ref_TArray.Push(TestReferences[1]);
|
|
TestObject->StructWithRefTArray.Ref_TArray.Push(TestReferences[2]);
|
|
|
|
// To trigger copy of data
|
|
Server->NetUpdate();
|
|
Server->PostSendUpdate();
|
|
|
|
FReferenceCollector& Collector = CollectOnlyValidCollector;
|
|
|
|
// Collect
|
|
VisitReferences(TestObjectStateBuffer, TestObjectProtocol, Collector);
|
|
|
|
UE_NET_ASSERT_EQ(Collector.References.Num(), 3);
|
|
UE_NET_ASSERT_TRUE(Collector.References[0].GetRefHandle() == TestReferences[0]->NetRefHandle);
|
|
UE_NET_ASSERT_TRUE(Collector.References[1].GetRefHandle() == TestReferences[1]->NetRefHandle);
|
|
UE_NET_ASSERT_TRUE(Collector.References[2].GetRefHandle() == TestReferences[2]->NetRefHandle);
|
|
}
|
|
|
|
UE_NET_TEST_FIXTURE(FTestObjectReferencesFixture, TestReferenceVisitor_RefCArray)
|
|
{
|
|
// Setup references
|
|
TestObject->StructWithRefCArray.Ref_CArray[0] = TestReferences[0];
|
|
|
|
// To trigger copy of data
|
|
Server->NetUpdate();
|
|
Server->PostSendUpdate();
|
|
|
|
FReferenceCollector& Collector = CollectOnlyValidCollector;
|
|
|
|
// Collect
|
|
VisitReferences(TestObjectStateBuffer, TestObjectProtocol, Collector);
|
|
|
|
UE_NET_ASSERT_EQ(Collector.References.Num(), 1);
|
|
UE_NET_ASSERT_TRUE(Collector.References[0].GetRefHandle() == TestReferences[0]->NetRefHandle);
|
|
}
|
|
|
|
UE_NET_TEST_FIXTURE(FTestObjectReferencesFixture, TestReferenceVisitor_RefCArrayMulti)
|
|
{
|
|
// Setup references
|
|
TestObject->Ref_CArray[0] = TestReferences[0];
|
|
TestObject->Ref_CArray[1] = TestReferences[1];
|
|
TestObject->Ref_CArray[2] = TestReferences[2];
|
|
|
|
// To trigger copy of data
|
|
Server->NetUpdate();
|
|
Server->PostSendUpdate();
|
|
|
|
FReferenceCollector& Collector = CollectOnlyValidCollector;
|
|
|
|
// Collect
|
|
VisitReferences(TestObjectStateBuffer, TestObjectProtocol, Collector);
|
|
|
|
UE_NET_ASSERT_EQ(Collector.References.Num(), 3);
|
|
UE_NET_ASSERT_TRUE(Collector.References[0].GetRefHandle() == TestReferences[0]->NetRefHandle);
|
|
UE_NET_ASSERT_TRUE(Collector.References[1].GetRefHandle() == TestReferences[1]->NetRefHandle);
|
|
UE_NET_ASSERT_TRUE(Collector.References[2].GetRefHandle() == TestReferences[2]->NetRefHandle);
|
|
}
|
|
|
|
UE_NET_TEST_FIXTURE(FTestObjectReferencesFixture, TestReferenceVisitor_RefTArray)
|
|
{
|
|
// Setup references
|
|
TestObject->Ref_TArray.Push(TestReferences[0]);
|
|
|
|
// To trigger copy of data
|
|
Server->NetUpdate();
|
|
Server->PostSendUpdate();
|
|
|
|
FReferenceCollector& Collector = CollectOnlyValidCollector;
|
|
|
|
// Collect
|
|
VisitReferences(TestObjectStateBuffer, TestObjectProtocol, Collector);
|
|
|
|
UE_NET_ASSERT_EQ(Collector.References.Num(), 1);
|
|
UE_NET_ASSERT_TRUE(Collector.References[0].GetRefHandle() == TestReferences[0]->NetRefHandle);
|
|
}
|
|
|
|
UE_NET_TEST_FIXTURE(FTestObjectReferencesFixture, TestReferenceVisitor_RefTArrayMulti)
|
|
{
|
|
// Setup references
|
|
TestObject->Ref_TArray.Push(TestReferences[0]);
|
|
TestObject->Ref_TArray.Push(TestReferences[1]);
|
|
TestObject->Ref_TArray.Push(TestReferences[2]);
|
|
|
|
// To trigger copy of data
|
|
Server->NetUpdate();
|
|
Server->PostSendUpdate();
|
|
|
|
FReferenceCollector& Collector = CollectOnlyValidCollector;
|
|
|
|
// Collect
|
|
VisitReferences(TestObjectStateBuffer, TestObjectProtocol, Collector);
|
|
|
|
UE_NET_ASSERT_EQ(Collector.References.Num(), 3);
|
|
UE_NET_ASSERT_TRUE(Collector.References[0].GetRefHandle() == TestReferences[0]->NetRefHandle);
|
|
UE_NET_ASSERT_TRUE(Collector.References[1].GetRefHandle() == TestReferences[1]->NetRefHandle);
|
|
UE_NET_ASSERT_TRUE(Collector.References[2].GetRefHandle() == TestReferences[2]->NetRefHandle);
|
|
}
|
|
|
|
UE_NET_TEST_FIXTURE(FTestObjectReferencesFixture, TestReferenceVisitor_StructWithRef_CArray)
|
|
{
|
|
// Setup references
|
|
TestObject->StructWithRef_CArray[0].ObjectRef = TestReferences[0];
|
|
|
|
// To trigger copy of data
|
|
Server->NetUpdate();
|
|
Server->PostSendUpdate();
|
|
|
|
FReferenceCollector& Collector = CollectOnlyValidCollector;
|
|
|
|
// Collect
|
|
VisitReferences(TestObjectStateBuffer, TestObjectProtocol, Collector);
|
|
|
|
UE_NET_ASSERT_EQ(Collector.References.Num(), 1);
|
|
UE_NET_ASSERT_TRUE(Collector.References[0].GetRefHandle() == TestReferences[0]->NetRefHandle);
|
|
}
|
|
|
|
UE_NET_TEST_FIXTURE(FTestObjectReferencesFixture, TestReferenceVisitor_StructWithRef_CArrayMulti)
|
|
{
|
|
// Setup references
|
|
TestObject->StructWithRef_CArray[0].ObjectRef = TestReferences[0];
|
|
TestObject->StructWithRef_CArray[1].ObjectRef = TestReferences[1];
|
|
TestObject->StructWithRef_CArray[2].ObjectRef = TestReferences[2];
|
|
|
|
// To trigger copy of data
|
|
Server->NetUpdate();
|
|
Server->PostSendUpdate();
|
|
|
|
FReferenceCollector& Collector = CollectOnlyValidCollector;
|
|
|
|
// Collect
|
|
VisitReferences(TestObjectStateBuffer, TestObjectProtocol, Collector);
|
|
|
|
UE_NET_ASSERT_EQ(Collector.References.Num(), 3);
|
|
UE_NET_ASSERT_TRUE(Collector.References[0].GetRefHandle() == TestReferences[0]->NetRefHandle);
|
|
UE_NET_ASSERT_TRUE(Collector.References[1].GetRefHandle() == TestReferences[1]->NetRefHandle);
|
|
UE_NET_ASSERT_TRUE(Collector.References[2].GetRefHandle() == TestReferences[2]->NetRefHandle);
|
|
}
|
|
|
|
UE_NET_TEST_FIXTURE(FTestObjectReferencesFixture, TestReferenceVisitor_StructWithRef_TArray)
|
|
{
|
|
// Setup references
|
|
TestObject->StructWithRef_TArray.SetNum(1);
|
|
TestObject->StructWithRef_TArray[0].ObjectRef = TestReferences[0];
|
|
|
|
// To trigger copy of data
|
|
Server->NetUpdate();
|
|
Server->PostSendUpdate();
|
|
|
|
FReferenceCollector& Collector = CollectOnlyValidCollector;
|
|
|
|
// Collect
|
|
VisitReferences(TestObjectStateBuffer, TestObjectProtocol, Collector);
|
|
|
|
UE_NET_ASSERT_EQ(Collector.References.Num(), 1);
|
|
UE_NET_ASSERT_TRUE(Collector.References[0].GetRefHandle() == TestReferences[0]->NetRefHandle);
|
|
}
|
|
|
|
UE_NET_TEST_FIXTURE(FTestObjectReferencesFixture, TestReferenceVisitor_StructWithRef_TArrayMulti)
|
|
{
|
|
// Setup references
|
|
TestObject->StructWithRef_TArray.SetNum(3);
|
|
TestObject->StructWithRef_TArray[0].ObjectRef = TestReferences[0];
|
|
TestObject->StructWithRef_TArray[1].ObjectRef = TestReferences[1];
|
|
TestObject->StructWithRef_TArray[2].ObjectRef = TestReferences[2];
|
|
|
|
// To trigger copy of data
|
|
Server->NetUpdate();
|
|
Server->PostSendUpdate();
|
|
|
|
FReferenceCollector& Collector = CollectOnlyValidCollector;
|
|
|
|
// Collect
|
|
VisitReferences(TestObjectStateBuffer, TestObjectProtocol, Collector);
|
|
|
|
UE_NET_ASSERT_EQ(Collector.References.Num(), 3);
|
|
UE_NET_ASSERT_TRUE(Collector.References[0].GetRefHandle() == TestReferences[0]->NetRefHandle);
|
|
UE_NET_ASSERT_TRUE(Collector.References[1].GetRefHandle() == TestReferences[1]->NetRefHandle);
|
|
UE_NET_ASSERT_TRUE(Collector.References[2].GetRefHandle() == TestReferences[2]->NetRefHandle);
|
|
}
|
|
|
|
UE_NET_TEST_FIXTURE(FTestObjectReferencesFixture, TestStructWithNestedRefCArray_CArray)
|
|
{
|
|
// Setup references
|
|
TestObject->TestStructWithNestedRefCArray_CArray[0].StructWithRef_CArray[0].Ref_CArray[0] = TestReferences[0];
|
|
|
|
// To trigger copy of data
|
|
Server->NetUpdate();
|
|
Server->PostSendUpdate();
|
|
|
|
FReferenceCollector& Collector = CollectOnlyValidCollector;
|
|
|
|
// Collect
|
|
VisitReferences(TestObjectStateBuffer, TestObjectProtocol, Collector);
|
|
|
|
UE_NET_ASSERT_EQ(Collector.References.Num(), 1);
|
|
UE_NET_ASSERT_TRUE(Collector.References[0].GetRefHandle() == TestReferences[0]->NetRefHandle);
|
|
}
|
|
|
|
UE_NET_TEST_FIXTURE(FTestObjectReferencesFixture, TestStructWithNestedRefCArray_CArrayMulti)
|
|
{
|
|
// Setup references
|
|
TestObject->TestStructWithNestedRefCArray_CArray[0].StructWithRef_CArray[0].Ref_CArray[0] = TestReferences[0];
|
|
TestObject->TestStructWithNestedRefCArray_CArray[1].StructWithRef_CArray[0].Ref_CArray[0] = TestReferences[1];
|
|
TestObject->TestStructWithNestedRefCArray_CArray[1].StructWithRef_CArray[1].Ref_CArray[0] = TestReferences[2];
|
|
|
|
// To trigger copy of data
|
|
Server->NetUpdate();
|
|
Server->PostSendUpdate();
|
|
|
|
FReferenceCollector& Collector = CollectOnlyValidCollector;
|
|
|
|
// Collect
|
|
VisitReferences(TestObjectStateBuffer, TestObjectProtocol, Collector);
|
|
|
|
UE_NET_ASSERT_EQ(Collector.References.Num(), 3);
|
|
UE_NET_ASSERT_TRUE(Collector.References[0].GetRefHandle() == TestReferences[0]->NetRefHandle);
|
|
UE_NET_ASSERT_TRUE(Collector.References[1].GetRefHandle() == TestReferences[1]->NetRefHandle);
|
|
UE_NET_ASSERT_TRUE(Collector.References[2].GetRefHandle() == TestReferences[2]->NetRefHandle);
|
|
}
|
|
|
|
UE_NET_TEST_FIXTURE(FTestObjectReferencesFixture, TestStructWithNestedRefTArray_TArray)
|
|
{
|
|
// Setup references
|
|
TestObject->TestStructWithNestedRefTArray_TArray.SetNum(1);
|
|
TestObject->TestStructWithNestedRefTArray_TArray[0].StructWithRef_TArray.SetNum(1);
|
|
TestObject->TestStructWithNestedRefTArray_TArray[0].StructWithRef_TArray[0].Ref_TArray.SetNum(1);
|
|
TestObject->TestStructWithNestedRefTArray_TArray[0].StructWithRef_TArray[0].Ref_TArray[0] = TestReferences[0];
|
|
|
|
// To trigger copy of data
|
|
Server->NetUpdate();
|
|
Server->PostSendUpdate();
|
|
|
|
FReferenceCollector& Collector = CollectOnlyValidCollector;
|
|
|
|
// Collect
|
|
VisitReferences(TestObjectStateBuffer, TestObjectProtocol, Collector);
|
|
|
|
UE_NET_ASSERT_EQ(Collector.References.Num(), 1);
|
|
UE_NET_ASSERT_TRUE(Collector.References[0].GetRefHandle() == TestReferences[0]->NetRefHandle);
|
|
}
|
|
|
|
UE_NET_TEST_FIXTURE(FTestObjectReferencesFixture, TestStructWithNestedRefTArray_TArrayMulti)
|
|
{
|
|
// Setup references
|
|
TestObject->TestStructWithNestedRefTArray_TArray.SetNum(2);
|
|
TestObject->TestStructWithNestedRefTArray_TArray[0].StructWithRef_TArray.SetNum(1);
|
|
TestObject->TestStructWithNestedRefTArray_TArray[0].StructWithRef_TArray[0].Ref_TArray.SetNum(1);
|
|
TestObject->TestStructWithNestedRefTArray_TArray[0].StructWithRef_TArray[0].Ref_TArray[0] = TestReferences[0];
|
|
|
|
TestObject->TestStructWithNestedRefTArray_TArray[1].StructWithRef_TArray.SetNum(2);
|
|
TestObject->TestStructWithNestedRefTArray_TArray[1].StructWithRef_TArray[0].Ref_TArray.SetNum(1);
|
|
TestObject->TestStructWithNestedRefTArray_TArray[1].StructWithRef_TArray[0].Ref_TArray[0] = TestReferences[1];
|
|
TestObject->TestStructWithNestedRefTArray_TArray[1].StructWithRef_TArray[1].Ref_TArray.SetNum(1);
|
|
TestObject->TestStructWithNestedRefTArray_TArray[1].StructWithRef_TArray[1].Ref_TArray[0] = TestReferences[2];
|
|
|
|
// To trigger copy of data
|
|
Server->NetUpdate();
|
|
Server->PostSendUpdate();
|
|
|
|
FReferenceCollector& Collector = CollectOnlyValidCollector;
|
|
|
|
// Collect
|
|
VisitReferences(TestObjectStateBuffer, TestObjectProtocol, Collector);
|
|
|
|
UE_NET_ASSERT_EQ(Collector.References.Num(), 3);
|
|
UE_NET_ASSERT_TRUE(Collector.References[0].GetRefHandle() == TestReferences[0]->NetRefHandle);
|
|
UE_NET_ASSERT_TRUE(Collector.References[1].GetRefHandle() == TestReferences[1]->NetRefHandle);
|
|
UE_NET_ASSERT_TRUE(Collector.References[2].GetRefHandle() == TestReferences[2]->NetRefHandle);
|
|
}
|
|
|
|
UE_NET_TEST_FIXTURE(FTestObjectReferencesFixture, TestStructWithNestedRefTArray_Combo)
|
|
{
|
|
// Setup references
|
|
uint32 CurrentReferenceIndex = 0;
|
|
|
|
TestObject->ObjectRef = TestReferences[CurrentReferenceIndex++];
|
|
|
|
TestObject->StructWithRef.ObjectRef = TestReferences[CurrentReferenceIndex++];
|
|
|
|
TestObject->StructWithRefCArray.Ref_CArray[0] = TestReferences[CurrentReferenceIndex++];
|
|
TestObject->StructWithRefCArray.Ref_CArray[1] = TestReferences[CurrentReferenceIndex++];
|
|
TestObject->StructWithRefCArray.Ref_CArray[2] = TestReferences[CurrentReferenceIndex++];
|
|
|
|
TestObject->StructWithRefTArray.Ref_TArray.Push(TestReferences[CurrentReferenceIndex++]);
|
|
TestObject->StructWithRefTArray.Ref_TArray.Push(TestReferences[CurrentReferenceIndex++]);
|
|
TestObject->StructWithRefTArray.Ref_TArray.Push(TestReferences[CurrentReferenceIndex++]);
|
|
|
|
TestObject->Ref_CArray[0] = TestReferences[CurrentReferenceIndex++];
|
|
TestObject->Ref_CArray[1] = TestReferences[CurrentReferenceIndex++];
|
|
TestObject->Ref_CArray[2] = TestReferences[CurrentReferenceIndex++];
|
|
|
|
TestObject->Ref_TArray.Push(TestReferences[CurrentReferenceIndex++]);
|
|
TestObject->Ref_TArray.Push(TestReferences[CurrentReferenceIndex++]);
|
|
TestObject->Ref_TArray.Push(TestReferences[CurrentReferenceIndex++]);
|
|
|
|
TestObject->StructWithRef_CArray[0].ObjectRef = TestReferences[CurrentReferenceIndex++];
|
|
TestObject->StructWithRef_CArray[1].ObjectRef = TestReferences[CurrentReferenceIndex++];
|
|
TestObject->StructWithRef_CArray[2].ObjectRef = TestReferences[CurrentReferenceIndex++];
|
|
|
|
TestObject->StructWithRef_TArray.SetNum(3);
|
|
TestObject->StructWithRef_TArray[0].ObjectRef = TestReferences[CurrentReferenceIndex++];
|
|
TestObject->StructWithRef_TArray[1].ObjectRef = TestReferences[CurrentReferenceIndex++];
|
|
TestObject->StructWithRef_TArray[2].ObjectRef = TestReferences[CurrentReferenceIndex++];
|
|
|
|
TestObject->TestStructWithNestedRefTArray_TArray.SetNum(2);
|
|
TestObject->TestStructWithNestedRefTArray_TArray[0].StructWithRef_TArray.SetNum(1);
|
|
TestObject->TestStructWithNestedRefTArray_TArray[0].StructWithRef_TArray[0].Ref_TArray.SetNum(1);
|
|
TestObject->TestStructWithNestedRefTArray_TArray[0].StructWithRef_TArray[0].Ref_TArray[0] = TestReferences[CurrentReferenceIndex++];
|
|
|
|
TestObject->TestStructWithNestedRefTArray_TArray[1].StructWithRef_TArray.SetNum(2);
|
|
TestObject->TestStructWithNestedRefTArray_TArray[1].StructWithRef_TArray[0].Ref_TArray.SetNum(1);
|
|
TestObject->TestStructWithNestedRefTArray_TArray[1].StructWithRef_TArray[0].Ref_TArray[0] = TestReferences[CurrentReferenceIndex++];
|
|
TestObject->TestStructWithNestedRefTArray_TArray[1].StructWithRef_TArray[1].Ref_TArray.SetNum(1);
|
|
TestObject->TestStructWithNestedRefTArray_TArray[1].StructWithRef_TArray[1].Ref_TArray[0] = TestReferences[CurrentReferenceIndex++];
|
|
|
|
TestObject->TestStructWithNestedRefCArray_CArray[0].StructWithRef_CArray[0].Ref_CArray[0] = TestReferences[CurrentReferenceIndex++];
|
|
TestObject->TestStructWithNestedRefCArray_CArray[1].StructWithRef_CArray[0].Ref_CArray[0] = TestReferences[CurrentReferenceIndex++];
|
|
TestObject->TestStructWithNestedRefCArray_CArray[1].StructWithRef_CArray[1].Ref_CArray[0] = TestReferences[CurrentReferenceIndex++];
|
|
|
|
// To trigger copy of data
|
|
Server->NetUpdate();
|
|
Server->PostSendUpdate();
|
|
|
|
FReferenceCollector& Collector = CollectOnlyValidCollector;
|
|
|
|
// Collect
|
|
VisitReferences(TestObjectStateBuffer, TestObjectProtocol, Collector);
|
|
|
|
UE_NET_ASSERT_EQ((uint32)Collector.References.Num(), CurrentReferenceIndex);
|
|
for (int32 It = 0; It < Collector.References.Num(); ++It)
|
|
{
|
|
UE_NET_ASSERT_TRUE(Collector.References[It].GetRefHandle() == TestReferences[It]->NetRefHandle);
|
|
}
|
|
}
|
|
|
|
UE_NET_TEST_FIXTURE(FTestObjectReferencesFixture, TestVisitAllDirty)
|
|
{
|
|
// Setup references
|
|
uint32 CurrentReferenceIndex = 0;
|
|
|
|
TestObject->ObjectRef = TestReferences[CurrentReferenceIndex++]; // Init
|
|
|
|
TestObject->StructWithRef.ObjectRef = TestReferences[CurrentReferenceIndex++]; // 0
|
|
|
|
TestObject->StructWithRefCArray.Ref_CArray[0] = TestReferences[CurrentReferenceIndex++]; // 1
|
|
TestObject->StructWithRefCArray.Ref_CArray[1] = TestReferences[CurrentReferenceIndex++]; // 1
|
|
TestObject->StructWithRefCArray.Ref_CArray[2] = TestReferences[CurrentReferenceIndex++]; // 1
|
|
|
|
TestObject->StructWithRefTArray.Ref_TArray.Push(TestReferences[CurrentReferenceIndex++]); // 2
|
|
TestObject->StructWithRefTArray.Ref_TArray.Push(TestReferences[CurrentReferenceIndex++]); // 2
|
|
TestObject->StructWithRefTArray.Ref_TArray.Push(TestReferences[CurrentReferenceIndex++]); // 2
|
|
|
|
TestObject->Ref_CArray[0] = TestReferences[CurrentReferenceIndex++]; // 3
|
|
TestObject->Ref_CArray[1] = TestReferences[CurrentReferenceIndex++]; // 4
|
|
TestObject->Ref_CArray[2] = TestReferences[CurrentReferenceIndex++]; // 5
|
|
|
|
TestObject->Ref_TArray.Push(TestReferences[CurrentReferenceIndex++]); // 6
|
|
TestObject->Ref_TArray.Push(TestReferences[CurrentReferenceIndex++]); // 6
|
|
TestObject->Ref_TArray.Push(TestReferences[CurrentReferenceIndex++]); // 6
|
|
|
|
TestObject->StructWithRef_CArray[0].ObjectRef = TestReferences[CurrentReferenceIndex++]; // 7
|
|
TestObject->StructWithRef_CArray[1].ObjectRef = TestReferences[CurrentReferenceIndex++]; // 8
|
|
TestObject->StructWithRef_CArray[2].ObjectRef = TestReferences[CurrentReferenceIndex++]; // 9
|
|
|
|
TestObject->StructWithRef_TArray.SetNum(3);
|
|
TestObject->StructWithRef_TArray[0].ObjectRef = TestReferences[CurrentReferenceIndex++]; // 10
|
|
TestObject->StructWithRef_TArray[1].ObjectRef = TestReferences[CurrentReferenceIndex++]; // 10
|
|
TestObject->StructWithRef_TArray[2].ObjectRef = TestReferences[CurrentReferenceIndex++]; // 10
|
|
|
|
TestObject->TestStructWithNestedRefTArray_TArray.SetNum(2);
|
|
TestObject->TestStructWithNestedRefTArray_TArray[0].StructWithRef_TArray.SetNum(1);
|
|
TestObject->TestStructWithNestedRefTArray_TArray[0].StructWithRef_TArray[0].Ref_TArray.SetNum(1);
|
|
TestObject->TestStructWithNestedRefTArray_TArray[0].StructWithRef_TArray[0].Ref_TArray[0] = TestReferences[CurrentReferenceIndex++]; // 11
|
|
|
|
TestObject->TestStructWithNestedRefTArray_TArray[1].StructWithRef_TArray.SetNum(2);
|
|
TestObject->TestStructWithNestedRefTArray_TArray[1].StructWithRef_TArray[0].Ref_TArray.SetNum(1);
|
|
TestObject->TestStructWithNestedRefTArray_TArray[1].StructWithRef_TArray[0].Ref_TArray[0] = TestReferences[CurrentReferenceIndex++]; // 11
|
|
TestObject->TestStructWithNestedRefTArray_TArray[1].StructWithRef_TArray[1].Ref_TArray.SetNum(1);
|
|
TestObject->TestStructWithNestedRefTArray_TArray[1].StructWithRef_TArray[1].Ref_TArray[0] = TestReferences[CurrentReferenceIndex++]; // 11
|
|
|
|
TestObject->TestStructWithNestedRefCArray_CArray[0].StructWithRef_CArray[0].Ref_CArray[0] = TestReferences[CurrentReferenceIndex++]; // 12
|
|
TestObject->TestStructWithNestedRefCArray_CArray[1].StructWithRef_CArray[1].Ref_CArray[1] = TestReferences[CurrentReferenceIndex++]; // 13
|
|
TestObject->TestStructWithNestedRefCArray_CArray[2].StructWithRef_CArray[2].Ref_CArray[2] = TestReferences[CurrentReferenceIndex++]; // 14
|
|
|
|
FNetBitArray ChangeMaskStorage(TestObjectProtocol->ChangeMaskBitCount);
|
|
FNetBitArrayView ChangeMask = MakeNetBitArrayView(ChangeMaskStorage);
|
|
|
|
// To trigger copy of data
|
|
Server->NetUpdate();
|
|
Server->PostSendUpdate();
|
|
|
|
// Collect with empty changemask
|
|
{
|
|
FCollectValidReferenceCollector Collector(false, ChangeMask);
|
|
|
|
VisitReferences(TestObjectStateBuffer, TestObjectProtocol, Collector);
|
|
UE_NET_ASSERT_EQ((uint32)Collector.References.Num(), 0U);
|
|
}
|
|
|
|
// Collect init only
|
|
{
|
|
FCollectValidReferenceCollector Collector(true, ChangeMask);
|
|
|
|
VisitReferences(TestObjectStateBuffer, TestObjectProtocol, Collector);
|
|
UE_NET_ASSERT_EQ((uint32)Collector.References.Num(), 1U);
|
|
UE_NET_ASSERT_EQ(Collector.References[0].GetRefHandle(), TestReferences[0]->NetRefHandle);
|
|
}
|
|
|
|
// Partial
|
|
{
|
|
FCollectValidReferenceCollector Collector(false, ChangeMask);
|
|
ChangeMask.ClearAllBits();
|
|
|
|
// Mark member 11 as dirty. This corresponds to TestStructWithNestedRefTArray_TArray.
|
|
SetMemberDirty(ChangeMask, 11);
|
|
|
|
VisitReferences(TestObjectStateBuffer, TestObjectProtocol, Collector);
|
|
|
|
UE_NET_ASSERT_EQ(Collector.References.Num(), 3);
|
|
for (int32 It = 0; It < Collector.References.Num(); ++It)
|
|
{
|
|
UE_NET_ASSERT_EQ(Collector.References[It].GetRefHandle(), TestReferences[It + 20]->NetRefHandle);
|
|
}
|
|
}
|
|
|
|
// Mark dirty
|
|
{
|
|
FCollectValidReferenceCollector Collector(true, ChangeMask);
|
|
ChangeMask.SetAllBits();
|
|
VisitReferences(TestObjectStateBuffer, TestObjectProtocol, Collector);
|
|
|
|
UE_NET_ASSERT_EQ((uint32)Collector.References.Num(), CurrentReferenceIndex);
|
|
for (int32 It = 0; It < Collector.References.Num(); ++It)
|
|
{
|
|
UE_NET_ASSERT_EQ(Collector.References[It].GetRefHandle(), TestReferences[It]->NetRefHandle);
|
|
}
|
|
}
|
|
|
|
// All but no init
|
|
{
|
|
FCollectValidReferenceCollector Collector(false, ChangeMask);
|
|
ChangeMask.SetAllBits();
|
|
VisitReferences(TestObjectStateBuffer, TestObjectProtocol, Collector);
|
|
|
|
UE_NET_ASSERT_EQ((uint32)Collector.References.Num(), CurrentReferenceIndex - 1);
|
|
for (int32 It = 0; It < Collector.References.Num(); ++It)
|
|
{
|
|
UE_NET_ASSERT_EQ(Collector.References[It].GetRefHandle(), TestReferences[It + 1]->NetRefHandle);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Test that reference to inlined subobject works as expected
|
|
UE_NET_TEST_FIXTURE(FReplicationSystemServerClientTestFixture, TestInlinedSubObjectReference)
|
|
{
|
|
// Add a client
|
|
FReplicationSystemTestClient* Client = CreateClient();
|
|
|
|
// Spawn objects on server
|
|
UTestObjectReferences_TestClassWithDefaultSubObject* Object = Server->CreateObject<UTestObjectReferences_TestClassWithDefaultSubObject>();
|
|
|
|
// Verify subobject
|
|
UE_NET_ASSERT_TRUE(Object->CreatedSubObjectRef != nullptr);
|
|
UE_NET_ASSERT_TRUE((Object->CreatedSubObjectRef->HasAnyFlags(RF_DefaultSubObject) || Object->IsDefaultSubobject()));
|
|
|
|
// Replicate object
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Verify that object has been spawned on client
|
|
auto ClientObject = Client->GetObjectAs<UTestObjectReferences_TestClassWithDefaultSubObject>(Object->NetRefHandle);
|
|
|
|
// Verify that default subobject is created
|
|
UE_NET_ASSERT_TRUE(ClientObject->CreatedSubObjectRef != nullptr);
|
|
UE_NET_ASSERT_TRUE((ClientObject->CreatedSubObjectRef->HasAnyFlags(RF_DefaultSubObject) || ClientObject->IsDefaultSubobject()));
|
|
|
|
// Set a reference to subobject
|
|
Object->ObjectRef = Object->CreatedSubObjectRef;
|
|
|
|
// Replicate
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Verify that we could resolve the subobject ref and that we got the expected reference
|
|
UE_NET_ASSERT_TRUE(ClientObject->ObjectRef != nullptr);
|
|
UE_NET_ASSERT_EQ(ClientObject->ObjectRef, ClientObject->CreatedSubObjectRef);
|
|
}
|
|
|
|
// Test that reference to separate subobject works as expected
|
|
UE_NET_TEST_FIXTURE(FReplicationSystemServerClientTestFixture, TestExternalSubObjectReference)
|
|
{
|
|
// Add a client
|
|
FReplicationSystemTestClient* Client = CreateClient();
|
|
|
|
// Spawn objects on server
|
|
UTestObjectReferences_TestClassWithDefaultSubObject* Object = Server->CreateObject<UTestObjectReferences_TestClassWithDefaultSubObject>();
|
|
|
|
// Verify internal subobject
|
|
UE_NET_ASSERT_TRUE(Object->CreatedSubObjectRef != nullptr);
|
|
UE_NET_ASSERT_TRUE((Object->CreatedSubObjectRef->HasAnyFlags(RF_DefaultSubObject) || Object->IsDefaultSubobject()));
|
|
|
|
// Create external subobject
|
|
UTestObjectReferences_TestClassWithDefaultSubObject* ExternalSubObject = Server->CreateSubObject<UTestObjectReferences_TestClassWithDefaultSubObject>(Object->NetRefHandle);
|
|
|
|
// Replicate object
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Verify that object has been spawned on client
|
|
auto ClientObject = Client->GetObjectAs<UTestObjectReferences_TestClassWithDefaultSubObject>(Object->NetRefHandle);
|
|
auto ClientExternalSubObject = Client->GetObjectAs<UTestObjectReferences_TestClassWithDefaultSubObject>(ExternalSubObject->NetRefHandle);
|
|
|
|
// Verify that default subobject is created
|
|
UE_NET_ASSERT_TRUE(ClientObject->CreatedSubObjectRef != nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientExternalSubObject != nullptr);
|
|
UE_NET_ASSERT_TRUE((ClientObject->CreatedSubObjectRef->HasAnyFlags(RF_DefaultSubObject) || ClientObject->IsDefaultSubobject()));
|
|
|
|
// Set a reference to external subobject
|
|
Object->ObjectRef = ExternalSubObject;
|
|
|
|
// Replicate
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Verify that we could resolve the subobject ref and that we got the expected reference
|
|
UE_NET_ASSERT_TRUE(ClientObject->ObjectRef != nullptr);
|
|
UE_NET_ASSERT_EQ(ClientObject->ObjectRef, TObjectPtr<UObject>(ClientExternalSubObject));
|
|
}
|
|
|
|
// Test partial resolve of references in array
|
|
UE_NET_TEST_FIXTURE(FReplicationSystemServerClientTestFixture, TestPartialResolveOfArrayReferences)
|
|
{
|
|
// Add a client
|
|
FReplicationSystemTestClient* Client = CreateClient();
|
|
|
|
// Spawn objects on server
|
|
UTestObjectReferences_TestClassWithReferences* ServerObject = Server->CreateObject<UTestObjectReferences_TestClassWithReferences>();
|
|
|
|
// Spawn objects to reference
|
|
UReplicatedTestObject* ServerReferencedObjectA = Server->CreateObject(0 ,0);
|
|
UReplicatedTestObject* ServerReferencedObjectB = Server->CreateObject(0 ,0);
|
|
UReplicatedTestObject* ServerReferencedObjectC = Server->CreateObject(0 ,0);
|
|
|
|
// Setup references
|
|
ServerObject->Ref_TArray.Add(ServerReferencedObjectA);
|
|
ServerObject->Ref_TArray.Add(ServerReferencedObjectB);
|
|
ServerObject->Ref_TArray.Add(ServerReferencedObjectC);
|
|
|
|
// Make sure that references are not replicated to client
|
|
Server->ReplicationSystem->AddToGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectA->NetRefHandle);
|
|
Server->ReplicationSystem->AddToGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectB->NetRefHandle);
|
|
Server->ReplicationSystem->AddToGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectC->NetRefHandle);
|
|
|
|
// Replicate
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Verify that object has been spawned on client
|
|
auto ClientObject = Client->GetObjectAs<UTestObjectReferences_TestClassWithReferences>(ServerObject->NetRefHandle);
|
|
UE_NET_ASSERT_TRUE(ClientObject != nullptr);
|
|
|
|
// Verify that array has been replicated
|
|
UE_NET_ASSERT_EQ(3, ClientObject->Ref_TArray.Num());
|
|
|
|
// Verify that objects could not be resolved
|
|
UE_NET_ASSERT_TRUE(ClientObject->Ref_TArray[0] == nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientObject->Ref_TArray[1] == nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientObject->Ref_TArray[2] == nullptr);
|
|
|
|
// Enable replication for ServerReferenceObjectA
|
|
Server->ReplicationSystem->RemoveFromGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectA->NetRefHandle);
|
|
|
|
// Replicate
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Verify that we managed to resolve objectA even though we have other unresolved objects in the array
|
|
UE_NET_ASSERT_TRUE(ClientObject->Ref_TArray[0] != nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientObject->Ref_TArray[1] == nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientObject->Ref_TArray[2] == nullptr);
|
|
|
|
// Enable replication for ServerReferenceObjectB
|
|
Server->ReplicationSystem->RemoveFromGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectB->NetRefHandle);
|
|
|
|
// Replicate
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Verify that we managed to resolve objectA even though we have other unresolved objects in the array
|
|
UE_NET_ASSERT_TRUE(ClientObject->Ref_TArray[0] != nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientObject->Ref_TArray[1] != nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientObject->Ref_TArray[2] == nullptr);
|
|
|
|
// Enable replication for ServerReferenceObjectB
|
|
Server->ReplicationSystem->RemoveFromGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectC->NetRefHandle);
|
|
|
|
// Replicate
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Verify that we managed to resolve objectA even though we have other unresolved objects in the array
|
|
UE_NET_ASSERT_TRUE(ClientObject->Ref_TArray[0] != nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientObject->Ref_TArray[1] != nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientObject->Ref_TArray[2] != nullptr);
|
|
}
|
|
|
|
// Test partial out of order resolve of references in fast array
|
|
UE_NET_TEST_FIXTURE(FReplicationSystemServerClientTestFixture, TestOutOfOrderResolveInFastArray)
|
|
{
|
|
// Add a client
|
|
FReplicationSystemTestClient* Client = CreateClient();
|
|
|
|
// Spawn objects on server
|
|
UTestObjectReferences_TestClassWithReferences* ServerObject = Server->CreateObject<UTestObjectReferences_TestClassWithReferences>();
|
|
|
|
// Spawn objects to reference
|
|
UReplicatedTestObject* ServerReferencedObjectA = Server->CreateObject(0 ,0);
|
|
UReplicatedTestObject* ServerReferencedObjectB = Server->CreateObject(0 ,0);
|
|
UReplicatedTestObject* ServerReferencedObjectC = Server->CreateObject(0 ,0);
|
|
|
|
// Setup references
|
|
auto& ServerFastArray = ServerObject->Ref_FastArray;
|
|
|
|
FTestObjectReferences_TestObjectRefFastArrayItem Item;
|
|
Item.ObjectRef = ServerReferencedObjectA;
|
|
ServerFastArray.Items.Add(Item);
|
|
ServerFastArray.MarkItemDirty(ServerFastArray.Items[0]);
|
|
|
|
Item.ObjectRef = ServerReferencedObjectB;
|
|
ServerFastArray.Items.Add(Item);
|
|
ServerFastArray.MarkItemDirty(ServerFastArray.Items[1]);
|
|
|
|
Item.ObjectRef = ServerReferencedObjectC;
|
|
ServerFastArray.Items.Add(Item);
|
|
ServerFastArray.MarkItemDirty(ServerFastArray.Items[2]);
|
|
#if !UE_BUILD_SHIPPING
|
|
UE::Net::IrisDebugHelper::DebugOutputNetObjectState(ServerObject->NetRefHandle.GetId(), ServerObject->NetRefHandle.GetReplicationSystemId());
|
|
#endif
|
|
|
|
// Make sure that references are not replicated to client
|
|
Server->ReplicationSystem->AddToGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectA->NetRefHandle);
|
|
Server->ReplicationSystem->AddToGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectB->NetRefHandle);
|
|
Server->ReplicationSystem->AddToGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectC->NetRefHandle);
|
|
|
|
// Replicate
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Verify that object has been spawned on client
|
|
auto ClientObject = Client->GetObjectAs<UTestObjectReferences_TestClassWithReferences>(ServerObject->NetRefHandle);
|
|
UE_NET_ASSERT_TRUE(ClientObject != nullptr);
|
|
|
|
auto& ClientFastArray = ClientObject->Ref_FastArray;
|
|
|
|
// Verify that array has been replicated
|
|
UE_NET_ASSERT_EQ(3, ClientFastArray.Items.Num());
|
|
|
|
// Verify that objects could not be resolved
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[0].ObjectRef == nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[1].ObjectRef == nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[2].ObjectRef == nullptr);
|
|
|
|
// Enable replication for ServerReferenceObjectA
|
|
Server->ReplicationSystem->RemoveFromGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectA->NetRefHandle);
|
|
|
|
// Replicate
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
#if !UE_BUILD_SHIPPING
|
|
UE::Net::IrisDebugHelper::DebugOutputNetObjectState(ClientObject->NetRefHandle.GetId(), ClientObject->NetRefHandle.GetReplicationSystemId());
|
|
#endif
|
|
|
|
// Verify that we managed to resolve objectA even though we have other unresolved objects in the array
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[0].ObjectRef != nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[1].ObjectRef == nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[2].ObjectRef == nullptr);
|
|
|
|
// Enable replication for ServerReferenceObjectB
|
|
Server->ReplicationSystem->RemoveFromGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectB->NetRefHandle);
|
|
|
|
// Replicate
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Verify that we managed to resolve objectB even though we have other unresolved objects in the array
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[0].ObjectRef != nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[1].ObjectRef != nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[2].ObjectRef == nullptr);
|
|
|
|
// Enable replication for ServerReferenceObjectC
|
|
Server->ReplicationSystem->RemoveFromGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectC->NetRefHandle);
|
|
|
|
// Replicate
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Verify that we managed to resolve all references
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[0].ObjectRef != nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[1].ObjectRef != nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[2].ObjectRef != nullptr);
|
|
}
|
|
|
|
// Test partial out of order resolve of references in fast array
|
|
UE_NET_TEST_FIXTURE(FReplicationSystemServerClientTestFixture, TestOutOfOrderResolveInNativeFastArray)
|
|
{
|
|
// Add a client
|
|
FReplicationSystemTestClient* Client = CreateClient();
|
|
|
|
// Spawn objects on server
|
|
UTestObjectReferences_TestClassWithReferences* ServerObject = Server->CreateObject<UTestObjectReferences_TestClassWithReferences>();
|
|
|
|
// Spawn objects to reference
|
|
UReplicatedTestObject* ServerReferencedObjectA = Server->CreateObject(0 ,0);
|
|
UReplicatedTestObject* ServerReferencedObjectB = Server->CreateObject(0 ,0);
|
|
UReplicatedTestObject* ServerReferencedObjectC = Server->CreateObject(0 ,0);
|
|
|
|
// Setup references
|
|
auto ServerFastArrayEditor = ServerObject->Ref_NativeFastArray.Edit();
|
|
|
|
FTestObjectReferences_TestObjectRefFastArrayItem Item;
|
|
Item.ObjectRef = ServerReferencedObjectA;
|
|
ServerFastArrayEditor.Add(Item);
|
|
|
|
Item.ObjectRef = ServerReferencedObjectB;
|
|
ServerFastArrayEditor.Add(Item);
|
|
|
|
Item.ObjectRef = ServerReferencedObjectC;
|
|
ServerFastArrayEditor.Add(Item);
|
|
|
|
// Make sure that references are not replicated to client
|
|
Server->ReplicationSystem->AddToGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectA->NetRefHandle);
|
|
Server->ReplicationSystem->AddToGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectB->NetRefHandle);
|
|
Server->ReplicationSystem->AddToGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectC->NetRefHandle);
|
|
|
|
// Replicate
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Verify that object has been spawned on client
|
|
auto ClientObject = Client->GetObjectAs<UTestObjectReferences_TestClassWithReferences>(ServerObject->NetRefHandle);
|
|
UE_NET_ASSERT_TRUE(ClientObject != nullptr);
|
|
|
|
auto& ClientFastArray = ClientObject->Ref_NativeFastArray;
|
|
|
|
// Verify that array has been replicated
|
|
UE_NET_ASSERT_EQ(3, ClientFastArray.Items.Num());
|
|
|
|
// Verify that objects could not be resolved
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[0].ObjectRef == nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[1].ObjectRef == nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[2].ObjectRef == nullptr);
|
|
|
|
// Enable replication for ServerReferenceObjectA
|
|
Server->ReplicationSystem->RemoveFromGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectA->NetRefHandle);
|
|
|
|
// Replicate
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Verify that we managed to resolve objectA even though we have other unresolved objects in the array
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[0].ObjectRef != nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[1].ObjectRef == nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[2].ObjectRef == nullptr);
|
|
|
|
// Enable replication for ServerReferenceObjectB
|
|
Server->ReplicationSystem->RemoveFromGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectB->NetRefHandle);
|
|
|
|
// Replicate
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Verify that we managed to resolve objectB even though we have other unresolved objects in the array
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[0].ObjectRef != nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[1].ObjectRef != nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[2].ObjectRef == nullptr);
|
|
|
|
// Enable replication for ServerReferenceObjectC
|
|
Server->ReplicationSystem->RemoveFromGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectC->NetRefHandle);
|
|
|
|
// Replicate
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Verify that we managed to resolve all references
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[0].ObjectRef != nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[1].ObjectRef != nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[2].ObjectRef != nullptr);
|
|
|
|
}
|
|
|
|
// Test partial out of order resolve of references in fast array
|
|
UE_NET_TEST_FIXTURE(FReplicationSystemServerClientTestFixture, TestOutOfOrderResolveOfArrayInNativeFastArray)
|
|
{
|
|
// Add a client
|
|
FReplicationSystemTestClient* Client = CreateClient();
|
|
|
|
// Spawn objects on server
|
|
UTestObjectReferences_TestClassWithReferences* ServerObject = Server->CreateObject<UTestObjectReferences_TestClassWithReferences>();
|
|
|
|
// Spawn objects to reference
|
|
UReplicatedTestObject* ServerReferencedObjectA = Server->CreateObject(0 ,0);
|
|
UReplicatedTestObject* ServerReferencedObjectB = Server->CreateObject(0 ,0);
|
|
UReplicatedTestObject* ServerReferencedObjectC = Server->CreateObject(0 ,0);
|
|
|
|
// Setup references
|
|
auto ServerFastArrayEditor = ServerObject->Ref_NativeFastArray.Edit();
|
|
|
|
FTestObjectReferences_TestObjectRefFastArrayItem Item;
|
|
Item.Ref_TArray.SetNum(1);
|
|
Item.Ref_TArray[0] = ServerReferencedObjectA;
|
|
Item.ObjectRef = nullptr;
|
|
|
|
ServerFastArrayEditor.Add(Item);
|
|
|
|
Item.Ref_TArray[0] = ServerReferencedObjectB;
|
|
ServerFastArrayEditor.Add(Item);
|
|
|
|
Item.Ref_TArray[0] = ServerReferencedObjectC;
|
|
ServerFastArrayEditor.Add(Item);
|
|
|
|
// Make sure that references are not replicated to client
|
|
Server->ReplicationSystem->AddToGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectA->NetRefHandle);
|
|
Server->ReplicationSystem->AddToGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectB->NetRefHandle);
|
|
Server->ReplicationSystem->AddToGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectC->NetRefHandle);
|
|
|
|
// Replicate
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Modify the array
|
|
//Item.Ref_TArray[0] = ServerReferencedObjectC;
|
|
//ServerFastArrayEditor.Add(Item);
|
|
|
|
// Verify that object has been spawned on client
|
|
auto ClientObject = Client->GetObjectAs<UTestObjectReferences_TestClassWithReferences>(ServerObject->NetRefHandle);
|
|
UE_NET_ASSERT_TRUE(ClientObject != nullptr);
|
|
|
|
auto& ClientFastArray = ClientObject->Ref_NativeFastArray;
|
|
|
|
// Verify that array has been replicated
|
|
UE_NET_ASSERT_EQ(3, ClientFastArray.Items.Num());
|
|
|
|
// Verify that objects could not be resolved
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[0].Ref_TArray.Num() == 1);
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[0].Ref_TArray[0] == nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[1].Ref_TArray.Num() == 1);
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[1].Ref_TArray[0] == nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[2].Ref_TArray.Num() == 1);
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[2].Ref_TArray[0] == nullptr);
|
|
|
|
// Enable replication for ServerReferenceObjectA
|
|
Server->ReplicationSystem->RemoveFromGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectA->NetRefHandle);
|
|
|
|
// Replicate
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Verify that we managed to resolve objectA even though we have other unresolved objects in the array
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[0].Ref_TArray[0] != nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[1].Ref_TArray[0] == nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[2].Ref_TArray[0] == nullptr);
|
|
|
|
// Enable replication for ServerReferenceObjectB
|
|
Server->ReplicationSystem->RemoveFromGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectB->NetRefHandle);
|
|
|
|
// Replicate
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Verify that we managed to resolve objectB even though we have other unresolved objects in the array
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[0].Ref_TArray[0] != nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[1].Ref_TArray[0] != nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[2].Ref_TArray[0] == nullptr);
|
|
|
|
// Enable replication for ServerReferenceObjectC
|
|
Server->ReplicationSystem->RemoveFromGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectC->NetRefHandle);
|
|
|
|
// Replicate
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Verify that we managed to resolve all references
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[0].Ref_TArray[0] != nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[1].Ref_TArray[0] != nullptr);
|
|
UE_NET_ASSERT_TRUE(ClientFastArray.Items[2].Ref_TArray[0] != nullptr);
|
|
}
|
|
|
|
// Replicate an object with a reference to another object which is later filtered out and then replicated again.
|
|
UE_NET_TEST_FIXTURE(FReplicationSystemServerClientTestFixture, TestRemovedReferenceIsRemapped)
|
|
{
|
|
// Add a client
|
|
FReplicationSystemTestClient* Client = CreateClient();
|
|
|
|
// Spawn objects on server
|
|
UTestObjectReferences_TestClassWithReferences* ServerObject = Server->CreateObject<UTestObjectReferences_TestClassWithReferences>();
|
|
|
|
// Spawn object to be referenced
|
|
UReplicatedTestObject* ServerReferencedObjectA = Server->CreateObject(0 ,0);
|
|
|
|
// Setup references
|
|
ServerObject->StructWithRef.ObjectRef = ServerReferencedObjectA;
|
|
|
|
// Replicate
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Verify that object has been spawned on client
|
|
auto ClientObject = Client->GetObjectAs<UTestObjectReferences_TestClassWithReferences>(ServerObject->NetRefHandle);
|
|
UE_NET_ASSERT_TRUE(ClientObject != nullptr);
|
|
|
|
// Verify that object can be resolved
|
|
UE_NET_ASSERT_NE(ClientObject->StructWithRef.ObjectRef, TObjectPtr<UObject>(nullptr));
|
|
|
|
// Disable replication for ServerReferenceObjectA
|
|
Server->ReplicationSystem->AddToGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectA->NetRefHandle);
|
|
|
|
// Replicate to make sure object is destroyed on client
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Change the int value to force the reference in the struct to be re-resolved (normally GC would null them out).
|
|
ServerObject->StructWithRef.IntValue ^= 1;
|
|
|
|
// Replicate
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Verify that object can no longer be resolved
|
|
UE_NET_ASSERT_EQ(ClientObject->StructWithRef.ObjectRef, TObjectPtr<UObject>(nullptr));
|
|
|
|
// Enable replication for ServerReferenceObjectA
|
|
Server->ReplicationSystem->RemoveFromGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectA->NetRefHandle);
|
|
|
|
// Replicate
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Client will not send anything, but need object reference tracking update.
|
|
Client->NetUpdate();
|
|
Client->PostSendUpdate();
|
|
|
|
// Verify that we can now resolve the referenced object again
|
|
UE_NET_ASSERT_NE(ClientObject->StructWithRef.ObjectRef, TObjectPtr<UObject>(nullptr));
|
|
}
|
|
|
|
// Replicate an object with a reference to another object, in two different changemasks, which is later filtered out and then replicated again.
|
|
UE_NET_TEST_FIXTURE(FReplicationSystemServerClientTestFixture, TestRemovedReferenceIsRemappedEverywhere)
|
|
{
|
|
// Add a client
|
|
FReplicationSystemTestClient* Client = CreateClient();
|
|
|
|
// Spawn objects on server
|
|
UTestObjectReferences_TestClassWithReferences* ServerObject = Server->CreateObject<UTestObjectReferences_TestClassWithReferences>();
|
|
|
|
// Spawn object to be referenced
|
|
UReplicatedTestObject* ServerReferencedObjectA = Server->CreateObject(0 ,0);
|
|
|
|
// Setup references
|
|
ServerObject->StructWithRef.ObjectRef = ServerReferencedObjectA;
|
|
ServerObject->StructWithRef_CArray[0].ObjectRef = ServerReferencedObjectA;
|
|
|
|
// Replicate
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Client will not send anything, but need object reference tracking update.
|
|
Client->NetUpdate();
|
|
Client->PostSendUpdate();
|
|
|
|
// Verify that object has been spawned on client
|
|
auto ClientObject = Client->GetObjectAs<UTestObjectReferences_TestClassWithReferences>(ServerObject->NetRefHandle);
|
|
UE_NET_ASSERT_TRUE(ClientObject != nullptr);
|
|
|
|
// Verify that object can be resolved
|
|
UE_NET_ASSERT_NE(ClientObject->StructWithRef.ObjectRef, TObjectPtr<UObject>(nullptr));
|
|
UE_NET_ASSERT_NE(ClientObject->StructWithRef_CArray[0].ObjectRef, TObjectPtr<UObject>(nullptr));
|
|
|
|
// Disable replication for ServerReferenceObjectA
|
|
Server->ReplicationSystem->AddToGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectA->NetRefHandle);
|
|
|
|
// Replicate to make sure object is destroyed on client
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Change the int values of the structs to force the object references to be re-resolved (normally GC would null them out).
|
|
ServerObject->StructWithRef.IntValue ^= 1;
|
|
ServerObject->StructWithRef_CArray[0].IntValue ^= 1;
|
|
|
|
// Replicate
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Verify that object can no longer be resolved
|
|
UE_NET_ASSERT_EQ(ClientObject->StructWithRef.ObjectRef, TObjectPtr<UObject>(nullptr));
|
|
UE_NET_ASSERT_EQ(ClientObject->StructWithRef_CArray[0].ObjectRef, TObjectPtr<UObject>(nullptr));
|
|
|
|
// Enable replication for ServerReferenceObjectA
|
|
Server->ReplicationSystem->RemoveFromGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectA->NetRefHandle);
|
|
|
|
// Replicate
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Client will not send anything, but need object reference tracking update.
|
|
Client->NetUpdate();
|
|
Client->PostSendUpdate();
|
|
|
|
// Verify that we can now resolve the referenced object again
|
|
UE_NET_ASSERT_NE(ClientObject->StructWithRef.ObjectRef, TObjectPtr<UObject>(nullptr));
|
|
UE_NET_ASSERT_NE(ClientObject->StructWithRef_CArray[0].ObjectRef, TObjectPtr<UObject>(nullptr));
|
|
}
|
|
|
|
// Replicate an object with references to multiple objects, in a single changemask, which are later filtered out and then replicated again.
|
|
UE_NET_TEST_FIXTURE(FReplicationSystemServerClientTestFixture, TestRemovingReferencesFromArrayRemapsEverywhere)
|
|
{
|
|
// Add a client
|
|
FReplicationSystemTestClient* Client = CreateClient();
|
|
|
|
// Spawn objects on server
|
|
UTestObjectReferences_TestClassWithReferences* ServerObject = Server->CreateObject<UTestObjectReferences_TestClassWithReferences>();
|
|
|
|
// Spawn objects to be referenced
|
|
UReplicatedTestObject* ServerReferencedObjectA = Server->CreateObject(0, 0);
|
|
UReplicatedTestObject* ServerReferencedObjectB = Server->CreateObject(0, 0);
|
|
UReplicatedTestObject* ServerReferencedObjectC = Server->CreateObject(0, 0);
|
|
UReplicatedTestObject* ServerReferencedObjectD = Server->CreateObject(0, 0);
|
|
|
|
// Setup references
|
|
auto& ServerTArray = ServerObject->StructWithRef_TArray;
|
|
|
|
FTestObjectReferences_TestStructWithRef Item;
|
|
|
|
Item.ObjectRef = ServerReferencedObjectA;
|
|
ServerTArray.Add(Item);
|
|
|
|
Item.ObjectRef = ServerReferencedObjectB;
|
|
ServerTArray.Add(Item);
|
|
|
|
Item.ObjectRef = ServerReferencedObjectC;
|
|
ServerTArray.Add(Item);
|
|
|
|
Item.ObjectRef = ServerReferencedObjectD;
|
|
ServerTArray.Add(Item);
|
|
|
|
// Replicate
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Verify that object has been spawned on client
|
|
auto ClientObject = Client->GetObjectAs<UTestObjectReferences_TestClassWithReferences>(ServerObject->NetRefHandle);
|
|
UE_NET_ASSERT_NE(ClientObject, nullptr);
|
|
auto& ClientTArray = ClientObject->StructWithRef_TArray;
|
|
|
|
// Verify that objects can be resolved
|
|
UE_NET_ASSERT_NE(ClientTArray[0].ObjectRef, TObjectPtr<UObject>(nullptr));
|
|
UE_NET_ASSERT_NE(ClientTArray[1].ObjectRef, TObjectPtr<UObject>(nullptr));
|
|
UE_NET_ASSERT_NE(ClientTArray[2].ObjectRef, TObjectPtr<UObject>(nullptr));
|
|
UE_NET_ASSERT_NE(ClientTArray[3].ObjectRef, TObjectPtr<UObject>(nullptr));
|
|
|
|
// Disable replication for ServerReferenceObjectA, B and D.
|
|
Server->ReplicationSystem->AddToGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectA->NetRefHandle);
|
|
Server->ReplicationSystem->AddToGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectB->NetRefHandle);
|
|
Server->ReplicationSystem->AddToGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectD->NetRefHandle);
|
|
|
|
// Replicate to make sure objects are destroyed on client
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Client will not send anything, but need object reference tracking update.
|
|
Client->NetUpdate();
|
|
Client->PostSendUpdate();
|
|
|
|
// Change the int values of the structs to force the object references to be re-resolved (normally GC would null them out).
|
|
ServerTArray[0].IntValue ^= 1;
|
|
ServerTArray[1].IntValue ^= 1;
|
|
ServerTArray[2].IntValue ^= 1;
|
|
ServerTArray[3].IntValue ^= 1;
|
|
|
|
// Replicate
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Client will not send anything, but need object reference tracking update.
|
|
Client->NetUpdate();
|
|
Client->PostSendUpdate();
|
|
|
|
// Verify that objects A, B and D can no longer be resolved, while C still can be resolved.
|
|
UE_NET_ASSERT_EQ(ClientTArray[0].ObjectRef, TObjectPtr<UObject>(nullptr));
|
|
UE_NET_ASSERT_EQ(ClientTArray[1].ObjectRef, TObjectPtr<UObject>(nullptr));
|
|
UE_NET_ASSERT_NE(ClientTArray[2].ObjectRef, TObjectPtr<UObject>(nullptr));
|
|
UE_NET_ASSERT_EQ(ClientTArray[3].ObjectRef, TObjectPtr<UObject>(nullptr));
|
|
|
|
// Enable replication for ServerReferenceObjectA, B and D.
|
|
Server->ReplicationSystem->RemoveFromGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectA->NetRefHandle);
|
|
Server->ReplicationSystem->RemoveFromGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectB->NetRefHandle);
|
|
Server->ReplicationSystem->RemoveFromGroup(Server->GetReplicationSystem()->GetNotReplicatedNetObjectGroup(), ServerReferencedObjectD->NetRefHandle);
|
|
|
|
// Replicate
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Client will not send anything, but need object reference tracking update.
|
|
Client->NetUpdate();
|
|
Client->PostSendUpdate();
|
|
|
|
// Verify that we can now resolve all the referenced objects again
|
|
UE_NET_ASSERT_NE(ClientTArray[0].ObjectRef, TObjectPtr<UObject>(nullptr));
|
|
UE_NET_ASSERT_NE(ClientTArray[1].ObjectRef, TObjectPtr<UObject>(nullptr));
|
|
UE_NET_ASSERT_NE(ClientTArray[2].ObjectRef, TObjectPtr<UObject>(nullptr));
|
|
UE_NET_ASSERT_NE(ClientTArray[3].ObjectRef, TObjectPtr<UObject>(nullptr));
|
|
}
|
|
|
|
// Replicate an object with reference to an object which is later torn off.
|
|
UE_NET_TEST_FIXTURE(FReplicationSystemServerClientTestFixture, TestTearOffDoesInvalidateReference)
|
|
{
|
|
// Add a client
|
|
FReplicationSystemTestClient* Client = CreateClient();
|
|
|
|
// Spawn object on server
|
|
UTestObjectReferences_TestClassWithReferences* ServerObject = Server->CreateObject<UTestObjectReferences_TestClassWithReferences>();
|
|
|
|
// Spawn object to be referenced
|
|
UReplicatedTestObject* ServerReferencedObjectA = Server->CreateObject(0 ,0);
|
|
|
|
// Setup references
|
|
ServerObject->StructWithRef.ObjectRef = ServerReferencedObjectA;
|
|
|
|
// Replicate
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Client will not send anything, but need object reference tracking update.
|
|
Client->NetUpdate();
|
|
Client->PostSendUpdate();
|
|
|
|
// Verify that object has been spawned on client
|
|
auto ClientObject = Client->GetObjectAs<UTestObjectReferences_TestClassWithReferences>(ServerObject->NetRefHandle);
|
|
UE_NET_ASSERT_NE(ClientObject, nullptr);
|
|
|
|
// Verify that object can be resolved
|
|
UE_NET_ASSERT_NE(ClientObject->StructWithRef.ObjectRef, TObjectPtr<UObject>(nullptr));
|
|
|
|
// Tear off ServerReferenceObjectA
|
|
Server->ReplicationBridge->EndReplication(ServerReferencedObjectA, EEndReplicationFlags::TearOff);
|
|
|
|
// Replicate
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Client will not send anything, but need object reference tracking update.
|
|
Client->NetUpdate();
|
|
Client->PostSendUpdate();
|
|
|
|
// Change the int value to force the reference in the struct to be re-resolved
|
|
ServerObject->StructWithRef.IntValue ^= 1;
|
|
|
|
// Replicate
|
|
Server->NetUpdate();
|
|
Server->SendAndDeliverTo(Client, true);
|
|
Server->PostSendUpdate();
|
|
|
|
// Client will not send anything, but need object reference tracking update.
|
|
Client->NetUpdate();
|
|
Client->PostSendUpdate();
|
|
|
|
// Verify that object cannot be resolved
|
|
UE_NET_ASSERT_EQ(ClientObject->StructWithRef.ObjectRef, TObjectPtr<UObject>(nullptr));
|
|
}
|
|
|
|
}
|