mm_cachebase 1.8.6 → 1.8.8

package/test.js

@@ -13,24 +13,24 @@ class TestRunner {
       await testFunction();
       this.passedTests++;
       this.results.push({ name, passed: true });
-      console.log(`✅ ${name}`);
+      $.log.debug(`✅ ${name}`);
     } catch (error) {
       this.results.push({ name, passed: false, error: error.message });
-      console.log(`❌ ${name} - ${error.message}`);
+      $.log.debug(`❌ ${name} - ${error.message}`);
     }
   }
 
   displayResults() {
-    console.log('\n========== 测试结果 ==========');
+    $.log.debug('\n========== 测试结果 ==========');
     const passRate = (this.passedTests / this.totalTests * 100).toFixed(2);
-    console.log(`通过: ${this.passedTests}/${this.totalTests} (${passRate}%)`);
+    $.log.debug(`通过: ${this.passedTests}/${this.totalTests} (${passRate}%)`);
     
     // 显示失败的测试
     const failedTests = this.results.filter(r => !r.passed);
     if (failedTests.length > 0) {
-      console.log('\n失败的测试:');
+      $.log.debug('\n失败的测试:');
       failedTests.forEach(test => {
-        console.log(`  - ${test.name}: ${test.error}`);
+        $.log.debug(`  - ${test.name}: ${test.error}`);
       });
     }
     
@@ -38,444 +38,469 @@ class TestRunner {
   }
 }
 
-async function runAllTests() {
-  const runner = new TestRunner();
+async function test() {
+  $.log.debug('[CacheBase] ==============================');
+  $.log.debug('[CacheBase] 开始兼容性测试');
+  $.log.debug('[CacheBase] ==============================');
   
-  // 测试基础方法
-  await testBasicMethods(runner);
-  
-  // 测试哈希表方法
-  await testHashMethods(runner);
-  
-  // 测试批量操作
-  await testBatchOperations(runner);
-  
-  // 测试过期时间
-  await testExpiration(runner);
-  
-  // 测试数值操作
-  await testNumericOperations(runner);
-  
-  // 测试字符串操作
-  await testStringOperations(runner);
-  
-  // 测试事件触发
-  await testEvents(runner);
-  
-  // 测试管理功能
-  await testAdminFunctions(runner);
-  
-  // 显示测试结果
-  return runner.displayResults();
-}
-
-// 测试基础方法
-async function testBasicMethods(runner) {
-  console.log('\n========== 测试基础方法 ==========');
-  const cache = new CacheBase();
-  
-  await runner.runTest('set和get方法', async () => {
-    await cache.set('key1', 'value1');
-    const value = await cache.get('key1');
-    if (value !== 'value1') {
-      throw new Error(`预期值: value1, 实际值: ${value}`);
-    }
-  });
-  
-  await runner.runTest('del方法', async () => {
-    await cache.set('key2', 'value2');
-    const deleted = await cache.del('key2');
-    if (deleted !== 1) {
-      throw new Error(`删除失败，预期: 1, 实际: ${deleted}`);
-    }
-    const value = await cache.get('key2');
-    if (value !== undefined) {
-      throw new Error(`键未被删除，值: ${value}`);
-    }
-  });
-  
-  await runner.runTest('exists/has方法', async () => {
-    await cache.set('key3', 'value3');
-    const exists = await cache.exists('key3');
-    if (exists !== 1) {
-      throw new Error(`exists失败，预期: 1, 实际: ${exists}`);
-    }
-    const has = await cache.has('key3');
-    if (!has) {
-      throw new Error(`has失败，预期: true, 实际: ${has}`);
-    }
-  });
-  
-  await runner.runTest('keys方法', async () => {
-    await cache.clear();
-    await cache.set('key4', 'value4');
-    await cache.set('key5', 'value5');
-    const keys = await cache.keys();
-    if (keys.length !== 2 || !keys.includes('key4') || !keys.includes('key5')) {
-      throw new Error(`keys失败，预期包含key4和key5, 实际: ${JSON.stringify(keys)}`);
-    }
-    const filteredKeys = await cache.keys('key4*');
-    if (filteredKeys.length !== 1 || filteredKeys[0] !== 'key4') {
-      throw new Error(`keys过滤失败，预期: ["key4"], 实际: ${JSON.stringify(filteredKeys)}`);
-    }
-  });
-  
-  await runner.runTest('dbsize方法', async () => {
-    const size = await cache.dbsize();
-    if (size !== 2) {
-      throw new Error(`dbsize失败，预期: 2, 实际: ${size}`);
-    }
-  });
-  
-  await runner.runTest('getset方法', async () => {
-    const oldValue = await cache.getset('key4', 'newvalue4');
-    if (oldValue !== 'value4') {
-      throw new Error(`getset失败，预期旧值: value4, 实际: ${oldValue}`);
-    }
-    const newValue = await cache.get('key4');
-    if (newValue !== 'newvalue4') {
-      throw new Error(`getset失败，预期新值: newvalue4, 实际: ${newValue}`);
-    }
-  });
-  
-  await runner.runTest('flushdb/clear方法', async () => {
-    let result = await cache.clear();
-    if (result !== 'OK') {
-      throw new Error(`flushdb失败，预期: OK, 实际: ${result}`);
-    }
-    const size = await cache.dbsize();
-    if (size !== 0) {
-      throw new Error(`flushdb后大小不为0: ${size}`);
-    }
+  try {
+    const runner = new TestRunner();
     
-    // 测试clear方法（兼容）
-    await cache.set('key6', 'value6');
-    result = await cache.clear();
-    if (result !== 'OK') {
-      throw new Error(`clear失败，预期: OK, 实际: ${result}`);
-    }
-    const sizeAfterClear = await cache.dbsize();
-    if (sizeAfterClear !== 0) {
-      throw new Error(`clear后大小不为0: ${sizeAfterClear}`);
-    }
-  });
-}
-
-// 测试哈希表方法
-async function testHashMethods(runner) {
-  console.log('\n========== 测试哈希表方法 ==========');
-  const cache = new CacheBase();
-  
-  await runner.runTest('hset和hget方法', async () => {
-    const result1 = await cache.hset('hash1', 'field1', 'value1');
-    if (result1 !== 1) {
-      throw new Error(`hset新建失败，预期: 1, 实际: ${result1}`);
-    }
+    // 测试基础方法
+    $.log.debug('[CacheBase] \n========== 测试基础方法 ==========');
+    const cache = new CacheBase();
     
-    const result2 = await cache.hset('hash1', 'field1', 'value1_updated');
-    if (result2 !== 0) {
-      throw new Error(`hset更新失败，预期: 0, 实际: ${result2}`);
-    }
+    await runner.runTest('set和get方法', async () => {
+      await cache.set('key1', 'value1');
+      const value = await cache.get('key1');
+      if (value !== 'value1') {
+        throw new Error(`预期值: value1, 实际值: ${value}`);
+      }
+    });
     
-    const value = await cache.hget('hash1', 'field1');
-    if (value !== 'value1_updated') {
-      throw new Error(`hget失败，预期: value1_updated, 实际: ${value}`);
-    }
-  });
-  
-  await runner.runTest('hgetall方法', async () => {
-    await cache.hset('hash1', 'field2', 'value2');
-    const hash = await cache.hgetall('hash1');
-    if (JSON.stringify(hash) !== JSON.stringify({ field1: 'value1_updated', field2: 'value2' })) {
-      throw new Error(`hgetall失败，预期: {"field1":"value1_updated","field2":"value2"}, 实际: ${JSON.stringify(hash)}`);
-    }
-  });
-  
-  await runner.runTest('hdel方法', async () => {
-    const result = await cache.hdel('hash1', 'field1');
-    if (result !== 1) {
-      throw new Error(`hdel失败，预期: 1, 实际: ${result}`);
-    }
-    const value = await cache.hget('hash1', 'field1');
-    if (value !== undefined) {
-      throw new Error(`hdel后字段未被删除，值: ${value}`);
-    }
+    await runner.runTest('del方法', async () => {
+      await cache.set('key2', 'value2');
+      const deleted = await cache.del('key2');
+      if (deleted !== true) {
+        throw new Error(`删除失败，预期: true, 实际: ${deleted}`);
+      }
+      const value = await cache.get('key2');
+      if (value !== null) {
+        throw new Error(`键未被删除，值: ${value}`);
+      }
+    });
     
-    // 删除不存在的字段
-    const result2 = await cache.hdel('hash1', 'non_existent');
-    if (result2 !== 0) {
-      throw new Error(`hdel不存在字段失败，预期: 0, 实际: ${result2}`);
-    }
-  });
-}
-
-// 测试批量操作
-async function testBatchOperations(runner) {
-  console.log('\n========== 测试批量操作 ==========');
-  const cache = new CacheBase();
-  
-  await runner.runTest('mset方法', async () => {
-    const result = await cache.mset({ key7: 'value7', key8: 'value8' });
-    if (result !== 'OK') {
-      throw new Error(`mset失败，预期: OK, 实际: ${result}`);
-    }
-    const value7 = await cache.get('key7');
-    const value8 = await cache.get('key8');
-    if (value7 !== 'value7' || value8 !== 'value8') {
-      throw new Error(`mset后值不匹配: key7=${value7}, key8=${value8}`);
-    }
-  });
-  
-  await runner.runTest('mget方法', async () => {
-    const values = await cache.mget(['key7', 'key8', 'non_existent']);
-    if (JSON.stringify(values) !== JSON.stringify(['value7', 'value8', undefined])) {
-      throw new Error(`mget失败，预期: ["value7","value8",undefined], 实际: ${JSON.stringify(values)}`);
-    }
-  });
-}
-
-// 测试过期时间
-async function testExpiration(runner) {
-  console.log('\n========== 测试过期时间 ==========');
-  const cache = new CacheBase();
-  
-  await runner.runTest('set带过期时间', async () => {
-    await cache.set('expire1', 'value1', 1); // 1秒过期
-    let ttl = await cache.ttl('expire1');
-    if (ttl <= 0) {
-      throw new Error(`ttl初始值错误: ${ttl}`);
-    }
+    await runner.runTest('exists/has方法', async () => {
+      await cache.set('key3', 'value3');
+      const exists = await cache.exists('key3');
+      if (exists !== true) {
+        throw new Error(`exists失败，预期: true, 实际: ${exists}`);
+      }
+      const has = await cache.has('key3');
+      if (!has) {
+        throw new Error(`has失败，预期: true, 实际: ${has}`);
+      }
+    });
     
-    // 等待过期
-    await new Promise(resolve => setTimeout(resolve, 1100));
+    await runner.runTest('keys方法', async () => {
+      await cache.clear();
+      await cache.set('key4', 'value4');
+      await cache.set('key5', 'value5');
+      const keys = await cache.keys();
+      if (keys.length !== 2 || !keys.includes('key4') || !keys.includes('key5')) {
+        throw new Error(`keys失败，预期包含key4和key5, 实际: ${JSON.stringify(keys)}`);
+      }
+      const filteredKeys = await cache.keys('key4*');
+      if (filteredKeys.length !== 1 || filteredKeys[0] !== 'key4') {
+        throw new Error(`keys过滤失败，预期: ["key4"], 实际: ${JSON.stringify(filteredKeys)}`);
+      }
+    });
     
-    ttl = await cache.ttl('expire1');
-    if (ttl !== -2) {
-      throw new Error(`过期后ttl错误，预期: -2, 实际: ${ttl}`);
-    }
+    await runner.runTest('dbsize方法', async () => {
+      const size = await cache.dbsize();
+      if (size !== 2) {
+        throw new Error(`dbsize失败，预期: 2, 实际: ${size}`);
+      }
+    });
     
-    const value = await cache.get('expire1');
-    if (value !== undefined) {
-      throw new Error(`过期后键仍存在: ${value}`);
-    }
-  });
-  
-  await runner.runTest('expire方法', async () => {
-    await cache.set('expire2', 'value2');
-    const result = await cache.expire('expire2', 1);
-    if (result !== 1) {
-      throw new Error(`expire设置失败，预期: 1, 实际: ${result}`);
-    }
-    let ttl = await cache.ttl('expire2');
-    if (ttl <= 0) {
-      throw new Error(`expire后ttl错误: ${ttl}`);
-    }
-  });
-  
-  await runner.runTest('persist方法', async () => {
-    await cache.set('expire3', 'value3', 30);
-    const result = await cache.persist('expire3');
-    if (result !== 1) {
-      throw new Error(`persist设置失败，预期: 1, 实际: ${result}`);
-    }
-    const ttl = await cache.ttl('expire3');
-    if (ttl !== -1) {
-      throw new Error(`persist后ttl错误，预期: -1, 实际: ${ttl}`);
-    }
-  });
-}
-
-// 测试数值操作
-async function testNumericOperations(runner) {
-  console.log('\n========== 测试数值操作 ==========');
-  const cache = new CacheBase();
-  
-  await runner.runTest('incr方法', async () => {
-    const result1 = await cache.incr('counter');
-    if (result1 !== 1) {
-      throw new Error(`incr初始值失败，预期: 1, 实际: ${result1}`);
-    }
-    const result2 = await cache.incr('counter');
-    if (result2 !== 2) {
-      throw new Error(`incr递增失败，预期: 2, 实际: ${result2}`);
-    }
-  });
-  
-  await runner.runTest('decr方法', async () => {
-    const result = await cache.decr('counter');
-    if (result !== 1) {
-      throw new Error(`decr递减失败，预期: 1, 实际: ${result}`);
-    }
-  });
-  
-  await runner.runTest('incrby方法', async () => {
-    const result = await cache.incrby('counter', 5);
-    if (result !== 6) {
-      throw new Error(`incrby增加失败，预期: 6, 实际: ${result}`);
-    }
-  });
-  
-  await runner.runTest('decrby方法', async () => {
-    const result = await cache.decrby('counter', 2);
-    if (result !== 4) {
-      throw new Error(`decrby减少失败，预期: 4, 实际: ${result}`);
-    }
-  });
-  
-  await runner.runTest('incrbyfloat方法', async () => {
-    const result = await cache.incrbyfloat('counter', 0.5);
-    if (result !== 4.5) {
-      throw new Error(`incrbyfloat增加失败，预期: 4.5, 实际: ${result}`);
-    }
-  });
-  
-  await runner.runTest('add方法（兼容）', async () => {
-    const result = await cache.add('counter', 10);
-    if (result !== 14.5) {
-      throw new Error(`add增加失败，预期: 14.5, 实际: ${result}`);
-    }
-  });
-  
-  await runner.runTest('addFloat方法（兼容）', async () => {
-    const result = await cache.addFloat('counter', 0.5);
-    if (result !== 15) {
-      throw new Error(`addFloat增加失败，预期: 15, 实际: ${result}`);
-    }
-  });
-}
-
-// 测试字符串操作
-async function testStringOperations(runner) {
-  console.log('\n========== 测试字符串操作 ==========');
-  const cache = new CacheBase();
-  
-  await runner.runTest('append方法', async () => {
-    await cache.set('str', 'hello');
-    const result = await cache.append('str', ' world');
-    if (result !== 11) {
-      throw new Error(`append长度错误，预期: 11, 实际: ${result}`);
-    }
-    const value = await cache.get('str');
-    if (value !== 'hello world') {
-      throw new Error(`append值错误，预期: hello world, 实际: ${value}`);
-    }
-  });
-  
-  await runner.runTest('strlen方法', async () => {
-    const result = await cache.strlen('str');
-    if (result !== 11) {
-      throw new Error(`strlen长度错误，预期: 11, 实际: ${result}`);
-    }
+    await runner.runTest('getset方法', async () => {
+      const oldValue = await cache.getset('key4', 'newvalue4');
+      if (oldValue !== 'value4') {
+        throw new Error(`getset失败，预期旧值: value4, 实际: ${oldValue}`);
+      }
+      const newValue = await cache.get('key4');
+      if (newValue !== 'newvalue4') {
+        throw new Error(`getset失败，预期新值: newvalue4, 实际: ${newValue}`);
+      }
+    });
     
-    // 不存在的键
-    const result2 = await cache.strlen('non_existent');
-    if (result2 !== 0) {
-      throw new Error(`strlen不存在键错误，预期: 0, 实际: ${result2}`);
-    }
-  });
-  
-  await runner.runTest('addStr方法（兼容）', async () => {
-    const result = await cache.addStr('str', '!');
-    if (result !== 12) {
-      throw new Error(`addStr长度错误，预期: 12, 实际: ${result}`);
-    }
-    const value = await cache.get('str');
-    if (value !== 'hello world!') {
-      throw new Error(`addStr值错误，预期: hello world!, 实际: ${value}`);
-    }
-  });
-}
-
-// 测试事件触发
-async function testEvents(runner) {
-  console.log('\n========== 测试事件触发 ==========');
-  const cache = new CacheBase();
-  
-  await runner.runTest('set事件触发', async () => {
-    return new Promise(async (resolve, reject) => {
-      let beforeTriggered = false;
-      let afterTriggered = false;
+    await runner.runTest('flushdb/clear方法', async () => {
+      let result = await cache.clear();
+      if (result !== true) {
+        throw new Error(`flushdb失败，预期: true, 实际: ${result}`);
+      }
+      const size = await cache.dbsize();
+      if (size !== 0) {
+        throw new Error(`flushdb后大小不为0: ${size}`);
+      }
       
-      cache.once('set_before', (data) => {
-        if (data.key === 'event_key' && data.value === 'event_value') {
-          beforeTriggered = true;
-        }
-      });
+      // 测试clear方法（兼容）
+      await cache.set('key6', 'value6');
+      result = await cache.clear();
+      if (result !== true) {
+        throw new Error(`clear失败，预期: true, 实际: ${result}`);
+      }
+      const sizeAfterClear = await cache.dbsize();
+      if (sizeAfterClear !== 0) {
+        throw new Error(`clear后大小不为0: ${sizeAfterClear}`);
+      }
+    });
+    
+    // 测试哈希表方法
+    $.log.debug('[CacheBase] \n========== 测试哈希表方法 ==========');
+    const hashCache = new CacheBase();
+    
+    await runner.runTest('hset和hget方法', async () => {
+      const result1 = await hashCache.hset('hash1', 'field1', 'value1');
+      if (result1 !== 1) {
+        throw new Error(`hset新建失败，预期: 1, 实际: ${result1}`);
+      }
+      
+      const result2 = await hashCache.hset('hash1', 'field1', 'value1_updated');
+      if (result2 !== 0) {
+        throw new Error(`hset更新失败，预期: 0, 实际: ${result2}`);
+      }
+      
+      const value = await hashCache.hget('hash1', 'field1');
+      if (value !== 'value1_updated') {
+        throw new Error(`hget失败，预期: value1_updated, 实际: ${value}`);
+      }
+    });
+    
+    await runner.runTest('hgetall方法', async () => {
+      await hashCache.hset('hash1', 'field2', 'value2');
+      const hash = await hashCache.hgetall('hash1');
+      if (JSON.stringify(hash) !== JSON.stringify({ field1: 'value1_updated', field2: 'value2' })) {
+        throw new Error(`hgetall失败，预期: {"field1":"value1_updated","field2":"value2"}, 实际: ${JSON.stringify(hash)}`);
+      }
+    });
+    
+    await runner.runTest('hdel方法', async () => {
+      const result = await hashCache.hdel('hash1', 'field1');
+      if (result !== true) {
+        throw new Error(`hdel失败，预期: true, 实际: ${result}`);
+      }
+      const value = await hashCache.hget('hash1', 'field1');
+      if (value !== undefined) {
+        throw new Error(`hdel后字段未被删除，值: ${value}`);
+      }
+      
+      // 删除不存在的字段
+      const result2 = await hashCache.hdel('hash1', 'non_existent');
+      if (result2 !== false) {
+        throw new Error(`hdel不存在字段失败，预期: false, 实际: ${result2}`);
+      }
+    });
+    
+    // 测试批量操作
+    $.log.debug('[CacheBase] \n========== 测试批量操作 ==========');
+    const batchCache = new CacheBase();
+    
+    await runner.runTest('mset方法', async () => {
+      const result = await batchCache.mset('key7', 'value7', 'key8', 'value8');
+      if (result !== true) {
+        throw new Error(`mset失败，预期: true, 实际: ${result}`);
+      }
+      const value7 = await batchCache.get('key7');
+      const value8 = await batchCache.get('key8');
+      if (value7 !== 'value7' || value8 !== 'value8') {
+        throw new Error(`mset设置失败，value7: ${value7}, value8: ${value8}`);
+      }
+    });
+    
+    await runner.runTest('mget方法', async () => {
+      const values = await batchCache.mget(['key7', 'key8', 'nonExistentKey']);
+      if (JSON.stringify(values) !== JSON.stringify(['value7', 'value8', null])) {
+        throw new Error(`mget失败，预期: ["value7","value8",null], 实际: ${JSON.stringify(values)}`);
+      }
+    });
+    
+    // 测试过期时间
+    $.log.debug('[CacheBase] \n========== 测试过期时间 ==========');
+    const expireCache = new CacheBase();
+    
+    await runner.runTest('set带过期时间', async () => {
+      await expireCache.set('expire1', 'value1', 1); // 1秒过期
+      let ttl = await expireCache.ttl('expire1');
+      if (ttl <= 0) {
+        throw new Error(`ttl初始值错误: ${ttl}`);
+      }
+      
+      // 等待过期
+      await new Promise(resolve => setTimeout(resolve, 1100));
+      
+      ttl = await expireCache.ttl('expire1');
+      if (ttl !== -2) {
+        throw new Error(`过期后ttl错误，预期: -2, 实际: ${ttl}`);
+      }
+      
+      const value = await expireCache.get('expire1');
+      if (value !== null) {
+        throw new Error(`过期后键仍存在: ${value}`);
+      }
+    });
+    
+    await runner.runTest('expire方法', async () => {
+      await expireCache.set('expire2', 'value2');
+      const result = await expireCache.expire('expire2', 1);
+      if (result !== true) {
+        throw new Error(`expire设置失败，预期: true, 实际: ${result}`);
+      }
+      let ttl = await expireCache.ttl('expire2');
+      if (ttl <= 0) {
+        throw new Error(`expire后ttl错误: ${ttl}`);
+      }
+    });
+    
+    await runner.runTest('persist方法', async () => {
+      await expireCache.set('expire3', 'value3', 30);
+      const result = await expireCache.persist('expire3');
+      if (result !== true) {
+        throw new Error(`persist设置失败，预期: true, 实际: ${result}`);
+      }
+      const ttl = await expireCache.ttl('expire3');
+      if (ttl !== -1) {
+        throw new Error(`persist后ttl错误，预期: -1, 实际: ${ttl}`);
+      }
+    });
+    
+    // 测试数值操作
+    $.log.debug('[CacheBase] \n========== 测试数值操作 ==========');
+    const numCache = new CacheBase();
+    
+    await runner.runTest('incr方法', async () => {
+      const result1 = await numCache.incr('counter');
+      if (result1 !== 1) {
+        throw new Error(`incr初始值失败，预期: 1, 实际: ${result1}`);
+      }
+      const value1 = await numCache.get('counter');
+      if (value1 !== 1) {
+        throw new Error(`incr值错误，预期: 1, 实际: ${value1}`);
+      }
+      
+      const result2 = await numCache.incr('counter');
+      if (result2 !== 2) {
+        throw new Error(`incr递增失败，预期: 2, 实际: ${result2}`);
+      }
+      const value2 = await numCache.get('counter');
+      if (value2 !== 2) {
+        throw new Error(`incr递增后值错误，预期: 2, 实际: ${value2}`);
+      }
+    });
+    
+    await runner.runTest('decr方法', async () => {
+      const result = await numCache.decr('counter');
+      if (result !== 1) {
+        throw new Error(`decr递减失败，预期: 1, 实际: ${result}`);
+      }
+      const value = await numCache.get('counter');
+      if (value !== 1) {
+        throw new Error(`decr递减后值错误，预期: 1, 实际: ${value}`);
+      }
+    });
+    
+    await runner.runTest('incrby方法', async () => {
+      const result = await numCache.incrby('counter', 5);
+      if (result !== 6) {
+        throw new Error(`incrby增加失败，预期: 6, 实际: ${result}`);
+      }
+      const value = await numCache.get('counter');
+      if (value !== 6) {
+        throw new Error(`incrby增加后值错误，预期: 6, 实际: ${value}`);
+      }
+    });
+    
+    await runner.runTest('decrby方法', async () => {
+      const result = await numCache.decrby('counter', 2);
+      if (result !== 4) {
+        throw new Error(`decrby减少失败，预期: 4, 实际: ${result}`);
+      }
+      const value = await numCache.get('counter');
+      if (value !== 4) {
+        throw new Error(`decrby减少后值错误，预期: 4, 实际: ${value}`);
+      }
+    });
+    
+    await runner.runTest('incrbyfloat方法', async () => {
+      const result = await numCache.incrbyfloat('counter', 0.5);
+      if (result !== 4.5) {
+        throw new Error(`incrbyfloat增加失败，预期: 4.5, 实际: ${result}`);
+      }
+      const value = await numCache.get('counter');
+      if (value !== 4.5) {
+        throw new Error(`incrbyfloat增加后值错误，预期: 4.5, 实际: ${value}`);
+      }
+    });
+    
+    await runner.runTest('add方法（兼容）', async () => {
+      // 先删除键，确保它不存在
+      await numCache.del('counter');
+      const result = await numCache.add('counter', 10);
+      if (result !== true) {
+        throw new Error(`add增加失败，预期: true, 实际: ${result}`);
+      }
+      const value = await numCache.get('counter');
+      if (value !== 10) {
+        throw new Error(`add增加后值错误，预期: 10, 实际: ${value}`);
+      }
       
-      cache.once('set_after', (data) => {
-        if (data.key === 'event_key' && data.value === 'event_value' && data.result === 'OK') {
-          afterTriggered = true;
+      // 测试键已存在时的行为（不应修改值）
+      const result2 = await numCache.add('counter', 20);
+      if (result2 !== false) {
+        throw new Error(`add键已存在时失败，预期: false, 实际: ${result2}`);
+      }
+      const value2 = await numCache.get('counter');
+      if (value2 !== 10) {
+        throw new Error(`add键已存在时值不应改变，预期: 10, 实际: ${value2}`);
+      }
+    });
+    
+    await runner.runTest('addFloat方法（兼容）', async () => {
+      const result = await numCache.addFloat('counter', 0.5);
+      if (result !== 10.5) {
+        throw new Error(`addFloat增加失败，预期: 10.5, 实际: ${result}`);
+      }
+      const value = await numCache.get('counter');
+      if (value !== 10.5) {
+        throw new Error(`addFloat增加后值错误，预期: 10.5, 实际: ${value}`);
+      }
+    });
+    
+    // 测试字符串操作
+    $.log.debug('[CacheBase] \n========== 测试字符串操作 ==========');
+    const strCache = new CacheBase();
+    
+    await runner.runTest('append方法', async () => {
+      await strCache.set('str', 'hello');
+      const result = await strCache.append('str', ' world');
+      if (result !== 11) {
+        throw new Error(`append长度错误，预期: 11, 实际: ${result}`);
+      }
+      const value = await strCache.get('str');
+      if (value !== 'hello world') {
+        throw new Error(`append值错误，预期: hello world, 实际: ${value}`);
+      }
+    });
+    
+    await runner.runTest('strlen方法', async () => {
+      const result = await strCache.strlen('str');
+      if (result !== 11) {
+        throw new Error(`strlen长度错误，预期: 11, 实际: ${result}`);
+      }
+      
+      // 不存在的键
+      const result2 = await strCache.strlen('non_existent');
+      if (result2 !== 0) {
+        throw new Error(`strlen不存在键错误，预期: 0, 实际: ${result2}`);
+      }
+    });
+    
+    await runner.runTest('addStr方法（兼容）', async () => {
+      const result = await strCache.addStr('str', '!');
+      if (result !== 12) {
+        throw new Error(`addStr长度错误，预期: 12, 实际: ${result}`);
+      }
+      const value = await strCache.get('str');
+      if (value !== 'hello world!') {
+        throw new Error(`addStr值错误，预期: hello world!, 实际: ${value}`);
+      }
+    });
+    
+    // 测试事件触发
+    $.log.debug('[CacheBase] \n========== 测试事件触发 ==========');
+    const eventCache = new CacheBase();
+    
+    await runner.runTest('set事件触发', async () => {
+      return new Promise(async (resolve, reject) => {
+        let beforeTriggered = false;
+        let afterTriggered = false;
+        
+        eventCache.once('set_before', (data) => {
+          if (data.key === 'event_key' && data.value === 'event_value') {
+            beforeTriggered = true;
+          }
+        });
+        
+        eventCache.once('set_after', (data) => {
+          if (data.key === 'event_key' && data.value === 'event_value' && data.result === 'OK') {
+            afterTriggered = true;
+            setTimeout(() => {
+              if (beforeTriggered && afterTriggered) {
+                resolve();
+              } else {
+                reject(new Error('set事件未全部触发'));
+              }
+            }, 10);
+          }
+        });
+        
+        await eventCache.set('event_key', 'event_value');
+      });
+    });
+    
+    await runner.runTest('error事件触发', async () => {
+      return new Promise(async (resolve, reject) => {
+        eventCache.once('mset_error', (data) => {
+          if (data.error && data.error.message.includes('必须是对象')) {
+            resolve();
+          } else {
+            reject(new Error('mset_error事件触发但消息不正确'));
+          }
+        });
+        
+        try {
+          await eventCache.mset(null);
+          reject(new Error('mset应抛出错误但没有'));
+        } catch (error) {
+          // 预期的错误，等待事件触发
           setTimeout(() => {
-            if (beforeTriggered && afterTriggered) {
-              resolve();
-            } else {
-              reject(new Error('set事件未全部触发'));
-            }
-          }, 10);
+            reject(new Error('mset_error事件未触发'));
+          }, 100);
         }
       });
+    });
+    
+    // 测试管理功能
+    $.log.debug('[CacheBase] \n========== 测试管理功能 ==========');
+    
+    await runner.runTest('cachebase_admin创建实例', async () => {
+      const cache1 = cachebase_admin('test_scope');
+      const cache2 = cachebase_admin('test_scope');
+      if (cache1 !== cache2) {
+        throw new Error('cachebase_admin应返回相同实例但没有');
+      }
       
-      await cache.set('event_key', 'event_value');
+      const cache3 = cachebase_admin('another_scope');
+      if (cache1 === cache3) {
+        throw new Error('cachebase_admin应返回不同作用域的不同实例但没有');
+      }
     });
-  });
-  
-  // 注意：已移除get事件触发测试，因为get方法不再触发事件以提高性能
-  
-  await runner.runTest('error事件触发', async () => {
-    return new Promise(async (resolve, reject) => {
-      cache.once('mset_error', (data) => {
-        if (data.error && data.error.message.includes('必须是对象')) {
-          resolve();
-        } else {
-          reject(new Error('mset_error事件触发但消息不正确'));
-        }
-      });
+    
+    await runner.runTest('dispose方法', async () => {
+      const disposeCache = new CacheBase();
+      await disposeCache.set('key_to_dispose', 'value');
+      disposeCache.dispose();
       
-      try {
-        await cache.mset(null);
-        reject(new Error('mset应抛出错误但没有'));
-      } catch (error) {
-        // 预期的错误，等待事件触发
-        setTimeout(() => {
-          reject(new Error('mset_error事件未触发'));
-        }, 100);
+      const size = await disposeCache.dbsize();
+      if (size !== 0) {
+        throw new Error(`dispose后大小不为0: ${size}`);
       }
     });
-  });
-}
-
-// 测试管理功能
-async function testAdminFunctions(runner) {
-  console.log('\n========== 测试管理功能 ==========');
-  
-  await runner.runTest('cachebase_admin创建实例', async () => {
-    const cache1 = cachebase_admin('test_scope');
-    const cache2 = cachebase_admin('test_scope');
-    if (cache1 !== cache2) {
-      throw new Error('cachebase_admin应返回相同实例但没有');
-    }
     
-    const cache3 = cachebase_admin('another_scope');
-    if (cache1 === cache3) {
-      throw new Error('cachebase_admin应返回不同作用域的不同实例但没有');
-    }
-  });
-  
-  await runner.runTest('dispose方法', async () => {
-    const cache = new CacheBase();
-    await cache.set('key_to_dispose', 'value');
-    cache.dispose();
+    // 显示测试结果
+    const passRate = runner.displayResults();
+    $.log.debug(`[CacheBase] \n测试完成！通过率: ${passRate}%`);
     
-    const size = await cache.dbsize();
-    if (size !== 0) {
-      throw new Error(`dispose后大小不为0: ${size}`);
-    }
-  });
+    $.log.debug('[CacheBase] \n==============================');
+    $.log.debug('[CacheBase] 所有兼容性测试完成!');
+    $.log.debug('[CacheBase] ==============================');
+    
+  } catch (error) {
+    $.log.error('[CacheBase] 测试过程中出现错误:', error);
+  }
 }
 
-// 运行所有测试
-runAllTests().then(passRate => {
-  console.log(`\n测试完成！通过率: ${passRate}%`);
-}).catch(error => {
-  console.error('测试运行失败:', error);
-});
+test().then(() => {
+  // 测试成功完成
+  $.log.debug('[CacheBase] 测试脚本正常退出');
+  process.exit(0);
+}).catch(err => {
+  $.log.error('[CacheBase] 未捕获的错误:', err);
+  process.exit(1);
+});
+
+// 添加超时保护，但让Promise处理正常结束
+setTimeout(() => {
+  $.log.warn('[CacheBase] 测试脚本超时');
+  process.exit(1);
+}, 10000); // 10秒超时