【m】插件上传

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

@@ -0,0 +1,47 @@
+using NUnit.Framework;
+using Unity.RenderStreaming.InputSystem;
+using UnityEngine.InputSystem;
+using UnityEngine.InputSystem.Layouts;
+using Assert = NUnit.Framework.Assert;
+
+namespace Unity.RenderStreaming.RuntimeTest
+{
+    using InputSystem = UnityEngine.InputSystem.InputSystem;
+
+    class InputDeviceExtensionTest
+    {
+        [Test]
+        public void SetDescription()
+        {
+            var device = InputSystem.AddDevice<Mouse>();
+            InputDeviceDescription empty;
+            InputDeviceDescription origin = device.description;
+            device.SetDescription(empty);
+            Assert.That(device.description, Is.EqualTo(empty));
+            device.SetDescription(origin);
+            Assert.That(device.description, Is.EqualTo(origin));
+        }
+        [Test]
+        public void SetParticipantId()
+        {
+            var device = InputSystem.AddDevice<Mouse>();
+            int participantId = 0;
+            int origin = device.GetParticipantId();
+            device.SetParticipantId(participantId);
+            Assert.That(device.GetParticipantId(), Is.EqualTo(participantId));
+            device.SetParticipantId(origin);
+            Assert.That(device.GetParticipantId(), Is.EqualTo(origin));
+        }
+        [Test]
+        public void SetDeviceFlags()
+        {
+            var device = InputSystem.AddDevice<Mouse>();
+            int deviceFlags = 0;
+            int origin = device.GetDeviceFlags();
+            device.SetDeviceFlags(deviceFlags);
+            Assert.That(device.GetDeviceFlags(), Is.EqualTo(deviceFlags));
+            device.SetDeviceFlags(origin);
+            Assert.That(device.GetDeviceFlags(), Is.EqualTo(origin));
+        }
+    }
+}

Packages/com.unity.renderstreaming@3.1.0-exp.9/Tests/Runtime/InputSystem/InputDeviceExtensionTest.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 385b386710aac644991171f0a1f789d9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,27 @@
+namespace Unity.RenderStreaming.RuntimeTest
+{
+#if UNITY_EDITOR && !INPUTSYSTEM_1_1_OR_NEWER
+    class InputEditorUserSettingsTest
+    {
+        [SetUp]
+        public void SetUp()
+        {
+            InputEditorUserSettings.Load();
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            InputEditorUserSettings.Delete();
+        }
+
+        [Test]
+        public void LockInputToGameView()
+        {
+            Assert.That(InputEditorUserSettings.lockInputToGameView, Is.False);
+            InputEditorUserSettings.lockInputToGameView = true;
+            Assert.That(InputEditorUserSettings.lockInputToGameView, Is.True);
+        }
+    }
+#endif
+}

Packages/com.unity.renderstreaming@3.1.0-exp.9/Tests/Runtime/InputSystem/InputEditorUserSettingsTest.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: dcb16a2d6c29aaa4586616b57ea3cc9e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,254 @@
+using System.Collections;
+using NUnit.Framework;
+using Unity.RenderStreaming.InputSystem;
+using Unity.RenderStreaming.RuntimeTest.Signaling;
+using Unity.WebRTC;
+using UnityEngine;
+using UnityEngine.InputSystem;
+using UnityEngine.TestTools;
+using Assert = NUnit.Framework.Assert;
+
+namespace Unity.RenderStreaming.RuntimeTest
+{
+    using InputRemoting = InputSystem.InputRemoting;
+
+    class MessageSerializerTest
+    {
+        [Test]
+        public void Serialize()
+        {
+            InputRemoting.Message message1 = new InputRemoting.Message
+            {
+                participantId = 1,
+                type = InputRemoting.MessageType.NewEvents,
+                data = new byte[] { 1, 2, 3, 4, 5 },
+            };
+
+            var bytes = MessageSerializer.Serialize(ref message1);
+
+            Assert.That(bytes, Is.Not.Null);
+            Assert.That(bytes, Has.Length.GreaterThan(0));
+
+            MessageSerializer.Deserialize(bytes, out var message2);
+            Assert.That(message2.participantId, Is.EqualTo(message1.participantId));
+            Assert.That(message2.type, Is.EqualTo(message1.type));
+            Assert.That(message2.data, Is.EqualTo(message1.data));
+        }
+    }
+
+    /// todo(kazuki):workaround
+    class InputRemotingTest
+    {
+        class MyMonoBehaviourTest : MonoBehaviour, IMonoBehaviourTest
+        {
+            public bool IsTestFinished
+            {
+                get { return true; }
+            }
+        }
+
+        private MonoBehaviourTest<MyMonoBehaviourTest> _test;
+        private SignalingManagerInternal _target1, _target2;
+        private RTCDataChannel _channel1, _channel2;
+        private string connectionId = "12345";
+        const float ResendOfferInterval = 3f;
+
+        private RenderStreamingDependencies CreateDependencies()
+        {
+            return new RenderStreamingDependencies
+            {
+                signaling = new MockSignaling(),
+                config = new RTCConfiguration
+                {
+                    iceServers = new[] { new RTCIceServer { urls = new[] { "stun:stun.l.google.com:19302" } } },
+                },
+                startCoroutine = _test.component.StartCoroutine,
+                stopCoroutine = _test.component.StopCoroutine,
+                resentOfferInterval = ResendOfferInterval,
+            };
+        }
+
+        [UnitySetUp]
+        public IEnumerator UnitySetUp()
+        {
+            MockSignaling.Reset(true);
+            _test = new MonoBehaviourTest<MyMonoBehaviourTest>();
+
+            var dependencies1 = CreateDependencies();
+            var dependencies2 = CreateDependencies();
+            _target1 = new SignalingManagerInternal(ref dependencies1);
+            _target2 = new SignalingManagerInternal(ref dependencies2);
+
+            bool isStarted1 = false;
+            bool isStarted2 = false;
+            _target1.onStart += () => { isStarted1 = true; };
+            _target2.onStart += () => { isStarted2 = true; };
+            yield return new WaitUntil(() => isStarted1 && isStarted2);
+
+            bool isCreatedConnection1 = false;
+            bool isCreatedConnection2 = false;
+            _target1.onCreatedConnection += _ => { isCreatedConnection1 = true; };
+            _target2.onCreatedConnection += _ => { isCreatedConnection2 = true; };
+
+            // _target1 is Receiver in private mode
+            _target1.CreateConnection(connectionId);
+            yield return new WaitUntil(() => isCreatedConnection1);
+
+            // _target2 is sender in private mode
+            _target2.CreateConnection(connectionId);
+            yield return new WaitUntil(() => isCreatedConnection2);
+
+            _target1.onAddChannel += (_, channel) => { _channel1 = channel; };
+
+            // send offer automatically after creating channel
+            _channel2 = _target2.CreateChannel(connectionId, "_test");
+
+            bool isGotOffer1 = false;
+            bool isGotAnswer2 = false;
+            _target1.onGotOffer += (_, sdp) => { isGotOffer1 = true; };
+            _target2.onGotAnswer += (_, sdp) => { isGotAnswer2 = true; };
+
+            // each peer are not stable, signaling process not complete.
+            yield return new WaitUntil(() => isGotOffer1);
+
+            _target1.SendAnswer(connectionId);
+            yield return new WaitUntil(() => isGotAnswer2);
+            Assert.That(isGotAnswer2, Is.True);
+
+            // If target1 processes resent　Offer from target2, target1 is not stable.
+            Assert.That(_target2.IsStable(connectionId), Is.True);
+
+            yield return new WaitUntil(() => _channel1 != null);
+            Assert.That(_channel1.ReadyState, Is.EqualTo(RTCDataChannelState.Open));
+        }
+
+        [UnityTearDown]
+        public IEnumerator UnityTearDown()
+        {
+            _target1.DeleteConnection(connectionId);
+            _target2.DeleteConnection(connectionId);
+
+            bool isDeletedConnection1 = false;
+            bool isDeletedConnection2 = false;
+            _target1.onDeletedConnection += _ => { isDeletedConnection1 = true; };
+            _target2.onDeletedConnection += _ => { isDeletedConnection2 = true; };
+            yield return new WaitUntil(() => isDeletedConnection1 && isDeletedConnection2);
+
+            _channel1.Dispose();
+            _channel2.Dispose();
+            _channel1 = null;
+            _channel2 = null;
+            _test.component.StopAllCoroutines();
+            _target1.Dispose();
+            _target2.Dispose();
+            UnityEngine.Object.DestroyImmediate(_test.gameObject);
+        }
+
+        [Test]
+        public void DoNothing()
+        {
+        }
+
+
+        [Test]
+        public void Sender()
+        {
+            var sender = new Sender();
+            Assert.That(sender.layouts, Is.Not.Empty);
+            Assert.That(sender.devices, Is.Not.Empty);
+            Assert.That(sender.GetDeviceById(0), Is.Null);
+            var senderInput = new InputRemoting(sender);
+            var senderDisposer = senderInput.Subscribe(new Observer(_channel1));
+            senderInput.StartSending();
+            senderInput.StopSending();
+            senderDisposer.Dispose();
+            sender.Dispose();
+        }
+
+        [Test]
+        public void Receiver()
+        {
+            var receiver = new Receiver(_channel1);
+            Assert.That(receiver.remoteDevices, Is.Empty);
+            Assert.That(receiver.remoteLayouts, Is.Empty);
+            Assert.That(receiver.GetDeviceById(0), Is.Null);
+            var receiverInput = new InputRemoting(receiver);
+            var receiverDisposer = receiverInput.Subscribe(receiverInput);
+            receiverInput.StartSending();
+            receiverInput.StopSending();
+            receiverDisposer.Dispose();
+        }
+
+        /// todo(kazuki): This test is failed for timeout on macOS.
+        /// todo(kazuki): This test is failed for timeout on iPhonePlayer.
+        [UnityTest, Timeout(3000)]
+        [UnityPlatform(exclude = new[] { RuntimePlatform.OSXPlayer, RuntimePlatform.IPhonePlayer })]
+        public IEnumerator AddDevice()
+        {
+            var sender = new Sender();
+            var senderInput = new InputRemoting(sender);
+            var senderSubscriberDisposer = senderInput.Subscribe(new Observer(_channel1));
+
+            var receiver = new Receiver(_channel2);
+            var receiverInput = new InputRemoting(receiver);
+            var receiverSubscriberDisposer = receiverInput.Subscribe(receiverInput);
+
+            InputDevice device = null;
+            InputDeviceChange change = default;
+            receiver.onDeviceChange += (_device, _change) =>
+            {
+                device = _device;
+                change = _change;
+            };
+            string layoutName = null;
+            InputControlLayoutChange layoutChange = default;
+            receiver.onLayoutChange += (_name, _change) =>
+            {
+                layoutName = _name;
+                layoutChange = _change;
+            };
+
+            receiverInput.StartSending();
+            senderInput.StartSending();
+
+            yield return new WaitUntil(() => device != null);
+            yield return new WaitUntil(() => layoutName != null);
+
+            Assert.That(device, Is.Not.Null);
+            Assert.That(change, Is.EqualTo(InputDeviceChange.Added));
+            Assert.That(layoutName, Is.Not.Null);
+            Assert.That(layoutChange, Is.EqualTo(InputControlLayoutChange.Added));
+
+            Assert.That(receiver.remoteLayouts, Is.Not.Empty);
+            Assert.That(receiver.remoteDevices, Is.Not.Empty);
+            Assert.That(receiver.remoteDevices, Has.All.Matches<InputDevice>(d => d.remote));
+
+            senderInput.StopSending();
+            receiverInput.StopSending();
+
+            senderSubscriberDisposer.Dispose();
+            receiverSubscriberDisposer.Dispose();
+            sender.Dispose();
+            receiver.Dispose();
+        }
+
+        [Test]
+        public void RemoveRemoteDevices()
+        {
+            var sender = new Sender();
+            var senderInput = new InputRemoting(sender);
+            senderInput.RemoveRemoteDevices(0);
+            sender.Dispose();
+        }
+
+        [Test]
+        public void SaveState()
+        {
+            var sender = new Sender();
+            var inputRemoting = new InputRemoting(sender);
+            var state = inputRemoting.SaveState();
+            inputRemoting.RestoreState(state, sender);
+            sender.Dispose();
+        }
+    }
+}

Packages/com.unity.renderstreaming@3.1.0-exp.9/Tests/Runtime/InputSystem/InputRemotingTest.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: adb3bfa611b70d243a3d5d87b5990736
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: