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/gametest/GameTestHelpersIntegratedDynamics.java

package org.cyclops.integrateddynamics.gametest;

import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
import net.minecraft.gametest.framework.GameTestAssertException;
import net.minecraft.gametest.framework.GameTestHelper;
import net.minecraft.network.chat.Component;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.level.Level;
import org.apache.commons.lang3.tuple.Pair;
import org.cyclops.integrateddynamics.IntegratedDynamics;
import org.cyclops.integrateddynamics.RegistryEntries;
import org.cyclops.integrateddynamics.api.evaluate.EvaluationException;
import org.cyclops.integrateddynamics.api.evaluate.operator.IOperator;
import org.cyclops.integrateddynamics.api.evaluate.variable.IValue;
import org.cyclops.integrateddynamics.api.evaluate.variable.IValueType;
import org.cyclops.integrateddynamics.api.evaluate.variable.IVariable;
import org.cyclops.integrateddynamics.api.evaluate.variable.ValueDeseralizationContext;
import org.cyclops.integrateddynamics.api.item.IAspectVariableFacade;
import org.cyclops.integrateddynamics.api.item.IVariableFacade;
import org.cyclops.integrateddynamics.api.item.IVariableFacadeHandlerRegistry;
import org.cyclops.integrateddynamics.api.part.IPartState;
import org.cyclops.integrateddynamics.api.part.PartPos;
import org.cyclops.integrateddynamics.api.part.PartTarget;
import org.cyclops.integrateddynamics.api.part.aspect.IAspect;
import org.cyclops.integrateddynamics.api.part.aspect.IAspectRead;
import org.cyclops.integrateddynamics.api.part.aspect.IAspectVariable;
import org.cyclops.integrateddynamics.api.part.aspect.IAspectWrite;
import org.cyclops.integrateddynamics.api.part.read.IPartStateReader;
import org.cyclops.integrateddynamics.api.part.read.IPartTypeReader;
import org.cyclops.integrateddynamics.api.part.write.IPartStateWriter;
import org.cyclops.integrateddynamics.api.part.write.IPartTypeWriter;
import org.cyclops.integrateddynamics.core.evaluate.operator.Operators;
import org.cyclops.integrateddynamics.core.evaluate.variable.ValueTypeOperator;
import org.cyclops.integrateddynamics.core.evaluate.variable.ValueTypes;
import org.cyclops.integrateddynamics.core.evaluate.variable.Variable;
import org.cyclops.integrateddynamics.core.helper.PartHelpers;
import org.cyclops.integrateddynamics.core.item.AspectVariableFacade;
import org.cyclops.integrateddynamics.core.logicprogrammer.OperatorLPElement;
import org.cyclops.integrateddynamics.core.logicprogrammer.ValueTypeLPElementBase;
import org.cyclops.integrateddynamics.part.PartTypePanelDisplay;
import org.cyclops.integrateddynamics.part.aspect.Aspects;

import javax.annotation.Nullable;
import java.util.List;
import java.util.Objects;
import java.util.function.Predicate;
import java.util.function.Supplier;

/**
 * @author rubensworks
 */
public class GameTestHelpersIntegratedDynamics {

    public static void assertValueEqual(GameTestHelper helper, IValue value1, IValue value2) {
        if (!Objects.equals(value1, value2)) {
            throw new GameTestAssertException(Component.literal(String.format("Value %s does not equal value %s", value1, value2)), (int) helper.getTick());
        }
    }

    public static void assertValueEqual(GameTestHelper helper, @Nullable IVariable value1, IValue value2) {
        if (value1 == null) {
            throw new GameTestAssertException(Component.literal("Variable is null"), (int) helper.getTick());
        }
        try {
            assertValueEqual(helper, value1.getValue(), value2);
        } catch (EvaluationException e) {
            throw new GameTestAssertException(e.getErrorMessage(), (int) helper.getTick());
        }
    }

    public static ItemStack createVariableForValue(Level level, IValueType valueType, IValue value) {
        IVariableFacadeHandlerRegistry registry = IntegratedDynamics._instance.getRegistryManager().getRegistry(IVariableFacadeHandlerRegistry.class);
        ItemStack itemStack = new ItemStack(RegistryEntries.ITEM_VARIABLE);
        return registry.writeVariableFacadeItem(true, itemStack, ValueTypes.REGISTRY,
                new ValueTypeLPElementBase.ValueTypeVariableFacadeFactory(valueType, value), level, null, RegistryEntries.BLOCK_LOGIC_PROGRAMMER.get().defaultBlockState());
    }

    public static ItemStack createVariableForOperator(Level level, IOperator operator, int[] variableIds) {
        IVariableFacadeHandlerRegistry registry = IntegratedDynamics._instance.getRegistryManager().getRegistry(IVariableFacadeHandlerRegistry.class);
        ItemStack itemStack = new ItemStack(RegistryEntries.ITEM_VARIABLE);
        return registry.writeVariableFacadeItem(true, itemStack, Operators.REGISTRY,
                new OperatorLPElement.OperatorVariableFacadeFactory(operator, variableIds), level, null, RegistryEntries.BLOCK_LOGIC_PROGRAMMER.get().defaultBlockState());
    }

    public static IVariableFacade getVariableFacade(Level level, ItemStack itemStack) {
        return RegistryEntries.ITEM_VARIABLE.get().getVariableFacade(ValueDeseralizationContext.of(level), itemStack);
    }

    public static ItemStack createVariableFromReader(Level level, PartPos partPos, final IAspect aspect) {
        return createVariableFromReader(level, aspect, PartHelpers.getPart(partPos).getState());
    }

    public static ItemStack createVariableFromReader(Level level, final IAspect aspect, IPartState partState) {
        IVariableFacadeHandlerRegistry registry = IntegratedDynamics._instance.getRegistryManager().getRegistry(IVariableFacadeHandlerRegistry.class);
        ItemStack itemStack = new ItemStack(RegistryEntries.ITEM_VARIABLE);
        return registry.writeVariableFacadeItem(true, itemStack, Aspects.REGISTRY, new IVariableFacadeHandlerRegistry.IVariableFacadeFactory<>() {
            @Override
            public IAspectVariableFacade create(boolean generateId) {
                return new AspectVariableFacade(generateId, partState.getId(), aspect);
            }

            @Override
            public IAspectVariableFacade create(int id) {
                return new AspectVariableFacade(id, partState.getId(), aspect);
            }
        }, level, null, null);
    }

    public static void placeVariableInWriter(GameTestHelper helper, Level level, PartPos partPos, final IAspectWrite<?, ?> aspect, ItemStack variableAspect) {
        PartHelpers.PartStateHolder<?, ?> partStateHolder = PartHelpers.getPart(partPos);
        IPartTypeWriter<?, ?> part = (IPartTypeWriter<?, ?>) partStateHolder.getPart();
        IPartStateWriter<?> state = (IPartStateWriter<?>) partStateHolder.getState();

        // Find aspect index
        int aspectIndex = -1;
        for (int i = 0; i < part.getWriteAspects().size(); i++) {
            if (part.getWriteAspects().get(i) == aspect) {
                aspectIndex = i;
            }
        }
        if (aspectIndex < 0) {
            throw new GameTestAssertException(Component.literal("Aspect " + aspect + " not found"), (int) helper.getTick());
        }

        // Insert variable
        state.getInventory().setItem(aspectIndex, variableAspect);

        // Activate aspect
        ((IPartTypeWriter) part).updateActivation(PartTarget.fromCenter(partPos), state, null, false);
    }

    public static Pair<PartTypePanelDisplay, PartTypePanelDisplay.State> placeVariableInDisplayPanel(Level level, PartPos partPos, ItemStack variableAspect) {
        PartHelpers.PartStateHolder<?, ?> partStateHolder = PartHelpers.getPart(partPos);
        PartTypePanelDisplay part = (PartTypePanelDisplay) partStateHolder.getPart();
        PartTypePanelDisplay.State state = (PartTypePanelDisplay.State) partStateHolder.getState();

        // Insert variable
        state.getInventory().setItem(0, variableAspect);

        return Pair.of(part, state);
    }

    public static Supplier<IAspectVariable> testReadAspectSetup(BlockPos pos, GameTestHelper helper, IPartTypeReader<?, ?> partType, IAspectRead<?, ?> aspectRead) {
        // Place cable
        helper.setBlock(pos, RegistryEntries.BLOCK_CABLE.value());

        // Place part
        PartHelpers.addPart(helper.getLevel(), helper.absolutePos(pos), Direction.WEST, partType, new ItemStack(partType.getItem()));
        PartPos partPos = PartPos.of(helper.getLevel(), helper.absolutePos(pos), Direction.WEST);
        PartHelpers.PartStateHolder<?, ?> partStateHolder = PartHelpers.getPart(partPos);
        IPartTypeReader partReader = (IPartTypeReader) partStateHolder.getPart();
        IPartStateReader partStateReader = (IPartStateReader) partStateHolder.getState();
        return () -> partReader.getVariable(PartTarget.fromCenter(partPos), partStateReader, aspectRead);
    }

    public static <V extends IValue> void testReadAspectThrows(BlockPos pos, GameTestHelper helper, IPartTypeReader<?, ?> partType, IAspectRead<V, ?> aspectRead) {
        Supplier<IAspectVariable> variableSupplier = testReadAspectSetup(pos, helper, partType, aspectRead);
        helper.succeedWhen(() -> {
            try {
                variableSupplier.get().getValue();
                helper.assertTrue(false, Component.literal("The aspect did not throw"));
            } catch (EvaluationException e) {
                helper.assertTrue(true, Component.literal("The aspect did successfully throw"));
            }
        });
    }

    public static <V extends IValue> void testReadAspect(BlockPos pos, GameTestHelper helper, IPartTypeReader<?, ?> partType, IAspectRead<V, ?> aspectRead, V expectedValue) {
        Supplier<IAspectVariable> variableSupplier = testReadAspectSetup(pos, helper, partType, aspectRead);
        helper.succeedWhen(() -> assertValueEqual(helper, variableSupplier.get(), expectedValue));
    }

    public static <V extends IValue> void testReadAspectPredicate(BlockPos pos, GameTestHelper helper, IPartTypeReader<?, ?> partType, IAspectRead<V, ?> aspectRead, Predicate<V> asserter) {
        Supplier<IAspectVariable> variableSupplier = testReadAspectSetup(pos, helper, partType, aspectRead);
        helper.succeedWhen(() -> {
            try {
                helper.assertTrue(asserter.test((V) variableSupplier.get().getValue()), Component.literal("Value was not asserted correctly"));
            } catch (EvaluationException e) {
                throw new RuntimeException(e);
            }
        });
    }

    public static <V extends IValue> void testReadAspectOperator(BlockPos pos, GameTestHelper helper, IPartTypeReader<?, ?> partType, IAspectRead<V, ?> aspectRead, List<IValue> operatorInputs, IValue expectedOperatorOutput) {
        Supplier<IAspectVariable> variableSupplier = testReadAspectSetup(pos, helper, partType, aspectRead);
        helper.succeedWhen(() -> {
            try {
                IValue operatorValue = variableSupplier.get().getValue();
                if (!(operatorValue instanceof ValueTypeOperator.ValueOperator operator)) {
                    throw new GameTestAssertException(Component.literal("Return value is not an operator"), (int) helper.getTick());
                }
                IValue output = operator.getRawValue().evaluate(operatorInputs.stream().map(Variable::new).toArray(Variable[]::new));
                assertValueEqual(helper, output, expectedOperatorOutput);
            } catch (EvaluationException e) {
                throw new GameTestAssertException(e.getErrorMessage(), (int) helper.getTick());
            }
        });
    }

    public static <V extends IValue> void testReadAspectOperatorPredicate(BlockPos pos, GameTestHelper helper, IPartTypeReader<?, ?> partType, IAspectRead<V, ?> aspectRead, List<IValue> operatorInputs, Predicate<IValue> asserter) {
        Supplier<IAspectVariable> variableSupplier = testReadAspectSetup(pos, helper, partType, aspectRead);
        helper.succeedWhen(() -> {
            try {
                IValue operatorValue = variableSupplier.get().getValue();
                if (!(operatorValue instanceof ValueTypeOperator.ValueOperator operator)) {
                    throw new GameTestAssertException(Component.literal("Return value is not an operator"), (int) helper.getTick());
                }
                IValue output = operator.getRawValue().evaluate(operatorInputs.stream().map(Variable::new).toArray(Variable[]::new));
                helper.assertTrue(asserter.test(output), Component.literal("Value was not asserted correctly"));
            } catch (EvaluationException e) {
                throw new GameTestAssertException(e.getErrorMessage(), (int) helper.getTick());
            }
        });
    }

    public static <V extends IValue> void testWriteAspectSetup(BlockPos pos, GameTestHelper helper, IPartTypeWriter<?, ?> partType, IAspectWrite<V, ?> aspectWrite, ItemStack variableAspect) {
        // Place cable
        if (helper.getLevel().isEmptyBlock(helper.absolutePos(pos))) {
            helper.setBlock(pos, RegistryEntries.BLOCK_CABLE.value());
        }

        // Place part
        PartHelpers.addPart(helper.getLevel(), helper.absolutePos(pos), Direction.WEST, partType, new ItemStack(partType.getItem()));
        PartPos partPos = PartPos.of(helper.getLevel(), helper.absolutePos(pos), Direction.WEST);
        placeVariableInWriter(helper, helper.getLevel(), partPos, aspectWrite, variableAspect);
    }

    public static <V extends IValue> void testWriteAspectSetup(BlockPos pos, GameTestHelper helper, IPartTypeWriter<?, ?> partType, IAspectWrite<V, ?> aspectWrite, V value) {
        testWriteAspectSetup(pos, helper, partType, aspectWrite, createVariableForValue(helper.getLevel(), value.getType(), value));
    }

}

1	package org.cyclops.integrateddynamics.gametest;
2
3	import net.minecraft.core.BlockPos;
4	import net.minecraft.core.Direction;
5	import net.minecraft.gametest.framework.GameTestAssertException;
6	import net.minecraft.gametest.framework.GameTestHelper;
7	import net.minecraft.network.chat.Component;
8	import net.minecraft.world.item.ItemStack;
9	import net.minecraft.world.level.Level;
10	import org.apache.commons.lang3.tuple.Pair;
11	import org.cyclops.integrateddynamics.IntegratedDynamics;
12	import org.cyclops.integrateddynamics.RegistryEntries;
13	import org.cyclops.integrateddynamics.api.evaluate.EvaluationException;
14	import org.cyclops.integrateddynamics.api.evaluate.operator.IOperator;
15	import org.cyclops.integrateddynamics.api.evaluate.variable.IValue;
16	import org.cyclops.integrateddynamics.api.evaluate.variable.IValueType;
17	import org.cyclops.integrateddynamics.api.evaluate.variable.IVariable;
18	import org.cyclops.integrateddynamics.api.evaluate.variable.ValueDeseralizationContext;
19	import org.cyclops.integrateddynamics.api.item.IAspectVariableFacade;
20	import org.cyclops.integrateddynamics.api.item.IVariableFacade;
21	import org.cyclops.integrateddynamics.api.item.IVariableFacadeHandlerRegistry;
22	import org.cyclops.integrateddynamics.api.part.IPartState;
23	import org.cyclops.integrateddynamics.api.part.PartPos;
24	import org.cyclops.integrateddynamics.api.part.PartTarget;
25	import org.cyclops.integrateddynamics.api.part.aspect.IAspect;
26	import org.cyclops.integrateddynamics.api.part.aspect.IAspectRead;
27	import org.cyclops.integrateddynamics.api.part.aspect.IAspectVariable;
28	import org.cyclops.integrateddynamics.api.part.aspect.IAspectWrite;
29	import org.cyclops.integrateddynamics.api.part.read.IPartStateReader;
30	import org.cyclops.integrateddynamics.api.part.read.IPartTypeReader;
31	import org.cyclops.integrateddynamics.api.part.write.IPartStateWriter;
32	import org.cyclops.integrateddynamics.api.part.write.IPartTypeWriter;
33	import org.cyclops.integrateddynamics.core.evaluate.operator.Operators;
34	import org.cyclops.integrateddynamics.core.evaluate.variable.ValueTypeOperator;
35	import org.cyclops.integrateddynamics.core.evaluate.variable.ValueTypes;
36	import org.cyclops.integrateddynamics.core.evaluate.variable.Variable;
37	import org.cyclops.integrateddynamics.core.helper.PartHelpers;
38	import org.cyclops.integrateddynamics.core.item.AspectVariableFacade;
39	import org.cyclops.integrateddynamics.core.logicprogrammer.OperatorLPElement;
40	import org.cyclops.integrateddynamics.core.logicprogrammer.ValueTypeLPElementBase;
41	import org.cyclops.integrateddynamics.part.PartTypePanelDisplay;
42	import org.cyclops.integrateddynamics.part.aspect.Aspects;
43
44	import javax.annotation.Nullable;
45	import java.util.List;
46	import java.util.Objects;
47	import java.util.function.Predicate;
48	import java.util.function.Supplier;
49
50	/**
51	* @author rubensworks
52	*/
53	public class GameTestHelpersIntegratedDynamics {	×
54
55	public static void assertValueEqual(GameTestHelper helper, IValue value1, IValue value2) {
56	if (!Objects.equals(value1, value2)) {	×
57	throw new GameTestAssertException(Component.literal(String.format("Value %s does not equal value %s", value1, value2)), (int) helper.getTick());	×
58	}
59	}	×
60
61	public static void assertValueEqual(GameTestHelper helper, @Nullable IVariable value1, IValue value2) {
62	if (value1 == null) {	×
63	throw new GameTestAssertException(Component.literal("Variable is null"), (int) helper.getTick());	×
64	}
65	try {
66	assertValueEqual(helper, value1.getValue(), value2);	×
67	} catch (EvaluationException e) {	×
68	throw new GameTestAssertException(e.getErrorMessage(), (int) helper.getTick());	×
69	}	×
70	}	×
71
72	public static ItemStack createVariableForValue(Level level, IValueType valueType, IValue value) {
73	IVariableFacadeHandlerRegistry registry = IntegratedDynamics._instance.getRegistryManager().getRegistry(IVariableFacadeHandlerRegistry.class);	×
74	ItemStack itemStack = new ItemStack(RegistryEntries.ITEM_VARIABLE);	×
75	return registry.writeVariableFacadeItem(true, itemStack, ValueTypes.REGISTRY,	×
76	new ValueTypeLPElementBase.ValueTypeVariableFacadeFactory(valueType, value), level, null, RegistryEntries.BLOCK_LOGIC_PROGRAMMER.get().defaultBlockState());	×
77	}
78
79	public static ItemStack createVariableForOperator(Level level, IOperator operator, int[] variableIds) {
80	IVariableFacadeHandlerRegistry registry = IntegratedDynamics._instance.getRegistryManager().getRegistry(IVariableFacadeHandlerRegistry.class);	×
81	ItemStack itemStack = new ItemStack(RegistryEntries.ITEM_VARIABLE);	×
82	return registry.writeVariableFacadeItem(true, itemStack, Operators.REGISTRY,	×
83	new OperatorLPElement.OperatorVariableFacadeFactory(operator, variableIds), level, null, RegistryEntries.BLOCK_LOGIC_PROGRAMMER.get().defaultBlockState());	×
84	}
85
86	public static IVariableFacade getVariableFacade(Level level, ItemStack itemStack) {
87	return RegistryEntries.ITEM_VARIABLE.get().getVariableFacade(ValueDeseralizationContext.of(level), itemStack);	×
88	}
89
90	public static ItemStack createVariableFromReader(Level level, PartPos partPos, final IAspect aspect) {
91	return createVariableFromReader(level, aspect, PartHelpers.getPart(partPos).getState());	×
92	}
93
94	public static ItemStack createVariableFromReader(Level level, final IAspect aspect, IPartState partState) {
95	IVariableFacadeHandlerRegistry registry = IntegratedDynamics._instance.getRegistryManager().getRegistry(IVariableFacadeHandlerRegistry.class);	×
96	ItemStack itemStack = new ItemStack(RegistryEntries.ITEM_VARIABLE);	×
97	return registry.writeVariableFacadeItem(true, itemStack, Aspects.REGISTRY, new IVariableFacadeHandlerRegistry.IVariableFacadeFactory<>() {	×
98	@Override
99	public IAspectVariableFacade create(boolean generateId) {
100	return new AspectVariableFacade(generateId, partState.getId(), aspect);	×
101	}
102
103	@Override
104	public IAspectVariableFacade create(int id) {
105	return new AspectVariableFacade(id, partState.getId(), aspect);	×
106	}
107	}, level, null, null);
108	}
109
110	public static void placeVariableInWriter(GameTestHelper helper, Level level, PartPos partPos, final IAspectWrite<?, ?> aspect, ItemStack variableAspect) {
111	PartHelpers.PartStateHolder<?, ?> partStateHolder = PartHelpers.getPart(partPos);	×
112	IPartTypeWriter<?, ?> part = (IPartTypeWriter<?, ?>) partStateHolder.getPart();	×
113	IPartStateWriter<?> state = (IPartStateWriter<?>) partStateHolder.getState();	×
114
115	// Find aspect index
116	int aspectIndex = -1;	×
117	for (int i = 0; i < part.getWriteAspects().size(); i++) {	×
118	if (part.getWriteAspects().get(i) == aspect) {	×
119	aspectIndex = i;	×
120	}
121	}
122	if (aspectIndex < 0) {	×
123	throw new GameTestAssertException(Component.literal("Aspect " + aspect + " not found"), (int) helper.getTick());	×
124	}
125
126	// Insert variable
127	state.getInventory().setItem(aspectIndex, variableAspect);	×
128
129	// Activate aspect
130	((IPartTypeWriter) part).updateActivation(PartTarget.fromCenter(partPos), state, null, false);	×
131	}	×
132
133	public static Pair<PartTypePanelDisplay, PartTypePanelDisplay.State> placeVariableInDisplayPanel(Level level, PartPos partPos, ItemStack variableAspect) {
134	PartHelpers.PartStateHolder<?, ?> partStateHolder = PartHelpers.getPart(partPos);	×
135	PartTypePanelDisplay part = (PartTypePanelDisplay) partStateHolder.getPart();	×
136	PartTypePanelDisplay.State state = (PartTypePanelDisplay.State) partStateHolder.getState();	×
137
138	// Insert variable
139	state.getInventory().setItem(0, variableAspect);	×
140
141	return Pair.of(part, state);	×
142	}
143
144	public static Supplier<IAspectVariable> testReadAspectSetup(BlockPos pos, GameTestHelper helper, IPartTypeReader<?, ?> partType, IAspectRead<?, ?> aspectRead) {
145	// Place cable
146	helper.setBlock(pos, RegistryEntries.BLOCK_CABLE.value());	×
147
148	// Place part
149	PartHelpers.addPart(helper.getLevel(), helper.absolutePos(pos), Direction.WEST, partType, new ItemStack(partType.getItem()));	×
150	PartPos partPos = PartPos.of(helper.getLevel(), helper.absolutePos(pos), Direction.WEST);	×
151	PartHelpers.PartStateHolder<?, ?> partStateHolder = PartHelpers.getPart(partPos);	×
152	IPartTypeReader partReader = (IPartTypeReader) partStateHolder.getPart();	×
153	IPartStateReader partStateReader = (IPartStateReader) partStateHolder.getState();	×
154	return () -> partReader.getVariable(PartTarget.fromCenter(partPos), partStateReader, aspectRead);	×
155	}
156
157	public static <V extends IValue> void testReadAspectThrows(BlockPos pos, GameTestHelper helper, IPartTypeReader<?, ?> partType, IAspectRead<V, ?> aspectRead) {
158	Supplier<IAspectVariable> variableSupplier = testReadAspectSetup(pos, helper, partType, aspectRead);	×
159	helper.succeedWhen(() -> {	×
160	try {
161	variableSupplier.get().getValue();	×
162	helper.assertTrue(false, Component.literal("The aspect did not throw"));	×
163	} catch (EvaluationException e) {	×
164	helper.assertTrue(true, Component.literal("The aspect did successfully throw"));	×
165	}	×
166	});	×
167	}	×
168
169	public static <V extends IValue> void testReadAspect(BlockPos pos, GameTestHelper helper, IPartTypeReader<?, ?> partType, IAspectRead<V, ?> aspectRead, V expectedValue) {
170	Supplier<IAspectVariable> variableSupplier = testReadAspectSetup(pos, helper, partType, aspectRead);	×
171	helper.succeedWhen(() -> assertValueEqual(helper, variableSupplier.get(), expectedValue));	×
172	}	×
173
174	public static <V extends IValue> void testReadAspectPredicate(BlockPos pos, GameTestHelper helper, IPartTypeReader<?, ?> partType, IAspectRead<V, ?> aspectRead, Predicate<V> asserter) {
175	Supplier<IAspectVariable> variableSupplier = testReadAspectSetup(pos, helper, partType, aspectRead);	×
176	helper.succeedWhen(() -> {	×
177	try {
178	helper.assertTrue(asserter.test((V) variableSupplier.get().getValue()), Component.literal("Value was not asserted correctly"));	×
179	} catch (EvaluationException e) {	×
180	throw new RuntimeException(e);	×
181	}	×
182	});	×
183	}	×
184
185	public static <V extends IValue> void testReadAspectOperator(BlockPos pos, GameTestHelper helper, IPartTypeReader<?, ?> partType, IAspectRead<V, ?> aspectRead, List<IValue> operatorInputs, IValue expectedOperatorOutput) {
186	Supplier<IAspectVariable> variableSupplier = testReadAspectSetup(pos, helper, partType, aspectRead);	×
187	helper.succeedWhen(() -> {	×
188	try {
189	IValue operatorValue = variableSupplier.get().getValue();	×
190	if (!(operatorValue instanceof ValueTypeOperator.ValueOperator operator)) {	×
191	throw new GameTestAssertException(Component.literal("Return value is not an operator"), (int) helper.getTick());	×
192	}
193	IValue output = operator.getRawValue().evaluate(operatorInputs.stream().map(Variable::new).toArray(Variable[]::new));	×
194	assertValueEqual(helper, output, expectedOperatorOutput);	×
195	} catch (EvaluationException e) {	×
196	throw new GameTestAssertException(e.getErrorMessage(), (int) helper.getTick());	×
197	}	×
198	});	×
199	}	×
200
201	public static <V extends IValue> void testReadAspectOperatorPredicate(BlockPos pos, GameTestHelper helper, IPartTypeReader<?, ?> partType, IAspectRead<V, ?> aspectRead, List<IValue> operatorInputs, Predicate<IValue> asserter) {
202	Supplier<IAspectVariable> variableSupplier = testReadAspectSetup(pos, helper, partType, aspectRead);	×
203	helper.succeedWhen(() -> {	×
204	try {
205	IValue operatorValue = variableSupplier.get().getValue();	×
206	if (!(operatorValue instanceof ValueTypeOperator.ValueOperator operator)) {	×
207	throw new GameTestAssertException(Component.literal("Return value is not an operator"), (int) helper.getTick());	×
208	}
209	IValue output = operator.getRawValue().evaluate(operatorInputs.stream().map(Variable::new).toArray(Variable[]::new));	×
210	helper.assertTrue(asserter.test(output), Component.literal("Value was not asserted correctly"));	×
211	} catch (EvaluationException e) {	×
212	throw new GameTestAssertException(e.getErrorMessage(), (int) helper.getTick());	×
213	}	×
214	});	×
215	}	×
216
217	public static <V extends IValue> void testWriteAspectSetup(BlockPos pos, GameTestHelper helper, IPartTypeWriter<?, ?> partType, IAspectWrite<V, ?> aspectWrite, ItemStack variableAspect) {
218	// Place cable
219	if (helper.getLevel().isEmptyBlock(helper.absolutePos(pos))) {	×
220	helper.setBlock(pos, RegistryEntries.BLOCK_CABLE.value());	×
221	}
222
223	// Place part
224	PartHelpers.addPart(helper.getLevel(), helper.absolutePos(pos), Direction.WEST, partType, new ItemStack(partType.getItem()));	×
225	PartPos partPos = PartPos.of(helper.getLevel(), helper.absolutePos(pos), Direction.WEST);	×
226	placeVariableInWriter(helper, helper.getLevel(), partPos, aspectWrite, variableAspect);	×
227	}	×
228
229	public static <V extends IValue> void testWriteAspectSetup(BlockPos pos, GameTestHelper helper, IPartTypeWriter<?, ?> partType, IAspectWrite<V, ?> aspectWrite, V value) {
230	testWriteAspectSetup(pos, helper, partType, aspectWrite, createVariableForValue(helper.getLevel(), value.getType(), value));	×
231	}	×
232
233	}

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