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

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.7] - 2022-04-01

### Added

- Added editor only check prior to entering into play mode if the currently open and active scene is in the build list and if not displays a dialog box asking the user if they would like to automatically add it prior to entering into play mode. (#1828)
- Added `UnityTransport` implementation and `com.unity.transport` package dependency (#1823)
- Added `NetworkVariableWritePermission` to `NetworkVariableBase` and implemented `Owner` client writable netvars. (#1762)
- `UnityTransport` settings can now be set programmatically. (#1845)
- `FastBufferWriter` and Reader IsInitialized property. (#1859)

### Changed

- Updated `UnityTransport` dependency on `com.unity.transport` to 1.0.0 (#1849)

### Removed

- Removed `SnapshotSystem` (#1852)
- Removed `com.unity.modules.animation`, `com.unity.modules.physics` and `com.unity.modules.physics2d` dependencies from the package (#1812)
- Removed `com.unity.collections` dependency from the package (#1849)

### Fixed
- Fixed in-scene placed NetworkObjects not being found/ignored after a client disconnects and then reconnects. (#1850)
- Fixed issue where `UnityTransport` send queues were not flushed when calling `DisconnectLocalClient` or `DisconnectRemoteClient`. (#1847)
- Fixed NetworkBehaviour dependency verification check for an existing NetworkObject not searching from root parent transform relative GameObject. (#1841)
- Fixed issue where entries were not being removed from the NetworkSpawnManager.OwnershipToObjectsTable. (#1838)
- Fixed ClientRpcs would always send to all connected clients by default as opposed to only sending to the NetworkObject's Observers list by default. (#1836)
- Fixed clarity for NetworkSceneManager client side notification when it receives a scene hash value that does not exist in its local hash table. (#1828)
- Fixed client throws a key not found exception when it times out using UNet or UTP. (#1821)
- Fixed network variable updates are no longer limited to 32,768 bytes when NetworkConfig.EnsureNetworkVariableLengthSafety is enabled. The limits are now determined by what the transport can send in a message. (#1811)
- Fixed in-scene NetworkObjects get destroyed if a client fails to connect and shuts down the NetworkManager. (#1809)
- Fixed user never being notified in the editor that a NetworkBehaviour requires a NetworkObject to function properly. (#1808)
- Fixed PlayerObjects and dynamically spawned NetworkObjects not being added to the NetworkClient's OwnedObjects (#1801)
- Fixed issue where NetworkManager would continue starting even if the NetworkTransport selected failed. (#1780)
- Fixed issue when spawning new player if an already existing player exists it does not remove IsPlayer from the previous player (#1779)
- Fixed lack of notification that NetworkManager and NetworkObject cannot be added to the same GameObject with in-editor notifications (#1777)
- Fixed parenting warning printing for false positives (#1855)

Tests/Runtime/Transports/DummyTransport.cs

@@ -0,0 +1,52 @@
+using System;
+
+
+namespace Unity.Netcode.RuntimeTests
+{
+    internal class DummyTransport : TestingNetworkTransport
+    {
+        public override ulong ServerClientId { get; } = 0;
+        public override void Send(ulong clientId, ArraySegment<byte> payload, NetworkDelivery networkDelivery)
+        {
+        }
+
+        public override NetworkEvent PollEvent(out ulong clientId, out ArraySegment<byte> payload, out float receiveTime)
+        {
+            clientId = 0;
+            payload = new ArraySegment<byte>();
+            receiveTime = 0;
+            return NetworkEvent.Nothing;
+        }
+
+        public override bool StartClient()
+        {
+            return true;
+        }
+
+        public override bool StartServer()
+        {
+            return true;
+        }
+
+        public override void DisconnectRemoteClient(ulong clientId)
+        {
+        }
+
+        public override void DisconnectLocalClient()
+        {
+        }
+
+        public override ulong GetCurrentRtt(ulong clientId)
+        {
+            return 0;
+        }
+
+        public override void Shutdown()
+        {
+        }
+
+        public override void Initialize(NetworkManager networkManager = null)
+        {
+        }
+    }
+}

Tests/Runtime/Transports/DummyTransport.cs.meta

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

Tests/Runtime/Transports/SIPTransportTests.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Text;
+using NUnit.Framework;
+using UnityEngine;
+using Unity.Netcode.TestHelpers.Runtime;
+
+namespace Unity.Netcode.RuntimeTests
+{
+    public class SIPTransportTests
+    {
+        [Test]
+        public void SendReceiveData()
+        {
+            SIPTransport server = new GameObject("Server").AddComponent<SIPTransport>();
+            SIPTransport client = new GameObject("Client").AddComponent<SIPTransport>();
+
+            server.Initialize();
+            server.StartServer();
+
+            client.Initialize();
+            client.StartClient();
+
+            NetworkEvent serverEvent = server.PollEvent(out ulong clientId, out _, out _);
+            NetworkEvent clientEvent = client.PollEvent(out ulong serverId, out _, out _);
+
+            // Make sure both connected
+            Assert.True(serverEvent == NetworkEvent.Connect);
+            Assert.True(clientEvent == NetworkEvent.Connect);
+
+            // Send data
+            server.Send(clientId, new ArraySegment<byte>(Encoding.ASCII.GetBytes("Hello Client")), NetworkDelivery.ReliableSequenced);
+            client.Send(serverId, new ArraySegment<byte>(Encoding.ASCII.GetBytes("Hello Server")), NetworkDelivery.ReliableSequenced);
+
+            serverEvent = server.PollEvent(out ulong newClientId, out ArraySegment<byte> serverPayload, out _);
+            clientEvent = client.PollEvent(out ulong newServerId, out ArraySegment<byte> clientPayload, out _);
+
+            // Make sure we got data
+            Assert.True(serverEvent == NetworkEvent.Data);
+            Assert.True(clientEvent == NetworkEvent.Data);
+
+            // Make sure the ID is correct
+            Assert.True(newClientId == clientId);
+            Assert.True(newServerId == serverId);
+
+            // Make sure the payload was correct
+            Assert.That(serverPayload, Is.EquivalentTo(Encoding.ASCII.GetBytes("Hello Server")));
+            Assert.That(clientPayload, Is.EquivalentTo(Encoding.ASCII.GetBytes("Hello Client")));
+
+            server.Shutdown();
+            client.Shutdown();
+        }
+    }
+}

Tests/Runtime/Transports/SIPTransportTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: e3fe3777ca6a4f4392d6281d148d0d3c
+timeCreated: 1620385694

Tests/Runtime/Transports/UnityTransportConnectionTests.cs

@@ -0,0 +1,383 @@
+using NUnit.Framework;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using Unity.Netcode.Transports.UTP;
+using UnityEngine;
+using UnityEngine.TestTools;
+using static Unity.Netcode.RuntimeTests.UnityTransportTestHelpers;
+
+namespace Unity.Netcode.RuntimeTests
+{
+    public class UnityTransportConnectionTests
+    {
+        // For tests using multiple clients.
+        private const int k_NumClients = 5;
+        private UnityTransport m_Server;
+        private UnityTransport[] m_Clients = new UnityTransport[k_NumClients];
+        private List<TransportEvent> m_ServerEvents;
+        private List<TransportEvent>[] m_ClientsEvents = new List<TransportEvent>[k_NumClients];
+
+        [UnityTearDown]
+        public IEnumerator Cleanup()
+        {
+            if (m_Server)
+            {
+                m_Server.Shutdown();
+                UnityEngine.Object.DestroyImmediate(m_Server);
+            }
+
+            foreach (var transport in m_Clients)
+            {
+                if (transport)
+                {
+                    transport.Shutdown();
+                    UnityEngine.Object.DestroyImmediate(transport);
+                }
+            }
+
+            foreach (var transportEvents in m_ClientsEvents)
+            {
+                transportEvents?.Clear();
+            }
+
+            yield return null;
+        }
+
+        // Check connection with a single client.
+        [UnityTest]
+        public IEnumerator ConnectSingleClient()
+        {
+            InitializeTransport(out m_Server, out m_ServerEvents);
+            InitializeTransport(out m_Clients[0], out m_ClientsEvents[0]);
+
+            m_Server.StartServer();
+            m_Clients[0].StartClient();
+
+            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_ClientsEvents[0]);
+
+            // Check we've received Connect event on server too.
+            Assert.AreEqual(1, m_ServerEvents.Count);
+            Assert.AreEqual(NetworkEvent.Connect, m_ServerEvents[0].Type);
+
+            yield return null;
+        }
+
+        // Check connection with multiple clients.
+        [UnityTest]
+        public IEnumerator ConnectMultipleClients()
+        {
+            InitializeTransport(out m_Server, out m_ServerEvents);
+            m_Server.StartServer();
+
+            for (int i = 0; i < k_NumClients; i++)
+            {
+                InitializeTransport(out m_Clients[i], out m_ClientsEvents[i]);
+                m_Clients[i].StartClient();
+            }
+
+            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_ClientsEvents[k_NumClients - 1]);
+
+            // Check that every client received a Connect event.
+            Assert.True(m_ClientsEvents.All(evs => evs.Count == 1));
+            Assert.True(m_ClientsEvents.All(evs => evs[0].Type == NetworkEvent.Connect));
+
+            // Check we've received Connect events on server too.
+            Assert.AreEqual(k_NumClients, m_ServerEvents.Count);
+            Assert.True(m_ServerEvents.All(ev => ev.Type == NetworkEvent.Connect));
+
+            yield return null;
+        }
+
+        // Check server disconnection with a single client.
+        [UnityTest]
+        public IEnumerator ServerDisconnectSingleClient()
+        {
+            InitializeTransport(out m_Server, out m_ServerEvents);
+            InitializeTransport(out m_Clients[0], out m_ClientsEvents[0]);
+
+            m_Server.StartServer();
+            m_Clients[0].StartClient();
+
+            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_ClientsEvents[0]);
+
+            m_Server.DisconnectRemoteClient(m_ServerEvents[0].ClientID);
+
+            yield return WaitForNetworkEvent(NetworkEvent.Disconnect, m_ClientsEvents[0]);
+
+            yield return null;
+        }
+
+        // Check server disconnection with multiple clients.
+        [UnityTest]
+        public IEnumerator ServerDisconnectMultipleClients()
+        {
+            InitializeTransport(out m_Server, out m_ServerEvents);
+            m_Server.StartServer();
+
+            for (int i = 0; i < k_NumClients; i++)
+            {
+                InitializeTransport(out m_Clients[i], out m_ClientsEvents[i]);
+                m_Clients[i].StartClient();
+            }
+
+            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_ClientsEvents[k_NumClients - 1]);
+
+            // Disconnect a single client.
+            m_Server.DisconnectRemoteClient(m_ServerEvents[0].ClientID);
+
+            // Need to manually wait since we don't know which client will get the Disconnect.
+            yield return new WaitForSeconds(MaxNetworkEventWaitTime);
+
+            // Check that we received a Disconnect event on only one client.
+            Assert.AreEqual(1, m_ClientsEvents.Count(evs => evs.Count == 2 && evs[1].Type == NetworkEvent.Disconnect));
+
+            // Disconnect all the other clients.
+            for (int i = 1; i < k_NumClients; i++)
+            {
+                m_Server.DisconnectRemoteClient(m_ServerEvents[i].ClientID);
+            }
+
+            // Need to manually wait since we don't know which client got the Disconnect.
+            yield return new WaitForSeconds(MaxNetworkEventWaitTime);
+
+            // Check that all clients got a Disconnect event.
+            Assert.True(m_ClientsEvents.All(evs => evs.Count == 2));
+            Assert.True(m_ClientsEvents.All(evs => evs[1].Type == NetworkEvent.Disconnect));
+
+            yield return null;
+        }
+
+        // Check client disconnection from a single client.
+        [UnityTest]
+        public IEnumerator ClientDisconnectSingleClient()
+        {
+            InitializeTransport(out m_Server, out m_ServerEvents);
+            InitializeTransport(out m_Clients[0], out m_ClientsEvents[0]);
+
+            m_Server.StartServer();
+            m_Clients[0].StartClient();
+
+            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_ClientsEvents[0]);
+
+            m_Clients[0].DisconnectLocalClient();
+
+            yield return WaitForNetworkEvent(NetworkEvent.Disconnect, m_ServerEvents);
+        }
+
+        // Check client disconnection with multiple clients.
+        [UnityTest]
+        public IEnumerator ClientDisconnectMultipleClients()
+        {
+            InitializeTransport(out m_Server, out m_ServerEvents);
+            m_Server.StartServer();
+
+            for (int i = 0; i < k_NumClients; i++)
+            {
+                InitializeTransport(out m_Clients[i], out m_ClientsEvents[i]);
+                m_Clients[i].StartClient();
+            }
+
+            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_ClientsEvents[k_NumClients - 1]);
+
+            // Disconnect a single client.
+            m_Clients[0].DisconnectLocalClient();
+
+            yield return WaitForNetworkEvent(NetworkEvent.Disconnect, m_ServerEvents);
+
+            // Disconnect all the other clients.
+            for (int i = 1; i < k_NumClients; i++)
+            {
+                m_Clients[i].DisconnectLocalClient();
+            }
+
+            yield return WaitForNetworkEvent(NetworkEvent.Disconnect, m_ServerEvents);
+
+            // Check that we got the correct number of Disconnect events on the server.
+            Assert.AreEqual(k_NumClients * 2, m_ServerEvents.Count);
+            Assert.AreEqual(k_NumClients, m_ServerEvents.Count(e => e.Type == NetworkEvent.Disconnect));
+
+            yield return null;
+        }
+
+        // Check that server re-disconnects are no-ops.
+        [UnityTest]
+        public IEnumerator RepeatedServerDisconnectsNoop()
+        {
+            InitializeTransport(out m_Server, out m_ServerEvents);
+            InitializeTransport(out m_Clients[0], out m_ClientsEvents[0]);
+
+            m_Server.StartServer();
+            m_Clients[0].StartClient();
+
+            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_ClientsEvents[0]);
+
+            m_Server.DisconnectRemoteClient(m_ServerEvents[0].ClientID);
+
+            yield return WaitForNetworkEvent(NetworkEvent.Disconnect, m_ClientsEvents[0]);
+
+            var previousServerEventsCount = m_ServerEvents.Count;
+            var previousClientEventsCount = m_ClientsEvents[0].Count;
+
+            m_Server.DisconnectRemoteClient(m_ServerEvents[0].ClientID);
+
+            // Need to wait manually since no event should be generated.
+            yield return new WaitForSeconds(MaxNetworkEventWaitTime);
+
+            // Check we haven't received anything else on the client or server.
+            Assert.AreEqual(m_ServerEvents.Count, previousServerEventsCount);
+            Assert.AreEqual(m_ClientsEvents[0].Count, previousClientEventsCount);
+
+            yield return null;
+        }
+
+        // Check that client re-disconnects are no-ops.
+        [UnityTest]
+        public IEnumerator RepeatedClientDisconnectsNoop()
+        {
+            InitializeTransport(out m_Server, out m_ServerEvents);
+            InitializeTransport(out m_Clients[0], out m_ClientsEvents[0]);
+
+            m_Server.StartServer();
+            m_Clients[0].StartClient();
+
+            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_ClientsEvents[0]);
+
+            m_Clients[0].DisconnectLocalClient();
+
+            yield return WaitForNetworkEvent(NetworkEvent.Disconnect, m_ServerEvents);
+
+            var previousServerEventsCount = m_ServerEvents.Count;
+            var previousClientEventsCount = m_ClientsEvents[0].Count;
+
+            m_Clients[0].DisconnectLocalClient();
+
+            // Need to wait manually since no event should be generated.
+            yield return new WaitForSeconds(MaxNetworkEventWaitTime);
+
+            // Check we haven't received anything else on the client or server.
+            Assert.AreEqual(m_ServerEvents.Count, previousServerEventsCount);
+            Assert.AreEqual(m_ClientsEvents[0].Count, previousClientEventsCount);
+
+            yield return null;
+        }
+
+        // Check connection with different server/listen addresses.
+        [UnityTest]
+        public IEnumerator DifferentServerAndListenAddresses()
+        {
+            InitializeTransport(out m_Server, out m_ServerEvents);
+            InitializeTransport(out m_Clients[0], out m_ClientsEvents[0]);
+
+            m_Server.SetConnectionData("127.0.0.1", 10042, "0.0.0.0");
+            m_Clients[0].SetConnectionData("127.0.0.1", 10042);
+
+            m_Server.StartServer();
+            m_Clients[0].StartClient();
+
+            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_ClientsEvents[0]);
+
+            // Check we've received Connect event on server too.
+            Assert.AreEqual(1, m_ServerEvents.Count);
+            Assert.AreEqual(NetworkEvent.Connect, m_ServerEvents[0].Type);
+
+            yield return null;
+        }
+
+        // Check server disconnection with data in send queue.
+        [UnityTest]
+        public IEnumerator ServerDisconnectWithDataInQueue()
+        {
+            InitializeTransport(out m_Server, out m_ServerEvents);
+            InitializeTransport(out m_Clients[0], out m_ClientsEvents[0]);
+
+            m_Server.StartServer();
+            m_Clients[0].StartClient();
+
+            // Wait for the client to connect before we disconnect the client
+            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_ClientsEvents[0]);
+
+            var data = new ArraySegment<byte>(new byte[] { 42 });
+            m_Server.Send(m_ServerEvents[0].ClientID, data, NetworkDelivery.Unreliable);
+
+            m_Server.DisconnectRemoteClient(m_ServerEvents[0].ClientID);
+
+            yield return WaitForNetworkEvent(NetworkEvent.Data, m_ClientsEvents[0]);
+
+            if (m_ClientsEvents[0].Count >= 3)
+            {
+                Assert.AreEqual(NetworkEvent.Disconnect, m_ClientsEvents[0][2].Type);
+            }
+            else
+            {
+                yield return WaitForNetworkEvent(NetworkEvent.Disconnect, m_ClientsEvents[0]);
+            }
+        }
+
+        // Check client disconnection with data in send queue.
+        [UnityTest]
+        public IEnumerator ClientDisconnectWithDataInQueue()
+        {
+            InitializeTransport(out m_Server, out m_ServerEvents);
+            InitializeTransport(out m_Clients[0], out m_ClientsEvents[0]);
+
+            m_Server.StartServer();
+            m_Clients[0].StartClient();
+
+            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_ServerEvents);
+
+            var data = new ArraySegment<byte>(new byte[] { 42 });
+            m_Clients[0].Send(m_Clients[0].ServerClientId, data, NetworkDelivery.Unreliable);
+
+            m_Clients[0].DisconnectLocalClient();
+
+            yield return WaitForNetworkEvent(NetworkEvent.Data, m_ServerEvents);
+
+            if (m_ServerEvents.Count >= 3)
+            {
+                Assert.AreEqual(NetworkEvent.Disconnect, m_ServerEvents[2].Type);
+            }
+            else
+            {
+                yield return WaitForNetworkEvent(NetworkEvent.Disconnect, m_ServerEvents);
+            }
+        }
+
+        // Check that a server can disconnect a client after another client has disconnected.
+        [UnityTest]
+        public IEnumerator ServerDisconnectAfterClientDisconnect()
+        {
+            InitializeTransport(out m_Server, out m_ServerEvents);
+            InitializeTransport(out m_Clients[0], out m_ClientsEvents[0]);
+            InitializeTransport(out m_Clients[1], out m_ClientsEvents[1]);
+
+            m_Server.StartServer();
+
+            m_Clients[0].StartClient();
+
+            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_ClientsEvents[0]);
+
+            m_Clients[1].StartClient();
+
+            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_ClientsEvents[1]);
+
+            m_Clients[0].DisconnectLocalClient();
+
+            yield return WaitForNetworkEvent(NetworkEvent.Disconnect, m_ServerEvents);
+
+            // Pick the client ID of the still connected client.
+            var clientId = m_ServerEvents[0].ClientID;
+            if (m_ServerEvents[2].ClientID == clientId)
+            {
+                clientId = m_ServerEvents[1].ClientID;
+            }
+
+            m_Server.DisconnectRemoteClient(clientId);
+
+            yield return WaitForNetworkEvent(NetworkEvent.Disconnect, m_ClientsEvents[1]);
+
+            yield return null;
+        }
+    }
+}

Tests/Runtime/Transports/UnityTransportConnectionTests.cs.meta

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

Tests/Runtime/Transports/UnityTransportDriverClient.cs

@@ -0,0 +1,94 @@
+using NUnit.Framework;
+using System.Collections;
+using Unity.Networking.Transport;
+using Unity.Networking.Transport.Utilities;
+using Unity.Netcode.Transports.UTP;
+using UnityEngine;
+
+using UTPNetworkEvent = Unity.Networking.Transport.NetworkEvent;
+using static Unity.Netcode.RuntimeTests.UnityTransportTestHelpers;
+
+namespace Unity.Netcode.RuntimeTests
+{
+    // Thin wrapper around a UTP NetworkDriver that can act as a client to a UnityTransport server.
+    // In particular that means the pipelines are set up the same way as in UnityTransport.
+    //
+    // The only reason it's defined as a MonoBehaviour is that OnDestroy is the only reliable way
+    // to get the driver's Dispose method called from a UnityTest. Making it disposable would be
+    // the preferred solution, but that doesn't always mesh well with coroutines.
+    public class UnityTransportDriverClient : MonoBehaviour
+    {
+        private NetworkDriver m_Driver;
+        public NetworkDriver Driver => m_Driver;
+
+        private NetworkConnection m_Connection;
+
+        private NetworkPipeline m_UnreliableSequencedPipeline;
+        private NetworkPipeline m_ReliableSequencedPipeline;
+        private NetworkPipeline m_ReliableSequencedFragmentedPipeline;
+
+        public NetworkPipeline UnreliableSequencedPipeline => m_UnreliableSequencedPipeline;
+        public NetworkPipeline ReliableSequencedPipeline => m_ReliableSequencedPipeline;
+        public NetworkPipeline ReliableSequencedFragmentedPipeline => m_ReliableSequencedFragmentedPipeline;
+
+        private NetworkPipeline m_LastEventPipeline;
+        public NetworkPipeline LastEventPipeline => m_LastEventPipeline;
+
+        private void Awake()
+        {
+            var maxCap = UnityTransport.InitialMaxPayloadSize + 128;
+
+            var settings = new NetworkSettings();
+            settings.WithFragmentationStageParameters(payloadCapacity: maxCap);
+
+            var fragParams = new FragmentationUtility.Parameters() { PayloadCapacity = maxCap };
+
+            m_Driver = NetworkDriver.Create(settings);
+
+            m_UnreliableSequencedPipeline = m_Driver.CreatePipeline(typeof(UnreliableSequencedPipelineStage));
+            m_ReliableSequencedPipeline = m_Driver.CreatePipeline(typeof(ReliableSequencedPipelineStage));
+            m_ReliableSequencedFragmentedPipeline = m_Driver.CreatePipeline(typeof(FragmentationPipelineStage), typeof(ReliableSequencedPipelineStage));
+        }
+
+        private void Update()
+        {
+            m_Driver.ScheduleUpdate().Complete();
+        }
+
+        private void OnDestroy()
+        {
+            if (m_Driver.IsCreated)
+            {
+                m_Driver.Dispose();
+            }
+        }
+
+        public void Connect()
+        {
+            var endpoint = NetworkEndPoint.LoopbackIpv4;
+            endpoint.Port = 7777;
+
+            m_Connection = m_Driver.Connect(endpoint);
+        }
+
+        // Wait for the given event to be generated by the client's driver.
+        public IEnumerator WaitForNetworkEvent(UTPNetworkEvent.Type type)
+        {
+            float startTime = Time.realtimeSinceStartup;
+
+            while (Time.realtimeSinceStartup - startTime < MaxNetworkEventWaitTime)
+            {
+                UTPNetworkEvent.Type eventType = m_Driver.PopEvent(out _, out _, out m_LastEventPipeline);
+                if (eventType != UTPNetworkEvent.Type.Empty)
+                {
+                    Assert.AreEqual(type, eventType);
+                    yield break;
+                }
+
+                yield return null;
+            }
+
+            Assert.Fail("Timed out while waiting for network event.");
+        }
+    }
+}

Tests/Runtime/Transports/UnityTransportDriverClient.cs.meta

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

Tests/Runtime/Transports/UnityTransportTestHelpers.cs

@@ -0,0 +1,85 @@
+using NUnit.Framework;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Unity.Netcode.Transports.UTP;
+using UnityEngine;
+
+namespace Unity.Netcode.RuntimeTests
+{
+    public static class UnityTransportTestHelpers
+    {
+        // Half a second might seem like a very long time to wait for a network event, but in CI
+        // many of the machines are underpowered (e.g. old Android devices or Macs) and there are
+        // sometimes very high lag spikes. PS4 and Switch are particularly sensitive in this regard
+        // so we allow even more time for these platforms.
+        public const float MaxNetworkEventWaitTime = 0.5f;
+
+        // Wait for an event to appear in the given event list (must be the very next event).
+        public static IEnumerator WaitForNetworkEvent(NetworkEvent type, List<TransportEvent> events, float timeout = MaxNetworkEventWaitTime)
+        {
+            int initialCount = events.Count;
+            float startTime = Time.realtimeSinceStartup;
+
+            while (Time.realtimeSinceStartup - startTime < timeout)
+            {
+                if (events.Count > initialCount)
+                {
+                    Assert.AreEqual(type, events[initialCount].Type);
+                    yield break;
+                }
+
+                yield return new WaitForSeconds(0.01f);
+            }
+
+            Assert.Fail("Timed out while waiting for network event.");
+        }
+
+        // Common code to initialize a UnityTransport that logs its events.
+        public static void InitializeTransport(out UnityTransport transport, out List<TransportEvent> events, int maxPayloadSize = UnityTransport.InitialMaxPayloadSize)
+        {
+            var logger = new TransportEventLogger();
+            events = logger.Events;
+
+            transport = new GameObject().AddComponent<UnityTransport>();
+            transport.OnTransportEvent += logger.HandleEvent;
+            transport.SetMaxPayloadSize(maxPayloadSize);
+            transport.Initialize();
+        }
+
+        // Information about an event generated by a transport (basically just the parameters that
+        // are normally passed along to a TransportEventDelegate).
+        public struct TransportEvent
+        {
+            public NetworkEvent Type;
+            public ulong ClientID;
+            public ArraySegment<byte> Data;
+            public float ReceiveTime;
+        }
+        // Utility class that logs events generated by a UnityTransport. Set it up by adding the
+        // HandleEvent method as an OnTransportEvent delegate of the transport. The list of events
+        // (in order in which they were generated) can be accessed through the Events property.
+        public class TransportEventLogger
+        {
+            private readonly List<TransportEvent> m_Events = new List<TransportEvent>();
+            public List<TransportEvent> Events => m_Events;
+            public void HandleEvent(NetworkEvent type, ulong clientID, ArraySegment<byte> data, float receiveTime)
+            {
+                // Copy the data since the backing array will be reused for future messages.
+                if (data != default(ArraySegment<byte>))
+                {
+                    var dataCopy = new byte[data.Count];
+                    Array.Copy(data.Array, data.Offset, dataCopy, 0, data.Count);
+                    data = new ArraySegment<byte>(dataCopy);
+                }
+                m_Events.Add(new TransportEvent
+                {
+                    Type = type,
+                    ClientID = clientID,
+                    Data = data,
+                    ReceiveTime = receiveTime
+                });
+            }
+        }
+    }
+}

Tests/Runtime/Transports/UnityTransportTestHelpers.cs.meta

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

Tests/Runtime/Transports/UnityTransportTests.cs

@@ -0,0 +1,461 @@
+using NUnit.Framework;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Unity.Netcode.Transports.UTP;
+using UnityEngine;
+using UnityEngine.TestTools;
+using static Unity.Netcode.RuntimeTests.UnityTransportTestHelpers;
+
+namespace Unity.Netcode.RuntimeTests
+{
+    public class UnityTransportTests
+    {
+        // No need to test all reliable delivery methods since they all map to the same pipeline.
+        private static readonly NetworkDelivery[] k_DeliveryParameters =
+        {
+            NetworkDelivery.Unreliable,
+            NetworkDelivery.UnreliableSequenced,
+            NetworkDelivery.Reliable
+        };
+
+        private UnityTransport m_Server, m_Client1, m_Client2;
+        private List<TransportEvent> m_ServerEvents, m_Client1Events, m_Client2Events;
+
+        [UnityTearDown]
+        public IEnumerator Cleanup()
+        {
+            if (m_Server)
+            {
+                m_Server.Shutdown();
+
+                // Need to destroy the GameObject (all assigned components will get destroyed too)
+                UnityEngine.Object.DestroyImmediate(m_Server.gameObject);
+            }
+
+            if (m_Client1)
+            {
+                m_Client1.Shutdown();
+
+                // Need to destroy the GameObject (all assigned components will get destroyed too)
+                UnityEngine.Object.DestroyImmediate(m_Client1.gameObject);
+            }
+
+            if (m_Client2)
+            {
+                m_Client2.Shutdown();
+
+                // Need to destroy the GameObject (all assigned components will get destroyed too)
+                UnityEngine.Object.DestroyImmediate(m_Client2.gameObject);
+            }
+
+            m_ServerEvents?.Clear();
+            m_Client1Events?.Clear();
+            m_Client2Events?.Clear();
+
+            yield return null;
+        }
+
+        // Check if can make a simple data exchange.
+        [UnityTest]
+        public IEnumerator PingPong([ValueSource("k_DeliveryParameters")] NetworkDelivery delivery)
+        {
+            InitializeTransport(out m_Server, out m_ServerEvents);
+            InitializeTransport(out m_Client1, out m_Client1Events);
+
+            m_Server.StartServer();
+            m_Client1.StartClient();
+
+            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_Client1Events);
+
+            var ping = new ArraySegment<byte>(Encoding.ASCII.GetBytes("ping"));
+            m_Client1.Send(m_Client1.ServerClientId, ping, delivery);
+
+            yield return WaitForNetworkEvent(NetworkEvent.Data, m_ServerEvents);
+
+            Assert.That(m_ServerEvents[1].Data, Is.EquivalentTo(Encoding.ASCII.GetBytes("ping")));
+
+            var pong = new ArraySegment<byte>(Encoding.ASCII.GetBytes("pong"));
+            m_Server.Send(m_ServerEvents[0].ClientID, pong, delivery);
+
+            yield return WaitForNetworkEvent(NetworkEvent.Data, m_Client1Events);
+
+            Assert.That(m_Client1Events[1].Data, Is.EquivalentTo(Encoding.ASCII.GetBytes("pong")));
+
+            yield return null;
+        }
+
+        // Check if can make a simple data exchange (both ways at a time).
+        [UnityTest]
+        public IEnumerator PingPongSimultaneous([ValueSource("k_DeliveryParameters")] NetworkDelivery delivery)
+        {
+            InitializeTransport(out m_Server, out m_ServerEvents);
+            InitializeTransport(out m_Client1, out m_Client1Events);
+
+            m_Server.StartServer();
+            m_Client1.StartClient();
+
+            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_Client1Events);
+
+            var ping = new ArraySegment<byte>(Encoding.ASCII.GetBytes("ping"));
+            m_Server.Send(m_ServerEvents[0].ClientID, ping, delivery);
+            m_Client1.Send(m_Client1.ServerClientId, ping, delivery);
+
+            // Once one event is in the other should be too.
+            yield return WaitForNetworkEvent(NetworkEvent.Data, m_ServerEvents);
+
+            Assert.That(m_ServerEvents[1].Data, Is.EquivalentTo(Encoding.ASCII.GetBytes("ping")));
+            Assert.That(m_Client1Events[1].Data, Is.EquivalentTo(Encoding.ASCII.GetBytes("ping")));
+
+            var pong = new ArraySegment<byte>(Encoding.ASCII.GetBytes("pong"));
+            m_Server.Send(m_ServerEvents[0].ClientID, pong, delivery);
+            m_Client1.Send(m_Client1.ServerClientId, pong, delivery);
+
+            // Once one event is in the other should be too.
+            yield return WaitForNetworkEvent(NetworkEvent.Data, m_ServerEvents);
+
+            Assert.That(m_ServerEvents[2].Data, Is.EquivalentTo(Encoding.ASCII.GetBytes("pong")));
+            Assert.That(m_Client1Events[2].Data, Is.EquivalentTo(Encoding.ASCII.GetBytes("pong")));
+
+            yield return null;
+        }
+
+        // Test is ignored on Switch, PS4, and PS5 because on these platforms the OS buffers for
+        // loopback traffic are too small for the amount of data sent in a single update here.
+        [UnityTest]
+        [UnityPlatform(exclude = new[] { RuntimePlatform.Switch, RuntimePlatform.PS4, RuntimePlatform.PS5 })]
+        public IEnumerator SendMaximumPayloadSize([ValueSource("k_DeliveryParameters")] NetworkDelivery delivery)
+        {
+            // We want something that's over the old limit of ~44KB for reliable payloads.
+            var payloadSize = 64 * 1024;
+
+            InitializeTransport(out m_Server, out m_ServerEvents, payloadSize);
+            InitializeTransport(out m_Client1, out m_Client1Events, payloadSize);
+
+            m_Server.StartServer();
+            m_Client1.StartClient();
+
+            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_Client1Events);
+
+            var payloadData = new byte[payloadSize];
+            for (int i = 0; i < payloadData.Length; i++)
+            {
+                payloadData[i] = (byte)i;
+            }
+
+            var payload = new ArraySegment<byte>(payloadData);
+            m_Client1.Send(m_Client1.ServerClientId, payload, delivery);
+
+            yield return WaitForNetworkEvent(NetworkEvent.Data, m_ServerEvents, MaxNetworkEventWaitTime * 4);
+
+            Assert.AreEqual(payloadSize, m_ServerEvents[1].Data.Count);
+
+            var receivedArray = m_ServerEvents[1].Data.Array;
+            var receivedArrayOffset = m_ServerEvents[1].Data.Offset;
+            for (int i = 0; i < payloadSize; i++)
+            {
+                Assert.AreEqual(payloadData[i], receivedArray[receivedArrayOffset + i]);
+            }
+
+            yield return null;
+        }
+
+        // Check making multiple sends to a client in a single frame.
+        [UnityTest]
+        public IEnumerator MultipleSendsSingleFrame([ValueSource("k_DeliveryParameters")] NetworkDelivery delivery)
+        {
+            InitializeTransport(out m_Server, out m_ServerEvents);
+            InitializeTransport(out m_Client1, out m_Client1Events);
+
+            m_Server.StartServer();
+            m_Client1.StartClient();
+
+            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_Client1Events);
+
+            var data1 = new ArraySegment<byte>(new byte[] { 11 });
+            m_Client1.Send(m_Client1.ServerClientId, data1, delivery);
+
+            var data2 = new ArraySegment<byte>(new byte[] { 22 });
+            m_Client1.Send(m_Client1.ServerClientId, data2, delivery);
+
+            yield return WaitForNetworkEvent(NetworkEvent.Data, m_ServerEvents);
+
+            Assert.AreEqual(3, m_ServerEvents.Count);
+            Assert.AreEqual(NetworkEvent.Data, m_ServerEvents[2].Type);
+
+            Assert.AreEqual(11, m_ServerEvents[1].Data.First());
+            Assert.AreEqual(22, m_ServerEvents[2].Data.First());
+
+            yield return null;
+        }
+
+        // Check sending data to multiple clients.
+        [UnityTest]
+        public IEnumerator SendMultipleClients([ValueSource("k_DeliveryParameters")] NetworkDelivery delivery)
+        {
+            InitializeTransport(out m_Server, out m_ServerEvents);
+            InitializeTransport(out m_Client1, out m_Client1Events);
+            InitializeTransport(out m_Client2, out m_Client2Events);
+
+            m_Server.StartServer();
+            m_Client1.StartClient();
+            m_Client2.StartClient();
+
+            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_Client1Events);
+            if (m_Client2Events.Count == 0)
+            {
+                yield return WaitForNetworkEvent(NetworkEvent.Connect, m_Client2Events);
+            }
+
+            // Ensure we got both Connect events.
+            Assert.AreEqual(2, m_ServerEvents.Count);
+
+            var data1 = new ArraySegment<byte>(new byte[] { 11 });
+            m_Server.Send(m_ServerEvents[0].ClientID, data1, delivery);
+
+            var data2 = new ArraySegment<byte>(new byte[] { 22 });
+            m_Server.Send(m_ServerEvents[1].ClientID, data2, delivery);
+
+            // Once one has received its data, the other should have too.
+            yield return WaitForNetworkEvent(NetworkEvent.Data, m_Client1Events);
+
+            // Do make sure the other client got its Data event.
+            Assert.AreEqual(2, m_Client2Events.Count);
+            Assert.AreEqual(NetworkEvent.Data, m_Client2Events[1].Type);
+
+            byte c1Data = m_Client1Events[1].Data.First();
+            byte c2Data = m_Client2Events[1].Data.First();
+            Assert.That((c1Data == 11 && c2Data == 22) || (c1Data == 22 && c2Data == 11));
+
+            yield return null;
+        }
+
+        // Check receiving data from multiple clients.
+        [UnityTest]
+        public IEnumerator ReceiveMultipleClients([ValueSource("k_DeliveryParameters")] NetworkDelivery delivery)
+        {
+            InitializeTransport(out m_Server, out m_ServerEvents);
+            InitializeTransport(out m_Client1, out m_Client1Events);
+            InitializeTransport(out m_Client2, out m_Client2Events);
+
+            m_Server.StartServer();
+            m_Client1.StartClient();
+            m_Client2.StartClient();
+
+            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_Client1Events);
+            if (m_Client2Events.Count == 0)
+            {
+                yield return WaitForNetworkEvent(NetworkEvent.Connect, m_Client2Events);
+            }
+
+            var data1 = new ArraySegment<byte>(new byte[] { 11 });
+            m_Client1.Send(m_Client1.ServerClientId, data1, delivery);
+
+            var data2 = new ArraySegment<byte>(new byte[] { 22 });
+            m_Client2.Send(m_Client2.ServerClientId, data2, delivery);
+
+            yield return WaitForNetworkEvent(NetworkEvent.Data, m_ServerEvents);
+
+            // Make sure we got both data messages.
+            Assert.AreEqual(4, m_ServerEvents.Count);
+            Assert.AreEqual(NetworkEvent.Data, m_ServerEvents[3].Type);
+
+            byte sData1 = m_ServerEvents[2].Data.First();
+            byte sData2 = m_ServerEvents[3].Data.First();
+            Assert.That((sData1 == 11 && sData2 == 22) || (sData1 == 22 && sData2 == 11));
+
+            yield return null;
+        }
+
+        // Check that we get disconnected when overflowing the reliable send queue.
+        [UnityTest]
+        public IEnumerator DisconnectOnReliableSendQueueOverflow()
+        {
+            InitializeTransport(out m_Server, out m_ServerEvents);
+            InitializeTransport(out m_Client1, out m_Client1Events);
+
+            m_Server.StartServer();
+            m_Client1.StartClient();
+
+            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_Client1Events);
+
+            m_Server.Shutdown();
+
+            var numSends = (UnityTransport.InitialMaxSendQueueSize / 1024);
+
+            for (int i = 0; i < numSends; i++)
+            {
+                var payload = new ArraySegment<byte>(new byte[1024]);
+                m_Client1.Send(m_Client1.ServerClientId, payload, NetworkDelivery.Reliable);
+            }
+
+            LogAssert.Expect(LogType.Error, "Couldn't add payload of size 1024 to reliable send queue. " +
+                $"Closing connection {m_Client1.ServerClientId} as reliability guarantees can't be maintained. " +
+                $"Perhaps 'Max Send Queue Size' ({UnityTransport.InitialMaxSendQueueSize}) is too small for workload.");
+
+            Assert.AreEqual(2, m_Client1Events.Count);
+            Assert.AreEqual(NetworkEvent.Disconnect, m_Client1Events[1].Type);
+
+            yield return null;
+        }
+
+        // Check that it's fine to overflow the unreliable send queue (traffic is flushed on overflow).
+        // Test is ignored on Switch, PS4, and PS5 because on these platforms the OS buffers for
+        // loopback traffic are too small for the amount of data sent in a single update here.
+        [UnityTest]
+        [UnityPlatform(exclude = new[] { RuntimePlatform.Switch, RuntimePlatform.PS4, RuntimePlatform.PS5 })]
+        public IEnumerator SendCompletesOnUnreliableSendQueueOverflow()
+        {
+            InitializeTransport(out m_Server, out m_ServerEvents);
+            InitializeTransport(out m_Client1, out m_Client1Events);
+
+            m_Server.StartServer();
+            m_Client1.StartClient();
+
+            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_Client1Events);
+
+            var numSends = (UnityTransport.InitialMaxSendQueueSize / 1024) + 1;
+
+            for (int i = 0; i < numSends; i++)
+            {
+                var payload = new ArraySegment<byte>(new byte[1024]);
+                m_Client1.Send(m_Client1.ServerClientId, payload, NetworkDelivery.Unreliable);
+            }
+
+            // Manually wait. This ends up generating quite a bit of packets and it might take a
+            // while for everything to make it to the server.
+            yield return new WaitForSeconds(numSends * 0.02f);
+
+            // Extra event is the connect event.
+            Assert.AreEqual(numSends + 1, m_ServerEvents.Count);
+
+            for (int i = 1; i <= numSends; i++)
+            {
+                Assert.AreEqual(NetworkEvent.Data, m_ServerEvents[i].Type);
+                Assert.AreEqual(1024, m_ServerEvents[i].Data.Count);
+            }
+
+            yield return null;
+        }
+
+        // Check that simulator parameters are effective. We only check with the drop rate, because
+        // that's easy to check and we only really want to make sure the simulator parameters are
+        // configured properly (the simulator pipeline stage is already well-tested in UTP).
+        [UnityTest]
+        [UnityPlatform(include = new[] { RuntimePlatform.OSXEditor, RuntimePlatform.WindowsEditor, RuntimePlatform.LinuxEditor })]
+        public IEnumerator SimulatorParametersAreEffective()
+        {
+            InitializeTransport(out m_Server, out m_ServerEvents);
+            InitializeTransport(out m_Client1, out m_Client1Events);
+
+            m_Server.SetDebugSimulatorParameters(0, 0, 100);
+
+            m_Server.StartServer();
+            m_Client1.StartClient();
+
+            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_Client1Events);
+
+            var data = new ArraySegment<byte>(new byte[] { 42 });
+            m_Client1.Send(m_Client1.ServerClientId, data, NetworkDelivery.Reliable);
+
+            yield return new WaitForSeconds(MaxNetworkEventWaitTime);
+
+            Assert.AreEqual(1, m_ServerEvents.Count);
+
+            yield return null;
+        }
+
+        // Check that RTT is reported correctly.
+        [UnityTest]
+        [UnityPlatform(include = new[] { RuntimePlatform.OSXEditor, RuntimePlatform.WindowsEditor, RuntimePlatform.LinuxEditor })]
+        public IEnumerator CurrentRttReportedCorrectly()
+        {
+            const int simulatedRtt = 25;
+
+            InitializeTransport(out m_Server, out m_ServerEvents);
+            InitializeTransport(out m_Client1, out m_Client1Events);
+
+            m_Server.SetDebugSimulatorParameters(simulatedRtt, 0, 0);
+
+            m_Server.StartServer();
+            m_Client1.StartClient();
+
+            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_Client1Events);
+
+            var data = new ArraySegment<byte>(new byte[] { 42 });
+            m_Client1.Send(m_Client1.ServerClientId, data, NetworkDelivery.Reliable);
+
+            yield return WaitForNetworkEvent(NetworkEvent.Data, m_ServerEvents,
+                timeout: MaxNetworkEventWaitTime + (2 * simulatedRtt));
+
+            Assert.GreaterOrEqual(m_Client1.GetCurrentRtt(m_Client1.ServerClientId), simulatedRtt);
+
+            yield return null;
+        }
+
+        [UnityTest]
+        public IEnumerator SendQueuesFlushedOnShutdown([ValueSource("k_DeliveryParameters")] NetworkDelivery delivery)
+        {
+            InitializeTransport(out m_Server, out m_ServerEvents);
+            InitializeTransport(out m_Client1, out m_Client1Events);
+
+            m_Server.StartServer();
+            m_Client1.StartClient();
+
+            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_Client1Events);
+
+            var data = new ArraySegment<byte>(new byte[] { 42 });
+            m_Client1.Send(m_Client1.ServerClientId, data, delivery);
+
+            m_Client1.Shutdown();
+
+            yield return WaitForNetworkEvent(NetworkEvent.Data, m_ServerEvents);
+
+            yield return null;
+        }
+
+        [UnityTest]
+        public IEnumerator SendQueuesFlushedOnLocalClientDisconnect([ValueSource("k_DeliveryParameters")] NetworkDelivery delivery)
+        {
+            InitializeTransport(out m_Server, out m_ServerEvents);
+            InitializeTransport(out m_Client1, out m_Client1Events);
+
+            m_Server.StartServer();
+            m_Client1.StartClient();
+
+            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_Client1Events);
+
+            var data = new ArraySegment<byte>(new byte[] { 42 });
+            m_Client1.Send(m_Client1.ServerClientId, data, delivery);
+
+            m_Client1.DisconnectLocalClient();
+
+            yield return WaitForNetworkEvent(NetworkEvent.Data, m_ServerEvents);
+
+            yield return null;
+        }
+
+        [UnityTest]
+        public IEnumerator SendQueuesFlushedOnRemoteClientDisconnect([ValueSource("k_DeliveryParameters")] NetworkDelivery delivery)
+        {
+            InitializeTransport(out m_Server, out m_ServerEvents);
+            InitializeTransport(out m_Client1, out m_Client1Events);
+
+            m_Server.StartServer();
+            m_Client1.StartClient();
+
+            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_Client1Events);
+
+            var data = new ArraySegment<byte>(new byte[] { 42 });
+            m_Server.Send(m_Client1.ServerClientId, data, delivery);
+
+            m_Server.DisconnectRemoteClient(m_ServerEvents[0].ClientID);
+
+            yield return WaitForNetworkEvent(NetworkEvent.Data, m_Client1Events);
+
+            yield return null;
+        }
+    }
+}

Tests/Runtime/Transports/UnityTransportTests.cs.meta

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