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
|
/*******************************************************************************
* Copyright (c) 2004, 2007 Boeing.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Boeing - initial API and implementation
*******************************************************************************/
package org.eclipse.osee.ote.message.elements;
import java.util.Collection;
import org.eclipse.osee.ote.core.environment.interfaces.ITestEnvironmentAccessor;
import org.eclipse.osee.ote.message.Message;
import org.eclipse.osee.ote.message.data.MemoryResource;
import org.eclipse.osee.ote.message.data.MessageData;
import org.eclipse.osee.ote.message.elements.nonmapping.NonMappingSignedInteger16Element;
import org.eclipse.osee.ote.message.interfaces.ITestAccessor;
/**
* @author Ryan D. Brooks
* @author Andrew M. Finkbeiner
*/
public class SignedInteger16Element extends NumericElement<Integer> {
@Override
public void visit(IElementVisitor visitor) {
visitor.asSignedInteger16Element(this);
}
public SignedInteger16Element(Message<?, ?, ?> message, String elementName, MessageData messageData, int byteOffset, int msb, int lsb) {
this(message, elementName, messageData, byteOffset, msb, lsb, msb, lsb);
}
public SignedInteger16Element(Message<?, ?, ?> message, String elementName, MessageData messageData, int bitOffset, int bitLength) {
super(message, elementName, messageData, bitOffset, bitLength);
}
public SignedInteger16Element(Message<?, ?, ?> message, String elementName, MessageData messageData, int byteOffset, int msb, int lsb, int originalLsb, int originalMsb) {
super(message, elementName, messageData, byteOffset, msb, lsb, originalLsb, originalMsb);
}
@Override
public SignedInteger16Element switchMessages(Collection<? extends Message<?, ?, ?>> messages) {
return (SignedInteger16Element) super.switchMessages(messages);
}
@Override
public String toString(Integer obj) {
return obj + "(0x" + Integer.toHexString(obj).toUpperCase() + ")";
}
@Override
public void setValue(Integer value) {
getMsgData().getMem().setInt(value, byteOffset, msb, lsb);
}
@Override
public Integer getValue() {
return Integer.valueOf(getMsgData().getMem().getSignedInt16(byteOffset, msb, lsb));
}
@Override
public Integer valueOf(MemoryResource mem) {
return Integer.valueOf(mem.getSignedInt16(byteOffset, msb, lsb));
}
/**
* Checks that this element correctly forwards a message sent from cause with the value passed.
*
* @param cause The originator of the signal
* @param value The value sent by cause and being forwarded by this element
*/
public void checkForwarding(ITestAccessor accessor, SignedInteger16Element cause, int value) throws InterruptedException {
/* check for 0 to begine */
check(accessor, 0, 0);
/* Set the DP1 Mux Signal */
cause.set(accessor, value);
/* Chk Value on DP2 */
check(accessor, value, 1000);
/* Set DP1 to 0 */
cause.set(accessor, 0);
/* Init DP2 Mux to 0 */
set(accessor, 0);
/* Chk Value on DP2 is still set */
check(accessor, value, 500);
/* Chk DP2 is 0 for two-pulse signals and high for four-pulse signal */
check(accessor, 0, 500);
}
/**
* This function will verify that this signal is pulsed for 2 cycles.
*
* @param value The value to be checked
*/
public void checkPulse(ITestAccessor accessor, int value) throws InterruptedException {
int nonPulsedValue = 0;
if (value == 0) {
nonPulsedValue = 1;
}
checkPulse(accessor, value, nonPulsedValue);
}
/**
* Sets the element to the "value" passed.
*
* @param value The value to set.
*/
public void set(ITestEnvironmentAccessor accessor, int value) {
super.set(accessor, value);
}
/**
* Sets the element to the "value" passed and immediately sends the message that contains it..
*
* @param value The value to set.
*/
public void setAndSend(ITestEnvironmentAccessor accessor, int value) {
this.set(accessor, value);
super.sendMessage();
}
/**
* Waits until the element has a value within the range specified. Either end of the range can be inclusive or not.
*
* @param minValue The minimum value of the range.
* @param minInclusive If the minumum value of the range is inclusive. If true the actual value must not < and not =
* to the range value.
* @param maxValue The maximum value of the range.
* @param maxInclusive If the maximum value of the range is inclusive. If true the actual value must not > and not =
* to the range value.
* @param milliseconds Number of milliseconds to wait before failing.
* @return last value observed
*/
public int waitForRange(ITestEnvironmentAccessor accessor, int minValue, boolean minInclusive, int maxValue, boolean maxInclusive, int milliseconds) throws InterruptedException {
return super.waitForRange(accessor, Integer.valueOf(minValue), minInclusive, Integer.valueOf(maxValue),
maxInclusive, milliseconds);
}
/**
* Waits until the element has a value within the range specified. Range is assumes to be inclusive.
*
* @param minValue The minimum value of the range.
* @param maxValue The maximum value of the range.
* @param milliseconds Number of milliseconds to wait before failing.
* @return last value observed
*/
public int waitForNotRange(ITestEnvironmentAccessor accessor, int minValue, int maxValue, int milliseconds) throws InterruptedException {
return this.waitForNotRange(accessor, minValue, true, maxValue, true, milliseconds);
}
/**
* Waits until the element has a value within the range specified. Either end of the range can be inclusive or not.
*
* @param minValue The minimum value of the range.
* @param minInclusive If the minumum value of the range is inclusive. If true the actual value must not < and not =
* to the range value.
* @param maxValue The maximum value of the range.
* @param maxInclusive If the maximum value of the range is inclusive. If true the actual value must not > and not =
* to the range value.
* @param milliseconds Number of milliseconds to wait before failing.
* @return last value observed
*/
public int waitForNotRange(ITestEnvironmentAccessor accessor, int minValue, boolean minInclusive, int maxValue, boolean maxInclusive, int milliseconds) throws InterruptedException {
return super.waitForNotRange(accessor, Integer.valueOf(minValue), minInclusive, Integer.valueOf(maxValue),
maxInclusive, milliseconds);
}
@Override
public void parseAndSet(ITestEnvironmentAccessor accessor, String value) throws IllegalArgumentException {
this.set(accessor, Integer.parseInt(value));
}
@Override
protected Element getNonMappingElement() {
return new NonMappingSignedInteger16Element(this);
}
@Override
public Integer elementMask(Integer value) {
return value;
}
@Override
public long getNumericBitValue() {
return getValue() & 0xFFFFFFFFL;
}
}
|
