【m】插件上传

Packages/com.unity.renderstreaming@3.1.0-exp.9/Tests/Editor/AudioCodecInfoObject.cs

@@ -0,0 +1,10 @@
+using UnityEngine;
+
+namespace Unity.RenderStreaming.EditorTest
+{
+    class AudioCodecInfoObject : ScriptableObject
+    {
+        [SerializeField]
+        public AudioCodecInfo info;
+    }
+}

Packages/com.unity.renderstreaming@3.1.0-exp.9/Tests/Editor/AudioCodecInfoObject.cs.meta

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

Packages/com.unity.renderstreaming@3.1.0-exp.9/Tests/Editor/EditorTest.cs

@@ -0,0 +1,238 @@
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using NUnit.Framework.Interfaces;
+using UnityEditor;
+using UnityEditor.TestTools;
+using UnityEngine;
+using UnityEngine.TestRunner;
+
+[assembly: TestPlayerBuildModifier(typeof(Unity.RenderStreaming.EditorTest.BuildModifier))]
+[assembly: TestRunCallback(typeof(Unity.RenderStreaming.EditorTest.TestListener))]
+
+
+namespace Unity.RenderStreaming.EditorTest
+{
+    class BuildModifier : ITestPlayerBuildModifier
+    {
+        const string path = "Packages/com.unity.renderstreaming/Tests/Editor/RenderStreamingSettings.asset";
+
+        public BuildPlayerOptions ModifyOptions(BuildPlayerOptions playerOptions)
+        {
+            var settings = AssetDatabase.LoadAssetAtPath<RenderStreamingSettings>(path);
+            RenderStreaming.Settings = settings;
+            return playerOptions;
+        }
+    }
+
+    class TestListener : ITestRunCallback
+    {
+        const string path = "Packages/com.unity.renderstreaming/Tests/Editor/RenderStreamingSettings.asset";
+
+        RenderStreamingSettings temp = null;
+
+        public void RunStarted(ITest testsToRun)
+        {
+            var settings = AssetDatabase.LoadAssetAtPath<RenderStreamingSettings>(path);
+            temp = RenderStreaming.Settings;
+            RenderStreaming.Settings = settings;
+        }
+
+        public void RunFinished(ITestResult testResults)
+        {
+            if (temp != null)
+                RenderStreaming.Settings = temp;
+        }
+
+        public void TestStarted(ITest test)
+        {
+        }
+
+        public void TestFinished(ITestResult result)
+        {
+        }
+    }
+
+
+    class VideoCodecInfoTest
+    {
+        [Test]
+        public void EqualityOperator()
+        {
+            VideoCodecInfo info = null;
+            Assert.That(info == null, Is.True);
+            Assert.That(info != null, Is.False);
+
+            VideoCodecInfo otherInfo = info;
+            Assert.That(info == otherInfo, Is.True);
+            Assert.That(info != otherInfo, Is.False);
+
+            info = VideoStreamSender.GetAvailableCodecs().First();
+            Assert.That(info == otherInfo, Is.False);
+            Assert.That(info == (object)otherInfo, Is.False);
+
+            otherInfo = info;
+            Assert.That(info == otherInfo, Is.True);
+            Assert.That(info == (object)otherInfo, Is.True);
+        }
+
+        [Test]
+        public void HashCode()
+        {
+            VideoCodecInfo info = VideoStreamSender.GetAvailableCodecs().First();
+            VideoCodecInfo otherInfo = info;
+            Assert.That(info.GetHashCode() == otherInfo.GetHashCode(), Is.True);
+
+            otherInfo = VideoStreamSender.GetAvailableCodecs().Last();
+            Assert.That(info.GetHashCode() == otherInfo.GetHashCode(), Is.False);
+        }
+    }
+
+    class AudioCodecInfoTest
+    {
+        [Test]
+        public void EqualityOperator()
+        {
+            AudioCodecInfo info = null;
+            Assert.That(info == null, Is.True);
+            Assert.That(info != null, Is.False);
+
+            AudioCodecInfo otherInfo = info;
+            Assert.That(info == otherInfo, Is.True);
+            Assert.That(info != otherInfo, Is.False);
+
+            info = AudioStreamSender.GetAvailableCodecs().First();
+            Assert.That(info == otherInfo, Is.False);
+            Assert.That(info == (object)otherInfo, Is.False);
+
+            otherInfo = info;
+            Assert.That(info == otherInfo, Is.True);
+            Assert.That(info == (object)otherInfo, Is.True);
+        }
+
+        [Test]
+        public void HashCode()
+        {
+            AudioCodecInfo info = AudioStreamSender.GetAvailableCodecs().First();
+            AudioCodecInfo otherInfo = info;
+            Assert.That(info.GetHashCode() == otherInfo.GetHashCode(), Is.True);
+
+            otherInfo = AudioStreamSender.GetAvailableCodecs().Last();
+            Assert.That(info.GetHashCode() == otherInfo.GetHashCode(), Is.False);
+        }
+
+    }
+
+    class VideoStreamSenderTest
+    {
+        [Test]
+        public void GetAvailableCodec()
+        {
+            var codecs = VideoStreamSender.GetAvailableCodecs();
+            Assert.That(codecs, Is.Not.Null.Or.Empty);
+            Assert.That(codecs, Is.Not.Contains(null));
+        }
+    }
+
+    class VideoStreamReceiverTest
+    {
+        [Test]
+        public void GetAvailableCodec()
+        {
+            var codecs = VideoStreamReceiver.GetAvailableCodecs();
+            Assert.That(codecs, Is.Not.Null.Or.Empty);
+            Assert.That(codecs, Is.Not.Contains(null));
+        }
+    }
+
+    class AudioStreamSenderTest
+    {
+        [Test]
+        public void GetAvailableCodec()
+        {
+            var codecs = AudioStreamSender.GetAvailableCodecs();
+            Assert.That(codecs, Is.Not.Null.Or.Empty);
+            Assert.That(codecs, Is.Not.Contains(null));
+        }
+    }
+
+    class AudioStreamReceiverTest
+    {
+        [Test]
+        public void GetAvailableCodec()
+        {
+            var codecs = AudioStreamReceiver.GetAvailableCodecs();
+            Assert.That(codecs, Is.Not.Null.Or.Empty);
+            Assert.That(codecs, Is.Not.Contains(null));
+        }
+    }
+
+    class RenderStreamingSettingsTest
+    {
+        [Test]
+        public void CheckDefaultSettings()
+        {
+            RenderStreamingSettings defaultSettings = AssetDatabase.LoadAssetAtPath<RenderStreamingSettings>(RenderStreaming.DefaultRenderStreamingSettingsPath);
+            Assert.That(defaultSettings.automaticStreaming, Is.True);
+            var defaultSignalingSettings = defaultSettings.signalingSettings as WebSocketSignalingSettings;
+            Assert.That(defaultSignalingSettings, Is.Not.Null);
+            Assert.That(defaultSignalingSettings.signalingClass, Is.EqualTo(typeof(Signaling.WebSocketSignaling)));
+            Assert.That(defaultSignalingSettings.url, Is.EqualTo("ws://127.0.0.1:80"));
+            Assert.That(defaultSignalingSettings.iceServers.ElementAt(0).urls, Is.EquivalentTo(new string[] { "stun:stun.l.google.com:19302" }));
+        }
+    }
+
+    class SerializeTest
+    {
+        [Test]
+        public void SerializeVideoCodecInfo()
+        {
+            IEnumerable<VideoCodecInfo> codecs = VideoStreamSender.GetAvailableCodecs();
+            var asset = ScriptableObject.CreateInstance<VideoCodecInfoObject>();
+            asset.info = codecs.First();
+
+            string exportPath = "Assets/test.asset";
+            AssetDatabase.CreateAsset(asset, exportPath);
+
+            EditorUtility.SetDirty(asset);
+            AssetDatabase.SaveAssets();
+
+            var otherAsset = AssetDatabase.LoadAssetAtPath<VideoCodecInfoObject>(exportPath);
+            Assert.That(asset.info, Is.Not.Null);
+            Assert.That(otherAsset.info, Is.Not.Null);
+            Assert.That(asset.info, Is.EqualTo(otherAsset.info));
+            Assert.That(asset.info.Equals(otherAsset.info), Is.True);
+            AssetDatabase.DeleteAsset(exportPath);
+        }
+
+        [Test]
+        public void SerializeAudioCodecInfo()
+        {
+            IEnumerable<AudioCodecInfo> codecs = AudioStreamSender.GetAvailableCodecs();
+            var asset = ScriptableObject.CreateInstance<AudioCodecInfoObject>();
+            asset.info = codecs.First();
+
+            string exportPath = "Assets/test.asset";
+            AssetDatabase.CreateAsset(asset, exportPath);
+
+            EditorUtility.SetDirty(asset);
+            AssetDatabase.SaveAssets();
+
+            var otherAsset = AssetDatabase.LoadAssetAtPath<AudioCodecInfoObject>(exportPath);
+            Assert.That(asset.info, Is.Not.Null);
+            Assert.That(otherAsset.info, Is.Not.Null);
+            Assert.That(asset.info, Is.EqualTo(otherAsset.info));
+            Assert.That(asset.info.Equals(otherAsset.info), Is.True);
+            AssetDatabase.DeleteAsset(exportPath);
+        }
+
+        [Test]
+        public void CreateSignalingSettingsObject()
+        {
+            var asset = SignalingSettingsObject.Create();
+            Assert.That(asset, Is.Not.Null);
+            Assert.That(asset.settings, Is.Not.Null);
+            Assert.That(asset.settings, Is.TypeOf<WebSocketSignalingSettings>());
+        }
+    }
+}

Packages/com.unity.renderstreaming@3.1.0-exp.9/Tests/Editor/EditorTest.cs.meta

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

Packages/com.unity.renderstreaming@3.1.0-exp.9/Tests/Editor/EditorUITest.cs

@@ -0,0 +1,63 @@
+using System;
+using NUnit.Framework;
+using Unity.RenderStreaming.Editor;
+
+namespace Unity.RenderStreaming.EditorTest
+{
+
+
+    class CustomSignalingSettingsEditorTest
+    {
+        [Test]
+        public void FindInspectorTypeByInspectedType()
+        {
+            Type type = typeof(WebSocketSignalingSettings);
+            Assert.That(CustomSignalingSettingsEditor.FindInspectorTypeByInspectedType(type), Is.EqualTo(typeof(WebSocketSignalingSettingsEditor)));
+
+            type = typeof(HttpSignalingSettings);
+            Assert.That(CustomSignalingSettingsEditor.FindInspectorTypeByInspectedType(type), Is.EqualTo(typeof(HttpSignalingSettingsEditor)));
+
+            type = typeof(int);
+            Assert.That(CustomSignalingSettingsEditor.FindInspectorTypeByInspectedType(type), Is.Null);
+        }
+
+        [Test]
+        public void FindInspectedTypeByLabel()
+        {
+            var labels = CustomSignalingSettingsEditor.Labels();
+            foreach (var label in labels)
+            {
+                Assert.That(CustomSignalingSettingsEditor.FindInspectedTypeByLabel(label), Is.Not.Null);
+            }
+            Assert.That(CustomSignalingSettingsEditor.FindInspectedTypeByLabel(null), Is.Null);
+            Assert.That(CustomSignalingSettingsEditor.FindInspectedTypeByLabel(string.Empty), Is.Null);
+            Assert.That(CustomSignalingSettingsEditor.FindInspectedTypeByLabel("dummy"), Is.Null);
+        }
+
+        [Test]
+        public void FindLabel()
+        {
+            Type inspectorType = typeof(WebSocketSignalingSettingsEditor);
+            Type inspectedType = typeof(WebSocketSignalingSettings);
+            Assert.That(CustomSignalingSettingsEditor.FindLabelByInspectorType(inspectorType), Is.EqualTo(CustomSignalingSettingsEditor.FindLabelByInspectedType(inspectedType)));
+
+            inspectorType = typeof(HttpSignalingSettingsEditor);
+            inspectedType = typeof(HttpSignalingSettings);
+            Assert.That(CustomSignalingSettingsEditor.FindLabelByInspectorType(inspectorType), Is.EqualTo(CustomSignalingSettingsEditor.FindLabelByInspectedType(inspectedType)));
+
+            inspectorType = typeof(int);
+            Assert.That(CustomSignalingSettingsEditor.FindLabelByInspectorType(inspectorType), Is.Null);
+            inspectedType = typeof(int);
+            Assert.That(CustomSignalingSettingsEditor.FindLabelByInspectedType(inspectedType), Is.Null);
+        }
+
+        [Test]
+        public void Labels()
+        {
+            var labels = CustomSignalingSettingsEditor.Labels();
+            Assert.That(labels, Is.Not.Empty);
+            Assert.That(labels, Is.Not.Contains(string.Empty));
+            Assert.That(labels, Is.Not.Contains(null));
+        }
+    }
+}

Packages/com.unity.renderstreaming@3.1.0-exp.9/Tests/Editor/EditorUITest.cs.meta

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

Packages/com.unity.renderstreaming@3.1.0-exp.9/Tests/Editor/RenderStreamingSettings.asset

@@ -0,0 +1,29 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: bc8ba17751ad4107a50fa1415017b6b1, type: 3}
+  m_Name: RenderStreamingSettings
+  m_EditorClassIdentifier: 
+  automaticStreaming: 0
+  signalingSettings:
+    id: 0
+  references:
+    version: 1
+    00000000:
+      type: {class: WebSocketSignalingSettings, ns: Unity.RenderStreaming, asm: Unity.RenderStreaming}
+      data:
+        m_url: ws://127.0.0.1:80
+        m_iceServers:
+        - m_urls:
+          - stun:stun.l.google.com:19302
+          m_username: 
+          m_credentialType: 0
+          m_credential: 

Packages/com.unity.renderstreaming@3.1.0-exp.9/Tests/Editor/RenderStreamingSettings.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 63a426df4894b1f4b94574475120a261
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.unity.renderstreaming@3.1.0-exp.9/Tests/Editor/RenderStreamingTest.cs

@@ -0,0 +1,61 @@
+using System.Linq;
+using NUnit.Framework;
+using Unity.RenderStreaming.Editor;
+using UnityEditor;
+using UnityEngine;
+
+namespace Unity.RenderStreaming.EditorTest
+{
+    class RenderStreamingTest
+    {
+        private RenderStreamingSettings temp;
+
+        [SetUp]
+        public void Setup()
+        {
+            temp = RenderStreaming.Settings;
+            RenderStreaming.Settings =
+                AssetDatabase.LoadAssetAtPath<RenderStreamingSettings>(RenderStreaming.DefaultRenderStreamingSettingsPath);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            if (temp != null)
+            {
+                RenderStreaming.Settings = temp;
+            }
+        }
+
+        [Test]
+        public void RenderStreamingSettings()
+        {
+            Assert.That(() => RenderStreamingEditor.SetRenderStreamingSettings(null), Throws.ArgumentNullException);
+
+            var settings = ScriptableObject.CreateInstance<RenderStreamingSettings>();
+            settings.signalingSettings = new WebSocketSignalingSettings();
+
+            RenderStreamingEditor.SetRenderStreamingSettings(settings);
+            Assert.That(RenderStreaming.Settings.automaticStreaming, Is.EqualTo(settings.automaticStreaming));
+            Assert.That(RenderStreaming.Settings.signalingSettings, Is.EqualTo(settings.signalingSettings));
+
+            Object.DestroyImmediate(settings);
+        }
+
+        [Test]
+        public void SignalingSettings()
+        {
+            Assert.That(() => RenderStreamingEditor.SetSignalingSettings(null), Throws.ArgumentNullException);
+
+            var url = "wss://127.0.0.1:8081";
+            var iceServers = new IceServer[] { new IceServer(new string[] { "stun:stun.l.google.com:19302" }) };
+            var signalingSettings = new WebSocketSignalingSettings(url, iceServers);
+
+            Assert.That(() => RenderStreamingEditor.SetSignalingSettings(signalingSettings), Throws.Nothing);
+
+            var settings = RenderStreaming.GetSignalingSettings<WebSocketSignalingSettings>();
+            Assert.That(settings.url, Is.EqualTo(url));
+            Assert.That(settings.iceServers.ElementAt(0).urls, Is.EquivalentTo(iceServers[0].urls));
+        }
+    }
+}

Packages/com.unity.renderstreaming@3.1.0-exp.9/Tests/Editor/RenderStreamingTest.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7107edca028c4640b99957dff2e7b6aa
+timeCreated: 1674443070

Packages/com.unity.renderstreaming@3.1.0-exp.9/Tests/Editor/RequestJobTest.cs

@@ -0,0 +1,44 @@
+using System.Collections;                   //IEnumerator
+using NUnit.Framework;                      //Timeout, Assert
+using Unity.RenderStreaming.Editor;         //RequestJobManager
+using UnityEditor.PackageManager;           //PackageCollection
+using UnityEditor.PackageManager.Requests;  //ListRequest, AddRequest, etc
+using UnityEngine.TestTools;                //UnityTest
+
+namespace Unity.RenderStreaming.EditorTest
+{
+    class RequestJobTest
+    {
+        [UnityTest]
+        [Timeout(5000)]
+        public IEnumerator VerifyRenderStreamingPackage()
+        {
+
+            RequestJobManager.CreateListRequest(false, false, OnListRequestSucceeded, OnListRequestFailed);
+            while (!m_listRequestCompleted)
+                yield return null;
+
+            Assert.True(m_packageFound);
+        }
+
+        //---------------------------------------------------------------------------------------------------------------------
+        void OnListRequestSucceeded(Request<PackageCollection> packageCollection)
+        {
+            m_listRequestCompleted = true;
+            m_packageFound = null != packageCollection.FindPackage("com.unity.renderstreaming");
+        }
+
+        //---------------------------------------------------------------------------------------------------------------------
+        void OnListRequestFailed(Request<PackageCollection> packageCollection)
+        {
+            m_listRequestCompleted = true;
+        }
+
+        //---------------------------------------------------------------------------------------------------------------------
+
+        bool m_listRequestCompleted = false;
+        bool m_packageFound = false;
+
+    }
+
+} //namespace Unity.RenderStreaming

Packages/com.unity.renderstreaming@3.1.0-exp.9/Tests/Editor/RequestJobTest.cs.meta

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

Packages/com.unity.renderstreaming@3.1.0-exp.9/Tests/Editor/Unity.RenderStreaming.EditorTests.asmdef

@@ -0,0 +1,26 @@
+{
+    "name": "Unity.RenderStreaming.EditorTests",
+    "rootNamespace": "",
+    "references": [
+        "GUID:40a5acf76f04c4c8ebb69605e4b0d5c7",
+        "GUID:7e479a0c97f111c48b6a279fad867f28",
+        "GUID:27619889b8ba8c24980f49ee34dbb44a",
+        "GUID:0acc523941302664db1f4e527237feb3",
+        "GUID:f12aafacab75a87499e7e45c873ffab8"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": true,
+    "precompiledReferences": [
+        "nunit.framework.dll"
+    ],
+    "autoReferenced": false,
+    "defineConstraints": [
+        "UNITY_INCLUDE_TESTS"
+    ],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

Packages/com.unity.renderstreaming@3.1.0-exp.9/Tests/Editor/Unity.RenderStreaming.EditorTests.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 6d0147213c4314f249ef115d9cd8589d
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.unity.renderstreaming@3.1.0-exp.9/Tests/Editor/VideoCodecInfoObject.cs

@@ -0,0 +1,10 @@
+using UnityEngine;
+
+namespace Unity.RenderStreaming.EditorTest
+{
+    class VideoCodecInfoObject : ScriptableObject
+    {
+        [SerializeField]
+        public VideoCodecInfo info;
+    }
+}

Packages/com.unity.renderstreaming@3.1.0-exp.9/Tests/Editor/VideoCodecInfoObject.cs.meta

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