[Test] public void Not_equals_operator_false_for_identical_Coordinates()
{
var c1 = new Coordinates(10d, 20d, 30d);
var c2 = new Coordinates(10d, 20d, 30d);
Assert.IsFalse(c1 != c2);
}
public void Equals_operator_false_for_different_Coordinates()
{
var c1 = new Coordinates(10d, 20d, 30d);
var c2 = new Coordinates(40d, 50d, 60d);
Assert.IsFalse(c1 == c2);
}
public void EvaluateSkinnedMeshesOffscreenUpdate()
{
// Arrange
var profile = new CullingControllerProfile();
profile.shadowMapProjectionSizeThreshold = 6;
profile.shadowRendererSizeThreshold = 20;
profile.shadowDistanceThreshold = 15;
var settings = new CullingControllerSettings();
settings.enableAnimationCullingDistance = 20;
settings.enableAnimationCulling = true;
// Act
var farTest = CullingControllerUtils.TestSkinnedRendererOffscreenRule(settings, 30);
var nearTest = CullingControllerUtils.TestSkinnedRendererOffscreenRule(settings, 10);
settings.enableAnimationCulling = false;
var farTestWithCullingDisabled = CullingControllerUtils.TestSkinnedRendererOffscreenRule(settings, 30);
// Assert
Assert.IsTrue(nearTest);
Assert.IsFalse(farTest);
Assert.IsTrue(farTestWithCullingDisabled);
}
public unsafe void RigidBodyCalculateDistancePointTest()
{
Physics.RigidBody rigidbody = Unity.Physics.RigidBody.Zero;
const float size = 1.0f;
const float convexRadius = 0.0f;
var queryPos = new float3(-10, -10, -10);
rigidbody.Collider = (Collider *)BoxCollider.Create(float3.zero, quaternion.identity, new float3(size), convexRadius).GetUnsafePtr();
var pointDistanceInput = new PointDistanceInput();
pointDistanceInput.Position = queryPos;
pointDistanceInput.Filter = CollisionFilter.Default;
var closestHit = new DistanceHit();
var allHits = new NativeList <DistanceHit>(Allocator.Temp);
// OK case : with enough max distance
pointDistanceInput.MaxDistance = 10000.0f;
Assert.IsTrue(rigidbody.CalculateDistance(pointDistanceInput));
Assert.IsTrue(rigidbody.CalculateDistance(pointDistanceInput, out closestHit));
Assert.IsTrue(rigidbody.CalculateDistance(pointDistanceInput, ref allHits));
// Fail case : not enough max distance
pointDistanceInput.MaxDistance = 1;
Assert.IsFalse(rigidbody.CalculateDistance(pointDistanceInput));
Assert.IsFalse(rigidbody.CalculateDistance(pointDistanceInput, out closestHit));
Assert.IsFalse(rigidbody.CalculateDistance(pointDistanceInput, ref allHits));
}
public void ResetObjects()
{
// Arrange
GameObject go1 = new GameObject();
GameObject go2 = new GameObject();
var r = go1.AddComponent <MeshRenderer>();
var skr = go2.AddComponent <SkinnedMeshRenderer>();
var anim = go2.AddComponent <Animation>();
r.forceRenderingOff = true;
skr.updateWhenOffscreen = false;
anim.cullingType = AnimationCullingType.BasedOnRenderers;
var mockTracker = Substitute.For <ICullingObjectsTracker>();
cullingController = CreateMockedCulledController(null, null, mockTracker);
mockTracker.GetRenderers().Returns(info => go1.GetComponentsInChildren <Renderer>());
mockTracker.GetSkinnedRenderers().Returns(info => go2.GetComponentsInChildren <SkinnedMeshRenderer>());
mockTracker.GetAnimations().Returns(info => go2.GetComponentsInChildren <Animation>());
// Act
cullingController.ResetObjects();
// Assert
Assert.IsFalse(r.forceRenderingOff);
Assert.IsTrue(skr.updateWhenOffscreen);
Assert.IsTrue(anim.cullingType == AnimationCullingType.AlwaysAnimate);
// Annihilate
Object.Destroy(go1);
Object.Destroy(go2);
}
internal Entity Import(UnityEngine.Object obj)
{
if (obj == null || !obj)
{
return(Entity.Null);
}
var entity = Entity.Null;
var assetImporter = m_AssetImporters.Values.FirstOrDefault(x => x.CanImport(obj));
if (assetImporter != null)
{
entity = assetImporter.Import(this, obj);
if (entity != Entity.Null)
{
var guid = obj.GetGuid();
Assert.IsTrue(guid != Guid.Empty);
Assert.IsFalse(EntityManager.HasComponent <EntityGuid>(entity));
WorldManager.SetEntityGuid(entity, guid);
Assert.IsFalse(EntityManager.HasComponent <AssetReference>(entity));
EntityManager.AddComponentData(entity, obj.ToAssetReference());
}
}
return(entity);
}
unsafe public void TestCreateTriangle()
{
float3[] vertices =
{
new float3(-1.4f, 1.4f, 5.6f),
new float3(1.4f, 1.4f, 3.6f),
new float3(0.2f, 1.2f, 5.6f)
};
float3 normal = math.normalize(math.cross(vertices[1] - vertices[0], vertices[2] - vertices[0]));
var collider = PolygonCollider.CreateTriangle(vertices[0], vertices[1], vertices[2]);
var triangleCollider = UnsafeUtilityEx.AsRef <PolygonCollider>(collider.GetUnsafePtr());
Assert.IsTrue(triangleCollider.IsTriangle);
Assert.IsFalse(triangleCollider.IsQuad);
TestUtils.AreEqual(triangleCollider.Vertices[0], vertices[0], 1e-3f);
TestUtils.AreEqual(triangleCollider.Vertices[1], vertices[1], 1e-3f);
TestUtils.AreEqual(triangleCollider.Vertices[2], vertices[2], 1e-3f);
Assert.AreEqual(2, triangleCollider.Planes.Length);
TestUtils.AreEqual(normal, triangleCollider.Planes[0].Normal, 1e-3f);
TestUtils.AreEqual(-normal, triangleCollider.Planes[1].Normal, 1e-3f);
Assert.AreEqual(ColliderType.Triangle, triangleCollider.Type);
Assert.AreEqual(CollisionType.Convex, triangleCollider.CollisionType);
}
unsafe public void TestCreateQuad()
{
float3[] vertices =
{
new float3(-4.5f, 0.0f, 1.0f),
new float3(3.4f, 0.7f, 1.0f),
new float3(3.4f, 2.7f, 1.0f),
new float3(-3.4f, 1.2f, 1.0f)
};
float3 normal = math.normalize(math.cross(vertices[2] - vertices[1], vertices[0] - vertices[1]));
var collider = PolygonCollider.CreateQuad(vertices[0], vertices[1], vertices[2], vertices[3]);
var quadCollider = UnsafeUtilityEx.AsRef <PolygonCollider>(collider.GetUnsafePtr());
Assert.IsFalse(quadCollider.IsTriangle);
Assert.IsTrue(quadCollider.IsQuad);
TestUtils.AreEqual(quadCollider.Vertices[0], vertices[0], 1e-3f);
TestUtils.AreEqual(quadCollider.Vertices[1], vertices[1], 1e-3f);
TestUtils.AreEqual(quadCollider.Vertices[2], vertices[2], 1e-3f);
TestUtils.AreEqual(quadCollider.Vertices[3], vertices[3], 1e-3f);
Assert.AreEqual(2, quadCollider.Planes.Length);
TestUtils.AreEqual(normal, quadCollider.Planes[0].Normal, 1e-3f);
TestUtils.AreEqual(-normal, quadCollider.Planes[1].Normal, 1e-3f);
Assert.AreEqual(ColliderType.Quad, quadCollider.Type);
Assert.AreEqual(CollisionType.Convex, quadCollider.CollisionType);
}
public IEnumerator ProductionTest()
{
SceneManager.LoadScene("ProductionAndScrappingTest");
yield return(null);
var helper = Object.FindObjectOfType <ProductionTestHelper>();
var resourceManager = Object.FindObjectOfType <ResourceManager>();
Assert.IsNotNull(helper);
Assert.IsNotNull(resourceManager);
var factory = helper.FactoryToFillOut;
int slotCount = factory.GetComponent <Node>().UnitSlots.Count;
for (int i = 0; i < slotCount; ++i)
{
helper.FactoryToFillOut.ProduceUnit(0);
yield return(new WaitForSeconds(0.1f));
}
yield return(null);
Assert.IsFalse(factory.GetComponent <Node>().UnitSlots.Exists(slot => !slot.IsOccupied));
Assert.IsTrue(resourceManager.ResourcesRemaining == (resourceManager.MaxResources - slotCount * helper.FactoryToFillOut.UnitProductionData[0].ProductionCost));
}
public void EvaluateRendererVisibility()
{
//Arrange
var profile = new CullingControllerProfile();
profile.emissiveSizeThreshold = 10;
profile.opaqueSizeThreshold = 20;
profile.visibleDistanceThreshold = 5;
// Act
// Truth tests
var farAndBigTest = CullingControllerUtils.TestRendererVisibleRule(profile, 30, 20, false, true, true);
var smallAndNearTest = CullingControllerUtils.TestRendererVisibleRule(profile, 5, 2, false, true, true);
var cameraInBoundsTest = CullingControllerUtils.TestRendererVisibleRule(profile, 1, 100, true, true, true);
var emissiveTest = CullingControllerUtils.TestRendererVisibleRule(profile, 15, 20, false, false, true);
// Falsehood tests
var farAndSmallTest = CullingControllerUtils.TestRendererVisibleRule(profile, 5, 20, false, true, true);
var emissiveAndFarTest = CullingControllerUtils.TestRendererVisibleRule(profile, 5, 20, false, false, true);
var farAndTransparentTest = CullingControllerUtils.TestRendererVisibleRule(profile, 1, 50, false, false, false);
// Assert
Assert.IsTrue(farAndBigTest);
Assert.IsTrue(smallAndNearTest);
Assert.IsTrue(cameraInBoundsTest);
Assert.IsTrue(emissiveTest);
Assert.IsFalse(farAndSmallTest);
Assert.IsFalse(emissiveAndFarTest);
Assert.IsFalse(farAndTransparentTest);
}
public void TestInstanceCreate(bool result, bool required)
{
Loader.DisableValidationChecksOnEnteringPlaymode = true;
bool instanceCreated = false;
bool hookInstanceProcAddr = false;
bool other = false;
MockRuntime.Instance.TestCallback = (methodName, param) =>
{
switch (methodName)
{
case nameof(OpenXRFeature.OnInstanceCreate):
instanceCreated = true;
return(result);
case nameof(OpenXRFeature.HookGetInstanceProcAddr):
hookInstanceProcAddr = true;
break;
default:
other = true;
break;
}
return(true);
};
MockRuntime.Instance.required = required;
base.InitializeAndStart();
Assert.IsTrue(instanceCreated);
Assert.IsTrue(hookInstanceProcAddr);
if (required && !result)
{
Assert.IsNull(OpenXRLoaderBase.Instance);
}
else
{
Assert.IsNotNull(OpenXRLoaderBase.Instance);
}
// A feature that fails that is not required should be disabled
if (!result && !required)
{
Assert.IsFalse(MockRuntime.Instance.enabled);
}
base.StopAndShutdown();
if (result)
{
Assert.IsTrue(other);
}
else
{
// A feature that fails initialize should have no further callbacks
Assert.IsFalse(other);
}
}
public void EnableFeatureSetEnablesFeatures()
{
OpenXRFeatureSetManager.InitializeFeatureSets(true);
var extInfo = FeatureHelpersInternal.GetAllFeatureInfo(BuildTargetGroup.Standalone);
foreach (var ext in extInfo.Features)
{
Assert.IsFalse(ext.Feature.enabled);
}
var foundFeatureSet = OpenXRFeatureSetManager.GetFeatureSetInfoWithId(BuildTargetGroup.Standalone, k_TestFeatureSetId);
Assert.IsNotNull(foundFeatureSet);
foundFeatureSet.isEnabled = true;
foundFeatureSet.wasChanged = true;
OpenXRFeatureSetManager.SetFeaturesFromEnabledFeatureSets(BuildTargetGroup.Standalone);
foreach (var ext in extInfo.Features)
{
if (String.Compare(ext.Attribute.FeatureId, MicrosoftHandInteraction.featureId, true) == 0)
{
Assert.IsTrue(ext.Feature.enabled);
}
else
{
Assert.IsFalse(ext.Feature.enabled);
}
}
}
public void Equals_operator_false_for_different_EdgeLength()
{
var e1 = new EdgeLength(10d, 20d, 30d);
var e2 = new EdgeLength(40d, 50d, 60d);
Assert.IsFalse(e1 == e2);
}
public void BuildTest()
{
var jacobian = new LinearLimitJacobian();
var aFromConstraint = MTransform.Identity;
var bFromConstraint = MTransform.Identity;
var velocityA = MotionVelocity.Zero;
var velocityB = MotionVelocity.Zero;
var motionA = MotionData.Zero;
var motionB = MotionData.Zero;
var constraint = new Constraint()
{
ConstrainedAxes = new bool3(true, true, true)
};
var tau = 1.0f;
var damping = 1.0f;
jacobian.Build(aFromConstraint, bFromConstraint, velocityA, velocityB, motionA, motionB, constraint, tau, damping);
Assert.AreEqual(RigidTransform.identity, jacobian.WorldFromA);
Assert.AreEqual(RigidTransform.identity, jacobian.WorldFromB);
Assert.AreEqual(float3.zero, jacobian.PivotAinA);
Assert.AreEqual(float3.zero, jacobian.PivotBinB);
Assert.AreEqual(float3.zero, jacobian.AxisInB);
Assert.IsFalse(jacobian.Is1D);
Assert.AreEqual(0.0f, jacobian.MinDistance);
Assert.AreEqual(0.0f, jacobian.MaxDistance);
Assert.AreEqual(1.0f, jacobian.Tau);
Assert.AreEqual(1.0f, jacobian.Damping);
Assert.AreEqual(0.0f, jacobian.InitialError);
}
public void Not_equals_operator_false_for_identical_EdgeLength()
{
var e1 = new EdgeLength(10d, 20d, 30d);
var e2 = new EdgeLength(10d, 20d, 30d);
Assert.IsFalse(e1 != e2);
}
public void TestAabb()
{
float3 v0 = float3(100, 200, 300);
float3 v1 = float3(200, 300, 400);
float3 v2 = float3(50, 100, 350);
Aabb a0; a0.Min = float3.zero; a0.Max = v0;
Aabb a1; a1.Min = float3.zero; a1.Max = v1;
Aabb a2; a2.Min = v2; a2.Max = v1;
Aabb a3; a3.Min = v2; a3.Max = v0;
Assert.IsTrue(a0.IsValid);
Assert.IsTrue(a1.IsValid);
Assert.IsTrue(a2.IsValid);
Assert.IsFalse(a3.IsValid);
Assert.IsTrue(a1.Contains(a0));
Assert.IsFalse(a0.Contains(a1));
Assert.IsTrue(a1.Contains(a2));
Assert.IsFalse(a2.Contains(a1));
Assert.IsFalse(a0.Contains(a2));
Assert.IsFalse(a2.Contains(a0));
// Test Expand / Contains
{
Aabb a5; a5.Min = v2; a5.Max = v1;
float3 testPoint = float3(v2.x - 1.0f, v1.y + 1.0f, .5f * (v2.z + v1.z));
Assert.IsFalse(a5.Contains(testPoint));
a5.Expand(1.5f);
Assert.IsTrue(a5.Contains(testPoint));
}
// Test transform
{
Aabb ut; ut.Min = v0; ut.Max = v1;
// Identity transform should not modify aabb
Aabb outAabb = Unity.Physics.Math.TransformAabb(RigidTransform.identity, ut);
TestUtils.AreEqual(ut.Min, outAabb.Min, 1e-3f);
// Test translation
outAabb = Unity.Physics.Math.TransformAabb(new RigidTransform(quaternion.identity, float3(100.0f, 0.0f, 0.0f)), ut);
Assert.AreEqual(outAabb.Min.x, 200);
Assert.AreEqual(outAabb.Min.y, 200);
Assert.AreEqual(outAabb.Max.x, 300);
Assert.AreEqual(outAabb.Max.z, 400);
// Test rotation
quaternion rot = quaternion.EulerXYZ(0.0f, 0.0f, k_pi2);
outAabb = Unity.Physics.Math.TransformAabb(new RigidTransform(rot, float3.zero), ut);
TestUtils.AreEqual(outAabb.Min, float3(-300.0f, 100.0f, 300.0f), 1e-3f);
TestUtils.AreEqual(outAabb.Max, float3(-200.0f, 200.0f, 400.0f), 1e-3f);
TestUtils.AreEqual(outAabb.SurfaceArea, ut.SurfaceArea, 1e-2f);
}
}
public void Transitions_From_StateA_To_StateA()
{
Assert.IsFalse(stateA.IsActive);
stateManager.Transition <TestStateA>();
Assert.IsTrue(stateA.IsActive);
stateManager.Transition <TestStateA>();
Assert.IsTrue(stateA.IsActive);
}
public void CloneTest()
{
var original = new EventType("T", _Behaviour, _Behaviour, _Event);
var clone = original.Clone();
Assert.IsFalse(ReferenceEquals(original, clone));
Assert.AreEqual(original, clone);
}
public void CreateAndDestroyTimelineAssets()
{
PlayableDirector director = CreateDirectorWithTimelineAsset(TIMELINE_ASSET_PATH, out TimelineAsset _);
string timelineAssetPath = AssetDatabase.GetAssetPath(director.playableAsset);
TimelineEditorUtility.DestroyAssets(director.playableAsset);
Assert.IsFalse(File.Exists(timelineAssetPath));
}
public void pauseSpeechAnimationTest()
{
const int testValue = 5;
var sam = new SpeechAnimationManager();
sam.startSpeechAnimation(0);
sam.pauseSpeechAnimation(testValue);
Assert.IsFalse(sam.getIsSpeaking());
Assert.AreEqual(testValue, sam.getCharIndex());
}
public void TransformEqualsSame()
{
var transform1 = _transform;
var transform2 = transform1;
Assert.IsTrue(transform1 == transform2);
Assert.IsFalse(transform1 != transform2);
Assert.IsTrue(transform1.Equals(transform2));
Assert.IsTrue(ReferenceEquals(transform1, transform2));
}
static void TestSegmentEquality <T>(ActionSegment <T> actionSegment, T[] actionBuffer)
where T : struct
{
Assert.IsFalse(actionSegment.Length == 0);
for (var i = 0; i < actionSegment.Length; i++)
{
var action = actionSegment[i];
Assert.AreEqual(action, actionBuffer[actionSegment.Offset + i]);
}
}
public void EnableFeatures()
{
var featureInfos = GetFeatureInfos(BuildTargetGroup.Standalone);
featureInfos.SingleOrDefault(ext => ext.Attribute.UiName == "Mock Runtime").Feature.enabled = true;
Assert.IsTrue(MockRuntime.Instance.enabled);
featureInfos.SingleOrDefault(ext => ext.Attribute.UiName == "Mock Runtime").Feature.enabled = false;
Assert.IsFalse(MockRuntime.Instance.enabled);
}
public void EnableFeatures()
{
var extInfo = FeatureHelpersInternal.GetAllFeatureInfo(BuildTargetGroup.Standalone);
extInfo.Features.SingleOrDefault(ext => ext.Attribute.UiName == "Mock Runtime").Feature.enabled = true;
Assert.IsTrue(MockRuntime.Instance.enabled);
extInfo.Features.SingleOrDefault(ext => ext.Attribute.UiName == "Mock Runtime").Feature.enabled = false;
Assert.IsFalse(MockRuntime.Instance.enabled);
}
public void TransformEqualsOther()
{
var transform1 = new GameObject("LHS").transform;
var transform2 = new GameObject("RHS").transform;
Assert.IsFalse(transform1 == transform2);
Assert.IsTrue(transform1 != transform2);
Assert.IsFalse(transform1.Equals(transform2));
Assert.IsFalse(ReferenceEquals(transform1, transform2));
}
public void ReadOnlyObjectEqualsSame()
{
var obj1 = new ReadOnlyObject(new Object());
var obj2 = obj1;
Assert.IsTrue(obj1 == obj2);
Assert.IsFalse(obj1 != obj2);
Assert.IsTrue(obj1.Equals(obj2));
Assert.IsTrue(ReferenceEquals(obj1, obj2));
}
public void ObjectEqualsOther()
{
var obj1 = new Object();
var obj2 = new Object();
Assert.IsTrue(obj1 == obj2);
Assert.IsFalse(obj1 != obj2);
Assert.IsTrue(obj1.Equals(obj2));
Assert.IsFalse(ReferenceEquals(obj1, obj2));
}
private IEnumerator TryToLoadUrl(string url)
{
yield return(new WaitForEndOfFrame());
var www = UnityWebRequest.Get(url);
yield return(www.SendWebRequest());
Assert.IsFalse(www.isHttpError || www.isNetworkError, www.error);
Assert.AreEqual(www.responseCode, 200, "Unexpected HTTP response code");
yield return(new WaitForEndOfFrame());
}
public void JacobianIteratorHasJacobiansLeftTest()
{
var jacobianStream = new BlockStream(1, 0x01234567);
BlockStream.Reader jacobianStreamReader = jacobianStream;
int workItemIndex = 0;
var jacIterator = new JacobianIterator(jacobianStreamReader, workItemIndex);
Assert.IsFalse(jacIterator.HasJacobiansLeft());
jacobianStream.Dispose();
}
public void JacobianIteratorHasJacobiansLeftTest()
{
var jacobianStream = new NativeStream(1, Allocator.Temp);
NativeStream.Reader jacobianStreamReader = jacobianStream.AsReader();
int workItemIndex = 0;
var jacIterator = new JacobianIterator(jacobianStreamReader, workItemIndex);
Assert.IsFalse(jacIterator.HasJacobiansLeft());
jacobianStream.Dispose();
}