RyanJson/test/unityTest/cases/core/testChange.c

#include "testBase.h"

static void testChangeEdgeCases(void)
{
	// 测试 NULL 输入处理
	TEST_ASSERT_FALSE_MESSAGE(RyanJsonChangeBoolValue(NULL, true), "ChangeBoolValue(NULL) 应返回 False");
	TEST_ASSERT_FALSE_MESSAGE(RyanJsonChangeIntValue(NULL, 1), "ChangeIntValue(NULL) 应返回 False");
	TEST_ASSERT_FALSE_MESSAGE(RyanJsonChangeDoubleValue(NULL, 1.0), "ChangeDoubleValue(NULL) 应返回 False");
	TEST_ASSERT_FALSE_MESSAGE(RyanJsonChangeStringValue(NULL, "test"), "ChangeStringValue(NULL) 应返回 False");
	TEST_ASSERT_FALSE_MESSAGE(RyanJsonChangeKey(NULL, "key"), "ChangeKey(NULL) 应返回 False");

	// 测试类型不匹配处理
	RyanJson_t intNode = RyanJsonCreateInt(NULL, 1);
	RyanJson_t doubleNode = RyanJsonCreateDouble(NULL, 1.0);
	RyanJson_t boolNode = RyanJsonCreateBool(NULL, RyanJsonTrue);
	RyanJson_t strNode = RyanJsonCreateString(NULL, "s");
	RyanJson_t keyedStrNode = RyanJsonCreateString("k", "v");
	RyanJson_t keyedBoolNode = RyanJsonCreateBool("flag", RyanJsonTrue);
	TEST_ASSERT_NOT_NULL(intNode);
	TEST_ASSERT_NOT_NULL(doubleNode);
	TEST_ASSERT_NOT_NULL(boolNode);
	TEST_ASSERT_NOT_NULL(strNode);
	TEST_ASSERT_NOT_NULL(keyedStrNode);
	TEST_ASSERT_NOT_NULL(keyedBoolNode);

	TEST_ASSERT_FALSE_MESSAGE(RyanJsonChangeIntValue(doubleNode, 3), "ChangeIntValue(非Int节点) 应返回 False");
	TEST_ASSERT_FALSE_MESSAGE(RyanJsonChangeDoubleValue(intNode, 3.14), "ChangeDoubleValue(非Double节点) 应返回 False");
	TEST_ASSERT_FALSE_MESSAGE(RyanJsonChangeBoolValue(intNode, RyanJsonTrue), "ChangeBoolValue(非Bool节点) 应返回 False");
	TEST_ASSERT_FALSE_MESSAGE(RyanJsonChangeStringValue(intNode, "x"), "ChangeStringValue(非String节点) 应返回 False");
	TEST_ASSERT_FALSE_MESSAGE(RyanJsonChangeKey(strNode, "k2"), "ChangeKey(无Key的String节点) 应返回 False");
	TEST_ASSERT_FALSE_MESSAGE(RyanJsonChangeKey(keyedStrNode, NULL), "ChangeKey(key!=NULL 前置条件) 应返回 False");

	// 失败后原值应保持不变
	TEST_ASSERT_TRUE_MESSAGE(RyanJsonGetBoolValue(boolNode), "bool 初始值错误");
	TEST_ASSERT_FALSE_MESSAGE(RyanJsonChangeIntValue(boolNode, 9), "ChangeIntValue(Bool节点) 应返回 False");
	TEST_ASSERT_TRUE_MESSAGE(RyanJsonGetBoolValue(boolNode), "失败后 bool 值不应变化");

	TEST_ASSERT_EQUAL_INT_MESSAGE(1, RyanJsonGetIntValue(intNode), "int 初始值错误");
	TEST_ASSERT_FALSE_MESSAGE(RyanJsonChangeDoubleValue(intNode, 8.8), "ChangeDoubleValue(Int节点) 应返回 False");
	TEST_ASSERT_EQUAL_INT_MESSAGE(1, RyanJsonGetIntValue(intNode), "失败后 int 值不应变化");

	TEST_ASSERT_EQUAL_STRING_MESSAGE("v", RyanJsonGetStringValue(keyedStrNode), "string 初始值错误");
	TEST_ASSERT_FALSE_MESSAGE(RyanJsonChangeBoolValue(keyedStrNode, RyanJsonFalse), "ChangeBoolValue(String节点) 应返回 False");
	TEST_ASSERT_EQUAL_STRING_MESSAGE("v", RyanJsonGetStringValue(keyedStrNode), "失败后 string 值不应变化");
	TEST_ASSERT_EQUAL_STRING_MESSAGE("k", RyanJsonGetKey(keyedStrNode), "失败后 key 不应变化");

	// 有 key 的非字符串节点允许改 key，且值不应改变
	TEST_ASSERT_TRUE_MESSAGE(RyanJsonChangeKey(keyedBoolNode, "flag2"), "ChangeKey(Bool+Key 节点) 应成功");
	TEST_ASSERT_EQUAL_STRING_MESSAGE("flag2", RyanJsonGetKey(keyedBoolNode), "Bool 节点改 key 失败");
	TEST_ASSERT_TRUE_MESSAGE(RyanJsonGetBoolValue(keyedBoolNode), "Bool 节点改 key 后 value 不应变化");

	RyanJsonDelete(intNode);
	RyanJsonDelete(doubleNode);
	RyanJsonDelete(boolNode);
	RyanJsonDelete(strNode);
	RyanJsonDelete(keyedStrNode);
	RyanJsonDelete(keyedBoolNode);
}

static void testChangeValueStress(void)
{
	RyanJson_t root = RyanJsonCreateObject();
	RyanJsonAddStringToObject(root, "k", "v");

	// 高频修改 strValue
	// 变为超长
	char *longStr = (char *)malloc(1000);
	memset(longStr, 'A', 999);
	longStr[999] = '\0';
	TEST_ASSERT_TRUE(RyanJsonChangeStringValue(RyanJsonGetObjectByKey(root, "k"), longStr));
	TEST_ASSERT_EQUAL_STRING(longStr, RyanJsonGetStringValue(RyanJsonGetObjectByKey(root, "k")));

	// 变为特殊字符
	const char *specials = "\t\n\r\b\f\"\\/";
	TEST_ASSERT_TRUE(RyanJsonChangeStringValue(RyanJsonGetObjectByKey(root, "k"), specials));
	TEST_ASSERT_EQUAL_STRING(specials, RyanJsonGetStringValue(RyanJsonGetObjectByKey(root, "k")));

	// 变为空串
	TEST_ASSERT_TRUE(RyanJsonChangeStringValue(RyanJsonGetObjectByKey(root, "k"), ""));
	TEST_ASSERT_EQUAL_STRING("", RyanJsonGetStringValue(RyanJsonGetObjectByKey(root, "k")));

	// 高频修改 key
	// 变为超长
	TEST_ASSERT_TRUE(RyanJsonChangeKey(RyanJsonGetObjectByKey(root, "k"), longStr));
	TEST_ASSERT_TRUE(RyanJsonHasObjectByKey(root, longStr));

	// 变为空 key
	TEST_ASSERT_TRUE(RyanJsonChangeKey(RyanJsonGetObjectByKey(root, longStr), ""));
	TEST_ASSERT_TRUE(RyanJsonHasObjectByKey(root, ""));

	free(longStr);
	RyanJsonDelete(root);
}

static void testChangeScalarAndStorageMode(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\",\"0\":\"1\",\"nameaaaaaaaaaaaaaaaaaaaaaaaaaaaa\":\"Mash\",\"2\":\"3\",\"name\":"
		"\"Mashaaaaaaaaaaaaaaaaaaaaaaaa\"}";

	RyanJson_t jsonRoot = RyanJsonParse(jsonstr);
	TEST_ASSERT_NOT_NULL_MESSAGE(jsonRoot, "解析基础 Json 失败");

	/**
	 * @brief 修改基本类型
	 */
	// 修改整数
	RyanJsonChangeIntValue(RyanJsonGetObjectToKey(jsonRoot, "inter"), 20);
	TEST_ASSERT_TRUE_MESSAGE(RyanJsonIsInt(RyanJsonGetObjectToKey(jsonRoot, "inter")), "字段 'inter' 修改后不是整数");
	TEST_ASSERT_EQUAL_INT_MESSAGE(20, RyanJsonGetIntValue(RyanJsonGetObjectToKey(jsonRoot, "inter")), "字段 'inter' 值不匹配");

	// 修改浮点数
	RyanJsonChangeDoubleValue(RyanJsonGetObjectToKey(jsonRoot, "double"), 20.89);
	TEST_ASSERT_TRUE_MESSAGE(RyanJsonIsDouble(RyanJsonGetObjectToKey(jsonRoot, "double")), "字段 'double' 修改后不是浮点数");
	TEST_ASSERT_TRUE_MESSAGE(RyanJsonCompareDouble(RyanJsonGetDoubleValue(RyanJsonGetObjectToKey(jsonRoot, "double")), 20.89),
				 "字段 'double' 值不匹配");

	// 修改 Key (inline 模式，不超过长度)
	RyanJsonChangeKey(RyanJsonGetObjectByKey(jsonRoot, "0"), "type");
	TEST_ASSERT_EQUAL_STRING_MESSAGE("type", RyanJsonGetKey(RyanJsonGetObjectToKey(jsonRoot, "type")), "字段 'type' 的 Key 不匹配");
	TEST_ASSERT_EQUAL_STRING_MESSAGE("1", RyanJsonGetStringValue(RyanJsonGetObjectToKey(jsonRoot, "type")), "字段 'type' 的内容不匹配");

	// 修改 Key (从 inline 转 ptr 模式)
	RyanJsonChangeKey(RyanJsonGetObjectByKey(jsonRoot, "type"), "type000000000000000");
	TEST_ASSERT_EQUAL_STRING_MESSAGE("type000000000000000", RyanJsonGetKey(RyanJsonGetObjectToKey(jsonRoot, "type000000000000000")),
					 "长 Key 模式下的 Key 不匹配");
	TEST_ASSERT_EQUAL_STRING_MESSAGE("1", RyanJsonGetStringValue(RyanJsonGetObjectToKey(jsonRoot, "type000000000000000")),
					 "长 Key 模式下的内容不匹配");

	// 修改 Key (从 ptr 转 inline 模式)
	RyanJsonChangeKey(RyanJsonGetObjectByKey(jsonRoot, "nameaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), "na");
	TEST_ASSERT_EQUAL_STRING_MESSAGE("na", RyanJsonGetKey(RyanJsonGetObjectToKey(jsonRoot, "na")), "回退到 inline 模式的 Key 不匹配");
	TEST_ASSERT_EQUAL_STRING_MESSAGE("Mash", RyanJsonGetStringValue(RyanJsonGetObjectToKey(jsonRoot, "na")),
					 "回退到 inline 模式的内容不匹配");

	// 修改 Value (inline 模式，不超过长度)
	RyanJsonChangeStringValue(RyanJsonGetObjectByKey(jsonRoot, "2"), "type");
	TEST_ASSERT_EQUAL_STRING_MESSAGE("2", RyanJsonGetKey(RyanJsonGetObjectToKey(jsonRoot, "2")), "字段 '2' 的 Key 不匹配");
	TEST_ASSERT_EQUAL_STRING_MESSAGE("type", RyanJsonGetStringValue(RyanJsonGetObjectToKey(jsonRoot, "2")), "字段 '2' 的新内容不匹配");

	// 修改 Value (从 ptr 转 inline 模式)
	RyanJsonChangeStringValue(RyanJsonGetObjectByKey(jsonRoot, "name"), "Ma");
	TEST_ASSERT_EQUAL_STRING_MESSAGE("name", RyanJsonGetKey(RyanJsonGetObjectToKey(jsonRoot, "name")), "字段 'name' 的 Key 不匹配");
	TEST_ASSERT_EQUAL_STRING_MESSAGE("Ma", RyanJsonGetStringValue(RyanJsonGetObjectToKey(jsonRoot, "name")),
					 "回退到 inline 模式的 Value 不匹配");

	// 修改 Value (从 ptr 转 ptr 模式)
	RyanJsonChangeStringValue(RyanJsonGetObjectByKey(jsonRoot, "name"), "Mashaaaaaaaaaaaaaaaaaaaaaaaa");
	TEST_ASSERT_EQUAL_STRING_MESSAGE("name", RyanJsonGetKey(RyanJsonGetObjectToKey(jsonRoot, "name")), "字段 'name' 的 Key 不匹配");
	TEST_ASSERT_EQUAL_STRING_MESSAGE("Mashaaaaaaaaaaaaaaaaaaaaaaaa", RyanJsonGetStringValue(RyanJsonGetObjectToKey(jsonRoot, "name")),
					 "长 Value 模式下的内容不匹配");

	// 修改字符串
	RyanJsonChangeStringValue(RyanJsonGetObjectToKey(jsonRoot, "string"), "world");
	TEST_ASSERT_TRUE_MESSAGE(RyanJsonIsString(RyanJsonGetObjectToKey(jsonRoot, "string")), "字段 'string' 修改后不是字符串");
	TEST_ASSERT_EQUAL_STRING_MESSAGE("world", RyanJsonGetStringValue(RyanJsonGetObjectToKey(jsonRoot, "string")),
					 "字段 'string' 内容不匹配");

	// 修改 boolValue (true -> false)
	RyanJsonChangeBoolValue(RyanJsonGetObjectToKey(jsonRoot, "boolTrue"), RyanJsonFalse);
	TEST_ASSERT_TRUE_MESSAGE(RyanJsonIsBool(RyanJsonGetObjectToKey(jsonRoot, "boolTrue")), "字段 'boolTrue' 类型错误");
	TEST_ASSERT_EQUAL_INT_MESSAGE(RyanJsonFalse, RyanJsonGetBoolValue(RyanJsonGetObjectToKey(jsonRoot, "boolTrue")),
				      "字段 'boolTrue' 值错误");

	// 修改 boolValue (false -> true)
	RyanJsonChangeBoolValue(RyanJsonGetObjectToKey(jsonRoot, "boolFalse"), RyanJsonTrue);
	TEST_ASSERT_TRUE_MESSAGE(RyanJsonIsBool(RyanJsonGetObjectToKey(jsonRoot, "boolFalse")), "字段 'boolFalse' 类型错误");
	TEST_ASSERT_EQUAL_INT_MESSAGE(RyanJsonTrue, RyanJsonGetBoolValue(RyanJsonGetObjectToKey(jsonRoot, "boolFalse")),
				      "字段 'boolFalse' 值错误");

	/**
	 * @brief 修改数组元素 (arrayInt)
	 */
	RyanJsonChangeIntValue(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(jsonRoot, "arrayInt"), 0), 99);
	TEST_ASSERT_EQUAL_INT_MESSAGE(99, RyanJsonGetIntValue(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(jsonRoot, "arrayInt"), 0)),
				      "数组元素修改失败");

	/**
	 * @brief 修改数组元素 (arrayDouble)
	 */
	RyanJsonChangeDoubleValue(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(jsonRoot, "arrayDouble"), 1), 99.99);
	TEST_ASSERT_TRUE_MESSAGE(
		RyanJsonCompareDouble(RyanJsonGetDoubleValue(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(jsonRoot, "arrayDouble"), 1)),
				      99.99),
		"数组浮点元素修改失败");

	/**
	 * @brief 修改数组元素 (arrayString)
	 */
	RyanJsonChangeStringValue(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(jsonRoot, "arrayString"), 2), "changedString");
	TEST_ASSERT_EQUAL_STRING_MESSAGE(
		"changedString", RyanJsonGetStringValue(RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(jsonRoot, "arrayString"), 2)),
		"数组字符串元素修改失败");

	/**
	 * @brief 修改嵌套对象
	 */
	RyanJson_t nestedObj = RyanJsonGetObjectToKey(jsonRoot, "item");
	RyanJsonChangeStringValue(RyanJsonGetObjectToKey(nestedObj, "string"), "nestedWorld");
	TEST_ASSERT_EQUAL_STRING_MESSAGE("nestedWorld", RyanJsonGetStringValue(RyanJsonGetObjectToKey(nestedObj, "string")),
					 "嵌套对象修改失败");

	/**
	 * @brief 修改数组对象中的字段 (arrayItem[0].inter -> 123)
	 */
	RyanJson_t arrayItem0 = RyanJsonGetObjectToIndex(RyanJsonGetObjectToKey(jsonRoot, "arrayItem"), 0);
	RyanJsonChangeIntValue(RyanJsonGetObjectToKey(arrayItem0, "inter"), 123);
	TEST_ASSERT_EQUAL_INT_MESSAGE(123, RyanJsonGetIntValue(RyanJsonGetObjectToKey(arrayItem0, "inter")), "数组中对象的字段修改失败");

	char *str = RyanJsonPrint(jsonRoot, 1024, RyanJsonTrue, NULL);
	RyanJsonFree(str);
	RyanJsonDelete(jsonRoot);

	/**
	 * @brief 验证创建后的内存模式库切换 (Create -> Change)
	 */
	RyanJson_t json = RyanJsonCreateString("key", "val");
	TEST_ASSERT_NOT_NULL(json);
	TEST_ASSERT_EQUAL_STRING_MESSAGE("val", RyanJsonGetStringValue(json), "Inline 模式初次设置失败");

	// 修改为长字符串 (触发自动切换到 ptr 模式)
	const char *longVal = "This is a very long string that definitely exceeds the inline threshold of RyanJson structure.";
	RyanJsonChangeStringValue(json, longVal);
	TEST_ASSERT_EQUAL_STRING_MESSAGE(longVal, RyanJsonGetStringValue(json), "切换到 Ptr 模式后值错误");

	// 修改回短字符串
	RyanJsonChangeStringValue(json, "new");
	TEST_ASSERT_EQUAL_STRING_MESSAGE("new", RyanJsonGetStringValue(json), "切回短字符串后值错误");

	// 修改 Key 为长 Key
	const char *longKey = "a_very_long_key_name_to_trigger_ptr_mode_for_key_storage_in_ryanjson";
	RyanJsonChangeKey(json, longKey);
	TEST_ASSERT_EQUAL_STRING_MESSAGE(longKey, RyanJsonGetKey(json), "Key 切换到 Ptr 模式后错误");

	RyanJsonDelete(json);
}

static void testChangeInlineCalcBoundary(void)
{
	/**
	 * 这个测试的目标：
	 * 验证 RyanJsonInternalChangeString 的容量判断在“临界长度”处是否正确；
	 * 验证 value 和 key 两条路径都会发生 inline <-> ptr 的双向切换；
	 * 不依赖固定常量（例如 keyLen=255），而是基于当前编译配置动态计算边界。
	 *
	 * 背景：
	 * RyanJsonInternalChangeString 的判定核心是：
	 *   if ((mallocSize + keyLenFieldBytes) <= RyanJsonInlineStringSize) => inline
	 *   else => ptr
	 *
	 * 因此这里分别构造：
	 * - 恰好满足 <= 的输入（应保持/切回 inline）
	 * - 超过 1 字节的输入（应切到 ptr）
	 */
	uint32_t inlineSize = RyanJsonInlineStringSize;
	uint32_t fixedKeyLen = 1;
	uint32_t fixedValueLen = 1;

	/**
	 * value 边界计算（固定 key="k"）：
	 * 需要占用的总 inline 空间 = keyFieldLen + keyLen + '\0' + valueLen + '\0'
	 * 先算出不含 value 内容本体时的固定开销 baseNeedForValue，
	 * 再反推出 value 能放进 inline 的最大长度 maxInlineValueLen。
	 */
	uint32_t keyFieldLenForValue = RyanJsonInternalDecodeKeyLenField(RyanJsonInternalCalcLenBytes(fixedKeyLen));
	uint32_t baseNeedForValue = keyFieldLenForValue + fixedKeyLen + 1 + 1; // keyField + key + '\0' + value '\0'
	TEST_ASSERT_TRUE_MESSAGE(inlineSize >= baseNeedForValue, "inline 大小异常，无法完成边界测试");

	uint32_t maxInlineValueLen = inlineSize - baseNeedForValue;
	// valueInline: 恰好命中 inline 临界；valuePtr: 比临界多 1 字节，必须走 ptr
	char *valueInline = (char *)malloc((size_t)maxInlineValueLen + 1U);
	char *valuePtr = (char *)malloc((size_t)maxInlineValueLen + 2U);
	TEST_ASSERT_NOT_NULL(valueInline);
	TEST_ASSERT_NOT_NULL(valuePtr);
	memset(valueInline, 'v', maxInlineValueLen);
	valueInline[maxInlineValueLen] = '\0';
	memset(valuePtr, 'p', maxInlineValueLen + 1U);
	valuePtr[maxInlineValueLen + 1U] = '\0';

	RyanJson_t valueNode = RyanJsonCreateString("k", "");
	TEST_ASSERT_NOT_NULL(valueNode);
	// 临界长度：应为 inline
	TEST_ASSERT_TRUE(RyanJsonChangeStringValue(valueNode, valueInline));
	TEST_ASSERT_FALSE_MESSAGE(RyanJsonGetPayloadStrIsPtrByFlag(valueNode), "value 临界长度应为 inline");
	// 超临界：应切到 ptr
	TEST_ASSERT_TRUE(RyanJsonChangeStringValue(valueNode, valuePtr));
	TEST_ASSERT_TRUE_MESSAGE(RyanJsonGetPayloadStrIsPtrByFlag(valueNode), "value 超过临界长度应切到 ptr");
	// 回退到临界：应能从 ptr 回到 inline（覆盖回切逻辑）
	TEST_ASSERT_TRUE(RyanJsonChangeStringValue(valueNode, valueInline));
	TEST_ASSERT_FALSE_MESSAGE(RyanJsonGetPayloadStrIsPtrByFlag(valueNode), "value 回退到临界长度应切回 inline");

	/**
	 * key 边界计算（固定 value="v"）：
	 * keyLen 变化时，keyLenField 可能从 1/2/4 字节变化，
	 * 所以不能硬编码某个 keyLen，必须遍历找到“当前配置下最大可 inline 的 key 长度”。
	 */
	uint32_t maxInlineKeyLen = 0;
	for (uint32_t keyLen = 0; keyLen <= inlineSize; keyLen++)
	{
		uint32_t keyFieldLen = RyanJsonInternalDecodeKeyLenField(RyanJsonInternalCalcLenBytes(keyLen));
		uint32_t need = keyFieldLen + keyLen + 1 + fixedValueLen + 1;
		if (need <= inlineSize) { maxInlineKeyLen = keyLen; }
	}

	// 交叉校验：maxInlineKeyLen 应满足 inline；maxInlineKeyLen+1 应超过 inline
	uint32_t inlineNeed =
		RyanJsonInternalDecodeKeyLenField(RyanJsonInternalCalcLenBytes(maxInlineKeyLen)) + maxInlineKeyLen + 1 + fixedValueLen + 1;
	uint32_t ptrNeed = RyanJsonInternalDecodeKeyLenField(RyanJsonInternalCalcLenBytes(maxInlineKeyLen + 1U)) + (maxInlineKeyLen + 1U) +
			   1 + fixedValueLen + 1;
	TEST_ASSERT_TRUE_MESSAGE(inlineNeed <= inlineSize, "inline key 临界值计算错误");
	TEST_ASSERT_TRUE_MESSAGE(ptrNeed > inlineSize, "ptr key 临界值计算错误");

	// keyInline: 恰好临界；keyPtr: 超临界 1 字节
	char *keyInline = (char *)malloc((size_t)maxInlineKeyLen + 1U);
	char *keyPtr = (char *)malloc((size_t)maxInlineKeyLen + 2U);
	TEST_ASSERT_NOT_NULL(keyInline);
	TEST_ASSERT_NOT_NULL(keyPtr);
	memset(keyInline, 'k', maxInlineKeyLen);
	keyInline[maxInlineKeyLen] = '\0';
	memset(keyPtr, 'K', maxInlineKeyLen + 1U);
	keyPtr[maxInlineKeyLen + 1U] = '\0';

	RyanJson_t keyNode = RyanJsonCreateString("", "v");
	TEST_ASSERT_NOT_NULL(keyNode);
	// key 临界长度：应为 inline
	TEST_ASSERT_TRUE(RyanJsonChangeKey(keyNode, keyInline));
	TEST_ASSERT_FALSE_MESSAGE(RyanJsonGetPayloadStrIsPtrByFlag(keyNode), "key 临界长度应为 inline");
	// key 超临界：应切到 ptr
	TEST_ASSERT_TRUE(RyanJsonChangeKey(keyNode, keyPtr));
	TEST_ASSERT_TRUE_MESSAGE(RyanJsonGetPayloadStrIsPtrByFlag(keyNode), "key 超过临界长度应切到 ptr");
	// key 回退临界：应切回 inline
	TEST_ASSERT_TRUE(RyanJsonChangeKey(keyNode, keyInline));
	TEST_ASSERT_FALSE_MESSAGE(RyanJsonGetPayloadStrIsPtrByFlag(keyNode), "key 回退到临界长度应切回 inline");

	// 释放临时资源，避免单测内存泄漏
	RyanJsonDelete(valueNode);
	RyanJsonDelete(keyNode);
	free(valueInline);
	free(valuePtr);
	free(keyInline);
	free(keyPtr);
}

void testChangeRunner(void)
{
	UnitySetTestFile(__FILE__);
	RUN_TEST(testChangeEdgeCases);
	RUN_TEST(testChangeValueStress);
	RUN_TEST(testChangeScalarAndStorageMode);
	RUN_TEST(testChangeInlineCalcBoundary);
}