上传YomovSDK

Packages/com.unity.xr.openxr/Tests/Runtime/MockRuntimeTests.cs

@@ -0,0 +1,438 @@
+using System.Collections;
+using System.Collections.Generic;
+using NUnit.Framework;
+using UnityEngine.XR.OpenXR.Features;
+using UnityEngine.XR.OpenXR.Features.Mock;
+using UnityEngine.TestTools;
+using UnityEngine.TestTools.Utils;
+using UnityEngine.XR.OpenXR.NativeTypes;
+
+namespace UnityEngine.XR.OpenXR.Tests
+{
+    /// <summary>
+    /// Defines tests that validate the MockRuntime itself.
+    /// </summary>
+    internal class MockRuntimeTests : OpenXRLoaderSetup
+    {
+        [UnityTest]
+        public IEnumerator TransitionToState()
+        {
+            InitializeAndStart();
+            yield return new WaitForXrFrame();
+
+            Assert.AreEqual(MockRuntime.sessionState, XrSessionState.Focused, "MockRuntime must be in focused state for this test to work correctly");
+            Assert.IsTrue(MockRuntime.TransitionToState(XrSessionState.Visible, false), "Failed to transition to visible state");
+
+            Assert.AreEqual(MockRuntime.sessionState, XrSessionState.Visible);
+        }
+
+        [UnityTest]
+        public IEnumerator TransitionToStateForced()
+        {
+            InitializeAndStart();
+            yield return new WaitForXrFrame();
+
+            Assert.IsFalse(MockRuntime.TransitionToState(XrSessionState.Synchronized, false), "Synchronized state must be an invalid transition for this test to be valid");
+            Assert.IsTrue(MockRuntime.TransitionToState(XrSessionState.Synchronized, true), "Force state transition should not return false");
+
+            yield return new WaitForXrFrame();
+
+            Assert.IsTrue(MockRuntime.sessionState == XrSessionState.Synchronized);
+        }
+
+        [UnityTest]
+        public IEnumerator CreateSessionFailure()
+        {
+            bool sawCreateSession = false;
+            MockRuntime.Instance.TestCallback = (methodName, param) =>
+            {
+                if (methodName == nameof(OpenXRFeature.OnSessionCreate))
+                {
+                    sawCreateSession = true;
+                }
+
+                return true;
+            };
+
+            MockRuntime.SetFunctionCallback("xrCreateSession", (name) => XrResult.RuntimeFailure);
+
+            base.InitializeAndStart();
+
+            yield return null;
+
+            Assert.IsFalse(sawCreateSession);
+        }
+
+        static XrResult[] beginSessionSuccessResults = new XrResult[]
+        {
+            XrResult.Success,
+            XrResult.LossPending
+        };
+
+        [UnityTest]
+        public IEnumerator BeginSessionSuccessWithValues([ValueSource("beginSessionSuccessResults")]
+            XrResult successResult)
+        {
+            var states = new List<XrSessionState>();
+            MockRuntime.Instance.TestCallback = (methodName, param) =>
+            {
+                if (methodName == nameof(OpenXRFeature.OnSessionStateChange))
+                {
+                    var newState = (XrSessionState)((MockRuntime.XrSessionStateChangedParams)param).NewState;
+                    states.Add(newState);
+                }
+
+                return true;
+            };
+
+            MockRuntime.SetFunctionCallback("xrBeginSession", (name) => successResult);
+
+            base.InitializeAndStart();
+
+            yield return null;
+
+            Assert.IsTrue(base.IsRunning<XRDisplaySubsystem>());
+
+            switch (successResult)
+            {
+                case XrResult.Success:
+                    Assert.IsTrue(states.Contains(XrSessionState.Ready));
+                    Assert.IsTrue(states.Contains(XrSessionState.Synchronized));
+                    Assert.IsTrue(states.Contains(XrSessionState.Visible));
+                    Assert.IsTrue(states.Contains(XrSessionState.Focused));
+                    break;
+
+                case XrResult.LossPending:
+                    Assert.IsTrue(states.Contains(XrSessionState.Ready));
+                    Assert.IsFalse(states.Contains(XrSessionState.Synchronized));
+                    Assert.IsFalse(states.Contains(XrSessionState.Visible));
+                    Assert.IsFalse(states.Contains(XrSessionState.Focused));
+                    break;
+            }
+        }
+
+        [UnityTest]
+        public IEnumerator BeginSessionFailure()
+        {
+            var states = new List<XrSessionState>();
+            MockRuntime.Instance.TestCallback = (methodName, param) =>
+            {
+                if (methodName == nameof(OpenXRFeature.OnSessionStateChange))
+                {
+                    var newState = (XrSessionState)((MockRuntime.XrSessionStateChangedParams)param).NewState;
+                    states.Add(newState);
+                }
+
+                return true;
+            };
+
+            MockRuntime.SetFunctionCallback("xrBeginSession", (name) => XrResult.RuntimeFailure);
+
+            InitializeAndStart();
+
+            yield return null;
+
+            Assert.IsTrue(base.IsRunning<XRDisplaySubsystem>());
+
+            Assert.IsTrue(states.Contains(XrSessionState.Ready));
+            Assert.IsFalse(states.Contains(XrSessionState.Synchronized));
+            Assert.IsFalse(states.Contains(XrSessionState.Visible));
+            Assert.IsFalse(states.Contains(XrSessionState.Focused));
+        }
+
+#if false
+        // TEST WAS UNSTABLE, DISABLING FOR RELEASE ONLY
+        [UnityTest]
+        public IEnumerator TestRequestExitShutsdownSubsystems()
+        {
+            bool sawSessionDestroy = false;
+            MockRuntime.Instance.TestCallback = (methodName, param) =>
+            {
+                if (methodName == nameof(OpenXRFeature.OnSessionDestroy))
+                {
+                    sawSessionDestroy = true;
+                }
+
+                return true;
+            };
+
+            AddExtension(MockRuntime.XR_UNITY_mock_test);
+
+            base.InitializeAndStart();
+
+            yield return null;
+
+            Assert.IsTrue(base.IsRunning<XRDisplaySubsystem>());
+
+            var wait = new WaitForLoaderShutdown(Loader);
+            MockDriver.RequestExitSession(MockRuntime.Instance.XrSession);
+
+            yield return wait;
+
+            Assert.IsTrue(sawSessionDestroy);
+        }
+
+#endif
+
+        [UnityTest]
+        public IEnumerator RequestExitSession()
+        {
+            InitializeAndStart();
+
+            // Wait for a single XrFrame to make sure OpenXR is up and running
+            yield return new WaitForXrFrame();
+
+            // Request the session exit which should shutdown OpenXR
+            MockRuntime.RequestExitSession();
+
+            // Wait for OpenXR to shutdown
+            yield return new WaitForLoaderShutdown();
+        }
+
+        [UnityTest]
+        public IEnumerator CauseInstanceLoss()
+        {
+            bool instanceLost = false;
+            MockRuntime.Instance.TestCallback = (methodName, param) =>
+            {
+                if (methodName == nameof(OpenXRFeature.OnInstanceLossPending))
+                {
+                    instanceLost = true;
+                }
+
+                return true;
+            };
+
+            InitializeAndStart();
+
+            yield return null;
+
+            MockRuntime.CauseInstanceLoss();
+
+            yield return new WaitForLoaderShutdown();
+
+            Assert.IsTrue(instanceLost);
+        }
+
+        [UnityTest]
+        public IEnumerator DisplayTransparent()
+        {
+            AddExtension(MockRuntime.XR_UNITY_mock_test);
+
+            MockRuntime.Instance.TestCallback = (methodName, param) =>
+            {
+                if (methodName == nameof(OpenXRFeature.OnInstanceCreate))
+                {
+                    MockRuntime.ChooseEnvironmentBlendMode(XrEnvironmentBlendMode.Additive);
+                }
+
+                return true;
+            };
+
+            base.InitializeAndStart();
+
+            yield return null;
+            var displays = new List<XRDisplaySubsystem>();
+            SubsystemManager.GetSubsystems(displays);
+            Assert.AreEqual(false, displays[0].displayOpaque);
+        }
+
+        [UnityTest]
+        public IEnumerator DisplayOpaque()
+        {
+            base.InitializeAndStart();
+
+            yield return null;
+            var displays = new List<XRDisplaySubsystem>();
+            SubsystemManager.GetSubsystems(displays);
+            Assert.AreEqual(true, displays[0].displayOpaque);
+        }
+
+        [UnityTest]
+        public IEnumerator MultipleEnvironmentBlendModes()
+        {
+            //Mock available environmentBlendModes are Opaque and Additive in mock_runtime.cpp EnumerateEnvironmentBlendModes.
+            AddExtension(MockRuntime.XR_UNITY_mock_test);
+            base.InitializeAndStart();
+            yield return null;
+
+            //check default mode is Opaque.
+            Assert.AreEqual(XrEnvironmentBlendMode.Opaque, MockRuntime.GetXrEnvironmentBlendMode());
+
+            //Switch to another supported mode - Additive.
+            MockRuntime.ChooseEnvironmentBlendMode(XrEnvironmentBlendMode.Additive);
+            yield return new WaitForXrFrame(2);
+            Assert.AreEqual(XrEnvironmentBlendMode.Additive, MockRuntime.GetXrEnvironmentBlendMode());
+
+            //Set to unsupported mode - Alpha_blend
+            MockRuntime.ChooseEnvironmentBlendMode(XrEnvironmentBlendMode.AlphaBlend);
+            yield return new WaitForXrFrame(2);
+            Assert.AreNotEqual(XrEnvironmentBlendMode.AlphaBlend, MockRuntime.GetXrEnvironmentBlendMode());
+        }
+
+        [UnityTest]
+        public IEnumerator BoundaryPoints()
+        {
+            AddExtension(MockRuntime.XR_UNITY_mock_test);
+
+            base.InitializeAndStart();
+
+            yield return null;
+
+            Assert.IsTrue(base.IsRunning<XRInputSubsystem>(), "Input subsystem failed to properly start!");
+
+            MockRuntime.SetReferenceSpaceBounds(XrReferenceSpaceType.Stage, new Vector2 { x = 1.0f, y = 3.0f });
+
+            yield return null;
+
+            var input = Loader.GetLoadedSubsystem<XRInputSubsystem>();
+            Assert.That(() => input, Is.Not.Null);
+
+            input.TrySetTrackingOriginMode(TrackingOriginModeFlags.Floor);
+
+            yield return null;
+
+            var points = new List<Vector3>();
+            Assert.IsTrue(input.TryGetBoundaryPoints(points), "Failed to get boundary points!");
+            Assert.That(() => points.Count, Is.EqualTo(4), "Incorrect number of boundary points received!");
+
+            var comparer = new Vector3EqualityComparer(10e-6f);
+
+            Assert.That(points[0], Is.EqualTo(new Vector3 { x = -0.5f, y = 0.0f, z = -1.5f }).Using(comparer));
+            Assert.That(points[1], Is.EqualTo(new Vector3 { x = -0.5f, y = 0.0f, z = 1.5f }).Using(comparer));
+            Assert.That(points[2], Is.EqualTo(new Vector3 { x = 0.5f, y = 0.0f, z = 1.5f }).Using(comparer));
+            Assert.That(points[3], Is.EqualTo(new Vector3 { x = 0.5f, y = 0.0f, z = -1.5f }).Using(comparer));
+        }
+
+        [UnityTest]
+        public IEnumerator NoBoundaryPoints()
+        {
+            AddExtension(MockRuntime.XR_UNITY_mock_test);
+
+            base.InitializeAndStart();
+
+            yield return null;
+
+            Assert.IsTrue(base.IsRunning<XRInputSubsystem>(), "Input subsystem failed to properly start!");
+
+            var input = Loader.GetLoadedSubsystem<XRInputSubsystem>();
+            Assert.That(() => input, Is.Not.Null);
+
+            input.TrySetTrackingOriginMode(TrackingOriginModeFlags.Floor);
+
+            yield return null;
+
+            var points = new List<Vector3>();
+            input.TryGetBoundaryPoints(points);
+            Assert.That(() => points.Count, Is.EqualTo(0), "Incorrect number of boundary points received!");
+        }
+
+        [UnityTest]
+        public IEnumerator BoundryPointsForTrackingOrigin()
+        {
+            AddExtension(MockRuntime.XR_UNITY_mock_test);
+
+            base.InitializeAndStart();
+
+            yield return null;
+
+            Assert.IsTrue(base.IsRunning<XRInputSubsystem>(), "Input subsystem failed to properly start!");
+
+            MockRuntime.SetReferenceSpaceBounds(XrReferenceSpaceType.Stage, new Vector2 { x = 1.0f, y = 3.0f });
+
+            yield return null;
+
+            var input = Loader.GetLoadedSubsystem<XRInputSubsystem>();
+            Assert.That(() => input, Is.Not.Null);
+
+            input.TrySetTrackingOriginMode(TrackingOriginModeFlags.Floor);
+
+            yield return null;
+
+            var points = new List<Vector3>();
+            Assert.IsTrue(input.TryGetBoundaryPoints(points), "Failed to get boundary points!");
+            Assert.That(() => points.Count, Is.EqualTo(4), "Incorrect number of boundary points received!");
+
+            input.TrySetTrackingOriginMode(TrackingOriginModeFlags.Device);
+
+            yield return null;
+
+            points.Clear();
+            input.TryGetBoundaryPoints(points);
+            Assert.That(() => points.Count, Is.EqualTo(0), "Incorrect number of boundary points received!");
+        }
+
+        [UnityTest]
+        public IEnumerator BeforeFunctionCallbackSuccess()
+        {
+            var createInstanceCalled = false;
+
+            MockRuntime.SetFunctionCallback("xrCreateInstance", (name) =>
+            {
+                createInstanceCalled = true;
+                return XrResult.Success;
+            });
+
+            InitializeAndStart();
+
+            yield return new WaitForXrFrame(1);
+
+            Assert.IsTrue(createInstanceCalled, "xrCreateInstance callback was not called");
+        }
+
+        [Test]
+        public void BeforeFunctionCallbackError()
+        {
+            var createInstanceCalled = false;
+
+            MockRuntime.SetFunctionCallback("xrCreateInstance", (name) =>
+            {
+                createInstanceCalled = true;
+                return XrResult.RuntimeFailure;
+            });
+
+            LogAssert.ignoreFailingMessages = true;
+            InitializeAndStart();
+            LogAssert.ignoreFailingMessages = false;
+
+            Assert.IsTrue(OpenXRLoaderBase.Instance == null, "OpenXR instance should have failed to initialize");
+
+            Assert.IsTrue(createInstanceCalled, "xrCreateInstance callback was not called");
+        }
+
+        [UnityTest]
+        public IEnumerator AfterFunctionCallback()
+        {
+            var createInstanceCalled = false;
+            var createInstanceSuccess = false;
+
+            MockRuntime.SetFunctionCallback("xrCreateInstance", (name, result) =>
+            {
+                createInstanceCalled = true;
+                createInstanceSuccess = result == XrResult.Success;
+            });
+
+            InitializeAndStart();
+
+            yield return new WaitForXrFrame(1);
+
+            Assert.IsTrue(createInstanceCalled, "xrCreateInstance callback was not called");
+            Assert.IsTrue(createInstanceSuccess, "xrCreateInstance result was not XR_SUCCESS");
+        }
+
+        [UnityTest]
+        public IEnumerator CallbacksClearedOnLoaderShutdown()
+        {
+            MockRuntime.SetFunctionCallback("xrBeginSession", (func) => XrResult.Success);
+
+            InitializeAndStart();
+
+            yield return new WaitForXrFrame(1);
+
+            StopAndShutdown();
+
+            Assert.IsTrue(OpenXRLoader.Instance == null, "OpenXR should not be running");
+            Assert.IsNull(MockRuntime.GetBeforeFunctionCallback("xrBeginSession"), "Callback should have been cleared when loader shut down");
+        }
+    }
+}