| /** @file | |
| Copyright (c) 2022-2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. | |
| SPDX-License-Identifier: BSD-2-Clause-Patent | |
| **/ | |
| #include <stdarg.h> | |
| #include <stddef.h> | |
| #include <setjmp.h> | |
| #include <stdint.h> | |
| #include <cmocka.h> | |
| #include <Uefi.h> | |
| #include <Library/BaseMemoryLib.h> | |
| #include <Library/DebugLib.h> | |
| #include <Library/MemoryAllocationLib.h> | |
| #include <Library/HostBasedTestStubLib/IpmiStubLib.h> | |
| #include <Library/UnitTestLib.h> | |
| #include <Protocol/IpmiBlobTransfer.h> | |
| #include "../InternalIpmiBlobTransfer.h" | |
| #define UNIT_TEST_NAME "IPMI Blob Transfer Unit Tests" | |
| #define UNIT_TEST_VERSION "1.0" | |
| UINT8 InvalidCompletion[] = { | |
| 0xC0, // CompletionCode | |
| 0xCF, 0xC2, 0x00, // OpenBMC OEN | |
| }; | |
| #define INVALID_COMPLETION_SIZE 4 * sizeof(UINT8) | |
| UINT8 NoDataResponse[] = { | |
| 0x00, // CompletionCode | |
| 0xCF, 0xC2, 0x00, // OpenBMC OEN | |
| }; | |
| #define NO_DATA_RESPONSE_SIZE 4 * sizeof(UINT8) | |
| UINT8 BadOenResponse[] = { | |
| 0x00, // CompletionCode | |
| 0xFF, 0xC2, 0x00, // Wrong OEN | |
| }; | |
| #define BAD_OEN_RESPONSE_SIZE 4 * sizeof(UINT8) | |
| UINT8 BadCrcResponse[] = { | |
| 0x00, // CompletionCode | |
| 0xCF, 0xC2, 0x00, // OpenBMC OEN | |
| 0x00, 0x00, // CRC | |
| 0x01, 0x00, 0x00, 0x00, // Data | |
| }; | |
| #define BAD_CRC_RESPONSE_SIZE 10 * sizeof(UINT8) | |
| UINT8 ValidNoDataResponse[] = { | |
| 0x00, // CompletionCode | |
| 0xCF, 0xC2, 0x00, // OpenBMC OEN | |
| }; | |
| #define VALID_NODATA_RESPONSE_SIZE 4 * sizeof(UINT8) | |
| /** | |
| @param[in] Context [Optional] An optional parameter that enables: | |
| 1) test-case reuse with varied parameters and | |
| 2) test-case re-entry for Target tests that need a | |
| reboot. This parameter is a VOID* and it is the | |
| responsibility of the test author to ensure that the | |
| contents are well understood by all test cases that may | |
| consume it. | |
| @retval UNIT_TEST_PASSED The Unit test has completed and the test | |
| case was successful. | |
| @retval UNIT_TEST_ERROR_TEST_FAILED A test case assertion has failed. | |
| **/ | |
| UNIT_TEST_STATUS | |
| EFIAPI | |
| GoodCrc ( | |
| IN UNIT_TEST_CONTEXT Context | |
| ) | |
| { | |
| UINT8 Data[5]; | |
| UINTN DataSize; | |
| UINT16 Crc; | |
| Data = { 0x12, 0x34, 0x56, 0x78, 0x90 }; | |
| DataSize = sizeof (Data); | |
| Crc = CalculateCrc16Ccitt (Data, DataSize); | |
| UT_ASSERT_EQUAL (Crc, 0xB928); | |
| return UNIT_TEST_PASSED; | |
| } | |
| /** | |
| @param[in] Context [Optional] An optional parameter that enables: | |
| 1) test-case reuse with varied parameters and | |
| 2) test-case re-entry for Target tests that need a | |
| reboot. This parameter is a VOID* and it is the | |
| responsibility of the test author to ensure that the | |
| contents are well understood by all test cases that may | |
| consume it. | |
| @retval UNIT_TEST_PASSED The Unit test has completed and the test | |
| case was successful. | |
| @retval UNIT_TEST_ERROR_TEST_FAILED A test case assertion has failed. | |
| **/ | |
| UNIT_TEST_STATUS | |
| EFIAPI | |
| BadCrc ( | |
| IN UNIT_TEST_CONTEXT Context | |
| ) | |
| { | |
| UINT8 Data[5]; | |
| UINTN DataSize; | |
| UINT16 Crc; | |
| Data = { 0x12, 0x34, 0x56, 0x78, 0x90 }; | |
| DataSize = sizeof (Data); | |
| Crc = CalculateCrc16Ccitt (Data, DataSize); | |
| UT_ASSERT_NOT_EQUAL (Crc, 0x3409); | |
| return UNIT_TEST_PASSED; | |
| } | |
| /** | |
| @param[in] Context [Optional] An optional parameter that enables: | |
| 1) test-case reuse with varied parameters and | |
| 2) test-case re-entry for Target tests that need a | |
| reboot. This parameter is a VOID* and it is the | |
| responsibility of the test author to ensure that the | |
| contents are well understood by all test cases that may | |
| consume it. | |
| @retval UNIT_TEST_PASSED The Unit test has completed and the test | |
| case was successful. | |
| @retval UNIT_TEST_ERROR_TEST_FAILED A test case assertion has failed. | |
| **/ | |
| UNIT_TEST_STATUS | |
| EFIAPI | |
| SendIpmiBadCompletion ( | |
| IN UNIT_TEST_CONTEXT Context | |
| ) | |
| { | |
| VOID *ResponseData; | |
| UINT32 *ResponseDataSize; | |
| EFI_STATUS Status; | |
| VOID *MockResponseResults; | |
| MockResponseResults = (UINT8 *)AllocateZeroPool (INVALID_COMPLETION_SIZE); | |
| ResponseDataSize = (UINT32 *)AllocateZeroPool (sizeof (UINT32)); | |
| CopyMem (MockResponseResults, &InvalidCompletion, INVALID_COMPLETION_SIZE); | |
| MockIpmiSubmitCommand ((UINT8 *)MockResponseResults, INVALID_COMPLETION_SIZE, EFI_SUCCESS); | |
| ResponseData = (UINT8 *)AllocateZeroPool (*ResponseDataSize); | |
| Status = IpmiBlobTransferSendIpmi (IpmiBlobTransferSubcommandGetCount, NULL, 0, ResponseData, ResponseDataSize); | |
| UT_ASSERT_STATUS_EQUAL (Status, EFI_PROTOCOL_ERROR); | |
| FreePool (MockResponseResults); | |
| FreePool (ResponseDataSize); | |
| FreePool (ResponseData); | |
| return UNIT_TEST_PASSED; | |
| } | |
| /** | |
| @param[in] Context [Optional] An optional parameter that enables: | |
| 1) test-case reuse with varied parameters and | |
| 2) test-case re-entry for Target tests that need a | |
| reboot. This parameter is a VOID* and it is the | |
| responsibility of the test author to ensure that the | |
| contents are well understood by all test cases that may | |
| consume it. | |
| @retval UNIT_TEST_PASSED The Unit test has completed and the test | |
| case was successful. | |
| @retval UNIT_TEST_ERROR_TEST_FAILED A test case assertion has failed. | |
| **/ | |
| UNIT_TEST_STATUS | |
| EFIAPI | |
| SendIpmiNoDataResponse ( | |
| IN UNIT_TEST_CONTEXT Context | |
| ) | |
| { | |
| VOID *ResponseData; | |
| UINT32 *ResponseDataSize; | |
| EFI_STATUS Status; | |
| VOID *MockResponseResults; | |
| MockResponseResults = (UINT8 *)AllocateZeroPool (NO_DATA_RESPONSE_SIZE); | |
| ResponseDataSize = (UINT32 *)AllocateZeroPool (sizeof (UINT32)); | |
| CopyMem (MockResponseResults, &NoDataResponse, NO_DATA_RESPONSE_SIZE); | |
| Status = MockIpmiSubmitCommand ((UINT8 *)MockResponseResults, NO_DATA_RESPONSE_SIZE, EFI_SUCCESS); | |
| if (EFI_ERROR (Status)) { | |
| return UNIT_TEST_ERROR_TEST_FAILED; | |
| } | |
| ResponseData = (UINT8 *)AllocateZeroPool (sizeof (NoDataResponse)); | |
| Status = IpmiBlobTransferSendIpmi (IpmiBlobTransferSubcommandGetCount, NULL, 0, ResponseData, ResponseDataSize); | |
| UT_ASSERT_STATUS_EQUAL (Status, EFI_SUCCESS); | |
| UT_ASSERT_EQUAL (*ResponseDataSize, 0); | |
| FreePool (MockResponseResults); | |
| FreePool (ResponseDataSize); | |
| FreePool (ResponseData); | |
| return UNIT_TEST_PASSED; | |
| } | |
| /** | |
| @param[in] Context [Optional] An optional parameter that enables: | |
| 1) test-case reuse with varied parameters and | |
| 2) test-case re-entry for Target tests that need a | |
| reboot. This parameter is a VOID* and it is the | |
| responsibility of the test author to ensure that the | |
| contents are well understood by all test cases that may | |
| consume it. | |
| @retval UNIT_TEST_PASSED The Unit test has completed and the test | |
| case was successful. | |
| @retval UNIT_TEST_ERROR_TEST_FAILED A test case assertion has failed. | |
| **/ | |
| UNIT_TEST_STATUS | |
| EFIAPI | |
| SendIpmiBadOenResponse ( | |
| IN UNIT_TEST_CONTEXT Context | |
| ) | |
| { | |
| VOID *ResponseData; | |
| UINT32 *ResponseDataSize; | |
| EFI_STATUS Status; | |
| VOID *MockResponseResults; | |
| MockResponseResults = (UINT8 *)AllocateZeroPool (BAD_OEN_RESPONSE_SIZE); | |
| ResponseDataSize = (UINT32 *)AllocateZeroPool (sizeof (UINT32)); | |
| CopyMem (MockResponseResults, &BadOenResponse, BAD_OEN_RESPONSE_SIZE); | |
| Status = MockIpmiSubmitCommand ((UINT8 *)MockResponseResults, BAD_OEN_RESPONSE_SIZE, EFI_SUCCESS); | |
| if (EFI_ERROR (Status)) { | |
| return UNIT_TEST_ERROR_TEST_FAILED; | |
| } | |
| ResponseData = (UINT8 *)AllocateZeroPool (sizeof (BadOenResponse)); | |
| Status = IpmiBlobTransferSendIpmi (IpmiBlobTransferSubcommandGetCount, NULL, 0, ResponseData, ResponseDataSize); | |
| UT_ASSERT_STATUS_EQUAL (Status, EFI_PROTOCOL_ERROR); | |
| FreePool (MockResponseResults); | |
| FreePool (ResponseDataSize); | |
| FreePool (ResponseData); | |
| return UNIT_TEST_PASSED; | |
| } | |
| /** | |
| @param[in] Context [Optional] An optional parameter that enables: | |
| 1) test-case reuse with varied parameters and | |
| 2) test-case re-entry for Target tests that need a | |
| reboot. This parameter is a VOID* and it is the | |
| responsibility of the test author to ensure that the | |
| contents are well understood by all test cases that may | |
| consume it. | |
| @retval UNIT_TEST_PASSED The Unit test has completed and the test | |
| case was successful. | |
| @retval UNIT_TEST_ERROR_TEST_FAILED A test case assertion has failed. | |
| **/ | |
| UNIT_TEST_STATUS | |
| EFIAPI | |
| SendIpmiBadCrcResponse ( | |
| IN UNIT_TEST_CONTEXT Context | |
| ) | |
| { | |
| VOID *ResponseData; | |
| UINT32 *ResponseDataSize; | |
| EFI_STATUS Status; | |
| VOID *MockResponseResults; | |
| MockResponseResults = (UINT8 *)AllocateZeroPool (sizeof (BAD_CRC_RESPONSE_SIZE)); | |
| ResponseDataSize = (UINT32 *)AllocateZeroPool (sizeof (UINT32)); | |
| CopyMem (MockResponseResults, &BadCrcResponse, BAD_CRC_RESPONSE_SIZE); | |
| Status = MockIpmiSubmitCommand ((UINT8 *)MockResponseResults, BAD_CRC_RESPONSE_SIZE, EFI_SUCCESS); | |
| if (EFI_ERROR (Status)) { | |
| return UNIT_TEST_ERROR_TEST_FAILED; | |
| } | |
| ResponseData = (UINT8 *)AllocateZeroPool (sizeof (BadCrcResponse)); | |
| Status = IpmiBlobTransferSendIpmi (IpmiBlobTransferSubcommandGetCount, NULL, 0, ResponseData, ResponseDataSize); | |
| UT_ASSERT_STATUS_EQUAL (Status, EFI_CRC_ERROR); | |
| FreePool (MockResponseResults); | |
| FreePool (ResponseDataSize); | |
| FreePool (ResponseData); | |
| return UNIT_TEST_PASSED; | |
| } | |
| UINT8 ValidGetCountResponse[] = { | |
| 0x00, // CompletionCode | |
| 0xCF, 0xC2, 0x00, // OpenBMC OEN | |
| 0xA4, 0x78, // CRC | |
| 0x01, 0x00, 0x00, 0x00, // Data | |
| }; | |
| #define VALID_GET_COUNT_RESPONSE_SIZE 10 * sizeof(UINT8) | |
| /** | |
| @param[in] Context [Optional] An optional parameter that enables: | |
| 1) test-case reuse with varied parameters and | |
| 2) test-case re-entry for Target tests that need a | |
| reboot. This parameter is a VOID* and it is the | |
| responsibility of the test author to ensure that the | |
| contents are well understood by all test cases that may | |
| consume it. | |
| @retval UNIT_TEST_PASSED The Unit test has completed and the test | |
| case was successful. | |
| @retval UNIT_TEST_ERROR_TEST_FAILED A test case assertion has failed. | |
| **/ | |
| UNIT_TEST_STATUS | |
| EFIAPI | |
| SendIpmiValidCountResponse ( | |
| IN UNIT_TEST_CONTEXT Context | |
| ) | |
| { | |
| UINT8 *ResponseData; | |
| UINT32 *ResponseDataSize; | |
| EFI_STATUS Status; | |
| VOID *MockResponseResults; | |
| MockResponseResults = (UINT8 *)AllocateZeroPool (sizeof (VALID_GET_COUNT_RESPONSE_SIZE)); | |
| ResponseDataSize = (UINT32 *)AllocateZeroPool (sizeof (UINT32)); | |
| CopyMem (MockResponseResults, &ValidGetCountResponse, VALID_GET_COUNT_RESPONSE_SIZE); | |
| Status = MockIpmiSubmitCommand ((UINT8 *)MockResponseResults, VALID_GET_COUNT_RESPONSE_SIZE, EFI_SUCCESS); | |
| if (EFI_ERROR (Status)) { | |
| return UNIT_TEST_ERROR_TEST_FAILED; | |
| } | |
| ResponseData = AllocateZeroPool (sizeof (ValidGetCountResponse)); | |
| Status = IpmiBlobTransferSendIpmi (IpmiBlobTransferSubcommandGetCount, NULL, 0, ResponseData, ResponseDataSize); | |
| UT_ASSERT_STATUS_EQUAL (Status, EFI_SUCCESS); | |
| FreePool (MockResponseResults); | |
| FreePool (ResponseDataSize); | |
| FreePool (ResponseData); | |
| return UNIT_TEST_PASSED; | |
| } | |
| /** | |
| @param[in] Context [Optional] An optional parameter that enables: | |
| 1) test-case reuse with varied parameters and | |
| 2) test-case re-entry for Target tests that need a | |
| reboot. This parameter is a VOID* and it is the | |
| responsibility of the test author to ensure that the | |
| contents are well understood by all test cases that may | |
| consume it. | |
| @retval UNIT_TEST_PASSED The Unit test has completed and the test | |
| case was successful. | |
| @retval UNIT_TEST_ERROR_TEST_FAILED A test case assertion has failed. | |
| **/ | |
| UNIT_TEST_STATUS | |
| EFIAPI | |
| GetCountValidCountResponse ( | |
| IN UNIT_TEST_CONTEXT Context | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| UINT32 Count; | |
| VOID *MockResponseResults; | |
| Count = 0; | |
| MockResponseResults = (UINT8 *)AllocateZeroPool (sizeof (VALID_GET_COUNT_RESPONSE_SIZE)); | |
| CopyMem (MockResponseResults, &ValidGetCountResponse, VALID_GET_COUNT_RESPONSE_SIZE); | |
| Status = MockIpmiSubmitCommand ((UINT8 *)MockResponseResults, VALID_GET_COUNT_RESPONSE_SIZE, EFI_SUCCESS); | |
| if (EFI_ERROR (Status)) { | |
| return UNIT_TEST_ERROR_TEST_FAILED; | |
| } | |
| Status = IpmiBlobTransferGetCount (&Count); | |
| UT_ASSERT_STATUS_EQUAL (Status, EFI_SUCCESS); | |
| UT_ASSERT_EQUAL (Count, 1); | |
| FreePool (MockResponseResults); | |
| return UNIT_TEST_PASSED; | |
| } | |
| UINT8 ValidEnumerateResponse[] = { | |
| 0x00, // CompletionCode | |
| 0xCF, 0xC2, 0x00, // OpenBMC OEN | |
| 0x81, 0x13, // CRC | |
| 0x2F, 0x73, 0x6D, 0x62, // Data = "/smbios" | |
| 0x69, 0x6F, 0x73, 0x00, | |
| }; | |
| #define VALID_ENUMERATE_RESPONSE_SIZE 14 * sizeof(UINT8) | |
| /** | |
| @param[in] Context [Optional] An optional parameter that enables: | |
| 1) test-case reuse with varied parameters and | |
| 2) test-case re-entry for Target tests that need a | |
| reboot. This parameter is a VOID* and it is the | |
| responsibility of the test author to ensure that the | |
| contents are well understood by all test cases that may | |
| consume it. | |
| @retval UNIT_TEST_PASSED The Unit test has completed and the test | |
| case was successful. | |
| @retval UNIT_TEST_ERROR_TEST_FAILED A test case assertion has failed. | |
| **/ | |
| UNIT_TEST_STATUS | |
| EFIAPI | |
| EnumerateValidResponse ( | |
| IN UNIT_TEST_CONTEXT Context | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| CHAR8 *BlobId; | |
| VOID *MockResponseResults; | |
| MockResponseResults = (UINT8 *)AllocateZeroPool (sizeof (VALID_ENUMERATE_RESPONSE_SIZE)); | |
| CopyMem (MockResponseResults, &ValidEnumerateResponse, VALID_ENUMERATE_RESPONSE_SIZE); | |
| Status = MockIpmiSubmitCommand ((UINT8 *)MockResponseResults, VALID_ENUMERATE_RESPONSE_SIZE, EFI_SUCCESS); | |
| if (EFI_ERROR (Status)) { | |
| return UNIT_TEST_ERROR_TEST_FAILED; | |
| } | |
| BlobId = AllocateZeroPool (sizeof (CHAR8) * BLOB_MAX_DATA_PER_PACKET); | |
| Status = IpmiBlobTransferEnumerate (0, BlobId); | |
| UT_ASSERT_STATUS_EQUAL (Status, EFI_SUCCESS); | |
| UT_ASSERT_MEM_EQUAL (BlobId, "/smbios", 7); | |
| FreePool (MockResponseResults); | |
| FreePool (BlobId); | |
| return UNIT_TEST_PASSED; | |
| } | |
| /** | |
| @param[in] Context [Optional] An optional parameter that enables: | |
| 1) test-case reuse with varied parameters and | |
| 2) test-case re-entry for Target tests that need a | |
| reboot. This parameter is a VOID* and it is the | |
| responsibility of the test author to ensure that the | |
| contents are well understood by all test cases that may | |
| consume it. | |
| @retval UNIT_TEST_PASSED The Unit test has completed and the test | |
| case was successful. | |
| @retval UNIT_TEST_ERROR_TEST_FAILED A test case assertion has failed. | |
| **/ | |
| UNIT_TEST_STATUS | |
| EFIAPI | |
| EnumerateInvalidBuffer ( | |
| IN UNIT_TEST_CONTEXT Context | |
| ) | |
| { | |
| CHAR8 *BlobId; | |
| EFI_STATUS Status; | |
| VOID *MockResponseResults; | |
| MockResponseResults = (UINT8 *)AllocateZeroPool (sizeof (VALID_ENUMERATE_RESPONSE_SIZE)); | |
| CopyMem (MockResponseResults, &ValidEnumerateResponse, VALID_ENUMERATE_RESPONSE_SIZE); | |
| Status = MockIpmiSubmitCommand ((UINT8 *)MockResponseResults, VALID_ENUMERATE_RESPONSE_SIZE, EFI_SUCCESS); | |
| if (EFI_ERROR (Status)) { | |
| return UNIT_TEST_ERROR_TEST_FAILED; | |
| } | |
| BlobId = NULL; | |
| UT_EXPECT_ASSERT_FAILURE (IpmiBlobTransferEnumerate (0, BlobId), NULL); | |
| FreePool (MockResponseResults); | |
| return UNIT_TEST_PASSED; | |
| } | |
| UINT8 ValidOpenResponse[] = { | |
| 0x00, // CompletionCode | |
| 0xCF, 0xC2, 0x00, // OpenBMC OEN | |
| 0x93, 0xD1, // CRC | |
| 0x03, 0x00, // SessionId = 3 | |
| }; | |
| #define VALID_OPEN_RESPONSE_SIZE 8 * sizeof(UINT8) | |
| /** | |
| @param[in] Context [Optional] An optional parameter that enables: | |
| 1) test-case reuse with varied parameters and | |
| 2) test-case re-entry for Target tests that need a | |
| reboot. This parameter is a VOID* and it is the | |
| responsibility of the test author to ensure that the | |
| contents are well understood by all test cases that may | |
| consume it. | |
| @retval UNIT_TEST_PASSED The Unit test has completed and the test | |
| case was successful. | |
| @retval UNIT_TEST_ERROR_TEST_FAILED A test case assertion has failed. | |
| **/ | |
| UNIT_TEST_STATUS | |
| EFIAPI | |
| OpenValidResponse ( | |
| IN UNIT_TEST_CONTEXT Context | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| CHAR8 *BlobId; | |
| UINT16 Flags; | |
| UINT16 SessionId; | |
| VOID *MockResponseResults; | |
| VOID *MockResponseResults2; | |
| VOID *MockResponseResults3; | |
| MockResponseResults = NULL; | |
| MockResponseResults2 = NULL; | |
| MockResponseResults3 = NULL; | |
| Flags = BLOB_TRANSFER_STAT_OPEN_W; | |
| // | |
| // An open call effectively leads to three IPMI commands | |
| // 1. GetCount of blobs | |
| // 2. Enumerate the requested blob | |
| // 3. Open the requested blob | |
| // | |
| // So we'll push three Ipmi responses in this case | |
| // | |
| MockResponseResults = (UINT8 *)AllocateZeroPool (sizeof (VALID_OPEN_RESPONSE_SIZE)); | |
| CopyMem (MockResponseResults, &ValidOpenResponse, VALID_OPEN_RESPONSE_SIZE); | |
| Status = MockIpmiSubmitCommand ((UINT8 *)MockResponseResults, VALID_OPEN_RESPONSE_SIZE, EFI_SUCCESS); | |
| if (EFI_ERROR (Status)) { | |
| return UNIT_TEST_ERROR_TEST_FAILED; | |
| } | |
| MockResponseResults2 = (UINT8 *)AllocateZeroPool (sizeof (VALID_ENUMERATE_RESPONSE_SIZE)); | |
| CopyMem (MockResponseResults2, &ValidEnumerateResponse, VALID_ENUMERATE_RESPONSE_SIZE); | |
| Status = MockIpmiSubmitCommand ((UINT8 *)MockResponseResults2, VALID_ENUMERATE_RESPONSE_SIZE, EFI_SUCCESS); | |
| if (EFI_ERROR (Status)) { | |
| return UNIT_TEST_ERROR_TEST_FAILED; | |
| } | |
| MockResponseResults3 = (UINT8 *)AllocateZeroPool (sizeof (VALID_GET_COUNT_RESPONSE_SIZE)); | |
| CopyMem (MockResponseResults3, &ValidGetCountResponse, VALID_GET_COUNT_RESPONSE_SIZE); | |
| Status = MockIpmiSubmitCommand ((UINT8 *)MockResponseResults3, VALID_GET_COUNT_RESPONSE_SIZE, EFI_SUCCESS); | |
| if (EFI_ERROR (Status)) { | |
| return UNIT_TEST_ERROR_TEST_FAILED; | |
| } | |
| BlobId = "/smbios"; | |
| Status = IpmiBlobTransferOpen (BlobId, Flags, &SessionId); | |
| UT_ASSERT_STATUS_EQUAL (Status, EFI_SUCCESS); | |
| UT_ASSERT_EQUAL (SessionId, 3); | |
| FreePool (MockResponseResults); | |
| return UNIT_TEST_PASSED; | |
| } | |
| UINT8 ValidReadResponse[] = { | |
| 0x00, // CompletionCode | |
| 0xCF, 0xC2, 0x00, // OpenBMC OEN | |
| 0x21, 0x6F, // CRC | |
| 0x00, 0x01, 0x02, 0x03, // Data to read | |
| }; | |
| #define VALID_READ_RESPONSE_SIZE 10 * sizeof(UINT8) | |
| /** | |
| @param[in] Context [Optional] An optional parameter that enables: | |
| 1) test-case reuse with varied parameters and | |
| 2) test-case re-entry for Target tests that need a | |
| reboot. This parameter is a VOID* and it is the | |
| responsibility of the test author to ensure that the | |
| contents are well understood by all test cases that may | |
| consume it. | |
| @retval UNIT_TEST_PASSED The Unit test has completed and the test | |
| case was successful. | |
| @retval UNIT_TEST_ERROR_TEST_FAILED A test case assertion has failed. | |
| **/ | |
| UNIT_TEST_STATUS | |
| EFIAPI | |
| ReadValidResponse ( | |
| IN UNIT_TEST_CONTEXT Context | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| UINT8 *ResponseData; | |
| UINT8 ExpectedDataResponse[4]; | |
| VOID *MockResponseResults; | |
| ExpectedDataResponse = { 0x00, 0x01, 0x02, 0x03 }; | |
| MockResponseResults = (UINT8 *)AllocateZeroPool (sizeof (VALID_READ_RESPONSE_SIZE)); | |
| CopyMem (MockResponseResults, &ValidReadResponse, VALID_READ_RESPONSE_SIZE); | |
| ResponseData = AllocateZeroPool (sizeof (ValidReadResponse)); | |
| Status = MockIpmiSubmitCommand ((UINT8 *)MockResponseResults, VALID_READ_RESPONSE_SIZE, EFI_SUCCESS); | |
| if (EFI_ERROR (Status)) { | |
| return UNIT_TEST_ERROR_TEST_FAILED; | |
| } | |
| Status = IpmiBlobTransferRead (0, 0, 4, ResponseData); | |
| UT_ASSERT_STATUS_EQUAL (Status, EFI_SUCCESS); | |
| UT_ASSERT_MEM_EQUAL (ResponseData, ExpectedDataResponse, 4); | |
| FreePool (MockResponseResults); | |
| FreePool (ResponseData); | |
| return UNIT_TEST_PASSED; | |
| } | |
| /** | |
| @param[in] Context [Optional] An optional parameter that enables: | |
| 1) test-case reuse with varied parameters and | |
| 2) test-case re-entry for Target tests that need a | |
| reboot. This parameter is a VOID* and it is the | |
| responsibility of the test author to ensure that the | |
| contents are well understood by all test cases that may | |
| consume it. | |
| @retval UNIT_TEST_PASSED The Unit test has completed and the test | |
| case was successful. | |
| @retval UNIT_TEST_ERROR_TEST_FAILED A test case assertion has failed. | |
| **/ | |
| UNIT_TEST_STATUS | |
| EFIAPI | |
| ReadInvalidBuffer ( | |
| IN UNIT_TEST_CONTEXT Context | |
| ) | |
| { | |
| UINT8 *ResponseData; | |
| EFI_STATUS Status; | |
| VOID *MockResponseResults; | |
| MockResponseResults = (UINT8 *)AllocateZeroPool (sizeof (VALID_READ_RESPONSE_SIZE)); | |
| CopyMem (MockResponseResults, &ValidReadResponse, VALID_READ_RESPONSE_SIZE); | |
| ResponseData = NULL; | |
| Status = MockIpmiSubmitCommand ((UINT8 *)MockResponseResults, VALID_READ_RESPONSE_SIZE, EFI_SUCCESS); | |
| if (EFI_ERROR (Status)) { | |
| return UNIT_TEST_ERROR_TEST_FAILED; | |
| } | |
| UT_EXPECT_ASSERT_FAILURE (IpmiBlobTransferRead (0, 0, 4, ResponseData), NULL); | |
| FreePool (MockResponseResults); | |
| return UNIT_TEST_PASSED; | |
| } | |
| /** | |
| @param[in] Context [Optional] An optional parameter that enables: | |
| 1) test-case reuse with varied parameters and | |
| 2) test-case re-entry for Target tests that need a | |
| reboot. This parameter is a VOID* and it is the | |
| responsibility of the test author to ensure that the | |
| contents are well understood by all test cases that may | |
| consume it. | |
| @retval UNIT_TEST_PASSED The Unit test has completed and the test | |
| case was successful. | |
| @retval UNIT_TEST_ERROR_TEST_FAILED A test case assertion has failed. | |
| **/ | |
| UNIT_TEST_STATUS | |
| EFIAPI | |
| WriteValidResponse ( | |
| IN UNIT_TEST_CONTEXT Context | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| UINT8 SendData[4]; | |
| VOID *MockResponseResults; | |
| SendData = { 0x00, 0x01, 0x02, 0x03 }; | |
| MockResponseResults = (UINT8 *)AllocateZeroPool (sizeof (VALID_NODATA_RESPONSE_SIZE)); | |
| CopyMem (MockResponseResults, &ValidNoDataResponse, VALID_NODATA_RESPONSE_SIZE); | |
| Status = MockIpmiSubmitCommand ((UINT8 *)MockResponseResults, VALID_NODATA_RESPONSE_SIZE, EFI_SUCCESS); | |
| if (EFI_ERROR (Status)) { | |
| return UNIT_TEST_ERROR_TEST_FAILED; | |
| } | |
| Status = IpmiBlobTransferWrite (0, 0, SendData, 4); | |
| UT_ASSERT_STATUS_EQUAL (Status, EFI_SUCCESS); | |
| FreePool (MockResponseResults); | |
| return UNIT_TEST_PASSED; | |
| } | |
| /** | |
| @param[in] Context [Optional] An optional parameter that enables: | |
| 1) test-case reuse with varied parameters and | |
| 2) test-case re-entry for Target tests that need a | |
| reboot. This parameter is a VOID* and it is the | |
| responsibility of the test author to ensure that the | |
| contents are well understood by all test cases that may | |
| consume it. | |
| @retval UNIT_TEST_PASSED The Unit test has completed and the test | |
| case was successful. | |
| @retval UNIT_TEST_ERROR_TEST_FAILED A test case assertion has failed. | |
| **/ | |
| UNIT_TEST_STATUS | |
| EFIAPI | |
| CommitValidResponse ( | |
| IN UNIT_TEST_CONTEXT Context | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| UINT8 SendData[4]; | |
| VOID *MockResponseResults; | |
| SendData = { 0x00, 0x01, 0x02, 0x03 }; | |
| MockResponseResults = (UINT8 *)AllocateZeroPool (sizeof (VALID_NODATA_RESPONSE_SIZE)); | |
| CopyMem (MockResponseResults, &ValidNoDataResponse, VALID_NODATA_RESPONSE_SIZE); | |
| Status = MockIpmiSubmitCommand ((UINT8 *)MockResponseResults, VALID_NODATA_RESPONSE_SIZE, EFI_SUCCESS); | |
| if (EFI_ERROR (Status)) { | |
| return UNIT_TEST_ERROR_TEST_FAILED; | |
| } | |
| Status = IpmiBlobTransferCommit (0, 4, SendData); | |
| UT_ASSERT_STATUS_EQUAL (Status, EFI_SUCCESS); | |
| FreePool (MockResponseResults); | |
| return UNIT_TEST_PASSED; | |
| } | |
| /** | |
| @param[in] Context [Optional] An optional parameter that enables: | |
| 1) test-case reuse with varied parameters and | |
| 2) test-case re-entry for Target tests that need a | |
| reboot. This parameter is a VOID* and it is the | |
| responsibility of the test author to ensure that the | |
| contents are well understood by all test cases that may | |
| consume it. | |
| @retval UNIT_TEST_PASSED The Unit test has completed and the test | |
| case was successful. | |
| @retval UNIT_TEST_ERROR_TEST_FAILED A test case assertion has failed. | |
| **/ | |
| UNIT_TEST_STATUS | |
| EFIAPI | |
| CloseValidResponse ( | |
| IN UNIT_TEST_CONTEXT Context | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| VOID *MockResponseResults; | |
| MockResponseResults = (UINT8 *)AllocateZeroPool (sizeof (VALID_NODATA_RESPONSE_SIZE)); | |
| CopyMem (MockResponseResults, &ValidNoDataResponse, VALID_NODATA_RESPONSE_SIZE); | |
| Status = MockIpmiSubmitCommand ((UINT8 *)MockResponseResults, VALID_NODATA_RESPONSE_SIZE, EFI_SUCCESS); | |
| if (EFI_ERROR (Status)) { | |
| return UNIT_TEST_ERROR_TEST_FAILED; | |
| } | |
| Status = IpmiBlobTransferClose (1); | |
| UT_ASSERT_STATUS_EQUAL (Status, EFI_SUCCESS); | |
| FreePool (MockResponseResults); | |
| return UNIT_TEST_PASSED; | |
| } | |
| /** | |
| @param[in] Context [Optional] An optional parameter that enables: | |
| 1) test-case reuse with varied parameters and | |
| 2) test-case re-entry for Target tests that need a | |
| reboot. This parameter is a VOID* and it is the | |
| responsibility of the test author to ensure that the | |
| contents are well understood by all test cases that may | |
| consume it. | |
| @retval UNIT_TEST_PASSED The Unit test has completed and the test | |
| case was successful. | |
| @retval UNIT_TEST_ERROR_TEST_FAILED A test case assertion has failed. | |
| **/ | |
| UNIT_TEST_STATUS | |
| EFIAPI | |
| DeleteValidResponse ( | |
| IN UNIT_TEST_CONTEXT Context | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| VOID *MockResponseResults; | |
| MockResponseResults = (UINT8 *)AllocateZeroPool (sizeof (VALID_NODATA_RESPONSE_SIZE)); | |
| CopyMem (MockResponseResults, &ValidNoDataResponse, VALID_NODATA_RESPONSE_SIZE); | |
| Status = MockIpmiSubmitCommand ((UINT8 *)MockResponseResults, VALID_NODATA_RESPONSE_SIZE, EFI_SUCCESS); | |
| if (EFI_ERROR (Status)) { | |
| return UNIT_TEST_ERROR_TEST_FAILED; | |
| } | |
| Status = IpmiBlobTransferDelete ("/smbios"); | |
| UT_ASSERT_STATUS_EQUAL (Status, EFI_SUCCESS); | |
| FreePool (MockResponseResults); | |
| return UNIT_TEST_PASSED; | |
| } | |
| UINT8 ValidBlobStatResponse[] = { | |
| 0x00, // CompletionCode | |
| 0xCF, 0xC2, 0x00, // OpenBMC OEN | |
| 0x1F, 0x4F, // Crc | |
| 0x01, 0x00, // BlobState | |
| 0x02, 0x03, 0x04, 0x05, // BlobSize | |
| 0x04, // MetaDataLen | |
| 0x06, 0x07, 0x08, 0x09, // MetaData | |
| }; | |
| #define VALID_BLOB_STAT_RESPONSE_SIZE 17 * sizeof(UINT8) | |
| /** | |
| @param[in] Context [Optional] An optional parameter that enables: | |
| 1) test-case reuse with varied parameters and | |
| 2) test-case re-entry for Target tests that need a | |
| reboot. This parameter is a VOID* and it is the | |
| responsibility of the test author to ensure that the | |
| contents are well understood by all test cases that may | |
| consume it. | |
| @retval UNIT_TEST_PASSED The Unit test has completed and the test | |
| case was successful. | |
| @retval UNIT_TEST_ERROR_TEST_FAILED A test case assertion has failed. | |
| **/ | |
| UNIT_TEST_STATUS | |
| EFIAPI | |
| BlobStatValidResponse ( | |
| IN UNIT_TEST_CONTEXT Context | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| UINT16 *BlobState; | |
| UINT32 *Size; | |
| UINT8 *MetadataLength; | |
| UINT8 *Metadata; | |
| UINT8 *ExpectedMetadata; | |
| CHAR8 *BlobId; | |
| VOID *MockResponseResults; | |
| BlobState = AllocateZeroPool (sizeof (UINT16)); | |
| Size = AllocateZeroPool (sizeof (UINT32)); | |
| BlobId = "BlobId"; | |
| MetadataLength = AllocateZeroPool (sizeof (UINT8)); | |
| Metadata = AllocateZeroPool (4 * sizeof (UINT8)); | |
| ExpectedMetadata = AllocateZeroPool (4 * sizeof (UINT8)); | |
| MockResponseResults = (UINT8 *)AllocateZeroPool (sizeof (VALID_BLOB_STAT_RESPONSE_SIZE)); | |
| CopyMem (MockResponseResults, &ValidBlobStatResponse, VALID_BLOB_STAT_RESPONSE_SIZE); | |
| Status = MockIpmiSubmitCommand ((UINT8 *)MockResponseResults, VALID_BLOB_STAT_RESPONSE_SIZE, EFI_SUCCESS); | |
| if (EFI_ERROR (Status)) { | |
| return UNIT_TEST_ERROR_TEST_FAILED; | |
| } | |
| Status = IpmiBlobTransferStat (BlobId, BlobState, Size, MetadataLength, Metadata); | |
| UT_ASSERT_STATUS_EQUAL (Status, EFI_SUCCESS); | |
| UT_ASSERT_EQUAL (*BlobState, 1); | |
| UT_ASSERT_EQUAL (*Size, 0x05040302); | |
| UT_ASSERT_EQUAL (*MetadataLength, 4); | |
| UT_ASSERT_MEM_EQUAL (Metadata, ExpectedMetadata, 4); | |
| FreePool (MockResponseResults); | |
| FreePool (BlobState); | |
| FreePool (Size); | |
| FreePool (MetadataLength); | |
| FreePool (Metadata); | |
| return UNIT_TEST_PASSED; | |
| } | |
| /** | |
| @param[in] Context [Optional] An optional parameter that enables: | |
| 1) test-case reuse with varied parameters and | |
| 2) test-case re-entry for Target tests that need a | |
| reboot. This parameter is a VOID* and it is the | |
| responsibility of the test author to ensure that the | |
| contents are well understood by all test cases that may | |
| consume it. | |
| @retval UNIT_TEST_PASSED The Unit test has completed and the test | |
| case was successful. | |
| @retval UNIT_TEST_ERROR_TEST_FAILED A test case assertion has failed. | |
| **/ | |
| UNIT_TEST_STATUS | |
| EFIAPI | |
| BlobStatInvalidBuffer ( | |
| IN UNIT_TEST_CONTEXT Context | |
| ) | |
| { | |
| UINT8 *Metadata; | |
| EFI_STATUS Status; | |
| VOID *MockResponseResults; | |
| Metadata = NULL; | |
| MockResponseResults = (UINT8 *)AllocateZeroPool (sizeof (VALID_BLOB_STAT_RESPONSE_SIZE)); | |
| CopyMem (MockResponseResults, &ValidBlobStatResponse, VALID_BLOB_STAT_RESPONSE_SIZE); | |
| Status = MockIpmiSubmitCommand ((UINT8 *)MockResponseResults, VALID_BLOB_STAT_RESPONSE_SIZE, EFI_SUCCESS); | |
| if (EFI_ERROR (Status)) { | |
| return UNIT_TEST_ERROR_TEST_FAILED; | |
| } | |
| UT_EXPECT_ASSERT_FAILURE (IpmiBlobTransferStat (NULL, 0, 0, 0, Metadata), NULL); | |
| FreePool (MockResponseResults); | |
| return UNIT_TEST_PASSED; | |
| } | |
| /** | |
| @param[in] Context [Optional] An optional parameter that enables: | |
| 1) test-case reuse with varied parameters and | |
| 2) test-case re-entry for Target tests that need a | |
| reboot. This parameter is a VOID* and it is the | |
| responsibility of the test author to ensure that the | |
| contents are well understood by all test cases that may | |
| consume it. | |
| @retval UNIT_TEST_PASSED The Unit test has completed and the test | |
| case was successful. | |
| @retval UNIT_TEST_ERROR_TEST_FAILED A test case assertion has failed. | |
| **/ | |
| UNIT_TEST_STATUS | |
| EFIAPI | |
| SessionStatValidResponse ( | |
| IN UNIT_TEST_CONTEXT Context | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| UINT16 *BlobState; | |
| UINT32 *Size; | |
| UINT8 *MetadataLength; | |
| UINT8 *Metadata; | |
| UINT8 *ExpectedMetadata; | |
| VOID *MockResponseResults; | |
| BlobState = AllocateZeroPool (sizeof (UINT16)); | |
| Size = AllocateZeroPool (sizeof (UINT32)); | |
| MetadataLength = AllocateZeroPool (sizeof (UINT8)); | |
| Metadata = AllocateZeroPool (4 * sizeof (UINT8)); | |
| ExpectedMetadata = AllocateZeroPool (4 * sizeof (UINT8)); | |
| MockResponseResults = (UINT8 *)AllocateZeroPool (sizeof (VALID_BLOB_STAT_RESPONSE_SIZE)); | |
| CopyMem (MockResponseResults, &ValidBlobStatResponse, VALID_BLOB_STAT_RESPONSE_SIZE); | |
| Status = MockIpmiSubmitCommand ((UINT8 *)MockResponseResults, VALID_BLOB_STAT_RESPONSE_SIZE, EFI_SUCCESS); | |
| if (EFI_ERROR (Status)) { | |
| return UNIT_TEST_ERROR_TEST_FAILED; | |
| } | |
| Status = IpmiBlobTransferSessionStat (0, BlobState, Size, MetadataLength, Metadata); | |
| UT_ASSERT_STATUS_EQUAL (Status, EFI_SUCCESS); | |
| UT_ASSERT_EQUAL (*BlobState, 1); | |
| UT_ASSERT_EQUAL (*Size, 0x05040302); | |
| UT_ASSERT_EQUAL (*MetadataLength, 4); | |
| UT_ASSERT_MEM_EQUAL (Metadata, ExpectedMetadata, 4); | |
| FreePool (MockResponseResults); | |
| FreePool (BlobState); | |
| FreePool (Size); | |
| FreePool (MetadataLength); | |
| FreePool (Metadata); | |
| return UNIT_TEST_PASSED; | |
| } | |
| /** | |
| @param[in] Context [Optional] An optional parameter that enables: | |
| 1) test-case reuse with varied parameters and | |
| 2) test-case re-entry for Target tests that need a | |
| reboot. This parameter is a VOID* and it is the | |
| responsibility of the test author to ensure that the | |
| contents are well understood by all test cases that may | |
| consume it. | |
| @retval UNIT_TEST_PASSED The Unit test has completed and the test | |
| case was successful. | |
| @retval UNIT_TEST_ERROR_TEST_FAILED A test case assertion has failed. | |
| **/ | |
| UNIT_TEST_STATUS | |
| EFIAPI | |
| SessionStatInvalidBuffer ( | |
| IN UNIT_TEST_CONTEXT Context | |
| ) | |
| { | |
| UINT8 *Metadata; | |
| EFI_STATUS Status; | |
| VOID *MockResponseResults; | |
| Metadata = NULL; | |
| MockResponseResults = (UINT8 *)AllocateZeroPool (sizeof (VALID_BLOB_STAT_RESPONSE_SIZE)); | |
| CopyMem (MockResponseResults, &ValidBlobStatResponse, VALID_BLOB_STAT_RESPONSE_SIZE); | |
| Status = MockIpmiSubmitCommand ((UINT8 *)MockResponseResults, VALID_BLOB_STAT_RESPONSE_SIZE, EFI_SUCCESS); | |
| if (EFI_ERROR (Status)) { | |
| return UNIT_TEST_ERROR_TEST_FAILED; | |
| } | |
| UT_EXPECT_ASSERT_FAILURE (IpmiBlobTransferSessionStat (0, 0, 0, 0, Metadata), NULL); | |
| FreePool (MockResponseResults); | |
| return UNIT_TEST_PASSED; | |
| } | |
| /** | |
| @param[in] Context [Optional] An optional parameter that enables: | |
| 1) test-case reuse with varied parameters and | |
| 2) test-case re-entry for Target tests that need a | |
| reboot. This parameter is a VOID* and it is the | |
| responsibility of the test author to ensure that the | |
| contents are well understood by all test cases that may | |
| consume it. | |
| @retval UNIT_TEST_PASSED The Unit test has completed and the test | |
| case was successful. | |
| @retval UNIT_TEST_ERROR_TEST_FAILED A test case assertion has failed. | |
| **/ | |
| UNIT_TEST_STATUS | |
| EFIAPI | |
| WriteMetaValidResponse ( | |
| IN UNIT_TEST_CONTEXT Context | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| VOID *MockResponseResults; | |
| MockResponseResults = (UINT8 *)AllocateZeroPool (sizeof (VALID_NODATA_RESPONSE_SIZE)); | |
| CopyMem (MockResponseResults, &ValidNoDataResponse, VALID_NODATA_RESPONSE_SIZE); | |
| Status = MockIpmiSubmitCommand ((UINT8 *)MockResponseResults, VALID_NODATA_RESPONSE_SIZE, EFI_SUCCESS); | |
| if (EFI_ERROR (Status)) { | |
| return UNIT_TEST_ERROR_TEST_FAILED; | |
| } | |
| Status = IpmiBlobTransferWriteMeta (0, 0, NULL, 0); | |
| UT_ASSERT_STATUS_EQUAL (Status, EFI_SUCCESS); | |
| FreePool (MockResponseResults); | |
| return UNIT_TEST_PASSED; | |
| } | |
| /** | |
| Initialize the unit test framework, suite, and unit tests for the | |
| sample unit tests and run the unit tests. | |
| @retval EFI_SUCCESS All test cases were dispatched. | |
| @retval EFI_OUT_OF_RESOURCES There are not enough resources available to | |
| initialize the unit tests. | |
| **/ | |
| EFI_STATUS | |
| EFIAPI | |
| SetupAndRunUnitTests ( | |
| VOID | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| UNIT_TEST_FRAMEWORK_HANDLE Framework; | |
| UNIT_TEST_SUITE_HANDLE IpmiBlobTransfer; | |
| Framework = NULL; | |
| DEBUG ((DEBUG_INFO, "%a: v%a\n", UNIT_TEST_NAME, UNIT_TEST_VERSION)); | |
| Status = InitUnitTestFramework (&Framework, UNIT_TEST_NAME, gEfiCallerBaseName, UNIT_TEST_VERSION); | |
| if (EFI_ERROR (Status)) { | |
| DEBUG ((DEBUG_ERROR, "Failed to setup Test Framework. Exiting with status = %r\n", Status)); | |
| ASSERT (FALSE); | |
| return Status; | |
| } | |
| // | |
| // Populate the Unit Test Suite. | |
| // | |
| Status = CreateUnitTestSuite (&IpmiBlobTransfer, Framework, "IPMI Blob Transfer Tests", "UnitTest.IpmiBlobTransferCB", NULL, NULL); | |
| if (EFI_ERROR (Status)) { | |
| DEBUG ((DEBUG_ERROR, "Failed in CreateUnitTestSuite for IPMI Blob Transfer Tests\n")); | |
| Status = EFI_OUT_OF_RESOURCES; | |
| return Status; | |
| } | |
| // CalculateCrc16Ccitt | |
| Status = AddTestCase (IpmiBlobTransfer, "Test CRC Calculation", "GoodCrc", GoodCrc, NULL, NULL, NULL); | |
| Status = AddTestCase (IpmiBlobTransfer, "Test Bad CRC Calculation", "BadCrc", BadCrc, NULL, NULL, NULL); | |
| // IpmiBlobTransferSendIpmi | |
| Status = AddTestCase (IpmiBlobTransfer, "Send IPMI returns bad completion", "SendIpmiBadCompletion", SendIpmiBadCompletion, NULL, NULL, NULL); | |
| Status = AddTestCase (IpmiBlobTransfer, "Send IPMI returns successfully with no data", "SendIpmiNoDataResponse", SendIpmiNoDataResponse, NULL, NULL, NULL); | |
| Status = AddTestCase (IpmiBlobTransfer, "Send IPMI returns successfully with bad OEN", "SendIpmiBadOenResponse", SendIpmiBadOenResponse, NULL, NULL, NULL); | |
| Status = AddTestCase (IpmiBlobTransfer, "Send IPMI returns successfully with bad CRC", "SendIpmiBadCrcResponse", SendIpmiBadCrcResponse, NULL, NULL, NULL); | |
| Status = AddTestCase (IpmiBlobTransfer, "Send IPMI returns with valid GetCount data", "SendIpmiValidCountResponse", SendIpmiValidCountResponse, NULL, NULL, NULL); | |
| // IpmiBlobTransferGetCount | |
| Status = AddTestCase (IpmiBlobTransfer, "GetCount call with valid data", "GetCountValidCountResponse", GetCountValidCountResponse, NULL, NULL, NULL); | |
| // IpmiBlobTransferEnumerate | |
| Status = AddTestCase (IpmiBlobTransfer, "Enumerate call with valid data", "EnumerateValidResponse", EnumerateValidResponse, NULL, NULL, NULL); | |
| Status = AddTestCase (IpmiBlobTransfer, "Enumerate call with invalid output buffer", "EnumerateInvalidBuffer", EnumerateInvalidBuffer, NULL, NULL, NULL); | |
| // IpmiBlobTransferOpen | |
| Status = AddTestCase (IpmiBlobTransfer, "Open call with valid data", "OpenValidResponse", OpenValidResponse, NULL, NULL, NULL); | |
| // IpmiBlobTransferRead | |
| Status = AddTestCase (IpmiBlobTransfer, "Read call with valid data", "ReadValidResponse", ReadValidResponse, NULL, NULL, NULL); | |
| Status = AddTestCase (IpmiBlobTransfer, "Read call with invalid buffer", "ReadInvalidBuffer", ReadInvalidBuffer, NULL, NULL, NULL); | |
| // IpmiBlobTransferWrite | |
| Status = AddTestCase (IpmiBlobTransfer, "Write call with valid data", "WriteValidResponse", WriteValidResponse, NULL, NULL, NULL); | |
| // IpmiBlobTransferCommit | |
| Status = AddTestCase (IpmiBlobTransfer, "Commit call with valid data", "CommitValidResponse", CommitValidResponse, NULL, NULL, NULL); | |
| // IpmiBlobTransferClose | |
| Status = AddTestCase (IpmiBlobTransfer, "Close call with valid data", "CloseValidResponse", CloseValidResponse, NULL, NULL, NULL); | |
| // IpmiBlobTransferDelete | |
| Status = AddTestCase (IpmiBlobTransfer, "Delete call with valid data", "DeleteValidResponse", DeleteValidResponse, NULL, NULL, NULL); | |
| // IpmiBlobTransferStat | |
| Status = AddTestCase (IpmiBlobTransfer, "Blob Stat call with valid data", "BlobStatValidResponse", BlobStatValidResponse, NULL, NULL, NULL); | |
| Status = AddTestCase (IpmiBlobTransfer, "Blob Stat call with invalid buffer", "BlobStatInvalidBuffer", BlobStatInvalidBuffer, NULL, NULL, NULL); | |
| // IpmiBlobTransferSessionStat | |
| Status = AddTestCase (IpmiBlobTransfer, "Session Stat call with valid data", "SessionStatValidResponse", SessionStatValidResponse, NULL, NULL, NULL); | |
| Status = AddTestCase (IpmiBlobTransfer, "Session Stat call with invalid buffer", "SessionStatInvalidBuffer", SessionStatInvalidBuffer, NULL, NULL, NULL); | |
| // IpmiBlobTransferWriteMeta | |
| Status = AddTestCase (IpmiBlobTransfer, "WriteMeta call with valid data", "WriteMetaValidResponse", WriteMetaValidResponse, NULL, NULL, NULL); | |
| // Execute the tests. | |
| Status = RunAllTestSuites (Framework); | |
| return Status; | |
| } | |
| /** | |
| Standard UEFI entry point for target based | |
| unit test execution from UEFI Shell. | |
| @param ImageHandle The firmware allocated handle for the UEFI image. | |
| @param SystemTable A pointer to the EFI System Table. | |
| @retval EFI_SUCCESS The operation completed successfully. | |
| @retval Others An unexpected error occurred. | |
| **/ | |
| EFI_STATUS | |
| EFIAPI | |
| BaseLibUnitTestAppEntry ( | |
| IN EFI_HANDLE ImageHandle, | |
| IN EFI_SYSTEM_TABLE *SystemTable | |
| ) | |
| { | |
| return SetupAndRunUnitTests (); | |
| } | |
| /** | |
| Standard POSIX C entry point for host based unit test execution. | |
| @param[in] argc Number of argument. | |
| @param[in] argv Arguments. | |
| **/ | |
| int | |
| main ( | |
| int argc, | |
| char *argv[] | |
| ) | |
| { | |
| return SetupAndRunUnitTests (); | |
| } |