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