thepaperpilot/Advent-Incremental
1
0
Fork 0
mirror of https://github.com/thepaperpilot/Advent-Incremental.git synced 2024-12-03 21:31:31 +00:00
Code Issues Releases Activity Actions
Advent-Incremental/tests/game/formulas.test.ts

450 lines
18 KiB
TypeScript
Raw Blame History

import Formula, { FormulaSource, InvertibleFormula } from "game/formulas";
import Decimal, { DecimalSource, format } from "util/bignum";
import { beforeAll, describe, expect, test, vi } from "vitest";
import { ref } from "vue";
type FormulaFunctions = keyof Formula & keyof typeof Formula & keyof typeof Decimal;
interface FixedLengthArray<T, L extends number> extends ArrayLike<T> {
length: L;
}
expect.extend({
compare_tolerance(received, expected) {
const { isNot } = this;
return {
// do not alter your "pass" based on isNot. Vitest does it for you
pass: Decimal.eq_tolerance(received, expected),
message: () =>
`Expected ${received} to${
(isNot as boolean) ? " not" : ""
} be close to ${expected}`,
expected: format(expected),
actual: format(received)
};
}
});
interface CustomMatchers<R = unknown> {
compare_tolerance(expected: DecimalSource): R;
}
declare global {
// eslint-disable-next-line @typescript-eslint/no-namespace
namespace Vi {
// eslint-disable-next-line @typescript-eslint/no-empty-interface
interface Assertion extends CustomMatchers {}
// eslint-disable-next-line @typescript-eslint/no-empty-interface
interface AsymmetricMatchersContaining extends CustomMatchers {}
}
}
function testConstant(
desc: string,
formulaFunc: () => InvertibleFormula,
expectedValue: DecimalSource = 10
) {
describe(desc, () => {
let formula: Formula;
beforeAll(() => {
formula = formulaFunc();
});
test("evaluates correctly", async () =>
expect(formula.evaluate()).compare_tolerance(expectedValue));
test("invert is pass-through", async () =>
expect(formula.invert(25)).compare_tolerance(25));
test("is invertible", async () => expect(formula.invertible).toBe(true));
test("is not marked as having a variable", async () =>
expect(formula.hasVariable).toBe(false));
});
}
// Utility function that will test all the different
// It's a lot of tests, but I'd rather be exhaustive
function testFormula<T extends FormulaFunctions>(
functionName: T,
args: Readonly<FixedLengthArray<number, Parameters<typeof Formula[T]>["length"]>>,
invertible = true
) {
let value: Decimal;
beforeAll(() => {
value = testValueFormulas[args[0]].evaluate();
});
let testName = functionName + "(";
for (let i = 0; i < args.length; i++) {
if (i !== 0) {
testName += ", ";
}
testName += testValues[args[i]];
}
testName += ")";
describe(testName, () => {
let expectedEvaluation: Decimal | undefined;
const formulaArgs: Formula[] = [];
let staticFormula: Formula;
let instanceFormula: Formula;
beforeAll(() => {
for (let i = 0; i < args.length; i++) {
formulaArgs.push(testValueFormulas[args[i]]);
}
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
staticFormula = Formula[functionName](...formulaArgs);
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
instanceFormula = formulaArgs[0][functionName](...formulaArgs.slice(1));
try {
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
expectedEvaluation = Decimal[functionName](...args);
} catch {
// If this is an invalid Decimal operation, then ignore this test case
return;
}
});
test("Static formula is not marked as having a variable", async () =>
expect(staticFormula.hasVariable).toBe(false));
test("Static function evaluates correctly", async () =>
expectedEvaluation != null &&
expect(staticFormula.evaluate()).compare_tolerance(expectedEvaluation));
test("Static function invertible", async () =>
expect(staticFormula.invertible).toBe(invertible));
if (invertible) {
test("Static function inverts correctly", async () =>
expectedEvaluation != null &&
!Decimal.isNaN(expectedEvaluation) &&
expect(staticFormula.invert(expectedEvaluation)).compare_tolerance(value));
}
// Do those tests again but for non-static methods
test("Instance formula is not marked as having a variable", async () =>
expect(instanceFormula.hasVariable).toBe(false));
test("Instance function evaluates correctly", async () =>
expectedEvaluation != null &&
expect(instanceFormula.evaluate()).compare_tolerance(expectedEvaluation));
test("Instance function invertible", async () =>
expect(instanceFormula.invertible).toBe(invertible));
if (invertible) {
test("Instance function inverts correctly", async () =>
expectedEvaluation != null &&
!Decimal.isNaN(expectedEvaluation) &&
expect(instanceFormula.invert(expectedEvaluation)).compare_tolerance(value));
}
});
}
function testAliases<T extends FormulaFunctions[]>(
formula: Formula,
aliases: T,
args: FormulaSource[]
) {
const spy = vi.spyOn(formula, aliases[0]);
expect(spy).not.toHaveBeenCalled();
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
aliases.slice(1).forEach(name => formula[name](...args));
expect(spy).toHaveBeenCalledTimes(aliases.length - 1);
}
const testValues = [-2.5, -1, -0.1, 0, 0.1, 1, 2.5] as const;
let testValueFormulas: InvertibleFormula[] = [];
const invertibleZeroParamFunctionNames = [
"neg",
"recip",
"log10",
"log2",
"ln",
"pow10",
"exp",
"sqr",
"sqrt",
"cube",
"cbrt",
"lambertw",
"ssqrt",
"sin",
"cos",
"tan",
"asin",
"acos",
"atan",
"sinh",
"cosh",
"tanh",
"asinh",
"acosh",
"atanh"
] as const;
const nonInvertibleZeroParamFunctionNames = [
"abs",
"sign",
"round",
"floor",
"ceil",
"trunc",
"pLog10",
"absLog10",
"factorial",
"gamma",
"lngamma"
] as const;
const invertibleOneParamFunctionNames = [
"add",
"sub",
"mul",
"div",
"log",
"pow",
"root",
"slog"
] as const;
const nonInvertibleOneParamFunctionNames = [
"max",
"min",
"maxabs",
"minabs",
"clampMin",
"clampMax",
"layeradd10"
] as const;
const invertibleTwoParamFunctionNames = ["tetrate", "layeradd", "iteratedexp"] as const;
const nonInvertibleTwoParamFunctionNames = ["clamp", "iteratedlog", "pentate"] as const;
describe.concurrent("Creating Formulas", () => {
beforeAll(() => {
testValueFormulas = testValues.map(v => Formula.constant(v));
});
describe("Constants", () => {
testConstant("number", () => Formula.constant(10));
testConstant("string", () => Formula.constant("10"));
testConstant("formula", () => Formula.constant(Formula.constant(10)));
testConstant("decimal", () => Formula.constant(new Decimal("1e400")), "1e400");
testConstant("ref", () => Formula.constant(ref(10)));
});
// Test that these are just pass-throughts so we don't need to test each one everywhere else
describe("Function aliases", () => {
let formula: Formula;
beforeAll(() => {
formula = Formula.constant(10);
});
test("neg", async () => testAliases(formula, ["neg", "negate", "negated"], [0]));
test("recip", async () =>
testAliases(formula, ["recip", "reciprocal", "reciprocate"], [0]));
test("sign", async () => testAliases(formula, ["sign", "sgn"], [0]));
test("add", async () => testAliases(formula, ["add", "plus"], [0]));
test("sub", async () => testAliases(formula, ["sub", "subtract", "minus"], [0]));
test("mul", async () => testAliases(formula, ["mul", "multiply", "times"], [0]));
test("div", async () => testAliases(formula, ["div", "divide"], [1]));
test("log", async () => testAliases(formula, ["log", "logarithm"], [0]));
});
describe("Invertible 0-param", () => {
invertibleZeroParamFunctionNames.forEach(names => {
for (let i = 0; i < testValues.length; i++) {
testFormula(names, [i] as const);
}
});
});
describe("Non-Invertible 0-param", () => {
nonInvertibleZeroParamFunctionNames.forEach(names => {
for (let i = 0; i < testValues.length; i++) {
testFormula(names, [i] as const, false);
}
});
});
describe("Invertible 1-param", () => {
invertibleOneParamFunctionNames.forEach(names => {
for (let i = 0; i < testValues.length; i++) {
for (let j = 0; j < testValues.length; j++) {
testFormula(names, [i, j] as const);
}
}
});
});
describe("Non-Invertible 1-param", () => {
nonInvertibleOneParamFunctionNames.forEach(names => {
for (let i = 0; i < testValues.length; i++) {
for (let j = 0; j < testValues.length; j++) {
testFormula(names, [i, j] as const, false);
}
}
});
});
describe("Invertible 2-param", () => {
invertibleTwoParamFunctionNames.forEach(names => {
for (let i = 0; i < testValues.length; i++) {
for (let j = 0; j < testValues.length; j++) {
for (let k = 0; k < testValues.length; k++) {
testFormula(names, [i, j, k] as const);
}
}
}
});
});
describe("Non-Invertible 2-param", () => {
nonInvertibleTwoParamFunctionNames.forEach(names => {
for (let i = 0; i < testValues.length; i++) {
for (let j = 0; j < testValues.length; j++) {
for (let k = 0; k < testValues.length; k++) {
testFormula(names, [i, j, k] as const, false);
}
}
}
});
});
});
describe("Variables", () => {
let variable: Formula;
let constant: Formula;
beforeAll(() => {
variable = Formula.variable(10);
constant = Formula.constant(10);
});
test("Created variable is marked as a variable", () => expect(variable.hasVariable).toBe(true));
test("Evaluate() returns variable's value", () =>
expect(variable.evaluate()).compare_tolerance(10));
test("Invert() is pass-through", () => expect(variable.invert(100)).compare_tolerance(100));
test("Nested variable is marked as having a variable", () =>
expect(variable.add(10).div(3).pow(2).hasVariable).toBe(true));
test("Nested non-variable is marked as not having a variable", () =>
expect(constant.add(10).div(3).pow(2).hasVariable).toBe(false));
describe("Invertible Formulas correctly calculate when they contain a variable", () => {
function checkFormula(formula: Formula, expectedBool = true) {
expect(formula.invertible).toBe(expectedBool);
expect(formula.hasVariable).toBe(expectedBool);
}
invertibleZeroParamFunctionNames.forEach(name => {
describe(name, () => {
test(`${name}(var) is marked as invertible and having a variable`, () =>
checkFormula(Formula[name](variable)));
});
});
invertibleOneParamFunctionNames.forEach(name => {
describe(name, () => {
test(`${name}(var, const) is marked as invertible and having a variable`, () =>
checkFormula(Formula[name](variable, constant)));
test(`${name}(const, var) is marked as invertible and having a variable`, () =>
checkFormula(Formula[name](constant, variable)));
test(`${name}(var, var) is marked as not invertible and not having a variable`, () =>
checkFormula(Formula[name](variable, variable), false));
});
});
invertibleTwoParamFunctionNames.forEach(name => {
describe(name, () => {
test(`${name}(var, const, const) is marked as invertible and having a variable`, () =>
checkFormula(Formula[name](variable, constant, constant)));
test(`${name}(const, var, const) is marked as invertible and having a variable`, () =>
checkFormula(Formula[name](constant, variable, constant)));
test(`${name}(const, const, var) is marked as invertible and having a variable`, () =>
checkFormula(Formula[name](constant, constant, variable)));
test(`${name}(var, var, const) is marked as not invertible and not having a variable`, () =>
checkFormula(Formula[name](variable, variable, constant), false));
test(`${name}(var, const, var) is marked as not invertible and not having a variable`, () =>
checkFormula(Formula[name](variable, constant, variable), false));
test(`${name}(const, var, var) is marked as not invertible and not having a variable`, () =>
checkFormula(Formula[name](constant, variable, variable), false));
test(`${name}(var, var, var) is marked as not invertible and not having a variable`, () =>
checkFormula(Formula[name](variable, variable, variable), false));
});
});
});
describe("Non-Invertible Formulas never marked as having a variable", () => {
function checkFormula(formula: Formula) {
expect(formula.invertible).toBe(false);
expect(formula.hasVariable).toBe(false);
}
nonInvertibleZeroParamFunctionNames.forEach(name => {
describe(name, () => {
test(`${name}(var) is marked as not invertible and not having a variable`, () =>
checkFormula(Formula[name](variable)));
});
});
nonInvertibleOneParamFunctionNames.forEach(name => {
describe(name, () => {
test(`${name}(var, const) is marked as not invertible and not having a variable`, () =>
checkFormula(Formula[name](variable, constant)));
test(`${name}(const, var) is marked as not invertible and not having a variable`, () =>
checkFormula(Formula[name](constant, variable)));
test(`${name}(var, var) is marked as not invertible and not having a variable`, () =>
checkFormula(Formula[name](variable, variable)));
});
});
nonInvertibleTwoParamFunctionNames.forEach(name => {
describe(name, () => {
test(`${name}(var, const, const) is marked as not invertible and not having a variable`, () =>
checkFormula(Formula[name](variable, constant, constant)));
test(`${name}(const, var, const) is marked as not invertible and not having a variable`, () =>
checkFormula(Formula[name](constant, variable, constant)));
test(`${name}(const, const, var) is marked as not invertible and not having a variable`, () =>
checkFormula(Formula[name](constant, constant, variable)));
test(`${name}(var, var, const) is marked as not invertible and not having a variable`, () =>
checkFormula(Formula[name](variable, variable, constant)));
test(`${name}(var, const, var) is marked as not invertible and not having a variable`, () =>
checkFormula(Formula[name](variable, constant, variable)));
test(`${name}(const, var, var) is marked as not invertible and not having a variable`, () =>
checkFormula(Formula[name](constant, variable, variable)));
test(`${name}(var, var, var) is marked as not invertible and not having a variable`, () =>
checkFormula(Formula[name](variable, variable, variable)));
});
});
});
describe("Inverting calculates the value of the variable", () => {
let variable: Formula;
let constant: Formula;
beforeAll(() => {
variable = Formula.variable(2);
constant = Formula.constant(3);
});
invertibleOneParamFunctionNames.forEach(name =>
describe(name, () => {
test(`${name}(var, const).invert()`, () => {
const formula = Formula[name](variable, constant);
const result = formula.evaluate();
expect(formula.invert(result)).compare_tolerance(2);
});
test(`${name}(const, var).invert()`, () => {
const formula = Formula[name](constant, variable);
const result = formula.evaluate();
expect(formula.invert(result)).compare_tolerance(2);
});
})
);
invertibleTwoParamFunctionNames.forEach(name =>
describe(name, () => {
test(`${name}(var, const, const).invert()`, () => {
const formula = Formula[name](variable, constant, constant);
const result = formula.evaluate();
expect(formula.invert(result)).compare_tolerance(2);
});
test(`${name}(const, var, const).invert()`, () => {
const formula = Formula[name](constant, variable, constant);
const result = formula.evaluate();
expect(formula.invert(result)).compare_tolerance(2);
});
test(`${name}(const, const, var).invert()`, () => {
const formula = Formula[name](constant, constant, variable);
const result = formula.evaluate();
expect(formula.invert(result)).compare_tolerance(2);
});
})
);
});
});
Reference in a new issue View git blame Copy permalink