mm_cachebase 1.8.5 → 1.8.7

package/test_compatibility_improvements.js

@@ -1,147 +0,0 @@
-const assert = require('assert');
-const { CacheBase } = require('./index');
-async function testCompatibility() {
-  console.log('开始测试兼容性改进...');
-  
-  // 创建缓存实例
-  const cache = new CacheBase('test_compatibility');
-  
-  try {
-    // 清空之前的测试数据
-    await cache.clear();
-    
-    console.log('\n1. 测试 set 方法兼容性');
-    // 测试set方法
-    const setResult = await cache.set('test_key', 'test_value');
-    assert.strictEqual(setResult, 'OK', 'set方法应返回OK');
-    const getResult = await cache.get('test_key');
-    assert.strictEqual(getResult, 'test_value', 'set方法设置的值应正确');
-    console.log('✓ set 方法测试通过');
-    
-    console.log('\n2. 测试 del 方法兼容性');
-    // 测试del方法删除存在的键
-    const delResult1 = await cache.del('test_key');
-    assert.strictEqual(delResult1, 1, 'del方法应返回删除的键数量1');
-    const exists1 = await cache.exists('test_key');
-    assert.strictEqual(exists1, 0, '删除的键不应再存在');
-    
-    // 测试del方法删除不存在的键
-    const delResult2 = await cache.del('non_existent_key');
-    assert.strictEqual(delResult2, 0, '删除不存在的键应返回0');
-    console.log('✓ del 方法测试通过');
-    
-    console.log('\n3. 测试 exists 方法兼容性');
-    // 设置一些测试键
-    await cache.set('exists_key1', 'value1');
-    await cache.set('exists_key2', 'value2', 1); // 1秒过期
-    
-    // 测试单个键存在
-    const existsResult1 = await cache.exists('exists_key1');
-    assert.strictEqual(existsResult1, 1, 'exists方法应返回存在的键数量1');
-    
-    // 测试多个键存在
-    const existsResult2 = await cache.exists(['exists_key1', 'exists_key2', 'non_existent']);
-    assert.strictEqual(existsResult2, 2, 'exists方法应返回存在的键数量2');
-    
-    // 测试不存在的键
-    const existsResult3 = await cache.exists('non_existent');
-    assert.strictEqual(existsResult3, 0, '不存在的键应返回0');
-    console.log('✓ exists 方法测试通过');
-    
-    console.log('\n4. 测试 ttl 方法兼容性');
-    // 设置带过期时间的键
-    await cache.set('ttl_key', 'ttl_value', 10); // 10秒过期
-    
-    // 测试永不过期的键
-    await cache.set('ttl_key_forever', 'forever_value');
-    const ttlForever = await cache.ttl('ttl_key_forever');
-    assert.strictEqual(ttlForever, -1, '永不过期的键ttl应返回-1');
-    
-    // 测试存在但已过期的键
-    await cache.set('ttl_key_expire', 'expire_value', 1); // 1秒过期
-    await new Promise(resolve => setTimeout(resolve, 1500)); // 等待过期
-    const ttlExpired = await cache.ttl('ttl_key_expire');
-    assert.strictEqual(ttlExpired, -2, '已过期的键ttl应返回-2');
-    
-    // 测试不存在的键
-    const ttlNonExistent = await cache.ttl('non_existent_ttl');
-    assert.strictEqual(ttlNonExistent, -2, '不存在的键ttl应返回-2');
-    
-    // 测试有过期时间的键
-    await cache.set('ttl_key_with_ttl', 'value_with_ttl', 2); // 2秒过期
-    const ttlWithTtl = await cache.ttl('ttl_key_with_ttl');
-    assert.ok(ttlWithTtl >= 0 && ttlWithTtl <= 2, '有过期时间的键应返回剩余秒数');
-    console.log('✓ ttl 方法测试通过');
-    
-    console.log('\n5. 测试 clear 方法兼容性');
-    // 设置一些测试键
-    await cache.set('clear_key1', 'value1');
-    await cache.set('clear_key2', 'value2');
-    await cache.set('test_pattern1', 'pattern1');
-    await cache.set('test_pattern2', 'pattern2');
-    
-    // 测试模式匹配清除
-    await cache.clear('test_pattern*');
-    const existsPattern1 = await cache.exists('test_pattern1');
-    const existsPattern2 = await cache.exists('test_pattern2');
-    const existsClear1 = await cache.exists('clear_key1');
-    assert.strictEqual(existsPattern1, 0, '模式匹配的键应被清除');
-    assert.strictEqual(existsPattern2, 0, '模式匹配的键应被清除');
-    assert.strictEqual(existsClear1, 1, '非模式匹配的键应保留');
-    
-    // 测试全部清除
-    await cache.clear();
-    const existsAfterClear = await cache.exists(['clear_key1', 'clear_key2']);
-    assert.strictEqual(existsAfterClear, 0, 'clear方法应清除所有键');
-    console.log('✓ clear 方法测试通过');
-    
-    // 新添加的测试：addInt、addStr、addFloat、mset、mget
-    console.log('\n6. 测试 addInt 方法兼容性');
-    const intResult1 = await cache.addInt('int_key', 10);
-    assert.strictEqual(intResult1, 10, 'addInt初始值应为10');
-    const intResult2 = await cache.addInt('int_key', 5);
-    assert.strictEqual(intResult2, 15, 'addInt增加后应为15');
-    console.log('✓ addInt 方法测试通过');
-    
-    console.log('\n7. 测试 addStr 方法兼容性');
-    const strResult1 = await cache.addStr('str_key', 'hello');
-    assert.strictEqual(strResult1, 5, '初始字符串长度应为5');
-    const strResult2 = await cache.addStr('str_key', ' world');
-    assert.strictEqual(strResult2, 11, '追加后字符串长度应为11');
-    console.log('✓ addStr 方法测试通过');
-    
-    console.log('\n8. 测试 addFloat 方法兼容性');
-    const floatResult1 = await cache.addFloat('float_key', 10.5);
-    assert.strictEqual(floatResult1, 10.5, '初始浮点数应为10.5');
-    const floatResult2 = await cache.addFloat('float_key', 2.5);
-    assert.strictEqual(floatResult2, 13.0, '增加后浮点数应为13.0');
-    console.log('✓ addFloat 方法测试通过');
-    
-    console.log('\n9. 测试 mset 方法兼容性');
-    const msetResult = await cache.mset({ mkey1: 'value1', mkey2: 'value2' });
-    assert.strictEqual(msetResult, 'OK', 'mset应返回OK');
-    assert.strictEqual(await cache.get('mkey1'), 'value1', 'mset应正确设置值1');
-    assert.strictEqual(await cache.get('mkey2'), 'value2', 'mset应正确设置值2');
-    console.log('✓ mset 方法测试通过');
-    
-    console.log('\n10. 测试 mget 方法兼容性');
-    const mgetResult = await cache.mget(['mkey1', 'mkey2', 'nonexistent']);
-    assert.deepStrictEqual(mgetResult, ['value1', 'value2', undefined], 'mget应正确获取多个值');
-    console.log('✓ mget 方法测试通过');
-    
-    console.log('\n所有兼容性测试通过!');
-    return true;
-  } catch (error) {
-    console.error('测试失败:', error);
-    return false;
-  } finally {
-    // 清理测试数据
-    await cache.clear();
-    await cache.save();
-  }
-}
-
-// 运行测试
-testCompatibility().then(success => {
-  process.exit(success ? 0 : 1);
-});

package/test_list_and_decr_compatibility.js

@@ -1,99 +0,0 @@
-const assert = require('assert');
-const { CacheBase } = require('./index');
-async function testCompatibilityImprovements() {
-  console.log('开始测试兼容性改进方法...');
-  
-  // 创建缓存实例
-  const cache = new CacheBase('test_compatibility_methods');
-  
-  try {
-    // 清空之前的测试数据
-    await cache.clear();
-    
-    console.log('\n1. 测试 decr 方法兼容性');
-    // 测试decr方法初始值
-    const decrResult1 = await cache.decr('decr_key');
-    assert.strictEqual(decrResult1, -1, 'decr初始值应为-1');
-    
-    // 测试decr方法增加值
-    const decrResult2 = await cache.decr('decr_key');
-    assert.strictEqual(decrResult2, -2, 'decr减少后应为-2');
-    
-    // 测试已有数值的decr
-    await cache.set('decr_existing', 5);
-    const decrResult3 = await cache.decr('decr_existing');
-    assert.strictEqual(decrResult3, 4, '现有数值decr后应为4');
-    console.log('✓ decr 方法测试通过');
-    
-    console.log('\n2. 测试 list_set 方法兼容性');
-    // 测试list_set返回列表长度
-    const listSetResult1 = await cache.list_set('list_key', ['item1', 'item2']);
-    assert.strictEqual(listSetResult1, 2, 'list_set应返回列表长度');
-    
-    // 测试非数组值
-    const listSetResult2 = await cache.list_set('list_key_single', 'single_item');
-    assert.strictEqual(listSetResult2, 1, '非数组值list_set应返回1');
-    const listContent = await cache.list_get('list_key_single');
-    assert.deepStrictEqual(listContent, ['single_item'], '非数组值应被包装为数组');
-    console.log('✓ list_set 方法测试通过');
-    
-    console.log('\n3. 测试 list_add 方法兼容性');
-    // 测试list_add返回列表长度
-    await cache.list_set('add_list', ['initial']);
-    const listAddResult1 = await cache.list_add('add_list', 'new_item');
-    assert.strictEqual(listAddResult1, 2, 'list_add应返回添加后列表长度');
-    
-    // 测试空列表添加
-    const listAddResult2 = await cache.list_add('new_list', 'first_item');
-    assert.strictEqual(listAddResult2, 1, '空列表添加应返回1');
-    console.log('✓ list_add 方法测试通过');
-    
-    console.log('\n4. 测试 list_has 方法兼容性');
-    // 设置测试列表
-    await cache.list_set('has_list', ['item1', 'item2', 'item3']);
-    
-    // 测试存在的项
-    const hasResult1 = await cache.list_has('has_list', 'item2');
-    assert.strictEqual(hasResult1, 1, '存在的项应返回1');
-    
-    // 测试不存在的项
-    const hasResult2 = await cache.list_has('has_list', 'item4');
-    assert.strictEqual(hasResult2, 0, '不存在的项应返回0');
-    
-    // 测试不存在的键
-    const hasResult3 = await cache.list_has('non_existent_list', 'anything');
-    assert.strictEqual(hasResult3, 0, '不存在的键应返回0');
-    console.log('✓ list_has 方法测试通过');
-    
-    console.log('\n5. 测试 list_get 方法兼容性');
-    // 设置测试列表
-    await cache.list_set('range_list', ['item0', 'item1', 'item2', 'item3', 'item4']);
-    
-    // 测试全量获取
-    const getResult1 = await cache.list_get('range_list');
-    assert.deepStrictEqual(getResult1, ['item0', 'item1', 'item2', 'item3', 'item4'], '默认应返回全部元素');
-    
-    // 测试范围获取
-    const getResult2 = await cache.list_get('range_list', 1, 3);
-    assert.deepStrictEqual(getResult2, ['item1', 'item2', 'item3'], '范围获取应返回指定元素');
-    
-    // 测试起始索引获取
-    const getResult3 = await cache.list_get('range_list', 2);
-    assert.deepStrictEqual(getResult3, ['item2', 'item3', 'item4'], '只指定起始索引应返回从该索引到末尾');
-    
-    // 测试不存在的键
-    const getResult4 = await cache.list_get('non_existent_range');
-    assert.deepStrictEqual(getResult4, [], '不存在的键应返回空数组');
-    console.log('✓ list_get 方法测试通过');
-    
-    // 清理测试数据
-    await cache.clear();
-    console.log('\n所有兼容性改进方法测试通过!');
-    
-  } catch (error) {
-    console.error('兼容性改进方法测试失败:', error);
-    process.exit(1);
-  }
-}
-
-testCompatibilityImprovements();

package/test_multi_file_persistence.js

@@ -1,160 +0,0 @@
-const { CacheBase } = require('./index');
-const fs = require('fs');
-const path = require('path');
-
-async function testMultiFilePersistence() {
-  console.log('====== 测试多文件持久化功能 ======');
-  
-  // 测试目录
-  const testDir = './test_cache';
-  
-  // 清理之前的测试文件
-  console.log('清理之前的测试文件...');
-  if (fs.existsSync(testDir)) {
-    const files = fs.readdirSync(testDir);
-    for (const file of files) {
-      if (file.endsWith('.cache.json')) {
-        fs.unlinkSync(path.join(testDir, file));
-        console.log(`删除文件: ${file}`);
-      }
-    }
-  }
-  
-  try {
-    // 创建多个不同scope的缓存实例
-    console.log('\n创建多个缓存实例...');
-    
-    const cache1 = new CacheBase('scope1', {
-      persist: true,
-      dir: testDir
-    });
-    
-    const cache2 = new CacheBase('scope2', {
-      persist: true,
-      dir: testDir
-    });
-    
-    const cache3 = new CacheBase('scope3', {
-      persist: true,
-      dir: testDir
-    });
-    
-    // 为每个实例设置数据
-    console.log('\n为每个实例设置数据...');
-    
-    // scope1 数据
-    await cache1.set('scope1_key1', 'scope1_value1');
-    await cache1.set('scope1_key2', { nested: 'object1' });
-    await cache1.set('scope1_key3', 100);
-    console.log('scope1 设置的数据:');
-    console.log('scope1_key1:', await cache1.get('scope1_key1'));
-    console.log('scope1_key2:', await cache1.get('scope1_key2'));
-    console.log('scope1_key3:', await cache1.get('scope1_key3'));
-    
-    // scope2 数据
-    await cache2.set('scope2_key1', 'scope2_value1');
-    await cache2.set('scope2_key2', { nested: 'object2' });
-    await cache2.set('scope2_key3', 200);
-    console.log('\nscope2 设置的数据:');
-    console.log('scope2_key1:', await cache2.get('scope2_key1'));
-    console.log('scope2_key2:', await cache2.get('scope2_key2'));
-    console.log('scope2_key3:', await cache2.get('scope2_key3'));
-    
-    // scope3 数据
-    await cache3.set('scope3_key1', 'scope3_value1');
-    await cache3.set('scope3_key2', { nested: 'object3' });
-    await cache3.set('scope3_key3', 300);
-    console.log('\nscope3 设置的数据:');
-    console.log('scope3_key1:', await cache3.get('scope3_key1'));
-    console.log('scope3_key2:', await cache3.get('scope3_key2'));
-    console.log('scope3_key3:', await cache3.get('scope3_key3'));
-    
-    // 手动保存数据
-    console.log('\n手动保存所有数据...');
-    await cache1.save();
-    await cache2.save();
-    await cache3.save();
-    
-    // 检查生成的文件
-    console.log('\n检查生成的缓存文件:');
-    const files = fs.readdirSync(testDir);
-    const cacheFiles = files.filter(file => file.endsWith('.cache.json'));
-    console.log('生成的缓存文件:', cacheFiles);
-    
-    // 销毁所有实例
-    console.log('\n销毁所有实例...');
-    await cache1.dispose();
-    await cache2.dispose();
-    await cache3.dispose();
-    
-    // 重新创建实例并验证数据隔离
-    console.log('\n重新创建缓存实例并验证数据隔离...');
-    
-    // 只应该加载自己scope的数据
-    const newCache1 = new CacheBase('scope1', {
-      persist: true,
-      dir: testDir
-    });
-    
-    const newCache2 = new CacheBase('scope2', {
-      persist: true,
-      dir: testDir
-    });
-    
-    const newCache3 = new CacheBase('scope3', {
-      persist: true,
-      dir: testDir
-    });
-    
-    // 验证每个实例只加载了自己scope的数据
-    console.log('\n验证数据隔离:');
-    
-    // 验证scope1只加载了自己的数据
-    const scope1Keys = await newCache1.keys();
-    console.log('scope1 加载的键数量:', scope1Keys.length);
-    console.log('scope1 加载的键:', scope1Keys);
-    
-    // 验证scope2只加载了自己的数据
-    const scope2Keys = await newCache2.keys();
-    console.log('scope2 加载的键数量:', scope2Keys.length);
-    console.log('scope2 加载的键:', scope2Keys);
-    
-    // 验证scope3只加载了自己的数据
-    const scope3Keys = await newCache3.keys();
-    console.log('scope3 加载的键数量:', scope3Keys.length);
-    console.log('scope3 加载的键:', scope3Keys);
-    
-    // 验证数据正确性
-    console.log('\n验证数据正确性:');
-    console.log('scope1_key1:', await newCache1.get('scope1_key1'));
-    console.log('scope2_key1:', await newCache2.get('scope2_key1'));
-    console.log('scope3_key1:', await newCache3.get('scope3_key1'));
-    
-    // 验证数据隔离 - scope1不应该能访问scope2的数据
-    console.log('\n验证数据隔离 - scope1不应访问其他scope数据:');
-    console.log('scope1能否获取scope2_key1:', await newCache1.get('scope2_key1') === undefined ? '✓ 不能 (正确)' : '✗ 能 (错误)');
-    console.log('scope1能否获取scope3_key1:', await newCache1.get('scope3_key1') === undefined ? '✓ 不能 (正确)' : '✗ 能 (错误)');
-    
-    // 清理测试数据
-    console.log('\n清理测试数据...');
-    await newCache1.flushdb();
-    await newCache2.flushdb();
-    await newCache3.flushdb();
-    await newCache1.save();
-    await newCache2.save();
-    await newCache3.save();
-    
-    // 销毁实例
-    await newCache1.dispose();
-    await newCache2.dispose();
-    await newCache3.dispose();
-    
-    console.log('\n多文件持久化测试完成！');
-    
-  } catch (error) {
-    console.error('测试过程中发生错误:', error);
-  }
-}
-
-// 运行测试
-testMultiFilePersistence();

package/test_persistence.js

@@ -1,138 +0,0 @@
-const { CacheBase } = require('./index');
-const fs = require('fs');
-const path = require('path');
-
-async function testPersistence() {
-  console.log('====== 测试数据持久化功能 ======');
-  
-  // 清理之前的测试文件
-  const testDir = './test_cache';
-  const testFilePath = path.join(testDir, 'test_scope.cache.json');
-  if (fs.existsSync(testFilePath)) {
-    fs.unlinkSync(testFilePath);
-    console.log(`清理之前的测试文件: ${testFilePath}`);
-  }
-  
-  // 创建缓存实例，启用持久化
-  // 注意：最新版本的构造函数签名是 (scope, config)
-  const cache = new CacheBase('test_scope', {
-    persist: true,
-    dir: './test_cache',
-    saveInterval: 5000 // 5秒保存一次
-  });
-  
-  try {
-    // 启动定时保存
-    console.log('启动定时保存...');
-    const connected = await cache.connect();
-    console.log(`定时保存启动${connected ? '成功' : '失败'}`);
-    
-    // 设置一些测试数据
-    console.log('\n设置测试数据...');
-    await cache.set('key1', 'value1');
-    await cache.set('key2', { nested: 'object', array: [1, 2, 3], boolean: true });
-    await cache.set('key3', 123);
-    await cache.set('key4', 'expire_value', 30); // 30秒过期
-    
-    // 增加更多测试数据
-    await cache.set('number_key', 42.5);
-    await cache.set('boolean_key', false);
-    await cache.set('array_key', [1, 'two', { three: 3 }]);
-    await cache.set('null_key', null);
-    await cache.set('undefined_key', undefined);
-    await cache.set('empty_string', '');
-    await cache.set('long_string', '这是一个很长的字符串，用于测试不同长度的数据存储。This is a long string for testing data storage with different lengths.');
-    
-    // 使用哈希表功能
-    await cache.hset('hash_key', 'field1', 'hash_value1');
-    await cache.hset('hash_key', 'field2', 100);
-    await cache.hset('hash_key', 'field3', { nested: 'data' });
-    
-    // 设置一些递增递减的值
-    await cache.incr('counter');
-    await cache.incrby('counter_by', 10);
-    await cache.decr('counter_dec');
-    
-    // 检查设置的数据
-    console.log('设置的数据:');
-    console.log('key1:', await cache.get('key1'));
-    console.log('key2:', JSON.stringify(await cache.get('key2')));
-    console.log('key3:', await cache.get('key3'));
-    console.log('key4:', await cache.get('key4'));
-    console.log('新增数据示例:');
-    console.log('array_key:', JSON.stringify(await cache.get('array_key')));
-    console.log('hash_key 字段1:', await cache.hget('hash_key', 'field1'));
-    console.log('counter:', await cache.get('counter'));
-    
-    // 获取键数量
-    const initialKeys = await cache.keys();
-    console.log(`\n初始设置的键数量: ${initialKeys.length}`);
-    console.log('键列表:', initialKeys);
-    
-    // 手动保存数据
-    console.log('\n手动保存数据...');
-    const saved = await cache.save();
-    console.log(`手动保存${saved ? '成功' : '失败'}`);
-    
-    // 销毁当前实例
-    console.log('\n销毁当前实例...');
-    await cache.dispose();
-    console.log('实例已销毁');
-    
-    // 创建新实例，应该能加载之前保存的数据
-    console.log('\n创建新实例，尝试加载数据...');
-    const newCache = new CacheBase('test_scope', {
-      persist: true,
-      dir: './test_cache'
-    });
-    
-    // 检查数据是否被正确加载
-    console.log('\n加载的数据:');
-    console.log('key1:', await newCache.get('key1'));
-    console.log('key2:', JSON.stringify(await newCache.get('key2')));
-    console.log('key3:', await newCache.get('key3'));
-    console.log('key4:', await newCache.get('key4'));
-    
-    // 验证新加的数据是否正确加载
-    console.log('\n验证新加的数据:');
-    console.log('number_key:', await newCache.get('number_key'));
-    console.log('boolean_key:', await newCache.get('boolean_key'));
-    console.log('array_key:', JSON.stringify(await newCache.get('array_key')));
-    console.log('null_key:', await newCache.get('null_key'));
-    console.log('undefined_key:', await newCache.get('undefined_key'));
-    console.log('empty_string:', JSON.stringify(await newCache.get('empty_string')));
-    console.log('long_string 长度:', (await newCache.get('long_string')).length);
-    
-    // 验证哈希表数据
-    console.log('\n验证哈希表数据:');
-    console.log('hash_key 字段1:', await newCache.hget('hash_key', 'field1'));
-    console.log('hash_key 字段2:', await newCache.hget('hash_key', 'field2'));
-    console.log('hash_key 字段3:', JSON.stringify(await newCache.hget('hash_key', 'field3')));
-    
-    // 验证计数数据
-    console.log('\n验证计数数据:');
-    console.log('counter:', await newCache.get('counter'));
-    console.log('counter_by:', await newCache.get('counter_by'));
-    console.log('counter_dec:', await newCache.get('counter_dec'));
-    
-    // 验证键的数量
-    const loadedKeys = await newCache.keys();
-    console.log('\n加载的键数量:', loadedKeys.length);
-    console.log('键列表:', loadedKeys);
-    
-    // 清理测试数据
-    console.log('\n清理测试数据...');
-    await newcache.clear();
-    await newCache.save();
-    await newCache.dispose();
-    
-    console.log('\n测试完成！');
-    
-  } catch (error) {
-    console.error('测试过程中发生错误:', error);
-    await cache.dispose().catch(() => {});
-  }
-}
-
-// 运行测试
-testPersistence();

package/test_redis_behavior.js

@@ -1,57 +0,0 @@
-const { CacheBase } = require('./index.js');
-
-async function testRedisBehavior() {
-  console.log('测试Redis兼容行为...');
-  const cache = new CacheBase();
-  
-  // 清空缓存
-  await cache.clear();
-  
-  console.log('\n===== 测试1: 键不存在时设置数值 =====');
-  const result1 = await cache.add('num_key', 10);
-  console.log(`add('num_key', 10) = ${result1}`);
-  console.log(`get('num_key') = ${await cache.get('num_key')}`);
-  
-  console.log('\n===== 测试2: 键存在时增加值 =====');
-  const result2 = await cache.add('num_key', 5);
-  console.log(`add('num_key', 5) = ${result2}`);
-  console.log(`get('num_key') = ${await cache.get('num_key')}`);
-  
-  console.log('\n===== 测试3: 字符串形式的数字 =====');
-  const result3 = await cache.add('num_key2', '123');
-  console.log(`add('num_key2', '123') = ${result3}`);
-  console.log(`get('num_key2') = ${await cache.get('num_key2')}`);
-  
-  console.log('\n===== 测试4: 非数值字符串输入 =====');
-  try {
-    await cache.add('num_key3', 'abc');
-  } catch (error) {
-    console.log(`预期的错误: ${error.message}`);
-  }
-  
-  console.log('\n===== 测试5: 现有值为非数值时 =====');
-  // 先设置一个字符串值
-  await cache.set('str_key', 'hello');
-  console.log(`set('str_key', 'hello') 后的值: ${await cache.get('str_key')}`);
-  
-  // 尝试对字符串值执行add操作（应该抛出错误，符合Redis行为）
-  try {
-    await cache.add('str_key', 10);
-  } catch (error) {
-    console.log(`预期的错误: ${error.message}`);
-  }
-  
-  console.log('\n===== 测试6: 现有值为数字字符串时 =====');
-  // 设置一个数字字符串值
-  await cache.set('num_str_key', '42');
-  console.log(`set('num_str_key', '42') 后的值: ${await cache.get('num_str_key')}`);
-  
-  // 对数字字符串执行add操作（应该成功，符合Redis行为）
-  const result6 = await cache.add('num_str_key', 8);
-  console.log(`add('num_str_key', 8) = ${result6}`);
-  console.log(`get('num_str_key') = ${await cache.get('num_str_key')}`);
-  
-  console.log('\n所有测试完成！');
-}
-
-testRedisBehavior().catch(console.error);

package/test_undocumented_methods.js

@@ -1,57 +0,0 @@
-const assert = require('assert');
-const { CacheBase } = require('./index');
-
-async function testUndocumentedMethods() {
-  console.log('开始测试文档与实现不一致的方法...');
-  
-  // 创建缓存实例
-  const cache = new CacheBase('test_undocumented');
-  
-  try {
-    // 清空之前的测试数据
-    await cache.clear();
-    
-    console.log('\n1. 测试 addInt 方法');
-    const intResult1 = await cache.addInt('int_key', 10);
-    assert.strictEqual(intResult1, 10, 'addInt初始值应为10');
-    const intResult2 = await cache.addInt('int_key', 5);
-    assert.strictEqual(intResult2, 15, 'addInt增加后应为15');
-    console.log('✓ addInt 方法测试通过');
-    
-    console.log('\n2. 测试 addStr 方法');
-    const strResult1 = await cache.addStr('str_key', 'hello');
-    assert.strictEqual(strResult1, 5, '初始字符串长度应为5');
-    const strResult2 = await cache.addStr('str_key', ' world');
-    assert.strictEqual(strResult2, 11, '追加后字符串长度应为11');
-    console.log('✓ addStr 方法测试通过');
-    
-    console.log('\n3. 测试 addFloat 方法');
-    const floatResult1 = await cache.addFloat('float_key', 10.5);
-    assert.strictEqual(floatResult1, 10.5, '初始浮点数应为10.5');
-    const floatResult2 = await cache.addFloat('float_key', 2.5);
-    assert.strictEqual(floatResult2, 13.0, '增加后浮点数应为13.0');
-    console.log('✓ addFloat 方法测试通过');
-    
-    console.log('\n4. 测试 mset 方法');
-    const msetResult = await cache.mset({ mkey1: 'value1', mkey2: 'value2' });
-    assert.strictEqual(msetResult, 'OK', 'mset应返回OK');
-    assert.strictEqual(await cache.get('mkey1'), 'value1', 'mset应正确设置值1');
-    assert.strictEqual(await cache.get('mkey2'), 'value2', 'mset应正确设置值2');
-    console.log('✓ mset 方法测试通过');
-    
-    console.log('\n5. 测试 mget 方法');
-    const mgetResult = await cache.mget(['mkey1', 'mkey2', 'nonexistent']);
-    assert.deepStrictEqual(mgetResult, ['value1', 'value2', undefined], 'mget应正确获取多个值');
-    console.log('✓ mget 方法测试通过');
-    
-    // 清理测试数据
-    await cache.clear();
-    console.log('\n所有测试通过！');
-    
-  } catch (error) {
-    console.error('测试失败:', error);
-    process.exit(1);
-  }
-}
-
-testUndocumentedMethods();