Used ASSERT_* in places where tests should be stopped immediately. Refactored to get rid of else branches that did nothing but ASSERT_TRUE(false).

Author: feasel0

src/protocols/bdx/tests/BUILD.gn

@@ -1,23 +1,22 @@
-# Copyright (c) 2020 Project CHIP Authors
+#Copyright(c) 2020 Project CHIP Authors
 #
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
+#Licensed under the Apache License, Version 2.0(the "License");
+#you may not use this file except in compliance with the License.
+#You may obtain a copy of the License at
 #
-# http://www.apache.org/licenses/LICENSE-2.0
+#http: // www.apache.org/licenses/LICENSE-2.0
 #
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
+#Unless required by applicable law or agreed to in writing, software
+#distributed under the License is distributed on an "AS IS" BASIS,
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#See the License for the specific language governing permissions and
+#limitations under the License.
 
 import("//build_overrides/build.gni")
 import("//build_overrides/chip.gni")
 import("//build_overrides/pigweed.gni")
 
 import("${chip_root}/build/chip/chip_test_suite.gni")
-
 chip_test_suite("tests") {
   output_name = "libBDXTests"
 

src/protocols/bdx/tests/TestBdxMessages.cpp

@@ -22,15 +22,15 @@ void TestHelperWrittenAndParsedMatch(MsgType & testMsg)
 
     size_t msgSize = testMsg.MessageSize();
     Encoding::LittleEndian::PacketBufferWriter bbuf(System::PacketBufferHandle::New(msgSize));
-    EXPECT_FALSE(bbuf.IsNull());
+    ASSERT_FALSE(bbuf.IsNull());
 
     testMsg.WriteToBuffer(bbuf);
     EXPECT_TRUE(bbuf.Fit());
 
     System::PacketBufferHandle msgBuf = bbuf.Finalize();
-    EXPECT_FALSE(msgBuf.IsNull());
+    ASSERT_FALSE(msgBuf.IsNull());
     System::PacketBufferHandle rcvBuf = System::PacketBufferHandle::NewWithData(msgBuf->Start(), msgSize);
-    EXPECT_FALSE(rcvBuf.IsNull());
+    ASSERT_FALSE(rcvBuf.IsNull());
 
     MsgType testMsgRcvd;
     err = testMsgRcvd.Parse(std::move(rcvBuf));
@@ -43,7 +43,7 @@ struct TestBdxMessages : public ::testing::Test
     static void SetUpTestSuite()
     {
         CHIP_ERROR error = chip::Platform::MemoryInit();
-        EXPECT_EQ(error, CHIP_NO_ERROR);
+        ASSERT_EQ(error, CHIP_NO_ERROR);
     }
 
     static void TearDownTestSuite() { chip::Platform::MemoryShutdown(); }

src/protocols/bdx/tests/TestBdxTransferSession.cpp

@@ -104,18 +104,10 @@ void VerifyStatusReport(const System::PacketBufferHandle & msg, StatusCode expec
 {
     CHIP_ERROR err = CHIP_NO_ERROR;
 
-    if (msg.IsNull())
-    {
-        EXPECT_TRUE(false);
-        return;
-    }
+    ASSERT_FALSE(msg.IsNull())
 
     System::PacketBufferHandle msgCopy = msg.CloneData();
-    if (msgCopy.IsNull())
-    {
-        EXPECT_TRUE(false);
-        return;
-    }
+    ASSERT_FALSE(msgCopy.IsNull())
 
     SecureChannel::StatusReport report;
     err = report.Parse(std::move(msgCopy));
@@ -175,22 +167,14 @@ void SendAndVerifyTransferInit(TransferSession::OutputEvent & outEvent, System::
     }
     if (outEvent.transferInitData.Metadata != nullptr)
     {
-        EXPECT_EQ(outEvent.transferInitData.MetadataLength, initData.MetadataLength);
-        if (outEvent.transferInitData.MetadataLength == initData.MetadataLength)
-        {
-            // Even if initData.MetadataLength is 0, it is still technically undefined behaviour to call memcmp with a null
-            bool isNullAndLengthZero = initData.Metadata == nullptr && initData.MetadataLength == 0;
-            if (!isNullAndLengthZero)
-            {
-                // Only check that metadata buffers match. The OutputEvent can still be inspected when this function returns to
-                // parse the metadata and verify that it matches.
-                EXPECT_EQ(0,
-                          memcmp(initData.Metadata, outEvent.transferInitData.Metadata, outEvent.transferInitData.MetadataLength));
-            }
-        }
-        else
+        ASSERT_EQ(outEvent.transferInitData.MetadataLength, initData.MetadataLength);
+        // Even if initData.MetadataLength is 0, it is still technically undefined behaviour to call memcmp with a null
+        bool isNullAndLengthZero = initData.Metadata == nullptr && initData.MetadataLength == 0;
+        if (!isNullAndLengthZero)
         {
-            EXPECT_TRUE(false); // Metadata length mismatch
+            // Only check that metadata buffers match. The OutputEvent can still be inspected when this function returns to
+            // parse the metadata and verify that it matches.
+            EXPECT_EQ(0, memcmp(initData.Metadata, outEvent.transferInitData.Metadata, outEvent.transferInitData.MetadataLength));
         }
     }
 }
@@ -235,23 +219,15 @@ void SendAndVerifyAcceptMsg(TransferSession::OutputEvent & outEvent, TransferSes
     EXPECT_EQ(outEvent.transferAcceptData.Length, acceptData.Length);
     if (outEvent.transferAcceptData.Metadata != nullptr)
     {
-        EXPECT_EQ(outEvent.transferAcceptData.MetadataLength, acceptData.MetadataLength);
-        if (outEvent.transferAcceptData.MetadataLength == acceptData.MetadataLength)
+        ASSERT_EQ(outEvent.transferAcceptData.MetadataLength, acceptData.MetadataLength);
+        // Even if acceptData.MetadataLength is 0, it is still technically undefined behaviour to call memcmp with a null
+        bool isNullAndLengthZero = acceptData.Metadata == nullptr && acceptData.MetadataLength == 0;
+        if (!isNullAndLengthZero)
         {
-            // Even if acceptData.MetadataLength is 0, it is still technically undefined behaviour to call memcmp with a null
-            bool isNullAndLengthZero = acceptData.Metadata == nullptr && acceptData.MetadataLength == 0;
-            if (!isNullAndLengthZero)
-            {
-                // Only check that metadata buffers match. The OutputEvent can still be inspected when this function returns to
-                // parse the metadata and verify that it matches.
-                EXPECT_EQ(
-                    0,
-                    memcmp(acceptData.Metadata, outEvent.transferAcceptData.Metadata, outEvent.transferAcceptData.MetadataLength));
-            }
-        }
-        else
-        {
-            EXPECT_TRUE(false); // Metadata length mismatch
+            // Only check that metadata buffers match. The OutputEvent can still be inspected when this function returns to
+            // parse the metadata and verify that it matches.
+            EXPECT_EQ(
+                0, memcmp(acceptData.Metadata, outEvent.transferAcceptData.Metadata, outEvent.transferAcceptData.MetadataLength));
         }
     }
 
@@ -289,11 +265,7 @@ void SendAndVerifyArbitraryBlock(TransferSession & sender, TransferSession & rec
 
     EXPECT_GT(maxBlockSize, 0);
     System::PacketBufferHandle fakeDataBuf = System::PacketBufferHandle::New(maxBlockSize);
-    if (fakeDataBuf.IsNull())
-    {
-        EXPECT_TRUE(false);
-        return;
-    }
+    ASSERT_FALSE(fakeDataBuf.IsNull());
 
     uint8_t * fakeBlockData = fakeDataBuf->Start();
     fakeBlockData[0]        = dataCount++;
@@ -356,7 +328,7 @@ struct TestBdxTransferSession : public ::testing::Test
     static void SetUpTestSuite()
     {
         CHIP_ERROR error = chip::Platform::MemoryInit();
-        EXPECT_EQ(error, CHIP_NO_ERROR);
+        ASSERT_EQ(error, CHIP_NO_ERROR);
     }
 
     static void TearDownTestSuite() { chip::Platform::MemoryShutdown(); }
@@ -434,11 +406,7 @@ TEST_F(TestBdxTransferSession, TestInitiatingReceiverReceiverDrive)
     // Test only one block can be prepared at a time, without receiving a response to the first
     System::PacketBufferHandle fakeBuf = System::PacketBufferHandle::New(testSmallerBlockSize);
     TransferSession::BlockData prematureBlock;
-    if (fakeBuf.IsNull())
-    {
-        EXPECT_TRUE(false);
-        return;
-    }
+    ASSERT_FALSE(fakeBuf.IsNull());
     prematureBlock.Data   = fakeBuf->Start();
     prematureBlock.Length = testSmallerBlockSize;
     prematureBlock.IsEof  = false;