Quick updates to AzNetworking unit tests

Signed-off-by: puvvadar <[email protected]>

Code/Framework/AzNetworking/AzNetworking/DataStructures/FixedSizeBitsetView.inl

@@ -15,12 +15,12 @@ namespace AzNetworking
         , m_startOffset(startOffset)
         , m_count(startOffset < bitset.GetValidBitCount() && startOffset + count <= bitset.GetValidBitCount() ? count : 0)
     {
-        AZ_Assert(startOffset + count <= bitset.GetValidBitCount(), "Out of bounds setup in BitsetSubset. Defaulting to 0 bit count.");
+        AZ_Warning("FixedSizeBitsetView", startOffset + count <= bitset.GetValidBitCount(), "Out of bounds setup in BitsetSubset. Defaulting to 0 bit count.");
     }
 
     inline void FixedSizeBitsetView::SetBit(uint32_t index, bool value)
     {
-        AZ_Assert(index < m_count, "Out of bounds access in BitsetSubset (requested %u, count %u)", index, m_count);
+        AZ_Warning("FixedSizeBitsetView", index < m_count, "Out of bounds access in BitsetSubset (requested %u, count %u)", index, m_count);
         if (m_count)
         {
             m_bitset.SetBit(m_startOffset + index, value);
@@ -29,7 +29,7 @@ namespace AzNetworking
 
     inline bool FixedSizeBitsetView::GetBit(uint32_t index) const
     {
-        AZ_Assert(index < m_count, "Out of bounds access in BitsetSubset (requested %u, count %u)", index, m_count);
+        AZ_Warning("FixedSizeBitsetView", index < m_count, "Out of bounds access in BitsetSubset (requested %u, count %u)", index, m_count);
         if (m_count)
         {
             return m_bitset.GetBit(m_startOffset + index);

Code/Framework/AzNetworking/Tests/DataStructures/FixedSizeBitsetTests.cpp

@@ -55,5 +55,8 @@ namespace UnitTest
             unusedBitTest.SetBit(i, false);
         }
         EXPECT_FALSE(unusedBitTest.AnySet());
+
+        unusedBitTest.SetBit(0, true);
+        EXPECT_TRUE(unusedBitTest.AnySet());
     }
 }

Code/Framework/AzNetworking/Tests/DataStructures/FixedSizeBitsetViewTests.cpp

@@ -42,4 +42,27 @@ namespace UnitTest
             EXPECT_FALSE(view.GetBit(0));
         }
     }
+
+    TEST(FixedSizeBitsetView, EmptyBitset)
+    {
+        AzNetworking::FixedSizeBitset<32> bitset;
+        AzNetworking::FixedSizeBitsetView view(bitset, 10, 0);
+        EXPECT_FALSE(view.GetBit(0));
+    }
+
+    TEST(FixedSizeBitsetView, TestAnySet)
+    {
+        AzNetworking::FixedSizeBitset<9> unusedBitTest(true);
+        AzNetworking::FixedSizeBitsetView view(unusedBitTest, 0, 5);
+        for (uint32_t i = 0; i < 5; ++i)
+        {
+            view.SetBit(i, false);
+        }
+        EXPECT_FALSE(view.AnySet());
+
+        view.SetBit(0, true);
+        EXPECT_TRUE(view.AnySet());
+
+        EXPECT_EQ(view.GetValidBitCount(), 5);
+    }
 }

Code/Framework/AzNetworking/Tests/TcpTransport/TcpTransportTests.cpp

@@ -148,6 +148,11 @@ namespace UnitTest
 
         EXPECT_EQ(testServer.m_serverNetworkInterface->GetConnectionSet().GetConnectionCount(), 1);
         EXPECT_EQ(testClient.m_clientNetworkInterface->GetConnectionSet().GetConnectionCount(), 1);
+
+        testClient.m_clientNetworkInterface->SetTimeoutEnabled(true);
+        EXPECT_TRUE(testClient.m_clientNetworkInterface->IsTimeoutEnabled());
+
+        EXPECT_TRUE(testServer.m_serverNetworkInterface->StopListening());
     }
 
     #if AZ_TRAIT_DISABLE_FAILED_NETWORKING_TESTS

Code/Framework/AzNetworking/Tests/UdpTransport/UdpTransportTests.cpp

@@ -125,6 +125,18 @@ namespace UnitTest
         AzNetworking::NetworkingSystemComponent* m_networkingSystemComponent;
     };
 
+    TEST_F(UdpTransportTests, PacketIdWrap)
+    {
+        const uint32_t SEQUENCE_BOUNDARY = 0xFFFF;
+        UdpPacketTracker tracker;
+
+        for (uint32_t i = 0; i < SEQUENCE_BOUNDARY; ++i)
+        {
+            tracker.GetNextPacketId();
+        }
+        EXPECT_EQ(tracker.GetNextPacketId(), PacketId(SEQUENCE_BOUNDARY + 1));
+    }
+
     TEST_F(UdpTransportTests, AckReplication)
     {
         static const SequenceId TestReliableSequenceId = InvalidSequenceId;
@@ -266,6 +278,15 @@ namespace UnitTest
 
         EXPECT_EQ(testServer.m_serverNetworkInterface->GetConnectionSet().GetConnectionCount(), 1);
         EXPECT_EQ(testClient.m_clientNetworkInterface->GetConnectionSet().GetConnectionCount(), 1);
+
+        testClient.m_clientNetworkInterface->SetTimeoutEnabled(true);
+        EXPECT_TRUE(testClient.m_clientNetworkInterface->IsTimeoutEnabled());
+
+        EXPECT_FALSE(dynamic_cast<UdpNetworkInterface*>(testClient.m_clientNetworkInterface)->IsEncrypted());
+
+        EXPECT_TRUE(testServer.m_serverNetworkInterface->StopListening());
+        EXPECT_FALSE(testServer.m_serverNetworkInterface->StopListening());
+        EXPECT_FALSE(dynamic_cast<UdpNetworkInterface*>(testServer.m_serverNetworkInterface)->IsOpen());
     }
 
     TEST_F(UdpTransportTests, TestMultipleClients)

Code/Framework/AzNetworking/Tests/Utilities/IpAddressTests.cpp

@@ -11,4 +11,16 @@
 
 namespace UnitTest
 {
+    TEST(IpAddressTests, TestIpQuads)
+    {
+        const AzNetworking::IpAddress ip = AzNetworking::IpAddress(127, 0, 0, 1, 12345);
+
+        EXPECT_EQ(ip.GetQuadA(), 127);
+        EXPECT_EQ(ip.GetQuadB(), 0);
+        EXPECT_EQ(ip.GetQuadC(), 0);
+        EXPECT_EQ(ip.GetQuadD(), 1);
+
+        EXPECT_EQ(ip.GetString(), "127.0.0.1:12345");
+        EXPECT_EQ(ip.GetIpString(), "127.0.0.1");
+    }
 }

Code/Framework/AzNetworking/Tests/Utilities/QuantizedValuesTests.cpp

@@ -79,13 +79,12 @@ namespace UnitTest
     template <uint32_t NUM_ELEMENTS, uint32_t NUM_BYTES>
     void TestQuantizedValuesHelper01()
     {
-        AzNetworking::QuantizedValues<NUM_ELEMENTS, NUM_BYTES, 0, 1> testIn, testOut; // Transmits float values between 0 and 1 using NUM_BYTES
+        AzNetworking::QuantizedValues<NUM_ELEMENTS, NUM_BYTES, 0, 1> testIn(ValueFromFloat<NUM_ELEMENTS>::Construct(0.0f)), testOut; // Transmits float values between 0 and 1 using NUM_BYTES
 
         AZStd::array<uint8_t, 1024> buffer;
         AzNetworking::NetworkInputSerializer  inputSerializer(buffer.data(), static_cast<uint32_t>(buffer.size()));
         AzNetworking::NetworkOutputSerializer outputSerializer(buffer.data(), static_cast<uint32_t>(buffer.size()));
 
-        testIn = ValueFromFloat<NUM_ELEMENTS>::Construct(0.0f);
         EXPECT_EQ(static_cast<typename ValueFromFloat<NUM_ELEMENTS>::ValueType>(testIn), ValueFromFloat<NUM_ELEMENTS>::Construct(0.0f));
         testIn.Serialize(inputSerializer);
         EXPECT_EQ(inputSerializer.GetSize(), NUM_BYTES * NUM_ELEMENTS);
@@ -95,6 +94,8 @@ namespace UnitTest
         testIn = ValueFromFloat<NUM_ELEMENTS>::Construct(1.0f);
         EXPECT_EQ(static_cast<typename ValueFromFloat<NUM_ELEMENTS>::ValueType>(testIn), ValueFromFloat<NUM_ELEMENTS>::Construct(1.0f));
         testIn.Serialize(inputSerializer);
+        EXPECT_NE(testIn, testOut);
+        EXPECT_NE(testIn.GetQuantizedIntegralValues()[0], testOut.GetQuantizedIntegralValues()[0]);
         testOut.Serialize(outputSerializer);
         EXPECT_EQ(testIn, testOut);