@cloudcome/utils-core 1.1.0 → 1.1.1

package/test/number.test.ts

@@ -0,0 +1,213 @@
+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

@@ -0,0 +1,309 @@
+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

@@ -0,0 +1,156 @@
+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');
+  });
+});