izzy/UnrealEngineUWP
0
0
Fork 0
mirror of https://github.com/izzy2lost/UnrealEngineUWP.git synced 2026-03-26 18:15:20 -07:00
Code Issues Packages Projects Releases Wiki Activity
Files
c19d8d88faa4194fb2356076e97cf57358f912f4
UnrealEngineUWP/Engine/Source/Runtime/CoreUObject/Tests/ObjectPtrTest.cpp

1174 lines
51 KiB
C++
Raw Normal View History

Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
// Copyright Epic Games, Inc. All Rights Reserved.
#include "UObject/ObjectPtr.h"
#include "ObjectRefTrackingTestBase.h"
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
#include "ObjectPtrTestClass.h"
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
#include "Concepts/EqualityComparable.h"
#include "Serialization/ArchiveCountMem.h"
#include "Templates/Models.h"
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
#include "UObject/LinkerLoadImportBehavior.h"
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
#include "UObject/Interface.h"
Revision 2 (with handling for uninitialized object references): -Compile in lazy resolve functionality for editor binaries -Add "-LazyResolveAllImports" commandline switch to allow lazy RESOLVE of all wrapped object references -Functionality confirmed: load default map in ShooterGame Editor, cook ShooterGame, load LumenReflectiveTest in FortGPUTestbed, load default map and P_Construct in Frosty -Renamed "-DisableLoadingAllImports" to "-LazyLoadAllImports" commandline switch to allow lazy LOAD of all wrapped object references and ensured it works with AsyncLoading code path -Non functional when combined with lazy resolve - will be worked on afterwards -Added CPU timing scopes to measure performance impact of lazy resolve Fixed lazy resolve bugs: -Ensure null check on an unresolved object reference resolves the object reference (a non-null unresolved reference can become a null resolved reference) -Ensure hash of an unresolved object reference resolves the object reference and hashes the resultant address (otherwise we can't reliably ensure hash consistency in the face of object redirection or stale references) -Avoid using package name hash internally as it immediately manifested in hash collisions on a moderately sized project -Ensure StaticFindObjectFastInternal instead of StaticFindObjectFast to ensure we can find/resolve not fully loaded objects -Ensure UObjectRedirectors are handled when resolving wrapped object pointers -Ensure we handle the possibility that a package has been partially loaded and we may not find our target object within it because the object hasn't been created yet Automated testing: -Adding hash consistency and redirector resolve tests to ObjectPtr unit tests #rb devin.doucette [CL 15571874 by Zousar Shaker in ue5-main branch]
2021-03-02 14:39:53 -04:00
#include "UObject/MetaData.h"
code cleanup of ObjectHandle made ObjectPathId to private trimmed down the public API as much as possible https://p4-swarm.epicgames.net/reviews/23658342 #rb zousar.shaker #preflight 63c5c8922a6acaf1625fcf25 [CL 23734208 by joe pribele in ue5-main branch]
2023-01-16 19:20:47 -05:00
#include "UObject/ObjectPathId.h"
Fix non-unity compile error due to missing include. #jira UE-109855 #rb trivial [CL 15584093 by Zousar Shaker in ue5-main branch]
2021-03-03 12:50:39 -04:00
#include "UObject/ObjectRedirector.h"
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
#include "UObject/Package.h"
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
#include "UObject/SoftObjectPath.h"
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
#include "Misc/ScopeExit.h"
Undo //UE5/Main/Engine/... changelist 23416765 #preflight 638fed855c5308d18c157af0 [CL 23423019 by joe pribele in ue5-main branch]
2022-12-06 20:58:56 -05:00
#include <type_traits>
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #preflight 638fad1b5624e6da5e166024 [CL 23416765 by joe pribele in ue5-main branch]
2022-12-06 16:27:20 -05:00
code cleanup of ObjectHandle made ObjectPathId to private trimmed down the public API as much as possible https://p4-swarm.epicgames.net/reviews/23658342 #rb zousar.shaker #preflight 63c5c8922a6acaf1625fcf25 [CL 23734208 by joe pribele in ue5-main branch]
2023-01-16 19:20:47 -05:00
namespace UE::CoreObject::Private::Tests
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
{
using FMutableObjectPtr = TObjectPtr<UObject>;
using FMutableInterfacePtr = TObjectPtr<UInterface>;
using FMutablePackagePtr = TObjectPtr<UPackage>;
using FConstObjectPtr = TObjectPtr<const UObject>;
using FConstInterfacePtr = TObjectPtr<const UInterface>;
using FConstPackagePtr = TObjectPtr<const UPackage>;
class UForwardDeclaredObjDerived;
class FForwardDeclaredNotObjDerived;
static_assert(sizeof(FObjectPtr) == sizeof(FObjectHandle), "FObjectPtr type must always compile to something equivalent to an FObjectHandle size.");
static_assert(sizeof(FObjectPtr) == sizeof(void*), "FObjectPtr type must always compile to something equivalent to a pointer size.");
static_assert(sizeof(TObjectPtr<UObject>) == sizeof(void*), "TObjectPtr<UObject> type must always compile to something equivalent to a pointer size.");
// Ensure that a TObjectPtr is trivially copyable, (copy/move) constructible, (copy/move) assignable, and destructible
static_assert(std::is_trivially_copyable<FMutableObjectPtr>::value, "TObjectPtr must be trivially copyable");
static_assert(std::is_trivially_copy_constructible<FMutableObjectPtr>::value, "TObjectPtr must be trivially copy constructible");
static_assert(std::is_trivially_move_constructible<FMutableObjectPtr>::value, "TObjectPtr must be trivially move constructible");
static_assert(std::is_trivially_copy_assignable<FMutableObjectPtr>::value, "TObjectPtr must be trivially copy assignable");
static_assert(std::is_trivially_move_assignable<FMutableObjectPtr>::value, "TObjectPtr must be trivially move assignable");
static_assert(std::is_trivially_destructible<FMutableObjectPtr>::value, "TObjectPtr must be trivially destructible");
// Ensure that raw pointers can be used to construct wrapped object pointers and that const-ness isn't stripped when constructing or converting with raw pointers
static_assert(std::is_constructible<FMutableObjectPtr, UObject*>::value, "TObjectPtr<UObject> must be constructible from a raw UObject*");
static_assert(!std::is_constructible<FMutableObjectPtr, const UObject*>::value, "TObjectPtr<UObject> must not be constructible from a const raw UObject*");
static_assert(std::is_convertible<FMutableObjectPtr, UObject*>::value, "TObjectPtr<UObject> must be convertible to a raw UObject*");
static_assert(std::is_convertible<FMutableObjectPtr, const UObject*>::value, "TObjectPtr<UObject> must be convertible to a const raw UObject*");
static_assert(std::is_constructible<FConstObjectPtr, UObject*>::value, "TObjectPtr<const UObject> must be constructible from a raw UObject*");
static_assert(std::is_constructible<FConstObjectPtr, const UObject*>::value, "TObjectPtr<const UObject> must be constructible from a const raw UObject*");
static_assert(!std::is_convertible<FConstObjectPtr, UObject*>::value, "TObjectPtr<const UObject> must not be convertible to a raw UObject*");
static_assert(std::is_convertible<FConstObjectPtr, const UObject*>::value, "TObjectPtr<const UObject> must be convertible to a const raw UObject*");
// Ensure that a TObjectPtr<const UObject> is constructible and assignable from a TObjectPtr<UObject> but not vice versa
static_assert(std::is_constructible<FConstObjectPtr, const FMutableObjectPtr&>::value, "Missing constructor (TObjectPtr<const UObject> from TObjectPtr<UObject>)");
static_assert(!std::is_constructible<FMutableObjectPtr, const FConstObjectPtr&>::value, "Invalid constructor (TObjectPtr<UObject> from TObjectPtr<const UObject>)");
static_assert(std::is_assignable<FConstObjectPtr, const FMutableObjectPtr&>::value, "Missing assignment (TObjectPtr<const UObject> from TObjectPtr<UObject>)");
static_assert(!std::is_assignable<FMutableObjectPtr, const FConstObjectPtr&>::value, "Invalid assignment (TObjectPtr<UObject> from TObjectPtr<const UObject>)");
static_assert(std::is_constructible<FConstObjectPtr, const FConstObjectPtr&>::value, "Missing constructor (TObjectPtr<const UObject> from TObjectPtr<const UObject>)");
static_assert(std::is_assignable<FConstObjectPtr, const FConstObjectPtr&>::value, "Missing assignment (TObjectPtr<const UObject> from TObjectPtr<const UObject>)");
// Ensure that a TObjectPtr<UObject> is constructible and assignable from a TObjectPtr<UInterface> but not vice versa
static_assert(std::is_constructible<FMutableObjectPtr, const FMutableInterfacePtr&>::value, "Missing constructor (TObjectPtr<UObject> from TObjectPtr<UInterface>)");
static_assert(!std::is_constructible<FMutableInterfacePtr, const FMutableObjectPtr&>::value, "Invalid constructor (TObjectPtr<UInterface> from TObjectPtr<UObject>)");
static_assert(std::is_constructible<FConstObjectPtr, const FConstInterfacePtr&>::value, "Missing constructor (TObjectPtr<const UObject> from TObjectPtr<const UInterface>)");
static_assert(std::is_constructible<FConstObjectPtr, const FMutableInterfacePtr&>::value, "Missing constructor (TObjectPtr<const UObject> from TObjectPtr<UInterface>)");
static_assert(!std::is_constructible<FConstInterfacePtr, const FConstObjectPtr&>::value, "Invalid constructor (TObjectPtr<const UInterface> from TObjectPtr<const UObject>)");
static_assert(!std::is_constructible<FConstInterfacePtr, const FMutableObjectPtr&>::value, "Invalid constructor (TObjectPtr<const UInterface> from TObjectPtr<UObject>)");
static_assert(std::is_assignable<FMutableObjectPtr, const FMutableInterfacePtr&>::value, "Missing assignment (TObjectPtr<UObject> from TObjectPtr<UInterface>)");
static_assert(std::is_assignable<FConstObjectPtr, const FMutableInterfacePtr&>::value, "Missing assignment (TObjectPtr<const UObject> from TObjectPtr<UInterface>)");
static_assert(std::is_assignable<FConstObjectPtr, const FConstInterfacePtr&>::value, "Missing assignment (TObjectPtr<const UObject> from TObjectPtr<const UInterface>)");
static_assert(!std::is_assignable<FMutableInterfacePtr, const FMutableObjectPtr&>::value, "Invalid assignment (TObjectPtr<UInterface> from TObjectPtr<UObject>)");
static_assert(!std::is_assignable<FConstInterfacePtr, const FMutableObjectPtr&>::value, "Invalid assignment (TObjectPtr<const UInterface> from TObjectPtr<UObject>)");
static_assert(!std::is_assignable<FConstInterfacePtr, const FConstObjectPtr&>::value, "Invalid assignment (TObjectPtr<const UInterface> from TObjectPtr<const UObject>)");
// Ensure that TObjectPtr<[const] UObject> is comparable with another TObjectPtr<[const] UObject> regardless of constness
Replaced TModels traits class with TModels_V. #rb devin.doucette #preflight 63d3aabf5354589b5cd2343b [CL 23889491 by steve robb in ue5-main branch]
2023-01-27 14:51:16 -05:00
static_assert(TModels_V<CEqualityComparableWith, FConstObjectPtr, FConstObjectPtr>, "Must be able to compare equality and inequality bidirectionally between TObjectPtr<const UObject> and TObjectPtr<const UObject>");
static_assert(TModels_V<CEqualityComparableWith, FMutableObjectPtr, FConstObjectPtr>, "Must be able to compare equality and inequality bidirectionally between TObjectPtr<UObject> and TObjectPtr<const UObject>");
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
// Ensure that TObjectPtr<[const] UObject> is comparable with another TObjectPtr<[const] UInterface> regardless of constness
Replaced TModels traits class with TModels_V. #rb devin.doucette #preflight 63d3aabf5354589b5cd2343b [CL 23889491 by steve robb in ue5-main branch]
2023-01-27 14:51:16 -05:00
static_assert(TModels_V<CEqualityComparableWith, FConstObjectPtr, FConstInterfacePtr>, "Must be able to compare equality and inequality bidirectionally between TObjectPtr<const UObject> and TObjectPtr<const UInterface>");
static_assert(TModels_V<CEqualityComparableWith, FMutableObjectPtr, FConstInterfacePtr>, "Must be able to compare equality and inequality bidirectionally between TObjectPtr<UObject> and TObjectPtr<const UInterface>");
static_assert(TModels_V<CEqualityComparableWith, FConstObjectPtr, FMutableInterfacePtr>, "Must be able to compare equality and inequality bidirectionally between TObjectPtr<const UObject> and TObjectPtr<UInterface>");
static_assert(TModels_V<CEqualityComparableWith, FMutableObjectPtr, FMutableInterfacePtr>, "Must be able to compare equality and inequality bidirectionally between TObjectPtr<UObject> and TObjectPtr<UInterface>");
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
// Ensure that TObjectPtr<[const] UPackage> is not comparable with a TObjectPtr<[const] UInterface> regardless of constness
// TODO: This only ensures that at least one of the A==B,B==A,A!=B,B!=A operations fail, not that they all fail.
Speculative fix for licensee reported compile error on Xbox I'm unable to repro a reported compilation issue on Xbox but CL 14587450 addressed the same issue for Hololens by adding a platform exclusion to these static asserts. I've changed it to exclude all Microsoft platforms rather than be piecemeal. #rb David.Harvey #jira none [CL 15106695 by eric mcdaniel in ue5-main branch]
2021-01-15 11:12:51 -04:00
#if !(PLATFORM_MICROSOFT) || !defined(_MSC_EXTENSIONS) // MSVC static analyzer is run in non-conformance mode, and that causes these checks to fail.
Replaced TModels traits class with TModels_V. #rb devin.doucette #preflight 63d3aabf5354589b5cd2343b [CL 23889491 by steve robb in ue5-main branch]
2023-01-27 14:51:16 -05:00
static_assert(!TModels_V<CEqualityComparableWith, FConstPackagePtr, FConstInterfacePtr>, "Must not be able to compare equality and inequality bidirectionally between TObjectPtr<const UPackage> and TObjectPtr<const UInterface>");
static_assert(!TModels_V<CEqualityComparableWith, FMutablePackagePtr, FConstInterfacePtr>, "Must not be able to compare equality and inequality bidirectionally between TObjectPtr<UPackage> and TObjectPtr<const UInterface>");
static_assert(!TModels_V<CEqualityComparableWith, FConstPackagePtr, FMutableInterfacePtr>, "Must not be able to compare equality and inequality bidirectionally between TObjectPtr<const UPackage> and TObjectPtr<UInterface>");
static_assert(!TModels_V<CEqualityComparableWith, FMutablePackagePtr, FMutableInterfacePtr>, "Must not be able to compare equality and inequality bidirectionally between TObjectPtr<UPackage> and TObjectPtr<UInterface>");
Speculative fix for licensee reported compile error on Xbox I'm unable to repro a reported compilation issue on Xbox but CL 14587450 addressed the same issue for Hololens by adding a platform exclusion to these static asserts. I've changed it to exclude all Microsoft platforms rather than be piecemeal. #rb David.Harvey #jira none [CL 15106695 by eric mcdaniel in ue5-main branch]
2021-01-15 11:12:51 -04:00
#endif // #if !(PLATFORM_MICROSOFT) || !defined(_MSC_EXTENSIONS)
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
// Ensure that TObjectPtr<[const] UObject> is comparable with a raw pointer of the same referenced type regardless of constness
Replaced TModels traits class with TModels_V. #rb devin.doucette #preflight 63d3aabf5354589b5cd2343b [CL 23889491 by steve robb in ue5-main branch]
2023-01-27 14:51:16 -05:00
static_assert(TModels_V<CEqualityComparableWith, FConstObjectPtr, const UObject*>, "Must be able to compare equality and inequality bidirectionally between TObjectPtr<const UObject> and const UObject*");
static_assert(TModels_V<CEqualityComparableWith, FMutableObjectPtr, const UObject*>, "Must be able to compare equality and inequality bidirectionally between TObjectPtr<UObject> and const UObject*");
static_assert(TModels_V<CEqualityComparableWith, FConstObjectPtr, UObject*>, "Must be able to compare equality and inequality bidirectionally between TObjectPtr<const UObject> and UObject*");
static_assert(TModels_V<CEqualityComparableWith, FMutableObjectPtr, UObject*>, "Must be able to compare equality and inequality bidirectionally between TObjectPtr<UObject> and UObject*");
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
// Ensure that TObjectPtr<[const] UObject> is comparable with a UInterface raw pointer regardless of constness
Replaced TModels traits class with TModels_V. #rb devin.doucette #preflight 63d3aabf5354589b5cd2343b [CL 23889491 by steve robb in ue5-main branch]
2023-01-27 14:51:16 -05:00
static_assert(TModels_V<CEqualityComparableWith, FConstObjectPtr, const UInterface*>, "Must be able to compare equality and inequality bidirectionally between TObjectPtr<const UObject> and const UInterface*");
static_assert(TModels_V<CEqualityComparableWith, FMutableObjectPtr, const UInterface*>, "Must be able to compare equality and inequality bidirectionally between TObjectPtr<UObject> and const UInterface*");
static_assert(TModels_V<CEqualityComparableWith, FConstObjectPtr, UInterface*>, "Must be able to compare equality and inequality bidirectionally between TObjectPtr<const UObject> and UInterface*");
static_assert(TModels_V<CEqualityComparableWith, FMutableObjectPtr, UInterface*>, "Must be able to compare equality and inequality bidirectionally between TObjectPtr<UObject> and UInterface*");
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
// Ensure that TObjectPtr<[const] UInterface> is comparable with a UObject raw pointer regardless of constness
Replaced TModels traits class with TModels_V. #rb devin.doucette #preflight 63d3aabf5354589b5cd2343b [CL 23889491 by steve robb in ue5-main branch]
2023-01-27 14:51:16 -05:00
static_assert(TModels_V<CEqualityComparableWith, FConstInterfacePtr, const UObject*>, "Must be able to compare equality and inequality bidirectionally between TObjectPtr<const UInterface> and const UObject*");
static_assert(TModels_V<CEqualityComparableWith, FMutableInterfacePtr, const UObject*>, "Must be able to compare equality and inequality bidirectionally between TObjectPtr<UInterface> and const UObject*");
static_assert(TModels_V<CEqualityComparableWith, FConstInterfacePtr, UObject*>, "Must be able to compare equality and inequality bidirectionally between TObjectPtr<const UInterface> and UObject*");
static_assert(TModels_V<CEqualityComparableWith, FMutableInterfacePtr, UObject*>, "Must be able to compare equality and inequality bidirectionally between TObjectPtr<UInterface> and UObject*");
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
// Ensure that TObjectPtr<[const] UInterface> is not comparable with a UPackage raw pointer regardless of constness
// TODO: This only ensures that at least one of the A==B,B==A,A!=B,B!=A operations fail, not that they all fail.
Replaced TModels traits class with TModels_V. #rb devin.doucette #preflight 63d3aabf5354589b5cd2343b [CL 23889491 by steve robb in ue5-main branch]
2023-01-27 14:51:16 -05:00
static_assert(!TModels_V<CEqualityComparableWith, FConstInterfacePtr, const UPackage*>, "Must not be able to compare equality and inequality bidirectionally between TObjectPtr<const UInterface> and const UPackage*");
static_assert(!TModels_V<CEqualityComparableWith, FMutableInterfacePtr, const UPackage*>, "Must not be able to compare equality and inequality bidirectionally between TObjectPtr<UInterface> and const UPackage*");
static_assert(!TModels_V<CEqualityComparableWith, FConstInterfacePtr, UPackage*>, "Must not be able to compare equality and inequality bidirectionally between TObjectPtr<const UInterface> and UPackage*");
static_assert(!TModels_V<CEqualityComparableWith, FMutableInterfacePtr, UPackage*>, "Must not be able to compare equality and inequality bidirectionally between TObjectPtr<UInterface> and UPackage*");
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
// Ensure that TObjectPtr<[const] UInterface> is not comparable with a char raw pointer regardless of constness
// TODO: This only ensures that at least one of the A==B,B==A,A!=B,B!=A operations fail, not that they all fail.
Replaced TModels traits class with TModels_V. #rb devin.doucette #preflight 63d3aabf5354589b5cd2343b [CL 23889491 by steve robb in ue5-main branch]
2023-01-27 14:51:16 -05:00
static_assert(!TModels_V<CEqualityComparableWith, FConstObjectPtr, const char*>, "Must not be able to compare equality and inequality bidirectionally between TObjectPtr<const UObject> and const UObject*");
static_assert(!TModels_V<CEqualityComparableWith, FMutableObjectPtr, const char*>, "Must not be able to compare equality and inequality bidirectionally between TObjectPtr<UObject> and const UObject*");
static_assert(!TModels_V<CEqualityComparableWith, FConstObjectPtr, char*>, "Must not be able to compare equality and inequality bidirectionally between TObjectPtr<const UObject> and UObject*");
static_assert(!TModels_V<CEqualityComparableWith, FMutableObjectPtr, char*>, "Must not be able to compare equality and inequality bidirectionally between TObjectPtr<UObject> and UObject*");
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
// Ensure that TObjectPtr<[const] UObject> is comparable with nullptr regardless of constness
Replaced TModels traits class with TModels_V. #rb devin.doucette #preflight 63d3aabf5354589b5cd2343b [CL 23889491 by steve robb in ue5-main branch]
2023-01-27 14:51:16 -05:00
static_assert(TModels_V<CEqualityComparableWith, FConstObjectPtr, TYPE_OF_NULLPTR>, "Must be able to compare equality and inequality bidirectionally between TObjectPtr<const UObject> and nullptr");
static_assert(TModels_V<CEqualityComparableWith, FMutableObjectPtr, TYPE_OF_NULLPTR>, "Must be able to compare equality and inequality bidirectionally between TObjectPtr<UObject> and nullptr");
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
Fix compile errors about operator ambiguity when comparing a TObjectPtr and NULL (not nullptr) specifically in MSVC non-conformance mode. The fix introduces an issue where people could now compare TObjectPtr with an arbitrary integer when compiling in non-conformance mode. The alternatives considered: 1) Use safe bool idiom - fails due to ambiguity with implicit cast operator to T* 2) Use constexpr comparison operators with validation that the TYPE_OF_NULL parameter is always zero - can't find a way to accomplish this with function parameters at compile time. The issue arises only when a type has conversion operator to a bool (explicit or implicit), and removal of that operator just leads to other problems where a TObjectPtr must be resolved before it can be checked against null, which is something that I've tried to avoid in anticipation of lazy load. If we end up abandoning the idea of null checking a TObjectPtr without resolving it, we can revisit this code and strip out this workaround. #jira UE-107385 #rb none [CL 15259425 by Zousar Shaker in ue5-main branch]
2021-01-28 23:01:43 -04:00
#if !UE_OBJECT_PTR_NONCONFORMANCE_SUPPORT // Specialized NULL support causes these checks to fail.
Replaced TModels traits class with TModels_V. #rb devin.doucette #preflight 63d3aabf5354589b5cd2343b [CL 23889491 by steve robb in ue5-main branch]
2023-01-27 14:51:16 -05:00
static_assert(!TModels_V<CEqualityComparableWith, FConstObjectPtr, long>, "Should not be able to compare equality and inequality bidirectionally between TObjectPtr<const UObject> and long");
static_assert(!TModels_V<CEqualityComparableWith, FMutableObjectPtr, long>, "Should not be able to compare equality and inequality bidirectionally between TObjectPtr<UObject> and long");
Fix compile errors about operator ambiguity when comparing a TObjectPtr and NULL (not nullptr) specifically in MSVC non-conformance mode. The fix introduces an issue where people could now compare TObjectPtr with an arbitrary integer when compiling in non-conformance mode. The alternatives considered: 1) Use safe bool idiom - fails due to ambiguity with implicit cast operator to T* 2) Use constexpr comparison operators with validation that the TYPE_OF_NULL parameter is always zero - can't find a way to accomplish this with function parameters at compile time. The issue arises only when a type has conversion operator to a bool (explicit or implicit), and removal of that operator just leads to other problems where a TObjectPtr must be resolved before it can be checked against null, which is something that I've tried to avoid in anticipation of lazy load. If we end up abandoning the idea of null checking a TObjectPtr without resolving it, we can revisit this code and strip out this workaround. #jira UE-107385 #rb none [CL 15259425 by Zousar Shaker in ue5-main branch]
2021-01-28 23:01:43 -04:00
#endif // #if !UE_OBJECT_PTR_NONCONFORMANCE_SUPPORT
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
Improve debugability of FObjectPtr/TObjectPtr by supplying a "DebugPtr" member on both that can be used to dereference resolved object references in debugger watch windows. This required changing TObjectPtr to not privately inherit from FObjectPtr, but to instead contain an FObjectPtr. #rb devin.doucette #rb matt.peters [CL 22147494 by zousar shaker in ue5-main branch]
2022-09-22 18:18:37 -04:00
#if WITH_LOW_LEVEL_TESTS
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
// Ensure that the use of incomplete types doesn't provide a means to bypass type safety on TObjectPtr
// NOTE: This is disabled because we're permitting this operation with a deprecation warning.
//static_assert(!std::is_assignable<TObjectPtr<UForwardDeclaredObjDerived>, UForwardDeclaredObjDerived*>::value, "Should not be able to assign raw pointer of incomplete type that descends from UObject to exactly this type of TObjectPtr");
//static_assert(!std::is_assignable<TObjectPtr<FForwardDeclaredNotObjDerived>, FForwardDeclaredNotObjDerived*>::value, "Should not be able to assign raw pointer of incomplete type that does not descend from UObject to exactly this type of TObjectPtr");
class FObjectPtrTestBase : public FObjectRefTrackingTestBase
{
public:
protected:
};
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
#if UE_WITH_OBJECT_HANDLE_LATE_RESOLVE
TEST_CASE("CoreUObject::TObjectPtr::FindLoadBehavior")
{
CHECK(UE::LinkerLoad::FindLoadBehavior(*UObjectPtrTestClass::StaticClass()) == UE::LinkerLoad::EImportBehavior::LazyOnDemand);
CHECK(::UE::LinkerLoad::FindLoadBehavior(*UObjectPtrDerrivedTestClass::StaticClass()) == ::UE::LinkerLoad::EImportBehavior::LazyOnDemand);
CHECK(::UE::LinkerLoad::FindLoadBehavior(*UObjectPtrNotLazyTestClass::StaticClass()) == ::UE::LinkerLoad::EImportBehavior::Eager);
}
#endif
TEST_CASE("CoreUObject::TObjectPtr::Null", "[CoreUObject][ObjectPtr]")
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
{
TObjectPtr<UObject> NullObjectPtr(nullptr);
Add new Unit Tests #rb Chris.Constantinescu #preflight 62458f77292f228e09013681 [CL 19571202 by mark lintott in ue5-main branch]
2022-03-31 07:45:37 -04:00
TEST_TRUE(TEXT("Nullptr should equal a null object pointer"), nullptr == NullObjectPtr);
TEST_TRUE(TEXT("A null object pointer should equal nullptr"), NullObjectPtr == nullptr);
TEST_FALSE(TEXT("A null object pointer should evaluate to false"), !!NullObjectPtr);
TEST_TRUE(TEXT("Negation of a null object pointer should evaluate to true"), !NullObjectPtr);
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
}
code cleanup of ObjectHandle made ObjectPathId to private trimmed down the public API as much as possible https://p4-swarm.epicgames.net/reviews/23658342 #rb zousar.shaker #preflight 63c5c8922a6acaf1625fcf25 [CL 23734208 by joe pribele in ue5-main branch]
2023-01-16 19:20:47 -05:00
#if UE_WITH_OBJECT_HANDLE_LATE_RESOLVE || UE_WITH_OBJECT_HANDLE_TRACKING
Introduce global setup for the LowLevelTests project. Motivation: CoreUObject, taskgraph and threads are global constructs and need to be initialized as such and are expensive to setup/teardown before/after multiple single tests. Introduced --global-setup and --no-global-setup to control execution of global test setup. Unit tests that rely heavily on mocking and are designed to run without any global context should use --no-global-setup Other: Removed CoreTestFixture and applied minor fixes wherever things didn't make sense. One particular CoreUObject test was converted but had always failed to run on non-desktop platforms. It needs to be addressed ASAP. #preflight 625873c7e304a95465fc148e #rb Devin.Doucette, Zousar.Shaker [CL 19769262 by chris constantinescu in ue5-main branch]
2022-04-15 07:21:27 -04:00
TEST_CASE_METHOD(FObjectPtrTestBase, "CoreUObject::TObjectPtr::Default Serialize", "[CoreUObject][ObjectPtr]")
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
{
FSnapshotObjectRefMetrics ObjectRefMetrics(*this);
Introduce global setup for the LowLevelTests project. Motivation: CoreUObject, taskgraph and threads are global constructs and need to be initialized as such and are expensive to setup/teardown before/after multiple single tests. Introduced --global-setup and --no-global-setup to control execution of global test setup. Unit tests that rely heavily on mocking and are designed to run without any global context should use --no-global-setup Other: Removed CoreTestFixture and applied minor fixes wherever things didn't make sense. One particular CoreUObject test was converted but had always failed to run on non-desktop platforms. It needs to be addressed ASAP. #preflight 625873c7e304a95465fc148e #rb Devin.Doucette, Zousar.Shaker [CL 19769262 by chris constantinescu in ue5-main branch]
2022-04-15 07:21:27 -04:00
const FName TestPackageName(TEXT("/Engine/Test/ObjectPtrDefaultSerialize/Transient"));
UPackage* TestPackage = NewObject<UPackage>(nullptr, TestPackageName, RF_Transient);
TestPackage->AddToRoot();
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
UObject* TestSoftObject = NewObject<UObjectPtrTestClass>(TestPackage, TEXT("DefaultSerializeObject"));
Introduce global setup for the LowLevelTests project. Motivation: CoreUObject, taskgraph and threads are global constructs and need to be initialized as such and are expensive to setup/teardown before/after multiple single tests. Introduced --global-setup and --no-global-setup to control execution of global test setup. Unit tests that rely heavily on mocking and are designed to run without any global context should use --no-global-setup Other: Removed CoreTestFixture and applied minor fixes wherever things didn't make sense. One particular CoreUObject test was converted but had always failed to run on non-desktop platforms. It needs to be addressed ASAP. #preflight 625873c7e304a95465fc148e #rb Devin.Doucette, Zousar.Shaker [CL 19769262 by chris constantinescu in ue5-main branch]
2022-04-15 07:21:27 -04:00
code cleanup of ObjectHandle made ObjectPathId to private trimmed down the public API as much as possible https://p4-swarm.epicgames.net/reviews/23658342 #rb zousar.shaker #preflight 63c5c8922a6acaf1625fcf25 [CL 23734208 by joe pribele in ue5-main branch]
2023-01-16 19:20:47 -05:00
#if UE_WITH_OBJECT_HANDLE_LATE_RESOLVE
FObjectPtr DefaultSerializeObjectPtr(MakeUnresolvedHandle(TestSoftObject));
#else
FObjectPtr DefaultSerializeObjectPtr(TestSoftObject);
#endif
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
code cleanup of ObjectHandle made ObjectPathId to private trimmed down the public API as much as possible https://p4-swarm.epicgames.net/reviews/23658342 #rb zousar.shaker #preflight 63c5c8922a6acaf1625fcf25 [CL 23734208 by joe pribele in ue5-main branch]
2023-01-16 19:20:47 -05:00
ObjectRefMetrics.TestNumResolves(TEXT("Unexpected resolve count after initializing an FObjectPtr"), 0);
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
ObjectRefMetrics.TestNumFailedResolves(TEXT("Unexpected resolve failure after initializing an FObjectPtr"), 0);
ObjectRefMetrics.TestNumReads(TEXT("NumReads should not change when initializing an FObjectPtr"), 0);
Avoid resolving wrapped object pointer references when serializing to archive for memory counting purposes. #rb devin.doucette #preflight 60511dc194e6100001bf6338 [CL 15715895 by Zousar Shaker in ue5-main branch]
2021-03-16 17:53:58 -04:00
FArchiveUObject Writer;
Introduce global setup for the LowLevelTests project. Motivation: CoreUObject, taskgraph and threads are global constructs and need to be initialized as such and are expensive to setup/teardown before/after multiple single tests. Introduced --global-setup and --no-global-setup to control execution of global test setup. Unit tests that rely heavily on mocking and are designed to run without any global context should use --no-global-setup Other: Removed CoreTestFixture and applied minor fixes wherever things didn't make sense. One particular CoreUObject test was converted but had always failed to run on non-desktop platforms. It needs to be addressed ASAP. #preflight 625873c7e304a95465fc148e #rb Devin.Doucette, Zousar.Shaker [CL 19769262 by chris constantinescu in ue5-main branch]
2022-04-15 07:21:27 -04:00
Writer << DefaultSerializeObjectPtr;
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
code cleanup of ObjectHandle made ObjectPathId to private trimmed down the public API as much as possible https://p4-swarm.epicgames.net/reviews/23658342 #rb zousar.shaker #preflight 63c5c8922a6acaf1625fcf25 [CL 23734208 by joe pribele in ue5-main branch]
2023-01-16 19:20:47 -05:00
ObjectRefMetrics.TestNumResolves(TEXT("Serializing an FObjectPtr should force it to resolve"), UE_WITH_OBJECT_HANDLE_LATE_RESOLVE ? 1 : 0);
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
ObjectRefMetrics.TestNumFailedResolves(TEXT("Unexpected resolve failure after serializing an FObjectPtr"), 0);
ObjectRefMetrics.TestNumReads(TEXT("NumReads should increase after serializing an FObjectPtr"), 1);
Introduce global setup for the LowLevelTests project. Motivation: CoreUObject, taskgraph and threads are global constructs and need to be initialized as such and are expensive to setup/teardown before/after multiple single tests. Introduced --global-setup and --no-global-setup to control execution of global test setup. Unit tests that rely heavily on mocking and are designed to run without any global context should use --no-global-setup Other: Removed CoreTestFixture and applied minor fixes wherever things didn't make sense. One particular CoreUObject test was converted but had always failed to run on non-desktop platforms. It needs to be addressed ASAP. #preflight 625873c7e304a95465fc148e #rb Devin.Doucette, Zousar.Shaker [CL 19769262 by chris constantinescu in ue5-main branch]
2022-04-15 07:21:27 -04:00
Writer << DefaultSerializeObjectPtr;
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
code cleanup of ObjectHandle made ObjectPathId to private trimmed down the public API as much as possible https://p4-swarm.epicgames.net/reviews/23658342 #rb zousar.shaker #preflight 63c5c8922a6acaf1625fcf25 [CL 23734208 by joe pribele in ue5-main branch]
2023-01-16 19:20:47 -05:00
ObjectRefMetrics.TestNumResolves(TEXT("Serializing an FObjectPtr twice should only require it to resolve once"), UE_WITH_OBJECT_HANDLE_LATE_RESOLVE ? 1 : 0);
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
ObjectRefMetrics.TestNumFailedResolves(TEXT("Unexpected resolve failure after serializing an FObjectPtr"), 0);
ObjectRefMetrics.TestNumReads(TEXT("NumReads should increase after serializing an FObjectPtr"), 2);
Introduce global setup for the LowLevelTests project. Motivation: CoreUObject, taskgraph and threads are global constructs and need to be initialized as such and are expensive to setup/teardown before/after multiple single tests. Introduced --global-setup and --no-global-setup to control execution of global test setup. Unit tests that rely heavily on mocking and are designed to run without any global context should use --no-global-setup Other: Removed CoreTestFixture and applied minor fixes wherever things didn't make sense. One particular CoreUObject test was converted but had always failed to run on non-desktop platforms. It needs to be addressed ASAP. #preflight 625873c7e304a95465fc148e #rb Devin.Doucette, Zousar.Shaker [CL 19769262 by chris constantinescu in ue5-main branch]
2022-04-15 07:21:27 -04:00
TestPackage->RemoveFromRoot();
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
}
code cleanup of ObjectHandle made ObjectPathId to private trimmed down the public API as much as possible https://p4-swarm.epicgames.net/reviews/23658342 #rb zousar.shaker #preflight 63c5c8922a6acaf1625fcf25 [CL 23734208 by joe pribele in ue5-main branch]
2023-01-16 19:20:47 -05:00
#endif
#if UE_WITH_OBJECT_HANDLE_LATE_RESOLVE || UE_WITH_OBJECT_HANDLE_TRACKING
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
CoreUObject test conversion damage control. Correcting tests commited in CL 19498448 that were converted and tagged [Smoke] but weren't marked with EAUtomationTestFlags::SmokeFilter in the original source. EditorBulkDataTests was left unconverted, moved back to original Private/Tests/Serialization folder ObjectPtrTest -> CoreUObject::TObjectPtr::Soft Object Path fails at line 197 on non-desktop platforms but it didn't failed before the conversion. #preflight 624eee0a2c01f9c6da9446e0 #rb Devin.Doucette [CL 19668909 by chris constantinescu in ue5-main branch]
2022-04-07 10:34:55 -04:00
TEST_CASE_METHOD(FObjectPtrTestBase, "CoreUObject::TObjectPtr::Soft Object Path", "[CoreUObject][ObjectPtr]")
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
{
FSnapshotObjectRefMetrics ObjectRefMetrics(*this);
Introduce global setup for the LowLevelTests project. Motivation: CoreUObject, taskgraph and threads are global constructs and need to be initialized as such and are expensive to setup/teardown before/after multiple single tests. Introduced --global-setup and --no-global-setup to control execution of global test setup. Unit tests that rely heavily on mocking and are designed to run without any global context should use --no-global-setup Other: Removed CoreTestFixture and applied minor fixes wherever things didn't make sense. One particular CoreUObject test was converted but had always failed to run on non-desktop platforms. It needs to be addressed ASAP. #preflight 625873c7e304a95465fc148e #rb Devin.Doucette, Zousar.Shaker [CL 19769262 by chris constantinescu in ue5-main branch]
2022-04-15 07:21:27 -04:00
const FName TestPackageName(TEXT("/Engine/Test/ObjectPtrSoftObjectPath/Transient"));
UPackage* TestPackage = NewObject<UPackage>(nullptr, TestPackageName, RF_Transient);
TestPackage->AddToRoot();
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
UObject* TestSoftObject = NewObject<UObjectPtrTestClass>(TestPackage, TEXT("TestSoftObject"));
Introduce global setup for the LowLevelTests project. Motivation: CoreUObject, taskgraph and threads are global constructs and need to be initialized as such and are expensive to setup/teardown before/after multiple single tests. Introduced --global-setup and --no-global-setup to control execution of global test setup. Unit tests that rely heavily on mocking and are designed to run without any global context should use --no-global-setup Other: Removed CoreTestFixture and applied minor fixes wherever things didn't make sense. One particular CoreUObject test was converted but had always failed to run on non-desktop platforms. It needs to be addressed ASAP. #preflight 625873c7e304a95465fc148e #rb Devin.Doucette, Zousar.Shaker [CL 19769262 by chris constantinescu in ue5-main branch]
2022-04-15 07:21:27 -04:00
code cleanup of ObjectHandle made ObjectPathId to private trimmed down the public API as much as possible https://p4-swarm.epicgames.net/reviews/23658342 #rb zousar.shaker #preflight 63c5c8922a6acaf1625fcf25 [CL 23734208 by joe pribele in ue5-main branch]
2023-01-16 19:20:47 -05:00
#if UE_WITH_OBJECT_HANDLE_LATE_RESOLVE
FObjectPtr DefaultSoftObjPtr(MakeUnresolvedHandle(TestSoftObject));
#else
FObjectPtr DefaultSoftObjPtr(TestSoftObject);
#endif
ObjectRefMetrics.TestNumResolves(TEXT("Unexpected resolve count after initializing an FObjectPtr"), 0);
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
ObjectRefMetrics.TestNumFailedResolves(TEXT("Unexpected resolve failure after initializing an FObjectPtr"), 0);
ObjectRefMetrics.TestNumReads(TEXT("NumReads should not change when initializing an FObjectPtr"), 0);
Edits changed where the variable was accessible, adjusting that. [CL 22064674 by nick darnell in ue5-main branch]
2022-09-16 21:00:59 -04:00
// Initializing a soft object path from a TObjectPtr that's unresolved should stay unresolved.
FSoftObjectPath DefaultSoftObjPath(DefaultSoftObjPtr);
ObjectRefMetrics.TestNumResolves(TEXT("Unexpected resolve count after initializing an FSoftObjectPath from an FObjectPtr"), 0);
code cleanup of ObjectHandle made ObjectPathId to private trimmed down the public API as much as possible https://p4-swarm.epicgames.net/reviews/23658342 #rb zousar.shaker #preflight 63c5c8922a6acaf1625fcf25 [CL 23734208 by joe pribele in ue5-main branch]
2023-01-16 19:20:47 -05:00
ObjectRefMetrics.TestNumReads(TEXT("NumReads should have changed when initializing a FSoftObjectPath"), UE_WITH_OBJECT_HANDLE_LATE_RESOLVE ? 0 : 1);
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
Introduce global setup for the LowLevelTests project. Motivation: CoreUObject, taskgraph and threads are global constructs and need to be initialized as such and are expensive to setup/teardown before/after multiple single tests. Introduced --global-setup and --no-global-setup to control execution of global test setup. Unit tests that rely heavily on mocking and are designed to run without any global context should use --no-global-setup Other: Removed CoreTestFixture and applied minor fixes wherever things didn't make sense. One particular CoreUObject test was converted but had always failed to run on non-desktop platforms. It needs to be addressed ASAP. #preflight 625873c7e304a95465fc148e #rb Devin.Doucette, Zousar.Shaker [CL 19769262 by chris constantinescu in ue5-main branch]
2022-04-15 07:21:27 -04:00
TEST_EQUAL_STR(TEXT("Soft object path constructed from an FObjectPtr does not have the expected path value"), TEXT("/Engine/Test/ObjectPtrSoftObjectPath/Transient.TestSoftObject"), *DefaultSoftObjPath.ToString());
TestPackage->RemoveFromRoot();
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
}
code cleanup of ObjectHandle made ObjectPathId to private trimmed down the public API as much as possible https://p4-swarm.epicgames.net/reviews/23658342 #rb zousar.shaker #preflight 63c5c8922a6acaf1625fcf25 [CL 23734208 by joe pribele in ue5-main branch]
2023-01-16 19:20:47 -05:00
#endif
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
CoreUObject test conversion damage control. Correcting tests commited in CL 19498448 that were converted and tagged [Smoke] but weren't marked with EAUtomationTestFlags::SmokeFilter in the original source. EditorBulkDataTests was left unconverted, moved back to original Private/Tests/Serialization folder ObjectPtrTest -> CoreUObject::TObjectPtr::Soft Object Path fails at line 197 on non-desktop platforms but it didn't failed before the conversion. #preflight 624eee0a2c01f9c6da9446e0 #rb Devin.Doucette [CL 19668909 by chris constantinescu in ue5-main branch]
2022-04-07 10:34:55 -04:00
TEST_CASE_METHOD(FObjectPtrTestBase, "CoreUObject::TObjectPtr::Forward Declared", "[CoreUObject][ObjectPtr]")
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
{
UForwardDeclaredObjDerived* PtrFwd = nullptr;
TObjectPtr<UForwardDeclaredObjDerived> ObjPtrFwd(MakeObjectPtrUnsafe<UForwardDeclaredObjDerived>(reinterpret_cast<UObject*>(PtrFwd)));
removed usage of TObjectPtr.IsNull and IsNullNoResolve #rb zousar.shaker #p4v-preflight-copy 22193787 [CL 22361481 by joe pribele in ue5-main branch]
2022-10-05 15:34:23 -04:00
TEST_TRUE(TEXT("Null forward declared pointer used to construct a TObjectPtr should result in a null TObjectPtr"), !ObjPtrFwd);
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
}
code cleanup of ObjectHandle made ObjectPathId to private trimmed down the public API as much as possible https://p4-swarm.epicgames.net/reviews/23658342 #rb zousar.shaker #preflight 63c5c8922a6acaf1625fcf25 [CL 23734208 by joe pribele in ue5-main branch]
2023-01-16 19:20:47 -05:00
#if UE_WITH_OBJECT_HANDLE_LATE_RESOLVE
CoreUObject test conversion damage control. Correcting tests commited in CL 19498448 that were converted and tagged [Smoke] but weren't marked with EAUtomationTestFlags::SmokeFilter in the original source. EditorBulkDataTests was left unconverted, moved back to original Private/Tests/Serialization folder ObjectPtrTest -> CoreUObject::TObjectPtr::Soft Object Path fails at line 197 on non-desktop platforms but it didn't failed before the conversion. #preflight 624eee0a2c01f9c6da9446e0 #rb Devin.Doucette [CL 19668909 by chris constantinescu in ue5-main branch]
2022-04-07 10:34:55 -04:00
TEST_CASE_METHOD(FObjectPtrTestBase, "CoreUObject::TObjectPtr::Hash Consistency", "[CoreUObject][ObjectPtr]")
Revision 2 (with handling for uninitialized object references): -Compile in lazy resolve functionality for editor binaries -Add "-LazyResolveAllImports" commandline switch to allow lazy RESOLVE of all wrapped object references -Functionality confirmed: load default map in ShooterGame Editor, cook ShooterGame, load LumenReflectiveTest in FortGPUTestbed, load default map and P_Construct in Frosty -Renamed "-DisableLoadingAllImports" to "-LazyLoadAllImports" commandline switch to allow lazy LOAD of all wrapped object references and ensured it works with AsyncLoading code path -Non functional when combined with lazy resolve - will be worked on afterwards -Added CPU timing scopes to measure performance impact of lazy resolve Fixed lazy resolve bugs: -Ensure null check on an unresolved object reference resolves the object reference (a non-null unresolved reference can become a null resolved reference) -Ensure hash of an unresolved object reference resolves the object reference and hashes the resultant address (otherwise we can't reliably ensure hash consistency in the face of object redirection or stale references) -Avoid using package name hash internally as it immediately manifested in hash collisions on a moderately sized project -Ensure StaticFindObjectFastInternal instead of StaticFindObjectFast to ensure we can find/resolve not fully loaded objects -Ensure UObjectRedirectors are handled when resolving wrapped object pointers -Ensure we handle the possibility that a package has been partially loaded and we may not find our target object within it because the object hasn't been created yet Automated testing: -Adding hash consistency and redirector resolve tests to ObjectPtr unit tests #rb devin.doucette [CL 15571874 by Zousar Shaker in ue5-main branch]
2021-03-02 14:39:53 -04:00
{
const FName TestPackage1Name(TEXT("/Engine/Test/ObjectPtrHashConsistency1/Transient"));
UPackage* TestPackage1 = NewObject<UPackage>(nullptr, TestPackage1Name, RF_Transient);
TestPackage1->AddToRoot();
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
UObject* TestOuter1 = NewObject<UObjectPtrTestClass>(TestPackage1, TEXT("TestOuter1"));
UObject* TestOuter2 = NewObject<UObjectPtrTestClass>(TestPackage1, TEXT("TestOuter2"));
UObject* TestOuter3 = NewObject<UObjectPtrTestClass>(TestPackage1, TEXT("TestOuter3"));
UObject* TestOuter4 = NewObject<UObjectPtrTestClass>(TestPackage1, TEXT("TestOuter4"));
Revision 2 (with handling for uninitialized object references): -Compile in lazy resolve functionality for editor binaries -Add "-LazyResolveAllImports" commandline switch to allow lazy RESOLVE of all wrapped object references -Functionality confirmed: load default map in ShooterGame Editor, cook ShooterGame, load LumenReflectiveTest in FortGPUTestbed, load default map and P_Construct in Frosty -Renamed "-DisableLoadingAllImports" to "-LazyLoadAllImports" commandline switch to allow lazy LOAD of all wrapped object references and ensured it works with AsyncLoading code path -Non functional when combined with lazy resolve - will be worked on afterwards -Added CPU timing scopes to measure performance impact of lazy resolve Fixed lazy resolve bugs: -Ensure null check on an unresolved object reference resolves the object reference (a non-null unresolved reference can become a null resolved reference) -Ensure hash of an unresolved object reference resolves the object reference and hashes the resultant address (otherwise we can't reliably ensure hash consistency in the face of object redirection or stale references) -Avoid using package name hash internally as it immediately manifested in hash collisions on a moderately sized project -Ensure StaticFindObjectFastInternal instead of StaticFindObjectFast to ensure we can find/resolve not fully loaded objects -Ensure UObjectRedirectors are handled when resolving wrapped object pointers -Ensure we handle the possibility that a package has been partially loaded and we may not find our target object within it because the object hasn't been created yet Automated testing: -Adding hash consistency and redirector resolve tests to ObjectPtr unit tests #rb devin.doucette [CL 15571874 by Zousar Shaker in ue5-main branch]
2021-03-02 14:39:53 -04:00
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
UObject* TestPublicObject = NewObject<UObjectPtrTestClass>(TestOuter1, TEXT("TestPublicObject"), RF_Public);
code cleanup of ObjectHandle made ObjectPathId to private trimmed down the public API as much as possible https://p4-swarm.epicgames.net/reviews/23658342 #rb zousar.shaker #preflight 63c5c8922a6acaf1625fcf25 [CL 23734208 by joe pribele in ue5-main branch]
2023-01-16 19:20:47 -05:00
UE::CoreUObject::Private::MakePackedObjectRef(TestPublicObject); //construct a packed object ref the exported object. replicates linker load
Revision 2 (with handling for uninitialized object references): -Compile in lazy resolve functionality for editor binaries -Add "-LazyResolveAllImports" commandline switch to allow lazy RESOLVE of all wrapped object references -Functionality confirmed: load default map in ShooterGame Editor, cook ShooterGame, load LumenReflectiveTest in FortGPUTestbed, load default map and P_Construct in Frosty -Renamed "-DisableLoadingAllImports" to "-LazyLoadAllImports" commandline switch to allow lazy LOAD of all wrapped object references and ensured it works with AsyncLoading code path -Non functional when combined with lazy resolve - will be worked on afterwards -Added CPU timing scopes to measure performance impact of lazy resolve Fixed lazy resolve bugs: -Ensure null check on an unresolved object reference resolves the object reference (a non-null unresolved reference can become a null resolved reference) -Ensure hash of an unresolved object reference resolves the object reference and hashes the resultant address (otherwise we can't reliably ensure hash consistency in the face of object redirection or stale references) -Avoid using package name hash internally as it immediately manifested in hash collisions on a moderately sized project -Ensure StaticFindObjectFastInternal instead of StaticFindObjectFast to ensure we can find/resolve not fully loaded objects -Ensure UObjectRedirectors are handled when resolving wrapped object pointers -Ensure we handle the possibility that a package has been partially loaded and we may not find our target object within it because the object hasn't been created yet Automated testing: -Adding hash consistency and redirector resolve tests to ObjectPtr unit tests #rb devin.doucette [CL 15571874 by Zousar Shaker in ue5-main branch]
2021-03-02 14:39:53 -04:00
// Perform hash consistency checks on public object reference
{
// Check that unresolved/resolved pointers produce the same hash
FSnapshotObjectRefMetrics ObjectRefMetrics(*this);
code cleanup of ObjectHandle made ObjectPathId to private trimmed down the public API as much as possible https://p4-swarm.epicgames.net/reviews/23658342 #rb zousar.shaker #preflight 63c5c8922a6acaf1625fcf25 [CL 23734208 by joe pribele in ue5-main branch]
2023-01-16 19:20:47 -05:00
#if UE_WITH_OBJECT_HANDLE_LATE_RESOLVE
FObjectPtr TestPublicWrappedObjectPtr(MakeUnresolvedHandle(TestPublicObject));
#else
FObjectPtr TestPublicWrappedObjectPtr(TestPublicObject);
#endif
ObjectRefMetrics.TestNumResolves(TEXT("Unexpected resolve count after initializing an FObjectPtr"), 0);
Revision 2 (with handling for uninitialized object references): -Compile in lazy resolve functionality for editor binaries -Add "-LazyResolveAllImports" commandline switch to allow lazy RESOLVE of all wrapped object references -Functionality confirmed: load default map in ShooterGame Editor, cook ShooterGame, load LumenReflectiveTest in FortGPUTestbed, load default map and P_Construct in Frosty -Renamed "-DisableLoadingAllImports" to "-LazyLoadAllImports" commandline switch to allow lazy LOAD of all wrapped object references and ensured it works with AsyncLoading code path -Non functional when combined with lazy resolve - will be worked on afterwards -Added CPU timing scopes to measure performance impact of lazy resolve Fixed lazy resolve bugs: -Ensure null check on an unresolved object reference resolves the object reference (a non-null unresolved reference can become a null resolved reference) -Ensure hash of an unresolved object reference resolves the object reference and hashes the resultant address (otherwise we can't reliably ensure hash consistency in the face of object redirection or stale references) -Avoid using package name hash internally as it immediately manifested in hash collisions on a moderately sized project -Ensure StaticFindObjectFastInternal instead of StaticFindObjectFast to ensure we can find/resolve not fully loaded objects -Ensure UObjectRedirectors are handled when resolving wrapped object pointers -Ensure we handle the possibility that a package has been partially loaded and we may not find our target object within it because the object hasn't been created yet Automated testing: -Adding hash consistency and redirector resolve tests to ObjectPtr unit tests #rb devin.doucette [CL 15571874 by Zousar Shaker in ue5-main branch]
2021-03-02 14:39:53 -04:00
ObjectRefMetrics.TestNumFailedResolves(TEXT("Unexpected resolve failure after initializing an FObjectPtr"), 0);
uint32 HashWrapped = GetTypeHash(TestPublicWrappedObjectPtr);
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
ObjectRefMetrics.TestNumResolves(TEXT("Unexpected resolve count after hashing an FObjectPtr"), 0);
Revision 2 (with handling for uninitialized object references): -Compile in lazy resolve functionality for editor binaries -Add "-LazyResolveAllImports" commandline switch to allow lazy RESOLVE of all wrapped object references -Functionality confirmed: load default map in ShooterGame Editor, cook ShooterGame, load LumenReflectiveTest in FortGPUTestbed, load default map and P_Construct in Frosty -Renamed "-DisableLoadingAllImports" to "-LazyLoadAllImports" commandline switch to allow lazy LOAD of all wrapped object references and ensured it works with AsyncLoading code path -Non functional when combined with lazy resolve - will be worked on afterwards -Added CPU timing scopes to measure performance impact of lazy resolve Fixed lazy resolve bugs: -Ensure null check on an unresolved object reference resolves the object reference (a non-null unresolved reference can become a null resolved reference) -Ensure hash of an unresolved object reference resolves the object reference and hashes the resultant address (otherwise we can't reliably ensure hash consistency in the face of object redirection or stale references) -Avoid using package name hash internally as it immediately manifested in hash collisions on a moderately sized project -Ensure StaticFindObjectFastInternal instead of StaticFindObjectFast to ensure we can find/resolve not fully loaded objects -Ensure UObjectRedirectors are handled when resolving wrapped object pointers -Ensure we handle the possibility that a package has been partially loaded and we may not find our target object within it because the object hasn't been created yet Automated testing: -Adding hash consistency and redirector resolve tests to ObjectPtr unit tests #rb devin.doucette [CL 15571874 by Zousar Shaker in ue5-main branch]
2021-03-02 14:39:53 -04:00
ObjectRefMetrics.TestNumFailedResolves(TEXT("Unexpected resolve failure after hashing an FObjectPtr"), 0);
TestPublicWrappedObjectPtr.Get();
ObjectRefMetrics.TestNumResolves(TEXT("Unexpected resolve count after resolving an FObjectPtr"), 1);
ObjectRefMetrics.TestNumFailedResolves(TEXT("Unexpected resolve failure after resolving an FObjectPtr"), 0);
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
TObjectPtr<UObject> ObjectPtr = TestPublicObject;
uint32 ObjectPtrHash = GetTypeHash(ObjectPtr);
TEST_EQUAL(TEXT("Hash of FObjectPtr should equal hash of TObjectPtr"), ObjectPtrHash, HashWrapped);
Revision 2 (with handling for uninitialized object references): -Compile in lazy resolve functionality for editor binaries -Add "-LazyResolveAllImports" commandline switch to allow lazy RESOLVE of all wrapped object references -Functionality confirmed: load default map in ShooterGame Editor, cook ShooterGame, load LumenReflectiveTest in FortGPUTestbed, load default map and P_Construct in Frosty -Renamed "-DisableLoadingAllImports" to "-LazyLoadAllImports" commandline switch to allow lazy LOAD of all wrapped object references and ensured it works with AsyncLoading code path -Non functional when combined with lazy resolve - will be worked on afterwards -Added CPU timing scopes to measure performance impact of lazy resolve Fixed lazy resolve bugs: -Ensure null check on an unresolved object reference resolves the object reference (a non-null unresolved reference can become a null resolved reference) -Ensure hash of an unresolved object reference resolves the object reference and hashes the resultant address (otherwise we can't reliably ensure hash consistency in the face of object redirection or stale references) -Avoid using package name hash internally as it immediately manifested in hash collisions on a moderately sized project -Ensure StaticFindObjectFastInternal instead of StaticFindObjectFast to ensure we can find/resolve not fully loaded objects -Ensure UObjectRedirectors are handled when resolving wrapped object pointers -Ensure we handle the possibility that a package has been partially loaded and we may not find our target object within it because the object hasn't been created yet Automated testing: -Adding hash consistency and redirector resolve tests to ObjectPtr unit tests #rb devin.doucette [CL 15571874 by Zousar Shaker in ue5-main branch]
2021-03-02 14:39:53 -04:00
//Check that renaming an object doesn't change its hash
TestPublicObject->Rename(TEXT("TestPublicObjectRenamed"));
uint32 HashWrappedAfterRename = GetTypeHash(TestPublicWrappedObjectPtr);
Add new Unit Tests #rb Chris.Constantinescu #preflight 62458f77292f228e09013681 [CL 19571202 by mark lintott in ue5-main branch]
2022-03-31 07:45:37 -04:00
TEST_EQUAL(TEXT("Hash of resolved public FObjectPtr before rename should equal hash of resolved public FObjectPtr after rename"), HashWrappedAfterRename, HashWrapped);
Revision 2 (with handling for uninitialized object references): -Compile in lazy resolve functionality for editor binaries -Add "-LazyResolveAllImports" commandline switch to allow lazy RESOLVE of all wrapped object references -Functionality confirmed: load default map in ShooterGame Editor, cook ShooterGame, load LumenReflectiveTest in FortGPUTestbed, load default map and P_Construct in Frosty -Renamed "-DisableLoadingAllImports" to "-LazyLoadAllImports" commandline switch to allow lazy LOAD of all wrapped object references and ensured it works with AsyncLoading code path -Non functional when combined with lazy resolve - will be worked on afterwards -Added CPU timing scopes to measure performance impact of lazy resolve Fixed lazy resolve bugs: -Ensure null check on an unresolved object reference resolves the object reference (a non-null unresolved reference can become a null resolved reference) -Ensure hash of an unresolved object reference resolves the object reference and hashes the resultant address (otherwise we can't reliably ensure hash consistency in the face of object redirection or stale references) -Avoid using package name hash internally as it immediately manifested in hash collisions on a moderately sized project -Ensure StaticFindObjectFastInternal instead of StaticFindObjectFast to ensure we can find/resolve not fully loaded objects -Ensure UObjectRedirectors are handled when resolving wrapped object pointers -Ensure we handle the possibility that a package has been partially loaded and we may not find our target object within it because the object hasn't been created yet Automated testing: -Adding hash consistency and redirector resolve tests to ObjectPtr unit tests #rb devin.doucette [CL 15571874 by Zousar Shaker in ue5-main branch]
2021-03-02 14:39:53 -04:00
//Check that reparenting an object doesn't change its hash
TestPublicObject->Rename(nullptr, TestOuter2);
uint32 HashWrappedAfterReparent = GetTypeHash(TestPublicWrappedObjectPtr);
Add new Unit Tests #rb Chris.Constantinescu #preflight 62458f77292f228e09013681 [CL 19571202 by mark lintott in ue5-main branch]
2022-03-31 07:45:37 -04:00
TEST_EQUAL(TEXT("Hash of resolved public FObjectPtr before reparenting should equal hash of resolved public FObjectPtr after reparenting"), HashWrappedAfterReparent, HashWrapped);
Revision 2 (with handling for uninitialized object references): -Compile in lazy resolve functionality for editor binaries -Add "-LazyResolveAllImports" commandline switch to allow lazy RESOLVE of all wrapped object references -Functionality confirmed: load default map in ShooterGame Editor, cook ShooterGame, load LumenReflectiveTest in FortGPUTestbed, load default map and P_Construct in Frosty -Renamed "-DisableLoadingAllImports" to "-LazyLoadAllImports" commandline switch to allow lazy LOAD of all wrapped object references and ensured it works with AsyncLoading code path -Non functional when combined with lazy resolve - will be worked on afterwards -Added CPU timing scopes to measure performance impact of lazy resolve Fixed lazy resolve bugs: -Ensure null check on an unresolved object reference resolves the object reference (a non-null unresolved reference can become a null resolved reference) -Ensure hash of an unresolved object reference resolves the object reference and hashes the resultant address (otherwise we can't reliably ensure hash consistency in the face of object redirection or stale references) -Avoid using package name hash internally as it immediately manifested in hash collisions on a moderately sized project -Ensure StaticFindObjectFastInternal instead of StaticFindObjectFast to ensure we can find/resolve not fully loaded objects -Ensure UObjectRedirectors are handled when resolving wrapped object pointers -Ensure we handle the possibility that a package has been partially loaded and we may not find our target object within it because the object hasn't been created yet Automated testing: -Adding hash consistency and redirector resolve tests to ObjectPtr unit tests #rb devin.doucette [CL 15571874 by Zousar Shaker in ue5-main branch]
2021-03-02 14:39:53 -04:00
}
TestPackage1->RemoveFromRoot();
}
code cleanup of ObjectHandle made ObjectPathId to private trimmed down the public API as much as possible https://p4-swarm.epicgames.net/reviews/23658342 #rb zousar.shaker #preflight 63c5c8922a6acaf1625fcf25 [CL 23734208 by joe pribele in ue5-main branch]
2023-01-16 19:20:47 -05:00
#endif
Revision 2 (with handling for uninitialized object references): -Compile in lazy resolve functionality for editor binaries -Add "-LazyResolveAllImports" commandline switch to allow lazy RESOLVE of all wrapped object references -Functionality confirmed: load default map in ShooterGame Editor, cook ShooterGame, load LumenReflectiveTest in FortGPUTestbed, load default map and P_Construct in Frosty -Renamed "-DisableLoadingAllImports" to "-LazyLoadAllImports" commandline switch to allow lazy LOAD of all wrapped object references and ensured it works with AsyncLoading code path -Non functional when combined with lazy resolve - will be worked on afterwards -Added CPU timing scopes to measure performance impact of lazy resolve Fixed lazy resolve bugs: -Ensure null check on an unresolved object reference resolves the object reference (a non-null unresolved reference can become a null resolved reference) -Ensure hash of an unresolved object reference resolves the object reference and hashes the resultant address (otherwise we can't reliably ensure hash consistency in the face of object redirection or stale references) -Avoid using package name hash internally as it immediately manifested in hash collisions on a moderately sized project -Ensure StaticFindObjectFastInternal instead of StaticFindObjectFast to ensure we can find/resolve not fully loaded objects -Ensure UObjectRedirectors are handled when resolving wrapped object pointers -Ensure we handle the possibility that a package has been partially loaded and we may not find our target object within it because the object hasn't been created yet Automated testing: -Adding hash consistency and redirector resolve tests to ObjectPtr unit tests #rb devin.doucette [CL 15571874 by Zousar Shaker in ue5-main branch]
2021-03-02 14:39:53 -04:00
code cleanup of ObjectHandle made ObjectPathId to private trimmed down the public API as much as possible https://p4-swarm.epicgames.net/reviews/23658342 #rb zousar.shaker #preflight 63c5c8922a6acaf1625fcf25 [CL 23734208 by joe pribele in ue5-main branch]
2023-01-16 19:20:47 -05:00
#if UE_WITH_OBJECT_HANDLE_LATE_RESOLVE
CoreUObject test conversion damage control. Correcting tests commited in CL 19498448 that were converted and tagged [Smoke] but weren't marked with EAUtomationTestFlags::SmokeFilter in the original source. EditorBulkDataTests was left unconverted, moved back to original Private/Tests/Serialization folder ObjectPtrTest -> CoreUObject::TObjectPtr::Soft Object Path fails at line 197 on non-desktop platforms but it didn't failed before the conversion. #preflight 624eee0a2c01f9c6da9446e0 #rb Devin.Doucette [CL 19668909 by chris constantinescu in ue5-main branch]
2022-04-07 10:34:55 -04:00
TEST_CASE_METHOD(FObjectPtrTestBase, "CoreUObject::TObjectPtr::Long Path", "[CoreUObject][ObjectPtr]")
Add TargetRules.bFNameOutlineNumber as an option to reduce the size of FName by 4 bytes by storing the number in the name table. Adds a define UE_FNAME_OUTLINE_NUMBER. Removes of FName, FMinimalName from memory image support. Adds of FMemoryImageName. Removal of FMinimalName operator&lt;&lt;, all fields made private, size made variable. All fields of FScriptName made private. Added console commands for dumping numbered/unnumbered names and stats. #rb johan.torp #ROBOMERGE-OWNER: robert.millar #ROBOMERGE-AUTHOR: robert.millar #ROBOMERGE-SOURCE: CL 19058026 via CL 19058611 via CL 19058656 via CL 19061727 via CL 19061740 via CL 19064047 #ROBOMERGE-BOT: UE5 (Release-Engine-Staging -> Main) (v918-19018356) [CL 19066701 by robert millar in ue5-main branch]
2022-02-21 02:35:48 -05:00
{
const FName TestPackage1Name(TEXT("/Engine/Test/FObjectPtrTestLongPath/Transient"));
UPackage* TestPackage1 = NewObject<UPackage>(nullptr, TestPackage1Name, RF_Transient);
TestPackage1->AddToRoot();
ON_SCOPE_EXIT{
TestPackage1->RemoveFromRoot();
};
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
UObject* TestObject1 = NewObject<UObjectPtrTestClass>(TestPackage1, TEXT("TestObject1"));
UObject* TestObject2 = NewObject<UObjectPtrTestClass>(TestObject1, TEXT("TestObject2"));
UObject* TestObject3 = NewObject<UObjectPtrTestClass>(TestObject2, TEXT("TestObject3"));
UObject* TestObject4 = NewObject<UObjectPtrTestClass>(TestObject3, TEXT("TestObject4"));
Add TargetRules.bFNameOutlineNumber as an option to reduce the size of FName by 4 bytes by storing the number in the name table. Adds a define UE_FNAME_OUTLINE_NUMBER. Removes of FName, FMinimalName from memory image support. Adds of FMemoryImageName. Removal of FMinimalName operator&lt;&lt;, all fields made private, size made variable. All fields of FScriptName made private. Added console commands for dumping numbered/unnumbered names and stats. #rb johan.torp #ROBOMERGE-OWNER: robert.millar #ROBOMERGE-AUTHOR: robert.millar #ROBOMERGE-SOURCE: CL 19058026 via CL 19058611 via CL 19058656 via CL 19061727 via CL 19061740 via CL 19064047 #ROBOMERGE-BOT: UE5 (Release-Engine-Staging -> Main) (v918-19018356) [CL 19066701 by robert millar in ue5-main branch]
2022-02-21 02:35:48 -05:00
code cleanup of ObjectHandle made ObjectPathId to private trimmed down the public API as much as possible https://p4-swarm.epicgames.net/reviews/23658342 #rb zousar.shaker #preflight 63c5c8922a6acaf1625fcf25 [CL 23734208 by joe pribele in ue5-main branch]
2023-01-16 19:20:47 -05:00
UE::CoreUObject::Private::FObjectPathId LongPath(TestObject4);
UE::CoreUObject::Private::FObjectPathId::ResolvedNameContainerType ResolvedNames;
Add TargetRules.bFNameOutlineNumber as an option to reduce the size of FName by 4 bytes by storing the number in the name table. Adds a define UE_FNAME_OUTLINE_NUMBER. Removes of FName, FMinimalName from memory image support. Adds of FMemoryImageName. Removal of FMinimalName operator&lt;&lt;, all fields made private, size made variable. All fields of FScriptName made private. Added console commands for dumping numbered/unnumbered names and stats. #rb johan.torp #ROBOMERGE-OWNER: robert.millar #ROBOMERGE-AUTHOR: robert.millar #ROBOMERGE-SOURCE: CL 19058026 via CL 19058611 via CL 19058656 via CL 19061727 via CL 19061740 via CL 19064047 #ROBOMERGE-BOT: UE5 (Release-Engine-Staging -> Main) (v918-19018356) [CL 19066701 by robert millar in ue5-main branch]
2022-02-21 02:35:48 -05:00
LongPath.Resolve(ResolvedNames);
Add new Unit Tests #rb Chris.Constantinescu #preflight 62458f77292f228e09013681 [CL 19571202 by mark lintott in ue5-main branch]
2022-03-31 07:45:37 -04:00
TEST_EQUAL(TEXT("Resolved path from FObjectPathId should have 4 elements"), ResolvedNames.Num(), 4);
TEST_EQUAL(TEXT("Resolved path from FObjectPathId should have TestObject1 at element 0"), ResolvedNames[0], TestObject1->GetFName());
TEST_EQUAL(TEXT("Resolved path from FObjectPathId should have TestObject2 at element 1"), ResolvedNames[1], TestObject2->GetFName());
TEST_EQUAL(TEXT("Resolved path from FObjectPathId should have TestObject3 at element 2"), ResolvedNames[2], TestObject3->GetFName());
TEST_EQUAL(TEXT("Resolved path from FObjectPathId should have TestObject4 at element 3"), ResolvedNames[3], TestObject4->GetFName());
Add TargetRules.bFNameOutlineNumber as an option to reduce the size of FName by 4 bytes by storing the number in the name table. Adds a define UE_FNAME_OUTLINE_NUMBER. Removes of FName, FMinimalName from memory image support. Adds of FMemoryImageName. Removal of FMinimalName operator&lt;&lt;, all fields made private, size made variable. All fields of FScriptName made private. Added console commands for dumping numbered/unnumbered names and stats. #rb johan.torp #ROBOMERGE-OWNER: robert.millar #ROBOMERGE-AUTHOR: robert.millar #ROBOMERGE-SOURCE: CL 19058026 via CL 19058611 via CL 19058656 via CL 19061727 via CL 19061740 via CL 19064047 #ROBOMERGE-BOT: UE5 (Release-Engine-Staging -> Main) (v918-19018356) [CL 19066701 by robert millar in ue5-main branch]
2022-02-21 02:35:48 -05:00
}
code cleanup of ObjectHandle made ObjectPathId to private trimmed down the public API as much as possible https://p4-swarm.epicgames.net/reviews/23658342 #rb zousar.shaker #preflight 63c5c8922a6acaf1625fcf25 [CL 23734208 by joe pribele in ue5-main branch]
2023-01-16 19:20:47 -05:00
#endif
Add TargetRules.bFNameOutlineNumber as an option to reduce the size of FName by 4 bytes by storing the number in the name table. Adds a define UE_FNAME_OUTLINE_NUMBER. Removes of FName, FMinimalName from memory image support. Adds of FMemoryImageName. Removal of FMinimalName operator&lt;&lt;, all fields made private, size made variable. All fields of FScriptName made private. Added console commands for dumping numbered/unnumbered names and stats. #rb johan.torp #ROBOMERGE-OWNER: robert.millar #ROBOMERGE-AUTHOR: robert.millar #ROBOMERGE-SOURCE: CL 19058026 via CL 19058611 via CL 19058656 via CL 19061727 via CL 19061740 via CL 19064047 #ROBOMERGE-BOT: UE5 (Release-Engine-Staging -> Main) (v918-19018356) [CL 19066701 by robert millar in ue5-main branch]
2022-02-21 02:35:48 -05:00
[CoreUObject] changed to check for null in `TObjectPtr.GetPathName()` #preflight 63643317de2c4dbb5d47122c [CL 22968073 by joe pribele in ue5-main branch]
2022-11-03 17:47:24 -04:00
TEST_CASE("CoreUObject::TObjectPtr::GetPathName", "[CoreUObject][ObjectPtr]")
{
const FName TestPackage1Name(TEXT("/Engine/Test/FObjectPtrTestLongPath/Transient"));
UPackage* TestPackage1 = NewObject<UPackage>(nullptr, TestPackage1Name, RF_Transient);
TestPackage1->AddToRoot();
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
UObject* TestObject1 = NewObject<UObjectPtrTestClass>(TestPackage1, TEXT("TestObject1"));
[CoreUObject] changed to check for null in `TObjectPtr.GetPathName()` #preflight 63643317de2c4dbb5d47122c [CL 22968073 by joe pribele in ue5-main branch]
2022-11-03 17:47:24 -04:00
#if UE_WITH_OBJECT_HANDLE_TRACKING
int ResolveCount = 0;
changed ObjectHandleTracking to use Functions instead of delegates as the performance of delegate is poor https://p4-swarm.epicgames.net/reviews/23751084 #rb zousar.shaker #preflight 63c9ae14d45afa2a8fc37d9d [CL 23781117 by joe pribele in ue5-main branch]
2023-01-19 16:34:29 -05:00
auto ResolveDelegate = [&ResolveCount](const FObjectRef& SourceRef, UPackage* ObjectPackage, UObject* Object)
[CoreUObject] changed to check for null in `TObjectPtr.GetPathName()` #preflight 63643317de2c4dbb5d47122c [CL 22968073 by joe pribele in ue5-main branch]
2022-11-03 17:47:24 -04:00
{
++ResolveCount;
changed ObjectHandleTracking to use Functions instead of delegates as the performance of delegate is poor https://p4-swarm.epicgames.net/reviews/23751084 #rb zousar.shaker #preflight 63c9ae14d45afa2a8fc37d9d [CL 23781117 by joe pribele in ue5-main branch]
2023-01-19 16:34:29 -05:00
};
auto Handle = UE::CoreUObject::AddObjectHandleReferenceResolvedCallback(ResolveDelegate);
[CoreUObject] changed to check for null in `TObjectPtr.GetPathName()` #preflight 63643317de2c4dbb5d47122c [CL 22968073 by joe pribele in ue5-main branch]
2022-11-03 17:47:24 -04:00
#endif
ON_SCOPE_EXIT
{
TestPackage1->RemoveFromRoot();
#if UE_WITH_OBJECT_HANDLE_TRACKING
changed ObjectHandleTracking to use Functions instead of delegates as the performance of delegate is poor https://p4-swarm.epicgames.net/reviews/23751084 #rb zousar.shaker #preflight 63c9ae14d45afa2a8fc37d9d [CL 23781117 by joe pribele in ue5-main branch]
2023-01-19 16:34:29 -05:00
UE::CoreUObject::RemoveObjectHandleReferenceResolvedCallback(Handle);
[CoreUObject] changed to check for null in `TObjectPtr.GetPathName()` #preflight 63643317de2c4dbb5d47122c [CL 22968073 by joe pribele in ue5-main branch]
2022-11-03 17:47:24 -04:00
#endif
};
TObjectPtr<UObject> Ptr = nullptr;
CHECK(TEXT("None") == Ptr.GetPathName());
Ptr = TestObject1;
CHECK(TestObject1->GetPathName() == Ptr.GetPathName());
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
Ptr = TestPackage1;
CHECK(TestPackage1->GetPathName() == Ptr.GetPathName());
[CoreUObject] changed to check for null in `TObjectPtr.GetPathName()` #preflight 63643317de2c4dbb5d47122c [CL 22968073 by joe pribele in ue5-main branch]
2022-11-03 17:47:24 -04:00
#if UE_WITH_OBJECT_HANDLE_LATE_RESOLVE
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
{
code cleanup of ObjectHandle made ObjectPathId to private trimmed down the public API as much as possible https://p4-swarm.epicgames.net/reviews/23658342 #rb zousar.shaker #preflight 63c5c8922a6acaf1625fcf25 [CL 23734208 by joe pribele in ue5-main branch]
2023-01-16 19:20:47 -05:00
FObjectPtr ObjPtr(MakeUnresolvedHandle(TestObject1));
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
Ptr = *reinterpret_cast<TObjectPtr<UObject>*>(&ObjPtr);
REQUIRE(!Ptr.IsResolved());
CHECK(TestObject1->GetPathName() == Ptr.GetPathName());
CHECK(TestObject1->GetClass() == Ptr.GetClass());
}
{
code cleanup of ObjectHandle made ObjectPathId to private trimmed down the public API as much as possible https://p4-swarm.epicgames.net/reviews/23658342 #rb zousar.shaker #preflight 63c5c8922a6acaf1625fcf25 [CL 23734208 by joe pribele in ue5-main branch]
2023-01-16 19:20:47 -05:00
FObjectPtr ObjPtr(MakeUnresolvedHandle(TestPackage1));
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
Ptr = *reinterpret_cast<TObjectPtr<UObject>*>(&ObjPtr);
REQUIRE(!Ptr.IsResolved());
CHECK(TestPackage1->GetPathName() == Ptr.GetPathName());
CHECK(TestPackage1->GetClass() == Ptr.GetClass());
}
[CoreUObject] changed to check for null in `TObjectPtr.GetPathName()` #preflight 63643317de2c4dbb5d47122c [CL 22968073 by joe pribele in ue5-main branch]
2022-11-03 17:47:24 -04:00
#endif
#if UE_WITH_OBJECT_HANDLE_TRACKING
REQUIRE(ResolveCount == 0);
#endif
}
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
#if UE_WITH_OBJECT_HANDLE_LATE_RESOLVE
TEST_CASE("CoreUObject::TObjectPtr::PackageRename")
{
const FName TestPackageName(TEXT("/Engine/Test/TestName/Transient"));
UPackage* TestPackage = NewObject<UPackage>(nullptr, TestPackageName, RF_Transient);
TestPackage->AddToRoot();
//register package with the object handle registry
code cleanup of ObjectHandle made ObjectPathId to private trimmed down the public API as much as possible https://p4-swarm.epicgames.net/reviews/23658342 #rb zousar.shaker #preflight 63c5c8922a6acaf1625fcf25 [CL 23734208 by joe pribele in ue5-main branch]
2023-01-16 19:20:47 -05:00
UE::CoreUObject::Private::MakePackedObjectRef(TestPackage);
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
UObject* Obj1 = NewObject<UObjectPtrTestClass>(TestPackage, TEXT("Obj1"));
UObject* Inner1 = NewObject<UObjectPtrTestClass>(Obj1, TEXT("Inner1"));
UObject* Class = Obj1->GetClass();
Class->GetOutermost()->GetMetaData()->SetValue(Class, TEXT("LoadBehavior"), TEXT("LazyOnDemand"));
code cleanup of ObjectHandle made ObjectPathId to private trimmed down the public API as much as possible https://p4-swarm.epicgames.net/reviews/23658342 #rb zousar.shaker #preflight 63c5c8922a6acaf1625fcf25 [CL 23734208 by joe pribele in ue5-main branch]
2023-01-16 19:20:47 -05:00
FObjectPtr ObjPtr(MakeUnresolvedHandle(Obj1));
FObjectPtr InnerPtr(MakeUnresolvedHandle(Inner1));
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
TObjectPtr<UObject> BeforeRename = *reinterpret_cast<TObjectPtr<UObject>*>(&ObjPtr);
TObjectPtr<UObject> BeforeRenameInner = *reinterpret_cast<TObjectPtr<UObject>*>(&InnerPtr);
REQUIRE(!BeforeRename.IsResolved());
CHECK(Obj1->GetPathName() == BeforeRename.GetPathName());
REQUIRE(!BeforeRenameInner.IsResolved());
CHECK(Inner1->GetPathName() == BeforeRenameInner.GetPathName());
TestPackage->Rename(TEXT("/Engine/Test/TestName/NewName"));
CHECK(Obj1->GetPathName() == BeforeRename.GetPathName());
CHECK(Inner1->GetPathName() == BeforeRenameInner.GetPathName());
TObjectPtr<UObject> AfterRenameResolved = Obj1;
TObjectPtr<UObject> AfterRenameInnerResolved = Inner1;
CHECK(BeforeRename == AfterRenameResolved);
CHECK(BeforeRenameInner == AfterRenameInnerResolved);
code cleanup of ObjectHandle made ObjectPathId to private trimmed down the public API as much as possible https://p4-swarm.epicgames.net/reviews/23658342 #rb zousar.shaker #preflight 63c5c8922a6acaf1625fcf25 [CL 23734208 by joe pribele in ue5-main branch]
2023-01-16 19:20:47 -05:00
FObjectPtr ObjPtr2(MakeUnresolvedHandle(Obj1));
FObjectPtr InnerPtr2(MakeUnresolvedHandle(Inner1));
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
TObjectPtr<UObject> AfterRenameUnresolved = *reinterpret_cast<TObjectPtr<UObject>*>(&ObjPtr2);
TObjectPtr<UObject> AfterRenameInnerUnresolved = *reinterpret_cast<TObjectPtr<UObject>*>(&InnerPtr2);
CHECK(BeforeRename == AfterRenameUnresolved);
CHECK(BeforeRenameInner == AfterRenameInnerUnresolved);
Obj1->Rename(TEXT("RenamedObj"), nullptr);
CHECK(Obj1->GetPathName() == BeforeRename.GetPathName());
CHECK(Inner1->GetPathName() == BeforeRenameInner.GetPathName());
CHECK(BeforeRename == AfterRenameResolved);
CHECK(BeforeRenameInner == AfterRenameInnerResolved);
}
TEST_CASE("CoreUObject::TObjectPtr::InnerRename")
{
const FName TestPackageName(TEXT("/Engine/TestPackage"));
UPackage* TestPackage = NewObject<UPackage>(nullptr, TestPackageName, RF_Transient);
TestPackage->AddToRoot();
UObject* Obj1 = NewObject<UObjectPtrTestClass>(TestPackage, TEXT("Obj1"));
UObject* Inner1 = NewObject<UObjectPtrTestClass>(Obj1, TEXT("Inner1"));
UObject* Obj2 = NewObject<UObjectPtrTestClass>(TestPackage, TEXT("Obj2"));
UObject* Inner2 = NewObject<UObjectPtrTestClass>(Obj2, TEXT("Inner2"));
code cleanup of ObjectHandle made ObjectPathId to private trimmed down the public API as much as possible https://p4-swarm.epicgames.net/reviews/23658342 #rb zousar.shaker #preflight 63c5c8922a6acaf1625fcf25 [CL 23734208 by joe pribele in ue5-main branch]
2023-01-16 19:20:47 -05:00
FObjectPtr ObjPtr1(MakeUnresolvedHandle(Obj1));
FObjectPtr InnerPtr1(MakeUnresolvedHandle(Inner1));
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
code cleanup of ObjectHandle made ObjectPathId to private trimmed down the public API as much as possible https://p4-swarm.epicgames.net/reviews/23658342 #rb zousar.shaker #preflight 63c5c8922a6acaf1625fcf25 [CL 23734208 by joe pribele in ue5-main branch]
2023-01-16 19:20:47 -05:00
FObjectPtr ObjPtr2(MakeUnresolvedHandle(Obj2));
FObjectPtr InnerPtr2(MakeUnresolvedHandle(Inner2));
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
TObjectPtr<UObject> BeforeRename1 = *reinterpret_cast<TObjectPtr<UObject>*>(&ObjPtr1);
TObjectPtr<UObject> BeforeRenameInner1 = *reinterpret_cast<TObjectPtr<UObject>*>(&InnerPtr1);
TObjectPtr<UObject> BeforeRename2 = *reinterpret_cast<TObjectPtr<UObject>*>(&ObjPtr2);
TObjectPtr<UObject> BeforeRenameInner2 = *reinterpret_cast<TObjectPtr<UObject>*>(&InnerPtr2);
REQUIRE(!BeforeRename1.IsResolved());
CHECK(Obj1->GetPathName() == BeforeRename1.GetPathName());
REQUIRE(!BeforeRenameInner1.IsResolved());
CHECK(Inner1->GetPathName() == BeforeRenameInner1.GetPathName());
REQUIRE(!BeforeRename2.IsResolved());
CHECK(Obj2->GetPathName() == BeforeRename2.GetPathName());
REQUIRE(!BeforeRenameInner2.IsResolved());
CHECK(Inner2->GetPathName() == BeforeRenameInner2.GetPathName());
Obj1->Rename(TEXT("RenamedObj"), nullptr);
code cleanup of ObjectHandle made ObjectPathId to private trimmed down the public API as much as possible https://p4-swarm.epicgames.net/reviews/23658342 #rb zousar.shaker #preflight 63c5c8922a6acaf1625fcf25 [CL 23734208 by joe pribele in ue5-main branch]
2023-01-16 19:20:47 -05:00
FObjectPtr AfterRenameObjPtr1(MakeUnresolvedHandle(Obj1));
FObjectPtr AfterRenameInnerPtr1(MakeUnresolvedHandle(Inner1));
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
TObjectPtr<UObject> AfterRenameUnresolved1 = *reinterpret_cast<TObjectPtr<UObject>*>(&AfterRenameObjPtr1);
TObjectPtr<UObject> AfterRenameInnerUnresolved1 = *reinterpret_cast<TObjectPtr<UObject>*>(&AfterRenameInnerPtr1);
TObjectPtr<UObject> AfterRename1 = Obj1;
TObjectPtr<UObject> AfterRenameInner1 = Inner1;
CHECK(Obj1->GetPathName() == BeforeRename1.GetPathName());
REQUIRE(!BeforeRenameInner1.IsResolved());
CHECK(Inner1->GetPathName() == BeforeRenameInner1.GetPathName());
CHECK(BeforeRename1 == AfterRename1);
CHECK(BeforeRenameInner1 == AfterRenameInner1);
CHECK(BeforeRename1 == AfterRenameUnresolved1);
CHECK(BeforeRenameInner1 == AfterRenameInnerUnresolved1);
Obj1->Rename(nullptr, Inner2);
CHECK(Obj2->GetPathName() == BeforeRename2.GetPathName());
REQUIRE(!BeforeRenameInner2.IsResolved());
CHECK(Inner2->GetPathName() == BeforeRenameInner2.GetPathName());
CHECK(BeforeRename1 == AfterRename1);
CHECK(BeforeRename1.GetPathName() == AfterRename1.GetPathName());
CHECK(BeforeRenameInner1 == AfterRenameInner1);
TestPackage->RemoveFromRoot();
}
second attempt to fix for performance problem when converting arrays of TObjectPtr to UObject* changed the access tracking to a bulk operation api to allow for single calls instead of O(n) calls #preflight 63fe5fc7ac6c61e2b553e9a9 [CL 24449378 by joe pribele in ue5-main branch]
2023-02-28 15:26:26 -05:00
TEST_CASE("CoreUObject::TObjectPtr::Swap")
{
const FName TestPackageName(TEXT("/Engine/TestPackage"));
UPackage* TestPackage = NewObject<UPackage>(nullptr, TestPackageName, RF_Transient);
TestPackage->AddToRoot();
UObject* Obj1 = NewObject<UObjectPtrTestClass>(TestPackage, TEXT("Obj1"));
UObject* Inner1 = NewObject<UObjectPtrTestClass>(Obj1, TEXT("Inner1"));
UObject* RawPtrA = Obj1;
UObject* RawPtrB = Inner1;
FObjectPtr ObjPtr1(MakeUnresolvedHandle(RawPtrA));
FObjectPtr InnerPtr1(MakeUnresolvedHandle(RawPtrB));
TObjectPtr<UObject> PtrA = *reinterpret_cast<TObjectPtr<UObject>*>(&ObjPtr1);
TObjectPtr<UObject> PtrB = *reinterpret_cast<TObjectPtr<UObject>*>(&InnerPtr1);
CHECK(!PtrA.IsResolved());
CHECK(!PtrB.IsResolved());
Swap(PtrA, PtrB);
CHECK(!PtrA.IsResolved());
CHECK(!PtrB.IsResolved());
CHECK(PtrA != PtrB);
CHECK(PtrA != RawPtrA);
Swap(PtrA, RawPtrA);
CHECK(PtrA.IsResolved());
CHECK(RawPtrA == Inner1);
CHECK(PtrA == Obj1);
Swap(PtrB, PtrA);
CHECK(!PtrA.IsResolved());
CHECK(PtrB.IsResolved());
}
TEST_CASE("CoreUObject::TObjectPtr::SwapArray")
{
const FName TestPackageName(TEXT("/Engine/TestPackage"));
UPackage* TestPackage = NewObject<UPackage>(nullptr, TestPackageName, RF_Transient);
TestPackage->AddToRoot();
UObject* Obj1 = NewObject<UObjectPtrTestClass>(TestPackage, TEXT("Obj1"));
UObject* Inner1 = NewObject<UObjectPtrTestClass>(Obj1, TEXT("Inner1"));
UObject* RawPtrA = Obj1;
UObject* RawPtrB = Inner1;
FObjectPtr ObjPtr1(MakeUnresolvedHandle(RawPtrA));
FObjectPtr InnerPtr1(MakeUnresolvedHandle(RawPtrB));
TObjectPtr<UObject> PtrA = *reinterpret_cast<TObjectPtr<UObject>*>(&ObjPtr1);
TObjectPtr<UObject> PtrB = *reinterpret_cast<TObjectPtr<UObject>*>(&InnerPtr1);
TArray<TObjectPtr<UObject>> ArrayPtr;
auto t = ArrayPtr.begin();
ArrayPtr.Add(PtrA);
TArray<UObject*> ArrayRaw;
ArrayRaw.Add(RawPtrB);
Swap(ArrayRaw, ArrayPtr);
CHECK(ArrayRaw[0] == RawPtrA);
CHECK(ArrayPtr[0] == RawPtrB);
}
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
TEST_CASE("CoreUObject::TObjectPtr::Move")
{
UPackage* TestPackageA = NewObject<UPackage>(nullptr, TEXT("/Engine/PackageA"), RF_Transient);
TestPackageA->AddToRoot();
UObject* Obj1 = NewObject<UObjectPtrTestClass>(TestPackageA, TEXT("Obj1"));
UObject* Inner1 = NewObject<UObjectPtrTestClass>(Obj1, TEXT("Inner1"));
UPackage* TestPackageB = NewObject<UPackage>(nullptr, TEXT("/Engine/PackageB"), RF_Transient);
TestPackageB->AddToRoot();
code cleanup of ObjectHandle made ObjectPathId to private trimmed down the public API as much as possible https://p4-swarm.epicgames.net/reviews/23658342 #rb zousar.shaker #preflight 63c5c8922a6acaf1625fcf25 [CL 23734208 by joe pribele in ue5-main branch]
2023-01-16 19:20:47 -05:00
FObjectPtr FObjPtr(MakeUnresolvedHandle(Obj1));
FObjectPtr FInnerPtr(MakeUnresolvedHandle(Inner1));
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
TObjectPtr<UObject> BeforeRename = *reinterpret_cast<TObjectPtr<UObject>*>(&FObjPtr);
TObjectPtr<UObject> BeforeRenameInner = *reinterpret_cast<TObjectPtr<UObject>*>(&FInnerPtr);
TObjectPtr<UObject> ObjPtr1 = Obj1;
TObjectPtr<UObject> InnerPtr1 = Inner1;
REQUIRE(!BeforeRename.IsResolved());
CHECK(BeforeRename == ObjPtr1);
CHECK(Obj1->GetPathName() == BeforeRename.GetPathName());
REQUIRE(!BeforeRenameInner.IsResolved());
CHECK(InnerPtr1 == BeforeRenameInner);
CHECK(Inner1->GetPathName() == BeforeRenameInner.GetPathName());
Obj1->Rename(TEXT("Obj2"), TestPackageB);
bool e = BeforeRename == ObjPtr1;
REQUIRE(!BeforeRename.IsResolved());
CHECK(BeforeRename == ObjPtr1);
CHECK(Obj1->GetPathName() == BeforeRename.GetPathName());
CHECK(InnerPtr1 == BeforeRenameInner);
CHECK(Inner1->GetPathName() == BeforeRenameInner.GetPathName());
TObjectPtr<UObject> AfterRename = Obj1;
TObjectPtr<UObject> AfterRenameInner = Inner1;
CHECK(BeforeRename == AfterRename);
CHECK(BeforeRenameInner == AfterRenameInner);
TestPackageA->RemoveFromRoot();
TestPackageB->RemoveFromRoot();
}
TEST_CASE("CoreUObject::TObjectPtr::GetTypeHash")
{
int ResolveCount = 0;
#if UE_WITH_OBJECT_HANDLE_TRACKING
changed ObjectHandleTracking to use Functions instead of delegates as the performance of delegate is poor https://p4-swarm.epicgames.net/reviews/23751084 #rb zousar.shaker #preflight 63c9ae14d45afa2a8fc37d9d [CL 23781117 by joe pribele in ue5-main branch]
2023-01-19 16:34:29 -05:00
auto ResolveDelegate = [&ResolveCount](const FObjectRef& SourceRef, UPackage* ObjectPackage, UObject* Object)
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
{
++ResolveCount;
changed ObjectHandleTracking to use Functions instead of delegates as the performance of delegate is poor https://p4-swarm.epicgames.net/reviews/23751084 #rb zousar.shaker #preflight 63c9ae14d45afa2a8fc37d9d [CL 23781117 by joe pribele in ue5-main branch]
2023-01-19 16:34:29 -05:00
};
auto Handle = UE::CoreUObject::AddObjectHandleReferenceResolvedCallback(ResolveDelegate);
ON_SCOPE_EXIT
{
UE::CoreUObject::RemoveObjectHandleReferenceResolvedCallback(Handle);
};
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
#endif
UPackage* TestPackageA = NewObject<UPackage>(nullptr, TEXT("/Engine/PackageA"), RF_Transient);
TestPackageA->AddToRoot();
TObjectPtr<UObject> Obj1 = NewObject<UObjectPtrTestClass>(TestPackageA, TEXT("Obj1"));
TObjectPtr<UObject> Inner1 = NewObject<UObjectPtrTestClass>(Obj1, TEXT("Inner1"));
code cleanup of ObjectHandle made ObjectPathId to private trimmed down the public API as much as possible https://p4-swarm.epicgames.net/reviews/23658342 #rb zousar.shaker #preflight 63c5c8922a6acaf1625fcf25 [CL 23734208 by joe pribele in ue5-main branch]
2023-01-16 19:20:47 -05:00
UE::CoreUObject::Private::MakePackedObjectRef(TestPackageA);
UE::CoreUObject::Private::MakePackedObjectRef(Obj1.Get());
UE::CoreUObject::Private::MakePackedObjectRef(Inner1.Get());
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
TMap<TObjectPtr<UObject>, int> TestMap;
int32 BeforeKey = GetTypeHash(Obj1);
int32 BeforeKeyInner = GetTypeHash(Inner1);
int32 BeforeKeyPackage = GetTypeHash(TestPackageA);
TestMap.Add(Obj1, 0);
TestMap.Add(Inner1, 1);
TestMap.Add(TestPackageA, 3);
//add a bunch of objects
for (int i = 0; i < 10; ++i)
{
TestMap.Add(NewObject<UObjectPtrTestClass>(TestPackageA), TestMap.Num());;
}
for (int i = 0; i < 10; ++i)
{
TestMap.Add(NewObject<UObjectPtrNotLazyTestClass>(TestPackageA), i);;
}
TObjectPtr<UObject> NotLazy = NewObject<UObjectPtrNotLazyTestClass>(TestPackageA);
int NotLazyValue = TestMap.Num();
TestMap.Add(NotLazy, NotLazyValue);
CHECK(GetTypeHash(NotLazy) == GetTypeHash(NotLazy.Get()));
CHECK(TestMap[NotLazy] == NotLazyValue);
code cleanup of ObjectHandle made ObjectPathId to private trimmed down the public API as much as possible https://p4-swarm.epicgames.net/reviews/23658342 #rb zousar.shaker #preflight 63c5c8922a6acaf1625fcf25 [CL 23734208 by joe pribele in ue5-main branch]
2023-01-16 19:20:47 -05:00
FObjectPtr FPackagePtr(MakeUnresolvedHandle(TestPackageA));
FObjectPtr FObjPtr(MakeUnresolvedHandle(Obj1));
FObjectPtr FInnerPtr(MakeUnresolvedHandle(Inner1));
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
TObjectPtr<UObject> BeforeRename = *reinterpret_cast<TObjectPtr<UObject>*>(&FObjPtr);
TObjectPtr<UObject> BeforeRenameInner = *reinterpret_cast<TObjectPtr<UObject>*>(&FInnerPtr);
TObjectPtr<UObject> BeforeRenamePackage = *reinterpret_cast<TObjectPtr<UObject>*>(&FPackagePtr);
int32 BeforeRenameTypeHash = GetTypeHash(BeforeRename);
int32 BeforeRenameTypeHashInner = GetTypeHash(BeforeRenameInner);
int32 BeforeRenamePackageTypeHash = GetTypeHash(BeforeRenamePackage);
CHECK(BeforeKey == BeforeRenameTypeHash);
CHECK(BeforeKey == BeforeRenameTypeHash);
CHECK(BeforeKeyInner == BeforeRenameTypeHashInner);
CHECK(ResolveCount == 0);
CHECK(TestMap[Obj1] == 0);
CHECK(TestMap[BeforeRename] == 0);
CHECK(TestMap[Inner1] == 1);
CHECK(TestMap[BeforeRenameInner] == 1);
CHECK(TestMap[TestPackageA] == 3);
CHECK(TestMap[BeforeRenamePackage] == 3);
CHECK(!BeforeRename.IsResolved());
CHECK(!BeforeRenameInner.IsResolved());
CHECK(!BeforeRenamePackage.IsResolved());
auto TestMapFunc = [&]()
{
TMap<TObjectPtr<UObject>, bool> Map;
Map.Add(Obj1, false);
Map.Add(Inner1, true);
CHECK(ResolveCount == 0);
bool* Found = Map.Find(BeforeRename);
CHECK(ResolveCount == 0);
CHECK(Found != nullptr);
CHECK(!*Found);
Found = Map.Find(BeforeRenameInner);
CHECK(ResolveCount == 0);
CHECK(Found != nullptr);
CHECK(*Found);
CHECK(ResolveCount == 0);
Found = Map.Find(Obj1);
CHECK(ResolveCount == 0);
CHECK(Found != nullptr);
CHECK(!*Found);
CHECK(ResolveCount == 0);
Found = Map.Find(Inner1);
CHECK(ResolveCount == 0);
CHECK(Found != nullptr);
CHECK(*Found);
};
auto TestUnResolvedMapFunc = [&]()
{
TMap<TObjectPtr<UObject>, bool> Map;
Map.Add(BeforeRename, false);
Map.Add(BeforeRenameInner, true);
CHECK(ResolveCount == 0);
bool* Found = Map.Find(BeforeRename);
CHECK(ResolveCount == 0);
CHECK(Found != nullptr);
CHECK(!*Found);
Found = Map.Find(BeforeRenameInner);
CHECK(ResolveCount == 0);
CHECK(Found != nullptr);
CHECK(*Found);
CHECK(ResolveCount == 0);
Found = Map.Find(Obj1);
CHECK(ResolveCount == 0);
CHECK(Found != nullptr);
CHECK(!*Found);
CHECK(ResolveCount == 0);
Found = Map.Find(Inner1);
CHECK(ResolveCount == 0);
CHECK(Found != nullptr);
CHECK(*Found);
};
TestMapFunc();
TestUnResolvedMapFunc();
UPackage* TestPackageB = NewObject<UPackage>(nullptr, TEXT("/Engine/PackageB"), RF_Transient);
TestPackageB->AddToRoot();
Obj1->Rename(nullptr, TestPackageB);
TestMapFunc();
TestUnResolvedMapFunc();
TestPackageA->RemoveFromRoot();
TestPackageB->RemoveFromRoot();
}
second attempt to fix for performance problem when converting arrays of TObjectPtr to UObject* changed the access tracking to a bulk operation api to allow for single calls instead of O(n) calls #preflight 63fe5fc7ac6c61e2b553e9a9 [CL 24449378 by joe pribele in ue5-main branch]
2023-02-28 15:26:26 -05:00
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
#endif
second attempt to fix for performance problem when converting arrays of TObjectPtr to UObject* changed the access tracking to a bulk operation api to allow for single calls instead of O(n) calls #preflight 63fe5fc7ac6c61e2b553e9a9 [CL 24449378 by joe pribele in ue5-main branch]
2023-02-28 15:26:26 -05:00
template<typename TObj>
void TestArrayConversion()
{
const FName TestPackageName(TEXT("/Engine/TestPackage"));
UPackage* TestPackage = NewObject<UPackage>(nullptr, TestPackageName, RF_Transient);
TestPackage->AddToRoot();
UObject* Obj1 = NewObject<UObjectPtrTestClass>(TestPackage, TEXT("Obj1"));
#if UE_WITH_OBJECT_HANDLE_TRACKING
int ResolveCount = 0;
uint32 ObjCount = 0;
auto ResolveDelegate = [&](TArrayView<const UObject* const> Objects)
{
++ResolveCount;
ObjCount = Objects.Num();
for(const UObject* ReadObj : Objects)
{
CHECK(ReadObj == Obj1);
}
};
auto Handle = UE::CoreUObject::AddObjectHandleReadCallback(ResolveDelegate);
ON_SCOPE_EXIT
{
UE::CoreUObject::RemoveObjectHandleReadCallback(Handle);
};
#endif
TArray<TObjectPtr<TObj>> PtrArray;
uint32 NumObjs = 1000000;
for (uint32 i = 0; i < NumObjs; ++i)
{
PtrArray.Add(Obj1);
}
{
TArray<TObj*> RawArray;
RawArray = PtrArray;
#if UE_WITH_OBJECT_HANDLE_TRACKING
CHECK(ResolveCount == 1);
CHECK(ObjCount == NumObjs);
ResolveCount = 0;
ObjCount = 0;
#endif
CHECK(RawArray.Num() == NumObjs);
for (uint32 i = 0; i < NumObjs; ++i)
{
CHECK(RawArray[i] == Obj1);
}
}
{
TArray<TObjectPtr<TObj>> EmptyArray;
TArray<TObj*> RawArray;
RawArray = EmptyArray;
#if UE_WITH_OBJECT_HANDLE_TRACKING
CHECK(ResolveCount == 1);
CHECK(ObjCount == 0);
ResolveCount = 0;
ObjCount = 0;
#endif
CHECK(RawArray.Num() == 0);
}
{
const TArray<TObjectPtr<TObj>>& ConstPtrArray = PtrArray;
TArray<TObj*> RawArray;
RawArray = ConstPtrArray;
#if UE_WITH_OBJECT_HANDLE_TRACKING
CHECK(ResolveCount == 1);
CHECK(ObjCount == NumObjs);
ResolveCount = 0;
ObjCount = 0;
#endif
CHECK(RawArray.Num() == NumObjs);
for (uint32 i = 0; i < NumObjs; ++i)
{
CHECK(RawArray[i] == Obj1);
}
}
{
TArray<TObjectPtr<TObj>> EmptyArray;
const TArray<TObjectPtr<TObj>>& ConstPtrArray = EmptyArray;
TArray<TObj*> RawArray;
RawArray = ConstPtrArray;
#if UE_WITH_OBJECT_HANDLE_TRACKING
CHECK(ResolveCount == 1);
CHECK(ObjCount == 0);
ResolveCount = 0;
ObjCount = 0;
#endif
CHECK(RawArray.Num() == 0);
}
{
const TArray<TObjectPtr<TObj>>& ConstPtrArray = PtrArray;
const TArray<TObj*>& RawArray = ConstPtrArray;
#if UE_WITH_OBJECT_HANDLE_TRACKING
CHECK(ResolveCount == 1);
CHECK(ObjCount == NumObjs);
ResolveCount = 0;
ObjCount = 0;
#endif
CHECK(RawArray.Num() == NumObjs);
for (uint32 i = 0; i < NumObjs; ++i)
{
CHECK(RawArray[i] == Obj1);
}
}
{
TArray<TObjectPtr<TObj>> EmptyArray;
const TArray<TObjectPtr<TObj>>& ConstPtrArray = EmptyArray;
const TArray<TObj*>& RawArray = ConstPtrArray;
#if UE_WITH_OBJECT_HANDLE_TRACKING
CHECK(ResolveCount == 1);
CHECK(ObjCount == 0);
ResolveCount = 0;
ObjCount = 0;
#endif
CHECK(RawArray.Num() == 0);
}
//ArrayView
{
TArrayView<TObj*> RawArray = PtrArray;
#if UE_WITH_OBJECT_HANDLE_TRACKING
CHECK(ResolveCount == 1);
CHECK(ObjCount == NumObjs);
ResolveCount = 0;
ObjCount = 0;
#endif
CHECK(RawArray.Num() == NumObjs);
for (uint32 i = 0; i < NumObjs; ++i)
{
CHECK(RawArray[i] == Obj1);
}
}
{
TArray<TObjectPtr<TObj>> EmptyArray;
TArrayView<TObj*> RawArray = EmptyArray;
#if UE_WITH_OBJECT_HANDLE_TRACKING
CHECK(ResolveCount == 1);
CHECK(ObjCount == 0);
ResolveCount = 0;
ObjCount = 0;
#endif
CHECK(RawArray.Num() == 0);
}
{
const TArray<TObjectPtr<TObj>>& ConstPtrArray = PtrArray;
const TArrayView<TObj* const> RawArray = ConstPtrArray;
#if UE_WITH_OBJECT_HANDLE_TRACKING
CHECK(ResolveCount == 1);
CHECK(ObjCount == NumObjs);
ResolveCount = 0;
ObjCount = 0;
#endif
CHECK(RawArray.Num() == NumObjs);
for (uint32 i = 0; i < NumObjs; ++i)
{
CHECK(RawArray[i] == Obj1);
}
}
{
TArray<TObjectPtr<TObj>> EmptyArray;
const TArray<TObjectPtr<TObj>>& ConstPtrArray = EmptyArray;
const TArrayView<TObj* const> RawArray = ConstPtrArray;
#if UE_WITH_OBJECT_HANDLE_TRACKING
CHECK(ResolveCount == 1);
CHECK(ObjCount == 0);
ResolveCount = 0;
ObjCount = 0;
#endif
CHECK(RawArray.Num() == 0);
}
}
TEST_CASE("CoreUObject::TObjectPtr::ArrayConversion")
{
TestArrayConversion<UObject>();
TestArrayConversion<const UObject>();
}
TEST_CASE("CoreUObject::TObjectPtr::ArrayConversionReferenceForSet")
{
const FName TestPackageName(TEXT("/Engine/TestPackage"));
UPackage* TestPackage = NewObject<UPackage>(nullptr, TestPackageName, RF_Transient);
TestPackage->AddToRoot();
UObject* Obj1 = NewObject<UObjectPtrTestClass>(TestPackage, TEXT("Obj1"));
UObject* Obj2 = NewObject<UObjectPtrTestClass>(TestPackage, TEXT("Obj2"));
#if UE_WITH_OBJECT_HANDLE_TRACKING
int ResolveCount = 0;
uint32 ObjCount = 0;
auto ResolveDelegate = [&](TArrayView<const UObject* const> Objects)
{
++ResolveCount;
ObjCount = Objects.Num();
if (ObjCount == 2)
{
CHECK(Objects[0] == Obj1);
CHECK(Objects[1] == Obj2);
}
};
auto Handle = UE::CoreUObject::AddObjectHandleReadCallback(ResolveDelegate);
ON_SCOPE_EXIT
{
UE::CoreUObject::RemoveObjectHandleReadCallback(Handle);
};
#endif
{
TArray<TObjectPtr<UObject>> Array;
Array.Add(Obj1);
Array.Add(Obj2);
TSet<UObject*> RawSet(Array);
#if UE_WITH_OBJECT_HANDLE_TRACKING
CHECK(ResolveCount == 1);
CHECK(ObjCount == 2);
ResolveCount = 0;
ObjCount = 0;
#endif
CHECK(RawSet.Num() == 2);
}
{
TArray<TObjectPtr<UObject>> Array;
TSet<UObject*> RawSet(Array);
#if UE_WITH_OBJECT_HANDLE_TRACKING
CHECK(ResolveCount == 1);
CHECK(ObjCount == 0);
ResolveCount = 0;
ObjCount = 0;
#endif
CHECK(RawSet.Num() == 0);
}
}
TEST_CASE("CoreUObject::TObjectPtr::ConstArrayViewConversion")
{
TObjectPtr<UObject> ObjectArray[3];
TConstArrayView<TObjectPtr<UObject>> View(&ObjectArray[0], 3);
#if UE_WITH_OBJECT_HANDLE_TRACKING
int ResolveCount = 0;
auto ResolveDelegate = [&](TArrayView<const UObject* const> Objects)
{
++ResolveCount;
CHECK(Objects.Num() == 3);
CHECK(Objects[0] == nullptr);
CHECK(Objects[1] == nullptr);
CHECK(Objects[2] == nullptr);
};
auto Handle = UE::CoreUObject::AddObjectHandleReadCallback(ResolveDelegate);
ON_SCOPE_EXIT
{
UE::CoreUObject::RemoveObjectHandleReadCallback(Handle);
};
#endif
{
TConstArrayView<UObject*> ConvertedArray = View;
#if UE_WITH_OBJECT_HANDLE_TRACKING
CHECK(ResolveCount == 1);
ResolveCount = 0;
#endif
CHECK(ConvertedArray.Num() == 3);
CHECK(ConvertedArray[0] == nullptr);
CHECK(ConvertedArray[1] == nullptr);
CHECK(ConvertedArray[2] == nullptr);
}
{
TArrayView<const TObjectPtr<UObject>> ConstArray(&ObjectArray[0], 3);
TArrayView<const UObject* const> ConvertedArray = ConstArray;
#if UE_WITH_OBJECT_HANDLE_TRACKING
CHECK(ResolveCount == 1);
#endif
CHECK(ConvertedArray.Num() == 3);
CHECK(ConvertedArray[0] == nullptr);
CHECK(ConvertedArray[1] == nullptr);
CHECK(ConvertedArray[2] == nullptr);
}
}
Avoid resolving wrapped object pointer references when serializing to archive for memory counting purposes. #rb devin.doucette #preflight 60511dc194e6100001bf6338 [CL 15715895 by Zousar Shaker in ue5-main branch]
2021-03-16 17:53:58 -04:00
// @TODO: OBJPTR: We should have a test that ensures that lazy loading of an object with an external package is handled correctly.
// This should also include external packages in the outer chain of the target object.
Removal of TEXT literal concatenations, which doesn't work in UTF-8 mode. #rb devin.doucette #jira UE-132142 #preflight 62a8748fa76c84377748036b #ROBOMERGE-OWNER: steve.robb #ROBOMERGE-AUTHOR: steve.robb #ROBOMERGE-SOURCE: CL 20647443 via CL 20648283 via CL 20648315 #ROBOMERGE-BOT: UE5 (Release-Engine-Staging -> Main) (v955-20579017) [CL 20651786 by steve robb in ue5-main branch]
2022-06-14 12:46:34 -04:00
// IMPLEMENT_CUSTOM_SIMPLE_AUTOMATION_TEST(FObjectPtrTestExternalPackages, FObjectPtrTestBase, TEXT(TEST_NAME_ROOT ".ExternalPackages"), ObjectPtrTestFlags)
Avoid resolving wrapped object pointer references when serializing to archive for memory counting purposes. #rb devin.doucette #preflight 60511dc194e6100001bf6338 [CL 15715895 by Zousar Shaker in ue5-main branch]
2021-03-16 17:53:58 -04:00
// bool FObjectPtrTestExternalPackages::RunTest(const FString& Parameters)
// {
// const FName TestExternalPackage1Name(TEXT("/Engine/Test/ObjectPtrExternalPackages1/Transient"));
// UPackage* TestExternalPackage1 = NewObject<UPackage>(nullptr, TestExternalPackage1Name, RF_Transient);
// TestExternalPackage1->SetPackageFlags(PKG_EditorOnly | PKG_ContainsMapData);
// TestExternalPackage1->AddToRoot();
// const FName TestPackage1Name(TEXT("/Engine/Test/ObjectPtrExternalPackages1/Transient"));
// UPackage* TestPackage1 = NewObject<UPackage>(nullptr, TestPackage1Name, RF_Transient);
// TestPackage1->AddToRoot();
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
// UObject* TestOuter1 = NewObject<UObjectPtrTestClass>(TestPackage1, TEXT("TestOuter1"));
// UObject* TestOuter2 = NewObject<UObjectPtrTestClass>(TestPackage1, TEXT("TestOuter2"));
// UObject* TestOuter3 = NewObject<UObjectPtrTestClass>(TestPackage1, TEXT("TestOuter3"));
// UObject* TestOuter4 = NewObject<UObjectPtrTestClass>(TestPackage1, TEXT("TestOuter4"));
Avoid resolving wrapped object pointer references when serializing to archive for memory counting purposes. #rb devin.doucette #preflight 60511dc194e6100001bf6338 [CL 15715895 by Zousar Shaker in ue5-main branch]
2021-03-16 17:53:58 -04:00
support for TObjectPtr handling renames and GetTypeHash(TObjectPtr) no long has to resolve GetTypeHash will create a packaged object ref for hashing if the class is defined as lazy load otherwise raw pointer is hashed a map was added for moved objects and ObjectPathId can be a WeakObjectPtr the map allows UObjects to be mapped back to packed object refs #rb zousar.shaker https://p4-swarm.epicgames.net/reviews/23356491 #preflight 63b5de641c35d1cbdbccecf7 #preflight 63b70406e26e31879b8aa6d3 [CL 23589497 by joe pribele in ue5-main branch]
2023-01-05 12:27:16 -05:00
// UObject* TestPublicObject = NewObject<UObjectPtrTestClass>(TestOuter4, TEXT("TestPublicObject"), RF_Public);
Avoid resolving wrapped object pointer references when serializing to archive for memory counting purposes. #rb devin.doucette #preflight 60511dc194e6100001bf6338 [CL 15715895 by Zousar Shaker in ue5-main branch]
2021-03-16 17:53:58 -04:00
// TestPublicObject->SetExternalPackage(TestExternalPackage1);
// TestPackage1->RemoveFromRoot();
// TestExternalPackage1->RemoveFromRoot();
// return true;
// }
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
// @TODO: OBJPTR: We should have a test that ensures that we can (de)serialize an FObjectPtr to FLinkerSave/FLinkerLoad and that upon load the object
// pointer is not resolved if we are in a configuration that supports lazy load. This is proving difficult due to the restrictions around how
// FLinkerSave/FLinkerLoad is used.
Removal of TEXT literal concatenations, which doesn't work in UTF-8 mode. #rb devin.doucette #jira UE-132142 #preflight 62a8748fa76c84377748036b #ROBOMERGE-OWNER: steve.robb #ROBOMERGE-AUTHOR: steve.robb #ROBOMERGE-SOURCE: CL 20647443 via CL 20648283 via CL 20648315 #ROBOMERGE-BOT: UE5 (Release-Engine-Staging -> Main) (v955-20579017) [CL 20651786 by steve robb in ue5-main branch]
2022-06-14 12:46:34 -04:00
// IMPLEMENT_CUSTOM_SIMPLE_AUTOMATION_TEST(FObjectPtrTestLinkerSerializeBehavior, FObjectPtrTestBase, TEXT(TEST_NAME_ROOT ".LinkerSerialize"), ObjectPtrTestFlags)
Copying //UE5/Dev-Cooker@14539516 to Main (//UE5/Main) [CL 14539954 by Zousar Shaker in ue5-main branch]
2020-10-21 17:56:05 -04:00
// bool FObjectPtrTestLinkerSerializeBehavior::RunTest(const FString& Parameters)
// {
// FSnapshotObjectRefMetrics ObjectRefMetrics(*this);
// FObjectPtr DefaultTexturePtr(FObjectRef {FName("/Engine/EngineResources/DefaultTexture"), NAME_None, NAME_None, FObjectPathId("DefaultTexture")});
// TUniquePtr<FLinkerSave> Linker = TUniquePtr<FLinkerSave>(new FLinkerSave(nullptr /*InOuter*/, false /*bForceByteSwapping*/, true /*bSaveUnversioned*/));
// return true;
// }
[CoreUObject] fix for TObjectPtr equals operator with multiple inheritance resolved pointers where comparing uintptr_t instead of the raw pointers which allow for inheritance #jira https://jira.it.epicgames.com/browse/UE-168013 #rb zousar.shaker #preflight 6356c19a9e14ee3c795a2b6f [CL 22731180 by joe pribele in ue5-main branch]
2022-10-24 13:12:36 -04:00
[CoreUObject] compile fix for Linux. moved test classes outside of namespace as that was causing problems for the compiler #preflight 6356dcc73a547c3da332a751 [CL 22733737 by joe pribele in ue5-main branch]
2022-10-24 15:11:24 -04:00
#endif
class UForwardDeclaredObjDerived: public UObject {};
class FForwardDeclaredNotObjDerived {};
}
#if WITH_LOW_LEVEL_TESTS
//bunch of class to reproduce multiple inheritance issues.
//need to live outside of the namespace be IMPLEMENT_CORE_INTRINSIC_CLASS don't like namespaces
[CoreUObject] fix for TObjectPtr equals operator with multiple inheritance resolved pointers where comparing uintptr_t instead of the raw pointers which allow for inheritance #jira https://jira.it.epicgames.com/browse/UE-168013 #rb zousar.shaker #preflight 6356c19a9e14ee3c795a2b6f [CL 22731180 by joe pribele in ue5-main branch]
2022-10-24 13:12:36 -04:00
class FTestBaseClass
{
public:
virtual ~FTestBaseClass() = default;
virtual void VirtFunc() { };
};
class UMiddleClass : public UObject, public FTestBaseClass
{
DECLARE_CLASS_INTRINSIC(UMiddleClass, UObject, CLASS_MatchedSerializers, TEXT("/Script/CoreUObject"))
public:
virtual void VirtFunc() override { };
};
class FAnotherBaseClass
{
public:
virtual ~FAnotherBaseClass() = default;
virtual void AnotherVirtFunc() { };
};
class UDerrivedClass : public UMiddleClass, public FAnotherBaseClass
{
DECLARE_CLASS_INTRINSIC(UDerrivedClass, UMiddleClass, CLASS_MatchedSerializers, TEXT("/Script/CoreUObject"))
public:
virtual void AnotherVirtFunc() override { };
};
IMPLEMENT_CORE_INTRINSIC_CLASS(UMiddleClass, UObject,
{
}
);
IMPLEMENT_CORE_INTRINSIC_CLASS(UDerrivedClass, UMiddleClass,
{
}
);
TEST_CASE("CoreUObject::TObjectPtr::TestEquals")
{
const FName TestPackageName(TEXT("/Engine/Test/TestEquals/Transient"));
UPackage* TestPackage = NewObject<UPackage>(nullptr, TestPackageName, RF_Transient);
TestPackage->AddToRoot();
UDerrivedClass* Obj = NewObject<UDerrivedClass>(TestPackage, TEXT("DefaultSerializeObject"));
FTestBaseClass* BasePtr = Obj;
TObjectPtr<UDerrivedClass> ObjPtr(Obj);
CHECK(BasePtr == ObjPtr);
}
code cleanup of ObjectHandle made ObjectPathId to private trimmed down the public API as much as possible https://p4-swarm.epicgames.net/reviews/23658342 #rb zousar.shaker #preflight 63c5c8922a6acaf1625fcf25 [CL 23734208 by joe pribele in ue5-main branch]
2023-01-16 19:20:47 -05:00
#endif
Reference in New Issue Copy Permalink