prog-intro/java/base/Selector.java

package base;

import java.util.*;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Function;

/**
 * @author Georgiy Korneev (kgeorgiy@kgeorgiy.info)
 */
public final class Selector {

    private final Class<?> owner;
    private final List<String> modes;
    private final Set<String> variantNames = new LinkedHashSet<>();
    private final Map<String, Consumer<TestCounter>> variants =
        new LinkedHashMap<>();

    public Selector(final Class<?> owner, final String... modes) {
        this.owner = owner;
        this.modes = List.of(modes);
    }

    public Selector variant(
        final String name,
        final Consumer<TestCounter> operations
    ) {
        Asserts.assertTrue(
            "Duplicate variant " + name,
            variants.put(name.toLowerCase(), operations) == null
        );
        variantNames.add(name);
        return this;
    }

    private static void check(
        final boolean condition,
        final String format,
        final Object... args
    ) {
        if (!condition) {
            throw new IllegalArgumentException(String.format(format, args));
        }
    }

    @SuppressWarnings("UseOfSystemOutOrSystemErr")
    public void main(final String... args) {
        try {
            final String mode;
            if (modes.isEmpty()) {
                check(
                    args.length >= 1,
                    "At least one argument expected, found %s",
                    args.length
                );
                mode = "";
            } else {
                check(
                    args.length >= 2,
                    "At least two arguments expected, found %s",
                    args.length
                );
                mode = args[0];
            }

            final List<String> vars = Arrays.stream(args)
                .skip(modes.isEmpty() ? 0 : 1)
                .flatMap(arg -> Arrays.stream(arg.split("[ +]+")))
                .toList();

            test(mode, vars);
        } catch (final IllegalArgumentException e) {
            System.err.println("ERROR: " + e.getMessage());
            if (modes.isEmpty()) {
                System.err.println("Usage: " + owner.getName() + " VARIANT...");
            } else {
                System.err.println(
                    "Usage: " + owner.getName() + " MODE VARIANT..."
                );
                System.err.println("Modes: " + String.join(", ", modes));
            }
            System.err.println("Variants: " + String.join(", ", variantNames));
            System.exit(1);
        }
    }

    public void test(final String mode, List<String> vars) {
        final int modeNo = modes.isEmpty() ? -1 : modes.indexOf(mode);
        check(modes.isEmpty() || modeNo >= 0, "Unknown mode '%s'", mode);
        if (variantNames.contains("Base") && !vars.contains("Base")) {
            vars = new ArrayList<>(vars);
            vars.add(0, "Base");
        }

        vars.forEach(variant ->
            check(
                variants.containsKey(variant.toLowerCase()),
                "Unknown variant '%s'",
                variant
            )
        );

        final Map<String, String> properties = modes.isEmpty()
            ? Map.of("variant", String.join("+", vars))
            : Map.of("variant", String.join("+", vars), "mode", mode);
        final TestCounter counter = new TestCounter(owner, modeNo, properties);
        counter.printHead();
        vars.forEach(variant ->
            counter.scope("Testing " + variant, () ->
                variants.get(variant.toLowerCase()).accept(counter)
            )
        );
        counter.printStatus();
    }

    public static <V extends Tester> Composite<V> composite(
        final Class<?> owner,
        final Function<TestCounter, V> factory,
        final String... modes
    ) {
        return new Composite<>(
            owner,
            factory,
            (tester, counter) -> tester.test(),
            modes
        );
    }

    public static <V> Composite<V> composite(
        final Class<?> owner,
        final Function<TestCounter, V> factory,
        final BiConsumer<V, TestCounter> tester,
        final String... modes
    ) {
        return new Composite<>(owner, factory, tester, modes);
    }

    public List<String> getModes() {
        return modes.isEmpty() ? List.of("~") : modes;
    }

    public List<String> getVariants() {
        return List.copyOf(variants.keySet());
    }

    /**
     * @author Georgiy Korneev (kgeorgiy@kgeorgiy.info)
     */
    public static final class Composite<V> {

        private final Selector selector;
        private final Function<TestCounter, V> factory;
        private final BiConsumer<V, TestCounter> tester;
        private List<Consumer<? super V>> base;

        private Composite(
            final Class<?> owner,
            final Function<TestCounter, V> factory,
            final BiConsumer<V, TestCounter> tester,
            final String... modes
        ) {
            selector = new Selector(owner, modes);
            this.factory = factory;
            this.tester = tester;
        }

        @SafeVarargs
        public final Composite<V> variant(
            final String name,
            final Consumer<? super V>... parts
        ) {
            if ("Base".equalsIgnoreCase(name)) {
                base = List.of(parts);
                return v(name.toLowerCase());
            } else {
                return v(name, parts);
            }
        }

        @SafeVarargs
        private Composite<V> v(
            final String name,
            final Consumer<? super V>... parts
        ) {
            selector.variant(name, counter -> {
                final V variant = factory.apply(counter);
                for (final Consumer<? super V> part : base) {
                    part.accept(variant);
                }
                for (final Consumer<? super V> part : parts) {
                    part.accept(variant);
                }
                tester.accept(variant, counter);
            });
            return this;
        }

        public Selector selector() {
            return selector;
        }
    }
}