Added Unity project files

Packages/com.vrchat.base/Editor/VRCSDK/VTP/MockNetworkStream.cs

@@ -0,0 +1,57 @@
+using System;
+using System.IO;
+
+namespace VRC.SDKBase.Editor.VTP
+{
+    // A mock for testing VTP code that expects a network stream.
+    public class MockNetworkStream : Stream
+    {
+        // Since with a network stream you can write to the stream and you won't read back what you wrote, we have to use two memory streams to implement that.
+        public MemoryStream incomingStream;
+        public MemoryStream outgoingStream;
+
+        public MockNetworkStream(MemoryStream incomingStream, MemoryStream outgoingStream)
+        {
+            this.incomingStream = incomingStream;
+            this.outgoingStream = outgoingStream;
+        }
+        
+        public override bool CanRead => true;
+        
+        public override bool CanSeek => false;
+        
+        public override bool CanWrite => true;
+        public override long Length => incomingStream.Length;
+        public override long Position { get; set; }
+
+        public override void Flush()
+        {
+            outgoingStream.Flush();
+        }
+        
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            if (Position < 0 || Position > incomingStream.Length)
+                throw new ArgumentOutOfRangeException(nameof(Position), "Position is out of bounds");
+            incomingStream.Position = Position;
+            int read = incomingStream.Read(buffer, offset, count);
+            Position += read;
+            return read;
+        }
+        
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            throw new NotSupportedException($"Seek operation is not supported for {nameof(MockNetworkStream)}");
+        }
+        
+        public override void SetLength(long value)
+        {
+            incomingStream.SetLength(value);
+        }
+        
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            outgoingStream.Write(buffer, offset, count);
+        }
+    }
+}

Packages/com.vrchat.base/Editor/VRCSDK/VTP/MockNetworkStream.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7da9354981014f12b906d26674f2c00d
+timeCreated: 1742935460

Packages/com.vrchat.base/Editor/VRCSDK/VTP/VTPTests.cs

@@ -0,0 +1,187 @@
+using System.IO;
+using System.Threading;
+using NUnit.Framework;
+using UnityEditor;
+using UnityEngine;
+using VRC.Core;
+
+namespace VRC.SDKBase.Editor.VTP
+{
+    public class VTPTests
+    {
+        [Test]
+        public void TestVTP()
+        {
+            MemoryStream clientOutServerIn = new MemoryStream();
+            MemoryStream clientInServerOut = new MemoryStream();
+
+            MockNetworkStream clientNetworkStream = new MockNetworkStream(clientInServerOut, clientOutServerIn);
+            MockNetworkStream serverNetworkStream = new MockNetworkStream(clientOutServerIn, clientInServerOut);
+
+            TestHeartbeat(clientNetworkStream, serverNetworkStream);
+            TestHello(clientNetworkStream, serverNetworkStream);
+
+            System.Random random = new System.Random(42);
+            int fileSize = random.Next(5 * 1024, 50 * 1024);
+            byte[] fileContents = new byte[fileSize];
+            random.NextBytes(fileContents);
+
+            TestSendAvatar(fileContents, clientNetworkStream, serverNetworkStream);
+            TestSendWorld(fileContents, clientNetworkStream, serverNetworkStream);
+
+            TestError(clientNetworkStream, serverNetworkStream);
+        }
+
+        private static void TestHeartbeat(MockNetworkStream clientNetworkStream, MockNetworkStream serverNetworkStream)
+        {
+            { // CLIENT: Heartbeat from client to server
+                using BinaryWriter writer = new BinaryWriter(clientNetworkStream);
+                VRChatTestProtocol.WriteHeartbeat(writer);
+            }
+            { // SERVER: Read heartbeat from client
+                using BinaryReader reader = new BinaryReader(serverNetworkStream);
+                Assert.AreEqual( (VTP_PacketID) reader.ReadInt32(), VTP_PacketID.Heartbeat); // Read packet ID
+            }
+            { // SERVER: Heartbeat from server to client
+                using BinaryWriter writer = new BinaryWriter(serverNetworkStream);
+                VRChatTestProtocol.WriteHeartbeat(writer);
+            }
+            { // CLIENT: Read heartbeat from server
+                using BinaryReader reader = new BinaryReader(clientNetworkStream);
+                Assert.AreEqual( (VTP_PacketID) reader.ReadInt32(), VTP_PacketID.Heartbeat); // Read packet ID
+            }
+        }
+        
+        private static void TestHello(MockNetworkStream clientNetworkStream, MockNetworkStream serverNetworkStream)
+        {
+            int testVersion = 123;
+            string testDeviceType = "testDevice";
+            string testModel = "testModel";
+            { // CLIENT: Hello client to server
+                using BinaryWriter writer = new BinaryWriter(clientNetworkStream);
+                VRChatTestProtocol.WriteHello(writer, testVersion, testDeviceType, testModel);
+            }
+            { // SERVER: Read hello from client
+                using BinaryReader reader = new BinaryReader(serverNetworkStream);
+                Assert.AreEqual( (VTP_PacketID) reader.ReadInt32(), VTP_PacketID.HelloMessage); // Read packet ID
+                VRChatTestProtocol.ReadHello(reader, out int version, out string deviceType, out string deviceModel);
+            
+                Assert.AreEqual(testVersion, version);
+                Assert.AreEqual(testDeviceType, deviceType);
+                Assert.AreEqual(testModel, deviceModel);
+            }
+            { // SERVER: Send hello to client
+                using BinaryWriter writer = new BinaryWriter(serverNetworkStream);
+                VRChatTestProtocol.WriteHello(writer, testVersion, testDeviceType, testModel);
+            }
+            { // CLIENT: Read hello from Server
+                using BinaryReader reader = new BinaryReader(clientNetworkStream);
+                Assert.AreEqual( (VTP_PacketID) reader.ReadInt32(), VTP_PacketID.HelloMessage); // Read packet ID
+                VRChatTestProtocol.ReadHello(reader, out int version, out string deviceType, out string deviceModel);
+            
+                Assert.AreEqual(testVersion, version);
+                Assert.AreEqual(testDeviceType, deviceType);
+                Assert.AreEqual(testModel, deviceModel);
+            }
+        }
+
+        public void TestSendAvatar(byte[] fileContents, MockNetworkStream clientNetworkStream, MockNetworkStream serverNetworkStream, int fileSizeLimit = VRChatTestProtocol.MaxFileSize)
+        {
+            { // SERVER: Send avatar to client
+                string path = Path.Combine(Path.GetTempPath(), $"test-avatar-{GUID.Generate()}.bin" );
+                File.WriteAllBytes(path, fileContents);
+                
+                using BinaryWriter writer = new BinaryWriter(serverNetworkStream);
+                VRChatTestProtocol.WriteSendAvatar(writer, path, "testAvatar");
+                File.Delete(path);
+            }
+            { // CLIENT: Read avatar from server
+                BinaryWriter errorWriter = new BinaryWriter(clientNetworkStream);
+                using BinaryReader reader = new BinaryReader(clientNetworkStream);
+                Assert.AreEqual( (VTP_PacketID) reader.ReadInt32(), VTP_PacketID.SendAvatar); // Read packet ID
+                string outputPath = VRChatTestProtocol.ReadAvatarFileToStream(reader, clientNetworkStream, errorWriter, CancellationToken.None, fileSizeLimit);
+                byte[] outputBytes = File.ReadAllBytes(outputPath);
+                Assert.AreEqual(fileContents, outputBytes);
+                File.Delete(outputPath);
+            }
+        }
+        
+        public void TestSendWorld(byte[] fileContents, MockNetworkStream clientNetworkStream, MockNetworkStream serverNetworkStream, int fileSizeLimit = VRChatTestProtocol.MaxFileSize)
+        {
+            { // SERVER: Send world to client
+                string path = Path.Combine(Path.GetTempPath(), $"test-world-{GUID.Generate()}.bin" );
+                File.WriteAllBytes(path, fileContents);
+                
+                using BinaryWriter writer = new BinaryWriter(serverNetworkStream);
+                VRChatTestProtocol.WriteSendWorld(writer, path);
+                File.Delete(path);
+            }
+            { // CLIENT: Read world from server
+                BinaryWriter errorWriter = new BinaryWriter(clientNetworkStream);
+                using BinaryReader reader = new BinaryReader(clientNetworkStream);
+                Assert.AreEqual( (VTP_PacketID) reader.ReadInt32(), VTP_PacketID.SendWorld); // Read packet ID
+                string outputPath = VRChatTestProtocol.ReadWorldFileToStream(reader, clientNetworkStream, errorWriter, CancellationToken.None,fileSizeLimit);
+                byte[] outputBytes = File.ReadAllBytes(outputPath);
+                Assert.AreEqual(fileContents, outputBytes);
+                File.Delete(outputPath);
+            }
+        }
+        
+        
+        [Test]
+        public void TestSendAvatarTooBig()
+        {
+            MemoryStream clientOutServerIn = new MemoryStream();
+            MemoryStream clientInServerOut = new MemoryStream();
+            
+            MockNetworkStream clientNetworkStream = new MockNetworkStream(clientInServerOut, clientOutServerIn);
+            MockNetworkStream serverNetworkStream = new MockNetworkStream(clientOutServerIn, clientInServerOut);
+            
+            Assert.Throws<VTPFileSizeException>(() =>
+            {
+                TestSendAvatar(new byte[100], clientNetworkStream, serverNetworkStream, fileSizeLimit: 10);
+            });
+        }
+        
+        [Test]
+        public void TestSendWorldTooBig()
+        {
+            MemoryStream clientOutServerIn = new MemoryStream();
+            MemoryStream clientInServerOut = new MemoryStream();
+            
+            MockNetworkStream clientNetworkStream = new MockNetworkStream(clientInServerOut, clientOutServerIn);
+            MockNetworkStream serverNetworkStream = new MockNetworkStream(clientOutServerIn, clientInServerOut);
+            
+            Assert.Throws<VTPFileSizeException>(() =>
+            {
+                TestSendWorld(new byte[100], clientNetworkStream, serverNetworkStream, fileSizeLimit: 10);
+            });
+        }
+        
+        
+        private void TestError(MockNetworkStream clientNetworkStream, MockNetworkStream serverNetworkStream)
+        {
+            string errorMessage = "This is a test error.";
+            { // CLIENT: Error client to server
+                using BinaryWriter writer = new BinaryWriter(clientNetworkStream);
+                VRChatTestProtocol.WriteError(writer, errorMessage);
+            }
+            { // SERVER: Read error from client
+                using BinaryReader reader = new BinaryReader(serverNetworkStream);
+                Assert.AreEqual( (VTP_PacketID) reader.ReadInt32(), VTP_PacketID.Error); // Read packet ID
+                string readError = VRChatTestProtocol.ReadError(reader);
+                Assert.AreEqual(errorMessage, readError);
+            }
+            { // SERVER: Send error to client
+                using BinaryWriter writer = new BinaryWriter(serverNetworkStream);
+                VRChatTestProtocol.WriteError(writer, errorMessage);
+            }
+            { // CLIENT: Read error from Server
+                using BinaryReader reader = new BinaryReader(clientNetworkStream);
+                Assert.AreEqual( (VTP_PacketID) reader.ReadInt32(), VTP_PacketID.Error); // Read packet ID
+                string readError = VRChatTestProtocol.ReadError(reader);
+                Assert.AreEqual(errorMessage, readError);
+            }
+        }
+    }
+}

Packages/com.vrchat.base/Editor/VRCSDK/VTP/VTPTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 99c200778d4044f39026136fff493edd
+timeCreated: 1742935400