@cloudcome/utils-core 1.1.1 → 1.2.1

package/test/async.test.ts

@@ -1,375 +0,0 @@
-import { AsyncQueue, asyncLimit, asyncShared } from '@/async';
-import { fnNoop } from '@/fn';
-import { promiseDelay } from '@/promise';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { createAfn } from './helpers';
-
-beforeEach(() => {
-  vi.useFakeTimers();
-});
-
-describe('asyncShared', () => {
-  it('应共享同一个异步函数的结果', async () => {
-    const mockFn = vi.fn().mockImplementation(async (id: number) => {
-      await new Promise((resolve) => setTimeout(resolve, 100));
-      return id;
-    });
-
-    const sharedFn = asyncShared(mockFn);
-    const result1 = sharedFn(1);
-    const result2 = sharedFn(2);
-    const result3 = sharedFn(3);
-
-    await vi.runAllTimersAsync();
-    await expect(result1).resolves.toBe(1);
-    await expect(result2).resolves.toBe(1);
-    await expect(result3).resolves.toBe(1);
-    expect(mockFn).toHaveBeenCalledTimes(1); // 三次 calling，一次 execute
-  });
-
-  it('应遵守 maxAge 设置', async () => {
-    const mockFn = vi.fn().mockImplementation(async (id: number) => {
-      await new Promise((resolve) => setTimeout(resolve, 50));
-      return id;
-    });
-
-    const sharedFn = asyncShared(mockFn, { maxAge: 100 });
-    const result1 = sharedFn(1);
-    await vi.runAllTimersAsync();
-    await expect(result1).resolves.toBe(1);
-
-    // 在 maxAge 时间内再次调用
-    await vi.advanceTimersByTimeAsync(50);
-    const result2 = sharedFn(1);
-    await vi.runAllTimersAsync();
-    await expect(result2).resolves.toBe(1);
-    expect(mockFn).toHaveBeenCalledTimes(1); // 应使用缓存
-
-    // 超过 maxAge 后再次调用
-    await vi.advanceTimersByTimeAsync(100);
-    const result3 = sharedFn(1);
-    await vi.runAllTimersAsync();
-    await expect(result3).resolves.toBe(1);
-    expect(mockFn).toHaveBeenCalledTimes(2); // 应重新执行
-  });
-
-  it('应正确处理 trailing 选项', async () => {
-    const mockFn = vi.fn().mockImplementation(async (id: number) => {
-      await new Promise((resolve) => setTimeout(resolve, 100));
-      return id;
-    });
-
-    const sharedFn = asyncShared(mockFn, { trailing: true });
-    const result1 = sharedFn(1);
-    const result2 = sharedFn(1); // 执行中再次调用
-
-    await vi.runAllTimersAsync();
-    await expect(result1).resolves.toBe(1);
-    await expect(result2).resolves.toBe(1);
-    expect(mockFn).toHaveBeenCalledTimes(2); // 应执行两次
-
-    // 测试 trailing 选项在非执行期间的行为
-    await vi.advanceTimersByTimeAsync(100);
-    const result3 = sharedFn(1);
-    await vi.runAllTimersAsync();
-    await expect(result3).resolves.toBe(1);
-    expect(mockFn).toHaveBeenCalledTimes(3); // 应再次执行
-  });
-
-  it('应正确处理错误情况', async () => {
-    const error = new Error('test error');
-    let times = 0;
-    const mockFn = async () => {
-      await promiseDelay();
-      return times++ === 0 ? Promise.reject(error) : Promise.resolve('success');
-    };
-
-    const sharedFn = asyncShared(mockFn);
-
-    const result1 = sharedFn();
-    const result2 = sharedFn(); // 共享错误
-
-    await vi.runAllTimersAsync();
-    await expect(result1).rejects.toThrow(error);
-    await expect(result2).rejects.toThrow(error);
-
-    // 错误后再次调用应重新执行
-    const result3 = sharedFn();
-    await vi.runAllTimersAsync();
-    await expect(result3).resolves.toBe('success');
-  });
-
-  it('应正确处理 onTrigger 回调', async () => {
-    const mockFn = vi.fn().mockResolvedValue(1);
-    const onTrigger = vi.fn();
-
-    const sharedFn = asyncShared(mockFn, { onTrigger });
-    sharedFn(1);
-    sharedFn(1);
-
-    await vi.runAllTimersAsync();
-    expect(onTrigger).toHaveBeenCalledTimes(2); // 应调用两次
-  });
-
-  it('应正确处理 onExecute 回调', async () => {
-    const mockFn = vi.fn().mockResolvedValue(1);
-    const onTrigger = vi.fn();
-    const onExecute = vi.fn();
-
-    const sharedFn = asyncShared(mockFn, { onTrigger, onExecute });
-    sharedFn(1);
-    sharedFn(1);
-
-    await vi.runAllTimersAsync();
-    expect(onTrigger).toHaveBeenCalledTimes(2); // 应只触发一次
-    expect(onExecute).toHaveBeenCalledTimes(1); // 应只调用一次
-  });
-
-  it('应正确处理 onSuccess 回调', async () => {
-    const mockFn = vi.fn().mockResolvedValue(1);
-    const onSuccess = vi.fn();
-
-    const sharedFn = asyncShared(mockFn, { onSuccess });
-    sharedFn(1);
-    sharedFn(1);
-
-    await vi.runAllTimersAsync();
-    expect(onSuccess).toHaveBeenCalledTimes(1); // 应只调用一次
-    expect(onSuccess).toHaveBeenCalledWith(1);
-  });
-
-  it('应正确处理 onError 回调', async () => {
-    const error = new Error('test error');
-    const mockFn = vi.fn().mockRejectedValue(error);
-    const onError = vi.fn();
-
-    const sharedFn = asyncShared(mockFn, { onError });
-    sharedFn(1);
-    sharedFn(1);
-
-    await vi.runAllTimersAsync();
-    expect(onError).toHaveBeenCalledTimes(1); // 应只调用一次
-    expect(onError).toHaveBeenCalledWith(error);
-  });
-
-  it('应正确处理 onFinally 回调', async () => {
-    const mockFn = vi.fn().mockResolvedValue(1);
-    const onFinally = vi.fn();
-
-    const sharedFn = asyncShared(mockFn, { onFinally });
-    sharedFn(1);
-    sharedFn(1);
-
-    await vi.runAllTimersAsync();
-    expect(onFinally).toHaveBeenCalledTimes(1); // 应只调用一次
-  });
-});
-
-afterEach(() => {
-  vi.restoreAllMocks();
-});
-
-describe('asyncLimit', () => {
-  it('应正确处理空 Promise 数组', async () => {
-    const results = await asyncLimit([], 2);
-    expect(results).toEqual([]);
-  });
-
-  it('应在限制数量内并发执行 Promise', async () => {
-    const delays = [100, 50, 200, 150];
-    const results = asyncLimit(
-      delays.map((delay) =>
-        createAfn({
-          delay: delay,
-          result: delay,
-        }),
-      ),
-      2,
-    );
-
-    await vi.runAllTimersAsync();
-    await expect(results).resolves.toEqual(delays);
-  });
-
-  it('应正确处理小于限制数量的 Promise', async () => {
-    const delays = [100, 50];
-    const results = asyncLimit(
-      delays.map((delay) =>
-        createAfn({
-          delay: delay,
-          result: delay,
-        }),
-      ),
-      5,
-    );
-
-    await vi.runAllTimersAsync();
-    await expect(results).resolves.toEqual(delays);
-  });
-
-  it('应正确处理超过限制数量的 Promise', async () => {
-    const delays = [100, 50, 200, 150, 300];
-    const startTime = Date.now();
-    const fn = vi.fn();
-    const results = asyncLimit(
-      delays.map((delay) =>
-        createAfn({
-          delay: delay,
-          result: delay,
-          onResolved() {
-            fn(Date.now() - startTime);
-          },
-        }),
-      ),
-      2,
-    );
-
-    await vi.runAllTimersAsync();
-    await expect(results).resolves.toEqual(delays);
-    expect(fn).toHaveBeenCalledTimes(5);
-  });
-});
-
-describe('AsyncQueue', () => {
-  it('应按顺序执行任务', async () => {
-    const delays = [100, 50, 200];
-    const queue = new AsyncQueue(
-      delays.map((delay) =>
-        createAfn({
-          delay: delay,
-          result: delay,
-        }),
-      ),
-    );
-
-    const startPromise = queue.start();
-    await vi.runAllTimersAsync();
-    await expect(startPromise).resolves.toEqual(delays);
-  });
-
-  it('应正确处理空任务队列', async () => {
-    const queue = new AsyncQueue<number>([]);
-    const result = await queue.start();
-    expect(result).toEqual([]);
-  });
-
-  it('应正确处理单个任务', async () => {
-    const queue = new AsyncQueue([createAfn({ delay: 100, result: 1 })]);
-    const result = queue.start();
-    await vi.runAllTimersAsync();
-    await expect(result).resolves.toEqual([1]);
-  });
-
-  it('应正确处理多个任务', async () => {
-    const delays = [100, 50, 200];
-    const queue = new AsyncQueue(
-      delays.map((delay) =>
-        createAfn({
-          delay: delay,
-          result: delay,
-        }),
-      ),
-    );
-
-    const result = queue.start();
-    await vi.runAllTimersAsync();
-    await expect(result).resolves.toEqual(delays);
-  });
-
-  it('应正确处理任务失败', async () => {
-    const error = new Error('test error');
-    const queue = new AsyncQueue([() => Promise.reject(error)]);
-
-    await expect(queue.start()).rejects.toThrow(error);
-  });
-
-  it('应正确处理任务添加和启动顺序', async () => {
-    const queue = new AsyncQueue([]);
-    const delay = 100;
-    const promise1 = queue.push(() =>
-      createAfn({
-        delay: delay,
-        result: delay,
-      })(),
-    );
-
-    const promise2 = queue.start();
-    await vi.runAllTimersAsync();
-    await expect(promise1).resolves.toEqual(delay);
-    await expect(promise2).resolves.toEqual([delay]);
-  });
-
-  it('应正确处理并发限制', async () => {
-    const delays = [100, 50, 200, 150];
-    const fn = vi.fn();
-    const queue = new AsyncQueue(
-      delays.map((delay) =>
-        createAfn({
-          delay: delay,
-          result: delay,
-          onResolved() {
-            fn();
-          },
-        }),
-      ),
-      { limit: 2 },
-    );
-
-    queue.start();
-    expect(fn).toHaveBeenCalledTimes(0);
-    await vi.advanceTimersByTimeAsync(50);
-    expect(fn).toHaveBeenCalledTimes(1);
-    await vi.advanceTimersByTimeAsync(50);
-    expect(fn).toHaveBeenCalledTimes(2);
-    await vi.runAllTimersAsync();
-    expect(fn).toHaveBeenCalledTimes(4);
-  });
-
-  it('应正确处理任务停止', async () => {
-    const delays = [100, 50, 200];
-    const queue = new AsyncQueue(
-      delays.map((delay) =>
-        createAfn({
-          delay: delay,
-          result: delay,
-        }),
-      ),
-    );
-
-    const startPromise = queue.start();
-    const stopPromise = queue.stop();
-    await vi.runAllTimersAsync();
-    await expect(startPromise).resolves.toEqual([100, 50, 200]);
-    await expect(stopPromise).resolves.toEqual([100, 50, 200]);
-  });
-
-  it('应正确处理多次停止', async () => {
-    const delays = [100, 50, 200];
-    const queue = new AsyncQueue(
-      delays.map((delay) =>
-        createAfn({
-          delay: delay,
-          result: delay,
-        }),
-      ),
-    );
-
-    const startPromise = queue.start();
-    const stopPromise1 = queue.stop();
-    const stopPromise2 = queue.stop();
-    await vi.runAllTimersAsync();
-    await expect(startPromise).resolves.toEqual([100, 50, 200]);
-    await expect(stopPromise1).resolves.toEqual([100, 50, 200]);
-    await expect(stopPromise2).resolves.toEqual([100, 50, 200]);
-  });
-
-  it('应正确处理停止后添加任务', async () => {
-    const queue = new AsyncQueue([]);
-    const stopPromise = queue.stop();
-    const pushPromise = queue.push(createAfn({ delay: 100, result: 1 }));
-    pushPromise.catch(fnNoop);
-    await vi.runAllTimersAsync();
-    await expect(stopPromise).resolves.toEqual([]);
-    await expect(pushPromise).rejects.toThrow('异步队列已被终止，无法添加新的任务');
-  });
-});

package/test/base64.test.ts

@@ -1,32 +0,0 @@
-import { base64toBlob } from '@/base64';
-import { describe, expect, test } from 'vitest';
-
-describe('base64toBlob', () => {
-  // 通用验证方法
-  const validateBlob = (base64: string, expectedType: string) => {
-    const blob = base64toBlob(base64);
-    expect(blob).toBeInstanceOf(Blob);
-    expect(blob.type).toBe(expectedType);
-    return blob;
-  };
-
-  test('PNG 转换验证', () => {
-    const pngBase64 =
-      'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==';
-    const blob = validateBlob(pngBase64, 'image/png');
-    expect(blob.size).toBe(70); // 实际解码后的字节长度
-  });
-
-  test('JPEG 转换验证', () => {
-    const jpegBase64 =
-      'data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAABAAEDASIAAhEBAxEB/8QAFQABAQAAAAAAAAAAAAAAAAAAAAf/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/8QAFAEBAAAAAAAAAAAAAAAAAAAAAP/EABQRAQAAAAAAAAAAAAAAAAAAAAD/2gAMAwEAAhEDEQA/AJVAAP/aAAwDAQACEQMRAD8AlUAA//Z';
-    const blob = validateBlob(jpegBase64, 'image/jpeg');
-    expect(blob.size).toBe(302);
-  });
-
-  test('无数据前缀处理', () => {
-    const rawBase64 =
-      'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==';
-    expect(() => base64toBlob(rawBase64)).toThrowError();
-  });
-});

package/test/cache.test.ts

@@ -1,83 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { MemoryCache, createMemCache } from '../src/cache';
-
-describe('内存缓存', () => {
-  let cache: MemoryCache<string>;
-
-  beforeEach(() => {
-    cache = createMemCache<string>();
-    vi.useFakeTimers();
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it('应该能够设置和获取缓存', () => {
-    cache.set('key1', 'value1');
-    expect(cache.get('key1')?.data).toBe('value1');
-  });
-
-  it('获取不存在的缓存应该返回 null', () => {
-    expect(cache.get('non-existent')).toBeNull();
-  });
-
-  it('应该能够删除缓存', () => {
-    cache.set('key1', 'value1');
-    cache.del('key1');
-    expect(cache.get('key1')).toBeNull();
-  });
-
-  it('缓存过期后应该返回 null', () => {
-    cache.set('key1', 'value1', { maxAge: 1000 });
-    vi.advanceTimersByTime(1001);
-    expect(cache.get('key1')).toBeNull();
-  });
-
-  it('未设置 maxAge 的缓存应该不会过期', () => {
-    cache.set('key1', 'value1');
-    vi.advanceTimersByTime(10000);
-    expect(cache.get('key1')?.data).toBe('value1');
-  });
-
-  it('createMemCache 应该返回一个新的 MemoryCache 实例', () => {
-    const newCache = createMemCache<string>();
-    expect(newCache).toBeInstanceOf(MemoryCache);
-  });
-
-  it('expiredAt 应该优先于 maxAge', () => {
-    const future = Date.now() + 5000;
-    cache.set('key1', 'value1', { maxAge: 10000, expiredAt: future });
-    vi.advanceTimersByTime(6000);
-    expect(cache.get('key1')).toBeNull();
-  });
-
-  it('应该能够清空缓存', () => {
-    cache.set('key1', 'value1');
-    cache.set('key2', 'value2');
-    cache.clear();
-    expect(cache.get('key1')).toBeNull();
-    expect(cache.get('key2')).toBeNull();
-  });
-
-  it('normalizeCached 应该正确处理过期时间', () => {
-    const now = Date.now();
-    const cached = cache.normalizeCached('key1', 'value1', {
-      maxAge: 1000,
-      expiredAt: now + 2000,
-    });
-    expect(cached.expiredAt).toBe(now + 2000);
-  });
-
-  it('isExpired 应该正确判断缓存是否过期', () => {
-    const cached = {
-      id: 'key1',
-      data: 'value1',
-      createdAt: Date.now(),
-      expiredAt: Date.now() + 1000,
-    };
-    expect(cache.isExpired(cached)).toBe(false);
-    vi.advanceTimersByTime(1001);
-    expect(cache.isExpired(cached)).toBe(true);
-  });
-});

package/test/color.test.ts

@@ -1,163 +0,0 @@
-import type { HEX, HSL, HSV, HWB, RGB } from '@/color';
-import {
-  distance,
-  hexToHsl,
-  hexToHsv,
-  hexToHwb,
-  hexToRgb,
-  hslToHex,
-  hslToRgb,
-  hsvToHex,
-  hsvToRgb,
-  hwbToHex,
-  hwbToRgb,
-  mix,
-  rgbToHex,
-  rgbToHsl,
-  rgbToHsv,
-  rgbToHwb,
-  rgbToXyz,
-  xyzToLab,
-} from '@/color';
-import { expect, test } from 'vitest';
-
-test('颜色值转换', () => {
-  expect(hexToRgb('#00ff00')).toEqual<RGB>({ r: 0, g: 255, b: 0 });
-  expect(hexToRgb('#f5222d')).toEqual<RGB>({ r: 245, g: 34, b: 45 });
-  expect(rgbToHex({ r: 245, g: 34, b: 45 })).toEqual('#f5222d');
-
-  expect(rgbToHsv({ r: 245, g: 34, b: 45 })).toEqual<HSV>({
-    h: 356.87203791469193,
-    s: 86.12244897959184,
-    v: 96.07843137254902,
-  });
-  expect(hsvToRgb({ h: 357, s: 86, v: 96 })).toEqual<RGB>({
-    r: 244.79999999999998,
-    g: 34.272000000000006,
-    b: 44.79839999999996,
-  });
-
-  expect(hexToHsv('#f5222d')).toEqual<HSV>({
-    h: 356.87203791469193,
-    s: 86.12244897959184,
-    v: 96.07843137254902,
-  });
-  expect(
-    hsvToHex({
-      h: 356.87203791469193,
-      s: 86.12244897959184,
-      v: 96.07843137254902,
-    }),
-  ).toEqual('#f5222d');
-
-  expect(
-    rgbToHsl({
-      r: 245,
-      g: 34,
-      b: 45,
-    }),
-  ).toEqual<HSL>({
-    h: 356.87203791469193,
-    l: 54.70588235294118,
-    s: 91.34199134199136,
-  });
-  expect(
-    hslToRgb({
-      h: 356.87203791469193,
-      l: 54.70588235294118,
-      s: 91.34199134199136,
-    }),
-  ).toEqual<RGB>({
-    r: 245.00000000000003,
-    g: 34.00000000000001,
-    b: 45.00000000000001,
-  });
-
-  expect(
-    rgbToHsl({
-      r: 0,
-      g: 100,
-      b: 213,
-    }),
-  ).toEqual<HSL>({
-    h: 211.83098591549296,
-    s: 100,
-    l: 41.76470588235294,
-  });
-  expect(hexToHsl('#123456')).toEqual<HSL>({
-    h: 210,
-    s: 65.3846153846154,
-    l: 20.392156862745097,
-  });
-  expect(
-    hslToHex({
-      h: 210,
-      s: 65,
-      l: 20,
-    }),
-  ).toEqual<HEX>('#123354');
-
-  expect(
-    rgbToHwb({
-      r: 12,
-      g: 34,
-      b: 56,
-    }),
-  ).toEqual<HWB>({
-    h: 210,
-    w: 4.705882352941177,
-    b: 78.03921568627452,
-  });
-  expect(
-    hwbToRgb({
-      h: 210,
-      w: 4.705882352941177,
-      b: 78.03921568627452,
-    }),
-  ).toEqual<RGB>({
-    r: 12,
-    g: 33.99999999999998,
-    b: 55.99999999999996,
-  });
-
-  expect(hexToHwb('#fedcba')).toEqual<HWB>({
-    h: 30.000000000000014,
-    w: 72.94117647058823,
-    b: 0.39215686274509665,
-  });
-  expect(
-    hwbToHex({
-      h: 30.000000000000014,
-      w: 72.94117647058823,
-      b: 0.39215686274509665,
-    }),
-  ).toEqual<HEX>('#fedcba');
-});
-
-test('mix', () => {
-  expect(rgbToHex(mix(hexToRgb('#00ff00'), hexToRgb('#ff0000')))).toEqual('#808000');
-  expect(hsvToHex(mix(hexToHsv('#00ff00'), hexToHsv('#ff0000')))).toEqual('#ffff00');
-});
-
-test('lab', () => {
-  const color1 = '#9ea9b5';
-  const color2 = '#8592a1';
-
-  const rgb1 = hexToRgb(color1);
-  const rgb2 = hexToRgb(color2);
-
-  const xyz1 = rgbToXyz(rgb1);
-  const xyz2 = rgbToXyz(rgb2);
-
-  const lab1 = xyzToLab(xyz1);
-  const lab2 = xyzToLab(xyz2);
-
-  const d = distance(lab1, lab2);
-
-  // console.log(lab1);
-  // console.log(lab2);
-  // console.log(d);
-
-  expect(d).toBeLessThan(1);
-  expect(d).toBeGreaterThan(0);
-});

package/test/crypto.test.ts

@@ -1,34 +0,0 @@
-import { md5String, sha1String, sha256String, sha512String } from '@/crypto';
-import { describe, expect, it } from 'vitest';
-
-describe('crypto', () => {
-  it('md5String 应正确计算 MD5 哈希值', () => {
-    expect(md5String('hello world')).toBe('5eb63bbbe01eeed093cb22bb8f5acdc3');
-    expect(md5String('')).toBe('d41d8cd98f00b204e9800998ecf8427e');
-    expect(md5String('123456')).toBe('e10adc3949ba59abbe56e057f20f883e');
-  });
-
-  it('sha1String 应正确计算 SHA1 哈希值', () => {
-    expect(sha1String('hello world')).toBe('2aae6c35c94fcfb415dbe95f408b9ce91ee846ed');
-    expect(sha1String('')).toBe('da39a3ee5e6b4b0d3255bfef95601890afd80709');
-    expect(sha1String('123456')).toBe('7c4a8d09ca3762af61e59520943dc26494f8941b');
-  });
-
-  it('sha256String 应正确计算 SHA256 哈希值', () => {
-    expect(sha256String('hello world')).toBe('b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9');
-    expect(sha256String('')).toBe('e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855');
-    expect(sha256String('123456')).toBe('8d969eef6ecad3c29a3a629280e686cf0c3f5d5a86aff3ca12020c923adc6c92');
-  });
-
-  it('sha512String 应正确计算 SHA512 哈希值', () => {
-    expect(sha512String('hello world')).toBe(
-      '309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f989dd35bc5ff499670da34255b45b0cfd830e81f605dcf7dc5542e93ae9cd76f',
-    );
-    expect(sha512String('')).toBe(
-      'cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e',
-    );
-    expect(sha512String('123456')).toBe(
-      'ba3253876aed6bc22d4a6ff53d8406c6ad864195ed144ab5c87621b6c233b548baeae6956df346ec8c17f5ea10f35ee3cbc514797ed7ddd3145464e2a0bab413',
-    );
-  });
-});