20210191346

Committed 14 Dec 2025 03:32PM UTC coverage: 19.514% (-33.5%) from 53.061%

Build # 20210191346

Build Type

push

github

Committed by

rubensworks

Commit Message

Remove deprecations

Run Details

663 of 8728 branches covered (7.6%)

Branch coverage included in aggregate %.

6786 of 29445 relevant lines covered (23.05%)

1.09 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/main/java/org/cyclops/integrateddynamics/command/CommandTest.java

package org.cyclops.integrateddynamics.command;

import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.mojang.brigadier.Command;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import com.mojang.brigadier.context.CommandContext;
import com.mojang.brigadier.exceptions.CommandSyntaxException;
import net.minecraft.commands.CommandSourceStack;
import net.minecraft.commands.Commands;
import net.minecraft.network.chat.Component;
import org.cyclops.integrateddynamics.core.test.IntegrationBefore;
import org.cyclops.integrateddynamics.core.test.IntegrationTest;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.List;
import java.util.Map;

/**
 * Command for initiating the integration tests.
 * @author rubensworks
 *
 */
public class CommandTest implements Command<CommandSourceStack> {

    public static final String P = "org.cyclops.integrateddynamics.gametest.integration.";
    public static final List<String> CLASSES = Lists.newArrayList(
            P + "TestVariables",
            P + "TestBlockOperators",
            P + "TestItemStackOperators",
            P + "TestEntityOperators",
            P + "TestFluidStackOperators",
            P + "TestIngredientsOperators",
            P + "TestRecipeOperators"
    );

    @Override
    public int run(CommandContext<CommandSourceStack> context) throws CommandSyntaxException {
        context.getSource().getPlayerOrException().sendSystemMessage(Component.literal("Running tests..."));
        try {
            if(!test()) {
                context.getSource().getPlayerOrException().sendSystemMessage(Component.literal("There were failing tests, see results in console."));
            } else {
                context.getSource().getPlayerOrException().sendSystemMessage(Component.literal("All tests succeeded!"));
            }
            return 0;
        } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
            return 1;
        }
    }

    protected boolean test() throws IllegalAccessException, InstantiationException, InvocationTargetException {
        int ok = 0;
        int total = 0;
        for(String className : CLASSES) {
            try {
                Class<?> clazz = Class.forName(className);
                Object testInstance = clazz.newInstance();

                // Collect test methods
                List<Method> befores = Lists.newLinkedList();
                Map<Method, Boolean> tests = Maps.newHashMap();
                for (Method method : clazz.getDeclaredMethods()) {
                    if (method.isAnnotationPresent(IntegrationBefore.class)) {
                        befores.add(method);
                    }
                    if (method.isAnnotationPresent(IntegrationTest.class)) {
                        tests.put(method, false);
                    }
                }

                // Run tests
                for (Method test : tests.keySet()) {
                    String testName = className.replace(P, "") + "#" + test.getName();
                    for (Method before : befores) {
                        before.invoke(testInstance);
                    }
                    boolean testOk;
                    try {
                        test.invoke(testInstance);
                        testOk = true;
                    } catch (InvocationTargetException e) {
                        Class<?> excepted = test.getAnnotation(IntegrationTest.class).expected();
                        if (!excepted.isInstance(e.getTargetException())) {
                            testOk = false;
                            if (e.getTargetException() instanceof IllegalStateException || e.getTargetException() instanceof AssertionError) {
                                System.err.println("Test " + testName + " failed!");
                                e.getTargetException().printStackTrace();
                            } else {
                                System.err.println(String.format("Expected at %s exception %s, but found:", testName, e));
                                e.getTargetException().printStackTrace();
                            }
                        } else {
                            testOk = true;
                        }
                    }
                    tests.put(test, testOk);
                }

                // Count results
                for (Boolean result : tests.values()) {
                    if (result) {
                        ok++;
                    }
                }
                total += tests.size();
            } catch (ClassNotFoundException e) {
                System.err.println("Skipped test class: " + className);
            }
        }
        System.err.println(String.format("Tests succeeded: %s/%s", ok, total));
        return ok == total;
    }

    public static LiteralArgumentBuilder<CommandSourceStack> make() {
        return Commands.literal("test")
                .requires((commandSource) -> commandSource.hasPermission(2))
                .executes(new CommandTest());
    }

}

1	package org.cyclops.integrateddynamics.command;
2
3	import com.google.common.collect.Lists;
4	import com.google.common.collect.Maps;
5	import com.mojang.brigadier.Command;
6	import com.mojang.brigadier.builder.LiteralArgumentBuilder;
7	import com.mojang.brigadier.context.CommandContext;
8	import com.mojang.brigadier.exceptions.CommandSyntaxException;
9	import net.minecraft.commands.CommandSourceStack;
10	import net.minecraft.commands.Commands;
11	import net.minecraft.network.chat.Component;
12	import org.cyclops.integrateddynamics.core.test.IntegrationBefore;
13	import org.cyclops.integrateddynamics.core.test.IntegrationTest;
14
15	import java.lang.reflect.InvocationTargetException;
16	import java.lang.reflect.Method;
17	import java.util.List;
18	import java.util.Map;
19
20	/**
21	* Command for initiating the integration tests.
22	* @author rubensworks
23	*
24	*/
25	public class CommandTest implements Command<CommandSourceStack> {	×
26
27	public static final String P = "org.cyclops.integrateddynamics.gametest.integration.";
28	public static final List<String> CLASSES = Lists.newArrayList(	×
29	P + "TestVariables",
30	P + "TestBlockOperators",
31	P + "TestItemStackOperators",
32	P + "TestEntityOperators",
33	P + "TestFluidStackOperators",
34	P + "TestIngredientsOperators",
35	P + "TestRecipeOperators"
36	);
37
38	@Override
39	public int run(CommandContext<CommandSourceStack> context) throws CommandSyntaxException {
40	context.getSource().getPlayerOrException().sendSystemMessage(Component.literal("Running tests..."));	×
41	try {
42	if(!test()) {	×
43	context.getSource().getPlayerOrException().sendSystemMessage(Component.literal("There were failing tests, see results in console."));	×
44	} else {
45	context.getSource().getPlayerOrException().sendSystemMessage(Component.literal("All tests succeeded!"));	×
46	}
47	return 0;	×
48	} catch (InstantiationException \| IllegalAccessException \| InvocationTargetException e) {	×
49	e.printStackTrace();	×
50	return 1;	×
51	}
52	}
53
54	protected boolean test() throws IllegalAccessException, InstantiationException, InvocationTargetException {
55	int ok = 0;	×
56	int total = 0;	×
57	for(String className : CLASSES) {	×
58	try {
59	Class<?> clazz = Class.forName(className);	×
60	Object testInstance = clazz.newInstance();	×
61
62	// Collect test methods
63	List<Method> befores = Lists.newLinkedList();	×
64	Map<Method, Boolean> tests = Maps.newHashMap();	×
65	for (Method method : clazz.getDeclaredMethods()) {	×
66	if (method.isAnnotationPresent(IntegrationBefore.class)) {	×
67	befores.add(method);	×
68	}
69	if (method.isAnnotationPresent(IntegrationTest.class)) {	×
70	tests.put(method, false);	×
71	}
72	}
73
74	// Run tests
75	for (Method test : tests.keySet()) {	×
76	String testName = className.replace(P, "") + "#" + test.getName();	×
77	for (Method before : befores) {	×
78	before.invoke(testInstance);	×
79	}	×
80	boolean testOk;
81	try {
82	test.invoke(testInstance);	×
83	testOk = true;	×
84	} catch (InvocationTargetException e) {	×
85	Class<?> excepted = test.getAnnotation(IntegrationTest.class).expected();	×
86	if (!excepted.isInstance(e.getTargetException())) {	×
87	testOk = false;	×
88	if (e.getTargetException() instanceof IllegalStateException \|\| e.getTargetException() instanceof AssertionError) {	×
89	System.err.println("Test " + testName + " failed!");	×
90	e.getTargetException().printStackTrace();	×
91	} else {
92	System.err.println(String.format("Expected at %s exception %s, but found:", testName, e));	×
93	e.getTargetException().printStackTrace();	×
94	}
95	} else {
96	testOk = true;	×
97	}
98	}	×
99	tests.put(test, testOk);	×
100	}	×
101
102	// Count results
103	for (Boolean result : tests.values()) {	×
104	if (result) {	×
105	ok++;	×
106	}
107	}	×
108	total += tests.size();	×
109	} catch (ClassNotFoundException e) {	×
110	System.err.println("Skipped test class: " + className);	×
111	}	×
112	}	×
113	System.err.println(String.format("Tests succeeded: %s/%s", ok, total));	×
114	return ok == total;	×
115	}
116
117	public static LiteralArgumentBuilder<CommandSourceStack> make() {
118	return Commands.literal("test")	×
119	.requires((commandSource) -> commandSource.hasPermission(2))	×
120	.executes(new CommandTest());	×
121	}
122
123	}

CyclopsMC / IntegratedDynamics / 20210191346

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous