initial commit
This commit is contained in:
288
java/expression/ExpressionTester.java
Normal file
288
java/expression/ExpressionTester.java
Normal file
@@ -0,0 +1,288 @@
|
||||
package expression;
|
||||
|
||||
import base.*;
|
||||
import expression.common.*;
|
||||
|
||||
import java.lang.reflect.Constructor;
|
||||
import java.lang.reflect.Modifier;
|
||||
import java.util.*;
|
||||
import java.util.function.BinaryOperator;
|
||||
import java.util.function.Function;
|
||||
import java.util.stream.Collectors;
|
||||
import java.util.stream.IntStream;
|
||||
import java.util.stream.Stream;
|
||||
|
||||
import static base.Asserts.assertTrue;
|
||||
|
||||
/**
|
||||
* @author Georgiy Korneev (kgeorgiy@kgeorgiy.info)
|
||||
*/
|
||||
public class ExpressionTester<E extends ToMiniString, C> extends Tester {
|
||||
private final List<Integer> VALUES = IntStream.rangeClosed(-10, 10).boxed().toList();
|
||||
private final ExpressionKind<E, C> kind;
|
||||
|
||||
private final List<Test> basic = new ArrayList<>();
|
||||
private final List<Test> advanced = new ArrayList<>();
|
||||
private final Set<String> used = new HashSet<>();
|
||||
private final GeneratorBuilder generator;
|
||||
|
||||
private final List<Pair<ToMiniString, String>> prev = new ArrayList<>();
|
||||
private final Map<String, C> mappings;
|
||||
|
||||
protected ExpressionTester(
|
||||
final TestCounter counter,
|
||||
final ExpressionKind<E, C> kind,
|
||||
final Function<C, E> expectedConstant,
|
||||
final Binary<C, E> binary,
|
||||
final BinaryOperator<C> add,
|
||||
final BinaryOperator<C> sub,
|
||||
final BinaryOperator<C> mul,
|
||||
final BinaryOperator<C> div,
|
||||
final Map<String, C> mappings
|
||||
) {
|
||||
super(counter);
|
||||
this.kind = kind;
|
||||
this.mappings = mappings;
|
||||
|
||||
generator = new GeneratorBuilder(expectedConstant, kind::constant, binary, kind::randomValue);
|
||||
generator.binary("+", 1600, add, Add.class);
|
||||
generator.binary("-", 1602, sub, Subtract.class);
|
||||
generator.binary("*", 2001, mul, Multiply.class);
|
||||
generator.binary("/", 2002, div, Divide.class);
|
||||
}
|
||||
|
||||
protected ExpressionTester(
|
||||
final TestCounter counter,
|
||||
final ExpressionKind<E, C> kind,
|
||||
final Function<C, E> expectedConstant,
|
||||
final Binary<C, E> binary,
|
||||
final BinaryOperator<C> add,
|
||||
final BinaryOperator<C> sub,
|
||||
final BinaryOperator<C> mul,
|
||||
final BinaryOperator<C> div
|
||||
) {
|
||||
this(counter, kind, expectedConstant, binary, add, sub, mul, div, Map.of());
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return kind.getName();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void test() {
|
||||
counter.scope("Basic tests", () -> basic.forEach(Test::test));
|
||||
counter.scope("Advanced tests", () -> advanced.forEach(Test::test));
|
||||
counter.scope("Random tests", generator::testRandom);
|
||||
}
|
||||
|
||||
@SuppressWarnings({"ConstantValue", "EqualsWithItself"})
|
||||
private void checkEqualsAndToString(final String full, final String mini, final ToMiniString expression, final ToMiniString copy) {
|
||||
checkToString("toString", full, expression.toString());
|
||||
if (mode() > 0) {
|
||||
checkToString("toMiniString", mini, expression.toMiniString());
|
||||
}
|
||||
|
||||
counter.test(() -> {
|
||||
assertTrue("Equals to this", expression.equals(expression));
|
||||
assertTrue("Equals to copy", expression.equals(copy));
|
||||
assertTrue("Equals to null", !expression.equals(null));
|
||||
assertTrue("Copy equals to null", !copy.equals(null));
|
||||
});
|
||||
|
||||
final String expressionToString = Objects.requireNonNull(expression.toString());
|
||||
for (final Pair<ToMiniString, String> pair : prev) {
|
||||
counter.test(() -> {
|
||||
final ToMiniString prev = pair.first();
|
||||
final String prevToString = pair.second();
|
||||
final boolean equals = prevToString.equals(expressionToString);
|
||||
assertTrue("Equals to " + prevToString, prev.equals(expression) == equals);
|
||||
assertTrue("Equals to " + prevToString, expression.equals(prev) == equals);
|
||||
assertTrue("Inconsistent hashCode for " + prev + " and " + expression, (prev.hashCode() == expression.hashCode()) == equals);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
private void checkToString(final String method, final String expected, final String actual) {
|
||||
counter.test(() -> assertTrue(String.format("Invalid %s\n expected: %s\n actual: %s", method, expected, actual), expected.equals(actual)));
|
||||
}
|
||||
|
||||
private void check(
|
||||
final String full,
|
||||
final E expected,
|
||||
final E actual,
|
||||
final List<String> variables,
|
||||
final List<C> values
|
||||
) {
|
||||
final String vars = IntStream.range(0, variables.size())
|
||||
.mapToObj(i -> variables.get(i) + "=" + values.get(i))
|
||||
.collect(Collectors.joining(","));
|
||||
counter.test(() -> {
|
||||
final Object expectedResult = evaluate(expected, variables, values);
|
||||
final Object actualResult = evaluate(actual, variables, values);
|
||||
final String reason = String.format(
|
||||
"%s:%n expected `%s`,%n actual `%s`",
|
||||
String.format("f(%s)\nwhere f is %s", vars, full),
|
||||
Asserts.toString(expectedResult),
|
||||
Asserts.toString(actualResult)
|
||||
);
|
||||
if (
|
||||
expectedResult != null && actualResult != null &&
|
||||
expectedResult.getClass() == actualResult.getClass()
|
||||
&& (expectedResult.getClass() == Double.class || expectedResult.getClass() == Float.class)
|
||||
) {
|
||||
final double expectedValue = ((Number) expectedResult).doubleValue();
|
||||
final double actualValue = ((Number) actualResult).doubleValue();
|
||||
Asserts.assertEquals(reason, expectedValue, actualValue, 1e-6);
|
||||
} else {
|
||||
assertTrue(reason, Objects.deepEquals(expectedResult, actualResult));
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
private Object evaluate(final E expression, final List<String> variables, final List<C> values) {
|
||||
try {
|
||||
return kind.evaluate(expression, variables, values);
|
||||
} catch (final Exception e) {
|
||||
return e.getClass().getName();
|
||||
}
|
||||
}
|
||||
|
||||
protected ExpressionTester<E, C> basic(final String full, final String mini, final E expected, final E actual) {
|
||||
return basicF(full, mini, expected, vars -> actual);
|
||||
}
|
||||
|
||||
protected ExpressionTester<E, C> basicF(final String full, final String mini, final E expected, final Function<List<String>, E> actual) {
|
||||
return basic(new Test(full, mini, expected, actual));
|
||||
}
|
||||
|
||||
private ExpressionTester<E, C> basic(final Test test) {
|
||||
Asserts.assertTrue(test.full, used.add(test.full));
|
||||
basic.add(test);
|
||||
return this;
|
||||
}
|
||||
|
||||
protected ExpressionTester<E, C> advanced(final String full, final String mini, final E expected, final E actual) {
|
||||
return advancedF(full, mini, expected, vars -> actual);
|
||||
}
|
||||
|
||||
protected ExpressionTester<E, C> advancedF(final String full, final String mini, final E expected, final Function<List<String>, E> actual) {
|
||||
Asserts.assertTrue(full, used.add(full));
|
||||
advanced.add(new Test(full, mini, expected, actual));
|
||||
return this;
|
||||
}
|
||||
|
||||
protected static <E> Named<E> variable(final String name, final E expected) {
|
||||
return Named.of(name, expected);
|
||||
}
|
||||
|
||||
@FunctionalInterface
|
||||
public interface Binary<C, E> {
|
||||
E apply(BinaryOperator<C> op, E a, E b);
|
||||
}
|
||||
|
||||
private final class Test {
|
||||
private final String full;
|
||||
private final String mini;
|
||||
private final E expected;
|
||||
private final Function<List<String>, E> actual;
|
||||
|
||||
private Test(final String full, final String mini, final E expected, final Function<List<String>, E> actual) {
|
||||
this.full = full;
|
||||
this.mini = mini;
|
||||
this.expected = expected;
|
||||
this.actual = actual;
|
||||
}
|
||||
|
||||
private void test() {
|
||||
final List<Pair<String, E>> variables = kind.variables().generate(random(), 3);
|
||||
final List<String> names = Functional.map(variables, Pair::first);
|
||||
final E actual = kind.cast(this.actual.apply(names));
|
||||
final String full = mangle(this.full, names);
|
||||
final String mini = mangle(this.mini, names);
|
||||
|
||||
counter.test(() -> {
|
||||
kind.allValues(variables.size(), VALUES).forEach(values -> check(mini, expected, actual, names, values));
|
||||
checkEqualsAndToString(full, mini, actual, actual);
|
||||
prev.add(Pair.of(actual, full));
|
||||
});
|
||||
}
|
||||
|
||||
private String mangle(String string, final List<String> names) {
|
||||
for (int i = 0; i < names.size(); i++) {
|
||||
string = string.replace("$" + (char) ('x' + i), names.get(i));
|
||||
}
|
||||
for (final Map.Entry<String, C> mapping : mappings.entrySet()) {
|
||||
string = string.replace(mapping.getKey(), mapping.getValue().toString());
|
||||
}
|
||||
return string;
|
||||
}
|
||||
}
|
||||
|
||||
private final class GeneratorBuilder {
|
||||
private final Generator.Builder<C> generator;
|
||||
private final NodeRendererBuilder<C> renderer = new NodeRendererBuilder<>(random());
|
||||
private final Renderer.Builder<C, Unit, E> expected;
|
||||
private final Renderer.Builder<C, Unit, E> actual;
|
||||
private final Renderer.Builder<C, Unit, E> copy;
|
||||
private final Binary<C, E> binary;
|
||||
|
||||
private GeneratorBuilder(
|
||||
final Function<C, E> expectedConstant,
|
||||
final Function<? super C, E> actualConstant,
|
||||
final Binary<C, E> binary,
|
||||
final Function<ExtendedRandom, C> randomValue
|
||||
) {
|
||||
generator = Generator.builder(() -> randomValue.apply(random()), random());
|
||||
expected = Renderer.builder(expectedConstant::apply);
|
||||
actual = Renderer.builder(actualConstant::apply);
|
||||
copy = Renderer.builder(actualConstant::apply);
|
||||
|
||||
this.binary = binary;
|
||||
}
|
||||
|
||||
private void binary(final String name, final int priority, final BinaryOperator<C> op, final Class<?> type) {
|
||||
generator.add(name, 2);
|
||||
renderer.binary(name, priority);
|
||||
|
||||
expected.binary(name, (unit, a, b) -> binary.apply(op, a, b));
|
||||
|
||||
@SuppressWarnings("unchecked") final Constructor<? extends E> constructor = (Constructor<? extends E>) Arrays.stream(type.getConstructors())
|
||||
.filter(cons -> Modifier.isPublic(cons.getModifiers()))
|
||||
.filter(cons -> cons.getParameterCount() == 2)
|
||||
.findFirst()
|
||||
.orElseGet(() -> counter.fail("%s(..., ...) constructor not found", type.getSimpleName()));
|
||||
final Renderer.BinaryOperator<Unit, E> actual = (unit, a, b) -> {
|
||||
try {
|
||||
return constructor.newInstance(a, b);
|
||||
} catch (final Exception e) {
|
||||
return counter.fail(e);
|
||||
}
|
||||
};
|
||||
this.actual.binary(name, actual);
|
||||
copy.binary(name, actual);
|
||||
}
|
||||
|
||||
private void testRandom() {
|
||||
final NodeRenderer<C> renderer = this.renderer.build();
|
||||
final Renderer<C, Unit, E> expectedRenderer = this.expected.build();
|
||||
final Renderer<C, Unit, E> actualRenderer = this.actual.build();
|
||||
final expression.common.Generator<C, E> generator = this.generator.build(kind.variables(), List.of());
|
||||
generator.testRandom(counter, 1, expr -> {
|
||||
final String full = renderer.render(expr, NodeRenderer.FULL);
|
||||
final String mini = renderer.render(expr, NodeRenderer.MINI);
|
||||
final E expected = expectedRenderer.render(expr, Unit.INSTANCE);
|
||||
final E actual = actualRenderer.render(expr, Unit.INSTANCE);
|
||||
|
||||
final List<Pair<String, E>> variables = expr.variables();
|
||||
final List<String> names = Functional.map(variables, Pair::first);
|
||||
final List<C> values = Stream.generate(() -> kind.randomValue(random()))
|
||||
.limit(variables.size())
|
||||
.toList();
|
||||
|
||||
checkEqualsAndToString(full, mini, actual, copy.build().render(expr, Unit.INSTANCE));
|
||||
check(full, expected, actual, names, values);
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user