386 lines
12 KiB
C#
Executable File
386 lines
12 KiB
C#
Executable File
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using NUnit.Framework;
|
|
using UnityEngine.TestTools;
|
|
|
|
using UnityEditor;
|
|
using UnityEngine.Rendering;
|
|
|
|
namespace UnityEngine.XR.Management.Tests
|
|
{
|
|
public abstract class XRSettingsManagerTestBase
|
|
{
|
|
private XRManagerSettings m_Manager;
|
|
public XRManagerSettings manager => m_Manager;
|
|
|
|
private List<XRLoader> m_Loaders;
|
|
public List<XRLoader> loaders => m_Loaders;
|
|
|
|
public abstract int loaderCount { get; }
|
|
|
|
protected void SetupBase()
|
|
{
|
|
m_Manager = ScriptableObject.CreateInstance<XRManagerSettings>();
|
|
manager.automaticLoading = false;
|
|
|
|
m_Loaders = new List<XRLoader>();
|
|
|
|
for (int i = 0; i < loaderCount; i++)
|
|
{
|
|
DummyLoader dl = ScriptableObject.CreateInstance(typeof(DummyLoader)) as DummyLoader;
|
|
dl.id = i;
|
|
dl.shouldFail = true;
|
|
loaders.Add(dl);
|
|
m_Manager.currentLoaders.Add(dl);
|
|
m_Manager.registeredLoaders.Add(dl);
|
|
}
|
|
}
|
|
|
|
protected void TeardownBase()
|
|
{
|
|
#if UNITY_EDITOR
|
|
if (!Application.isPlaying)
|
|
{
|
|
Object.DestroyImmediate(m_Manager);
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
Object.Destroy(m_Manager);
|
|
}
|
|
|
|
m_Manager = null;
|
|
}
|
|
}
|
|
|
|
[TestFixture(0, -1)] // No loaders, should never have any results
|
|
[TestFixture(1, -1)] // 1 loader, fails so no active loaders
|
|
[TestFixture(1, 0)] // All others, make sure the active loader is expected loader.
|
|
[TestFixture(2, 0)]
|
|
[TestFixture(2, 1)]
|
|
[TestFixture(3, 2)]
|
|
class ManualLifetimeTests : XRSettingsManagerTestBase
|
|
{
|
|
int m_LoaderIndexToWin;
|
|
public override int loaderCount { get; }
|
|
|
|
public ManualLifetimeTests(int loaderCountIn, int loaderIndexToWin)
|
|
{
|
|
loaderCount = loaderCountIn;
|
|
m_LoaderIndexToWin = loaderIndexToWin;
|
|
}
|
|
|
|
[SetUp]
|
|
public void SetupXRManagerTest()
|
|
{
|
|
SetupBase();
|
|
|
|
if (loaderCount > m_LoaderIndexToWin && m_LoaderIndexToWin >= 0 && loaders[m_LoaderIndexToWin] is DummyLoader)
|
|
{
|
|
var dlToWin = manager.activeLoaders[m_LoaderIndexToWin] as DummyLoader;
|
|
dlToWin.shouldFail = false;
|
|
}
|
|
}
|
|
|
|
[TearDown]
|
|
public void TeardownXRManagerTest()
|
|
{
|
|
TeardownBase();
|
|
}
|
|
|
|
[UnityTest]
|
|
public IEnumerator CheckActivatedLoader()
|
|
{
|
|
Assert.IsNotNull(manager);
|
|
|
|
yield return manager.InitializeLoader();
|
|
|
|
if (m_LoaderIndexToWin < 0 || m_LoaderIndexToWin >= loaders.Count)
|
|
{
|
|
Assert.IsNull(manager.activeLoader);
|
|
}
|
|
else
|
|
{
|
|
Assert.IsNotNull(manager.activeLoader);
|
|
Assert.AreEqual(loaders[m_LoaderIndexToWin], manager.activeLoader);
|
|
}
|
|
|
|
manager.DeinitializeLoader();
|
|
|
|
Assert.IsNull(manager.activeLoader);
|
|
|
|
manager.TrySetLoaders(new List<XRLoader>());
|
|
}
|
|
}
|
|
|
|
#if UNITY_EDITOR_WIN || UNITY_EDITOR_OSX
|
|
|
|
#if UNITY_EDITOR_WIN
|
|
[TestFixture(GraphicsDeviceType.Direct3D11, 0, GraphicsDeviceType.Direct3D11, null)]
|
|
[TestFixture(GraphicsDeviceType.Direct3D11, 1, GraphicsDeviceType.Direct3D12, GraphicsDeviceType.Direct3D11)]
|
|
[TestFixture(GraphicsDeviceType.Direct3D11, -1, GraphicsDeviceType.Direct3D12, GraphicsDeviceType.Vulkan)]
|
|
[TestFixture(GraphicsDeviceType.Direct3D11, 0, GraphicsDeviceType.Null, GraphicsDeviceType.Vulkan)]
|
|
[TestFixture(GraphicsDeviceType.Direct3D11, 1, GraphicsDeviceType.Vulkan, GraphicsDeviceType.Null)]
|
|
#elif UNITY_EDITOR_OSX
|
|
[TestFixture(GraphicsDeviceType.Metal, 0, GraphicsDeviceType.Metal, null)]
|
|
[TestFixture(GraphicsDeviceType.Metal, 1, GraphicsDeviceType.Direct3D12, GraphicsDeviceType.Metal)]
|
|
[TestFixture(GraphicsDeviceType.Metal, -1, GraphicsDeviceType.OpenGLES3, GraphicsDeviceType.Vulkan)]
|
|
[TestFixture(GraphicsDeviceType.Metal, 0, GraphicsDeviceType.Null, GraphicsDeviceType.Vulkan)]
|
|
[TestFixture(GraphicsDeviceType.Metal, 1, GraphicsDeviceType.Vulkan, GraphicsDeviceType.Null)]
|
|
#endif
|
|
class GraphicsAPICompatibilityTests : XRSettingsManagerTestBase
|
|
{
|
|
public override int loaderCount { get; }
|
|
|
|
private GraphicsDeviceType m_PlayerSettingsDeviceType;
|
|
private GraphicsDeviceType[] m_LoadersSupporteDeviceTypes;
|
|
int m_LoaderIndexToWin;
|
|
public GraphicsAPICompatibilityTests(GraphicsDeviceType playerSettingsDeviceType, int indexToWin, GraphicsDeviceType loader0, GraphicsDeviceType? loader1)
|
|
{
|
|
m_LoaderIndexToWin = indexToWin;
|
|
m_PlayerSettingsDeviceType = playerSettingsDeviceType;
|
|
|
|
if (loader1.HasValue)
|
|
{
|
|
m_LoadersSupporteDeviceTypes = new[] {loader0, loader1.Value};
|
|
}
|
|
else
|
|
{
|
|
m_LoadersSupporteDeviceTypes = new[] {loader0};
|
|
}
|
|
|
|
loaderCount = m_LoadersSupporteDeviceTypes.Length;
|
|
}
|
|
|
|
[SetUp]
|
|
public void SetupPlayerSettings()
|
|
{
|
|
SetupBase();
|
|
|
|
GraphicsDeviceType[] deviceTypes = PlayerSettings.GetGraphicsAPIs(BuildTarget.StandaloneOSX);
|
|
var oldGfxType = m_PlayerSettingsDeviceType;
|
|
|
|
// If the type we want to check isn't the supported graphics type, then substitute it out
|
|
// so we can still pass the tests. Semantics are the same regardless of actual devices.
|
|
if (SystemInfo.graphicsDeviceType != m_PlayerSettingsDeviceType)
|
|
{
|
|
m_PlayerSettingsDeviceType = SystemInfo.graphicsDeviceType;
|
|
|
|
for (int i = 0; i < m_LoadersSupporteDeviceTypes.Length; i++)
|
|
{
|
|
if (oldGfxType == m_LoadersSupporteDeviceTypes[i])
|
|
{
|
|
m_LoadersSupporteDeviceTypes[i] = m_PlayerSettingsDeviceType;
|
|
}
|
|
}
|
|
}
|
|
|
|
#if UNITY_EDITOR_WIN
|
|
PlayerSettings.SetGraphicsAPIs(BuildTarget.StandaloneWindows64, new[] { m_PlayerSettingsDeviceType });
|
|
#elif UNITY_EDITOR_OSX
|
|
PlayerSettings.SetGraphicsAPIs(BuildTarget.StandaloneOSX, new[] { m_PlayerSettingsDeviceType });
|
|
#endif
|
|
|
|
for (var i = 0; i < loaderCount; ++i)
|
|
{
|
|
var dl = loaders[i] as DummyLoader;
|
|
dl.shouldFail = (i != m_LoaderIndexToWin);
|
|
dl.supportedDeviceType = m_LoadersSupporteDeviceTypes[i];
|
|
}
|
|
}
|
|
|
|
[TearDown]
|
|
public void TearDown()
|
|
{
|
|
TeardownBase();
|
|
}
|
|
|
|
[Test]
|
|
public void CheckGraphicsAPICompatibilitySync()
|
|
{
|
|
manager.InitializeLoaderSync();
|
|
|
|
if (m_LoaderIndexToWin < 0 || m_LoaderIndexToWin >= loaders.Count)
|
|
{
|
|
Assert.IsNull(manager.activeLoader);
|
|
}
|
|
else
|
|
{
|
|
Assert.IsNotNull(manager.activeLoader);
|
|
Assert.AreEqual(loaders[m_LoaderIndexToWin], manager.activeLoader);
|
|
manager.DeinitializeLoader();
|
|
}
|
|
|
|
manager.TrySetLoaders(new List<XRLoader>());
|
|
}
|
|
|
|
[UnityTest]
|
|
public IEnumerator CheckGraphicsAPICompatibility()
|
|
{
|
|
yield return manager.InitializeLoader();
|
|
|
|
if (m_LoaderIndexToWin < 0 || m_LoaderIndexToWin >= loaders.Count)
|
|
{
|
|
Assert.IsNull(manager.activeLoader);
|
|
}
|
|
else
|
|
{
|
|
Assert.IsNotNull(manager.activeLoader);
|
|
Assert.AreEqual(loaders[m_LoaderIndexToWin], manager.activeLoader);
|
|
manager.DeinitializeLoader();
|
|
}
|
|
|
|
manager.TrySetLoaders(new List<XRLoader>());
|
|
}
|
|
}
|
|
#endif // UNITY_EDITOR_WIN || UNITY_EDITOR_OSX
|
|
|
|
|
|
[TestFixture(0)] // Test case where no loaders exist in the list
|
|
[TestFixture(1)]
|
|
[TestFixture(2)]
|
|
[TestFixture(3)]
|
|
[TestFixture(4)]
|
|
class RuntimeActiveLoadersManipulationTests : XRSettingsManagerTestBase
|
|
{
|
|
public override int loaderCount { get; }
|
|
public RuntimeActiveLoadersManipulationTests(int loaderCountIn)
|
|
{
|
|
loaderCount = loaderCountIn;
|
|
}
|
|
|
|
[SetUp]
|
|
public void SetupRuntimeActiveLoadersManipulationTest()
|
|
{
|
|
SetupBase();
|
|
}
|
|
|
|
[TearDown]
|
|
public void TeardownRuntimeActiveLoadersManipulationTest()
|
|
{
|
|
TeardownBase();
|
|
}
|
|
|
|
[Test]
|
|
public void CheckIfSetLegalLoaderListWorks()
|
|
{
|
|
Assert.IsNotNull(manager);
|
|
|
|
var originalLoaders = new List<XRLoader>(manager.activeLoaders);
|
|
|
|
// An empty loader list is valid
|
|
Assert.True(manager.TrySetLoaders(new List<XRLoader>()));
|
|
|
|
// Make sure that the registered loaders hasn't been modified at all
|
|
if (loaderCount > 0)
|
|
Assert.IsNotEmpty(manager.registeredLoaders);
|
|
Assert.AreEqual(manager.registeredLoaders.Count, loaderCount >= 0 ? loaderCount : 0);
|
|
|
|
// All loaders should be registered
|
|
Assert.True(manager.TrySetLoaders(originalLoaders));
|
|
}
|
|
|
|
[Test]
|
|
public void CheckIfLegalAddSucceeds()
|
|
{
|
|
Assert.IsNotNull(manager);
|
|
|
|
var originalLoaders = new List<XRLoader>(manager.activeLoaders);
|
|
|
|
Assert.True(manager.TrySetLoaders(new List<XRLoader>()));
|
|
|
|
if (loaderCount > 0)
|
|
Assert.IsNotEmpty(manager.registeredLoaders);
|
|
Assert.AreEqual(manager.registeredLoaders.Count, loaderCount);
|
|
|
|
for (var i = 0; i < originalLoaders.Count; ++i)
|
|
{
|
|
Assert.True(manager.TryAddLoader(originalLoaders[originalLoaders.Count - 1 - i]));
|
|
}
|
|
|
|
Assert.AreEqual(manager.registeredLoaders.Count, loaderCount);
|
|
}
|
|
|
|
[Test]
|
|
public void CheckIfIllegalAddFails()
|
|
{
|
|
Assert.IsNotNull(manager);
|
|
|
|
var dl = ScriptableObject.CreateInstance(typeof(DummyLoader)) as DummyLoader;
|
|
dl.id = -1;
|
|
dl.shouldFail = true;
|
|
|
|
Assert.False(manager.TryAddLoader(dl));
|
|
}
|
|
|
|
[Test]
|
|
public void CheckIfIllegalSetLoaderListFails()
|
|
{
|
|
Assert.IsNotNull(manager);
|
|
|
|
var dl = ScriptableObject.CreateInstance(typeof(DummyLoader)) as DummyLoader;
|
|
dl.id = -1;
|
|
dl.shouldFail = true;
|
|
|
|
var invalidList = new List<XRLoader>(manager.activeLoaders) { dl };
|
|
|
|
Assert.False(manager.TrySetLoaders(invalidList));
|
|
|
|
invalidList = new List<XRLoader> { dl };
|
|
|
|
Assert.False(manager.TrySetLoaders(invalidList));
|
|
}
|
|
|
|
[Test]
|
|
public void CheckIfRemoveAndReAddAtSameIndexWorks()
|
|
{
|
|
Assert.IsNotNull(manager);
|
|
|
|
var originalList = manager.activeLoaders;
|
|
|
|
for (var i = 0; i < originalList.Count; ++i)
|
|
{
|
|
var loader = originalList[i];
|
|
Assert.True(manager.TryRemoveLoader(loader));
|
|
|
|
if (loaderCount > 0)
|
|
Assert.IsNotEmpty(manager.registeredLoaders);
|
|
Assert.AreEqual(manager.registeredLoaders.Count, loaderCount > 0 ? loaderCount : 0);
|
|
|
|
Assert.True(manager.TryAddLoader(loader, i));
|
|
|
|
Assert.AreEqual(originalList[i], manager.activeLoaders[i]);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void CheckIfAttemptToAddDuplicateLoadersFails()
|
|
{
|
|
Assert.IsNotNull(manager);
|
|
|
|
var originalLoaders = manager.activeLoaders;
|
|
foreach (var loader in originalLoaders)
|
|
{
|
|
Assert.False(manager.TryAddLoader(loader));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void CheckIfAttemptsToSetLoaderListThatContainDuplicatesFails()
|
|
{
|
|
Assert.IsNotNull(manager);
|
|
|
|
if (loaderCount > 0)
|
|
{
|
|
var originalLoaders = manager.activeLoaders;
|
|
var loadersWithDuplicates = new List<XRLoader>(manager.activeLoaders);
|
|
|
|
loadersWithDuplicates.AddRange(originalLoaders);
|
|
|
|
Assert.False(manager.TrySetLoaders(loadersWithDuplicates));
|
|
}
|
|
}
|
|
}
|
|
}
|