test/test-soc-reset-me.cpp - pldm-oem-google - Git at Google

 /*
  * Copyright 2023 Google LLC
  *
  * 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
  *
  * 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.
  */
 #include "src/soc-reset-me.hpp"

 #include <sdbusplus/test/sdbus_mock.hpp>

 #include <gmock/gmock.h>
 #include <gtest/gtest.h>

 using ::testing::_;
 using ::testing::StrEq;
 namespace pldm_oem_google
 {
 namespace soc_reset_me
 {
 // PeerSoCId tests
 class PeerSoCIdTest : public ::testing::Test
 {
     void SetUp() override
     {
         // reset the internal optional
         PeerSoCId::socId.reset();
     }
 };
 // current implemetation in Athena
 // valid instance value is "0", "1"
 // instance 0 => CN_1, instance 1 => CN_2
 // this unit test to capture this arbitary mapping policy/assumption
 // accidently changed in the future
 TEST_F(PeerSoCIdTest, SetWithPldmdInstanceParam)
 {
     // Test setting with invalid instance (e.g., non-integer).
     EXPECT_FALSE(PeerSoCId::setWithPldmdInstanceParam("invalid"));
     EXPECT_EQ(PeerSoCId::value(), SocId::cnDefault);
     EXPECT_TRUE(PeerSoCId::isDefault());

     // Test setting with an unsupported SoC ID.
     EXPECT_FALSE(PeerSoCId::setWithPldmdInstanceParam("3"));
     EXPECT_EQ(PeerSoCId::value(), SocId::cnDefault);
     EXPECT_TRUE(PeerSoCId::isDefault());

     // Test setting with valid instance: "0"
     EXPECT_TRUE(PeerSoCId::setWithPldmdInstanceParam("0"));
     EXPECT_EQ(PeerSoCId::value(), SocId::cn1);
     EXPECT_FALSE(PeerSoCId::isDefault());
 }

 TEST_F(PeerSoCIdTest, SetWithPldmdInstanceParam_cn1)
 {
     // Test setting with valid instance: "0"
     EXPECT_TRUE(PeerSoCId::setWithPldmdInstanceParam("0"));
     EXPECT_EQ(PeerSoCId::value(), SocId::cn1);
     EXPECT_FALSE(PeerSoCId::isDefault());

     // Test setting with valid instance: "1", immutable after first set
     EXPECT_FALSE(PeerSoCId::setWithPldmdInstanceParam("1"));
     EXPECT_EQ(PeerSoCId::value(), SocId::cn1);
     EXPECT_FALSE(PeerSoCId::isDefault());
 }

 TEST_F(PeerSoCIdTest, SetWithPldmdInstanceParam_cn2)
 {
     // Test setting with valid instance: "1"
     EXPECT_TRUE(PeerSoCId::setWithPldmdInstanceParam("1"));
     EXPECT_EQ(PeerSoCId::value(), SocId::cn2);
     EXPECT_FALSE(PeerSoCId::isDefault());

     // Test setting with valid instance: "0", immutable after first set
     EXPECT_FALSE(PeerSoCId::setWithPldmdInstanceParam("0"));
     EXPECT_EQ(PeerSoCId::value(), SocId::cn2);
     EXPECT_FALSE(PeerSoCId::isDefault());
 }

 // Test fixture for SocResetMeHandler tests
 class SocResetMeHandlerTest : public testing::Test
 {
   protected:
     static constexpr auto hostStateReboot =
         "xyz.openbmc_project.State.Host.Transition.Reboot";
     static constexpr auto dbusPropIntf = "org.freedesktop.DBus.Properties";
     ::testing::NiceMock<sdbusplus::SdBusMock> mock;
     static auto dbusParams(SocResetMeHandler& h)
     {
         return h.dbusParams;
     }
     static void resetSoC(SocResetMeHandler& h)
     {
         h.resetSoC(SOC_RESET_ME_AUTO);
     }
     static auto quicentEnd(SocResetMeHandler& h)
     {
         return h.quiescentEnd;
     }
     static void
         mockQuiecentEnd(SocResetMeHandler& h,
                         decltype(SocResetMeHandler::quiescentEnd) mocktime)
     {
         h.quiescentEnd = mocktime;
     }
     void expectNewSetPropMethod(const struct ResetDBusParams* params)
     {
         EXPECT_CALL(mock, sd_bus_message_new_method_call(
                               _, _, StrEq(params->conn), StrEq(params->path),
                               StrEq(dbusPropIntf), StrEq("Set")))
             .WillOnce(::testing::Return(0));
     }
     void expectMessageAppend(const char* val)
     {
         using testing::MatcherCast;
         using testing::Pointee;
         using testing::SafeMatcherCast;
         using ::testing::StrEq;
         EXPECT_CALL(mock, sd_bus_message_append_basic(
                               _, SD_BUS_TYPE_STRING,
                               MatcherCast<const void*>(
                                   SafeMatcherCast<const char*>(StrEq(val)))))
             .WillOnce(::testing::Return(0));
     }
     void expectSetHostTransactionProp(const struct ResetDBusParams* params)
     {
         expectNewSetPropMethod(params);
         expectMessageAppend(params->intf);
         expectMessageAppend(params->prop);
         expectMessageAppend(hostStateReboot);
         // sync call without timeout
         EXPECT_CALL(mock, sd_bus_call(_, _, 0, _, _)).Times(1);
     }

     auto resetMeRequestMsg(uint32_t quiescentPeriod, const char* str)
     {
         std::string_view resetReason{str};

         memset(&data, 0, sizeof(data));
         memcpy(data + sizeof(struct pldm_event_oem_google_soc_reset_me),
                resetReason.data(), resetReason.length());
         auto* msg =
             reinterpret_cast<struct pldm_event_oem_google_soc_reset_me*>(data);
         msg->descLen = resetReason.length();
         msg->resetQuiesent = quiescentPeriod;
         return msg;
     }

     uint8_t data[sizeof(struct pldm_event_oem_google_soc_reset_me) + 128];
 };

 // Test SocResetMeHandler constructor
 TEST_F(SocResetMeHandlerTest, Constructor_InitializeDBusParams)
 {
     SocResetMeHandler mockCn1Handler(SocId::cn1,
                                      sdbusplus::get_mocked_new(&mock));
     EXPECT_EQ(dbusParams(mockCn1Handler), cn1DbusParams());
     SocResetMeHandler mockCn2Handler(SocId::cn2,
                                      sdbusplus::get_mocked_new(&mock));
     EXPECT_EQ(dbusParams(mockCn2Handler), cn2DbusParams());
     EXPECT_THROW(SocResetMeHandler mockInvalidHander(
                      SocId::cnDefault, sdbusplus::get_mocked_new(&mock)),
                  InvalidSoCIdException);
     EXPECT_THROW(SocResetMeHandler mockInvalidHander(
                      static_cast<SocId>(-1), sdbusplus::get_mocked_new(&mock)),
                  InvalidSoCIdException);
 }

 class MockSocResetMeHandler : public SocResetMeHandler
 {
   public:
     // Constructor taking the same parameters as SocResetMeHandler
     MockSocResetMeHandler(const SocId id, sdbusplus::bus_t&& b) :
         SocResetMeHandler(id, std::move(b))
     {}

     MOCK_METHOD(void, resetSoC, (const uint16_t resetType), (override));
     MOCK_METHOD(void, logRequest,
                 (uint64_t internalInfo, uint16_t resetType,
                  uint32_t quiescentPeriod, const std::string& resetReason),
                 (const, override));
     MOCK_METHOD(void, logRequestIgnored, (const ResetTimeStamp& requestTime),
                 (const, override));
     MOCK_METHOD(void, logRequestIssued, (const ResetTimeStamp& requestTime),
                 (const, override));
 };

 // First time handling shall not in any reset quiecent period
 // so shall reset and update the reset quiecentEnd to
 // handleTime + requestQuiesent
 TEST_F(SocResetMeHandlerTest, HandleSocResetMeFirstTime)
 {
     using std::chrono::seconds;
     using std::chrono::_V2::steady_clock;
     const auto* reason = "HandleSocResetMeFirstTime";
     auto* msg = resetMeRequestMsg(0, reason);

     MockSocResetMeHandler mockHandler(SocId::cn1,
                                       sdbusplus::get_mocked_new(&mock));
     EXPECT_CALL(mockHandler, resetSoC(msg->resetType)).Times(1);
     EXPECT_CALL(mockHandler, logRequest(msg->internalInfo, msg->resetType,
                                         msg->resetQuiesent, StrEq(reason)))
         .Times(1);
     EXPECT_CALL(mockHandler, logRequestIssued(_)).Times(1);
     EXPECT_CALL(mockHandler, logRequestIgnored(_)).Times(0);

     mockHandler.handle(0, msg, msg->descLen + sizeof(*msg));

     EXPECT_EQ(
         duration_cast<seconds>(quicentEnd(mockHandler).time_since_epoch()),
         duration_cast<seconds>(
             (steady_clock::now() + seconds(msg->resetQuiesent))
                 .time_since_epoch()));
 }

 // Following on handling request out of quiencent
 // reset SoC and update quiecentEnd to handletTime + requestQuiesent
 TEST_F(SocResetMeHandlerTest, HandleSocResetMeOutQuiesent)
 {
     using std::chrono::seconds;
     using std::chrono::_V2::steady_clock;
     const auto* reason = "HandleSocResetMeOutQuiesent";
     auto* msg = resetMeRequestMsg(10, reason);
     MockSocResetMeHandler mockHandler(SocId::cn1,
                                       sdbusplus::get_mocked_new(&mock));
     auto mocktime = steady_clock::now() - seconds(30);
     mockQuiecentEnd(mockHandler, mocktime);
     EXPECT_CALL(mockHandler, resetSoC(msg->resetType)).Times(1);
     EXPECT_CALL(mockHandler, logRequest(msg->internalInfo, msg->resetType,
                                         msg->resetQuiesent, StrEq(reason)))
         .Times(1);
     EXPECT_CALL(mockHandler, logRequestIssued(_)).Times(1);
     EXPECT_CALL(mockHandler, logRequestIgnored(_)).Times(0);
     mockHandler.handle(0, msg, msg->descLen + sizeof(*msg));

     EXPECT_EQ(
         duration_cast<seconds>(quicentEnd(mockHandler).time_since_epoch()),
         duration_cast<seconds>(
             (steady_clock::now() + seconds(msg->resetQuiesent))
                 .time_since_epoch()));
 }

 // Following on handling request within quiencent period
 // ingore this request and w/o resetting SoC nor updating quiecentEnd
 TEST_F(SocResetMeHandlerTest, HandleSocResetMeInQuiesent)
 {
     using std::chrono::seconds;
     using std::chrono::_V2::steady_clock;
     const auto* reason = "HandleSocResetMeInQuiesent";
     auto* msg = resetMeRequestMsg(10, reason);

     MockSocResetMeHandler mockHandler(SocId::cn1,
                                       sdbusplus::get_mocked_new(&mock));
     auto mocktime = steady_clock::now() + seconds(30);
     mockQuiecentEnd(mockHandler, mocktime);
     EXPECT_CALL(mockHandler, resetSoC(msg->resetType)).Times(0);
     EXPECT_CALL(mockHandler, logRequest(msg->internalInfo, msg->resetType,
                                         msg->resetQuiesent, StrEq(reason)))
         .Times(1);
     EXPECT_CALL(mockHandler, logRequestIssued(_)).Times(0);
     EXPECT_CALL(mockHandler, logRequestIgnored(_)).Times(1);

     mockHandler.handle(0, msg, sizeof(*msg) + msg->descLen);

     EXPECT_EQ(quicentEnd(mockHandler), mocktime);
 }

 // Test the expected behavior: set the corresponding state transaction property
 TEST_F(SocResetMeHandlerTest, SocResetCn1)
 {
     expectSetHostTransactionProp(cn1DbusParams());
     SocResetMeHandler mockHandler(SocId::cn1, sdbusplus::get_mocked_new(&mock));
     resetSoC(mockHandler);
 }

 TEST_F(SocResetMeHandlerTest, SocResetCn2)
 {
     expectSetHostTransactionProp(cn2DbusParams());
     SocResetMeHandler mockHandler(SocId::cn2, sdbusplus::get_mocked_new(&mock));
     resetSoC(mockHandler);
 }

 } // namespace soc_reset_me
 } // namespace pldm_oem_google
	/*
	* Copyright 2023 Google LLC
	*
	* 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
	*
	* 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.
	*/
	#include "src/soc-reset-me.hpp"

	#include <sdbusplus/test/sdbus_mock.hpp>

	#include <gmock/gmock.h>
	#include <gtest/gtest.h>

	using ::testing::_;
	using ::testing::StrEq;
	namespace pldm_oem_google
	{
	namespace soc_reset_me
	{
	// PeerSoCId tests
	class PeerSoCIdTest : public ::testing::Test
	{
	void SetUp() override
	{
	// reset the internal optional
	PeerSoCId::socId.reset();
	}
	};
	// current implemetation in Athena
	// valid instance value is "0", "1"
	// instance 0 => CN_1, instance 1 => CN_2
	// this unit test to capture this arbitary mapping policy/assumption
	// accidently changed in the future
	TEST_F(PeerSoCIdTest, SetWithPldmdInstanceParam)
	{
	// Test setting with invalid instance (e.g., non-integer).
	EXPECT_FALSE(PeerSoCId::setWithPldmdInstanceParam("invalid"));
	EXPECT_EQ(PeerSoCId::value(), SocId::cnDefault);
	EXPECT_TRUE(PeerSoCId::isDefault());

	// Test setting with an unsupported SoC ID.
	EXPECT_FALSE(PeerSoCId::setWithPldmdInstanceParam("3"));
	EXPECT_EQ(PeerSoCId::value(), SocId::cnDefault);
	EXPECT_TRUE(PeerSoCId::isDefault());

	// Test setting with valid instance: "0"
	EXPECT_TRUE(PeerSoCId::setWithPldmdInstanceParam("0"));
	EXPECT_EQ(PeerSoCId::value(), SocId::cn1);
	EXPECT_FALSE(PeerSoCId::isDefault());
	}

	TEST_F(PeerSoCIdTest, SetWithPldmdInstanceParam_cn1)
	{
	// Test setting with valid instance: "0"
	EXPECT_TRUE(PeerSoCId::setWithPldmdInstanceParam("0"));
	EXPECT_EQ(PeerSoCId::value(), SocId::cn1);
	EXPECT_FALSE(PeerSoCId::isDefault());

	// Test setting with valid instance: "1", immutable after first set
	EXPECT_FALSE(PeerSoCId::setWithPldmdInstanceParam("1"));
	EXPECT_EQ(PeerSoCId::value(), SocId::cn1);
	EXPECT_FALSE(PeerSoCId::isDefault());
	}

	TEST_F(PeerSoCIdTest, SetWithPldmdInstanceParam_cn2)
	{
	// Test setting with valid instance: "1"
	EXPECT_TRUE(PeerSoCId::setWithPldmdInstanceParam("1"));
	EXPECT_EQ(PeerSoCId::value(), SocId::cn2);
	EXPECT_FALSE(PeerSoCId::isDefault());

	// Test setting with valid instance: "0", immutable after first set
	EXPECT_FALSE(PeerSoCId::setWithPldmdInstanceParam("0"));
	EXPECT_EQ(PeerSoCId::value(), SocId::cn2);
	EXPECT_FALSE(PeerSoCId::isDefault());
	}

	// Test fixture for SocResetMeHandler tests
	class SocResetMeHandlerTest : public testing::Test
	{
	protected:
	static constexpr auto hostStateReboot =
	"xyz.openbmc_project.State.Host.Transition.Reboot";
	static constexpr auto dbusPropIntf = "org.freedesktop.DBus.Properties";
	::testing::NiceMock<sdbusplus::SdBusMock> mock;
	static auto dbusParams(SocResetMeHandler& h)
	{
	return h.dbusParams;
	}
	static void resetSoC(SocResetMeHandler& h)
	{
	h.resetSoC(SOC_RESET_ME_AUTO);
	}
	static auto quicentEnd(SocResetMeHandler& h)
	{
	return h.quiescentEnd;
	}
	static void
	mockQuiecentEnd(SocResetMeHandler& h,
	decltype(SocResetMeHandler::quiescentEnd) mocktime)
	{
	h.quiescentEnd = mocktime;
	}
	void expectNewSetPropMethod(const struct ResetDBusParams* params)
	{
	EXPECT_CALL(mock, sd_bus_message_new_method_call(
	_, _, StrEq(params->conn), StrEq(params->path),
	StrEq(dbusPropIntf), StrEq("Set")))
	.WillOnce(::testing::Return(0));
	}
	void expectMessageAppend(const char* val)
	{
	using testing::MatcherCast;
	using testing::Pointee;
	using testing::SafeMatcherCast;
	using ::testing::StrEq;
	EXPECT_CALL(mock, sd_bus_message_append_basic(
	_, SD_BUS_TYPE_STRING,
	MatcherCast<const void*>(
	SafeMatcherCast<const char*>(StrEq(val)))))
	.WillOnce(::testing::Return(0));
	}
	void expectSetHostTransactionProp(const struct ResetDBusParams* params)
	{
	expectNewSetPropMethod(params);
	expectMessageAppend(params->intf);
	expectMessageAppend(params->prop);
	expectMessageAppend(hostStateReboot);
	// sync call without timeout
	EXPECT_CALL(mock, sd_bus_call(_, _, 0, _, _)).Times(1);
	}

	auto resetMeRequestMsg(uint32_t quiescentPeriod, const char* str)
	{
	std::string_view resetReason{str};

	memset(&data, 0, sizeof(data));
	memcpy(data + sizeof(struct pldm_event_oem_google_soc_reset_me),
	resetReason.data(), resetReason.length());
	auto* msg =
	reinterpret_cast<struct pldm_event_oem_google_soc_reset_me*>(data);
	msg->descLen = resetReason.length();
	msg->resetQuiesent = quiescentPeriod;
	return msg;
	}

	uint8_t data[sizeof(struct pldm_event_oem_google_soc_reset_me) + 128];
	};

	// Test SocResetMeHandler constructor
	TEST_F(SocResetMeHandlerTest, Constructor_InitializeDBusParams)
	{
	SocResetMeHandler mockCn1Handler(SocId::cn1,
	sdbusplus::get_mocked_new(&mock));
	EXPECT_EQ(dbusParams(mockCn1Handler), cn1DbusParams());
	SocResetMeHandler mockCn2Handler(SocId::cn2,
	sdbusplus::get_mocked_new(&mock));
	EXPECT_EQ(dbusParams(mockCn2Handler), cn2DbusParams());
	EXPECT_THROW(SocResetMeHandler mockInvalidHander(
	SocId::cnDefault, sdbusplus::get_mocked_new(&mock)),
	InvalidSoCIdException);
	EXPECT_THROW(SocResetMeHandler mockInvalidHander(
	static_cast<SocId>(-1), sdbusplus::get_mocked_new(&mock)),
	InvalidSoCIdException);
	}

	class MockSocResetMeHandler : public SocResetMeHandler
	{
	public:
	// Constructor taking the same parameters as SocResetMeHandler
	MockSocResetMeHandler(const SocId id, sdbusplus::bus_t&& b) :
	SocResetMeHandler(id, std::move(b))
	{}

	MOCK_METHOD(void, resetSoC, (const uint16_t resetType), (override));
	MOCK_METHOD(void, logRequest,
	(uint64_t internalInfo, uint16_t resetType,
	uint32_t quiescentPeriod, const std::string& resetReason),
	(const, override));
	MOCK_METHOD(void, logRequestIgnored, (const ResetTimeStamp& requestTime),
	(const, override));
	MOCK_METHOD(void, logRequestIssued, (const ResetTimeStamp& requestTime),
	(const, override));
	};

	// First time handling shall not in any reset quiecent period
	// so shall reset and update the reset quiecentEnd to
	// handleTime + requestQuiesent
	TEST_F(SocResetMeHandlerTest, HandleSocResetMeFirstTime)
	{
	using std::chrono::seconds;
	using std::chrono::_V2::steady_clock;
	const auto* reason = "HandleSocResetMeFirstTime";
	auto* msg = resetMeRequestMsg(0, reason);

	MockSocResetMeHandler mockHandler(SocId::cn1,
	sdbusplus::get_mocked_new(&mock));
	EXPECT_CALL(mockHandler, resetSoC(msg->resetType)).Times(1);
	EXPECT_CALL(mockHandler, logRequest(msg->internalInfo, msg->resetType,
	msg->resetQuiesent, StrEq(reason)))
	.Times(1);
	EXPECT_CALL(mockHandler, logRequestIssued(_)).Times(1);
	EXPECT_CALL(mockHandler, logRequestIgnored(_)).Times(0);

	mockHandler.handle(0, msg, msg->descLen + sizeof(*msg));

	EXPECT_EQ(
	duration_cast<seconds>(quicentEnd(mockHandler).time_since_epoch()),
	duration_cast<seconds>(
	(steady_clock::now() + seconds(msg->resetQuiesent))
	.time_since_epoch()));
	}

	// Following on handling request out of quiencent
	// reset SoC and update quiecentEnd to handletTime + requestQuiesent
	TEST_F(SocResetMeHandlerTest, HandleSocResetMeOutQuiesent)
	{
	using std::chrono::seconds;
	using std::chrono::_V2::steady_clock;
	const auto* reason = "HandleSocResetMeOutQuiesent";
	auto* msg = resetMeRequestMsg(10, reason);
	MockSocResetMeHandler mockHandler(SocId::cn1,
	sdbusplus::get_mocked_new(&mock));
	auto mocktime = steady_clock::now() - seconds(30);
	mockQuiecentEnd(mockHandler, mocktime);
	EXPECT_CALL(mockHandler, resetSoC(msg->resetType)).Times(1);
	EXPECT_CALL(mockHandler, logRequest(msg->internalInfo, msg->resetType,
	msg->resetQuiesent, StrEq(reason)))
	.Times(1);
	EXPECT_CALL(mockHandler, logRequestIssued(_)).Times(1);
	EXPECT_CALL(mockHandler, logRequestIgnored(_)).Times(0);
	mockHandler.handle(0, msg, msg->descLen + sizeof(*msg));

	EXPECT_EQ(
	duration_cast<seconds>(quicentEnd(mockHandler).time_since_epoch()),
	duration_cast<seconds>(
	(steady_clock::now() + seconds(msg->resetQuiesent))
	.time_since_epoch()));
	}

	// Following on handling request within quiencent period
	// ingore this request and w/o resetting SoC nor updating quiecentEnd
	TEST_F(SocResetMeHandlerTest, HandleSocResetMeInQuiesent)
	{
	using std::chrono::seconds;
	using std::chrono::_V2::steady_clock;
	const auto* reason = "HandleSocResetMeInQuiesent";
	auto* msg = resetMeRequestMsg(10, reason);

	MockSocResetMeHandler mockHandler(SocId::cn1,
	sdbusplus::get_mocked_new(&mock));
	auto mocktime = steady_clock::now() + seconds(30);
	mockQuiecentEnd(mockHandler, mocktime);
	EXPECT_CALL(mockHandler, resetSoC(msg->resetType)).Times(0);
	EXPECT_CALL(mockHandler, logRequest(msg->internalInfo, msg->resetType,
	msg->resetQuiesent, StrEq(reason)))
	.Times(1);
	EXPECT_CALL(mockHandler, logRequestIssued(_)).Times(0);
	EXPECT_CALL(mockHandler, logRequestIgnored(_)).Times(1);

	mockHandler.handle(0, msg, sizeof(*msg) + msg->descLen);

	EXPECT_EQ(quicentEnd(mockHandler), mocktime);
	}

	// Test the expected behavior: set the corresponding state transaction property
	TEST_F(SocResetMeHandlerTest, SocResetCn1)
	{
	expectSetHostTransactionProp(cn1DbusParams());
	SocResetMeHandler mockHandler(SocId::cn1, sdbusplus::get_mocked_new(&mock));
	resetSoC(mockHandler);
	}

	TEST_F(SocResetMeHandlerTest, SocResetCn2)
	{
	expectSetHostTransactionProp(cn2DbusParams());
	SocResetMeHandler mockHandler(SocId::cn2, sdbusplus::get_mocked_new(&mock));
	resetSoC(mockHandler);
	}

	} // namespace soc_reset_me
	} // namespace pldm_oem_google