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" |
George Liu | 0d7aca8 | 2020-03-30 15:01:36 +0800 | [diff] [blame] | 4 | #include "libpldmresponder/platform_state_effecter.hpp" |
George Liu | 1e44c73 | 2020-02-28 20:20:06 +0800 | [diff] [blame] | 5 | #include "mocked_utils.hpp" |
| 6 | #include "utils.hpp" |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 7 | |
| 8 | #include <iostream> |
| 9 | |
George Liu | 1e44c73 | 2020-02-28 20:20:06 +0800 | [diff] [blame] | 10 | using namespace pldm::utils; |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 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(); |
Pavithra Barithaya | 51efaf8 | 2020-04-02 02:42:27 -0500 | [diff] [blame] | 28 | Handler handler("./pdr_jsons/state_effecter/good", pdrRepo, nullptr); |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 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(); |
Pavithra Barithaya | 51efaf8 | 2020-04-02 02:42:27 -0500 | [diff] [blame] | 59 | Handler handler("./pdr_jsons/state_effecter/good", pdrRepo, nullptr); |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 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(); |
Pavithra Barithaya | 51efaf8 | 2020-04-02 02:42:27 -0500 | [diff] [blame] | 84 | Handler handler("./pdr_jsons/state_effecter/good", pdrRepo, nullptr); |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 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(); |
Pavithra Barithaya | 51efaf8 | 2020-04-02 02:42:27 -0500 | [diff] [blame] | 107 | Handler handler("./pdr_jsons/state_effecter/good", pdrRepo, nullptr); |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 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(); |
Pavithra Barithaya | 51efaf8 | 2020-04-02 02:42:27 -0500 | [diff] [blame] | 132 | Handler handler("./pdr_jsons/state_effecter/good", pdrRepo, nullptr); |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 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 | |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 178 | TEST(setStateEffecterStatesHandler, testGoodRequest) |
| 179 | { |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 180 | auto inPDRRepo = pldm_pdr_init(); |
| 181 | auto outPDRRepo = pldm_pdr_init(); |
| 182 | Repo outRepo(outPDRRepo); |
Pavithra Barithaya | 51efaf8 | 2020-04-02 02:42:27 -0500 | [diff] [blame] | 183 | Handler handler("./pdr_jsons/state_effecter/good", inPDRRepo, nullptr); |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 184 | Repo inRepo(inPDRRepo); |
| 185 | getRepoByType(inRepo, outRepo, PLDM_STATE_EFFECTER_PDR); |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 186 | pdr_utils::PdrEntry e; |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 187 | auto record1 = pdr::getRecordByHandle(outRepo, 1, e); |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 188 | ASSERT_NE(record1, nullptr); |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 189 | pldm_state_effecter_pdr* pdr = |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 190 | reinterpret_cast<pldm_state_effecter_pdr*>(e.data); |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 191 | EXPECT_EQ(pdr->hdr.type, PLDM_STATE_EFFECTER_PDR); |
| 192 | |
| 193 | std::vector<set_effecter_state_field> stateField; |
| 194 | stateField.push_back({PLDM_REQUEST_SET, 1}); |
| 195 | stateField.push_back({PLDM_REQUEST_SET, 1}); |
George Liu | 1ec85d4 | 2020-02-12 16:05:32 +0800 | [diff] [blame] | 196 | std::string value = "xyz.openbmc_project.Foo.Bar.V1"; |
George Liu | 1e44c73 | 2020-02-28 20:20:06 +0800 | [diff] [blame] | 197 | PropertyValue propertyValue = value; |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 198 | |
| 199 | MockdBusHandler handlerObj; |
George Liu | 1ec85d4 | 2020-02-12 16:05:32 +0800 | [diff] [blame] | 200 | DBusMapping dbusMapping{"/foo/bar", "xyz.openbmc_project.Foo.Bar", |
| 201 | "propertyName", "string"}; |
George Liu | 1e44c73 | 2020-02-28 20:20:06 +0800 | [diff] [blame] | 202 | |
| 203 | EXPECT_CALL(handlerObj, setDbusProperty(dbusMapping, propertyValue)) |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 204 | .Times(2); |
George Liu | 0d7aca8 | 2020-03-30 15:01:36 +0800 | [diff] [blame] | 205 | auto rc = platform_state_effecter::setStateEffecterStatesHandler< |
| 206 | MockdBusHandler, Handler>(handlerObj, handler, 0x1, stateField); |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 207 | ASSERT_EQ(rc, 0); |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 208 | |
| 209 | pldm_pdr_destroy(inPDRRepo); |
| 210 | pldm_pdr_destroy(outPDRRepo); |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 211 | } |
| 212 | |
| 213 | TEST(setStateEffecterStatesHandler, testBadRequest) |
| 214 | { |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 215 | auto inPDRRepo = pldm_pdr_init(); |
| 216 | auto outPDRRepo = pldm_pdr_init(); |
| 217 | Repo outRepo(outPDRRepo); |
Pavithra Barithaya | 51efaf8 | 2020-04-02 02:42:27 -0500 | [diff] [blame] | 218 | Handler handler("./pdr_jsons/state_effecter/good", inPDRRepo, nullptr); |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 219 | Repo inRepo(inPDRRepo); |
| 220 | getRepoByType(inRepo, outRepo, PLDM_STATE_EFFECTER_PDR); |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 221 | pdr_utils::PdrEntry e; |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 222 | auto record1 = pdr::getRecordByHandle(outRepo, 1, e); |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 223 | ASSERT_NE(record1, nullptr); |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 224 | pldm_state_effecter_pdr* pdr = |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 225 | reinterpret_cast<pldm_state_effecter_pdr*>(e.data); |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 226 | EXPECT_EQ(pdr->hdr.type, PLDM_STATE_EFFECTER_PDR); |
| 227 | |
| 228 | std::vector<set_effecter_state_field> stateField; |
| 229 | stateField.push_back({PLDM_REQUEST_SET, 3}); |
| 230 | stateField.push_back({PLDM_REQUEST_SET, 4}); |
| 231 | |
| 232 | MockdBusHandler handlerObj; |
George Liu | 0d7aca8 | 2020-03-30 15:01:36 +0800 | [diff] [blame] | 233 | auto rc = platform_state_effecter::setStateEffecterStatesHandler< |
| 234 | MockdBusHandler, Handler>(handlerObj, handler, 0x1, stateField); |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 235 | ASSERT_EQ(rc, PLDM_PLATFORM_SET_EFFECTER_UNSUPPORTED_SENSORSTATE); |
| 236 | |
George Liu | 0d7aca8 | 2020-03-30 15:01:36 +0800 | [diff] [blame] | 237 | rc = platform_state_effecter::setStateEffecterStatesHandler<MockdBusHandler, |
| 238 | Handler>( |
| 239 | handlerObj, handler, 0x9, stateField); |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 240 | ASSERT_EQ(rc, PLDM_PLATFORM_INVALID_EFFECTER_ID); |
| 241 | |
| 242 | stateField.push_back({PLDM_REQUEST_SET, 4}); |
George Liu | 0d7aca8 | 2020-03-30 15:01:36 +0800 | [diff] [blame] | 243 | rc = platform_state_effecter::setStateEffecterStatesHandler<MockdBusHandler, |
| 244 | Handler>( |
| 245 | handlerObj, handler, 0x1, stateField); |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 246 | ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA); |
| 247 | |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 248 | pldm_pdr_destroy(inPDRRepo); |
| 249 | pldm_pdr_destroy(outPDRRepo); |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 250 | } |