Examples with Memory jmri.Memory used on opensource projects

Example 26 with Memory

use of jmri.Memory in project JMRI by JMRI.

the class BlockManagerXmlTest method testLoadCurrent.

public void testLoadCurrent() throws Exception {
    JUnitUtil.resetInstanceManager();
    JUnitUtil.initConfigureManager();
    JUnitUtil.initInternalTurnoutManager();
    JUnitUtil.initInternalLightManager();
    JUnitUtil.initInternalSensorManager();
    JUnitUtil.initMemoryManager();
    JUnitUtil.initLayoutBlockManager();
    // load file
    InstanceManager.getDefault(ConfigureManager.class).load(new java.io.File("java/test/jmri/configurexml/load/BlockManagerXmlTest.xml"));
    // check existance of blocks
    Assert.assertNotNull(InstanceManager.getDefault(jmri.BlockManager.class).getBlock("IB1"));
    Assert.assertNull(InstanceManager.getDefault(jmri.BlockManager.class).getBlock("no block"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.BlockManager.class).getBlock("IB2"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.BlockManager.class).getBlock("IB3"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.BlockManager.class).getBlock("IB4"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.BlockManager.class).getBlock("IB5"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.BlockManager.class).getBlock("IB6"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.BlockManager.class).getBlock("IB7"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.BlockManager.class).getBlock("IB8"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.BlockManager.class).getBlock("IB9"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.BlockManager.class).getBlock("IB10"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.BlockManager.class).getBlock("IB11"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.BlockManager.class).getBlock("IB12"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blocknorthwest"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blocknorth"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blocknorthsiding"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blocknortheast"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blockeast"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blockeastsiding"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blocksoutheast"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blocksouth"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blocksouthsiding"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blocksouthwest"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blockwest"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blockwestsiding"));
    //         Assert.assertNotNull(InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlock("ILB1"));
    //         Assert.assertNotNull(InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlock("ILB2"));
    //         Assert.assertNotNull(InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlock("ILB3"));
    //         Assert.assertNotNull(InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlock("ILB4"));
    //         Assert.assertNotNull(InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlock("ILB5"));
    //         Assert.assertNotNull(InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlock("ILB6"));
    //         Assert.assertNotNull(InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlock("ILB7"));
    //         Assert.assertNotNull(InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlock("ILB8"));
    //         Assert.assertNotNull(InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlock("ILB9"));
    //         Assert.assertNotNull(InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlock("ILB10"));
    //         Assert.assertNotNull(InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlock("ILB11"));
    //         Assert.assertNotNull(InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlock("ILB12"));
    //         Assert.assertNotNull(InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlock("blocknorthwest"));
    //         Assert.assertNotNull(InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlock("blocknorth"));
    //         Assert.assertNotNull(InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlock("blocknorthsiding"));
    //         Assert.assertNotNull(InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlock("blocknortheast"));
    //         Assert.assertNotNull(InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlock("blockeast"));
    //         Assert.assertNotNull(InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlock("blockeastsiding"));
    //         Assert.assertNotNull(InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlock("blocksoutheast"));
    //         Assert.assertNotNull(InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlock("blocksouth"));
    //         Assert.assertNotNull(InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlock("blocksouthsiding"));
    //         Assert.assertNotNull(InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlock("blocksouthwest"));
    //         Assert.assertNotNull(InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlock("blockwest"));
    //         Assert.assertNotNull(InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlock("blockwestsiding"));
    // check existance of turmouts
    Assert.assertNotNull(InstanceManager.turnoutManagerInstance().getTurnout("IT1"));
    Assert.assertNull(InstanceManager.turnoutManagerInstance().getTurnout("no turnout"));
    Assert.assertNotNull(InstanceManager.turnoutManagerInstance().getTurnout("IT2"));
    Assert.assertNotNull(InstanceManager.turnoutManagerInstance().getTurnout("IT3"));
    Assert.assertNotNull(InstanceManager.turnoutManagerInstance().getTurnout("IT4"));
    Assert.assertNotNull(InstanceManager.turnoutManagerInstance().getTurnout("IT5"));
    Assert.assertNotNull(InstanceManager.turnoutManagerInstance().getTurnout("IT6"));
    Assert.assertNotNull(InstanceManager.turnoutManagerInstance().getTurnout("IT7"));
    Assert.assertNotNull(InstanceManager.turnoutManagerInstance().getTurnout("IT8"));
    // check existance of memories        
    Assert.assertNotNull(InstanceManager.memoryManagerInstance().getMemory("IM:AUTO:0001"));
    Assert.assertNull(InstanceManager.memoryManagerInstance().getMemory("no memory"));
    Assert.assertNotNull(InstanceManager.memoryManagerInstance().getMemory("IM:AUTO:0002"));
    Assert.assertNotNull(InstanceManager.memoryManagerInstance().getMemory("IM:AUTO:0003"));
    Assert.assertNotNull(InstanceManager.memoryManagerInstance().getMemory("IM:AUTO:0004"));
    Assert.assertNotNull(InstanceManager.memoryManagerInstance().getMemory("IM:AUTO:0005"));
    Assert.assertNotNull(InstanceManager.memoryManagerInstance().getMemory("IM:AUTO:0006"));
    Assert.assertNotNull(InstanceManager.memoryManagerInstance().getMemory("IM:AUTO:0007"));
    Assert.assertNotNull(InstanceManager.memoryManagerInstance().getMemory("IM:AUTO:0008"));
    Assert.assertNotNull(InstanceManager.memoryManagerInstance().getMemory("IM:AUTO:0009"));
    Assert.assertNotNull(InstanceManager.memoryManagerInstance().getMemory("IM:AUTO:0010"));
    Assert.assertNotNull(InstanceManager.memoryManagerInstance().getMemory("IM:AUTO:0011"));
    Assert.assertNotNull(InstanceManager.memoryManagerInstance().getMemory("IM:AUTO:0012"));
    Assert.assertNotNull(InstanceManager.memoryManagerInstance().getMemory("blocknorthwestmemory"));
    Assert.assertNotNull(InstanceManager.memoryManagerInstance().getMemory("blocknorthmemory"));
    Assert.assertNotNull(InstanceManager.memoryManagerInstance().getMemory("blocknorthsidingmemory"));
    Assert.assertNotNull(InstanceManager.memoryManagerInstance().getMemory("blocknortheastmemory"));
    Assert.assertNotNull(InstanceManager.memoryManagerInstance().getMemory("blockeastmemory"));
    Assert.assertNotNull(InstanceManager.memoryManagerInstance().getMemory("blockeastsidingmemory"));
    Assert.assertNotNull(InstanceManager.memoryManagerInstance().getMemory("blocksoutheastmemory"));
    Assert.assertNotNull(InstanceManager.memoryManagerInstance().getMemory("blocksouthmemory"));
    Assert.assertNotNull(InstanceManager.memoryManagerInstance().getMemory("blocksouthsidingmemory"));
    Assert.assertNotNull(InstanceManager.memoryManagerInstance().getMemory("blocksouthwestmemory"));
    Assert.assertNotNull(InstanceManager.memoryManagerInstance().getMemory("blockwestmemory"));
    Assert.assertNotNull(InstanceManager.memoryManagerInstance().getMemory("blockwestsidingmemory"));
    // check existance of sensors
    Assert.assertNotNull(InstanceManager.sensorManagerInstance().getSensor("ISBO1"));
    Assert.assertNull(InstanceManager.sensorManagerInstance().getSensor("no sensor"));
    Assert.assertNotNull(InstanceManager.sensorManagerInstance().getSensor("ISBO2"));
    Assert.assertNotNull(InstanceManager.sensorManagerInstance().getSensor("ISBO3"));
    Assert.assertNotNull(InstanceManager.sensorManagerInstance().getSensor("ISBO4"));
    Assert.assertNotNull(InstanceManager.sensorManagerInstance().getSensor("ISBO5"));
    Assert.assertNotNull(InstanceManager.sensorManagerInstance().getSensor("ISBO6"));
    Assert.assertNotNull(InstanceManager.sensorManagerInstance().getSensor("ISBO7"));
    Assert.assertNotNull(InstanceManager.sensorManagerInstance().getSensor("ISBO8"));
    Assert.assertNotNull(InstanceManager.sensorManagerInstance().getSensor("ISBO9"));
    Assert.assertNotNull(InstanceManager.sensorManagerInstance().getSensor("ISBO10"));
    Assert.assertNotNull(InstanceManager.sensorManagerInstance().getSensor("ISBO11"));
    Assert.assertNotNull(InstanceManager.sensorManagerInstance().getSensor("ISBO12"));
    Assert.assertNotNull(InstanceManager.sensorManagerInstance().getSensor("blocknorthwestoccupied"));
    Assert.assertNotNull(InstanceManager.sensorManagerInstance().getSensor("blocknorthoccupied"));
    Assert.assertNotNull(InstanceManager.sensorManagerInstance().getSensor("blocknorthsidingoccupied"));
    Assert.assertNotNull(InstanceManager.sensorManagerInstance().getSensor("blocknortheastoccupied"));
    Assert.assertNotNull(InstanceManager.sensorManagerInstance().getSensor("blockeastoccupied"));
    Assert.assertNotNull(InstanceManager.sensorManagerInstance().getSensor("blockeastsidingoccupied"));
    Assert.assertNotNull(InstanceManager.sensorManagerInstance().getSensor("blocksoutheastoccupied"));
    Assert.assertNotNull(InstanceManager.sensorManagerInstance().getSensor("blocksouthoccupied"));
    Assert.assertNotNull(InstanceManager.sensorManagerInstance().getSensor("blocksouthsidingoccupied"));
    Assert.assertNotNull(InstanceManager.sensorManagerInstance().getSensor("blocksouthwestoccupied"));
    Assert.assertNotNull(InstanceManager.sensorManagerInstance().getSensor("blockwestoccupied"));
    Assert.assertNotNull(InstanceManager.sensorManagerInstance().getSensor("blockwestsidingoccupied"));
    // check existance of paths between blocks
    Block[] blockstotest;
    Sensor[] occupiedsensor;
    int[] expectedpreviouspaths;
    int[] expectednextpaths;
    //Make sure this is bigger than the list below
    blockstotest = new Block[12];
    //Make sure this is bigger than the list below
    occupiedsensor = new Sensor[12];
    //Make sure this is bigger than the list below
    expectedpreviouspaths = new int[12];
    //Make sure this is bigger than the list below
    expectednextpaths = new int[12];
    Boolean[] passprevioustest;
    Boolean[] passnexttest;
    //Make sure this is bigger than needed
    passprevioustest = new Boolean[4];
    //Make sure this is bigger than needed
    passnexttest = new Boolean[4];
    Block[][] previousblock;
    //Make sure this is bigger than the list below
    previousblock = new Block[12][4];
    Block[][] nextblock;
    //Make sure this is bigger than the list below
    nextblock = new Block[12][4];
    //  This matches up with the test file, ...
    blockstotest[0] = InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blocknorthwest");
    Assert.assertNotNull(blockstotest[0]);
    occupiedsensor[0] = InstanceManager.sensorManagerInstance().getSensor("blocknorthwestoccupied");
    Assert.assertNotNull(occupiedsensor[0]);
    blockstotest[1] = InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blocknorth");
    Assert.assertNotNull(blockstotest[1]);
    occupiedsensor[1] = InstanceManager.sensorManagerInstance().getSensor("blocknorthoccupied");
    Assert.assertNotNull(occupiedsensor[1]);
    blockstotest[2] = InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blocknorthsiding");
    Assert.assertNotNull(blockstotest[2]);
    occupiedsensor[2] = InstanceManager.sensorManagerInstance().getSensor("blocknorthsidingoccupied");
    Assert.assertNotNull(occupiedsensor[2]);
    blockstotest[3] = InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blocknortheast");
    Assert.assertNotNull(blockstotest[3]);
    occupiedsensor[3] = InstanceManager.sensorManagerInstance().getSensor("blocknortheastoccupied");
    Assert.assertNotNull(occupiedsensor[3]);
    blockstotest[4] = InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blockeast");
    Assert.assertNotNull(blockstotest[4]);
    occupiedsensor[4] = InstanceManager.sensorManagerInstance().getSensor("blockeastoccupied");
    Assert.assertNotNull(occupiedsensor[4]);
    blockstotest[5] = InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blockeastsiding");
    Assert.assertNotNull(blockstotest[5]);
    occupiedsensor[5] = InstanceManager.sensorManagerInstance().getSensor("blockeastsidingoccupied");
    Assert.assertNotNull(occupiedsensor[5]);
    blockstotest[6] = InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blocksoutheast");
    Assert.assertNotNull(blockstotest[6]);
    occupiedsensor[6] = InstanceManager.sensorManagerInstance().getSensor("blocksoutheastoccupied");
    Assert.assertNotNull(occupiedsensor[6]);
    blockstotest[7] = InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blocksouth");
    Assert.assertNotNull(blockstotest[7]);
    occupiedsensor[7] = InstanceManager.sensorManagerInstance().getSensor("blocksouthoccupied");
    Assert.assertNotNull(occupiedsensor[7]);
    blockstotest[8] = InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blocksouthsiding");
    Assert.assertNotNull(blockstotest[8]);
    occupiedsensor[8] = InstanceManager.sensorManagerInstance().getSensor("blocksouthsidingoccupied");
    Assert.assertNotNull(occupiedsensor[8]);
    blockstotest[9] = InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blocksouthwest");
    Assert.assertNotNull(blockstotest[9]);
    occupiedsensor[9] = InstanceManager.sensorManagerInstance().getSensor("blocksouthwestoccupied");
    Assert.assertNotNull(occupiedsensor[9]);
    blockstotest[10] = InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blockwest");
    Assert.assertNotNull(blockstotest[10]);
    occupiedsensor[10] = InstanceManager.sensorManagerInstance().getSensor("blockwestoccupied");
    Assert.assertNotNull(occupiedsensor[10]);
    blockstotest[11] = InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blockwestsiding");
    Assert.assertNotNull(blockstotest[11]);
    occupiedsensor[11] = InstanceManager.sensorManagerInstance().getSensor("blockwestsidingoccupied");
    Assert.assertNotNull(occupiedsensor[11]);
    // The references are circular so the definitons are split up, ...
    expectedpreviouspaths[0] = 2;
    previousblock[0][0] = blockstotest[10];
    previousblock[0][1] = blockstotest[11];
    expectednextpaths[0] = 2;
    nextblock[0][0] = blockstotest[1];
    nextblock[0][1] = blockstotest[2];
    expectedpreviouspaths[1] = 1;
    previousblock[1][0] = blockstotest[0];
    expectednextpaths[1] = 1;
    nextblock[1][0] = blockstotest[3];
    expectedpreviouspaths[2] = 1;
    previousblock[2][0] = blockstotest[0];
    expectednextpaths[2] = 1;
    nextblock[2][0] = blockstotest[3];
    expectedpreviouspaths[3] = 2;
    previousblock[3][0] = blockstotest[1];
    previousblock[3][1] = blockstotest[2];
    expectednextpaths[3] = 2;
    nextblock[3][0] = blockstotest[4];
    nextblock[3][1] = blockstotest[5];
    expectedpreviouspaths[4] = 1;
    previousblock[4][0] = blockstotest[3];
    expectednextpaths[4] = 1;
    nextblock[4][0] = blockstotest[6];
    expectedpreviouspaths[5] = 1;
    previousblock[5][0] = blockstotest[3];
    expectednextpaths[5] = 1;
    nextblock[5][0] = blockstotest[6];
    expectedpreviouspaths[6] = 2;
    previousblock[6][0] = blockstotest[4];
    previousblock[6][1] = blockstotest[5];
    expectednextpaths[6] = 2;
    nextblock[6][0] = blockstotest[7];
    nextblock[6][1] = blockstotest[8];
    expectedpreviouspaths[7] = 1;
    previousblock[7][0] = blockstotest[6];
    expectednextpaths[7] = 1;
    nextblock[7][0] = blockstotest[9];
    expectedpreviouspaths[8] = 1;
    previousblock[8][0] = blockstotest[6];
    expectednextpaths[8] = 1;
    nextblock[8][0] = blockstotest[9];
    expectedpreviouspaths[9] = 2;
    previousblock[9][0] = blockstotest[7];
    previousblock[9][1] = blockstotest[8];
    expectednextpaths[9] = 2;
    nextblock[9][0] = blockstotest[10];
    nextblock[9][1] = blockstotest[11];
    expectedpreviouspaths[10] = 1;
    previousblock[10][0] = blockstotest[9];
    expectednextpaths[10] = 1;
    nextblock[10][0] = blockstotest[0];
    expectedpreviouspaths[11] = 1;
    previousblock[11][0] = blockstotest[9];
    expectednextpaths[11] = 1;
    nextblock[11][0] = blockstotest[0];
    for (int testblockfocus = 0; testblockfocus < 12; testblockfocus++) {
        // Set to one greater than above
        int expectedcentrepaths = expectedpreviouspaths[testblockfocus] + expectednextpaths[testblockfocus];
        Block focusBlock = blockstotest[testblockfocus];
        Memory expectedtestmemory = InstanceManager.memoryManagerInstance().getMemory("blocknorthmemory");
        expectedtestmemory.setValue("Memory test: " + testblockfocus);
        Assert.assertNotNull(expectedtestmemory);
        // TODO: BOB C: Memory Test
        //            Memory actualtestmemory = (Memory) focusBlock.getValue();
        //            Assert.assertNotNull(actualtestmemory);
        //            Assert.assertEquals("Memory where Focus was: " + testblockfocus, expectedtestmemory, actualtestmemory);
        Assert.assertEquals("Sensor where Focus was: " + testblockfocus, occupiedsensor[testblockfocus].getSystemName(), focusBlock.getSensor().getSystemName());
        List<Path> testpaths = focusBlock.getPaths();
        Assert.assertEquals("Block Path size where Block Focus was: " + testblockfocus, expectedcentrepaths, testpaths.size());
        for (int p = 0; p < expectedpreviouspaths[testblockfocus]; p++) {
            passprevioustest[p] = false;
        }
        for (int n = 0; n < expectednextpaths[testblockfocus]; n++) {
            passnexttest[n] = false;
        }
        for (int i = 0; i < testpaths.size(); i++) {
            Block testblock = testpaths.get(i).getBlock();
            Assert.assertNotNull(testblock);
            for (int p = 0; p < expectedpreviouspaths[testblockfocus]; p++) {
                if (testblock == previousblock[testblockfocus][p]) {
                    passprevioustest[p] = true;
                }
            }
            for (int n = 0; n < expectednextpaths[testblockfocus]; n++) {
                if (testblock == nextblock[testblockfocus][n]) {
                    passnexttest[n] = true;
                }
            }
        }
        for (int p = 0; p < expectedpreviouspaths[testblockfocus]; p++) {
            Assert.assertTrue("Block Focus was: " + testblockfocus + " previous path: " + p, passprevioustest[p]);
        }
        for (int n = 0; n < expectednextpaths[testblockfocus]; n++) {
            Assert.assertTrue("Block Focus was: " + testblockfocus + " next path: " + n, passnexttest[n]);
        }
    }
}

Example 27 with Memory

use of jmri.Memory in project JMRI by JMRI.

the class LogixActionTest method testLogixAction.

@Test
public void testLogixAction() throws Exception {
    jmri.configurexml.ConfigXmlManager cm = new jmri.configurexml.ConfigXmlManager() {
    };
    // load and display sample file. Panel file does not display screen
    java.io.File f = new java.io.File("java/test/jmri/jmrit/logix/valid/LogixActionTest.xml");
    cm.load(f);
    InstanceManager.getDefault(jmri.LogixManager.class).activateAllLogixs();
    Memory im6 = InstanceManager.memoryManagerInstance().getMemory("IM6");
    Assert.assertNotNull("Memory IM6", im6);
    Assert.assertEquals("Contents IM6", "EastToWestOnSiding", im6.getValue());
    /* Find Enable Logix button  <<< I'd like to use jfcunit but can't figure out the usage
         AbstractButtonFinder finder = new AbstractButtonFinder("Enable/Disable Tests" );
         JButton button = ( JButton ) finder.find();
         Assert.assertNotNull(button);   // Fails here after long wait. stack overflow?
         // Click button
         getHelper().enterClickAndLeave( new MouseEventData( this, button ) );
         */
    // OK, do it this way
    Sensor sensor = InstanceManager.sensorManagerInstance().getSensor("enableButton");
    Assert.assertNotNull("Sensor IS5", sensor);
    sensor.setState(Sensor.ACTIVE);
    sensor.setState(Sensor.INACTIVE);
    sensor.setState(Sensor.ACTIVE);
    SignalHead sh1 = InstanceManager.getDefault(jmri.SignalHeadManager.class).getSignalHead("IH1");
    Assert.assertNotNull("shi null", sh1);
    Assert.assertEquals("SignalHead IH1", SignalHead.RED, sh1.getAppearance());
    // do some buttons -Sensors
    sensor = InstanceManager.sensorManagerInstance().getSensor("ISLITERAL");
    Assert.assertNotNull("sensor null", sensor);
    // activate direct logix action
    sensor.setState(Sensor.ACTIVE);
    Sensor is1 = InstanceManager.sensorManagerInstance().getSensor("sensor1");
    Assert.assertNotNull("is1 null", is1);
    // action
    Assert.assertEquals("direct set Sensor IS1 active", Sensor.ACTIVE, is1.getState());
    sensor = InstanceManager.sensorManagerInstance().getSensor("ISINDIRECT");
    Assert.assertNotNull("sensor null", sensor);
    // activate Indirect logix action
    sensor.setState(Sensor.ACTIVE);
    // action
    Assert.assertEquals("Indirect set Sensor IS1 inactive", Sensor.INACTIVE, is1.getState());
    // SignalHead buttons
    Sensor is4 = InstanceManager.sensorManagerInstance().getSensor("IS4");
    Assert.assertNotNull("is4 null", is4);
    // activate direct logix action
    is4.setState(Sensor.ACTIVE);
    Assert.assertEquals("direct set SignalHead IH1 to Green", SignalHead.GREEN, sh1.getAppearance());
    // activate direct logix action
    is4.setState(Sensor.INACTIVE);
    Assert.assertEquals("direct set SignalHead IH1 to Red", SignalHead.RED, sh1.getAppearance());
    Memory im3 = InstanceManager.memoryManagerInstance().getMemory("IM3");
    Assert.assertNotNull("Memory IM3", im3);
    Assert.assertEquals("Contents IM3", "IH1", im3.getValue());
    Sensor is3 = InstanceManager.sensorManagerInstance().getSensor("IS3");
    Assert.assertNotNull("is3 null", is3);
    // activate indirect logix action
    is3.setState(Sensor.ACTIVE);
    Assert.assertEquals("Indirect set SignalHead IH1 to Green", SignalHead.GREEN, sh1.getAppearance());
    // activate indirect logix action
    is3.setState(Sensor.INACTIVE);
    Assert.assertEquals("Indirect set SignalHead IH1 to Red", SignalHead.RED, sh1.getAppearance());
    // change memory value
    im3.setValue("IH2");
    // activate logix action
    is3.setState(Sensor.ACTIVE);
    Assert.assertEquals("Contents IM3", "IH2", im3.getValue());
    SignalHead sh2 = InstanceManager.getDefault(jmri.SignalHeadManager.class).getSignalHead("IH2");
    Assert.assertNotNull("sh2 null", sh2);
    Assert.assertEquals("Indirect SignalHead IH2", SignalHead.GREEN, sh2.getAppearance());
    // Turnout Buttons
    Sensor is6 = InstanceManager.sensorManagerInstance().getSensor("IS6");
    Assert.assertNotNull("is6 null", is6);
    // activate direct logix action
    is6.setState(Sensor.ACTIVE);
    Turnout it2 = InstanceManager.turnoutManagerInstance().getTurnout("IT2");
    Assert.assertNotNull("it2 null", it2);
    Assert.assertEquals("direct set Turnout IT2 to Closed", Turnout.CLOSED, it2.getState());
    Memory im4 = InstanceManager.memoryManagerInstance().getMemory("IM4");
    Assert.assertNotNull("im4 null", im4);
    Assert.assertEquals("Contents IM4", "IT3", im4.getValue());
    Sensor is7 = InstanceManager.sensorManagerInstance().getSensor("IS7");
    Assert.assertNotNull("is7 null", is7);
    // activate indirect logix action
    is7.setState(Sensor.INACTIVE);
    Turnout it3 = InstanceManager.turnoutManagerInstance().getTurnout("IT3");
    Assert.assertNotNull("it3 null", it3);
    Assert.assertEquals("Indirect set Turnout IT2 to Thrown", Turnout.THROWN, it3.getState());
    // activate indirect logix action
    is7.setState(Sensor.ACTIVE);
    Assert.assertEquals("Indirect set Turnout IT2 to Closed", Turnout.CLOSED, it3.getState());
    // change memory value
    im4.setValue("IT2");
    Assert.assertEquals("Contents IM4", "IT2", im4.getValue());
    // activate indirect logix action
    is7.setState(Sensor.INACTIVE);
    Assert.assertEquals("Indirect set Turnout IT2 to Thrown", Turnout.THROWN, it2.getState());
    // activate indirect logix action
    is7.setState(Sensor.ACTIVE);
    Assert.assertEquals("Indirect set Turnout IT2 to Closed", Turnout.CLOSED, it2.getState());
    // OBlock Buttons
    OBlock ob1 = InstanceManager.getDefault(OBlockManager.class).getOBlock("Left");
    Assert.assertEquals("OBlock OB1", (OBlock.OUT_OF_SERVICE | Sensor.INACTIVE), ob1.getState());
    OBlock ob2 = InstanceManager.getDefault(OBlockManager.class).getOBlock("Right");
    Assert.assertEquals("OBlock OB2", (OBlock.TRACK_ERROR | Sensor.INACTIVE), ob2.getState());
    Sensor is8 = InstanceManager.sensorManagerInstance().getSensor("IS8");
    Assert.assertNotNull("is8 null", is8);
    // direct action
    is8.setState(Sensor.ACTIVE);
    Assert.assertEquals("Direct set OBlock OB1 to normal", Sensor.INACTIVE, ob1.getState());
    // direct action
    is8.setState(Sensor.INACTIVE);
    Assert.assertEquals("Direct set OBlock OB1 to OOS", (OBlock.OUT_OF_SERVICE | Sensor.INACTIVE), ob1.getState());
    Sensor is9 = InstanceManager.sensorManagerInstance().getSensor("IS9");
    Assert.assertNotNull("is9 null", is9);
    // indirect action
    is9.setState(Sensor.ACTIVE);
    Assert.assertEquals("Indirect set OBlock OB2 to normal", Sensor.INACTIVE, ob2.getState());
    // change memory value
    Memory im5 = InstanceManager.memoryManagerInstance().getMemory("IM5");
    Assert.assertNotNull("im5 null", im5);
    im5.setValue("OB1");
    // indirect action
    is9.setState(Sensor.INACTIVE);
    Assert.assertEquals("Indirect set OBlock OB1 to normal", (OBlock.TRACK_ERROR | OBlock.OUT_OF_SERVICE | Sensor.INACTIVE), ob1.getState());
    // indirect action
    is9.setState(Sensor.ACTIVE);
    // indirect action
    is8.setState(Sensor.ACTIVE);
    Assert.assertEquals("Direct set OBlock OB1 to normal", Sensor.INACTIVE, ob1.getState());
    // Warrant buttons
    Sensor is14 = InstanceManager.sensorManagerInstance().getSensor("IS14");
    Assert.assertNotNull("is14 null", is14);
    // indirect action
    is14.setState(Sensor.ACTIVE);
    Warrant w = InstanceManager.getDefault(WarrantManager.class).getWarrant("EastToWestOnSiding");
    Assert.assertTrue("warrant EastToWestOnSiding allocated", w.isAllocated());
    Sensor is15 = InstanceManager.sensorManagerInstance().getSensor("IS15");
    Assert.assertNotNull("is15 null", is15);
    // indirect action
    is15.setState(Sensor.ACTIVE);
    Assert.assertFalse("warrant EastToWestOnSiding deallocated", w.isAllocated());
    // change memory value
    im6.setValue("WestToEastOnMain");
    // toggle
    is14.setState(Sensor.INACTIVE);
    // indirect action
    is14.setState(Sensor.ACTIVE);
    Warrant w2 = InstanceManager.getDefault(WarrantManager.class).getWarrant("WestToEastOnMain");
    Assert.assertTrue("warrant WestToEastOnMain allocated", w2.isAllocated());
    im6.setValue("LeftToRightOnPath");
    // toggle
    is14.setState(Sensor.INACTIVE);
    // indirect action
    is14.setState(Sensor.ACTIVE);
    w = InstanceManager.getDefault(WarrantManager.class).getWarrant("LeftToRightOnPath");
    Assert.assertTrue("warrant LeftToRightOnPath allocated", w.isAllocated());
}

Example 28 with Memory

use of jmri.Memory in project JMRI by JMRI.

the class AbstractMemoryManagerConfigXML method store.

/**
     * Default implementation for storing the contents of a MemoryManager
     *
     * @param o Object to store, of type MemoryManager
     * @return Element containing the complete info
     */
@Override
public Element store(Object o) {
    Element memories = new Element("memories");
    setStoreElementClass(memories);
    MemoryManager tm = (MemoryManager) o;
    if (tm != null) {
        java.util.Iterator<String> iter = tm.getSystemNameList().iterator();
        // don't return an element if there are not memories to include
        if (!iter.hasNext()) {
            return null;
        }
        // store the memories
        while (iter.hasNext()) {
            String sname = iter.next();
            if (sname == null) {
                log.error("System name null during store");
                break;
            }
            log.debug("system name is " + sname);
            Memory m = tm.getBySystemName(sname);
            Element elem = new Element("memory");
            elem.addContent(new Element("systemName").addContent(sname));
            // store common part
            storeCommon(m, elem);
            // store value if non-null; null values omitted
            Object obj = m.getValue();
            if (obj != null) {
                if (obj instanceof jmri.jmrit.roster.RosterEntry) {
                    String valueClass = obj.getClass().getName();
                    String value = ((RosterEntry) obj).getId();
                    elem.setAttribute("value", value);
                    elem.setAttribute("valueClass", valueClass);
                } else {
                    String value = obj.toString();
                    elem.setAttribute("value", value);
                }
            }
            log.debug("store Memory " + sname);
            memories.addContent(elem);
        }
    }
    return memories;
}

Example 29 with Memory

use of jmri.Memory in project JMRI by JMRI.

the class JsonMemoryHttpService method doGet.

@Override
public JsonNode doGet(String type, String name, Locale locale) throws JsonException {
    Memory memory = InstanceManager.memoryManagerInstance().getMemory(name);
    ObjectNode data = this.getNamedBean(memory, name, type, locale);
    ObjectNode root = mapper.createObjectNode();
    root.put(TYPE, MEMORY);
    root.put(DATA, data);
    if (memory != null) {
        if (memory.getValue() == null) {
            data.putNull(VALUE);
        } else {
            data.put(VALUE, memory.getValue().toString());
        }
    }
    return root;
}

Example 30 with Memory

use of jmri.Memory in project JMRI by JMRI.

the class MemoryIconXml method load.

/**
     * Load, starting with the memoryicon element, then all the value-icon pairs
     *
     * @param element Top level Element to unpack.
     * @param o       an Editor as an Object
     */
@Override
public void load(Element element, Object o) {
    Editor ed = null;
    MemoryIcon l;
    if (o instanceof LayoutEditor) {
        ed = (LayoutEditor) o;
        l = new jmri.jmrit.display.layoutEditor.MemoryIcon("   ", (LayoutEditor) ed);
    } else if (o instanceof jmri.jmrit.display.Editor) {
        ed = (Editor) o;
        l = new MemoryIcon("", ed);
    } else {
        log.error("Unrecognizable class - " + o.getClass().getName());
        return;
    }
    String name;
    Attribute attr = element.getAttribute("memory");
    if (attr == null) {
        log.error("incorrect information for a memory location; must use memory name");
        ed.loadFailed();
        return;
    } else {
        name = attr.getValue();
    }
    loadTextInfo(l, element);
    Memory m = jmri.InstanceManager.memoryManagerInstance().getMemory(name);
    if (m != null) {
        l.setMemory(name);
    } else {
        log.error("Memory named '" + attr.getValue() + "' not found.");
        ed.loadFailed();
    }
    Attribute a = element.getAttribute("selectable");
    if (a != null && a.getValue().equals("yes")) {
        l.setSelectable(true);
    } else {
        l.setSelectable(false);
    }
    a = element.getAttribute("updateBlockValue");
    if (a != null && a.getValue().equals("yes")) {
        l.updateBlockValueOnChange(true);
    }
    // get the icon pairs
    List<Element> items = element.getChildren("memorystate");
    for (int i = 0; i < items.size(); i++) {
        // get the class, hence the adapter object to do loading
        Element item = items.get(i);
        String iconName = item.getAttribute("icon").getValue();
        NamedIcon icon = NamedIcon.getIconByName(iconName);
        if (icon == null) {
            icon = ed.loadFailed("Memory " + name, iconName);
            if (icon == null) {
                log.info("Memory \"" + name + "\" icon removed for url= " + iconName);
            }
        }
        if (icon != null) {
            String keyValue = item.getAttribute("value").getValue();
            l.addKeyAndIcon(icon, keyValue);
        }
    }
    ed.putItem(l);
    // load individual item's option settings after editor has set its global settings
    loadCommonAttributes(l, Editor.MEMORIES, element);
    int x = 0;
    int y = 0;
    try {
        x = element.getAttribute("x").getIntValue();
        y = element.getAttribute("y").getIntValue();
    } catch (org.jdom2.DataConversionException e) {
        log.error("failed to convert positional attribute");
    }
    l.setOriginalLocation(x, y);
    l.displayState();
}