364 lines
13 KiB
TypeScript
364 lines
13 KiB
TypeScript
import { describe, it, expect } from 'vitest'
|
||
import { DEFAULT_FUNCTIONS } from './functions'
|
||
|
||
describe('DEFAULT_FUNCTIONS', () => {
|
||
// ==================== Математические ====================
|
||
|
||
describe('СУММ', () => {
|
||
it('суммирует числа', () => {
|
||
expect(DEFAULT_FUNCTIONS.СУММ(1, 2, 3)).toBe(6)
|
||
})
|
||
it('суммирует массив', () => {
|
||
expect(DEFAULT_FUNCTIONS.СУММ([1, 2, 3])).toBe(6)
|
||
})
|
||
it('игнорирует не-числа', () => {
|
||
expect(DEFAULT_FUNCTIONS.СУММ(1, 'abc', 3)).toBe(4)
|
||
})
|
||
it('возвращает 0 без аргументов', () => {
|
||
expect(DEFAULT_FUNCTIONS.СУММ()).toBe(0)
|
||
})
|
||
})
|
||
|
||
describe('СРЗНАЧ', () => {
|
||
it('считает среднее', () => {
|
||
expect(DEFAULT_FUNCTIONS.СРЗНАЧ(2, 4, 6)).toBe(4)
|
||
})
|
||
it('игнорирует не-числа', () => {
|
||
expect(DEFAULT_FUNCTIONS.СРЗНАЧ(2, 'abc', 4)).toBe(3)
|
||
})
|
||
it('возвращает 0 если нет чисел', () => {
|
||
expect(DEFAULT_FUNCTIONS.СРЗНАЧ('a', 'b')).toBe(0)
|
||
})
|
||
})
|
||
|
||
describe('СЧЁТ', () => {
|
||
it('считает количество чисел', () => {
|
||
expect(DEFAULT_FUNCTIONS['СЧЁТ'](1, 'a', 2, null, 3)).toBe(3)
|
||
})
|
||
it('возвращает 0 без чисел', () => {
|
||
expect(DEFAULT_FUNCTIONS['СЧЁТ']('a', 'b')).toBe(0)
|
||
})
|
||
})
|
||
|
||
describe('МАКС', () => {
|
||
it('возвращает максимум из двух', () => {
|
||
expect(DEFAULT_FUNCTIONS.МАКС(3, 7)).toBe(7)
|
||
})
|
||
it('возвращает максимум из нескольких', () => {
|
||
expect(DEFAULT_FUNCTIONS.МАКС(3, 7, 100)).toBe(100)
|
||
})
|
||
it('работает с массивом', () => {
|
||
expect(DEFAULT_FUNCTIONS.МАКС([3, 7, 1])).toBe(7)
|
||
})
|
||
it('игнорирует не-числа', () => {
|
||
expect(DEFAULT_FUNCTIONS.МАКС('a' as any, 1)).toBe(1)
|
||
})
|
||
it('игнорирует Infinity', () => {
|
||
expect(DEFAULT_FUNCTIONS.МАКС(Infinity, 1)).toBe(1)
|
||
})
|
||
it('ошибка без валидных чисел', () => {
|
||
expect(DEFAULT_FUNCTIONS.МАКС('a' as any, 'b' as any)).toBe('#ЗНАЧ!')
|
||
})
|
||
})
|
||
|
||
describe('МИН', () => {
|
||
it('возвращает минимум', () => {
|
||
expect(DEFAULT_FUNCTIONS.МИН(3, 7, 1)).toBe(1)
|
||
})
|
||
it('работает с массивом', () => {
|
||
expect(DEFAULT_FUNCTIONS.МИН([3, 7, 1])).toBe(1)
|
||
})
|
||
it('возвращает 0 без чисел', () => {
|
||
expect(DEFAULT_FUNCTIONS.МИН('a', 'b')).toBe(0)
|
||
})
|
||
})
|
||
|
||
describe('ABS', () => {
|
||
it('возвращает модуль', () => {
|
||
expect(DEFAULT_FUNCTIONS.ABS(-5)).toBe(5)
|
||
expect(DEFAULT_FUNCTIONS.ABS(5)).toBe(5)
|
||
expect(DEFAULT_FUNCTIONS.ABS(0)).toBe(0)
|
||
})
|
||
it('ошибка при не-числе', () => {
|
||
expect(DEFAULT_FUNCTIONS.ABS('abc' as any)).toBe('#ЗНАЧ!')
|
||
})
|
||
it('ошибка при Infinity', () => {
|
||
expect(DEFAULT_FUNCTIONS.ABS(Infinity)).toBe('#ЧИСЛО!')
|
||
})
|
||
})
|
||
|
||
describe('КОРЕНЬ', () => {
|
||
it('возвращает корень', () => {
|
||
expect(DEFAULT_FUNCTIONS['КОРЕНЬ'](9)).toBe(3)
|
||
expect(DEFAULT_FUNCTIONS['КОРЕНЬ'](0)).toBe(0)
|
||
})
|
||
it('ошибка при отрицательном числе', () => {
|
||
expect(DEFAULT_FUNCTIONS['КОРЕНЬ'](-4)).toBe('#ЧИСЛО!')
|
||
})
|
||
it('ошибка при не-числе', () => {
|
||
expect(DEFAULT_FUNCTIONS['КОРЕНЬ']('abc' as any)).toBe('#ЗНАЧ!')
|
||
})
|
||
})
|
||
|
||
describe('СТЕПЕНЬ', () => {
|
||
it('возводит в степень', () => {
|
||
expect(DEFAULT_FUNCTIONS['СТЕПЕНЬ'](2, 3)).toBe(8)
|
||
expect(DEFAULT_FUNCTIONS['СТЕПЕНЬ'](5, 0)).toBe(1)
|
||
expect(DEFAULT_FUNCTIONS['СТЕПЕНЬ'](9, 0.5)).toBe(3)
|
||
})
|
||
it('ошибка при не-числе', () => {
|
||
expect(DEFAULT_FUNCTIONS['СТЕПЕНЬ']('a' as any, 2)).toBe('#ЗНАЧ!')
|
||
})
|
||
it('ошибка при Infinity', () => {
|
||
expect(DEFAULT_FUNCTIONS['СТЕПЕНЬ'](Infinity, 2)).toBe('#ЧИСЛО!')
|
||
})
|
||
it('ошибка при переполнении', () => {
|
||
expect(DEFAULT_FUNCTIONS['СТЕПЕНЬ'](10, 1000)).toBe('#ЧИСЛО!')
|
||
})
|
||
})
|
||
|
||
// ==================== Сравнение ====================
|
||
|
||
describe('БОЛЬШЕ', () => {
|
||
it('возвращает true когда первое больше', () => {
|
||
expect(DEFAULT_FUNCTIONS['БОЛЬШЕ'](5, 3)).toBe(true)
|
||
})
|
||
it('возвращает false когда первое меньше', () => {
|
||
expect(DEFAULT_FUNCTIONS['БОЛЬШЕ'](3, 5)).toBe(false)
|
||
})
|
||
it('возвращает false при равенстве', () => {
|
||
expect(DEFAULT_FUNCTIONS['БОЛЬШЕ'](5, 5)).toBe(false)
|
||
})
|
||
it('ошибка при не-числах', () => {
|
||
expect(DEFAULT_FUNCTIONS['БОЛЬШЕ']('a' as any, 1)).toBe('#ЗНАЧ!')
|
||
})
|
||
it('ошибка при Infinity', () => {
|
||
expect(DEFAULT_FUNCTIONS['БОЛЬШЕ'](Infinity, 1)).toBe('#ЧИСЛО!')
|
||
})
|
||
})
|
||
|
||
describe('МЕНЬШЕ', () => {
|
||
it('возвращает true когда первое меньше', () => {
|
||
expect(DEFAULT_FUNCTIONS['МЕНЬШЕ'](3, 5)).toBe(true)
|
||
})
|
||
it('возвращает false когда первое больше', () => {
|
||
expect(DEFAULT_FUNCTIONS['МЕНЬШЕ'](5, 3)).toBe(false)
|
||
})
|
||
it('возвращает false при равенстве', () => {
|
||
expect(DEFAULT_FUNCTIONS['МЕНЬШЕ'](5, 5)).toBe(false)
|
||
})
|
||
it('ошибка при не-числах', () => {
|
||
expect(DEFAULT_FUNCTIONS['МЕНЬШЕ']('a' as any, 1)).toBe('#ЗНАЧ!')
|
||
})
|
||
})
|
||
|
||
describe('ЕПУСТО', () => {
|
||
it('true для null', () => {
|
||
expect(DEFAULT_FUNCTIONS['ЕПУСТО'](null)).toBe(true)
|
||
})
|
||
it('true для undefined', () => {
|
||
expect(DEFAULT_FUNCTIONS['ЕПУСТО'](undefined)).toBe(true)
|
||
})
|
||
it('true для пустой строки', () => {
|
||
expect(DEFAULT_FUNCTIONS['ЕПУСТО']('')).toBe(true)
|
||
})
|
||
it('false для числа', () => {
|
||
expect(DEFAULT_FUNCTIONS['ЕПУСТО'](0)).toBe(false)
|
||
})
|
||
it('false для строки', () => {
|
||
expect(DEFAULT_FUNCTIONS['ЕПУСТО']('текст')).toBe(false)
|
||
})
|
||
it('false для false', () => {
|
||
expect(DEFAULT_FUNCTIONS['ЕПУСТО'](false)).toBe(false)
|
||
})
|
||
})
|
||
|
||
// ==================== Логические ====================
|
||
|
||
describe('ЕСЛИ', () => {
|
||
it('возвращает значение при истине', () => {
|
||
expect(DEFAULT_FUNCTIONS['ЕСЛИ'](true, 'да', 'нет')).toBe('да')
|
||
})
|
||
it('возвращает значение при лжи', () => {
|
||
expect(DEFAULT_FUNCTIONS['ЕСЛИ'](false, 'да', 'нет')).toBe('нет')
|
||
})
|
||
})
|
||
|
||
describe('И', () => {
|
||
it('true когда все true', () => {
|
||
expect(DEFAULT_FUNCTIONS['И'](true, true, true)).toBe(true)
|
||
})
|
||
it('false когда хоть один false', () => {
|
||
expect(DEFAULT_FUNCTIONS['И'](true, false, true)).toBe(false)
|
||
})
|
||
})
|
||
|
||
describe('ИЛИ', () => {
|
||
it('true когда хоть один true', () => {
|
||
expect(DEFAULT_FUNCTIONS['ИЛИ'](false, true, false)).toBe(true)
|
||
})
|
||
it('false когда все false', () => {
|
||
expect(DEFAULT_FUNCTIONS['ИЛИ'](false, false, false)).toBe(false)
|
||
})
|
||
})
|
||
|
||
describe('НЕ', () => {
|
||
it('инвертирует true', () => {
|
||
expect(DEFAULT_FUNCTIONS['НЕ'](true)).toBe(false)
|
||
})
|
||
it('инвертирует false', () => {
|
||
expect(DEFAULT_FUNCTIONS['НЕ'](false)).toBe(true)
|
||
})
|
||
})
|
||
|
||
// ==================== Строковые ====================
|
||
|
||
describe('СЦЕПИТЬ', () => {
|
||
it('объединяет строки', () => {
|
||
expect(DEFAULT_FUNCTIONS['СЦЕПИТЬ']('Привет', ' ', 'мир')).toBe(
|
||
'Привет мир'
|
||
)
|
||
})
|
||
})
|
||
|
||
describe('ДЛСТР', () => {
|
||
it('возвращает длину строки', () => {
|
||
expect(DEFAULT_FUNCTIONS['ДЛСТР']('hello')).toBe(5)
|
||
})
|
||
it('возвращает 0 для пустого', () => {
|
||
expect(DEFAULT_FUNCTIONS['ДЛСТР']('')).toBe(0)
|
||
})
|
||
})
|
||
|
||
describe('ПРОПИСН', () => {
|
||
it('переводит в верхний регистр', () => {
|
||
expect(DEFAULT_FUNCTIONS['ПРОПИСН']('hello')).toBe('HELLO')
|
||
})
|
||
})
|
||
|
||
describe('СТРОЧН', () => {
|
||
it('переводит в нижний регистр', () => {
|
||
expect(DEFAULT_FUNCTIONS['СТРОЧН']('HELLO')).toBe('hello')
|
||
})
|
||
})
|
||
|
||
describe('СЖПРОБЕЛЫ', () => {
|
||
it('удаляет пробелы по краям', () => {
|
||
expect(DEFAULT_FUNCTIONS['СЖПРОБЕЛЫ'](' hello ')).toBe('hello')
|
||
})
|
||
})
|
||
|
||
// ==================== Округление ====================
|
||
|
||
describe('ОКРУГЛ', () => {
|
||
it('округляет до целого', () => {
|
||
expect(DEFAULT_FUNCTIONS['ОКРУГЛ'](3.7)).toBe(4)
|
||
expect(DEFAULT_FUNCTIONS['ОКРУГЛ'](3.2)).toBe(3)
|
||
})
|
||
it('округляет до разрядов', () => {
|
||
expect(DEFAULT_FUNCTIONS['ОКРУГЛ'](3.456, 2)).toBe(3.46)
|
||
})
|
||
})
|
||
|
||
describe('ОКРУГЛВВЕРХ', () => {
|
||
it('округляет вверх', () => {
|
||
expect(DEFAULT_FUNCTIONS['ОКРУГЛВВЕРХ'](3.1)).toBe(4)
|
||
})
|
||
it('округляет вверх с разрядами', () => {
|
||
expect(DEFAULT_FUNCTIONS['ОКРУГЛВВЕРХ'](3.411, 1)).toBe(3.5)
|
||
})
|
||
})
|
||
|
||
describe('ОКРУГЛВНИЗ', () => {
|
||
it('округляет вниз', () => {
|
||
expect(DEFAULT_FUNCTIONS['ОКРУГЛВНИЗ'](3.9)).toBe(3)
|
||
})
|
||
})
|
||
|
||
describe('ОКРВВЕРХ', () => {
|
||
it('округляет вверх до кратного', () => {
|
||
expect(DEFAULT_FUNCTIONS['ОКРВВЕРХ'](7, 5)).toBe(10)
|
||
})
|
||
it('возвращает 0 при кратном 0', () => {
|
||
expect(DEFAULT_FUNCTIONS['ОКРВВЕРХ'](7, 0)).toBe(0)
|
||
})
|
||
})
|
||
|
||
describe('ОКРВНИЗ', () => {
|
||
it('округляет вниз до кратного', () => {
|
||
expect(DEFAULT_FUNCTIONS['ОКРВНИЗ'](7, 5)).toBe(5)
|
||
})
|
||
})
|
||
|
||
describe('ЦЕЛОЕ', () => {
|
||
it('отбрасывает дробную часть вниз', () => {
|
||
expect(DEFAULT_FUNCTIONS['ЦЕЛОЕ'](3.9)).toBe(3)
|
||
expect(DEFAULT_FUNCTIONS['ЦЕЛОЕ'](-3.1)).toBe(-4)
|
||
})
|
||
})
|
||
|
||
describe('ОТБР', () => {
|
||
it('отбрасывает дробную часть', () => {
|
||
expect(DEFAULT_FUNCTIONS['ОТБР'](3.9)).toBe(3)
|
||
expect(DEFAULT_FUNCTIONS['ОТБР'](-3.9)).toBe(-3)
|
||
})
|
||
it('с разрядами', () => {
|
||
expect(DEFAULT_FUNCTIONS['ОТБР'](3.456, 2)).toBe(3.45)
|
||
})
|
||
})
|
||
|
||
describe('ОКРУГЛТ', () => {
|
||
it('округляет до кратного', () => {
|
||
expect(DEFAULT_FUNCTIONS['ОКРУГЛТ'](7, 5)).toBe(5)
|
||
expect(DEFAULT_FUNCTIONS['ОКРУГЛТ'](8, 5)).toBe(10)
|
||
})
|
||
it('возвращает 0 при кратном 0', () => {
|
||
expect(DEFAULT_FUNCTIONS['ОКРУГЛТ'](7, 0)).toBe(0)
|
||
})
|
||
})
|
||
|
||
// ==================== Случайные ====================
|
||
|
||
describe('СЛУЧ', () => {
|
||
it('возвращает число от 0 до 1', () => {
|
||
const result = DEFAULT_FUNCTIONS['СЛУЧ']()
|
||
expect(result).toBeGreaterThanOrEqual(0)
|
||
expect(result).toBeLessThan(1)
|
||
})
|
||
})
|
||
|
||
describe('СЛУЧМЕЖДУ', () => {
|
||
it('возвращает целое число в диапазоне', () => {
|
||
for (let i = 0; i < 20; i++) {
|
||
const result = DEFAULT_FUNCTIONS['СЛУЧМЕЖДУ'](1, 10) as number
|
||
expect(result).toBeGreaterThanOrEqual(1)
|
||
expect(result).toBeLessThanOrEqual(10)
|
||
expect(Number.isInteger(result)).toBe(true)
|
||
}
|
||
})
|
||
})
|
||
|
||
describe('СЛУЧДР', () => {
|
||
it('возвращает число в диапазоне', () => {
|
||
for (let i = 0; i < 20; i++) {
|
||
const result = DEFAULT_FUNCTIONS['СЛУЧДР'](1, 10, 2) as number
|
||
expect(result).toBeGreaterThanOrEqual(1)
|
||
expect(result).toBeLessThanOrEqual(10)
|
||
}
|
||
})
|
||
it('ошибка при не-числах', () => {
|
||
expect(DEFAULT_FUNCTIONS['СЛУЧДР']('a' as any, 10, 2)).toBe('#ЗНАЧ!')
|
||
})
|
||
it('ошибка при Infinity', () => {
|
||
expect(DEFAULT_FUNCTIONS['СЛУЧДР'](Infinity, 10, 2)).toBe('#ЧИСЛО!')
|
||
})
|
||
it('меняет местами если низ > верх', () => {
|
||
for (let i = 0; i < 20; i++) {
|
||
const result = DEFAULT_FUNCTIONS['СЛУЧДР'](10, 1, 0) as number
|
||
expect(result).toBeGreaterThanOrEqual(1)
|
||
expect(result).toBeLessThanOrEqual(10)
|
||
}
|
||
})
|
||
})
|
||
})
|