Refactor ASSERT_* to EXPECT_* where applicable

ASSERT_* were left only where continuing the test is unsafe or
makes no sense.

Change-Id: If93fdb88bb53e2f6aec92a7f05eb51aea9554977

diff --git a/tests/bluetooth_tests.cpp b/tests/bluetooth_tests.cpp
index 3831aaee68ab653390359c4390d0ee7823fb0df8..da064606f63fbb488ab39376c39c13a3d36902da 100644 (file)
--- a/tests/bluetooth_tests.cpp
+++ b/tests/bluetooth_tests.cpp
@@ -55,9 +55,9 @@ TEST(BluetoothTest, safely_deferring_callback_to_be_run_after_g_main_loop_run)
         },
         static_cast<gpointer>(&data),
         nullptr);
-    ASSERT_FALSE(data.second);
+    EXPECT_FALSE(data.second);
     g_main_loop_run(data.first);
-    ASSERT_TRUE(data.second);
+    EXPECT_TRUE(data.second);
     g_main_loop_unref(data.first);
 }
 
@@ -73,7 +73,7 @@ TEST(BluetoothTest, scan_fails_if_bluetooth_is_turned_off)
                        void * /*userData*/) noexcept { return IBluetooth::Scanning::CONTINUE; };
     EXPECT_EQ(err = bt.StartLEAdvertScanAndAwaitStop(callback, nullptr), BT_ERROR_NOT_ENABLED)
         << BtErrorToString(err);
-    ASSERT_EQ(err = bt.Deinitialize(), BT_ERROR_NONE) << BtErrorToString(err);
+    EXPECT_EQ(err = bt.Deinitialize(), BT_ERROR_NONE) << BtErrorToString(err);
 }
 
 TEST(BluetoothTest, scan_for_up_to_1_second)
@@ -99,7 +99,7 @@ TEST(BluetoothTest, scan_for_up_to_1_second)
     EXPECT_EQ(err = bt.StartLEAdvertScanAndAwaitStop(callback, nullptr), BT_ERROR_CANCELLED)
         << BtErrorToString(err);
     otherThread.join();
-    ASSERT_EQ(err = bt.Deinitialize(), BT_ERROR_NONE) << BtErrorToString(err);
+    EXPECT_EQ(err = bt.Deinitialize(), BT_ERROR_NONE) << BtErrorToString(err);
 }
 
 namespace {

diff --git a/tests/cbor_tests.cpp b/tests/cbor_tests.cpp
index ab60f4300793615ce318359438b6035f18e090fd..f61e7051af99f6306f9004599db76b20e7f1d514 100644 (file)
--- a/tests/cbor_tests.cpp
+++ b/tests/cbor_tests.cpp
@@ -262,14 +262,14 @@ TEST(CborEncoding, EmptyBuffers)
     Buffer output(16);
     auto encoder = CborEncoding::Encoder::Create(output.data(), output.size());
     auto map = encoder.OpenMap(4);
-    ASSERT_NO_THROW(map.AppendTextStringZAt(0x01, ""));
-    ASSERT_NO_THROW(map.AppendByteStringAt(0x02, Buffer{}));
+    EXPECT_NO_THROW(map.AppendTextStringZAt(0x01, ""));
+    EXPECT_NO_THROW(map.AppendByteStringAt(0x02, Buffer{}));
     wauthn_const_buffer_s buffer;
     buffer.data = nullptr;
     buffer.size = 0;
-    ASSERT_NO_THROW(map.AppendByteStringAt(0x03, buffer));
+    EXPECT_NO_THROW(map.AppendByteStringAt(0x03, buffer));
     buffer.size = 10;
-    ASSERT_THROW(map.AppendByteStringAt(0x04, buffer), Exception::InvalidParam);
+    EXPECT_THROW(map.AppendByteStringAt(0x04, buffer), Exception::InvalidParam);
 }
 
 TEST(Cbor, MapInt64EncodingAndDecoding)
@@ -411,7 +411,7 @@ TEST(Cbor, MapOptionalTextStringEncodingAndDecoding)
 TEST(Cbor, EncodingToNullBuffer)
 {
     std::vector<uint8_t> emptyBuffer(0);
-    ASSERT_THROW(CborEncoding::Encoder::Create(emptyBuffer.data(), emptyBuffer.size()), Unknown);
+    EXPECT_THROW(CborEncoding::Encoder::Create(emptyBuffer.data(), emptyBuffer.size()), Unknown);
 }
 
 TEST(Cbor, EmptyStringEncoding)
@@ -420,8 +420,8 @@ TEST(Cbor, EmptyStringEncoding)
     auto encoder = CborEncoding::Encoder::Create(buffer.data(), buffer.size());
     {
         auto map = encoder.OpenMap(2);
-        ASSERT_THROW(map.AppendTextStringZAt(1, nullptr), Unknown);
-        ASSERT_NO_THROW(map.AppendTextStringZAt(2, ""));
+        EXPECT_THROW(map.AppendTextStringZAt(1, nullptr), Unknown);
+        EXPECT_NO_THROW(map.AppendTextStringZAt(2, ""));
     }
 }
 
@@ -446,7 +446,7 @@ TEST(Cbor, MapDecodingValuesOfDifferentTypeThanExpected)
     auto parser = CborParsing::Parser::Create(buffer.data(), buffer.size());
     auto parserMap = parser.EnterMap();
 
-    ASSERT_THROW(parserMap.GetByteStringAt(0), Unknown);
+    EXPECT_THROW(parserMap.GetByteStringAt(0), Unknown);
     EXPECT_EQ(parserMap.GetTextStringAt(1), std::nullopt);
     EXPECT_EQ(parserMap.GetInt64At(2), std::nullopt);
     EXPECT_EQ(parserMap.GetUint64At(2), std::nullopt);
@@ -469,7 +469,7 @@ TEST(Cbor, DecodingMapWithNotSortedKeysFails)
 
     EXPECT_EQ(encoder.GetBufferSize(), buffer.size());
 
-    ASSERT_THROW(CborParsing::Parser::Create(buffer.data(), buffer.size()), Unknown);
+    EXPECT_THROW(CborParsing::Parser::Create(buffer.data(), buffer.size()), Unknown);
 }
 
 TEST(Cbor, DecodingMapWithDuplicatedKeysFails)
@@ -484,7 +484,7 @@ TEST(Cbor, DecodingMapWithDuplicatedKeysFails)
 
     EXPECT_EQ(encoder.GetBufferSize(), buffer.size());
 
-    ASSERT_THROW(CborParsing::Parser::Create(buffer.data(), buffer.size()), Unknown);
+    EXPECT_THROW(CborParsing::Parser::Create(buffer.data(), buffer.size()), Unknown);
 }
 
 TEST(Cbor, MapWithKeysOfDifferentTypesEncodingAndDecoding)
@@ -590,9 +590,9 @@ TEST(CborParsing, SortedMapPeekAndLocateKey)
     auto map = parser.EnterMap();
     EXPECT_EQ(std::get<int64_t>(map.PeekKey()), 16);
     EXPECT_EQ(map.GetTextStringAt(16), TEXT);
-    ASSERT_THROW(map.PeekKey(), Unknown);
+    EXPECT_THROW(map.PeekKey(), Unknown);
     EXPECT_EQ(map.GetInt64At("test"), std::nullopt);
-    ASSERT_THROW(map.PeekKey(), Unknown);
+    EXPECT_THROW(map.PeekKey(), Unknown);
 }
 
 TEST(Cbor, SkippingUnknownKeysWhileDecodingMap)
@@ -635,7 +635,7 @@ TEST(Cbor, DecodingGarbageAtEnd)
     EXPECT_EQ(encoder.GetBufferSize(), buffer.size());
     buffer.emplace_back(0x00);
 
-    ASSERT_THROW(CborParsing::Parser::Create(buffer.data(), buffer.size()), Unknown);
+    EXPECT_THROW(CborParsing::Parser::Create(buffer.data(), buffer.size()), Unknown);
 }
 
 TEST(Cbor, DecodingMapUnknownIntKey)
@@ -654,7 +654,7 @@ TEST(Cbor, DecodingMapUnknownIntKey)
     auto parser = CborParsing::Parser::Create(buffer.data(), buffer.size());
     auto parserMap = parser.EnterMap();
 
-    ASSERT_NO_THROW(parserMap.EnterMapAt(5));
+    EXPECT_NO_THROW(parserMap.EnterMapAt(5));
     EXPECT_EQ(parserMap.GetInt64At(5), std::nullopt);
 }
 
@@ -737,7 +737,7 @@ TEST(Cbor, NestedStructuresEncodingAndDecoding1)
         auto firstArrayParser = parserMap.EnterArrayAt(0).value();
         for (auto x : INT64T_VALUES)
             EXPECT_EQ(firstArrayParser.GetInt64(), x);
-        ASSERT_THROW(firstArrayParser.GetInt64(), Unknown);
+        EXPECT_THROW(firstArrayParser.GetInt64(), Unknown);
     }
 
     {
@@ -754,7 +754,7 @@ TEST(Cbor, NestedStructuresEncodingAndDecoding1)
         auto secondArrayParser = secondMapParser.EnterArrayAt(4).value();
         for (auto x : INT64T_VALUES)
             EXPECT_EQ(secondArrayParser.GetInt64(), x);
-        ASSERT_THROW(secondArrayParser.GetInt64(), Unknown);
+        EXPECT_THROW(secondArrayParser.GetInt64(), Unknown);
     }
 }
 
@@ -945,7 +945,7 @@ TEST(Cbor, SkippingUndecodedEntriesUponContainerClose)
 TEST_CBOR_ENCODING(ContainerNullInAppendTextStringZ,
                    "\x81",
                    auto array = encoder.OpenArray(1),
-                   ASSERT_THROW(array.AppendTextStringZ(nullptr), Unknown))
+                   EXPECT_THROW(array.AppendTextStringZ(nullptr), Unknown))
 TEST_CBOR_ENCODING(ContainerEmptyStringInAppendTextStringZ,
                    "\x81\x60",
                    auto array = encoder.OpenArray(1),
@@ -1920,7 +1920,7 @@ TEST_CBOR_PARSING(SortedMapUndefinedKeyInPeekKey,
 TEST_CBOR_PARSING(SortedMapEmptyMapInPeekKey,
                   "\xa0",
                   auto map = parser.EnterMap(),
-                  ASSERT_THROW(map.PeekKey(), Unknown))
+                  EXPECT_THROW(map.PeekKey(), Unknown))
 TEST_CBOR_PARSING(SortedMapNullKeyInPeekKey,
                   "\xa1\xF6\x07",
                   auto map = parser.EnterMap(),

diff --git a/tests/crypto/ec_key_unittest.cpp b/tests/crypto/ec_key_unittest.cpp
index 30b2b262d71ef3638551d8624d93e1afbbc79ecc..6779bab0962ea579acf0ea069d5eb70d5407bde2 100644 (file)
--- a/tests/crypto/ec_key_unittest.cpp
+++ b/tests/crypto/ec_key_unittest.cpp
@@ -25,9 +25,9 @@ TEST(X9_62_P_256_KeyTest, CreateExportImportTest)
     auto pubKey1 = key1.ExportPublicKey(false);
     auto pubKeyCompressed1 = key1.ExportPublicKey(true);
 
-    ASSERT_EQ(privKey1.size(), 32);
-    ASSERT_EQ(pubKey1.size(), 65);
-    ASSERT_EQ(pubKeyCompressed1.size(), 33);
+    EXPECT_EQ(privKey1.size(), 32);
+    EXPECT_EQ(pubKey1.size(), 65);
+    EXPECT_EQ(pubKeyCompressed1.size(), 33);
 
     auto key2 = Crypto::X9_62_P_256_Key::ImportPrivateKey(privKey1);
     auto privKey2 = key2.ExportPrivateKey();

diff --git a/tests/handshake_tests.cpp b/tests/handshake_tests.cpp
index d342eb8c2b6646596a141145bd1c7821e3a27306..4e9fe74c9d68887ef505eaffbacb082f1694884a 100644 (file)
--- a/tests/handshake_tests.cpp
+++ b/tests/handshake_tests.cpp
@@ -189,7 +189,7 @@ public:
 
         auto ciphertext = CryptoBuffer{msg.begin() + exportedPlatformEphemeralPubKeyLen, msg.end()};
         auto plaintext = noise.DecryptAndHash(ciphertext);
-        ASSERT_TRUE(plaintext.empty());
+        EXPECT_EQ(plaintext, CryptoBuffer{});
 
         // Prepare response
         auto authenticatorEphemeralPrivKey = Crypto::X9_62_P_256_Key::Create();

diff --git a/tests/tunnel/auto_tests.cpp b/tests/tunnel/auto_tests.cpp
index a6612d6c9343425f0d155db2e27e9aaa612039d3..3961845e362b6d6a22ff54c264894e74646a6473 100644 (file)
--- a/tests/tunnel/auto_tests.cpp
+++ b/tests/tunnel/auto_tests.cpp
@@ -554,7 +554,7 @@ TEST(TunnelMockedTests, InjectedEvents)
                           std::vector<uint8_t> data = std::vector<uint8_t>()) override
         {
             auto &expectedEvent = EXPECTED_ORDER[m_eventNo];
-            ASSERT_EQ(reason, expectedEvent.reason) << "m_eventNo: " << m_eventNo;
+            EXPECT_EQ(reason, expectedEvent.reason) << "m_eventNo: " << m_eventNo;
 
             while (m_injectionsMapNextEventIdx < m_injectionsMap->size() &&
                    (*m_injectionsMap)[m_injectionsMapNextEventIdx].id == expectedEvent.id) {