/
SerialAddressTest.java
240 lines (204 loc) · 12.9 KB
/
SerialAddressTest.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
package jmri.jmrix.maple;
import jmri.Manager.NameValidity;
import jmri.util.JUnitAppender;
import jmri.util.JUnitUtil;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
/**
* JUnit tests for the SerialAddress utility class.
*
* @author Dave Duchamp Copyright 2004
*/
public class SerialAddressTest {
@Test
public void testValidateSystemNameFormat() {
Assert.assertTrue("valid format - KL2", NameValidity.VALID == SerialAddress.validSystemNameFormat("KL2", 'L', "K"));
Assert.assertTrue("invalid format - KL", NameValidity.VALID != SerialAddress.validSystemNameFormat("KL", 'L', "K"));
JUnitAppender.assertWarnMessage("missing numerical node address in system name: KL");
Assert.assertTrue("valid format - KL2005", NameValidity.VALID == SerialAddress.validSystemNameFormat("KL2005", 'L', "K"));
Assert.assertTrue("valid format - KT2005", NameValidity.VALID == SerialAddress.validSystemNameFormat("KT2005", 'T', "K"));
Assert.assertTrue("valid format - KS205", NameValidity.VALID == SerialAddress.validSystemNameFormat("KS205", 'S', "K"));
Assert.assertTrue("invalid format - KY2005", NameValidity.VALID != SerialAddress.validSystemNameFormat("KY2005", 'L', "K"));
JUnitAppender.assertErrorMessage("invalid character in header field of system name: KY2005");
Assert.assertTrue("valid format - KL1", NameValidity.VALID == SerialAddress.validSystemNameFormat("KL1", 'L', "K"));
Assert.assertTrue("valid format - KL1000", NameValidity.VALID == SerialAddress.validSystemNameFormat("KL1000", 'L', "K"));
// note: address format is invalid (out of range) as checked upon user input
Assert.assertTrue("invalid format - KL0", NameValidity.VALID != SerialAddress.validSystemNameFormat("KL0", 'L', "K"));
JUnitAppender.assertWarnMessage("node address field out of range in system name - KL0");
Assert.assertTrue("valid format - KL2999", NameValidity.VALID == SerialAddress.validSystemNameFormat("KL2999", 'L', "K"));
Assert.assertTrue("valid format - KL7999", NameValidity.VALID == SerialAddress.validSystemNameFormat("KL7999", 'L', "K"));
Assert.assertTrue("invalid format - KL2oo5", NameValidity.VALID != SerialAddress.validSystemNameFormat("KL2oo5", 'L', "K"));
JUnitAppender.assertWarnMessage("invalid character in number field of system name: KL2oo5");
JUnitAppender.assertWarnMessage("node address field out of range in system name - KL2oo5");
}
@Test
public void testGetBitFromSystemName() {
Assert.assertEquals("KL2", 2, SerialAddress.getBitFromSystemName("KL2", "K"));
Assert.assertEquals("KL2002", 2002, SerialAddress.getBitFromSystemName("KL2002", "K"));
Assert.assertEquals("KL1", 1, SerialAddress.getBitFromSystemName("KL1", "K"));
Assert.assertEquals("KL2001", 2001, SerialAddress.getBitFromSystemName("KL2001", "K"));
Assert.assertEquals("KL999", 999, SerialAddress.getBitFromSystemName("KL999", "K"));
Assert.assertEquals("KL2999", 2999, SerialAddress.getBitFromSystemName("KL2999", "K"));
Assert.assertEquals("KL29O9", 0, SerialAddress.getBitFromSystemName("KL29O9", "K"));
JUnitAppender.assertWarnMessage("invalid character in number field of system name: KL29O9");
}
@Test
public void testValidSystemNameConfig() {
InputBits.setNumInputBits(40);
OutputBits.setNumOutputBits(201);
Assert.assertTrue("valid config KL47", SerialAddress.validSystemNameConfig("KL47", 'L', memo));
Assert.assertTrue("valid config KS17", SerialAddress.validSystemNameConfig("KS17", 'S', memo));
Assert.assertTrue("valid config KL148", SerialAddress.validSystemNameConfig("KL148", 'L', memo));
Assert.assertTrue("invalid config KL1049", !SerialAddress.validSystemNameConfig("KL1049", 'L', memo));
JUnitAppender.assertWarnMessage("Maple hardware address out of range in system name: KL1049");
Assert.assertTrue("valid config KS24", SerialAddress.validSystemNameConfig("KS24", 'S', memo));
Assert.assertTrue("valid config KS40", SerialAddress.validSystemNameConfig("KS40", 'S', memo));
Assert.assertTrue("invalid config KS41", !SerialAddress.validSystemNameConfig("KS41", 'S', memo));
JUnitAppender.assertWarnMessage("Maple hardware address out of range in system name: KS41");
Assert.assertTrue("invalid config KS0", !SerialAddress.validSystemNameConfig("KS0", 'S', memo));
JUnitAppender.assertWarnMessage("node address field out of range in system name - KS0");
Assert.assertTrue("valid config KT201", SerialAddress.validSystemNameConfig("KT201", 'T', memo));
Assert.assertTrue("invalid config KT202", !SerialAddress.validSystemNameConfig("KT202", 'T', memo));
JUnitAppender.assertWarnMessage("Maple hardware address out of range in system name: KT202");
Assert.assertTrue("invalid config KT4129", !SerialAddress.validSystemNameConfig("KT4129", 'T', memo));
JUnitAppender.assertWarnMessage("Maple hardware address out of range in system name: KT4129");
}
@Test
public void testNormalizeSystemName() {
Assert.assertEquals("normalize KL007", "KL7", SerialAddress.normalizeSystemName("KL007", "K"));
Assert.assertEquals("normalize KL004007", "KL4007", SerialAddress.normalizeSystemName("KL004007", "K"));
Assert.assertEquals("normalize KL12007", "", SerialAddress.normalizeSystemName("KL12007", "K"));
JUnitAppender.assertWarnMessage("node address field out of range in system name - KL12007");
}
@Test
public void testConstructSystemName() {
Assert.assertEquals("make KL7", "KL7", SerialAddress.makeSystemName("L", 7, "K"));
Assert.assertEquals("make KT7", "KT7", SerialAddress.makeSystemName("T", 7, "K"));
Assert.assertEquals("make KS7", "KS7", SerialAddress.makeSystemName("S", 7, "K"));
Assert.assertEquals("make illegal 1", "", SerialAddress.makeSystemName("L", 0, "K"));
JUnitAppender.assertWarnMessage("illegal address range proposed for system name - 0");
Assert.assertEquals("make illegal 2", "", SerialAddress.makeSystemName("L", 9990, "K"));
JUnitAppender.assertWarnMessage("illegal address range proposed for system name - 9990");
Assert.assertEquals("make illegal 3", "", SerialAddress.makeSystemName("R", 120, "K"));
JUnitAppender.assertErrorMessage("illegal type character proposed for system name - R");
Assert.assertEquals("make KS999", "KS999", SerialAddress.makeSystemName("S", 999, "K"));
Assert.assertEquals("make KS1000", "KS1000", SerialAddress.makeSystemName("S", 1000, "K"));
}
@Test
public void testIsOutputBitFree() {
// create a new turnout
jmri.TurnoutManager tMgr = memo.getTurnoutManager();
jmri.Turnout t1 = tMgr.newTurnout("KT034", "userT34");
// check that turnout was created correctly including normalizing system name
Assert.assertEquals("create KT34 check 1", "KT34", t1.getSystemName());
// create a new turnout
jmri.Turnout t2 = tMgr.newTurnout("KT32", "userT32");
// check that turnout was created correctly
Assert.assertEquals("create KT32 check 1", "KT32", t2.getSystemName());
// create two new lights
jmri.LightManager lMgr = memo.getLightManager();
jmri.Light lgt1 = lMgr.newLight("KL36", "userL36");
jmri.Light lgt2 = lMgr.newLight("KL037", "userL37");
// check that the lights were created as expected
Assert.assertEquals("create KL36 check", "KL36", lgt1.getSystemName());
Assert.assertEquals("create KL37 check", "KL37", lgt2.getSystemName());
// test
Assert.assertEquals("test bit 30", "", SerialAddress.isOutputBitFree(30, "K"));
Assert.assertEquals("test bit 34", "KT34", SerialAddress.isOutputBitFree(34, "K"));
Assert.assertEquals("test bit 36", "KL36", SerialAddress.isOutputBitFree(36, "K"));
Assert.assertEquals("test bit 37", "KL37", SerialAddress.isOutputBitFree(37, "K"));
Assert.assertEquals("test bit 38", "", SerialAddress.isOutputBitFree(38, "K"));
Assert.assertEquals("test bit 39", "", SerialAddress.isOutputBitFree(39, "K"));
Assert.assertEquals("test bit 1000", "", SerialAddress.isOutputBitFree(1000, "K"));
}
@Test
public void testIsInputBitFree() {
jmri.SensorManager sMgr = memo.getSensorManager();
// create 4 new sensors
jmri.Sensor s1 = sMgr.newSensor("KS16", "userS16");
jmri.Sensor s2 = sMgr.newSensor("KS014", "userS14");
jmri.Sensor s3 = sMgr.newSensor("KS17", "userS17");
jmri.Sensor s4 = sMgr.newSensor("KS12", "userS12");
// check that the sensors were created as expected
Assert.assertEquals("create KS16 check", "KS16", s1.getSystemName());
Assert.assertEquals("create KS14 check", "KS14", s2.getSystemName());
Assert.assertEquals("create KS17 check", "KS17", s3.getSystemName());
Assert.assertEquals("create KS12 check", "KS12", s4.getSystemName());
// test
Assert.assertEquals("test bit 10", "", SerialAddress.isInputBitFree(10, "K"));
Assert.assertEquals("test bit 11", "", SerialAddress.isInputBitFree(11, "K"));
Assert.assertEquals("test bit 12", "KS12", SerialAddress.isInputBitFree(12, "K"));
Assert.assertEquals("test bit 13", "", SerialAddress.isInputBitFree(13, "K"));
Assert.assertEquals("test bit 14", "KS14", SerialAddress.isInputBitFree(14, "K"));
Assert.assertEquals("test bit 15", "", SerialAddress.isInputBitFree(15, "K"));
Assert.assertEquals("test bit 16", "KS16", SerialAddress.isInputBitFree(16, "K"));
Assert.assertEquals("test bit 17", "KS17", SerialAddress.isInputBitFree(17, "K"));
Assert.assertEquals("test bit 18", "", SerialAddress.isInputBitFree(18, "K"));
}
@Test
public void testGetUserNameFromSystemName() {
jmri.SensorManager sMgr = jmri.InstanceManager.sensorManagerInstance();
// create 4 new sensors
sMgr.newSensor("KS16", "userS16");
sMgr.newSensor("KS014", "userS14");
sMgr.newSensor("KS17", "userS17");
sMgr.newSensor("KS12", "userS12");
jmri.LightManager lMgr = memo.getLightManager();
lMgr.newLight("KL36", "userL36");
lMgr.newLight("KL037", "userL37");
jmri.TurnoutManager tMgr = memo.getTurnoutManager();
tMgr.newTurnout("KT32", "userT32");
tMgr.newTurnout("KT34", "userT34");
Assert.assertEquals("test KS16", "userS16", SerialAddress.getUserNameFromSystemName("KS16", "K"));
Assert.assertEquals("test KS12", "userS12", SerialAddress.getUserNameFromSystemName("KS12", "K"));
Assert.assertEquals("test KS17", "userS17", SerialAddress.getUserNameFromSystemName("KS17", "K"));
Assert.assertEquals("test undefined KS10", "", SerialAddress.getUserNameFromSystemName("KS10", "K"));
Assert.assertEquals("test KL37", "userL37", SerialAddress.getUserNameFromSystemName("KL37", "K"));
Assert.assertEquals("test KL36", "userL36", SerialAddress.getUserNameFromSystemName("KL36", "K"));
Assert.assertEquals("test undefined KL30", "", SerialAddress.getUserNameFromSystemName("KL30", "K"));
Assert.assertEquals("test KT32", "userT32", SerialAddress.getUserNameFromSystemName("KT32", "K"));
Assert.assertEquals("test KT34", "userT34", SerialAddress.getUserNameFromSystemName("KT34", "K"));
Assert.assertEquals("test undefined KT39", "", SerialAddress.getUserNameFromSystemName("KT39", "K"));
}
// from here down is testing infrastructure
@Before
public void setUp() {
JUnitUtil.setUp();
// create and register the manager objects
SerialTrafficControlScaffold tc = new SerialTrafficControlScaffold();
memo = new MapleSystemConnectionMemo("K", "Maple");
memo.setTrafficController(tc);
new InputBits(tc);
new OutputBits(tc);
new SerialNode(4, 0,tc);
new SerialNode(10, 0,tc);
new SerialNode(99, 0,tc);
new SerialNode(18, 0,tc);
SerialTurnoutManager l = new SerialTurnoutManager(memo) {
@Override
public void notifyTurnoutCreationError(String conflict, int bitNum) {
}
};
jmri.InstanceManager.setTurnoutManager(l);
memo.setTurnoutManager(l);
SerialLightManager lgt = new SerialLightManager(memo) {
@Override
public void notifyLightCreationError(String conflict, int bitNum) {
}
};
jmri.InstanceManager.setLightManager(lgt);
memo.setLightManager(lgt);
SerialSensorManager s = new SerialSensorManager(memo);
jmri.InstanceManager.setSensorManager(s);
memo.setSensorManager(s);
}
private MapleSystemConnectionMemo memo = null;
// The minimal setup for log4J
@After
public void tearDown() {
memo = null;
JUnitUtil.tearDown();
}
}