608 lines
24 KiB
C++
608 lines
24 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "HeadlessChaosApp.h"
|
|
|
|
#include "HeadlessChaos.h"
|
|
#include "HeadlessChaosTestBP.h"
|
|
#include "HeadlessChaosTestBroadphase.h"
|
|
#include "HeadlessChaosTestCloth.h"
|
|
#include "HeadlessChaosTestClustering.h"
|
|
#include "HeadlessChaosTestCollisions.h"
|
|
#include "HeadlessChaosTestForces.h"
|
|
#include "HeadlessChaosTestGJK.h"
|
|
#include "HeadlessChaosTestImplicits.h"
|
|
#include "HeadlessChaosTestRaycast.h"
|
|
#include "HeadlessChaosTestSerialization.h"
|
|
#include "HeadlessChaosTestSpatialHashing.h"
|
|
#include "HeadlessChaosTestTriangleMesh.h"
|
|
#include "Modules/ModuleManager.h"
|
|
#include "RequiredProgramMainCPPInclude.h"
|
|
#include "Chaos/PBDRigidsEvolution.h"
|
|
#include "Chaos/PBDJointConstraints.h"
|
|
#include "Chaos/Box.h"
|
|
#include "Chaos/Sphere.h"
|
|
#include "Chaos/Utilities.h"
|
|
#include "HeadlessChaosTestParticleHandle.h"
|
|
#include "HeadlessChaosTestClustering.h"
|
|
#include "HeadlessChaosTestSerialization.h"
|
|
#include "HeadlessChaosTestBP.h"
|
|
#include "HeadlessChaosTestRaycast.h"
|
|
#include "HeadlessChaosTestSweep.h"
|
|
#include "HeadlessChaosTestOverlap.h"
|
|
#include "HeadlessChaosTestGJK.h"
|
|
#include "HeadlessChaosTestEPA.h"
|
|
#include "HeadlessChaosTestBroadphase.h"
|
|
#include "HeadlessChaosTestMostOpposing.h"
|
|
#include "HeadlessChaosTestSolverCommandList.h"
|
|
#include "HeadlessChaosTestSolverProxies.h"
|
|
#include "HeadlessChaosTestHandles.h"
|
|
#include "HeadlessChaosCache.h"
|
|
|
|
|
|
#include "GeometryCollection/GeometryCollectionTest.h"
|
|
#include "GeometryCollection/GeometryCollectionTestBoneHierarchy.h"
|
|
#include "GeometryCollection/GeometryCollectionTestClean.h"
|
|
#include "GeometryCollection/GeometryCollectionTestClustering.h"
|
|
#include "GeometryCollection/GeometryCollectionTestCollisionResolution.h"
|
|
#include "GeometryCollection/GeometryCollectionTestCreation.h"
|
|
#include "GeometryCollection/GeometryCollectionTestDecimation.h"
|
|
#include "GeometryCollection/GeometryCollectionTestFields.h"
|
|
#include "GeometryCollection/GeometryCollectionTestImplicitCapsule.h"
|
|
#include "GeometryCollection/GeometryCollectionTestImplicitCylinder.h"
|
|
#include "GeometryCollection/GeometryCollectionTestImplicitSphere.h"
|
|
#include "GeometryCollection/GeometryCollectionTestInitilization.h"
|
|
#include "GeometryCollection/GeometryCollectionTestMassProperties.h"
|
|
#include "GeometryCollection/GeometryCollectionTestMatrices.h"
|
|
#include "GeometryCollection/GeometryCollectionTestProximity.h"
|
|
#include "GeometryCollection/GeometryCollectionTestResponse.h"
|
|
#include "GeometryCollection/GeometryCollectionTestSimulation.h"
|
|
#include "GeometryCollection/GeometryCollectionTestSimulationField.h"
|
|
#include "GeometryCollection/GeometryCollectionTestSimulationSolver.h"
|
|
#include "GeometryCollection/GeometryCollectionTestSimulationStreaming.h"
|
|
#include "GeometryCollection/GeometryCollectionTestSpatialHash.h"
|
|
#include "GeometryCollection/GeometryCollectionTestVisibility.h"
|
|
#include "GeometryCollection/GeometryCollectionTestEvents.h"
|
|
#include "GeometryCollection/GeometryCollectionTestSerialization.h"
|
|
|
|
#include "CompGeom/ExactPredicates.h"
|
|
|
|
IMPLEMENT_APPLICATION(HeadlessChaos, "HeadlessChaos");
|
|
|
|
#define LOCTEXT_NAMESPACE "HeadlessChaos"
|
|
|
|
DEFINE_LOG_CATEGORY(LogHeadlessChaos);
|
|
|
|
TEST(ImplicitTests, Implicit) {
|
|
ChaosTest::ImplicitPlane();
|
|
ChaosTest::ImplicitTetrahedron();
|
|
ChaosTest::ImplicitCube();
|
|
ChaosTest::ImplicitSphere();
|
|
ChaosTest::ImplicitCylinder();
|
|
ChaosTest::ImplicitTaperedCylinder();
|
|
ChaosTest::ImplicitTaperedCapsule();
|
|
ChaosTest::ImplicitCapsule();
|
|
ChaosTest::ImplicitScaled();
|
|
ChaosTest::ImplicitScaled2();
|
|
ChaosTest::ImplicitTransformed();
|
|
ChaosTest::ImplicitIntersection();
|
|
ChaosTest::ImplicitUnion();
|
|
ChaosTest::UpdateImplicitUnion();
|
|
// @todo: Make this work at some point
|
|
//ChaosTest::ImplicitLevelset();
|
|
|
|
SUCCEED();
|
|
}
|
|
|
|
TEST(ImplicitTests, Rasterization) {
|
|
ChaosTest::RasterizationImplicit();
|
|
ChaosTest::RasterizationImplicitWithHole();
|
|
}
|
|
|
|
TEST(ImplicitTests, ConvexHull) {
|
|
ChaosTest::ConvexHull();
|
|
ChaosTest::ConvexHull2();
|
|
ChaosTest::Simplify();
|
|
}
|
|
|
|
TEST(CollisionTests, Collisions) {
|
|
GEnsureOnNANDiagnostic = 1;
|
|
|
|
ChaosTest::LevelsetConstraint();
|
|
// ChaosTest::LevelsetConstraintGJK();
|
|
ChaosTest::CollisionBoxPlane();
|
|
ChaosTest::CollisionBoxPlaneZeroResitution();
|
|
ChaosTest::CollisionBoxPlaneRestitution();
|
|
ChaosTest::CollisionCubeCubeRestitution();
|
|
ChaosTest::CollisionBoxToStaticBox();
|
|
ChaosTest::CollisionCapsuleCapsule();
|
|
ChaosTest::CollisionConvexConvex();
|
|
|
|
// @ todo: Make this work at some point
|
|
//ChaosTest::SpatialHashing();
|
|
|
|
SUCCEED();
|
|
}
|
|
|
|
TEST(Clustering, Clustering) {
|
|
ChaosTest::ImplicitCluster();
|
|
ChaosTest::FractureCluster();
|
|
ChaosTest::PartialFractureCluster();
|
|
SUCCEED();
|
|
}
|
|
|
|
TEST(SerializationTests, Serialization) {
|
|
// LWC-TODO : re-enable that when we have proper double serialization in LWC mode
|
|
#if 0
|
|
ChaosTest::SimpleTypesSerialization();
|
|
#endif
|
|
ChaosTest::SimpleObjectsSerialization();
|
|
ChaosTest::SharedObjectsSerialization();
|
|
ChaosTest::GraphSerialization();
|
|
ChaosTest::ObjectUnionSerialization();
|
|
ChaosTest::ParticleSerialization();
|
|
ChaosTest::BVHSerialization();
|
|
ChaosTest::RigidParticlesSerialization();
|
|
ChaosTest::BVHParticlesSerialization();
|
|
ChaosTest::HeightFieldSerialization();
|
|
SUCCEED();
|
|
}
|
|
|
|
TEST(BroadphaseTests, Broadphase) {
|
|
ChaosTest::BPPerfTest();
|
|
//ChaosTest::SpatialAccelerationDirtyAndGlobalQueryStrestTest();
|
|
SUCCEED();
|
|
}
|
|
|
|
//TEST(ClothTests, DeformableGravity) {
|
|
// ChaosTest::DeformableGravity();
|
|
//
|
|
// SUCCEED();
|
|
//}
|
|
//
|
|
//TEST(ClothTests, EdgeConstraints) {
|
|
// ChaosTest::EdgeConstraints();
|
|
//
|
|
// SUCCEED();
|
|
//}
|
|
|
|
TEST(ClothTests, ClothCollection) {
|
|
ChaosTest::ClothCollection();
|
|
SUCCEED();
|
|
}
|
|
|
|
TEST(RaycastTests, Raycast) {
|
|
ChaosTest::SphereRaycast();
|
|
ChaosTest::PlaneRaycast();
|
|
//ChaosTest::CylinderRaycast();
|
|
//ChaosTest::TaperedCylinderRaycast();
|
|
ChaosTest::CapsuleRaycast();
|
|
ChaosTest::CapsuleRaycastFastLargeDistance();
|
|
ChaosTest::CapsuleRaycastMissWithEndPointOnBounds();
|
|
ChaosTest::TriangleRaycast();
|
|
ChaosTest::TriangleRaycastDenegerated();
|
|
ChaosTest::BoxRaycast();
|
|
ChaosTest::VectorizedAABBRaycast();
|
|
ChaosTest::ScaledRaycast();
|
|
//ChaosTest::TransformedRaycast();
|
|
//ChaosTest::UnionRaycast();
|
|
//ChaosTest::IntersectionRaycast();
|
|
|
|
SUCCEED();
|
|
}
|
|
|
|
TEST(SweepTests, Sweep) {
|
|
ChaosTest::CapsuleSweepAgainstTriMeshReal();
|
|
|
|
SUCCEED();
|
|
}
|
|
|
|
// This test is disabled until we implement local clipping feature
|
|
TEST(SweepTests, DISABLED_LargeSweep)
|
|
{
|
|
ChaosTest::GJKLargeDistanceCapsuleSweep();
|
|
|
|
SUCCEED();
|
|
}
|
|
|
|
TEST(OverlapTests, Overlap) {
|
|
ChaosTest::OverlapTriMesh();
|
|
|
|
SUCCEED();
|
|
}
|
|
|
|
TEST(MostOpposingTests, MostOpposing) {
|
|
ChaosTest::TrimeshMostOpposing();
|
|
ChaosTest::ConvexMostOpposing();
|
|
ChaosTest::ScaledMostOpposing();
|
|
|
|
SUCCEED();
|
|
}
|
|
|
|
TEST(GJK, Simplexes) {
|
|
ChaosTest::SimplexLine();
|
|
ChaosTest::SimplexTriangle();
|
|
ChaosTest::SimplexTetrahedron();
|
|
|
|
SUCCEED();
|
|
}
|
|
|
|
TEST(GJK, GJKIntersectTests) {
|
|
ChaosTest::GJKSphereSphereTest();
|
|
ChaosTest::GJKSphereBoxTest();
|
|
ChaosTest::GJKSphereCapsuleTest();
|
|
ChaosTest::GJKSphereConvexTest();
|
|
ChaosTest::GJKSphereScaledSphereTest();
|
|
|
|
SUCCEED();
|
|
}
|
|
|
|
TEST(GJK, GJKRaycastTests) {
|
|
ChaosTest::GJKSphereSphereSweep();
|
|
ChaosTest::GJKSphereBoxSweep();
|
|
ChaosTest::GJKSphereCapsuleSweep();
|
|
ChaosTest::GJKSphereConvexSweep();
|
|
ChaosTest::GJKSphereScaledSphereSweep();
|
|
ChaosTest::GJKBoxCapsuleSweep();
|
|
ChaosTest::GJKBoxBoxSweep();
|
|
ChaosTest::GJKCapsuleConvexInitialOverlapSweep();
|
|
ChaosTest::GJKConvexCapsule();
|
|
SUCCEED();
|
|
}
|
|
|
|
TEST(EPA, EPATests) {
|
|
ChaosTest::EPAInitTest();
|
|
ChaosTest::EPASimpleTest();
|
|
SUCCEED();
|
|
}
|
|
|
|
TEST(BP, BroadphaseTests) {
|
|
ChaosTest::AABBTreeDirtyGridFunctionsWithEdgeCase();
|
|
ChaosTest::GridBPTest();
|
|
ChaosTest::GridBPEarlyExitTest();
|
|
ChaosTest::GridBPTest2();
|
|
ChaosTest::AABBTreeTest();
|
|
ChaosTest::AABBTreeTestDynamic();
|
|
ChaosTest::AABBTreeDirtyTreeTest();
|
|
ChaosTest::AABBTreeDirtyGridTest();
|
|
ChaosTest::AABBTreeTimesliceTest();
|
|
ChaosTest::DoForSweepIntersectCellsImpTest();
|
|
ChaosTest::BoundingVolumeNoBoundsTest();
|
|
ChaosTest::BroadphaseCollectionTest();
|
|
SUCCEED();
|
|
}
|
|
|
|
TEST(ParticleHandle, ParticleHandleTests)
|
|
{
|
|
ChaosTest::ParticleIteratorTest();
|
|
ChaosTest::ParticleHandleTest();
|
|
ChaosTest::AccelerationStructureHandleComparison();
|
|
ChaosTest::HandleObjectStateChangeTest();
|
|
SUCCEED();
|
|
}
|
|
|
|
TEST(Perf, PerfTests)
|
|
{
|
|
ChaosTest::EvolutionPerfHarness();
|
|
SUCCEED();
|
|
}
|
|
|
|
TEST(Handles, FrameworkTests)
|
|
{
|
|
ChaosTest::Handles::HandleArrayTest();
|
|
ChaosTest::Handles::HandleHeapTest();
|
|
ChaosTest::Handles::HandleSerializeTest();
|
|
ChaosTest::Handles::HandleArrayIteratorTest();
|
|
}
|
|
|
|
TEST(TriangleMesh, TriangleMeshTests) {
|
|
ChaosTest::TriangleMeshProjectTest();
|
|
SUCCEED();
|
|
}
|
|
|
|
//TEST(Vehicle, VehicleTests) {
|
|
//
|
|
// ChaosTest::SystemTemplateTest<float>();
|
|
//
|
|
// ChaosTest::AerofoilTestLiftDrag<float>();
|
|
//
|
|
// ChaosTest::TransmissionTestManualGearSelection<float>();
|
|
// ChaosTest::TransmissionTestAutoGearSelection<float>();
|
|
// ChaosTest::TransmissionTestGearRatios<float>();
|
|
//
|
|
// ChaosTest::EngineRPM<float>();
|
|
//
|
|
// ChaosTest::WheelLateralSlip<float>();
|
|
// ChaosTest::WheelBrakingLongitudinalSlip<float>();
|
|
// ChaosTest::WheelAcceleratingLongitudinalSlip<float>();
|
|
//
|
|
// ChaosTest::SuspensionForce<float>();
|
|
//}
|
|
|
|
|
|
//////////////////////////////////////////////////////////
|
|
///// GEOMETRY COLLECTION ///////////////////////////////
|
|
|
|
|
|
// Matrices Tests
|
|
TEST(GeometryCollection_MatricesTest,BasicGlobalMatrices) { GeometryCollectionTest::BasicGlobalMatrices();SUCCEED(); }
|
|
TEST(GeometryCollection_MatricesTest,TransformMatrixElement) { GeometryCollectionTest::TransformMatrixElement(); SUCCEED(); }
|
|
TEST(GeometryCollection_MatricesTest,ReparentingMatrices) { GeometryCollectionTest::ReparentingMatrices(); SUCCEED(); }
|
|
|
|
// Creation Tests CollectionCycleTest
|
|
TEST(GeometryCollection_CreationTest, CheckClassTypes) { GeometryCollectionTest::CheckClassTypes(); SUCCEED(); }
|
|
TEST(GeometryCollection_CreationTest, CheckIncrementMask) { GeometryCollectionTest::CheckIncrementMask(); SUCCEED(); }
|
|
TEST(GeometryCollection_CreationTest,Creation) { GeometryCollectionTest::Creation(); SUCCEED(); }
|
|
TEST(GeometryCollection_CreationTest,Empty) { GeometryCollectionTest::Empty(); SUCCEED(); }
|
|
TEST(GeometryCollection_CreationTest,AppendTransformHierarchy) { GeometryCollectionTest::AppendTransformHierarchy(); SUCCEED(); }
|
|
TEST(GeometryCollection_CreationTest,ParentTransformTest) { GeometryCollectionTest::ParentTransformTest(); SUCCEED(); }
|
|
TEST(GeometryCollection_CreationTest,DeleteFromEnd) { GeometryCollectionTest::DeleteFromEnd(); SUCCEED(); }
|
|
TEST(GeometryCollection_CreationTest,DeleteFromStart) { GeometryCollectionTest::DeleteFromStart(); SUCCEED(); }
|
|
TEST(GeometryCollection_CreationTest,DeleteFromMiddle) { GeometryCollectionTest::DeleteFromMiddle(); SUCCEED(); }
|
|
TEST(GeometryCollection_CreationTest,DeleteBranch) { GeometryCollectionTest::DeleteBranch(); SUCCEED(); }
|
|
TEST(GeometryCollection_CreationTest,DeleteRootLeafMiddle) { GeometryCollectionTest::DeleteRootLeafMiddle(); SUCCEED(); }
|
|
TEST(GeometryCollection_CreationTest,DeleteEverything) { GeometryCollectionTest::DeleteEverything(); SUCCEED(); }
|
|
TEST(GeometryCollection_CreationTest,ReindexMaterialsTest) { GeometryCollectionTest::ReindexMaterialsTest(); SUCCEED(); }
|
|
TEST(GeometryCollection_CreationTest,ContiguousElementsTest) { GeometryCollectionTest::ContiguousElementsTest(); SUCCEED(); }
|
|
TEST(GeometryCollection_CreationTest, AttributeDependencyTest) { GeometryCollectionTest::AttributeDependencyTest(); SUCCEED(); }
|
|
TEST(GeometryCollection_CreationTest, IntListReindexOnDeletionTest) { GeometryCollectionTest::IntListReindexOnDeletionTest(); SUCCEED(); }
|
|
TEST(GeometryCollection_CreationTest, IntListSelfDependencyTest) { GeometryCollectionTest::IntListSelfDependencyTest(); SUCCEED(); }
|
|
TEST(GeometryCollection_CreationTest, AppendManagedArrayCollectionTest) { GeometryCollectionTest::AppendManagedArrayCollectionTest(); SUCCEED(); }
|
|
TEST(GeometryCollection_CreationTest, AppendTransformCollectionTest) { GeometryCollectionTest::AppendTransformCollectionTest(); SUCCEED(); }
|
|
TEST(GeometryCollection_CreationTest, CollectionCycleTest) { GeometryCollectionTest::CollectionCycleTest(); SUCCEED(); }
|
|
|
|
|
|
// Proximity Tests
|
|
TEST(GeometryCollection_ProximityTest,BuildProximity) { GeometryCollectionTest::BuildProximity(); SUCCEED(); }
|
|
TEST(GeometryCollection_ProximityTest,GeometryDeleteFromStart) { GeometryCollectionTest::GeometryDeleteFromStart(); SUCCEED(); }
|
|
TEST(GeometryCollection_ProximityTest,GeometryDeleteFromEnd) { GeometryCollectionTest::GeometryDeleteFromEnd(); SUCCEED(); }
|
|
TEST(GeometryCollection_ProximityTest,GeometryDeleteFromMiddle) { GeometryCollectionTest::GeometryDeleteFromMiddle(); SUCCEED(); }
|
|
TEST(GeometryCollection_ProximityTest,GeometryDeleteMultipleFromMiddle) { GeometryCollectionTest::GeometryDeleteMultipleFromMiddle(); SUCCEED(); }
|
|
TEST(GeometryCollection_ProximityTest,GeometryDeleteRandom) { GeometryCollectionTest::GeometryDeleteRandom(); SUCCEED(); }
|
|
TEST(GeometryCollection_ProximityTest,GeometryDeleteRandom2) { GeometryCollectionTest::GeometryDeleteRandom2(); SUCCEED(); }
|
|
TEST(GeometryCollection_ProximityTest,GeometryDeleteAll) { GeometryCollectionTest::GeometryDeleteAll(); SUCCEED(); }
|
|
TEST(GeometryCollection_ProximityTest,GeometrySwapFlat) { GeometryCollectionTest::GeometrySwapFlat(); SUCCEED(); }
|
|
TEST(GeometryCollection_ProximityTest,TestFracturedGeometry) { GeometryCollectionTest::TestFracturedGeometry(); SUCCEED(); }
|
|
|
|
// Clean Tests
|
|
TEST(GeometryCollection_CleanTest,TestDeleteCoincidentVertices) { GeometryCollectionTest::TestDeleteCoincidentVertices(); SUCCEED(); }
|
|
TEST(GeometryCollection_CleanTest,TestDeleteCoincidentVertices2) { GeometryCollectionTest::TestDeleteCoincidentVertices2(); SUCCEED(); }
|
|
TEST(GeometryCollection_CleanTest,TestDeleteZeroAreaFaces) { GeometryCollectionTest::TestDeleteZeroAreaFaces(); SUCCEED(); }
|
|
TEST(GeometryCollection_CleanTest,TestDeleteHiddenFaces) { GeometryCollectionTest::TestDeleteHiddenFaces(); SUCCEED(); }
|
|
TEST(GeometryCollection_CleanTest,TestFillHoles) { GeometryCollectionTest::TestFillHoles(); SUCCEED(); }
|
|
|
|
// SpatialHash Tests
|
|
TEST(GeometryCollection_SpatialHashTest,GetClosestPointsTest1) { GeometryCollectionTest::GetClosestPointsTest1(); SUCCEED(); }
|
|
TEST(GeometryCollection_SpatialHashTest,GetClosestPointsTest2) { GeometryCollectionTest::GetClosestPointsTest2(); SUCCEED(); }
|
|
TEST(GeometryCollection_SpatialHashTest,GetClosestPointsTest3) { GeometryCollectionTest::GetClosestPointsTest3(); SUCCEED(); }
|
|
TEST(GeometryCollection_SpatialHashTest,GetClosestPointTest) { GeometryCollectionTest::GetClosestPointTest(); SUCCEED(); }
|
|
TEST(GeometryCollection_SpatialHashTest,HashTableUpdateTest) { GeometryCollectionTest::HashTableUpdateTest(); SUCCEED(); }
|
|
TEST(GeometryCollection_SpatialHashTest,HashTablePressureTest) { GeometryCollectionTest::HashTablePressureTest(); SUCCEED(); }
|
|
|
|
// HideVertices Test
|
|
TEST(GeometryCollection_HideVerticesTest,TestHideVertices) { GeometryCollectionTest::TestHideVertices(); SUCCEED(); }
|
|
|
|
// Object Collision Test
|
|
//TEST(GeometryCollection_CollisionTest, DISABLED_TestGeometryDecimation) { GeometryCollectionTest::TestGeometryDecimation(); SUCCEED(); } Fix or remove support for decimation
|
|
TEST(GeometryCollection_CollisionTest,TestImplicitCapsule) { GeometryCollectionTest::TestImplicitCapsule(); SUCCEED(); }
|
|
TEST(GeometryCollection_CollisionTest,TestImplicitCylinder) { GeometryCollectionTest::TestImplicitCylinder(); SUCCEED(); }
|
|
TEST(GeometryCollection_CollisionTest,TestImplicitSphere) { GeometryCollectionTest::TestImplicitSphere(); SUCCEED(); }
|
|
TEST(GeometryCollection_CollisionTest,TestImplicitBoneHierarchy) { GeometryCollectionTest::TestImplicitBoneHierarchy(); SUCCEED(); }
|
|
|
|
// Fields Tests
|
|
TEST(GeometryCollection_FieldTest,Fields_NoiseSample) { GeometryCollectionTest::Fields_NoiseSample(); SUCCEED(); }
|
|
TEST(GeometryCollection_FieldTest,Fields_RadialIntMask) { GeometryCollectionTest::Fields_RadialIntMask(); SUCCEED(); }
|
|
TEST(GeometryCollection_FieldTest,Fields_RadialFalloff) { GeometryCollectionTest::Fields_RadialFalloff(); SUCCEED(); }
|
|
TEST(GeometryCollection_FieldTest,Fields_PlaneFalloff) { GeometryCollectionTest::Fields_PlaneFalloff(); SUCCEED(); }
|
|
TEST(GeometryCollection_FieldTest,Fields_UniformVector) { GeometryCollectionTest::Fields_UniformVector(); SUCCEED(); }
|
|
TEST(GeometryCollection_FieldTest,Fields_RaidalVector) { GeometryCollectionTest::Fields_RaidalVector(); SUCCEED(); }
|
|
TEST(GeometryCollection_FieldTest,Fields_SumVectorFullMult) { GeometryCollectionTest::Fields_SumVectorFullMult(); SUCCEED(); }
|
|
TEST(GeometryCollection_FieldTest,Fields_SumVectorFullDiv) { GeometryCollectionTest::Fields_SumVectorFullDiv(); SUCCEED(); }
|
|
TEST(GeometryCollection_FieldTest,Fields_SumVectorFullAdd) { GeometryCollectionTest::Fields_SumVectorFullAdd(); SUCCEED(); }
|
|
TEST(GeometryCollection_FieldTest,Fields_SumVectorFullSub) { GeometryCollectionTest::Fields_SumVectorFullSub(); SUCCEED(); }
|
|
TEST(GeometryCollection_FieldTest,Fields_SumVectorLeftSide) { GeometryCollectionTest::Fields_SumVectorLeftSide(); SUCCEED(); }
|
|
TEST(GeometryCollection_FieldTest,Fields_SumVectorRightSide) { GeometryCollectionTest::Fields_SumVectorRightSide(); SUCCEED(); }
|
|
TEST(GeometryCollection_FieldTest,Fields_SumScalar) { GeometryCollectionTest::Fields_SumScalar(); SUCCEED(); }
|
|
TEST(GeometryCollection_FieldTest,Fields_SumScalarRightSide) { GeometryCollectionTest::Fields_SumScalarRightSide(); SUCCEED(); }
|
|
TEST(GeometryCollection_FieldTest,Fields_SumScalarLeftSide) { GeometryCollectionTest::Fields_SumScalarLeftSide(); SUCCEED(); }
|
|
TEST(GeometryCollection_FieldTest,Fields_Culling) { GeometryCollectionTest::Fields_Culling(); SUCCEED(); }
|
|
TEST(GeometryCollection_FieldTest,Fields_SerializeAPI) { GeometryCollectionTest::Fields_SerializeAPI(); SUCCEED(); }
|
|
|
|
// Cache track compression
|
|
TEST(ChaosCacheTests, TrackCompression)
|
|
{
|
|
ChaosTest::ChaosCache::TrackCompressionTest();
|
|
SUCCEED();
|
|
}
|
|
|
|
GTEST_TEST(ArrayTests, TestArrayMax)
|
|
{
|
|
// The first 3 arrays without Reserve will over-allocate. We aren't testing anything
|
|
// useful on these - they are just here for examples...
|
|
|
|
// This allocates space for 4 elements
|
|
TArray<int32> Ints1;
|
|
Ints1.SetNum(1);
|
|
EXPECT_LE(Ints1.Num(), Ints1.Max());
|
|
|
|
// This allocates space for 5 elements
|
|
TArray<int32> Ints2;
|
|
Ints2.SetNum(5);
|
|
EXPECT_LE(Ints2.Num(), Ints2.Max());
|
|
|
|
// This allocates space for 4 elements and grows to 22 elements
|
|
TArray<int32> Ints3;
|
|
Ints3.SetNum(1);
|
|
Ints3.SetNum(5);
|
|
EXPECT_LE(Ints3.Num(), Ints3.Max());
|
|
|
|
// We rely on tight-fitting arrays for memory conservation. Make sure that the
|
|
// default Reserve policy still enforces tight-fitting arrays.
|
|
TArray<int32> Ints4;
|
|
Ints4.Reserve(1);
|
|
Ints4.SetNum(1);
|
|
EXPECT_EQ(Ints4.Max(), Ints4.Num());
|
|
|
|
TArray<int32> Ints5;
|
|
Ints5.Reserve(5);
|
|
Ints5.SetNum(5);
|
|
EXPECT_EQ(Ints5.Max(), Ints5.Num());
|
|
|
|
TArray<int32> Ints6;
|
|
Ints6.Reserve(1);
|
|
Ints6.SetNum(1);
|
|
Ints6.Reserve(5);
|
|
Ints6.SetNum(5);
|
|
EXPECT_EQ(Ints6.Max(), Ints6.Num());
|
|
|
|
// Reset also sets the exact buffer size and we are relying on that too
|
|
TArray<int32> Ints7;
|
|
Ints7.Reset(1);
|
|
Ints7.SetNum(1);
|
|
EXPECT_EQ(Ints7.Max(), Ints7.Num());
|
|
|
|
TArray<int32> Ints8;
|
|
Ints8.Reset(5);
|
|
Ints8.SetNum(5);
|
|
EXPECT_EQ(Ints8.Max(), Ints8.Num());
|
|
|
|
TArray<int32> Ints9;
|
|
Ints9.Reset(1);
|
|
Ints9.SetNum(1);
|
|
Ints9.Reset(5);
|
|
Ints9.SetNum(5);
|
|
EXPECT_EQ(Ints9.Max(), Ints9.Num());
|
|
|
|
}
|
|
|
|
//TEST(GeometryCollectionTest,RigidBodies_CollisionGroup); // fix me
|
|
//
|
|
// Broken
|
|
//
|
|
|
|
/*
|
|
TEST(GeometryCollectionTest, RigidBodies_ClusterTest_KinematicAnchor) { GeometryCollectionTest::RigidBodies_ClusterTest_KinematicAnchor<float>(); SUCCEED(); }
|
|
TEST(GeometryCollectionTest, RigidBodies_ClusterTest_StaticAnchor) { GeometryCollectionTest::RigidBodies_ClusterTest_StaticAnchor<float>(); SUCCEED(); }
|
|
TEST(GeometryCollectionTest, RigidBodies_ClusterTest_ReleaseClusterParticles_AllLeafNodes) { GeometryCollectionTest::RigidBodies_ClusterTest_ReleaseClusterParticles_AllLeafNodes<float>(); SUCCEED(); }
|
|
TEST(GeometryCollectionTest, RigidBodies_ClusterTest_ReleaseClusterParticles_ClusterNodeAndSubClusterNode) { GeometryCollectionTest::RigidBodies_ClusterTest_ReleaseClusterParticles_ClusterNodeAndSubClusterNode<float>(); SUCCEED(); }
|
|
TEST(GeometryCollectionTest, RigidBodies_ClusterTest_RemoveOnFracture) { GeometryCollectionTest::RigidBodies_ClusterTest_RemoveOnFracture<float>(); SUCCEED(); }
|
|
TEST(GeometryCollectionTest, RigidBodiess_ClusterTest_ParticleImplicitCollisionGeometry) { GeometryCollectionTest::RigidBodiess_ClusterTest_ParticleImplicitCollisionGeometry<float>(); SUCCEED(); }
|
|
*/
|
|
|
|
|
|
// SimulationStreaming Tests
|
|
// broken and/or crashing
|
|
/*
|
|
TEST(GeometryCollectionTest, RigidBodies_Streaming_StartSolverEmpty) { GeometryCollectionTest::RigidBodies_Streaming_StartSolverEmpty<float>(); SUCCEED(); }
|
|
TEST(GeometryCollectionTest, RigidBodies_Streaming_BulkInitialization) { GeometryCollectionTest::RigidBodies_Streaming_BulkInitialization<float>(); SUCCEED(); }
|
|
TEST(GeometryCollectionTest, RigidBodies_Streaming_DeferedClusteringInitialization) { GeometryCollectionTest::RigidBodies_Streaming_DeferedClusteringInitialization<float>(); SUCCEED(); }
|
|
*/
|
|
|
|
|
|
// Secondary Particle Events
|
|
//TEST(GeometryCollectionTest, Solver_ValidateReverseMapping) { GeometryCollectionTest::Solver_ValidateReverseMapping<float>(); SUCCEED(); }
|
|
|
|
|
|
|
|
// Static and Skeletal Mesh Tests
|
|
// broken and/or crashing
|
|
/*
|
|
TEST(SkeletalMeshPhysicsProxyTest, RegistersCorrectly){GeometryCollectionTest::TestSkeletalMeshPhysicsProxy_Register<float>();SUCCEED();}
|
|
TEST(SkeletalMeshPhysicsProxyTest, KinematicBonesMoveCorrectly){GeometryCollectionTest::TestSkeletalMeshPhysicsProxy_Kinematic<float>();SUCCEED();}
|
|
TEST(SkeletalMeshPhysicsProxyTest, DynamicBonesMoveCorrectly){GeometryCollectionTest::TestSkeletalMeshPhysicsProxy_Dynamic<float>();SUCCEED();}
|
|
*/
|
|
|
|
// Serialization
|
|
TEST(GeometryCollectionSerializationTests,GeometryCollectionSerializesCorrectly){ GeometryCollectionTests::GeometryCollectionSerialization();SUCCEED(); }
|
|
|
|
|
|
/**/
|
|
|
|
class UEGTestPrinter : public ::testing::EmptyTestEventListener
|
|
{
|
|
virtual void OnTestStart(const ::testing::TestInfo& TestInfo)
|
|
{
|
|
UE_LOG(LogHeadlessChaos, Verbose, TEXT("Test %s.%s Starting"), *FString(TestInfo.test_case_name()), *FString(TestInfo.name()));
|
|
}
|
|
|
|
virtual void OnTestPartResult(const ::testing::TestPartResult& TestPartResult)
|
|
{
|
|
if (TestPartResult.failed())
|
|
{
|
|
UE_LOG(LogHeadlessChaos, Error, TEXT("FAILED in %s:%d\n%s"), *FString(TestPartResult.file_name()), TestPartResult.line_number(), *FString(TestPartResult.summary()))
|
|
}
|
|
else
|
|
{
|
|
UE_LOG(LogHeadlessChaos, Verbose, TEXT("Succeeded in %s:%d\n%s"), *FString(TestPartResult.file_name()), TestPartResult.line_number(), *FString(TestPartResult.summary()))
|
|
}
|
|
}
|
|
|
|
virtual void OnTestEnd(const ::testing::TestInfo& TestInfo)
|
|
{
|
|
UE_LOG(LogHeadlessChaos, Verbose, TEXT("Test %s.%s Ending"), *FString(TestInfo.test_case_name()), *FString(TestInfo.name()));
|
|
}
|
|
};
|
|
|
|
int32 tchar_main(int32 ArgC, TCHAR* ArgV[])
|
|
{
|
|
UE::Geometry::ExactPredicates::GlobalInit();
|
|
|
|
// start up the main loop
|
|
GEngineLoop.PreInit(ArgC, ArgV);
|
|
FModuleManager::Get().StartProcessingNewlyLoadedObjects();
|
|
|
|
::testing::InitGoogleTest(&ArgC, ArgV);
|
|
|
|
// Add a UE-formatting printer
|
|
::testing::TestEventListeners& Listeners = ::testing::UnitTest::GetInstance()->listeners();
|
|
Listeners.Append(new UEGTestPrinter);
|
|
|
|
ensure(RUN_ALL_TESTS() == 0);
|
|
|
|
RequestEngineExit(TEXT("Exiting"));
|
|
FEngineLoop::AppPreExit();
|
|
FModuleManager::Get().UnloadModulesAtShutdown();
|
|
FEngineLoop::AppExit();
|
|
|
|
return 0;
|
|
}
|
|
|
|
// We need to provide a non-wide main otherwise we default to one inside gtest
|
|
// which doesn't correctly initialise the tests.
|
|
int32 main(int32 ArgC, ANSICHAR* Utf8ArgV[])
|
|
{
|
|
// Allocated storage for TCHAR arguments
|
|
TCHAR** LocalArgs = new TCHAR* [ArgC];
|
|
|
|
// Gtest will directly modify the args array we pass in to the InitGoogleTest call
|
|
// so we need to pass it a copy of the pointers otherwise we lose track and leak
|
|
// the allocations for the args
|
|
TCHAR** PassthroughArgs = new TCHAR* [ArgC];
|
|
|
|
for(int32 ArgIndex = 0; ArgIndex < ArgC; ArgIndex++)
|
|
{
|
|
FUTF8ToTCHAR ConvertFromUtf8(Utf8ArgV[ArgIndex]);
|
|
LocalArgs[ArgIndex] = new TCHAR[ConvertFromUtf8.Length() + 1];
|
|
|
|
// Copy the pointer to give to Gtest
|
|
PassthroughArgs[ArgIndex] = LocalArgs[ArgIndex];
|
|
|
|
// Fill in the arg
|
|
FCString::Strncpy(LocalArgs[ArgIndex], ConvertFromUtf8.Get(), ConvertFromUtf8.Length() + 1);
|
|
}
|
|
|
|
// Run our actual test main
|
|
int32 Result = tchar_main(ArgC, PassthroughArgs);
|
|
|
|
for(int32 ArgIndex = 0; ArgIndex < ArgC; ArgIndex++)
|
|
{
|
|
delete[] LocalArgs[ArgIndex];
|
|
}
|
|
|
|
delete[] PassthroughArgs;
|
|
delete[] LocalArgs;
|
|
|
|
return Result;
|
|
}
|
|
|
|
#undef LOCTEXT_NAMESPACE
|