Merge pull request #6 from Ryan-CW-Code/next

Next

.clang-format

@@ -10,26 +10,42 @@
 #   - https://clang.llvm.org/docs/ClangFormatStyleOptions.html
 
 ---
-# 基于 LLVM 的代码风格
+# 基于 LLVM 的代码风格作为起点，随后覆盖指定字段
 BasedOnStyle: LLVM
-# 连续宏定义的对齐方式：跨注释对齐
+
+# 连续宏定义的对齐方式
+# Enabled: true         -> 启用对齐连续宏定义
+# AcrossComments: true  -> 跨注释也会对齐，适合一组宏中间穿插注释的情况
 AlignConsecutiveMacros:
   Enabled: true
   AcrossComments: true
-# 短代码块不允许单行显示
-AllowShortBlocksOnASingleLine: Never
-# 短 case 标签不允许单行显示
+
+# 是否允许短代码块（如 { ... }）出现在单行
+AllowShortBlocksOnASingleLine: true
+
+# 是否允许短 case 标签单行
+# true  -> 允许 `case X: doSomething();`
 AllowShortCaseLabelsOnASingleLine: true
-# 短枚举不允许单行显示
+
+# 是否允许短枚举在一行
+# true  -> 允许短枚举如 `enum { A, B };`
 AllowShortEnumsOnASingleLine: false
-# 短函数不允许单行显示（None 表示对所有函数都应用此规则）
-AllowShortFunctionsOnASingleLine: None
-# 短 if 语句不允许单行显示
+
+# 是否允许短函数在单行
+AllowShortFunctionsOnASingleLine: true
+
+AllowShortCaseExpressionOnASingleLine: true
+
+# 短 if 语句单行显示策略
+# Always  -> 允许并尽可能保留短 if 语句为单行（包括带 else 的情况）
+# 你希望单行 + 大括号时使用这个选项
 AllowShortIfStatementsOnASingleLine: true
-# 短循环不允许单行显示
+
+# 是否允许短循环（for/while）单行显示
 AllowShortLoopsOnASingleLine: true
 
-# 属性宏列表
+# 属性宏列表，列出在格式化时应视为属性的宏（影响对齐、换行等）
+# 如果代码库使用自定义属性宏，把它们列在这里可以提升格式化准确性
 AttributeMacros:
   - __aligned
   - __deprecated
@@ -39,17 +55,19 @@ AttributeMacros:
   - __syscall_always_inline
   - __subsystem
 
-# 位字段冒号后的空格位置：冒号后
+# 位字段冒号后的空格：After 表示 `int x : 3;` 中冒号后带一个空格（风格选择）
 BitFieldColonSpacing: After
 
+# 大括号换行策略：使用 Custom 配合 BraceWrapping 指定细节
+# 你用了 Custom，这意味着下面的 BraceWrapping 字段决定具体行为
 BreakBeforeBraces: Custom
 BraceWrapping:
-  AfterCaseLabel: false
-  AfterClass: true
-  AfterControlStatement: Always
-  AfterEnum: true
+  AfterCaseLabel: false           # case 标签后不另起行放 {，通常 case: 仍和语句对齐
+  AfterClass: true                # class 后大括号另起行
+  AfterControlStatement: Always   # 控制语句（if/for/while）后通常将 { 放在新行（可被覆盖）
+  AfterEnum: true                 # enum 后另起行
   AfterExternBlock: false
-  AfterFunction: true
+  AfterFunction: true             # 函数体大括号另起行
   AfterNamespace: true
   AfterObjCDeclaration: true
   AfterStruct: true
@@ -58,28 +76,32 @@ BraceWrapping:
   BeforeElse: true
   BeforeLambdaBody: false
   BeforeWhile: false
-  IndentBraces: false
+  IndentBraces: false             # 不单独缩进大括号行
   SplitEmptyFunction: true
   SplitEmptyRecord: true
   SplitEmptyNamespace: true
 
-# 单行代码的最大列数
-ColumnLimit: 200
-# 构造函数初始化列表的缩进宽度
+# 单行代码的最大列数（换行阈值）
+ColumnLimit: 140
+
+# 构造函数初始化列表的缩进宽度（可针对长列表调整可读性）
 ConstructorInitializerIndentWidth: 8
-# 折行缩进宽度
+
+# 折行缩进宽度（续行缩进）
 ContinuationIndentWidth: 8
-# ForEach 宏列表
+
+# ForEach 宏列表：告诉 clang-format 哪些宏应当当作循环处理（便于格式化块体）
 ForEachMacros:
   - "ARRAY_FOR_EACH"
   - "ARRAY_FOR_EACH_PTR"
   - "FOR_EACH"
 
-# If 宏列表
+# If 宏列表：把 CHECKIF 等宏视为 if 语句（影响括号和后续块处理）
 IfMacros:
   - "CHECKIF"
 
-# 包含文件的分类和优先级
+# include 文件的分类和排序优先级
+# Regex: 正则匹配，Priority: 数字越小优先级越高（越先放）
 IncludeCategories:
   - Regex: '^".*\.h"$'
     Priority: 0
@@ -90,25 +112,38 @@ IncludeCategories:
   - Regex: ".*"
     Priority: 3
 
-# case 标签不缩进
+# case 标签是否缩进（true 会将 case 缩进到 switch 中）
+# false -> case 与 switch 对齐（你原先设置 false）
 IndentCaseLabels: false
-# goto 标签不缩进
+
+# goto 标签是否缩进（false 表示标签在行首）
 IndentGotoLabels: false
-# 缩进宽度
+
+# 缩进宽度（通常与制表符策略配合使用）
 IndentWidth: 8
-# 自动插入大括号
+
+# 自动插入大括号（即使单语句也插入 { }）
+# 这可以避免单行语句因为后续添加语句而引入 bug
 InsertBraces: true
-# 文件末尾自动插入新行
+
+# 文件末尾自动插入换行
 InsertNewlineAtEOF: true
-# 继承冒号前不加空格
+
+# 继承冒号前是否加空格（False 表示不加空格："class A: public B"）
 SpaceBeforeInheritanceColon: False
-# 控制语句（除了控制宏）前加空格
+
+# 控制语句后是否加空格（这个值控制 if/for/while 等的格式）
+# ControlStatementsExceptControlMacros -> 控制语句（非宏）前加空格：`if (cond)` 而非 `if(cond)`
 SpaceBeforeParens: ControlStatementsExceptControlMacros
-# 从不排序包含文件
+
+# 包含文件是否自动排序（Never 表示不排序）
 SortIncludes: Never
-# 使用制表符进行续行和缩进
+
+# 缩进与续行使用制表符策略
+# ForContinuationAndIndentation -> 续行与缩进使用制表符，其他空格仍按规则
 UseTab: ForContinuationAndIndentation
-# 对空白字符敏感的宏列表
+
+# 对空白敏感的宏列表（多用于预处理器宏展开格式保持）
 WhitespaceSensitiveMacros:
   - COND_CODE_0
   - COND_CODE_1
@@ -118,3 +153,11 @@ WhitespaceSensitiveMacros:
   - STRINGIFY
   - Z_STRINGIFY
   - DT_FOREACH_PROP_ELEM_SEP
+
+# --------------------------
+# 可选：降低 clang-format 拆行惩罚，使其更倾向于保留短 if/else 单行
+# 下面两个值可以帮助把格式化后的多行 if/else 更可能压缩成单行（仅在 AllowShortIfStatementsOnASingleLine: Always 有效时可用）
+# PenaltyBreakIfElse: 0
+# PenaltyBreakStatement: 0
+
+# 注：上面的 Penalty 设置是可选的，如果你发现 clang-format 依旧不把某些 if/else 压成单行，可以取消注释并试验效果。

.clang-format-ignore

@@ -1,2 +1,2 @@
-# 忽略coreMqtt
+# 忽略外部包
 externalModule/*

.clang-tidy

@@ -31,7 +31,7 @@ Checks:
   # 静默的窄化转换交给编译器来判断？
   - 'bugprone-*,-bugprone-easily-swappable-parameters'
   - 'readability-identifier-naming'
-  - 'misc-*,-misc-const-correctness,-misc-unused-parameters,-misc-non-private-member-variables-in-classes,-misc-no-recursion,-misc-use-anonymous-namespace,-misc-include-cleaner'
+  - 'misc-*,-misc-const-correctness,-misc-no-recursion,-misc-include-cleaner'
 
 CheckOptions:
   # 类名使用帕斯卡命名法（如 MyClass）

.gitignore

@@ -13,5 +13,12 @@ null
 core
 build
 .xmake
+.dump
 .vscode-ctags
 
+default.profdata
+default.profraw
+test/fuzzer/corpus
+docs
+
+fuzz-*

.vscode/settings.json

@@ -20,6 +20,18 @@
         // "--suppress=constVariablePointer",
         // "--suppress=constParameter",
     ],
+    "files.watcherExclude": {
+        "**/test/fuzzer/corpus/**": true,
+        "./docs": true,
+        "./build": true,
+        "./.xmake": true,
+    },
+    "files.exclude": {
+        "**/test/fuzzer/corpus/**": true,
+        "./docs": true,
+        "./build": true,
+        "./.xmake": true,
+    },
     "files.associations": {
         "*.c": "c",
         "inttypes.h": "c",
@@ -30,6 +42,19 @@
         "stdint.h": "c",
         "ryanjsontest.h": "c",
         "dirent.h": "c",
-        "valloc.h": "c"
+        "valloc.h": "c",
+        "initializer_list": "c",
+        "array": "c",
+        "string_view": "c",
+        "utility": "c",
+        "math.h": "c",
+        "compare": "c",
+        "type_traits": "c",
+        "cjson.h": "c",
+        "ryanjson.h": "c",
+        "string.h": "c",
+        "stdarg.h": "c",
+        "cstdlib": "c",
+        "ryanjsonconfig.h": "c"
     },
 }

README.md

@@ -1,24 +1,34 @@
 # RyanJson
 ### *希望有兴趣的大佬多试试，找找bug、提提意见*
 
+📢 **使用过程中遇到问题？欢迎提交 Issue 或在 [RT-Thread 社区](https://club.rt-thread.org/index.html) 提问，感谢支持！**
+
 ***一个针对资源受限的嵌入式设备优化的Json库，内存占用极小的通用Json库，简洁高效！***
 
-*初衷：项目进行重构Json结构变复杂了很多，cJSON内存占用太高，已经满足不了需求。*
+***示例代码请参考`example`文件夹！***
+
+### 1、介绍
 
-***示例代码请参考`RyanJsonExample`文件夹内！***
+**RyanJson** 是一个小巧的 C 语言 JSON 解析器，支持 JSON 文本的解析与生成，针对嵌入式平台的 **低内存占用** 进行了深度优化。
 
-## 1、介绍
+*初衷：项目重构后 JSON 结构复杂度提升，cJSON 内存占用过高，无法满足嵌入式场景需求。*
 
-RyanJson是一个小巧的C语言Json解析器，包含json文本文件解析 / 生成，**专门针对内存占用进行优化**，相比cJSON内存占用减少30% - 60%，运行速度和cJSON差不多。
+#### ✅ 特性亮点
 
-- **低内存占用**：使用动态扩展技术，在32位系统下，一个基础json节点仅占用8字节。
-- **开发人员友好**：仅有一个c文件和头文件轻松集成，hook函数方便自定义内存钩子。类cJSON的api，迁移成本低。
-- **严格但不严苛**：符合 RFC 8295 大部分JSON标准，支持无限的json嵌套级别（需注意堆栈空间）、灵活的配置修改项
-- **可扩展性**：允许注释(需调用mini函数清除注释后再解析)、尾随逗号等无效字符(parse时可配置是否允许)等
+- 💡 **极致内存优化**：在资源受限设备上实现 **40-70% 内存节省**（对比 cJSON），在 RT-Thread 平台 malloc 头部空间为 12 字节时节省约 40%，无 malloc 头部空间可接近 70%。同时保持工业级健壮性，运行速度与 cJSON 基本持平。
+- 🔍 **模糊测试保障**：基于[LLVM Fuzzer](https://llvm.org/docs/LibFuzzer.html) ，上亿级数据输入分支覆盖率 **99.9%**，确保在各种非法输入和极端场景下依旧安全。**[点击在线查看覆盖率信息](https://ryan-cw-code.github.io/RyanJson/)** 
+- 🛡️ **运行时安全分析验证**，使用 **[Sanitizer](https://clang.llvm.org/docs/index.html#sanitizers)** 系列工具，捕获内存越界、Use-after-free、数据竞争、未定义行为、内存泄漏等问题，提升代码健壮性与安全性
+- 📐**高质量代码保障** ， 引入 **[clang-tidy](https://clang.llvm.org/extra/clang-tidy/#clang-tidy)** 与 **[Cppcheck](https://cppcheck.sourceforge.io/)** 进行静态分析，实现接近语法级的"**零缺陷**"，显著提升可维护性与可读性
+- 🤖  **AI 辅助开发与审查**，结合  **[coderabbitai](https://www.coderabbit.ai)** 、 **[Copilot](https://github.com/features/copilot)** 、**[Gemini Code Assist](https://codeassist.google/)**，在编码与代码审查阶段持续优化代码质量，构建多层安全防线
+- 🧪 **9 大类专项测试用例**，覆盖广泛场景，全链路内存泄漏检测，强化稳定性与可靠性
+- ⚙️ **低内存占用**：动态内存扩展方案，内存空间利用率高。
+- 👩‍💻 **开发者友好**：轻松集成，类 cJSON API，迁移成本低。
+- 📜 **严格但不严苛**：符合 RFC 8259 绝大部分JSON标准，支持无限的Json嵌套级别（需注意堆栈空间）、灵活的配置修改项
+- 🔧 **可扩展性**：允许注释(需调用mini函数清除注释后再解析)、尾随逗号等无效字符(parse时可配置是否允许)等
 
-## 2、设计
+### 2、设计
 
-**RyanJson设计时大量借鉴了 [json](https://api.gitee.com/Lamdonn/json) 和 [cJSON](https://github.com/DaveGamble/cJSON) ! 是从 [json](https://api.gitee.com/Lamdonn/json) 的基础上修改来的**
+**RyanJson设计时大量借鉴了 [json](https://api.gitee.com/Lamdonn/json) 和 [cJSON](https://github.com/DaveGamble/cJSON) ! **
 
 Json语法是**JavaScript**对象语法的子集，可通过下面两个连接学习json语法。
 
@@ -26,73 +36,149 @@ Json语法是**JavaScript**对象语法的子集，可通过下面两个连接
 
 [Parsing JSON is a Minefield 建议看看](https://seriot.ch/projects/parsing_json.html)
 
-在json语法中，数据以**键值对**的形式存储（数组的子项没有key）
-
-在RyanJson解析器中，**使用结构体来表示一个键值对，是存储的最小单元**，结构如下：
+在RyanJson中，**结构体表示最小存储单元（键值对）**，通过单链表组织，结构如下：
 
 ```c
+// Json 的最基础节点，所有 Json 元素都由该节点表示。
+// 结构体中仅包含固定的 next 指针，用于单向链表串联。
+// 其余数据（flag、key、stringValue、numberValue、doubleValue 等）均通过动态内存分配管理。
 struct RyanJsonNode
 {
-    uint32_t info;             // 包含类型，key等标志
-    struct RyanJsonNode *next; // 单链表node节点
-
-    // [char *key] 有key的json节点, 会动态申请内存
-
-    // 有value值的节点, 会动态申请内存
-    // [int32_t value / double value / char* value / RyanJson_t item]
+	struct RyanJsonNode *next; // 单链表节点指针
+
+	/*
+	 * 在 next 后紧跟一个字节的 flag，用于描述节点的核心信息：
+	 *
+	 * 位分布如下：
+	 * bit7   bit6   bit5   bit4   bit3   bit2   bit1   bit0
+	 * -----------------------------------------------------
+	 * 保留   KeyLen KeyLen HasKey NumExt Type2 Type1 Type0
+	 *
+	 * 各位含义：
+	 * - bit0-2 : 节点类型
+	 *            000=Unknown, 001=Null, 010=Bool, 011=Number,
+	 *            100=String, 101=Array, 110=Object, 111=Reserved
+	 *
+	 * - bit3   : 扩展位
+	 *            Bool 类型：0=false, 1=true
+	 *            Number 类型：0=int, 1=double
+	 *
+	 * - bit4   : 是否包含 Key
+	 *            0=无 Key（数组元素）
+	 *            1=有 Key（对象成员）
+	 *
+	 * - bit5-6 : Key 长度字段字节数
+	 *            00=1字节 (≤255)
+	 *            01=2字节 (≤65535)
+	 *            10=3字节 (≤16M)
+	 *            11=4字节 (≤UINT32_MAX)
+	 *
+	 * - bit7   : 保留位（未来可用于压缩标记、特殊类型等）
+	 */
+
+	/*
+	 * flag 后若节点包含 key / strValue，则跟随一个指针，
+	 * 指向存储区：[ keyLen | key | stringValue ]
+	 * 其中 keyLen 的大小由 flag 中的长度信息决定（最多 4 字节）。
+	 *
+	 * 在指针之后，根据节点类型存储具体数据：
+	 * - null / bool : 由 flag 表示
+	 * - string      : 由上述指针指向
+	 * - number      : 根据 flag 决定存储 int(4字节) 或 double(8字节)
+	 * - object      : 动态分配空间存储子节点，链表结构如下：
+	 *
+	 *   {
+	 *       "name": "RyanJson",
+	 *   next (
+	 *       "version": "xxx",
+	 *   next (
+	 *       "repository": "https://github.com/Ryan-CW-Code/RyanJson",
+	 *   next (
+	 *       "keywords": ["json", "streamlined", "parser"],
+	 *   next (
+	 *       "others": { ... }
+	 *   )))
+	 *   }
+	 */
+
+	/*
+	 * 设计特点：
+	 * - 一个 Json 节点最多 malloc 两次（一次节点本身，一次可选的 key/stringValue），
+	 *   对嵌入式系统非常友好，减少 malloc 头部开销, 尽可能的减少内存碎片。
+	 *
+	 * - key 和 stringValue 必须通过指针管理：
+	 *   * 如果直接放在节点里，虽然只需一次 malloc，
+	 *     但修改场景会遇到替换/释放困难。
+	 *   * 用户可能传递的 Json 对象不是指针，无法直接替换节点，
+	 *     要求应用层传递指针会增加侵入性，不符合“应用层无需修改”的目标。
+	 *
+	 * - 因此采用指针方式，保证灵活性和低侵入性。
+	 */
 };
 
 typedef struct RyanJsonNode *RyanJson_t;
 ```
 
-**此结构体包含两个固定成员 info 和 next；**
+### 3、测试体系
 
-**info**：为当前节点的配置信息用来表示 节点数据类型 和 flag标志位。
+**LLVM模糊测试**（核心亮点），模糊测试是 RyanJson 的 **核心稳定性保障**。
 
-```
-bits  low --> high
----------------------------------------------------------------------
-| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | NA | NA | .......
----------------------------------------------------------------------
-\______________________________/  |   |   |
-             low 8bits            |   |   |
-                |                 |   |   |
-                V                 |   |   |
-   RyanJsonTypeUnknow    (bit0)   |   |   |
-   RyanJsonTypeNull      (bit1)   |   |   |
-   RyanJsonTypeBool      (bit2)   |   |   +----> RyanJsonWithKeyFlag            (1 << 10)
-   RyanJsonTypeNumber    (bit3)   |   |
-   RyanJsonTypeString    (bit4)   |   +--------> RyanJsonValueNumberIntFlag     (1 << 9)
-   RyanJsonTypeArray     (bit5)   |
-   RyanJsonTypeObject    (bit6)   +------------> RyanJsonValueBoolTrueFlag      (1 << 8)
-   spare                 (bit7)
-```
+**[点击在线查看覆盖率信息](https://ryan-cw-code.github.io/RyanJson/)** 
 
-**next**：指针指向链表下一个节点
+- **千万级测试样本**：[LLVM Fuzzer](https://llvm.org/docs/LibFuzzer.html)  自动生成并执行上亿级随机与非法 JSON 输入。
+- **覆盖率极高**：分支覆盖率 **99.9%**，无崩溃、无泄漏。
+- **鲁棒性验证**：内存申请失败、扩容失败、非法转义字符、尾随逗号、嵌套过深、随机类型切换。
+- **内存安全验证**：结合 Sanitizer 工具链，确保无泄漏、无悬空指针、无越界。
 
-```
-{
-      "name": "RyanJson",
-next (
-      "version": "xxx",
-next (
-      "repository": "https://github.com/Ryan-CW-Code/RyanJson",
-next (
-      "keywords": ["json", "streamlined", "parser"],
-next (      \__item__/  \__next__/    \__next__/
-      "others": {
-            ...
-      }
-}
-```
+| 测试类别                              | 测试目标                 |
+| ------------------------------------- | ------------------------ |
+| 内存故障测试                          | 验证内存不足时的健壮性   |
+| 解析 Json 节点测试                    | 随机非法/合法输入解析    |
+| 循环遍历删除节点测试                  | 确保链表删除安全性       |
+| 循环遍历分离节点测试                  | 验证节点分离逻辑正确性   |
+| Json 压缩去除转义测试                 | 检查转义字符处理健壮性   |
+| Json 打印和解析测试                   | 序列化与反序列化一致性   |
+| 循环遍历获取 Value 测试               | 确保随机访问稳定性       |
+| 循环遍历随机复制 Json 节点测试        | 验证深拷贝与浅拷贝安全性 |
+| 循环遍历随机修改节点类型/创建节点测试 | 动态扩展与类型切换能力   |
+
+#### 📊 手写的专项基础测试用例
+
+| 测试类别             | 测试目标                    |
+| -------------------- | --------------------------- |
+| 文本解析 Json 测试   | 基础解析与加载能力验证      |
+| 创建 Json 节点树测试 | 节点生成与结构正确性检查    |
+| 修改 Json 节点测试   | 字段修改的条件覆盖与正确性  |
+| 删除 Json 节点测试   | 各类删除场景与边界条件验证  |
+| 分离 Json 节点测试   | 节点分离与引用关系稳定性    |
+| 替换 Json 节点测试   | 节点替换行为与一致性验证    |
+| 比较 Json 节点测试   | 节点比较与等价性一致性      |
+| 复制 Json 节点测试   | 深拷贝/浅拷贝的语义与完整性 |
+| Json 循环测试        | 遍历性能与迭代稳定性        |
+
+### 4、代码质量与规范
+
+#### ✅ 工具链全面集成
+
+| 工具                                                         | 用途                                                         |
+| ------------------------------------------------------------ | ------------------------------------------------------------ |
+| **[Sanitizer](https://clang.llvm.org/docs/index.html#sanitizers)** | 运行时捕获内存与线程安全问题                                 |
+| **[clang-tidy](https://clang.llvm.org/extra/clang-tidy/#clang-tidy)** | 静态分析潜在缺陷（空指针、资源泄漏等）                       |
+| **[Cppcheck](https://cppcheck.sourceforge.io/)**             | 深度扫描内存与资源问题                                       |
+| **[ClangFormat](https://clang.llvm.org/docs/ClangFormat.html)** | 统一代码风格                                                 |
+| **编译器警告**                                               | `-Wall -Wextra`（默认）、`-Weffc++`/`-Weverything`（Clang 可选，CI 强化时开启） |
+
+#### ✅ 检查重点覆盖
+
+- 内存安全：杜绝泄漏、越界、悬空指针
+- 性能优化：减少冗余拷贝与低效算法
+- 可读性：命名规范、注释完整、逻辑清晰
 
-**此结构体还包括两个可能动态创建的成员 key 和 value；**
+> ✅ **成果**：实现接近语法级"**零缺陷**"，长期维护成本大幅降低
 
-**key**：存储JSON键值对的 key 信息，当存在key时会在申请RyanJsonNode内存时动态添加。
 
-**value**：存储JSON键值对的 value 信息，会根据不同节点类型创建不同的value值。会在申请RyanJsonNode内存时动态添加。
 
-## 3、测试
+### 5、示例
 
 *测试代码和示例代码可在本项目根目录`RyanJsonExample`文件夹查看。*
 
@@ -102,31 +188,150 @@ next (      \__item__/  \__next__/    \__next__/
 
 
 #### 内存占用测试
-*此测试结果为(2023.08.22)时测试，测试代码可在本项目根目录`RyanJsonExample`文件夹查看。新版本内存占用更低!*
-![image-20230822200726742](docs/assert/README.assert/image-20230822200726742.png)
+*(20251222 linux平台，**不考虑malloc头部空间)**测试代码可在本项目根目录`RyanJsonExample`文件夹查看。新版本内存占用更低!*
 
+```
+*****************************************************************************
+*************************** RyanJson / cJSON / yyjson 内存对比程序 **************************
+*****************************************************************************
+
+--------------------------- 混合类型json数据测试 --------------------------
+json原始文本长度为 2265, 序列化后RyanJson内存占用: 3613, cJSON内存占用: 9160, yyjson内存占用: 8692
+比cJSON节省: 60.56% 内存占用, 比yyjson节省: 58.43% 内存占用
+
+--------------------------- 对象占多json数据测试 --------------------------
+json原始文本长度为 3991, 序列化后RyanJson内存占用: 5436, cJSON内存占用: 11633, yyjson内存占用: 12640
+比cJSON节省: 53.27% 内存占用, 比yyjson节省: 56.99% 内存占用
+
+--------------------------- 数组占多json数据测试 --------------------------
+json原始文本长度为 1205, 序列化后RyanJson内存占用: 2365, cJSON内存占用: 7340, yyjson内存占用: 5028
+比cJSON节省: 67.78% 内存占用, 比yyjson节省: 52.96% 内存占用
+
+--------------------------- 小对象json 混合类型内存占用测试 --------------------------
+json原始文本长度为 90, 序列化后RyanJson内存占用: 131, cJSON内存占用: 309, yyjson内存占用: 636
+比cJSON节省: 57.61% 内存占用, 比yyjson节省: 79.40% 内存占用
+
+--------------------------- 小对象json 纯字符串内存占用测试 --------------------------
+json原始文本长度为 100, 序列化后RyanJson内存占用: 144, cJSON内存占用: 339, yyjson内存占用: 636
+比cJSON节省: 57.52% 内存占用, 比yyjson节省: 77.36% 内存占用
+```
+
+RT-Thread平台考虑malloc**头部空间12字节**情况下，嵌入式平台下占用最高的反而是malloc的内存头开销，所以建议用户优先选择malloc头部空间小的heap管理算法
 
+```
+*****************************************************************************
+*************************** RyanJson / cJSON / yyjson 内存对比程序 **************************
+*****************************************************************************
+
+--------------------------- 混合类型json数据测试 --------------------------
+json原始文本长度为 2265, 序列化后RyanJson内存占用: 7993, cJSON内存占用: 13732, yyjson内存占用: 8752
+比cJSON节省: 41.79% 内存占用, 比yyjson节省: 8.67% 内存占用
+
+--------------------------- 对象占多json数据测试 --------------------------
+json原始文本长度为 3991, 序列化后RyanJson内存占用: 10668, cJSON内存占用: 19109, yyjson内存占用: 12712
+比cJSON节省: 44.17% 内存占用, 比yyjson节省: 16.08% 内存占用
+
+--------------------------- 数组占多json数据测试 --------------------------
+json原始文本长度为 1205, 序列化后RyanJson内存占用: 5449, cJSON内存占用: 10424, yyjson内存占用: 5076
+比cJSON节省: 47.73% 内存占用, 比yyjson节省: -7.35% 内存占用
 
-#### RFC 8295 标准测试，大部分嵌入式场景不会出现复杂的特殊json结构
+--------------------------- 小对象json 混合类型内存占用测试 --------------------------
+json原始文本长度为 90, 序列化后RyanJson内存占用: 287, cJSON内存占用: 477, yyjson内存占用: 672
+比cJSON节省: 39.83% 内存占用, 比yyjson节省: 57.29% 内存占用
+
+--------------------------- 小对象json 纯字符串内存占用测试 --------------------------
+json原始文本长度为 100, 序列化后RyanJson内存占用: 300, cJSON内存占用: 567, yyjson内存占用: 672
+比cJSON节省: 47.09% 内存占用, 比yyjson节省: 55.36% 内存占用
+```
 
-***RyanJson和cJSON都不适合处理复杂的UTF-16字符集，如果项目需要兼容Unicode字符集，可以考虑yyjson / json-c***
 
-![image-20230822200717809](docs/assert/README.assert/image-20230822200717809.png)
 
-## 4、局限性
+RFC 8259 标准测试，大部分嵌入式场景不会出现极为特殊的Unicode字符集
 
-- 使用int / double表示json中的number类型，**精度有所丢失**。建议64位的number类型最好用string字符串表示。
-- **对象中允许有重复的key**，RyanJson库采用单向链表，会访问到第一个对象。
+***如果项目需要完全兼容Unicode字符集，可以考虑yyjson / json-c***
 
-## 5、文档
+```
+*****************************************************************************
+*************************** RyanJson / cJSON / yyjson RFC8259标准测试 **************************
+*****************************************************************************
+开始 RFC 8259 JSON 测试
+--------------------------- RFC8259  RyanJson --------------------------
+1 数据不完全一致 -- 原始: {"min":-1.0e+28,"max":1.0e+28} -- 序列化: {"min":-9999999999999999583119736832.0,"max":9999999999999999583119736832.0}
+2 数据不完全一致 -- 原始: [123e65] -- 序列化: [12300000.0]
+应该失败，但是成功: 123, len: 4
+3 数据不完全一致 -- 原始: [-123123e100000] -- 序列化: [-123123.0]
+4 数据不完全一致 -- 原始: {"foo\u0000bar":42} -- 序列化: {"foo":42}
+5 数据不完全一致 -- 原始: [1E22] -- 序列化: [100.0]
+6 数据不完全一致 -- 原始: [1eE2] -- 序列化: [100.0]
+应该失败，但是成功: [1eE2], len: 6
+应该成功，但是失败: [20e1], len: 6
+7 数据不完全一致 -- 原始: [123e45] -- 序列化: [12300000.0]
+8 数据不完全一致 -- 原始: ["\u0000"] -- 序列化: [""]
+9 数据不完全一致 -- 原始: [123123e100000] -- 序列化: [123123.0]
+应该成功，但是失败: [0e1], len: 5
+10 数据不完全一致 -- 原始: [123.456e78] -- 序列化: [12345600000.0]
+11 数据不完全一致 -- 原始: [-0.000000000000000000000000000000000000000000000000000000000000000000000000000001] -- 序列化: [-1.000000e-78]
+12 数据不完全一致 -- 原始: {"title":"\u041f\u043e\u043b\u0442\u043e\u0440\u0430 \u0417\u0435\u043c\u043b\u0435\u043a\u043e\u043f\u0430"} -- 序列化: {"title":"Полтора Землекопа"}
+RFC 8259 JSON: (318/322)
+
+--------------------------- RFC8259  cJSON --------------------------
+应该失败，但是成功: [1.], len: 4
+1 数据不完全一致 -- 原始: {"min":-1.0e+28,"max":1.0e+28} -- 序列化: {"min":-1e+28,"max":1e+28}
+2 数据不完全一致 -- 原始: [
+                           ] -- 序列化: []
+应该失败，但是成功: [
+                     ], len: 3
+3 数据不完全一致 -- 原始: ["\uqqqq"] -- 序列化: [""]
+应该失败，但是成功: ["\uqqqq"], len: 10
+应该失败，但是成功: [2.e-3], len: 7
+应该失败，但是成功: [-2.], len: 5
+应该失败，但是成功: [-.123], len: 7
+应该失败，但是成功: 123, len: 4
+4 数据不完全一致 -- 原始: [-123123e100000] -- 序列化: [null]
+5 数据不完全一致 -- 原始: [-1e+9999] -- 序列化: [null]
+6 数据不完全一致 -- 原始: {"foo\u0000bar":42} -- 序列化: {"foo":42}
+应该失败，但是成功: [2.e+3], len: 7
+应该失败，但是成功: [0.e1], len: 6
+7 数据不完全一致 -- 原始:  -- 序列化: [""]
+8 数据不完全一致 -- 原始: [0.4e00669999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999969999999006] -- 序列化: [null]
+9 数据不完全一致 -- 原始: ["\u0000"] -- 序列化: [""]
+10 数据不完全一致 -- 原始: {} -- 序列化: {}
+11 数据不完全一致 -- 原始: ["a -- 序列化: ["a"]
+应该失败，但是成功: ["a, len: 7
+应该失败，但是成功: [-012], len: 6
+12 数据不完全一致 -- 原始: [ -- 序列化: []
+应该失败，但是成功: [, len: 3
+应该失败，但是成功: [012], len: 5
+应该失败，但是成功: ["new
+line"], len: 12
+13 数据不完全一致 -- 原始: [ -- 序列化: [""]
+应该失败，但是成功: ["  "], len: 5
+14 数据不完全一致 -- 原始: [1.5e+9999] -- 序列化: [null]
+应该失败，但是成功: [-01], len: 5
+15 数据不完全一致 -- 原始: [123123e100000] -- 序列化: [null]
+16 数据不完全一致 -- 原始: [-0.000000000000000000000000000000000000000000000000000000000000000000000000000001] -- 序列化: [-1e-78]
+17 数据不完全一致 -- 原始: {"title":"\u041f\u043e\u043b\u0442\u043e\u0440\u0430 \u0417\u0435\u043c\u043b\u0435\u043a\u043e\u043f\u0430"} -- 序列化: {"title":"Полтора Землекопа"}
+应该失败，但是成功: [2.e3], len: 6
+RFC 8259 JSON: (305/322)
+
+--------------------------- RFC8259  yyjson --------------------------
+1 数据不完全一致 -- 原始: {"min":-1.0e+28,"max":1.0e+28} -- 序列化: {"min":-1e28,"max":1e28}
+2 数据不完全一致 -- 原始: [-0.000000000000000000000000000000000000000000000000000000000000000000000000000001] -- 序列化: [-1e-78]
+3 数据不完全一致 -- 原始: {"title":"\u041f\u043e\u043b\u0442\u043e\u0440\u0430 \u0417\u0435\u043c\u043b\u0435\u043a\u043e\u043f\u0430"} -- 序列化: {"title":"Полтора Землекопа"}
+RFC 8259 JSON: (322/322)
+|||----------->>> area = 0, size = 0
+```
 
-文档可在 [Ryan文档中心](https://ryan-cw-code.github.io/RyanDocs/)获取
+### 6、局限性
 
-## 6、联系
+- 使用`int / double`表示 JSON number 类型，**可能存在精度丢失**。建议 64 位数值用字符串表示。
+- **对象中允许有重复的key**，RyanJson库采用**单向链表**，链表结构会返回第一个匹配项。
 
-Email：1831931681@qq.com
+### 7、文档
 
-wx：17513216936
+📂 示例代码：`RyanJsonExample` 文件夹
 
+📖 文档中心：RyanDocs
 
+📧 联系方式：1831931681@qq.com
 

RyanJson/RyanJson.h

@@ -1,4 +1,3 @@
-
 #ifndef __RyanJson__
 #define __RyanJson__
 
@@ -6,176 +5,265 @@
 extern "C" {
 #endif
 
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdint.h>
-#include <string.h>
-#include <stdarg.h>
-#include <limits.h>
-#include <float.h>
-#include <math.h>
-#include <inttypes.h>
-
-#define RyanMqttMemset  memset
-#define RyanMqttMemcpy  memcpy
-#define RyanMqttStrlen  strlen
-#define RyanMqttStrncmp strncmp
-#define RyanMqttStrcmp  strcmp
-#define RyanMqttSprintf sprintf
+#include "RyanJsonConfig.h"
 
-typedef enum
-{
-	// 类型标志 占用8字节,剩余一个备用
-	RyanJsonTypeUnknow = 1 << 0,
-	RyanJsonTypeNull = 1 << 1,
-	RyanJsonTypeBool = 1 << 2,
-	RyanJsonTypeNumber = 1 << 3,
-	RyanJsonTypeString = 1 << 4,
-	RyanJsonTypeArray = 1 << 5,
-	RyanJsonTypeObject = 1 << 6,
-} RyanjsonType_e;
+/**
+ * @brief Json 错误处理块
+ *
+ */
+#define RyanJsonCheckCodeNoReturn(EX, code)                                                                                                \
+	if (!(EX))                                                                                                                         \
+	{                                                                                                                                  \
+		jsonLog("\r\n%s:%d Check failed: %s\n", __FILE__, __LINE__, #EX);                                                          \
+		code                                                                                                                       \
+	}
+
+#define RyanJsonCheckCode(EX, code) RyanJsonCheckCodeNoReturn(EX, code)
+
+#define RyanJsonCheckReturnFalse(EX) RyanJsonCheckCode(EX, return RyanJsonFalse;)
+#define RyanJsonCheckReturnNull(EX)  RyanJsonCheckCode(EX, return NULL;)
+#ifdef RyanJsonEnableAssert
+#define RyanJsonCheckAssert(EX) RyanJsonCheckCode(EX, RyanJsonAssert(NULL && "RyanJsonCheckAssert");)
+#else
+#define RyanJsonCheckAssert(EX) (void)(EX)
+#endif
 
-typedef enum
+// Json 的最基础节点，所有 Json 元素都由该节点表示。
+// 结构体中仅包含固定的 next 指针，用于单向链表串联。
+// 其余数据（flag、key、stringValue、numberValue、doubleValue 等）均通过动态内存分配管理。
+struct RyanJsonNode
 {
-	// flag标志
-	RyanJsonValueBoolTrueFlag = 1 << 8,
-	RyanJsonValueNumberIntFlag = 1 << 9,
-	RyanJsonWithKeyFlag = 1 << 10
-} RyanJsonInfoFlag_e;
+	struct RyanJsonNode *next; // 单链表节点指针
+
+	/*
+	 * 在 next 后紧跟一个字节的 flag，用于描述节点的核心信息：
+	 *
+	 * 位分布如下：
+	 * bit7   bit6   bit5   bit4   bit3   bit2   bit1   bit0
+	 * -----------------------------------------------------
+	 * 保留   KeyLen KeyLen HasKey NumExt Type2 Type1 Type0
+	 *
+	 * 各位含义：
+	 * - bit0-2 : 节点类型
+	 *            000=Unknown, 001=Null, 010=Bool, 011=Number,
+	 *            100=String, 101=Array, 110=Object, 111=Reserved
+	 *
+	 * - bit3   : 扩展位
+	 *            Bool 类型：0=false, 1=true
+	 *            Number 类型：0=int, 1=double
+	 *
+	 * - bit4   : 是否包含 Key
+	 *            0=无 Key（数组元素）
+	 *            1=有 Key（对象成员）
+	 *
+	 * - bit5-6 : Key 长度字段字节数
+	 *            00=1字节 (≤255)
+	 *            01=2字节 (≤65535)
+	 *            10=3字节 (≤16M)
+	 *            11=4字节 (≤UINT32_MAX)
+	 *
+	 * - bit7   : 保留位（未来可用于压缩标记、特殊类型等）
+	 */
+
+	/*
+	 * flag 后若节点包含 key / strValue，则跟随一个指针，
+	 * 指向存储区：[ keyLen | key | stringValue ]
+	 * 其中 keyLen 的大小由 flag 中的长度信息决定（最多 4 字节）。
+	 *
+	 * 在指针之后，根据节点类型存储具体数据：
+	 * - null / bool : 由 flag 表示
+	 * - string      : 由上述指针指向
+	 * - number      : 根据 flag 决定存储 int(4字节) 或 double(8字节)
+	 * - object      : 动态分配空间存储子节点，链表结构如下：
+	 *
+	 *   {
+	 *       "name": "RyanJson",
+	 *   next (
+	 *       "version": "xxx",
+	 *   next (
+	 *       "repository": "https://github.com/Ryan-CW-Code/RyanJson",
+	 *   next (
+	 *       "keywords": ["json", "streamlined", "parser"],
+	 *   next (
+	 *       "others": { ... }
+	 *   )))
+	 *   }
+	 */
+
+	/*
+	 * 设计特点：
+	 * - 一个 Json 节点最多 malloc 两次（一次节点本身，一次可选的 key/stringValue），
+	 *   对嵌入式系统非常友好，减少 malloc 头部开销, 尽可能的减少内存碎片。
+	 *
+	 * - key 和 stringValue 必须通过指针管理：
+	 *   * 如果直接放在节点里，虽然只需一次 malloc，
+	 *     但修改场景会遇到替换/释放困难。
+	 *   * 用户可能传递的 Json 对象不是指针，无法直接替换节点，
+	 *     要求应用层传递指针会增加侵入性，不符合“应用层无需修改”的目标。
+	 *
+	 * - 因此采用指针方式，保证灵活性和低侵入性。
+	 */
+};
+
+typedef struct RyanJsonNode *RyanJson_t;
 
 typedef enum
 {
-	RyanJsonFalse = 0,
-	RyanJsonTrue = 1
-} RyanJsonBool_e;
+	// 类型标志 占用8字节,剩余一个备用
+	RyanJsonTypeNull = 1,
+	RyanJsonTypeBool = 2,
+	RyanJsonTypeNumber = 3,
+	RyanJsonTypeString = 4,
+	RyanJsonTypeArray = 5,
+	RyanJsonTypeObject = 6,
+} RyanjsonType_e;
+
+#define RyanJsonFalse (false)
+#define RyanJsonTrue  (true)
 
 // !兼容之前的类型定义
+typedef bool RyanJsonBool_e;
 typedef RyanJsonBool_e RyanJsonBool;
 
-struct RyanJsonNode
-{
-	uint32_t info;             // 包含类型，key等标志
-	struct RyanJsonNode *next; // 单链表node节点
-
-	// [char *key] 有key的json节点, 会动态创建指针
-
-	// 有value值的节点, 会动态创建指针
-	// [int32_t value / double value / char* value / RyanJson_t item]
-};
-
-typedef struct RyanJsonNode *RyanJson_t;
-
 // 内存钩子函数
-typedef void *(*malloc_t)(size_t size);
-typedef void (*free_t)(void *block);
-typedef void *(*realloc_t)(void *block, size_t size);
-
-// 限制解析数组/对象中嵌套的深度
-// RyanJson使用递归 序列化/反序列化 json
-// 请根据单片机资源合理设置以防止堆栈溢出。
-#ifndef RyanJsonNestingLimit
-#define RyanJsonNestingLimit 30000
-#endif
-
-// 当 RyanJsonPrint 剩余缓冲空间不足时申请的空间大小
-#define RyanJsonPrintfPreAlloSize (64)
+typedef void *(*RyanJsonMalloc_t)(size_t size);
+typedef void (*RyanJsonFree_t)(void *block);
+typedef void *(*RyanJsonRealloc_t)(void *block, size_t size);
 
 /**
- * @brief 较底层接口, 不推荐用户使用，除非用户知道这些接口意义
+ * !!! 较底层接口, 不推荐用户使用，除非用户知道这些接口意义
+ * !!! 一定要看这里，这里的接口不推荐使用
  */
-#define RyanJsonGetInfo(pJson) ((pJson) ? ((pJson)->info) : 0)
-// NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
-#define RyanJsonGetType(pJson) ((RyanjsonType_e)((uint8_t)RyanJsonGetInfo(pJson)))
-extern RyanJsonBool_e RyanJsonInsert(RyanJson_t pJson, int32_t index, RyanJson_t item);
+#define RyanJsonGetMask(bits)                           (((1U << (bits)) - 1))
+#define RyanJsonGetPayloadPtr(pJson)                    ((uint8_t *)(pJson) + sizeof(struct RyanJsonNode))
+#define RyanJsonGetPayloadFlagField(pJson, shift, mask) (((*RyanJsonGetPayloadPtr(pJson)) >> (shift)) & (mask))
+#define RyanJsonSetPayloadFlagField(pJson, shift, mask, value)                                                                             \
+	((*RyanJsonGetPayloadPtr(pJson)) =                                                                                                 \
+		 ((*RyanJsonGetPayloadPtr(pJson)) & ~((mask) << (shift))) | ((uint8_t)(((value) & (mask)) << (shift))))
+
+#define RyanJsonGetType(pJson)       ((RyanjsonType_e)RyanJsonGetPayloadFlagField((pJson), 0, RyanJsonGetMask(3)))
+#define RyanJsonSetType(pJson, type) (RyanJsonSetPayloadFlagField((pJson), 0, RyanJsonGetMask(3), (RyanjsonType_e)(type)))
+
+// bool跟number用一个字段，因为bool和number类型不会同时存在
+#define RyanJsonGetPayloadBoolValueByFlag(pJson)             RyanJsonGetPayloadFlagField((pJson), 3, RyanJsonGetMask(1))
+#define RyanJsonSetPayloadBoolValueByFlag(pJson, value)      RyanJsonSetPayloadFlagField((pJson), 3, RyanJsonGetMask(1), (value))
+#define RyanJsonGetPayloadNumberIsDoubleByFlag(pJson)        RyanJsonGetPayloadFlagField((pJson), 3, RyanJsonGetMask(1))
+#define RyanJsonSetPayloadNumberIsDoubleByFlag(pJson, value) RyanJsonSetPayloadFlagField((pJson), 3, RyanJsonGetMask(1), (value))
+
+#define RyanJsonGetPayloadWhiteKeyByFlag(pJson)        RyanJsonGetPayloadFlagField((pJson), 4, RyanJsonGetMask(1))
+#define RyanJsonSetPayloadWhiteKeyByFlag(pJson, value) RyanJsonSetPayloadFlagField((pJson), 4, RyanJsonGetMask(1), (value))
+
+// ! 使用超过8字节后一定要注意 RyanJsonSetPayloadFlagField 目前限制uint8_t类型
+// flag空间不够的时候可以把这个字段弃用，用redis的listpack方法将key和keyLen一起表示，内存占用也挺好，但是复杂度高，有空间就保持现在这样
+#define RyanJsonGetPayloadEncodeKeyLenByFlag(pJson)        ((uint8_t)RyanJsonGetPayloadFlagField((pJson), 5, RyanJsonGetMask(2)) + 1)
+#define RyanJsonSetPayloadEncodeKeyLenByFlag(pJson, value) RyanJsonSetPayloadFlagField((pJson), 5, RyanJsonGetMask(2), (value))
+extern RyanJsonBool_e RyanJsonInsert(RyanJson_t pJson, uint32_t index, RyanJson_t item);
 extern void *RyanJsonGetValue(RyanJson_t pJson);
-extern RyanJson_t RyanJsonGetObjectByIndexs(RyanJson_t pJson, int32_t index, ...);
-extern RyanJson_t RyanJsonGetObjectByKeys(RyanJson_t pJson, char *key, ...);
-extern RyanJsonBool_e RyanJsonReapplyString(char **dst, const char *src);
-extern RyanJson_t RyanJsonCreateItem(const char *key, RyanJson_t item);
+extern RyanJson_t RyanJsonCreateItem(const char *key, RyanJson_t item); // 需用户释放内存
+/**
+ * !!!上面的接口不推荐使用
+ *
+ */
 
 /**
  * @brief json对象函数
  */
-extern RyanJsonBool_e RyanJsonInitHooks(malloc_t _malloc, free_t _free, realloc_t _realloc);
-extern RyanJson_t RyanJsonParseOptions(const char *text, uint32_t size, RyanJsonBool_e mustBeNullTerminated, const char **parseEndPtr); // 需用户释放内存
-#define RyanJsonParse(text) RyanJsonParseOptions(text, strlen(text), RyanJsonFalse, NULL)                                               // 需用户释放内存
+extern RyanJsonBool_e RyanJsonInitHooks(RyanJsonMalloc_t _malloc, RyanJsonFree_t _free, RyanJsonRealloc_t _realloc);
+extern RyanJson_t RyanJsonParseOptions(const char *text, uint32_t size, RyanJsonBool_e requireNullTerminator,
+				       const char **parseEndPtr);                                             // 需用户释放内存
+#define RyanJsonParse(text) RyanJsonParseOptions((text), (uint32_t)RyanJsonStrlen(text), RyanJsonFalse, NULL) // 需用户释放内存
+extern void RyanJsonDelete(RyanJson_t pJson);
+extern void RyanJsonFree(void *block);
 
+/**
+ * @brief 打印json对象函数
+ */
 extern char *RyanJsonPrint(RyanJson_t pJson, uint32_t preset, RyanJsonBool_e format, uint32_t *len); // 需用户释放内存
 extern char *RyanJsonPrintPreallocated(RyanJson_t pJson, char *buffer, uint32_t length, RyanJsonBool_e format, uint32_t *len);
 
+/**
+ * @brief json杂项函数
+ */
 extern RyanJson_t RyanJsonDuplicate(RyanJson_t pJson); // 需用户释放内存
-extern uint32_t RyanJsonGetSize(RyanJson_t pJson);     // 获取Json中子项个数
-extern void RyanJsonMinify(char *text);
-
-extern void RyanJsonDelete(RyanJson_t pJson);
-extern void RyanJsonFree(void *block);
-
-extern RyanJsonBool_e RyanJsonCompare(RyanJson_t a, RyanJson_t b);
-extern RyanJsonBool_e RyanJsonCompareOnlyKey(RyanJson_t a, RyanJson_t b);
+extern uint32_t RyanJsonMinify(char *text, int32_t textLen);
+extern RyanJsonBool_e RyanJsonCompare(RyanJson_t leftJson, RyanJson_t rightJson);
+extern uint32_t RyanJsonGetSize(RyanJson_t pJson);
+#define RyanJsonGetArraySize(pJson) RyanJsonGetSize(pJson)
 
 /**
- * @brief 添加 / 删除相关函数
+ * @brief 添加相关函数
  */
-extern RyanJson_t RyanJsonCreateObject(void);                            // 如果没有添加到父json, 则需释放内存
-extern RyanJson_t RyanJsonCreateNull(char *key);                         // 如果没有添加到父json, 则需释放内存
-extern RyanJson_t RyanJsonCreateBool(char *key, RyanJsonBool_e boolean); // 如果没有添加到父json, 则需释放内存
-extern RyanJson_t RyanJsonCreateInt(char *key, int32_t number);          // 如果没有添加到父json, 则需释放内存
-extern RyanJson_t RyanJsonCreateDouble(char *key, double number);        // 如果没有添加到父json, 则需释放内存
-extern RyanJson_t RyanJsonCreateString(char *key, const char *string);   // 如果没有添加到父json, 则需释放内存
+extern RyanJson_t RyanJsonCreateObject(void);                                  // 如果没有添加到父json, 则需释放内存
+extern RyanJson_t RyanJsonCreateNull(const char *key);                         // 如果没有添加到父json, 则需释放内存
+extern RyanJson_t RyanJsonCreateBool(const char *key, RyanJsonBool_e boolean); // 如果没有添加到父json, 则需释放内存
+extern RyanJson_t RyanJsonCreateInt(const char *key, int32_t number);          // 如果没有添加到父json, 则需释放内存
+extern RyanJson_t RyanJsonCreateDouble(const char *key, double number);        // 如果没有添加到父json, 则需释放内存
+extern RyanJson_t RyanJsonCreateString(const char *key, const char *string);   // 如果没有添加到父json, 则需释放内存
+extern RyanJson_t RyanJsonCreateArray(void);                                   // 如果没有添加到父json, 则需释放内存
 
-extern RyanJson_t RyanJsonCreateArray(void);                                       // 如果没有添加到父json, 则需释放内存
-extern RyanJson_t RyanJsonCreateIntArray(const int32_t *numbers, int32_t count);   // 语法糖，根据传入的numbers数组创建一个int类型的数组。如果没有添加到父json, 则需释放内存
-extern RyanJson_t RyanJsonCreateDoubleArray(const double *numbers, int32_t count); // 语法糖，根据传入的numbers数组创建一个double类型的数组。如果没有添加到父json, 则需释放内存
-extern RyanJson_t RyanJsonCreateStringArray(const char **strings, int32_t count);  // 语法糖，根据传入的strings数组创建一个string类型的数组。如果没有添加到父json, 则需释放内存
+/**
+ * @brief 分离相关函数
+ */
+extern RyanJson_t RyanJsonDetachByIndex(RyanJson_t pJson, uint32_t index); // 需用户释放内存
+extern RyanJson_t RyanJsonDetachByKey(RyanJson_t pJson, const char *key);  // 需用户释放内存
 
-extern RyanJson_t RyanJsonDetachByIndex(RyanJson_t pJson, int32_t index); // 需用户释放内存
-extern RyanJson_t RyanJsonDetachByKey(RyanJson_t pJson, const char *key); // 需用户释放内存
-extern RyanJsonBool_e RyanJsonDeleteByIndex(RyanJson_t pJson, int32_t index);
+/**
+ * @brief 删除相关函数
+ */
+extern RyanJsonBool_e RyanJsonDeleteByIndex(RyanJson_t pJson, uint32_t index);
 extern RyanJsonBool_e RyanJsonDeleteByKey(RyanJson_t pJson, const char *key);
 
 /**
  * @brief 查询函数
  */
 extern RyanJson_t RyanJsonGetObjectByKey(RyanJson_t pJson, const char *key);
-extern RyanJson_t RyanJsonGetObjectByIndex(RyanJson_t pJson, int32_t index);
-#define RyanJsonGetObjectToKey(pJson, key, ...)     RyanJsonGetObjectByKeys(pJson, key, ##__VA_ARGS__, NULL)
-#define RyanJsonGetObjectToIndex(pJson, index, ...) RyanJsonGetObjectByIndexs(pJson, index, ##__VA_ARGS__, INT_MIN)
-
-#define RyanJsonHasObjectByKey(pJson, key)        (RyanJsonGetObjectByKey(pJson, key) ? RyanJsonTrue : RyanJsonFalse)
-#define RyanJsonHasObjectByIndex(pJson, key)      (RyanJsonGetObjectByIndex(pJson, index) ? RyanJsonTrue : RyanJsonFalse)
-#define RyanJsonHasObjectToKey(pJson, key, ...)   (RyanJsonGetObjectByKeys(pJson, key, ##__VA_ARGS__, NULL) ? RyanJsonTrue : RyanJsonFalse)
-#define RyanJsonHasObjectToIndex(pJson, key, ...) (RyanJsonGetObjectByIndexs(pJson, index, ##__VA_ARGS__, INT_MIN) ? RyanJsonTrue : RyanJsonFalse)
-
-#define returnJsonBool(ex)      ((ex) ? RyanJsonTrue : RyanJsonFalse)
-#define RyanJsonIsKey(pJson)    returnJsonBool(RyanJsonGetInfo(pJson) & RyanJsonWithKeyFlag)
-#define RyanJsonIsNull(pJson)   returnJsonBool(RyanJsonGetType(pJson) & RyanJsonTypeNull)
-#define RyanJsonIsBool(pJson)   returnJsonBool(RyanJsonGetType(pJson) & RyanJsonTypeBool)
-#define RyanJsonIsNumber(pJson) returnJsonBool(RyanJsonGetType(pJson) & RyanJsonTypeNumber)
-#define RyanJsonIsInt(pJson)    returnJsonBool(RyanJsonIsNumber(pJson) && (RyanJsonGetInfo(pJson) & RyanJsonValueNumberIntFlag))
-#define RyanJsonIsDouble(pJson) returnJsonBool(RyanJsonIsNumber(pJson) && !(RyanJsonGetInfo(pJson) & RyanJsonValueNumberIntFlag))
-#define RyanJsonIsString(pJson) returnJsonBool(RyanJsonGetType(pJson) & RyanJsonTypeString)
-#define RyanJsonIsArray(pJson)  returnJsonBool(RyanJsonGetType(pJson) & RyanJsonTypeArray)
-#define RyanJsonIsObject(pJson) returnJsonBool(RyanJsonGetType(pJson) & RyanJsonTypeObject)
-
-//! get value函数使用前建议RyanJsonIsXXXX宏做好判断
-#define RyanJsonGetKey(pJson)         (*(char **)((RyanJson_t)(pJson) + 1))
-#define RyanJsonGetNullValue(pJson)   (NULL)
-#define RyanJsonGetBoolValue(pJson)   (RyanJsonGetInfo(pJson) & RyanJsonValueBoolTrueFlag ? RyanJsonTrue : RyanJsonFalse)
+extern RyanJson_t RyanJsonGetObjectByIndex(RyanJson_t pJson, uint32_t index);
+
+// 工具宏
+#define RyanJsonMakeBool(ex) ((ex) ? RyanJsonTrue : RyanJsonFalse)
+
+/**
+ * @brief 查询函数
+ */
+#define RyanJsonHasObjectByKey(pJson, key)     RyanJsonMakeBool(RyanJsonGetObjectByKey(pJson, key))
+#define RyanJsonHasObjectByIndex(pJson, index) RyanJsonMakeBool(RyanJsonGetObjectByIndex(pJson, index))
+
+/**
+ * @brief RyanJson 类型判断接口
+ */
+extern RyanJsonBool_e RyanJsonIsKey(RyanJson_t pJson);
+extern RyanJsonBool_e RyanJsonIsNull(RyanJson_t pJson);
+extern RyanJsonBool_e RyanJsonIsBool(RyanJson_t pJson);
+extern RyanJsonBool_e RyanJsonIsNumber(RyanJson_t pJson);
+extern RyanJsonBool_e RyanJsonIsString(RyanJson_t pJson);
+extern RyanJsonBool_e RyanJsonIsArray(RyanJson_t pJson);
+extern RyanJsonBool_e RyanJsonIsObject(RyanJson_t pJson);
+extern RyanJsonBool_e RyanJsonIsInt(RyanJson_t pJson);
+extern RyanJsonBool_e RyanJsonIsDouble(RyanJson_t pJson);
+
+/**
+ * @brief 取值宏
+ * !取值宏使用前一定要RyanJsonIsXXXX类型判断函数做好判断,否则会内存访问越界
+ */
+extern char *RyanJsonGetKey(RyanJson_t pJson);
+extern char *RyanJsonGetStringValue(RyanJson_t pJson);
+#define RyanJsonGetBoolValue(pJson)   RyanJsonGetPayloadBoolValueByFlag(pJson)
 #define RyanJsonGetIntValue(pJson)    (*(int32_t *)RyanJsonGetValue(pJson))
 #define RyanJsonGetDoubleValue(pJson) (*(double *)RyanJsonGetValue(pJson))
-#define RyanJsonGetStringValue(pJson) (*(char **)RyanJsonGetValue(pJson))
 #define RyanJsonGetArrayValue(pJson)  (*(RyanJson_t *)RyanJsonGetValue(pJson))
 #define RyanJsonGetObjectValue(pJson) (*(RyanJson_t *)RyanJsonGetValue(pJson))
 
-#define RyanJsonGetArraySize(pJson) RyanJsonGetSize(pJson)
-
-//! add函数使用前建议RyanJsonIsXXXX宏判断是否是对象 / 数组
-#define RyanJsonAddNullToObject(pJson, key)           RyanJsonInsert(pJson, INT_MAX, RyanJsonCreateNull(key))
-#define RyanJsonAddBoolToObject(pJson, key, boolean)  RyanJsonInsert(pJson, INT_MAX, RyanJsonCreateBool(key, boolean))
-#define RyanJsonAddIntToObject(pJson, key, number)    RyanJsonInsert(pJson, INT_MAX, RyanJsonCreateInt(key, number))
-#define RyanJsonAddDoubleToObject(pJson, key, number) RyanJsonInsert(pJson, INT_MAX, RyanJsonCreateDouble(key, number))
-#define RyanJsonAddStringToObject(pJson, key, string) RyanJsonInsert(pJson, INT_MAX, RyanJsonCreateString(key, string))
-#define RyanJsonAddItemToObject(pJson, key, item)     RyanJsonInsert(pJson, INT_MAX, RyanJsonCreateItem(key, item))
+/**
+ * @brief 添加相关函数
+ * ! add函数使用前建议RyanJsonIsXXXX宏判断是否是对象 / 数组,否则会内存访问越界
+ * ! add函数内部会处理失败情况，如果返回false，不需要用户手动释放内存
+ */
+#define RyanJsonAddNullToObject(pJson, key)           RyanJsonInsert(pJson, UINT32_MAX, RyanJsonCreateNull(key))
+#define RyanJsonAddBoolToObject(pJson, key, boolean)  RyanJsonInsert(pJson, UINT32_MAX, RyanJsonCreateBool(key, boolean))
+#define RyanJsonAddIntToObject(pJson, key, number)    RyanJsonInsert(pJson, UINT32_MAX, RyanJsonCreateInt(key, number))
+#define RyanJsonAddDoubleToObject(pJson, key, number) RyanJsonInsert(pJson, UINT32_MAX, RyanJsonCreateDouble(key, number))
+#define RyanJsonAddStringToObject(pJson, key, string) RyanJsonInsert(pJson, UINT32_MAX, RyanJsonCreateString(key, string))
+extern RyanJsonBool_e RyanJsonAddItemToObject(RyanJson_t pJson, const char *key, RyanJson_t item);
 
 #define RyanJsonAddNullToArray(pJson)           RyanJsonAddNullToObject(pJson, NULL)
 #define RyanJsonAddBoolToArray(pJson, boolean)  RyanJsonAddBoolToObject(pJson, NULL, boolean)
@@ -184,24 +272,30 @@ extern RyanJson_t RyanJsonGetObjectByIndex(RyanJson_t pJson, int32_t index);
 #define RyanJsonAddStringToArray(pJson, string) RyanJsonAddStringToObject(pJson, NULL, string)
 #define RyanJsonAddItemToArray(pJson, item)     RyanJsonAddItemToObject(pJson, NULL, item)
 
-// 便利函数
+/**
+ * @brief 遍历函数
+ */
 #define RyanJsonArrayForEach(pJson, item)  for ((item) = RyanJsonGetArrayValue(pJson); NULL != (item); (item) = (item)->next)
 #define RyanJsonObjectForEach(pJson, item) for ((item) = RyanJsonGetObjectValue(pJson); NULL != (item); (item) = (item)->next)
 
 /**
- * @brief change函数
- * !change函数没有对入参做校验，使用前请做使用RyanJsonIsXXXX宏做好判断
+ * @brief 修改相关函数
+ * !修改函数没有对入参做校验，使用前请做使用RyanJsonIsXXXX类型判断宏做好判断,否则会内存访问越界
  */
-#define RyanJsonChangeKey(pJson, key)            (RyanJsonReapplyString(&RyanJsonGetKey(pJson), key))
-#define RyanJsonChangeStringValue(pJson, string) (RyanJsonReapplyString(&RyanJsonGetStringValue(pJson), string))
-#define RyanJsonChangeBoolValue(pJson, boolean)  ((boolean) == RyanJsonTrue) ? ((pJson)->info |= (RyanJsonValueBoolTrueFlag)) : ((pJson)->info &= (~RyanJsonValueBoolTrueFlag))
+extern RyanJsonBool_e RyanJsonChangeKey(RyanJson_t pJson, const char *key);
+extern RyanJsonBool_e RyanJsonChangeStringValue(RyanJson_t pJson, const char *strValue);
+#define RyanJsonChangeBoolValue(pJson, boolean)  RyanJsonSetPayloadBoolValueByFlag(pJson, boolean)
 #define RyanJsonChangeIntValue(pJson, number)    (RyanJsonGetIntValue(pJson) = (number))
 #define RyanJsonChangeDoubleValue(pJson, number) (RyanJsonGetDoubleValue(pJson) = (number))
 
 // 这是change方法的补充，当需要修改value类型时，使用此函数
 // 请参考 changeJsonTest 示例，严格按照规则来使用
+/**
+ * @brief
+ * !这是change方法的补充，当需要修改value类型时，使用此函数，请参考 RyanJsonBaseTestChangeJson 示例，严格按照规则来使用
+ */
 extern RyanJsonBool_e RyanJsonReplaceByKey(RyanJson_t pJson, const char *key, RyanJson_t item);
-extern RyanJsonBool_e RyanJsonReplaceByIndex(RyanJson_t pJson, int32_t index, RyanJson_t item); // object对象也可以使用，但是不推荐
+extern RyanJsonBool_e RyanJsonReplaceByIndex(RyanJson_t pJson, uint32_t index, RyanJson_t item); // object对象也可以使用，但是不推荐
 
 #ifdef __cplusplus
 }

RyanJson/RyanJsonConfig.h

@@ -0,0 +1,153 @@
+#ifndef __RyanJsonConfig__
+#define __RyanJsonConfig__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdbool.h>
+#include <limits.h>
+#include <float.h>
+#include <math.h>
+#include <inttypes.h>
+
+#ifdef RT_VER_NUM
+#include "rtthread.h"
+#define RyanJsonMemset             rt_memset
+#define RyanJsonMemcpy             rt_memcpy
+#define RyanJsonStrlen             rt_strlen
+#define RyanJsonStrcmp             rt_strcmp
+#define RyanJsonSnprintf           rt_snprintf
+#define RyanJsonPlatformAssert(EX) RT_ASSERT(EX)
+#else
+#include <assert.h>
+#define RyanJsonMemset             memset
+#define RyanJsonMemcpy             memcpy
+#define RyanJsonStrlen             strlen
+#define RyanJsonStrcmp             strcmp
+#define RyanJsonSnprintf           snprintf
+#define RyanJsonPlatformAssert(EX) assert(EX)
+#endif
+
+// 是否启用assert
+// #define RyanJsonEnableAssert
+
+// 是否支持未对齐访问,未定义时会根据平台选择，
+// 一般不用管，如果你明白你的需求就自己定义
+// true 表示支持未对齐访问
+// false 表示不支持未对齐访问
+// UINT8_MAX 标识让RyanJson自动判断，但可能会漏掉支持对齐访问的平台
+#ifndef RyanJsonUnalignedAccessSupported
+#define RyanJsonUnalignedAccessSupported UINT8_MAX
+#endif
+
+// 限制解析数组/对象中嵌套的深度
+// RyanJson使用递归 序列化/反序列化 json
+// 请根据单片机资源合理设置以防止堆栈溢出。
+#ifndef RyanJsonNestingLimit
+#define RyanJsonNestingLimit 3000
+#endif
+
+// 当 RyanJsonPrint 剩余缓冲空间不足时申请的空间大小
+#ifndef RyanJsonPrintfPreAlloSize
+#define RyanJsonPrintfPreAlloSize (64U)
+#endif
+
+/**
+ * @brief 调试相关配置
+ *
+ */
+// #define jsonLog(fmt, ...) printf("%s:%d " fmt, __FILE__, __LINE__, ##__VA_ARGS__)
+#define jsonLog(...)
+
+#ifdef RyanJsonEnableAssert
+#define RyanJsonAssert(EX) RyanJsonPlatformAssert(EX)
+#else
+#define RyanJsonAssert(EX) (void)(EX)
+#endif
+
+/**
+ * @brief 判断是否支持未对齐访问
+ *
+ */
+#if UINT8_MAX == RyanJsonUnalignedAccessSupported
+#undef RyanJsonUnalignedAccessSupported
+
+// Cortex-M0/M0+/M1 属于 ARMv6-M
+#if defined(__ARM_ARCH_6M__)
+#define RyanJsonUnalignedAccessSupported false
+
+// Cortex-M3/M4/M7 属于 ARMv7-M/EM
+#elif defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__)
+#define RyanJsonUnalignedAccessSupported true
+
+// Cortex-M23/M33 属于 ARMv8-M
+#elif defined(__ARM_ARCH_8M_BASE__) || defined(__ARM_ARCH_8M_MAIN__)
+#define RyanJsonUnalignedAccessSupported true
+
+// Cortex-A/R 属于 ARMv7-A/R
+#elif defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__)
+#define RyanJsonUnalignedAccessSupported true
+
+// ARM9/ARM11 等老核
+#elif defined(__ARM_ARCH_5__) || defined(__ARM_ARCH_5E__)
+#define RyanJsonUnalignedAccessSupported false
+
+// ARMv8-A / ARM64
+#elif defined(__aarch64__) || defined(__ARM_ARCH_8A__) || defined(__ARM_ARCH_9__)
+#define RyanJsonUnalignedAccessSupported true
+
+// RISC-V MCU 默认不支持未对齐访问
+#elif defined(__riscv)
+#define RyanJsonUnalignedAccessSupported false
+
+// x86 / x86-64
+#elif defined(__i386__) || defined(__x86_64__)
+#define RyanJsonUnalignedAccessSupported true
+
+// MIPS
+#elif defined(__mips__)
+#define RyanJsonUnalignedAccessSupported false
+
+// PowerPC
+#elif defined(__powerpc__) || defined(__ppc__)
+#define RyanJsonUnalignedAccessSupported false
+
+// SPARC
+#elif defined(__sparc__)
+#define RyanJsonUnalignedAccessSupported false
+
+// SuperH
+#elif defined(__sh__)
+#define RyanJsonUnalignedAccessSupported false
+
+// Alpha
+#elif defined(__alpha__)
+#define RyanJsonUnalignedAccessSupported true
+
+// Itanium
+#elif defined(__ia64__)
+#define RyanJsonUnalignedAccessSupported false
+
+#else
+// 默认认为不支持未对齐访问
+#define RyanJsonUnalignedAccessSupported false
+#endif
+
+#endif // UINT8_MAX == RyanJsonUnalignedAccessSupported
+
+#if true != RyanJsonUnalignedAccessSupported
+#define RyanJsonAlign sizeof(void *)
+#else
+#define RyanJsonAlign sizeof(uint8_t)
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

RyanJson/RyanJsonUtils.c

@@ -0,0 +1,164 @@
+#include "RyanJsonUtils.h"
+
+/**
+ * @brief 连续通过 key 获取json对象的子项
+ *
+ * @param pJson
+ * @param key
+ * @param ... 可变参，连续输入key，直到NULL结束
+ * @return RyanJson_t
+ */
+RyanJson_t RyanJsonGetObjectByKeys(RyanJson_t pJson, const char *key, ...)
+{
+	RyanJsonCheckReturnNull(NULL != pJson && NULL != key);
+
+	const char *nextKey = key;
+	RyanJson_t nextItem = RyanJsonGetObjectByKey(pJson, nextKey);
+	RyanJsonCheckReturnNull(NULL != nextItem && RyanJsonIsKey(nextItem));
+
+	va_list args;
+	va_start(args, key);
+	nextKey = va_arg(args, const char *);
+	while (nextItem && NULL != nextKey)
+	{
+		nextItem = RyanJsonGetObjectByKey(nextItem, nextKey);
+		nextKey = va_arg(args, const char *);
+	}
+	va_end(args);
+
+	return nextItem;
+}
+
+/**
+ * @brief 连续通过 索引 获取json对象的子项
+ *
+ * @param pJson
+ * @param index
+ * @param ... 可变参，连续输入索引，直到UINT32_MAX结束
+ * @return RyanJson_t
+ */
+RyanJson_t RyanJsonGetObjectByIndexs(RyanJson_t pJson, uint32_t index, ...)
+{
+	RyanJsonCheckReturnNull(NULL != pJson);
+
+	uint32_t nextIndex = index;
+	RyanJson_t nextItem = RyanJsonGetObjectByIndex(pJson, nextIndex);
+	RyanJsonCheckReturnNull(NULL != nextItem);
+
+	va_list args;
+	va_start(args, index);
+	nextIndex = va_arg(args, uint32_t);
+	while (nextItem && UINT32_MAX != nextIndex)
+	{
+		nextItem = RyanJsonGetObjectByIndex(nextItem, nextIndex);
+		nextIndex = va_arg(args, uint32_t);
+	}
+	va_end(args);
+
+	return nextItem;
+}
+
+/**
+ * @brief 创建一个int类型的数组json对象
+ *
+ * @param numbers 数组的地址必须为int类型
+ * @param count 数组的长度
+ * @return RyanJson_t
+ */
+RyanJson_t RyanJsonCreateIntArray(const int32_t *numbers, uint32_t count)
+{
+	RyanJsonCheckReturnNull(NULL != numbers);
+
+	RyanJson_t pJson = RyanJsonCreateArray();
+	for (uint32_t i = 0; pJson && i < count; i++) { RyanJsonAddIntToArray(pJson, numbers[i]); }
+	return pJson;
+}
+
+/**
+ * @brief 创建一个double类型的数组json对象
+ *
+ * @param numbers
+ * @param count
+ * @return RyanJson_t
+ */
+RyanJson_t RyanJsonCreateDoubleArray(const double *numbers, uint32_t count)
+{
+	RyanJsonCheckReturnNull(NULL != numbers);
+
+	RyanJson_t pJson = RyanJsonCreateArray();
+	for (uint32_t i = 0; pJson && i < count; i++) { RyanJsonAddDoubleToArray(pJson, numbers[i]); }
+	return pJson;
+}
+
+/**
+ * @brief 创建一个string类型的数组json对象
+ *
+ * @param strings
+ * @param count
+ * @return RyanJson_t
+ */
+RyanJson_t RyanJsonCreateStringArray(const char **strings, uint32_t count)
+{
+	RyanJsonCheckReturnNull(NULL != strings);
+
+	RyanJson_t pJson = RyanJsonCreateArray();
+	for (uint32_t i = 0; pJson && i < count; i++) { RyanJsonAddStringToArray(pJson, strings[i]); }
+	return pJson;
+}
+
+/**
+ * @brief 递归比较两个 pJson 对象key是否相等。
+ * 此接口效率较低, 谨慎使用
+ * @param leftJson
+ * @param rightJson
+ * @return RyanJsonBool_e
+ */
+RyanJsonBool_e RyanJsonCompareOnlyKey(RyanJson_t leftJson, RyanJson_t rightJson)
+{
+	if (NULL == leftJson || NULL == rightJson) { return RyanJsonFalse; }
+
+	// 相同的对象相等
+	if (leftJson == rightJson) { return RyanJsonTrue; }
+
+	if (RyanJsonGetType(leftJson) != RyanJsonGetType(rightJson)) { return RyanJsonFalse; }
+
+	switch (RyanJsonGetType(leftJson))
+	{
+	case RyanJsonTypeBool:
+	case RyanJsonTypeNull:
+	case RyanJsonTypeNumber:
+	case RyanJsonTypeString: return RyanJsonTrue;
+
+	case RyanJsonTypeArray: {
+		if (RyanJsonGetSize(leftJson) != RyanJsonGetSize(rightJson)) { return RyanJsonFalse; }
+
+		RyanJson_t item;
+		uint32_t itemIndex = 0;
+		RyanJsonArrayForEach(leftJson, item)
+		{
+			if (RyanJsonTrue != RyanJsonCompareOnlyKey(item, RyanJsonGetObjectByIndex(rightJson, itemIndex)))
+			{
+				return RyanJsonFalse;
+			}
+			itemIndex++;
+		}
+		return RyanJsonTrue;
+	}
+
+	case RyanJsonTypeObject: {
+		if (RyanJsonGetSize(leftJson) != RyanJsonGetSize(rightJson)) { return RyanJsonFalse; }
+
+		RyanJson_t item;
+		RyanJsonObjectForEach(leftJson, item)
+		{
+			if (RyanJsonTrue != RyanJsonCompareOnlyKey(item, RyanJsonGetObjectByKey(rightJson, RyanJsonGetKey(item))))
+			{
+				return RyanJsonFalse;
+			}
+		}
+		return RyanJsonTrue;
+	}
+	}
+
+	return RyanJsonFalse;
+}

RyanJson/RyanJsonUtils.h

@@ -0,0 +1,45 @@
+#ifndef __RyanJsonUtils__
+#define __RyanJsonUtils__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "RyanJson.h"
+#include <stdarg.h>
+
+// 语法糖，根据传入的numbers数组创建一个int类型的数组。如果没有添加到父json, 则需释放内存
+extern RyanJson_t RyanJsonCreateIntArray(const int32_t *numbers, uint32_t count);
+// 语法糖，根据传入的numbers数组创建一个double类型的数组。如果没有添加到父json, 则需释放内存
+extern RyanJson_t RyanJsonCreateDoubleArray(const double *numbers, uint32_t count);
+// 语法糖，根据传入的strings数组创建一个string类型的数组。如果没有添加到父json, 则需释放内存
+extern RyanJson_t RyanJsonCreateStringArray(const char **strings, uint32_t count);
+
+extern RyanJsonBool_e RyanJsonCompareOnlyKey(RyanJson_t leftJson, RyanJson_t rightJson);
+
+/**
+ * @brief 查询函数，此接口较为底层，请使用下发的宏定义调用
+ */
+extern RyanJson_t RyanJsonGetObjectByIndexs(RyanJson_t pJson, uint32_t index, ...);
+extern RyanJson_t RyanJsonGetObjectByKeys(RyanJson_t pJson, const char *key, ...);
+
+/**
+ * @brief 可使用此宏进行嵌套式查找，例如 RyanJsonGetObjectToKey(json, "test", "inter")
+ * 
+ */
+#define RyanJsonGetObjectToKey(pJson, key, ...)     RyanJsonGetObjectByKeys(pJson, (key), ##__VA_ARGS__, NULL)
+
+/**
+ * @brief 可使用此宏进行嵌套式查找，例如 RyanJsonGetObjectToIndex(json, 0, 2)
+ * 
+ */
+#define RyanJsonGetObjectToIndex(pJson, index, ...) RyanJsonGetObjectByIndexs(pJson, (index), ##__VA_ARGS__, UINT32_MAX)
+
+#define RyanJsonHasObjectToKey(pJson, key, ...)     RyanJsonMakeBool(RyanJsonGetObjectByKeys(pJson, key, ##__VA_ARGS__, NULL))
+#define RyanJsonHasObjectToIndex(pJson, index, ...) RyanJsonMakeBool(RyanJsonGetObjectByIndexs(pJson, index, ##__VA_ARGS__, UINT32_MAX))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

example/RyanJsonExample.c

@@ -6,6 +6,7 @@
 #include <time.h>
 
 #include "RyanJson.h"
+#include "RyanJsonUtils.h"
 #include "valloc.h"
 
 /**
@@ -37,16 +38,21 @@ static int createJsonExample(void)
 	RyanJsonAddNullToObject(item, "null");
 	RyanJsonAddItemToObject(jsonRoot, "item", item); // 将上面创建的item子对象添加到root父对象
 
-	// 添加子数组
+	// 添加数字子数组
 	int arrayInt[] = {16, 16, 16, 16, 16};
 	RyanJsonAddItemToObject(jsonRoot, "arrayInt", RyanJsonCreateIntArray(arrayInt, sizeof(arrayInt) / sizeof(arrayInt[0])));
 
+	// 添加浮点数子数组
 	double arrayDouble[] = {16.89, 16.89, 16.89, 16.89, 16.89};
-	RyanJsonAddItemToObject(jsonRoot, "arrayDouble", RyanJsonCreateDoubleArray(arrayDouble, sizeof(arrayDouble) / sizeof(arrayDouble[0])));
+	RyanJsonAddItemToObject(jsonRoot, "arrayDouble",
+				RyanJsonCreateDoubleArray(arrayDouble, sizeof(arrayDouble) / sizeof(arrayDouble[0])));
 
+	// 添加字符串子数组
 	const char *arrayString[] = {"hello", "hello", "hello", "hello", "hello"};
-	RyanJsonAddItemToObject(jsonRoot, "arrayString", RyanJsonCreateStringArray(arrayString, sizeof(arrayString) / sizeof(arrayString[0])));
+	RyanJsonAddItemToObject(jsonRoot, "arrayString",
+				RyanJsonCreateStringArray(arrayString, sizeof(arrayString) / sizeof(arrayString[0])));
 
+	// 添加杂项数组
 	RyanJson_t array = RyanJsonCreateArray();
 	RyanJsonAddIntToArray(array, 16);
 	RyanJsonAddDoubleToArray(array, 16.89);
@@ -80,7 +86,7 @@ static int createJsonExample(void)
 
 	uint32_t len = 0;
 	str = RyanJsonPrint(jsonRoot, 250, RyanJsonTrue, &len); // 以带格式方式将数据打印出来
-	printf("strLen: %d, data: %s\r\n", len, str);
+	printf("strLen: %" PRIu32 ", data: %s\r\n", len, str);
 	RyanJsonFree(str);
 
 	RyanJsonDelete(jsonRoot);
@@ -97,10 +103,14 @@ static int loadJsonExample(void)
 {
 	char *str = NULL;
 	RyanJson_t jsonRoot;
-	const char jsonstr[] = "{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,\"item\":{\"inter\":16,\"double\":16.89,\"string\":\"hello\","
-			       "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89],\"arrayString\":[\"hello\","
-			       "\"hello\",\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,\"double\":16.89,\"string\":\"hello\","
-			       "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}]}";
+	const char jsonstr[] = "{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,"
+			       "\"item\":{\"inter\":16,\"double\":16.89,\"string\":\"hello\","
+			       "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,"
+			       "16.89,16.89,16.89,16.89],\"arrayString\":[\"hello\","
+			       "\"hello\",\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{"
+			       "\"inter\":16,\"double\":16.89,\"string\":\"hello\","
+			       "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\","
+			       "\"boolTrue\":true,\"boolFalse\":false,\"null\":null}]}";
 
 	// 解析json数据
 	jsonRoot = RyanJsonParse(jsonstr);
@@ -124,7 +134,7 @@ static int loadJsonExample(void)
 	// 将序列化的数据以有格式样式打印出来
 	uint32_t len = 0;
 	str = RyanJsonPrint(jsonRoot, 250, RyanJsonTrue, &len);
-	printf("strLen: %d, data: %s\r\n", len, str);
+	printf("strLen: %" PRIu32 ", data: %s\r\n", len, str);
 	RyanJsonFree(str);
 
 	// 删除json对象
@@ -165,7 +175,7 @@ static int changeJsonExample(void)
 	// 将序列化的数据以有格式样式打印出来
 	uint32_t len = 0;
 	str = RyanJsonPrint(jsonRoot, 250, RyanJsonTrue, &len);
-	printf("strLen: %d, data: %s\r\n", len, str);
+	printf("strLen: %" PRIu32 ", data: %s\r\n", len, str);
 	RyanJsonFree(str);
 
 	// 删除json对象
@@ -174,7 +184,7 @@ static int changeJsonExample(void)
 	return 0;
 }
 
-int RyanJsonExample(void)
+RyanJsonBool_e RyanJsonExample(void)
 {
 	RyanJsonInitHooks(v_malloc, v_free, v_realloc);
 
@@ -187,5 +197,5 @@ int RyanJsonExample(void)
 	printf("\r\n--------------------------- RyanJson 修改json示例 --------------------------\r\n");
 	changeJsonExample();
 
-	return -1;
+	return RyanJsonTrue;
 }

externalModule/cJSON/cJSON.c

@@ -117,7 +117,7 @@ CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON * const item)
 }
 
 /* This is a safeguard to prevent copy-pasters from using incompatible C and header files */
-#if (CJSON_VERSION_MAJOR != 1) || (CJSON_VERSION_MINOR != 7) || (CJSON_VERSION_PATCH != 18)
+#if (CJSON_VERSION_MAJOR != 1) || (CJSON_VERSION_MINOR != 7) || (CJSON_VERSION_PATCH != 19)
     #error cJSON.h and cJSON.c have different versions. Make sure that both have the same.
 #endif
 

externalModule/cJSON/cJSON.h

@@ -81,7 +81,7 @@ then using the CJSON_API_VISIBILITY flag to "export" the same symbols the way CJ
 /* project version */
 #define CJSON_VERSION_MAJOR 1
 #define CJSON_VERSION_MINOR 7
-#define CJSON_VERSION_PATCH 18
+#define CJSON_VERSION_PATCH 19
 
 #include <stddef.h>
 

externalModule/yyjson/yyjson.c

@@ -35,7 +35,7 @@
 #   pragma clang diagnostic ignored "-Wunused-label"
 #   pragma clang diagnostic ignored "-Wunused-macros"
 #   pragma clang diagnostic ignored "-Wunused-variable"
-#elif defined(__GNUC__)
+#elif YYJSON_IS_REAL_GCC
 #   pragma GCC diagnostic ignored "-Wunused-function"
 #   pragma GCC diagnostic ignored "-Wunused-parameter"
 #   pragma GCC diagnostic ignored "-Wunused-label"
@@ -46,6 +46,7 @@
 #   pragma warning(disable:4101) /* unreferenced variable */
 #   pragma warning(disable:4102) /* unreferenced label */
 #   pragma warning(disable:4127) /* conditional expression is constant */
+#   pragma warning(disable:4702) /* unreachable code */
 #   pragma warning(disable:4706) /* assignment within conditional expression */
 #endif
 
@@ -338,8 +339,9 @@ uint32_t yyjson_version(void) {
 #ifndef YYJSON_DISABLE_UTF8_VALIDATION
 #define YYJSON_DISABLE_UTF8_VALIDATION 0
 #endif
-
-
+#ifndef YYJSON_READER_DEPTH_LIMIT
+#define YYJSON_READER_DEPTH_LIMIT 0
+#endif
 
 /*==============================================================================
  * MARK: - Macros (Private)
@@ -438,6 +440,7 @@ uint32_t yyjson_version(void) {
 #define MSG_ERR_UTF8    "invalid utf-8 encoding in string"
 #define MSG_ERR_UTF16   "UTF-16 encoding is not supported"
 #define MSG_ERR_UTF32   "UTF-32 encoding is not supported"
+#define MSG_DEPTH       "depth limit exceeded"
 
 /* U64 constant values */
 #undef  U64_MAX
@@ -1187,11 +1190,13 @@ utf8_seq_def(b4_req2, 03, 30, 00, 00)
 /** Maximum pow10 exponent that can be represented exactly as a float64. */
 #define F64_POW10_MAX_EXACT_EXP 22
 
+#if YYJSON_DOUBLE_MATH_CORRECT
 /** Cached pow10 table. */
 static const f64 f64_pow10_table[F64_POW10_MAX_EXACT_EXP + 1] = {
     1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12,
     1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22
 };
+#endif
 
 /** Maximum pow10 exponent that can be represented exactly as a uint64. */
 #define U64_POW10_MAX_EXACT_EXP 19
@@ -5306,6 +5311,7 @@ fail_literal_null:  return_err(cur, LITERAL, MSG_CHAR_N);
 fail_character:     return_err(cur, UNEXPECTED_CHARACTER, MSG_CHAR);
 fail_comment:       return_err(cur, INVALID_COMMENT, MSG_COMMENT);
 fail_garbage:       return_err(cur, UNEXPECTED_CONTENT, MSG_GARBAGE);
+fail_depth:         return_err(cur, DEPTH, MSG_DEPTH);
 
 #undef return_err
 }
@@ -5366,6 +5372,10 @@ static_inline yyjson_doc *read_root_minify(u8 *hdr, u8 *cur, u8 *eof,
     u8 *raw_ptr = raw_end;
     u8 **pre = &raw_ptr; /* previous raw end pointer */
 
+#if YYJSON_READER_DEPTH_LIMIT
+    u32 container_depth = 0; /* current array/object depth */
+#endif
+
     dat_len = has_flg(STOP_WHEN_DONE) ? 256 : (usize)(eof - cur);
     hdr_len = sizeof(yyjson_doc) / sizeof(yyjson_val);
     hdr_len += (sizeof(yyjson_doc) % sizeof(yyjson_val)) > 0;
@@ -5391,6 +5401,12 @@ static_inline yyjson_doc *read_root_minify(u8 *hdr, u8 *cur, u8 *eof,
     }
 
 arr_begin:
+#if YYJSON_READER_DEPTH_LIMIT
+    container_depth++;
+    if (unlikely(container_depth >= YYJSON_READER_DEPTH_LIMIT)) {
+        goto fail_depth;
+    }
+#endif
     /* save current container */
     ctn->tag = (((u64)ctn_len + 1) << YYJSON_TAG_BIT) |
                (ctn->tag & YYJSON_TAG_MASK);
@@ -5496,6 +5512,9 @@ arr_val_end:
     goto fail_character_arr_end;
 
 arr_end:
+#if YYJSON_READER_DEPTH_LIMIT
+    container_depth--;
+#endif
     /* get parent container */
     ctn_parent = (yyjson_val *)(void *)((u8 *)ctn - ctn->uni.ofs);
 
@@ -5514,6 +5533,12 @@ arr_end:
     }
 
 obj_begin:
+#if YYJSON_READER_DEPTH_LIMIT
+    container_depth++;
+    if (unlikely(container_depth >= YYJSON_READER_DEPTH_LIMIT)) {
+        goto fail_depth;
+    }
+#endif
     /* push container */
     ctn->tag = (((u64)ctn_len + 1) << YYJSON_TAG_BIT) |
                (ctn->tag & YYJSON_TAG_MASK);
@@ -5660,6 +5685,9 @@ obj_val_end:
     goto fail_character_obj_end;
 
 obj_end:
+#if YYJSON_READER_DEPTH_LIMIT
+    container_depth--;
+#endif
     /* pop container */
     ctn_parent = (yyjson_val *)(void *)((u8 *)ctn - ctn->uni.ofs);
     /* point to the next value */
@@ -5709,6 +5737,7 @@ fail_character_obj_sep: return_err(cur, UNEXPECTED_CHARACTER, MSG_OBJ_SEP);
 fail_character_obj_end: return_err(cur, UNEXPECTED_CHARACTER, MSG_OBJ_END);
 fail_comment:           return_err(cur, INVALID_COMMENT, MSG_COMMENT);
 fail_garbage:           return_err(cur, UNEXPECTED_CONTENT, MSG_GARBAGE);
+fail_depth:             return_err(cur, DEPTH, MSG_DEPTH);
 
 #undef val_incr
 #undef return_err
@@ -5769,6 +5798,9 @@ static_inline yyjson_doc *read_root_pretty(u8 *hdr, u8 *cur, u8 *eof,
     u8 raw_end[1]; /* raw end for null-terminator */
     u8 *raw_ptr = raw_end;
     u8 **pre = &raw_ptr; /* previous raw end pointer */
+#if YYJSON_READER_DEPTH_LIMIT
+    u32 container_depth = 0; /* current array/object depth */
+#endif
 
     dat_len = has_flg(STOP_WHEN_DONE) ? 256 : (usize)(eof - cur);
     hdr_len = sizeof(yyjson_doc) / sizeof(yyjson_val);
@@ -5797,6 +5829,13 @@ static_inline yyjson_doc *read_root_pretty(u8 *hdr, u8 *cur, u8 *eof,
     }
 
 arr_begin:
+#if YYJSON_READER_DEPTH_LIMIT
+    container_depth++;
+    if (unlikely(container_depth >= YYJSON_READER_DEPTH_LIMIT)) {
+        goto fail_depth;
+    }
+#endif
+
     /* save current container */
     ctn->tag = (((u64)ctn_len + 1) << YYJSON_TAG_BIT) |
                (ctn->tag & YYJSON_TAG_MASK);
@@ -5919,6 +5958,9 @@ arr_val_end:
     goto fail_character_arr_end;
 
 arr_end:
+#if YYJSON_READER_DEPTH_LIMIT
+    container_depth--;
+#endif
     /* get parent container */
     ctn_parent = (yyjson_val *)(void *)((u8 *)ctn - ctn->uni.ofs);
 
@@ -5938,6 +5980,13 @@ arr_end:
     }
 
 obj_begin:
+#if YYJSON_READER_DEPTH_LIMIT
+    container_depth++;
+    if (unlikely(container_depth >= YYJSON_READER_DEPTH_LIMIT)) {
+        goto fail_depth;
+    }
+#endif
+
     /* push container */
     ctn->tag = (((u64)ctn_len + 1) << YYJSON_TAG_BIT) |
                (ctn->tag & YYJSON_TAG_MASK);
@@ -6104,6 +6153,10 @@ obj_val_end:
     goto fail_character_obj_end;
 
 obj_end:
+#if YYJSON_READER_DEPTH_LIMIT
+    container_depth--;
+#endif
+
     /* pop container */
     ctn_parent = (yyjson_val *)(void *)((u8 *)ctn - ctn->uni.ofs);
     /* point to the next value */
@@ -6154,6 +6207,7 @@ fail_character_obj_sep: return_err(cur, UNEXPECTED_CHARACTER, MSG_OBJ_SEP);
 fail_character_obj_end: return_err(cur, UNEXPECTED_CHARACTER, MSG_OBJ_END);
 fail_comment:           return_err(cur, INVALID_COMMENT, MSG_COMMENT);
 fail_garbage:           return_err(cur, UNEXPECTED_CONTENT, MSG_GARBAGE);
+fail_depth:             return_err(cur, DEPTH, MSG_DEPTH);
 
 #undef val_incr
 #undef return_err
@@ -6612,6 +6666,10 @@ yyjson_doc *yyjson_incr_read(yyjson_incr_state *state, size_t len,
     u8 **con = NULL; /* for incremental string parsing */
     u8 saved_end = '\0'; /* saved end char */
 
+#if YYJSON_READER_DEPTH_LIMIT
+    u32 container_depth = 0; /* current array/object depth */
+#endif
+
     /* validate input parameters */
     if (!err) err = &tmp_err;
     if (unlikely(!state)) {
@@ -6733,6 +6791,13 @@ doc_begin:
     return_err(cur, UNEXPECTED_CHARACTER, msg);
 
 arr_begin:
+#if YYJSON_READER_DEPTH_LIMIT
+    container_depth++;
+    if (unlikely(container_depth >= YYJSON_READER_DEPTH_LIMIT)) {
+        goto fail_depth;
+    }
+#endif
+
     /* save current container */
     ctn->tag = (((u64)ctn_len + 1) << YYJSON_TAG_BIT) |
                (ctn->tag & YYJSON_TAG_MASK);
@@ -6822,6 +6887,9 @@ arr_val_end:
     goto fail_character_arr_end;
 
 arr_end:
+#if YYJSON_READER_DEPTH_LIMIT
+    container_depth--;
+#endif
     /* get parent container */
     ctn_parent = (yyjson_val *)(void *)((u8 *)ctn - ctn->uni.ofs);
 
@@ -6840,6 +6908,13 @@ arr_end:
     }
 
 obj_begin:
+#if YYJSON_READER_DEPTH_LIMIT
+    container_depth++;
+    if (unlikely(container_depth >= YYJSON_READER_DEPTH_LIMIT)) {
+        goto fail_depth;
+    }
+#endif
+
     /* push container */
     ctn->tag = (((u64)ctn_len + 1) << YYJSON_TAG_BIT) |
                (ctn->tag & YYJSON_TAG_MASK);
@@ -6954,6 +7029,10 @@ obj_val_end:
     goto fail_character_obj_end;
 
 obj_end:
+#if YYJSON_READER_DEPTH_LIMIT
+    container_depth--;
+#endif
+
     /* pop container */
     ctn_parent = (yyjson_val *)(void *)((u8 *)ctn - ctn->uni.ofs);
     /* point to the next value */
@@ -7020,6 +7099,7 @@ fail_character_obj_key: return_err(cur, UNEXPECTED_CHARACTER, MSG_OBJ_KEY);
 fail_character_obj_sep: return_err(cur, UNEXPECTED_CHARACTER, MSG_OBJ_SEP);
 fail_character_obj_end: return_err(cur, UNEXPECTED_CHARACTER, MSG_OBJ_END);
 fail_garbage:           return_err(cur, UNEXPECTED_CONTENT, MSG_GARBAGE);
+fail_depth:             return_err(cur, DEPTH, MSG_DEPTH);
 
 #undef val_incr
 #undef return_err
@@ -8944,11 +9024,11 @@ static_inline void yyjson_write_ctx_get(yyjson_write_ctx *ctx,
 }
 
 /** Write single JSON value. */
-static_inline u8 *yyjson_write_single(yyjson_val *val,
-                                      yyjson_write_flag flg,
-                                      yyjson_alc alc,
-                                      usize *dat_len,
-                                      yyjson_write_err *err) {
+static_inline u8 *write_root_single(yyjson_val *val,
+                                    yyjson_write_flag flg,
+                                    yyjson_alc alc,
+                                    char *buf, usize *dat_len,
+                                    yyjson_write_err *err) {
 #define return_err(_code, _msg) do { \
     if (hdr) alc.free(alc.ctx, (void *)hdr); \
     *dat_len = 0; \
@@ -8958,7 +9038,8 @@ static_inline u8 *yyjson_write_single(yyjson_val *val,
 } while (false)
 
 #define incr_len(_len) do { \
-    hdr = (u8 *)alc.malloc(alc.ctx, _len); \
+    if (buf) hdr = *dat_len >= _len ? (u8 *)buf : (u8 *)NULL; \
+    else hdr = (u8 *)alc.malloc(alc.ctx, _len); \
     if (!hdr) goto fail_alloc; \
     cur = hdr; \
 } while (false)
@@ -9050,11 +9131,11 @@ fail_str:   return_err(INVALID_STRING, MSG_ERR_UTF8);
 
 /** Write JSON document minify.
     The root of this document should be a non-empty container. */
-static_inline u8 *yyjson_write_minify(const yyjson_val *root,
-                                      const yyjson_write_flag flg,
-                                      const yyjson_alc alc,
-                                      usize *dat_len,
-                                      yyjson_write_err *err) {
+static_inline u8 *write_root_minify(const yyjson_val *root,
+                                    const yyjson_write_flag flg,
+                                    const yyjson_alc alc,
+                                    char *buf, usize *dat_len,
+                                    yyjson_write_err *err) {
 #define return_err(_code, _msg) do { \
     *dat_len = 0; \
     err->code = YYJSON_WRITE_ERROR_##_code; \
@@ -9104,11 +9185,18 @@ static_inline u8 *yyjson_write_minify(const yyjson_val *root,
     bool inv = has_allow(INVALID_UNICODE) != 0;
     bool newline = has_flg(NEWLINE_AT_END) != 0;
 
-    alc_len = root->uni.ofs / sizeof(yyjson_val);
-    alc_len = alc_len * YYJSON_WRITER_ESTIMATED_MINIFY_RATIO + 64;
-    alc_len = size_align_up(alc_len, sizeof(yyjson_write_ctx));
-    hdr = (u8 *)alc.malloc(alc.ctx, alc_len);
-    if (!hdr) goto fail_alloc;
+    if (buf) {
+        hdr = (u8 *)buf;
+        alc_len = *dat_len;
+        alc_len = size_align_down(alc_len, sizeof(yyjson_write_ctx));
+        if (alc_len <= sizeof(yyjson_write_ctx)) goto fail_alloc;
+    } else {
+        alc_len = root->uni.ofs / sizeof(yyjson_val);
+        alc_len = alc_len * YYJSON_WRITER_ESTIMATED_MINIFY_RATIO + 64;
+        alc_len = size_align_up(alc_len, sizeof(yyjson_write_ctx));
+        hdr = (u8 *)alc.malloc(alc.ctx, alc_len);
+        if (!hdr) goto fail_alloc;
+    }
     cur = hdr;
     end = hdr + alc_len;
     ctx = (yyjson_write_ctx *)(void *)end;
@@ -9149,7 +9237,7 @@ val_begin:
                     (YYJSON_TYPE_ARR & YYJSON_TYPE_OBJ)) {
         ctn_len_tmp = unsafe_yyjson_get_len(val);
         ctn_obj_tmp = (val_type == YYJSON_TYPE_OBJ);
-        incr_len(16);
+        incr_len(2 * sizeof(*ctx));
         if (unlikely(ctn_len_tmp == 0)) {
             /* write empty container */
             *cur++ = (u8)('[' | ((u8)ctn_obj_tmp << 5));
@@ -9231,11 +9319,11 @@ fail_str:   return_err(INVALID_STRING, MSG_ERR_UTF8);
 
 /** Write JSON document pretty.
     The root of this document should be a non-empty container. */
-static_inline u8 *yyjson_write_pretty(const yyjson_val *root,
-                                      const yyjson_write_flag flg,
-                                      const yyjson_alc alc,
-                                      usize *dat_len,
-                                      yyjson_write_err *err) {
+static_inline u8 *write_root_pretty(const yyjson_val *root,
+                                    const yyjson_write_flag flg,
+                                    const yyjson_alc alc,
+                                    char *buf, usize *dat_len,
+                                    yyjson_write_err *err) {
 #define return_err(_code, _msg) do { \
     *dat_len = 0; \
     err->code = YYJSON_WRITE_ERROR_##_code; \
@@ -9286,11 +9374,18 @@ static_inline u8 *yyjson_write_pretty(const yyjson_val *root,
     usize spaces = has_flg(PRETTY_TWO_SPACES) ? 2 : 4;
     bool newline = has_flg(NEWLINE_AT_END) != 0;
 
-    alc_len = root->uni.ofs / sizeof(yyjson_val);
-    alc_len = alc_len * YYJSON_WRITER_ESTIMATED_PRETTY_RATIO + 64;
-    alc_len = size_align_up(alc_len, sizeof(yyjson_write_ctx));
-    hdr = (u8 *)alc.malloc(alc.ctx, alc_len);
-    if (!hdr) goto fail_alloc;
+    if (buf) {
+        hdr = (u8 *)buf;
+        alc_len = *dat_len;
+        alc_len = size_align_down(alc_len, sizeof(yyjson_write_ctx));
+        if (alc_len <= sizeof(yyjson_write_ctx)) goto fail_alloc;
+    } else {
+        alc_len = root->uni.ofs / sizeof(yyjson_val);
+        alc_len = alc_len * YYJSON_WRITER_ESTIMATED_PRETTY_RATIO + 64;
+        alc_len = size_align_up(alc_len, sizeof(yyjson_write_ctx));
+        hdr = (u8 *)alc.malloc(alc.ctx, alc_len);
+        if (!hdr) goto fail_alloc;
+    }
     cur = hdr;
     end = hdr + alc_len;
     ctx = (yyjson_write_ctx *)(void *)end;
@@ -9340,9 +9435,9 @@ val_begin:
         no_indent = (bool)((u8)ctn_obj & (u8)ctn_len);
         ctn_len_tmp = unsafe_yyjson_get_len(val);
         ctn_obj_tmp = (val_type == YYJSON_TYPE_OBJ);
+        incr_len(2 * sizeof(*ctx) + (no_indent ? 0 : level * 4));
         if (unlikely(ctn_len_tmp == 0)) {
             /* write empty container */
-            incr_len(16 + (no_indent ? 0 : level * 4));
             cur = write_indent(cur, no_indent ? 0 : level, spaces);
             *cur++ = (u8)('[' | ((u8)ctn_obj_tmp << 5));
             *cur++ = (u8)(']' | ((u8)ctn_obj_tmp << 5));
@@ -9351,7 +9446,6 @@ val_begin:
             goto val_end;
         } else {
             /* push context, setup new container */
-            incr_len(32 + (no_indent ? 0 : level * 4));
             yyjson_write_ctx_set(--ctx, ctn_len, ctn_obj);
             ctn_len = ctn_len_tmp << (u8)ctn_obj_tmp;
             ctn_obj = ctn_obj_tmp;
@@ -9436,17 +9530,11 @@ fail_str:   return_err(INVALID_STRING, MSG_ERR_UTF8);
 #undef check_str_len
 }
 
-
-
-/*==============================================================================
- * MARK: - JSON Writer (Public)
- *============================================================================*/
-
-char *yyjson_val_write_opts(const yyjson_val *val,
-                            yyjson_write_flag flg,
-                            const yyjson_alc *alc_ptr,
-                            usize *dat_len,
-                            yyjson_write_err *err) {
+static char *write_root(const yyjson_val *val,
+                        yyjson_write_flag flg,
+                        const yyjson_alc *alc_ptr,
+                        char *buf, usize *dat_len,
+                        yyjson_write_err *err) {
     yyjson_write_err tmp_err;
     usize tmp_dat_len;
     yyjson_alc alc = alc_ptr ? *alc_ptr : YYJSON_DEFAULT_ALC;
@@ -9463,21 +9551,35 @@ char *yyjson_val_write_opts(const yyjson_val *val,
     }
 
     if (!unsafe_yyjson_is_ctn(root) || unsafe_yyjson_get_len(root) == 0) {
-        return (char *)yyjson_write_single(root, flg, alc, dat_len, err);
+        return (char *)write_root_single(root, flg, alc, buf, dat_len, err);
     } else if (flg & (YYJSON_WRITE_PRETTY | YYJSON_WRITE_PRETTY_TWO_SPACES)) {
-        return (char *)yyjson_write_pretty(root, flg, alc, dat_len, err);
+        return (char *)write_root_pretty(root, flg, alc, buf, dat_len, err);
     } else {
-        return (char *)yyjson_write_minify(root, flg, alc, dat_len, err);
+        return (char *)write_root_minify(root, flg, alc, buf, dat_len, err);
     }
 }
 
+
+
+/*==============================================================================
+ * MARK: - JSON Writer (Public)
+ *============================================================================*/
+
+char *yyjson_val_write_opts(const yyjson_val *val,
+                            yyjson_write_flag flg,
+                            const yyjson_alc *alc_ptr,
+                            usize *dat_len,
+                            yyjson_write_err *err) {
+    return write_root(val, flg, alc_ptr, NULL, dat_len, err);
+}
+
 char *yyjson_write_opts(const yyjson_doc *doc,
                         yyjson_write_flag flg,
                         const yyjson_alc *alc_ptr,
                         usize *dat_len,
                         yyjson_write_err *err) {
     yyjson_val *root = doc ? doc->root : NULL;
-    return yyjson_val_write_opts(root, flg, alc_ptr, dat_len, err);
+    return write_root(root, flg, alc_ptr, NULL, dat_len, err);
 }
 
 bool yyjson_val_write_file(const char *path,
@@ -9499,7 +9601,7 @@ bool yyjson_val_write_file(const char *path,
         return false;
     }
 
-    dat = (u8 *)yyjson_val_write_opts(root, flg, &alc, &dat_len, err);
+    dat = (u8 *)write_root(root, flg, &alc, NULL, &dat_len, err);
     if (unlikely(!dat)) return false;
     suc = write_dat_to_file(path, dat, dat_len, err);
     alc.free(alc.ctx, dat);
@@ -9525,13 +9627,27 @@ bool yyjson_val_write_fp(FILE *fp,
         return false;
     }
 
-    dat = (u8 *)yyjson_val_write_opts(root, flg, &alc, &dat_len, err);
+    dat = (u8 *)write_root(root, flg, &alc, NULL, &dat_len, err);
     if (unlikely(!dat)) return false;
     suc = write_dat_to_fp(fp, dat, dat_len, err);
     alc.free(alc.ctx, dat);
     return suc;
 }
 
+size_t yyjson_val_write_buf(char *buf, size_t buf_len,
+                            const yyjson_val *val,
+                            yyjson_write_flag flg,
+                            yyjson_write_err *err) {
+    if (unlikely(!buf || !buf_len)) {
+        if (err) err->code = YYJSON_WRITE_ERROR_INVALID_PARAMETER;
+        if (err) err->msg = "input buf or buf_len is invalid";
+        return 0;
+    } else {
+        write_root(val, flg, &YYJSON_NULL_ALC, buf, &buf_len, err);
+        return buf_len;
+    }
+}
+
 bool yyjson_write_file(const char *path,
                        const yyjson_doc *doc,
                        yyjson_write_flag flg,
@@ -9550,6 +9666,14 @@ bool yyjson_write_fp(FILE *fp,
     return yyjson_val_write_fp(fp, root, flg, alc_ptr, err);
 }
 
+size_t yyjson_write_buf(char *buf, size_t buf_len,
+                        const yyjson_doc *doc,
+                        yyjson_write_flag flg,
+                        yyjson_write_err *err) {
+    yyjson_val *root = doc ? doc->root : NULL;
+    return yyjson_val_write_buf(buf, buf_len, root, flg, err);
+}
+
 
 
 /*==============================================================================
@@ -9593,22 +9717,22 @@ static_inline usize yyjson_mut_doc_estimated_val_num(
 }
 
 /** Write single JSON value. */
-static_inline u8 *yyjson_mut_write_single(yyjson_mut_val *val,
-                                          yyjson_write_flag flg,
-                                          yyjson_alc alc,
-                                          usize *dat_len,
-                                          yyjson_write_err *err) {
-    return yyjson_write_single((yyjson_val *)val, flg, alc, dat_len, err);
+static_inline u8 *mut_write_root_single(yyjson_mut_val *val,
+                                        yyjson_write_flag flg,
+                                        yyjson_alc alc,
+                                        char *buf, usize *dat_len,
+                                        yyjson_write_err *err) {
+    return write_root_single((yyjson_val *)val, flg, alc, buf, dat_len, err);
 }
 
 /** Write JSON document minify.
     The root of this document should be a non-empty container. */
-static_inline u8 *yyjson_mut_write_minify(const yyjson_mut_val *root,
-                                          usize estimated_val_num,
-                                          yyjson_write_flag flg,
-                                          yyjson_alc alc,
-                                          usize *dat_len,
-                                          yyjson_write_err *err) {
+static_inline u8 *mut_write_root_minify(const yyjson_mut_val *root,
+                                        usize estimated_val_num,
+                                        yyjson_write_flag flg,
+                                        yyjson_alc alc,
+                                        char *buf, usize *dat_len,
+                                        yyjson_write_err *err) {
 #define return_err(_code, _msg) do { \
     *dat_len = 0; \
     err->code = YYJSON_WRITE_ERROR_##_code; \
@@ -9658,10 +9782,17 @@ static_inline u8 *yyjson_mut_write_minify(const yyjson_mut_val *root,
     bool inv = has_allow(INVALID_UNICODE) != 0;
     bool newline = has_flg(NEWLINE_AT_END) != 0;
 
-    alc_len = estimated_val_num * YYJSON_WRITER_ESTIMATED_MINIFY_RATIO + 64;
-    alc_len = size_align_up(alc_len, sizeof(yyjson_mut_write_ctx));
-    hdr = (u8 *)alc.malloc(alc.ctx, alc_len);
-    if (!hdr) goto fail_alloc;
+    if (buf) {
+        hdr = (u8 *)buf;
+        alc_len = *dat_len;
+        alc_len = size_align_down(alc_len, sizeof(yyjson_mut_write_ctx));
+        if (alc_len <= sizeof(yyjson_mut_write_ctx)) goto fail_alloc;
+    } else {
+        alc_len = estimated_val_num * YYJSON_WRITER_ESTIMATED_MINIFY_RATIO + 64;
+        alc_len = size_align_up(alc_len, sizeof(yyjson_mut_write_ctx));
+        hdr = (u8 *)alc.malloc(alc.ctx, alc_len);
+        if (!hdr) goto fail_alloc;
+    }
     cur = hdr;
     end = hdr + alc_len;
     ctx = (yyjson_mut_write_ctx *)(void *)end;
@@ -9704,7 +9835,7 @@ val_begin:
                     (YYJSON_TYPE_ARR & YYJSON_TYPE_OBJ)) {
         ctn_len_tmp = unsafe_yyjson_get_len(val);
         ctn_obj_tmp = (val_type == YYJSON_TYPE_OBJ);
-        incr_len(16);
+        incr_len(2 * sizeof(*ctx));
         if (unlikely(ctn_len_tmp == 0)) {
             /* write empty container */
             *cur++ = (u8)('[' | ((u8)ctn_obj_tmp << 5));
@@ -9790,12 +9921,12 @@ fail_str:   return_err(INVALID_STRING, MSG_ERR_UTF8);
 
 /** Write JSON document pretty.
     The root of this document should be a non-empty container. */
-static_inline u8 *yyjson_mut_write_pretty(const yyjson_mut_val *root,
-                                          usize estimated_val_num,
-                                          yyjson_write_flag flg,
-                                          yyjson_alc alc,
-                                          usize *dat_len,
-                                          yyjson_write_err *err) {
+static_inline u8 *mut_write_root_pretty(const yyjson_mut_val *root,
+                                        usize estimated_val_num,
+                                        yyjson_write_flag flg,
+                                        yyjson_alc alc,
+                                        char *buf, usize *dat_len,
+                                        yyjson_write_err *err) {
 #define return_err(_code, _msg) do { \
     *dat_len = 0; \
     err->code = YYJSON_WRITE_ERROR_##_code; \
@@ -9846,10 +9977,17 @@ static_inline u8 *yyjson_mut_write_pretty(const yyjson_mut_val *root,
     usize spaces = has_flg(PRETTY_TWO_SPACES) ? 2 : 4;
     bool newline = has_flg(NEWLINE_AT_END) != 0;
 
-    alc_len = estimated_val_num * YYJSON_WRITER_ESTIMATED_PRETTY_RATIO + 64;
-    alc_len = size_align_up(alc_len, sizeof(yyjson_mut_write_ctx));
-    hdr = (u8 *)alc.malloc(alc.ctx, alc_len);
-    if (!hdr) goto fail_alloc;
+    if (buf) {
+        hdr = (u8 *)buf;
+        alc_len = *dat_len;
+        alc_len = size_align_down(alc_len, sizeof(yyjson_mut_write_ctx));
+        if (alc_len <= sizeof(yyjson_mut_write_ctx)) goto fail_alloc;
+    } else {
+        alc_len = estimated_val_num * YYJSON_WRITER_ESTIMATED_PRETTY_RATIO + 64;
+        alc_len = size_align_up(alc_len, sizeof(yyjson_mut_write_ctx));
+        hdr = (u8 *)alc.malloc(alc.ctx, alc_len);
+        if (!hdr) goto fail_alloc;
+    }
     cur = hdr;
     end = hdr + alc_len;
     ctx = (yyjson_mut_write_ctx *)(void *)end;
@@ -9901,9 +10039,9 @@ val_begin:
         no_indent = (bool)((u8)ctn_obj & (u8)ctn_len);
         ctn_len_tmp = unsafe_yyjson_get_len(val);
         ctn_obj_tmp = (val_type == YYJSON_TYPE_OBJ);
+        incr_len(2 * sizeof(*ctx) + (no_indent ? 0 : level * 4));
         if (unlikely(ctn_len_tmp == 0)) {
             /* write empty container */
-            incr_len(16 + (no_indent ? 0 : level * 4));
             cur = write_indent(cur, no_indent ? 0 : level, spaces);
             *cur++ = (u8)('[' | ((u8)ctn_obj_tmp << 5));
             *cur++ = (u8)(']' | ((u8)ctn_obj_tmp << 5));
@@ -9912,7 +10050,6 @@ val_begin:
             goto val_end;
         } else {
             /* push context, setup new container */
-            incr_len(32 + (no_indent ? 0 : level * 4));
             yyjson_mut_write_ctx_set(--ctx, ctn, ctn_len, ctn_obj);
             ctn_len = ctn_len_tmp << (u8)ctn_obj_tmp;
             ctn_obj = ctn_obj_tmp;
@@ -10001,12 +10138,12 @@ fail_str:   return_err(INVALID_STRING, MSG_ERR_UTF8);
 #undef check_str_len
 }
 
-static char *yyjson_mut_write_opts_impl(const yyjson_mut_val *val,
-                                        usize estimated_val_num,
-                                        yyjson_write_flag flg,
-                                        const yyjson_alc *alc_ptr,
-                                        usize *dat_len,
-                                        yyjson_write_err *err) {
+static char *mut_write_root(const yyjson_mut_val *val,
+                            usize estimated_val_num,
+                            yyjson_write_flag flg,
+                            const yyjson_alc *alc_ptr,
+                            char *buf, usize *dat_len,
+                            yyjson_write_err *err) {
     yyjson_write_err tmp_err;
     usize tmp_dat_len;
     yyjson_alc alc = alc_ptr ? *alc_ptr : YYJSON_DEFAULT_ALC;
@@ -10023,13 +10160,13 @@ static char *yyjson_mut_write_opts_impl(const yyjson_mut_val *val,
     }
 
     if (!unsafe_yyjson_is_ctn(root) || unsafe_yyjson_get_len(root) == 0) {
-        return (char *)yyjson_mut_write_single(root, flg, alc, dat_len, err);
+        return (char *)mut_write_root_single(root, flg, alc, buf, dat_len, err);
     } else if (flg & (YYJSON_WRITE_PRETTY | YYJSON_WRITE_PRETTY_TWO_SPACES)) {
-        return (char *)yyjson_mut_write_pretty(root, estimated_val_num,
-                                               flg, alc, dat_len, err);
+        return (char *)mut_write_root_pretty(root, estimated_val_num,
+                                             flg, alc, buf, dat_len, err);
     } else {
-        return (char *)yyjson_mut_write_minify(root, estimated_val_num,
-                                               flg, alc, dat_len, err);
+        return (char *)mut_write_root_minify(root, estimated_val_num,
+                                             flg, alc, buf, dat_len, err);
     }
 }
 
@@ -10044,7 +10181,7 @@ char *yyjson_mut_val_write_opts(const yyjson_mut_val *val,
                                 const yyjson_alc *alc_ptr,
                                 usize *dat_len,
                                 yyjson_write_err *err) {
-    return yyjson_mut_write_opts_impl(val, 0, flg, alc_ptr, dat_len, err);
+    return mut_write_root(val, 0, flg, alc_ptr, NULL, dat_len, err);
 }
 
 char *yyjson_mut_write_opts(const yyjson_mut_doc *doc,
@@ -10061,8 +10198,8 @@ char *yyjson_mut_write_opts(const yyjson_mut_doc *doc,
         root = NULL;
         estimated_val_num = 0;
     }
-    return yyjson_mut_write_opts_impl(root, estimated_val_num,
-                                      flg, alc_ptr, dat_len, err);
+    return mut_write_root(root, estimated_val_num,
+                          flg, alc_ptr, NULL, dat_len, err);
 }
 
 bool yyjson_mut_val_write_file(const char *path,
@@ -10117,6 +10254,20 @@ bool yyjson_mut_val_write_fp(FILE *fp,
     return suc;
 }
 
+size_t yyjson_mut_val_write_buf(char *buf, size_t buf_len,
+                                const yyjson_mut_val *val,
+                                yyjson_write_flag flg,
+                                yyjson_write_err *err) {
+    if (unlikely(!buf || !buf_len)) {
+        if (err) err->code = YYJSON_WRITE_ERROR_INVALID_PARAMETER;
+        if (err) err->msg = "input buf or buf_len is invalid";
+        return 0;
+    } else {
+        mut_write_root(val, 0, flg, &YYJSON_NULL_ALC, buf, &buf_len, err);
+        return buf_len;
+    }
+}
+
 bool yyjson_mut_write_file(const char *path,
                            const yyjson_mut_doc *doc,
                            yyjson_write_flag flg,
@@ -10135,6 +10286,14 @@ bool yyjson_mut_write_fp(FILE *fp,
     return yyjson_mut_val_write_fp(fp, root, flg, alc_ptr, err);
 }
 
+size_t yyjson_mut_write_buf(char *buf, size_t buf_len,
+                            const yyjson_mut_doc *doc,
+                            yyjson_write_flag flg,
+                            yyjson_write_err *err) {
+    yyjson_mut_val *root = doc ? doc->root : NULL;
+    return yyjson_mut_val_write_buf(buf, buf_len, root, flg, err);
+}
+
 #undef has_flg
 #undef has_allow
 #endif /* YYJSON_DISABLE_WRITER */

externalModule/yyjson/yyjson.h

@@ -142,6 +142,9 @@
 #ifndef YYJSON_HAS_STDBOOL_H
 #endif
 
+/* Define to an integer to set a depth limit for containers (arrays, objects). */
+#ifndef YYJSON_READER_DEPTH_LIMIT
+#endif
 
 
 /*==============================================================================
@@ -418,8 +421,8 @@
 
 /** stdbool (C89 compatible) */
 #if (defined(YYJSON_HAS_STDBOOL_H) && YYJSON_HAS_STDBOOL_H) || \
-    (yyjson_has_include(<stdbool.h>) && !defined(__STRICT_ANSI__)) || \
-    YYJSON_MSC_VER >= 1800 || YYJSON_STDC_VER >= 199901L
+    YYJSON_MSC_VER >= 1800 || YYJSON_STDC_VER >= 199901L || \
+    (yyjson_has_include(<stdbool.h>) && !defined(__STRICT_ANSI__))
 #   include <stdbool.h>
 #elif !defined(__bool_true_false_are_defined)
 #   define __bool_true_false_are_defined 1
@@ -474,7 +477,7 @@ extern "C" {
 #   pragma clang diagnostic push
 #   pragma clang diagnostic ignored "-Wunused-function"
 #   pragma clang diagnostic ignored "-Wunused-parameter"
-#elif defined(__GNUC__)
+#elif YYJSON_IS_REAL_GCC
 #   if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
 #       pragma GCC diagnostic push
 #   endif
@@ -875,6 +878,9 @@ static const yyjson_read_code YYJSON_READ_ERROR_FILE_READ               = 13;
 /** Incomplete input during incremental parsing; parsing state is preserved. */
 static const yyjson_read_code YYJSON_READ_ERROR_MORE                    = 14;
 
+/** Read depth limit exceeded. */
+static const yyjson_read_code YYJSON_READ_ERROR_DEPTH                   = 15;
+
 /** Error information for JSON reader. */
 typedef struct yyjson_read_err {
     /** Error code, see `yyjson_read_code` for all possible values. */
@@ -1338,6 +1344,30 @@ yyjson_api bool yyjson_write_fp(FILE *fp,
                                 const yyjson_alc *alc,
                                 yyjson_write_err *err);
 
+/**
+ Write a document into a buffer.
+
+ This function does not allocate memory, but the buffer must be larger than the
+ final JSON size to allow temporary space. See `API.md` for details.
+
+ @param buf The output buffer.
+    If the buffer is NULL, the function will fail and return 0.
+ @param buf_len The buffer length.
+    If the buf_len is too small, the function will fail and return 0.
+ @param doc doc The JSON document.
+    If this doc is NULL or has no root, the function will fail and return 0.
+ @param flg flg The JSON write options.
+    Multiple options can be combined with `|` operator. 0 means no options.
+ @param err err A pointer to receive error information.
+    Pass NULL if you don't need error information.
+ @return The number of bytes written (excluding the null terminator),
+    or 0 on failure.
+ */
+yyjson_api size_t yyjson_write_buf(char *buf, size_t buf_len,
+                                   const yyjson_doc *doc,
+                                   yyjson_write_flag flg,
+                                   yyjson_write_err *err);
+
 /**
  Write a document to JSON string.
 
@@ -1442,6 +1472,30 @@ yyjson_api bool yyjson_mut_write_fp(FILE *fp,
                                     const yyjson_alc *alc,
                                     yyjson_write_err *err);
 
+/**
+ Write a document into a buffer.
+ 
+ This function does not allocate memory, but the buffer must be larger than the
+ final JSON size to allow temporary space. See `API.md` for details.
+ 
+ @param buf The output buffer.
+    If the buffer is NULL, the function will fail and return 0.
+ @param buf_len The buffer length.
+    If the buf_len is too small, the function will fail and return 0.
+ @param doc doc The JSON document.
+    If this doc is NULL or has no root, the function will fail and return 0.
+ @param flg flg The JSON write options.
+    Multiple options can be combined with `|` operator. 0 means no options.
+ @param err err A pointer to receive error information.
+    Pass NULL if you don't need error information.
+ @return The number of bytes written (excluding the null terminator),
+    or 0 on failure.
+ */
+yyjson_api size_t yyjson_mut_write_buf(char *buf, size_t buf_len,
+                                       const yyjson_mut_doc *doc,
+                                       yyjson_write_flag flg,
+                                       yyjson_write_err *err);
+
 /**
  Write a document to JSON string.
 
@@ -1549,6 +1603,30 @@ yyjson_api bool yyjson_val_write_fp(FILE *fp,
                                     const yyjson_alc *alc,
                                     yyjson_write_err *err);
 
+/**
+ Write a value into a buffer.
+
+ This function does not allocate memory, but the buffer must be larger than the
+ final JSON size to allow temporary space. See `API.md` for details.
+
+ @param buf The output buffer.
+    If the buffer is NULL, the function will fail and return 0.
+ @param buf_len The buffer length.
+    If the buf_len is too small, the function will fail and return 0.
+ @param val The JSON root value.
+    If this parameter is NULL, the function will fail and return NULL.
+ @param flg flg The JSON write options.
+    Multiple options can be combined with `|` operator. 0 means no options.
+ @param err err A pointer to receive error information.
+    Pass NULL if you don't need error information.
+ @return The number of bytes written (excluding the null terminator),
+    or 0 on failure.
+ */
+yyjson_api size_t yyjson_val_write_buf(char *buf, size_t buf_len,
+                                       const yyjson_val *val,
+                                       yyjson_write_flag flg,
+                                       yyjson_write_err *err);
+
 /**
  Write a value to JSON string.
 
@@ -1651,6 +1729,30 @@ yyjson_api bool yyjson_mut_val_write_fp(FILE *fp,
                                         const yyjson_alc *alc,
                                         yyjson_write_err *err);
 
+/**
+ Write a value into a buffer.
+
+ This function does not allocate memory, but the buffer must be larger than the
+ final JSON size to allow temporary space. See `API.md` for details.
+
+ @param buf The output buffer.
+    If the buffer is NULL, the function will fail and return 0.
+ @param buf_len The buffer length.
+    If the buf_len is too small, the function will fail and return 0.
+ @param val The JSON root value.
+    If this parameter is NULL, the function will fail and return NULL.
+ @param flg flg The JSON write options.
+    Multiple options can be combined with `|` operator. 0 means no options.
+ @param err err A pointer to receive error information.
+    Pass NULL if you don't need error information.
+ @return The number of bytes written (excluding the null terminator),
+    or 0 on failure.
+ */
+yyjson_api size_t yyjson_mut_val_write_buf(char *buf, size_t buf_len,
+                                           const yyjson_mut_val *val,
+                                           yyjson_write_flag flg,
+                                           yyjson_write_err *err);
+
 /**
  Write a value to JSON string.
 
@@ -1895,7 +1997,7 @@ yyjson_api_inline bool yyjson_set_sint(yyjson_val *val, int64_t num);
 /** Set the value to int.
     Returns false if input is NULL or `val` is object or array.
     @warning This will modify the `immutable` value, use with caution. */
-yyjson_api_inline bool yyjson_set_int(yyjson_val *val, int num);
+yyjson_api_inline bool yyjson_set_int(yyjson_val *val, int64_t num);
 
 /** Set the value to float.
     Returns false if input is NULL or `val` is object or array.
@@ -2498,7 +2600,7 @@ yyjson_api_inline bool yyjson_mut_set_sint(yyjson_mut_val *val, int64_t num);
 /** Set the value to int.
     Returns false if input is NULL.
     @warning This function should not be used on an existing object or array. */
-yyjson_api_inline bool yyjson_mut_set_int(yyjson_mut_val *val, int num);
+yyjson_api_inline bool yyjson_mut_set_int(yyjson_mut_val *val, int64_t num);
 
 /** Set the value to float.
     Returns false if input is NULL.
@@ -5324,9 +5426,9 @@ yyjson_api_inline bool yyjson_set_sint(yyjson_val *val, int64_t num) {
     return true;
 }
 
-yyjson_api_inline bool yyjson_set_int(yyjson_val *val, int num) {
+yyjson_api_inline bool yyjson_set_int(yyjson_val *val, int64_t num) {
     if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false;
-    unsafe_yyjson_set_sint(val, (int64_t)num);
+    unsafe_yyjson_set_sint(val, num);
     return true;
 }
 
@@ -5877,9 +5979,9 @@ yyjson_api_inline bool yyjson_mut_set_sint(yyjson_mut_val *val, int64_t num) {
     return true;
 }
 
-yyjson_api_inline bool yyjson_mut_set_int(yyjson_mut_val *val, int num) {
+yyjson_api_inline bool yyjson_mut_set_int(yyjson_mut_val *val, int64_t num) {
     if (yyjson_unlikely(!val)) return false;
-    unsafe_yyjson_set_sint(val, (int64_t)num);
+    unsafe_yyjson_set_sint(val, num);
     return true;
 }
 

run_coverage.sh

@@ -0,0 +1,48 @@
+#!/bin/bash
+set -e  # 遇到错误立即退出
+
+# ================================
+# 1. 运行 fuzzer
+# ================================
+./build/linux/x86/release/RyanJson \
+  ./test/fuzzer/corpus \
+  -dict=./test/fuzzer/RyanJsonFuzzer.dict \
+  -timeout=4 \
+  -runs=99999999 \
+  -verbosity=0 \
+  -max_len=8192 \
+  -workers=5 \
+  -jobs=10
+
+
+# ================================
+# 2. 合并 profile 数据
+# ================================
+llvm-profdata merge -sparse default.profraw -o default.profdata
+
+# ================================
+# 3. 生成覆盖率报告（文本汇总）
+# ================================
+# 注意：llvm-cov report 只支持汇总统计，不支持行级参数
+# --show-functions       显示函数级覆盖率
+# --show-region-summary  显示区域覆盖率
+llvm-cov report ./build/linux/x86/release/RyanJson \
+  -instr-profile=default.profdata \
+  -show-mcdc-summary \
+  -show-functions \
+  -show-region-summary \
+  -sources ./test/fuzzer ./RyanJson
+
+# ================================
+# 4. 生成覆盖率报告（HTML详细）
+# ================================
+llvm-cov show ./build/linux/x86/release/RyanJson \
+  -instr-profile=default.profdata \
+  -format=html \
+  -output-dir=coverage/docs \
+  -show-mcdc-summary \
+  -show-expansions \
+  -show-regions \
+  -show-line-counts-or-regions \
+  -sources ./RyanJson
+#   -sources ./test/fuzzer ./RyanJson

test/RFC8259JsonData/y_1.json

@@ -0,0 +1 @@
+{"emoji":"😀"}

test/RFC8259JsonData/y_2.json

@@ -0,0 +1 @@
+{"rare":"𠀀"}

test/RFC8259JsonData/y_3.json

@@ -0,0 +1 @@
+{"mahjong":"🀄"}

test/RFC8259JsonData/y_array_nesting.json

@@ -0,0 +1 @@
+[[], [], [], [], [], [], [], [], [], []]

test/RFC8259JsonTest.c

@@ -1,312 +0,0 @@
-#include "RyanJsonTest.h"
-
-#define PrintfStrCmpEnable
-
-typedef int (*jsonParseData)(char *fileName, char *data, uint32_t len);
-
-static void *yy_malloc(void *ctx, size_t size)
-{
-	return v_malloc(size);
-}
-static void *yy_realloc(void *ctx, void *ptr, size_t old_size, size_t size)
-{
-	return v_realloc(ptr, size);
-}
-static void yy_free(void *ctx, void *ptr)
-{
-	v_free(ptr);
-}
-
-static yyjson_alc yyalc = {yy_malloc, yy_realloc, yy_free, NULL};
-
-/* Read a file, parse, render back, etc. */
-static int testFile(const char *path, jsonParseData jsonParseDataHandle)
-{
-
-	DIR *dir = NULL;
-	struct dirent *entry;
-
-	int path_len = strlen(path);
-	int count = 0;
-	int used_count = 0;
-	if (!path || !path_len || !(dir = opendir(path)))
-	{
-		goto fail;
-	}
-
-	while ((entry = readdir(dir)))
-	{
-
-		char *name = (char *)entry->d_name;
-
-		if (!name || !strlen(name))
-		{
-			continue;
-		}
-
-		if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0)
-		{
-			continue;
-		}
-
-		char aaa[300] = {0};
-		snprintf(aaa, sizeof(aaa), "%s/%s", path, name);
-
-		FILE *f = fopen(aaa, "rb");
-		if (f == NULL)
-		{
-			goto fail;
-		}
-
-		fseek(f, 0, SEEK_END);
-		long len = ftell(f);
-		fseek(f, 0, SEEK_SET);
-		char *data = (char *)malloc(len + 10);
-		fread(data, 1, len, f);
-		data[len] = '\0';
-		fclose(f);
-		int status = 0;
-
-		status = jsonParseDataHandle(name, data, len);
-
-		used_count++;
-		if (0 == strncmp("y_", name, 2))
-		{
-			if (0 == status)
-			{
-				count++;
-			}
-			else
-			{
-				printf("应该成功，但是失败: %s, len: %ld\n", data, len);
-			}
-		}
-		else if (0 == strncmp("n_", name, 2))
-		{
-			if (0 != status)
-			{
-				count++;
-			}
-			else
-			{
-				printf("应该失败，但是成功: %s, len: %ld\n", data, len);
-			}
-		}
-		else if (0 == strncmp("i_", name, 2))
-		{
-			count++;
-		}
-
-		int area = 0, use = 0;
-		v_mcheck(&area, &use);
-		if (use != (len + 10))
-		{
-			free(data);
-			printf("内存泄漏 %s len: %ld\r\n", data, len);
-			// printf("内存泄漏 %x len: %ld\r\n", (unsigned int)data, len);
-			// printf("内存泄漏 %c len: %ld\r\n", (int)data, len);
-			printf("|||----------->>> area = %d, size = %d\r\n", area, use);
-			break;
-		}
-		free(data);
-	}
-
-	closedir(dir);
-
-	printf("RFC 8259 JSON: (%d/%d)\r\n", count, used_count);
-	return 0;
-
-fail:
-	if (dir)
-	{
-		closedir(dir);
-	}
-
-	return -1;
-}
-
-/**
- * @brief RyanJson 测试程序
- *
- * @param fileName
- * @param data
- * @param len
- * @return int
- */
-static int RyanJsonParseData(char *fileName, char *data, uint32_t len)
-{
-
-	if (strcmp(fileName, "n_structure_100000_opening_arrays.json") == 0 || strcmp(fileName, "n_structure_open_array_object.json") == 0 ||
-	    strcmp(fileName, "n_structure_100000_opening_arrays.json") == 0)
-	{
-		return -1;
-	}
-
-	RyanJson_t json = RyanJsonParseOptions(data, len, RyanJsonTrue, NULL);
-	if (NULL == json)
-	{
-		return -1;
-	}
-
-#ifdef PrintfStrCmpEnable
-	char *str = RyanJsonPrint(json, 60, RyanJsonFalse, NULL);
-	if (NULL == str)
-	{
-		printf("反序列化失败: [%s]\n", data);
-		goto err;
-	}
-
-	RyanJsonMinify(data);
-	if (0 != strcmp(data, str))
-	{
-		printf("数据不一致 -- 原始: %s -- 序列化: %s\n", data, str);
-	}
-
-	RyanJsonFree(str);
-#endif
-
-	RyanJsonDelete(json);
-	return 0;
-
-err:
-	RyanJsonDelete(json);
-	return -1;
-}
-
-/**
- * @brief cJson测试程序
- *
- * @param fileName
- * @param data
- * @param len
- * @return int
- */
-static int cJSONParseData(char *fileName, char *data, uint32_t len)
-{
-
-	if (strcmp(fileName, "n_structure_100000_opening_arrays.json") == 0 || strcmp(fileName, "n_structure_open_array_object.json") == 0 ||
-	    strcmp(fileName, "n_structure_100000_opening_arrays.json") == 0)
-	{
-		return -1;
-	}
-
-	cJSON *json = cJSON_ParseWithLengthOpts(data, len + sizeof(""), NULL, RyanJsonTrue);
-	if (NULL == json)
-	{
-		return -1;
-	}
-
-#ifdef PrintfStrCmpEnable
-	char *str = cJSON_PrintBuffered(json, 60, RyanJsonFalse);
-	if (NULL == str)
-	{
-		printf("反序列化失败: [%s]\n", data);
-		goto err;
-	}
-
-	cJSON_Minify(data);
-	if (0 != strcmp(data, str))
-	{
-		printf("-- 原始: %s -- 序列化: %s\n", data, str);
-	}
-
-	cJSON_free(str);
-#endif
-
-	cJSON_Delete(json);
-	return 0;
-err:
-	cJSON_Delete(json);
-	return -1;
-}
-
-/**
- * @brief cJson测试程序
- *
- * @param fileName
- * @param data
- * @param len
- * @return int
- */
-static int yyjsonParseData(char *fileName, char *data, uint32_t len)
-{
-
-	if (strcmp(fileName, "n_structure_100000_opening_arrays.json") == 0 || strcmp(fileName, "n_structure_open_array_object.json") == 0 ||
-	    strcmp(fileName, "n_structure_100000_opening_arrays.json") == 0)
-	{
-		return -1;
-	}
-
-	yyjson_doc *doc = yyjson_read_opts(data, len, YYJSON_READ_NOFLAG, &yyalc, NULL);
-	if (NULL == doc)
-	{
-		return -1;
-	}
-
-#ifdef PrintfStrCmpEnable
-	char *str = yyjson_write_opts(doc, YYJSON_WRITE_NOFLAG, &yyalc, NULL, NULL);
-	if (NULL == str)
-	{
-		printf("反序列化失败: [%s]\n", data);
-		goto err;
-	}
-
-	cJSON_Minify(data);
-	if (0 != strcmp(data, str))
-	{
-		printf("-- 原始: %s -- 序列化: %s\n", data, str);
-	}
-
-	free(str);
-#endif
-
-	yyjson_doc_free(doc);
-	return 0;
-err:
-	yyjson_doc_free(doc);
-	return -1;
-}
-
-// RFC 8259 JSON Test Suite
-// https://github.com/nst/JSONTestSuite
-RyanJsonBool RFC8259JsonTest(void)
-{
-	int result = 0;
-	RyanJsonInitHooks(v_malloc, v_free, v_realloc);
-
-	cJSON_Hooks hooks = {.malloc_fn = v_malloc, .free_fn = v_free};
-	cJSON_InitHooks(&hooks);
-
-	printf("开始 RFC 8259 JSON 测试");
-
-	printf("\r\n--------------------------- RFC8259  RyanJson --------------------------\r\n");
-	result = testFile("./RyanJsonExample/RFC8259JsonData", RyanJsonParseData);
-	if (0 != result)
-	{
-		printf("%s:%d RyanJson RFC8259JsonTest fail\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	printf("\r\n--------------------------- RFC8259  cJSON --------------------------\r\n");
-	result = testFile("./RyanJsonExample/RFC8259JsonData", cJSONParseData);
-	if (0 != result)
-	{
-		printf("%s:%d cJSON RFC8259JsonTest fail\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	printf("\r\n--------------------------- RFC8259  yyjson --------------------------\r\n");
-	result = testFile("./RyanJsonExample/RFC8259JsonData", yyjsonParseData);
-	if (0 != result)
-	{
-		printf("%s:%d yyjson RFC8259JsonTest fail\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	displayMem();
-	return RyanJsonTrue;
-
-err:
-	displayMem();
-	return RyanJsonFalse;
-}

test/RyanJsonBaseTest.c

@@ -1,1202 +0,0 @@
-
-#include <stdio.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <math.h>
-#include <time.h>
-
-#include "RyanJson.h"
-#include "cJSON.h"
-#include "valloc.h"
-
-/* --------------------------------------- jsonTest ------------------------------------------- */
-// !(fabs(RyanJsonGetDoubleValue(RyanJsonGetObjectToKey(json, "double")) - 16.89) < 1e-6)
-static RyanJsonBool compare_double(double a, double b)
-{
-	double maxVal = fabs(a) > fabs(b) ? fabs(a) : fabs(b);
-	return (fabs(a - b) <= maxVal * DBL_EPSILON);
-}
-
-static int rootNodeCheckTest(RyanJson_t json)
-{
-	if (!RyanJsonIsInt(RyanJsonGetObjectToKey(json, "inter")) || 16 != RyanJsonGetIntValue(RyanJsonGetObjectToKey(json, "inter")))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	if (!RyanJsonIsDouble(RyanJsonGetObjectToKey(json, "double")) || !compare_double(RyanJsonGetDoubleValue(RyanJsonGetObjectToKey(json, "double")), 16.89))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	if (!RyanJsonIsString(RyanJsonGetObjectToKey(json, "string")) || strcmp(RyanJsonGetStringValue(RyanJsonGetObjectToKey(json, "string")), "hello"))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	if (!RyanJsonIsBool(RyanJsonGetObjectToKey(json, "boolTrue")) || RyanJsonGetBoolValue(RyanJsonGetObjectToKey(json, "boolTrue")) != RyanJsonTrue)
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	if (!RyanJsonIsBool(RyanJsonGetObjectToKey(json, "boolFalse")) || RyanJsonGetBoolValue(RyanJsonGetObjectToKey(json, "boolFalse")) != RyanJsonFalse)
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	if (!RyanJsonIsNull(RyanJsonGetObjectToKey(json, "null")))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	return 0;
-}
-
-static int itemNodeCheckTest(RyanJson_t json)
-{
-	RyanJson_t item = RyanJsonGetObjectToKey(json, "item");
-	if (0 != rootNodeCheckTest(item))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	return 0;
-}
-
-static int arrayNodeCheckTest(RyanJson_t json)
-{
-	RyanJson_t item = NULL;
-
-	// 判断是不是数组类型
-	if (!RyanJsonIsArray(RyanJsonGetObjectToKey(json, "arrayInt")))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	if (!RyanJsonIsArray(RyanJsonGetObjectToKey(json, "arrayDouble")))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	if (!RyanJsonIsArray(RyanJsonGetObjectToKey(json, "arrayString")))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	if (!RyanJsonIsArray(RyanJsonGetObjectToKey(json, "array")))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	/**
-	 * @brief 检查弱类型数组
-	 *
-	 */
-	//   array: [16, 16.89, "hello", true, false, null],
-	if (!RyanJsonIsInt(RyanJsonGetObjectByIndex(RyanJsonGetObjectToKey(json, "array"), 0)) || 16 != RyanJsonGetIntValue(RyanJsonGetObjectByIndex(RyanJsonGetObjectToKey(json, "array"), 0)))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	if (!RyanJsonIsDouble(RyanJsonGetObjectByIndex(RyanJsonGetObjectToKey(json, "array"), 1)) ||
-	    !compare_double(RyanJsonGetDoubleValue(RyanJsonGetObjectByIndex(RyanJsonGetObjectToKey(json, "array"), 1)), 16.89))
-	{
-		printf("%s:%d 解析失败 %f\r\n", __FILE__, __LINE__, RyanJsonGetDoubleValue(RyanJsonGetObjectByIndex(RyanJsonGetObjectToKey(json, "array"), 1)));
-		return -1;
-	}
-
-	if (!RyanJsonIsString(RyanJsonGetObjectByIndex(RyanJsonGetObjectToKey(json, "array"), 2)) ||
-	    0 != strcmp(RyanJsonGetStringValue(RyanJsonGetObjectByIndex(RyanJsonGetObjectToKey(json, "array"), 2)), "hello"))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	if (!RyanJsonIsBool(RyanJsonGetObjectByIndex(RyanJsonGetObjectToKey(json, "array"), 3)) ||
-	    RyanJsonGetBoolValue(RyanJsonGetObjectByIndex(RyanJsonGetObjectToKey(json, "array"), 3)) != RyanJsonTrue)
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	if (!RyanJsonIsBool(RyanJsonGetObjectByIndex(RyanJsonGetObjectToKey(json, "array"), 4)) ||
-	    RyanJsonGetBoolValue(RyanJsonGetObjectByIndex(RyanJsonGetObjectToKey(json, "array"), 4)) != RyanJsonFalse)
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	if (!RyanJsonIsNull(RyanJsonGetObjectByIndex(RyanJsonGetObjectToKey(json, "array"), 5)))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	/**
-	 * @brief 检查强类型数组
-	 *
-	 */
-	for (uint32_t count = 0; count < RyanJsonGetSize(RyanJsonGetObjectToKey(json, "arrayInt")); count++)
-	{
-		item = RyanJsonGetObjectByIndex(RyanJsonGetObjectToKey(json, "arrayInt"), count);
-		if (!RyanJsonIsInt(item) || 16 != RyanJsonGetIntValue(item))
-		{
-			printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-			return -1;
-		}
-	}
-
-	for (uint32_t count = 0; count < RyanJsonGetSize(RyanJsonGetObjectToKey(json, "arrayDouble")); count++)
-	{
-		item = RyanJsonGetObjectByIndex(RyanJsonGetObjectToKey(json, "arrayDouble"), count);
-		if (!RyanJsonIsDouble(item) || fabs(RyanJsonGetDoubleValue(item) - 16.8) < 0.001)
-		{
-			printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-			return -1;
-		}
-	}
-
-	for (uint32_t count = 0; count < RyanJsonGetSize(RyanJsonGetObjectToKey(json, "arrayString")); count++)
-	{
-		item = RyanJsonGetObjectByIndex(RyanJsonGetObjectToKey(json, "arrayString"), count);
-		if (!RyanJsonIsString(item) || strcmp(RyanJsonGetStringValue(item), "hello"))
-		{
-			printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-			return -1;
-		}
-	}
-
-	if (6 != RyanJsonGetSize(RyanJsonGetObjectToKey(json, "array")))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	return 0;
-}
-
-static int arrayItemNodeCheckTest(RyanJson_t json)
-{
-	if (!RyanJsonIsArray(RyanJsonGetObjectToKey(json, "arrayItem")))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	if (0 != rootNodeCheckTest(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json, "arrayItem"), 0)))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	if (0 != rootNodeCheckTest(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json, "arrayItem"), 1)))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-	return 0;
-}
-
-/* --------------------------------------------------------------------- */
-
-static int loadJsonTest()
-{
-	char *str = NULL;
-	RyanJson_t json;
-	char jsonstr[] = "{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,\"item\":{\"inter\":16,\"double\":16.89,\"string\":\"hello\","
-			 "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89],\"arrayString\":[\"hello\",\"hello\","
-			 "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
-			 "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}]}";
-
-	json = RyanJsonParse(jsonstr);
-	if (json == NULL)
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	str = RyanJsonPrint(json, 250, RyanJsonFalse, NULL);
-	if (strcmp(str, jsonstr) != 0)
-	{
-		printf("%s:%d 序列化与反序列化后的数据不对应\r\n", __FILE__, __LINE__);
-		RyanJsonFree(str);
-		RyanJsonDelete(json);
-		return -1;
-	}
-
-	RyanJsonFree(str);
-
-	if (0 != rootNodeCheckTest(json))
-	{
-		RyanJsonDelete(json);
-		printf("%s:%d rootNodeCheckTest fail\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	if (0 != itemNodeCheckTest(json))
-	{
-		RyanJsonDelete(json);
-		printf("%s:%d itemNodeCheckTest fail\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	if (0 != arrayNodeCheckTest(json))
-	{
-		RyanJsonDelete(json);
-		printf("%s:%d arrayNodeCheckTest fail\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	if (0 != arrayItemNodeCheckTest(json))
-	{
-		RyanJsonDelete(json);
-		printf("%s:%d arrayItemNodeCheckTest fail\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-	RyanJsonDelete(json);
-
-	/**
-	 * @brief 测试序列化错误json结构
-	 *
-	 */
-	// \"inter\":16poi,  无效数字
-	json = RyanJsonParse("{\"inter\":16poi,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,\"item\":{\"inter\":16,\"double\":16.89,\"string\":\"hello\","
-			     "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89],\"arrayString\":[\"hello\",\"hello\","
-			     "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
-			     "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}]}");
-	if (json != NULL)
-	{
-		RyanJsonDelete(json);
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	// \"double\":16.8yu9,,  无效浮点数
-	json = RyanJsonParse("{\"inter\":16,\"double\":16.8yu9,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,\"item\":{\"inter\":16,\"double\":16.89,\"string\":\"hello\","
-			     "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89],\"arrayString\":[\"hello\",\"hello\","
-			     "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
-			     "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}]}");
-	if (json != NULL)
-	{
-		RyanJsonDelete(json);
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	// boolTrue 设置为 tru
-	json = RyanJsonParse("{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":tru,\"boolFalse\":false,\"null\":null,\"item\":{\"inter\":16,\"double\":16.89,\"string\":\"hello\","
-			     "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89],\"arrayString\":[\"hello\",\"hello\","
-			     "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
-			     "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}]}");
-	if (json != NULL)
-	{
-		RyanJsonDelete(json);
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	// boolFalse 设置为 fale
-	json = RyanJsonParse("{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":fale,\"null\":null,\"item\":{\"inter\":16,\"double\":16.89,\"string\":\"hello\","
-			     "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89],\"arrayString\":[\"hello\",\"hello\","
-			     "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
-			     "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}]}");
-	if (json != NULL)
-	{
-		RyanJsonDelete(json);
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	// null 设置为 nul
-	json = RyanJsonParse("{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":nul,\"item\":{\"inter\":16,\"double\":16.89,\"string\":\"hello\","
-			     "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89],\"arrayString\":[\"hello\",\"hello\","
-			     "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
-			     "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}]}");
-	if (json != NULL)
-	{
-		RyanJsonDelete(json);
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	// null 设置为 NULL
-	json = RyanJsonParse("{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":NULL,\"item\":{\"inter\":16,\"double\":16.89,\"string\":\"hello\","
-			     "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89],\"arrayString\":[\"hello\",\"hello\","
-			     "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
-			     "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}]}");
-	if (json != NULL)
-	{
-		RyanJsonDelete(json);
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	// \"inter\":16后面少个,
-	json = RyanJsonParse("{\"inter\":16\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,\"item\":{\"inter\":16,\"double\":16.89,\"string\":\"hello\","
-			     "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89],\"arrayString\":[\"hello\",\"hello\","
-			     "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
-			     "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}]}");
-	if (json != NULL)
-	{
-		RyanJsonDelete(json);
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	// array数组项少一个,
-	json = RyanJsonParse("{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,\"item\":{\"inter\":16,\"double\":16.89,\"string\":\"hello\","
-			     "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89],\"arrayString\":[\"hello\",\"hello\","
-			     "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
-			     "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}]}");
-	if (json != NULL)
-	{
-		RyanJsonDelete(json);
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	// \"item:{\"inter\":16,\"  少一个"
-	json = RyanJsonParse("{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,\"item:{\"inter\":16,\"double\":16.89,\"string\":\"hello\","
-			     "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89],\"arrayString\":[\"hello\",\"hello\","
-			     "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
-			     "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}]}");
-	if (json != NULL)
-	{
-		RyanJsonDelete(json);
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	// \"item\":{\"inter\":16,double\"  少一个"
-	json = RyanJsonParse("{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,\"item\":{\"inter\":16,double\":16.89,\"string\":\"hello\","
-			     "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89],\"arrayString\":[\"hello\",\"hello\","
-			     "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
-			     "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}]}");
-	if (json != NULL)
-	{
-		RyanJsonDelete(json);
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	// \"item\":{\"inter\":16,\"\"double\"  多一个"
-	json = RyanJsonParse("{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,\"item\":{\"inter\":16,\"\"double\":16.89,\"string\":\"hello\","
-			     "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89],\"arrayString\":[\"hello\",\"hello\","
-			     "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
-			     "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}]}");
-	if (json != NULL)
-	{
-		RyanJsonDelete(json);
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	// \"item\":{\"inter\":16\",\"double\"  多一个"
-	json = RyanJsonParse("{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,\"item\":{\"inter\":16\",\"double\":16.89,\"string\":\"hello\","
-			     "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89],\"arrayString\":[\"hello\",\"hello\","
-			     "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
-			     "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}]}");
-	if (json != NULL)
-	{
-		RyanJsonDelete(json);
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	// \"arrayInt\":[16,16,16m,16,16]  无效数组数字
-	json = RyanJsonParse("{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,\"item\":{\"inter\":16,\"double\":16.89,\"string\":\"hello\","
-			     "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16m,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89],\"arrayString\":[\"hello\",\"hello\","
-			     "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
-			     "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}]}");
-	if (json != NULL)
-	{
-		RyanJsonDelete(json);
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-	return 0;
-}
-
-static int createJsonTest()
-{
-	RyanJson_t jsonRoot, item;
-
-	// 对象生成测试
-	jsonRoot = RyanJsonCreateObject();
-	RyanJsonAddIntToObject(jsonRoot, "inter", 16);
-	RyanJsonAddDoubleToObject(jsonRoot, "double", 16.89);
-	RyanJsonAddStringToObject(jsonRoot, "string", "hello");
-	RyanJsonAddBoolToObject(jsonRoot, "boolTrue", RyanJsonTrue);
-	RyanJsonAddBoolToObject(jsonRoot, "boolFalse", RyanJsonFalse);
-	RyanJsonAddNullToObject(jsonRoot, "null");
-
-	/**
-	 * @brief 对象添加测试
-	 *
-	 */
-	item = RyanJsonCreateObject();
-	RyanJsonAddIntToObject(item, "inter", 16);
-	RyanJsonAddDoubleToObject(item, "double", 16.89);
-	RyanJsonAddStringToObject(item, "string", "hello");
-	RyanJsonAddBoolToObject(item, "boolTrue", RyanJsonTrue);
-	RyanJsonAddBoolToObject(item, "boolFalse", RyanJsonFalse);
-	RyanJsonAddNullToObject(item, "null");
-	RyanJsonAddItemToObject(jsonRoot, "item", item);
-
-	/**
-	 * @brief 数组添加测试
-	 *
-	 */
-	int arrayInt[] = {16, 16, 16, 16, 16};
-	RyanJsonAddItemToObject(jsonRoot, "arrayInt", RyanJsonCreateIntArray(arrayInt, sizeof(arrayInt) / sizeof(arrayInt[0])));
-
-	double arrayDouble[] = {16.89, 16.89, 16.89, 16.89, 16.89};
-	RyanJsonAddItemToObject(jsonRoot, "arrayDouble", RyanJsonCreateDoubleArray(arrayDouble, sizeof(arrayDouble) / sizeof(arrayDouble[0])));
-
-	const char *arrayString[] = {"hello", "hello", "hello", "hello", "hello"};
-	RyanJsonAddItemToObject(jsonRoot, "arrayString", RyanJsonCreateStringArray(arrayString, sizeof(arrayString) / sizeof(arrayString[0])));
-
-	RyanJson_t array = RyanJsonCreateArray();
-	RyanJsonAddIntToArray(array, 16);
-	RyanJsonAddDoubleToArray(array, 16.89);
-	RyanJsonAddStringToArray(array, "hello");
-	RyanJsonAddBoolToArray(array, RyanJsonTrue);
-	RyanJsonAddBoolToArray(array, RyanJsonFalse);
-	RyanJsonAddNullToArray(array);
-	RyanJsonAddItemToObject(jsonRoot, "array", array);
-
-	/**
-	 * @brief 对象数组测试
-	 *
-	 */
-	RyanJson_t arrayItem = RyanJsonCreateArray();
-	item = RyanJsonCreateObject();
-	RyanJsonAddIntToObject(item, "inter", 16);
-	RyanJsonAddDoubleToObject(item, "double", 16.89);
-	RyanJsonAddStringToObject(item, "string", "hello");
-	RyanJsonAddBoolToObject(item, "boolTrue", RyanJsonTrue);
-	RyanJsonAddBoolToObject(item, "boolFalse", RyanJsonFalse);
-	RyanJsonAddNullToObject(item, "null");
-	RyanJsonAddItemToObject(arrayItem, "item", item);
-
-	item = RyanJsonCreateObject();
-	RyanJsonAddIntToObject(item, "inter", 16);
-	RyanJsonAddDoubleToObject(item, "double", 16.89);
-	RyanJsonAddStringToObject(item, "string", "hello");
-	RyanJsonAddBoolToObject(item, "boolTrue", RyanJsonTrue);
-	RyanJsonAddBoolToObject(item, "boolFalse", RyanJsonFalse);
-	RyanJsonAddNullToObject(item, "null");
-	RyanJsonAddItemToObject(arrayItem, "item", item);
-
-	RyanJsonAddItemToObject(jsonRoot, "arrayItem", arrayItem);
-
-	if (0 != rootNodeCheckTest(jsonRoot))
-	{
-		RyanJsonDelete(jsonRoot);
-		printf("%s:%d rootNodeCheckTest fail\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	if (0 != itemNodeCheckTest(jsonRoot))
-	{
-		RyanJsonDelete(jsonRoot);
-		printf("%s:%d itemNodeCheckTest fail\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	if (0 != arrayNodeCheckTest(jsonRoot))
-	{
-		RyanJsonDelete(jsonRoot);
-		printf("%s:%d arrayNodeCheckTest fail\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	if (0 != arrayItemNodeCheckTest(jsonRoot))
-	{
-		RyanJsonDelete(jsonRoot);
-		printf("%s:%d arrayItemNodeCheckTest fail\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-	RyanJsonDelete(jsonRoot);
-
-	return 0;
-}
-
-static int changeJsonTest()
-{
-
-	char jsonstr[] = "{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,\"item\":{\"inter\":16,\"double\":16.89,\"string\":\"hello\","
-			 "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89],\"arrayString\":[\"hello\",\"hello\","
-			 "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
-			 "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}]}";
-
-	RyanJson_t json = RyanJsonParse(jsonstr);
-	if (json == NULL)
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		return -1;
-	}
-
-	/**
-	 * @brief 修改对应类型
-	 *
-	 */
-	RyanJsonChangeIntValue(RyanJsonGetObjectToKey(json, "inter"), 20);
-	if (!RyanJsonIsInt(RyanJsonGetObjectToKey(json, "inter")) || 20 != RyanJsonGetIntValue(RyanJsonGetObjectToKey(json, "inter")))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	RyanJsonChangeDoubleValue(RyanJsonGetObjectToKey(json, "double"), 20.89);
-	if (!RyanJsonIsDouble(RyanJsonGetObjectToKey(json, "double")) || !compare_double(RyanJsonGetDoubleValue(RyanJsonGetObjectToKey(json, "double")), 20.89))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	RyanJsonChangeStringValue(RyanJsonGetObjectToKey(json, "string"), "world");
-	if (!RyanJsonIsString(RyanJsonGetObjectToKey(json, "string")) || strcmp(RyanJsonGetStringValue(RyanJsonGetObjectToKey(json, "string")), "world"))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	RyanJsonChangeBoolValue(RyanJsonGetObjectToKey(json, "boolTrue"), RyanJsonFalse);
-	if (!RyanJsonIsBool(RyanJsonGetObjectToKey(json, "boolTrue")) || RyanJsonGetBoolValue(RyanJsonGetObjectToKey(json, "boolTrue")) != RyanJsonFalse)
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	RyanJsonChangeBoolValue(RyanJsonGetObjectToKey(json, "boolFalse"), RyanJsonTrue);
-	if (!RyanJsonIsBool(RyanJsonGetObjectToKey(json, "boolFalse")) || RyanJsonGetBoolValue(RyanJsonGetObjectToKey(json, "boolFalse")) != RyanJsonTrue)
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	/* ---------------------------------- replace使用 -------------------------------------*/
-	// 数组没有key, replace的子项不能有key, 函数内部没有做逻辑判断，会造成内存泄漏
-	RyanJsonReplaceByIndex(RyanJsonGetObjectToKey(json, "arrayInt"), 0, RyanJsonCreateString(NULL, "arrayInt"));
-	if (!RyanJsonIsString(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json, "arrayInt"), 0)) ||
-	    strcmp(RyanJsonGetStringValue(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json, "arrayInt"), 0)), "arrayInt"))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	RyanJsonReplaceByIndex(RyanJsonGetObjectToKey(json, "arrayItem"), 0, RyanJsonCreateString(NULL, "arrayItem"));
-	if (!RyanJsonIsString(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json, "arrayItem"), 0)) ||
-	    strcmp(RyanJsonGetStringValue(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json, "arrayItem"), 0)), "arrayItem"))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	// 对象必须包含key, 如果创建的对象key为null会引起内存错误
-	RyanJsonReplaceByKey(json, "arrayString", RyanJsonCreateString("", "arrayString"));
-	if (!RyanJsonIsString(RyanJsonGetObjectToKey(json, "arrayString")) || strcmp(RyanJsonGetStringValue(RyanJsonGetObjectToKey(json, "arrayString")), "arrayString"))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	// 修改数组节点为对象节点
-	RyanJsonReplaceByKey(json, "arrayDouble", RyanJsonDuplicate(RyanJsonGetObjectToKey(json, "item")));
-	if (!RyanJsonIsObject(RyanJsonGetObjectToKey(json, "arrayDouble")) || -1 == rootNodeCheckTest(RyanJsonGetObjectToKey(json, "arrayDouble")))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-
-		goto err;
-	}
-
-	/**
-	 * @brief 对象子项删除测试
-	 *
-	 */
-	RyanJsonDeleteByIndex(json, 0);
-	if (RyanJsonGetObjectToKey(json, "inter"))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	RyanJsonDeleteByKey(json, "double");
-	if (RyanJsonGetObjectToKey(json, "double"))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	/**
-	 * @brief 数组对象子项删除测试
-	 *
-	 */
-	RyanJsonDeleteByIndex(RyanJsonGetObjectToKey(json, "array"), 0);
-	if (RyanJsonGetSize(RyanJsonGetObjectToKey(json, "array")) != 5)
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	// str = RyanJsonPrint(json, 1024, RyanJsonTrue, NULL);
-	// printf("aa %s\r\n", str);
-	// RyanJsonFree(str);
-	RyanJsonDelete(json);
-	return 0;
-
-err:
-	RyanJsonDelete(json);
-	return -1;
-}
-
-static int compareJsonTest()
-{
-	char jsonstr[] = "{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,\"item\":{\"inter\":16,\"double\":16.89,\"string\":\"hello\","
-			 "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89],\"arrayString\":[\"hello\",\"hello\","
-			 "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
-			 "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}]}";
-	// char jsonstr[] = "{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}";
-
-	RyanJson_t json = RyanJsonParse(jsonstr);
-	RyanJson_t json2 = RyanJsonParse(jsonstr);
-
-	// 比较函数
-	if (RyanJsonTrue != RyanJsonCompare(json, json2))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	RyanJsonDelete(json2);
-	json2 = RyanJsonParse(jsonstr);
-	RyanJsonAddStringToObject(json2, "test", "hello");
-	if (RyanJsonFalse != RyanJsonCompare(json, json2))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	RyanJsonDelete(json2);
-	json2 = RyanJsonParse(jsonstr);
-	RyanJsonAddIntToObject(json2, "test", 1);
-	if (RyanJsonFalse != RyanJsonCompare(json, json2))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	RyanJsonDelete(json2);
-	json2 = RyanJsonParse(jsonstr);
-	RyanJsonAddDoubleToObject(json2, "test", 2.0);
-	if (RyanJsonFalse != RyanJsonCompare(json, json2))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	RyanJsonDelete(json2);
-	json2 = RyanJsonParse(jsonstr);
-	RyanJsonAddBoolToObject(json2, "test", RyanJsonTrue);
-	if (RyanJsonFalse != RyanJsonCompare(json, json2))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	RyanJsonDelete(json2);
-	json2 = RyanJsonParse(jsonstr);
-	RyanJsonAddNullToObject(json2, "test");
-	if (RyanJsonFalse != RyanJsonCompare(json, json2))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	RyanJsonDelete(json2);
-	json2 = RyanJsonParse(jsonstr);
-	RyanJsonAddIntToArray(RyanJsonGetObjectToKey(json2, "arrayInt"), 2);
-	if (RyanJsonFalse != RyanJsonCompare(json, json2))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	RyanJsonDelete(json2);
-	json2 = RyanJsonParse(jsonstr);
-	RyanJsonAddDoubleToArray(RyanJsonGetObjectToKey(json2, "arrayDouble"), 2.0);
-	if (RyanJsonFalse != RyanJsonCompare(json, json2))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	RyanJsonDelete(json2);
-	json2 = RyanJsonParse(jsonstr);
-	RyanJsonAddStringToArray(RyanJsonGetObjectToKey(json2, "arrayString"), "hello");
-	if (RyanJsonFalse != RyanJsonCompare(json, json2))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	RyanJsonDelete(json2);
-	json2 = RyanJsonParse(jsonstr);
-	RyanJsonAddItemToArray(RyanJsonGetObjectToKey(json2, "arrayItem"), RyanJsonCreateString("test", "hello"));
-	if (RyanJsonFalse != RyanJsonCompare(json, json2))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	RyanJsonDelete(json2);
-	json2 = RyanJsonParse(jsonstr);
-	RyanJsonChangeKey(RyanJsonGetObjectToKey(json2, "inter"), "int2");
-	if (RyanJsonFalse != RyanJsonCompare(json, json2))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	RyanJsonDelete(json2);
-	json2 = RyanJsonParse(jsonstr);
-	RyanJsonChangeIntValue(RyanJsonGetObjectToKey(json2, "inter"), 17);
-	if (RyanJsonFalse != RyanJsonCompare(json, json2))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	RyanJsonDelete(json2);
-	json2 = RyanJsonParse(jsonstr);
-	RyanJsonChangeDoubleValue(RyanJsonGetObjectToKey(json2, "double"), 20.89);
-	if (RyanJsonFalse != RyanJsonCompare(json, json2))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	RyanJsonDelete(json2);
-	json2 = RyanJsonParse(jsonstr);
-	RyanJsonChangeStringValue(RyanJsonGetObjectToKey(json2, "string"), "49");
-	if (RyanJsonFalse != RyanJsonCompare(json, json2))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	RyanJsonDelete(json2);
-	json2 = RyanJsonParse(jsonstr);
-	RyanJsonChangeBoolValue(RyanJsonGetObjectToKey(json2, "boolTrue"), RyanJsonFalse);
-	if (RyanJsonFalse != RyanJsonCompare(json, json2))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	RyanJsonDelete(json2);
-	json2 = RyanJsonParse(jsonstr);
-	RyanJsonChangeBoolValue(RyanJsonGetObjectToKey(json2, "item", "boolTrue"), RyanJsonFalse);
-	if (RyanJsonFalse != RyanJsonCompare(json, json2))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	RyanJsonDelete(json2);
-	json2 = RyanJsonParse(jsonstr);
-	RyanJsonChangeIntValue(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json2, "arrayInt"), 0), 17);
-	if (RyanJsonFalse != RyanJsonCompare(json, json2))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	RyanJsonDelete(json2);
-	json2 = RyanJsonParse(jsonstr);
-	RyanJsonChangeDoubleValue(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json2, "arrayDouble"), 0), 20.89);
-	if (RyanJsonFalse != RyanJsonCompare(json, json2))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	RyanJsonDelete(json2);
-	json2 = RyanJsonParse(jsonstr);
-	RyanJsonChangeStringValue(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json2, "arrayString"), 0), "20.89");
-	if (RyanJsonFalse != RyanJsonCompare(json, json2))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	RyanJsonDelete(json2);
-	json2 = RyanJsonParse(jsonstr);
-	RyanJsonChangeIntValue(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json2, "array"), 0), 17);
-	if (RyanJsonFalse != RyanJsonCompare(json, json2))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	RyanJsonDelete(json2);
-	json2 = RyanJsonParse(jsonstr);
-	RyanJsonChangeIntValue(RyanJsonGetObjectToKey(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json2, "arrayItem"), 0), "inter"), 17);
-	if (RyanJsonFalse != RyanJsonCompare(json, json2))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	RyanJsonDelete(json2);
-	json2 = RyanJsonParse(jsonstr);
-	RyanJsonDeleteByKey(json2, "arrayItem");
-	if (RyanJsonFalse != RyanJsonCompare(json, json2))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	RyanJsonDelete(json2);
-	json2 = RyanJsonParse(jsonstr);
-	RyanJsonDeleteByIndex(RyanJsonGetObjectToKey(json2, "arrayInt"), 2);
-	if (RyanJsonFalse != RyanJsonCompare(json, json2))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	RyanJsonDelete(json2);
-	json2 = RyanJsonParse(jsonstr);
-	RyanJsonDeleteByIndex(RyanJsonGetObjectToKey(json2, "arrayItem"), 0);
-	if (RyanJsonFalse != RyanJsonCompare(json, json2))
-	{
-		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
-		goto err;
-	}
-
-	RyanJsonDelete(json);
-	RyanJsonDelete(json2);
-	return 0;
-
-err:
-	RyanJsonDelete(json);
-	RyanJsonDelete(json2);
-	return -1;
-}
-
-static int duplicateTest()
-{
-	RyanJson_t json, dupItem, jsonRoot = NULL;
-	char jsonstr[] = "{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,\"item\":{\"inter\":16,\"double\":16.89,\"string\":\"hello\","
-			 "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89],\"arrayString\":[\"hello\",\"hello\","
-			 "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
-			 "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}]}";
-
-	/**
-	 * @brief 普通类型
-	 *
-	 */
-	json = RyanJsonParse(jsonstr);
-	dupItem = RyanJsonDuplicate(RyanJsonGetObjectToKey(json, "inter"));
-	if (RyanJsonFalse == RyanJsonCompare(dupItem, RyanJsonGetObjectToKey(json, "inter")))
-	{
-		goto err;
-	}
-	RyanJsonDelete(dupItem);
-
-	dupItem = RyanJsonDuplicate(RyanJsonGetObjectToKey(json, "inter"));
-	RyanJsonAddItemToObject(json, "test", dupItem);
-	if (RyanJsonFalse == RyanJsonCompare(RyanJsonGetObjectToKey(json, "test", "inter"), RyanJsonGetObjectToKey(json, "inter")))
-	{
-		goto err;
-	}
-	RyanJsonDelete(RyanJsonDetachByKey(json, "test"));
-
-	dupItem = RyanJsonDuplicate(RyanJsonGetObjectToKey(json, "inter"));
-	RyanJsonAddItemToObject(json, "test", dupItem);
-	if (RyanJsonFalse == RyanJsonCompare(RyanJsonGetObjectToKey(json, "test", "inter"), RyanJsonGetObjectToKey(json, "inter")))
-	{
-		goto err;
-	}
-	RyanJsonDelete(json);
-
-	json = RyanJsonParse(jsonstr);
-	dupItem = RyanJsonDuplicate(RyanJsonGetObjectToKey(json, "inter"));
-	RyanJsonAddItemToObject(json, "test", dupItem);
-	if (RyanJsonFalse == RyanJsonCompare(RyanJsonGetObjectToKey(json, "test", "inter"), RyanJsonGetObjectToKey(json, "inter")))
-	{
-		goto err;
-	}
-	RyanJsonDelete(RyanJsonDetachByKey(json, "test"));
-	RyanJsonDelete(json);
-
-	/**
-	 * @brief 对象类型
-	 *
-	 */
-	json = RyanJsonParse(jsonstr);
-	dupItem = RyanJsonDuplicate(RyanJsonGetObjectToKey(json, "item"));
-	if (RyanJsonFalse == RyanJsonCompare(dupItem, RyanJsonGetObjectToKey(json, "item")))
-	{
-		goto err;
-	}
-	RyanJsonDelete(dupItem);
-
-	dupItem = RyanJsonDuplicate(RyanJsonGetObjectToKey(json, "item"));
-	RyanJsonAddItemToObject(json, "test", dupItem);
-	if (RyanJsonFalse == RyanJsonCompare(RyanJsonGetObjectToKey(json, "test"), RyanJsonGetObjectToKey(json, "item")))
-	{
-		goto err;
-	}
-	RyanJsonDelete(RyanJsonDetachByKey(json, "test"));
-
-	dupItem = RyanJsonDuplicate(RyanJsonGetObjectToKey(json, "item"));
-	RyanJsonAddItemToObject(json, "test", dupItem);
-	if (RyanJsonFalse == RyanJsonCompare(RyanJsonGetObjectToKey(json, "test"), RyanJsonGetObjectToKey(json, "item")))
-	{
-		goto err;
-	}
-	RyanJsonDelete(json);
-
-	json = RyanJsonParse(jsonstr);
-	dupItem = RyanJsonDuplicate(RyanJsonGetObjectToKey(json, "item"));
-	RyanJsonAddItemToObject(json, "test", dupItem);
-	if (RyanJsonFalse == RyanJsonCompare(RyanJsonGetObjectToKey(json, "test"), RyanJsonGetObjectToKey(json, "item")))
-	{
-		goto err;
-	}
-	RyanJsonDelete(RyanJsonDetachByKey(json, "test"));
-	RyanJsonDelete(json);
-
-	/**
-	 * @brief 数组类型
-	 *
-	 */
-	json = RyanJsonParse(jsonstr);
-	dupItem = RyanJsonDuplicate(RyanJsonGetObjectToKey(json, "arrayItem"));
-	if (RyanJsonFalse == RyanJsonCompare(dupItem, RyanJsonGetObjectToKey(json, "arrayItem")))
-	{
-		goto err;
-	}
-	RyanJsonDelete(dupItem);
-
-	dupItem = RyanJsonDuplicate(RyanJsonGetObjectToKey(json, "arrayItem"));
-	RyanJsonAddItemToObject(json, "test", dupItem);
-	if (RyanJsonFalse == RyanJsonCompare(RyanJsonGetObjectToKey(json, "test"), RyanJsonGetObjectToKey(json, "arrayItem")))
-	{
-		goto err;
-	}
-	RyanJsonDelete(RyanJsonDetachByKey(json, "test"));
-
-	dupItem = RyanJsonDuplicate(RyanJsonGetObjectToKey(json, "arrayItem"));
-	RyanJsonAddItemToObject(json, "test", dupItem);
-	if (RyanJsonFalse == RyanJsonCompare(RyanJsonGetObjectToKey(json, "test"), RyanJsonGetObjectToKey(json, "arrayItem")))
-	{
-		goto err;
-	}
-	RyanJsonDelete(json);
-
-	json = RyanJsonParse(jsonstr);
-	dupItem = RyanJsonDuplicate(RyanJsonGetObjectToKey(json, "arrayItem"));
-	RyanJsonAddItemToObject(json, "test", dupItem);
-	if (RyanJsonFalse == RyanJsonCompare(RyanJsonGetObjectToKey(json, "test"), RyanJsonGetObjectToKey(json, "arrayItem")))
-	{
-		goto err;
-	}
-	RyanJsonDelete(RyanJsonDetachByKey(json, "test"));
-	RyanJsonDelete(json);
-
-	json = RyanJsonParse(jsonstr);
-	jsonRoot = RyanJsonCreateObject();
-	RyanJsonAddBoolToObject(jsonRoot, "arrayItem", RyanJsonTrue);
-	int use = 0;
-	for (uint8_t i = 0; i < 10; i++)
-	{
-		dupItem = RyanJsonParse(jsonstr);
-		RyanJsonReplaceByKey(jsonRoot, "arrayItem", RyanJsonDuplicate(dupItem));
-		if (RyanJsonFalse == RyanJsonCompare(RyanJsonGetObjectToKey(jsonRoot, "arrayItem"), dupItem))
-		{
-			goto err;
-		}
-		RyanJsonReplaceByKey(json, "arrayItem", RyanJsonDuplicate(RyanJsonGetObjectByKey(dupItem, "item")));
-		if (RyanJsonFalse == RyanJsonCompare(RyanJsonGetObjectToKey(json, "arrayItem"), RyanJsonGetObjectByKey(dupItem, "item")))
-		{
-			goto err;
-		}
-		RyanJsonDelete(dupItem);
-
-		int newuse = 0;
-		v_mcheck(NULL, &newuse);
-		if (i != 0 && newuse != use)
-		{
-			printf("%s:%d 内存泄漏\r\n", __FILE__, __LINE__);
-			goto err;
-		}
-		use = newuse;
-	}
-
-	RyanJsonDelete(json);
-	RyanJsonDelete(jsonRoot);
-	return 0;
-
-err:
-	RyanJsonDelete(json);
-	RyanJsonDelete(jsonRoot);
-	return -1;
-}
-
-static int likeReferenceTest()
-{
-
-	// char *str = NULL;
-	// char jsonstr[] =
-	// "{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,\"item\":{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89],\"arrayString\":[\"hello\",\"hello\",\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}]}";
-	// RyanJson_t json = RyanJsonParse(jsonstr);
-	// RyanJson_t item = NULL;
-
-	// // RyanJson_t adfasdf = RyanJsonDuplicate(RyanJsonGetObjectToKey(json, "item"));
-
-	// // RyanJsonAddItemToObject(json, "test", adfasdf);
-
-	// // 这里做你想做的事,这里我选择打印出来
-	// // str = RyanJsonPrint(json, 50, RyanJsonTrue, NULL);
-	// // printf("item %s \r\n", str);
-	// // RyanJsonFree(str);
-
-	// for (int i = 0; i < 1; i++)
-	// {
-	//     // 分离test对象
-	//     item = RyanJsonDetachByKey(json, "item");
-
-	//     // if (RyanJsonIsKey(item))
-	//     //     RyanJsonFree(RyanJsonGetKey(item));
-
-	//     // RyanJsonFree(item);
-	// }
-
-	// RyanJsonAddItemToObject(json, "item", item);
-
-	// str = RyanJsonPrint(json, 50, RyanJsonTrue, NULL);
-	// printf("item %s \r\n", str);
-	// RyanJsonFree(str);
-
-	// RyanJsonDelete(json);
-
-	return 0;
-}
-
-static int forEachTest()
-{
-	char *str = NULL;
-	char jsonstr[] = "{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,\"item\":{\"inter\":16,\"double\":16.89,\"string\":\"hello\","
-			 "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89],\"arrayString\":[\"hello\",\"hello\","
-			 "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
-			 "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}]}";
-
-	RyanJson_t json = RyanJsonParse(jsonstr);
-	RyanJson_t item = NULL;
-	printf("arrayDouble: ");
-	RyanJsonArrayForEach(RyanJsonGetObjectToKey(json, "arrayDouble"), item)
-	{
-		if (!RyanJsonIsDouble(item) || !compare_double(16.89, RyanJsonGetDoubleValue(item)))
-		{
-			goto err;
-		}
-	}
-
-	RyanJsonArrayForEach(RyanJsonGetObjectToKey(json, "arrayInt"), item)
-	{
-		if (!RyanJsonIsInt(item) || 16 != RyanJsonGetIntValue(item))
-		{
-			goto err;
-		}
-	}
-
-	uint32_t strLen;
-	RyanJsonObjectForEach(RyanJsonGetObjectToKey(json, "item"), item)
-	{
-		str = RyanJsonPrint(item, 50, RyanJsonTrue, &strLen);
-		printf("item { %s : %s }  %d\r\n", RyanJsonGetKey(item), str, strLen);
-		RyanJsonFree(str);
-	}
-
-	RyanJsonDelete(json);
-	return 0;
-
-err:
-	RyanJsonDelete(json);
-	return -1;
-}
-
-RyanJsonBool RyanJsonBaseTest(void)
-{
-	int result = 0;
-	RyanJsonInitHooks(v_malloc, v_free, v_realloc);
-
-	result = loadJsonTest(); // 从文本解析json测试
-	if (0 != result)
-	{
-		printf("%s:%d loadJsonTest fail\r\n", __FILE__, __LINE__);
-		return RyanJsonFalse;
-	}
-
-	result = createJsonTest(); // 生成json节点树测试
-	if (0 != result)
-	{
-		printf("%s:%d loadJsonTest fail\r\n", __FILE__, __LINE__);
-		return RyanJsonFalse;
-	}
-
-	result = changeJsonTest(); // 修改json节点测试,包含删除、分离
-	if (0 != result)
-	{
-		printf("%s:%d loadJsonTest fail\r\n", __FILE__, __LINE__);
-		return RyanJsonFalse;
-	}
-
-	result = compareJsonTest(); // 比较json节点树测试
-	if (0 != result)
-	{
-		printf("%s:%d loadJsonTest fail\r\n", __FILE__, __LINE__);
-		return RyanJsonFalse;
-	}
-
-	result = duplicateTest(); // 复制测试
-	if (0 != result)
-	{
-		printf("%s:%d loadJsonTest fail\r\n", __FILE__, __LINE__);
-		return RyanJsonFalse;
-	}
-
-	result = forEachTest();
-	if (0 != result)
-	{
-		printf("%s:%d loadJsonTest fail\r\n", __FILE__, __LINE__);
-		return RyanJsonFalse;
-	}
-
-	result = likeReferenceTest(); // 模仿 引用类型实现 示例
-	if (0 != result)
-	{
-		printf("%s:%d loadJsonTest fail\r\n", __FILE__, __LINE__);
-		return RyanJsonFalse;
-	}
-
-	displayMem();
-
-	return RyanJsonTrue;
-}

test/RyanJsonMemoryFootprintTest.c

@@ -1,22 +1,12 @@
 #include "RyanJsonTest.h"
 
-static void *yy_malloc(void *ctx, size_t size)
-{
-	return v_malloc(size);
-}
-static void *yy_realloc(void *ctx, void *ptr, size_t old_size, size_t size)
-{
-	return v_realloc(ptr, size);
-}
-static void yy_free(void *ctx, void *ptr)
-{
-	v_free(ptr);
-}
-
-static yyjson_alc yyalc = {yy_malloc, yy_realloc, yy_free, NULL};
+static void *yy_malloc(void *ctx, size_t size) { return v_malloc(size); }
+static void *yy_realloc(void *ctx, void *ptr, size_t old_size, size_t size) { return v_realloc(ptr, size); }
+static void yy_free(void *ctx, void *ptr) { v_free(ptr); }
 
 static int RyanJsonMemoryFootprint(char *jsonstr)
 {
+	int32_t use = vallocGetUse();
 	RyanJsonInitHooks(v_malloc, v_free, v_realloc);
 
 	RyanJson_t json = RyanJsonParse(jsonstr);
@@ -26,8 +16,7 @@ static int RyanJsonMemoryFootprint(char *jsonstr)
 		return -1;
 	}
 
-	int area = 0, use = 0;
-	v_mcheck(&area, &use);
+	use = vallocGetUse() - use;
 
 	RyanJsonDelete(json);
 	return use;
@@ -35,6 +24,7 @@ static int RyanJsonMemoryFootprint(char *jsonstr)
 
 static int cJSONMemoryFootprint(char *jsonstr)
 {
+	int32_t use = vallocGetUse();
 	cJSON_Hooks hooks = {.malloc_fn = v_malloc, .free_fn = v_free};
 	cJSON_InitHooks(&hooks);
 
@@ -45,26 +35,29 @@ static int cJSONMemoryFootprint(char *jsonstr)
 		return -1;
 	}
 
-	int area = 0, use = 0;
-	v_mcheck(&area, &use);
-
+	use = vallocGetUse() - use;
 	cJSON_Delete(json);
 	return use;
 }
 
 static int yyjsonMemoryFootprint(char *jsonstr)
 {
-
+	static yyjson_alc yyalc = {yy_malloc, yy_realloc, yy_free, NULL};
+	// 先解析成只读文档（可用自定义分配器 yyalc）
 	yyjson_doc *doc = yyjson_read_opts(jsonstr, strlen(jsonstr), YYJSON_READ_NOFLAG, &yyalc, NULL);
-	if (NULL == doc)
-	{
-		return -1;
-	}
+	if (doc == NULL) { return -1; }
+
+	// 从只读文档拷贝为可变文档（用于后续读写修改）
+	yyjson_mut_doc *mdoc = yyjson_doc_mut_copy(doc, &yyalc);
+	yyjson_doc_free(doc);
+	if (mdoc == NULL) { return -1; }
 
+	// 统计当前分配器的占用
 	int area = 0, use = 0;
 	v_mcheck(&area, &use);
 
-	yyjson_doc_free(doc);
+	// 用完释放可变文档
+	yyjson_mut_doc_free(mdoc);
 	return use;
 }
 
@@ -76,78 +69,163 @@ static void printfJsonCompera(char *jsonstr)
 	RyanJsonCount = RyanJsonMemoryFootprint(jsonstr);
 	cJSONCount = cJSONMemoryFootprint(jsonstr);
 	yyjsonCount = yyjsonMemoryFootprint(jsonstr);
-	printf("json原始文本长度为 %ld, 序列化后RyanJson内存占用: %d, cJSON内存占用: %d, yyjson内存占用: %d\r\n", strlen(jsonstr), RyanJsonCount, cJSONCount, yyjsonCount);
+	printf("json原始文本长度为 %ld, 序列化后RyanJson内存占用: %d, cJSON内存占用: %d, yyjson内存占用: %d\r\n", strlen(jsonstr),
+	       RyanJsonCount, cJSONCount, yyjsonCount);
+
+	double save_vs_cjson = 100.0 - ((double)RyanJsonCount * 100.0) / (double)cJSONCount;
+	double save_vs_yyjson = 100.0 - ((double)RyanJsonCount * 100.0) / (double)yyjsonCount;
 
-	printf("比cJSON节省: %d%% 内存占用, 比yyjson节省: %d%% 内存占用\r\n", 100 - RyanJsonCount * 100 / cJSONCount, 100 - RyanJsonCount * 100 / yyjsonCount);
+	printf("比cJSON节省: %.2f%% 内存占用, 比yyjson节省: %.2f%% 内存占用\r\n", save_vs_cjson, save_vs_yyjson);
 }
 
-RyanJsonBool RyanJsonMemoryFootprintTest(void)
+RyanJsonBool_e RyanJsonMemoryFootprintTest(void)
 {
 	char *jsonstr;
 
 	printf("\r\n--------------------------- 混合类型json数据测试 --------------------------\r\n");
-	jsonstr = "{\"item1\":{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,\"item\":{\"inter\":16,\"double\":16.89,\"string\":\"hello\","
-		  "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89],\"arrayString\":[\"hello\",\"hello\",\"hello\","
-		  "\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,"
-		  "\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}]},\"item2\":{\"inter\":16,\"double\":16.89,\"string\":"
-		  "\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,\"item\":{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null},"
-		  "\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89],\"arrayString\":[\"hello\",\"hello\",\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\","
-		  "true,false,null],\"arrayItem\":[{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":"
-		  "\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}]},\"item3\":{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,"
-		  "\"item\":{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,"
-		  "16.89,16.89],\"arrayString\":[\"hello\",\"hello\",\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,\"double\":16.89,"
-		  "\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}]}"
-		  ",\"item4\":{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,\"item\":{\"inter\":16,\"double\":16.89,\"string\":\"hello\","
-		  "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89],\"arrayString\":[\"hello\",\"hello\",\"hello\","
-		  "\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,"
-		  "\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}]}}";
+	jsonstr = "{\"item1\":{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,"
+		  "\"item\":{\"inter\":16,"
+		  "\"double\":16.89,\"string\":\"hello\","
+		  "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,"
+		  "16.89,16.89],"
+		  "\"arrayString\":[\"hello\",\"hello\",\"hello\","
+		  "\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,\"double\":16.89,"
+		  "\"string\":\"hello\","
+		  "\"boolTrue\":true,\"boolFalse\":false,"
+		  "\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}]"
+		  "},\"item2\":{"
+		  "\"inter\":16,\"double\":16.89,\"string\":"
+		  "\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,\"item\":{\"inter\":16,\"double\":16.89,\"string\":"
+		  "\"hello\",\"boolTrue\":"
+		  "true,\"boolFalse\":false,\"null\":null},"
+		  "\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89],\"arrayString\":[\"hello\",\"hello\","
+		  "\"hello\",\"hello\","
+		  "\"hello\"],\"array\":[16,16.89,\"hello\","
+		  "true,false,null],\"arrayItem\":[{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":"
+		  "false,\"null\":null},{"
+		  "\"inter\":16,\"double\":16.89,\"string\":"
+		  "\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}]},\"item3\":{\"inter\":16,\"double\":16.89,\"string\":"
+		  "\"hello\",\"boolTrue\":"
+		  "true,\"boolFalse\":false,\"null\":null,"
+		  "\"item\":{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null},"
+		  "\"arrayInt\":[16,16,16,16,"
+		  "16],\"arrayDouble\":[16.89,16.89,16.89,"
+		  "16.89,16.89],\"arrayString\":[\"hello\",\"hello\",\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,"
+		  "false,null],"
+		  "\"arrayItem\":[{\"inter\":16,\"double\":16.89,"
+		  "\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":"
+		  "\"hello\",\"boolTrue\":"
+		  "true,\"boolFalse\":false,\"null\":null}]}"
+		  ",\"item4\":{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,"
+		  "\"item\":{\"inter\":16,"
+		  "\"double\":16.89,\"string\":\"hello\","
+		  "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,"
+		  "16.89,16.89],"
+		  "\"arrayString\":[\"hello\",\"hello\",\"hello\","
+		  "\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,\"double\":16.89,"
+		  "\"string\":\"hello\","
+		  "\"boolTrue\":true,\"boolFalse\":false,"
+		  "\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}]"
+		  "}}";
 	printfJsonCompera(jsonstr);
 
 	printf("\r\n--------------------------- 对象占多json数据测试 --------------------------\r\n");
-	jsonstr = "{\"message\":\"success感谢又拍云(upyun.com)提供CDN赞助\",\"status\":200,\"date\":\"20230822\",\"time\":\"2023-08-22 "
-		  "09:44:54\",\"cityInfo\":{\"city\":\"郑州市\",\"citykey\":\"101180101\",\"parent\":\"河南\",\"updateTime\":\"07:46\"},\"data\":{\"shidu\":\"85%\",\"pm25\":20,\"pm10\":56,"
-		  "\"quality\":\"良\",\"wendu\":\"29\",\"ganmao\":\"极少数敏感人群应减少户外活动\",\"forecast\":[{\"date\":\"22\",\"high\":\"高温 35℃\",\"low\":\"低温 "
-		  "23℃\",\"ymd\":\"2023-08-22\",\"week\":\"星期二\",\"sunrise\":\"05:51\",\"sunset\":\"19:05\",\"aqi\":78,\"fx\":\"东南风\",\"fl\":\"2级\",\"type\":\"晴\",\"notice\":"
-		  "\"愿你拥有比阳光明媚的心情\"},{\"date\":\"23\",\"high\":\"高温 33℃\",\"low\":\"低温 "
-		  "23℃\",\"ymd\":\"2023-08-23\",\"week\":\"星期三\",\"sunrise\":\"05:52\",\"sunset\":\"19:04\",\"aqi\":71,\"fx\":\"南风\",\"fl\":\"2级\",\"type\":\"中雨\",\"notice\":"
-		  "\"记得随身携带雨伞哦\"},{\"date\":\"24\",\"high\":\"高温 31℃\",\"low\":\"低温 "
-		  "21℃\",\"ymd\":\"2023-08-24\",\"week\":\"星期四\",\"sunrise\":\"05:52\",\"sunset\":\"19:03\",\"aqi\":74,\"fx\":\"东风\",\"fl\":\"2级\",\"type\":\"晴\",\"notice\":"
-		  "\"愿你拥有比阳光明媚的心情\"},{\"date\":\"25\",\"high\":\"高温 30℃\",\"low\":\"低温 "
-		  "23℃\",\"ymd\":\"2023-08-25\",\"week\":\"星期五\",\"sunrise\":\"05:53\",\"sunset\":\"19:02\",\"aqi\":93,\"fx\":\"东风\",\"fl\":\"1级\",\"type\":\"小雨\",\"notice\":"
-		  "\"雨虽小，注意保暖别感冒\"},{\"date\":\"26\",\"high\":\"高温 25℃\",\"low\":\"低温 "
-		  "22℃\",\"ymd\":\"2023-08-26\",\"week\":\"星期六\",\"sunrise\":\"05:54\",\"sunset\":\"19:00\",\"aqi\":80,\"fx\":\"东北风\",\"fl\":\"1级\",\"type\":\"阴\",\"notice\":"
-		  "\"不要被阴云遮挡住好心情\"},{\"date\":\"27\",\"high\":\"高温 27℃\",\"low\":\"低温 "
-		  "20℃\",\"ymd\":\"2023-08-27\",\"week\":\"星期日\",\"sunrise\":\"05:55\",\"sunset\":\"18:59\",\"aqi\":74,\"fx\":\"西北风\",\"fl\":\"1级\",\"type\":\"阴\",\"notice\":"
-		  "\"不要被阴云遮挡住好心情\"},{\"date\":\"28\",\"high\":\"高温 30℃\",\"low\":\"低温 20℃\",\"ymd\":\"2023-08-28\",\"week\":\"星期 "
-		  "一\",\"sunrise\":\"05:55\",\"sunset\":\"18:58\",\"aqi\":80,\"fx\":\"东北风\",\"fl\":\"2级\",\"type\":\"多云\",\"notice\":\"阴晴之间，谨防紫外线侵扰\"},{\"date\":\"29\",\"high\":"
-		  "\"高温 30℃\",\"low\":\"低温 "
-		  "20℃\",\"ymd\":\"2023-08-29\",\"week\":\"星期二\",\"sunrise\":\"05:56\",\"sunset\":\"18:56\",\"aqi\":80,\"fx\":\"东北风\",\"fl\":\"2级\",\"type\":\"多云\",\"notice\":"
-		  "\"阴晴之间，谨防紫外线侵扰\"},{\"date\":\"30\",\"high\":\"高温 31℃\",\"low\":\"低温 "
-		  "20℃\",\"ymd\":\"2023-08-30\",\"week\":\"星期三\",\"sunrise\":\"05:57\",\"sunset\":\"18:55\",\"aqi\":92,\"fx\":\"南风\",\"fl\":\"1级\",\"type\":\"晴\",\"notice\":"
-		  "\"愿你拥有比阳光明媚的心情\"},{\"date\":\"31\",\"high\":\"高温 33℃\",\"low\":\" 低温 "
-		  "22℃\",\"ymd\":\"2023-08-31\",\"week\":\"星期四\",\"sunrise\":\"05:57\",\"sunset\":\"18:54\",\"aqi\":91,\"fx\":\"南风\",\"fl\":\"1级\",\"type\":\"晴\",\"notice\":"
-		  "\"愿你拥有比阳光明媚的心情\"},{\"date\":\"01\",\"high\":\"高温 34℃\",\"low\":\"低温 "
-		  "23℃\",\"ymd\":\"2023-09-01\",\"week\":\"星期五\",\"sunrise\":\"05:58\",\"sunset\":\"18:52\",\"aqi\":91,\"fx\":\"西风\",\"fl\":\"1级\",\"type\":\"晴\",\"notice\":"
-		  "\"愿你拥有比阳光明媚的心情\"},{\"date\":\"02\",\"high\":\"高温 36℃\",\"low\":\"低温 "
-		  "25℃\",\"ymd\":\"2023-09-02\",\"week\":\"星期六\",\"sunrise\":\"05:59\",\"sunset\":\"18:51\",\"aqi\":78,\"fx\":\"南风\",\"fl\":\"1级\",\"type\":\"阴\",\"notice\":"
-		  "\"不要被阴云遮挡住好心情\"},{\"date\":\"03\",\"high\":\"高温 35℃\",\"low\":\"低温 "
-		  "24℃\",\"ymd\":\"2023-09-03\",\"week\":\"星期日\",\"sunrise\":\"06:00\",\"sunset\":\"18:50\",\"aqi\":82,\"fx\":\"东北风\",\"fl\":\"1级\",\"type\":\"晴\",\"notice\":"
-		  "\"愿你拥有比阳光明媚的心情\"},{\"date\":\"04\",\"high\":\"高温 35℃\",\"low\":\"低温 "
-		  "25℃\",\"ymd\":\"2023-09-04\",\"week\":\"星期一\",\"sunrise\":\"06:00\",\"sunset\":\"18:48\",\"aqi\":88,\"fx\":\"南风\",\"fl\":\"2级\",\"type\":\"晴\",\"notice\":"
-		  "\"愿你拥有比阳光明媚的心情\"},{\"date\":\"05\",\"high\":\"高温 35℃\",\"low\":\"低温 "
-		  "25℃\",\"ymd\":\"2023-09-05\",\"week\":\"星期二\",\"sunrise\":\"06:01\",\"sunset\":\"18:47\",\"aqi\":58,\"fx\":\"南风\",\"fl\":\"2级\",\"type\":\"阴\",\"notice\":"
-		  "\"不要被阴云遮挡住好心情\"}],\"yesterday\":{\"date\":\"21\",\"high\":\"高温 34℃\",\"low\":\"低温 24℃\",\"ymd\":\"2023-08-21\",\"week\":\" "
-		  "星期一\",\"sunrise\":\"05:50\",\"sunset\":\"19:07\",\"aqi\":60,\"fx\":\"西风\",\"fl\":\"2级\",\"type\":\"小雨\",\"notice\":\"雨虽小，注意保暖别感冒\"}}}";
+	jsonstr =
+		"{\"message\":\"success感谢又拍云(upyun.com)提供CDN赞助\",\"status\":200,\"date\":\"20230822\",\"time\":\"2023-08-22 "
+		"09:44:54\",\"cityInfo\":{\"city\":\"郑州市\",\"citykey\":\"101180101\",\"parent\":\"河南\",\"updateTime\":\"07:46\"},"
+		"\"data\":{\"shidu\":"
+		"\"85%\",\"pm25\":20,\"pm10\":56,"
+		"\"quality\":\"良\",\"wendu\":\"29\",\"ganmao\":\"极少数敏感人群应减少户外活动\",\"forecast\":[{\"date\":\"22\",\"high\":"
+		"\"高温 "
+		"35℃\",\"low\":\"低温 "
+		"23℃\",\"ymd\":\"2023-08-22\",\"week\":\"星期二\",\"sunrise\":\"05:51\",\"sunset\":\"19:05\",\"aqi\":78,\"fx\":\"东南风\","
+		"\"fl\":\"2级\","
+		"\"type\":\"晴\",\"notice\":"
+		"\"愿你拥有比阳光明媚的心情\"},{\"date\":\"23\",\"high\":\"高温 33℃\",\"low\":\"低温 "
+		"23℃\",\"ymd\":\"2023-08-23\",\"week\":\"星期三\",\"sunrise\":\"05:52\",\"sunset\":\"19:04\",\"aqi\":71,\"fx\":\"南风\","
+		"\"fl\":\"2级\","
+		"\"type\":\"中雨\",\"notice\":"
+		"\"记得随身携带雨伞哦\"},{\"date\":\"24\",\"high\":\"高温 31℃\",\"low\":\"低温 "
+		"21℃\",\"ymd\":\"2023-08-24\",\"week\":\"星期四\",\"sunrise\":\"05:52\",\"sunset\":\"19:03\",\"aqi\":74,\"fx\":\"东风\","
+		"\"fl\":\"2级\","
+		"\"type\":\"晴\",\"notice\":"
+		"\"愿你拥有比阳光明媚的心情\"},{\"date\":\"25\",\"high\":\"高温 30℃\",\"low\":\"低温 "
+		"23℃\",\"ymd\":\"2023-08-25\",\"week\":\"星期五\",\"sunrise\":\"05:53\",\"sunset\":\"19:02\",\"aqi\":93,\"fx\":\"东风\","
+		"\"fl\":\"1级\","
+		"\"type\":\"小雨\",\"notice\":"
+		"\"雨虽小，注意保暖别感冒\"},{\"date\":\"26\",\"high\":\"高温 25℃\",\"low\":\"低温 "
+		"22℃\",\"ymd\":\"2023-08-26\",\"week\":\"星期六\",\"sunrise\":\"05:54\",\"sunset\":\"19:00\",\"aqi\":80,\"fx\":\"东北风\","
+		"\"fl\":\"1级\","
+		"\"type\":\"阴\",\"notice\":"
+		"\"不要被阴云遮挡住好心情\"},{\"date\":\"27\",\"high\":\"高温 27℃\",\"low\":\"低温 "
+		"20℃\",\"ymd\":\"2023-08-27\",\"week\":\"星期日\",\"sunrise\":\"05:55\",\"sunset\":\"18:59\",\"aqi\":74,\"fx\":\"西北风\","
+		"\"fl\":\"1级\","
+		"\"type\":\"阴\",\"notice\":"
+		"\"不要被阴云遮挡住好心情\"},{\"date\":\"28\",\"high\":\"高温 30℃\",\"low\":\"低温 "
+		"20℃\",\"ymd\":\"2023-08-28\",\"week\":\"星期 "
+		"一\",\"sunrise\":\"05:55\",\"sunset\":\"18:58\",\"aqi\":80,\"fx\":\"东北风\",\"fl\":\"2级\",\"type\":\"多云\",\"notice\":"
+		"\"阴晴之间，谨防紫外线侵扰\"},{\"date\":\"29\",\"high\":"
+		"\"高温 30℃\",\"low\":\"低温 "
+		"20℃\",\"ymd\":\"2023-08-29\",\"week\":\"星期二\",\"sunrise\":\"05:56\",\"sunset\":\"18:56\",\"aqi\":80,\"fx\":\"东北风\","
+		"\"fl\":\"2级\","
+		"\"type\":\"多云\",\"notice\":"
+		"\"阴晴之间，谨防紫外线侵扰\"},{\"date\":\"30\",\"high\":\"高温 31℃\",\"low\":\"低温 "
+		"20℃\",\"ymd\":\"2023-08-30\",\"week\":\"星期三\",\"sunrise\":\"05:57\",\"sunset\":\"18:55\",\"aqi\":92,\"fx\":\"南风\","
+		"\"fl\":\"1级\","
+		"\"type\":\"晴\",\"notice\":"
+		"\"愿你拥有比阳光明媚的心情\"},{\"date\":\"31\",\"high\":\"高温 33℃\",\"low\":\" 低温 "
+		"22℃\",\"ymd\":\"2023-08-31\",\"week\":\"星期四\",\"sunrise\":\"05:57\",\"sunset\":\"18:54\",\"aqi\":91,\"fx\":\"南风\","
+		"\"fl\":\"1级\","
+		"\"type\":\"晴\",\"notice\":"
+		"\"愿你拥有比阳光明媚的心情\"},{\"date\":\"01\",\"high\":\"高温 34℃\",\"low\":\"低温 "
+		"23℃\",\"ymd\":\"2023-09-01\",\"week\":\"星期五\",\"sunrise\":\"05:58\",\"sunset\":\"18:52\",\"aqi\":91,\"fx\":\"西风\","
+		"\"fl\":\"1级\","
+		"\"type\":\"晴\",\"notice\":"
+		"\"愿你拥有比阳光明媚的心情\"},{\"date\":\"02\",\"high\":\"高温 36℃\",\"low\":\"低温 "
+		"25℃\",\"ymd\":\"2023-09-02\",\"week\":\"星期六\",\"sunrise\":\"05:59\",\"sunset\":\"18:51\",\"aqi\":78,\"fx\":\"南风\","
+		"\"fl\":\"1级\","
+		"\"type\":\"阴\",\"notice\":"
+		"\"不要被阴云遮挡住好心情\"},{\"date\":\"03\",\"high\":\"高温 35℃\",\"low\":\"低温 "
+		"24℃\",\"ymd\":\"2023-09-03\",\"week\":\"星期日\",\"sunrise\":\"06:00\",\"sunset\":\"18:50\",\"aqi\":82,\"fx\":\"东北风\","
+		"\"fl\":\"1级\","
+		"\"type\":\"晴\",\"notice\":"
+		"\"愿你拥有比阳光明媚的心情\"},{\"date\":\"04\",\"high\":\"高温 35℃\",\"low\":\"低温 "
+		"25℃\",\"ymd\":\"2023-09-04\",\"week\":\"星期一\",\"sunrise\":\"06:00\",\"sunset\":\"18:48\",\"aqi\":88,\"fx\":\"南风\","
+		"\"fl\":\"2级\","
+		"\"type\":\"晴\",\"notice\":"
+		"\"愿你拥有比阳光明媚的心情\"},{\"date\":\"05\",\"high\":\"高温 35℃\",\"low\":\"低温 "
+		"25℃\",\"ymd\":\"2023-09-05\",\"week\":\"星期二\",\"sunrise\":\"06:01\",\"sunset\":\"18:47\",\"aqi\":58,\"fx\":\"南风\","
+		"\"fl\":\"2级\","
+		"\"type\":\"阴\",\"notice\":"
+		"\"不要被阴云遮挡住好心情\"}],\"yesterday\":{\"date\":\"21\",\"high\":\"高温 34℃\",\"low\":\"低温 "
+		"24℃\",\"ymd\":\"2023-08-21\",\"week\":\" "
+		"星期一\",\"sunrise\":\"05:50\",\"sunset\":\"19:07\",\"aqi\":60,\"fx\":\"西风\",\"fl\":\"2级\",\"type\":\"小雨\","
+		"\"notice\":"
+		"\"雨虽小，注意保暖别感冒\"}}}";
 	printfJsonCompera(jsonstr);
 
 	printf("\r\n--------------------------- 数组占多json数据测试 --------------------------\r\n");
-	jsonstr = "{\"item1\":{\"arrayInt\":[16,16,16,16,16,16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89,16.89,16.89,16.89,16.89,16.89],\"arrayString\":[\"hello\",\"hello\","
-		  "\"hello\",\"hello\",\"hello\",\"hello\",\"hello\",\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null,16,16.89,\"hello\",true,false,null]},\"item2\":{"
-		  "\"arrayInt\":[16,16,16,16,16,16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89,16.89,16.89,16.89,16.89,16.89],\"arrayString\":[\"hello\",\"hello\",\"hello\",\"hello\","
-		  "\"hello\",\"hello\",\"hello\",\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null,16,16.89,\"hello\",true,false,null]},\"item3\":{\"arrayInt\":[16,16,16,"
-		  "16,16,16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89,16.89,16.89,16.89,16.89,16.89],\"arrayString\":[\"hello\",\"hello\",\"hello\",\"hello\",\"hello\",\"hello\","
-		  "\"hello\",\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null,16,16.89,\"hello\",true,false,null]},\"item4\":{\"arrayInt\":[16,16,16,16,16,16,16,16,16,16],"
-		  "\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89,16.89,16.89,16.89,16.89,16.89],\"arrayString\":[\"hello\",\"hello\",\"hello\",\"hello\",\"hello\",\"hello\",\"hello\",\"hello\","
+	jsonstr = "{\"item1\":{\"arrayInt\":[16,16,16,16,16,16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89,16.89,16.89,16."
+		  "89,16.89,16.89],"
+		  "\"arrayString\":[\"hello\",\"hello\","
+		  "\"hello\",\"hello\",\"hello\",\"hello\",\"hello\",\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,"
+		  "false,null,16,16.89,"
+		  "\"hello\",true,false,null]},\"item2\":{"
+		  "\"arrayInt\":[16,16,16,16,16,16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89,16.89,16.89,16.89,16.89,16."
+		  "89],\"arrayString\":["
+		  "\"hello\",\"hello\",\"hello\",\"hello\","
+		  "\"hello\",\"hello\",\"hello\",\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null,16,16.89,"
+		  "\"hello\",true,false,"
+		  "null]},\"item3\":{\"arrayInt\":[16,16,16,"
+		  "16,16,16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89,16.89,16.89,16.89,16.89,16.89],\"arrayString\":["
+		  "\"hello\",\"hello\","
+		  "\"hello\",\"hello\",\"hello\",\"hello\","
+		  "\"hello\",\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null,16,16.89,\"hello\",true,false,"
+		  "null]},\"item4\":{"
+		  "\"arrayInt\":[16,16,16,16,16,16,16,16,16,16],"
+		  "\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89,16.89,16.89,16.89,16.89,16.89],\"arrayString\":[\"hello\",\"hello\","
+		  "\"hello\",\"hello\","
+		  "\"hello\",\"hello\",\"hello\",\"hello\","
 		  "\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null,16,16.89,\"hello\",true,false,null]}}";
 	printfJsonCompera(jsonstr);
 
@@ -156,7 +234,8 @@ RyanJsonBool RyanJsonMemoryFootprintTest(void)
 	printfJsonCompera(jsonstr);
 
 	printf("\r\n--------------------------- 小对象json 纯字符串内存占用测试 --------------------------\r\n");
-	jsonstr = "{\"inter\":\"16\",\"double\":\"16.89\",\"string\":\"hello\",\"boolTrue\":\"true\",\"boolFalse\":\"false\",\"null\":\"null\"}";
+	jsonstr = "{\"inter\":\"16\",\"double\":\"16.89\",\"string\":\"hello\",\"boolTrue\":\"true\",\"boolFalse\":\"false\",\"null\":"
+		  "\"null\"}";
 	printfJsonCompera(jsonstr);
 
 	/**

test/RyanJsonRFC8259JsonTest.c

@@ -0,0 +1,606 @@
+#include "RyanJsonTest.h"
+
+#define PrintfStrCmpEnable
+
+typedef int (*jsonParseData)(char *fileName, char *data, uint32_t len);
+
+/* Read a file, parse, render back, etc. */
+static int testFile(const char *path, jsonParseData jsonParseDataHandle)
+{
+
+	DIR *dir = NULL;
+	struct dirent *entry;
+
+	int path_len = strlen(path);
+	int count = 0;
+	int used_count = 0;
+	if (!path || !path_len || !(dir = opendir(path))) { goto fail; }
+
+	while ((entry = readdir(dir)))
+	{
+
+		char *name = (char *)entry->d_name;
+
+		if (!name || !strlen(name)) { continue; }
+
+		if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0) { continue; }
+
+		char aaa[300] = {0};
+		snprintf(aaa, sizeof(aaa), "%s/%s", path, name);
+
+		FILE *f = fopen(aaa, "rb");
+		if (f == NULL) { goto fail; }
+
+		fseek(f, 0, SEEK_END);
+		long len = ftell(f);
+		fseek(f, 0, SEEK_SET);
+		char *data = (char *)malloc(len + 10);
+		fread(data, 1, len, f);
+		data[len] = '\0';
+		fclose(f);
+		int status = 0;
+
+		int startUse = vallocGetUse();
+		status = jsonParseDataHandle(name, data, len);
+
+		used_count++;
+		if (0 == strncmp("y_", name, 2))
+		{
+			if (0 == status) { count++; }
+			else
+			{
+				printf("应该成功，但是失败: %s, len: %ld\n", data, len);
+			}
+		}
+		else if (0 == strncmp("n_", name, 2))
+		{
+			if (0 != status) { count++; }
+			else
+			{
+				printf("应该失败，但是成功: %s, len: %ld\n", data, len);
+			}
+		}
+		else if (0 == strncmp("i_", name, 2)) { count++; }
+
+		if (startUse != vallocGetUse())
+		{
+			int area = 0, use = 0;
+			v_mcheck(&area, &use);
+			printf("内存泄漏 %s len: %ld\r\n", data, len);
+            free(data);
+			// printf("内存泄漏 %x len: %ld\r\n", (unsigned int)data, len);
+			// printf("内存泄漏 %c len: %ld\r\n", (int)data, len);
+			printf("|||----------->>> area = %d, size = %d\r\n", area, use);
+			break;
+		}
+
+		// if (use != (len + 10))
+		// {
+		// 	int area = 0, use = 0;
+		// 	v_mcheck(&area, &use);
+		// 	free(data);
+		// 	printf("内存泄漏 %s len: %ld\r\n", data, len);
+		// 	// printf("内存泄漏 %x len: %ld\r\n", (unsigned int)data, len);
+		// 	// printf("内存泄漏 %c len: %ld\r\n", (int)data, len);
+		// 	printf("|||----------->>> area = %d, size = %d\r\n", area, use);
+		// 	break;
+		// }
+		free(data);
+	}
+
+	closedir(dir);
+
+	printf("RFC 8259 JSON: (%d/%d)\r\n", count, used_count);
+	return 0;
+
+fail:
+	if (dir) { closedir(dir); }
+
+	return -1;
+}
+
+typedef struct
+{
+	const char *p;
+	int32_t len;
+} Slice;
+
+static int hexval(int c)
+{
+	if (c >= '0' && c <= '9') { return c - '0'; }
+	c = (c >= 'a' && c <= 'f') ? (c - 'a' + 'A') : c;
+	if (c >= 'A' && c <= 'F') { return c - 'A' + 10; }
+	return -1;
+}
+
+static int decode_u4(const char *s, uint16_t *out)
+{
+	int h0 = hexval(s[0]), h1 = hexval(s[1]), h2 = hexval(s[2]), h3 = hexval(s[3]);
+	if (h0 < 0 || h1 < 0 || h2 < 0 || h3 < 0) { return 0; }
+	*out = (uint16_t)((h0 << 12) | (h1 << 8) | (h2 << 4) | h3);
+	return 1;
+}
+
+// 将 JSON 字符串（不含两端引号）规范化为 UTF-8 字节序列
+static int normalize_json_string(const char *in, int32_t in_len, unsigned char **out, int32_t *out_len)
+{
+	// 预留足够缓冲
+	int32_t cap = in_len * 4 + 8;
+	unsigned char *buf = (unsigned char *)malloc(cap);
+	if (!buf) { return 0; }
+	int32_t pos = 0;
+
+	for (int32_t i = 0; i < in_len; i++)
+	{
+		unsigned char ch = (unsigned char)in[i];
+
+		if (ch == '\\')
+		{
+			if (i + 1 >= in_len)
+			{
+				free(buf);
+				return 0;
+			}
+			unsigned char esc = (unsigned char)in[++i];
+			switch (esc)
+			{
+			case '\"': buf[pos++] = '\"'; break;
+			case '\\': buf[pos++] = '\\'; break;
+			case '/': buf[pos++] = '/'; break;
+			case 'b': buf[pos++] = '\b'; break;
+			case 'f': buf[pos++] = '\f'; break;
+			case 'n': buf[pos++] = '\n'; break;
+			case 'r': buf[pos++] = '\r'; break;
+			case 't': buf[pos++] = '\t'; break;
+			case 'u': {
+				if (i + 4 >= in_len)
+				{
+					free(buf);
+					return 0;
+				}
+				uint16_t u1;
+				if (!decode_u4(&in[i + 1], &u1))
+				{
+					free(buf);
+					return 0;
+				}
+				i += 4;
+
+				if (u1 >= 0xD800 && u1 <= 0xDBFF)
+				{
+					// 高代理，必须跟 \uXXXX 低代理
+					if (i + 2 >= in_len || in[i + 1] != '\\' || in[i + 2] != 'u' || i + 6 >= in_len)
+					{
+						free(buf);
+						return 0;
+					}
+					i += 2;
+					uint16_t u2;
+					if (!decode_u4(&in[i + 1], &u2))
+					{
+						free(buf);
+						return 0;
+					}
+					i += 4;
+					if (!(u2 >= 0xDC00 && u2 <= 0xDFFF))
+					{
+						free(buf);
+						return 0;
+					}
+					// 组合码点
+					uint32_t cp = 0x10000 + (((uint32_t)(u1 - 0xD800) << 10) | (uint32_t)(u2 - 0xDC00));
+					// 编码为 UTF-8
+					buf[pos++] = (unsigned char)(0xF0 | ((cp >> 18) & 0x07));
+					buf[pos++] = (unsigned char)(0x80 | ((cp >> 12) & 0x3F));
+					buf[pos++] = (unsigned char)(0x80 | ((cp >> 6) & 0x3F));
+					buf[pos++] = (unsigned char)(0x80 | (cp & 0x3F));
+				}
+				else if (u1 >= 0xDC00 && u1 <= 0xDFFF)
+				{
+					// 单独低代理非法
+					free(buf);
+					return 0;
+				}
+				else
+				{
+					// BMP 码点 → UTF-8
+					if (u1 <= 0x007F) { buf[pos++] = (unsigned char)u1; }
+					else if (u1 <= 0x07FF)
+					{
+						buf[pos++] = (unsigned char)(0xC0 | ((u1 >> 6) & 0x1F));
+						buf[pos++] = (unsigned char)(0x80 | (u1 & 0x3F));
+					}
+					else
+					{
+						buf[pos++] = (unsigned char)(0xE0 | ((u1 >> 12) & 0x0F));
+						buf[pos++] = (unsigned char)(0x80 | ((u1 >> 6) & 0x3F));
+						buf[pos++] = (unsigned char)(0x80 | (u1 & 0x3F));
+					}
+				}
+				break;
+			}
+			default:
+				// 非法转义
+				free(buf);
+				return 0;
+			}
+		}
+		else
+		{
+			// 原始字节：直接拷贝（假设输入整体是合法 UTF-8）
+			buf[pos++] = ch;
+		}
+
+		if (pos + 8 > cap)
+		{
+			cap *= 2;
+			unsigned char *nb = (unsigned char *)realloc(buf, cap);
+			if (!nb)
+			{
+				free(buf);
+				return 0;
+			}
+			buf = nb;
+		}
+	}
+
+	*out = buf;
+	*out_len = pos;
+	return 1;
+}
+
+// 比较：规范化两侧为 UTF-8 字节序列，再 memcmp
+static int json_string_equal_semantic(const char *a, int32_t a_len, const char *b, int32_t b_len)
+{
+	unsigned char *na = NULL, *nb = NULL;
+	int32_t nla = 0, nlb = 0;
+
+	if (!normalize_json_string(a, a_len, &na, &nla)) { return 0; }
+	if (!normalize_json_string(b, b_len, &nb, &nlb))
+	{
+		free(na);
+		return 0;
+	}
+
+	int eq = (nla == nlb) && (memcmp(na, nb, nla) == 0);
+	free(na);
+	free(nb);
+	return eq;
+}
+
+/* 去空白 */
+static void trim(const char **s, int32_t *len)
+{
+	const char *p = *s;
+	int32_t n = *len;
+	while (n && isspace((unsigned char)*p))
+	{
+		p++;
+		n--;
+	}
+	while (n && isspace((unsigned char)p[n - 1])) { n--; }
+	*s = p;
+	*len = n;
+}
+
+/* 是否是带双引号的字符串值 */
+static int is_quoted_string(const char *s, int32_t len) { return len >= 2 && s[0] == '\"' && s[len - 1] == '\"'; }
+
+/* 值级语义比较：字符串（去引号并 normalize）、数字（含科学计数法）、布尔、null */
+static int json_scalar_equal(const char *a, int32_t a_len, const char *b, int32_t b_len)
+{
+	trim(&a, &a_len);
+	trim(&b, &b_len);
+
+	/* 字符串：去掉引号后做转义规范化再比较字节 */
+	if (is_quoted_string(a, a_len) && is_quoted_string(b, b_len))
+	{
+		const char *as = a + 1;
+		int32_t al = a_len - 2;
+		const char *bs = b + 1;
+		int32_t bl = b_len - 2;
+
+		unsigned char *na = NULL, *nb = NULL;
+		int32_t nla = 0, nlb = 0;
+		if (!normalize_json_string(as, al, &na, &nla)) { return 0; }
+		if (!normalize_json_string(bs, bl, &nb, &nlb))
+		{
+			free(na);
+			return 0;
+		}
+
+		int eq = (nla == nlb) && (memcmp(na, nb, nla) == 0);
+		free(na);
+		free(nb);
+		return eq;
+	}
+
+	/* 布尔 / null */
+	if (a_len == 4 && strncmp(a, "true", 4) == 0 && b_len == 4 && strncmp(b, "true", 4) == 0) { return 1; }
+	if (a_len == 5 && strncmp(a, "false", 5) == 0 && b_len == 5 && strncmp(b, "false", 5) == 0) { return 1; }
+	if (a_len == 4 && strncmp(a, "null", 4) == 0 && b_len == 4 && strncmp(b, "null", 4) == 0) { return 1; }
+
+	/* 数字：用 strtod 支持科学计数法，最后一字节必须到达字符串末尾（避免部分解析） */
+	{
+		char *endA = NULL, *endB = NULL;
+
+		/* 拷贝到以 NUL 结尾的缓冲，避免 strtod 依赖外部长度 */
+		char *bufA = (char *)malloc(a_len + 1);
+		char *bufB = (char *)malloc(b_len + 1);
+		if (!bufA || !bufB)
+		{
+			free(bufA);
+			free(bufB);
+			return 0;
+		}
+
+		memcpy(bufA, a, a_len);
+		bufA[a_len] = '\0';
+		memcpy(bufB, b, b_len);
+		bufB[b_len] = '\0';
+
+		double va = strtod(bufA, &endA);
+		double vb = strtod(bufB, &endB);
+
+		int okA = (endA && *endA == '\0');
+		int okB = (endB && *endB == '\0');
+
+		free(bufA);
+		free(bufB);
+
+		if (okA && okB)
+		{
+			/* 直接相等（包含 -0 与 0）或允许极小误差 */
+			if (va == vb) { return 1; }
+			if (fabs(va - vb) < 1e-15) { return 1; }
+			return 0;
+		}
+	}
+
+	/* 其余作为纯文本兜底比较 */
+	return (a_len == b_len) && (memcmp(a, b, a_len) == 0);
+}
+
+/* 提取一元素数组的唯一元素；若不是一元素数组返回 0 */
+static int extract_single_array_element(const char *s, int32_t len, const char **elem, int32_t *elem_len)
+{
+	trim(&s, &len);
+	if (len < 2 || s[0] != '[' || s[len - 1] != ']') { return 0; }
+
+	const char *p = s + 1;
+	int32_t n = len - 2;
+
+	/* 去前后空白 */
+	trim(&p, &n);
+	if (n == 0) { return 0; /* 空数组 */ }
+
+	/* 扫描逗号，确保只有一个元素（字符串中的逗号不算） */
+	int in_str = 0;
+	int escape = 0;
+	for (int32_t i = 0; i < n; i++)
+	{
+		char c = p[i];
+		if (in_str)
+		{
+			if (escape) { escape = 0; }
+			else if (c == '\\') { escape = 1; }
+			else if (c == '\"') { in_str = 0; }
+		}
+		else
+		{
+			if (c == '\"') { in_str = 1; }
+			else if (c == ',') { return 0; /* 多元素数组 */ }
+		}
+	}
+
+	/* 去尾部空白 */
+	const char *q = p + n;
+	while (n && isspace((unsigned char)q[-1]))
+	{
+		q--;
+		n--;
+	}
+
+	*elem = p;
+	*elem_len = n;
+	return 1;
+}
+
+/* 顶层比较：若两侧都是一元素数组则剥离后比较；否则直接按值级比较 */
+static int json_value_equal(const char *a, int32_t a_len, const char *b, int32_t b_len)
+{
+	const char *ae = NULL, *be = NULL;
+	int32_t ale = 0, ble = 0;
+
+	if (extract_single_array_element(a, a_len, &ae, &ale) && extract_single_array_element(b, b_len, &be, &ble))
+	{
+		return json_scalar_equal(ae, ale, be, ble);
+	}
+
+	return json_scalar_equal(a, a_len, b, b_len);
+}
+
+static void checkadjfladjfl(char *data, uint32_t len, char *str, uint32_t strLen, uint32_t *alksdjfCOunt)
+{
+	if (0 != strcmp(data, str))
+	{
+		// data/str 是去掉两端引号后的 JSON 字符串内容，并且有长度
+		if (!json_value_equal(data, len, str, strLen))
+		{
+			(*alksdjfCOunt)++;
+			// 打印时避免 %s，被 NUL 截断；可以打印十六进制
+			printf("%d 数据不完全一致 -- 原始: %s -- 序列化: %s\n", *alksdjfCOunt, data, str);
+		}
+	}
+}
+
+/**
+ * @brief RyanJson 测试程序
+ *
+ * @param fileName
+ * @param data
+ * @param len
+ * @return int
+ */
+static int RyanJsonParseData(char *fileName, char *data, uint32_t len)
+{
+
+	if (strcmp(fileName, "n_structure_100000_opening_arrays.json") == 0 ||
+	    strcmp(fileName, "n_structure_open_array_object.json") == 0 || strcmp(fileName, "n_structure_100000_opening_arrays.json") == 0)
+	{
+		return -1;
+	}
+	// printf("开始解析: %s\r\n", fileName);
+	RyanJson_t json = RyanJsonParseOptions(data, len, RyanJsonTrue, NULL);
+	if (NULL == json) { return -1; }
+
+#ifdef PrintfStrCmpEnable
+	int32_t strLen = 0;
+	char *str = RyanJsonPrint(json, 60, RyanJsonFalse, &strLen);
+	if (NULL == str)
+	{
+		printf("反序列化失败: [%s]\n", data);
+		goto err;
+	}
+
+	RyanJsonMinify(data, len);
+	static uint32_t alksdjfCOunt = 0;
+	checkadjfladjfl(data, len, str, strLen, &alksdjfCOunt);
+
+	RyanJsonFree(str);
+#endif
+
+	RyanJsonDelete(json);
+	return 0;
+
+err:
+	RyanJsonDelete(json);
+	return -1;
+}
+
+/**
+ * @brief cJson测试程序
+ *
+ * @param fileName
+ * @param data
+ * @param len
+ * @return int
+ */
+static int cJSONParseData(char *fileName, char *data, uint32_t len)
+{
+
+	if (strcmp(fileName, "n_structure_100000_opening_arrays.json") == 0 ||
+	    strcmp(fileName, "n_structure_open_array_object.json") == 0 || strcmp(fileName, "n_structure_100000_opening_arrays.json") == 0)
+	{
+		return -1;
+	}
+
+	cJSON *json = cJSON_ParseWithLengthOpts(data, len + sizeof(""), NULL, RyanJsonTrue);
+	if (NULL == json) { return -1; }
+
+#ifdef PrintfStrCmpEnable
+	char *str = cJSON_PrintBuffered(json, 60, RyanJsonFalse);
+	if (NULL == str)
+	{
+		printf("反序列化失败: [%s]\n", data);
+		goto err;
+	}
+
+	cJSON_Minify(data);
+	static uint32_t alksdjfCOunt = 0;
+	checkadjfladjfl(data, len, str, strlen(str), &alksdjfCOunt);
+
+	cJSON_free(str);
+#endif
+
+	cJSON_Delete(json);
+	return 0;
+err:
+	cJSON_Delete(json);
+	return -1;
+}
+
+/**
+ * @brief cJson测试程序
+ *
+ * @param fileName
+ * @param data
+ * @param len
+ * @return int
+ */
+static int yyjsonParseData(char *fileName, char *data, uint32_t len)
+{
+	if (strcmp(fileName, "n_structure_100000_opening_arrays.json") == 0 ||
+	    strcmp(fileName, "n_structure_open_array_object.json") == 0 || strcmp(fileName, "n_structure_100000_opening_arrays.json") == 0)
+	{
+		return -1;
+	}
+
+	yyjson_doc *doc = yyjson_read(data, len, 0);
+	if (NULL == doc) { return -1; }
+
+#ifdef PrintfStrCmpEnable
+	char *str = yyjson_write(doc, 0, NULL);
+	if (NULL == str)
+	{
+		printf("反序列化失败: [%s]\n", data);
+		goto err;
+	}
+
+	cJSON_Minify(data);
+	static uint32_t alksdjfCOunt = 0;
+	checkadjfladjfl(data, len, str, strlen(str), &alksdjfCOunt);
+
+	free(str);
+#endif
+
+	yyjson_doc_free(doc);
+	return 0;
+err:
+	yyjson_doc_free(doc);
+	return -1;
+}
+
+// RFC 8259 JSON Test Suite
+// https://github.com/nst/JSONTestSuite
+RyanJsonBool_e RFC8259JsonTest(void)
+{
+	int result = 0;
+	RyanJsonInitHooks(v_malloc, v_free, v_realloc);
+
+	cJSON_Hooks hooks = {.malloc_fn = v_malloc, .free_fn = v_free};
+	cJSON_InitHooks(&hooks);
+
+	printf("开始 RFC 8259 JSON 测试");
+
+	printf("\r\n--------------------------- RFC8259  RyanJson --------------------------\r\n");
+	result = testFile("../../../../test//RFC8259JsonData", RyanJsonParseData);
+	if (0 != result)
+	{
+		printf("%s:%d RyanJson RFC8259JsonTest fail\r\n", __FILE__, __LINE__);
+		goto err;
+	}
+
+	printf("\r\n--------------------------- RFC8259  cJSON --------------------------\r\n");
+	result = testFile("../../../../test//RFC8259JsonData", cJSONParseData);
+	if (0 != result)
+	{
+		printf("%s:%d cJSON RFC8259JsonTest fail\r\n", __FILE__, __LINE__);
+		goto err;
+	}
+
+	printf("\r\n--------------------------- RFC8259  yyjson --------------------------\r\n");
+	result = testFile("../../../../test//RFC8259JsonData", yyjsonParseData);
+	if (0 != result)
+	{
+		printf("%s:%d yyjson RFC8259JsonTest fail\r\n", __FILE__, __LINE__);
+		goto err;
+	}
+
+	displayMem();
+	return RyanJsonTrue;
+
+err:
+	displayMem();
+	return RyanJsonFalse;
+}

test/RyanJsonTest.c

@@ -9,13 +9,44 @@ static void printfTitle(char *title)
 	printf("*****************************************************************************\r\n");
 }
 
+#ifndef isEnableFuzzer
+extern void printJsonDebug(RyanJson_t json);
 int main(void)
 {
-	RyanJsonBool result = 0;
-	printfTitle("RyanJson 示例程序");
-	// RyanJsonExample();
 
-	printfTitle("RyanJson 接口测试程序");
+	RyanJsonBool_e result = RyanJsonFalse;
+	RyanJsonInitHooks(v_malloc, v_free, v_realloc);
+
+	for (uint32_t i = 0; i < 1; i++)
+	{
+
+		char *str = NULL;
+		RyanJson_t jsonRoot, item;
+
+		// const char *jsonstr =
+		// 	"{\"emoji\":\"\\uD83D\\uDE00\"} ";
+		// const char *jsonstr = "{\"name\":\"Mash\",\"star\":4,\"hits\":[2,2,1,3]}";
+		const char *jsonstr = "[1";
+
+		// extern int LLVMFuzzerTestOneInput(const char *data, int32_t size);
+		// LLVMFuzzerTestOneInput(jsonstr, strlen(jsonstr));
+
+		// 解析json数据
+		// jsonRoot = RyanJsonParse(jsonstr);
+		// if (jsonRoot == NULL) { printf("%s:%d 序列化失败\r\n", __FILE__, __LINE__); }
+		// else
+		// {
+		// 	uint32_t len = 0;
+		// 	str = RyanJsonPrint(jsonRoot, 10, RyanJsonFalse, &len); // 以带格式方式将数据打印出来
+		// 	printf("strLen: %d, data: %s\r\n", len, str);
+
+		// 	RyanJsonFree(str);
+		// 	RyanJsonDelete(jsonRoot);
+		// }
+	}
+
+	RyanJsonExample();
+
 	result = RyanJsonBaseTest();
 	if (RyanJsonTrue != result)
 	{
@@ -23,17 +54,15 @@ int main(void)
 		return -1;
 	}
 
-	// printfTitle("RyanJson / cJSON / yyjson RFC8259标准测试");
-	// result = RFC8259JsonTest();
-	// if (0 != result)
-	// {
-	//     printf("%s:%d RFC8259JsonTest fail\r\n", __FILE__, __LINE__);
-	//     return -1;
-	// }
+	printfTitle("RyanJson / cJSON / yyjson RFC8259标准测试");
+	RFC8259JsonTest();
 
 	printfTitle("RyanJson / cJSON / yyjson 内存对比程序");
-	result = RyanJsonMemoryFootprintTest();
+	RyanJsonMemoryFootprintTest();
+	printf("\r\nok\r\n");
 
 	displayMem();
 	return 0;
 }
+
+#endif // isEnableFuzzer

test/RyanJsonTest.h

@@ -12,32 +12,29 @@ extern "C" {
 #include <time.h>
 #include <sys/stat.h>
 #include <dirent.h>
+#include <ctype.h>
 #include "valloc.h"
-#define malloc  v_malloc
-#define calloc  v_calloc
-#define free    v_free
-#define realloc v_realloc
-
 #include "RyanJson.h"
+#include "RyanJsonUtils.h"
 #include "cJSON.h"
 #include "yyjson.h"
 
 #define getArraySize(arr) ((int32_t)(sizeof(arr) / sizeof((arr)[0])))
-#define checkMemory                                                                                                                                                                                    \
-	do                                                                                                                                                                                             \
-	{                                                                                                                                                                                              \
-		int area = 0, use = 0;                                                                                                                                                                 \
-		v_mcheck(&area, &use);                                                                                                                                                                 \
-		if (area != 0 || use != 0)                                                                                                                                                             \
-		{                                                                                                                                                                                      \
-			RyanMqttLog_e("内存泄漏");                                                                                                                                                     \
-			while (1)                                                                                                                                                                      \
-			{                                                                                                                                                                              \
-				v_mcheck(&area, &use);                                                                                                                                                 \
-				RyanMqttLog_e("|||----------->>> area = %d, size = %d", area, use);                                                                                                    \
-				delay(3000);                                                                                                                                                           \
-			}                                                                                                                                                                              \
-		}                                                                                                                                                                                      \
+#define checkMemory                                                                                                                        \
+	do                                                                                                                                 \
+	{                                                                                                                                  \
+		int area = 0, use = 0;                                                                                                     \
+		v_mcheck(&area, &use);                                                                                                     \
+		if (area != 0 || use != 0)                                                                                                 \
+		{                                                                                                                          \
+			RyanMqttLog_e("内存泄漏");                                                                                         \
+			while (1)                                                                                                          \
+			{                                                                                                                  \
+				v_mcheck(&area, &use);                                                                                     \
+				RyanMqttLog_e("|||----------->>> area = %d, size = %d", area, use);                                        \
+				delay(3000);                                                                                               \
+			}                                                                                                                  \
+		}                                                                                                                          \
 	} while (0)
 
 // 定义枚举类型
@@ -45,9 +42,10 @@ extern "C" {
 // 定义结构体类型
 
 /* extern variables-----------------------------------------------------------*/
-extern RyanJsonBool RyanJsonBaseTest(void);
-extern RyanJsonBool RFC8259JsonTest(void);
-extern RyanJsonBool RyanJsonMemoryFootprintTest(void);
+extern RyanJsonBool_e RyanJsonExample(void);
+extern RyanJsonBool_e RyanJsonBaseTest(void);
+extern RyanJsonBool_e RFC8259JsonTest(void);
+extern RyanJsonBool_e RyanJsonMemoryFootprintTest(void);
 #ifdef __cplusplus
 }
 #endif

test/baseTest/RyanJsonBaseTest.c

@@ -0,0 +1,93 @@
+#include "RyanJsonBaseTest.h"
+
+static RyanJsonBool_e likeReferenceTest()
+{
+
+	// char *str = NULL;
+	// char jsonstr[] =
+	// "{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,\"item\":{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89],\"arrayString\":[\"hello\",\"hello\",\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}]}";
+	// RyanJson_t json = RyanJsonParse(jsonstr);
+	// RyanJson_t item = NULL;
+
+	// // RyanJson_t adfasdf = RyanJsonDuplicate(RyanJsonGetObjectToKey(json, "item"));
+
+	// // RyanJsonAddItemToObject(json, "test", adfasdf);
+
+	// // 这里做你想做的事,这里我选择打印出来
+	// // str = RyanJsonPrint(json, 50, RyanJsonTrue, NULL);
+	// // printf("item %s \r\n", str);
+	// // RyanJsonFree(str);
+
+	// for (int i = 0; i < 1; i++)
+	// {
+	//     // 分离test对象
+	//     item = RyanJsonDetachByKey(json, "item");
+
+	//     // if (RyanJsonIsKey(item))
+	//     //     RyanJsonFree(RyanJsonGetKey(item));
+
+	//     // RyanJsonFree(item);
+	// }
+
+	// RyanJsonAddItemToObject(json, "item", item);
+
+	// str = RyanJsonPrint(json, 50, RyanJsonTrue, NULL);
+	// printf("item %s \r\n", str);
+	// RyanJsonFree(str);
+
+	// RyanJsonDelete(json);
+
+	return 0;
+}
+
+uint64_t platformUptimeMs(void)
+{
+	struct timespec ts;
+	// CLOCK_MONOTONIC: 单调递增，不受系统时间修改影响，适合做耗时统计
+	clock_gettime(CLOCK_MONOTONIC, &ts);
+	return (uint64_t)ts.tv_sec * 1000 + ts.tv_nsec / 1000000;
+}
+
+RyanJsonBool_e RyanJsonBaseTest(void)
+{
+	int32_t result = 0;
+	RyanJsonInitHooks(v_malloc, v_free, v_realloc);
+
+	uint32_t testRunCount = 0;
+	uint64_t funcStartMs;
+#define runTestWithLogAndTimer(fun)                                                                                                        \
+	do                                                                                                                                 \
+	{                                                                                                                                  \
+		testRunCount++;                                                                                                            \
+		printf("┌── [TEST %d] 开始执行: " #fun "()\r\n", testRunCount);                                                            \
+		funcStartMs = platformUptimeMs();                                                                                          \
+		result = fun();                                                                                                            \
+		printf("└── [TEST %" PRIu32 "] 结束执行: 返回值 = %" PRId32 " %s | 耗时: %" PRIu64 " ms\x1b[0m\r\n\r\n", testRunCount,     \
+		       result, (result == RyanJsonTrue) ? "✅" : "❌", (platformUptimeMs() - funcStartMs));                                \
+		RyanJsonCheckCodeNoReturn(RyanJsonTrue == result, { goto __exit; });                                                       \
+	} while (0)
+
+	runTestWithLogAndTimer(RyanJsonBaseTestChangeJson);    // JSON 修改功能的条件覆盖测试
+	runTestWithLogAndTimer(RyanJsonBaseTestCompareJson);   // 节点比较与一致性验证
+	runTestWithLogAndTimer(RyanJsonBaseTestCreateJson);    // 节点创建与结构正确性检查
+	runTestWithLogAndTimer(RyanJsonBaseTestDeleteJson);    // JSON 删除功能的条件覆盖测试
+	runTestWithLogAndTimer(RyanJsonBaseTestDetachJson);    // 节点分离操作的条件覆盖测试
+	runTestWithLogAndTimer(RyanJsonBaseTestDuplicateJson); // 节点复制的深拷贝与浅拷贝验证
+	runTestWithLogAndTimer(RyanJsonBaseTestForEachJson);   // 节点遍历与迭代稳定性测试
+	runTestWithLogAndTimer(RyanJsonBaseTestLoadJson);      // JSON 文本解析与加载能力验证
+	runTestWithLogAndTimer(RyanJsonBaseTestReplaceJson);   // 节点替换功能的条件覆盖测试
+
+	// result = likeReferenceTest(); // 模仿 引用类型实现 示例
+	// if (0 != result)
+	// {
+	// 	printf("%s:%d loadJsonTest fail\r\n", __FILE__, __LINE__);
+	// 	return RyanJsonFalse;
+	// }
+
+	displayMem();
+	return RyanJsonTrue;
+
+__exit:
+	displayMem();
+	return RyanJsonFalse;
+}

test/baseTest/RyanJsonBaseTest.h

@@ -0,0 +1,49 @@
+#ifndef __RyanJsonBaseTest__
+#define __RyanJsonBaseTest__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <math.h>
+#include <time.h>
+
+#include "RyanJson.h"
+#include "RyanJsonUtils.h"
+#include "cJSON.h"
+#include "valloc.h"
+#include "RyanJsonTest.h"
+#define jsonLog(fmt, ...) printf("%s:%d " fmt, __FILE__, __LINE__, ##__VA_ARGS__)
+
+// 定义枚举类型
+
+// 定义结构体类型
+
+/* extern variables-----------------------------------------------------------*/
+
+extern RyanJsonBool_e compare_double(double a, double b);
+extern void printJsonDebug(RyanJson_t json);
+extern RyanJsonBool_e rootNodeCheckTest(RyanJson_t json);
+extern RyanJsonBool_e itemNodeCheckTest(RyanJson_t json);
+extern RyanJsonBool_e arrayNodeCheckTest(RyanJson_t json);
+extern RyanJsonBool_e arrayItemNodeCheckTest(RyanJson_t json);
+extern RyanJsonBool_e RyanJsonBaseTestCheckRoot(RyanJson_t pJson);
+
+extern RyanJsonBool_e RyanJsonBaseTestChangeJson(void);
+extern RyanJsonBool_e RyanJsonBaseTestCompareJson(void);
+extern RyanJsonBool_e RyanJsonBaseTestCreateJson(void);
+extern RyanJsonBool_e RyanJsonBaseTestDeleteJson(void);
+extern RyanJsonBool_e RyanJsonBaseTestDetachJson(void);
+extern RyanJsonBool_e RyanJsonBaseTestDuplicateJson(void);
+extern RyanJsonBool_e RyanJsonBaseTestForEachJson(void);
+extern RyanJsonBool_e RyanJsonBaseTestLoadJson(void);
+extern RyanJsonBool_e RyanJsonBaseTestReplaceJson(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

test/baseTest/RyanJsonBaseTestChangeJson.c

@@ -0,0 +1,103 @@
+#include "RyanJsonBaseTest.h"
+
+/* --------------------------------------------------------------------- */
+
+RyanJsonBool_e RyanJsonBaseTestChangeJson(void)
+{
+	char jsonstr[] =
+		"{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,"
+		"\"item\":{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null},"
+		"\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89],"
+		"\"arrayString\":[\"hello\",\"hello\",\"hello\",\"hello\",\"hello\"],"
+		"\"array\":[16,16.89,\"hello\",true,false,null],"
+		"\"arrayItem\":[{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null},"
+		"{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}],"
+		"\"string2222\":\"hello\"}";
+
+	RyanJson_t json = RyanJsonParse(jsonstr);
+	RyanJsonCheckReturnFalse(NULL != json);
+
+	/**
+	 * @brief 修改基本类型
+	 */
+	RyanJsonChangeIntValue(RyanJsonGetObjectToKey(json, "inter"), 20);
+	RyanJsonCheckCode(RyanJsonIsInt(RyanJsonGetObjectToKey(json, "inter")) &&
+				  20 == RyanJsonGetIntValue(RyanJsonGetObjectToKey(json, "inter")),
+			  { goto err; });
+
+	RyanJsonChangeDoubleValue(RyanJsonGetObjectToKey(json, "double"), 20.89);
+	RyanJsonCheckCode(RyanJsonIsDouble(RyanJsonGetObjectToKey(json, "double")) &&
+				  compare_double(RyanJsonGetDoubleValue(RyanJsonGetObjectToKey(json, "double")), 20.89),
+			  { goto err; });
+
+	RyanJsonChangeStringValue(RyanJsonGetObjectToKey(json, "string"), "world");
+	RyanJsonCheckCode(RyanJsonIsString(RyanJsonGetObjectToKey(json, "string")) &&
+				  strcmp(RyanJsonGetStringValue(RyanJsonGetObjectToKey(json, "string")), "world") == 0,
+			  { goto err; });
+
+	RyanJsonChangeBoolValue(RyanJsonGetObjectToKey(json, "boolTrue"), RyanJsonFalse);
+	RyanJsonCheckCode(RyanJsonIsBool(RyanJsonGetObjectToKey(json, "boolTrue")) &&
+				  RyanJsonGetBoolValue(RyanJsonGetObjectToKey(json, "boolTrue")) == RyanJsonFalse,
+			  { goto err; });
+
+	RyanJsonChangeBoolValue(RyanJsonGetObjectToKey(json, "boolFalse"), RyanJsonTrue);
+	RyanJsonCheckCode(RyanJsonIsBool(RyanJsonGetObjectToKey(json, "boolFalse")) &&
+				  RyanJsonGetBoolValue(RyanJsonGetObjectToKey(json, "boolFalse")) == RyanJsonTrue,
+			  { goto err; });
+
+	/**
+	 * @brief 修改数组元素 (arrayInt)
+	 */
+	RyanJsonChangeIntValue(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json, "arrayInt"), 0), 99);
+	RyanJsonCheckCode(RyanJsonIsInt(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json, "arrayInt"), 0)) &&
+				  RyanJsonGetIntValue(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json, "arrayInt"), 0)) == 99,
+			  { goto err; });
+
+	/**
+	 * @brief 修改数组元素 (arrayDouble)
+	 */
+	RyanJsonChangeDoubleValue(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json, "arrayDouble"), 1), 99.99);
+	RyanJsonCheckCode(
+		RyanJsonIsDouble(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json, "arrayDouble"), 1)) &&
+			compare_double(RyanJsonGetDoubleValue(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json, "arrayDouble"), 1)),
+				       99.99),
+		{ goto err; });
+
+	/**
+	 * @brief 修改数组元素 (arrayString)
+	 */
+	RyanJsonChangeStringValue(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json, "arrayString"), 2), "changedString");
+	RyanJsonCheckCode(RyanJsonIsString(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json, "arrayString"), 2)) &&
+				  strcmp(RyanJsonGetStringValue(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json, "arrayString"), 2)),
+					 "changedString") == 0,
+			  { goto err; });
+
+	/**
+	 * @brief 修改嵌套对象
+	 */
+	RyanJsonChangeStringValue(RyanJsonGetObjectToKey(RyanJsonGetObjectToKey(json, "item"), "string"), "nestedWorld");
+	RyanJsonCheckCode(RyanJsonIsString(RyanJsonGetObjectToKey(RyanJsonGetObjectToKey(json, "item"), "string")) &&
+				  strcmp(RyanJsonGetStringValue(RyanJsonGetObjectToKey(RyanJsonGetObjectToKey(json, "item"), "string")),
+					 "nestedWorld") == 0,
+			  { goto err; });
+
+	/**
+	 * @brief 修改数组对象中的字段 (arrayItem[0].inter -> 123)
+	 */
+	RyanJsonChangeIntValue(RyanJsonGetObjectToKey(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json, "arrayItem"), 0), "inter"),
+			       123);
+	RyanJsonCheckCode(
+		RyanJsonIsInt(RyanJsonGetObjectToKey(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json, "arrayItem"), 0), "inter")) &&
+			RyanJsonGetIntValue(RyanJsonGetObjectToKey(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json, "arrayItem"), 0),
+								   "inter")) == 123,
+		{ goto err; });
+
+	char *str = RyanJsonPrint(json, 1024, RyanJsonTrue, NULL);
+	RyanJsonFree(str);
+	RyanJsonDelete(json);
+	return RyanJsonTrue;
+
+err:
+	RyanJsonDelete(json);
+	return RyanJsonFalse;
+}

test/baseTest/RyanJsonBaseTestCompareJson.c

@@ -0,0 +1,158 @@
+#include "RyanJsonBaseTest.h"
+/* --------------------------------------------------------------------- */
+
+RyanJsonBool_e RyanJsonBaseTestCompareJson(void)
+{
+	char jsonstr[] = "{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,\"item\":"
+			 "{\"inter\":16,\"double\":16."
+			 "89,\"string\":\"hello\","
+			 "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,"
+			 "16.89,16.89,16.89],"
+			 "\"arrayString\":[\"hello\",\"hello\","
+			 "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,"
+			 "\"double\":16.89,\"string\":"
+			 "\"hello\",\"boolTrue\":true,"
+			 "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
+			 "\"boolFalse\":false,\"null\":null}]}";
+
+	RyanJson_t json = RyanJsonParse(jsonstr);
+	RyanJson_t json2 = RyanJsonParse(jsonstr);
+
+	// 比较函数
+	RyanJsonCheckCode(RyanJsonTrue == RyanJsonCompare(json, json2), { goto err; });
+
+	RyanJsonDelete(json2);
+	json2 = RyanJsonParse(jsonstr);
+	RyanJsonAddStringToObject(json2, "test", "hello");
+	RyanJsonCheckCode(RyanJsonFalse == RyanJsonCompare(json, json2), { goto err; });
+
+	RyanJsonDelete(json2);
+	json2 = RyanJsonParse(jsonstr);
+	RyanJsonAddIntToObject(json2, "test", 1);
+	RyanJsonCheckCode(RyanJsonFalse == RyanJsonCompare(json, json2), { goto err; });
+
+	RyanJsonDelete(json2);
+	json2 = RyanJsonParse(jsonstr);
+	RyanJsonAddDoubleToObject(json2, "test", 2.0);
+	RyanJsonCheckCode(RyanJsonFalse == RyanJsonCompare(json, json2), { goto err; });
+
+	RyanJsonDelete(json2);
+	json2 = RyanJsonParse(jsonstr);
+	RyanJsonAddBoolToObject(json2, "test", RyanJsonTrue);
+	RyanJsonCheckCode(RyanJsonFalse == RyanJsonCompare(json, json2), { goto err; });
+
+	RyanJsonDelete(json2);
+	json2 = RyanJsonParse(jsonstr);
+	RyanJsonAddNullToObject(json2, "test");
+	RyanJsonCheckCode(RyanJsonFalse == RyanJsonCompare(json, json2), { goto err; });
+
+	RyanJsonDelete(json2);
+	json2 = RyanJsonParse(jsonstr);
+	RyanJsonAddIntToArray(RyanJsonGetObjectToKey(json2, "arrayInt"), 2);
+	RyanJsonCheckCode(RyanJsonFalse == RyanJsonCompare(json, json2), { goto err; });
+
+	RyanJsonDelete(json2);
+	json2 = RyanJsonParse(jsonstr);
+	RyanJsonAddDoubleToArray(RyanJsonGetObjectToKey(json2, "arrayDouble"), 2.0);
+	RyanJsonCheckCode(RyanJsonFalse == RyanJsonCompare(json, json2), { goto err; });
+
+	RyanJsonDelete(json2);
+	json2 = RyanJsonParse(jsonstr);
+	RyanJsonAddStringToArray(RyanJsonGetObjectToKey(json2, "arrayString"), "hello");
+	RyanJsonCheckCode(RyanJsonFalse == RyanJsonCompare(json, json2), { goto err; });
+
+	RyanJsonDelete(json2);
+	json2 = RyanJsonParse(jsonstr);
+	RyanJsonAddItemToArray(RyanJsonGetObjectToKey(json2, "arrayItem"), RyanJsonCreateString("test", "hello"));
+	RyanJsonCheckCode(RyanJsonFalse == RyanJsonCompare(json, json2), { goto err; });
+
+	RyanJsonDelete(json2);
+	json2 = RyanJsonParse(jsonstr);
+	RyanJsonChangeKey(RyanJsonGetObjectToKey(json2, "inter"), "int2");
+	RyanJsonCheckCode(RyanJsonFalse == RyanJsonCompare(json, json2), { goto err; });
+
+	RyanJsonDelete(json2);
+	json2 = RyanJsonParse(jsonstr);
+	RyanJsonChangeIntValue(RyanJsonGetObjectToKey(json2, "inter"), 17);
+	RyanJsonCheckCode(RyanJsonFalse == RyanJsonCompare(json, json2), { goto err; });
+
+	RyanJsonDelete(json2);
+	json2 = RyanJsonParse(jsonstr);
+	RyanJsonChangeDoubleValue(RyanJsonGetObjectToKey(json2, "double"), 20.89);
+	if (RyanJsonFalse != RyanJsonCompare(json, json2))
+	{
+		printf("%s:%d 解析失败\r\n", __FILE__, __LINE__);
+		goto err;
+	}
+
+	RyanJsonDelete(json2);
+	json2 = RyanJsonParse(jsonstr);
+	RyanJsonDelete(RyanJsonDetachByKey(json2, "double"));
+	RyanJsonAddIntToObject(json2, "double", 20); // 改为int
+	RyanJsonCheckCode(RyanJsonFalse == RyanJsonCompare(json, json2), { goto err; });
+
+	RyanJsonDelete(json2);
+	json2 = RyanJsonParse(jsonstr);
+	RyanJsonChangeStringValue(RyanJsonGetObjectToKey(json2, "string"), "49");
+	RyanJsonCheckCode(RyanJsonFalse == RyanJsonCompare(json, json2), { goto err; });
+
+	RyanJsonDelete(json2);
+	json2 = RyanJsonParse(jsonstr);
+	RyanJsonChangeBoolValue(RyanJsonGetObjectToKey(json2, "boolTrue"), RyanJsonFalse);
+	RyanJsonCheckCode(RyanJsonFalse == RyanJsonCompare(json, json2), { goto err; });
+
+	RyanJsonDelete(json2);
+	json2 = RyanJsonParse(jsonstr);
+	RyanJsonChangeBoolValue(RyanJsonGetObjectToKey(json2, "item", "boolTrue"), RyanJsonFalse);
+	RyanJsonCheckCode(RyanJsonFalse == RyanJsonCompare(json, json2), { goto err; });
+
+	RyanJsonDelete(json2);
+	json2 = RyanJsonParse(jsonstr);
+	RyanJsonChangeIntValue(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json2, "arrayInt"), 0), 17);
+	RyanJsonCheckCode(RyanJsonFalse == RyanJsonCompare(json, json2), { goto err; });
+
+	RyanJsonDelete(json2);
+	json2 = RyanJsonParse(jsonstr);
+	RyanJsonChangeDoubleValue(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json2, "arrayDouble"), 0), 20.89);
+	RyanJsonCheckCode(RyanJsonFalse == RyanJsonCompare(json, json2), { goto err; });
+
+	RyanJsonDelete(json2);
+	json2 = RyanJsonParse(jsonstr);
+	RyanJsonChangeStringValue(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json2, "arrayString"), 0), "20.89");
+	RyanJsonCheckCode(RyanJsonFalse == RyanJsonCompare(json, json2), { goto err; });
+
+	RyanJsonDelete(json2);
+	json2 = RyanJsonParse(jsonstr);
+	RyanJsonChangeIntValue(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json2, "array"), 0), 17);
+	RyanJsonCheckCode(RyanJsonFalse == RyanJsonCompare(json, json2), { goto err; });
+
+	RyanJsonDelete(json2);
+	json2 = RyanJsonParse(jsonstr);
+	RyanJsonChangeIntValue(RyanJsonGetObjectToKey(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json2, "arrayItem"), 0), "inter"),
+			       17);
+	RyanJsonCheckCode(RyanJsonFalse == RyanJsonCompare(json, json2), { goto err; });
+
+	RyanJsonDelete(json2);
+	json2 = RyanJsonParse(jsonstr);
+	RyanJsonDeleteByKey(json2, "arrayItem");
+	RyanJsonCheckCode(RyanJsonFalse == RyanJsonCompare(json, json2), { goto err; });
+
+	RyanJsonDelete(json2);
+	json2 = RyanJsonParse(jsonstr);
+	RyanJsonDeleteByIndex(RyanJsonGetObjectToKey(json2, "arrayInt"), 2);
+	RyanJsonCheckCode(RyanJsonFalse == RyanJsonCompare(json, json2), { goto err; });
+
+	RyanJsonDelete(json2);
+	json2 = RyanJsonParse(jsonstr);
+	RyanJsonDeleteByIndex(RyanJsonGetObjectToKey(json2, "arrayItem"), 0);
+	RyanJsonCheckCode(RyanJsonFalse == RyanJsonCompare(json, json2), { goto err; });
+
+	RyanJsonDelete(json);
+	RyanJsonDelete(json2);
+	return RyanJsonTrue;
+
+err:
+	RyanJsonDelete(json);
+	RyanJsonDelete(json2);
+	return RyanJsonFalse;
+}

test/baseTest/RyanJsonBaseTestCreateJson.c

@@ -0,0 +1,86 @@
+
+#include "RyanJsonBaseTest.h"
+
+RyanJsonBool_e RyanJsonBaseTestCreateJson(void)
+{
+	RyanJson_t jsonRoot, item;
+
+	// 对象生成测试
+	jsonRoot = RyanJsonCreateObject();
+	RyanJsonAddIntToObject(jsonRoot, "inter", 16);
+	RyanJsonAddDoubleToObject(jsonRoot, "double", 16.89);
+	RyanJsonAddStringToObject(jsonRoot, "string", "hello");
+	RyanJsonAddBoolToObject(jsonRoot, "boolTrue", RyanJsonTrue);
+	RyanJsonAddBoolToObject(jsonRoot, "boolFalse", RyanJsonFalse);
+	RyanJsonAddNullToObject(jsonRoot, "null");
+
+	/**
+	 * @brief 对象添加测试
+	 *
+	 */
+	item = RyanJsonCreateObject();
+	RyanJsonAddIntToObject(item, "inter", 16);
+	RyanJsonAddDoubleToObject(item, "double", 16.89);
+	RyanJsonAddStringToObject(item, "string", "hello");
+	RyanJsonAddBoolToObject(item, "boolTrue", RyanJsonTrue);
+	RyanJsonAddBoolToObject(item, "boolFalse", RyanJsonFalse);
+	RyanJsonAddNullToObject(item, "null");
+	RyanJsonAddItemToObject(jsonRoot, "item", item);
+
+	/**
+	 * @brief 数组添加测试
+	 *
+	 */
+	int arrayInt[] = {16, 16, 16, 16, 16};
+	RyanJsonAddItemToObject(jsonRoot, "arrayInt", RyanJsonCreateIntArray(arrayInt, sizeof(arrayInt) / sizeof(arrayInt[0])));
+
+	double arrayDouble[] = {16.89, 16.89, 16.89, 16.89, 16.89};
+	RyanJsonAddItemToObject(jsonRoot, "arrayDouble",
+				RyanJsonCreateDoubleArray(arrayDouble, sizeof(arrayDouble) / sizeof(arrayDouble[0])));
+
+	const char *arrayString[] = {"hello", "hello", "hello", "hello", "hello"};
+	RyanJsonAddItemToObject(jsonRoot, "arrayString",
+				RyanJsonCreateStringArray(arrayString, sizeof(arrayString) / sizeof(arrayString[0])));
+
+	RyanJson_t array = RyanJsonCreateArray();
+	RyanJsonAddIntToArray(array, 16);
+	RyanJsonAddDoubleToArray(array, 16.89);
+	RyanJsonAddStringToArray(array, "hello");
+	RyanJsonAddBoolToArray(array, RyanJsonTrue);
+	RyanJsonAddBoolToArray(array, RyanJsonFalse);
+	RyanJsonAddNullToArray(array);
+	RyanJsonAddItemToObject(jsonRoot, "array", array);
+
+	/**
+	 * @brief 对象数组测试
+	 *
+	 */
+	RyanJson_t arrayItem = RyanJsonCreateArray();
+	item = RyanJsonCreateObject();
+	RyanJsonAddIntToObject(item, "inter", 16);
+	RyanJsonAddDoubleToObject(item, "double", 16.89);
+	RyanJsonAddStringToObject(item, "string", "hello");
+	RyanJsonAddBoolToObject(item, "boolTrue", RyanJsonTrue);
+	RyanJsonAddBoolToObject(item, "boolFalse", RyanJsonFalse);
+	RyanJsonAddNullToObject(item, "null");
+	RyanJsonAddItemToObject(arrayItem, "item", item);
+
+	item = RyanJsonCreateObject();
+	RyanJsonAddIntToObject(item, "inter", 16);
+	RyanJsonAddDoubleToObject(item, "double", 16.89);
+	RyanJsonAddStringToObject(item, "string", "hello");
+	RyanJsonAddBoolToObject(item, "boolTrue", RyanJsonTrue);
+	RyanJsonAddBoolToObject(item, "boolFalse", RyanJsonFalse);
+	RyanJsonAddNullToObject(item, "null");
+	RyanJsonAddItemToObject(arrayItem, "item", item);
+
+	RyanJsonAddItemToObject(jsonRoot, "arrayItem", arrayItem);
+
+	RyanJsonCheckCode(RyanJsonTrue == RyanJsonBaseTestCheckRoot(jsonRoot), {
+		RyanJsonDelete(jsonRoot);
+		return RyanJsonFalse;
+	});
+	RyanJsonDelete(jsonRoot);
+
+	return RyanJsonTrue;
+}

test/baseTest/RyanJsonBaseTestDeleteJson.c

@@ -0,0 +1,112 @@
+#include "RyanJsonBaseTest.h"
+
+/* --------------------------------------------------------------------- */
+
+RyanJsonBool_e RyanJsonBaseTestDeleteJson(void)
+{
+	// 保持原始 jsonStr，不做修改
+	char jsonstr[] =
+		"{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,\"item\":"
+		"{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null},"
+		"\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89],"
+		"\"arrayString\":[\"hello\",\"hello\",\"hello\",\"hello\",\"hello\"],"
+		"\"array\":[16,16.89,\"hello\",true,false,null],"
+		"\"arrayItem\":[{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null},"
+		"{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}],"
+		"\"string2222\":\"hello\"}";
+
+	RyanJson_t json = RyanJsonParse(jsonstr);
+	RyanJsonCheckReturnFalse(NULL != json);
+
+	/**
+	 * @brief 场景 1：删除对象中的节点（头、中、尾）
+	 */
+	{
+		// 删除中间节点 (double)
+		RyanJsonDeleteByKey(json, "double");
+		RyanJsonCheckCode(NULL == RyanJsonGetObjectToKey(json, "double"), { goto err; });
+
+		// 删除头部节点 (inter)
+		RyanJsonDeleteByIndex(json, 0);
+		RyanJsonCheckCode(NULL == RyanJsonGetObjectToKey(json, "inter"), { goto err; });
+
+		// 删除尾部节点 (string2222)
+		uint32_t lastIndex = RyanJsonGetSize(json) - 1;
+		RyanJsonDeleteByIndex(json, lastIndex);
+		RyanJsonCheckCode(NULL == RyanJsonGetObjectToKey(json, "string2222"), { goto err; });
+	}
+
+	/**
+	 * @brief 场景 2：删除数组中的元素（arrayInt）
+	 */
+	{
+		RyanJson_t array = RyanJsonGetObjectToKey(json, "arrayInt");
+
+		// 删除数组首位
+		RyanJsonDeleteByIndex(array, 0);
+		RyanJsonCheckCode(RyanJsonGetSize(array) == 4, { goto err; });
+
+		// 删除数组中间元素
+		RyanJsonDeleteByIndex(array, 1);
+		RyanJsonCheckCode(RyanJsonGetSize(array) == 3, { goto err; });
+
+		// 删除数组尾部元素
+		uint32_t lastIndex = RyanJsonGetSize(array) - 1;
+		RyanJsonDeleteByIndex(array, lastIndex);
+		RyanJsonCheckCode(RyanJsonGetSize(array) == 2, { goto err; });
+	}
+
+	/**
+	 * @brief 场景 3：深层嵌套删除（item）
+	 */
+	{
+		RyanJsonDeleteByKey(json, "item");
+		RyanJsonCheckCode(NULL == RyanJsonGetObjectToKey(json, "item"), { goto err; });
+	}
+
+	/**
+	 * @brief 场景 4：数组对象元素删除（arrayItem）
+	 */
+	{
+		RyanJson_t arrObj = RyanJsonGetObjectToKey(json, "arrayItem");
+
+		// 删除第一个对象
+		RyanJsonDeleteByIndex(arrObj, 0);
+		RyanJsonCheckCode(RyanJsonGetSize(arrObj) == 1, { goto err; });
+
+		// 删除最后一个对象
+		RyanJsonDeleteByIndex(arrObj, 0);
+		RyanJsonCheckCode(RyanJsonGetSize(arrObj) == 0, { goto err; });
+	}
+
+	/**
+	 * @brief 场景 5：特殊类型删除（null / bool）
+	 */
+	{
+		RyanJsonDeleteByKey(json, "null");
+		RyanJsonCheckCode(NULL == RyanJsonGetObjectToKey(json, "null"), { goto err; });
+
+		RyanJsonDeleteByKey(json, "boolTrue");
+		RyanJsonCheckCode(NULL == RyanJsonGetObjectToKey(json, "boolTrue"), { goto err; });
+
+		RyanJsonDeleteByKey(json, "boolFalse");
+		RyanJsonCheckCode(NULL == RyanJsonGetObjectToKey(json, "boolFalse"), { goto err; });
+	}
+
+	/**
+	 * @brief 场景 6：异常路径覆盖（健壮性）
+	 */
+	{
+		RyanJsonDeleteByKey(json, "non_exist"); // 删除不存在的 Key
+		RyanJsonDeleteByIndex(NULL, 0);         // 在 NULL 上操作
+	}
+
+	char *str = RyanJsonPrint(json, 1024, RyanJsonTrue, NULL);
+	RyanJsonFree(str);
+	RyanJsonDelete(json);
+	return RyanJsonTrue;
+
+err:
+	RyanJsonDelete(json);
+	return RyanJsonFalse;
+}

test/baseTest/RyanJsonBaseTestDetachJson.c

@@ -0,0 +1,217 @@
+#include "RyanJsonBaseTest.h"
+
+/* --------------------------------------------------------------------- */
+
+RyanJsonBool_e RyanJsonBaseTestDetachJson(void)
+{
+	char jsonstr[] =
+		"{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,\"item\":"
+		"{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null},"
+		"\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89],"
+		"\"arrayString\":[\"hello\",\"hello\",\"hello\",\"hello\",\"hello\"],"
+		"\"array\":[16,16.89,\"hello\",true,false,null],"
+		"\"arrayItem\":[{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null},{"
+		"\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null},{\"inter\":16,"
+		"\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,"
+		"\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null},"
+		"{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}],"
+		"\"string2222\":\"hello\"}";
+
+	RyanJson_t json = RyanJsonParse(jsonstr);
+	RyanJsonCheckReturnFalse(NULL != json);
+
+	/**
+	 * @brief 对象子项分离测试（头、中、尾）
+	 */
+	{
+		RyanJson_t json2 = RyanJsonParse(jsonstr);
+
+		// 头部 (第一个 key: inter)
+		RyanJsonDelete(RyanJsonDetachByIndex(json, 0));
+		if (RyanJsonGetObjectToKey(json, "inter"))
+		{
+			RyanJsonCheckCode(NULL, { goto err; });
+		}
+
+		// 中间 (double)
+		RyanJsonDelete(RyanJsonDetachByKey(json, "double"));
+		if (RyanJsonGetObjectToKey(json, "double"))
+		{
+			RyanJsonCheckCode(NULL, { goto err; });
+		}
+
+		// 尾部 (最后一个 key: string2222)
+		uint32_t lastIndex = RyanJsonGetSize(json) - 1;
+		RyanJsonDelete(RyanJsonDetachByIndex(json, lastIndex));
+		if (RyanJsonGetObjectToKey(json, "string2222"))
+		{
+			RyanJsonCheckCode(NULL, { goto err; });
+		}
+
+		RyanJsonDelete(json2);
+	}
+
+	/**
+	 * @brief 数组元素分离测试 (arrayInt 头、中、尾)
+	 */
+	{
+		RyanJson_t arr = RyanJsonGetObjectByKey(json, "arrayInt");
+		RyanJson_t json2 = RyanJsonParse(jsonstr);
+
+        uint32_t jsonSize =  RyanJsonGetSize(arr);
+		// 头部
+		RyanJsonDelete(RyanJsonDetachByIndex(arr, 0));
+		if (jsonSize == RyanJsonGetSize(arr))
+		{
+			RyanJsonCheckCode(NULL, { goto err; });
+		}
+
+		// 中间
+         jsonSize =  RyanJsonGetSize(arr);
+		RyanJsonDelete(RyanJsonDetachByIndex(arr, 2));
+		if (jsonSize == RyanJsonGetSize(arr))
+		{
+			RyanJsonCheckCode(NULL, { goto err; });
+		}
+
+		// 尾部
+		uint32_t lastIndex = RyanJsonGetSize(arr) - 1;
+		RyanJsonDelete(RyanJsonDetachByIndex(arr, lastIndex));
+		if (NULL != RyanJsonGetObjectToIndex(arr, lastIndex))
+		{
+			RyanJsonCheckCode(NULL, { goto err; });
+		}
+
+		RyanJsonDelete(json2);
+	}
+
+	/**
+	 * @brief 数组元素分离测试 (arrayDouble 头、中、尾)
+	 */
+	{
+		RyanJson_t arr = RyanJsonGetObjectByKey(json, "arrayDouble");
+		RyanJson_t json2 = RyanJsonParse(jsonstr);
+
+		RyanJsonDelete(RyanJsonDetachByIndex(arr, 0));
+		if (RyanJsonGetObjectToIndex(arr, 0) == NULL)
+		{
+			RyanJsonCheckCode(NULL, { goto err; });
+		}
+
+		RyanJsonDelete(RyanJsonDetachByIndex(arr, 2));
+		if (RyanJsonGetObjectToIndex(arr, 2) == NULL)
+		{
+			RyanJsonCheckCode(NULL, { goto err; });
+		}
+
+		uint32_t lastIndex = RyanJsonGetSize(arr) - 1;
+		RyanJsonDelete(RyanJsonDetachByIndex(arr, lastIndex));
+		if (RyanJsonGetObjectToIndex(arr, lastIndex) != NULL)
+		{
+			RyanJsonCheckCode(NULL, { goto err; });
+		}
+
+		RyanJsonDelete(json2);
+	}
+
+	/**
+	 * @brief 数组元素分离测试 (arrayString 头、中、尾)
+	 */
+	{
+		RyanJson_t arr = RyanJsonGetObjectByKey(json, "arrayString");
+		RyanJson_t json2 = RyanJsonParse(jsonstr);
+
+		RyanJsonDelete(RyanJsonDetachByIndex(arr, 0));
+		if (RyanJsonGetObjectToIndex(arr, 0) == NULL)
+		{
+			RyanJsonCheckCode(NULL, { goto err; });
+		}
+
+		RyanJsonDelete(RyanJsonDetachByIndex(arr, 2));
+		if (RyanJsonGetObjectToIndex(arr, 2) == NULL)
+		{
+			RyanJsonCheckCode(NULL, { goto err; });
+		}
+
+		uint32_t lastIndex = RyanJsonGetSize(arr) - 1;
+		RyanJsonDelete(RyanJsonDetachByIndex(arr, lastIndex));
+		if (RyanJsonGetObjectToIndex(arr, lastIndex) != NULL)
+		{
+			RyanJsonCheckCode(NULL, { goto err; });
+		}
+
+		RyanJsonDelete(json2);
+	}
+
+	/**
+	 * @brief 嵌套对象分离测试 (item)
+	 */
+	{
+		RyanJson_t json2 = RyanJsonParse(jsonstr);
+		RyanJsonDelete(RyanJsonDetachByKey(json, "item"));
+		if (RyanJsonGetObjectToKey(json, "item"))
+		{
+			RyanJsonCheckCode(NULL, { goto err; });
+		}
+		RyanJsonDelete(json2);
+	}
+
+	/**
+	 * @brief 数组对象元素分离测试 (arrayItem 头、中、尾)
+	 */
+	{
+		RyanJson_t arr = RyanJsonGetObjectByKey(json, "arrayItem");
+		RyanJson_t json2 = RyanJsonParse(jsonstr);
+
+		RyanJsonDelete(RyanJsonDetachByIndex(arr, 0));
+		if (RyanJsonGetObjectToIndex(arr, 0) == NULL)
+		{
+			RyanJsonCheckCode(NULL, { goto err; });
+		}
+
+		RyanJsonDelete(RyanJsonDetachByIndex(arr, 1));
+		if (RyanJsonGetObjectToIndex(arr, 1) == NULL)
+		{
+			RyanJsonCheckCode(NULL, { goto err; });
+		}
+
+		uint32_t lastIndex = RyanJsonGetSize(arr) - 1;
+		RyanJsonDelete(RyanJsonDetachByIndex(arr, lastIndex));
+		if (RyanJsonGetObjectToIndex(arr, lastIndex) != NULL)
+		{
+			RyanJsonCheckCode(NULL, { goto err; });
+		}
+
+		RyanJsonDelete(json2);
+	}
+
+	/**
+	 * @brief 特殊类型分离测试（null / bool）
+	 */
+	{
+		RyanJson_t json2 = RyanJsonParse(jsonstr);
+
+		RyanJsonDelete(RyanJsonDetachByKey(json, "null"));
+		if (RyanJsonGetObjectToKey(json, "null"))
+		{
+			RyanJsonCheckCode(NULL, { goto err; });
+		}
+
+		RyanJsonDelete(RyanJsonDetachByKey(json, "boolTrue"));
+		if (RyanJsonGetObjectToKey(json, "boolTrue"))
+		{
+			RyanJsonCheckCode(NULL, { goto err; });
+		}
+
+		RyanJsonDelete(json2);
+	}
+
+	char *str = RyanJsonPrint(json, 1024, RyanJsonTrue, NULL);
+	RyanJsonFree(str);
+	RyanJsonDelete(json);
+	return RyanJsonTrue;
+
+err:
+	RyanJsonDelete(json);
+	return RyanJsonFalse;
+}

test/baseTest/RyanJsonBaseTestDuplicateJson.c

@@ -0,0 +1,139 @@
+
+#include "RyanJsonBaseTest.h"
+
+RyanJsonBool_e RyanJsonBaseTestDuplicateJson(void)
+{
+	RyanJson_t json, dupItem, jsonRoot = NULL;
+	char jsonstr[] = "{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,\"item\":"
+			 "{\"inter\":16,\"double\":16."
+			 "89,\"string\":\"hello\","
+			 "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,"
+			 "16.89,16.89,16.89],"
+			 "\"arrayString\":[\"hello\",\"hello\","
+			 "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,"
+			 "\"double\":16.89,\"string\":"
+			 "\"hello\",\"boolTrue\":true,"
+			 "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
+			 "\"boolFalse\":false,\"null\":null}]}";
+
+	/**
+	 * @brief 普通类型
+	 *
+	 */
+	json = RyanJsonParse(jsonstr);
+	dupItem = RyanJsonDuplicate(RyanJsonGetObjectToKey(json, "inter"));
+	if (RyanJsonFalse == RyanJsonCompare(dupItem, RyanJsonGetObjectToKey(json, "inter"))) { goto err; }
+	RyanJsonDelete(dupItem);
+
+	dupItem = RyanJsonDuplicate(RyanJsonGetObjectToKey(json, "inter"));
+	RyanJsonAddItemToObject(json, "test", dupItem);
+	if (RyanJsonFalse == RyanJsonCompare(RyanJsonGetObjectToKey(json, "test", "inter"), RyanJsonGetObjectToKey(json, "inter")))
+	{
+		goto err;
+	}
+	RyanJsonDelete(RyanJsonDetachByKey(json, "test"));
+
+	dupItem = RyanJsonDuplicate(RyanJsonGetObjectToKey(json, "inter"));
+	RyanJsonAddItemToObject(json, "test", dupItem);
+	if (RyanJsonFalse == RyanJsonCompare(RyanJsonGetObjectToKey(json, "test", "inter"), RyanJsonGetObjectToKey(json, "inter")))
+	{
+		goto err;
+	}
+	RyanJsonDelete(json);
+
+	json = RyanJsonParse(jsonstr);
+	dupItem = RyanJsonDuplicate(RyanJsonGetObjectToKey(json, "inter"));
+	RyanJsonAddItemToObject(json, "test", dupItem);
+	if (RyanJsonFalse == RyanJsonCompare(RyanJsonGetObjectToKey(json, "test", "inter"), RyanJsonGetObjectToKey(json, "inter")))
+	{
+		goto err;
+	}
+	RyanJsonDelete(RyanJsonDetachByKey(json, "test"));
+	RyanJsonDelete(json);
+
+	/**
+	 * @brief 对象类型
+	 *
+	 */
+	json = RyanJsonParse(jsonstr);
+	dupItem = RyanJsonDuplicate(RyanJsonGetObjectToKey(json, "item"));
+	if (RyanJsonFalse == RyanJsonCompare(dupItem, RyanJsonGetObjectToKey(json, "item"))) { goto err; }
+	RyanJsonDelete(dupItem);
+
+	dupItem = RyanJsonDuplicate(RyanJsonGetObjectToKey(json, "item"));
+	RyanJsonAddItemToObject(json, "test", dupItem);
+	if (RyanJsonFalse == RyanJsonCompare(RyanJsonGetObjectToKey(json, "test"), RyanJsonGetObjectToKey(json, "item"))) { goto err; }
+	RyanJsonDelete(RyanJsonDetachByKey(json, "test"));
+
+	dupItem = RyanJsonDuplicate(RyanJsonGetObjectToKey(json, "item"));
+	RyanJsonAddItemToObject(json, "test", dupItem);
+	if (RyanJsonFalse == RyanJsonCompare(RyanJsonGetObjectToKey(json, "test"), RyanJsonGetObjectToKey(json, "item"))) { goto err; }
+	RyanJsonDelete(json);
+
+	json = RyanJsonParse(jsonstr);
+	dupItem = RyanJsonDuplicate(RyanJsonGetObjectToKey(json, "item"));
+	RyanJsonAddItemToObject(json, "test", dupItem);
+	if (RyanJsonFalse == RyanJsonCompare(RyanJsonGetObjectToKey(json, "test"), RyanJsonGetObjectToKey(json, "item"))) { goto err; }
+	RyanJsonDelete(RyanJsonDetachByKey(json, "test"));
+	RyanJsonDelete(json);
+
+	/**
+	 * @brief 数组类型
+	 *
+	 */
+	json = RyanJsonParse(jsonstr);
+	dupItem = RyanJsonDuplicate(RyanJsonGetObjectToKey(json, "arrayItem"));
+	if (RyanJsonFalse == RyanJsonCompare(dupItem, RyanJsonGetObjectToKey(json, "arrayItem"))) { goto err; }
+	RyanJsonDelete(dupItem);
+
+	dupItem = RyanJsonDuplicate(RyanJsonGetObjectToKey(json, "arrayItem"));
+	RyanJsonAddItemToObject(json, "test", dupItem);
+	if (RyanJsonFalse == RyanJsonCompare(RyanJsonGetObjectToKey(json, "test"), RyanJsonGetObjectToKey(json, "arrayItem"))) { goto err; }
+	RyanJsonDelete(RyanJsonDetachByKey(json, "test"));
+
+	dupItem = RyanJsonDuplicate(RyanJsonGetObjectToKey(json, "arrayItem"));
+	RyanJsonAddItemToObject(json, "test", dupItem);
+	if (RyanJsonFalse == RyanJsonCompare(RyanJsonGetObjectToKey(json, "test"), RyanJsonGetObjectToKey(json, "arrayItem"))) { goto err; }
+	RyanJsonDelete(json);
+
+	json = RyanJsonParse(jsonstr);
+	dupItem = RyanJsonDuplicate(RyanJsonGetObjectToKey(json, "arrayItem"));
+	RyanJsonAddItemToObject(json, "test", dupItem);
+	if (RyanJsonFalse == RyanJsonCompare(RyanJsonGetObjectToKey(json, "test"), RyanJsonGetObjectToKey(json, "arrayItem"))) { goto err; }
+	RyanJsonDelete(RyanJsonDetachByKey(json, "test"));
+	RyanJsonDelete(json);
+
+	json = RyanJsonParse(jsonstr);
+	jsonRoot = RyanJsonCreateObject();
+	RyanJsonAddBoolToObject(jsonRoot, "arrayItem", RyanJsonTrue);
+	int use = 0;
+	for (uint8_t i = 0; i < 10; i++)
+	{
+		dupItem = RyanJsonParse(jsonstr);
+		RyanJsonReplaceByKey(jsonRoot, "arrayItem", RyanJsonDuplicate(dupItem));
+		if (RyanJsonFalse == RyanJsonCompare(RyanJsonGetObjectToKey(jsonRoot, "arrayItem"), dupItem)) { goto err; }
+		RyanJsonReplaceByKey(json, "arrayItem", RyanJsonDuplicate(RyanJsonGetObjectByKey(dupItem, "item")));
+		if (RyanJsonFalse == RyanJsonCompare(RyanJsonGetObjectToKey(json, "arrayItem"), RyanJsonGetObjectByKey(dupItem, "item")))
+		{
+			goto err;
+		}
+		RyanJsonDelete(dupItem);
+
+		int newuse = vallocGetUse();
+		if (i != 0 && newuse != use)
+		{
+			printf("%s:%d 内存泄漏\r\n", __FILE__, __LINE__);
+			goto err;
+		}
+		use = newuse;
+	}
+
+	RyanJsonDelete(json);
+	RyanJsonDelete(jsonRoot);
+	return RyanJsonTrue;
+
+err:
+	RyanJsonDelete(json);
+	RyanJsonDelete(jsonRoot);
+	return RyanJsonFalse;
+}

test/baseTest/RyanJsonBaseTestForEachJson.c

@@ -0,0 +1,45 @@
+
+#include "RyanJsonBaseTest.h"
+
+RyanJsonBool_e RyanJsonBaseTestForEachJson(void)
+{
+	char *str = NULL;
+	char jsonstr[] = "{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,\"item\":"
+			 "{\"inter\":16,\"double\":16."
+			 "89,\"string\":\"hello\","
+			 "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,"
+			 "16.89,16.89,16.89],"
+			 "\"arrayString\":[\"hello\",\"hello\","
+			 "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,"
+			 "\"double\":16.89,\"string\":"
+			 "\"hello\",\"boolTrue\":true,"
+			 "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
+			 "\"boolFalse\":false,\"null\":null}]}";
+
+	RyanJson_t json = RyanJsonParse(jsonstr);
+	RyanJson_t item = NULL;
+	RyanJsonArrayForEach(RyanJsonGetObjectToKey(json, "arrayDouble"), item)
+	{
+		if (!RyanJsonIsDouble(item) || !compare_double(16.89, RyanJsonGetDoubleValue(item))) { goto err; }
+	}
+
+	RyanJsonArrayForEach(RyanJsonGetObjectToKey(json, "arrayInt"), item)
+	{
+		if (!RyanJsonIsInt(item) || 16 != RyanJsonGetIntValue(item)) { goto err; }
+	}
+
+	int32_t strLen;
+	RyanJsonObjectForEach(RyanJsonGetObjectToKey(json, "item"), item)
+	{
+		str = RyanJsonPrint(item, 50, RyanJsonTrue, &strLen);
+		printf("item { %s : %s }  %d\r\n", RyanJsonGetKey(item), str, strLen);
+		RyanJsonFree(str);
+	}
+
+	RyanJsonDelete(json);
+	return RyanJsonTrue;
+
+err:
+	RyanJsonDelete(json);
+	return RyanJsonFalse;
+}

test/baseTest/RyanJsonBaseTestLoadJson.c

@@ -0,0 +1,278 @@
+
+#include "RyanJsonBaseTest.h"
+
+/* --------------------------------------------------------------------- */
+
+RyanJsonBool_e RyanJsonBaseTestLoadJson(void)
+{
+	char *str = NULL;
+	RyanJson_t json;
+	char jsonstr[] = "{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,\"item\":"
+			 "{\"inter\":16,\"double\":16."
+			 "89,\"string\":\"hello\","
+			 "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,"
+			 "16.89,16.89,16.89],"
+			 "\"arrayString\":[\"hello\",\"hello\","
+			 "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,"
+			 "\"double\":16.89,\"string\":"
+			 "\"hello\",\"boolTrue\":true,"
+			 "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
+			 "\"boolFalse\":false,\"null\":null}]}";
+
+	json = RyanJsonParse(jsonstr);
+	RyanJsonCheckReturnFalse(NULL != json);
+
+	str = RyanJsonPrint(json, 250, RyanJsonFalse, NULL);
+	RyanJsonCheckCode(0 == strcmp(str, jsonstr), {
+		RyanJsonFree(str);
+		RyanJsonDelete(json);
+		return RyanJsonFalse;
+	});
+
+	RyanJsonFree(str);
+
+	RyanJsonCheckCode(RyanJsonTrue == RyanJsonBaseTestCheckRoot(json), {
+		RyanJsonDelete(json);
+		return RyanJsonFalse;
+	});
+
+	RyanJsonDelete(json);
+
+	/**
+	 * @brief 测试序列化错误json结构
+	 *
+	 */
+	// \"inter\":16poi,  无效数字
+	json = RyanJsonParse("{\"inter\":16poi,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,"
+			     "\"item\":{\"inter\":"
+			     "16,\"double\":16.89,\"string\":\"hello\","
+			     "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16."
+			     "89,16.89,16.89,16."
+			     "89],\"arrayString\":[\"hello\",\"hello\","
+			     "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,"
+			     "\"double\":16.89,"
+			     "\"string\":\"hello\",\"boolTrue\":true,"
+			     "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
+			     "\"boolFalse\":false,"
+			     "\"null\":null}]}");
+	RyanJsonCheckCode(NULL == json, {
+		RyanJsonDelete(json);
+		return RyanJsonFalse;
+	});
+
+	// \"double\":16.8yu9,,  无效浮点数
+	json = RyanJsonParse("{\"inter\":16,\"double\":16.8yu9,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,"
+			     "\"item\":{\"inter\":16,"
+			     "\"double\":16.89,\"string\":\"hello\","
+			     "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16."
+			     "89,16.89,16.89,16."
+			     "89],\"arrayString\":[\"hello\",\"hello\","
+			     "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,"
+			     "\"double\":16.89,"
+			     "\"string\":\"hello\",\"boolTrue\":true,"
+			     "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
+			     "\"boolFalse\":false,"
+			     "\"null\":null}]}");
+	RyanJsonCheckCode(NULL == json, {
+		RyanJsonDelete(json);
+		return RyanJsonFalse;
+	});
+
+	// boolTrue 设置为 tru
+	json = RyanJsonParse("{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":tru,\"boolFalse\":false,\"null\":null,"
+			     "\"item\":{\"inter\":16,"
+			     "\"double\":16.89,\"string\":\"hello\","
+			     "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16."
+			     "89,16.89,16.89,16."
+			     "89],\"arrayString\":[\"hello\",\"hello\","
+			     "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,"
+			     "\"double\":16.89,"
+			     "\"string\":\"hello\",\"boolTrue\":true,"
+			     "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
+			     "\"boolFalse\":false,"
+			     "\"null\":null}]}");
+	RyanJsonCheckCode(NULL == json, {
+		RyanJsonDelete(json);
+		return RyanJsonFalse;
+	});
+
+	// boolFalse 设置为 fale
+	json = RyanJsonParse("{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":fale,\"null\":null,"
+			     "\"item\":{\"inter\":16,"
+			     "\"double\":16.89,\"string\":\"hello\","
+			     "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16."
+			     "89,16.89,16.89,16."
+			     "89],\"arrayString\":[\"hello\",\"hello\","
+			     "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,"
+			     "\"double\":16.89,"
+			     "\"string\":\"hello\",\"boolTrue\":true,"
+			     "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
+			     "\"boolFalse\":false,"
+			     "\"null\":null}]}");
+	RyanJsonCheckCode(NULL == json, {
+		RyanJsonDelete(json);
+		return RyanJsonFalse;
+	});
+
+	// null 设置为 nul
+	json = RyanJsonParse("{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":nul,"
+			     "\"item\":{\"inter\":16,"
+			     "\"double\":16.89,\"string\":\"hello\","
+			     "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16."
+			     "89,16.89,16.89,16."
+			     "89],\"arrayString\":[\"hello\",\"hello\","
+			     "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,"
+			     "\"double\":16.89,"
+			     "\"string\":\"hello\",\"boolTrue\":true,"
+			     "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
+			     "\"boolFalse\":false,"
+			     "\"null\":null}]}");
+	RyanJsonCheckCode(NULL == json, {
+		RyanJsonDelete(json);
+		return RyanJsonFalse;
+	});
+
+	// null 设置为 NULL
+	json = RyanJsonParse("{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":NULL,"
+			     "\"item\":{\"inter\":16,"
+			     "\"double\":16.89,\"string\":\"hello\","
+			     "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16."
+			     "89,16.89,16.89,16."
+			     "89],\"arrayString\":[\"hello\",\"hello\","
+			     "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,"
+			     "\"double\":16.89,"
+			     "\"string\":\"hello\",\"boolTrue\":true,"
+			     "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
+			     "\"boolFalse\":false,"
+			     "\"null\":null}]}");
+	RyanJsonCheckCode(NULL == json, {
+		RyanJsonDelete(json);
+		return RyanJsonFalse;
+	});
+
+	// \"inter\":16后面少个,
+	json = RyanJsonParse("{\"inter\":16\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,"
+			     "\"item\":{\"inter\":16,"
+			     "\"double\":16.89,\"string\":\"hello\","
+			     "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16."
+			     "89,16.89,16.89,16."
+			     "89],\"arrayString\":[\"hello\",\"hello\","
+			     "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,"
+			     "\"double\":16.89,"
+			     "\"string\":\"hello\",\"boolTrue\":true,"
+			     "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
+			     "\"boolFalse\":false,"
+			     "\"null\":null}]}");
+	RyanJsonCheckCode(NULL == json, {
+		RyanJsonDelete(json);
+		return RyanJsonFalse;
+	});
+	// array数组项少一个,
+	json = RyanJsonParse("{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,"
+			     "\"item\":{\"inter\":16,"
+			     "\"double\":16.89,\"string\":\"hello\","
+			     "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16."
+			     "89,16.89,16.89,16."
+			     "89],\"arrayString\":[\"hello\",\"hello\","
+			     "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,"
+			     "\"double\":16.89,"
+			     "\"string\":\"hello\",\"boolTrue\":true,"
+			     "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
+			     "\"boolFalse\":false,"
+			     "\"null\":null}]}");
+	RyanJsonCheckCode(NULL == json, {
+		RyanJsonDelete(json);
+		return RyanJsonFalse;
+	});
+
+	// \"item:{\"inter\":16,\"  少一个"
+	json = RyanJsonParse("{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,"
+			     "\"item:{\"inter\":16,"
+			     "\"double\":16.89,\"string\":\"hello\","
+			     "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16."
+			     "89,16.89,16.89,16."
+			     "89],\"arrayString\":[\"hello\",\"hello\","
+			     "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,"
+			     "\"double\":16.89,"
+			     "\"string\":\"hello\",\"boolTrue\":true,"
+			     "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
+			     "\"boolFalse\":false,"
+			     "\"null\":null}]}");
+	RyanJsonCheckCode(NULL == json, {
+		RyanJsonDelete(json);
+		return RyanJsonFalse;
+	});
+
+	// \"item\":{\"inter\":16,double\"  少一个"
+	json = RyanJsonParse("{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,"
+			     "\"item\":{\"inter\":16,"
+			     "double\":16.89,\"string\":\"hello\","
+			     "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16."
+			     "89,16.89,16.89,16."
+			     "89],\"arrayString\":[\"hello\",\"hello\","
+			     "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,"
+			     "\"double\":16.89,"
+			     "\"string\":\"hello\",\"boolTrue\":true,"
+			     "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
+			     "\"boolFalse\":false,"
+			     "\"null\":null}]}");
+	RyanJsonCheckCode(NULL == json, {
+		RyanJsonDelete(json);
+		return RyanJsonFalse;
+	});
+
+	// \"item\":{\"inter\":16,\"\"double\"  多一个"
+	json = RyanJsonParse("{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,"
+			     "\"item\":{\"inter\":16,"
+			     "\"\"double\":16.89,\"string\":\"hello\","
+			     "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16."
+			     "89,16.89,16.89,16."
+			     "89],\"arrayString\":[\"hello\",\"hello\","
+			     "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,"
+			     "\"double\":16.89,"
+			     "\"string\":\"hello\",\"boolTrue\":true,"
+			     "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
+			     "\"boolFalse\":false,"
+			     "\"null\":null}]}");
+	RyanJsonCheckCode(NULL == json, {
+		RyanJsonDelete(json);
+		return RyanJsonFalse;
+	});
+
+	// \"item\":{\"inter\":16\",\"double\"  多一个"
+	json = RyanJsonParse("{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,"
+			     "\"item\":{\"inter\":16\","
+			     "\"double\":16.89,\"string\":\"hello\","
+			     "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16."
+			     "89,16.89,16.89,16."
+			     "89],\"arrayString\":[\"hello\",\"hello\","
+			     "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,"
+			     "\"double\":16.89,"
+			     "\"string\":\"hello\",\"boolTrue\":true,"
+			     "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
+			     "\"boolFalse\":false,"
+			     "\"null\":null}]}");
+	RyanJsonCheckCode(NULL == json, {
+		RyanJsonDelete(json);
+		return RyanJsonFalse;
+	});
+
+	// \"arrayInt\":[16,16,16m,16,16]  无效数组数字
+	json = RyanJsonParse("{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,"
+			     "\"item\":{\"inter\":16,"
+			     "\"double\":16.89,\"string\":\"hello\","
+			     "\"boolTrue\":true,\"boolFalse\":false,\"null\":null},\"arrayInt\":[16,16,16m,16,16],\"arrayDouble\":[16.89,"
+			     "16.89,16.89,16.89,16."
+			     "89],\"arrayString\":[\"hello\",\"hello\","
+			     "\"hello\",\"hello\",\"hello\"],\"array\":[16,16.89,\"hello\",true,false,null],\"arrayItem\":[{\"inter\":16,"
+			     "\"double\":16.89,"
+			     "\"string\":\"hello\",\"boolTrue\":true,"
+			     "\"boolFalse\":false,\"null\":null},{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,"
+			     "\"boolFalse\":false,"
+			     "\"null\":null}]}");
+	RyanJsonCheckCode(NULL == json, {
+		RyanJsonDelete(json);
+		return RyanJsonFalse;
+	});
+	return RyanJsonTrue;
+}

test/baseTest/RyanJsonBaseTestReplaceJson.c

@@ -0,0 +1,222 @@
+#include "RyanJsonBaseTest.h"
+
+/* --------------------------------------------------------------------- */
+
+RyanJsonBool_e RyanJsonBaseTestReplaceJson(void)
+{
+	char jsonstr[] =
+		"{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null,\"item\":"
+		"{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null},"
+		"\"arrayInt\":[16,16,16,16,16],\"arrayDouble\":[16.89,16.89,16.89,16.89,16.89],"
+		"\"arrayString\":[\"hello\",\"hello\",\"hello\",\"hello\",\"hello\"],"
+		"\"array\":[16,16.89,\"hello\",true,false,null],"
+		"\"arrayItem\":[{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null},"
+		"{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}],"
+		"\"string2222\":\"hello\"}";
+
+	RyanJson_t json = RyanJsonParse(jsonstr);
+	RyanJsonCheckReturnFalse(NULL != json);
+
+	/* ---------------- 保留原有测试（并补充校验） ---------------- */
+
+	// 数组替换测试：arrayInt 头
+	RyanJsonReplaceByIndex(RyanJsonGetObjectToKey(json, "arrayInt"), 0, RyanJsonCreateString(NULL, "arrayInt"));
+	{
+		RyanJson_t v = RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json, "arrayInt"), 0);
+		RyanJsonCheckCode(RyanJsonIsString(v), { goto err; });
+		RyanJsonCheckCode(strcmp(RyanJsonGetStringValue(v), "arrayInt") == 0, { goto err; });
+	}
+
+	// 数组替换测试：arrayInt 尾
+	{
+		RyanJson_t arr = RyanJsonGetObjectToKey(json, "arrayInt");
+		uint32_t last = RyanJsonGetSize(arr) - 1;
+		RyanJsonReplaceByIndex(arr, last, RyanJsonCreateString(NULL, "arrayInt"));
+		RyanJson_t v = RyanJsonGetObjectToIndex(arr, last);
+		RyanJsonCheckCode(RyanJsonIsString(v), { goto err; });
+		RyanJsonCheckCode(strcmp(RyanJsonGetStringValue(v), "arrayInt") == 0, { goto err; });
+	}
+
+	// 数组对象替换测试：arrayItem[0]
+	RyanJsonReplaceByIndex(RyanJsonGetObjectToKey(json, "arrayItem"), 0, RyanJsonCreateString(NULL, "arrayItem"));
+	{
+		RyanJson_t v = RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json, "arrayItem"), 0);
+		RyanJsonCheckCode(RyanJsonIsString(v), { goto err; });
+		RyanJsonCheckCode(strcmp(RyanJsonGetStringValue(v), "arrayItem") == 0, { goto err; });
+	}
+
+	// 数组对象替换测试：arrayItem[1]
+	RyanJsonReplaceByIndex(RyanJsonGetObjectToKey(json, "arrayItem"), 1, RyanJsonCreateString(NULL, "arrayItem"));
+	{
+		RyanJson_t v = RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json, "arrayItem"), 1);
+		RyanJsonCheckCode(RyanJsonIsString(v), { goto err; });
+		RyanJsonCheckCode(strcmp(RyanJsonGetStringValue(v), "arrayItem") == 0, { goto err; });
+	}
+
+	// 对象字段替换：inter -> 999
+	RyanJsonReplaceByKey(json, "inter", RyanJsonCreateInt("inter", 999));
+	{
+		RyanJson_t v = RyanJsonGetObjectToKey(json, "inter");
+		RyanJsonCheckCode(RyanJsonIsInt(v), { goto err; });
+		RyanJsonCheckCode(RyanJsonGetIntValue(v) == 999, { goto err; });
+	}
+
+	// 对象字段替换：double -> 123.45
+	RyanJsonReplaceByKey(json, "double", RyanJsonCreateDouble("double", 123.45));
+	{
+		RyanJson_t v = RyanJsonGetObjectToKey(json, "double");
+		RyanJsonCheckCode(RyanJsonIsDouble(v), { goto err; });
+		RyanJsonCheckCode(RyanJsonGetDoubleValue(v) == 123.45, { goto err; });
+	}
+
+	// 对象字段替换：string -> "newString"
+	RyanJsonReplaceByKey(json, "string", RyanJsonCreateString("string", "newString"));
+	{
+		RyanJson_t v = RyanJsonGetObjectToKey(json, "string");
+		RyanJsonCheckCode(RyanJsonIsString(v), { goto err; });
+		RyanJsonCheckCode(strcmp(RyanJsonGetStringValue(v), "newString") == 0, { goto err; });
+	}
+
+	// 对象字段替换：boolFalse -> true
+	RyanJsonReplaceByKey(json, "boolFalse", RyanJsonCreateBool("boolFalse", RyanJsonTrue));
+	{
+		RyanJson_t v = RyanJsonGetObjectToKey(json, "boolFalse");
+		RyanJsonCheckCode(RyanJsonIsBool(v), { goto err; });
+		RyanJsonCheckCode(RyanJsonGetBoolValue(v) == RyanJsonTrue, { goto err; });
+	}
+
+	// 数组替换：arrayInt 中间元素 -> "midInt"
+	RyanJsonReplaceByIndex(RyanJsonGetObjectToKey(json, "arrayInt"), 2, RyanJsonCreateString(NULL, "midInt"));
+	{
+		RyanJson_t v = RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json, "arrayInt"), 2);
+		RyanJsonCheckCode(RyanJsonIsString(v), { goto err; });
+		RyanJsonCheckCode(strcmp(RyanJsonGetStringValue(v), "midInt") == 0, { goto err; });
+	}
+
+	RyanJsonReplaceByIndex(RyanJsonGetObjectToKey(json, "arrayString"), 1, RyanJsonCreateString(NULL, "headString"));
+	{
+		RyanJson_t v = RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json, "arrayString"), 1);
+		RyanJsonCheckCode(RyanJsonIsString(v), { goto err; });
+		RyanJsonCheckCode(strcmp(RyanJsonGetStringValue(v), "headString") == 0, { goto err; });
+	}
+	{
+		RyanJson_t arr = RyanJsonGetObjectToKey(json, "arrayString");
+		uint32_t last = RyanJsonGetSize(arr) - 1;
+		RyanJsonReplaceByIndex(arr, last, RyanJsonCreateString(NULL, "tailString"));
+		RyanJson_t v = RyanJsonGetObjectToIndex(arr, last);
+		RyanJsonCheckCode(RyanJsonIsString(v), { goto err; });
+		RyanJsonCheckCode(strcmp(RyanJsonGetStringValue(v), "tailString") == 0, { goto err; });
+	}
+
+	// 数组对象替换：arrayItem 尾部 -> "arrayItemTail"
+	{
+		RyanJson_t arr = RyanJsonGetObjectToKey(json, "arrayItem");
+		uint32_t last = RyanJsonGetSize(arr) - 1;
+		RyanJsonReplaceByIndex(arr, last, RyanJsonCreateString(NULL, "arrayItemTail"));
+		RyanJson_t v = RyanJsonGetObjectToIndex(arr, last);
+		RyanJsonCheckCode(RyanJsonIsString(v), { goto err; });
+		RyanJsonCheckCode(strcmp(RyanJsonGetStringValue(v), "arrayItemTail") == 0, { goto err; });
+	}
+
+	// 嵌套对象替换：item.inter -> 111
+	RyanJsonReplaceByKey(RyanJsonGetObjectToKey(json, "item"), "inter", RyanJsonCreateInt("inter", 111));
+	{
+		RyanJson_t v = RyanJsonGetObjectToKey(RyanJsonGetObjectToKey(json, "item"), "inter");
+		RyanJsonCheckCode(RyanJsonIsInt(v), { goto err; });
+		RyanJsonCheckCode(RyanJsonGetIntValue(v) == 111, { goto err; });
+	}
+
+	// 嵌套对象替换：item.string -> "nestedReplace"
+	RyanJsonReplaceByKey(RyanJsonGetObjectToKey(json, "item"), "string", RyanJsonCreateString("string", "nestedReplace"));
+	{
+		RyanJson_t v = RyanJsonGetObjectToKey(RyanJsonGetObjectToKey(json, "item"), "string");
+		RyanJsonCheckCode(RyanJsonIsString(v), { goto err; });
+		RyanJsonCheckCode(strcmp(RyanJsonGetStringValue(v), "nestedReplace") == 0, { goto err; });
+	}
+
+	// 混合数组替换：各类型位置
+	// 0:int -> "intReplaced"
+	RyanJsonReplaceByIndex(RyanJsonGetObjectToKey(json, "array"), 0, RyanJsonCreateString(NULL, "intReplaced"));
+	{
+		RyanJson_t v = RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json, "array"), 0);
+		RyanJsonCheckCode(RyanJsonIsString(v), { goto err; });
+		RyanJsonCheckCode(strcmp(RyanJsonGetStringValue(v), "intReplaced") == 0, { goto err; });
+	}
+	// 1:double -> "doubleReplaced"
+	RyanJsonReplaceByIndex(RyanJsonGetObjectToKey(json, "array"), 1, RyanJsonCreateString(NULL, "doubleReplaced"));
+	{
+		RyanJson_t v = RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json, "array"), 1);
+		RyanJsonCheckCode(RyanJsonIsString(v), { goto err; });
+		RyanJsonCheckCode(strcmp(RyanJsonGetStringValue(v), "doubleReplaced") == 0, { goto err; });
+	}
+	// 2:string -> "stringReplaced"
+	RyanJsonReplaceByIndex(RyanJsonGetObjectToKey(json, "array"), 2, RyanJsonCreateString(NULL, "stringReplaced"));
+	{
+		RyanJson_t v = RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json, "array"), 2);
+		RyanJsonCheckCode(RyanJsonIsString(v), { goto err; });
+		RyanJsonCheckCode(strcmp(RyanJsonGetStringValue(v), "stringReplaced") == 0, { goto err; });
+	}
+	// 3:bool -> "boolReplaced"
+	RyanJsonReplaceByIndex(RyanJsonGetObjectToKey(json, "array"), 3, RyanJsonCreateString(NULL, "boolReplaced"));
+	{
+		RyanJson_t v = RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json, "array"), 3);
+		RyanJsonCheckCode(RyanJsonIsString(v), { goto err; });
+		RyanJsonCheckCode(strcmp(RyanJsonGetStringValue(v), "boolReplaced") == 0, { goto err; });
+	}
+	// 5:null -> "nullReplaced"
+	RyanJsonReplaceByIndex(RyanJsonGetObjectToKey(json, "array"), 5, RyanJsonCreateString(NULL, "nullReplaced"));
+	{
+		RyanJson_t v = RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json, "array"), 5);
+		RyanJsonCheckCode(RyanJsonIsString(v), { goto err; });
+		RyanJsonCheckCode(strcmp(RyanJsonGetStringValue(v), "nullReplaced") == 0, { goto err; });
+	}
+
+	// 对象替换测试：arrayString -> "arrayString2222"
+	RyanJsonReplaceByKey(json, "arrayString", RyanJsonCreateString("", "arrayString2222"));
+	{
+		RyanJson_t v = RyanJsonGetObjectToKey(json, "arrayString");
+		RyanJsonCheckCode(RyanJsonIsString(v), { goto err; });
+		RyanJsonCheckCode(strcmp(RyanJsonGetStringValue(v), "arrayString2222") == 0, { goto err; });
+	}
+
+	// 修改数组节点为对象节点：arrayDouble -> duplicate(item)
+	RyanJson_t duplicateJson = RyanJsonDuplicate(RyanJsonGetObjectToKey(json, "item"));
+	RyanJsonReplaceByKey(json, "arrayDouble", duplicateJson);
+	{
+		RyanJson_t v = RyanJsonGetObjectToKey(json, "arrayDouble");
+		RyanJsonCheckCode(RyanJsonIsObject(v), { goto err; });
+	}
+
+	// 替换普通 key 的值：string2222 -> "world"
+	RyanJsonReplaceByKey(json, "string2222", RyanJsonCreateString("string2222", "world"));
+	{
+		RyanJson_t v = RyanJsonGetObjectToKey(json, "string2222");
+		RyanJsonCheckCode(RyanJsonIsString(v), { goto err; });
+		RyanJsonCheckCode(strcmp(RyanJsonGetStringValue(v), "world") == 0, { goto err; });
+	}
+
+	// 替换布尔值：boolTrue -> false
+	RyanJsonReplaceByKey(json, "boolTrue", RyanJsonCreateBool("boolTrue", RyanJsonFalse));
+	{
+		RyanJson_t v = RyanJsonGetObjectToKey(json, "boolTrue");
+		RyanJsonCheckCode(RyanJsonIsBool(v), { goto err; });
+		RyanJsonCheckCode(RyanJsonGetBoolValue(v) == RyanJsonFalse, { goto err; });
+	}
+
+	// 替换 null：null -> "notNull"
+	RyanJsonReplaceByKey(json, "null", RyanJsonCreateString("null", "notNull"));
+	{
+		RyanJson_t v = RyanJsonGetObjectToKey(json, "null");
+		RyanJsonCheckCode(RyanJsonIsString(v), { goto err; });
+		RyanJsonCheckCode(strcmp(RyanJsonGetStringValue(v), "notNull") == 0, { goto err; });
+	}
+
+	char *str = RyanJsonPrint(json, 1024, RyanJsonTrue, NULL);
+	RyanJsonFree(str);
+	RyanJsonDelete(json);
+	return RyanJsonTrue;
+
+err:
+	RyanJsonDelete(json);
+	return RyanJsonFalse;
+}

test/baseTest/RyanJsonBaseTestUtile.c

@@ -0,0 +1,169 @@
+
+#include "RyanJsonBaseTest.h"
+
+/* --------------------------------------- jsonTest ------------------------------------------- */
+// !(fabs(RyanJsonGetDoubleValue(RyanJsonGetObjectToKey(json, "double")) - 16.89) < 1e-6)
+RyanJsonBool_e compare_double(double a, double b)
+{
+	double maxVal = fabs(a) > fabs(b) ? fabs(a) : fabs(b);
+	return (fabs(a - b) <= maxVal * DBL_EPSILON);
+}
+
+void printJsonDebug(RyanJson_t json)
+{
+	char *str = RyanJsonPrint(json, 1024, RyanJsonTrue, NULL);
+	printf("aa %s\r\n", str);
+	RyanJsonFree(str);
+}
+
+RyanJsonBool_e rootNodeCheckTest(RyanJson_t json)
+{
+	if (!RyanJsonIsInt(RyanJsonGetObjectToKey(json, "inter")) || 16 != RyanJsonGetIntValue(RyanJsonGetObjectToKey(json, "inter")))
+	{
+		RyanJsonCheckReturnFalse(NULL);
+	}
+
+	if (!RyanJsonIsDouble(RyanJsonGetObjectToKey(json, "double")) ||
+	    !compare_double(RyanJsonGetDoubleValue(RyanJsonGetObjectToKey(json, "double")), 16.89))
+	{
+		RyanJsonCheckReturnFalse(NULL);
+	}
+
+	if (!RyanJsonIsString(RyanJsonGetObjectToKey(json, "string")) ||
+	    strcmp(RyanJsonGetStringValue(RyanJsonGetObjectToKey(json, "string")), "hello"))
+	{
+		RyanJsonCheckReturnFalse(NULL);
+	}
+
+	if (!RyanJsonIsBool(RyanJsonGetObjectToKey(json, "boolTrue")) ||
+	    RyanJsonGetBoolValue(RyanJsonGetObjectToKey(json, "boolTrue")) != RyanJsonTrue)
+	{
+		RyanJsonCheckReturnFalse(NULL);
+	}
+
+	if (!RyanJsonIsBool(RyanJsonGetObjectToKey(json, "boolFalse")) ||
+	    RyanJsonGetBoolValue(RyanJsonGetObjectToKey(json, "boolFalse")) != RyanJsonFalse)
+	{
+		RyanJsonCheckReturnFalse(NULL);
+	}
+
+	if (!RyanJsonIsNull(RyanJsonGetObjectToKey(json, "null"))) { RyanJsonCheckReturnFalse(NULL); }
+
+	return RyanJsonTrue;
+}
+
+RyanJsonBool_e itemNodeCheckTest(RyanJson_t json)
+{
+	RyanJson_t item = RyanJsonGetObjectToKey(json, "item");
+	if (RyanJsonTrue != rootNodeCheckTest(item)) { RyanJsonCheckReturnFalse(NULL); }
+
+	return RyanJsonTrue;
+}
+
+RyanJsonBool_e arrayNodeCheckTest(RyanJson_t json)
+{
+	RyanJson_t item = NULL;
+
+	// 判断是不是数组类型
+	if (!RyanJsonIsArray(RyanJsonGetObjectToKey(json, "arrayInt"))) { RyanJsonCheckReturnFalse(NULL); }
+
+	if (!RyanJsonIsArray(RyanJsonGetObjectToKey(json, "arrayDouble"))) { RyanJsonCheckReturnFalse(NULL); }
+
+	if (!RyanJsonIsArray(RyanJsonGetObjectToKey(json, "arrayString"))) { RyanJsonCheckReturnFalse(NULL); }
+
+	if (!RyanJsonIsArray(RyanJsonGetObjectToKey(json, "array"))) { RyanJsonCheckReturnFalse(NULL); }
+
+	/**
+	 * @brief 检查弱类型数组
+	 *
+	 */
+	//   array: [16, 16.89, "hello", true, false, null],
+	if (!RyanJsonIsInt(RyanJsonGetObjectByIndex(RyanJsonGetObjectToKey(json, "array"), 0)) ||
+	    16 != RyanJsonGetIntValue(RyanJsonGetObjectByIndex(RyanJsonGetObjectToKey(json, "array"), 0)))
+	{
+		RyanJsonCheckReturnFalse(NULL);
+	}
+
+	if (!RyanJsonIsDouble(RyanJsonGetObjectByIndex(RyanJsonGetObjectToKey(json, "array"), 1)) ||
+	    !compare_double(RyanJsonGetDoubleValue(RyanJsonGetObjectByIndex(RyanJsonGetObjectToKey(json, "array"), 1)), 16.89))
+	{
+		printf("%s:%d 解析失败 %f\r\n", __FILE__, __LINE__,
+		       RyanJsonGetDoubleValue(RyanJsonGetObjectByIndex(RyanJsonGetObjectToKey(json, "array"), 1)));
+		RyanJsonCheckReturnFalse(NULL);
+	}
+
+	if (!RyanJsonIsString(RyanJsonGetObjectByIndex(RyanJsonGetObjectToKey(json, "array"), 2)) ||
+	    0 != strcmp(RyanJsonGetStringValue(RyanJsonGetObjectByIndex(RyanJsonGetObjectToKey(json, "array"), 2)), "hello"))
+	{
+		RyanJsonCheckReturnFalse(NULL);
+	}
+
+	if (!RyanJsonIsBool(RyanJsonGetObjectByIndex(RyanJsonGetObjectToKey(json, "array"), 3)) ||
+	    RyanJsonGetBoolValue(RyanJsonGetObjectByIndex(RyanJsonGetObjectToKey(json, "array"), 3)) != RyanJsonTrue)
+	{
+		RyanJsonCheckReturnFalse(NULL);
+	}
+
+	if (!RyanJsonIsBool(RyanJsonGetObjectByIndex(RyanJsonGetObjectToKey(json, "array"), 4)) ||
+	    RyanJsonGetBoolValue(RyanJsonGetObjectByIndex(RyanJsonGetObjectToKey(json, "array"), 4)) != RyanJsonFalse)
+	{
+		RyanJsonCheckReturnFalse(NULL);
+	}
+
+	if (!RyanJsonIsNull(RyanJsonGetObjectByIndex(RyanJsonGetObjectToKey(json, "array"), 5))) { RyanJsonCheckReturnFalse(NULL); }
+
+	/**
+	 * @brief 检查强类型数组
+	 *
+	 */
+	for (int32_t count = 0; count < RyanJsonGetSize(RyanJsonGetObjectToKey(json, "arrayInt")); count++)
+	{
+		item = RyanJsonGetObjectByIndex(RyanJsonGetObjectToKey(json, "arrayInt"), count);
+		if (!RyanJsonIsInt(item) || 16 != RyanJsonGetIntValue(item)) { RyanJsonCheckReturnFalse(NULL); }
+	}
+
+	for (int32_t count = 0; count < RyanJsonGetSize(RyanJsonGetObjectToKey(json, "arrayDouble")); count++)
+	{
+		item = RyanJsonGetObjectByIndex(RyanJsonGetObjectToKey(json, "arrayDouble"), count);
+		if (!RyanJsonIsDouble(item) || fabs(RyanJsonGetDoubleValue(item) - 16.8) < 0.001) { RyanJsonCheckReturnFalse(NULL); }
+	}
+
+	for (int32_t count = 0; count < RyanJsonGetSize(RyanJsonGetObjectToKey(json, "arrayString")); count++)
+	{
+		item = RyanJsonGetObjectByIndex(RyanJsonGetObjectToKey(json, "arrayString"), count);
+		if (!RyanJsonIsString(item) || strcmp(RyanJsonGetStringValue(item), "hello")) { RyanJsonCheckReturnFalse(NULL); }
+	}
+
+	if (6 != RyanJsonGetSize(RyanJsonGetObjectToKey(json, "array"))) { RyanJsonCheckReturnFalse(NULL); }
+
+	return RyanJsonTrue;
+}
+
+RyanJsonBool_e arrayItemNodeCheckTest(RyanJson_t json)
+{
+	if (!RyanJsonIsArray(RyanJsonGetObjectToKey(json, "arrayItem"))) { RyanJsonCheckReturnFalse(NULL); }
+
+	if (RyanJsonTrue != rootNodeCheckTest(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json, "arrayItem"), 0)))
+	{
+		RyanJsonCheckReturnFalse(NULL);
+	}
+
+	if (RyanJsonTrue != rootNodeCheckTest(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(json, "arrayItem"), 1)))
+	{
+		RyanJsonCheckReturnFalse(NULL);
+	}
+	return RyanJsonTrue;
+}
+
+RyanJsonBool_e RyanJsonBaseTestCheckRoot(RyanJson_t pJson)
+{
+	RyanJsonCheckReturnFalse(RyanJsonTrue == rootNodeCheckTest(pJson));
+
+	RyanJsonCheckReturnFalse(RyanJsonTrue == itemNodeCheckTest(pJson));
+
+	RyanJsonCheckReturnFalse(RyanJsonTrue == arrayNodeCheckTest(pJson));
+
+	RyanJsonCheckReturnFalse(RyanJsonTrue == arrayItemNodeCheckTest(pJson));
+
+	return RyanJsonTrue;
+}

test/fuzzer/RyanJsonFuzzer.c

@@ -0,0 +1,758 @@
+#include "RyanJsonTest.h"
+#include <signal.h>
+
+#define RyanJsonCheckGotoExit(EX)                                                                                                          \
+	RyanJsonCheckCode(EX, {                                                                                                            \
+		result = RyanJsonFalse;                                                                                                    \
+		goto __exit;                                                                                                               \
+	})
+
+RyanJsonBool_e isEnableRandomMemFail = RyanJsonTrue;
+
+static RyanJsonBool_e RyanJsonFuzzerTestByParseAndPrint(RyanJson_t pJson, const char *data, uint32_t size)
+{
+	RyanJsonAssert(NULL == RyanJsonPrint(NULL, 100, RyanJsonFalse, NULL));
+	RyanJsonAssert(NULL == RyanJsonPrintPreallocated(NULL, NULL, 100, RyanJsonFalse, NULL));
+	RyanJsonAssert(NULL == RyanJsonPrintPreallocated(pJson, NULL, 100, RyanJsonFalse, NULL));
+	RyanJsonAssert(NULL == RyanJsonPrintPreallocated(NULL, data, 100, RyanJsonFalse, NULL));
+	RyanJsonAssert(NULL == RyanJsonPrintPreallocated(pJson, data, 0, RyanJsonFalse, NULL));
+
+	uint32_t len = 0;
+	char *jsonStr =
+		RyanJsonPrint(pJson, size % 5 ? 100 : 0, size % 2 ? RyanJsonFalse : RyanJsonTrue, &len); // 以带格式方式将数据打印出来
+	RyanJsonCheckReturnFalse(NULL != jsonStr && len > 0);
+	RyanJsonFree(jsonStr);
+
+	uint32_t bufLen = len * 3;
+	if (bufLen < size * 2) { bufLen = size * 2; }
+	if (bufLen < 4096) { bufLen = 4096; }
+	char *buf = malloc((size_t)bufLen);
+	{
+		uint32_t len2 = 0;
+		char *jsonStr2 = RyanJsonPrintPreallocated(pJson, buf, bufLen, size % 2 ? RyanJsonFalse : RyanJsonTrue, &len2);
+		// printf("len: %d, len2: %d, str: %s\r\n", len, len2, NULL == jsonStr2 ? "NULL" : jsonStr2);
+		RyanJsonCheckCode(NULL != jsonStr2 && len == len2, {
+			free(buf);
+			return RyanJsonFalse;
+		});
+	}
+
+	memcpy(buf, data, (size_t)size);
+	buf[size] = 0;
+	RyanJson_t jsonRoot = RyanJsonParse(buf);
+	RyanJsonCheckCode(NULL != jsonRoot, {
+		free(buf);
+		return RyanJsonFalse;
+	});
+
+    // 测试多次打印结果是否一致
+	{
+		uint32_t len3 = 0;
+		char *jsonStr3 = RyanJsonPrint(jsonRoot, 100, size % 2 ? RyanJsonFalse : RyanJsonTrue, &len3); // 以带格式方式将数据打印出来
+		RyanJsonCheckCode(NULL != jsonStr3 && len == len3, {
+			free(buf);
+			if (jsonStr3) { RyanJsonFree(jsonStr3); }
+			RyanJsonDelete(jsonRoot);
+			return RyanJsonFalse;
+		});
+
+		RyanJsonFree(jsonStr3);
+	}
+
+	{
+		RyanJsonPrintPreallocated(jsonRoot, buf, bufLen / 15, RyanJsonTrue, NULL);
+	}
+
+	free(buf);
+	RyanJsonDelete(jsonRoot);
+	return RyanJsonTrue;
+}
+
+static RyanJsonBool_e RyanJsonFuzzerTestByDup(RyanJson_t pJson)
+{
+	RyanJsonBool_e result = RyanJsonTrue;
+	char *jsonStr = NULL;
+	char *jsonStrDup = NULL;
+	RyanJson_t pJsonDup = NULL;
+
+	// 测试打印和复制功能
+	uint32_t len = 0;
+
+	jsonStr = RyanJsonPrint(pJson, 100, RyanJsonFalse, &len);
+	RyanJsonCheckGotoExit(NULL != jsonStr && len > 0);
+
+	pJsonDup = RyanJsonDuplicate(pJson);
+	RyanJsonCheckGotoExit(NULL != pJsonDup);
+
+	// 测试dup失败情况
+	RyanJsonCheckGotoExit(NULL == RyanJsonDuplicate(NULL));
+
+	// 判断复制json的size是否一致
+	RyanJsonCheckGotoExit(0 == RyanJsonGetSize(NULL));
+	RyanJsonCheckGotoExit(RyanJsonGetSize(pJson) == RyanJsonGetSize(pJsonDup));
+	RyanJsonCompare(pJson, pJsonDup);
+	RyanJsonCompareOnlyKey(pJson, pJsonDup);
+	// assert(RyanJsonTrue == RyanJsonCompare(pJson, pJsonDup)); // 大浮点数判断容易出错
+	// RyanJsonCheckGotoExit(RyanJsonTrue == RyanJsonCompareOnlyKey(pJson, pJsonDup)); // 重复key也会失败
+
+	// 测试compare特殊情况
+	RyanJsonCheckGotoExit(RyanJsonTrue == RyanJsonCompare(pJson, pJson));
+	RyanJsonCheckGotoExit(RyanJsonFalse == RyanJsonCompare(NULL, pJsonDup));
+	RyanJsonCheckGotoExit(RyanJsonFalse == RyanJsonCompare(pJson, NULL));
+	RyanJsonCheckGotoExit(RyanJsonFalse == RyanJsonCompare(NULL, NULL));
+
+	// 测试compareKey特殊情况
+	RyanJsonCheckGotoExit(RyanJsonTrue == RyanJsonCompareOnlyKey(pJson, pJson));
+	RyanJsonCheckGotoExit(RyanJsonFalse == RyanJsonCompareOnlyKey(NULL, pJsonDup));
+	RyanJsonCheckGotoExit(RyanJsonFalse == RyanJsonCompareOnlyKey(pJson, NULL));
+	RyanJsonCheckGotoExit(RyanJsonFalse == RyanJsonCompareOnlyKey(NULL, NULL));
+
+	uint32_t dupLen = 0;
+	jsonStrDup = RyanJsonPrint(pJsonDup, 100, RyanJsonFalse, &dupLen); // 以带格式方式将数据打印出来
+	RyanJsonCheckGotoExit(NULL != jsonStrDup && dupLen > 0);
+
+	RyanJsonCheckCode(len == dupLen && 0 == memcmp(jsonStr, jsonStrDup, (size_t)len), {
+		printf("len:%" PRIu32 ", dupLen:%" PRIu32 "\r\n", len, dupLen);
+		printf("jsonStr:%s, jsonStrDup:%s\r\n", jsonStr, jsonStrDup);
+		RyanJsonCheckGotoExit(0);
+	});
+
+	if (RyanJsonIsArray(pJson) || RyanJsonIsObject(pJson))
+	{
+		// 测试size不相等
+		RyanJsonDelete(RyanJsonDetachByIndex(pJson, 0));
+
+		if (RyanJsonIsArray(pJson) || RyanJsonIsObject(pJson))
+		{
+			// 改变key
+			RyanJson_t item;
+			RyanJsonObjectForEach(pJson, item)
+			{
+				if (RyanJsonIsKey(item))
+				{
+					RyanJsonChangeKey(item, "key12231123");
+					break;
+				}
+			}
+
+			// 改变value
+			RyanJsonObjectForEach(pJson, item)
+			{
+				if (RyanJsonIsBool(item))
+				{
+					RyanJsonChangeBoolValue(item, !RyanJsonGetBoolValue(item));
+					break;
+				}
+			}
+
+			// 改变obj的key
+			RyanJsonObjectForEach(pJson, item)
+			{
+				if (RyanJsonIsKey(item) && RyanJsonIsObject(item))
+				{
+					RyanJsonChangeKey(item, "key12231123");
+					break;
+				}
+			}
+		}
+
+		RyanJsonCompare(pJson, pJsonDup);
+		RyanJsonCompareOnlyKey(pJson, pJsonDup);
+	}
+__exit:
+
+	if (jsonStr)
+	{
+		RyanJsonFree(jsonStr);
+		jsonStr = NULL;
+	}
+	if (pJsonDup)
+	{
+		RyanJsonDelete(pJsonDup);
+		pJsonDup = NULL;
+	}
+	if (jsonStrDup)
+	{
+		RyanJsonFree(jsonStrDup);
+		jsonStrDup = NULL;
+	}
+
+	return result;
+}
+
+static RyanJsonBool_e RyanJsonFuzzerTestByForEachChange(RyanJson_t pJson, uint32_t size)
+{
+	RyanJsonIsNull(pJson);
+
+	if (RyanJsonIsKey(pJson))
+	{
+		char *key = malloc(strlen(RyanJsonGetKey(pJson)) + 1);
+		if (key)
+		{
+			memcpy(key, RyanJsonGetKey(pJson), strlen(RyanJsonGetKey(pJson)));
+			key[strlen(RyanJsonGetKey(pJson))] = 0;
+
+			RyanJsonChangeKey(pJson, "key");
+			RyanJsonChangeKey(pJson, key);
+			free(key);
+		}
+	}
+	if (RyanJsonIsBool(pJson)) { RyanJsonChangeBoolValue(pJson, !RyanJsonGetBoolValue(pJson)); }
+	if (RyanJsonIsNumber(pJson))
+	{
+		if (RyanJsonIsInt(pJson))
+		{
+			int32_t value = RyanJsonGetIntValue(pJson);
+			RyanJsonChangeIntValue(pJson, (int32_t)size);
+			RyanJsonChangeIntValue(pJson, value);
+		}
+		if (RyanJsonIsDouble(pJson))
+		{
+			double value = RyanJsonGetDoubleValue(pJson);
+			RyanJsonChangeDoubleValue(pJson, size * 1.123456789);
+			RyanJsonChangeDoubleValue(pJson, value);
+		}
+	}
+
+	if (RyanJsonIsString(pJson))
+	{
+		char *value = malloc(strlen(RyanJsonGetStringValue(pJson)) + 1);
+		if (value)
+		{
+			memcpy(value, RyanJsonGetStringValue(pJson), strlen(RyanJsonGetStringValue(pJson)));
+			value[strlen(RyanJsonGetStringValue(pJson))] = 0;
+
+			RyanJsonChangeStringValue(pJson, "hello world");
+			RyanJsonChangeStringValue(pJson, value);
+
+			free(value);
+		}
+	}
+
+	if (RyanJsonIsArray(pJson) || RyanJsonIsObject(pJson))
+	{
+		RyanJson_t item;
+		RyanJsonArrayForEach(pJson, item)
+		{ RyanJsonCheckReturnFalse(RyanJsonTrue == RyanJsonFuzzerTestByForEachChange(item, size)); }
+	}
+
+	return RyanJsonTrue;
+}
+
+static RyanJsonBool_e RyanJsonFuzzerTestByForEachGet2(RyanJson_t lastJson, RyanJson_t pJson, uint32_t index, uint32_t size)
+{
+	RyanJsonIsNull(pJson);
+
+	RyanJsonAssert(NULL == RyanJsonGetValue(NULL));
+	RyanJsonAssert(NULL == RyanJsonGetKey(NULL));
+	RyanJsonAssert(NULL == RyanJsonGetStringValue(NULL));
+
+	RyanJsonAssert(NULL == RyanJsonGetObjectByKey(NULL, NULL));
+	RyanJsonAssert(NULL == RyanJsonGetObjectByKey(pJson, NULL));
+	RyanJsonAssert(NULL == RyanJsonGetObjectByKey(NULL, "NULL"));
+	if (!RyanJsonIsObject(pJson)) // pJson类型错误
+	{
+		RyanJsonAssert(NULL == RyanJsonGetObjectByKey(pJson, "NULL"));
+	}
+
+	RyanJsonAssert(NULL == RyanJsonGetObjectByIndex(NULL, 10));
+	if (!RyanJsonIsArray(pJson) && !RyanJsonIsObject(pJson)) // pJson类型错误
+	{
+		RyanJsonAssert(NULL == RyanJsonGetObjectByIndex(pJson, 0));
+	}
+
+	if (RyanJsonIsKey(pJson)) { RyanJsonGetObjectToKey(lastJson, RyanJsonGetKey(pJson)); }
+	else
+	{
+		RyanJsonGetObjectToIndex(lastJson, index);
+	}
+
+	if (RyanJsonIsArray(pJson) || RyanJsonIsObject(pJson))
+	{
+		RyanJson_t item;
+		RyanJsonObjectForEach(pJson, item) { RyanJsonFuzzerTestByForEachGet2(pJson, item, index, size); }
+	}
+
+	return RyanJsonTrue;
+}
+
+static RyanJsonBool_e RyanJsonFuzzerTestByForEachGet(RyanJson_t pJson, uint32_t size)
+{
+
+	if (RyanJsonIsArray(pJson) || RyanJsonIsObject(pJson))
+	{
+		RyanJson_t item;
+		uint32_t index = 0;
+		RyanJsonObjectForEach(pJson, item)
+		{
+			RyanJsonFuzzerTestByForEachGet2(pJson, item, index, size);
+			index++;
+		}
+	}
+	return RyanJsonTrue;
+}
+
+static RyanJson_t RyanJsonFuzzerCreateRandomNode(RyanJson_t pJson)
+{
+	static int32_t count = 0;
+	static int32_t count2 = 0;
+	count++;
+	char *key = "true";
+	if (count % 10 > 5) { key = NULL; }
+	switch (count % 50)
+	{
+	case 0: return RyanJsonCreateArray();
+	case 1: return RyanJsonCreateObject();
+	case 2:
+		count2++;
+		if (0 == count2 % 10) { return RyanJsonDuplicate(pJson); }
+	case 11:
+	case 12:
+	case 13: return RyanJsonCreateBool(key, RyanJsonTrue);
+	case 20:
+	case 21:
+	case 22: return RyanJsonCreateInt(key, count);
+	case 31:
+	case 32:
+	case 33: return RyanJsonCreateDouble(key, count * 1.123456789);
+
+	default: return RyanJsonCreateString(key, "true");
+	}
+}
+
+static RyanJsonBool_e RyanJsonFuzzerTestByForEachCreate(RyanJson_t pJson, uint32_t size)
+{
+	// RyanJsonInsert的特殊情况
+	RyanJsonCheckReturnFalse(RyanJsonFalse == RyanJsonInsert(NULL, UINT32_MAX, RyanJsonCreateString("key", "string")));
+	RyanJsonCheckReturnFalse(RyanJsonFalse == RyanJsonInsert(pJson, UINT32_MAX, NULL));
+	RyanJsonCheckReturnFalse(RyanJsonFalse == RyanJsonInsert(NULL, 0, NULL));
+
+	RyanJsonAssert(NULL == RyanJsonCreateString(NULL, NULL));
+	RyanJsonAssert(NULL == RyanJsonCreateString("NULL", NULL));
+
+	RyanJsonAssert(RyanJsonFalse == RyanJsonChangeStringValue(NULL, NULL));
+	RyanJsonAssert(RyanJsonFalse == RyanJsonChangeStringValue(pJson, NULL));
+	RyanJsonAssert(RyanJsonFalse == RyanJsonChangeStringValue(NULL, "NULL"));
+	if (!RyanJsonIsKey(pJson) && !RyanJsonIsString(pJson)) // pJson类型错误
+	{
+		RyanJsonAssert(RyanJsonFalse == RyanJsonChangeStringValue(pJson, "NULL"));
+	}
+
+	RyanJsonAssert(RyanJsonFalse == RyanJsonChangeKey(NULL, NULL));
+	RyanJsonAssert(RyanJsonFalse == RyanJsonChangeKey(pJson, NULL));
+	RyanJsonAssert(RyanJsonFalse == RyanJsonChangeKey(NULL, "NULL"));
+	if (!RyanJsonIsKey(pJson) && !RyanJsonIsString(pJson)) // pJson类型错误
+	{
+		RyanJsonAssert(RyanJsonFalse == RyanJsonChangeKey(pJson, "NULL"));
+	}
+
+	RyanJsonAssert(RyanJsonFalse == RyanJsonAddItemToObject(NULL, NULL, NULL));
+	RyanJsonAssert(RyanJsonFalse == RyanJsonAddItemToObject(pJson, NULL, NULL));
+
+	RyanJsonAssert(NULL == RyanJsonCreateIntArray(NULL, 0));
+	RyanJsonAssert(NULL == RyanJsonCreateDoubleArray(NULL, 0));
+	RyanJsonAssert(NULL == RyanJsonCreateStringArray(NULL, 0));
+
+	RyanJsonAssert(RyanJsonFalse == RyanJsonHasObjectToKey(NULL, "0", "1", "2", "3"));
+	RyanJsonAssert(RyanJsonFalse == RyanJsonHasObjectToIndex(NULL, 0, 1, 2, 3));
+	RyanJsonAssert(RyanJsonFalse == RyanJsonHasObjectToKey(pJson, "0", "1", "2", "3"));
+	RyanJsonAssert(RyanJsonFalse == RyanJsonHasObjectToIndex(pJson, 0, 1, 2, 3));
+
+	char *key = "keyaaa";
+	RyanJsonAddNullToObject(pJson, key);
+	if (RyanJsonIsKey(pJson)) { key = RyanJsonGetKey(pJson); }
+	if (RyanJsonIsBool(pJson)) { RyanJsonAddBoolToObject(pJson, key, RyanJsonGetBoolValue(pJson)); }
+	if (RyanJsonIsNumber(pJson))
+	{
+		if (RyanJsonIsInt(pJson))
+		{
+			RyanJsonAddIntToObject(pJson, key, RyanJsonGetIntValue(pJson));
+			int arrayInt[] = {RyanJsonGetIntValue(pJson), RyanJsonGetIntValue(pJson), RyanJsonGetIntValue(pJson),
+					  RyanJsonGetIntValue(pJson), RyanJsonGetIntValue(pJson)};
+			RyanJsonAddItemToObject(pJson, (size % 2) ? key : "arrayString",
+						RyanJsonCreateIntArray(arrayInt, sizeof(arrayInt) / sizeof(arrayInt[0])));
+		}
+		if (RyanJsonIsDouble(pJson))
+		{
+			RyanJsonAddDoubleToObject(pJson, key, RyanJsonGetDoubleValue(pJson));
+			double arrayDouble[] = {RyanJsonGetDoubleValue(pJson), RyanJsonGetDoubleValue(pJson), RyanJsonGetDoubleValue(pJson),
+						RyanJsonGetDoubleValue(pJson), RyanJsonGetDoubleValue(pJson)};
+			RyanJsonAddItemToObject(pJson, (size % 2) ? key : "arrayString",
+						RyanJsonCreateDoubleArray(arrayDouble, sizeof(arrayDouble) / sizeof(arrayDouble[0])));
+		}
+	}
+
+	if (RyanJsonIsString(pJson))
+	{
+		RyanJsonAddStringToObject(pJson, key, RyanJsonGetStringValue(pJson));
+		const char *arrayString[] = {RyanJsonGetStringValue(pJson), RyanJsonGetStringValue(pJson), RyanJsonGetStringValue(pJson),
+					     RyanJsonGetStringValue(pJson), RyanJsonGetStringValue(pJson)};
+		RyanJsonAddItemToObject(pJson, (size % 2) ? key : "arrayString",
+					RyanJsonCreateStringArray(arrayString, sizeof(arrayString) / sizeof(arrayString[0])));
+	}
+
+	if (RyanJsonIsArray(pJson) || RyanJsonIsObject(pJson))
+	{
+		RyanJson_t item;
+
+		RyanJsonObjectForEach(pJson, item) { RyanJsonFuzzerTestByForEachCreate(item, size); }
+
+		RyanJson_t pJson2 = RyanJsonFuzzerCreateRandomNode(pJson);
+		RyanJsonAddItemToObject(pJson, key, pJson2);
+
+		if (RyanJsonIsArray(pJson))
+		{
+			RyanJsonAddNullToArray(pJson);
+			RyanJsonAddBoolToArray(pJson, size % 2 ? RyanJsonTrue : RyanJsonFalse);
+			RyanJsonAddItemToArray(pJson, RyanJsonFuzzerCreateRandomNode(RyanJsonGetArrayValue(pJson)));
+		}
+	}
+
+	return RyanJsonTrue;
+}
+
+/**
+ * @brief 测试 Json 的 Replace 功能（保护根节点）
+ *
+ * @param pJson 待测试的 Json 节点
+ * @param size  用于计算 index 的模数
+ * @param isFirst 是否为第一次调用（根节点）
+ * @return RyanJsonBool_e
+ */
+static RyanJsonBool_e RyanJsonFuzzerTestByForEachReplace(RyanJson_t pJson, uint32_t size)
+{
+	{
+		isEnableRandomMemFail = RyanJsonFalse;
+		RyanJson_t strItem = RyanJsonCreateString("", "NULL");
+		RyanJsonAssert(RyanJsonFalse == RyanJsonReplaceByKey(NULL, NULL, NULL));
+		RyanJsonAssert(RyanJsonFalse == RyanJsonReplaceByKey(pJson, NULL, NULL));
+		RyanJsonAssert(RyanJsonFalse == RyanJsonReplaceByKey(NULL, "NULL", NULL));
+		RyanJsonAssert(RyanJsonFalse == RyanJsonReplaceByKey(NULL, NULL, strItem));
+		RyanJsonAssert(RyanJsonFalse == RyanJsonReplaceByKey(pJson, "NULL", NULL));
+		RyanJsonAssert(RyanJsonFalse == RyanJsonReplaceByKey(NULL, "NULL", strItem));
+		if (!RyanJsonIsObject(pJson)) // pJson类型错误
+		{
+			RyanJsonAssert(RyanJsonFalse == RyanJsonReplaceByKey(pJson, "NULL", strItem));
+		}
+
+		RyanJsonAssert(RyanJsonFalse == RyanJsonReplaceByIndex(NULL, 0, NULL));
+		RyanJsonAssert(RyanJsonFalse == RyanJsonReplaceByIndex(pJson, 0, NULL));
+		RyanJsonAssert(RyanJsonFalse == RyanJsonReplaceByIndex(NULL, 0, strItem));
+		RyanJsonAssert(RyanJsonFalse == RyanJsonReplaceByIndex(pJson, 0, NULL));
+		RyanJsonAssert(RyanJsonFalse == RyanJsonReplaceByIndex(NULL, 0, strItem));
+		if (!RyanJsonIsArray(pJson) && !RyanJsonIsObject(pJson)) // pJson类型错误
+		{
+			RyanJsonAssert(RyanJsonFalse == RyanJsonReplaceByIndex(pJson, 0, strItem));
+		}
+
+		RyanJson_t objItem = RyanJsonCreateObject();
+		RyanJsonAssert(RyanJsonFalse == RyanJsonReplaceByKey(objItem, "NULL", strItem));
+		RyanJsonAssert(RyanJsonFalse == RyanJsonReplaceByIndex(objItem, 0, strItem));
+
+		RyanJsonAddItemToObject(objItem, "item", RyanJsonCreateObject());
+		RyanJsonAssert(RyanJsonFalse == RyanJsonReplaceByKey(objItem, "NULL222", strItem));
+		RyanJsonAssert(RyanJsonFalse == RyanJsonReplaceByIndex(objItem, INT32_MAX, strItem));
+		isEnableRandomMemFail = RyanJsonTrue;
+
+		RyanJsonDelete(objItem);
+		RyanJsonDelete(strItem);
+	}
+
+	// 只处理数组或对象
+	if (!(RyanJsonIsArray(pJson) || RyanJsonIsObject(pJson))) { return RyanJsonTrue; }
+
+	// 递归替换子节点
+	RyanJson_t item = NULL;
+	RyanJson_t LastItem = NULL;
+	RyanJsonObjectForEach(pJson, item)
+	{
+		if (RyanJsonTrue != RyanJsonFuzzerTestByForEachReplace(item, size)) { return RyanJsonFalse; }
+		LastItem = item;
+	}
+
+	// 只有非根节点才做替换
+
+	// 按 key 替换（仅对象）
+	// 不要动第一个节点
+	if (RyanJsonIsObject(pJson))
+	{
+		if (LastItem && RyanJsonIsKey(LastItem))
+		{
+			RyanJson_t newNode = RyanJsonFuzzerCreateRandomNode(pJson);
+			if (RyanJsonFalse == RyanJsonReplaceByKey(pJson, RyanJsonGetKey(LastItem), newNode))
+			{
+				if (newNode) { RyanJsonDelete(newNode); }
+				return RyanJsonFalse;
+			}
+		}
+	}
+
+	// 按 index 替换
+	{
+		uint32_t idx = RyanJsonGetSize(pJson) % size;
+		RyanJson_t newNode = RyanJsonFuzzerCreateRandomNode(pJson);
+		if (RyanJsonFalse == RyanJsonReplaceByIndex(pJson, (size % 25) ? idx : 0, newNode))
+		{
+			if (newNode) { RyanJsonDelete(newNode); }
+			return RyanJsonFalse;
+		}
+	}
+
+	return RyanJsonTrue;
+}
+
+/**
+ * @brief 测试 Json 的 Detach 分离功能（保护根节点）
+ *
+ * @param pJson 待测试的 Json 节点
+ * @param size  用于计算 index 的模数
+ * @param isFirst 是否为第一次调用（根节点）
+ * @return RyanJsonBool_e
+ */
+static RyanJsonBool_e RyanJsonFuzzerTestByForEachDetach(RyanJson_t pJson, uint32_t size)
+{
+	RyanJsonAssert(RyanJsonFalse == RyanJsonDetachByKey(NULL, NULL));
+	RyanJsonAssert(RyanJsonFalse == RyanJsonDetachByKey(pJson, NULL));
+	RyanJsonAssert(RyanJsonFalse == RyanJsonDetachByKey(NULL, "NULL"));
+	if (!RyanJsonIsObject(pJson)) // pJson类型错误
+	{
+		RyanJsonAssert(NULL == RyanJsonDetachByKey(pJson, "NULL"));
+	}
+
+	RyanJsonAssert(NULL == RyanJsonDetachByIndex(NULL, 10));
+	if (!RyanJsonIsArray(pJson) && !RyanJsonIsObject(pJson)) // pJson类型错误
+	{
+		RyanJsonAssert(NULL == RyanJsonDetachByIndex(pJson, 0));
+	}
+
+	if (!(RyanJsonIsArray(pJson) || RyanJsonIsObject(pJson))) { return RyanJsonTrue; }
+
+	// 递归遍历子节点
+	RyanJson_t item = NULL;
+	RyanJson_t LastItem = NULL;
+	RyanJsonObjectForEach(pJson, item)
+	{
+		RyanJsonFuzzerTestByForEachDetach(item, size);
+		LastItem = item;
+	}
+
+	// 只有非根节点才做 detach
+
+	// 按 key 分离（仅对象）
+	if (RyanJsonIsObject(pJson))
+	{
+		if (LastItem && RyanJsonIsKey(LastItem))
+		{
+			RyanJson_t detached = RyanJsonDetachByKey(pJson, RyanJsonGetKey(LastItem));
+			if (detached) { RyanJsonDelete(detached); }
+
+			// RyanJsonAssert(RyanJsonFalse == RyanJsonDetachByKey(pJson, RyanJsonGetKey(LastItem)));
+		}
+	}
+
+	// 按 index 分离
+	{
+		uint32_t idx = RyanJsonGetSize(pJson) % size;
+		RyanJson_t detached = RyanJsonDetachByIndex(pJson, (size % 25) ? idx : 0);
+		if (detached) { RyanJsonDelete(detached); }
+	}
+
+	return RyanJsonTrue;
+}
+
+/**
+ * @brief 测试 Json 的 Delete 功能（保护根节点）
+ *
+ * @param pJson 待测试的 Json 节点
+ * @param size  用于计算 index 的模数
+ * @param isFirst 是否为第一次调用（根节点）
+ * @return RyanJsonBool_e
+ */
+static RyanJsonBool_e RyanJsonFuzzerTestByForEachDelete(RyanJson_t pJson, uint32_t size)
+{
+	if (!(RyanJsonIsArray(pJson) || RyanJsonIsObject(pJson))) { return RyanJsonTrue; }
+
+	// -------- 测试错误的 delete 调用 --------
+	// Key 删除错误用例
+	RyanJsonDeleteByKey(pJson, "non_exist_key");
+	RyanJsonDeleteByKey(NULL, "some_key");
+	RyanJsonDeleteByKey(pJson, NULL);
+	RyanJsonDeleteByKey(NULL, NULL);
+
+	// Index 删除错误用例
+	RyanJsonDeleteByIndex(pJson, RyanJsonGetSize(pJson)); // 越界
+	RyanJsonDeleteByIndex(NULL, (RyanJsonGetSize(pJson) % size));
+	RyanJsonDeleteByIndex(pJson, -size); // 负数
+	RyanJsonDeleteByIndex(NULL, -size);
+
+	// 递归遍历子节点
+	RyanJson_t item = NULL;
+	RyanJson_t LastItem = NULL;
+	RyanJsonObjectForEach(pJson, item)
+	{
+		RyanJsonFuzzerTestByForEachDelete(item, size);
+		LastItem = item;
+	}
+
+	// -------- 正常删除逻辑（保护根节点） --------
+
+	// 按 key 删除（仅对象）
+	if (RyanJsonIsObject(pJson))
+	{
+		if (LastItem && RyanJsonIsKey(LastItem))
+		{
+
+			// printf("key is %d %s\r\n", RyanJsonGetType(LastItem),
+			//        RyanJsonGetKey(LastItem) == NULL ? "NULL" : RyanJsonGetKey(LastItem));
+			RyanJsonDeleteByKey(pJson, RyanJsonGetKey(LastItem));
+		}
+	}
+
+	// 按 index 删除
+	uint32_t idx = RyanJsonGetSize(pJson) % size;
+	RyanJsonDeleteByIndex(pJson, (size % 25) ? idx : 0);
+
+	return RyanJsonTrue;
+}
+
+static RyanJsonBool_e RyanJsonFuzzerTestByMinify(const char *data, uint32_t size)
+{
+	char *buf = malloc(size + 100);
+	memcpy(buf, data, size);
+	memset(buf + size, 0, 100);
+
+	uint32_t size2 = RyanJsonMinify(buf, (int32_t)size);
+	// 非法情况
+	{
+		RyanJsonCheckReturnFalse(0 == RyanJsonMinify(NULL, 0));
+		RyanJsonCheckReturnFalse(0 == RyanJsonMinify(NULL, 10));
+		RyanJsonCheckReturnFalse(0 == RyanJsonMinify(NULL, -10));
+		RyanJsonCheckReturnFalse(0 == RyanJsonMinify(buf, -10));
+	}
+
+	// 内存泄漏就是上面出错了
+	RyanJson_t pJson2 = RyanJsonParseOptions(buf, size2, size % 2 ? RyanJsonTrue : RyanJsonFalse, NULL);
+	free(buf);
+	if (NULL != pJson2)
+	{
+		uint32_t len = 0;
+		char *jsonStr = RyanJsonPrint(pJson2, 100, RyanJsonFalse, &len); // 以带格式方式将数据打印出来
+		RyanJsonCheckCode(NULL != jsonStr && len > 0, {
+			RyanJsonDelete(pJson2);
+			return RyanJsonFalse;
+		});
+		RyanJsonFree(jsonStr);
+		RyanJsonDelete(pJson2);
+	}
+	else
+	{
+		return RyanJsonFalse;
+	}
+
+	return RyanJsonTrue;
+}
+
+static void *RyanJsonFuzzerMalloc(size_t size)
+{
+	static int32_t count = 0;
+	count++;
+	if (RyanJsonTrue == isEnableRandomMemFail)
+	{
+		if (0 == count % 598) { return NULL; }
+	}
+	return (char *)v_malloc(size);
+}
+
+static void RyanJsonFuzzerFree(void *block) { v_free(block); }
+
+static void *RyanJsonFuzzerRealloc(void *block, size_t size)
+{
+	static int32_t count = 0;
+	count++;
+	if (RyanJsonTrue == isEnableRandomMemFail)
+	{
+		if (0 == count % 508) { return NULL; }
+	}
+	return (char *)v_realloc(block, size);
+}
+
+int LLVMFuzzerTestOneInput(const char *data, uint32_t size)
+{
+
+	// !检查分支覆盖率的时候要把这个取消掉,否则不知道是这个测试用例还是Fuzzer触发的，期望的是Fuzzer触发
+	{
+		// // 执行基础测试
+		// static bool isFirst = true;
+		// if (true == isFirst)
+		// {
+		// 	RyanJsonBool_e result = RyanJsonBaseTest();
+		// 	if (RyanJsonTrue != result)
+		// 	{
+		// 		printf("%s:%d RyanJsonTest fail\r\n", __FILE__, __LINE__);
+		// 		return -1;
+		// 	}
+
+		// 	RFC8259JsonTest();
+		// 	isFirst = false;
+		// }
+	}
+
+	// for (int i = 0; i < size; i++) { printf("%c", size, data[i]); }
+	// printf("\r\n");
+
+	RyanJsonInitHooks(NULL, RyanJsonFuzzerFree, RyanJsonFuzzerRealloc);
+	RyanJsonInitHooks(RyanJsonFuzzerMalloc, NULL, RyanJsonFuzzerRealloc);
+	RyanJsonInitHooks(RyanJsonFuzzerMalloc, RyanJsonFuzzerFree, NULL);
+	RyanJsonInitHooks(NULL, NULL, NULL);
+
+	RyanJsonInitHooks(RyanJsonFuzzerMalloc, RyanJsonFuzzerFree, size % 2 ? NULL : RyanJsonFuzzerRealloc);
+
+	RyanJsonAssert(NULL == RyanJsonParseOptions(NULL, 100, RyanJsonFalse, NULL));
+	RyanJsonAssert(NULL == RyanJsonParseOptions(data, 0, RyanJsonFalse, NULL));
+
+	const char *parseEndPtr = NULL;
+	RyanJson_t pJson = RyanJsonParseOptions(data, size, size % 3 ? RyanJsonTrue : RyanJsonFalse, &parseEndPtr);
+	if (NULL != pJson)
+	{
+		assert(NULL != parseEndPtr && parseEndPtr - data <= size);
+
+		{
+			isEnableRandomMemFail = RyanJsonFalse;
+			RyanJson_t pJson2 = RyanJsonDuplicate(pJson);
+			isEnableRandomMemFail = RyanJsonTrue;
+			RyanJsonCheckCode(RyanJsonFuzzerTestByForEachDelete(pJson2, size), {
+				RyanJsonDelete(pJson2);
+				goto __exit;
+			});
+			RyanJsonDelete(pJson2);
+		}
+
+		{
+			isEnableRandomMemFail = RyanJsonFalse;
+			RyanJson_t pJson2 = RyanJsonDuplicate(pJson);
+			isEnableRandomMemFail = RyanJsonTrue;
+			RyanJsonCheckCode(RyanJsonFuzzerTestByForEachDetach(pJson2, size), {
+				RyanJsonDelete(pJson2);
+				goto __exit;
+			});
+			RyanJsonDelete(pJson2);
+		}
+
+		RyanJsonFuzzerTestByMinify(data, size);
+		RyanJsonFuzzerTestByParseAndPrint(pJson, data, size);
+		RyanJsonFuzzerTestByForEachGet(pJson, size);
+
+		RyanJsonFuzzerTestByDup(pJson);
+		RyanJsonCheckCode(RyanJsonFuzzerTestByForEachChange(pJson, size), { goto __exit; });
+		RyanJsonCheckCode(RyanJsonFuzzerTestByForEachCreate(pJson, size), { goto __exit; });
+		RyanJsonCheckCode(RyanJsonFuzzerTestByForEachReplace(pJson, size), { goto __exit; });
+
+		RyanJsonDelete(pJson);
+	}
+
+	return 0;
+
+__exit:
+	RyanJsonDelete(pJson);
+	return 0;
+}

test/fuzzer/RyanJsonFuzzer.dict

@@ -0,0 +1,253 @@
+# 基本关键字
+"true"
+"false"
+"null"
+
+# 对象结构
+"{"
+"}"
+":"
+","
+
+# 数组结构
+"["
+"]"
+
+# 常见字符串模式
+"\"key\""
+"\"value\""
+"\"name\""
+"\"id\""
+"\"string\""
+"\"number\""
+"\"message\""
+"\"data\""
+"\"status\""
+"\"error\""
+"""
+"\\"
+
+# 数字边界
+"0"
+"1"
+"-1"
+"1234567890"
+"3.14159"
+"1e10"
+"-1e-10"
+"999999999999999999999999999"
+"-999999999999999999999999999"
+"-"
+"000-000"
+"-0045.12348"
+"0123"
+"0123.123"
+
+# 嵌套结构
+"{\"a\":1}"
+"[1,2,3]"
+"{\"obj\":{\"nested\":true}}"
+"{\"arr\":[{\"x\":1},{\"y\":2}]}"
+"{\"deep\":{\"nest\":{\"more\":{\"inner\":{\"flag\":true}}}}}"
+"[{\"id\":1,\"val\":true},{\"id\":2,\"val\":false}]"
+
+# 复杂对象
+"{\"inter\":16,\"double\":16.89,\"string\":\"hello\",\"boolTrue\":true,\"boolFalse\":false,\"null\":null}"
+"{\"items\":[{\"id\":1},{\"id\":2},{\"id\":3}]}"
+"{\"user\":{\"id\":123,\"name\":\"Alice\",\"roles\":[\"admin\",\"editor\"]}}"
+"{\"response\":{\"status\":200,\"data\":[{\"id\":1},{\"id\":2}]}}"
+
+# 边界结构
+# 键未加引号
+"{a:1}"
+
+# 缺少冒号
+"{\"a\" 1}"
+
+# 缺少逗号
+"{\"a\":1 \"b\":2}"
+
+# 多余逗号
+"{\"a\":1,}"
+
+# 数组尾逗号
+"[1,2,3,]"
+
+# 空对象错误
+"{,}"
+
+# 空数组错误
+"[,]"
+
+# 未闭合字符串
+"{\"a\":\"value}"
+
+# 单引号字符串
+"{\"a\":'value'}"
+
+# 非法转义
+"{\"a\":\"\\q\"}"
+
+# 非法 Unicode 转义
+"{\"a\":\"\\uZZZZ\"}"
+
+# 位数不足
+"{\"a\":\"\\u12\"}"
+
+# 控制字符
+"{\"a\":\"\\x07\"}"
+
+# 小数点后无数字
+"1."
+
+# 科学计数法错误
+"1e"
+
+# 科学计数法错误
+"1e+"
+
+# 超大指数
+"1e9999"
+
+# 拼写错误
+"True"
+"False"
+"Null"
+"tru"
+"nul"
+
+# 顶层错误
+"string"
+"123"
+"true"
+"null"
+
+# 注释错误：单行
+"// comment"
+"/* block comment */"
+
+# 非 UTF-8 字节流
+"\xC0\xAF"
+"\xFF\xFF"
+"\xFE\xFF"
+
+# 空结构
+"{}"
+"[]"
+
+# 特殊转义
+"\\n"
+"\\r"
+"\\t"
+"\\b"
+"\\f"
+"\\u0000"
+"\\uD800\\uDC00"
+"\\uDBFF\\uDFFF"
+"\\\""
+"\\\\"
+"/"
+
+# 一维对象，覆盖所有 JSON 类型
+"{\"string\":\"hello\",\"number\":123,\"boolean_true\":true,\"boolean_false\":false,\"null_value\":null,\"array\":[1,\"two\",false,null],\"object\":{\"nested_key\":\"nested_value\"}}"
+
+# 错误重复结构
+"[{\"error\":4,\"error\":\"45\"}]"
+"[{\"id\":1,\"id\":2}]"
+"[{\"name\":\"Alice\",\"name\":\"Bob\"}]"
+"[{\"value\":true,\"value\":false}]"
+"[{\"unicode\":\"\\u4F60\\u597D\",\"unicode\":\"\\u4E16\\u754C\"}]"
+"[{\"data\":[1,2,3],\"data\":{\"x\":1}}]"
+"[{\"nested\":{\"a\":1},\"nested\":{\"a\":2}}]"
+"[{\"error\":null,\"error\":999}]"
+"[{\"flag\":false,\"flag\":true}]"
+"[{\"number\":123,\"number\":\"123\"}]"
+"[{\"list\":[1,2],\"list\":[3,4]}]"
+
+# Unicode 示例（转义形式）
+"{\"unicode\":\"\\u4F60\\u597D\"}"
+"{\"unicode\":\"\\u4E16\\u754C\"}"
+"{\"unicode\":\"\\uD83C\\uDF0D\"}"
+"{\"unicode\":\"\\uD83D\\uDE00\"}"
+# 孤立高代理
+"{\"unicode\":\"\\uD800\"}" 
+# 孤立低代理         
+"{\"unicode\":\"\\uDFFF\"}"  
+# 超出最大码点        
+"{\"unicode\":\"\\u110000\"}" 
+ # 非十六进制       
+"{\"unicode\":\"\\uZZZZ\"}"    
+# 位数不足     
+"{\"unicode\":\"\\u12\"}"     
+# 错误代理配对       
+"{\"unicode\":\"\\uD800\\u0041\"}"   
+
+# RESTful 风格常见响应
+"{\"status\":200,\"message\":\"OK\"}"
+"{\"status\":404,\"error\":\"Not Found\"}"
+"{\"status\":500,\"error\":\"Internal Server Error\"}"
+"{\"status\":401,\"error\":\"Unauthorized\"}"
+"{\"status\":403,\"error\":\"Forbidden\"}"
+
+# RESTful 数据响应
+"{\"status\":200,\"data\":{\"id\":1,\"name\":\"Alice\"}}"
+"{\"status\":200,\"data\":[{\"id\":1,\"name\":\"Alice\"},{\"id\":2,\"name\":\"Bob\"}]}"
+"{\"status\":200,\"data\":{\"items\":[{\"id\":1,\"value\":true},{\"id\":2,\"value\":false}]}}"
+
+# RESTful 分页响应
+"{\"status\":200,\"page\":1,\"pageSize\":10,\"total\":100,\"data\":[{\"id\":1},{\"id\":2}]}"
+"{\"status\":200,\"meta\":{\"page\":2,\"limit\":20},\"data\":[{\"id\":21},{\"id\":22}]}"
+
+# RESTful 错误响应
+"{\"error\":{\"code\":1234,\"message\":\"Invalid request\"}}"
+"{\"error\":{\"code\":5678,\"message\":\"Timeout\"}}"
+
+# RESTful 响应
+"{\"status\":200,\"user\":{\"id\":123,\"name\":\"Alice\",\"roles\":[\"admin\",\"editor\"]},\"token\":\"abcdef123456\"}"
+"{\"status\":200,\"config\":{\"theme\":\"dark\",\"language\":\"en\"},\"features\":[\"chat\",\"upload\",\"search\"]}"
+
+# 循环/深度嵌套场景
+"{\"a\":{\"b\":{\"c\":{\"d\":{\"e\":{\"f\":{\"g\":true}}}}}}}"
+"[[[[[[[[[[1]]]]]]]]]]"
+"[{\"a\":[{\"b\":[{\"c\":[{\"d\":true}]}]}]}]"
+"{\"a\":[{\"b\":[{\"c\":[{\"d\":[{\"e\":false}]}]}]}]}"
+"{\"node\":{\"id\":1,\"child\":{\"id\":2,\"child\":{\"id\":3,\"child\":{\"id\":4}}}}}"
+"{\"x\":{\"x\":{\"x\":{\"x\":{\"x\":{\"x\":null}}}}}}"
+"{\"status\":200,\"data\":{\"items\":[{\"id\":1,\"children\":[{\"id\":2,\"children\":[{\"id\":3}]}]}]}}"
+"{\"mixed\":[{\"obj\":{\"arr\":[{\"obj\":{\"arr\":[{\"obj\":{\"arr\":[true]}]}]}]}}]}"
+
+# 极端情况
+"{\"long\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"}"
+"{\"big\":999999999999999999999999999}"
+"[[],[],[],[],[],[],[],[],[],[]]"
+"{\"nestedArray\":[[1,2],[3,4],[5,[6,[7,[8]]]]]}"
+"{\"escape\":\"line1\\nline2\\tTabbed\"}"
+"{\"mixed\":[16,16.89,\"hello\",true,false,null,{\"deep\":{}}]}"
+
+# 非法/边界片段（测试错误处理）
+",{}"
+":[]"
+"[[]]"
+"{{}}"
+",[]"
+":{}"
+"''"
+"\\x00"
+"\\0"
+
+"//"
+"/**/"
+
+"\x01\x00"
+"\x00\x00\x00\x00"
+"\x00\x00\x00\x00\x00\x00\x00\x00"
+"\x00\x00\x00\x00\x00\x00\x00\x01"
+"\x01\x00\x00\x00\x00\x00\x00\x00"
+"\x10\x00\x00\x00\x00\x00\x00\x00"
+
+"\xff\xff"
+"\xfe\xff\xff\xee"
+"\xff\xff\xff\xff"
+"\xfe\xff\xff\xff\xff\xff\xff\xfa"
+"\xfb\xff\xff\xff\xff\xff\xff\xff"
+"\xff\xff\xff\xff\xff\xff\xff\xff"

test/valloc/valloc.c

@@ -5,28 +5,23 @@
 #include <unistd.h>
 #include "valloc.h"
 
-#define HEADER_SIZE sizeof(int)
+#define HEADER_SIZE        sizeof(int)
+#define MALLOC_HEADER_SIZE 12
 
 static int count = 0;
 static int use = 0;
 
 void *v_malloc(size_t size)
 {
-	if (size == 0)
-	{
-		return NULL;
-	}
+	if (size == 0) { return NULL; }
 
 	void *p = malloc(size + HEADER_SIZE);
-	if (!p)
-	{
-		return NULL;
-	}
+	if (!p) { return NULL; }
 
 	*(int *)p = (int)size;
 
 	count++;
-	use += (int)size;
+	use += (int)size + MALLOC_HEADER_SIZE;
 
 	return (char *)p + HEADER_SIZE;
 }
@@ -35,25 +30,19 @@ void *v_calloc(size_t num, size_t size)
 {
 	size_t total = num * size;
 	void *p = v_malloc(total);
-	if (p)
-	{
-		memset(p, 0, total);
-	}
+	if (p) { memset(p, 0, total); }
 	return p;
 }
 
 void v_free(void *block)
 {
-	if (!block)
-	{
-		return;
-	}
+	if (!block) { return; }
 
 	void *p = (char *)block - HEADER_SIZE;
 	int size = *(int *)p;
 
 	count--;
-	use -= size;
+	use -= size + MALLOC_HEADER_SIZE;
 
 	free(p);
 }
@@ -76,17 +65,11 @@ void *v_realloc(void *block, size_t size)
 	}
 
 	void *p = realloc(raw, size + HEADER_SIZE);
-	if (!p)
-	{
-		return NULL;
-	}
+	if (!p) { return NULL; }
 
 	*(int *)p = (int)size;
 
-	if (!block)
-	{
-		count++;
-	}
+	if (!block) { count++; }
 	use += (int)(size - old_size);
 
 	return (char *)p + HEADER_SIZE;
@@ -94,17 +77,25 @@ void *v_realloc(void *block, size_t size)
 
 int v_mcheck(int *dstCount, int *dstUse)
 {
-	if (dstCount)
-	{
-		*dstCount = count;
-	}
-	if (dstUse)
-	{
-		*dstUse = use;
-	}
+	if (dstCount) { *dstCount = count; }
+	if (dstUse) { *dstUse = use; }
 	return 0;
 }
 
+int32_t vallocGetArea(void)
+{
+	int32_t area2 = 0, use2 = 0;
+	v_mcheck(&area2, &use2);
+	return area2;
+}
+
+int32_t vallocGetUse(void)
+{
+	int32_t area2 = 0, use2 = 0;
+	v_mcheck(&area2, &use2);
+	return use2;
+}
+
 void displayMem(void)
 {
 	int32_t area2 = 0, use2 = 0;

test/valloc/valloc.h

@@ -16,6 +16,7 @@ extern "C" {
 #endif
 
 #include <stdlib.h>
+#include <stdint.h>
 
 extern void *v_malloc(size_t size);
 extern void *v_calloc(size_t num, size_t size);
@@ -24,6 +25,8 @@ extern void *v_realloc(void *block, size_t size);
 extern int v_mcheck(int *dstCount, int *dstUse);
 extern void displayMem(void);
 extern void vallocInit(void);
+extern int32_t vallocGetArea(void);
+extern int32_t vallocGetUse(void);
 
 #ifdef __cplusplus
 }

xmake.lua

@@ -2,19 +2,43 @@ add_rules("plugin.compile_commands.autoupdate", {outputdir = ".vscode"})
 target("RyanJson",function()
     set_kind("binary")
 
-    set_toolchains("gcc")  -- 确保使用 GCC
+    -- set_toolchains("gcc")  -- 确保使用 GCC
+    set_toolchains("clang")
+    set_plat("linux")
+    set_arch("x86")
     set_languages("gnu99") -- 关键！启用 GNU 扩展
+    add_defines("isEnableFuzzer")
+    add_cxflags("-fsanitize=fuzzer", "-fprofile-instr-generate", "-fcoverage-mapping", {force = true} )
+    add_ldflags("-fsanitize=fuzzer", "-fprofile-instr-generate", "-fcoverage-mapping", {force = true} )
 
+    set_policy("build.ccache", false)
     -- set_optimize("smallest") -- -Os
-    set_optimize("faster") -- -O2
-    -- set_optimize("fastest") -- -O3
+    -- set_optimize("faster") -- -O2
+    set_optimize("fastest") -- -O3
     -- set_optimize("aggressive") -- -Ofast
 
     -- 启用全部警告
     set_warnings("everything") -- -Wall -Wextra -Weffc++ / -Weverything
 
     -- 链接器选项：生成 map 文件
-    add_ldflags("-Wl,-Map=$(buildir)/RyanJson.map")
+    -- add_ldflags("-Wl,-Map=$(buildir)/RyanJson.map")
+
+    -- 开启库加固（需与 -O2 以上配合）
+    -- add_defines("_FORTIFY_SOURCE=2")   -- glibc 格式/内存函数加固
+
+    -- 链接器安全硬化与优化
+    add_ldflags(
+        "-flto",                    -- 链接时优化（启用 LTO，便于 CFI 等）
+        "-fPIE",                    -- 位置无关可执行
+        "-pie",                     -- 与 -fPIE 搭配，启用 ASLR
+        "-fno-omit-frame-pointer",  -- 保留帧指针，便于崩溃分析
+        "-fstack-clash-protection", -- 栈碰撞保护（平台支持时有效）
+        "-Wl,-z,relro",             -- 只读重定位（硬化）
+        "-Wl,-z,now",               -- 立即绑定（与 relro 搭配）
+        "-Wl,-z,noexecstack",       -- 栈不可执行
+        "-Wl,-z,separate-code",     -- 代码与数据段分离
+        {force = true}
+    )
 
     -- Sanitizer 检测项（运行时错误）
     add_ldflags(
@@ -26,55 +50,69 @@ target("RyanJson",function()
         "-fsanitize=bounds", -- 数组越界
         "-fsanitize=float-divide-by-zero", -- 浮点除零
         "-fsanitize=float-cast-overflow", -- 浮点转整数溢出
+        -- "-fsanitize=thread",      -- 多线程数据竞争
+        -- "-fsanitize=memory",      -- 未初始化内存使用
+        -- "-fsanitize=safe-stack",  -- 栈分离机制
+        -- "-fsanitize=cfi",         -- 控制流完整性（需 LTO 与 Clang）
         -- "-fsanitize=alignment", -- 检测未对齐的内存访问
-        "-fno-sanitize=alignment", -- 某些平台不兼容
+        -- "-fno-sanitize=alignment", -- 某些平台不兼容
         {force = true}
     )
 
-    -- 编译器警告与静态分析（开发期错误检测）
+    -- 编译器警告与静态分析（开发期错误检测，Clang 兼容）
     add_cxflags(
-        -- "-flto", -- 链接时优化（可选）
-        "-pedantic", -- 强制遵循 ISO C/C++ 标准
-        "-Wall", -- 启用大多数常见警告
-        "-Wextra", -- 启用额外警告
-        "-fanalyzer", -- 启用 gcc 静态分析器
-        "-Wno-unused-parameter",
-        "-Wfloat-equal", -- 浮点直接比较
-        "-Wshadow", -- 局部变量遮蔽
-        "-Wcast-align", -- 类型转换对齐问题
-        "-Wpointer-arith", -- 指针运算
-        "-Warray-bounds=2", -- 数组越界访问（编译期可分析到的）
-        "-Wstringop-overflow=2", -- memcpy / strcpy 等可能的溢出
-        "-Wstringop-truncation", -- 字符串截断风险
-        "-Walloc-zero", -- malloc(0) 等分配 0 字节的情况
-        "-Wfree-nonheap-object", -- 释放非堆对象
-        -- "-Wconversion", -- 隐式类型转换可能导致精度丢失/溢出
-        "-Wnull-dereference", -- 空指针解引用
-        "-Wlogical-op", -- 逻辑运算符误用
-        "-Wstrict-overflow=5", -- 有符号溢出优化假设
-        "-Wmissing-prototypes", -- 未在头文件声明的全局函数
-        "-Wmissing-declarations", -- 未声明的全局变量/函数
-        "-Wredundant-decls", -- 重复声明
-        "-Wunreachable-code", -- 不可达代码
-        "-Wunsafe-loop-optimizations", -- 循环优化可能引入的问题
-        "-Wtype-limits", -- 比较恒真/恒假的表达式（如 unsigned < 0）
-        "-Wshift-overflow=2", -- 移位导致的溢出
-        "-Wshift-negative-value", -- 对负数进行移位
-        "-Wdiv-by-zero", -- 除以零（编译期可分析到的）
-        "-Wformat-security", -- 格式化字符串安全问题
+        "-g3",                     -- 生成调试信息"
+        "-pedantic",               -- 强制遵循 ISO C 标准
+        "-Wall",                   -- 常见警告
+        "-Wextra",                 -- 额外警告
+        "-Wconversion",            -- 隐式类型转换风险
+        "-Wsign-conversion",       -- 有符号/无符号转换风险
+        "-Wdouble-promotion",      -- float 自动提升为 double
+        "-Wstrict-prototypes",     -- 函数声明必须带参数类型
+        "-Wold-style-definition",  -- 检测旧式函数定义
+        "-Wimplicit-fallthrough",  -- switch/case 未显式 fallthrough
+        "-Wshadow",                -- 局部变量遮蔽
+        "-Wcast-align",            -- 类型转换对齐问题
+        "-Wpointer-arith",         -- 指针运算风险
+        "-Warray-bounds",          -- 数组越界访问
+        "-Wshift-overflow",        -- 位移造成的溢出
+        "-Wformat-truncation",     -- 格式化字符串被截断风险（替代 stringop-truncation）
+        "-Walloc-size",            -- 分配大小问题（替代 alloc-zero）
+        "-Wnull-dereference",      -- 空指针解引用
+        "-Wtautological-compare",  -- 恒真/恒假的比较
+        "-Wstrict-overflow",       -- 有符号溢出优化假设
+        "-Wmissing-prototypes",    -- 全局函数未在头文件声明
+        "-Wmissing-declarations",  -- 全局变量/函数未声明
+        "-Wredundant-decls",       -- 重复声明
+        "-Wunreachable-code",      -- 不可达代码
+        "-Wtype-limits",           -- 比较恒真/恒假的表达式（如 unsigned < 0）
+        "-Wshift-negative-value",  -- 对负数进行移位
+        "-Wdiv-by-zero",           -- 除以零（编译期可分析）
+        "-Wformat-security",       -- 格式化字符串安全问题
         "-Wdisabled-optimization", -- 被禁用的优化
-        -- "-Wwrite-strings", -- 将字符串字面量视为 const char[]，防止被修改
-        "-Wreturn-local-addr", -- 返回局部变量地址
-        "-Wuse-after-free", -- 释放后使用（编译期可分析到的）
-        "-Wdangling-pointer=2", -- 悬空指针（GCC 12+）
-        "-fstack-protector-strong", -- 栈保护
-
-        -- clang 的兼容项（可选）
-        -- "-Wno-gnu-zero-variadic-macro-arguments",
-        -- "-Wno-c23-extensions",
+        "-Wreturn-local-addr",     -- 返回局部变量地址
+        "-Wdeprecated",            -- 使用已弃用的特性
+        -- "-Wunsafe-buffer-usage",   -- 不安全的数组/指针用法（Clang 新增）
+        "-Wuninitialized",         -- 使用未初始化变量
+        "-fstack-protector-strong",-- 栈保护
+        -- 进一步增强（可选，按需开启）
+        "-Wmissing-include-dirs",      -- 头文件目录缺失
+        "-Wcast-qual",                 -- 丢弃 const/volatile 限定符的转换
+        "-Wconditional-uninitialized", -- 条件路径未初始化
+        "-Wcovered-switch-default",    -- default 覆盖所有枚举值
+        "-Wformat-nonliteral",         -- 非字面量格式串
+        "-Wformat-signedness",         -- 格式化与符号性不匹配
+        "-Wvla",                       -- 可变长度数组（不安全/不建议使用）
+        "-fno-common",                 -- 禁止旧式多重定义（链接期更严格）
+        "-fno-strict-aliasing",        -- 禁止严格别名优化，减少别名相关 UB 风险
+        "-Wno-documentation", -- 临时变比
+        "-Wno-parentheses-equality",
         {force = true}
     )
 
+    add_includedirs('./test/fuzzer', {public = true})
+    add_files('./test/fuzzer/*.c', {public = true})
+
     --加入代码和头文件
     add_includedirs('./RyanJson', {public = true})
     add_files('./RyanJson/*.c', {public = true})
@@ -82,13 +120,15 @@ target("RyanJson",function()
     add_includedirs('./example', {public = true})
     add_includedirs('./test', {public = true})
     add_includedirs('./test/valloc', {public = true})
+    add_includedirs('./test/baseTest', {public = true})
     add_includedirs('./externalModule/cJSON', {public = true})
     add_includedirs('./externalModule/yyjson', {public = true})
 
     add_files('./example/*.c', {public = true})
-    add_files('./test/*.c', {public = true})
-    add_files('./test/valloc/*.c', {public = true})
-    add_files('./externalModule/cJSON/*.c', {public = true})
-    add_files('./externalModule/yyjson/*.c', {public = true})
+    add_files('./test/*.c', {public = true}, {cxflags = "-w"})
+    add_files('./test/valloc/*.c', {public = true}, {cxflags = "-w"})
+    add_files('./test/baseTest/*.c', {public = true}, {cxflags = "-w"})
+    add_files('./externalModule/cJSON/*.c', {public = true}, {cxflags = "-w"})
+    add_files('./externalModule/yyjson/*.c', {public = true}, {cxflags = "-w"})
 
 end)