304 lines
9.3 KiB
TypeScript
304 lines
9.3 KiB
TypeScript
import { describe, it, expect } from 'bun:test';
|
|
import {
|
|
randInt,
|
|
randBool,
|
|
choice,
|
|
weightedChoice,
|
|
shuffle,
|
|
mapNumber,
|
|
zip,
|
|
enumerate,
|
|
range,
|
|
clamp,
|
|
lerp,
|
|
prevent,
|
|
intHash,
|
|
sinHash,
|
|
throttle,
|
|
callUpdater,
|
|
} from '@common/utils';
|
|
|
|
describe('utils', () => {
|
|
describe('randInt', () => {
|
|
it('should return a number within the specified range', () => {
|
|
for (let i = 0; i < 100; i++) {
|
|
const result = randInt(1, 10);
|
|
expect(result).toBeGreaterThanOrEqual(1);
|
|
expect(result).toBeLessThanOrEqual(10);
|
|
}
|
|
});
|
|
|
|
it('should return integers only (no floats)', () => {
|
|
for (let i = 0; i < 100; i++) {
|
|
const result = randInt(0, 100);
|
|
expect(Number.isInteger(result)).toBe(true);
|
|
}
|
|
});
|
|
|
|
it('should handle single value range', () => {
|
|
expect(randInt(5, 6)).toBe(5);
|
|
});
|
|
});
|
|
|
|
describe('randBool', () => {
|
|
it('should return boolean values', () => {
|
|
for (let i = 0; i < 100; i++) {
|
|
const result = randBool();
|
|
expect(typeof result).toBe('boolean');
|
|
}
|
|
});
|
|
|
|
it('should return both true and false over multiple calls', () => {
|
|
const results = new Set();
|
|
for (let i = 0; i < 100; i++) {
|
|
results.add(randBool());
|
|
}
|
|
expect(results.has(true)).toBe(true);
|
|
expect(results.has(false)).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('choice', () => {
|
|
it('should return an element from the array', () => {
|
|
const array = [1, 2, 3, 4, 5];
|
|
const result = choice(array);
|
|
expect(array).toContain(result);
|
|
});
|
|
|
|
it('should work with string arrays', () => {
|
|
const array = ['a', 'b', 'c'];
|
|
const result = choice(array);
|
|
expect(array).toContain(result);
|
|
});
|
|
|
|
it('should work with object arrays', () => {
|
|
const array = [{ id: 1 }, { id: 2 }, { id: 3 }];
|
|
const result = choice(array);
|
|
expect(array).toContain(result);
|
|
});
|
|
});
|
|
|
|
describe('weightedChoice', () => {
|
|
it('should return an item based on weights (array input)', () => {
|
|
const options: [number, number][] = [[1, 10], [2, 1], [3, 1]];
|
|
const results = new Set<number>();
|
|
for (let i = 0; i < 100; i++) {
|
|
const result = weightedChoice(options);
|
|
if (result !== null) results.add(result);
|
|
}
|
|
// Item 1 has much higher weight, should appear most often
|
|
expect(results.has(1)).toBe(true);
|
|
});
|
|
|
|
it('should return an item based on weights (object input)', () => {
|
|
const options = { a: 10, b: 1, c: 1 };
|
|
const results = new Set<string>();
|
|
for (let i = 0; i < 100; i++) {
|
|
const result = weightedChoice(options);
|
|
if (result !== null) results.add(result);
|
|
}
|
|
expect(results.has('a')).toBe(true);
|
|
});
|
|
|
|
it('should return null for empty options', () => {
|
|
expect(weightedChoice([])).toBe(null);
|
|
expect(weightedChoice({})).toBe(null);
|
|
});
|
|
});
|
|
|
|
describe('shuffle', () => {
|
|
it('should return an array of the same length', () => {
|
|
const array = [1, 2, 3, 4, 5];
|
|
const shuffled = shuffle(array);
|
|
expect(shuffled.length).toBe(array.length);
|
|
});
|
|
|
|
it('should contain the same elements', () => {
|
|
const array = [1, 2, 3, 4, 5];
|
|
const shuffled = shuffle(array);
|
|
expect(shuffled.sort((a, b) => a - b)).toEqual(array);
|
|
});
|
|
|
|
it('should not modify the original array', () => {
|
|
const array = [1, 2, 3, 4, 5];
|
|
const original = [...array];
|
|
shuffle(array);
|
|
expect(array).toEqual(original);
|
|
});
|
|
|
|
it('should handle empty arrays', () => {
|
|
expect(shuffle([])).toEqual([]);
|
|
});
|
|
|
|
it('should handle single element arrays', () => {
|
|
expect(shuffle([1])).toEqual([1]);
|
|
});
|
|
});
|
|
|
|
describe('mapNumber', () => {
|
|
it('should map a number from one range to another', () => {
|
|
expect(mapNumber(5, 0, 10, 0, 100)).toBe(50);
|
|
});
|
|
|
|
it('should handle reverse ranges', () => {
|
|
expect(mapNumber(5, 0, 10, 100, 0)).toBe(50);
|
|
});
|
|
|
|
it('should handle negative ranges', () => {
|
|
expect(mapNumber(0, -10, 10, 0, 100)).toBe(50);
|
|
});
|
|
});
|
|
|
|
describe('zip', () => {
|
|
it('should zip two arrays together', () => {
|
|
const result = [...zip([1, 2, 3], ['a', 'b', 'c'])];
|
|
expect(result).toEqual([[1, 'a'], [2, 'b'], [3, 'c']]);
|
|
});
|
|
|
|
it('should stop at the shortest array', () => {
|
|
const result = [...zip([1, 2], ['a', 'b', 'c', 'd'])];
|
|
expect(result).toEqual([[1, 'a'], [2, 'b']]);
|
|
});
|
|
|
|
it('should zip three arrays', () => {
|
|
const result = [...zip([1, 2], ['a', 'b'], [true, false])];
|
|
expect(result).toEqual([[1, 'a', true], [2, 'b', false]]);
|
|
});
|
|
|
|
it('should handle empty arrays', () => {
|
|
expect([...zip([], [])]).toEqual([]);
|
|
});
|
|
});
|
|
|
|
describe('enumerate', () => {
|
|
it('should enumerate an array with indices', () => {
|
|
const result = [...enumerate(['a', 'b', 'c'])];
|
|
expect(result).toEqual([[0, 'a'], [1, 'b'], [2, 'c']]);
|
|
});
|
|
|
|
it('should handle empty arrays', () => {
|
|
expect([...enumerate([])]).toEqual([]);
|
|
});
|
|
});
|
|
|
|
describe('range', () => {
|
|
it('should create a range from a number', () => {
|
|
expect(range(5)).toEqual([0, 1, 2, 3, 4]);
|
|
});
|
|
|
|
it('should create a range from a string number', () => {
|
|
expect(range('5')).toEqual([0, 1, 2, 3, 4]);
|
|
});
|
|
|
|
it('should return empty array for 0', () => {
|
|
expect(range(0)).toEqual([]);
|
|
});
|
|
});
|
|
|
|
describe('clamp', () => {
|
|
it('should clamp a value within range', () => {
|
|
expect(clamp(5, 0, 10)).toBe(5);
|
|
});
|
|
|
|
it('should clamp values below minimum', () => {
|
|
expect(clamp(-5, 0, 10)).toBe(0);
|
|
});
|
|
|
|
it('should clamp values above maximum', () => {
|
|
expect(clamp(15, 0, 10)).toBe(10);
|
|
});
|
|
});
|
|
|
|
describe('lerp', () => {
|
|
it('should linearly interpolate between two values', () => {
|
|
expect(lerp(0, 100, 0.5)).toBe(50);
|
|
});
|
|
|
|
it('should return start value at t=0', () => {
|
|
expect(lerp(0, 100, 0)).toBe(0);
|
|
});
|
|
|
|
it('should return end value at t=1', () => {
|
|
expect(lerp(0, 100, 1)).toBe(100);
|
|
});
|
|
|
|
it('should handle values outside 0-1 range', () => {
|
|
expect(lerp(0, 100, -0.5)).toBe(-50);
|
|
expect(lerp(0, 100, 1.5)).toBe(150);
|
|
});
|
|
});
|
|
|
|
describe('prevent', () => {
|
|
it('should call preventDefault and return false', () => {
|
|
let preventDefaultCalled = false;
|
|
const mockEvent = {
|
|
preventDefault: () => { preventDefaultCalled = true; }
|
|
} as Event;
|
|
const result = prevent(mockEvent);
|
|
expect(preventDefaultCalled).toBe(true);
|
|
expect(result).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('intHash', () => {
|
|
it('should return a number', () => {
|
|
expect(typeof intHash(1, 2, 3)).toBe('number');
|
|
});
|
|
|
|
it('should be deterministic', () => {
|
|
const hash1 = intHash(1, 2, 3);
|
|
const hash2 = intHash(1, 2, 3);
|
|
expect(hash1).toBe(hash2);
|
|
});
|
|
|
|
it('should produce different hashes for different inputs', () => {
|
|
const hash1 = intHash(1);
|
|
const hash2 = intHash(2);
|
|
expect(hash1).not.toBe(hash2);
|
|
});
|
|
});
|
|
|
|
describe('sinHash', () => {
|
|
it('should return a number between 0 and 1', () => {
|
|
const result = sinHash(1, 2, 3);
|
|
expect(result).toBeGreaterThanOrEqual(0);
|
|
expect(result).toBeLessThanOrEqual(1);
|
|
});
|
|
|
|
it('should be deterministic', () => {
|
|
const hash1 = sinHash(1, 2, 3);
|
|
const hash2 = sinHash(1, 2, 3);
|
|
expect(hash1).toBe(hash2);
|
|
});
|
|
});
|
|
|
|
describe('throttle', () => {
|
|
it('should call the function immediately', () => {
|
|
let callCount = 0;
|
|
const fn = throttle(() => { callCount++; }, 1000);
|
|
fn();
|
|
expect(callCount).toBe(1);
|
|
});
|
|
|
|
it('should throttle subsequent calls', () => {
|
|
let callCount = 0;
|
|
const fn = throttle(() => { callCount++; }, 1000);
|
|
fn();
|
|
fn();
|
|
fn();
|
|
expect(callCount).toBe(1);
|
|
});
|
|
});
|
|
|
|
describe('callUpdater', () => {
|
|
it('should call a function updater', () => {
|
|
const updater = (prev: number) => prev + 1;
|
|
expect(callUpdater(updater, 5)).toBe(6);
|
|
});
|
|
|
|
it('should return a direct value updater', () => {
|
|
expect(callUpdater(10, 5)).toBe(10);
|
|
});
|
|
});
|
|
});
|