Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 1 | #include "libpldmresponder/pdr.hpp" |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 2 | #include "libpldmresponder/pdr_utils.hpp" |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 3 | #include "libpldmresponder/platform.hpp" |
| 4 | |
| 5 | #include <iostream> |
| 6 | |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 7 | #include <gmock/gmock-matchers.h> |
| 8 | #include <gmock/gmock.h> |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 9 | #include <gtest/gtest.h> |
| 10 | |
| 11 | using namespace pldm::responder; |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 12 | using namespace pldm::responder::platform; |
| 13 | using namespace pldm::responder::pdr; |
| 14 | using namespace pldm::responder::pdr_utils; |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 15 | |
| 16 | TEST(getPDR, testGoodPath) |
| 17 | { |
| 18 | std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES> |
| 19 | requestPayload{}; |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 20 | auto req = reinterpret_cast<pldm_msg*>(requestPayload.data()); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 21 | size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr); |
| 22 | |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 23 | struct pldm_get_pdr_req* request = |
| 24 | reinterpret_cast<struct pldm_get_pdr_req*>(req->payload); |
| 25 | request->request_count = 100; |
| 26 | |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 27 | auto pdrRepo = pldm_pdr_init(); |
| 28 | Handler handler("./pdr_jsons/state_effecter/good", pdrRepo); |
| 29 | Repo repo(pdrRepo); |
| 30 | ASSERT_EQ(repo.empty(), false); |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 31 | auto response = handler.getPDR(req, requestPayloadLength); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 32 | auto responsePtr = reinterpret_cast<pldm_msg*>(response.data()); |
| 33 | |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 34 | struct pldm_get_pdr_resp* resp = |
| 35 | reinterpret_cast<struct pldm_get_pdr_resp*>(responsePtr->payload); |
| 36 | ASSERT_EQ(PLDM_SUCCESS, resp->completion_code); |
| 37 | ASSERT_EQ(2, resp->next_record_handle); |
| 38 | ASSERT_EQ(true, resp->response_count != 0); |
| 39 | |
| 40 | pldm_pdr_hdr* hdr = reinterpret_cast<pldm_pdr_hdr*>(resp->record_data); |
| 41 | ASSERT_EQ(hdr->record_handle, 1); |
| 42 | ASSERT_EQ(hdr->version, 1); |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 43 | |
| 44 | pldm_pdr_destroy(pdrRepo); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 45 | } |
| 46 | |
| 47 | TEST(getPDR, testShortRead) |
| 48 | { |
| 49 | std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES> |
| 50 | requestPayload{}; |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 51 | auto req = reinterpret_cast<pldm_msg*>(requestPayload.data()); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 52 | size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr); |
| 53 | |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 54 | struct pldm_get_pdr_req* request = |
| 55 | reinterpret_cast<struct pldm_get_pdr_req*>(req->payload); |
| 56 | request->request_count = 1; |
| 57 | |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 58 | auto pdrRepo = pldm_pdr_init(); |
| 59 | Handler handler("./pdr_jsons/state_effecter/good", pdrRepo); |
| 60 | Repo repo(pdrRepo); |
| 61 | ASSERT_EQ(repo.empty(), false); |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 62 | auto response = handler.getPDR(req, requestPayloadLength); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 63 | auto responsePtr = reinterpret_cast<pldm_msg*>(response.data()); |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 64 | struct pldm_get_pdr_resp* resp = |
| 65 | reinterpret_cast<struct pldm_get_pdr_resp*>(responsePtr->payload); |
| 66 | ASSERT_EQ(PLDM_SUCCESS, resp->completion_code); |
| 67 | ASSERT_EQ(1, resp->response_count); |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 68 | pldm_pdr_destroy(pdrRepo); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 69 | } |
| 70 | |
| 71 | TEST(getPDR, testBadRecordHandle) |
| 72 | { |
| 73 | std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES> |
| 74 | requestPayload{}; |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 75 | auto req = reinterpret_cast<pldm_msg*>(requestPayload.data()); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 76 | size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr); |
| 77 | |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 78 | struct pldm_get_pdr_req* request = |
| 79 | reinterpret_cast<struct pldm_get_pdr_req*>(req->payload); |
| 80 | request->record_handle = 100000; |
| 81 | request->request_count = 1; |
| 82 | |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 83 | auto pdrRepo = pldm_pdr_init(); |
| 84 | Handler handler("./pdr_jsons/state_effecter/good", pdrRepo); |
| 85 | Repo repo(pdrRepo); |
| 86 | ASSERT_EQ(repo.empty(), false); |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 87 | auto response = handler.getPDR(req, requestPayloadLength); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 88 | auto responsePtr = reinterpret_cast<pldm_msg*>(response.data()); |
| 89 | |
| 90 | ASSERT_EQ(responsePtr->payload[0], PLDM_PLATFORM_INVALID_RECORD_HANDLE); |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 91 | |
| 92 | pldm_pdr_destroy(pdrRepo); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 93 | } |
| 94 | |
| 95 | TEST(getPDR, testNoNextRecord) |
| 96 | { |
| 97 | std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES> |
| 98 | requestPayload{}; |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 99 | auto req = reinterpret_cast<pldm_msg*>(requestPayload.data()); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 100 | size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr); |
| 101 | |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 102 | struct pldm_get_pdr_req* request = |
| 103 | reinterpret_cast<struct pldm_get_pdr_req*>(req->payload); |
| 104 | request->record_handle = 1; |
| 105 | |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 106 | auto pdrRepo = pldm_pdr_init(); |
| 107 | Handler handler("./pdr_jsons/state_effecter/good", pdrRepo); |
| 108 | Repo repo(pdrRepo); |
| 109 | ASSERT_EQ(repo.empty(), false); |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 110 | auto response = handler.getPDR(req, requestPayloadLength); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 111 | auto responsePtr = reinterpret_cast<pldm_msg*>(response.data()); |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 112 | struct pldm_get_pdr_resp* resp = |
| 113 | reinterpret_cast<struct pldm_get_pdr_resp*>(responsePtr->payload); |
| 114 | ASSERT_EQ(PLDM_SUCCESS, resp->completion_code); |
| 115 | ASSERT_EQ(2, resp->next_record_handle); |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 116 | |
| 117 | pldm_pdr_destroy(pdrRepo); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 118 | } |
| 119 | |
| 120 | TEST(getPDR, testFindPDR) |
| 121 | { |
| 122 | std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES> |
| 123 | requestPayload{}; |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 124 | auto req = reinterpret_cast<pldm_msg*>(requestPayload.data()); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 125 | size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr); |
| 126 | |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 127 | struct pldm_get_pdr_req* request = |
| 128 | reinterpret_cast<struct pldm_get_pdr_req*>(req->payload); |
| 129 | request->request_count = 100; |
| 130 | |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 131 | auto pdrRepo = pldm_pdr_init(); |
| 132 | Handler handler("./pdr_jsons/state_effecter/good", pdrRepo); |
| 133 | Repo repo(pdrRepo); |
| 134 | ASSERT_EQ(repo.empty(), false); |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 135 | auto response = handler.getPDR(req, requestPayloadLength); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 136 | |
| 137 | // Let's try to find a PDR of type stateEffecter (= 11) and entity type = |
| 138 | // 100 |
| 139 | bool found = false; |
| 140 | uint32_t handle = 0; // start asking for PDRs from recordHandle 0 |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 141 | while (!found) |
| 142 | { |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 143 | request->record_handle = handle; |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 144 | auto response = handler.getPDR(req, requestPayloadLength); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 145 | auto responsePtr = reinterpret_cast<pldm_msg*>(response.data()); |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 146 | struct pldm_get_pdr_resp* resp = |
| 147 | reinterpret_cast<struct pldm_get_pdr_resp*>(responsePtr->payload); |
| 148 | ASSERT_EQ(PLDM_SUCCESS, resp->completion_code); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 149 | |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 150 | handle = resp->next_record_handle; // point to the next pdr in case |
| 151 | // current is not what we want |
| 152 | |
| 153 | pldm_pdr_hdr* hdr = reinterpret_cast<pldm_pdr_hdr*>(resp->record_data); |
Sampa Misra | aa8ae72 | 2019-12-12 03:20:40 -0600 | [diff] [blame] | 154 | std::cerr << "PDR next record handle " << handle << "\n"; |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 155 | std::cerr << "PDR type " << hdr->type << "\n"; |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 156 | if (hdr->type == PLDM_STATE_EFFECTER_PDR) |
| 157 | { |
| 158 | pldm_state_effecter_pdr* pdr = |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 159 | reinterpret_cast<pldm_state_effecter_pdr*>(resp->record_data); |
Sampa Misra | aa8ae72 | 2019-12-12 03:20:40 -0600 | [diff] [blame] | 160 | std::cerr << "PDR entity type " << pdr->entity_type << "\n"; |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 161 | if (pdr->entity_type == 100) |
| 162 | { |
| 163 | found = true; |
| 164 | // Rest of the PDR can be accessed as need be |
| 165 | break; |
| 166 | } |
| 167 | } |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 168 | if (!resp->next_record_handle) // no more records |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 169 | { |
| 170 | break; |
| 171 | } |
| 172 | } |
| 173 | ASSERT_EQ(found, true); |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 174 | |
| 175 | pldm_pdr_destroy(pdrRepo); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 176 | } |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 177 | |
| 178 | namespace pldm |
| 179 | { |
| 180 | |
| 181 | namespace responder |
| 182 | { |
| 183 | |
| 184 | class MockdBusHandler |
| 185 | { |
| 186 | public: |
| 187 | MOCK_CONST_METHOD4(setDbusProperty, |
| 188 | int(const std::string&, const std::string&, |
| 189 | const std::string&, |
| 190 | const std::variant<std::string>&)); |
| 191 | }; |
| 192 | } // namespace responder |
| 193 | } // namespace pldm |
| 194 | |
| 195 | using ::testing::_; |
| 196 | using ::testing::Return; |
| 197 | |
| 198 | TEST(setStateEffecterStatesHandler, testGoodRequest) |
| 199 | { |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 200 | auto inPDRRepo = pldm_pdr_init(); |
| 201 | auto outPDRRepo = pldm_pdr_init(); |
| 202 | Repo outRepo(outPDRRepo); |
| 203 | Handler handler("./pdr_jsons/state_effecter/good", inPDRRepo); |
| 204 | Repo inRepo(inPDRRepo); |
| 205 | getRepoByType(inRepo, outRepo, PLDM_STATE_EFFECTER_PDR); |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 206 | pdr_utils::PdrEntry e; |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 207 | auto record1 = pdr::getRecordByHandle(outRepo, 1, e); |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 208 | ASSERT_NE(record1, nullptr); |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 209 | pldm_state_effecter_pdr* pdr = |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 210 | reinterpret_cast<pldm_state_effecter_pdr*>(e.data); |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 211 | EXPECT_EQ(pdr->hdr.type, PLDM_STATE_EFFECTER_PDR); |
| 212 | |
| 213 | std::vector<set_effecter_state_field> stateField; |
| 214 | stateField.push_back({PLDM_REQUEST_SET, 1}); |
| 215 | stateField.push_back({PLDM_REQUEST_SET, 1}); |
| 216 | |
| 217 | auto bootProgressInf = "xyz.openbmc_project.State.OperatingSystem.Status"; |
| 218 | auto bootProgressProp = "OperatingSystemState"; |
| 219 | std::string objPath = "/foo/bar"; |
| 220 | std::variant<std::string> value{"xyz.openbmc_project.State.OperatingSystem." |
| 221 | "Status.OSStatus.Standby"}; |
| 222 | |
| 223 | MockdBusHandler handlerObj; |
| 224 | EXPECT_CALL(handlerObj, setDbusProperty(objPath, bootProgressProp, |
| 225 | bootProgressInf, value)) |
| 226 | .Times(2); |
Deepak Kodihalli | bc669f1 | 2019-11-28 08:52:07 -0600 | [diff] [blame] | 227 | auto rc = handler.setStateEffecterStatesHandler<MockdBusHandler>( |
| 228 | handlerObj, 0x1, stateField); |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 229 | ASSERT_EQ(rc, 0); |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 230 | |
| 231 | pldm_pdr_destroy(inPDRRepo); |
| 232 | pldm_pdr_destroy(outPDRRepo); |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 233 | } |
| 234 | |
| 235 | TEST(setStateEffecterStatesHandler, testBadRequest) |
| 236 | { |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 237 | auto inPDRRepo = pldm_pdr_init(); |
| 238 | auto outPDRRepo = pldm_pdr_init(); |
| 239 | Repo outRepo(outPDRRepo); |
| 240 | Handler handler("./pdr_jsons/state_effecter/good", inPDRRepo); |
| 241 | Repo inRepo(inPDRRepo); |
| 242 | getRepoByType(inRepo, outRepo, PLDM_STATE_EFFECTER_PDR); |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 243 | pdr_utils::PdrEntry e; |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 244 | auto record1 = pdr::getRecordByHandle(outRepo, 1, e); |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 245 | ASSERT_NE(record1, nullptr); |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 246 | pldm_state_effecter_pdr* pdr = |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 247 | reinterpret_cast<pldm_state_effecter_pdr*>(e.data); |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 248 | EXPECT_EQ(pdr->hdr.type, PLDM_STATE_EFFECTER_PDR); |
| 249 | |
| 250 | std::vector<set_effecter_state_field> stateField; |
| 251 | stateField.push_back({PLDM_REQUEST_SET, 3}); |
| 252 | stateField.push_back({PLDM_REQUEST_SET, 4}); |
| 253 | |
| 254 | MockdBusHandler handlerObj; |
Deepak Kodihalli | bc669f1 | 2019-11-28 08:52:07 -0600 | [diff] [blame] | 255 | auto rc = handler.setStateEffecterStatesHandler<MockdBusHandler>( |
| 256 | handlerObj, 0x1, stateField); |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 257 | ASSERT_EQ(rc, PLDM_PLATFORM_SET_EFFECTER_UNSUPPORTED_SENSORSTATE); |
| 258 | |
Deepak Kodihalli | bc669f1 | 2019-11-28 08:52:07 -0600 | [diff] [blame] | 259 | rc = handler.setStateEffecterStatesHandler<MockdBusHandler>(handlerObj, 0x9, |
| 260 | stateField); |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 261 | ASSERT_EQ(rc, PLDM_PLATFORM_INVALID_EFFECTER_ID); |
| 262 | |
| 263 | stateField.push_back({PLDM_REQUEST_SET, 4}); |
Deepak Kodihalli | bc669f1 | 2019-11-28 08:52:07 -0600 | [diff] [blame] | 264 | rc = handler.setStateEffecterStatesHandler<MockdBusHandler>(handlerObj, 0x1, |
| 265 | stateField); |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 266 | ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA); |
| 267 | |
| 268 | std::vector<set_effecter_state_field> newStateField; |
| 269 | newStateField.push_back({PLDM_REQUEST_SET, 1}); |
| 270 | |
Deepak Kodihalli | bc669f1 | 2019-11-28 08:52:07 -0600 | [diff] [blame] | 271 | rc = handler.setStateEffecterStatesHandler<MockdBusHandler>(handlerObj, 0x2, |
| 272 | newStateField); |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 273 | ASSERT_EQ(rc, PLDM_PLATFORM_INVALID_STATE_VALUE); |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 274 | |
| 275 | pldm_pdr_destroy(inPDRRepo); |
| 276 | pldm_pdr_destroy(outPDRRepo); |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 277 | } |