[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(); }