22038774575

Committed 15 Feb 2026 04:05PM UTC coverage: 45.369% (+0.2%) from 45.155%

Build # 22038774575

Build Type

Pull #1602

github

Committed by

Copilot

Commit Message

Set default pulse length to 1, remove logs, add game tests

Co-authored-by: rubensworks <440384+rubensworks@users.noreply.github.com>

Pull Request Pull Request #1602: Add configurable pulse length property to Redstone Writer

Run Details

2666 of 8642 branches covered (30.85%)

Branch coverage included in aggregate %.

12020 of 23728 relevant lines covered (50.66%)

2.4 hits per line

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

82.81

/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.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.aspect.property.IAspectProperties;
import org.cyclops.integrateddynamics.api.part.aspect.property.IAspectPropertyTypeInstance;
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(IValue value1, IValue value2) {
        if (!Objects.equals(value1, value2)) {
            throw new GameTestAssertException(String.format("Value %s does not equal value %s", value1, value2));
        }
    }

    public static void assertValueEqual(@Nullable IVariable value1, IValue value2) {
        if (value1 == null) {
            throw new GameTestAssertException("Variable is null");
        }
        try {
            assertValueEqual(value1.getValue(), value2);
        } catch (EvaluationException e) {
            throw new GameTestAssertException(e.getMessage());
        }
    }

    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(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("Aspect " + aspect + " not found");
        }

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

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

    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, "The aspect did not throw");
            } catch (EvaluationException e) {
                helper.assertTrue(true, "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(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()), "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("Return value is not an operator");
                }
                IValue output = operator.getRawValue().evaluate(operatorInputs.stream().map(Variable::new).toArray(Variable[]::new));
                assertValueEqual(output, expectedOperatorOutput);
            } catch (EvaluationException e) {
                throw new GameTestAssertException(e.getMessage());
            }
        });
    }

    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("Return value is not an operator");
                }
                IValue output = operator.getRawValue().evaluate(operatorInputs.stream().map(Variable::new).toArray(Variable[]::new));
                helper.assertTrue(asserter.test(output), "Value was not asserted correctly");
            } catch (EvaluationException e) {
                throw new GameTestAssertException(e.getMessage());
            }
        });
    }

    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.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));
    }

    public static <T extends IValueType<V>, V extends IValue> void setAspectProperty(PartPos partPos, IAspect aspect, IAspectPropertyTypeInstance<T, V> property, V value) {
        PartHelpers.PartStateHolder<?, ?> partStateHolder = PartHelpers.getPart(partPos);
        IPartState<?> state = partStateHolder.getState();

        // Get or create aspect properties
        IAspectProperties properties = state.getAspectProperties(aspect);
        if (properties == null) {
            properties = aspect.getDefaultProperties();
        }

        // Set the property value
        properties.setValue(property, value);
        state.setAspectProperties(aspect, properties);
    }

}

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

CyclopsMC / IntegratedDynamics / 22038774575

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