InnoLab/com.unity.netcode.gameobjects
Archived
6
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

com.unity.netcode.gameobjects@1.0.0-pre.6

Browse Source 
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

Additional documentation and release notes are available at [Multiplayer Documentation](https://docs-multiplayer.unity3d.com).

## [1.0.0-pre.6] - 2022-03-02

### Added
- NetworkAnimator now properly synchrhonizes all animation layers as well as runtime-adjusted weighting between them (#1765)
- Added first set of tests for NetworkAnimator - parameter syncing, trigger set / reset, override network animator (#1735)

### Changed

### Fixed
- Fixed an issue where sometimes the first client to connect to the server could see messages from the server as coming from itself. (#1683)
- Fixed an issue where clients seemed to be able to send messages to ClientId 1, but these messages would actually still go to the server (id 0) instead of that client. (#1683)
- Improved clarity of error messaging when a client attempts to send a message to a destination other than the server, which isn't allowed. (#1683)
- Disallowed async keyword in RPCs (#1681)
- Fixed an issue where Alpha release versions of Unity (version 2022.2.0a5 and later) will not compile due to the UNet Transport no longer existing (#1678)
- Fixed messages larger than 64k being written with incorrectly truncated message size in header (#1686) (credit: @kaen)
- Fixed overloading RPC methods causing collisions and failing on IL2CPP targets. (#1694)
- Fixed spawn flow to propagate `IsSceneObject` down to children NetworkObjects, decouple implicit relationship between object spawning & `IsSceneObject` flag (#1685)
- Fixed error when serializing ConnectionApprovalMessage with scene management disabled when one or more objects is hidden via the CheckObjectVisibility delegate (#1720)
- Fixed CheckObjectVisibility delegate not being properly invoked for connecting clients when Scene Management is enabled. (#1680)
- Fixed NetworkList to properly call INetworkSerializable's NetworkSerialize() method (#1682)
- Fixed NetworkVariables containing more than 1300 bytes of data (such as large NetworkLists) no longer cause an OverflowException (the limit on data size is now whatever limit the chosen transport imposes on fragmented NetworkDelivery mechanisms) (#1725)
- Fixed ServerRpcParams and ClientRpcParams must be the last parameter of an RPC in order to function properly. Added a compile-time check to ensure this is the case and trigger an error if they're placed elsewhere (#1721)
- Fixed FastBufferReader being created with a length of 1 if provided an input of length 0 (#1724)
- Fixed The NetworkConfig's checksum hash includes the NetworkTick so that clients with a different tickrate than the server are identified and not allowed to connect (#1728)
- Fixed OwnedObjects not being properly modified when using ChangeOwnership (#1731)
- Improved performance in NetworkAnimator (#1735)
- Removed the "always sync" network animator (aka "autosend") parameters (#1746)
This commit is contained in:
Unity Technologies
2022-03-02 00:00:00 +00:00
parent 4818405514
commit 5b4aaa8b59
205 changed files with 6971 additions and 2722 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
Tests/Runtime/Metrics/MessagingMetricsTests.cs
View File

@@ -6,7 +6,7 @@ using System.Linq;
using NUnit.Framework;
using Unity.Collections;
using Unity.Multiplayer.Tools.MetricTypes;
using Unity.Netcode.RuntimeTests.Metrics.Utility;
using Unity.Netcode.TestHelpers.Runtime.Metrics;
using UnityEngine;
using UnityEngine.TestTools;
@@ -20,12 +20,12 @@ namespace Unity.Netcode.RuntimeTests.Metrics
private static readonly int k_NamedMessageOverhead = (int)k_MessageNameHashSize + k_MessageHeaderSize;
private static readonly int k_UnnamedMessageOverhead = k_MessageHeaderSize;
protected override int NbClients => 2;
protected override int NumberOfClients => 2;
[UnityTest]
public IEnumerator TrackNetworkMessageSentMetric()
{
var waitForMetricValues = new WaitForMetricValues<NetworkMessageEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.NetworkMessageSent);
var waitForMetricValues = new WaitForEventMetricValues<NetworkMessageEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.NetworkMessageSent);
var messageName = Guid.NewGuid();
using (var writer = new FastBufferWriter(1300, Allocator.Temp))
@@ -38,17 +38,15 @@ namespace Unity.Netcode.RuntimeTests.Metrics
yield return waitForMetricValues.WaitForMetricsReceived();
var networkMessageSentMetricValues = waitForMetricValues.AssertMetricValuesHaveBeenFound();
Assert.AreEqual(1, networkMessageSentMetricValues.Count);
var networkMessageEvent = networkMessageSentMetricValues.First();
Assert.AreEqual(nameof(NamedMessage), networkMessageEvent.Name);
Assert.AreEqual(FirstClient.LocalClientId, networkMessageEvent.Connection.Id);
// We should have 1 NamedMessage and some potential SnapshotMessage
Assert.That(networkMessageSentMetricValues, Has.Exactly(1).Matches<NetworkMessageEvent>(x => x.Name == nameof(NamedMessage)));
}
[UnityTest]
public IEnumerator TrackNetworkMessageSentMetricToMultipleClients()
{
var waitForMetricValues = new WaitForMetricValues<NetworkMessageEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.NetworkMessageSent);
var waitForMetricValues = new WaitForEventMetricValues<NetworkMessageEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.NetworkMessageSent);
var messageName = Guid.NewGuid();
using (var writer = new FastBufferWriter(1300, Allocator.Temp))
{
@@ -74,7 +72,9 @@ namespace Unity.Netcode.RuntimeTests.Metrics
{
Debug.Log($"Received from {sender}");
});
var waitForMetricValues = new WaitForMetricValues<NetworkMessageEvent>(FirstClientMetrics.Dispatcher, NetworkMetricTypes.NetworkMessageReceived);
var waitForMetricValues = new WaitForEventMetricValues<NetworkMessageEvent>(FirstClientMetrics.Dispatcher, NetworkMetricTypes.NetworkMessageReceived,
metric => metric.Name == nameof(NamedMessage));
using (var writer = new FastBufferWriter(1300, Allocator.Temp))
{
writer.WriteValueSafe(messageName);
@@ -85,16 +85,14 @@ namespace Unity.Netcode.RuntimeTests.Metrics
yield return waitForMetricValues.WaitForMetricsReceived();
var networkMessageReceivedValues = waitForMetricValues.AssertMetricValuesHaveBeenFound();
Assert.AreEqual(1, networkMessageReceivedValues.Count(x => x.Name.Equals(nameof(NamedMessage))));
var namedMessageReceived = networkMessageReceivedValues.First();
Assert.AreEqual(Server.LocalClientId, namedMessageReceived.Connection.Id);
// We should have 1 NamedMessage and some potential SnapshotMessage
Assert.That(networkMessageReceivedValues, Has.Exactly(1).Matches<NetworkMessageEvent>(x => x.Name == nameof(NamedMessage)));
}
[UnityTest]
public IEnumerator TrackNamedMessageSentMetric()
{
var waitForMetricValues = new WaitForMetricValues<NamedMessageEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.NamedMessageSent);
var waitForMetricValues = new WaitForEventMetricValues<NamedMessageEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.NamedMessageSent);
var messageName = Guid.NewGuid();
using (var writer = new FastBufferWriter(1300, Allocator.Temp))
@@ -119,7 +117,7 @@ namespace Unity.Netcode.RuntimeTests.Metrics
[UnityTest]
public IEnumerator TrackNamedMessageSentMetricToMultipleClients()
{
var waitForMetricValues = new WaitForMetricValues<NamedMessageEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.NamedMessageSent);
var waitForMetricValues = new WaitForEventMetricValues<NamedMessageEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.NamedMessageSent);
var messageName = Guid.NewGuid();
using (var writer = new FastBufferWriter(1300, Allocator.Temp))
{
@@ -140,7 +138,7 @@ namespace Unity.Netcode.RuntimeTests.Metrics
[UnityTest]
public IEnumerator TrackNamedMessageSentMetricToSelf()
{
var waitForMetricValues = new WaitForMetricValues<NamedMessageEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.NamedMessageSent);
var waitForMetricValues = new WaitForEventMetricValues<NamedMessageEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.NamedMessageSent);
var messageName = Guid.NewGuid();
using (var writer = new FastBufferWriter(1300, Allocator.Temp))
{
@@ -157,7 +155,7 @@ namespace Unity.Netcode.RuntimeTests.Metrics
[UnityTest]
public IEnumerator TrackNamedMessageReceivedMetric()
{
var waitForMetricValues = new WaitForMetricValues<NamedMessageEvent>(FirstClientMetrics.Dispatcher, NetworkMetricTypes.NamedMessageReceived);
var waitForMetricValues = new WaitForEventMetricValues<NamedMessageEvent>(FirstClientMetrics.Dispatcher, NetworkMetricTypes.NamedMessageReceived);
var messageName = Guid.NewGuid();
@@ -198,7 +196,7 @@ namespace Unity.Netcode.RuntimeTests.Metrics
}
var waitForMetricValues = new WaitForMetricValues<UnnamedMessageEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.UnnamedMessageSent);
var waitForMetricValues = new WaitForEventMetricValues<UnnamedMessageEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.UnnamedMessageSent);
yield return waitForMetricValues.WaitForMetricsReceived();
@@ -214,7 +212,7 @@ namespace Unity.Netcode.RuntimeTests.Metrics
public IEnumerator TrackUnnamedMessageSentMetricToMultipleClients()
{
var message = Guid.NewGuid();
var waitForMetricValues = new WaitForMetricValues<UnnamedMessageEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.UnnamedMessageSent);
var waitForMetricValues = new WaitForEventMetricValues<UnnamedMessageEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.UnnamedMessageSent);
using (var writer = new FastBufferWriter(1300, Allocator.Temp))
{
writer.WriteValueSafe(message);
@@ -237,7 +235,7 @@ namespace Unity.Netcode.RuntimeTests.Metrics
[UnityTest]
public IEnumerator TrackUnnamedMessageSentMetricToSelf()
{
var waitForMetricValues = new WaitForMetricValues<UnnamedMessageEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.UnnamedMessageSent);
var waitForMetricValues = new WaitForEventMetricValues<UnnamedMessageEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.UnnamedMessageSent);
var messageName = Guid.NewGuid();
using (var writer = new FastBufferWriter(1300, Allocator.Temp))
{
@@ -255,7 +253,7 @@ namespace Unity.Netcode.RuntimeTests.Metrics
public IEnumerator TrackUnnamedMessageReceivedMetric()
{
var message = Guid.NewGuid();
var waitForMetricValues = new WaitForMetricValues<UnnamedMessageEvent>(FirstClientMetrics.Dispatcher, NetworkMetricTypes.UnnamedMessageReceived);
var waitForMetricValues = new WaitForEventMetricValues<UnnamedMessageEvent>(FirstClientMetrics.Dispatcher, NetworkMetricTypes.UnnamedMessageReceived);
using (var writer = new FastBufferWriter(1300, Allocator.Temp))
{
writer.WriteValueSafe(message);

2
Tests/Runtime/Metrics/MetricsDispatchTests.cs
View File

@@ -4,6 +4,8 @@ using System.Collections;
using NUnit.Framework;
using Unity.Multiplayer.Tools.NetStats;
using UnityEngine.TestTools;
using Unity.Netcode.TestHelpers.Runtime;
using Unity.Netcode.TestHelpers.Runtime.Metrics;
namespace Unity.Netcode.RuntimeTests.Metrics
{

85
Tests/Runtime/Metrics/NetworkObjectMetricsTests.cs
View File

@@ -1,52 +1,43 @@
#if MULTIPLAYER_TOOLS
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using NUnit.Framework;
using Unity.Multiplayer.Tools.MetricTypes;
using Unity.Netcode.RuntimeTests.Metrics.Utility;
using UnityEngine;
using UnityEngine.TestTools;
using Unity.Netcode.TestHelpers.Runtime.Metrics;
namespace Unity.Netcode.RuntimeTests.Metrics
{
internal class NetworkObjectMetricsTests : SingleClientMetricTestBase
{
private const string k_NewNetworkObjectName = "TestNetworkObjectToSpawn";
private NetworkObject m_NewNetworkPrefab;
// Keep less than 23 chars to avoid issues if compared against a 32-byte fixed string
// since it will have "(Clone)" appended
private const string k_NewNetworkObjectName = "MetricObject";
private GameObject m_NewNetworkPrefab;
protected override Action<GameObject> UpdatePlayerPrefab => _ =>
/// <summary>
/// Use OnServerAndClientsCreated to create any additional prefabs that you might need
/// </summary>
protected override void OnServerAndClientsCreated()
{
var gameObject = new GameObject(k_NewNetworkObjectName);
m_NewNetworkPrefab = gameObject.AddComponent<NetworkObject>();
MultiInstanceHelpers.MakeNetworkObjectTestPrefab(m_NewNetworkPrefab);
var networkPrefab = new NetworkPrefab { Prefab = gameObject };
m_ServerNetworkManager.NetworkConfig.NetworkPrefabs.Add(networkPrefab);
foreach (var client in m_ClientNetworkManagers)
{
client.NetworkConfig.NetworkPrefabs.Add(networkPrefab);
}
};
base.OnServerAndClientsCreated();
m_NewNetworkPrefab = CreateNetworkObjectPrefab(k_NewNetworkObjectName);
}
private NetworkObject SpawnNetworkObject()
{
// Spawn another network object so we can hide multiple.
var gameObject = UnityEngine.Object.Instantiate(m_NewNetworkPrefab); // new GameObject(NewNetworkObjectName);
var networkObject = gameObject.GetComponent<NetworkObject>();
networkObject.NetworkManagerOwner = Server;
networkObject.Spawn();
return networkObject;
return SpawnObject(m_NewNetworkPrefab, m_ServerNetworkManager).GetComponent<NetworkObject>();
}
[UnityTest]
public IEnumerator TrackNetworkObjectSpawnSentMetric()
{
var waitForMetricEvent = new WaitForMetricValues<ObjectSpawnedEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.ObjectSpawnedSent);
var waitForMetricEvent = new WaitForEventMetricValues<ObjectSpawnedEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.ObjectSpawnedSent);
SpawnNetworkObject();
var spawnedObject = SpawnNetworkObject();
yield return waitForMetricEvent.WaitForMetricsReceived();
@@ -55,26 +46,27 @@ namespace Unity.Netcode.RuntimeTests.Metrics
var objectSpawned = objectSpawnedSentMetricValues.Last();
Assert.AreEqual(Client.LocalClientId, objectSpawned.Connection.Id);
Assert.AreEqual($"{k_NewNetworkObjectName}(Clone)", objectSpawned.NetworkId.Name);
Assert.AreEqual(spawnedObject.name, objectSpawned.NetworkId.Name);
Assert.AreNotEqual(0, objectSpawned.BytesCount);
}
[UnityTest]
public IEnumerator TrackNetworkObjectSpawnReceivedMetric()
{
var waitForMetricEvent = new WaitForMetricValues<ObjectSpawnedEvent>(ClientMetrics.Dispatcher, NetworkMetricTypes.ObjectSpawnedReceived);
var waitForMetricEvent = new WaitForEventMetricValues<ObjectSpawnedEvent>(ClientMetrics.Dispatcher, NetworkMetricTypes.ObjectSpawnedReceived);
var networkObject = SpawnNetworkObject();
yield return s_DefaultWaitForTick;
yield return waitForMetricEvent.WaitForMetricsReceived();
var objectSpawnedReceivedMetricValues = waitForMetricEvent.AssertMetricValuesHaveBeenFound();
Assert.AreEqual(1, objectSpawnedReceivedMetricValues.Count);
var clientSideObject = s_GlobalNetworkObjects[1][networkObject.NetworkObjectId];
var objectSpawned = objectSpawnedReceivedMetricValues.First();
Assert.AreEqual(Server.LocalClientId, objectSpawned.Connection.Id);
Assert.AreEqual(networkObject.NetworkObjectId, objectSpawned.NetworkId.NetworkId);
Assert.AreEqual($"{k_NewNetworkObjectName}(Clone)", objectSpawned.NetworkId.Name);
Assert.AreEqual(clientSideObject.name, objectSpawned.NetworkId.Name);
Assert.AreNotEqual(0, objectSpawned.BytesCount);
}
@@ -83,20 +75,22 @@ namespace Unity.Netcode.RuntimeTests.Metrics
{
var networkObject = SpawnNetworkObject();
yield return new WaitForSeconds(0.2f);
yield return s_DefaultWaitForTick;
var waitForMetricEvent = new WaitForMetricValues<ObjectDestroyedEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.ObjectDestroyedSent);
var waitForMetricEvent = new WaitForEventMetricValues<ObjectDestroyedEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.ObjectDestroyedSent);
var objectName = networkObject.name;
Server.SpawnManager.OnDespawnObject(networkObject, true);
yield return s_DefaultWaitForTick;
yield return waitForMetricEvent.WaitForMetricsReceived();
var objectDestroyedSentMetricValues = waitForMetricEvent.AssertMetricValuesHaveBeenFound();
Assert.AreEqual(2, objectDestroyedSentMetricValues.Count); // As there's a client and server, this event is emitted twice.
Assert.AreEqual(2, objectDestroyedSentMetricValues.Count);
var objectDestroyed = objectDestroyedSentMetricValues.Last();
Assert.AreEqual(Client.LocalClientId, objectDestroyed.Connection.Id);
Assert.AreEqual($"{k_NewNetworkObjectName}(Clone)", objectDestroyed.NetworkId.Name);
Assert.AreEqual(objectName, objectDestroyed.NetworkId.Name);
Assert.AreNotEqual(0, objectDestroyed.BytesCount);
}
@@ -105,11 +99,14 @@ namespace Unity.Netcode.RuntimeTests.Metrics
{
var networkObject = SpawnNetworkObject();
yield return new WaitForSeconds(0.2f);
yield return s_DefaultWaitForTick;
var waitForMetricEvent = new WaitForMetricValues<ObjectDestroyedEvent>(ClientMetrics.Dispatcher, NetworkMetricTypes.ObjectDestroyedReceived);
var waitForMetricEvent = new WaitForEventMetricValues<ObjectDestroyedEvent>(ClientMetrics.Dispatcher, NetworkMetricTypes.ObjectDestroyedReceived);
var objectId = networkObject.NetworkObjectId;
var objectName = s_GlobalNetworkObjects[1][objectId].name;
Server.SpawnManager.OnDespawnObject(networkObject, true);
yield return s_DefaultWaitForTick;
yield return waitForMetricEvent.WaitForMetricsReceived();
@@ -118,8 +115,8 @@ namespace Unity.Netcode.RuntimeTests.Metrics
var objectDestroyed = objectDestroyedReceivedMetricValues.First();
Assert.AreEqual(Server.LocalClientId, objectDestroyed.Connection.Id);
Assert.AreEqual(networkObject.NetworkObjectId, objectDestroyed.NetworkId.NetworkId);
Assert.AreEqual($"{k_NewNetworkObjectName}(Clone)", objectDestroyed.NetworkId.Name);
Assert.AreEqual(objectId, objectDestroyed.NetworkId.NetworkId);
Assert.AreEqual(objectName, objectDestroyed.NetworkId.Name);
Assert.AreNotEqual(0, objectDestroyed.BytesCount);
}
@@ -128,16 +125,16 @@ namespace Unity.Netcode.RuntimeTests.Metrics
{
var networkObject1 = SpawnNetworkObject();
var networkObject2 = SpawnNetworkObject();
yield return new WaitForSeconds(0.2f);
yield return s_DefaultWaitForTick;
NetworkObject.NetworkHide(new List<NetworkObject> { networkObject1, networkObject2 }, Client.LocalClientId);
yield return new WaitForSeconds(0.2f);
yield return s_DefaultWaitForTick;
var waitForMetricEvent = new WaitForMetricValues<ObjectSpawnedEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.ObjectSpawnedSent);
var waitForMetricEvent = new WaitForEventMetricValues<ObjectSpawnedEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.ObjectSpawnedSent);
NetworkObject.NetworkShow(new List<NetworkObject> { networkObject1, networkObject2 }, Client.LocalClientId);
yield return s_DefaultWaitForTick;
yield return waitForMetricEvent.WaitForMetricsReceived();
@@ -166,12 +163,12 @@ namespace Unity.Netcode.RuntimeTests.Metrics
var networkObject1 = SpawnNetworkObject();
var networkObject2 = SpawnNetworkObject();
yield return new WaitForSeconds(0.2f);
yield return s_DefaultWaitForTick;
var waitForMetricEvent = new WaitForMetricValues<ObjectDestroyedEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.ObjectDestroyedSent);
var waitForMetricEvent = new WaitForEventMetricValues<ObjectDestroyedEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.ObjectDestroyedSent);
NetworkObject.NetworkHide(new List<NetworkObject> { networkObject1, networkObject2 }, Client.LocalClientId);
yield return s_DefaultWaitForTick;
yield return waitForMetricEvent.WaitForMetricsReceived();
var objectDestroyedSentMetricValues = waitForMetricEvent.AssertMetricValuesHaveBeenFound();

14
Tests/Runtime/Metrics/NetworkVariableMetricsTests.cs
View File

@@ -1,23 +1,25 @@
#if MULTIPLAYER_TOOLS
using System;
using System.Collections;
using System.Linq;
using NUnit.Framework;
using Unity.Multiplayer.Tools.MetricTypes;
using Unity.Netcode.RuntimeTests.Metrics.Utility;
using UnityEngine;
using UnityEngine.TestTools;
using Unity.Netcode.TestHelpers.Runtime.Metrics;
namespace Unity.Netcode.RuntimeTests.Metrics
{
internal class NetworkVariableMetricsTests : SingleClientMetricTestBase
{
protected override Action<GameObject> UpdatePlayerPrefab => prefab => prefab.AddComponent<NetworkVariableComponent>();
protected override void OnCreatePlayerPrefab()
{
m_PlayerPrefab.AddComponent<NetworkVariableComponent>();
base.OnCreatePlayerPrefab();
}
[UnityTest]
public IEnumerator TrackNetworkVariableDeltaSentMetric()
{
var waitForMetricValues = new WaitForMetricValues<NetworkVariableEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.NetworkVariableDeltaSent);
var waitForMetricValues = new WaitForEventMetricValues<NetworkVariableEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.NetworkVariableDeltaSent);
yield return waitForMetricValues.WaitForMetricsReceived();
@@ -32,7 +34,7 @@ namespace Unity.Netcode.RuntimeTests.Metrics
[UnityTest]
public IEnumerator TrackNetworkVariableDeltaReceivedMetric()
{
var waitForMetricValues = new WaitForMetricValues<NetworkVariableEvent>(ClientMetrics.Dispatcher, NetworkMetricTypes.NetworkVariableDeltaReceived);
var waitForMetricValues = new WaitForEventMetricValues<NetworkVariableEvent>(ClientMetrics.Dispatcher, NetworkMetricTypes.NetworkVariableDeltaReceived);
yield return waitForMetricValues.WaitForMetricsReceived();

14
Tests/Runtime/Metrics/OwnershipChangeMetricsTests.cs
View File

@@ -4,9 +4,10 @@ using System.Collections;
using System.Linq;
using NUnit.Framework;
using Unity.Multiplayer.Tools.MetricTypes;
using Unity.Netcode.RuntimeTests.Metrics.Utility;
using UnityEngine;
using UnityEngine.TestTools;
using Unity.Netcode.TestHelpers.Runtime;
using Unity.Netcode.TestHelpers.Runtime.Metrics;
namespace Unity.Netcode.RuntimeTests.Metrics
{
@@ -17,11 +18,11 @@ namespace Unity.Netcode.RuntimeTests.Metrics
// Header is dynamically sized due to packing, will be 2 bytes for all test messages.
private const int k_MessageHeaderSize = 2;
protected override Action<GameObject> UpdatePlayerPrefab => _ =>
protected override void OnServerAndClientsCreated()
{
var gameObject = new GameObject(k_NewNetworkObjectName);
m_NewNetworkPrefab = gameObject.AddComponent<NetworkObject>();
MultiInstanceHelpers.MakeNetworkObjectTestPrefab(m_NewNetworkPrefab);
NetcodeIntegrationTestHelpers.MakeNetworkObjectTestPrefab(m_NewNetworkPrefab);
var networkPrefab = new NetworkPrefab { Prefab = gameObject };
m_ServerNetworkManager.NetworkConfig.NetworkPrefabs.Add(networkPrefab);
@@ -29,7 +30,8 @@ namespace Unity.Netcode.RuntimeTests.Metrics
{
client.NetworkConfig.NetworkPrefabs.Add(networkPrefab);
}
};
base.OnServerAndClientsCreated();
}
private NetworkObject SpawnNetworkObject()
{
@@ -49,7 +51,7 @@ namespace Unity.Netcode.RuntimeTests.Metrics
yield return new WaitForSeconds(0.2f);
var waitForMetricValues = new WaitForMetricValues<OwnershipChangeEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.OwnershipChangeSent);
var waitForMetricValues = new WaitForEventMetricValues<OwnershipChangeEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.OwnershipChangeSent);
networkObject.ChangeOwnership(1);
@@ -70,7 +72,7 @@ namespace Unity.Netcode.RuntimeTests.Metrics
yield return new WaitForSeconds(0.2f);
var waitForMetricValues = new WaitForMetricValues<OwnershipChangeEvent>(ClientMetrics.Dispatcher, NetworkMetricTypes.OwnershipChangeReceived);
var waitForMetricValues = new WaitForEventMetricValues<OwnershipChangeEvent>(ClientMetrics.Dispatcher, NetworkMetricTypes.OwnershipChangeReceived);
networkObject.ChangeOwnership(1);

62
Tests/Runtime/Metrics/PacketMetricsTests.cs Normal file
View File

@@ -0,0 +1,62 @@
#if MULTIPLAYER_TOOLS
#if MULTIPLAYER_TOOLS_1_0_0_PRE_4
using System.Collections;
using NUnit.Framework;
using Unity.Collections;
using Unity.Multiplayer.Tools.MetricTypes;
using UnityEngine.TestTools;
using Unity.Netcode.TestHelpers.Runtime;
using Unity.Netcode.TestHelpers.Runtime.Metrics;
namespace Unity.Netcode.RuntimeTests.Metrics
{
internal class PacketMetricsTests : SingleClientMetricTestBase
{
protected override void OnOneTimeSetup()
{
#if UTP_ADAPTER
m_NetworkTransport = NetcodeIntegrationTestHelpers.InstanceTransport.UTP;
#else
m_NetworkTransport = NetcodeIntegrationTestHelpers.InstanceTransport.SIP;
#endif
base.OnOneTimeSetup();
}
[UnityTest]
public IEnumerator TrackPacketSentMetric()
{
var waitForMetricValues = new WaitForCounterMetricValue(ServerMetrics.Dispatcher, NetworkMetricTypes.PacketsSent, metric => metric > 0);
using (var writer = new FastBufferWriter(sizeof(uint), Allocator.Temp))
{
writer.WriteValueSafe(1337);
Server.CustomMessagingManager.SendUnnamedMessageToAll(writer);
}
yield return waitForMetricValues.WaitForMetricsReceived();
var totalPacketCount = waitForMetricValues.AssertMetricValueHaveBeenFound();
Assert.That(totalPacketCount, Is.InRange(1, 4));
}
[UnityTest]
public IEnumerator TrackPacketReceivedMetric()
{
var waitForMetricValues = new WaitForCounterMetricValue(ClientMetrics.Dispatcher, NetworkMetricTypes.PacketsReceived, metric => metric > 0);
using (var writer = new FastBufferWriter(sizeof(uint), Allocator.Temp))
{
writer.WriteValueSafe(1337);
Server.CustomMessagingManager.SendUnnamedMessageToAll(writer);
}
yield return waitForMetricValues.WaitForMetricsReceived();
var totalPacketCount = waitForMetricValues.AssertMetricValueHaveBeenFound();
Assert.That(totalPacketCount, Is.InRange(1, 4));
}
}
}
#endif
#endif

3
Tests/Runtime/Metrics/PacketMetricsTests.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 84a4884f4ea744a9944284d56b29531b
timeCreated: 1644269306

43
Tests/Runtime/Metrics/RpcMetricsTests.cs
View File

@@ -1,28 +1,27 @@
#if MULTIPLAYER_TOOLS
using System;
using System.Collections;
using System.Linq;
using NUnit.Framework;
using Unity.Multiplayer.Tools.MetricTypes;
using Unity.Netcode.RuntimeTests.Metrics.Utility;
using UnityEngine;
using UnityEngine.TestTools;
using Unity.Netcode.TestHelpers.Runtime.Metrics;
namespace Unity.Netcode.RuntimeTests.Metrics
{
internal class RpcMetricsTests : SingleClientMetricTestBase
{
protected override Action<GameObject> UpdatePlayerPrefab => prefab => prefab.AddComponent<RpcTestComponent>();
protected override void OnCreatePlayerPrefab()
{
m_PlayerPrefab.AddComponent<RpcTestComponent>();
base.OnCreatePlayerPrefab();
}
[UnityTest]
public IEnumerator TrackRpcSentMetricOnServer()
{
var clientPlayer = new MultiInstanceHelpers.CoroutineResultWrapper<NetworkObject>();
yield return MultiInstanceHelpers.Run(MultiInstanceHelpers.GetNetworkObjectByRepresentation(x => x.IsPlayerObject && x.OwnerClientId == Client.LocalClientId, Server, clientPlayer));
var waitForMetricValues = new WaitForEventMetricValues<RpcEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.RpcSent);
var waitForMetricValues = new WaitForMetricValues<RpcEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.RpcSent);
clientPlayer.Result.GetComponent<RpcTestComponent>().MyClientRpc();
m_PlayerNetworkObjects[m_ServerNetworkManager.LocalClientId][Client.LocalClientId].GetComponent<RpcTestComponent>().MyClientRpc();
yield return waitForMetricValues.WaitForMetricsReceived();
@@ -39,12 +38,9 @@ namespace Unity.Netcode.RuntimeTests.Metrics
[UnityTest]
public IEnumerator TrackRpcSentMetricOnClient()
{
var clientPlayer = new MultiInstanceHelpers.CoroutineResultWrapper<NetworkObject>();
yield return MultiInstanceHelpers.Run(MultiInstanceHelpers.GetNetworkObjectByRepresentation(x => x.IsPlayerObject && x.OwnerClientId == Client.LocalClientId, Client, clientPlayer));
var waitForClientMetricsValues = new WaitForEventMetricValues<RpcEvent>(ClientMetrics.Dispatcher, NetworkMetricTypes.RpcSent);
var waitForClientMetricsValues = new WaitForMetricValues<RpcEvent>(ClientMetrics.Dispatcher, NetworkMetricTypes.RpcSent);
clientPlayer.Result.GetComponent<RpcTestComponent>().MyServerRpc();
m_PlayerNetworkObjects[Client.LocalClientId][Client.LocalClientId].GetComponent<RpcTestComponent>().MyServerRpc();
yield return waitForClientMetricsValues.WaitForMetricsReceived();
@@ -61,12 +57,8 @@ namespace Unity.Netcode.RuntimeTests.Metrics
[UnityTest]
public IEnumerator TrackRpcReceivedMetricOnServer()
{
var clientPlayer = new MultiInstanceHelpers.CoroutineResultWrapper<NetworkObject>();
yield return MultiInstanceHelpers.Run(MultiInstanceHelpers.GetNetworkObjectByRepresentation(x => x.IsPlayerObject && x.OwnerClientId == Client.LocalClientId, Client, clientPlayer));
var waitForServerMetricsValues = new WaitForMetricValues<RpcEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.RpcReceived);
clientPlayer.Result.GetComponent<RpcTestComponent>().MyServerRpc();
var waitForServerMetricsValues = new WaitForEventMetricValues<RpcEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.RpcReceived);
m_PlayerNetworkObjects[Client.LocalClientId][Client.LocalClientId].GetComponent<RpcTestComponent>().MyServerRpc();
yield return waitForServerMetricsValues.WaitForMetricsReceived();
@@ -83,16 +75,13 @@ namespace Unity.Netcode.RuntimeTests.Metrics
[UnityTest]
public IEnumerator TrackRpcReceivedMetricOnClient()
{
var clientPlayer = new MultiInstanceHelpers.CoroutineResultWrapper<NetworkObject>();
yield return MultiInstanceHelpers.Run(MultiInstanceHelpers.GetNetworkObjectByRepresentation(x => x.IsPlayerObject && x.OwnerClientId == Client.LocalClientId, Server, clientPlayer));
var waitForClientMetricsValues = new WaitForEventMetricValues<RpcEvent>(ClientMetrics.Dispatcher, NetworkMetricTypes.RpcReceived);
var waitForServerMetricsValues = new WaitForMetricValues<RpcEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.RpcReceived);
m_PlayerNetworkObjects[m_ServerNetworkManager.LocalClientId][Client.LocalClientId].GetComponent<RpcTestComponent>().MyClientRpc();
clientPlayer.Result.GetComponent<RpcTestComponent>().MyClientRpc();
yield return waitForClientMetricsValues.WaitForMetricsReceived();
yield return waitForServerMetricsValues.WaitForMetricsReceived();
var clientRpcReceivedValues = waitForServerMetricsValues.AssertMetricValuesHaveBeenFound();
var clientRpcReceivedValues = waitForClientMetricsValues.AssertMetricValuesHaveBeenFound();
Assert.AreEqual(1, clientRpcReceivedValues.Count);
var rpcReceived = clientRpcReceivedValues.First();

101
Tests/Runtime/Metrics/RttMetricsTests.cs Normal file
View File

@@ -0,0 +1,101 @@
#if MULTIPLAYER_TOOLS
#if MULTIPLAYER_TOOLS_1_0_0_PRE_4
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using NUnit.Framework;
using Unity.Collections;
using Unity.Multiplayer.Tools.MetricTypes;
using UnityEngine.TestTools;
using Unity.Netcode.TestHelpers.Runtime;
using Unity.Netcode.TestHelpers.Runtime.Metrics;
namespace Unity.Netcode.RuntimeTests.Metrics
{
/// <summary>
/// Note: This is one way to easily identify each specific test.
/// Since the test only tested 1 and then 2 clients, I made this
/// and enum, but you can always remove the enum in the constructor,
/// replace it with an int, and then test from 1 to 9 clients.
/// Just an example of how you can accomplish the same task using
/// the NetcodeIntegrationTest
/// </summary>
[TestFixture(ClientCount.OneClient)]
[TestFixture(ClientCount.TwoClients)]
internal class RttMetricsTests : NetcodeIntegrationTest
{
protected override int NumberOfClients => m_ClientCount;
public enum ClientCount
{
OneClient,
TwoClients
}
private int m_ClientCount;
public RttMetricsTests(ClientCount numberOfClients)
{
m_ClientCount = numberOfClients == ClientCount.OneClient ? 1 : 2;
}
/// <summary>
/// Note: We are using the OnOneTimeSetup to select the transport to use for
/// this test set.
/// </summary>
protected override void OnOneTimeSetup()
{
#if UTP_ADAPTER
m_NetworkTransport = NetcodeIntegrationTestHelpers.InstanceTransport.UTP;
#else
m_NetworkTransport = NetcodeIntegrationTestHelpers.InstanceTransport.SIP;
#endif
}
[UnityTest]
public IEnumerator TrackRttMetricServerToClient()
{
var waitForMetricValues = new WaitForGaugeMetricValues((m_ServerNetworkManager.NetworkMetrics as NetworkMetrics).Dispatcher, NetworkMetricTypes.RttToServer);
using (var writer = new FastBufferWriter(sizeof(uint), Allocator.Temp))
{
writer.WriteValueSafe(1337);
m_ServerNetworkManager.CustomMessagingManager.SendUnnamedMessageToAll(writer);
}
yield return WaitForConditionOrTimeOut(() => waitForMetricValues.MetricFound());
Assert.False(s_GlobalTimeoutHelper.TimedOut, $"{nameof(TrackRttMetricServerToClient)} timed out waiting for metric to be found for {m_ClientCount} clients!");
var rttValue = waitForMetricValues.AssertMetricValueHaveBeenFound();
Assert.AreEqual(0f, rttValue);
}
[UnityTest]
public IEnumerator TrackRttMetricClientToServer()
{
var clientGaugeMetricValues = new List<WaitForGaugeMetricValues>();
foreach (var client in m_ClientNetworkManagers)
{
clientGaugeMetricValues.Add(new WaitForGaugeMetricValues((client.NetworkMetrics as NetworkMetrics).Dispatcher, NetworkMetricTypes.RttToServer, metric => metric > 0f));
}
using (var writer = new FastBufferWriter(sizeof(uint), Allocator.Temp))
{
writer.WriteValueSafe(1337);
m_ServerNetworkManager.CustomMessagingManager.SendUnnamedMessageToAll(writer);
}
yield return WaitForConditionOrTimeOut(() => clientGaugeMetricValues.Where((c) => c.MetricFound()).Count() == NumberOfClients);
Assert.False(s_GlobalTimeoutHelper.TimedOut, $"{nameof(TrackRttMetricClientToServer)} timed out waiting for metric to be found for {m_ClientCount} clients!");
foreach (var clientGaugeMetricValue in clientGaugeMetricValues)
{
var rttValue = clientGaugeMetricValue.AssertMetricValueHaveBeenFound();
Assert.That(rttValue, Is.GreaterThanOrEqualTo(1f));
}
}
}
}
#endif
#endif

3
Tests/Runtime/Metrics/RttMetricsTests.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 452fbcb436d24291ba7db3a68e3e50ac
timeCreated: 1644269321

13
Tests/Runtime/Metrics/ServerLogsMetricTests.cs
View File

@@ -4,8 +4,8 @@ using System.Collections;
using System.Linq;
using NUnit.Framework;
using Unity.Multiplayer.Tools.MetricTypes;
using Unity.Netcode.RuntimeTests.Metrics.Utility;
using UnityEngine.TestTools;
using Unity.Netcode.TestHelpers.Runtime.Metrics;
namespace Unity.Netcode.RuntimeTests.Metrics
{
@@ -19,10 +19,13 @@ namespace Unity.Netcode.RuntimeTests.Metrics
[UnityTest]
public IEnumerator TrackServerLogSentMetric()
{
var waitForSentMetric = new WaitForMetricValues<ServerLogEvent>(ClientMetrics.Dispatcher, NetworkMetricTypes.ServerLogSent);
var waitForSentMetric = new WaitForEventMetricValues<ServerLogEvent>(ClientMetrics.Dispatcher, NetworkMetricTypes.ServerLogSent);
var message = Guid.NewGuid().ToString();
Client.LogLevel = LogLevel.Developer;
Server.LogLevel = LogLevel.Developer;
NetworkLog.LogWarningServer(message);
yield return s_DefaultWaitForTick;
yield return waitForSentMetric.WaitForMetricsReceived();
@@ -38,11 +41,15 @@ namespace Unity.Netcode.RuntimeTests.Metrics
[UnityTest]
public IEnumerator TrackServerLogReceivedMetric()
{
var waitForReceivedMetric = new WaitForMetricValues<ServerLogEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.ServerLogReceived);
var waitForReceivedMetric = new WaitForEventMetricValues<ServerLogEvent>(ServerMetrics.Dispatcher, NetworkMetricTypes.ServerLogReceived);
var message = Guid.NewGuid().ToString();
Client.LogLevel = LogLevel.Developer;
Server.LogLevel = LogLevel.Developer;
NetworkLog.LogWarningServer(message);
yield return s_DefaultWaitForTick;
yield return waitForReceivedMetric.WaitForMetricsReceived();
var receivedMetrics = waitForReceivedMetric.AssertMetricValuesHaveBeenFound();

6
Tests/Runtime/Metrics/TransportBytesMetricsTests.cs
View File

@@ -6,7 +6,7 @@ using NUnit.Framework;
using Unity.Collections;
using Unity.Multiplayer.Tools.MetricTypes;
using Unity.Multiplayer.Tools.NetStats;
using Unity.Netcode.RuntimeTests.Metrics.Utility;
using Unity.Netcode.TestHelpers.Runtime.Metrics;
using UnityEngine.TestTools;
namespace Unity.Netcode.RuntimeTests.Metrics
@@ -26,7 +26,7 @@ namespace Unity.Netcode.RuntimeTests.Metrics
try
{
writer.WriteValueSafe(messageName);
Server.CustomMessagingManager.SendNamedMessage(messageName.ToString(), Client.LocalClientId, writer);
}
finally
@@ -54,7 +54,7 @@ namespace Unity.Netcode.RuntimeTests.Metrics
try
{
writer.WriteValueSafe(messageName);
Server.CustomMessagingManager.SendNamedMessage(messageName.ToString(), Client.LocalClientId, writer);
}
finally

8
Tests/Runtime/Metrics/Utility.meta
View File

@@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: 4e60372130aba464f9f9ae4a24bb9fe0
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

71
Tests/Runtime/Metrics/Utility/MetricTestBase.cs
View File

@@ -1,71 +0,0 @@
#if MULTIPLAYER_TOOLS
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using NUnit.Framework;
using Unity.Multiplayer.Tools.MetricTypes;
using UnityEngine;
using UnityEngine.TestTools;
namespace Unity.Netcode.RuntimeTests.Metrics.Utility
{
internal abstract class SingleClientMetricTestBase : BaseMultiInstanceTest
{
protected override int NbClients => 1;
protected virtual Action<GameObject> UpdatePlayerPrefab => _ => { };
internal NetworkManager Server { get; private set; }
internal NetworkMetrics ServerMetrics { get; private set; }
internal NetworkManager Client { get; private set; }
internal NetworkMetrics ClientMetrics { get; private set; }
[UnitySetUp]
public override IEnumerator Setup()
{
yield return StartSomeClientsAndServerWithPlayers(true, NbClients, UpdatePlayerPrefab);
Server = m_ServerNetworkManager;
ServerMetrics = Server.NetworkMetrics as NetworkMetrics;
Client = m_ClientNetworkManagers[0];
ClientMetrics = Client.NetworkMetrics as NetworkMetrics;
}
}
public abstract class DualClientMetricTestBase : BaseMultiInstanceTest
{
protected override int NbClients => 2;
protected virtual Action<GameObject> UpdatePlayerPrefab => _ => { };
internal NetworkManager Server { get; private set; }
internal NetworkMetrics ServerMetrics { get; private set; }
internal NetworkManager FirstClient { get; private set; }
internal NetworkMetrics FirstClientMetrics { get; private set; }
internal NetworkManager SecondClient { get; private set; }
internal NetworkMetrics SecondClientMetrics { get; private set; }
[UnitySetUp]
public override IEnumerator Setup()
{
yield return StartSomeClientsAndServerWithPlayers(true, NbClients, UpdatePlayerPrefab);
Server = m_ServerNetworkManager;
ServerMetrics = Server.NetworkMetrics as NetworkMetrics;
FirstClient = m_ClientNetworkManagers[0];
FirstClientMetrics = FirstClient.NetworkMetrics as NetworkMetrics;
SecondClient = m_ClientNetworkManagers[0];
SecondClientMetrics = SecondClient.NetworkMetrics as NetworkMetrics;
}
}
}
#endif

11
Tests/Runtime/Metrics/Utility/MetricTestBase.cs.meta
View File

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

19
Tests/Runtime/Metrics/Utility/NetworkVariableComponent.cs
View File

@@ -1,19 +0,0 @@
#if MULTIPLAYER_TOOLS
using UnityEngine;
namespace Unity.Netcode.RuntimeTests.Metrics.Utility
{
public class NetworkVariableComponent : NetworkBehaviour
{
public NetworkVariable<int> MyNetworkVariable { get; } = new NetworkVariable<int>();
private void Update()
{
if (IsServer)
{
MyNetworkVariable.Value = Random.Range(100, 999);
}
}
}
}
#endif

11
Tests/Runtime/Metrics/Utility/NetworkVariableComponent.cs.meta
View File

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

22
Tests/Runtime/Metrics/Utility/RpcTestComponent.cs
View File

@@ -1,22 +0,0 @@
using System;
namespace Unity.Netcode.RuntimeTests.Metrics.Utility
{
public class RpcTestComponent : NetworkBehaviour
{
public event Action OnServerRpcAction;
public event Action OnClientRpcAction;
[ServerRpc]
public void MyServerRpc()
{
OnServerRpcAction?.Invoke();
}
[ClientRpc]
public void MyClientRpc()
{
OnClientRpcAction?.Invoke();
}
}
}

11
Tests/Runtime/Metrics/Utility/RpcTestComponent.cs.meta
View File

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

118
Tests/Runtime/Metrics/Utility/WaitForMetricValues.cs
View File

@@ -1,118 +0,0 @@
#if MULTIPLAYER_TOOLS
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using NUnit.Framework;
using Unity.Multiplayer.Tools.MetricTypes;
using Unity.Multiplayer.Tools.NetStats;
namespace Unity.Netcode.RuntimeTests.Metrics.Utility
{
internal class WaitForMetricValues<TMetric> : IMetricObserver
{
readonly string m_MetricName;
bool m_Found;
bool m_HasError;
string m_Error;
uint m_NbFrames = 0;
IReadOnlyCollection<TMetric> m_Values;
public delegate bool Filter(TMetric metric);
Filter m_FilterDelegate;
public WaitForMetricValues(IMetricDispatcher dispatcher, DirectionalMetricInfo directionalMetricName)
{
m_MetricName = directionalMetricName.Id;
dispatcher.RegisterObserver(this);
}
public WaitForMetricValues(IMetricDispatcher dispatcher, DirectionalMetricInfo directionalMetricName, Filter filter)
: this(dispatcher, directionalMetricName)
{
m_FilterDelegate = filter;
}
public IEnumerator WaitForMetricsReceived()
{
yield return WaitForFrames(60);
}
public IReadOnlyCollection<TMetric> AssertMetricValuesHaveBeenFound()
{
if (m_HasError)
{
Assert.Fail(m_Error);
}
if (!m_Found)
{
Assert.Fail($"Found no matching values for metric of type '{typeof(TMetric).Name}', with name '{m_MetricName}' during '{m_NbFrames}' frames.");
}
return m_Values;
}
public void AssertMetricValuesHaveNotBeenFound()
{
if (m_HasError)
{
Assert.Fail(m_Error);
}
if (!m_Found)
{
Assert.Pass();
}
else
{
Assert.Fail();
}
}
public void Observe(MetricCollection collection)
{
if (m_Found || m_HasError)
{
return;
}
var metric = collection.Metrics.SingleOrDefault(x => x.Name == m_MetricName);
if (metric == default)
{
m_HasError = true;
m_Error = $"Metric collection does not contain metric named '{m_MetricName}'.";
return;
}
var typedMetric = metric as IEventMetric<TMetric>;
if (typedMetric == default)
{
m_HasError = true;
m_Error = $"Metric collection contains a metric of type '{metric.GetType().Name}' for name '{m_MetricName}', but was expecting '{typeof(TMetric).Name}'.";
return;
}
if (typedMetric.Values.Any())
{
// Apply filter if one was provided
m_Values = m_FilterDelegate != null ? typedMetric.Values.Where(x => m_FilterDelegate(x)).ToList() : typedMetric.Values.ToList();
m_Found = m_Values.Count > 0;
}
}
private IEnumerator WaitForFrames(uint maxNbFrames)
{
while (!m_Found && m_NbFrames < maxNbFrames)
{
m_NbFrames++;
yield return null;
}
}
}
}
#endif

11
Tests/Runtime/Metrics/Utility/WaitForMetricValues.cs.meta
View File

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