【m】插件上传

Packages/com.unity.renderstreaming@3.1.0-exp.9/Tests/Runtime/SignalingManagerTest.cs

@@ -0,0 +1,191 @@
+using System.IO;
+using System.Linq;
+using NUnit.Framework;
+using Unity.RenderStreaming.RuntimeTest.Signaling;
+using Unity.RenderStreaming.Signaling;
+using UnityEngine;
+using UnityEngine.TestTools;
+using Object = UnityEngine.Object;
+
+namespace Unity.RenderStreaming.RuntimeTest
+{
+    class SignalingManagerTest
+    {
+        SignalingManager component;
+
+        [SetUp]
+        public void SetUp()
+        {
+            GameObject obj = new GameObject();
+            obj.SetActive(false);
+            component = obj.AddComponent<SignalingManager>();
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            Object.DestroyImmediate(component.gameObject);
+        }
+
+        [Test]
+        public void DoNothing()
+        {
+        }
+
+        [Test]
+        public void UseDefaultSettings()
+        {
+            Assert.That(component.useDefaultSettings, Is.True);
+            component.useDefaultSettings = false;
+            Assert.That(component.useDefaultSettings, Is.False);
+        }
+
+        [Test]
+        public void Run()
+        {
+            var handler = component.gameObject.AddComponent<SingleConnection>();
+            var handlers = new SignalingHandlerBase[] { handler };
+            ISignaling mock = new MockSignaling();
+            component.runOnAwake = false;
+            component.gameObject.SetActive(true);
+            component.Run(signaling: mock, handlers: handlers);
+        }
+
+        [Test, Ignore("Failed this test on macOS and Linux platform because of the signaling process.")]
+        public void RunDefault()
+        {
+            var handler = component.gameObject.AddComponent<SingleConnection>();
+            var handlers = new SignalingHandlerBase[] { handler };
+            ISignaling mock = new MockSignaling();
+            component.runOnAwake = false;
+            component.gameObject.SetActive(true);
+            component.Run(handlers: handlers);
+        }
+
+
+        [Test]
+        public void ThrowExceptionIfHandlerIsNullOrEmpty()
+        {
+            ISignaling mock = new MockSignaling();
+            component.runOnAwake = false;
+            component.gameObject.SetActive(true);
+            Assert.That(() => component.Run(signaling: mock), Throws.InvalidOperationException);
+
+            var handlers = new SignalingHandlerBase[] { };
+            Assert.That(() => component.Run(signaling: mock, handlers: handlers),
+                Throws.InvalidOperationException);
+        }
+
+
+        [Test]
+        public void RunAgain()
+        {
+            var handler = component.gameObject.AddComponent<SingleConnection>();
+            var handlers = new SignalingHandlerBase[] { handler };
+            ISignaling mock = new MockSignaling();
+            component.runOnAwake = false;
+            component.gameObject.SetActive(true);
+            component.Run(signaling: mock, handlers: handlers);
+            component.Stop();
+            component.Run(signaling: mock, handlers: handlers);
+        }
+
+        [Test]
+        public void GetDefaultSignalingSettings()
+        {
+            component.runOnAwake = false;
+            component.gameObject.SetActive(true);
+
+            var settings = component.GetSignalingSettings() as WebSocketSignalingSettings;
+            Assert.That(settings, Is.Not.Null);
+        }
+
+        [Test]
+        public void AddAndRemoveSignalingHandler()
+        {
+            component.runOnAwake = false;
+            component.gameObject.SetActive(true);
+            component.SetSignalingSettings(new MockSignalingSettings());
+            var handler = component.gameObject.AddComponent<SingleConnection>();
+            component.AddSignalingHandler(handler);
+            Assert.That(() => component.Run(), Throws.Nothing);
+            component.RemoveSignalingHandler(handler);
+        }
+
+        [Test]
+        public void ThrowExceptionSetSignalingOnRunning()
+        {
+            component.runOnAwake = false;
+            component.gameObject.SetActive(true);
+            component.SetSignalingSettings(new MockSignalingSettings());
+            var handler = component.gameObject.AddComponent<SingleConnection>();
+            component.AddSignalingHandler(handler);
+            Assert.That(() => component.Run(), Throws.Nothing);
+            Assert.That(component.Running, Is.True);
+
+            Assert.That(() => component.SetSignalingSettings(new MockSignalingSettings()), Throws.InvalidOperationException);
+        }
+
+        [Test]
+        [UnityPlatform(exclude = new[] { RuntimePlatform.Android, RuntimePlatform.IPhonePlayer })]
+        public void EvaluateCommandlineArguments()
+        {
+            // Change signaling type.
+            SignalingSettings settings = new WebSocketSignalingSettings("ws://127.0.0.1");
+            Assert.That(settings.iceServers, Is.Empty);
+
+            string[] arguments = { "-signalingType", "http" };
+            Assert.That(SignalingManager.EvaluateCommandlineArguments(ref settings, arguments), Is.True);
+            Assert.That(settings, Is.TypeOf<HttpSignalingSettings>());
+            Assert.That(settings.iceServers, Is.Not.Empty);
+
+            settings = new HttpSignalingSettings("http://127.0.0.1");
+            Assert.That(settings.iceServers, Is.Empty);
+
+            arguments = new string[] { "-signalingType", "websocket" };
+            Assert.That(SignalingManager.EvaluateCommandlineArguments(ref settings, arguments), Is.True);
+            Assert.That(settings, Is.TypeOf<WebSocketSignalingSettings>());
+            Assert.That(settings.iceServers, Is.Not.Empty);
+
+            // Change signaling url.
+            settings = new WebSocketSignalingSettings("ws://127.0.0.1");
+            string url = "ws://192.168.10.10";
+            arguments = new[] { "-signalingUrl", url };
+            Assert.That(SignalingManager.EvaluateCommandlineArguments(ref settings, arguments), Is.True);
+            Assert.That(settings, Is.TypeOf<WebSocketSignalingSettings>());
+            Assert.That((settings as WebSocketSignalingSettings).url, Is.EqualTo(url));
+
+            settings = new HttpSignalingSettings("http://127.0.0.1");
+            url = "http://192.168.10.10";
+            arguments = new[] { "-signalingUrl", url };
+            Assert.That(SignalingManager.EvaluateCommandlineArguments(ref settings, arguments), Is.True);
+            Assert.That(settings, Is.TypeOf<HttpSignalingSettings>());
+            Assert.That((settings as HttpSignalingSettings).url, Is.EqualTo(url));
+
+            // Import json for ice server settings.
+            settings = new WebSocketSignalingSettings("ws://127.0.0.1");
+            string json = "{\"iceServers\":[{\"credential\":\"pass\",\"username\":\"user\",\"credentialType\":\"password\"," +
+                          "\"urls\":[\"turn:192.168.10.10:3478?transport=udp\"]}]}";
+            string filepath = "dummy.json";
+            File.WriteAllText(filepath, json);
+            arguments = new[] { "-importJson", filepath };
+            var info = JsonUtility.FromJson<CommandLineInfo>(json);
+            Assert.That(SignalingManager.EvaluateCommandlineArguments(ref settings, arguments), Is.True);
+            Assert.That(settings, Is.TypeOf<WebSocketSignalingSettings>());
+            Assert.That(settings.iceServers.Count, Is.EqualTo(1));
+            Assert.That(settings.iceServers.ElementAt(0).credential, Is.EqualTo(info.iceServers[0].credential));
+            Assert.That(settings.iceServers.ElementAt(0).credentialType, Is.EqualTo((IceCredentialType)info.iceServers[0].credentialType));
+            File.Delete(filepath);
+
+            // Import json to change signaling type.
+            settings = new WebSocketSignalingSettings("ws://127.0.0.1");
+            json = "{\"signalingType\":\"websocket\"}";
+            File.WriteAllText(filepath, json);
+            arguments = new[] { "-importJson", filepath };
+            Assert.That(SignalingManager.EvaluateCommandlineArguments(ref settings, arguments), Is.True);
+            Assert.That(settings, Is.TypeOf<WebSocketSignalingSettings>());
+
+
+        }
+    }
+}