Merge remote-tracking branch 'os/master'

5 files changed, 977 insertions, 0 deletions

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..a935dd2
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/UDP/Tests/BasicCircuitTests.cs
@@ -0,0 +1,272 @@
+/*
+ * 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.Net;
+using log4net.Config;
+using Nini.Config;
+using NUnit.Framework;
+using OpenMetaverse;
+using OpenMetaverse.Packets;
+using OpenSim.Framework;
+using OpenSim.Framework.Monitoring;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Tests.Common;
+
+namespace OpenSim.Region.ClientStack.LindenUDP.Tests
+{
+    /// <summary>
+    /// This will contain basic tests for the LindenUDP client stack
+    /// </summary>
+    [TestFixture]
+    public class BasicCircuitTests : OpenSimTestCase
+    {
+        private Scene m_scene;
+
+        [TestFixtureSetUp]
+        public void FixtureInit()
+        {
+            // Don't allow tests to be bamboozled by asynchronous events.  Execute everything on the same thread.
+            Util.FireAndForgetMethod = FireAndForgetMethod.RegressionTest;
+        }
+
+        [TestFixtureTearDown]
+        public void TearDown()
+        {
+            // We must set this back afterwards, otherwise later tests will fail since they're expecting multiple
+            // threads.  Possibly, later tests should be rewritten so none of them require async stuff (which regression
+            // tests really shouldn't).
+            Util.FireAndForgetMethod = Util.DefaultFireAndForgetMethod;
+        }
+
+        [SetUp]
+        public override void SetUp()
+        {
+            base.SetUp();
+            m_scene = new SceneHelpers().SetupScene();
+            StatsManager.SimExtraStats = new SimExtraStatsCollector();
+        }
+        
+//        /// <summary>
+//        /// Build an object name packet for test purposes
+//        /// </summary>
+//        /// <param name="objectLocalId"></param>
+//        /// <param name="objectName"></param>
+//        private 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;
+//        }
+//
+        /// <summary>
+        /// Test adding a client to the stack
+        /// </summary>
+        [Test]
+        public void TestAddClient()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+
+            TestLLUDPServer udpServer = ClientStackHelpers.AddUdpServer(m_scene);
+
+            UUID myAgentUuid   = TestHelpers.ParseTail(0x1);
+            UUID mySessionUuid = TestHelpers.ParseTail(0x2);
+            uint myCircuitCode = 123456;
+            IPEndPoint testEp = new IPEndPoint(IPAddress.Loopback, 999);
+
+            UseCircuitCodePacket uccp = new UseCircuitCodePacket();
+
+            UseCircuitCodePacket.CircuitCodeBlock uccpCcBlock
+                = new UseCircuitCodePacket.CircuitCodeBlock();
+            uccpCcBlock.Code = myCircuitCode;
+            uccpCcBlock.ID = myAgentUuid;
+            uccpCcBlock.SessionID = mySessionUuid;
+            uccp.CircuitCode = uccpCcBlock;
+
+            byte[] uccpBytes = uccp.ToBytes();
+            UDPPacketBuffer upb = new UDPPacketBuffer(testEp, uccpBytes.Length);
+            upb.DataLength = uccpBytes.Length;  // God knows why this isn't set by the constructor.
+            Buffer.BlockCopy(uccpBytes, 0, upb.Data, 0, uccpBytes.Length);
+
+            udpServer.PacketReceived(upb);
+
+            // Presence shouldn't exist since the circuit manager doesn't know about this circuit for authentication yet
+            Assert.That(m_scene.GetScenePresence(myAgentUuid), Is.Null);
+
+            AgentCircuitData acd = new AgentCircuitData();
+            acd.AgentID = myAgentUuid;
+            acd.SessionID = mySessionUuid;
+
+            m_scene.AuthenticateHandler.AddNewCircuit(myCircuitCode, acd);
+
+            udpServer.PacketReceived(upb);
+
+            // Should succeed now
+            ScenePresence sp = m_scene.GetScenePresence(myAgentUuid);
+            Assert.That(sp.UUID, Is.EqualTo(myAgentUuid));
+
+            Assert.That(udpServer.PacketsSent.Count, Is.EqualTo(1));
+
+            Packet packet = udpServer.PacketsSent[0];
+            Assert.That(packet, Is.InstanceOf(typeof(PacketAckPacket)));
+
+            PacketAckPacket ackPacket = packet as PacketAckPacket;
+            Assert.That(ackPacket.Packets.Length, Is.EqualTo(1));
+            Assert.That(ackPacket.Packets[0].ID, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void TestLogoutClientDueToAck()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+
+            IniConfigSource ics = new IniConfigSource();
+            IConfig config = ics.AddConfig("ClientStack.LindenUDP");
+            config.Set("AckTimeout", -1);
+            TestLLUDPServer udpServer = ClientStackHelpers.AddUdpServer(m_scene, ics);
+
+            ScenePresence sp 
+                = ClientStackHelpers.AddChildClient(
+                    m_scene, udpServer, TestHelpers.ParseTail(0x1), TestHelpers.ParseTail(0x2), 123456);
+
+            udpServer.ClientOutgoingPacketHandler(sp.ControllingClient, true, false, false);
+
+            ScenePresence spAfterAckTimeout = m_scene.GetScenePresence(sp.UUID);
+            Assert.That(spAfterAckTimeout, Is.Null);
+        }
+
+//        /// <summary>
+//        /// Test removing a client from the stack
+//        /// </summary>
+//        [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-existent circuit doesn't have any bad effects
+//            testLLUDPServer.RemoveClientCircuit(101);
+//            Assert.IsFalse(testLLUDPServer.HasCircuit(101));
+//        }
+//        
+//        /// <summary>
+//        /// Make sure that the client stack reacts okay to malformed packets
+//        /// </summary>
+//        [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));
+//        }
+//        
+//        /// <summary>
+//        /// Test that the stack continues to work even if some client has caused a 
+//        /// SocketException on Socket.BeginReceive()
+//        /// </summary>
+//        [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/LLImageManagerTests.cs b/OpenSim/Region/ClientStack/Linden/UDP/Tests/LLImageManagerTests.cs
new file mode 100644
index 0000000..6c57e6d
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/UDP/Tests/LLImageManagerTests.cs
@@ -0,0 +1,174 @@
+/*
+ * 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.IO;
+using System.Net;
+using System.Reflection;
+using System.Threading;
+using log4net.Config;
+using Nini.Config;
+using NUnit.Framework;
+using OpenMetaverse;
+using OpenMetaverse.Packets;
+using OpenSim.Framework;
+using OpenSim.Region.CoreModules.Agent.TextureSender;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Tests.Common;
+
+namespace OpenSim.Region.ClientStack.LindenUDP.Tests
+{
+    [TestFixture]
+    public class LLImageManagerTests : OpenSimTestCase
+    {
+        private AssetBase m_testImageAsset;
+        private Scene scene;
+        private LLImageManager llim;
+        private TestClient tc;
+
+        [TestFixtureSetUp]
+        public void FixtureInit()
+        {
+            // Don't allow tests to be bamboozled by asynchronous events.  Execute everything on the same thread.
+            Util.FireAndForgetMethod = FireAndForgetMethod.None;
+
+            using (
+                Stream resource
+                    = GetType().Assembly.GetManifestResourceStream(
+                        "OpenSim.Region.ClientStack.LindenUDP.Tests.Resources.4-tile2.jp2"))
+            {
+                using (BinaryReader br = new BinaryReader(resource))
+                {
+                    m_testImageAsset
+                        = new AssetBase(
+                            TestHelpers.ParseTail(0x1),
+                            "Test Image",
+                            (sbyte)AssetType.Texture,
+                            TestHelpers.ParseTail(0x2).ToString());
+
+                    m_testImageAsset.Data = br.ReadBytes(99999999);
+                }
+            }
+        }
+
+        [TestFixtureTearDown]
+        public void TearDown()
+        {
+            // We must set this back afterwards, otherwise later tests will fail since they're expecting multiple
+            // threads.  Possibly, later tests should be rewritten not to worry about such things.
+            Util.FireAndForgetMethod = Util.DefaultFireAndForgetMethod;
+        }
+
+        [SetUp]
+        public override void SetUp()
+        {
+            base.SetUp();
+
+            UUID userId = TestHelpers.ParseTail(0x3);
+
+            J2KDecoderModule j2kdm = new J2KDecoderModule();
+
+            SceneHelpers sceneHelpers = new SceneHelpers();
+            scene = sceneHelpers.SetupScene();
+            SceneHelpers.SetupSceneModules(scene, j2kdm);
+
+            tc = new TestClient(SceneHelpers.GenerateAgentData(userId), scene);
+            llim = new LLImageManager(tc, scene.AssetService, j2kdm);
+        }
+
+        [Test]
+        public void TestSendImage()
+        {
+            TestHelpers.InMethod();
+//            XmlConfigurator.Configure();
+
+            scene.AssetService.Store(m_testImageAsset);
+
+            TextureRequestArgs args = new TextureRequestArgs();
+            args.RequestedAssetID = m_testImageAsset.FullID;
+            args.DiscardLevel = 0;
+            args.PacketNumber = 1;
+            args.Priority = 5;
+            args.requestSequence = 1;
+
+            llim.EnqueueReq(args);
+            llim.ProcessImageQueue(20);
+
+            Assert.That(tc.SentImageDataPackets.Count, Is.EqualTo(1));
+        }
+
+        [Test]
+        public void TestDiscardImage()
+        {
+            TestHelpers.InMethod();
+//            XmlConfigurator.Configure();
+
+            scene.AssetService.Store(m_testImageAsset);
+
+            TextureRequestArgs args = new TextureRequestArgs();
+            args.RequestedAssetID = m_testImageAsset.FullID;
+            args.DiscardLevel = 0;
+            args.PacketNumber = 1;
+            args.Priority = 5;
+            args.requestSequence = 1;
+            llim.EnqueueReq(args);
+
+            // Now create a discard request
+            TextureRequestArgs discardArgs = new TextureRequestArgs();
+            discardArgs.RequestedAssetID = m_testImageAsset.FullID;
+            discardArgs.DiscardLevel = -1;
+            discardArgs.PacketNumber = 1;
+            discardArgs.Priority = 0;
+            discardArgs.requestSequence = 2;
+            llim.EnqueueReq(discardArgs);
+
+            llim.ProcessImageQueue(20);
+
+            Assert.That(tc.SentImageDataPackets.Count, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void TestMissingImage()
+        {
+            TestHelpers.InMethod();
+//            XmlConfigurator.Configure();
+
+            TextureRequestArgs args = new TextureRequestArgs();
+            args.RequestedAssetID = m_testImageAsset.FullID;
+            args.DiscardLevel = 0;
+            args.PacketNumber = 1;
+            args.Priority = 5;
+            args.requestSequence = 1;
+
+            llim.EnqueueReq(args);
+            llim.ProcessImageQueue(20);
+
+            Assert.That(tc.SentImageDataPackets.Count, Is.EqualTo(0));
+            Assert.That(tc.SentImageNotInDatabasePackets.Count, Is.EqualTo(1));
+        }
+    }
+}
\ No newline at end of file
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..92f1fc3
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/UDP/Tests/PacketHandlerTests.cs
@@ -0,0 +1,104 @@
+/*
+ * 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 OpenMetaverse;
+using OpenMetaverse.Packets;
+using OpenSim.Framework;
+using OpenSim.Tests.Common;
+
+namespace OpenSim.Region.ClientStack.LindenUDP.Tests
+{
+    /// <summary>
+    /// Tests for the LL packet handler
+    /// </summary>
+    [TestFixture]
+    public class PacketHandlerTests : OpenSimTestCase
+    {
+//        [Test]
+//        /// <summary>
+//        /// More a placeholder, really
+//        /// </summary>
+//        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)));
+//        }
+//
+//        /// <summary>
+//        /// Add a client for testing
+//        /// </summary>
+//        /// <param name="scene"></param>
+//        /// <param name="testLLUDPServer"></param>
+//        /// <param name="testPacketServer"></param>
+//        /// <param name="acm">Agent circuit manager used in setting up the stack</param>
+//        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/Resources/4-tile2.jp2 b/OpenSim/Region/ClientStack/Linden/UDP/Tests/Resources/4-tile2.jp2
new file mode 100644
index 0000000..8c63104
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/UDP/Tests/Resources/4-tile2.jp2
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/Tests/ThrottleTests.cs b/OpenSim/Region/ClientStack/Linden/UDP/Tests/ThrottleTests.cs
new file mode 100644
index 0000000..3c82a78
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/UDP/Tests/ThrottleTests.cs
@@ -0,0 +1,427 @@
+/*
+ * 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 Nini.Config;
+using NUnit.Framework;
+using OpenMetaverse.Packets;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Tests.Common;
+
+namespace OpenSim.Region.ClientStack.LindenUDP.Tests
+{
+    [TestFixture]
+    public class ThrottleTests : OpenSimTestCase
+    {
+        [TestFixtureSetUp]
+        public void FixtureInit()
+        {
+            // Don't allow tests to be bamboozled by asynchronous events.  Execute everything on the same thread.
+            Util.FireAndForgetMethod = FireAndForgetMethod.RegressionTest;
+        }
+
+        [TestFixtureTearDown]
+        public void TearDown()
+        {
+            // We must set this back afterwards, otherwise later tests will fail since they're expecting multiple
+            // threads.  Possibly, later tests should be rewritten so none of them require async stuff (which regression
+            // tests really shouldn't).
+            Util.FireAndForgetMethod = Util.DefaultFireAndForgetMethod;
+        }
+
+        [Test]
+        public void TestSetRequestDripRate()
+        {
+            TestHelpers.InMethod();
+
+            TokenBucket tb = new TokenBucket("tb", null, 5000, 0);
+            AssertRates(tb, 5000, 0, 5000, 0);
+
+            tb.RequestedDripRate = 4000;
+            AssertRates(tb, 4000, 0, 4000, 0);
+
+            tb.RequestedDripRate = 6000;
+            AssertRates(tb, 6000, 0, 6000, 0);
+        }
+
+        [Test]
+        public void TestSetRequestDripRateWithMax()
+        {
+            TestHelpers.InMethod();
+
+            TokenBucket tb = new TokenBucket("tb", null, 5000, 10000);
+            AssertRates(tb, 5000, 0, 5000, 10000);
+
+            tb.RequestedDripRate = 4000;
+            AssertRates(tb, 4000, 0, 4000, 10000);
+
+            tb.RequestedDripRate = 6000;
+            AssertRates(tb, 6000, 0, 6000, 10000);
+
+            tb.RequestedDripRate = 12000;
+            AssertRates(tb, 10000, 0, 10000, 10000);
+        }
+
+        [Test]
+        public void TestSetRequestDripRateWithChildren()
+        {
+            TestHelpers.InMethod();
+
+            TokenBucket tbParent = new TokenBucket("tbParent", null, 0, 0);
+            TokenBucket tbChild1 = new TokenBucket("tbChild1", tbParent, 3000, 0);
+            TokenBucket tbChild2 = new TokenBucket("tbChild2", tbParent, 5000, 0);
+
+            AssertRates(tbParent, 8000, 8000, 8000, 0);
+            AssertRates(tbChild1, 3000, 0, 3000, 0);
+            AssertRates(tbChild2, 5000, 0, 5000, 0);
+
+            // Test: Setting a parent request greater than total children requests.
+            tbParent.RequestedDripRate = 10000;
+
+            AssertRates(tbParent, 10000, 8000, 8000, 0);
+            AssertRates(tbChild1, 3000, 0, 3000, 0);
+            AssertRates(tbChild2, 5000, 0, 5000, 0);
+
+            // Test: Setting a parent request lower than total children requests.
+            tbParent.RequestedDripRate = 6000;
+
+            AssertRates(tbParent, 6000, 8000, 6000, 0);
+            AssertRates(tbChild1, 3000, 0, 6000 / 8 * 3, 0);
+            AssertRates(tbChild2, 5000, 0, 6000 / 8 * 5, 0);
+        }
+
+        private void AssertRates(
+            TokenBucket tb, double requestedDripRate, double totalDripRequest, double dripRate, double maxDripRate)
+        {
+            Assert.AreEqual((int)requestedDripRate, tb.RequestedDripRate, "Requested drip rate");
+            Assert.AreEqual((int)totalDripRequest, tb.TotalDripRequest, "Total drip request");
+            Assert.AreEqual((int)dripRate, tb.DripRate, "Drip rate");
+            Assert.AreEqual((int)maxDripRate, tb.MaxDripRate, "Max drip rate");
+        }
+
+        [Test]
+        public void TestClientThrottleSetNoLimit()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+
+            Scene scene = new SceneHelpers().SetupScene();
+            TestLLUDPServer udpServer = ClientStackHelpers.AddUdpServer(scene);
+
+            ScenePresence sp 
+                = ClientStackHelpers.AddChildClient(
+                    scene, udpServer, TestHelpers.ParseTail(0x1), TestHelpers.ParseTail(0x2), 123456);
+
+            LLUDPClient udpClient = ((LLClientView)sp.ControllingClient).UDPClient;
+
+            udpServer.Throttle.DebugLevel = 1;
+            udpClient.ThrottleDebugLevel = 1;
+            
+            int resendBytes = 1000;
+            int landBytes = 2000;
+            int windBytes = 3000;
+            int cloudBytes = 4000;
+            int taskBytes = 5000;
+            int textureBytes = 6000;
+            int assetBytes = 7000;
+
+            SetThrottles(
+                udpClient, resendBytes, landBytes, windBytes, cloudBytes, taskBytes, textureBytes, assetBytes);
+
+            // We expect this to be lower because of the minimum bound set by MTU
+            int totalBytes = LLUDPServer.MTU + landBytes + windBytes + cloudBytes + taskBytes + textureBytes + assetBytes;
+
+            AssertThrottles(
+                udpClient, 
+                LLUDPServer.MTU, landBytes, windBytes, cloudBytes, taskBytes, 
+                textureBytes, assetBytes, totalBytes, 0, 0);
+        }
+
+        [Test]
+        public void TestClientThrottleAdaptiveNoLimit()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+
+            Scene scene = new SceneHelpers().SetupScene();
+
+            IniConfigSource ics = new IniConfigSource();
+            IConfig config = ics.AddConfig("ClientStack.LindenUDP");
+            config.Set("enable_adaptive_throttles", true);
+            config.Set("adaptive_throttle_min_bps", 32000);
+
+            TestLLUDPServer udpServer = ClientStackHelpers.AddUdpServer(scene, ics);
+
+            ScenePresence sp 
+                = ClientStackHelpers.AddChildClient(
+                    scene, udpServer, TestHelpers.ParseTail(0x1), TestHelpers.ParseTail(0x2), 123456);
+
+            LLUDPClient udpClient = ((LLClientView)sp.ControllingClient).UDPClient;
+
+            udpServer.Throttle.DebugLevel = 1;
+            udpClient.ThrottleDebugLevel = 1;
+
+            // Total is 275000
+            int resendBytes = 5000; // this is set low to test the minimum throttle override
+            int landBytes = 20000;
+            int windBytes = 30000;
+            int cloudBytes = 40000;
+            int taskBytes = 50000;
+            int textureBytes = 60000;
+            int assetBytes = 70000;
+            int totalBytes = resendBytes + landBytes + windBytes + cloudBytes + taskBytes + textureBytes + assetBytes;
+
+            SetThrottles(
+                udpClient, resendBytes, landBytes, windBytes, cloudBytes, taskBytes, textureBytes, assetBytes);
+
+            // Ratio of current adaptive drip rate to requested bytes, minimum rate is 32000
+            double commitRatio = 32000.0 / totalBytes;
+
+            AssertThrottles(
+                udpClient, 
+                LLUDPServer.MTU, landBytes * commitRatio, windBytes * commitRatio, cloudBytes * commitRatio, taskBytes * commitRatio,
+                textureBytes * commitRatio, assetBytes * commitRatio, udpClient.FlowThrottle.AdjustedDripRate, totalBytes, 0);
+
+            // Test an increase in target throttle, ack of 20 packets adds 20 * LLUDPServer.MTU bytes
+            // to the throttle, recompute commitratio from those numbers
+            udpClient.FlowThrottle.AcknowledgePackets(20);
+            commitRatio = (32000.0 + 20.0 * LLUDPServer.MTU) / totalBytes;
+
+            AssertThrottles(
+                udpClient, 
+                LLUDPServer.MTU, landBytes * commitRatio, windBytes * commitRatio, cloudBytes * commitRatio, taskBytes * commitRatio,
+                textureBytes * commitRatio, assetBytes * commitRatio, udpClient.FlowThrottle.AdjustedDripRate, totalBytes, 0);
+
+            // Test a decrease in target throttle, adaptive throttle should cut the rate by 50% with a floor
+            // set by the minimum adaptive rate
+            udpClient.FlowThrottle.ExpirePackets(1);
+            commitRatio = (32000.0 + (20.0 * LLUDPServer.MTU)/Math.Pow(2,1)) / totalBytes;
+
+            AssertThrottles(
+                udpClient, 
+                LLUDPServer.MTU, landBytes * commitRatio, windBytes * commitRatio, cloudBytes * commitRatio, taskBytes * commitRatio,
+                textureBytes * commitRatio, assetBytes * commitRatio, udpClient.FlowThrottle.AdjustedDripRate, totalBytes, 0);
+        }
+
+        /// <summary>
+        /// Test throttle setttings where max client throttle has been limited server side.
+        /// </summary>
+        [Test]
+        public void TestSingleClientThrottleRegionLimited()
+        {
+            TestHelpers.InMethod();
+            //            TestHelpers.EnableLogging();
+
+            int resendBytes = 6000;
+            int landBytes = 8000;
+            int windBytes = 10000;
+            int cloudBytes = 12000;
+            int taskBytes = 14000;
+            int textureBytes = 16000;
+            int assetBytes = 18000;
+            int totalBytes 
+                = (int)((resendBytes + landBytes + windBytes + cloudBytes + taskBytes + textureBytes + assetBytes) / 2);
+
+            Scene scene = new SceneHelpers().SetupScene();
+            TestLLUDPServer udpServer = ClientStackHelpers.AddUdpServer(scene);
+            udpServer.Throttle.RequestedDripRate = totalBytes;
+
+            ScenePresence sp1 
+                = ClientStackHelpers.AddChildClient(
+                    scene, udpServer, TestHelpers.ParseTail(0x1), TestHelpers.ParseTail(0x2), 123456);
+
+            LLUDPClient udpClient1 = ((LLClientView)sp1.ControllingClient).UDPClient;
+
+            SetThrottles(
+                udpClient1, resendBytes, landBytes, windBytes, cloudBytes, taskBytes, textureBytes, assetBytes);
+
+            AssertThrottles(
+                udpClient1, 
+                resendBytes / 2, landBytes / 2, windBytes / 2, cloudBytes / 2, taskBytes / 2, 
+                textureBytes / 2, assetBytes / 2, totalBytes, 0, 0);
+
+            // Test: Now add another client
+            ScenePresence sp2
+                = ClientStackHelpers.AddChildClient(
+                    scene, udpServer, TestHelpers.ParseTail(0x10), TestHelpers.ParseTail(0x20), 123457);
+
+            LLUDPClient udpClient2 = ((LLClientView)sp2.ControllingClient).UDPClient;
+            //            udpClient.ThrottleDebugLevel = 1;
+
+            SetThrottles(
+                udpClient2, resendBytes, landBytes, windBytes, cloudBytes, taskBytes, textureBytes, assetBytes);
+
+            AssertThrottles(
+                udpClient1, 
+                resendBytes / 4, landBytes / 4, windBytes / 4, cloudBytes / 4, taskBytes / 4, 
+                textureBytes / 4, assetBytes / 4, totalBytes / 2, 0, 0);
+
+            AssertThrottles(
+                udpClient2, 
+                resendBytes / 4, landBytes / 4, windBytes / 4, cloudBytes / 4, taskBytes / 4, 
+                textureBytes / 4, assetBytes / 4, totalBytes / 2, 0, 0);
+        }
+
+        /// <summary>
+        /// Test throttle setttings where max client throttle has been limited server side.
+        /// </summary>
+        [Test]
+        public void TestClientThrottlePerClientLimited()
+        {
+            TestHelpers.InMethod();
+            //            TestHelpers.EnableLogging();
+
+            int resendBytes = 4000;
+            int landBytes = 6000;
+            int windBytes = 8000;
+            int cloudBytes = 10000;
+            int taskBytes = 12000;
+            int textureBytes = 14000;
+            int assetBytes = 16000;
+            int totalBytes 
+                = (int)((resendBytes + landBytes + windBytes + cloudBytes + taskBytes + textureBytes + assetBytes) / 2);
+
+            Scene scene = new SceneHelpers().SetupScene();
+            TestLLUDPServer udpServer = ClientStackHelpers.AddUdpServer(scene);
+            udpServer.ThrottleRates.Total = totalBytes;
+
+            ScenePresence sp 
+                = ClientStackHelpers.AddChildClient(
+                    scene, udpServer, TestHelpers.ParseTail(0x1), TestHelpers.ParseTail(0x2), 123456);
+
+            LLUDPClient udpClient = ((LLClientView)sp.ControllingClient).UDPClient;
+            //            udpClient.ThrottleDebugLevel = 1;
+
+            SetThrottles(
+                udpClient, resendBytes, landBytes, windBytes, cloudBytes, taskBytes, textureBytes, assetBytes);
+
+            AssertThrottles(
+                udpClient, 
+                resendBytes / 2, landBytes / 2, windBytes / 2, cloudBytes / 2, taskBytes / 2, 
+                textureBytes / 2, assetBytes / 2, totalBytes, 0, totalBytes);
+        }
+
+        [Test]
+        public void TestClientThrottlePerClientAndRegionLimited()
+        {
+            TestHelpers.InMethod();
+            //TestHelpers.EnableLogging();
+
+            int resendBytes = 4000;
+            int landBytes = 6000;
+            int windBytes = 8000;
+            int cloudBytes = 10000;
+            int taskBytes = 12000;
+            int textureBytes = 14000;
+            int assetBytes = 16000;
+
+            // current total 70000
+            int totalBytes = resendBytes + landBytes + windBytes + cloudBytes + taskBytes + textureBytes + assetBytes;
+
+            Scene scene = new SceneHelpers().SetupScene();
+            TestLLUDPServer udpServer = ClientStackHelpers.AddUdpServer(scene);
+            udpServer.ThrottleRates.Total = (int)(totalBytes * 1.1);
+            udpServer.Throttle.RequestedDripRate = (int)(totalBytes * 1.5);
+
+            ScenePresence sp1 
+                = ClientStackHelpers.AddChildClient(
+                    scene, udpServer, TestHelpers.ParseTail(0x1), TestHelpers.ParseTail(0x2), 123456);
+
+            LLUDPClient udpClient1 = ((LLClientView)sp1.ControllingClient).UDPClient;
+            udpClient1.ThrottleDebugLevel = 1;
+
+            SetThrottles(
+                udpClient1, resendBytes, landBytes, windBytes, cloudBytes, taskBytes, textureBytes, assetBytes);
+
+            AssertThrottles(
+                udpClient1, 
+                resendBytes, landBytes, windBytes, cloudBytes, taskBytes, 
+                textureBytes, assetBytes, totalBytes, 0, totalBytes * 1.1);
+
+            // Now add another client
+            ScenePresence sp2
+                = ClientStackHelpers.AddChildClient(
+                    scene, udpServer, TestHelpers.ParseTail(0x10), TestHelpers.ParseTail(0x20), 123457);
+
+            LLUDPClient udpClient2 = ((LLClientView)sp2.ControllingClient).UDPClient;
+            udpClient2.ThrottleDebugLevel = 1;
+
+            SetThrottles(
+                udpClient2, resendBytes, landBytes, windBytes, cloudBytes, taskBytes, textureBytes, assetBytes);
+
+            AssertThrottles(
+                udpClient1, 
+                resendBytes * 0.75, landBytes * 0.75, windBytes * 0.75, cloudBytes * 0.75, taskBytes * 0.75, 
+                textureBytes * 0.75, assetBytes * 0.75, totalBytes * 0.75, 0, totalBytes * 1.1);
+
+            AssertThrottles(
+                udpClient2, 
+                resendBytes * 0.75, landBytes * 0.75, windBytes * 0.75, cloudBytes * 0.75, taskBytes * 0.75, 
+                textureBytes * 0.75, assetBytes * 0.75, totalBytes * 0.75, 0, totalBytes * 1.1);
+        }
+
+        private void AssertThrottles(
+            LLUDPClient udpClient, 
+            double resendBytes, double landBytes, double windBytes, double cloudBytes, double taskBytes, double textureBytes, double assetBytes,
+            double totalBytes, double targetBytes, double maxBytes)
+        {
+            ClientInfo ci = udpClient.GetClientInfo();
+
+//                            Console.WriteLine(
+//                                "Resend={0}, Land={1}, Wind={2}, Cloud={3}, Task={4}, Texture={5}, Asset={6}, TOTAL = {7}", 
+//                                ci.resendThrottle, ci.landThrottle, ci.windThrottle, ci.cloudThrottle, ci.taskThrottle, ci.textureThrottle, ci.assetThrottle, ci.totalThrottle);
+
+            Assert.AreEqual((int)resendBytes, ci.resendThrottle, "Resend");
+            Assert.AreEqual((int)landBytes, ci.landThrottle, "Land");
+            Assert.AreEqual((int)windBytes, ci.windThrottle, "Wind");
+            Assert.AreEqual((int)cloudBytes, ci.cloudThrottle, "Cloud");
+            Assert.AreEqual((int)taskBytes, ci.taskThrottle, "Task");
+            Assert.AreEqual((int)textureBytes, ci.textureThrottle, "Texture");
+            Assert.AreEqual((int)assetBytes, ci.assetThrottle, "Asset");
+            Assert.AreEqual((int)totalBytes, ci.totalThrottle, "Total");
+            Assert.AreEqual((int)targetBytes, ci.targetThrottle, "Target");
+            Assert.AreEqual((int)maxBytes, ci.maxThrottle, "Max");
+        }
+
+        private void SetThrottles(
+            LLUDPClient udpClient, int resendBytes, int landBytes, int windBytes, int cloudBytes, int taskBytes, int textureBytes, int assetBytes)
+        {
+            byte[] throttles = new byte[28];
+
+            Array.Copy(BitConverter.GetBytes((float)resendBytes * 8), 0, throttles, 0, 4);
+            Array.Copy(BitConverter.GetBytes((float)landBytes * 8), 0, throttles, 4, 4);
+            Array.Copy(BitConverter.GetBytes((float)windBytes * 8), 0, throttles, 8, 4);
+            Array.Copy(BitConverter.GetBytes((float)cloudBytes * 8), 0, throttles, 12, 4);
+            Array.Copy(BitConverter.GetBytes((float)taskBytes * 8), 0, throttles, 16, 4);
+            Array.Copy(BitConverter.GetBytes((float)textureBytes * 8), 0, throttles, 20, 4);
+            Array.Copy(BitConverter.GetBytes((float)assetBytes * 8), 0, throttles, 24, 4);
+
+            udpClient.SetThrottles(throttles);
+        }
+    }
+}
\ No newline at end of file