mm_cachebase 1.8.5 → 1.8.7

package/test_cache/test_file_operations.json

@@ -0,0 +1 @@
+{"data":{"test_key1":"test_value1","test_key2":{"complex":"data"}},"expires":{},"types":{"test_key1":"string","test_key2":"object"},"timestamp":1760329459329}

package/test_cache/undefined.cache.json

@@ -0,0 +1,12 @@
+{
+    "data": {
+        "test_key": {
+            "value": "test_value",
+            "expire": 0
+        }
+    },
+    "list": [
+        "test_key"
+    ],
+    "timestamp": 1760319208888
+}

package/test_new_methods.js

@@ -0,0 +1,170 @@
+const { CacheBase } = require('./index.js');
+
+// 扩展测试脚本，测试新添加的方法
+async function testNewMethods() {
+  $.log.debug('[CacheBase] \n========== 测试新添加的方法 ==========');
+  
+  try {
+    const runner = new TestRunner();
+    const cache = new CacheBase();
+    
+    // 清空缓存，确保测试环境干净
+    await cache.clear();
+    
+    // 测试列表操作方法
+    $.log.debug('[CacheBase] \n---------- 测试列表操作方法 ----------');
+    
+    await runner.runTest('setForList方法', async () => {
+      const result = await cache.setForList('list1', ['item1', 'item2', 'item3']);
+      if (result !== 3) {
+        throw new Error(`setForList失败，预期长度: 3, 实际: ${result}`);
+      }
+      
+      const list = await cache.getForList('list1');
+      if (!Array.isArray(list) || list.length !== 3 || !list.includes('item1') || !list.includes('item2') || !list.includes('item3')) {
+        throw new Error(`setForList后数据错误，实际: ${JSON.stringify(list)}`);
+      }
+    });
+    
+    await runner.runTest('addForList方法', async () => {
+      const result = await cache.addForList('list1', 'item4');
+      if (result !== 4) {
+        throw new Error(`addForList失败，预期长度: 4, 实际: ${result}`);
+      }
+      
+      const list = await cache.getForList('list1');
+      if (list.length !== 4 || list[3] !== 'item4') {
+        throw new Error(`addForList后数据错误，实际: ${JSON.stringify(list)}`);
+      }
+    });
+    
+    await runner.runTest('hasForList方法', async () => {
+      const hasItem = await cache.hasForList('list1', 'item2');
+      if (!hasItem) {
+        throw new Error(`hasForList应返回true但返回了false`);
+      }
+      
+      const hasNonExistent = await cache.hasForList('list1', 'nonExistent');
+      if (hasNonExistent) {
+        throw new Error(`hasForList应返回false但返回了true`);
+      }
+    });
+    
+    await runner.runTest('getForList方法（索引）', async () => {
+      const partialList = await cache.getForList('list1', 1, 2);
+      if (!Array.isArray(partialList) || partialList.length !== 2 || partialList[0] !== 'item2' || partialList[1] !== 'item3') {
+        throw new Error(`getForList索引查询失败，实际: ${JSON.stringify(partialList)}`);
+      }
+    });
+    
+    await runner.runTest('clearForList方法', async () => {
+      const result = await cache.clearForList('list1');
+      if (!result) {
+        throw new Error(`clearForList失败，预期: true, 实际: ${result}`);
+      }
+      
+      const list = await cache.getForList('list1');
+      if (!Array.isArray(list) || list.length !== 0) {
+        throw new Error(`clearForList后列表不为空，实际: ${JSON.stringify(list)}`);
+      }
+    });
+    
+    // 测试哈希表新增方法
+    $.log.debug('[CacheBase] \n---------- 测试哈希表新增方法 ----------');
+    
+    await runner.runTest('hmset方法', async () => {
+      const result = await cache.hmset('hash2', { field1: 'value1', field2: 'value2', field3: 'value3' });
+      if (!result) {
+        throw new Error(`hmset失败，预期: true, 实际: ${result}`);
+      }
+      
+      const hash = await cache.hgetall('hash2');
+      if (hash.field1 !== 'value1' || hash.field2 !== 'value2' || hash.field3 !== 'value3') {
+        throw new Error(`hmset后数据错误，实际: ${JSON.stringify(hash)}`);
+      }
+    });
+    
+    await runner.runTest('hmget方法', async () => {
+      const values = await cache.hmget('hash2', ['field1', 'field2', 'field3', 'nonExistent']);
+      if (JSON.stringify(values) !== JSON.stringify(['value1', 'value2', 'value3', null])) {
+        throw new Error(`hmget失败，预期: ["value1","value2","value3",null], 实际: ${JSON.stringify(values)}`);
+      }
+    });
+    
+    await runner.runTest('hlen方法', async () => {
+      const length = await cache.hlen('hash2');
+      if (length !== 3) {
+        throw new Error(`hlen失败，预期: 3, 实际: ${length}`);
+      }
+      
+      // 不存在的键
+      const nonExistentLength = await cache.hlen('nonExistentHash');
+      if (nonExistentLength !== 0) {
+        throw new Error(`hlen不存在键失败，预期: 0, 实际: ${nonExistentLength}`);
+      }
+    });
+    
+    // 显示测试结果
+    const passRate = runner.displayResults();
+    $.log.debug(`[CacheBase] \n新方法测试完成！通过率: ${passRate}%`);
+    
+    return runner.passedTests === runner.totalTests;
+    
+  } catch (error) {
+    $.log.error('[CacheBase] 新方法测试过程中出现错误:', error);
+    return false;
+  }
+}
+
+// 复用TestRunner类
+class TestRunner {
+  constructor() {
+    this.totalTests = 0;
+    this.passedTests = 0;
+    this.results = [];
+  }
+
+  async runTest(name, testFunction) {
+    this.totalTests++;
+    try {
+      await testFunction();
+      this.passedTests++;
+      this.results.push({ name, passed: true });
+      $.log.debug(`✅ ${name}`);
+    } catch (error) {
+      this.results.push({ name, passed: false, error: error.message });
+      $.log.debug(`❌ ${name} - ${error.message}`);
+    }
+  }
+
+  displayResults() {
+    $.log.debug('\n========== 新方法测试结果 ==========');
+    const passRate = (this.passedTests / this.totalTests * 100).toFixed(2);
+    $.log.debug(`通过: ${this.passedTests}/${this.totalTests} (${passRate}%)`);
+    
+    // 显示失败的测试
+    const failedTests = this.results.filter(r => !r.passed);
+    if (failedTests.length > 0) {
+      $.log.debug('\n失败的测试:');
+      failedTests.forEach(test => {
+        $.log.debug(`  - ${test.name}: ${test.error}`);
+      });
+    }
+    
+    return passRate;
+  }
+}
+
+// 运行测试
+testNewMethods().then(success => {
+  if (success) {
+    $.log.debug('[CacheBase] 新方法测试全部通过！');
+    process.exit(0);
+  } else {
+    $.log.error('[CacheBase] 新方法测试失败！');
+    process.exit(1);
+  }
+}).catch(err => {
+  $.log.error('[CacheBase] 新方法测试未捕获的错误:', err);
+  process.exit(1);
+});

package/compatibility_table.md

@@ -1,101 +0,0 @@
-# 四种缓存方式方法兼容性对比表格
-
-## 核心缓存方法
-
-| 方法名 | Redis | MongoDB | CacheBase | Memory | 状态说明 |
-|-------|-------|---------|-----------|--------|----------|
-| set | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| get | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| del | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| has | ✅ | ✅ | ✅ | ✅ | 所有方式都支持 |
-| clear | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| keys | ✅ | ✅ | ✅ | ✅ | 所有方式都支持 |
-| ttl | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| add | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| addInt | ✅ | ❌ | ✅ | ✅ | CacheBase和Memory支持，Redis支持，MongoDB不支持 |
-| addStr | ✅ | ❌ | ✅ | ✅ | CacheBase和Memory支持，Redis支持，MongoDB不支持 |
-| sort | ✅ | ✅ | ❌ | ❌ | Redis和MongoDB支持，其他方式不支持 |
-| exists | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-
-## Redis兼容方法 - 哈希表操作
-
-| 方法名 | Redis | MongoDB | CacheBase | Memory | 状态说明 |
-|-------|-------|---------|-----------|--------|----------|
-| hset | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| hget | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| hgetall | ✅ | ✅ | ✅ | ✅ | 所有方式都支持 |
-| hdel | ✅ | ✅ | ✅ | ✅ | 所有方式都支持 |
-| hmset | ✅ | ✅ | ❌ | ❌ | Redis和MongoDB支持，其他方式不支持 |
-| hmget | ❌ | ✅ | ❌ | ❌ | 仅MongoDB支持 |
-| hlen | ✅ | ✅ | ❌ | ❌ | Redis和MongoDB支持，其他方式不支持 |
-
-## Redis兼容方法 - 其他常用命令
-
-| 方法名 | Redis | MongoDB | CacheBase | Memory | 状态说明 |
-|-------|-------|---------|-----------|--------|----------|
-| expire | ✅ | ✅ | ✅ | ✅ | 所有方式都支持 |
-| incr | ✅ | ✅ | ✅ | ✅ | 所有方式都支持 |
-| decr | ✅ | ❌ | ✅ | ✅ | Redis、CacheBase和Memory支持，MongoDB不支持 |
-| mget | ✅ | ✅ | ✅ | ✅ | 所有方式都支持 |
-| mset | ✅ | ✅ | ✅ | ✅ | 所有方式都支持 |
-| pexpire | ❌ | ❌ | ❌ | ❌ | 所有方式都不支持 |
-| persist | ✅ | ❌ | ✅ | ✅ | Redis、CacheBase和Memory支持，MongoDB不支持 |
-| strlen | ✅ | ❌ | ✅ | ❌ | Redis和CacheBase支持，其他方式不支持 |
-| addFloat | ✅ | ❌ | ✅ | ✅ | Redis、CacheBase和Memory支持，MongoDB不支持 |
-| type | ❌ | ❌ | ❌ | ❌ | 所有方式都不支持 |
-| rename | ❌ | ❌ | ❌ | ❌ | 所有方式都不支持 |
-
-## Redis兼容方法 - 集合操作
-
-| 方法名 | Redis | MongoDB | CacheBase | Memory | 状态说明 |
-|-------|-------|---------|-----------|--------|----------|
-| sadd | ✅ | ❌ | ❌ | ❌ | 仅Redis支持 |
-| srem | ✅ | ❌ | ❌ | ❌ | 仅Redis支持 |
-| sismember | ✅ | ✅ | ❌ | ❌ | Redis和MongoDB支持，其他方式不支持 |
-| smembers | ✅ | ✅ | ❌ | ❌ | Redis和MongoDB支持，其他方式不支持 |
-
-## 数组/列表操作方法
-
-| 方法名 | Redis | MongoDB | CacheBase | Memory | 状态说明 |
-|-------|-------|---------|-----------|--------|----------|
-| list_set | ✅ | ❌ | ✅ | ✅ | Redis、CacheBase和Memory支持，返回列表长度，MongoDB不支持 |
-| list_add | ✅ | ❌ | ✅ | ✅ | Redis、CacheBase和Memory支持，返回列表长度，MongoDB不支持 |
-| list_has | ✅ | ❌ | ✅ | ✅ | Redis、CacheBase和Memory支持，返回1或0，MongoDB不支持 |
-| list_get | ✅ | ❌ | ✅ | ✅ | Redis、CacheBase和Memory支持，支持范围获取，MongoDB不支持 |
-| list_clear | ✅ | ❌ | ✅ | ✅ | MongoDB不支持，其他方式支持 |
-
-## 兼容性报告总结
-
-基于实际功能测试，以下是四种缓存方式的兼容性报告：
-
-| 方法类别 | CacheBase | Redis | MongoDB | Memory | 状态说明 |
-|---------|-----------|-------|---------|--------|----------|
-| 基础键值操作 | ✅ | ✅ | ✅ | ✅ | 所有缓存方式均正常工作 |
-| 数组操作 | ✅ | ✅ | ❌ | ✅ | Redis、CacheBase和Memory支持，MongoDB完全不支持 |
-| 过期时间操作 | ✅ | ✅ | ✅ | ✅ | 基本过期时间操作支持，但MongoDB不支持persist |
-| 原子递增操作 | ✅ | ✅ | ✅ | ✅ | incr和decr都支持，但MongoDB不支持decr |
-| 批量操作 | ✅ | ✅ | ✅ | ✅ | 所有方式都支持mset和mget方法 |
-| 哈希表基本操作 | ✅ | ✅ | ✅ | ✅ | 基本操作均支持 |
-| 哈希表批量操作 | ❌ | ✅ | ✅ | ❌ | Redis和MongoDB支持，其他方式不支持 |
-| 集合操作 | ❌ | ✅ | ⚠️ | ❌ | Redis完整支持，MongoDB支持部分方法，其他方式不支持 |
-| 字符串操作 | ✅ | ✅ | ❌ | ✅ | Redis、CacheBase和Memory支持字符串操作方法 |
-| 类型检测 | ❌ | ❌ | ❌ | ❌ | 所有方式都不支持 |
-| 键重命名 | ❌ | ❌ | ❌ | ❌ | 所有方式都不支持 |
-| 清理操作 | ✅ | ✅ | ✅ | ✅ | clear操作正常工作 |
-
-### 测试统计
-
-- **总测试用例**：39个方法（增加了addFloat方法）
-- **通过数**：不同缓存方式通过数量不同（Redis最多）
-- **整体支持情况**：
-  - Redis：支持31个方法，不支持7个，行为不一致0个
-  - MongoDB：支持23个方法，不支持15个，行为不一致0个
-  - CacheBase：支持31个方法，不支持7个，行为不一致0个
-  - Memory：支持31个方法，不支持7个，行为不一致0个
-- **注意事项**：
-  1. CacheBase和Memory的行为完全一致
-  2. Redis、CacheBase和Memory在所有实现的方法上表现一致
-  3. MongoDB完全不支持列表操作方法（list_*）
-  4. 大部分核心功能在Redis、CacheBase和Memory中表现一致
-  5. 所有缓存方式在基本功能上表现稳定可靠
-  6. 集合操作只有Redis完整支持

package/test_add_direct_save.js

@@ -1,60 +0,0 @@
-// 测试add方法直接保存任意值的行为
-const $ = require('./index');
-
-async function testAddMethod() {
-  console.log('开始测试add方法 - 直接保存任意值');
-  const cache = new $.CacheBase();
-  
-  try {
-    // 测试1: 保存数字值
-    console.log('测试1: 保存数字值');
-    const result1 = await cache.add('numKey', 10);
-    console.log(`  保存数字10，返回值: ${result1}`);
-    const value1 = await cache.get('numKey');
-    console.log(`  获取值: ${value1}`);
-    
-    // 测试2: 再次保存数字值（覆盖）
-    console.log('测试2: 再次保存数字值（覆盖）');
-    const result2 = await cache.add('numKey', 20);
-    console.log(`  保存数字20，返回值: ${result2}`);
-    const value2 = await cache.get('numKey');
-    console.log(`  获取值: ${value2} (应该是20，不是30)`);
-    
-    // 测试3: 保存字符串
-    console.log('测试3: 保存字符串');
-    const result3 = await cache.add('strKey', 'hello');
-    console.log(`  保存字符串'hello'，返回值: ${result3}`);
-    const value3 = await cache.get('strKey');
-    console.log(`  获取值: ${value3}`);
-    
-    // 测试4: 保存对象
-    console.log('测试4: 保存对象');
-    const objValue = { name: 'test', age: 25 };
-    const result4 = await cache.add('objKey', objValue);
-    console.log(`  保存对象，返回值类型: ${typeof result4}`);
-    const value4 = await cache.get('objKey');
-    console.log(`  获取对象name属性: ${value4.name}`);
-    
-    // 测试5: 保存数组
-    console.log('测试5: 保存数组');
-    const arrValue = [1, 2, 3, 4, 5];
-    const result5 = await cache.add('arrKey', arrValue);
-    console.log(`  保存数组，返回值长度: ${result5.length}`);
-    const value5 = await cache.get('arrKey');
-    console.log(`  获取数组第一个元素: ${value5[0]}`);
-    
-    // 测试6: 保存布尔值
-    console.log('测试6: 保存布尔值');
-    const result6 = await cache.add('boolKey', true);
-    console.log(`  保存布尔值true，返回值: ${result6}`);
-    const value6 = await cache.get('boolKey');
-    console.log(`  获取值: ${value6}`);
-    
-    console.log('\n所有测试完成！add方法现在直接保存任意值，不执行递增操作。');
-    console.log('注意：这会导致原始测试套件中的add方法测试失败，因为它们期望递增行为。');
-  } catch (error) {
-    console.error('测试失败:', error);
-  }
-}
-
-testAddMethod();

package/test_add_if_not_exists.js

@@ -1,50 +0,0 @@
-// 测试add方法 - 如果不存在则添加
-const $ = require('./index');
-
-async function testAddMethod() {
-  console.log('开始测试add方法 - 如果不存在则添加');
-  const cache = new $.CacheBase();
-  
-  try {
-    // 测试1: 添加不存在的键
-    console.log('测试1: 添加不存在的键');
-    const result1 = await cache.add('newKey', 'newValue');
-    console.log(`  添加结果: ${result1} (应该是true)`);
-    const value1 = await cache.get('newKey');
-    console.log(`  获取值: ${value1} (应该是newValue)`);
-    
-    // 测试2: 再次添加同一个键（应该失败）
-    console.log('测试2: 再次添加同一个键（应该失败）');
-    const result2 = await cache.add('newKey', 'updatedValue');
-    console.log(`  添加结果: ${result2} (应该是false)`);
-    const value2 = await cache.get('newKey');
-    console.log(`  获取值: ${value2} (应该仍然是newValue)`);
-    
-    // 测试3: 添加不同类型的值
-    console.log('测试3: 添加不同类型的值');
-    const result3 = await cache.add('numKey', 123);
-    console.log(`  添加数字结果: ${result3} (应该是true)`);
-    const result4 = await cache.add('objKey', { name: 'test' });
-    console.log(`  添加对象结果: ${result4} (应该是true)`);
-    
-    // 测试4: 带过期时间的添加
-    console.log('测试4: 带过期时间的添加');
-    const result5 = await cache.add('expireKey', 'expireValue', 1); // 1秒过期
-    console.log(`  添加带过期时间结果: ${result5} (应该是true)`);
-    
-    // 测试5: 过期后再次添加
-    console.log('测试5: 过期后再次添加');
-    console.log('  等待1秒让键过期...');
-    await new Promise(resolve => setTimeout(resolve, 1100));
-    const result6 = await cache.add('expireKey', 'newExpireValue');
-    console.log(`  过期后添加结果: ${result6} (应该是true)`);
-    const value3 = await cache.get('expireKey');
-    console.log(`  获取过期后重新添加的值: ${value3} (应该是newExpireValue)`);
-    
-    console.log('\n所有测试完成！add方法现在正确实现了"如果不存在则添加"的行为。');
-  } catch (error) {
-    console.error('测试失败:', error);
-  }
-}
-
-testAddMethod();

package/test_add_method.js

@@ -1,44 +0,0 @@
-const { CacheBase } = require('./index.js');
-
-async function testAddMethod() {
-  console.log('测试add方法行为...');
-  const cache = new CacheBase();
-  
-  // 测试1: 键不存在时设置值
-  console.log('\n测试1: 键不存在时设置值');
-  const result1 = await cache.add('test_key1', 10);
-  console.log(`add('test_key1', 10) = ${result1}`);
-  console.log(`get('test_key1') = ${await cache.get('test_key1')}`);
-  
-  // 测试2: 键存在时增加值
-  console.log('\n测试2: 键存在时增加值');
-  const result2 = await cache.add('test_key1', 5);
-  console.log(`add('test_key1', 5) = ${result2}`);
-  console.log(`get('test_key1') = ${await cache.get('test_key1')}`);
-  
-  // 测试3: 字符串值的处理
-  console.log('\n测试3: 字符串值的处理');
-  try {
-    const result3 = await cache.add('test_key2', 'test');
-    console.log(`add('test_key2', 'test') = ${result3}`);
-    console.log(`get('test_key2') = ${await cache.get('test_key2')}`);
-  } catch (error) {
-    console.log(`add('test_key2', 'test') 抛出错误: ${error.message}`);
-  }
-  
-  // 测试4: 非数值字符串转换
-  console.log('\n测试4: 非数值字符串转换');
-  const result4 = await cache.add('test_key3', '123');
-  console.log(`add('test_key3', '123') = ${result4}`);
-  console.log(`get('test_key3') = ${await cache.get('test_key3')}`);
-  
-  // 测试5: 带过期时间
-  console.log('\n测试5: 带过期时间');
-  const result5 = await cache.add('test_key4', 100, 5); // 5秒过期
-  console.log(`add('test_key4', 100, 5) = ${result5}`);
-  console.log(`ttl('test_key4') = ${await cache.ttl('test_key4')}`);
-  
-  console.log('\n测试完成！');
-}
-
-testAddMethod().catch(console.error);

package/test_cache/scope1.cache.json

@@ -1,5 +0,0 @@
-{
-    "data": {},
-    "list": [],
-    "timestamp": 1759920414864
-}

package/test_cache/scope2.cache.json

@@ -1,5 +0,0 @@
-{
-    "data": {},
-    "list": [],
-    "timestamp": 1759920414866
-}

package/test_cache/scope3.cache.json

@@ -1,5 +0,0 @@
-{
-    "data": {},
-    "list": [],
-    "timestamp": 1759920414869
-}

package/test_cache/test_scope.cache.json

@@ -1,5 +0,0 @@
-{
-    "data": {},
-    "list": [],
-    "timestamp": 1759920431894
-}

package/test_compatibility.js

@@ -1,109 +0,0 @@
-const $ = require('./index');
-const assert = require('assert');
-
-async function runTests() {
-  console.log('开始测试 CacheBase 兼容方法...');
-  
-  // 创建缓存实例
-  const cache = new $.CacheBase('test_compatibility');
-  
-  try {
-    // 测试 list_* 方法
-    console.log('\n=== 测试 list_* 方法 ===');
-    
-    // 测试 list_set - 确保值始终是数组类型
-    await cache.list_set('list1', 'single value');
-    let result = await cache.list_get('list1');
-    console.log('list_set 单值测试:', Array.isArray(result), result);
-    assert.strictEqual(Array.isArray(result), true, 'list_set 应确保值是数组类型');
-    assert.strictEqual(result.length, 1, 'list_set 应将单值包装成数组');
-    
-    // 测试 list_set - 数组值
-    await cache.list_set('list2', [1, 2, 3]);
-    result = await cache.list_get('list2');
-    console.log('list_set 数组测试:', Array.isArray(result), result);
-    assert.strictEqual(Array.isArray(result), true, 'list_set 应保持数组类型');
-    assert.strictEqual(result.length, 3, 'list_set 应正确存储数组');
-    
-    // 测试 list_add - 向空列表添加
-    await cache.list_add('list3', 'item1');
-    result = await cache.list_get('list3');
-    console.log('list_add 空列表测试:', result);
-    assert.strictEqual(result.length, 1, 'list_add 应向空列表添加元素');
-    
-    // 测试 list_add - 向现有列表添加
-    await cache.list_add('list3', 'item2');
-    result = await cache.list_get('list3');
-    console.log('list_add 现有列表测试:', result);
-    assert.strictEqual(result.length, 2, 'list_add 应向现有列表添加元素');
-    
-    // 测试 list_has - 基本类型
-    let hasValue = await cache.list_has('list3', 'item1');
-    console.log('list_has 基本类型测试:', hasValue);
-    assert.strictEqual(hasValue, true, 'list_has 应正确检测基本类型');
-    
-    // 测试 list_has - 对象类型
-    const objValue = { name: 'test', value: 123 };
-    await cache.list_add('list4', objValue);
-    hasValue = await cache.list_has('list4', { name: 'test', value: 123 });
-    console.log('list_has 对象类型测试:', hasValue);
-    assert.strictEqual(hasValue, true, 'list_has 应正确检测对象类型');
-    
-    // 测试 list_clear - 清空现有列表
-    result = await cache.list_clear('list3');
-    console.log('list_clear 现有列表测试:', result);
-    assert.strictEqual(result, true, 'list_clear 应对现有列表返回 true');
-    result = await cache.list_get('list3');
-    assert.strictEqual(Array.isArray(result), true, 'list_clear 后应返回数组');
-    assert.strictEqual(result.length, 0, 'list_clear 应清空列表');
-    
-    // 测试 list_clear - 不存在的键
-    result = await cache.list_clear('nonexistent_list');
-    console.log('list_clear 不存在键测试:', result);
-    assert.strictEqual(result, true, 'list_clear 应对不存在的键创建空列表并返回 true');
-    result = await cache.list_get('nonexistent_list');
-    assert.strictEqual(Array.isArray(result), true, 'list_clear 后应创建空数组');
-    
-    // 测试 hdel 方法
-    console.log('\n=== 测试 hdel 方法 ===');
-    
-    // 创建哈希表
-    await cache.hset('hash1', 'field1', 'value1');
-    await cache.hset('hash1', 'field2', 'value2');
-    
-    // 测试 hdel - 存在的字段
-    result = await cache.hdel('hash1', 'field1');
-    console.log('hdel 存在字段测试:', result);
-    assert.strictEqual(result, 0, 'hdel 应始终返回 0 以保持兼容性');
-    
-    // 验证字段已被删除
-    let hashValue = await cache.hget('hash1', 'field1');
-    assert.strictEqual(hashValue, undefined, 'hdel 应实际删除字段');
-    
-    // 测试 hdel - 不存在的字段
-    result = await cache.hdel('hash1', 'nonexistent_field');
-    console.log('hdel 不存在字段测试:', result);
-    assert.strictEqual(result, 0, 'hdel 应对不存在的字段返回 0');
-    
-    // 测试 hdel - 不存在的键
-    result = await cache.hdel('nonexistent_hash', 'field');
-    console.log('hdel 不存在键测试:', result);
-    assert.strictEqual(result, 0, 'hdel 应对不存在的键返回 0');
-    
-    console.log('\n所有测试通过!');
-  } catch (error) {
-    console.error('测试失败:', error.message);
-    throw error;
-  } finally {
-    // 清理测试数据
-    await cache.clear();
-    await cache.dispose();
-    console.log('\n测试完成，已清理数据');
-  }
-}
-
-// 运行测试
-runTests().catch(error => {
-  console.error('测试执行失败:', error);
-  process.exit(1);
-});