07f206ff9e
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.8.0] - 2023-12-12 ### Added - Added a new RPC attribute, which is simply `Rpc`. (#2762) - This is a generic attribute that can perform the functions of both Server and Client RPCs, as well as enabling client-to-client RPCs. Includes several default targets: `Server`, `NotServer`, `Owner`, `NotOwner`, `Me`, `NotMe`, `ClientsAndHost`, and `Everyone`. Runtime overrides are available for any of these targets, as well as for sending to a specific ID or groups of IDs. - This attribute also includes the ability to defer RPCs that are sent to the local process to the start of the next frame instead of executing them immediately, treating them as if they had gone across the network. The default behavior is to execute immediately. - This attribute effectively replaces `ServerRpc` and `ClientRpc`. `ServerRpc` and `ClientRpc` remain in their existing forms for backward compatibility, but `Rpc` will be the recommended and most supported option. - Added `NetworkManager.OnConnectionEvent` as a unified connection event callback to notify clients and servers of all client connections and disconnections within the session (#2762) - Added `NetworkManager.ServerIsHost` and `NetworkBehaviour.ServerIsHost` to allow a client to tell if it is connected to a host or to a dedicated server (#2762) - Added `SceneEventProgress.SceneManagementNotEnabled` return status to be returned when a `NetworkSceneManager` method is invoked and scene management is not enabled. (#2735) - Added `SceneEventProgress.ServerOnlyAction` return status to be returned when a `NetworkSceneManager` method is invoked by a client. (#2735) - Added `NetworkObject.InstantiateAndSpawn` and `NetworkSpawnManager.InstantiateAndSpawn` methods to simplify prefab spawning by assuring that the prefab is valid and applies any override prior to instantiating the `GameObject` and spawning the `NetworkObject` instance. (#2710) ### Fixed - Fixed issue where a client disconnected by a server-host would not receive a local notification. (#2789) - Fixed issue where a server-host could shutdown during a relay connection but periodically the transport disconnect message sent to any connected clients could be dropped. (#2789) - Fixed issue where a host could disconnect its local client but remain running as a server. (#2789) - Fixed issue where `OnClientDisconnectedCallback` was not being invoked under certain conditions. (#2789) - Fixed issue where `OnClientDisconnectedCallback` was always returning 0 as the client identifier. (#2789) - Fixed issue where if a host or server shutdown while a client owned NetworkObjects (other than the player) it would throw an exception. (#2789) - Fixed issue where setting values on a `NetworkVariable` or `NetworkList` within `OnNetworkDespawn` during a shutdown sequence would throw an exception. (#2789) - Fixed issue where a teleport state could potentially be overridden by a previous unreliable delta state. (#2777) - Fixed issue where `NetworkTransform` was using the `NetworkManager.ServerTime.Tick` as opposed to `NetworkManager.NetworkTickSystem.ServerTime.Tick` during the authoritative side's tick update where it performed a delta state check. (#2777) - Fixed issue where a parented in-scene placed NetworkObject would be destroyed upon a client or server exiting a network session but not unloading the original scene in which the NetworkObject was placed. (#2737) - Fixed issue where during client synchronization and scene loading, when client synchronization or the scene loading mode are set to `LoadSceneMode.Single`, a `CreateObjectMessage` could be received, processed, and the resultant spawned `NetworkObject` could be instantiated in the client's currently active scene that could, towards the end of the client synchronization or loading process, be unloaded and cause the newly created `NetworkObject` to be destroyed (and throw and exception). (#2735) - Fixed issue where a `NetworkTransform` instance with interpolation enabled would result in wide visual motion gaps (stuttering) under above normal latency conditions and a 1-5% or higher packet are drop rate. (#2713) - Fixed issue where you could not have multiple source network prefab overrides targeting the same network prefab as their override. (#2710) ### Changed - Changed the server or host shutdown so it will now perform a "soft shutdown" when `NetworkManager.Shutdown` is invoked. This will send a disconnect notification to all connected clients and the server-host will wait for all connected clients to disconnect or timeout after a 5 second period before completing the shutdown process. (#2789) - Changed `OnClientDisconnectedCallback` will now return the assigned client identifier on the local client side if the client was approved and assigned one prior to being disconnected. (#2789) - Changed `NetworkTransform.SetState` (and related methods) now are cumulative during a fractional tick period and sent on the next pending tick. (#2777) - `NetworkManager.ConnectedClientsIds` is now accessible on the client side and will contain the list of all clients in the session, including the host client if the server is operating in host mode (#2762) - Changed `NetworkSceneManager` to return a `SceneEventProgress` status and not throw exceptions for methods invoked when scene management is disabled and when a client attempts to access a `NetworkSceneManager` method by a client. (#2735) - Changed `NetworkTransform` authoritative instance tick registration so a single `NetworkTransform` specific tick event update will update all authoritative instances to improve perofmance. (#2713) - Changed `NetworkPrefabs.OverrideToNetworkPrefab` dictionary is no longer used/populated due to it ending up being related to a regression bug and not allowing more than one override to be assigned to a network prefab asset. (#2710) - Changed in-scene placed `NetworkObject`s now store their source network prefab asset's `GlobalObjectIdHash` internally that is used, when scene management is disabled, by clients to spawn the correct prefab even if the `NetworkPrefab` entry has an override. This does not impact dynamically spawning the same prefab which will yield the override on both host and client. (#2710) - Changed in-scene placed `NetworkObject`s no longer require a `NetworkPrefab` entry with `GlobalObjectIdHash` override in order for clients to properly synchronize. (#2710) - Changed in-scene placed `NetworkObject`s now set their `IsSceneObject` value when generating their `GlobalObjectIdHash` value. (#2710) - Changed the default `NetworkConfig.SpawnTimeout` value from 1.0s to 10.0s. (#2710)
1918 lines
73 KiB
C#
1918 lines
73 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using NUnit.Framework;
|
|
using Unity.Collections;
|
|
using Unity.Netcode.TestHelpers.Runtime;
|
|
using UnityEngine;
|
|
using Object = UnityEngine.Object;
|
|
using Random = System.Random;
|
|
|
|
// NOTE:
|
|
// Unity's test runner cannot handle a single test fixture with thousands of tests in it.
|
|
// Since this file contains thousands of tests (once all parameters have been taken into account),
|
|
// I had to split up the tests into separate fixtures for each test case.
|
|
// That was the only way to get Unity to actually be able to handle this number of tests.
|
|
// I put them in their own namespace so they would be easier to navigate in the test list.
|
|
namespace Unity.Netcode.RuntimeTests.UniversalRpcTests
|
|
{
|
|
public class UniversalRpcNetworkBehaviour : NetworkBehaviour
|
|
{
|
|
public bool Stop = false;
|
|
public string Received = string.Empty;
|
|
public Tuple<int, bool, float, string> ReceivedParams = null;
|
|
public ulong ReceivedFrom = ulong.MaxValue;
|
|
|
|
public void OnRpcReceived()
|
|
{
|
|
var st = new StackTrace();
|
|
var sf = st.GetFrame(1);
|
|
|
|
var currentMethod = sf.GetMethod();
|
|
Received = currentMethod.Name;
|
|
}
|
|
public void OnRpcReceivedWithParams(int a, bool b, float f, string s)
|
|
{
|
|
var st = new StackTrace();
|
|
var sf = st.GetFrame(1);
|
|
|
|
var currentMethod = sf.GetMethod();
|
|
Received = currentMethod.Name;
|
|
ReceivedParams = new Tuple<int, bool, float, string>(a, b, f, s);
|
|
}
|
|
|
|
// Basic RPCs
|
|
|
|
[Rpc(SendTo.Everyone)]
|
|
public void DefaultToEveryoneRpc()
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
[Rpc(SendTo.Me)]
|
|
public void DefaultToMeRpc()
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
[Rpc(SendTo.Owner)]
|
|
public void DefaultToOwnerRpc()
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
[Rpc(SendTo.NotOwner)]
|
|
public void DefaultToNotOwnerRpc()
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
[Rpc(SendTo.Server)]
|
|
public void DefaultToServerRpc()
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
[Rpc(SendTo.NotMe)]
|
|
public void DefaultToNotMeRpc()
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
[Rpc(SendTo.NotServer)]
|
|
public void DefaultToNotServerRpc()
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
[Rpc(SendTo.ClientsAndHost)]
|
|
public void DefaultToClientsAndHostRpc()
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
// RPCs with parameters
|
|
|
|
[Rpc(SendTo.Everyone)]
|
|
public void DefaultToEveryoneWithParamsRpc(int i, bool b, float f, string s)
|
|
{
|
|
OnRpcReceivedWithParams(i, b, f, s);
|
|
}
|
|
|
|
[Rpc(SendTo.Me)]
|
|
public void DefaultToMeWithParamsRpc(int i, bool b, float f, string s)
|
|
{
|
|
OnRpcReceivedWithParams(i, b, f, s);
|
|
}
|
|
|
|
[Rpc(SendTo.Owner)]
|
|
public void DefaultToOwnerWithParamsRpc(int i, bool b, float f, string s)
|
|
{
|
|
OnRpcReceivedWithParams(i, b, f, s);
|
|
}
|
|
|
|
[Rpc(SendTo.NotOwner)]
|
|
public void DefaultToNotOwnerWithParamsRpc(int i, bool b, float f, string s)
|
|
{
|
|
OnRpcReceivedWithParams(i, b, f, s);
|
|
}
|
|
|
|
[Rpc(SendTo.Server)]
|
|
public void DefaultToServerWithParamsRpc(int i, bool b, float f, string s)
|
|
{
|
|
OnRpcReceivedWithParams(i, b, f, s);
|
|
}
|
|
|
|
[Rpc(SendTo.NotMe)]
|
|
public void DefaultToNotMeWithParamsRpc(int i, bool b, float f, string s)
|
|
{
|
|
OnRpcReceivedWithParams(i, b, f, s);
|
|
}
|
|
|
|
[Rpc(SendTo.NotServer)]
|
|
public void DefaultToNotServerWithParamsRpc(int i, bool b, float f, string s)
|
|
{
|
|
OnRpcReceivedWithParams(i, b, f, s);
|
|
}
|
|
|
|
[Rpc(SendTo.ClientsAndHost)]
|
|
public void DefaultToClientsAndHostWithParamsRpc(int i, bool b, float f, string s)
|
|
{
|
|
OnRpcReceivedWithParams(i, b, f, s);
|
|
}
|
|
|
|
// RPCs with RPC parameters
|
|
|
|
[Rpc(SendTo.Everyone)]
|
|
public void DefaultToEveryoneWithRpcParamsRpc(RpcParams rpcParams)
|
|
{
|
|
OnRpcReceived();
|
|
ReceivedFrom = rpcParams.Receive.SenderClientId;
|
|
}
|
|
|
|
[Rpc(SendTo.Me)]
|
|
public void DefaultToMeWithRpcParamsRpc(RpcParams rpcParams)
|
|
{
|
|
OnRpcReceived();
|
|
ReceivedFrom = rpcParams.Receive.SenderClientId;
|
|
}
|
|
|
|
[Rpc(SendTo.Owner)]
|
|
public void DefaultToOwnerWithRpcParamsRpc(RpcParams rpcParams)
|
|
{
|
|
OnRpcReceived();
|
|
ReceivedFrom = rpcParams.Receive.SenderClientId;
|
|
}
|
|
|
|
[Rpc(SendTo.NotOwner)]
|
|
public void DefaultToNotOwnerWithRpcParamsRpc(RpcParams rpcParams)
|
|
{
|
|
OnRpcReceived();
|
|
ReceivedFrom = rpcParams.Receive.SenderClientId;
|
|
}
|
|
|
|
[Rpc(SendTo.Server)]
|
|
public void DefaultToServerWithRpcParamsRpc(RpcParams rpcParams)
|
|
{
|
|
OnRpcReceived();
|
|
ReceivedFrom = rpcParams.Receive.SenderClientId;
|
|
}
|
|
|
|
[Rpc(SendTo.NotMe)]
|
|
public void DefaultToNotMeWithRpcParamsRpc(RpcParams rpcParams)
|
|
{
|
|
OnRpcReceived();
|
|
ReceivedFrom = rpcParams.Receive.SenderClientId;
|
|
}
|
|
|
|
[Rpc(SendTo.NotServer)]
|
|
public void DefaultToNotServerWithRpcParamsRpc(RpcParams rpcParams)
|
|
{
|
|
OnRpcReceived();
|
|
ReceivedFrom = rpcParams.Receive.SenderClientId;
|
|
}
|
|
|
|
[Rpc(SendTo.ClientsAndHost)]
|
|
public void DefaultToClientsAndHostWithRpcParamsRpc(RpcParams rpcParams)
|
|
{
|
|
OnRpcReceived();
|
|
ReceivedFrom = rpcParams.Receive.SenderClientId;
|
|
}
|
|
|
|
|
|
// RPCs with parameters and RPC parameters
|
|
|
|
[Rpc(SendTo.Everyone)]
|
|
public void DefaultToEveryoneWithParamsAndRpcParamsRpc(int i, bool b, float f, string s, RpcParams rpcParams)
|
|
{
|
|
OnRpcReceivedWithParams(i, b, f, s);
|
|
}
|
|
|
|
[Rpc(SendTo.Me)]
|
|
public void DefaultToMeWithParamsAndRpcParamsRpc(int i, bool b, float f, string s, RpcParams rpcParams)
|
|
{
|
|
OnRpcReceivedWithParams(i, b, f, s);
|
|
}
|
|
|
|
[Rpc(SendTo.Owner)]
|
|
public void DefaultToOwnerWithParamsAndRpcParamsRpc(int i, bool b, float f, string s, RpcParams rpcParams)
|
|
{
|
|
OnRpcReceivedWithParams(i, b, f, s);
|
|
}
|
|
|
|
[Rpc(SendTo.NotOwner)]
|
|
public void DefaultToNotOwnerWithParamsAndRpcParamsRpc(int i, bool b, float f, string s, RpcParams rpcParams)
|
|
{
|
|
OnRpcReceivedWithParams(i, b, f, s);
|
|
}
|
|
|
|
[Rpc(SendTo.Server)]
|
|
public void DefaultToServerWithParamsAndRpcParamsRpc(int i, bool b, float f, string s, RpcParams rpcParams)
|
|
{
|
|
OnRpcReceivedWithParams(i, b, f, s);
|
|
}
|
|
|
|
[Rpc(SendTo.NotMe)]
|
|
public void DefaultToNotMeWithParamsAndRpcParamsRpc(int i, bool b, float f, string s, RpcParams rpcParams)
|
|
{
|
|
OnRpcReceivedWithParams(i, b, f, s);
|
|
}
|
|
|
|
[Rpc(SendTo.NotServer)]
|
|
public void DefaultToNotServerWithParamsAndRpcParamsRpc(int i, bool b, float f, string s, RpcParams rpcParams)
|
|
{
|
|
OnRpcReceivedWithParams(i, b, f, s);
|
|
}
|
|
|
|
[Rpc(SendTo.ClientsAndHost)]
|
|
public void DefaultToClientsAndHostWithParamsAndRpcParamsRpc(int i, bool b, float f, string s, RpcParams rpcParams)
|
|
{
|
|
OnRpcReceivedWithParams(i, b, f, s);
|
|
}
|
|
|
|
// RPCs with AllowTargetOverride = true
|
|
|
|
// AllowTargetOverried is implied with SpecifiedInParams and does not need to be stated
|
|
// Including it will cause a compiler warning
|
|
[Rpc(SendTo.SpecifiedInParams)]
|
|
public void DefaultToSpecifiedInParamsAllowOverrideRpc(RpcParams rpcParams)
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
[Rpc(SendTo.Everyone, AllowTargetOverride = true)]
|
|
public void DefaultToEveryoneAllowOverrideRpc(RpcParams rpcParams)
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
[Rpc(SendTo.Me, AllowTargetOverride = true)]
|
|
public void DefaultToMeAllowOverrideRpc(RpcParams rpcParams)
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
[Rpc(SendTo.Owner, AllowTargetOverride = true)]
|
|
public void DefaultToOwnerAllowOverrideRpc(RpcParams rpcParams)
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
[Rpc(SendTo.NotOwner, AllowTargetOverride = true)]
|
|
public void DefaultToNotOwnerAllowOverrideRpc(RpcParams rpcParams)
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
[Rpc(SendTo.Server, AllowTargetOverride = true)]
|
|
public void DefaultToServerAllowOverrideRpc(RpcParams rpcParams)
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
[Rpc(SendTo.NotMe, AllowTargetOverride = true)]
|
|
public void DefaultToNotMeAllowOverrideRpc(RpcParams rpcParams)
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
[Rpc(SendTo.NotServer, AllowTargetOverride = true)]
|
|
public void DefaultToNotServerAllowOverrideRpc(RpcParams rpcParams)
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
[Rpc(SendTo.ClientsAndHost, AllowTargetOverride = true)]
|
|
public void DefaultToClientsAndHostAllowOverrideRpc(RpcParams rpcParams)
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
// RPCs with DeferLocal = true
|
|
|
|
[Rpc(SendTo.Everyone, DeferLocal = true)]
|
|
public void DefaultToEveryoneDeferLocalRpc(RpcParams rpcParams)
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
[Rpc(SendTo.Me, DeferLocal = true)]
|
|
public void DefaultToMeDeferLocalRpc(RpcParams rpcParams)
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
[Rpc(SendTo.Owner, DeferLocal = true)]
|
|
public void DefaultToOwnerDeferLocalRpc(RpcParams rpcParams)
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
[Rpc(SendTo.NotOwner, DeferLocal = true)]
|
|
public void DefaultToNotOwnerDeferLocalRpc(RpcParams rpcParams)
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
[Rpc(SendTo.Server, DeferLocal = true)]
|
|
public void DefaultToServerDeferLocalRpc(RpcParams rpcParams)
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
[Rpc(SendTo.NotServer, DeferLocal = true)]
|
|
public void DefaultToNotServerDeferLocalRpc(RpcParams rpcParams)
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
[Rpc(SendTo.ClientsAndHost, DeferLocal = true)]
|
|
public void DefaultToClientsAndHostDeferLocalRpc(RpcParams rpcParams)
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
// RPCs with RequireOwnership = true
|
|
|
|
[Rpc(SendTo.Everyone, RequireOwnership = true)]
|
|
public void DefaultToEveryoneRequireOwnershipRpc()
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
[Rpc(SendTo.Me, RequireOwnership = true)]
|
|
public void DefaultToMeRequireOwnershipRpc()
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
[Rpc(SendTo.Owner, RequireOwnership = true)]
|
|
public void DefaultToOwnerRequireOwnershipRpc()
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
[Rpc(SendTo.NotOwner, RequireOwnership = true)]
|
|
public void DefaultToNotOwnerRequireOwnershipRpc()
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
[Rpc(SendTo.Server, RequireOwnership = true)]
|
|
public void DefaultToServerRequireOwnershipRpc()
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
[Rpc(SendTo.NotMe, RequireOwnership = true)]
|
|
public void DefaultToNotMeRequireOwnershipRpc()
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
[Rpc(SendTo.NotServer, RequireOwnership = true)]
|
|
public void DefaultToNotServerRequireOwnershipRpc()
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
[Rpc(SendTo.ClientsAndHost, RequireOwnership = true)]
|
|
public void DefaultToClientsAndHostRequireOwnershipRpc()
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
[Rpc(SendTo.SpecifiedInParams, RequireOwnership = true)]
|
|
public void SpecifiedInParamsRequireOwnershipRpc(RpcParams rpcParams)
|
|
{
|
|
OnRpcReceived();
|
|
}
|
|
|
|
|
|
// Mutual RPC Recursion
|
|
|
|
[Rpc(SendTo.Server, DeferLocal = true)]
|
|
public void MutualRecursionServerRpc()
|
|
{
|
|
if (Stop)
|
|
{
|
|
Stop = false;
|
|
return;
|
|
}
|
|
OnRpcReceived();
|
|
MutualRecursionClientRpc();
|
|
}
|
|
|
|
[Rpc(SendTo.NotServer, DeferLocal = true)]
|
|
public void MutualRecursionClientRpc()
|
|
{
|
|
OnRpcReceived();
|
|
MutualRecursionServerRpc();
|
|
}
|
|
|
|
// Self recursion
|
|
[Rpc(SendTo.Server, DeferLocal = true)]
|
|
public void SelfRecursiveRpc()
|
|
{
|
|
if (Stop)
|
|
{
|
|
Stop = false;
|
|
return;
|
|
}
|
|
OnRpcReceived();
|
|
SelfRecursiveRpc();
|
|
}
|
|
}
|
|
|
|
public class UniversalRpcTestsBase : NetcodeIntegrationTest
|
|
{
|
|
protected override int NumberOfClients => 2;
|
|
|
|
public UniversalRpcTestsBase(HostOrServer hostOrServer) : base(hostOrServer)
|
|
{
|
|
}
|
|
|
|
|
|
protected override NetworkManagerInstatiationMode OnSetIntegrationTestMode()
|
|
{
|
|
return NetworkManagerInstatiationMode.AllTests;
|
|
}
|
|
|
|
protected override bool m_EnableTimeTravel => true;
|
|
|
|
protected override bool m_SetupIsACoroutine => false;
|
|
protected override bool m_TearDownIsACoroutine => false;
|
|
|
|
protected GameObject m_ServerObject;
|
|
|
|
protected override void OnCreatePlayerPrefab()
|
|
{
|
|
m_PlayerPrefab.AddComponent<UniversalRpcNetworkBehaviour>();
|
|
}
|
|
|
|
protected override void OnServerAndClientsCreated()
|
|
{
|
|
m_ServerObject = new GameObject { name = "Server Object" };
|
|
var networkObject = m_ServerObject.AddComponent<NetworkObject>();
|
|
m_ServerObject.AddComponent<UniversalRpcNetworkBehaviour>();
|
|
networkObject.NetworkManagerOwner = m_ServerNetworkManager;
|
|
NetcodeIntegrationTestHelpers.MakeNetworkObjectTestPrefab(networkObject);
|
|
m_ServerNetworkManager.AddNetworkPrefab(m_ServerObject);
|
|
foreach (var client in m_ClientNetworkManagers)
|
|
{
|
|
client.AddNetworkPrefab(m_ServerObject);
|
|
}
|
|
}
|
|
|
|
protected override void OnInlineTearDown()
|
|
{
|
|
Clear();
|
|
}
|
|
|
|
protected void Clear()
|
|
{
|
|
foreach (var obj in Object.FindObjectsByType<UniversalRpcNetworkBehaviour>(FindObjectsSortMode.None))
|
|
{
|
|
obj.Received = string.Empty;
|
|
obj.ReceivedParams = null;
|
|
obj.ReceivedFrom = ulong.MaxValue;
|
|
}
|
|
}
|
|
|
|
protected override void OnOneTimeTearDown()
|
|
{
|
|
Object.DestroyImmediate(m_ServerObject);
|
|
}
|
|
|
|
protected override void OnTimeTravelServerAndClientsConnected()
|
|
{
|
|
m_ServerObject.GetComponent<NetworkObject>().Spawn();
|
|
WaitForMessageReceivedWithTimeTravel<CreateObjectMessage>(m_ClientNetworkManagers.ToList());
|
|
}
|
|
|
|
protected UniversalRpcNetworkBehaviour GetPlayerObject(ulong ownerClientId, ulong onClient)
|
|
{
|
|
if (ownerClientId == NetworkManager.ServerClientId && !m_ServerNetworkManager.IsHost)
|
|
{
|
|
foreach (var obj in Object.FindObjectsByType<UniversalRpcNetworkBehaviour>(FindObjectsSortMode.None))
|
|
{
|
|
if (obj.name.StartsWith("Server Object") && obj.OwnerClientId == ownerClientId && obj.NetworkManager.LocalClientId == onClient)
|
|
{
|
|
return obj;
|
|
}
|
|
}
|
|
}
|
|
|
|
return m_PlayerNetworkObjects[onClient][ownerClientId].GetComponent<UniversalRpcNetworkBehaviour>();
|
|
}
|
|
|
|
protected void VerifyLocalReceived(ulong objectOwner, ulong sender, string name, bool verifyReceivedFrom)
|
|
{
|
|
var obj = GetPlayerObject(objectOwner, sender);
|
|
Assert.AreEqual(name, obj.Received);
|
|
Assert.IsNull(obj.ReceivedParams);
|
|
if (verifyReceivedFrom)
|
|
{
|
|
Assert.AreEqual(sender, obj.ReceivedFrom);
|
|
}
|
|
}
|
|
|
|
protected void VerifyLocalReceivedWithParams(ulong objectOwner, ulong sender, string name, int i, bool b, float f, string s)
|
|
{
|
|
var obj = GetPlayerObject(objectOwner, sender);
|
|
Assert.AreEqual(name, obj.Received);
|
|
Assert.IsNotNull(obj.ReceivedParams);
|
|
Assert.AreEqual(i, obj.ReceivedParams.Item1);
|
|
Assert.AreEqual(b, obj.ReceivedParams.Item2);
|
|
Assert.AreEqual(f, obj.ReceivedParams.Item3);
|
|
Assert.AreEqual(s, obj.ReceivedParams.Item4);
|
|
}
|
|
|
|
protected void VerifyNotReceived(ulong objectOwner, ulong[] receivedBy)
|
|
{
|
|
foreach (var client in receivedBy)
|
|
{
|
|
UniversalRpcNetworkBehaviour playerObject = GetPlayerObject(objectOwner, client);
|
|
Assert.AreEqual(string.Empty, playerObject.Received);
|
|
Assert.IsNull(playerObject.ReceivedParams);
|
|
}
|
|
}
|
|
|
|
protected void VerifyRemoteReceived(ulong objectOwner, ulong sender, string message, ulong[] receivedBy, bool verifyReceivedFrom, bool waitForMessages = true)
|
|
{
|
|
foreach (var client in receivedBy)
|
|
{
|
|
if (client == sender)
|
|
{
|
|
VerifyLocalReceived(objectOwner, sender, message, verifyReceivedFrom);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (waitForMessages)
|
|
{
|
|
var needsProxyMessage = false;
|
|
var needsServerRpcMessage = false;
|
|
if (sender != 0)
|
|
{
|
|
foreach (var client in receivedBy)
|
|
{
|
|
if (client == sender)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (client != 0)
|
|
{
|
|
needsProxyMessage = true;
|
|
}
|
|
else
|
|
{
|
|
needsServerRpcMessage = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (needsProxyMessage)
|
|
{
|
|
var messages = new List<Type> { typeof(ProxyMessage) };
|
|
if (needsServerRpcMessage)
|
|
{
|
|
messages.Add(typeof(RpcMessage));
|
|
}
|
|
|
|
WaitForMessagesReceivedWithTimeTravel(messages, new[] { m_ServerNetworkManager }.ToList());
|
|
}
|
|
|
|
var managersThatNeedToWaitForRpc = new List<NetworkManager>();
|
|
if (needsServerRpcMessage && !needsProxyMessage)
|
|
{
|
|
managersThatNeedToWaitForRpc.Add(m_ServerNetworkManager);
|
|
}
|
|
|
|
foreach (var client in receivedBy)
|
|
{
|
|
if (client != sender && client != 0)
|
|
{
|
|
managersThatNeedToWaitForRpc.Add(m_ClientNetworkManagers[client - 1]);
|
|
}
|
|
}
|
|
|
|
WaitForMessageReceivedWithTimeTravel<RpcMessage>(managersThatNeedToWaitForRpc);
|
|
}
|
|
|
|
foreach (var client in receivedBy)
|
|
{
|
|
UniversalRpcNetworkBehaviour playerObject = GetPlayerObject(objectOwner, client);
|
|
Assert.AreEqual(message, playerObject.Received);
|
|
Assert.IsNull(playerObject.ReceivedParams);
|
|
if (verifyReceivedFrom)
|
|
{
|
|
Assert.AreEqual(sender, playerObject.ReceivedFrom);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected void VerifyRemoteReceivedWithParams(ulong objectOwner, ulong sender, string message, ulong[] receivedBy, int i, bool b, float f, string s)
|
|
{
|
|
foreach (var client in receivedBy)
|
|
{
|
|
if (client == sender)
|
|
{
|
|
VerifyLocalReceivedWithParams(objectOwner, sender, message, i, b, f, s);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
var needsProxyMessage = false;
|
|
var needsServerRpcMessage = false;
|
|
if (sender != 0)
|
|
{
|
|
foreach (var client in receivedBy)
|
|
{
|
|
if (client == sender)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (client != 0)
|
|
{
|
|
needsProxyMessage = true;
|
|
}
|
|
else
|
|
{
|
|
needsServerRpcMessage = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (needsProxyMessage)
|
|
{
|
|
var messages = new List<Type> { typeof(ProxyMessage) };
|
|
if (needsServerRpcMessage)
|
|
{
|
|
messages.Add(typeof(RpcMessage));
|
|
}
|
|
|
|
WaitForMessagesReceivedWithTimeTravel(messages, new[] { m_ServerNetworkManager }.ToList());
|
|
}
|
|
|
|
var managersThatNeedToWaitForRpc = new List<NetworkManager>();
|
|
if (needsServerRpcMessage && !needsProxyMessage)
|
|
{
|
|
managersThatNeedToWaitForRpc.Add(m_ServerNetworkManager);
|
|
}
|
|
|
|
foreach (var client in receivedBy)
|
|
{
|
|
if (client != sender && client != 0)
|
|
{
|
|
managersThatNeedToWaitForRpc.Add(m_ClientNetworkManagers[client - 1]);
|
|
}
|
|
}
|
|
|
|
WaitForMessageReceivedWithTimeTravel<RpcMessage>(managersThatNeedToWaitForRpc);
|
|
|
|
foreach (var client in receivedBy)
|
|
{
|
|
UniversalRpcNetworkBehaviour playerObject = GetPlayerObject(objectOwner, client);
|
|
Assert.AreEqual(message, playerObject.Received);
|
|
|
|
Assert.IsNotNull(playerObject.ReceivedParams);
|
|
Assert.AreEqual(i, playerObject.ReceivedParams.Item1);
|
|
Assert.AreEqual(b, playerObject.ReceivedParams.Item2);
|
|
Assert.AreEqual(f, playerObject.ReceivedParams.Item3);
|
|
Assert.AreEqual(s, playerObject.ReceivedParams.Item4);
|
|
}
|
|
}
|
|
|
|
protected static ulong[] s_ClientIds = new[] { 0ul, 1ul, 2ul };
|
|
|
|
public void VerifySentToEveryone(ulong objectOwner, ulong sender, string methodName)
|
|
{
|
|
VerifyRemoteReceived(objectOwner, sender, methodName, s_ClientIds, false);
|
|
}
|
|
|
|
public void VerifySentToEveryoneWithReceivedFrom(ulong objectOwner, ulong sender, string methodName)
|
|
{
|
|
VerifyRemoteReceived(objectOwner, sender, methodName, s_ClientIds, true);
|
|
}
|
|
|
|
public void VerifySentToEveryoneWithParams(ulong objectOwner, ulong sender, string methodName, int i, bool b, float f, string s)
|
|
{
|
|
VerifyRemoteReceivedWithParams(objectOwner, sender, methodName, s_ClientIds, i, b, f, s);
|
|
}
|
|
|
|
public void VerifySentToId(ulong objectOwner, ulong sender, ulong receiver, string methodName, bool verifyReceivedFrom)
|
|
{
|
|
VerifyRemoteReceived(objectOwner, sender, methodName, new[] { receiver }, verifyReceivedFrom);
|
|
VerifyNotReceived(objectOwner, s_ClientIds.Where(c => c != receiver).ToArray());
|
|
|
|
// Pass some time to make sure that no other client ever receives this
|
|
TimeTravel(1f, 30);
|
|
VerifyNotReceived(objectOwner, s_ClientIds.Where(c => c != receiver).ToArray());
|
|
}
|
|
|
|
public void VerifySentToNotId(ulong objectOwner, ulong sender, ulong notReceiver, string methodName, bool verifyReceivedFrom)
|
|
{
|
|
VerifyNotReceived(objectOwner, new[] { notReceiver });
|
|
VerifyRemoteReceived(objectOwner, sender, methodName, s_ClientIds.Where(c => c != notReceiver).ToArray(), verifyReceivedFrom);
|
|
// Verify again after all the waiting is finished
|
|
VerifyNotReceived(objectOwner, new[] { notReceiver });
|
|
}
|
|
|
|
public void VerifySentToIdWithParams(ulong objectOwner, ulong sender, ulong receiver, string methodName, int i, bool b, float f, string s)
|
|
{
|
|
VerifyRemoteReceivedWithParams(objectOwner, sender, methodName, new[] { receiver }, i, b, f, s);
|
|
VerifyNotReceived(objectOwner, s_ClientIds.Where(c => c != receiver).ToArray());
|
|
|
|
// Pass some time to make sure that no other client ever receives this
|
|
TimeTravel(1f, 30);
|
|
VerifyNotReceived(objectOwner, s_ClientIds.Where(c => c != receiver).ToArray());
|
|
}
|
|
|
|
public void VerifySentToNotIdWithParams(ulong objectOwner, ulong sender, ulong notReceiver, string methodName, int i, bool b, float f, string s)
|
|
{
|
|
VerifyNotReceived(objectOwner, new[] { notReceiver });
|
|
VerifyRemoteReceivedWithParams(objectOwner, sender, methodName, s_ClientIds.Where(c => c != notReceiver).ToArray(), i, b, f, s);
|
|
// Verify again after all the waiting is finished
|
|
VerifyNotReceived(objectOwner, new[] { notReceiver });
|
|
}
|
|
|
|
public void VerifySentToOwner(ulong objectOwner, ulong sender, string methodName)
|
|
{
|
|
VerifySentToId(objectOwner, sender, objectOwner, methodName, false);
|
|
}
|
|
|
|
public void VerifySentToNotOwner(ulong objectOwner, ulong sender, string methodName)
|
|
{
|
|
VerifySentToNotId(objectOwner, sender, objectOwner, methodName, false);
|
|
}
|
|
|
|
public void VerifySentToServer(ulong objectOwner, ulong sender, string methodName)
|
|
{
|
|
VerifySentToId(objectOwner, sender, NetworkManager.ServerClientId, methodName, false);
|
|
}
|
|
|
|
public void VerifySentToNotServer(ulong objectOwner, ulong sender, string methodName)
|
|
{
|
|
VerifySentToNotId(objectOwner, sender, NetworkManager.ServerClientId, methodName, false);
|
|
}
|
|
|
|
public void VerifySentToClientsAndHost(ulong objectOwner, ulong sender, string methodName)
|
|
{
|
|
if (m_ServerNetworkManager.IsHost)
|
|
{
|
|
VerifySentToEveryone(objectOwner, sender, methodName);
|
|
}
|
|
else
|
|
{
|
|
VerifySentToNotServer(objectOwner, sender, methodName);
|
|
}
|
|
}
|
|
|
|
public void VerifySentToMe(ulong objectOwner, ulong sender, string methodName)
|
|
{
|
|
VerifySentToId(objectOwner, sender, sender, methodName, false);
|
|
}
|
|
|
|
public void VerifySentToNotMe(ulong objectOwner, ulong sender, string methodName)
|
|
{
|
|
VerifySentToNotId(objectOwner, sender, sender, methodName, false);
|
|
}
|
|
|
|
public void VerifySentToOwnerWithReceivedFrom(ulong objectOwner, ulong sender, string methodName)
|
|
{
|
|
VerifySentToId(objectOwner, sender, objectOwner, methodName, true);
|
|
}
|
|
|
|
public void VerifySentToNotOwnerWithReceivedFrom(ulong objectOwner, ulong sender, string methodName)
|
|
{
|
|
VerifySentToNotId(objectOwner, sender, objectOwner, methodName, true);
|
|
}
|
|
|
|
public void VerifySentToServerWithReceivedFrom(ulong objectOwner, ulong sender, string methodName)
|
|
{
|
|
VerifySentToId(objectOwner, sender, NetworkManager.ServerClientId, methodName, true);
|
|
}
|
|
|
|
public void VerifySentToNotServerWithReceivedFrom(ulong objectOwner, ulong sender, string methodName)
|
|
{
|
|
VerifySentToNotId(objectOwner, sender, NetworkManager.ServerClientId, methodName, true);
|
|
}
|
|
|
|
public void VerifySentToClientsAndHostWithReceivedFrom(ulong objectOwner, ulong sender, string methodName)
|
|
{
|
|
if (m_ServerNetworkManager.IsHost)
|
|
{
|
|
VerifySentToEveryoneWithReceivedFrom(objectOwner, sender, methodName);
|
|
}
|
|
else
|
|
{
|
|
VerifySentToNotServerWithReceivedFrom(objectOwner, sender, methodName);
|
|
}
|
|
}
|
|
|
|
public void VerifySentToMeWithReceivedFrom(ulong objectOwner, ulong sender, string methodName)
|
|
{
|
|
VerifySentToId(objectOwner, sender, sender, methodName, true);
|
|
}
|
|
|
|
public void VerifySentToNotMeWithReceivedFrom(ulong objectOwner, ulong sender, string methodName)
|
|
{
|
|
VerifySentToNotId(objectOwner, sender, sender, methodName, true);
|
|
}
|
|
|
|
public void VerifySentToOwnerWithParams(ulong objectOwner, ulong sender, string methodName, int i, bool b, float f, string s)
|
|
{
|
|
VerifySentToIdWithParams(objectOwner, sender, objectOwner, methodName, i, b, f, s);
|
|
}
|
|
|
|
public void VerifySentToNotOwnerWithParams(ulong objectOwner, ulong sender, string methodName, int i, bool b, float f, string s)
|
|
{
|
|
VerifySentToNotIdWithParams(objectOwner, sender, objectOwner, methodName, i, b, f, s);
|
|
}
|
|
|
|
public void VerifySentToServerWithParams(ulong objectOwner, ulong sender, string methodName, int i, bool b, float f, string s)
|
|
{
|
|
VerifySentToIdWithParams(objectOwner, sender, NetworkManager.ServerClientId, methodName, i, b, f, s);
|
|
}
|
|
|
|
public void VerifySentToNotServerWithParams(ulong objectOwner, ulong sender, string methodName, int i, bool b, float f, string s)
|
|
{
|
|
VerifySentToNotIdWithParams(objectOwner, sender, NetworkManager.ServerClientId, methodName, i, b, f, s);
|
|
}
|
|
|
|
public void VerifySentToClientsAndHostWithParams(ulong objectOwner, ulong sender, string methodName, int i, bool b, float f, string s)
|
|
{
|
|
if (m_ServerNetworkManager.IsHost)
|
|
{
|
|
VerifySentToEveryoneWithParams(objectOwner, sender, methodName, i, b, f, s);
|
|
}
|
|
else
|
|
{
|
|
VerifySentToNotServerWithParams(objectOwner, sender, methodName, i, b, f, s);
|
|
}
|
|
}
|
|
|
|
public void VerifySentToMeWithParams(ulong objectOwner, ulong sender, string methodName, int i, bool b, float f, string s)
|
|
{
|
|
VerifySentToIdWithParams(objectOwner, sender, sender, methodName, i, b, f, s);
|
|
}
|
|
|
|
public void VerifySentToNotMeWithParams(ulong objectOwner, ulong sender, string methodName, int i, bool b, float f, string s)
|
|
{
|
|
VerifySentToNotIdWithParams(objectOwner, sender, sender, methodName, i, b, f, s);
|
|
}
|
|
|
|
public void RethrowTargetInvocationException(Action action)
|
|
{
|
|
try
|
|
{
|
|
action.Invoke();
|
|
}
|
|
catch (TargetInvocationException e)
|
|
{
|
|
throw e.InnerException;
|
|
}
|
|
}
|
|
}
|
|
|
|
[TestFixture(HostOrServer.Host)]
|
|
[TestFixture(HostOrServer.Server)]
|
|
internal class UniversalRpcTestSendingNoOverride : UniversalRpcTestsBase
|
|
{
|
|
public UniversalRpcTestSendingNoOverride(HostOrServer hostOrServer) : base(hostOrServer)
|
|
{
|
|
|
|
}
|
|
|
|
[Test]
|
|
public void TestSendingNoOverride(
|
|
// Excludes SendTo.SpecifiedInParams
|
|
[Values(SendTo.Everyone, SendTo.Me, SendTo.Owner, SendTo.Server, SendTo.NotMe, SendTo.NotOwner, SendTo.NotServer, SendTo.ClientsAndHost)] SendTo sendTo,
|
|
[Values(0u, 1u, 2u)] ulong objectOwner,
|
|
[Values(0u, 1u, 2u)] ulong sender
|
|
)
|
|
{
|
|
var sendMethodName = $"DefaultTo{sendTo}Rpc";
|
|
var verifyMethodName = $"VerifySentTo{sendTo}";
|
|
|
|
var senderObject = GetPlayerObject(objectOwner, sender);
|
|
var sendMethod = senderObject.GetType().GetMethod(sendMethodName);
|
|
sendMethod.Invoke(senderObject, new object[] { });
|
|
|
|
var verifyMethod = GetType().GetMethod(verifyMethodName);
|
|
verifyMethod.Invoke(this, new object[] { objectOwner, sender, sendMethodName });
|
|
}
|
|
|
|
}
|
|
|
|
[TestFixture(HostOrServer.Host)]
|
|
[TestFixture(HostOrServer.Server)]
|
|
internal class UniversalRpcTestSenderClientId : UniversalRpcTestsBase
|
|
{
|
|
public UniversalRpcTestSenderClientId(HostOrServer hostOrServer) : base(hostOrServer)
|
|
{
|
|
|
|
}
|
|
|
|
[Test]
|
|
public void TestSenderClientId(
|
|
// Excludes SendTo.SpecifiedInParams
|
|
[Values(SendTo.Everyone, SendTo.Me, SendTo.Owner, SendTo.Server, SendTo.NotMe, SendTo.NotOwner, SendTo.NotServer, SendTo.ClientsAndHost)] SendTo sendTo,
|
|
[Values(0u, 1u, 2u)] ulong objectOwner,
|
|
[Values(0u, 1u, 2u)] ulong sender
|
|
)
|
|
{
|
|
var sendMethodName = $"DefaultTo{sendTo}WithRpcParamsRpc";
|
|
var verifyMethodName = $"VerifySentTo{sendTo}WithReceivedFrom";
|
|
|
|
var senderObject = GetPlayerObject(objectOwner, sender);
|
|
var sendMethod = senderObject.GetType().GetMethod(sendMethodName);
|
|
sendMethod.Invoke(senderObject, new object[] { new RpcParams() });
|
|
|
|
var verifyMethod = GetType().GetMethod(verifyMethodName);
|
|
verifyMethod.Invoke(this, new object[] { objectOwner, sender, sendMethodName });
|
|
}
|
|
|
|
}
|
|
|
|
[TestFixture(HostOrServer.Host)]
|
|
[TestFixture(HostOrServer.Server)]
|
|
internal class UniversalRpcTestSendingNoOverrideWithParams : UniversalRpcTestsBase
|
|
{
|
|
public UniversalRpcTestSendingNoOverrideWithParams(HostOrServer hostOrServer) : base(hostOrServer)
|
|
{
|
|
|
|
}
|
|
|
|
[Test]
|
|
public void TestSendingNoOverrideWithParams(
|
|
// Excludes SendTo.SpecifiedInParams
|
|
[Values(SendTo.Everyone, SendTo.Me, SendTo.Owner, SendTo.Server, SendTo.NotMe, SendTo.NotOwner, SendTo.NotServer, SendTo.ClientsAndHost)] SendTo sendTo,
|
|
[Values(0u, 1u, 2u)] ulong objectOwner,
|
|
[Values(0u, 1u, 2u)] ulong sender
|
|
)
|
|
{
|
|
var rand = new Random();
|
|
var i = rand.Next();
|
|
var f = (float)rand.NextDouble();
|
|
var b = rand.Next() % 2 == 1;
|
|
var s = "";
|
|
var numChars = rand.Next() % 5 + 5;
|
|
const string chars = "abcdefghijklmnopqrstuvwxycABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-=_+[]{}\\|;':\",./<>?";
|
|
for (var j = 0; j < numChars; ++j)
|
|
{
|
|
s += chars[rand.Next(chars.Length)];
|
|
}
|
|
|
|
var sendMethodName = $"DefaultTo{sendTo}WithParamsRpc";
|
|
var verifyMethodName = $"VerifySentTo{sendTo}WithParams";
|
|
|
|
var senderObject = GetPlayerObject(objectOwner, sender);
|
|
var sendMethod = senderObject.GetType().GetMethod(sendMethodName);
|
|
sendMethod.Invoke(senderObject, new object[] { i, b, f, s });
|
|
|
|
var verifyMethod = GetType().GetMethod(verifyMethodName);
|
|
verifyMethod.Invoke(this, new object[] { objectOwner, sender, sendMethodName, i, b, f, s });
|
|
}
|
|
|
|
}
|
|
|
|
[TestFixture(HostOrServer.Host)]
|
|
[TestFixture(HostOrServer.Server)]
|
|
internal class UniversalRpcTestSendingNoOverrideWithParamsAndRpcParams : UniversalRpcTestsBase
|
|
{
|
|
public UniversalRpcTestSendingNoOverrideWithParamsAndRpcParams(HostOrServer hostOrServer) : base(hostOrServer)
|
|
{
|
|
|
|
}
|
|
|
|
[Test]
|
|
public void TestSendingNoOverrideWithParamsAndRpcParams(
|
|
// Excludes SendTo.SpecifiedInParams
|
|
[Values(SendTo.Everyone, SendTo.Me, SendTo.Owner, SendTo.Server, SendTo.NotMe, SendTo.NotOwner, SendTo.NotServer, SendTo.ClientsAndHost)] SendTo sendTo,
|
|
[Values(0u, 1u, 2u)] ulong objectOwner,
|
|
[Values(0u, 1u, 2u)] ulong sender
|
|
)
|
|
{
|
|
var rand = new Random();
|
|
var i = rand.Next();
|
|
var f = (float)rand.NextDouble();
|
|
var b = rand.Next() % 2 == 1;
|
|
var s = "";
|
|
var numChars = rand.Next() % 5 + 5;
|
|
const string chars = "abcdefghijklmnopqrstuvwxycABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-=_+[]{}\\|;':\",./<>?";
|
|
for (var j = 0; j < numChars; ++j)
|
|
{
|
|
s += chars[rand.Next(chars.Length)];
|
|
}
|
|
|
|
var sendMethodName = $"DefaultTo{sendTo}WithParamsAndRpcParamsRpc";
|
|
var verifyMethodName = $"VerifySentTo{sendTo}WithParams";
|
|
|
|
var senderObject = GetPlayerObject(objectOwner, sender);
|
|
var sendMethod = senderObject.GetType().GetMethod(sendMethodName);
|
|
sendMethod.Invoke(senderObject, new object[] { i, b, f, s, new RpcParams() });
|
|
|
|
var verifyMethod = GetType().GetMethod(verifyMethodName);
|
|
verifyMethod.Invoke(this, new object[] { objectOwner, sender, sendMethodName, i, b, f, s });
|
|
}
|
|
|
|
}
|
|
|
|
[TestFixture(HostOrServer.Host)]
|
|
[TestFixture(HostOrServer.Server)]
|
|
internal class UniversalRpcTestRequireOwnership : UniversalRpcTestsBase
|
|
{
|
|
public UniversalRpcTestRequireOwnership(HostOrServer hostOrServer) : base(hostOrServer)
|
|
{
|
|
|
|
}
|
|
|
|
[Test]
|
|
public void TestRequireOwnership(
|
|
// Excludes SendTo.SpecifiedInParams
|
|
[Values(SendTo.Everyone, SendTo.Me, SendTo.Owner, SendTo.Server, SendTo.NotMe, SendTo.NotOwner, SendTo.NotServer, SendTo.ClientsAndHost)] SendTo sendTo,
|
|
[Values(0u, 1u, 2u)] ulong objectOwner,
|
|
[Values(0u, 1u, 2u)] ulong sender
|
|
)
|
|
{
|
|
var sendMethodName = $"DefaultTo{sendTo}RequireOwnershipRpc";
|
|
|
|
var senderObject = GetPlayerObject(objectOwner, sender);
|
|
var sendMethod = senderObject.GetType().GetMethod(sendMethodName);
|
|
if (sender != objectOwner)
|
|
{
|
|
Assert.Throws<RpcException>(() => RethrowTargetInvocationException(() => sendMethod.Invoke(senderObject, new object[] { })));
|
|
}
|
|
else
|
|
{
|
|
var verifyMethodName = $"VerifySentTo{sendTo}";
|
|
sendMethod.Invoke(senderObject, new object[] { });
|
|
|
|
var verifyMethod = GetType().GetMethod(verifyMethodName);
|
|
verifyMethod.Invoke(this, new object[] { objectOwner, sender, sendMethodName });
|
|
}
|
|
}
|
|
}
|
|
|
|
[TestFixture(HostOrServer.Host)]
|
|
[TestFixture(HostOrServer.Server)]
|
|
internal class UniversalRpcTestDisallowedOverride : UniversalRpcTestsBase
|
|
{
|
|
public UniversalRpcTestDisallowedOverride(HostOrServer hostOrServer) : base(hostOrServer)
|
|
{
|
|
|
|
}
|
|
|
|
[Test]
|
|
public void TestDisallowedOverride(
|
|
// Excludes SendTo.SpecifiedInParams
|
|
[Values(SendTo.Everyone, SendTo.Me, SendTo.Owner, SendTo.Server, SendTo.NotMe, SendTo.NotOwner, SendTo.NotServer, SendTo.ClientsAndHost)] SendTo sendTo,
|
|
[Values(0u, 1u, 2u)] ulong objectOwner,
|
|
[Values(0u, 1u, 2u)] ulong sender)
|
|
{
|
|
var senderObject = GetPlayerObject(objectOwner, sender);
|
|
var methodName = $"DefaultTo{sendTo}WithRpcParamsRpc";
|
|
var method = senderObject.GetType().GetMethod(methodName);
|
|
Assert.Throws<RpcException>(() => RethrowTargetInvocationException(() => method.Invoke(senderObject, new object[] { (RpcParams)senderObject.RpcTarget.Everyone })));
|
|
Assert.Throws<RpcException>(() => RethrowTargetInvocationException(() => method.Invoke(senderObject, new object[] { (RpcParams)senderObject.RpcTarget.Owner })));
|
|
Assert.Throws<RpcException>(() => RethrowTargetInvocationException(() => method.Invoke(senderObject, new object[] { (RpcParams)senderObject.RpcTarget.NotOwner })));
|
|
Assert.Throws<RpcException>(() => RethrowTargetInvocationException(() => method.Invoke(senderObject, new object[] { (RpcParams)senderObject.RpcTarget.Server })));
|
|
Assert.Throws<RpcException>(() => RethrowTargetInvocationException(() => method.Invoke(senderObject, new object[] { (RpcParams)senderObject.RpcTarget.NotServer })));
|
|
Assert.Throws<RpcException>(() => RethrowTargetInvocationException(() => method.Invoke(senderObject, new object[] { (RpcParams)senderObject.RpcTarget.ClientsAndHost })));
|
|
Assert.Throws<RpcException>(() => RethrowTargetInvocationException(() => method.Invoke(senderObject, new object[] { (RpcParams)senderObject.RpcTarget.Me })));
|
|
Assert.Throws<RpcException>(() => RethrowTargetInvocationException(() => method.Invoke(senderObject, new object[] { (RpcParams)senderObject.RpcTarget.NotMe })));
|
|
Assert.Throws<RpcException>(() => RethrowTargetInvocationException(() => method.Invoke(senderObject, new object[] { (RpcParams)senderObject.RpcTarget.Single(0, RpcTargetUse.Temp) })));
|
|
Assert.Throws<RpcException>(() => RethrowTargetInvocationException(() => method.Invoke(senderObject, new object[] { (RpcParams)senderObject.RpcTarget.Not(0, RpcTargetUse.Temp) })));
|
|
Assert.Throws<RpcException>(() => RethrowTargetInvocationException(() => method.Invoke(senderObject, new object[] { (RpcParams)senderObject.RpcTarget.Group(new[] { 0ul, 1ul, 2ul }, RpcTargetUse.Temp) })));
|
|
Assert.Throws<RpcException>(() => RethrowTargetInvocationException(() => method.Invoke(senderObject, new object[] { (RpcParams)senderObject.RpcTarget.Not(new[] { 0ul, 1ul, 2ul }, RpcTargetUse.Temp) })));
|
|
}
|
|
|
|
}
|
|
|
|
[TestFixture(HostOrServer.Host)]
|
|
[TestFixture(HostOrServer.Server)]
|
|
internal class UniversalRpcTestSendingWithTargetOverride : UniversalRpcTestsBase
|
|
{
|
|
public UniversalRpcTestSendingWithTargetOverride(HostOrServer hostOrServer) : base(hostOrServer)
|
|
{
|
|
|
|
}
|
|
|
|
[Test]
|
|
public void TestSendingWithTargetOverride(
|
|
[Values] SendTo defaultSendTo,
|
|
[Values(SendTo.Everyone, SendTo.Me, SendTo.Owner, SendTo.Server, SendTo.NotMe, SendTo.NotOwner, SendTo.NotServer, SendTo.ClientsAndHost)] SendTo overrideSendTo,
|
|
[Values(0u, 1u, 2u)] ulong objectOwner,
|
|
[Values(0u, 1u, 2u)] ulong sender
|
|
)
|
|
{
|
|
var sendMethodName = $"DefaultTo{defaultSendTo}AllowOverrideRpc";
|
|
var targetField = typeof(RpcTarget).GetField(overrideSendTo.ToString());
|
|
var verifyMethodName = $"VerifySentTo{overrideSendTo}";
|
|
|
|
var senderObject = GetPlayerObject(objectOwner, sender);
|
|
var target = (BaseRpcTarget)targetField.GetValue(senderObject.RpcTarget);
|
|
var sendMethod = senderObject.GetType().GetMethod(sendMethodName);
|
|
sendMethod.Invoke(senderObject, new object[] { (RpcParams)target });
|
|
|
|
var verifyMethod = GetType().GetMethod(verifyMethodName);
|
|
verifyMethod.Invoke(this, new object[] { objectOwner, sender, sendMethodName });
|
|
}
|
|
|
|
|
|
}
|
|
|
|
[TestFixture(HostOrServer.Host)]
|
|
[TestFixture(HostOrServer.Server)]
|
|
internal class UniversalRpcTestSendingWithSingleOverride : UniversalRpcTestsBase
|
|
{
|
|
public UniversalRpcTestSendingWithSingleOverride(HostOrServer hostOrServer) : base(hostOrServer)
|
|
{
|
|
|
|
}
|
|
|
|
[Test]
|
|
public void TestSendingWithSingleOverride(
|
|
[Values] SendTo defaultSendTo,
|
|
[Values(0u, 1u, 2u)] ulong recipient,
|
|
[Values(0u, 1u, 2u)] ulong objectOwner,
|
|
[Values(0u, 1u, 2u)] ulong sender
|
|
)
|
|
{
|
|
var sendMethodName = $"DefaultTo{defaultSendTo}AllowOverrideRpc";
|
|
|
|
var senderObject = GetPlayerObject(objectOwner, sender);
|
|
var target = senderObject.RpcTarget.Single(recipient, RpcTargetUse.Temp);
|
|
var sendMethod = senderObject.GetType().GetMethod(sendMethodName);
|
|
sendMethod.Invoke(senderObject, new object[] { (RpcParams)target });
|
|
|
|
VerifyRemoteReceived(objectOwner, sender, sendMethodName, new[] { recipient }, false);
|
|
VerifyNotReceived(objectOwner, s_ClientIds.Where(c => recipient != c).ToArray());
|
|
|
|
// Pass some time to make sure that no other client ever receives this
|
|
TimeTravel(1f, 30);
|
|
VerifyNotReceived(objectOwner, s_ClientIds.Where(c => recipient != c).ToArray());
|
|
}
|
|
|
|
}
|
|
|
|
[TestFixture(HostOrServer.Host)]
|
|
[TestFixture(HostOrServer.Server)]
|
|
internal class UniversalRpcTestSendingWithSingleNotOverride : UniversalRpcTestsBase
|
|
{
|
|
public UniversalRpcTestSendingWithSingleNotOverride(HostOrServer hostOrServer) : base(hostOrServer)
|
|
{
|
|
|
|
}
|
|
|
|
[Test]
|
|
public void TestSendingWithSingleNotOverride(
|
|
[Values] SendTo defaultSendTo,
|
|
[Values(0u, 1u, 2u)] ulong recipient,
|
|
[Values(0u, 1u, 2u)] ulong objectOwner,
|
|
[Values(0u, 1u, 2u)] ulong sender
|
|
)
|
|
{
|
|
var sendMethodName = $"DefaultTo{defaultSendTo}AllowOverrideRpc";
|
|
|
|
var senderObject = GetPlayerObject(objectOwner, sender);
|
|
var target = senderObject.RpcTarget.Not(recipient, RpcTargetUse.Temp);
|
|
var sendMethod = senderObject.GetType().GetMethod(sendMethodName);
|
|
sendMethod.Invoke(senderObject, new object[] { (RpcParams)target });
|
|
|
|
VerifyRemoteReceived(objectOwner, sender, sendMethodName, s_ClientIds.Where(c => recipient != c).ToArray(), false);
|
|
VerifyNotReceived(objectOwner, new[] { recipient });
|
|
|
|
// Pass some time to make sure that no other client ever receives this
|
|
TimeTravel(1f, 30);
|
|
VerifyNotReceived(objectOwner, new[] { recipient });
|
|
}
|
|
|
|
}
|
|
|
|
[TestFixture(HostOrServer.Host)]
|
|
[TestFixture(HostOrServer.Server)]
|
|
internal class UniversalRpcTestSendingWithGroupOverride : UniversalRpcTestsBase
|
|
{
|
|
public UniversalRpcTestSendingWithGroupOverride(HostOrServer hostOrServer) : base(hostOrServer)
|
|
{
|
|
|
|
}
|
|
|
|
public static ulong[][] RecipientGroups = new[]
|
|
{
|
|
new[] { 0ul },
|
|
new[] { 1ul },
|
|
new[] { 0ul, 1ul },
|
|
new[] { 0ul, 1ul, 2ul }
|
|
};
|
|
|
|
public enum AllocationType
|
|
{
|
|
Array,
|
|
NativeArray,
|
|
NativeList,
|
|
List
|
|
}
|
|
|
|
[Test]
|
|
public void TestSendingWithGroupOverride(
|
|
[Values] SendTo defaultSendTo,
|
|
[ValueSource(nameof(RecipientGroups))] ulong[] recipient,
|
|
[Values(0u, 1u, 2u)] ulong objectOwner,
|
|
[Values(0u, 1u, 2u)] ulong sender,
|
|
[Values] AllocationType allocationType
|
|
)
|
|
{
|
|
var sendMethodName = $"DefaultTo{defaultSendTo}AllowOverrideRpc";
|
|
|
|
var senderObject = GetPlayerObject(objectOwner, sender);
|
|
BaseRpcTarget target = null;
|
|
switch (allocationType)
|
|
{
|
|
case AllocationType.Array:
|
|
target = senderObject.RpcTarget.Group(recipient, RpcTargetUse.Temp);
|
|
break;
|
|
case AllocationType.List:
|
|
target = senderObject.RpcTarget.Group(recipient.ToList(), RpcTargetUse.Temp);
|
|
break;
|
|
case AllocationType.NativeArray:
|
|
var arr = new NativeArray<ulong>(recipient, Allocator.Temp);
|
|
target = senderObject.RpcTarget.Group(arr, RpcTargetUse.Temp);
|
|
arr.Dispose();
|
|
break;
|
|
case AllocationType.NativeList:
|
|
// For some reason on 2020.3, calling list.AsArray() and passing that to the next function
|
|
// causes Allocator.Temp allocations to become invalid somehow. This is not an issue on later
|
|
// versions of Unity.
|
|
var list = new NativeList<ulong>(recipient.Length, Allocator.TempJob);
|
|
foreach (var id in recipient)
|
|
{
|
|
list.Add(id);
|
|
}
|
|
target = senderObject.RpcTarget.Group(list, RpcTargetUse.Temp);
|
|
list.Dispose();
|
|
break;
|
|
}
|
|
var sendMethod = senderObject.GetType().GetMethod(sendMethodName);
|
|
sendMethod.Invoke(senderObject, new object[] { (RpcParams)target });
|
|
|
|
VerifyRemoteReceived(objectOwner, sender, sendMethodName, s_ClientIds.Where(c => recipient.Contains(c)).ToArray(), false);
|
|
VerifyNotReceived(objectOwner, s_ClientIds.Where(c => !recipient.Contains(c)).ToArray());
|
|
|
|
// Pass some time to make sure that no other client ever receives this
|
|
TimeTravel(1f, 30);
|
|
VerifyNotReceived(objectOwner, s_ClientIds.Where(c => !recipient.Contains(c)).ToArray());
|
|
}
|
|
|
|
}
|
|
|
|
[TestFixture(HostOrServer.Host)]
|
|
[TestFixture(HostOrServer.Server)]
|
|
internal class UniversalRpcTestSendingWithGroupNotOverride : UniversalRpcTestsBase
|
|
{
|
|
public UniversalRpcTestSendingWithGroupNotOverride(HostOrServer hostOrServer) : base(hostOrServer)
|
|
{
|
|
|
|
}
|
|
|
|
public static ulong[][] RecipientGroups = new[]
|
|
{
|
|
new ulong[] {},
|
|
new[] { 0ul },
|
|
new[] { 1ul },
|
|
new[] { 0ul, 1ul },
|
|
};
|
|
|
|
public enum AllocationType
|
|
{
|
|
Array,
|
|
NativeArray,
|
|
NativeList,
|
|
List
|
|
}
|
|
|
|
[Test]
|
|
public void TestSendingWithGroupNotOverride(
|
|
[Values] SendTo defaultSendTo,
|
|
[ValueSource(nameof(RecipientGroups))] ulong[] recipient,
|
|
[Values(0u, 1u, 2u)] ulong objectOwner,
|
|
[Values(0u, 1u, 2u)] ulong sender,
|
|
[Values] AllocationType allocationType
|
|
)
|
|
{
|
|
var sendMethodName = $"DefaultTo{defaultSendTo}AllowOverrideRpc";
|
|
|
|
var senderObject = GetPlayerObject(objectOwner, sender);
|
|
BaseRpcTarget target = null;
|
|
switch (allocationType)
|
|
{
|
|
case AllocationType.Array:
|
|
target = senderObject.RpcTarget.Not(recipient, RpcTargetUse.Temp);
|
|
break;
|
|
case AllocationType.List:
|
|
target = senderObject.RpcTarget.Not(recipient.ToList(), RpcTargetUse.Temp);
|
|
break;
|
|
case AllocationType.NativeArray:
|
|
var arr = new NativeArray<ulong>(recipient, Allocator.Temp);
|
|
target = senderObject.RpcTarget.Not(arr, RpcTargetUse.Temp);
|
|
arr.Dispose();
|
|
break;
|
|
case AllocationType.NativeList:
|
|
// For some reason on 2020.3, calling list.AsArray() and passing that to the next function
|
|
// causes Allocator.Temp allocations to become invalid somehow. This is not an issue on later
|
|
// versions of Unity.
|
|
var list = new NativeList<ulong>(recipient.Length, Allocator.TempJob);
|
|
foreach (var id in recipient)
|
|
{
|
|
list.Add(id);
|
|
}
|
|
target = senderObject.RpcTarget.Not(list, RpcTargetUse.Temp);
|
|
list.Dispose();
|
|
break;
|
|
}
|
|
var sendMethod = senderObject.GetType().GetMethod(sendMethodName);
|
|
sendMethod.Invoke(senderObject, new object[] { (RpcParams)target });
|
|
|
|
VerifyRemoteReceived(objectOwner, sender, sendMethodName, s_ClientIds.Where(c => !recipient.Contains(c)).ToArray(), false);
|
|
VerifyNotReceived(objectOwner, s_ClientIds.Where(c => recipient.Contains(c)).ToArray());
|
|
|
|
// Pass some time to make sure that no other client ever receives this
|
|
TimeTravel(1f, 30);
|
|
VerifyNotReceived(objectOwner, s_ClientIds.Where(c => recipient.Contains(c)).ToArray());
|
|
}
|
|
|
|
}
|
|
|
|
[TestFixture(HostOrServer.Host)]
|
|
[TestFixture(HostOrServer.Server)]
|
|
internal class UniversalRpcTestDefaultSendToSpecifiedInParamsSendingToServerAndOwner : UniversalRpcTestsBase
|
|
{
|
|
public UniversalRpcTestDefaultSendToSpecifiedInParamsSendingToServerAndOwner(HostOrServer hostOrServer) : base(hostOrServer)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
[TestFixture(HostOrServer.Host)]
|
|
[TestFixture(HostOrServer.Server)]
|
|
internal class UniversalRpcTestDeferLocal : UniversalRpcTestsBase
|
|
{
|
|
public UniversalRpcTestDeferLocal(HostOrServer hostOrServer) : base(hostOrServer)
|
|
{
|
|
|
|
}
|
|
|
|
[Test]
|
|
// All the test cases that involve sends that will be delivered locally
|
|
[TestCase(SendTo.Everyone, 0u, 0u)]
|
|
[TestCase(SendTo.Everyone, 0u, 1u)]
|
|
[TestCase(SendTo.Everyone, 0u, 2u)]
|
|
[TestCase(SendTo.Everyone, 1u, 0u)]
|
|
[TestCase(SendTo.Everyone, 1u, 1u)]
|
|
[TestCase(SendTo.Everyone, 1u, 2u)]
|
|
[TestCase(SendTo.Everyone, 2u, 0u)]
|
|
[TestCase(SendTo.Everyone, 2u, 1u)]
|
|
[TestCase(SendTo.Everyone, 2u, 2u)]
|
|
[TestCase(SendTo.Me, 0u, 0u)]
|
|
[TestCase(SendTo.Me, 0u, 1u)]
|
|
[TestCase(SendTo.Me, 0u, 2u)]
|
|
[TestCase(SendTo.Me, 1u, 0u)]
|
|
[TestCase(SendTo.Me, 1u, 1u)]
|
|
[TestCase(SendTo.Me, 1u, 2u)]
|
|
[TestCase(SendTo.Me, 2u, 0u)]
|
|
[TestCase(SendTo.Me, 2u, 1u)]
|
|
[TestCase(SendTo.Me, 2u, 2u)]
|
|
[TestCase(SendTo.Owner, 0u, 0u)]
|
|
[TestCase(SendTo.Owner, 1u, 1u)]
|
|
[TestCase(SendTo.Owner, 2u, 2u)]
|
|
[TestCase(SendTo.Server, 0u, 0u)]
|
|
[TestCase(SendTo.Server, 1u, 0u)]
|
|
[TestCase(SendTo.Server, 2u, 0u)]
|
|
[TestCase(SendTo.NotOwner, 0u, 1u)]
|
|
[TestCase(SendTo.NotOwner, 0u, 2u)]
|
|
[TestCase(SendTo.NotOwner, 1u, 0u)]
|
|
[TestCase(SendTo.NotOwner, 1u, 2u)]
|
|
[TestCase(SendTo.NotOwner, 2u, 0u)]
|
|
[TestCase(SendTo.NotOwner, 2u, 1u)]
|
|
[TestCase(SendTo.NotServer, 0u, 1u)]
|
|
[TestCase(SendTo.NotServer, 0u, 2u)]
|
|
[TestCase(SendTo.NotServer, 1u, 1u)]
|
|
[TestCase(SendTo.NotServer, 1u, 2u)]
|
|
[TestCase(SendTo.NotServer, 2u, 1u)]
|
|
[TestCase(SendTo.NotServer, 2u, 2u)]
|
|
[TestCase(SendTo.ClientsAndHost, 0u, 0u)]
|
|
[TestCase(SendTo.ClientsAndHost, 0u, 1u)]
|
|
[TestCase(SendTo.ClientsAndHost, 0u, 2u)]
|
|
[TestCase(SendTo.ClientsAndHost, 1u, 0u)]
|
|
[TestCase(SendTo.ClientsAndHost, 1u, 1u)]
|
|
[TestCase(SendTo.ClientsAndHost, 1u, 2u)]
|
|
[TestCase(SendTo.ClientsAndHost, 2u, 0u)]
|
|
[TestCase(SendTo.ClientsAndHost, 2u, 1u)]
|
|
[TestCase(SendTo.ClientsAndHost, 2u, 2u)]
|
|
public void TestDeferLocal(
|
|
SendTo defaultSendTo,
|
|
ulong objectOwner,
|
|
ulong sender
|
|
)
|
|
{
|
|
if (defaultSendTo == SendTo.ClientsAndHost && sender == 0u && !m_ServerNetworkManager.IsHost)
|
|
{
|
|
// Not calling Assert.Ignore() because Unity will mark the whole block of tests as ignored
|
|
// Just consider this case a success...
|
|
return;
|
|
}
|
|
var sendMethodName = $"DefaultTo{defaultSendTo}DeferLocalRpc";
|
|
var verifyMethodName = $"VerifySentTo{defaultSendTo}";
|
|
var senderObject = GetPlayerObject(objectOwner, sender);
|
|
var sendMethod = senderObject.GetType().GetMethod(sendMethodName);
|
|
sendMethod.Invoke(senderObject, new object[] { new RpcParams() });
|
|
|
|
VerifyNotReceived(objectOwner, new[] { sender });
|
|
// Should be received on the next frame
|
|
SimulateOneFrame();
|
|
VerifyLocalReceived(objectOwner, sender, sendMethodName, false);
|
|
|
|
var verifyMethod = GetType().GetMethod(verifyMethodName);
|
|
verifyMethod.Invoke(this, new object[] { objectOwner, sender, sendMethodName });
|
|
}
|
|
|
|
[Test]
|
|
// All the test cases that involve sends that will be delivered locally
|
|
[TestCase(SendTo.Everyone, 0u, 0u)]
|
|
[TestCase(SendTo.Everyone, 0u, 1u)]
|
|
[TestCase(SendTo.Everyone, 0u, 2u)]
|
|
[TestCase(SendTo.Everyone, 1u, 0u)]
|
|
[TestCase(SendTo.Everyone, 1u, 1u)]
|
|
[TestCase(SendTo.Everyone, 1u, 2u)]
|
|
[TestCase(SendTo.Everyone, 2u, 0u)]
|
|
[TestCase(SendTo.Everyone, 2u, 1u)]
|
|
[TestCase(SendTo.Everyone, 2u, 2u)]
|
|
[TestCase(SendTo.Me, 0u, 0u)]
|
|
[TestCase(SendTo.Me, 0u, 1u)]
|
|
[TestCase(SendTo.Me, 0u, 2u)]
|
|
[TestCase(SendTo.Me, 1u, 0u)]
|
|
[TestCase(SendTo.Me, 1u, 1u)]
|
|
[TestCase(SendTo.Me, 1u, 2u)]
|
|
[TestCase(SendTo.Me, 2u, 0u)]
|
|
[TestCase(SendTo.Me, 2u, 1u)]
|
|
[TestCase(SendTo.Me, 2u, 2u)]
|
|
[TestCase(SendTo.Owner, 0u, 0u)]
|
|
[TestCase(SendTo.Owner, 1u, 1u)]
|
|
[TestCase(SendTo.Owner, 2u, 2u)]
|
|
[TestCase(SendTo.Server, 0u, 0u)]
|
|
[TestCase(SendTo.Server, 1u, 0u)]
|
|
[TestCase(SendTo.Server, 2u, 0u)]
|
|
[TestCase(SendTo.NotOwner, 0u, 1u)]
|
|
[TestCase(SendTo.NotOwner, 0u, 2u)]
|
|
[TestCase(SendTo.NotOwner, 1u, 0u)]
|
|
[TestCase(SendTo.NotOwner, 1u, 2u)]
|
|
[TestCase(SendTo.NotOwner, 2u, 0u)]
|
|
[TestCase(SendTo.NotOwner, 2u, 1u)]
|
|
[TestCase(SendTo.NotServer, 0u, 1u)]
|
|
[TestCase(SendTo.NotServer, 0u, 2u)]
|
|
[TestCase(SendTo.NotServer, 1u, 1u)]
|
|
[TestCase(SendTo.NotServer, 1u, 2u)]
|
|
[TestCase(SendTo.NotServer, 2u, 1u)]
|
|
[TestCase(SendTo.NotServer, 2u, 2u)]
|
|
[TestCase(SendTo.ClientsAndHost, 0u, 0u)]
|
|
[TestCase(SendTo.ClientsAndHost, 0u, 1u)]
|
|
[TestCase(SendTo.ClientsAndHost, 0u, 2u)]
|
|
[TestCase(SendTo.ClientsAndHost, 1u, 0u)]
|
|
[TestCase(SendTo.ClientsAndHost, 1u, 1u)]
|
|
[TestCase(SendTo.ClientsAndHost, 1u, 2u)]
|
|
[TestCase(SendTo.ClientsAndHost, 2u, 0u)]
|
|
[TestCase(SendTo.ClientsAndHost, 2u, 1u)]
|
|
[TestCase(SendTo.ClientsAndHost, 2u, 2u)]
|
|
public void TestDeferLocalOverrideToTrue(
|
|
SendTo defaultSendTo,
|
|
ulong objectOwner,
|
|
ulong sender
|
|
)
|
|
{
|
|
if (defaultSendTo == SendTo.ClientsAndHost && sender == 0u && !m_ServerNetworkManager.IsHost)
|
|
{
|
|
// Not calling Assert.Ignore() because Unity will mark the whole block of tests as ignored
|
|
// Just consider this case a success...
|
|
return;
|
|
}
|
|
var sendMethodName = $"DefaultTo{defaultSendTo}WithRpcParamsRpc";
|
|
var verifyMethodName = $"VerifySentTo{defaultSendTo}";
|
|
var senderObject = GetPlayerObject(objectOwner, sender);
|
|
var sendMethod = senderObject.GetType().GetMethod(sendMethodName);
|
|
sendMethod.Invoke(senderObject, new object[] { (RpcParams)LocalDeferMode.Defer });
|
|
|
|
VerifyNotReceived(objectOwner, new[] { sender });
|
|
// Should be received on the next frame
|
|
SimulateOneFrame();
|
|
VerifyLocalReceived(objectOwner, sender, sendMethodName, false);
|
|
|
|
var verifyMethod = GetType().GetMethod(verifyMethodName);
|
|
verifyMethod.Invoke(this, new object[] { objectOwner, sender, sendMethodName });
|
|
}
|
|
|
|
[Test]
|
|
// All the test cases that involve sends that will be delivered locally
|
|
[TestCase(SendTo.Everyone, 0u, 0u)]
|
|
[TestCase(SendTo.Everyone, 0u, 1u)]
|
|
[TestCase(SendTo.Everyone, 0u, 2u)]
|
|
[TestCase(SendTo.Everyone, 1u, 0u)]
|
|
[TestCase(SendTo.Everyone, 1u, 1u)]
|
|
[TestCase(SendTo.Everyone, 1u, 2u)]
|
|
[TestCase(SendTo.Everyone, 2u, 0u)]
|
|
[TestCase(SendTo.Everyone, 2u, 1u)]
|
|
[TestCase(SendTo.Everyone, 2u, 2u)]
|
|
[TestCase(SendTo.Me, 0u, 0u)]
|
|
[TestCase(SendTo.Me, 0u, 1u)]
|
|
[TestCase(SendTo.Me, 0u, 2u)]
|
|
[TestCase(SendTo.Me, 1u, 0u)]
|
|
[TestCase(SendTo.Me, 1u, 1u)]
|
|
[TestCase(SendTo.Me, 1u, 2u)]
|
|
[TestCase(SendTo.Me, 2u, 0u)]
|
|
[TestCase(SendTo.Me, 2u, 1u)]
|
|
[TestCase(SendTo.Me, 2u, 2u)]
|
|
[TestCase(SendTo.Owner, 0u, 0u)]
|
|
[TestCase(SendTo.Owner, 1u, 1u)]
|
|
[TestCase(SendTo.Owner, 2u, 2u)]
|
|
[TestCase(SendTo.Server, 0u, 0u)]
|
|
[TestCase(SendTo.Server, 1u, 0u)]
|
|
[TestCase(SendTo.Server, 2u, 0u)]
|
|
[TestCase(SendTo.NotOwner, 0u, 1u)]
|
|
[TestCase(SendTo.NotOwner, 0u, 2u)]
|
|
[TestCase(SendTo.NotOwner, 1u, 0u)]
|
|
[TestCase(SendTo.NotOwner, 1u, 2u)]
|
|
[TestCase(SendTo.NotOwner, 2u, 0u)]
|
|
[TestCase(SendTo.NotOwner, 2u, 1u)]
|
|
[TestCase(SendTo.NotServer, 0u, 1u)]
|
|
[TestCase(SendTo.NotServer, 0u, 2u)]
|
|
[TestCase(SendTo.NotServer, 1u, 1u)]
|
|
[TestCase(SendTo.NotServer, 1u, 2u)]
|
|
[TestCase(SendTo.NotServer, 2u, 1u)]
|
|
[TestCase(SendTo.NotServer, 2u, 2u)]
|
|
[TestCase(SendTo.ClientsAndHost, 0u, 0u)]
|
|
[TestCase(SendTo.ClientsAndHost, 0u, 1u)]
|
|
[TestCase(SendTo.ClientsAndHost, 0u, 2u)]
|
|
[TestCase(SendTo.ClientsAndHost, 1u, 0u)]
|
|
[TestCase(SendTo.ClientsAndHost, 1u, 1u)]
|
|
[TestCase(SendTo.ClientsAndHost, 1u, 2u)]
|
|
[TestCase(SendTo.ClientsAndHost, 2u, 0u)]
|
|
[TestCase(SendTo.ClientsAndHost, 2u, 1u)]
|
|
[TestCase(SendTo.ClientsAndHost, 2u, 2u)]
|
|
public void TestDeferLocalOverrideToFalse(
|
|
SendTo defaultSendTo,
|
|
ulong objectOwner,
|
|
ulong sender
|
|
)
|
|
{
|
|
if (defaultSendTo == SendTo.ClientsAndHost && sender == 0u && !m_ServerNetworkManager.IsHost)
|
|
{
|
|
// Not calling Assert.Ignore() because Unity will mark the whole block of tests as ignored
|
|
// Just consider this case a success...
|
|
return;
|
|
}
|
|
var sendMethodName = $"DefaultTo{defaultSendTo}DeferLocalRpc";
|
|
var verifyMethodName = $"VerifySentTo{defaultSendTo}";
|
|
var senderObject = GetPlayerObject(objectOwner, sender);
|
|
var sendMethod = senderObject.GetType().GetMethod(sendMethodName);
|
|
sendMethod.Invoke(senderObject, new object[] { (RpcParams)LocalDeferMode.SendImmediate });
|
|
|
|
VerifyLocalReceived(objectOwner, sender, sendMethodName, false);
|
|
|
|
var verifyMethod = GetType().GetMethod(verifyMethodName);
|
|
verifyMethod.Invoke(this, new object[] { objectOwner, sender, sendMethodName });
|
|
}
|
|
|
|
}
|
|
|
|
[TestFixture(HostOrServer.Host)]
|
|
[TestFixture(HostOrServer.Server)]
|
|
internal class UniversalRpcTestMutualRecursion : UniversalRpcTestsBase
|
|
{
|
|
public UniversalRpcTestMutualRecursion(HostOrServer hostOrServer) : base(hostOrServer)
|
|
{
|
|
|
|
}
|
|
|
|
[Test]
|
|
public void TestMutualRecursion()
|
|
{
|
|
var serverObj = GetPlayerObject(NetworkManager.ServerClientId, NetworkManager.ServerClientId);
|
|
|
|
serverObj.MutualRecursionClientRpc();
|
|
|
|
var serverIdArray = new[] { NetworkManager.ServerClientId };
|
|
var clientIdArray = s_ClientIds.Where(c => c != NetworkManager.ServerClientId).ToArray();
|
|
|
|
var clientList = m_ClientNetworkManagers.ToList();
|
|
var serverList = new List<NetworkManager> { m_ServerNetworkManager };
|
|
|
|
VerifyNotReceived(NetworkManager.ServerClientId, s_ClientIds);
|
|
|
|
for (var i = 0; i < 10; ++i)
|
|
{
|
|
WaitForMessageReceivedWithTimeTravel<RpcMessage>(clientList);
|
|
VerifyRemoteReceived(NetworkManager.ServerClientId, NetworkManager.ServerClientId, nameof(UniversalRpcNetworkBehaviour.MutualRecursionClientRpc), clientIdArray, false, false);
|
|
VerifyNotReceived(NetworkManager.ServerClientId, serverIdArray);
|
|
|
|
Clear();
|
|
|
|
WaitForMessageReceivedWithTimeTravel<RpcMessage>(serverList);
|
|
VerifyRemoteReceived(NetworkManager.ServerClientId, NetworkManager.ServerClientId, nameof(UniversalRpcNetworkBehaviour.MutualRecursionServerRpc), serverIdArray, false, false);
|
|
VerifyNotReceived(NetworkManager.ServerClientId, clientIdArray);
|
|
|
|
Clear();
|
|
}
|
|
serverObj.Stop = true;
|
|
WaitForMessageReceivedWithTimeTravel<RpcMessage>(serverList);
|
|
Assert.IsFalse(serverObj.Stop);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
[TestFixture(HostOrServer.Host)]
|
|
[TestFixture(HostOrServer.Server)]
|
|
internal class UniversalRpcTestSelfRecursion : UniversalRpcTestsBase
|
|
{
|
|
public UniversalRpcTestSelfRecursion(HostOrServer hostOrServer) : base(hostOrServer)
|
|
{
|
|
|
|
}
|
|
|
|
[Test]
|
|
public void TestSelfRecursion()
|
|
{
|
|
var serverObj = GetPlayerObject(NetworkManager.ServerClientId, NetworkManager.ServerClientId);
|
|
|
|
serverObj.SelfRecursiveRpc();
|
|
|
|
var serverIdArray = new[] { NetworkManager.ServerClientId };
|
|
var clientIdArray = s_ClientIds.Where(c => c != NetworkManager.ServerClientId).ToArray();
|
|
|
|
var clientList = m_ClientNetworkManagers.ToList();
|
|
var serverList = new List<NetworkManager> { m_ServerNetworkManager };
|
|
|
|
for (var i = 0; i < 10; ++i)
|
|
{
|
|
VerifyNotReceived(NetworkManager.ServerClientId, s_ClientIds);
|
|
SimulateOneFrame();
|
|
VerifyLocalReceived(NetworkManager.ServerClientId, NetworkManager.ServerClientId, nameof(UniversalRpcNetworkBehaviour.SelfRecursiveRpc), false);
|
|
|
|
Clear();
|
|
}
|
|
|
|
serverObj.Stop = true;
|
|
SimulateOneFrame();
|
|
Assert.IsFalse(serverObj.Stop);
|
|
VerifyNotReceived(NetworkManager.ServerClientId, s_ClientIds);
|
|
}
|
|
|
|
}
|
|
|
|
[TestFixture(ObjType.Server)]
|
|
[TestFixture(ObjType.Client)]
|
|
internal class UniversalRpcTestRpcTargetUse : UniversalRpcTestsBase
|
|
{
|
|
private ObjType m_ObjType;
|
|
|
|
public UniversalRpcTestRpcTargetUse(ObjType objType) : base(HostOrServer.Server)
|
|
{
|
|
m_ObjType = objType;
|
|
}
|
|
|
|
public enum AllocationType
|
|
{
|
|
Array,
|
|
NativeArray,
|
|
NativeList,
|
|
List
|
|
}
|
|
private BaseRpcTarget GetGroup(NetworkBehaviour senderObject, ulong[] recipient, AllocationType allocationType, RpcTargetUse use)
|
|
{
|
|
switch (allocationType)
|
|
{
|
|
case AllocationType.Array:
|
|
return senderObject.RpcTarget.Group(recipient, use);
|
|
case AllocationType.List:
|
|
return senderObject.RpcTarget.Group(recipient.ToList(), use);
|
|
case AllocationType.NativeArray:
|
|
var arr = new NativeArray<ulong>(recipient, Allocator.Temp);
|
|
var naTarget = senderObject.RpcTarget.Group(arr, use);
|
|
arr.Dispose();
|
|
return naTarget;
|
|
case AllocationType.NativeList:
|
|
// For some reason on 2020.3, calling list.AsArray() and passing that to the next function
|
|
// causes Allocator.Temp allocations to become invalid somehow. This is not an issue on later
|
|
// versions of Unity.
|
|
var list = new NativeList<ulong>(recipient.Length, Allocator.TempJob);
|
|
foreach (var id in recipient)
|
|
{
|
|
list.Add(id);
|
|
}
|
|
var nlTarget = senderObject.RpcTarget.Group(list, use);
|
|
list.Dispose();
|
|
return nlTarget;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
private BaseRpcTarget GetNot(NetworkBehaviour senderObject, ulong[] recipient, AllocationType allocationType, RpcTargetUse use)
|
|
{
|
|
switch (allocationType)
|
|
{
|
|
case AllocationType.Array:
|
|
return senderObject.RpcTarget.Not(recipient, use);
|
|
case AllocationType.List:
|
|
return senderObject.RpcTarget.Not(recipient.ToList(), use);
|
|
case AllocationType.NativeArray:
|
|
var arr = new NativeArray<ulong>(recipient, Allocator.Temp);
|
|
var naTarget = senderObject.RpcTarget.Not(arr, use);
|
|
arr.Dispose();
|
|
return naTarget;
|
|
case AllocationType.NativeList:
|
|
// For some reason on 2020.3, calling list.AsArray() and passing that to the next function
|
|
// causes Allocator.Temp allocations to become invalid somehow. This is not an issue on later
|
|
// versions of Unity.
|
|
var list = new NativeList<ulong>(recipient.Length, Allocator.TempJob);
|
|
foreach (var id in recipient)
|
|
{
|
|
list.Add(id);
|
|
}
|
|
var nlTarget = senderObject.RpcTarget.Not(list, use);
|
|
list.Dispose();
|
|
return nlTarget;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public enum ObjType
|
|
{
|
|
Client,
|
|
Server
|
|
}
|
|
|
|
private NetworkBehaviour m_Obj;
|
|
|
|
protected override void OnTimeTravelServerAndClientsConnected()
|
|
{
|
|
base.OnTimeTravelServerAndClientsConnected();
|
|
|
|
if (m_ObjType == ObjType.Server)
|
|
{
|
|
m_Obj = GetPlayerObject(NetworkManager.ServerClientId, NetworkManager.ServerClientId);
|
|
}
|
|
else
|
|
{
|
|
m_Obj = GetPlayerObject(1, 1);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestRpcTargetUseGroup([Values] AllocationType allocationType)
|
|
{
|
|
var group1 = GetGroup(m_Obj, new[] { 1ul, 2ul }, allocationType, RpcTargetUse.Temp);
|
|
var group2 = GetGroup(m_Obj, new[] { 2ul, 3ul }, allocationType, RpcTargetUse.Temp);
|
|
var group3 = GetGroup(m_Obj, new[] { 1ul, 2ul }, allocationType, RpcTargetUse.Persistent);
|
|
var group4 = GetGroup(m_Obj, new[] { 2ul, 3ul }, allocationType, RpcTargetUse.Persistent);
|
|
|
|
Assert.AreSame(group1, group2);
|
|
Assert.AreNotSame(group1, group3);
|
|
Assert.AreNotSame(group1, group4);
|
|
Assert.AreNotSame(group2, group3);
|
|
Assert.AreNotSame(group2, group4);
|
|
Assert.AreNotSame(group3, group4);
|
|
|
|
Assert.Throws<Exception>(() =>
|
|
{
|
|
group1.Dispose();
|
|
});
|
|
|
|
Assert.Throws<Exception>(() =>
|
|
{
|
|
group2.Dispose();
|
|
});
|
|
|
|
group3.Dispose();
|
|
group4.Dispose();
|
|
}
|
|
|
|
[Test]
|
|
public void TestRpcTargetUseNotGroup([Values] AllocationType allocationType)
|
|
{
|
|
var not1 = GetNot(m_Obj, new[] { 1ul, 2ul }, allocationType, RpcTargetUse.Temp);
|
|
var not2 = GetNot(m_Obj, new[] { 2ul, 3ul }, allocationType, RpcTargetUse.Temp);
|
|
var not3 = GetNot(m_Obj, new[] { 1ul, 2ul }, allocationType, RpcTargetUse.Persistent);
|
|
var not4 = GetNot(m_Obj, new[] { 2ul, 3ul }, allocationType, RpcTargetUse.Persistent);
|
|
|
|
Assert.AreSame(not1, not2);
|
|
Assert.AreNotSame(not1, not3);
|
|
Assert.AreNotSame(not1, not4);
|
|
Assert.AreNotSame(not2, not3);
|
|
Assert.AreNotSame(not2, not4);
|
|
Assert.AreNotSame(not3, not4);
|
|
|
|
Assert.Throws<Exception>(() =>
|
|
{
|
|
not1.Dispose();
|
|
});
|
|
|
|
Assert.Throws<Exception>(() =>
|
|
{
|
|
not2.Dispose();
|
|
});
|
|
|
|
not3.Dispose();
|
|
not4.Dispose();
|
|
}
|
|
|
|
[Test]
|
|
public void TestRpcTargetUseSingle()
|
|
{
|
|
// Not using 1 here because 1 is a special case that returns a LocalSendTarget for the client
|
|
// because the client versin of this test uses m_Obj from client ID 1 (ergo 1 is localhost in this test).
|
|
// So 1 will always be different from 2 and we want to verify the first two are the same.
|
|
var single1 = m_Obj.RpcTarget.Single(2ul, RpcTargetUse.Temp);
|
|
var single2 = m_Obj.RpcTarget.Single(3ul, RpcTargetUse.Temp);
|
|
var single3 = m_Obj.RpcTarget.Single(2ul, RpcTargetUse.Persistent);
|
|
var single4 = m_Obj.RpcTarget.Single(3ul, RpcTargetUse.Persistent);
|
|
Assert.AreSame(single1, single2);
|
|
Assert.AreNotSame(single1, single3);
|
|
Assert.AreNotSame(single1, single4);
|
|
Assert.AreNotSame(single2, single3);
|
|
Assert.AreNotSame(single2, single4);
|
|
Assert.AreNotSame(single3, single4);
|
|
|
|
Assert.Throws<Exception>(() =>
|
|
{
|
|
single1.Dispose();
|
|
});
|
|
|
|
Assert.Throws<Exception>(() =>
|
|
{
|
|
single2.Dispose();
|
|
});
|
|
|
|
single3.Dispose();
|
|
single4.Dispose();
|
|
}
|
|
|
|
[Test]
|
|
public void TestRpcTargetUseNotSingle()
|
|
{
|
|
var singleNot1 = m_Obj.RpcTarget.Not(1ul, RpcTargetUse.Temp);
|
|
var singleNot2 = m_Obj.RpcTarget.Not(2ul, RpcTargetUse.Temp);
|
|
var singleNot3 = m_Obj.RpcTarget.Not(1ul, RpcTargetUse.Persistent);
|
|
var singleNot4 = m_Obj.RpcTarget.Not(2ul, RpcTargetUse.Persistent);
|
|
Assert.AreSame(singleNot1, singleNot2);
|
|
Assert.AreNotSame(singleNot1, singleNot3);
|
|
Assert.AreNotSame(singleNot1, singleNot4);
|
|
Assert.AreNotSame(singleNot2, singleNot3);
|
|
Assert.AreNotSame(singleNot2, singleNot4);
|
|
Assert.AreNotSame(singleNot3, singleNot4);
|
|
|
|
Assert.Throws<Exception>(() =>
|
|
{
|
|
singleNot1.Dispose();
|
|
});
|
|
|
|
Assert.Throws<Exception>(() =>
|
|
{
|
|
singleNot2.Dispose();
|
|
});
|
|
|
|
singleNot3.Dispose();
|
|
singleNot4.Dispose();
|
|
}
|
|
|
|
}
|
|
}
|