.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"
 }

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 <stdlib.h>
+#include <stdint.h>
 
-uint16_t convertU8ArrayToU16_BigEndian(const uint8_t *paucBuffer) 
+#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) { \
-    return ((uint16_t)paucBuffer[0] << 8) |
+    _Static_assert(sizeof(type_to) % sizeof(type_from) == 0, "Size ratio must be integer"); \
-           ((uint16_t)paucBuffer[1]);
+    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) 
+#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) { \
-    return ((uint16_t)paucBuffer[1] << 8) |
+    _Static_assert(sizeof(type_to) % sizeof(type_from) == 0, "Size ratio must be integer"); \
-           ((uint16_t)paucBuffer[0]);
+    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) 
+#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) { \
-    return ((uint32_t)paucBuffer[0] << 24) |
+    _Static_assert(sizeof(type_from) % sizeof(type_to) == 0, "Size ratio must be integer"); \
-           ((uint32_t)paucBuffer[1] << 16) |
+    const size_t elements_needed = sizeof(type_from) / sizeof(type_to); \
-           ((uint32_t)paucBuffer[2] << 8)  |
+    const size_t shift_per_element = sizeof(type_to) * 8; \
-           ((uint32_t)paucBuffer[3]);
+    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) 
+#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) { \
-    return ((uint32_t)paucBuffer[3] << 24) |
+    _Static_assert(sizeof(type_from) % sizeof(type_to) == 0, "Size ratio must be integer"); \
-           ((uint32_t)paucBuffer[2] << 16) |
+    const size_t elements_needed = sizeof(type_from) / sizeof(type_to); \
-           ((uint32_t)paucBuffer[1] << 8)  |
+    const size_t shift_per_element = sizeof(type_to) * 8; \
-           ((uint32_t)paucBuffer[0]);
+    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) 
+// 生成函数（数组 → 整数）
-{
+CONVERT_UXX_ARRAY_TO_UYY_BIG_ENDIAN(uint8_t, uint16_t)
-    return ((uint64_t)paucBuffer[0] << 56) |
+CONVERT_UXX_ARRAY_TO_UYY_BIG_ENDIAN(uint8_t, uint32_t)
-           ((uint64_t)paucBuffer[1] << 48) |
+CONVERT_UXX_ARRAY_TO_UYY_BIG_ENDIAN(uint8_t, uint64_t)
-           ((uint64_t)paucBuffer[2] << 40) |
+CONVERT_UXX_ARRAY_TO_UYY_BIG_ENDIAN(uint16_t, uint32_t)
-           ((uint64_t)paucBuffer[3] << 32) |
+CONVERT_UXX_ARRAY_TO_UYY_BIG_ENDIAN(uint16_t, uint64_t)
-           ((uint64_t)paucBuffer[4] << 24) |
+CONVERT_UXX_ARRAY_TO_UYY_BIG_ENDIAN(uint32_t, uint64_t)
-           ((uint64_t)paucBuffer[5] << 16) |
-           ((uint64_t)paucBuffer[6] << 8)  |
-           ((uint64_t)paucBuffer[7]);
-}
 
-uint64_t convertU8ArrayToU64_LittleEndian(const uint8_t *paucBuffer) 
+CONVERT_UXX_ARRAY_TO_UYY_LITTLE_ENDIAN(uint8_t, uint16_t)
-{
+CONVERT_UXX_ARRAY_TO_UYY_LITTLE_ENDIAN(uint8_t, uint32_t)
-    return ((uint64_t)paucBuffer[7] << 56) |
+CONVERT_UXX_ARRAY_TO_UYY_LITTLE_ENDIAN(uint8_t, uint64_t)
-           ((uint64_t)paucBuffer[6] << 48) |
+CONVERT_UXX_ARRAY_TO_UYY_LITTLE_ENDIAN(uint16_t, uint32_t)
-           ((uint64_t)paucBuffer[5] << 40) |
+CONVERT_UXX_ARRAY_TO_UYY_LITTLE_ENDIAN(uint16_t, uint64_t)
-           ((uint64_t)paucBuffer[4] << 32) |
+CONVERT_UXX_ARRAY_TO_UYY_LITTLE_ENDIAN(uint32_t, uint64_t)
-           ((uint64_t)paucBuffer[3] << 24) |
-           ((uint64_t)paucBuffer[2] << 16) |
-           ((uint64_t)paucBuffer[1] << 8)  |
-           ((uint64_t)paucBuffer[0]);
-}
 
-uint32_t convertU16ArrayToU32_BigEndian(const uint16_t *pauBuffer) 
+// 生成函数（整数 → 数组）
-{
+CONVERT_UXX_TO_UYY_ARRAY_BIG_ENDIAN(uint16_t, uint8_t)
-    return ((uint32_t)pauBuffer[0] << 16) |
+CONVERT_UXX_TO_UYY_ARRAY_BIG_ENDIAN(uint32_t, uint8_t)
-           ((uint32_t)pauBuffer[1]);
+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) 
+CONVERT_UXX_TO_UYY_ARRAY_LITTLE_ENDIAN(uint16_t, uint8_t)
-{
+CONVERT_UXX_TO_UYY_ARRAY_LITTLE_ENDIAN(uint32_t, uint8_t)
-    return ((uint32_t)pauBuffer[1] << 16) |
+CONVERT_UXX_TO_UYY_ARRAY_LITTLE_ENDIAN(uint64_t, uint8_t)
-           ((uint32_t)pauBuffer[0]);
+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)
-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;
-}

src/lib/data/data.h

@@ -21,26 +21,39 @@
 #define U32TOU64(value) ((uint64_t)(value))
 
 
-#pragma pack(1)
+#include <stdint.h>
-typedef struct  vector{
+#include <stddef.h>
-    void *data;      // 数据指针
-    size_t size;     // 当前元素数量
-    size_t capacity; // 总容量
-    size_t elem_size;// 单个元素大小
-} vector_t;
-#pragma pack()
 
-#pragma pack(1)
+// 数组 → 整数转换函数声明 (大端序)
-enum vector_error {
+uint16_t convertuint8_tArrayTouint16_t_BigEndian(const uint8_t *pArray);
-    VECTOR_OK = 0,          // 成功
+uint32_t convertuint8_tArrayTouint32_t_BigEndian(const uint8_t *pArray);
-    VECTOR_ERR_NULL,       // 空指针错误
+uint64_t convertuint8_tArrayTouint64_t_BigEndian(const uint8_t *pArray);
-    VECTOR_ERR_OUT_OF_BOUNDS, // 索引越界错误
+uint32_t convertuint16_tArrayTouint32_t_BigEndian(const uint16_t *pArray);
-    VECTOR_ERR_MEMORY,     // 内存分配错误
+uint64_t convertuint16_tArrayTouint64_t_BigEndian(const uint16_t *pArray);
-    VECTOR_ERR_INVALID_SIZE, // 无效大小错误
+uint64_t convertuint32_tArrayTouint64_t_BigEndian(const uint32_t *pArray);
-    VECTOR_ERR_MULTIPLE, // 多重定义错误
-    VECTOR_ERR_NOT_MATCH // 未找到错误
-};
-#pragma pack()
 
+// 数组 → 整数转换函数声明 (小端序)
+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

src/main.c

@@ -11,8 +11,345 @@
 #include "lib/data/data.h"
 #include <stdio.h>
 #include <string.h>
+#include <assert.h>
 
-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;
 }