codejava/prog-intro
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Upload files to "java/base"

Browse Source
This commit is contained in:
codejava
2026-04-13 10:38:59 +03:00
parent b7460dd507
commit 5b9012d3b9
5 changed files with 756 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

281
java/base/Runner.java Normal file
View File

@@ -0,0 +1,281 @@
package base;
import java.io.*;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* @author Georgiy Korneev (kgeorgiy@kgeorgiy.info)
*/
@SuppressWarnings("unused")
@FunctionalInterface
public interface Runner {
List<String> run(final TestCounter counter, final List<String> input);
default List<String> run(final TestCounter counter, final String... input) {
return run(counter, List.of(input));
}
default void testEquals(
final TestCounter counter,
final List<String> input,
final List<String> expected
) {
counter.test(() -> {
final List<String> actual = run(counter, input);
for (int i = 0; i < Math.min(expected.size(), actual.size()); i++) {
final String exp = expected.get(i);
final String act = actual.get(i);
if (!exp.equalsIgnoreCase(act)) {
Asserts.assertEquals("Line " + (i + 1), exp, act);
return;
}
}
Asserts.assertEquals(
"Number of lines",
expected.size(),
actual.size()
);
});
}
static Packages packages(final String... packages) {
return new Packages(List.of(packages));
}
@FunctionalInterface
interface CommentRunner {
List<String> run(
String comment,
TestCounter counter,
List<String> input
);
}
final class Packages {
private final List<String> packages;
private Packages(final List<String> packages) {
this.packages = packages;
}
public Runner std(final String className) {
final CommentRunner main = main(className);
return (counter, input) ->
counter.call("io", () -> {
final ByteArrayOutputStream baos =
new ByteArrayOutputStream();
try (
final PrintWriter writer = new PrintWriter(
baos,
false,
StandardCharsets.UTF_8
)
) {
input.forEach(writer::println);
}
final InputStream oldIn = System.in;
try {
System.setIn(
new ByteArrayInputStream(baos.toByteArray())
);
return main.run(
String.format("[%d input lines]", input.size()),
counter,
List.of()
);
} finally {
System.setIn(oldIn);
}
});
}
@SuppressWarnings("ConfusingMainMethod")
public CommentRunner main(final String className) {
final Method method = findMain(className);
return (comment, counter, input) -> {
counter.format(
"Running test %02d: java %s %s%n",
counter.getTestNo(),
method.getDeclaringClass().getName(),
comment
);
final ByteArrayOutputStream out = new ByteArrayOutputStream();
@SuppressWarnings("UseOfSystemOutOrSystemErr")
final PrintStream oldOut = System.out;
try {
System.setOut(
new PrintStream(out, false, StandardCharsets.UTF_8)
);
method.invoke(
null,
new Object[] { input.toArray(String[]::new) }
);
final BufferedReader reader = new BufferedReader(
new InputStreamReader(
new ByteArrayInputStream(out.toByteArray()),
StandardCharsets.UTF_8
)
);
final List<String> result = new ArrayList<>();
while (true) {
final String line = reader.readLine();
if (line == null) {
if (result.isEmpty()) {
result.add("");
}
return result;
}
result.add(line.trim());
}
} catch (final InvocationTargetException e) {
final Throwable cause = e.getCause();
throw Asserts.error(
"main thrown exception %s: %s",
cause.getClass().getSimpleName(),
cause
);
} catch (final Exception e) {
throw Asserts.error(
"Cannot invoke main: %s: %s",
e.getClass().getSimpleName(),
e.getMessage()
);
} finally {
System.setOut(oldOut);
}
};
}
private Method findMain(final String className) {
try {
final URL url = new File(".").toURI().toURL();
final List<String> candidates = packages
.stream()
.flatMap(pkg -> {
final String prefix = pkg.isEmpty() ? pkg : pkg + ".";
return Stream.of(
prefix + className,
prefix + "$" + className
);
})
.toList();
//noinspection ClassLoaderInstantiation,resource,IOResourceOpenedButNotSafelyClosed
final URLClassLoader classLoader = new URLClassLoader(
new URL[] { url }
);
for (final String candidate : candidates) {
try {
final Class<?> loaded = classLoader.loadClass(
candidate
);
if (!Modifier.isPublic(loaded.getModifiers())) {
throw Asserts.error(
"Class %s is not public",
candidate
);
}
final Method main = loaded.getMethod(
"main",
String[].class
);
if (
!Modifier.isPublic(main.getModifiers()) ||
!Modifier.isStatic(main.getModifiers())
) {
throw Asserts.error(
"Method main of class %s should be public and static",
candidate
);
}
return main;
} catch (final ClassNotFoundException e) {
// Ignore
} catch (final NoSuchMethodException e) {
throw Asserts.error(
"Could not find method main(String[]) in class %s",
candidate,
e
);
}
}
throw Asserts.error(
"Could not find neither of classes %s",
candidates
);
} catch (final MalformedURLException e) {
throw Asserts.error("Invalid path", e);
}
}
private static String getClassName(
final String pkg,
final String className
) {
return pkg.isEmpty() ? className : pkg + "." + className;
}
public Runner args(final String className) {
final CommentRunner main = main(className);
// final AtomicReference<String> prev = new AtomicReference<>("");
return (counter, input) -> {
final int total =
input.stream().mapToInt(String::length).sum() +
input.size() * 3;
final String comment =
total <= 300
? input
.stream()
.collect(Collectors.joining("\" \"", "\"", "\""))
: input.size() <= 100
? String.format(
"[%d arguments, sizes: %s]",
input.size(),
input
.stream()
.mapToInt(String::length)
.mapToObj(String::valueOf)
.collect(Collectors.joining(", "))
)
: String.format(
"[%d arguments, total size: %d]",
input.size(),
total
);
// assert comment.length() <= 5 || !prev.get().equals(comment) : "Duplicate tests " + comment;
// prev.set(comment);
return main.run(comment, counter, input);
};
}
public Runner files(final String className) {
final Runner args = args(className);
return (counter, input) ->
counter.call("io", () -> {
final Path inf = counter.getFile("in");
final Path ouf = counter.getFile("out");
Files.write(inf, input);
args.run(counter, List.of(inf.toString(), ouf.toString()));
final List<String> output = Files.readAllLines(ouf);
Files.delete(inf);
Files.delete(ouf);
return output;
});
}
}
}

202
java/base/Selector.java Normal file
View File

@@ -0,0 +1,202 @@
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;
}
}
}

236
java/base/TestCounter.java Normal file
View File

@@ -0,0 +1,236 @@
package base;
import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
import java.util.Map;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
/**
* @author Georgiy Korneev (kgeorgiy@kgeorgiy.info)
*/
public class TestCounter extends Log {
public static final int DENOMINATOR = Integer.getInteger(
"base.denominator",
1
);
public static final int DENOMINATOR2 = (int) Math.round(
Math.sqrt(DENOMINATOR)
);
private static final String JAR_EXT = ".jar";
private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat(
"dd.MM.yyyy HH:mm:ss"
);
private final Class<?> owner;
private final int mode;
private final Map<String, ?> properties;
private final ExtendedRandom random;
private final long start = System.currentTimeMillis();
private int passed;
public TestCounter(
final Class<?> owner,
final int mode,
final Map<String, ?> properties
) {
Locale.setDefault(Locale.US);
Asserts.checkAssert(getClass());
this.owner = owner;
this.mode = mode;
this.properties = properties;
random = new ExtendedRandom(owner);
}
public int mode() {
return mode;
}
public int getTestNo() {
return passed + 1;
}
public void test(final Runnable action) {
testV(() -> {
action.run();
return null;
});
}
public <T> void testForEach(
final Iterable<? extends T> items,
final Consumer<? super T> action
) {
for (final T item : items) {
test(() -> action.accept(item));
}
}
public <T> T testV(final Supplier<T> action) {
return silentScope("Test " + getTestNo(), () -> {
final T result = action.get();
passed++;
return result;
});
}
private String getLine() {
return getIndent() == 0 ? "=" : "-";
}
public void printHead() {
println("=== " + getTitle());
}
public void printStatus() {
format("%s%n%s%n", getLine().repeat(30), getTitle());
format(
"%d tests passed in %dms%n",
passed,
System.currentTimeMillis() - start
);
println("Version: " + getVersion(owner));
println("");
}
private String getTitle() {
return String.format(
"%s %s",
owner.getSimpleName(),
properties.isEmpty() ? "" : properties
);
}
private static String getVersion(final Class<?> clazz) {
try {
final ClassLoader cl = clazz.getClassLoader();
final URL url = cl.getResource(
clazz.getName().replace('.', '/') + ".class"
);
if (url == null) {
return "(no manifest)";
}
final String path = url.getPath();
final int index = path.indexOf(JAR_EXT);
if (index == -1) {
return DATE_FORMAT.format(
new Date(new File(path).lastModified())
);
}
final String jarPath = path.substring(0, index + JAR_EXT.length());
try (
final JarFile jarFile = new JarFile(new File(new URI(jarPath)))
) {
final JarEntry entry = jarFile.getJarEntry(
"META-INF/MANIFEST.MF"
);
return DATE_FORMAT.format(new Date(entry.getTime()));
}
} catch (final IOException | URISyntaxException e) {
return "error: " + e;
}
}
public <T> T call(final String message, final SupplierE<T> supplier) {
return get(supplier).either(
e -> fail(e, "%s", message),
Function.identity()
);
}
public void shouldFail(
final String message,
@SuppressWarnings("TypeMayBeWeakened") final RunnableE action
) {
test(() -> get(action).either(e -> null, v -> fail("%s", message)));
}
public <T> T fail(final String format, final Object... args) {
return fail(Asserts.error(format, args));
}
public <T> T fail(final Throwable throwable) {
return fail(
throwable,
"%s: %s",
throwable.getClass().getSimpleName(),
throwable.getMessage()
);
}
public <T> T fail(
final Throwable throwable,
final String format,
final Object... args
) {
final String message = String.format(format, args);
println("ERROR: " + message);
throw throwable instanceof Error
? (Error) throwable
: new AssertionError(throwable);
}
public void checkTrue(
final boolean condition,
final String message,
final Object... args
) {
if (!condition) {
fail(message, args);
}
}
public static <T> Either<Exception, T> get(final SupplierE<T> supplier) {
return supplier.get();
}
public Path getFile(final String suffix) {
return Paths.get(String.format("test%d.%s", getTestNo(), suffix));
}
public ExtendedRandom random() {
return random;
}
@FunctionalInterface
public interface SupplierE<T> extends Supplier<Either<Exception, T>> {
T getE() throws Exception;
@Override
default Either<Exception, T> get() {
try {
return Either.right(getE());
} catch (final Exception e) {
return Either.left(e);
}
}
}
@FunctionalInterface
public interface RunnableE extends SupplierE<Void> {
void run() throws Exception;
@Override
default Void getE() throws Exception {
run();
return null;
}
}
}

21
java/base/Tester.java Normal file
View File

@@ -0,0 +1,21 @@
package base;
/**
* @author Georgiy Korneev (kgeorgiy@kgeorgiy.info)
*/
public abstract class Tester extends BaseChecker {
protected Tester(final TestCounter counter) {
super(counter);
}
public abstract void test();
public void run(final Class<?> test, final String... args) {
System.out.println(
"=== Testing " + test.getSimpleName() + " " + String.join(" ", args)
);
test();
counter.printStatus();
}
}

16
java/base/Unit.java Normal file
View File

@@ -0,0 +1,16 @@
package base;
/**
* @author Georgiy Korneev (kgeorgiy@kgeorgiy.info)
*/
public final class Unit {
public static final Unit INSTANCE = new Unit();
private Unit() {}
@Override
public String toString() {
return "unit";
}
}