@cloudcome/utils-core 1.1.1 → 1.2.1

package/test/number.test.ts

@@ -1,213 +0,0 @@
-import { fileSizeAbbr } from '@/number';
-import { numberAbbr, numberConvert, numberFixed, numberFormat, randomNumber } from '@/number';
-import { describe, expect, it } from 'vitest';
-
-describe('randomNumber', () => {
-  it('应在指定范围内生成随机整数', () => {
-    for (let i = 0; i < 100; i++) {
-      const result = randomNumber(1, 10);
-      expect(result).toBeGreaterThanOrEqual(1);
-      expect(result).toBeLessThanOrEqual(10);
-    }
-  });
-
-  it('应处理 min 大于 max 的情况', () => {
-    for (let i = 0; i < 100; i++) {
-      const result = randomNumber(10, 1);
-      expect(result).toBeGreaterThanOrEqual(1);
-      expect(result).toBeLessThanOrEqual(10);
-    }
-  });
-
-  it('应处理边界情况', () => {
-    expect(randomNumber(0, 0)).toBe(0);
-    expect(randomNumber(5, 5)).toBe(5);
-  });
-
-  it('应处理负数范围', () => {
-    for (let i = 0; i < 100; i++) {
-      const result = randomNumber(-10, -1);
-      expect(result).toBeGreaterThanOrEqual(-10);
-      expect(result).toBeLessThanOrEqual(-1);
-    }
-  });
-
-  it('应处理负数和正数混合范围', () => {
-    for (let i = 0; i < 100; i++) {
-      const result = randomNumber(-5, 5);
-      expect(result).toBeGreaterThanOrEqual(-5);
-      expect(result).toBeLessThanOrEqual(5);
-    }
-  });
-});
-
-describe('numberAbbr', () => {
-  it('应正确转换数字为带单位的缩写', () => {
-    expect(numberAbbr(1500, ['', 'K', 'M'], { base: 1000 })).toBe('1K');
-    expect(numberAbbr(123456, ['B', 'KB', 'MB'], { precision: 1 })).toBe('123.4KB');
-    expect(numberAbbr(500, ['B', 'KB'])).toBe('500B');
-  });
-
-  it('应处理单位数组为空的情况', () => {
-    expect(() => numberAbbr(1000, [])).toThrow('数字单位组不能为空');
-  });
-
-  it('应处理自定义进制基数', () => {
-    expect(numberAbbr(1024, ['B', 'KB', 'MB'], { base: 1024 })).toBe('1KB');
-    expect(numberAbbr(1048576, ['B', 'KB', 'MB'], { base: 1024 })).toBe('1MB');
-    expect(numberAbbr(1048576, ['', '万', '亿'], { base: 10000 })).toBe('104万');
-    expect(numberAbbr(10485769, ['', '万', '亿'], { base: 10000 })).toBe('1048万');
-    expect(numberAbbr(10485769012, ['', '万', '亿'], { base: 10000 })).toBe('104亿');
-  });
-
-  it('应处理小数位数', () => {
-    expect(numberAbbr(1234, ['', 'K', 'M'], { precision: 2 })).toBe('1.23K');
-    expect(numberAbbr(1234567, ['', 'K', 'M'], { precision: 3 })).toBe('1.234M');
-  });
-
-  it('应处理不足基数的情况', () => {
-    expect(numberAbbr(999, ['', 'K', 'M'])).toBe('999');
-    expect(numberAbbr(999999, ['', 'K', 'M'])).toBe('999K');
-  });
-});
-
-describe('numberFixed', () => {
-  it('应正确执行四舍五入', () => {
-    // biome-ignore lint/suspicious/noApproximativeNumericConstant: <explanation>
-    expect(numberFixed(3.1415, { precision: 2 })).toBe(3.14);
-    expect(numberFixed(3.145, { precision: 2 })).toBe(3.15);
-    expect(numberFixed(3.5)).toBe(4);
-  });
-
-  it('应正确执行向上取整', () => {
-    expect(numberFixed(3.1, { round: 1 })).toBe(4);
-    expect(numberFixed(-3.1, { round: 1 })).toBe(-3);
-  });
-
-  it('应正确执行向下取整', () => {
-    expect(numberFixed(3.9, { round: -1 })).toBe(3);
-    expect(numberFixed(-3.9, { round: -1 })).toBe(-4);
-  });
-
-  it('应处理负数和小数位', () => {
-    // biome-ignore lint/suspicious/noApproximativeNumericConstant: <explanation>
-    expect(numberFixed(-3.1415, { precision: 3 })).toBe(-3.141);
-    expect(numberFixed(-3.149, { precision: 2, round: -1 })).toBe(-3.15);
-  });
-
-  it('应支持默认参数', () => {
-    expect(numberFixed(2.5)).toBe(3);
-    expect(numberFixed(2.5, {})).toBe(3);
-  });
-
-  it('应处理精度为0的情况', () => {
-    expect(numberFixed(99.9, { precision: 0 })).toBe(100);
-    expect(numberFixed(99.4, { precision: 0, round: -1 })).toBe(99);
-  });
-});
-
-describe('fileSizeAbbr', () => {
-  it('应正确转换基础文件大小', () => {
-    expect(fileSizeAbbr(1024)).toBe('1KB');
-    expect(fileSizeAbbr(1048576)).toBe('1MB');
-    expect(fileSizeAbbr(500)).toBe('500B');
-    expect(fileSizeAbbr(1073741824)).toBe('1GB');
-  });
-
-  it('应处理自定义小数位', () => {
-    expect(fileSizeAbbr(123456, 1)).toBe('120.5KB');
-    expect(fileSizeAbbr(1050000, 2)).toBe('1MB');
-  });
-
-  it('应处理不足基数的情况', () => {
-    expect(fileSizeAbbr(999)).toBe('999B');
-    expect(fileSizeAbbr(1023)).toBe('1023B');
-  });
-
-  it('应处理大单位转换', () => {
-    expect(fileSizeAbbr(1099511627776)).toBe('1TB');
-    expect(fileSizeAbbr(2199023255552)).toBe('2TB');
-  });
-
-  it('应处理零值', () => {
-    expect(fileSizeAbbr(0)).toBe('0B');
-  });
-
-  it('应处理边界情况', () => {
-    expect(fileSizeAbbr(1024 * 1024 - 1)).toBe('1023KB');
-    expect(fileSizeAbbr(1024 ** 3)).toBe('1GB');
-  });
-});
-
-describe('numberConvert', () => {
-  it('应正确将十进制数转换为默认 62 进制字符串', () => {
-    expect(numberConvert(123456789)).toBe('8M0kX');
-  });
-
-  it('应正确将十进制数转换为自定义 16 进制字符串', () => {
-    expect(numberConvert(255, '0123456789ABCDEF')).toBe('FF');
-  });
-
-  it('应正确处理大整数', () => {
-    expect(numberConvert(9007199254740991n)).toBe('fFgnDxSe7');
-  });
-
-  it('应处理字符字典长度小于 2 的情况', () => {
-    expect(() => numberConvert(123, 'A')).toThrow('进制转换字典长度不能小于 2');
-  });
-
-  it('应处理字符字典为空的情况', () => {
-    expect(() => numberConvert(123, 'a')).toThrow('进制转换字典长度不能小于 2');
-  });
-
-  it('应处理负数', () => {
-    expect(numberConvert(-123)).toBe('-1z');
-  });
-
-  it('应处理零', () => {
-    expect(numberConvert(0)).toBe('0');
-  });
-});
-
-describe('numberFormat', () => {
-  it('应支持默认分隔符和步长', () => {
-    expect(numberFormat(123456.789)).toBe('123,456.789');
-    expect(numberFormat(1000)).toBe('1,000');
-    expect(numberFormat(0)).toBe('0');
-    expect(numberFormat(-123456)).toBe('-123,456');
-  });
-
-  it('应支持自定义分隔符', () => {
-    expect(numberFormat(123456, '_')).toBe('123_456');
-    expect(numberFormat(123456.789, '_')).toBe('123_456.789');
-  });
-
-  it('应支持自定义步长', () => {
-    expect(numberFormat(123456, 2)).toBe('12,34,56');
-    expect(numberFormat(123456.789, 2)).toBe('12,34,56.789');
-    expect(numberFormat(100000, 3)).toBe('100,000');
-  });
-
-  it('应支持对象配置', () => {
-    expect(numberFormat(123456, { separator: '.', step: 4 })).toBe('12.3456');
-    expect(numberFormat(123456.789, { separator: ' ', step: 3 })).toBe('123 456.789');
-  });
-
-  it('应处理小数部分', () => {
-    expect(numberFormat(1234.5678)).toBe('1,234.5678');
-    expect(numberFormat(0.1234)).toBe('0.1234');
-    expect(numberFormat(123456.789, { step: 3 })).toBe('123,456.789');
-  });
-
-  it('应处理特殊数值', () => {
-    expect(numberFormat(999)).toBe('999');
-    expect(numberFormat(1000)).toBe('1,000');
-    expect(numberFormat(1000000)).toBe('1,000,000');
-    expect(numberFormat(-123456.789)).toBe('-123,456.789');
-  });
-
-  it('应处理非整数步长参数', () => {
-    expect(numberFormat(123456, 4)).toBe('12,3456');
-    expect(numberFormat(123456, { step: 4 })).toBe('12,3456');
-  });
-});

package/test/object.test.ts

@@ -1,309 +0,0 @@
-import {
-  isEmptyObject,
-  isPlainObject,
-  objectDefaults,
-  objectEach,
-  objectEachAsync,
-  objectGet,
-  objectMap,
-  objectMerge,
-  objectOmit,
-  objectPick,
-  objectSet,
-} from '@/object';
-import type { DeepPartial } from '@/types';
-import { describe, expect, it } from 'vitest';
-
-describe('objectEach', () => {
-  it('应正确遍历对象的每个键值对', () => {
-    const obj = { a: 1, b: 2, c: 3 };
-    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-    const results: any[] = [];
-    objectEach(obj, (val, key) => {
-      results.push([key, val]);
-    });
-    expect(results).toEqual([
-      ['a', 1],
-      ['b', 2],
-      ['c', 3],
-    ]);
-  });
-
-  it('应支持提前终止遍历', () => {
-    const obj = { a: 1, b: 2, c: 3 };
-    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-    const results: any[] = [];
-    objectEach(obj, (val, key) => {
-      results.push([key, val]);
-      if (key === 'b') {
-        return false;
-      }
-    });
-    expect(results).toEqual([
-      ['a', 1],
-      ['b', 2],
-    ]);
-  });
-});
-
-describe('objectEachAsync', () => {
-  it('应正确异步遍历对象的每个键值对', async () => {
-    const obj = { a: 1, b: 2, c: 3 };
-    const results: [string, number][] = [];
-    await objectEachAsync(obj, async (val, key) => {
-      results.push([key, val]);
-    });
-    expect(results).toEqual([
-      ['a', 1],
-      ['b', 2],
-      ['c', 3],
-    ]);
-  });
-
-  it('应支持提前终止异步遍历', async () => {
-    const obj = { a: 1, b: 2, c: 3 };
-    const results: [string, number][] = [];
-    await objectEachAsync(obj, async (val, key) => {
-      results.push([key, val]);
-      if (key === 'b') {
-        return false;
-      }
-    });
-    expect(results).toEqual([
-      ['a', 1],
-      ['b', 2],
-    ]);
-  });
-});
-
-describe('objectMerge', () => {
-  it('应正确合并两个对象', () => {
-    const obj1 = { a: 1, b: { x: 10 } };
-    const obj2 = { b: { y: 20 }, c: 3 };
-    const merged = objectMerge(obj1, obj2);
-    expect(merged).toEqual({ a: 1, b: { x: 10, y: 20 }, c: 3 });
-  });
-
-  it('应正确处理循环引用', () => {
-    const obj1 = { a: 1 };
-    const obj2 = { c: obj1 };
-    // { a: 1, b: <{b: obj1}> }
-    // @ts-expect-error
-    obj1.b = obj2;
-    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-    const merged = objectMerge({}, obj1) as any;
-    expect(merged.a).toBe(1);
-    expect(merged.b.c).toBe(merged);
-  });
-
-  it('应正确合并多个对象', () => {
-    const obj1 = { a: 1 };
-    const obj2 = { b: 2 };
-    const obj3 = { c: 3 };
-    const merged = objectMerge(obj1, obj2, obj3);
-    expect(merged).toEqual({ a: 1, b: 2, c: 3 });
-  });
-
-  it('应正确合并数组', () => {
-    const obj1 = { a: [1, 2, 3] };
-    const obj2 = { a: [3, 4] };
-    const merged = objectMerge(obj1, obj2);
-    expect(merged).toEqual({ a: [3, 4, 3] });
-  });
-
-  it('不同类型的值应被覆盖，返回数组', () => {
-    const obj1 = { a: 1 };
-    const obj2 = [1];
-    const merged = objectMerge(obj1, obj2);
-    expect(merged).toEqual([1]);
-  });
-
-  it('不同类型的值应被覆盖，返回对象', () => {
-    const obj1 = { a: 1 };
-    const obj2 = [1];
-    const merged = objectMerge(obj2, obj1);
-    expect(merged).toEqual({ a: 1 });
-  });
-});
-
-// 新增 objectDefaults 单测
-describe('objectDefaults', () => {
-  it('应正确设置默认值', () => {
-    type Obj = {
-      a: number;
-      b: number;
-      c: number;
-    };
-    const obj: Partial<Obj> = { a: 1, b: undefined };
-    const defaults = { a: 4, b: 2, c: 3 };
-    const result = objectDefaults(obj, defaults);
-    expect(result).toEqual({ a: 1, b: 2, c: 3 });
-  });
-
-  it('应支持多个默认对象', () => {
-    type Obj = {
-      a: number;
-      b: number;
-      c: number;
-    };
-    const obj: Partial<Obj> = { a: 1, b: undefined };
-    const defaults1 = { a: 4, b: 2, c: 3 };
-    const result = objectDefaults(obj, defaults1);
-    expect(result).toEqual({ a: 1, b: 2, c: 3 });
-  });
-
-  it('不应覆盖已定义的值', () => {
-    const obj = { a: 1, b: 2 };
-    const defaults = { a: 5, b: 3, c: 4 };
-    const result = objectDefaults(obj, defaults);
-    expect(result).toEqual({ a: 1, b: 2, c: 4 });
-  });
-
-  it('应处理嵌套对象', () => {
-    type Obj = {
-      a: { x: number; y: number; z: number };
-      b: { y: number };
-    };
-    const obj: DeepPartial<Obj> = { a: { x: 1 }, b: undefined };
-    const defaults = { a: { x: 4, z: 3 }, b: { y: 2 } };
-    const result = objectDefaults(obj, defaults);
-    expect(result).toEqual({ a: { x: 1, z: 3 }, b: { y: 2 } });
-  });
-});
-
-describe('objectPick', () => {
-  it('应正确选择指定键的对象', () => {
-    const obj = { a: 1, b: 2, c: 3 };
-    const result = objectPick(obj, ['a', 'c']);
-    expect(result).toEqual({ a: 1, c: 3 });
-  });
-
-  it('应忽略不存在的键', () => {
-    const obj = { a: 1, b: 2, c: 3, d: 4 };
-    const result = objectPick(obj, ['a', 'd']);
-    expect(result).toEqual({ a: 1, d: 4 });
-  });
-
-  it('应返回空对象如果键数组为空', () => {
-    const obj = { a: 1, b: 2, c: 3 };
-    const result = objectPick(obj, []);
-    expect(result).toEqual({});
-  });
-});
-
-describe('objectOmit', () => {
-  it('应正确排除指定键的对象', () => {
-    const obj = { a: 1, b: 2, c: 3 };
-    const result = objectOmit(obj, ['a', 'c']);
-    expect(result).toEqual({ b: 2 });
-  });
-
-  it('应忽略不存在的键', () => {
-    const obj = { a: 1, b: 2, c: 3, d: 4 };
-    const result = objectOmit(obj, ['a', 'd']);
-    expect(result).toEqual({ b: 2, c: 3 });
-  });
-
-  it('应返回原对象如果键数组为空', () => {
-    const obj = { a: 1, b: 2, c: 3 };
-    const result = objectOmit(obj, []);
-    expect(result).toEqual({ a: 1, b: 2, c: 3 });
-  });
-});
-
-describe('objectMap', () => {
-  it('应正确映射对象的每个键值对', () => {
-    const obj = { a: 1, b: 2, c: 3 };
-    const result = objectMap(obj, (val, key) => val * 2);
-    expect(result).toEqual({ a: 2, b: 4, c: 6 });
-  });
-
-  it('应支持将值映射为不同类型的值', () => {
-    const obj = { a: 1, b: 2, c: 3 };
-    const result = objectMap(obj, (val, key) => String(val * 2));
-    expect(result).toEqual({ a: '2', b: '4', c: '6' });
-  });
-
-  it('应返回空对象如果输入对象为空', () => {
-    const obj = {};
-    const result = objectMap(obj, (val, key) => val);
-    expect(result).toEqual({});
-  });
-});
-
-describe('objectGet', () => {
-  it('应正确获取嵌套属性值（字符串路径）', () => {
-    const obj = { a: { b: { c: 42 } } };
-    const result = objectGet(obj, 'a.b.c');
-    expect(result.value).toBe(42);
-  });
-
-  it('应正确获取嵌套属性值（数组路径）', () => {
-    const obj = { a: { b: { c: 42 } } };
-    const result = objectGet(obj, ['a', 'b', 'c']);
-    expect(result.value).toBe(42);
-  });
-
-  it('应返回 undefined 如果路径不存在', () => {
-    const obj = { a: { b: { c: 42 } } };
-    const result = objectGet(obj, 'a.b.x');
-    expect(result.value).toBeUndefined();
-  });
-});
-
-describe('objectSet', () => {
-  it('应正确设置嵌套属性值', () => {
-    const obj = { a: { b: { c: 42 } } };
-    objectSet(obj, 'a.b.c', 100);
-    expect(obj.a.b.c).toBe(100);
-  });
-
-  it('应正确创建未定义的中间节点', () => {
-    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-    const obj: Record<string, any> = {};
-    objectSet(obj, 'a.b.c', 42);
-    expect(obj.a.b.c).toBe(42);
-  });
-
-  it('应在 beforeSet 返回 false 时阻止设置值', () => {
-    const obj = { a: { b: { c: 42 } } };
-    objectSet(obj, 'a.b.c', 100, {
-      beforeSet: () => false,
-    });
-    expect(obj.a.b.c).toBe(42);
-  });
-
-  it('应在 undefinedSet 返回自定义值时使用该值', () => {
-    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-    const obj: Record<string, any> = {};
-    objectSet(obj, 'a.b.c', 42, {
-      undefinedSet: () => ({ custom: 'value' }),
-    });
-    expect(obj.a.b).toEqual({ custom: 'value', c: 42 });
-  });
-});
-
-describe('isEmptyObject', () => {
-  it('应该正确识别空对象', () => {
-    expect(isEmptyObject({})).toBe(true);
-    expect(isEmptyObject(Object.create(null))).toBe(true);
-  });
-
-  it('应该识别非空对象', () => {
-    expect(isEmptyObject({ a: 1 })).toBe(false);
-    expect(isEmptyObject({ [Symbol('key')]: 'value' })).toBe(false);
-  });
-});
-
-describe('isPlainObject', () => {
-  it('应识别普通对象', () => {
-    expect(isPlainObject({})).toBe(true);
-    expect(isPlainObject(Object.create(null))).toBe(true);
-  });
-
-  it('应排除非纯对象', () => {
-    const o = {};
-    Object.setPrototypeOf(o, { aa: 1 });
-    expect(isPlainObject(o)).toBe(false);
-  });
-});

package/test/path.test.ts

@@ -1,156 +0,0 @@
-import path from 'node:path/posix';
-import { isAbsolutePath, isRelativePath, pathJoin, pathNormalize, pathRelativize, pathResolve } from '@/path';
-import { describe, expect, it } from 'vitest';
-
-function testNormalize(value: string) {
-  expect(pathNormalize(value)).toBe(path.normalize(value));
-}
-
-function testJoin(from: string, ...to: string[]) {
-  expect(pathJoin.apply(pathJoin, [from, ...to])).toBe(path.join.apply(path, [from, ...to]));
-}
-
-describe('pathNormalize', () => {
-  it('应正确标准化路径', () => {
-    testNormalize('/path///to///file');
-    testNormalize('path/to/file');
-    testNormalize('/path/to/./file');
-    testNormalize('/path/to/../file');
-    testNormalize('/path/to/../../file');
-    testNormalize('/path/to/../../../file');
-    testNormalize('/path/to/../../../../file');
-    testNormalize('/path/to/../../file/');
-    testNormalize('/path/to/./file/');
-    testNormalize('/path/to/./');
-    testNormalize('/path/to/../');
-    testNormalize('/path/to/../../');
-    testNormalize('/path/to/../../../');
-    testNormalize('/path/to/../../../../');
-    testNormalize('/path/to/./././file');
-    testNormalize('/path/to/.././file');
-    testNormalize('/path/to/../.././file');
-    testNormalize('/path/to/../../.././file');
-    testNormalize('/path/to/../../../.././file');
-    testNormalize('/path/to/./../file');
-    testNormalize('/path/to/./../../file');
-    testNormalize('/path/to/./../../../file');
-    testNormalize('/path/to/./../../../../file');
-    testNormalize('/path/to/././file');
-    testNormalize('/path/to/../././file');
-    testNormalize('/path/to/../../././file');
-    testNormalize('/path/to/../../../././file');
-    testNormalize('/path/to/../../../../././file');
-  });
-
-  it('应正确处理绝对路径和相对路径', () => {
-    testNormalize('/path/to/file');
-    testNormalize('path/to/file');
-    testNormalize('/./path/to/file');
-    testNormalize('./path/to/file');
-    testNormalize('../path/to/file');
-    testNormalize('/path/to/./file');
-    testNormalize('path/to/./file');
-    testNormalize('/path/to/../file');
-    testNormalize('path/to/../file');
-    testNormalize('/path/to/../../file');
-    testNormalize('path/to/../../file');
-    testNormalize('/path/to/../../../file');
-    testNormalize('path/to/../../../file');
-    testNormalize('/path/to/../../../../file');
-    testNormalize('path/to/../../../../file');
-  });
-});
-
-describe('pathJoin', () => {
-  it('应正确合并路径', () => {
-    testJoin('/path', 'to', 'file');
-    testJoin('path', 'to', 'file');
-    testJoin('/path', '/to', 'file');
-    testJoin('path', '/to', 'file');
-    testJoin('/path', 'to', '/file');
-    testJoin('path', 'to', '/file');
-    testJoin('/path', '/to', '/file');
-    testJoin('path', '/to', '/file');
-    testJoin('/path', 'to', 'file/');
-    testJoin('path', 'to', 'file/');
-    testJoin('/path', 'to/', 'file');
-    testJoin('path', 'to/', 'file');
-    testJoin('/path', 'to/', 'file/');
-    testJoin('path', 'to/', 'file/');
-    testJoin('/path', '/to', 'file/');
-    testJoin('path', '/to', 'file/');
-    testJoin('/path', '/to/', 'file');
-    testJoin('path', '/to/', 'file');
-    testJoin('/path', '/to/', 'file/');
-    testJoin('path', '/to/', 'file/');
-    testJoin('/path', 'to', '/file/');
-    testJoin('path', 'to', '/file/');
-    testJoin('/path', '/to', '/file/');
-    testJoin('path', '/to', '/file/');
-  });
-});
-
-describe('isAbsolutePath', () => {
-  it('应正确判断绝对路径', () => {
-    expect(isAbsolutePath('/path/to/file')).toBe(true);
-    expect(isAbsolutePath('/')).toBe(true);
-    expect(isAbsolutePath('/path/../to/file')).toBe(true);
-    expect(isAbsolutePath('/path/./to/file')).toBe(true);
-  });
-
-  it('应正确判断非绝对路径', () => {
-    expect(isAbsolutePath('path/to/file')).toBe(false);
-    expect(isAbsolutePath('./path/to/file')).toBe(false);
-    expect(isAbsolutePath('../path/to/file')).toBe(false);
-    expect(isAbsolutePath('')).toBe(false);
-  });
-});
-
-describe('isRelativePath', () => {
-  it('应正确判断相对路径', () => {
-    expect(isRelativePath('path/to/file')).toBe(true);
-    expect(isRelativePath('./path/to/file')).toBe(true);
-    expect(isRelativePath('../path/to/file')).toBe(true);
-    expect(isRelativePath('')).toBe(true);
-  });
-
-  it('应正确判断非相对路径', () => {
-    expect(isRelativePath('/path/to/file')).toBe(false);
-    expect(isRelativePath('/')).toBe(false);
-    expect(isRelativePath('/path/../to/file')).toBe(false);
-    expect(isRelativePath('/path/./to/file')).toBe(false);
-  });
-});
-
-describe('pathResolve', () => {
-  it('应正确解析路径', () => {
-    expect(pathResolve('/path', 'to', 'file')).toBe('/path/to/file');
-    expect(pathResolve('/path', '/to', 'file')).toBe('/to/file');
-    expect(pathResolve('/path', 'to', '/file')).toBe('/file');
-    expect(pathResolve('path', 'to', 'file')).toBe('path/to/file');
-    expect(pathResolve('path', '/to', 'file')).toBe('/to/file');
-    expect(pathResolve('path', 'to', '/file')).toBe('/file');
-    expect(pathResolve('/path', 'to/../file')).toBe('/path/file');
-    expect(pathResolve('/path', 'to/./file')).toBe('/path/to/file');
-    expect(pathResolve('/path', 'to/../../file')).toBe('/file');
-  });
-});
-
-describe('pathRelativize', () => {
-  it('应正确相对化路径', () => {
-    // 绝对路径应保持不变
-    expect(pathRelativize('/path/to/file')).toBe('/path/to/file');
-    expect(pathRelativize('/')).toBe('/');
-
-    // 已带'./'前缀的相对路径应保持不变
-    expect(pathRelativize('./path/to/file')).toBe('./path/to/file');
-    expect(pathRelativize('./')).toBe('./');
-
-    // 不带'./'前缀的相对路径应添加'./'前缀
-    expect(pathRelativize('path/to/file')).toBe('./path/to/file');
-    expect(pathRelativize('file')).toBe('./file');
-
-    // 带'../'前缀的相对路径应保持不变
-    expect(pathRelativize('../path/to/file')).toBe('../path/to/file');
-  });
-});