IVGCVSW-4541 Modify Timeline Packet construction

 * Changed TimelinePacket encoding so that there is only one header for
   multiple timeline swtrace messages
 * Refactored function names to have more suitable description
 * Refactored CodeStyle to coincide with ArmNN coding standards
 * Refactored profiling test names to be descriptive
 * Refactored ErrorCode name to TimelineStatus
 * Updated existing unit tests

Signed-off-by: Keith Davis <keith.davis@arm.com>
Change-Id: I83bd4bb9e7393617bca97eba96a6e1388916e5b0

1 files changed, 145 insertions, 298 deletions

diff --git a/src/profiling/test/TimelinePacketTests.cpp b/src/profiling/test/TimelinePacketTests.cpp
index 824f055a41..1d5d45176c 100644
--- a/src/profiling/test/TimelinePacketTests.cpp
+++ b/src/profiling/test/TimelinePacketTests.cpp
@@ -12,7 +12,7 @@ using namespace armnn::profiling;
 
 BOOST_AUTO_TEST_SUITE(TimelinePacketTests)
 
-BOOST_AUTO_TEST_CASE(TimelineLabelPacketTest1)
+BOOST_AUTO_TEST_CASE(TimelineLabelPacketTestNoBuffer)
 {
     const uint64_t profilingGuid = 123456u;
     const std::string label = "some label";
@@ -26,7 +26,7 @@ BOOST_AUTO_TEST_CASE(TimelineLabelPacketTest1)
     BOOST_CHECK(numberOfBytesWritten == 0);
 }
 
-BOOST_AUTO_TEST_CASE(TimelineLabelPacketTest2)
+BOOST_AUTO_TEST_CASE(TimelineLabelPacketTestBufferExhaustionZeroValue)
 {
     std::vector<unsigned char> buffer(512, 0);
 
@@ -42,7 +42,7 @@ BOOST_AUTO_TEST_CASE(TimelineLabelPacketTest2)
     BOOST_CHECK(numberOfBytesWritten == 0);
 }
 
-BOOST_AUTO_TEST_CASE(TimelineLabelPacketTest3)
+BOOST_AUTO_TEST_CASE(TimelineLabelPacketTestBufferExhaustionFixedValue)
 {
     std::vector<unsigned char> buffer(10, 0);
 
@@ -58,7 +58,7 @@ BOOST_AUTO_TEST_CASE(TimelineLabelPacketTest3)
     BOOST_CHECK(numberOfBytesWritten == 0);
 }
 
-BOOST_AUTO_TEST_CASE(TimelineLabelPacketTest4)
+BOOST_AUTO_TEST_CASE(TimelineLabelPacketTestInvalidLabel)
 {
     std::vector<unsigned char> buffer(512, 0);
 
@@ -74,7 +74,7 @@ BOOST_AUTO_TEST_CASE(TimelineLabelPacketTest4)
     BOOST_CHECK(numberOfBytesWritten == 0);
 }
 
-BOOST_AUTO_TEST_CASE(TimelineLabelPacketTest5)
+BOOST_AUTO_TEST_CASE(TimelineLabelPacketTestSingleConstructionOfData)
 {
     std::vector<unsigned char> buffer(512, 0);
 
@@ -87,32 +87,13 @@ BOOST_AUTO_TEST_CASE(TimelineLabelPacketTest5)
                                                                  boost::numeric_cast<unsigned int>(buffer.size()),
                                                                  numberOfBytesWritten);
     BOOST_CHECK(result == TimelinePacketStatus::Ok);
-    BOOST_CHECK(numberOfBytesWritten == 36);
+    BOOST_CHECK(numberOfBytesWritten == 28);
 
     unsigned int uint32_t_size = sizeof(uint32_t);
     unsigned int uint64_t_size = sizeof(uint64_t);
 
     // Check the packet header
     unsigned int offset = 0;
-    uint32_t packetHeaderWord0 = ReadUint32(buffer.data(), offset);
-    uint32_t packetFamily = (packetHeaderWord0 >> 26) & 0x0000003F;
-    uint32_t packetClass  = (packetHeaderWord0 >> 19) & 0x0000007F;
-    uint32_t packetType   = (packetHeaderWord0 >> 16) & 0x00000007;
-    uint32_t streamId     = (packetHeaderWord0 >>  0) & 0x00000007;
-    BOOST_CHECK(packetFamily == 1);
-    BOOST_CHECK(packetClass  == 0);
-    BOOST_CHECK(packetType   == 1);
-    BOOST_CHECK(streamId     == 0);
-
-    offset += uint32_t_size;
-    uint32_t packetHeaderWord1 = ReadUint32(buffer.data(), offset);
-    uint32_t sequenceNumbered = (packetHeaderWord1 >> 24) & 0x00000001;
-    uint32_t dataLength       = (packetHeaderWord1 >>  0) & 0x00FFFFFF;
-    BOOST_CHECK(sequenceNumbered ==  0);
-    BOOST_CHECK(dataLength       == 28);
-
-    // Check decl_Id
-    offset += uint32_t_size;
     uint32_t decl_Id = ReadUint32(buffer.data(), offset);
     BOOST_CHECK(decl_Id == uint32_t(0));
 
@@ -142,13 +123,13 @@ BOOST_AUTO_TEST_CASE(TimelineRelationshipPacketNullBufferTest)
     const uint64_t headGuid = 234567u;
     const uint64_t tailGuid = 345678u;
     unsigned int numberOfBytesWritten = 789u;
-    TimelinePacketStatus result = WriteTimelineRelationshipBinaryPacket(relationshipType,
-                                                                        relationshipGuid,
-                                                                        headGuid,
-                                                                        tailGuid,
-                                                                        nullptr,
-                                                                        512u,
-                                                                        numberOfBytesWritten);
+    TimelinePacketStatus result = WriteTimelineRelationshipBinary(relationshipType,
+                                                                  relationshipGuid,
+                                                                  headGuid,
+                                                                  tailGuid,
+                                                                  nullptr,
+                                                                  512u,
+                                                                  numberOfBytesWritten);
     BOOST_CHECK(result == TimelinePacketStatus::BufferExhaustion);
     BOOST_CHECK(numberOfBytesWritten == 0);
 }
@@ -162,13 +143,13 @@ BOOST_AUTO_TEST_CASE(TimelineRelationshipPacketZeroBufferSizeTest)
     const uint64_t headGuid = 234567u;
     const uint64_t tailGuid = 345678u;
     unsigned int numberOfBytesWritten = 789u;
-    TimelinePacketStatus result = WriteTimelineRelationshipBinaryPacket(relationshipType,
-                                                                        relationshipGuid,
-                                                                        headGuid,
-                                                                        tailGuid,
-                                                                        buffer.data(),
-                                                                        0,
-                                                                        numberOfBytesWritten);
+    TimelinePacketStatus result = WriteTimelineRelationshipBinary(relationshipType,
+                                                                  relationshipGuid,
+                                                                  headGuid,
+                                                                  tailGuid,
+                                                                  buffer.data(),
+                                                                  0,
+                                                                  numberOfBytesWritten);
     BOOST_CHECK(result == TimelinePacketStatus::BufferExhaustion);
     BOOST_CHECK(numberOfBytesWritten == 0);
 }
@@ -183,13 +164,13 @@ BOOST_AUTO_TEST_CASE(TimelineRelationshipPacketSmallBufferSizeTest)
     const uint64_t tailGuid = 345678u;
     unsigned int numberOfBytesWritten = 789u;
     TimelinePacketStatus result =
-        WriteTimelineRelationshipBinaryPacket(relationshipType,
-                                              relationshipGuid,
-                                              headGuid,
-                                              tailGuid,
-                                              buffer.data(),
-                                              boost::numeric_cast<unsigned int>(buffer.size()),
-                                              numberOfBytesWritten);
+                             WriteTimelineRelationshipBinary(relationshipType,
+                                                             relationshipGuid,
+                                                             headGuid,
+                                                             tailGuid,
+                                                             buffer.data(),
+                                                             boost::numeric_cast<unsigned int>(buffer.size()),
+                                                             numberOfBytesWritten);
     BOOST_CHECK(result == TimelinePacketStatus::BufferExhaustion);
     BOOST_CHECK(numberOfBytesWritten == 0);
 }
@@ -203,19 +184,19 @@ BOOST_AUTO_TEST_CASE(TimelineRelationshipPacketInvalidRelationTest)
     const uint64_t tailGuid = 345678u;
     unsigned int numberOfBytesWritten = 789u;
 
-    BOOST_CHECK_THROW(WriteTimelineRelationshipBinaryPacket(relationshipType,
-                                                            relationshipGuid,
-                                                            headGuid,
-                                                            tailGuid,
-                                                            buffer.data(),
-                                                            boost::numeric_cast<unsigned int>(buffer.size()),
-                                                            numberOfBytesWritten),
-                       armnn::InvalidArgumentException);
+    BOOST_CHECK_THROW(WriteTimelineRelationshipBinary(relationshipType,
+                                                      relationshipGuid,
+                                                      headGuid,
+                                                      tailGuid,
+                                                      buffer.data(),
+                                                      boost::numeric_cast<unsigned int>(buffer.size()),
+                                                      numberOfBytesWritten),
+                      armnn::InvalidArgumentException);
 
     BOOST_CHECK(numberOfBytesWritten == 0);
 }
 
-BOOST_AUTO_TEST_CASE(TimelineRelationshipPacketTest)
+BOOST_AUTO_TEST_CASE(TimelineRelationshipPacketTestDataConstruction)
 {
     std::vector<unsigned char> buffer(512, 0);
 
@@ -225,40 +206,22 @@ BOOST_AUTO_TEST_CASE(TimelineRelationshipPacketTest)
     const uint64_t tailGuid = 345678u;
     unsigned int numberOfBytesWritten = 789u;
     TimelinePacketStatus result =
-        WriteTimelineRelationshipBinaryPacket(relationshipType,
-                                              relationshipGuid,
-                                              headGuid,
-                                              tailGuid,
-                                              buffer.data(),
-                                              boost::numeric_cast<unsigned int>(buffer.size()),
-                                              numberOfBytesWritten);
+                             WriteTimelineRelationshipBinary(relationshipType,
+                                                             relationshipGuid,
+                                                             headGuid,
+                                                             tailGuid,
+                                                             buffer.data(),
+                                                             boost::numeric_cast<unsigned int>(buffer.size()),
+                                                             numberOfBytesWritten);
     BOOST_CHECK(result == TimelinePacketStatus::Ok);
-    BOOST_CHECK(numberOfBytesWritten == 40);
+    BOOST_CHECK(numberOfBytesWritten == 32);
 
     unsigned int uint32_t_size = sizeof(uint32_t);
     unsigned int uint64_t_size = sizeof(uint64_t);
 
     // Check the packet header
     unsigned int offset = 0;
-    uint32_t packetHeaderWord0 = ReadUint32(buffer.data(), offset);
-    uint32_t packetFamily = (packetHeaderWord0 >> 26) & 0x0000003F;
-    uint32_t packetClass  = (packetHeaderWord0 >> 19) & 0x0000007F;
-    uint32_t packetType   = (packetHeaderWord0 >> 16) & 0x00000007;
-    uint32_t streamId     = (packetHeaderWord0 >>  0) & 0x00000007;
-    BOOST_CHECK(packetFamily == 1);
-    BOOST_CHECK(packetClass  == 0);
-    BOOST_CHECK(packetType   == 1);
-    BOOST_CHECK(streamId     == 0);
-
-    offset += uint32_t_size;
-    uint32_t packetHeaderWord1 = ReadUint32(buffer.data(), offset);
-    uint32_t sequenceNumbered = (packetHeaderWord1 >> 24) & 0x00000001;
-    uint32_t dataLength       = (packetHeaderWord1 >>  0) & 0x00FFFFFF;
-    BOOST_CHECK(sequenceNumbered ==  0);
-    BOOST_CHECK(dataLength       == 32);
-
     // Check the decl_id
-    offset += uint32_t_size;
     uint32_t readDeclId = ReadUint32(buffer.data(), offset);
     BOOST_CHECK(readDeclId == 3);
 
@@ -283,7 +246,7 @@ BOOST_AUTO_TEST_CASE(TimelineRelationshipPacketTest)
     BOOST_CHECK(readTailGuid == tailGuid);
 }
 
-BOOST_AUTO_TEST_CASE(TimelineRelationshipPacketExecutionLinkTest)
+BOOST_AUTO_TEST_CASE(TimelineRelationshipPacketExecutionLinkTestDataConstruction)
 {
     std::vector<unsigned char> buffer(512, 0);
 
@@ -293,40 +256,20 @@ BOOST_AUTO_TEST_CASE(TimelineRelationshipPacketExecutionLinkTest)
     const uint64_t tailGuid = 345678u;
     unsigned int numberOfBytesWritten = 789u;
     TimelinePacketStatus result =
-        WriteTimelineRelationshipBinaryPacket(relationshipType,
-                                              relationshipGuid,
-                                              headGuid,
-                                              tailGuid,
-                                              buffer.data(),
-                                              boost::numeric_cast<unsigned int>(buffer.size()),
-                                              numberOfBytesWritten);
+                             WriteTimelineRelationshipBinary(relationshipType,
+                                                             relationshipGuid,
+                                                             headGuid,
+                                                             tailGuid,
+                                                             buffer.data(),
+                                                             boost::numeric_cast<unsigned int>(buffer.size()),
+                                                             numberOfBytesWritten);
     BOOST_CHECK(result == TimelinePacketStatus::Ok);
-    BOOST_CHECK(numberOfBytesWritten == 40);
+    BOOST_CHECK(numberOfBytesWritten == 32);
 
     unsigned int uint32_t_size = sizeof(uint32_t);
     unsigned int uint64_t_size = sizeof(uint64_t);
 
-    // Check the packet header
     unsigned int offset = 0;
-    uint32_t packetHeaderWord0 = ReadUint32(buffer.data(), offset);
-    uint32_t packetFamily = (packetHeaderWord0 >> 26) & 0x0000003F;
-    uint32_t packetClass  = (packetHeaderWord0 >> 19) & 0x0000007F;
-    uint32_t packetType   = (packetHeaderWord0 >> 16) & 0x00000007;
-    uint32_t streamId     = (packetHeaderWord0 >>  0) & 0x00000007;
-    BOOST_CHECK(packetFamily == 1);
-    BOOST_CHECK(packetClass  == 0);
-    BOOST_CHECK(packetType   == 1);
-    BOOST_CHECK(streamId     == 0);
-
-    offset += uint32_t_size;
-    uint32_t packetHeaderWord1 = ReadUint32(buffer.data(), offset);
-    uint32_t sequenceNumbered = (packetHeaderWord1 >> 24) & 0x00000001;
-    uint32_t dataLength       = (packetHeaderWord1 >>  0) & 0x00FFFFFF;
-    BOOST_CHECK(sequenceNumbered ==  0);
-    BOOST_CHECK(dataLength       == 32);
-
-    // Check the decl_id
-    offset += uint32_t_size;
     uint32_t readDeclId = ReadUint32(buffer.data(), offset);
     BOOST_CHECK(readDeclId == 3);
 
@@ -352,7 +295,7 @@ BOOST_AUTO_TEST_CASE(TimelineRelationshipPacketExecutionLinkTest)
 }
 
 
-BOOST_AUTO_TEST_CASE(TimelineRelationshipPacketDataLinkTest)
+BOOST_AUTO_TEST_CASE(TimelineRelationshipPacketDataLinkTestDataConstruction)
 {
     std::vector<unsigned char> buffer(512, 0);
 
@@ -362,40 +305,20 @@ BOOST_AUTO_TEST_CASE(TimelineRelationshipPacketDataLinkTest)
     const uint64_t tailGuid = 345678u;
     unsigned int numberOfBytesWritten = 789u;
     TimelinePacketStatus result =
-        WriteTimelineRelationshipBinaryPacket(relationshipType,
-                                              relationshipGuid,
-                                              headGuid,
-                                              tailGuid,
-                                              buffer.data(),
-                                              boost::numeric_cast<unsigned int>(buffer.size()),
-                                              numberOfBytesWritten);
+                             WriteTimelineRelationshipBinary(relationshipType,
+                                                             relationshipGuid,
+                                                             headGuid,
+                                                             tailGuid,
+                                                             buffer.data(),
+                                                             boost::numeric_cast<unsigned int>(buffer.size()),
+                                                             numberOfBytesWritten);
     BOOST_CHECK(result == TimelinePacketStatus::Ok);
-    BOOST_CHECK(numberOfBytesWritten == 40);
+    BOOST_CHECK(numberOfBytesWritten == 32);
 
     unsigned int uint32_t_size = sizeof(uint32_t);
     unsigned int uint64_t_size = sizeof(uint64_t);
 
-    // Check the packet header
     unsigned int offset = 0;
-    uint32_t packetHeaderWord0 = ReadUint32(buffer.data(), offset);
-    uint32_t packetFamily = (packetHeaderWord0 >> 26) & 0x0000003F;
-    uint32_t packetClass  = (packetHeaderWord0 >> 19) & 0x0000007F;
-    uint32_t packetType   = (packetHeaderWord0 >> 16) & 0x00000007;
-    uint32_t streamId     = (packetHeaderWord0 >>  0) & 0x00000007;
-    BOOST_CHECK(packetFamily == 1);
-    BOOST_CHECK(packetClass  == 0);
-    BOOST_CHECK(packetType   == 1);
-    BOOST_CHECK(streamId     == 0);
-
-    offset += uint32_t_size;
-    uint32_t packetHeaderWord1 = ReadUint32(buffer.data(), offset);
-    uint32_t sequenceNumbered = (packetHeaderWord1 >> 24) & 0x00000001;
-    uint32_t dataLength       = (packetHeaderWord1 >>  0) & 0x00FFFFFF;
-    BOOST_CHECK(sequenceNumbered ==  0);
-    BOOST_CHECK(dataLength       == 32);
-
-    // Check the decl_id
-    offset += uint32_t_size;
     uint32_t readDeclId = ReadUint32(buffer.data(), offset);
     BOOST_CHECK(readDeclId == 3);
 
@@ -421,7 +344,7 @@ BOOST_AUTO_TEST_CASE(TimelineRelationshipPacketDataLinkTest)
 }
 
 
-BOOST_AUTO_TEST_CASE(TimelineRelationshipPacketLabelLinkTest)
+BOOST_AUTO_TEST_CASE(TimelineRelationshipPacketLabelLinkTestDataConstruction)
 {
     std::vector<unsigned char> buffer(512, 0);
 
@@ -431,40 +354,21 @@ BOOST_AUTO_TEST_CASE(TimelineRelationshipPacketLabelLinkTest)
     const uint64_t tailGuid = 345678u;
     unsigned int numberOfBytesWritten = 789u;
     TimelinePacketStatus result =
-        WriteTimelineRelationshipBinaryPacket(relationshipType,
-                                              relationshipGuid,
-                                              headGuid,
-                                              tailGuid,
-                                              buffer.data(),
-                                              boost::numeric_cast<unsigned int>(buffer.size()),
-                                              numberOfBytesWritten);
+                             WriteTimelineRelationshipBinary(relationshipType,
+                                                             relationshipGuid,
+                                                             headGuid,
+                                                             tailGuid,
+                                                             buffer.data(),
+                                                             boost::numeric_cast<unsigned int>(buffer.size()),
+                                                             numberOfBytesWritten);
     BOOST_CHECK(result == TimelinePacketStatus::Ok);
-    BOOST_CHECK(numberOfBytesWritten == 40);
+    BOOST_CHECK(numberOfBytesWritten == 32);
 
     unsigned int uint32_t_size = sizeof(uint32_t);
     unsigned int uint64_t_size = sizeof(uint64_t);
 
     // Check the packet header
     unsigned int offset = 0;
-    uint32_t packetHeaderWord0 = ReadUint32(buffer.data(), offset);
-    uint32_t packetFamily = (packetHeaderWord0 >> 26) & 0x0000003F;
-    uint32_t packetClass  = (packetHeaderWord0 >> 19) & 0x0000007F;
-    uint32_t packetType   = (packetHeaderWord0 >> 16) & 0x00000007;
-    uint32_t streamId     = (packetHeaderWord0 >>  0) & 0x00000007;
-    BOOST_CHECK(packetFamily == 1);
-    BOOST_CHECK(packetClass  == 0);
-    BOOST_CHECK(packetType   == 1);
-    BOOST_CHECK(streamId     == 0);
-
-    offset += uint32_t_size;
-    uint32_t packetHeaderWord1 = ReadUint32(buffer.data(), offset);
-    uint32_t sequenceNumbered = (packetHeaderWord1 >> 24) & 0x00000001;
-    uint32_t dataLength       = (packetHeaderWord1 >>  0) & 0x00FFFFFF;
-    BOOST_CHECK(sequenceNumbered ==  0);
-    BOOST_CHECK(dataLength       == 32);
-
-    // Check the decl_id
-    offset += uint32_t_size;
     uint32_t readDeclId = ReadUint32(buffer.data(), offset);
     BOOST_CHECK(readDeclId == 3);
 
@@ -489,7 +393,7 @@ BOOST_AUTO_TEST_CASE(TimelineRelationshipPacketLabelLinkTest)
     BOOST_CHECK(readTailGuid == tailGuid);
 }
 
-BOOST_AUTO_TEST_CASE(TimelineMessageDirectoryPacketTest1)
+BOOST_AUTO_TEST_CASE(TimelineMessageDirectoryPacketTestNoBuffer)
 {
     unsigned int numberOfBytesWritten = 789u;
     TimelinePacketStatus result = WriteTimelineMessageDirectoryPackage(nullptr,
@@ -499,7 +403,7 @@ BOOST_AUTO_TEST_CASE(TimelineMessageDirectoryPacketTest1)
     BOOST_CHECK(numberOfBytesWritten == 0);
 }
 
-BOOST_AUTO_TEST_CASE(TimelineMessageDirectoryPacketTest2)
+BOOST_AUTO_TEST_CASE(TimelineMessageDirectoryPacketTestBufferExhausted)
 {
     std::vector<unsigned char> buffer(512, 0);
 
@@ -511,7 +415,7 @@ BOOST_AUTO_TEST_CASE(TimelineMessageDirectoryPacketTest2)
     BOOST_CHECK(numberOfBytesWritten == 0);
 }
 
-BOOST_AUTO_TEST_CASE(TimelineMessageDirectoryPacketTest3)
+BOOST_AUTO_TEST_CASE(TimelineMessageDirectoryPacketTestFullConstruction)
 {
     std::vector<unsigned char> buffer(512, 0);
     unsigned int numberOfBytesWritten = 789u;
@@ -636,82 +540,63 @@ BOOST_AUTO_TEST_CASE(TimelineMessageDirectoryPacketTest3)
                             swTraceDeclNameLength - 1) == 0); // The length of the label
 }
 
-BOOST_AUTO_TEST_CASE(TimelineEntityPacketTest1)
+BOOST_AUTO_TEST_CASE(TimelineEntityPacketTestNoBuffer)
 {
     const uint64_t profilingGuid = 123456u;
     unsigned int numberOfBytesWritten = 789u;
-    TimelinePacketStatus result = WriteTimelineEntityBinaryPacket(profilingGuid,
-                                                                 nullptr,
-                                                                 512u,
-                                                                 numberOfBytesWritten);
+    TimelinePacketStatus result = WriteTimelineEntityBinary(profilingGuid,
+                                                            nullptr,
+                                                            512u,
+                                                            numberOfBytesWritten);
     BOOST_CHECK(result == TimelinePacketStatus::BufferExhaustion);
     BOOST_CHECK(numberOfBytesWritten == 0);
 }
 
-BOOST_AUTO_TEST_CASE(TimelineEntityPacketTest2)
+BOOST_AUTO_TEST_CASE(TimelineEntityPacketTestBufferExhaustedWithZeroBufferSize)
 {
     std::vector<unsigned char> buffer(512, 0);
 
     const uint64_t profilingGuid = 123456u;
     unsigned int numberOfBytesWritten = 789u;
-    TimelinePacketStatus result = WriteTimelineEntityBinaryPacket(profilingGuid,
-                                                                 buffer.data(),
-                                                                 0,
-                                                                 numberOfBytesWritten);
+    TimelinePacketStatus result = WriteTimelineEntityBinary(profilingGuid,
+                                                            buffer.data(),
+                                                            0,
+                                                            numberOfBytesWritten);
     BOOST_CHECK(result == TimelinePacketStatus::BufferExhaustion);
     BOOST_CHECK(numberOfBytesWritten == 0);
 }
 
-BOOST_AUTO_TEST_CASE(TimelineEntityPacketTest3)
+BOOST_AUTO_TEST_CASE(TimelineEntityPacketTestBufferExhaustedWithFixedBufferSize)
 {
     std::vector<unsigned char> buffer(10, 0);
 
     const uint64_t profilingGuid = 123456u;
     unsigned int numberOfBytesWritten = 789u;
-    TimelinePacketStatus result = WriteTimelineEntityBinaryPacket(profilingGuid,
-                                                                 buffer.data(),
-                                                                 boost::numeric_cast<unsigned int>(buffer.size()),
-                                                                 numberOfBytesWritten);
+    TimelinePacketStatus result = WriteTimelineEntityBinary(profilingGuid,
+                                                            buffer.data(),
+                                                            boost::numeric_cast<unsigned int>(buffer.size()),
+                                                            numberOfBytesWritten);
     BOOST_CHECK(result == TimelinePacketStatus::BufferExhaustion);
     BOOST_CHECK(numberOfBytesWritten == 0);
 }
 
-BOOST_AUTO_TEST_CASE(TimelineEntityPacketTest4)
+BOOST_AUTO_TEST_CASE(TimelineEntityPacketTestFullConstructionOfData)
 {
     std::vector<unsigned char> buffer(512, 0);
 
     const uint64_t profilingGuid = 123456u;
     unsigned int numberOfBytesWritten = 789u;
-    TimelinePacketStatus result = WriteTimelineEntityBinaryPacket(profilingGuid,
-                                                                 buffer.data(),
-                                                                 boost::numeric_cast<unsigned int>(buffer.size()),
-                                                                 numberOfBytesWritten);
+    TimelinePacketStatus result = WriteTimelineEntityBinary(profilingGuid,
+                                                            buffer.data(),
+                                                            boost::numeric_cast<unsigned int>(buffer.size()),
+                                                            numberOfBytesWritten);
     BOOST_CHECK(result == TimelinePacketStatus::Ok);
-    BOOST_CHECK(numberOfBytesWritten == 20);
+    BOOST_CHECK(numberOfBytesWritten == 12);
 
     unsigned int uint32_t_size = sizeof(uint32_t);
 
-    // Check the packet header
     unsigned int offset = 0;
-    uint32_t packetHeaderWord0 = ReadUint32(buffer.data(), offset);
-    uint32_t packetFamily = (packetHeaderWord0 >> 26) & 0x0000003F;
-    uint32_t packetClass  = (packetHeaderWord0 >> 19) & 0x0000007F;
-    uint32_t packetType   = (packetHeaderWord0 >> 16) & 0x00000007;
-    uint32_t streamId     = (packetHeaderWord0 >>  0) & 0x00000007;
-    BOOST_CHECK(packetFamily == 1);
-    BOOST_CHECK(packetClass  == 0);
-    BOOST_CHECK(packetType   == 1);
-    BOOST_CHECK(streamId     == 0);
-
-    offset += uint32_t_size;
-    uint32_t packetHeaderWord1 = ReadUint32(buffer.data(), offset);
-    uint32_t sequenceNumbered = (packetHeaderWord1 >> 24) & 0x00000001;
-    uint32_t dataLength       = (packetHeaderWord1 >>  0) & 0x00FFFFFF;
-    BOOST_CHECK(sequenceNumbered ==  0);
-    BOOST_CHECK(dataLength       == 12);
-
     // Check decl_Id
-    offset += uint32_t_size;
     uint32_t decl_Id = ReadUint32(buffer.data(), offset);
     BOOST_CHECK(decl_Id == uint32_t(1));
 
@@ -721,82 +606,63 @@ BOOST_AUTO_TEST_CASE(TimelineEntityPacketTest4)
     BOOST_CHECK(readProfilingGuid == profilingGuid);
 }
 
-BOOST_AUTO_TEST_CASE(TimelineEventClassTest1)
+BOOST_AUTO_TEST_CASE(TimelineEventClassTestNoBuffer)
 {
     const uint64_t profilingGuid = 123456u;
     unsigned int numberOfBytesWritten = 789u;
-    TimelinePacketStatus result = WriteTimelineEventClassBinaryPacket(profilingGuid,
-                                                                      nullptr,
-                                                                      512u,
-                                                                      numberOfBytesWritten);
+    TimelinePacketStatus result = WriteTimelineEventClassBinary(profilingGuid,
+                                                                nullptr,
+                                                                512u,
+                                                                numberOfBytesWritten);
     BOOST_CHECK(result == TimelinePacketStatus::BufferExhaustion);
     BOOST_CHECK(numberOfBytesWritten == 0);
 }
 
-BOOST_AUTO_TEST_CASE(TimelineEventClassTest2)
+BOOST_AUTO_TEST_CASE(TimelineEventClassTestBufferExhaustionZeroValue)
 {
     std::vector<unsigned char> buffer(512, 0);
 
     const uint64_t profilingGuid = 123456u;
     unsigned int numberOfBytesWritten = 789u;
-    TimelinePacketStatus result = WriteTimelineEventClassBinaryPacket(profilingGuid,
-                                                                      buffer.data(),
-                                                                      0,
-                                                                      numberOfBytesWritten);
+    TimelinePacketStatus result = WriteTimelineEventClassBinary(profilingGuid,
+                                                                buffer.data(),
+                                                                0,
+                                                                numberOfBytesWritten);
     BOOST_CHECK(result == TimelinePacketStatus::BufferExhaustion);
     BOOST_CHECK(numberOfBytesWritten == 0);
 }
 
-BOOST_AUTO_TEST_CASE(TimelineEventClassTest3)
+BOOST_AUTO_TEST_CASE(TimelineEventClassTestBufferExhaustionFixedValue)
 {
     std::vector<unsigned char> buffer(10, 0);
 
     const uint64_t profilingGuid = 123456u;
     unsigned int numberOfBytesWritten = 789u;
-    TimelinePacketStatus result = WriteTimelineEventClassBinaryPacket(profilingGuid,
-                                                                      buffer.data(),
-                                                                      boost::numeric_cast<unsigned int>(buffer.size()),
-                                                                      numberOfBytesWritten);
+    TimelinePacketStatus result = WriteTimelineEventClassBinary(profilingGuid,
+                                                                buffer.data(),
+                                                                boost::numeric_cast<unsigned int>(buffer.size()),
+                                                                numberOfBytesWritten);
     BOOST_CHECK(result == TimelinePacketStatus::BufferExhaustion);
     BOOST_CHECK(numberOfBytesWritten == 0);
 }
 
-BOOST_AUTO_TEST_CASE(TimelineEventClassTest4)
+BOOST_AUTO_TEST_CASE(TimelineEventClassTestFullConstructionOfData)
 {
     std::vector<unsigned char> buffer(512, 0);
 
     const uint64_t profilingGuid = 123456u;
     unsigned int numberOfBytesWritten = 789u;
-    TimelinePacketStatus result = WriteTimelineEventClassBinaryPacket(profilingGuid,
-                                                                      buffer.data(),
-                                                                      boost::numeric_cast<unsigned int>(buffer.size()),
-                                                                      numberOfBytesWritten);
+    TimelinePacketStatus result = WriteTimelineEventClassBinary(profilingGuid,
+                                                                buffer.data(),
+                                                                boost::numeric_cast<unsigned int>(buffer.size()),
+                                                                numberOfBytesWritten);
     BOOST_CHECK(result == TimelinePacketStatus::Ok);
-    BOOST_CHECK(numberOfBytesWritten == 20);
+    BOOST_CHECK(numberOfBytesWritten == 12);
 
     unsigned int uint32_t_size = sizeof(uint32_t);
 
-    // Check the packet header
     unsigned int offset = 0;
-    uint32_t packetHeaderWord0 = ReadUint32(buffer.data(), offset);
-    uint32_t packetFamily = (packetHeaderWord0 >> 26) & 0x0000003F;
-    uint32_t packetClass  = (packetHeaderWord0 >> 19) & 0x0000007F;
-    uint32_t packetType   = (packetHeaderWord0 >> 16) & 0x00000007;
-    uint32_t streamId     = (packetHeaderWord0 >>  0) & 0x00000007;
-    BOOST_CHECK(packetFamily == 1);
-    BOOST_CHECK(packetClass  == 0);
-    BOOST_CHECK(packetType   == 1);
-    BOOST_CHECK(streamId     == 0);
-
-    offset += uint32_t_size;
-    uint32_t packetHeaderWord1 = ReadUint32(buffer.data(), offset);
-    uint32_t sequenceNumbered = (packetHeaderWord1 >> 24) & 0x00000001;
-    uint32_t dataLength       = (packetHeaderWord1 >>  0) & 0x00FFFFFF;
-    BOOST_CHECK(sequenceNumbered ==  0);
-    BOOST_CHECK(dataLength       == 12);
-
     // Check the decl_id
-    offset += uint32_t_size;
     uint32_t declId = ReadUint32(buffer.data(), offset);
     BOOST_CHECK(declId == uint32_t(2));
 
@@ -806,23 +672,23 @@ BOOST_AUTO_TEST_CASE(TimelineEventClassTest4)
     BOOST_CHECK(readProfilingGuid == profilingGuid);
 }
 
-BOOST_AUTO_TEST_CASE(TimelineEventPacketTest1)
+BOOST_AUTO_TEST_CASE(TimelineEventPacketTestNoBuffer)
 {
     const uint64_t timestamp = 456789u;
     const std::thread::id threadId = std::this_thread::get_id();
     const uint64_t profilingGuid = 123456u;
     unsigned int numberOfBytesWritten = 789u;
-    TimelinePacketStatus result = WriteTimelineEventBinaryPacket(timestamp,
-                                                                 threadId,
-                                                                 profilingGuid,
-                                                                 nullptr,
-                                                                 512u,
-                                                                 numberOfBytesWritten);
+    TimelinePacketStatus result = WriteTimelineEventBinary(timestamp,
+                                                           threadId,
+                                                           profilingGuid,
+                                                           nullptr,
+                                                           512u,
+                                                           numberOfBytesWritten);
     BOOST_CHECK(result == TimelinePacketStatus::BufferExhaustion);
     BOOST_CHECK(numberOfBytesWritten == 0);
 }
 
-BOOST_AUTO_TEST_CASE(TimelineEventPacketTest2)
+BOOST_AUTO_TEST_CASE(TimelineEventPacketTestBufferExhaustionZeroValue)
 {
     std::vector<unsigned char> buffer(512, 0);
 
@@ -830,17 +696,17 @@ BOOST_AUTO_TEST_CASE(TimelineEventPacketTest2)
     const std::thread::id threadId = std::this_thread::get_id();
     const uint64_t profilingGuid = 123456u;
     unsigned int numberOfBytesWritten = 789u;
-    TimelinePacketStatus result = WriteTimelineEventBinaryPacket(timestamp,
-                                                                 threadId,
-                                                                 profilingGuid,
-                                                                 buffer.data(),
-                                                                 0,
-                                                                 numberOfBytesWritten);
+    TimelinePacketStatus result = WriteTimelineEventBinary(timestamp,
+                                                           threadId,
+                                                           profilingGuid,
+                                                           buffer.data(),
+                                                           0,
+                                                           numberOfBytesWritten);
     BOOST_CHECK(result == TimelinePacketStatus::BufferExhaustion);
     BOOST_CHECK(numberOfBytesWritten == 0);
 }
 
-BOOST_AUTO_TEST_CASE(TimelineEventPacketTest3)
+BOOST_AUTO_TEST_CASE(TimelineEventPacketTestBufferExhaustionFixedValue)
 {
     std::vector<unsigned char> buffer(10, 0);
 
@@ -848,17 +714,17 @@ BOOST_AUTO_TEST_CASE(TimelineEventPacketTest3)
     const std::thread::id threadId = std::this_thread::get_id();
     const uint64_t profilingGuid = 123456u;
     unsigned int numberOfBytesWritten = 789u;
-    TimelinePacketStatus result = WriteTimelineEventBinaryPacket(timestamp,
-                                                                 threadId,
-                                                                 profilingGuid,
-                                                                 buffer.data(),
-                                                                 boost::numeric_cast<unsigned int>(buffer.size()),
-                                                                 numberOfBytesWritten);
+    TimelinePacketStatus result = WriteTimelineEventBinary(timestamp,
+                                                           threadId,
+                                                           profilingGuid,
+                                                           buffer.data(),
+                                                           boost::numeric_cast<unsigned int>(buffer.size()),
+                                                           numberOfBytesWritten);
     BOOST_CHECK(result == TimelinePacketStatus::BufferExhaustion);
     BOOST_CHECK(numberOfBytesWritten == 0);
 }
 
-BOOST_AUTO_TEST_CASE(TimelineEventPacketTest4)
+BOOST_AUTO_TEST_CASE(TimelineEventPacketTestFullConstructionOfData)
 {
     std::vector<unsigned char> buffer(512, 0);
 
@@ -866,40 +732,21 @@ BOOST_AUTO_TEST_CASE(TimelineEventPacketTest4)
     const std::thread::id threadId = std::this_thread::get_id();
     const uint64_t profilingGuid = 123456u;
     unsigned int numberOfBytesWritten = 789u;
-    TimelinePacketStatus result = WriteTimelineEventBinaryPacket(timestamp,
-                                                                 threadId,
-                                                                 profilingGuid,
-                                                                 buffer.data(),
-                                                                 boost::numeric_cast<unsigned int>(buffer.size()),
-                                                                 numberOfBytesWritten);
+    TimelinePacketStatus result = WriteTimelineEventBinary(timestamp,
+                                                           threadId,
+                                                           profilingGuid,
+                                                           buffer.data(),
+                                                           boost::numeric_cast<unsigned int>(buffer.size()),
+                                                           numberOfBytesWritten);
     BOOST_CHECK(result == TimelinePacketStatus::Ok);
-    BOOST_CHECK(numberOfBytesWritten == 36);
+    BOOST_CHECK(numberOfBytesWritten == 28);
 
     unsigned int uint32_t_size = sizeof(uint32_t);
     unsigned int uint64_t_size = sizeof(uint64_t);
     unsigned int threadId_size = sizeof(std::thread::id);
 
-    // Check the packet header
     unsigned int offset = 0;
-    uint32_t packetHeaderWord0 = ReadUint32(buffer.data(), offset);
-    uint32_t packetFamily = (packetHeaderWord0 >> 26) & 0x0000003F;
-    uint32_t packetClass  = (packetHeaderWord0 >> 19) & 0x0000007F;
-    uint32_t packetType   = (packetHeaderWord0 >> 16) & 0x00000007;
-    uint32_t streamId     = (packetHeaderWord0 >>  0) & 0x00000007;
-    BOOST_CHECK(packetFamily == 1);
-    BOOST_CHECK(packetClass  == 0);
-    BOOST_CHECK(packetType   == 1);
-    BOOST_CHECK(streamId     == 0);
-
-    offset += uint32_t_size;
-    uint32_t packetHeaderWord1 = ReadUint32(buffer.data(), offset);
-    uint32_t sequenceNumbered = (packetHeaderWord1 >> 24) & 0x00000001;
-    uint32_t dataLength       = (packetHeaderWord1 >>  0) & 0x00FFFFFF;
-    BOOST_CHECK(sequenceNumbered ==  0);
-    BOOST_CHECK(dataLength       == 28);
-
     // Check the decl_id
-    offset += uint32_t_size;
     uint32_t readDeclId = ReadUint32(buffer.data(), offset);
     BOOST_CHECK(readDeclId == 4);