From d8ee0cbe1cf93ca521f52ce39aa2a15cb5784e48 Mon Sep 17 00:00:00 2001 From: Diva Canto Date: Sat, 30 Apr 2011 09:24:15 -0700 Subject: First stab at cleaning up Caps. Compiles. Untested. --- .../Linden/UDP/Tests/BasicCircuitTests.cs | 299 +++++++++++++++++++++ .../ClientStack/Linden/UDP/Tests/MockScene.cs | 72 +++++ .../Linden/UDP/Tests/PacketHandlerTests.cs | 106 ++++++++ .../Linden/UDP/Tests/TestLLPacketServer.cs | 72 +++++ .../Linden/UDP/Tests/TestLLUDPServer.cs | 153 +++++++++++ 5 files changed, 702 insertions(+) create mode 100644 OpenSim/Region/ClientStack/Linden/UDP/Tests/BasicCircuitTests.cs create mode 100644 OpenSim/Region/ClientStack/Linden/UDP/Tests/MockScene.cs create mode 100644 OpenSim/Region/ClientStack/Linden/UDP/Tests/PacketHandlerTests.cs create mode 100644 OpenSim/Region/ClientStack/Linden/UDP/Tests/TestLLPacketServer.cs create mode 100644 OpenSim/Region/ClientStack/Linden/UDP/Tests/TestLLUDPServer.cs (limited to 'OpenSim/Region/ClientStack/Linden/UDP/Tests') diff --git a/OpenSim/Region/ClientStack/Linden/UDP/Tests/BasicCircuitTests.cs b/OpenSim/Region/ClientStack/Linden/UDP/Tests/BasicCircuitTests.cs new file mode 100644 index 0000000..daab84f --- /dev/null +++ b/OpenSim/Region/ClientStack/Linden/UDP/Tests/BasicCircuitTests.cs @@ -0,0 +1,299 @@ +/* + * Copyright (c) Contributors, http://opensimulator.org/ + * See CONTRIBUTORS.TXT for a full list of copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the OpenSimulator Project nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System.Net; +using log4net.Config; +using Nini.Config; +using NUnit.Framework; +using NUnit.Framework.SyntaxHelpers; +using OpenMetaverse; +using OpenMetaverse.Packets; +using OpenSim.Framework; +using OpenSim.Tests.Common; +using OpenSim.Tests.Common.Mock; + +namespace OpenSim.Region.ClientStack.LindenUDP.Tests +{ + /// + /// This will contain basic tests for the LindenUDP client stack + /// + [TestFixture] + public class BasicCircuitTests + { + [SetUp] + public void Init() + { + try + { + XmlConfigurator.Configure(); + } + catch + { + // I don't care, just leave log4net off + } + } + + /// + /// Add a client for testing + /// + /// + /// + /// + /// Agent circuit manager used in setting up the stack + protected void SetupStack( + IScene scene, out TestLLUDPServer testLLUDPServer, out TestLLPacketServer testPacketServer, + out AgentCircuitManager acm) + { + IConfigSource configSource = new IniConfigSource(); + ClientStackUserSettings userSettings = new ClientStackUserSettings(); + testLLUDPServer = new TestLLUDPServer(); + acm = new AgentCircuitManager(); + + uint port = 666; + testLLUDPServer.Initialise(null, ref port, 0, false, configSource, acm); + testPacketServer = new TestLLPacketServer(testLLUDPServer, userSettings); + testLLUDPServer.LocalScene = scene; + } + + /// + /// Set up a client for tests which aren't concerned with this process itself and where only one client is being + /// tested + /// + /// + /// + /// + /// + protected void AddClient( + uint circuitCode, EndPoint epSender, TestLLUDPServer testLLUDPServer, AgentCircuitManager acm) + { + UUID myAgentUuid = UUID.Parse("00000000-0000-0000-0000-000000000001"); + UUID mySessionUuid = UUID.Parse("00000000-0000-0000-0000-000000000002"); + + AddClient(circuitCode, epSender, myAgentUuid, mySessionUuid, testLLUDPServer, acm); + } + + /// + /// Set up a client for tests which aren't concerned with this process itself + /// + /// + /// + /// + /// + /// + /// + protected void AddClient( + uint circuitCode, EndPoint epSender, UUID agentId, UUID sessionId, + TestLLUDPServer testLLUDPServer, AgentCircuitManager acm) + { + AgentCircuitData acd = new AgentCircuitData(); + acd.AgentID = agentId; + acd.SessionID = sessionId; + + UseCircuitCodePacket uccp = new UseCircuitCodePacket(); + + UseCircuitCodePacket.CircuitCodeBlock uccpCcBlock + = new UseCircuitCodePacket.CircuitCodeBlock(); + uccpCcBlock.Code = circuitCode; + uccpCcBlock.ID = agentId; + uccpCcBlock.SessionID = sessionId; + uccp.CircuitCode = uccpCcBlock; + + acm.AddNewCircuit(circuitCode, acd); + + testLLUDPServer.LoadReceive(uccp, epSender); + testLLUDPServer.ReceiveData(null); + } + + /// + /// Build an object name packet for test purposes + /// + /// + /// + protected ObjectNamePacket BuildTestObjectNamePacket(uint objectLocalId, string objectName) + { + ObjectNamePacket onp = new ObjectNamePacket(); + ObjectNamePacket.ObjectDataBlock odb = new ObjectNamePacket.ObjectDataBlock(); + odb.LocalID = objectLocalId; + odb.Name = Utils.StringToBytes(objectName); + onp.ObjectData = new ObjectNamePacket.ObjectDataBlock[] { odb }; + onp.Header.Zerocoded = false; + + return onp; + } + + /// + /// Test adding a client to the stack + /// + [Test, LongRunning] + public void TestAddClient() + { + TestHelper.InMethod(); + + uint myCircuitCode = 123456; + UUID myAgentUuid = UUID.Parse("00000000-0000-0000-0000-000000000001"); + UUID mySessionUuid = UUID.Parse("00000000-0000-0000-0000-000000000002"); + + TestLLUDPServer testLLUDPServer; + TestLLPacketServer testLLPacketServer; + AgentCircuitManager acm; + SetupStack(new MockScene(), out testLLUDPServer, out testLLPacketServer, out acm); + + AgentCircuitData acd = new AgentCircuitData(); + acd.AgentID = myAgentUuid; + acd.SessionID = mySessionUuid; + + UseCircuitCodePacket uccp = new UseCircuitCodePacket(); + + UseCircuitCodePacket.CircuitCodeBlock uccpCcBlock + = new UseCircuitCodePacket.CircuitCodeBlock(); + uccpCcBlock.Code = myCircuitCode; + uccpCcBlock.ID = myAgentUuid; + uccpCcBlock.SessionID = mySessionUuid; + uccp.CircuitCode = uccpCcBlock; + + EndPoint testEp = new IPEndPoint(IPAddress.Loopback, 999); + + testLLUDPServer.LoadReceive(uccp, testEp); + testLLUDPServer.ReceiveData(null); + + // Circuit shouildn't exist since the circuit manager doesn't know about this circuit for authentication yet + Assert.IsFalse(testLLUDPServer.HasCircuit(myCircuitCode)); + + acm.AddNewCircuit(myCircuitCode, acd); + + testLLUDPServer.LoadReceive(uccp, testEp); + testLLUDPServer.ReceiveData(null); + + // Should succeed now + Assert.IsTrue(testLLUDPServer.HasCircuit(myCircuitCode)); + Assert.IsFalse(testLLUDPServer.HasCircuit(101)); + } + + /// + /// Test removing a client from the stack + /// + [Test] + public void TestRemoveClient() + { + TestHelper.InMethod(); + + uint myCircuitCode = 123457; + + TestLLUDPServer testLLUDPServer; + TestLLPacketServer testLLPacketServer; + AgentCircuitManager acm; + SetupStack(new MockScene(), out testLLUDPServer, out testLLPacketServer, out acm); + AddClient(myCircuitCode, new IPEndPoint(IPAddress.Loopback, 1000), testLLUDPServer, acm); + + testLLUDPServer.RemoveClientCircuit(myCircuitCode); + Assert.IsFalse(testLLUDPServer.HasCircuit(myCircuitCode)); + + // Check that removing a non-existant circuit doesn't have any bad effects + testLLUDPServer.RemoveClientCircuit(101); + Assert.IsFalse(testLLUDPServer.HasCircuit(101)); + } + + /// + /// Make sure that the client stack reacts okay to malformed packets + /// + [Test] + public void TestMalformedPacketSend() + { + TestHelper.InMethod(); + + uint myCircuitCode = 123458; + EndPoint testEp = new IPEndPoint(IPAddress.Loopback, 1001); + MockScene scene = new MockScene(); + + TestLLUDPServer testLLUDPServer; + TestLLPacketServer testLLPacketServer; + AgentCircuitManager acm; + SetupStack(scene, out testLLUDPServer, out testLLPacketServer, out acm); + AddClient(myCircuitCode, testEp, testLLUDPServer, acm); + + byte[] data = new byte[] { 0x01, 0x02, 0x03, 0x04 }; + + // Send two garbled 'packets' in succession + testLLUDPServer.LoadReceive(data, testEp); + testLLUDPServer.LoadReceive(data, testEp); + testLLUDPServer.ReceiveData(null); + + // Check that we are still here + Assert.IsTrue(testLLUDPServer.HasCircuit(myCircuitCode)); + Assert.That(testLLPacketServer.GetTotalPacketsReceived(), Is.EqualTo(0)); + + // Check that sending a valid packet to same circuit still succeeds + Assert.That(scene.ObjectNameCallsReceived, Is.EqualTo(0)); + + testLLUDPServer.LoadReceive(BuildTestObjectNamePacket(1, "helloooo"), testEp); + testLLUDPServer.ReceiveData(null); + + Assert.That(testLLPacketServer.GetTotalPacketsReceived(), Is.EqualTo(1)); + Assert.That(testLLPacketServer.GetPacketsReceivedFor(PacketType.ObjectName), Is.EqualTo(1)); + } + + /// + /// Test that the stack continues to work even if some client has caused a + /// SocketException on Socket.BeginReceive() + /// + [Test] + public void TestExceptionOnBeginReceive() + { + TestHelper.InMethod(); + + MockScene scene = new MockScene(); + + uint circuitCodeA = 130000; + EndPoint epA = new IPEndPoint(IPAddress.Loopback, 1300); + UUID agentIdA = UUID.Parse("00000000-0000-0000-0000-000000001300"); + UUID sessionIdA = UUID.Parse("00000000-0000-0000-0000-000000002300"); + + uint circuitCodeB = 130001; + EndPoint epB = new IPEndPoint(IPAddress.Loopback, 1301); + UUID agentIdB = UUID.Parse("00000000-0000-0000-0000-000000001301"); + UUID sessionIdB = UUID.Parse("00000000-0000-0000-0000-000000002301"); + + TestLLUDPServer testLLUDPServer; + TestLLPacketServer testLLPacketServer; + AgentCircuitManager acm; + SetupStack(scene, out testLLUDPServer, out testLLPacketServer, out acm); + AddClient(circuitCodeA, epA, agentIdA, sessionIdA, testLLUDPServer, acm); + AddClient(circuitCodeB, epB, agentIdB, sessionIdB, testLLUDPServer, acm); + + testLLUDPServer.LoadReceive(BuildTestObjectNamePacket(1, "packet1"), epA); + testLLUDPServer.LoadReceive(BuildTestObjectNamePacket(1, "packet2"), epB); + testLLUDPServer.LoadReceiveWithBeginException(epA); + testLLUDPServer.LoadReceive(BuildTestObjectNamePacket(2, "packet3"), epB); + testLLUDPServer.ReceiveData(null); + + Assert.IsFalse(testLLUDPServer.HasCircuit(circuitCodeA)); + + Assert.That(testLLPacketServer.GetTotalPacketsReceived(), Is.EqualTo(3)); + Assert.That(testLLPacketServer.GetPacketsReceivedFor(PacketType.ObjectName), Is.EqualTo(3)); + } + } +} diff --git a/OpenSim/Region/ClientStack/Linden/UDP/Tests/MockScene.cs b/OpenSim/Region/ClientStack/Linden/UDP/Tests/MockScene.cs new file mode 100644 index 0000000..34c21aa --- /dev/null +++ b/OpenSim/Region/ClientStack/Linden/UDP/Tests/MockScene.cs @@ -0,0 +1,72 @@ +/* + * Copyright (c) Contributors, http://opensimulator.org/ + * See CONTRIBUTORS.TXT for a full list of copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the OpenSimulator Project nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using OpenMetaverse; +using OpenSim.Framework; +using OpenSim.Region.Framework.Scenes; +using GridRegion = OpenSim.Services.Interfaces.GridRegion; + +namespace OpenSim.Region.ClientStack.LindenUDP.Tests +{ + /// + /// Mock scene for unit tests + /// + public class MockScene : SceneBase + { + public int ObjectNameCallsReceived + { + get { return m_objectNameCallsReceived; } + } + protected int m_objectNameCallsReceived; + + public MockScene() + { + m_regInfo = new RegionInfo(1000, 1000, null, null); + m_regStatus = RegionStatus.Up; + } + + public override void Update() {} + public override void LoadWorldMap() {} + + public override void AddNewClient(IClientAPI client) + { + client.OnObjectName += RecordObjectNameCall; + } + + public override void RemoveClient(UUID agentID) {} + public override void CloseAllAgents(uint circuitcode) {} + public override void OtherRegionUp(GridRegion otherRegion) { } + + /// + /// Doesn't really matter what the call is - we're using this to test that a packet has actually been received + /// + protected void RecordObjectNameCall(IClientAPI remoteClient, uint localID, string message) + { + m_objectNameCallsReceived++; + } + } +} diff --git a/OpenSim/Region/ClientStack/Linden/UDP/Tests/PacketHandlerTests.cs b/OpenSim/Region/ClientStack/Linden/UDP/Tests/PacketHandlerTests.cs new file mode 100644 index 0000000..7d0757f --- /dev/null +++ b/OpenSim/Region/ClientStack/Linden/UDP/Tests/PacketHandlerTests.cs @@ -0,0 +1,106 @@ +/* + * Copyright (c) Contributors, http://opensimulator.org/ + * See CONTRIBUTORS.TXT for a full list of copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the OpenSimulator Project nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using Nini.Config; +using NUnit.Framework; +using NUnit.Framework.SyntaxHelpers; +using OpenMetaverse; +using OpenMetaverse.Packets; +using OpenSim.Framework; +using OpenSim.Tests.Common.Mock; +using OpenSim.Tests.Common; + +namespace OpenSim.Region.ClientStack.LindenUDP.Tests +{ + /// + /// Tests for the LL packet handler + /// + [TestFixture] + public class PacketHandlerTests + { + [Test] + /// + /// More a placeholder, really + /// + public void InPacketTest() + { + TestHelper.InMethod(); + + AgentCircuitData agent = new AgentCircuitData(); + agent.AgentID = UUID.Random(); + agent.firstname = "testfirstname"; + agent.lastname = "testlastname"; + agent.SessionID = UUID.Zero; + agent.SecureSessionID = UUID.Zero; + agent.circuitcode = 123; + agent.BaseFolder = UUID.Zero; + agent.InventoryFolder = UUID.Zero; + agent.startpos = Vector3.Zero; + agent.CapsPath = "http://wibble.com"; + + TestLLUDPServer testLLUDPServer; + TestLLPacketServer testLLPacketServer; + AgentCircuitManager acm; + IScene scene = new MockScene(); + SetupStack(scene, out testLLUDPServer, out testLLPacketServer, out acm); + + TestClient testClient = new TestClient(agent, scene); + + LLPacketHandler packetHandler + = new LLPacketHandler(testClient, testLLPacketServer, new ClientStackUserSettings()); + + packetHandler.InPacket(new AgentAnimationPacket()); + LLQueItem receivedPacket = packetHandler.PacketQueue.Dequeue(); + + Assert.That(receivedPacket, Is.Not.Null); + Assert.That(receivedPacket.Incoming, Is.True); + Assert.That(receivedPacket.Packet, Is.TypeOf(typeof(AgentAnimationPacket))); + } + + /// + /// Add a client for testing + /// + /// + /// + /// + /// Agent circuit manager used in setting up the stack + protected void SetupStack( + IScene scene, out TestLLUDPServer testLLUDPServer, out TestLLPacketServer testPacketServer, + out AgentCircuitManager acm) + { + IConfigSource configSource = new IniConfigSource(); + ClientStackUserSettings userSettings = new ClientStackUserSettings(); + testLLUDPServer = new TestLLUDPServer(); + acm = new AgentCircuitManager(); + + uint port = 666; + testLLUDPServer.Initialise(null, ref port, 0, false, configSource, acm); + testPacketServer = new TestLLPacketServer(testLLUDPServer, userSettings); + testLLUDPServer.LocalScene = scene; + } + } +} diff --git a/OpenSim/Region/ClientStack/Linden/UDP/Tests/TestLLPacketServer.cs b/OpenSim/Region/ClientStack/Linden/UDP/Tests/TestLLPacketServer.cs new file mode 100644 index 0000000..e995d65 --- /dev/null +++ b/OpenSim/Region/ClientStack/Linden/UDP/Tests/TestLLPacketServer.cs @@ -0,0 +1,72 @@ +/* + * Copyright (c) Contributors, http://opensimulator.org/ + * See CONTRIBUTORS.TXT for a full list of copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the OpenSimulator Project nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System.Collections.Generic; +using OpenMetaverse.Packets; + +namespace OpenSim.Region.ClientStack.LindenUDP.Tests +{ + public class TestLLPacketServer : LLPacketServer + { + /// + /// Record counts of packets received + /// + protected Dictionary m_packetsReceived = new Dictionary(); + + public TestLLPacketServer(LLUDPServer networkHandler, ClientStackUserSettings userSettings) + : base(networkHandler, userSettings) + {} + + public override void InPacket(uint circuitCode, Packet packet) + { + base.InPacket(circuitCode, packet); + + if (m_packetsReceived.ContainsKey(packet.Type)) + m_packetsReceived[packet.Type]++; + else + m_packetsReceived[packet.Type] = 1; + } + + public int GetTotalPacketsReceived() + { + int totalCount = 0; + + foreach (int count in m_packetsReceived.Values) + totalCount += count; + + return totalCount; + } + + public int GetPacketsReceivedFor(PacketType packetType) + { + if (m_packetsReceived.ContainsKey(packetType)) + return m_packetsReceived[packetType]; + else + return 0; + } + } +} diff --git a/OpenSim/Region/ClientStack/Linden/UDP/Tests/TestLLUDPServer.cs b/OpenSim/Region/ClientStack/Linden/UDP/Tests/TestLLUDPServer.cs new file mode 100644 index 0000000..f98586d --- /dev/null +++ b/OpenSim/Region/ClientStack/Linden/UDP/Tests/TestLLUDPServer.cs @@ -0,0 +1,153 @@ +/* + * Copyright (c) Contributors, http://opensimulator.org/ + * See CONTRIBUTORS.TXT for a full list of copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the OpenSimulator Project nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using System.Collections.Generic; +using System.Net; +using System.Net.Sockets; +using OpenMetaverse.Packets; + +namespace OpenSim.Region.ClientStack.LindenUDP.Tests +{ + /// + /// This class enables synchronous testing of the LLUDPServer by allowing us to load our own data into the end + /// receive event + /// + public class TestLLUDPServer : LLUDPServer + { + /// + /// The chunks of data to pass to the LLUDPServer when it calls EndReceive + /// + protected Queue m_chunksToLoad = new Queue(); + + protected override void BeginReceive() + { + if (m_chunksToLoad.Count > 0 && m_chunksToLoad.Peek().BeginReceiveException) + { + ChunkSenderTuple tuple = m_chunksToLoad.Dequeue(); + reusedEpSender = tuple.Sender; + throw new SocketException(); + } + } + + protected override bool EndReceive(out int numBytes, IAsyncResult result, ref EndPoint epSender) + { + numBytes = 0; + + //m_log.Debug("Queue size " + m_chunksToLoad.Count); + + if (m_chunksToLoad.Count <= 0) + return false; + + ChunkSenderTuple tuple = m_chunksToLoad.Dequeue(); + RecvBuffer = tuple.Data; + numBytes = tuple.Data.Length; + epSender = tuple.Sender; + + return true; + } + + public override void SendPacketTo(byte[] buffer, int size, SocketFlags flags, uint circuitcode) + { + // Don't do anything just yet + } + + /// + /// Signal that this chunk should throw an exception on Socket.BeginReceive() + /// + /// + public void LoadReceiveWithBeginException(EndPoint epSender) + { + ChunkSenderTuple tuple = new ChunkSenderTuple(epSender); + tuple.BeginReceiveException = true; + m_chunksToLoad.Enqueue(tuple); + } + + /// + /// Load some data to be received by the LLUDPServer on the next receive call + /// + /// + /// + public void LoadReceive(byte[] data, EndPoint epSender) + { + m_chunksToLoad.Enqueue(new ChunkSenderTuple(data, epSender)); + } + + /// + /// Load a packet to be received by the LLUDPServer on the next receive call + /// + /// + public void LoadReceive(Packet packet, EndPoint epSender) + { + LoadReceive(packet.ToBytes(), epSender); + } + + /// + /// Calls the protected asynchronous result method. This fires out all data chunks currently queued for send + /// + /// + public void ReceiveData(IAsyncResult result) + { + while (m_chunksToLoad.Count > 0) + OnReceivedData(result); + } + + /// + /// Has a circuit with the given code been established? + /// + /// + /// + public bool HasCircuit(uint circuitCode) + { + lock (clientCircuits_reverse) + { + return clientCircuits_reverse.ContainsKey(circuitCode); + } + } + } + + /// + /// Record the data and sender tuple + /// + public class ChunkSenderTuple + { + public byte[] Data; + public EndPoint Sender; + public bool BeginReceiveException; + + public ChunkSenderTuple(byte[] data, EndPoint sender) + { + Data = data; + Sender = sender; + } + + public ChunkSenderTuple(EndPoint sender) + { + Sender = sender; + } + } +} -- cgit v1.1