From 066c0e8f0bddef60a5b5c47c7e3d443c3fccd5fe Mon Sep 17 00:00:00 2001 From: guishenking Date: Wed, 26 Nov 2025 22:56:39 +0800 Subject: [PATCH] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E4=B8=BA=E5=AE=8F=E5=AE=9A?= =?UTF-8?q?=E4=B9=89=EF=BC=8C=E6=B5=8B=E8=AF=95=E7=94=A8=E4=BE=8B=E9=80=9A?= =?UTF-8?q?=E8=BF=87=E3=80=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .vscode/settings.json | 17 ++- src/lib/data/data.c | 251 ++++++++----------------------- src/lib/data/data.h | 51 ++++--- src/main.c | 341 +++++++++++++++++++++++++++++++++++++++++- 4 files changed, 453 insertions(+), 207 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index 3a22d1e..11cdbbe 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,7 +1,22 @@ { "C_Cpp.default.compilerPath": "/usr/bin/g++-14", "files.associations": { - "stdio.h": "c" + "stdio.h": "c", + "chrono": "c", + "functional": "c", + "compare": "c", + "cstdint": "c", + "format": "c", + "any": "c", + "array": "c", + "charconv": "c", + "complex": "c", + "ratio": "c", + "scoped_allocator": "c", + "tuple": "c", + "type_traits": "c", + "utility": "c", + "variant": "c" }, "commentTranslate.targetLanguage": "en" } \ No newline at end of file diff --git a/src/lib/data/data.c b/src/lib/data/data.c index d4b4ac3..44d1bb5 100755 --- a/src/lib/data/data.c +++ b/src/lib/data/data.c @@ -1,7 +1,7 @@ /******************************************************************************************** * @file data.c * @author jinguishen (jinguishen@crte.com.cn) - * Description : + * Description : guishenking * @version 0.1 * @date 2025-11-26 * @@ -10,199 +10,80 @@ *********************************************************************************************/ #include "data.h" #include +#include -uint16_t convertU8ArrayToU16_BigEndian(const uint8_t *paucBuffer) -{ - return ((uint16_t)paucBuffer[0] << 8) | - ((uint16_t)paucBuffer[1]); +#define CONVERT_UXX_ARRAY_TO_UYY_BIG_ENDIAN(type_from, type_to) \ +type_to convert##type_from##ArrayTo##type_to##_BigEndian(const type_from *pArray) { \ + _Static_assert(sizeof(type_to) % sizeof(type_from) == 0, "Size ratio must be integer"); \ + const size_t elements_needed = sizeof(type_to) / sizeof(type_from); \ + const size_t shift_per_element = sizeof(type_from) * 8; \ + type_to result = 0; \ + for (size_t i = 0; i < elements_needed; i++) { \ + result |= ((type_to)pArray[i] << ((elements_needed - 1 - i) * shift_per_element)); \ + } \ + return result; \ } -uint16_t convertU8ArrayToU16_LittleEndian(const uint8_t *paucBuffer) -{ - return ((uint16_t)paucBuffer[1] << 8) | - ((uint16_t)paucBuffer[0]); +#define CONVERT_UXX_ARRAY_TO_UYY_LITTLE_ENDIAN(type_from, type_to) \ +type_to convert##type_from##ArrayTo##type_to##_LittleEndian(const type_from *pArray) { \ + _Static_assert(sizeof(type_to) % sizeof(type_from) == 0, "Size ratio must be integer"); \ + const size_t elements_needed = sizeof(type_to) / sizeof(type_from); \ + const size_t shift_per_element = sizeof(type_from) * 8; \ + type_to result = 0; \ + for (size_t i = 0; i < elements_needed; i++) { \ + result |= ((type_to)pArray[i] << (i * shift_per_element)); \ + } \ + return result; \ } -uint32_t convertU8ArrayToU32_BigEndian(const uint8_t *paucBuffer) -{ - return ((uint32_t)paucBuffer[0] << 24) | - ((uint32_t)paucBuffer[1] << 16) | - ((uint32_t)paucBuffer[2] << 8) | - ((uint32_t)paucBuffer[3]); +#define CONVERT_UXX_TO_UYY_ARRAY_LITTLE_ENDIAN(type_from, type_to) \ +type_to* convert##type_from##To##type_to##Array_LittleEndian(type_from value, type_to *pArray) { \ + _Static_assert(sizeof(type_from) % sizeof(type_to) == 0, "Size ratio must be integer"); \ + const size_t elements_needed = sizeof(type_from) / sizeof(type_to); \ + const size_t shift_per_element = sizeof(type_to) * 8; \ + for (size_t i = 0; i < elements_needed; i++) { \ + pArray[i] = (type_to)((value >> (i * shift_per_element)) & ((type_to)~0)); \ + } \ + return pArray; \ } -uint32_t convertU8ArrayToU32_LittleEndian(const uint8_t *paucBuffer) -{ - return ((uint32_t)paucBuffer[3] << 24) | - ((uint32_t)paucBuffer[2] << 16) | - ((uint32_t)paucBuffer[1] << 8) | - ((uint32_t)paucBuffer[0]); +#define CONVERT_UXX_TO_UYY_ARRAY_BIG_ENDIAN(type_from, type_to) \ +type_to* convert##type_from##To##type_to##Array_BigEndian(type_from value, type_to *pArray) { \ + _Static_assert(sizeof(type_from) % sizeof(type_to) == 0, "Size ratio must be integer"); \ + const size_t elements_needed = sizeof(type_from) / sizeof(type_to); \ + const size_t shift_per_element = sizeof(type_to) * 8; \ + for (size_t i = 0; i < elements_needed; i++) { \ + pArray[i] = (type_to)((value >> ((elements_needed - 1 - i) * shift_per_element)) & ((type_to)~0)); \ + } \ + return pArray; \ } -uint64_t convertU8ArrayToU64_BigEndian(const uint8_t *paucBuffer) -{ - return ((uint64_t)paucBuffer[0] << 56) | - ((uint64_t)paucBuffer[1] << 48) | - ((uint64_t)paucBuffer[2] << 40) | - ((uint64_t)paucBuffer[3] << 32) | - ((uint64_t)paucBuffer[4] << 24) | - ((uint64_t)paucBuffer[5] << 16) | - ((uint64_t)paucBuffer[6] << 8) | - ((uint64_t)paucBuffer[7]); -} +// 生成函数（数组 → 整数） +CONVERT_UXX_ARRAY_TO_UYY_BIG_ENDIAN(uint8_t, uint16_t) +CONVERT_UXX_ARRAY_TO_UYY_BIG_ENDIAN(uint8_t, uint32_t) +CONVERT_UXX_ARRAY_TO_UYY_BIG_ENDIAN(uint8_t, uint64_t) +CONVERT_UXX_ARRAY_TO_UYY_BIG_ENDIAN(uint16_t, uint32_t) +CONVERT_UXX_ARRAY_TO_UYY_BIG_ENDIAN(uint16_t, uint64_t) +CONVERT_UXX_ARRAY_TO_UYY_BIG_ENDIAN(uint32_t, uint64_t) -uint64_t convertU8ArrayToU64_LittleEndian(const uint8_t *paucBuffer) -{ - return ((uint64_t)paucBuffer[7] << 56) | - ((uint64_t)paucBuffer[6] << 48) | - ((uint64_t)paucBuffer[5] << 40) | - ((uint64_t)paucBuffer[4] << 32) | - ((uint64_t)paucBuffer[3] << 24) | - ((uint64_t)paucBuffer[2] << 16) | - ((uint64_t)paucBuffer[1] << 8) | - ((uint64_t)paucBuffer[0]); -} +CONVERT_UXX_ARRAY_TO_UYY_LITTLE_ENDIAN(uint8_t, uint16_t) +CONVERT_UXX_ARRAY_TO_UYY_LITTLE_ENDIAN(uint8_t, uint32_t) +CONVERT_UXX_ARRAY_TO_UYY_LITTLE_ENDIAN(uint8_t, uint64_t) +CONVERT_UXX_ARRAY_TO_UYY_LITTLE_ENDIAN(uint16_t, uint32_t) +CONVERT_UXX_ARRAY_TO_UYY_LITTLE_ENDIAN(uint16_t, uint64_t) +CONVERT_UXX_ARRAY_TO_UYY_LITTLE_ENDIAN(uint32_t, uint64_t) -uint32_t convertU16ArrayToU32_BigEndian(const uint16_t *pauBuffer) -{ - return ((uint32_t)pauBuffer[0] << 16) | - ((uint32_t)pauBuffer[1]); -} +// 生成函数（整数 → 数组） +CONVERT_UXX_TO_UYY_ARRAY_BIG_ENDIAN(uint16_t, uint8_t) +CONVERT_UXX_TO_UYY_ARRAY_BIG_ENDIAN(uint32_t, uint8_t) +CONVERT_UXX_TO_UYY_ARRAY_BIG_ENDIAN(uint64_t, uint8_t) +CONVERT_UXX_TO_UYY_ARRAY_BIG_ENDIAN(uint32_t, uint16_t) +CONVERT_UXX_TO_UYY_ARRAY_BIG_ENDIAN(uint64_t, uint16_t) +CONVERT_UXX_TO_UYY_ARRAY_BIG_ENDIAN(uint64_t, uint32_t) -uint32_t convertU16ArrayToU32_LittleEndian(const uint16_t *pauBuffer) -{ - return ((uint32_t)pauBuffer[1] << 16) | - ((uint32_t)pauBuffer[0]); -} - -uint64_t convertU16ArrayToU64_BigEndian(const uint16_t *pauBuffer) -{ - return ((uint64_t)pauBuffer[0] << 48) | - ((uint64_t)pauBuffer[1] << 32) | - ((uint64_t)pauBuffer[2] << 16) | - ((uint64_t)pauBuffer[3]); -} - -uint64_t convertU16ArrayToU64_LittleEndian(const uint16_t *pauBuffer) -{ - return ((uint64_t)pauBuffer[3] << 48) | - ((uint64_t)pauBuffer[2] << 32) | - ((uint64_t)pauBuffer[1] << 16) | - ((uint64_t)pauBuffer[0]); -} - -uint64_t convertU32ArrayToU64_BigEndian(const uint32_t *pausBuffer) -{ - return ((uint64_t)pausBuffer[0] << 32) | - ((uint64_t)pausBuffer[1]); -} - -uint64_t convertU32ArrayToU64_LittleEndian(const uint32_t *pausBuffer) -{ - return ((uint64_t)pausBuffer[1] << 32) | - ((uint64_t)pausBuffer[0]); -} - -uint8_t* convertU16ToU8Array_BigEndian(uint16_t value, uint8_t *paucBuffer) -{ - paucBuffer[0] = (uint8_t)(value >> 8); - paucBuffer[1] = (uint8_t)(value & 0xFF); - return paucBuffer; -} - -uint8_t* convertU16ToU8Array_LittleEndian(uint16_t value, uint8_t *paucBuffer) -{ - paucBuffer[1] = (uint8_t)(value >> 8); - paucBuffer[0] = (uint8_t)(value & 0xFF); - return paucBuffer; -} - -uint8_t* convertU32ToU8Array_BigEndian(uint32_t value, uint8_t *paucBuffer) -{ - paucBuffer[0] = (uint8_t)(value >> 24); - paucBuffer[1] = (uint8_t)((value >> 16) & 0xFF); - paucBuffer[2] = (uint8_t)((value >> 8) & 0xFF); - paucBuffer[3] = (uint8_t)(value & 0xFF); - return paucBuffer; -} - -uint8_t* convertU32ToU8Array_LittleEndian(uint32_t value, uint8_t *paucBuffer) -{ - paucBuffer[3] = (uint8_t)(value >> 24); - paucBuffer[2] = (uint8_t)((value >> 16) & 0xFF); - paucBuffer[1] = (uint8_t)((value >> 8) & 0xFF); - paucBuffer[0] = (uint8_t)(value & 0xFF); - return paucBuffer; -} - -uint8_t* convertU64ToU8Array_BigEndian(uint64_t value, uint8_t *paucBuffer) -{ - paucBuffer[0] = (uint8_t)(value >> 56); - paucBuffer[1] = (uint8_t)((value >> 48) & 0xFF); - paucBuffer[2] = (uint8_t)((value >> 40) & 0xFF); - paucBuffer[3] = (uint8_t)((value >> 32) & 0xFF); - paucBuffer[4] = (uint8_t)((value >> 24) & 0xFF); - paucBuffer[5] = (uint8_t)((value >> 16) & 0xFF); - paucBuffer[6] = (uint8_t)((value >> 8) & 0xFF); - paucBuffer[7] = (uint8_t)(value & 0xFF); - return paucBuffer; -} - -uint8_t* convertU64ToU8Array_LittleEndian(uint64_t value, uint8_t* paucBuffer) -{ - paucBuffer[7] = (uint8_t)(value >> 56); - paucBuffer[6] = (uint8_t)((value >> 48) & 0xFF); - paucBuffer[5] = (uint8_t)((value >> 40) & 0xFF); - paucBuffer[4] = (uint8_t)((value >> 32) & 0xFF); - paucBuffer[3] = (uint8_t)((value >> 24) & 0xFF); - paucBuffer[2] = (uint8_t)((value >> 16) & 0xFF); - paucBuffer[1] = (uint8_t)((value >> 8) & 0xFF); - paucBuffer[0] = (uint8_t)(value & 0xFF); - return paucBuffer; -} - -uint16_t* convertU32ToU16Array_BigEndian(uint32_t value, uint16_t* pauBuffer) -{ - pauBuffer[0] = (uint16_t)((value >> 16) & 0xFFFF); - pauBuffer[1] = (uint16_t)(value & 0xFFFF); - return pauBuffer; -} - -uint16_t* convertU32ToU16Array_LittleEndian(uint32_t value, uint16_t* pauBuffer) -{ - pauBuffer[1] = (uint16_t)((value >> 16) & 0xFFFF); - pauBuffer[0] = (uint16_t)(value & 0xFFFF); - return pauBuffer; -} - -uint16_t* convertU64ToU16Array_BigEndian(uint64_t value, uint16_t* pauBuffer) -{ - pauBuffer[0] = (uint16_t)(value >> 48); - pauBuffer[1] = (uint16_t)((value >> 32) & 0xFFFF); - pauBuffer[2] = (uint16_t)((value >> 16) & 0xFFFF); - pauBuffer[3] = (uint16_t)(value & 0xFFFF); - return pauBuffer; -} - -uint16_t* convertU64ToU16Array_LittleEndian(uint64_t value, uint16_t* pauBuffer) -{ - pauBuffer[3] = (uint16_t)(value >> 48); - pauBuffer[2] = (uint16_t)((value >> 32) & 0xFFFF); - pauBuffer[1] = (uint16_t)((value >> 16) & 0xFFFF); - pauBuffer[0] = (uint16_t)(value & 0xFFFF); - return pauBuffer; -} - -uint32_t* convertU64ToU32Array_BigEndian(uint64_t value, uint32_t* pausBuffer) -{ - pausBuffer[0] = (uint32_t)((value >> 32) & 0xFFFFFFFF); - pausBuffer[1] = (uint32_t)(value & 0xFFFFFFFF); - return pausBuffer; -} - -uint32_t* convertU64ToU32Array_LittleEndian(uint64_t value, uint32_t* pausBuffer) -{ - pausBuffer[1] = (uint32_t)((value >> 32) & 0xFFFFFFFF); - pausBuffer[0] = (uint32_t)(value & 0xFFFFFFFF); - return pausBuffer; -} \ No newline at end of file +CONVERT_UXX_TO_UYY_ARRAY_LITTLE_ENDIAN(uint16_t, uint8_t) +CONVERT_UXX_TO_UYY_ARRAY_LITTLE_ENDIAN(uint32_t, uint8_t) +CONVERT_UXX_TO_UYY_ARRAY_LITTLE_ENDIAN(uint64_t, uint8_t) +CONVERT_UXX_TO_UYY_ARRAY_LITTLE_ENDIAN(uint32_t, uint16_t) +CONVERT_UXX_TO_UYY_ARRAY_LITTLE_ENDIAN(uint64_t, uint16_t) +CONVERT_UXX_TO_UYY_ARRAY_LITTLE_ENDIAN(uint64_t, uint32_t) \ No newline at end of file diff --git a/src/lib/data/data.h b/src/lib/data/data.h index 7b8994d..0909d21 100755 --- a/src/lib/data/data.h +++ b/src/lib/data/data.h @@ -21,26 +21,39 @@ #define U32TOU64(value) ((uint64_t)(value)) -#pragma pack(1) -typedef struct vector{ - void *data; // 数据指针 - size_t size; // 当前元素数量 - size_t capacity; // 总容量 - size_t elem_size;// 单个元素大小 -} vector_t; -#pragma pack() +#include +#include -#pragma pack(1) -enum vector_error { - VECTOR_OK = 0, // 成功 - VECTOR_ERR_NULL, // 空指针错误 - VECTOR_ERR_OUT_OF_BOUNDS, // 索引越界错误 - VECTOR_ERR_MEMORY, // 内存分配错误 - VECTOR_ERR_INVALID_SIZE, // 无效大小错误 - VECTOR_ERR_MULTIPLE, // 多重定义错误 - VECTOR_ERR_NOT_MATCH // 未找到错误 -}; -#pragma pack() +// 数组 → 整数转换函数声明 (大端序) +uint16_t convertuint8_tArrayTouint16_t_BigEndian(const uint8_t *pArray); +uint32_t convertuint8_tArrayTouint32_t_BigEndian(const uint8_t *pArray); +uint64_t convertuint8_tArrayTouint64_t_BigEndian(const uint8_t *pArray); +uint32_t convertuint16_tArrayTouint32_t_BigEndian(const uint16_t *pArray); +uint64_t convertuint16_tArrayTouint64_t_BigEndian(const uint16_t *pArray); +uint64_t convertuint32_tArrayTouint64_t_BigEndian(const uint32_t *pArray); +// 数组 → 整数转换函数声明 (小端序) +uint16_t convertuint8_tArrayTouint16_t_LittleEndian(const uint8_t *pArray); +uint32_t convertuint8_tArrayTouint32_t_LittleEndian(const uint8_t *pArray); +uint64_t convertuint8_tArrayTouint64_t_LittleEndian(const uint8_t *pArray); +uint32_t convertuint16_tArrayTouint32_t_LittleEndian(const uint16_t *pArray); +uint64_t convertuint16_tArrayTouint64_t_LittleEndian(const uint16_t *pArray); +uint64_t convertuint32_tArrayTouint64_t_LittleEndian(const uint32_t *pArray); + +// 整数 → 数组转换函数声明 (大端序) +uint8_t* convertuint16_tTouint8_tArray_BigEndian(uint16_t value, uint8_t *pArray); +uint8_t* convertuint32_tTouint8_tArray_BigEndian(uint32_t value, uint8_t *pArray); +uint8_t* convertuint64_tTouint8_tArray_BigEndian(uint64_t value, uint8_t *pArray); +uint16_t* convertuint32_tTouint16_tArray_BigEndian(uint32_t value, uint16_t *pArray); +uint16_t* convertuint64_tTouint16_tArray_BigEndian(uint64_t value, uint16_t *pArray); +uint32_t* convertuint64_tTouint32_tArray_BigEndian(uint64_t value, uint32_t *pArray); + +// 整数 → 数组转换函数声明 (小端序) +uint8_t* convertuint16_tTouint8_tArray_LittleEndian(uint16_t value, uint8_t *pArray); +uint8_t* convertuint32_tTouint8_tArray_LittleEndian(uint32_t value, uint8_t *pArray); +uint8_t* convertuint64_tTouint8_tArray_LittleEndian(uint64_t value, uint8_t *pArray); +uint16_t* convertuint32_tTouint16_tArray_LittleEndian(uint32_t value, uint16_t *pArray); +uint16_t* convertuint64_tTouint16_tArray_LittleEndian(uint64_t value, uint16_t *pArray); +uint32_t* convertuint64_tTouint32_tArray_LittleEndian(uint64_t value, uint32_t *pArray); #endif // DATA_PROCESS_H \ No newline at end of file diff --git a/src/main.c b/src/main.c index 8da402a..928c886 100755 --- a/src/main.c +++ b/src/main.c @@ -11,8 +11,345 @@ #include "lib/data/data.h" #include #include +#include -int main(void) -{ +// 测试辅助函数 +void print_array_u8(const char *label, const uint8_t *array, size_t size) { + printf("%s: ", label); + for (size_t i = 0; i < size; i++) { + printf("0x%02X ", array[i]); + } + printf("\n"); +} + +void print_array_u16(const char *label, const uint16_t *array, size_t size) { + printf("%s: ", label); + for (size_t i = 0; i < size; i++) { + printf("0x%04X ", array[i]); + } + printf("\n"); +} + +void print_array_u32(const char *label, const uint32_t *array, size_t size) { + printf("%s: ", label); + for (size_t i = 0; i < size; i++) { + printf("0x%08X ", array[i]); + } + printf("\n"); +} + +// 1. 测试 uint8_t 数组 → 各种整数 (Big Endian) +void test_u8_array_to_int_be() { + printf("=== 测试 uint8_t 数组 → 整数 (大端序) ===\n"); + + // uint8_t[2] → uint16_t + uint8_t u8_to_u16[] = {0x12, 0x34}; + uint16_t result_u16 = convertuint8_tArrayTouint16_t_BigEndian(u8_to_u16); + assert(result_u16 == 0x1234); + printf("uint8_t[2] → uint16_t (BE): 0x%04X ✓\n", result_u16); + + // uint8_t[4] → uint32_t + uint8_t u8_to_u32[] = {0x12, 0x34, 0x56, 0x78}; + uint32_t result_u32 = convertuint8_tArrayTouint32_t_BigEndian(u8_to_u32); + assert(result_u32 == 0x12345678); + printf("uint8_t[4] → uint32_t (BE): 0x%08X ✓\n", result_u32); + + // uint8_t[8] → uint64_t + uint8_t u8_to_u64[] = {0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0}; + uint64_t result_u64 = convertuint8_tArrayTouint64_t_BigEndian(u8_to_u64); + assert(result_u64 == 0x123456789ABCDEF0); + printf("uint8_t[8] → uint64_t (BE): 0x%016lX ✓\n", result_u64); +} + +// 2. 测试 uint8_t 数组 → 各种整数 (Little Endian) +void test_u8_array_to_int_le() { + printf("\n=== 测试 uint8_t 数组 → 整数 (小端序) ===\n"); + + // uint8_t[2] → uint16_t + uint8_t u8_to_u16[] = {0x34, 0x12}; + uint16_t result_u16 = convertuint8_tArrayTouint16_t_LittleEndian(u8_to_u16); + assert(result_u16 == 0x1234); + printf("uint8_t[2] → uint16_t (LE): 0x%04X ✓\n", result_u16); + + // uint8_t[4] → uint32_t + uint8_t u8_to_u32[] = {0x78, 0x56, 0x34, 0x12}; + uint32_t result_u32 = convertuint8_tArrayTouint32_t_LittleEndian(u8_to_u32); + assert(result_u32 == 0x12345678); + printf("uint8_t[4] → uint32_t (LE): 0x%08X ✓\n", result_u32); + + // uint8_t[8] → uint64_t + uint8_t u8_to_u64[] = {0xF0, 0xDE, 0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12}; + uint64_t result_u64 = convertuint8_tArrayTouint64_t_LittleEndian(u8_to_u64); + assert(result_u64 == 0x123456789ABCDEF0); + printf("uint8_t[8] → uint64_t (LE): 0x%016lX ✓\n", result_u64); +} + +// 3. 测试 uint16_t 数组 → 各种整数 (Big Endian) +void test_u16_array_to_int_be() { + printf("\n=== 测试 uint16_t 数组 → 整数 (大端序) ===\n"); + + // uint16_t[2] → uint32_t + uint16_t u16_to_u32[] = {0x1234, 0x5678}; + uint32_t result_u32 = convertuint16_tArrayTouint32_t_BigEndian(u16_to_u32); + assert(result_u32 == 0x12345678); + printf("uint16_t[2] → uint32_t (BE): 0x%08X ✓\n", result_u32); + + // uint16_t[4] → uint64_t + uint16_t u16_to_u64[] = {0x1234, 0x5678, 0x9ABC, 0xDEF0}; + uint64_t result_u64 = convertuint16_tArrayTouint64_t_BigEndian(u16_to_u64); + assert(result_u64 == 0x123456789ABCDEF0); + printf("uint16_t[4] → uint64_t (BE): 0x%016lX ✓\n", result_u64); +} + +// 4. 测试 uint16_t 数组 → 各种整数 (Little Endian) +void test_u16_array_to_int_le() { + printf("\n=== 测试 uint16_t 数组 → 整数 (小端序) ===\n"); + + // uint16_t[2] → uint32_t + uint16_t u16_to_u32[] = {0x5678, 0x1234}; + uint32_t result_u32 = convertuint16_tArrayTouint32_t_LittleEndian(u16_to_u32); + assert(result_u32 == 0x12345678); + printf("uint16_t[2] → uint32_t (LE): 0x%08X ✓\n", result_u32); + + // uint16_t[4] → uint64_t + uint16_t u16_to_u64[] = {0xDEF0, 0x9ABC, 0x5678, 0x1234}; + uint64_t result_u64 = convertuint16_tArrayTouint64_t_LittleEndian(u16_to_u64); + assert(result_u64 == 0x123456789ABCDEF0); + printf("uint16_t[4] → uint64_t (LE): 0x%016lX ✓\n", result_u64); +} + +// 5. 测试 uint32_t 数组 → uint64_t (Big Endian) +void test_u32_array_to_int_be() { + printf("\n=== 测试 uint32_t 数组 → uint64_t (大端序) ===\n"); + + uint32_t u32_to_u64[] = {0x12345678, 0x9ABCDEF0}; + uint64_t result_u64 = convertuint32_tArrayTouint64_t_BigEndian(u32_to_u64); + assert(result_u64 == 0x123456789ABCDEF0); + printf("uint32_t[2] → uint64_t (BE): 0x%016lX ✓\n", result_u64); +} + +// 6. 测试 uint32_t 数组 → uint64_t (Little Endian) +void test_u32_array_to_int_le() { + printf("\n=== 测试 uint32_t 数组 → uint64_t (小端序) ===\n"); + + uint32_t u32_to_u64[] = {0x9ABCDEF0, 0x12345678}; + uint64_t result_u64 = convertuint32_tArrayTouint64_t_LittleEndian(u32_to_u64); + assert(result_u64 == 0x123456789ABCDEF0); + printf("uint32_t[2] → uint64_t (LE): 0x%016lX ✓\n", result_u64); +} + +// 7. 测试各种整数 → uint8_t 数组 (Big Endian) +void test_int_to_u8_array_be() { + printf("\n=== 测试整数 → uint8_t 数组 (大端序) ===\n"); + + // uint16_t → uint8_t[2] + uint16_t value_u16 = 0x1234; + uint8_t array_u16_to_u8[2]; + convertuint16_tTouint8_tArray_BigEndian(value_u16, array_u16_to_u8); + uint8_t expected_u16[] = {0x12, 0x34}; + assert(memcmp(array_u16_to_u8, expected_u16, 2) == 0); + print_array_u8("uint16_t → uint8_t[2] (BE)", array_u16_to_u8, 2); + + // uint32_t → uint8_t[4] + uint32_t value_u32 = 0x12345678; + uint8_t array_u32_to_u8[4]; + convertuint32_tTouint8_tArray_BigEndian(value_u32, array_u32_to_u8); + uint8_t expected_u32[] = {0x12, 0x34, 0x56, 0x78}; + assert(memcmp(array_u32_to_u8, expected_u32, 4) == 0); + print_array_u8("uint32_t → uint8_t[4] (BE)", array_u32_to_u8, 4); + + // uint64_t → uint8_t[8] + uint64_t value_u64 = 0x123456789ABCDEF0; + uint8_t array_u64_to_u8[8]; + convertuint64_tTouint8_tArray_BigEndian(value_u64, array_u64_to_u8); + uint8_t expected_u64[] = {0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0}; + assert(memcmp(array_u64_to_u8, expected_u64, 8) == 0); + print_array_u8("uint64_t → uint8_t[8] (BE)", array_u64_to_u8, 8); +} + +// 8. 测试各种整数 → uint8_t 数组 (Little Endian) +void test_int_to_u8_array_le() { + printf("\n=== 测试整数 → uint8_t 数组 (小端序) ===\n"); + + // uint16_t → uint8_t[2] + uint16_t value_u16 = 0x1234; + uint8_t array_u16_to_u8[2]; + convertuint16_tTouint8_tArray_LittleEndian(value_u16, array_u16_to_u8); + uint8_t expected_u16[] = {0x34, 0x12}; + assert(memcmp(array_u16_to_u8, expected_u16, 2) == 0); + print_array_u8("uint16_t → uint8_t[2] (LE)", array_u16_to_u8, 2); + + // uint32_t → uint8_t[4] + uint32_t value_u32 = 0x12345678; + uint8_t array_u32_to_u8[4]; + convertuint32_tTouint8_tArray_LittleEndian(value_u32, array_u32_to_u8); + uint8_t expected_u32[] = {0x78, 0x56, 0x34, 0x12}; + assert(memcmp(array_u32_to_u8, expected_u32, 4) == 0); + print_array_u8("uint32_t → uint8_t[4] (LE)", array_u32_to_u8, 4); + + // uint64_t → uint8_t[8] + uint64_t value_u64 = 0x123456789ABCDEF0; + uint8_t array_u64_to_u8[8]; + convertuint64_tTouint8_tArray_LittleEndian(value_u64, array_u64_to_u8); + uint8_t expected_u64[] = {0xF0, 0xDE, 0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12}; + assert(memcmp(array_u64_to_u8, expected_u64, 8) == 0); + print_array_u8("uint64_t → uint8_t[8] (LE)", array_u64_to_u8, 8); +} + +// 9. 测试各种整数 → uint16_t 数组 (Big Endian) +void test_int_to_u16_array_be() { + printf("\n=== 测试整数 → uint16_t 数组 (大端序) ===\n"); + + // uint32_t → uint16_t[2] + uint32_t value_u32 = 0x12345678; + uint16_t array_u32_to_u16[2]; + convertuint32_tTouint16_tArray_BigEndian(value_u32, array_u32_to_u16); + uint16_t expected_u32[] = {0x1234, 0x5678}; + assert(memcmp(array_u32_to_u16, expected_u32, 4) == 0); + print_array_u16("uint32_t → uint16_t[2] (BE)", array_u32_to_u16, 2); + + // uint64_t → uint16_t[4] + uint64_t value_u64 = 0x123456789ABCDEF0; + uint16_t array_u64_to_u16[4]; + convertuint64_tTouint16_tArray_BigEndian(value_u64, array_u64_to_u16); + uint16_t expected_u64[] = {0x1234, 0x5678, 0x9ABC, 0xDEF0}; + assert(memcmp(array_u64_to_u16, expected_u64, 8) == 0); + print_array_u16("uint64_t → uint16_t[4] (BE)", array_u64_to_u16, 4); +} + +// 10. 测试各种整数 → uint16_t 数组 (Little Endian) +void test_int_to_u16_array_le() { + printf("\n=== 测试整数 → uint16_t 数组 (小端序) ===\n"); + + // uint32_t → uint16_t[2] + uint32_t value_u32 = 0x12345678; + uint16_t array_u32_to_u16[2]; + convertuint32_tTouint16_tArray_LittleEndian(value_u32, array_u32_to_u16); + uint16_t expected_u32[] = {0x5678, 0x1234}; + assert(memcmp(array_u32_to_u16, expected_u32, 4) == 0); + print_array_u16("uint32_t → uint16_t[2] (LE)", array_u32_to_u16, 2); + + // uint64_t → uint16_t[4] + uint64_t value_u64 = 0x123456789ABCDEF0; + uint16_t array_u64_to_u16[4]; + convertuint64_tTouint16_tArray_LittleEndian(value_u64, array_u64_to_u16); + uint16_t expected_u64[] = {0xDEF0, 0x9ABC, 0x5678, 0x1234}; + assert(memcmp(array_u64_to_u16, expected_u64, 8) == 0); + print_array_u16("uint64_t → uint16_t[4] (LE)", array_u64_to_u16, 4); +} + +// 11. 测试 uint64_t → uint32_t 数组 (Big Endian) +void test_u64_to_u32_array_be() { + printf("\n=== 测试 uint64_t → uint32_t 数组 (大端序) ===\n"); + + uint64_t value_u64 = 0x123456789ABCDEF0; + uint32_t array_u64_to_u32[2]; + convertuint64_tTouint32_tArray_BigEndian(value_u64, array_u64_to_u32); + uint32_t expected[] = {0x12345678, 0x9ABCDEF0}; + assert(memcmp(array_u64_to_u32, expected, 8) == 0); + print_array_u32("uint64_t → uint32_t[2] (BE)", array_u64_to_u32, 2); +} + +// 12. 测试 uint64_t → uint32_t 数组 (Little Endian) +void test_u64_to_u32_array_le() { + printf("\n=== 测试 uint64_t → uint32_t 数组 (小端序) ===\n"); + + uint64_t value_u64 = 0x123456789ABCDEF0; + uint32_t array_u64_to_u32[2]; + convertuint64_tTouint32_tArray_LittleEndian(value_u64, array_u64_to_u32); + uint32_t expected[] = {0x9ABCDEF0, 0x12345678}; + assert(memcmp(array_u64_to_u32, expected, 8) == 0); + print_array_u32("uint64_t → uint32_t[2] (LE)", array_u64_to_u32, 2); +} + +// 13. 往返测试 (Round-trip) +// 13. 往返测试 (Round-trip) +void test_round_trip() { + printf("\n=== 往返转换测试 ===\n"); + + // uint32_t → uint16_t[2] → uint32_t (大端序) + uint32_t original_u32 = 0x12345678; + uint16_t temp_u16[2]; + + convertuint32_tTouint16_tArray_BigEndian(original_u32, temp_u16); + uint32_t recovered_u32 = convertuint16_tArrayTouint32_t_BigEndian(temp_u16); + + assert(original_u32 == recovered_u32); + printf("uint32_t → uint16_t[2] → uint32_t (BE): 0x%08X → 0x%08X ✓\n", original_u32, recovered_u32); + + // uint32_t → uint8_t[4] → uint32_t (小端序) + uint8_t temp_u8_32[4]; + convertuint32_tTouint8_tArray_LittleEndian(original_u32, temp_u8_32); + recovered_u32 = convertuint8_tArrayTouint32_t_LittleEndian(temp_u8_32); + + assert(original_u32 == recovered_u32); + printf("uint32_t → uint8_t[4] → uint32_t (LE): 0x%08X → 0x%08X ✓\n", original_u32, recovered_u32); + + // uint64_t → uint8_t[8] → uint64_t (小端序) + uint64_t original_u64 = 0x123456789ABCDEF0; + uint8_t temp_u8[8]; + + convertuint64_tTouint8_tArray_LittleEndian(original_u64, temp_u8); + uint64_t recovered_u64 = convertuint8_tArrayTouint64_t_LittleEndian(temp_u8); + + assert(original_u64 == recovered_u64); + printf("uint64_t → uint8_t[8] → uint64_t (LE): 0x%016lX → 0x%016lX ✓\n", original_u64, recovered_u64); + + // uint64_t → uint16_t[4] → uint64_t (大端序) + uint16_t temp_u16_64[4]; + convertuint64_tTouint16_tArray_BigEndian(original_u64, temp_u16_64); + recovered_u64 = convertuint16_tArrayTouint64_t_BigEndian(temp_u16_64); + + assert(original_u64 == recovered_u64); + printf("uint64_t → uint16_t[4] → uint64_t (BE): 0x%016lX → 0x%016lX ✓\n", original_u64, recovered_u64); + + // uint64_t → uint32_t[2] → uint64_t (小端序) + uint32_t temp_u32[2]; + convertuint64_tTouint32_tArray_LittleEndian(original_u64, temp_u32); + recovered_u64 = convertuint32_tArrayTouint64_t_LittleEndian(temp_u32); + + assert(original_u64 == recovered_u64); + printf("uint64_t → uint32_t[2] → uint64_t (LE): 0x%016lX → 0x%016lX ✓\n", original_u64, recovered_u64); + + // uint64_t → uint32_t[2] → uint64_t (大端序) + convertuint64_tTouint32_tArray_BigEndian(original_u64, temp_u32); + recovered_u64 = convertuint32_tArrayTouint64_t_BigEndian(temp_u32); + + assert(original_u64 == recovered_u64); + printf("uint64_t → uint32_t[2] → uint64_t (BE): 0x%016lX → 0x%016lX ✓\n", original_u64, recovered_u64); + + // uint32_t → uint16_t[2] → uint32_t (小端序) + convertuint32_tTouint16_tArray_LittleEndian(original_u32, temp_u16); + recovered_u32 = convertuint16_tArrayTouint32_t_LittleEndian(temp_u16); + + assert(original_u32 == recovered_u32); + printf("uint32_t → uint16_t[2] → uint32_t (LE): 0x%08X → 0x%08X ✓\n", original_u32, recovered_u32); + + // uint32_t → uint8_t[4] → uint32_t (大端序) + convertuint32_tTouint8_tArray_BigEndian(original_u32, temp_u8_32); + recovered_u32 = convertuint8_tArrayTouint32_t_BigEndian(temp_u8_32); + + assert(original_u32 == recovered_u32); + printf("uint32_t → uint8_t[4] → uint32_t (BE): 0x%08X → 0x%08X ✓\n", original_u32, recovered_u32); +} + +int main() { + printf("开始完整测试数据转换函数...\n\n"); + + test_u8_array_to_int_be(); + test_u8_array_to_int_le(); + test_u16_array_to_int_be(); + test_u16_array_to_int_le(); + test_u32_array_to_int_be(); + test_u32_array_to_int_le(); + test_int_to_u8_array_be(); + test_int_to_u8_array_le(); + test_int_to_u16_array_be(); + test_int_to_u16_array_le(); + test_u64_to_u32_array_be(); + test_u64_to_u32_array_le(); + test_round_trip(); + + printf("\n🎉 所有测试通过！全部 %d 个转换函数工作正常。\n", 24); return 0; } \ No newline at end of file