Implement more unit tests

Source/FeatureHelpers/FeatureToggle.h

@@ -23,11 +23,6 @@ class FeatureToggleBase {
  }
  }
 
- [[nodiscard]] bool isEnabled() const noexcept
- {
- return static_cast<Feature&>(*this).enabledVariable(ToggleMethod{});
- }
-
 private:
  void callOnEnable() noexcept
  {

Source/Features/Hud/DefusingAlert/DefusingAlertPanel.h

@@ -7,7 +7,7 @@ struct DefusingAlertPanel {
  {
  }
 
- void showAndUpdate(const auto bomb) const noexcept
+ void showAndUpdate(auto&& bomb) const noexcept
  {
  context.defusingAlertContainerPanel().show();
  context.defusingCountdownTextPanel()

Tests/CMakeLists.txt

@@ -17,7 +17,9 @@ add_executable(Tests
  FeatureTests/HudFeaturesTests/BombTimerTests/BombTimerPanelTests.cpp
  FeatureTests/HudFeaturesTests/BombTimerTests/BombTimerTests.cpp
  FeatureTests/HudFeaturesTests/BombTimerTests/BombTimerTextPanelTests.cpp
+ FeatureTests/HudFeaturesTests/BombTimerTests/BombTimerToggleTests.cpp
  FeatureTests/HudFeaturesTests/BombTimerTests/GameBombStatusPanelTests.cpp
+ FeatureTests/HudFeaturesTests/DefusingAlertTests/DefusingAlertPanelTests.cpp
 )
 
 add_subdirectory(HelpersTests)

Tests/FeatureTests/HudFeaturesTests/BombTimerTests/BombSiteIconPanelTests.cpp

@@ -24,5 +24,5 @@ TEST_P(BombSiteIconPanelTestWithParam, SetsCorrectImageUrl) {
  bombSiteIconPanel.setIcon(GetParam());
 }
 
-INSTANTIATE_TEST_CASE_P(, BombSiteIconPanelTestWithParam,
+INSTANTIATE_TEST_SUITE_P(, BombSiteIconPanelTestWithParam,
  testing::Values(cs2::kBombSiteAIconUrl, cs2::kBombSiteBIconUrl));

Tests/FeatureTests/HudFeaturesTests/BombTimerTests/BombTimerPanelTests.cpp

@@ -20,7 +20,7 @@ class BombTimerPanelTest : public testing::Test {
  BombTimerPanel<MockBombTimerContext&> bombTimerPanel{mockBombTimerContext};
 };
 
-TEST_F(BombTimerPanelTest, HideMethodHidesContainerPanel) {
+TEST_F(BombTimerPanelTest, HidesContainerPanel) {
  EXPECT_CALL(mockBombTimerContext, bombTimerContainerPanel()).WillOnce(testing::ReturnRef(mockBombTimerContainerPanel));
  EXPECT_CALL(mockBombTimerContainerPanel, hide());
 
@@ -35,7 +35,7 @@ struct BombTimerPanelTestParam {
 class BombTimerPanelTestWithParam : public BombTimerPanelTest, public testing::WithParamInterface<BombTimerPanelTestParam> {
 };
 
-TEST_P(BombTimerPanelTestWithParam, aaa) {
+TEST_P(BombTimerPanelTestWithParam, ShowsContainerPanelAndSetsBombSiteIconAndTimeToExplosion) {
  EXPECT_CALL(mockBombTimerContext, bombTimerContainerPanel()).WillOnce(testing::ReturnRef(mockBombTimerContainerPanel));
  EXPECT_CALL(mockBombTimerContext, tickingC4()).WillOnce(testing::ReturnRef(mockPlantedC4));
  EXPECT_CALL(mockBombTimerContext, bombSiteIconPanel()).WillOnce(testing::ReturnRef(mockBombSiteIconPanel));

Tests/FeatureTests/HudFeaturesTests/BombTimerTests/BombTimerToggleTests.cpp

@@ -0,0 +1,55 @@
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <Fakes/FakeBombTimerState.h>
+#include <Features/Hud/BombTimer/BombTimerToggle.h>
+#include <Mocks/MockBombTimerContext.h>
+#include <Mocks/MockBombTimerPanel.h>
+#include <Mocks/MockGameBombStatusPanel.h>
+
+class BombTimerToggleTest : public testing::Test {
+protected:
+ BombTimerToggleTest()
+ {
+ EXPECT_CALL(mockBombTimerContext, state()).WillOnce(testing::ReturnRef(state));
+ }
+
+ testing::StrictMock<MockBombTimerContext> mockBombTimerContext;
+ testing::StrictMock<MockGameBombStatusPanel> mockGameBombStatusPanel;
+ testing::StrictMock<MockBombTimerPanel> mockBombTimerPanel;
+
+ BombTimerToggle<MockBombTimerContext&> bombTimerToggle{mockBombTimerContext};
+ FakeBombTimerState state;
+};
+
+TEST_F(BombTimerToggleTest, EnablingSetsEnabledVariableToTrue) {
+ state.enabled = false;
+ bombTimerToggle.enable();
+ EXPECT_EQ(state.enabled, true);
+}
+
+TEST_F(BombTimerToggleTest, EnablingDoesNothingIfAlreadyEnabled) {
+ state.enabled = true;
+ bombTimerToggle.enable();
+ EXPECT_EQ(state.enabled, true);
+}
+
+TEST_F(BombTimerToggleTest, DisablingDoesNothingIfAlreadyDisabled) {
+ state.enabled = false;
+ bombTimerToggle.disable();
+ EXPECT_EQ(state.enabled, false);
+}
+
+TEST_F(BombTimerToggleTest, DisablingRestoresBombStatusPanelAndHidesBombTimerPanel) {
+ state.enabled = true;
+
+ EXPECT_CALL(mockBombTimerContext, gameBombStatusPanel()).WillOnce(testing::ReturnRef(mockGameBombStatusPanel));
+ EXPECT_CALL(mockGameBombStatusPanel, restore());
+
+ EXPECT_CALL(mockBombTimerContext, bombTimerPanel()).WillOnce(testing::ReturnRef(mockBombTimerPanel));
+ EXPECT_CALL(mockBombTimerPanel, hide());
+
+ bombTimerToggle.disable();
+
+ EXPECT_EQ(state.enabled, false);
+}

Tests/FeatureTests/HudFeaturesTests/DefusingAlertTests/DefusingAlertPanelTests.cpp

@@ -0,0 +1,60 @@
+#include <optional>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <Features/Hud/DefusingAlert/DefusingAlertPanel.h>
+#include <Mocks/MockDefusingAlertContext.h>
+#include <Mocks/MockDefusingCountdownTextPanel.h>
+#include <Mocks/MockPanel.h>
+#include <Mocks/MockPlantedC4.h>
+
+class DefusingAlertPanelTest : public testing::Test {
+protected:
+ testing::StrictMock<MockDefusingAlertContext> mockDefusingAlertContext;
+ testing::StrictMock<MockPanel> mockDefusingAlertContainerPanel;
+ testing::StrictMock<MockDefusingCountdownTextPanel> mockDefusingCountdownTextPanel;
+ testing::StrictMock<MockPlantedC4> mockPlantedC4;
+
+ DefusingAlertPanel<MockDefusingAlertContext&> defusingAlertPanel{mockDefusingAlertContext};
+};
+
+TEST_F(DefusingAlertPanelTest, HidesDefusingAlertContainerPanel) {
+ EXPECT_CALL(mockDefusingAlertContext, defusingAlertContainerPanel()).WillOnce(testing::ReturnRef(mockDefusingAlertContainerPanel));
+ EXPECT_CALL(mockDefusingAlertContainerPanel, hide());
+
+ defusingAlertPanel.hide();
+}
+
+struct DefusingAlertPanelTestParam {
+ std::optional<float> timeToDefuseEnd{3.34f};
+ std::optional<bool> canBeDefused{true};
+};
+
+class DefusingAlertPanelTestWithParam : public DefusingAlertPanelTest, public testing::WithParamInterface<DefusingAlertPanelTestParam> {
+};
+
+TEST_P(DefusingAlertPanelTestWithParam, ShowsDefusingAlertContainerPanelAndUpdatesCountdownTextPanel) {
+ EXPECT_CALL(mockDefusingAlertContext, defusingAlertContainerPanel()).WillOnce(testing::ReturnRef(mockDefusingAlertContainerPanel));
+ EXPECT_CALL(mockDefusingAlertContainerPanel, show());
+
+ EXPECT_CALL(mockDefusingAlertContext, defusingCountdownTextPanel()).WillOnce(testing::ReturnRef(mockDefusingCountdownTextPanel));
+ EXPECT_CALL(mockDefusingCountdownTextPanel, setTimeToDefuseEnd(GetParam().timeToDefuseEnd)).WillOnce(testing::ReturnRef(mockDefusingCountdownTextPanel));
+ EXPECT_CALL(mockDefusingCountdownTextPanel, setCanBeDefused(GetParam().canBeDefused)).WillOnce(testing::ReturnRef(mockDefusingCountdownTextPanel));
+
+ EXPECT_CALL(mockPlantedC4, getTimeToDefuseEnd()).WillOnce(testing::Return(GetParam().timeToDefuseEnd));
+ EXPECT_CALL(mockPlantedC4, canBeDefused()).WillOnce(testing::Return(GetParam().canBeDefused));
+
+ defusingAlertPanel.showAndUpdate(mockPlantedC4);
+}
+
+INSTANTIATE_TEST_SUITE_P(, DefusingAlertPanelTestWithParam, testing::Values(
+ DefusingAlertPanelTestParam{.timeToDefuseEnd = 0.0f},
+ DefusingAlertPanelTestParam{.timeToDefuseEnd = 3.45f},
+ DefusingAlertPanelTestParam{.timeToDefuseEnd = 10.0f},
+ DefusingAlertPanelTestParam{.timeToDefuseEnd = std::nullopt},
+ DefusingAlertPanelTestParam{.canBeDefused = false},
+ DefusingAlertPanelTestParam{.canBeDefused = true},
+ DefusingAlertPanelTestParam{.canBeDefused = std::nullopt},
+ DefusingAlertPanelTestParam{.timeToDefuseEnd = std::nullopt, .canBeDefused = std::nullopt}
+));

Tests/Mocks/MockDefusingAlertContext.h

@@ -0,0 +1,9 @@
+#pragma once
+
+struct MockDefusingCountdownTextPanel;
+struct MockPanel;
+
+struct MockDefusingAlertContext {
+ MOCK_METHOD(MockPanel&, defusingAlertContainerPanel, ());
+ MOCK_METHOD(MockDefusingCountdownTextPanel&, defusingCountdownTextPanel, ());
+};

Tests/Mocks/MockDefusingCountdownTextPanel.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <optional>
+
+#include <gmock/gmock.h>
+
+struct MockDefusingCountdownTextPanel {
+ MOCK_METHOD(MockDefusingCountdownTextPanel&, setTimeToDefuseEnd, (std::optional<float> timeToDefuseEnd));
+ MOCK_METHOD(MockDefusingCountdownTextPanel&, setCanBeDefused, (std::optional<bool> canBeDefused));
+};

Tests/Mocks/MockPlantedC4.h

@@ -1,8 +1,12 @@
 #pragma once
 
+#include <optional>
+
 #include <gmock/gmock.h>
 
 struct MockPlantedC4 {
  MOCK_METHOD(const char*, getBombSiteIconUrl, ());
  MOCK_METHOD(float, getTimeToExplosion, ());
+ MOCK_METHOD(std::optional<float>, getTimeToDefuseEnd, ());
+ MOCK_METHOD(std::optional<bool>, canBeDefused, ());
 };