Serge NOEL
496 lines
25 KiB
Java
496 lines
25 KiB
Java
package jmri.jmrit.logixng.expressions;
|
|
|
|
import static org.junit.jupiter.api.Assertions.assertEquals;
|
|
import static org.junit.jupiter.api.Assertions.assertFalse;
|
|
import static org.junit.jupiter.api.Assertions.assertNotNull;
|
|
import static org.junit.jupiter.api.Assertions.assertNull;
|
|
import static org.junit.jupiter.api.Assertions.assertSame;
|
|
import static org.junit.jupiter.api.Assertions.assertThrows;
|
|
import static org.junit.jupiter.api.Assertions.assertTrue;
|
|
import static org.junit.jupiter.api.Assertions.fail;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.concurrent.atomic.AtomicBoolean;
|
|
|
|
import jmri.*;
|
|
import jmri.jmrit.logixng.*;
|
|
import jmri.jmrit.logixng.actions.ActionAtomicBoolean;
|
|
import jmri.jmrit.logixng.actions.IfThenElse;
|
|
import jmri.jmrit.logixng.implementation.DefaultConditionalNGScaffold;
|
|
import jmri.jmrit.logixng.implementation.DefaultSymbolTable;
|
|
import jmri.util.JUnitUtil;
|
|
|
|
import org.junit.jupiter.api.AfterEach;
|
|
import org.junit.jupiter.api.BeforeEach;
|
|
import org.junit.jupiter.api.Test;
|
|
|
|
/**
|
|
* Test ExpressionLocalVariable
|
|
*
|
|
* @author Daniel Bergqvist 2021
|
|
*/
|
|
public class ExpressionLocalVariableTest extends AbstractDigitalExpressionTestBase {
|
|
|
|
private LogixNG logixNG;
|
|
private ConditionalNG conditionalNG;
|
|
private ExpressionLocalVariable expressionLocalVariable;
|
|
private MaleSocket localVariableMaleSocket;
|
|
private ActionAtomicBoolean actionAtomicBoolean;
|
|
private AtomicBoolean atomicBoolean;
|
|
|
|
|
|
@Override
|
|
public ConditionalNG getConditionalNG() {
|
|
return conditionalNG;
|
|
}
|
|
|
|
@Override
|
|
public LogixNG getLogixNG() {
|
|
return logixNG;
|
|
}
|
|
|
|
@Override
|
|
public MaleSocket getConnectableChild() {
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public String getExpectedPrintedTree() {
|
|
return String.format("Local variable myVar is equal to \"\" ::: Use default%n ::: Local variable \"myVar\", init to String \"\"%n");
|
|
}
|
|
|
|
@Override
|
|
public String getExpectedPrintedTreeFromRoot() {
|
|
return String.format(
|
|
"LogixNG: A new logix for test%n" +
|
|
" ConditionalNG: A conditionalNG%n" +
|
|
" ! A%n" +
|
|
" If Then Else. Always execute ::: Use default%n" +
|
|
" ? If%n" +
|
|
" Local variable myVar is equal to \"\" ::: Use default%n" +
|
|
" ::: Local variable \"myVar\", init to String \"\"%n" +
|
|
" ! Then%n" +
|
|
" Set the atomic boolean to true ::: Use default%n" +
|
|
" ! Else%n" +
|
|
" Socket not connected%n");
|
|
}
|
|
|
|
@Override
|
|
public NamedBean createNewBean(String systemName) {
|
|
return new ExpressionLocalVariable(systemName, null);
|
|
}
|
|
|
|
@Override
|
|
public boolean addNewSocket() {
|
|
return false;
|
|
}
|
|
|
|
@Test
|
|
public void testCtor() {
|
|
ExpressionLocalVariable expression2;
|
|
|
|
expression2 = new ExpressionLocalVariable("IQDE321", null);
|
|
expression2.setLocalVariable("");
|
|
assertNotNull( expression2, "object exists");
|
|
assertNull( expression2.getUserName(), "Username matches");
|
|
assertEquals( "Local variable '' is equal to \"\"", expression2.getLongDescription(), "String matches");
|
|
|
|
expression2 = new ExpressionLocalVariable("IQDE321", "My memory");
|
|
expression2.setLocalVariable("");
|
|
assertNotNull( expression2, "object exists");
|
|
assertEquals( "My memory", expression2.getUserName(), "Username matches");
|
|
assertEquals( "Local variable '' is equal to \"\"", expression2.getLongDescription(), "String matches");
|
|
|
|
expression2 = new ExpressionLocalVariable("IQDE321", null);
|
|
expression2.setLocalVariable("myVar");
|
|
assertEquals( "myVar", expression2.getLocalVariable(), "variable is correct");
|
|
assertNotNull( expression2, "object exists");
|
|
assertNull( expression2.getUserName(), "Username matches");
|
|
assertEquals( "Local variable myVar is equal to \"\"", expression2.getLongDescription(), "String matches");
|
|
|
|
Memory l = InstanceManager.getDefault(MemoryManager.class).provide("IM2");
|
|
expression2 = new ExpressionLocalVariable("IQDE321", "My memory");
|
|
expression2.setLocalVariable("someVar");
|
|
expression2.getSelectMemoryNamedBean().setNamedBean(l);
|
|
assertEquals( l, expression2.getSelectMemoryNamedBean().getNamedBean().getBean(), "memory is correct");
|
|
assertNotNull( expression2, "object exists");
|
|
assertEquals( "My memory", expression2.getUserName(), "Username matches");
|
|
assertEquals( "Local variable someVar is equal to \"\"", expression2.getLongDescription(), "String matches");
|
|
|
|
IllegalArgumentException ex = assertThrows( IllegalArgumentException.class, () -> {
|
|
var t = new ExpressionLocalVariable("IQE55:12:XY11", null);
|
|
fail("Should have thrown, not created " + t);
|
|
}, "Illegal system name Expected exception thrown");
|
|
assertNotNull(ex);
|
|
|
|
ex = assertThrows( IllegalArgumentException.class, () -> {
|
|
var t = new ExpressionLocalVariable("IQE55:12:XY11", "A name");
|
|
fail("Should have thrown, not created " + t);
|
|
}, "Illegal system name Expected exception thrown");
|
|
assertNotNull(ex);
|
|
}
|
|
|
|
@Test
|
|
public void testGetChild() {
|
|
assertEquals( 0, expressionLocalVariable.getChildCount(), "getChildCount() returns 0");
|
|
|
|
UnsupportedOperationException ex = assertThrows( UnsupportedOperationException.class, () ->
|
|
expressionLocalVariable.getChild(0), "Exception is thrown");
|
|
assertEquals( "Not supported.", ex.getMessage(), "Error message is correct");
|
|
}
|
|
|
|
@Test
|
|
public void testVariableOperation() {
|
|
assertEquals( "is less than", ExpressionLocalVariable.VariableOperation.LessThan.toString(), "String matches");
|
|
assertEquals( "is less than or equal", ExpressionLocalVariable.VariableOperation.LessThanOrEqual.toString(), "String matches");
|
|
assertEquals( "is equal to", ExpressionLocalVariable.VariableOperation.Equal.toString(), "String matches");
|
|
assertEquals( "is greater than or equal to", ExpressionLocalVariable.VariableOperation.GreaterThanOrEqual.toString(), "String matches");
|
|
assertEquals( "is greater than", ExpressionLocalVariable.VariableOperation.GreaterThan.toString(), "String matches");
|
|
assertEquals( "is not equal to", ExpressionLocalVariable.VariableOperation.NotEqual.toString(), "String matches");
|
|
assertEquals( "is null", ExpressionLocalVariable.VariableOperation.IsNull.toString(), "String matches");
|
|
assertEquals( "is not null", ExpressionLocalVariable.VariableOperation.IsNotNull.toString(), "String matches");
|
|
assertEquals( "does match regular expression", ExpressionLocalVariable.VariableOperation.MatchRegex.toString(), "String matches");
|
|
assertEquals( "does not match regular expression", ExpressionLocalVariable.VariableOperation.NotMatchRegex.toString(), "String matches");
|
|
|
|
assertTrue( ExpressionLocalVariable.VariableOperation.LessThan.hasExtraValue(), "operation has extra value");
|
|
assertTrue( ExpressionLocalVariable.VariableOperation.LessThanOrEqual.hasExtraValue(), "operation has extra value");
|
|
assertTrue( ExpressionLocalVariable.VariableOperation.Equal.hasExtraValue(), "operation has extra value");
|
|
assertTrue( ExpressionLocalVariable.VariableOperation.GreaterThanOrEqual.hasExtraValue(), "operation has extra value");
|
|
assertTrue( ExpressionLocalVariable.VariableOperation.GreaterThan.hasExtraValue(), "operation has extra value");
|
|
assertTrue( ExpressionLocalVariable.VariableOperation.NotEqual.hasExtraValue(), "operation has extra value");
|
|
assertFalse( ExpressionLocalVariable.VariableOperation.IsNull.hasExtraValue(), "operation has not extra value");
|
|
assertFalse( ExpressionLocalVariable.VariableOperation.IsNotNull.hasExtraValue(), "operation has not extra value");
|
|
assertTrue( ExpressionLocalVariable.VariableOperation.MatchRegex.hasExtraValue(), "operation has extra value");
|
|
assertTrue( ExpressionLocalVariable.VariableOperation.NotMatchRegex.hasExtraValue(), "operation has extra value");
|
|
}
|
|
|
|
@Test
|
|
public void testCategory() {
|
|
assertSame( LogixNG_Category.ITEM, _base.getCategory(), "Category matches");
|
|
}
|
|
|
|
@Test
|
|
public void testDescription() {
|
|
// Disable the conditionalNG. This will unregister the listeners
|
|
conditionalNG.setEnabled(false);
|
|
|
|
expressionLocalVariable.setLocalVariable("someVar");
|
|
assertEquals("Local variable", expressionLocalVariable.getShortDescription());
|
|
assertEquals("Local variable someVar is equal to \"\"", expressionLocalVariable.getLongDescription());
|
|
expressionLocalVariable.setLocalVariable("myVar");
|
|
expressionLocalVariable.setConstantValue("A value");
|
|
assertEquals("Local variable myVar is equal to \"A value\"", expressionLocalVariable.getLongDescription());
|
|
expressionLocalVariable.setConstantValue("Another value");
|
|
assertEquals("Local variable myVar is equal to \"Another value\"", expressionLocalVariable.getLongDescription());
|
|
assertEquals("Local variable myVar is equal to \"Another value\"", expressionLocalVariable.getLongDescription());
|
|
}
|
|
|
|
@Test
|
|
public void testExpression() throws SocketAlreadyConnectedException, JmriException {
|
|
// Clear flag
|
|
atomicBoolean.set(false);
|
|
// Set the local variable
|
|
localVariableMaleSocket.clearLocalVariables();
|
|
localVariableMaleSocket.addLocalVariable("myVar", SymbolTable.InitialValueType.String, "New value");
|
|
|
|
// Disable the conditionalNG
|
|
conditionalNG.setEnabled(false);
|
|
|
|
expressionLocalVariable.setCompareTo(ExpressionLocalVariable.CompareTo.Value);
|
|
expressionLocalVariable.setVariableOperation(ExpressionLocalVariable.VariableOperation.Equal);
|
|
expressionLocalVariable.setConstantValue("New value");
|
|
|
|
// The action is not yet executed so the atomic boolean should be false
|
|
assertFalse( atomicBoolean.get(), "atomicBoolean is false");
|
|
// The conditionalNG is not yet enabled so it shouldn't be executed.
|
|
// So the atomic boolean should be false
|
|
assertFalse( atomicBoolean.get(), "atomicBoolean is false");
|
|
// The action is not yet executed so the atomic boolean should be false
|
|
assertFalse( atomicBoolean.get(), "atomicBoolean is false");
|
|
// Enable the conditionalNG and all its children.
|
|
conditionalNG.setEnabled(true);
|
|
// Set the memory. This should execute the conditional.
|
|
// The action should now be executed so the atomic boolean should be true
|
|
assertTrue( atomicBoolean.get(), "atomicBoolean is true");
|
|
|
|
|
|
// Test regular expression match
|
|
conditionalNG.setEnabled(false);
|
|
expressionLocalVariable.setVariableOperation(ExpressionLocalVariable.VariableOperation.MatchRegex);
|
|
expressionLocalVariable.setCompareTo(ExpressionLocalVariable.CompareTo.Value);
|
|
expressionLocalVariable.setRegEx("Hello.*");
|
|
// Set the local variable
|
|
localVariableMaleSocket.clearLocalVariables();
|
|
localVariableMaleSocket.addLocalVariable("myVar", SymbolTable.InitialValueType.String, "Hello world");
|
|
atomicBoolean.set(false);
|
|
assertFalse( atomicBoolean.get(), "The expression has not executed or returns false");
|
|
conditionalNG.setEnabled(true);
|
|
assertTrue( atomicBoolean.get(), "The expression returns true");
|
|
|
|
conditionalNG.setEnabled(false);
|
|
// Set the local variable
|
|
localVariableMaleSocket.clearLocalVariables();
|
|
localVariableMaleSocket.addLocalVariable("myVar", SymbolTable.InitialValueType.String, "Some world");
|
|
atomicBoolean.set(false);
|
|
assertFalse( atomicBoolean.get(), "The expression has not executed or returns false");
|
|
conditionalNG.setEnabled(true);
|
|
assertFalse( atomicBoolean.get(), "The expression returns false");
|
|
|
|
// Test regular expressions
|
|
conditionalNG.setEnabled(false);
|
|
expressionLocalVariable.setRegEx("\\w\\w\\d+\\s\\d+");
|
|
// Set the local variable
|
|
localVariableMaleSocket.clearLocalVariables();
|
|
localVariableMaleSocket.addLocalVariable("myVar", SymbolTable.InitialValueType.String, "Ab213 31");
|
|
atomicBoolean.set(false);
|
|
assertFalse( atomicBoolean.get(), "The expression has not executed or returns false");
|
|
conditionalNG.setEnabled(true);
|
|
assertTrue( atomicBoolean.get(), "The expression returns true");
|
|
|
|
conditionalNG.setEnabled(false);
|
|
// Set the local variable
|
|
localVariableMaleSocket.clearLocalVariables();
|
|
localVariableMaleSocket.addLocalVariable("myVar", SymbolTable.InitialValueType.String, "Ab213_31"); // Underscore instead of space
|
|
atomicBoolean.set(false);
|
|
assertFalse( atomicBoolean.get(), "The expression has not executed or returns false");
|
|
conditionalNG.setEnabled(true);
|
|
assertFalse( atomicBoolean.get(), "The expression returns false");
|
|
|
|
|
|
// Test regular expression not match
|
|
conditionalNG.setEnabled(false);
|
|
expressionLocalVariable.setVariableOperation(ExpressionLocalVariable.VariableOperation.NotMatchRegex);
|
|
expressionLocalVariable.setCompareTo(ExpressionLocalVariable.CompareTo.Value);
|
|
expressionLocalVariable.setRegEx("Hello.*");
|
|
// Set the local variable
|
|
localVariableMaleSocket.clearLocalVariables();
|
|
localVariableMaleSocket.addLocalVariable("myVar", SymbolTable.InitialValueType.String, "Hello world");
|
|
atomicBoolean.set(false);
|
|
assertFalse( atomicBoolean.get(), "The expression has not executed or returns false");
|
|
conditionalNG.setEnabled(true);
|
|
assertFalse( atomicBoolean.get(), "The expression returns false");
|
|
|
|
conditionalNG.setEnabled(false);
|
|
// Set the local variable
|
|
localVariableMaleSocket.clearLocalVariables();
|
|
localVariableMaleSocket.addLocalVariable("myVar", SymbolTable.InitialValueType.String, "Some world");
|
|
atomicBoolean.set(false);
|
|
assertFalse( atomicBoolean.get(), "The expression has not executed or returns false");
|
|
conditionalNG.setEnabled(true);
|
|
assertTrue( atomicBoolean.get(), "The expression returns true");
|
|
|
|
// Test regular expressions
|
|
conditionalNG.setEnabled(false);
|
|
expressionLocalVariable.setRegEx("\\w\\w\\d+\\s\\d+");
|
|
// Set the local variable
|
|
localVariableMaleSocket.clearLocalVariables();
|
|
localVariableMaleSocket.addLocalVariable("myVar", SymbolTable.InitialValueType.String, "Ab213 31");
|
|
atomicBoolean.set(false);
|
|
assertFalse( atomicBoolean.get(), "The expression has not executed or returns false");
|
|
conditionalNG.setEnabled(true);
|
|
assertFalse( atomicBoolean.get(), "The expression returns false");
|
|
|
|
conditionalNG.setEnabled(false);
|
|
// Set the local variable
|
|
localVariableMaleSocket.clearLocalVariables();
|
|
localVariableMaleSocket.addLocalVariable("myVar", SymbolTable.InitialValueType.String, "Ab213_31"); // Underscore instead of space
|
|
atomicBoolean.set(false);
|
|
assertFalse( atomicBoolean.get(), "The expression has not executed or returns false");
|
|
conditionalNG.setEnabled(true);
|
|
assertTrue( atomicBoolean.get(), "The expression returns true");
|
|
}
|
|
/*
|
|
@Test
|
|
public void testSetMemory() {
|
|
expressionLocalVariable.unregisterListeners();
|
|
|
|
Memory otherMemory = InstanceManager.getDefault(MemoryManager.class).provide("IM99");
|
|
Assert.assertNotEquals("Memorys are different", otherMemory, expressionLocalVariable.getMemory().getBean());
|
|
expressionLocalVariable.setMemory(otherMemory);
|
|
Assert.assertEquals("Memorys are equal", otherMemory, expressionLocalVariable.getMemory().getBean());
|
|
|
|
NamedBeanHandle<Memory> otherMemoryHandle =
|
|
InstanceManager.getDefault(NamedBeanHandleManager.class)
|
|
.getNamedBeanHandle(otherMemory.getDisplayName(), otherMemory);
|
|
expressionLocalVariable.removeMemory();
|
|
Assert.assertNull("Memory is null", expressionLocalVariable.getMemory());
|
|
expressionLocalVariable.setMemory(otherMemoryHandle);
|
|
Assert.assertEquals("Memorys are equal", otherMemory, expressionLocalVariable.getMemory().getBean());
|
|
Assert.assertEquals("MemoryHandles are equal", otherMemoryHandle, expressionLocalVariable.getMemory());
|
|
}
|
|
|
|
@Test
|
|
public void testSetMemory2() {
|
|
// Disable the conditionalNG. This will unregister the listeners
|
|
conditionalNG.setEnabled(false);
|
|
|
|
Memory memory11 = InstanceManager.getDefault(MemoryManager.class).provide("IM11");
|
|
Memory memory12 = InstanceManager.getDefault(MemoryManager.class).provide("IM12");
|
|
NamedBeanHandle<Memory> memoryHandle12 = InstanceManager.getDefault(NamedBeanHandleManager.class).getNamedBeanHandle(memory12.getDisplayName(), memory12);
|
|
Memory memory13 = InstanceManager.getDefault(MemoryManager.class).provide("IM13");
|
|
Memory memory14 = InstanceManager.getDefault(MemoryManager.class).provide("IM14");
|
|
memory14.setUserName("Some user name");
|
|
|
|
expressionLocalVariable.removeMemory();
|
|
Assert.assertNull("memory handle is null", expressionLocalVariable.getMemory());
|
|
|
|
expressionLocalVariable.setMemory(memory11);
|
|
Assert.assertTrue("memory is correct", memory11 == expressionLocalVariable.getMemory().getBean());
|
|
|
|
expressionLocalVariable.removeMemory();
|
|
Assert.assertNull("memory handle is null", expressionLocalVariable.getMemory());
|
|
|
|
expressionLocalVariable.setMemory(memoryHandle12);
|
|
Assert.assertTrue("memory handle is correct", memoryHandle12 == expressionLocalVariable.getMemory());
|
|
|
|
expressionLocalVariable.setMemory("A non existent memory");
|
|
Assert.assertNull("memory handle is null", expressionLocalVariable.getMemory());
|
|
JUnitAppender.assertWarnMessage("memory \"A non existent memory\" is not found");
|
|
|
|
expressionLocalVariable.setMemory(memory13.getSystemName());
|
|
Assert.assertTrue("memory is correct", memory13 == expressionLocalVariable.getMemory().getBean());
|
|
|
|
String userName = memory14.getUserName();
|
|
Assert.assertNotNull("memory is not null", userName);
|
|
expressionLocalVariable.setMemory(userName);
|
|
Assert.assertTrue("memory is correct", memory14 == expressionLocalVariable.getMemory().getBean());
|
|
}
|
|
|
|
@Test
|
|
public void testSetMemoryException() {
|
|
// Test setMemory() when listeners are registered
|
|
Assert.assertNotNull("Memory is not null", memory);
|
|
Assert.assertNotNull("Memory is not null", expressionLocalVariable.getMemory());
|
|
expressionLocalVariable.registerListeners();
|
|
boolean thrown = false;
|
|
try {
|
|
expressionLocalVariable.setMemory("A memory");
|
|
} catch (RuntimeException ex) {
|
|
thrown = true;
|
|
}
|
|
Assert.assertTrue("Expected exception thrown", thrown);
|
|
JUnitAppender.assertErrorMessage("setMemory must not be called when listeners are registered");
|
|
|
|
thrown = false;
|
|
try {
|
|
Memory memory99 = InstanceManager.getDefault(MemoryManager.class).provide("IM99");
|
|
NamedBeanHandle<Memory> memoryHandle99 =
|
|
InstanceManager.getDefault(NamedBeanHandleManager.class).getNamedBeanHandle(memory99.getDisplayName(), memory99);
|
|
expressionLocalVariable.setMemory(memoryHandle99);
|
|
} catch (RuntimeException ex) {
|
|
thrown = true;
|
|
}
|
|
Assert.assertTrue("Expected exception thrown", thrown);
|
|
JUnitAppender.assertErrorMessage("setMemory must not be called when listeners are registered");
|
|
|
|
thrown = false;
|
|
try {
|
|
expressionLocalVariable.setMemory((Memory)null);
|
|
} catch (RuntimeException ex) {
|
|
thrown = true;
|
|
}
|
|
Assert.assertTrue("Expected exception thrown", thrown);
|
|
JUnitAppender.assertErrorMessage("setMemory must not be called when listeners are registered");
|
|
}
|
|
|
|
@Test
|
|
public void testVetoableChange() throws PropertyVetoException {
|
|
// Disable the conditionalNG. This will unregister the listeners
|
|
conditionalNG.setEnabled(false);
|
|
|
|
// Get the expression and set the memory
|
|
Assert.assertNotNull("Memory is not null", memory);
|
|
|
|
// Get some other memory for later use
|
|
Memory otherMemory = InstanceManager.getDefault(MemoryManager.class).provide("IM99");
|
|
Assert.assertNotNull("Memory is not null", otherMemory);
|
|
Assert.assertNotEquals("Memory is not equal", memory, otherMemory);
|
|
|
|
// Test vetoableChange() for some other propery
|
|
expressionLocalVariable.vetoableChange(new PropertyChangeEvent(this, "CanSomething", "test", null));
|
|
Assert.assertEquals("Memory matches", memory, expressionLocalVariable.getMemory().getBean());
|
|
|
|
// Test vetoableChange() for a string
|
|
expressionLocalVariable.vetoableChange(new PropertyChangeEvent(this, "CanDelete", "test", null));
|
|
Assert.assertEquals("Memory matches", memory, expressionLocalVariable.getMemory().getBean());
|
|
expressionLocalVariable.vetoableChange(new PropertyChangeEvent(this, "DoDelete", "test", null));
|
|
Assert.assertEquals("Memory matches", memory, expressionLocalVariable.getMemory().getBean());
|
|
|
|
// Test vetoableChange() for another memory
|
|
expressionLocalVariable.vetoableChange(new PropertyChangeEvent(this, "CanDelete", otherMemory, null));
|
|
Assert.assertEquals("Memory matches", memory, expressionLocalVariable.getMemory().getBean());
|
|
expressionLocalVariable.vetoableChange(new PropertyChangeEvent(this, "DoDelete", otherMemory, null));
|
|
Assert.assertEquals("Memory matches", memory, expressionLocalVariable.getMemory().getBean());
|
|
|
|
// Test vetoableChange() for its own memory
|
|
boolean thrown = false;
|
|
try {
|
|
expressionLocalVariable.vetoableChange(new PropertyChangeEvent(this, "CanDelete", memory, null));
|
|
} catch (PropertyVetoException ex) {
|
|
thrown = true;
|
|
}
|
|
Assert.assertTrue("Expected exception thrown", thrown);
|
|
|
|
Assert.assertEquals("Memory matches", memory, expressionLocalVariable.getMemory().getBean());
|
|
expressionLocalVariable.vetoableChange(new PropertyChangeEvent(this, "DoDelete", memory, null));
|
|
Assert.assertNull("Memory is null", expressionLocalVariable.getMemory());
|
|
}
|
|
*/
|
|
|
|
@BeforeEach
|
|
public void setUp() throws SocketAlreadyConnectedException, SocketAlreadyConnectedException {
|
|
JUnitUtil.setUp();
|
|
JUnitUtil.resetInstanceManager();
|
|
JUnitUtil.resetProfileManager();
|
|
JUnitUtil.initConfigureManager();
|
|
JUnitUtil.initMemoryManager();
|
|
JUnitUtil.initLogixNGManager();
|
|
|
|
_category = LogixNG_Category.ITEM;
|
|
_isExternal = true;
|
|
|
|
logixNG = InstanceManager.getDefault(LogixNG_Manager.class).createLogixNG("A new logix for test"); // NOI18N
|
|
conditionalNG = new DefaultConditionalNGScaffold("IQC1", "A conditionalNG"); // NOI18N;
|
|
conditionalNG.setSymbolTable(new DefaultSymbolTable(conditionalNG));
|
|
InstanceManager.getDefault(ConditionalNG_Manager.class).register(conditionalNG);
|
|
conditionalNG.setRunDelayed(false);
|
|
conditionalNG.setEnabled(true);
|
|
|
|
logixNG.addConditionalNG(conditionalNG);
|
|
|
|
IfThenElse ifThenElse = new IfThenElse("IQDA321", null);
|
|
ifThenElse.setExecuteType(IfThenElse.ExecuteType.AlwaysExecute);
|
|
MaleSocket maleSocket =
|
|
InstanceManager.getDefault(DigitalActionManager.class).registerAction(ifThenElse);
|
|
conditionalNG.getChild(0).connect(maleSocket);
|
|
|
|
expressionLocalVariable = new ExpressionLocalVariable("IQDE321", null);
|
|
localVariableMaleSocket =
|
|
InstanceManager.getDefault(DigitalExpressionManager.class).registerExpression(expressionLocalVariable);
|
|
localVariableMaleSocket.addLocalVariable("myVar", SymbolTable.InitialValueType.String, "");
|
|
ifThenElse.getChild(0).connect(localVariableMaleSocket);
|
|
|
|
_base = expressionLocalVariable;
|
|
_baseMaleSocket = localVariableMaleSocket;
|
|
|
|
atomicBoolean = new AtomicBoolean(false);
|
|
actionAtomicBoolean = new ActionAtomicBoolean(atomicBoolean, true);
|
|
MaleSocket socketAtomicBoolean = InstanceManager.getDefault(DigitalActionManager.class).registerAction(actionAtomicBoolean);
|
|
ifThenElse.getChild(1).connect(socketAtomicBoolean);
|
|
|
|
expressionLocalVariable.setLocalVariable("myVar");
|
|
|
|
assertTrue( logixNG.setParentForAllChildren(new ArrayList<>()));
|
|
logixNG.activate();
|
|
logixNG.setEnabled(true);
|
|
}
|
|
|
|
@AfterEach
|
|
public void tearDown() {
|
|
jmri.jmrit.logixng.util.LogixNG_Thread.stopAllLogixNGThreads();
|
|
JUnitUtil.deregisterBlockManagerShutdownTask();
|
|
JUnitUtil.tearDown();
|
|
}
|
|
|
|
}
|