Merge pull request #194 from Fate-JH/pca

Packet Splitting, Bundling

common/src/test/scala/control/MultiPacketCollectorTest.scala

@@ -0,0 +1,183 @@
+// Copyright (c) 2017 PSForever
+package control
+
+import org.specs2.mutable._
+import net.psforever.packet.control.{ControlSync, MultiPacketBundle, MultiPacketCollector}
+import net.psforever.packet.crypto.{ClientFinished, ServerFinished}
+import net.psforever.packet.game.{ObjectDeleteMessage, PlanetSideGUID}
+
+class MultiPacketCollectorTest extends Specification {
+  val packet1 = ObjectDeleteMessage(PlanetSideGUID(1103), 2)
+
+  "MultiPacketBundle" should {
+    import scodec.bits._
+    val packet2 = ControlSync(21096, 0x4d, 0x52, 0x4d, 0x7c, 0x4d, 0x276, 0x275)
+
+    "construct" in {
+      MultiPacketBundle(List(packet1))
+      ok
+    }
+
+    "fail to construct if not initialized with PlanetSidePackets" in {
+      MultiPacketBundle(Nil) must throwA[IllegalArgumentException]
+    }
+
+    "concatenate bundles into a new bundle" in {
+      val obj1 = MultiPacketBundle(List(packet1))
+      val obj2 = MultiPacketBundle(List(packet2))
+      val obj3 = obj1 + obj2
+      obj3 match {
+        case MultiPacketBundle(list) =>
+          list.size mustEqual 2
+          list.head mustEqual packet1
+          list(1) mustEqual packet2
+        case _ =>
+          ko
+      }
+    }
+
+    "accept PlanetSideGamePackets and PlanetSideControlPackets" in {
+      MultiPacketBundle(List(packet2, packet1)) match {
+        case MultiPacketBundle(list) =>
+          list.size mustEqual 2
+          list.head mustEqual packet2
+          list(1) mustEqual packet1
+        case _ =>
+          ko
+      }
+    }
+
+    "ignore other types of PlanetSideContainerPackets" in {
+      val param = List(packet2, ClientFinished(hex"", hex""), packet1, ServerFinished(hex""))
+      MultiPacketBundle(param) match { //warning message will display in log
+        case MultiPacketBundle(list) =>
+          list.size mustEqual 2
+          list.head mustEqual param.head
+          list(1) mustEqual param(2)
+        case _ =>
+          ko
+      }
+    }
+  }
+
+  "MultiPacketCollector" should {
+    val packet2 = ObjectDeleteMessage(PlanetSideGUID(1105), 2)
+    val packet3 = ObjectDeleteMessage(PlanetSideGUID(1107), 2)
+
+    "construct" in {
+      new MultiPacketCollector()
+      ok
+    }
+
+    "construct with initial packets" in {
+      MultiPacketCollector(List(packet1, packet2))
+      ok
+    }
+
+    "can retrieve a bundle packets" in {
+      val obj = MultiPacketCollector(List(packet1, packet2))
+      obj.Bundle match {
+        case MultiPacketBundle(list) =>
+          list.size mustEqual 2
+          list.head mustEqual packet1
+          list(1) mustEqual packet2
+        case _ =>
+          ko
+      }
+    }
+
+    "can not retrieve a bundle of non-existent packets" in {
+      val obj = new MultiPacketCollector()
+      obj.Bundle must throwA[RuntimeException]
+    }
+
+    "can safely retrieve a bundle of potential packets" in {
+      val obj1 = new MultiPacketCollector()
+      obj1.BundleOption match {
+        case Some(_) =>
+          ko
+        case _ => ;
+      }
+
+      val obj2 = MultiPacketCollector(List(packet1, packet2))
+      obj2.BundleOption match {
+        case None =>
+          ko
+        case Some(MultiPacketBundle(list)) =>
+          list.size mustEqual 2
+          list.head mustEqual packet1
+          list(1) mustEqual packet2
+      }
+    }
+
+    "clear packets after being asked to bundle" in {
+      val list = List(packet1, packet2)
+      val obj = MultiPacketCollector(list)
+      obj.Bundle mustEqual MultiPacketBundle(list)
+      obj.Bundle must throwA[RuntimeException]
+    }
+
+    "add a packet" in {
+      val obj = new MultiPacketCollector()
+      obj.Add(packet1)
+      obj.Bundle match {
+        case MultiPacketBundle(list) =>
+          list.size mustEqual 1
+          list.head mustEqual packet1
+        case _ =>
+          ko
+      }
+    }
+
+    "add packets" in {
+      val obj = new MultiPacketCollector()
+      obj.Add(List(packet1, packet2))
+      obj.Bundle match {
+        case MultiPacketBundle(list) =>
+          list.size mustEqual 2
+          list.head mustEqual packet1
+          list(1) mustEqual packet2
+        case _ =>
+          ko
+      }
+    }
+
+    "concatenate bundles (1)" in {
+
+      val obj1 = new MultiPacketCollector()
+      obj1.Add(List(packet1, packet2))
+      val bundle1 = obj1.Bundle
+
+      val obj2 = MultiPacketCollector(bundle1)
+      obj2.Add(packet3)
+      obj2.Bundle match {
+        case MultiPacketBundle(list) =>
+          list.size mustEqual 3
+          list.head mustEqual packet1
+          list(1) mustEqual packet2
+          list(2) mustEqual packet3
+        case _ =>
+          ko
+      }
+    }
+
+    "concatenate bundles (2)" in {
+      val obj1 = new MultiPacketCollector()
+      obj1.Add(List(packet1, packet2))
+      val bundle1 = obj1.Bundle
+
+      val obj2 = new MultiPacketCollector()
+      obj2.Add(packet3)
+      obj2.Add(bundle1)
+      obj2.Bundle match {
+        case MultiPacketBundle(list) =>
+          list.size mustEqual 3
+          list.head mustEqual packet3
+          list(1) mustEqual packet1
+          list(2) mustEqual packet2
+        case _ =>
+          ko
+      }
+    }
+  }
+}

common/src/test/scala/control/RelatedATest.scala

@@ -3,24 +3,80 @@ package control
 
 import org.specs2.mutable._
 import net.psforever.packet._
-import net.psforever.packet.control._
+import net.psforever.packet.control.RelatedA
 import scodec.bits._
 
 class RelatedATest extends Specification {
   val string0 = hex"00 11 01 04"
+  val string1 = hex"00 12 01 04"
+  val string2 = hex"00 13 01 04"
+  val string3 = hex"00 14 01 04"
 
   "decode (0)" in {
     PacketCoding.DecodePacket(string0).require match {
-      case RelatedA0(slot) =>
-        slot mustEqual 260
+      case RelatedA(slot, subslot) =>
+        slot mustEqual 0
+        subslot mustEqual 260
+      case _ =>
+        ko
+    }
+  }
+
+  "decode (1)" in {
+    PacketCoding.DecodePacket(string1).require match {
+      case RelatedA(slot, subslot) =>
+        slot mustEqual 1
+        subslot mustEqual 260
+      case _ =>
+        ko
+    }
+  }
+
+  "decode (2)" in {
+    PacketCoding.DecodePacket(string2).require match {
+      case RelatedA(slot, subslot) =>
+        slot mustEqual 2
+        subslot mustEqual 260
+      case _ =>
+        ko
+    }
+  }
+
+  "decode (3)" in {
+    PacketCoding.DecodePacket(string3).require match {
+      case RelatedA(slot, subslot) =>
+        slot mustEqual 3
+        subslot mustEqual 260
       case _ =>
         ko
     }
   }
 
   "encode (0)" in {
-    val pkt = RelatedA0(260)
+    val pkt = RelatedA(0, 260)
     val msg = PacketCoding.EncodePacket(pkt).require.toByteVector
     msg mustEqual string0
   }
+
+  "encode (1)" in {
+    val pkt = RelatedA(1, 260)
+    val msg = PacketCoding.EncodePacket(pkt).require.toByteVector
+    msg mustEqual string1
+  }
+
+  "encode (2)" in {
+    val pkt = RelatedA(2, 260)
+    val msg = PacketCoding.EncodePacket(pkt).require.toByteVector
+    msg mustEqual string2
+  }
+
+  "encode (3)" in {
+    val pkt = RelatedA(3, 260)
+    val msg = PacketCoding.EncodePacket(pkt).require.toByteVector
+    msg mustEqual string3
+  }
+
+  "encode (n)" in {
+    RelatedA(4, 260) must throwA[IllegalArgumentException]
+  }
 }

common/src/test/scala/control/RelatedBTest.scala

@@ -3,24 +3,80 @@ package control
 
 import org.specs2.mutable._
 import net.psforever.packet._
-import net.psforever.packet.control._
+import net.psforever.packet.control.RelatedB
 import scodec.bits._
 
 class RelatedBTest extends Specification {
   val string0 = hex"00 15 01 04"
+  val string1 = hex"00 16 01 04"
+  val string2 = hex"00 17 01 04"
+  val string3 = hex"00 18 01 04"
 
   "decode (0)" in {
     PacketCoding.DecodePacket(string0).require match {
-      case RelatedB0(slot) =>
-        slot mustEqual 260
+      case RelatedB(slot, subslot) =>
+        slot mustEqual 0
+        subslot mustEqual 260
+      case _ =>
+        ko
+    }
+  }
+
+  "decode (1)" in {
+    PacketCoding.DecodePacket(string1).require match {
+      case RelatedB(slot, subslot) =>
+        slot mustEqual 1
+        subslot mustEqual 260
+      case _ =>
+        ko
+    }
+  }
+
+  "decode (2)" in {
+    PacketCoding.DecodePacket(string2).require match {
+      case RelatedB(slot, subslot) =>
+        slot mustEqual 2
+        subslot mustEqual 260
+      case _ =>
+        ko
+    }
+  }
+
+  "decode (3)" in {
+    PacketCoding.DecodePacket(string3).require match {
+      case RelatedB(slot, subslot) =>
+        slot mustEqual 3
+        subslot mustEqual 260
       case _ =>
         ko
     }
   }
 
   "encode (0)" in {
-    val pkt = RelatedB0(260)
+    val pkt = RelatedB(0, 260)
     val msg = PacketCoding.EncodePacket(pkt).require.toByteVector
     msg mustEqual string0
   }
+
+  "encode (1)" in {
+    val pkt = RelatedB(1, 260)
+    val msg = PacketCoding.EncodePacket(pkt).require.toByteVector
+    msg mustEqual string1
+  }
+
+  "encode (2)" in {
+    val pkt = RelatedB(2, 260)
+    val msg = PacketCoding.EncodePacket(pkt).require.toByteVector
+    msg mustEqual string2
+  }
+
+  "encode (3)" in {
+    val pkt = RelatedB(3, 260)
+    val msg = PacketCoding.EncodePacket(pkt).require.toByteVector
+    msg mustEqual string3
+  }
+
+  "encode (n)" in {
+    RelatedB(4, 260) must throwA[IllegalArgumentException]
+  }
 }

common/src/test/scala/control/SlottedMetaAckTest.scala

@@ -1,29 +0,0 @@
-// Copyright (c) 2017 PSForever
-package control
-
-import org.specs2.mutable._
-import net.psforever.packet._
-import net.psforever.packet.control._
-import scodec.bits._
-
-class SlottedMetaAckTest extends Specification {
-  val string = hex"00150da4"
-
-  "decode" in {
-    PacketCoding.DecodePacket(string).require match {
-      case SlottedMetaAck(_, _) =>
-        ko
-      case RelatedB0(subslot) => //important!
-        subslot mustEqual 3492
-      case _ =>
-        ko
-    }
-  }
-
-  "encode" in {
-    val pkt = SlottedMetaAck(0, 3492)
-    val msg = PacketCoding.EncodePacket(pkt).require.toByteVector
-
-    msg mustEqual string
-  }
-}