def test_time_type():
"""
Tests the TimeType serialization and deserialization
"""
TIME_SIZE = 11
in_no_err_list = [
(TimeBase["TB_NONE"].value, 1, 100, 999999),
(TimeBase["TB_PROC_TIME"].value, 0xFF, 1234567, 2952),
(TimeBase["TB_WORKSTATION_TIME"].value, 8, 1529430215, 12),
(TimeBase["TB_SC_TIME"].value, 231, 1344230277, 123456),
(TimeBase["TB_FPGA_TIME"].value, 78, 10395, 24556),
(TimeBase["TB_DONT_CARE"].value, 0xB3, 12390819, 12356),
]
in_err_list = [
(10, 58, 15345, 0),
(TimeBase["TB_NONE"].value, 1, 3, -1),
(TimeBase["TB_WORKSTATION_TIME"].value, 1, 700000, 1234567),
]
val = TimeType()
size = val.getSize()
assert size == TIME_SIZE
for (t_base, t_context, secs, usecs) in in_no_err_list:
ser_deser_time_test(t_base, t_context, secs, usecs)
for (t_base, t_context, secs, usecs) in in_err_list:
with pytest.raises(TypeRangeException):
ser_deser_time_test(t_base, t_context, secs, usecs)
def test_telemetry_predicates(self):
temp1 = ChTemplate(1, "Test Channel 1", "Predicate_Tester", I32Type())
temp2 = ChTemplate(2, "Test Channel 2", "Predicate_Tester",
StringType())
update1 = ChData(I32Type(20), TimeType(), temp1)
update2 = ChData(StringType("apple"), TimeType(), temp2)
pred = predicates.telemetry_predicate()
assert pred(
update1
), "If no fields are specified a ChData object should return True"
assert pred(
update2
), "If no fields are specified a ChData object should return True"
assert not pred(
"diff object"
), "Anything that's not a ChData object should be False"
assert not pred(
5), "Anything that's not a ChData object should be False"
self.check_str(pred)
id_pred = predicates.equal_to(1)
pred = predicates.telemetry_predicate(id_pred=id_pred)
assert pred(update1), "This predicate on the ID 1 should return True"
assert not pred(
update2), "This predicate on the ID 2 should return False"
self.check_str(pred)
val_pred = predicates.equal_to("apple")
pred = predicates.telemetry_predicate(value_pred=val_pred)
assert not pred(
update1), "This predicate on the value 20 should return False"
assert pred(
update2
), "This predicate on the value \"apple\" should return True"
self.check_str(pred)
time_pred = predicates.equal_to(0)
pred = predicates.telemetry_predicate(time_pred=time_pred)
assert pred(update1), "This predicate on the time 0 should return True"
assert pred(update2), "This predicate on the time 0 should return True"
self.check_str(pred)
val_pred = predicates.within_range(10, 30)
pred = predicates.telemetry_predicate(id_pred, val_pred, time_pred)
assert pred(
update1), "Specifying all fields should return True for update 1"
assert not pred(
update2), "Specifying all fields should return False for update 2"
self.check_str(pred)
def get_oscillator_sequence(self, length):
seq = []
for i in range(0, length):
ch_temp = self.pipeline.dictionaries.channel_name["Oscillator"]
val = int(round(10 * math.sin(math.radians(i))))
seq.append(ChData(I32Type(val), TimeType(), ch_temp))
return seq
def ser_deser_time_test(t_base, t_context, secs, usecs):
"""
Test serialization/deserialization of TimeType objects.
This test function creates a time type object with the given parameters and
then serializes it and deserializes it. Also prints it for visual inspection
of the formatted output.
Args:
t_base (int): Time base for the new time type object
t_context (int): Time context for the new time type object
secs (int): Seconds value for the new time type object
usecs (int): Seconds value for the new time type object
should_err (int): True if error expected, else False
Returns:
True if test passed, False otherwise
"""
val = TimeType(t_base, t_context, secs, usecs)
buff = val.serialize()
val2 = TimeType()
val2.deserialize(buff, 0)
assert val2.timeBase.value == t_base
assert val2.timeContext == t_context
assert val2.seconds == secs
assert val2.useconds == usecs
def get_range(self, length):
temp1 = ChTemplate(1, "Test Channel 1", "Chrono_Hist_Tester",
I32Type())
chList = []
ts0 = TimeType()
for item in range(length):
tsi = ts0 + time.time()
chList.append(ChData(I32Type(item), tsi, temp1))
return chList
def setUp(self):
for t in self.threads:
if t.isAlive():
t.join()
self.threads.clear()
count = len(self.case_list)
self.api.start_test_case(self._testMethodName, count)
self.case_list.append(1)
self.tHistory = TestHistory()
self.t0 = TimeType()
def __init__(self, cmd_args, cmd_temp, cmd_time=None):
"""
Constructor.
Args:
cmd_args: The arguments for the event. Should match the types of the
arguments in the cmd_temp object. Should be a tuple.
cmd_temp: Command Template instance for this command (this provides
the opcode and argument types are stored)
cmd_time: The time the event should occur. This is for sequences.
Should be a TimeType object with time base=TB_DONT_CARE
Returns:
An initialized CmdData object
"""
super().__init__()
self.id = cmd_temp.get_id()
self.template = cmd_temp
self.arg_vals = cmd_args
self.args = [deepcopy(typ) for (_, _, typ) in self.template.arguments]
self.arg_names = [name for (name, _, _) in self.template.arguments]
if cmd_time:
self.time = cmd_time
else:
self.time = TimeType(TimeBase["TB_DONT_CARE"].value)
errors = []
for val, typ in zip(self.arg_vals, self.args):
try:
self.convert_arg_value(val, typ)
errors.append("")
except Exception as exc:
errors.append(str(exc))
# If any errors occur, then raise a aggregated error
if [error for error in errors if error != ""]:
raise CommandArgumentsException(errors)
def decode_api(self, data):
'''
Decodes the given data and returns the result.
This function allows for non-registered code to call the same decoding
code as is used to parse data passed to the data_callback function.
Args:
data: Binary telemetry channel data to decode
Returns:
Parsed version of the channel telemetry data in the form of a
ChData object or None if the data is not decodable
'''
ptr = 0
# Decode Ch ID here...
id_obj = U32Type()
id_obj.deserialize(data, ptr)
ptr += id_obj.getSize()
ch_id = id_obj.val
# Decode time...
ch_time = TimeType()
ch_time.deserialize(data, ptr)
ptr += ch_time.getSize()
if ch_id in self.__dict:
# Retrieve the template instance for this channel
ch_temp = self.__dict[ch_id]
val_obj = self.decode_ch_val(data, ptr, ch_temp)
return ChData(val_obj, ch_time, ch_temp)
else:
print("Channel decode error: id %d not in dictionary" % ch_id)
return None
def test_pkt_encoder():
"""
Tests the encoding of the packet encoder
"""
config = ConfigManager()
config.set("types", "msg_len", "U16")
enc = PktEncoder()
enc_config = PktEncoder(config)
ch_temp_1 = ChTemplate(101, "test_ch", "test_comp", U32Type())
ch_temp_2 = ChTemplate(102, "test_ch2", "test_comp2", U8Type())
ch_temp_3 = ChTemplate(103, "test_ch3", "test_comp3", U16Type())
pkt_temp = PktTemplate(64, "test_pkt", [ch_temp_1, ch_temp_2, ch_temp_3])
time_obj = TimeType(2, 0, 1533758629, 123456)
ch_obj_1 = ChData(U32Type(1356), time_obj, ch_temp_1)
ch_obj_2 = ChData(U8Type(143), time_obj, ch_temp_2)
ch_obj_3 = ChData(U16Type(1509), time_obj, ch_temp_3)
pkt_obj = PktData([ch_obj_1, ch_obj_2, ch_obj_3], time_obj, pkt_temp)
desc_bin = b"\x00\x00\x00\x04"
id_bin = b"\x00\x40"
time_bin = b"\x00\x02\x00\x5b\x6b\x4c\xa5\x00\x01\xe2\x40"
ch_bin = b"\x00\x00\x05\x4c\x8F\x05\xe5"
long_len_bin = b"\x00\x00\x00\x18"
short_len_bin = b"\x00\x18"
reg_expected = long_len_bin + desc_bin + id_bin + time_bin + ch_bin
config_expected = short_len_bin + desc_bin + id_bin + time_bin + ch_bin
reg_output = enc.encode_api(pkt_obj)
assert (reg_output == reg_expected
), "FAIL: expected regular output to be %s, but found %s" % (
list(reg_expected),
list(reg_output),
)
config_output = enc_config.encode_api(pkt_obj)
assert (config_output == config_expected
), "FAIL: expected configured output to be %s, but found %s" % (
list(config_expected),
list(config_output),
)
def decode_api(self, data):
"""
Decodes the given data and returns the result.
This function allows for non-registered code to call the same decoding
code as is used to parse data passed to the data_callback function.
Args:
data: (bytearray) Binary packetized telemetry data to decode
Returns:
Parsed version of the input data in the form of a PktData object
or None if the data is not decodable
"""
ptr = 0
# Decode Pkt ID here...
id_obj = U16Type()
id_obj.deserialize(data, ptr)
ptr += id_obj.getSize()
pkt_id = id_obj.val
# Decode time...
pkt_time = TimeType()
pkt_time.deserialize(data, ptr)
ptr += pkt_time.getSize()
if pkt_id not in self.__dict:
# Don't crash if can't find pkt. Just notify and keep going
print("Packet decode error: id %d not in dictionary. Time=%s" %
(pkt_id, pkt_time.to_readable()))
print("Full pkt = \n")
for i in data:
print("0x%02x" % ord(i))
return None
# Retrieve the template instance for this channel
pkt_temp = self.__dict[pkt_id]
ch_temps = pkt_temp.get_ch_list()
ch_data_objs = []
for ch_temp in ch_temps:
val_obj = self.decode_ch_val(data, ptr, ch_temp)
ptr += val_obj.getSize()
ch_data_objs.append(ChData(val_obj, pkt_time, ch_temp))
return PktData(ch_data_objs, pkt_time, pkt_temp)
class CmdData(sys_data.SysData):
"""The CmdData class stores a specific command"""
def __init__(self, cmd_args, cmd_temp, cmd_time=None):
"""
Constructor.
Args:
cmd_args: The arguments for the event. Should match the types of the
arguments in the cmd_temp object. Should be a tuple.
cmd_temp: Command Template instance for this command (this provides
the opcode and argument types are stored)
cmd_time: The time the event should occur. This is for sequences.
Should be a TimeType object with time base=TB_DONT_CARE
Returns:
An initialized CmdData object
"""
super().__init__()
self.id = cmd_temp.get_id()
self.template = cmd_temp
self.arg_vals = cmd_args
self.args = [deepcopy(typ) for (_, _, typ) in self.template.arguments]
self.arg_names = [name for (name, _, _) in self.template.arguments]
if cmd_time:
self.time = cmd_time
else:
self.time = TimeType(TimeBase["TB_DONT_CARE"].value)
errors = []
for val, typ in zip(self.arg_vals, self.args):
try:
self.convert_arg_value(val, typ)
errors.append("")
except Exception as exc:
errors.append(str(exc))
# If any errors occur, then raise a aggregated error
if [error for error in errors if error != ""]:
raise CommandArgumentsException(errors)
def get_template(self):
"""Get the template class associate with this specific data object
Returns:
Template -- The template class for this data object
"""
return self.template
def get_id(self):
"""Get the ID associate with the template of this data object
Returns:
An ID number
"""
return self.id
def get_arg_vals(self):
"""Get the values for each argument in a command.
Returns:
list -- a list of value objects that were used in this data object.
"""
return self.arg_vals
def get_args(self):
"""Get the arguments associate with the template of this data object
Returns:
list -- A list of type objects representing the arguments of the template of this data object (in order)
"""
return self.args
def get_str(self, time_zone=None, verbose=False, csv=False):
"""
Convert the command data to a string
Args:
time_zone: (tzinfo, default=None) Timezone to print time in. If
time_zone=None, use local time.
verbose: (boolean, default=False) Prints extra fields if True
csv: (boolean, default=False) Prints each field with commas between
if true
Returns:
String version of the command data
"""
time_str = self.time.to_readable(time_zone)
raw_time_str = str(self.time)
name = self.template.get_full_name()
if self.args is None:
arg_str = "EMPTY COMMAND OBJ"
else:
# The arguments are currently serializable objects which cannot be
# used to fill in a format string. Convert them to values that can be
arg_val_list = [arg_obj.val for arg_obj in self.args]
arg_str = " ".join(str(arg_val_list))
if verbose and csv:
return "%s,%s,%s,%d,%s" % (time_str, raw_time_str, name, self.id,
arg_str)
elif verbose and not csv:
return "%s: %s (%d) %s : %s" % (
time_str,
name,
self.id,
raw_time_str,
arg_str,
)
elif not verbose and csv:
return "{},{},{}".format(time_str, name, arg_str)
else:
return "{}: {} : {}".format(time_str, name, arg_str)
def convert_arg_value(self, arg_val, arg_type):
if arg_val is None:
raise CommandArgumentException(
"Argument value could not be converted to type object")
if isinstance(arg_type, BoolType):
if arg_val == "False":
av = False
else:
av = True
arg_type.val = av
elif isinstance(arg_type, EnumType):
arg_type.val = arg_val
elif isinstance(arg_type, (F64Type, F32Type)):
arg_type.val = float(arg_val)
elif isinstance(
arg_type,
(I64Type, U64Type, I32Type, U32Type, I16Type, U16Type, I8Type,
U8Type),
):
arg_type.val = int(arg_val, 0)
elif isinstance(arg_type, StringType):
arg_type.val = arg_val
# Cannot handle serializable or array argument inputs
elif isinstance(arg_type, (SerializableType, ArrayType)):
pass
else:
raise CommandArgumentException(
"Argument value could not be converted to type object")
def __str__(self):
arg_str = ""
for name, typ in zip(self.arg_names, self.args):
arg_str += ("%s : %s |") % (name, str(typ.val))
arg_str = "w/ args | " + arg_str
arg_info = "%s " % self.template.mnemonic
if len(self.args) > 0:
return arg_info + arg_str
else:
return arg_info
def get_counter_sequence(self, length):
seq = []
for i in range(0, length):
ch_temp = self.pipeline.dictionaries.channel_name["Counter"]
seq.append(ChData(U32Type(i), TimeType(), ch_temp))
return seq
def test_event_predicates(self):
args1_def = [("name", "string", StringType()), ("age", "int", I32Type())]
temp1 = EventTemplate(
1,
"Test Msg 1",
"Predicate Tester",
args1_def,
EventSeverity.ACTIVITY_LO,
"",
)
args1 = (StringType("John"), I32Type(35))
msg1 = EventData(args1, TimeType(), temp1)
args2_def = [
("description", "string", StringType()),
("count", "int", I32Type()),
]
temp2 = EventTemplate(
2,
"Test Msg 2",
"Predicate Tester",
args2_def,
EventSeverity.ACTIVITY_HI,
"",
)
args2 = (StringType("Dozen"), I32Type(12))
msg2 = EventData(args2, TimeType(), temp2)
pred = predicates.event_predicate()
assert pred(
msg1
), "If no fields are specified an EventData object should return True"
assert pred(
msg2
), "If no fields are specified an EventData object should return True"
assert not pred(
"diff object"
), "Anything that's not an EventData object should be False"
assert not pred(5), "Anything that's not a EventData object should be False"
self.check_str(pred)
id_pred = predicates.equal_to(1)
pred = predicates.event_predicate(id_pred=id_pred)
assert pred(msg1), "This predicate on the ID 1 should return True"
assert not pred(msg2), "This predicate on the ID 2 should return False"
self.check_str(pred)
args_pred = predicates.args_predicate([None, None])
pred = predicates.event_predicate(args_pred=args_pred)
assert pred(
msg1
), "This predicate should return True, as it expects an event with 2 args"
assert pred(
msg2
), "This predicate should return True, as it expects an event with 2 args"
self.check_str(pred)
args_pred = predicates.args_predicate(["John", 35])
pred = predicates.event_predicate(args_pred=args_pred)
assert pred(
msg1
), "This predicate should return True as msg1 has args (str John, int32 35)"
assert not pred(
msg2
), "This predicate should return False as msg2 has args (str Dozen, int32 12)"
self.check_str(pred)
severity_pred = predicates.equal_to(EventSeverity.ACTIVITY_LO)
pred = predicates.event_predicate(severity_pred=severity_pred)
assert severity_pred(msg1.get_severity())
assert pred(
msg1
), "This predicate should return True as msg1 has an ACTIVITY_LO severity"
assert not pred(
msg2
), "This predicate should return False as msg2 has an ACTIVITY_HI severity"
self.check_str(pred)
time_pred = predicates.equal_to(0)
pred = predicates.event_predicate(time_pred=time_pred)
assert pred(msg1), "This predicate on the time 0 should return True"
assert pred(msg2), "This predicate on the time 0 should return True"
self.check_str(pred)
pred = predicates.event_predicate(id_pred, args_pred, severity_pred, time_pred)
assert pred(msg1), "Specifying all fields should return True for msg1"
assert not pred(msg2), "Specifying all fields should return False for msg2"
self.check_str(pred)
def get_severity_event(self, severity="DIAGNOSTIC"):
name = "Severity" + severity
temp = self.pipeline.dictionaries.event_name[name]
event = EventData(tuple(), TimeType(), temp)
return event
def test_event_encoder():
"""
Tests the encoding of the event encoder
"""
config = ConfigManager()
config.set("types", "msg_len", "U16")
enc = EventEncoder()
enc_config = EventEncoder(config)
temp = EventTemplate(
101,
"test_ch",
"test_comp",
[("a1", "a1", U32Type()), ("a2", "a2", U32Type())],
EventSeverity["DIAGNOSTIC"],
"%d %d",
)
time_obj = TimeType(2, 0, 1533758629, 123456)
event_obj = EventData((U32Type(42), U32Type(10)), time_obj, temp)
desc_bin = b"\x00\x00\x00\x02"
id_bin = b"\x00\x00\x00\x65"
time_bin = b"\x00\x02\x00\x5b\x6b\x4c\xa5\x00\x01\xe2\x40"
arg_bin = b"\x00\x00\x00\x2a\x00\x00\x00\x0a"
long_len_bin = b"\x00\x00\x00\x1b"
short_len_bin = b"\x00\x1b"
reg_expected = long_len_bin + desc_bin + id_bin + time_bin + arg_bin
config_expected = short_len_bin + desc_bin + id_bin + time_bin + arg_bin
reg_output = enc.encode_api(event_obj)
assert (reg_output == reg_expected
), "FAIL: expected regular output to be %s, but found %s" % (
list(reg_expected),
list(reg_output),
)
config_output = enc_config.encode_api(event_obj)
assert (config_output == config_expected
), "FAIL: expected configured output to be %s, but found %s" % (
list(config_expected),
list(config_output),
)
temp = EventTemplate(
102,
"test_ch2",
"test_comp2",
[("a1", "a1", U8Type()), ("a2", "a2", U16Type())],
EventSeverity["DIAGNOSTIC"],
"%d %d",
)
time_obj = TimeType(2, 0, 1533758628, 123457)
event_obj = EventData((U8Type(128), U16Type(40)), time_obj, temp)
desc_bin = b"\x00\x00\x00\x02"
id_bin = b"\x00\x00\x00\x66"
time_bin = b"\x00\x02\x00\x5b\x6b\x4c\xa4\x00\x01\xe2\x41"
arg_bin = b"\x80\x00\x28"
long_len_bin = b"\x00\x00\x00\x16"
short_len_bin = b"\x00\x16"
reg_expected = long_len_bin + desc_bin + id_bin + time_bin + arg_bin
config_expected = short_len_bin + desc_bin + id_bin + time_bin + arg_bin
reg_output = enc.encode_api(event_obj)
assert (reg_output == reg_expected
), "FAIL: expected regular output to be %s, but found %s" % (
list(reg_expected),
list(reg_output),
)
config_output = enc_config.encode_api(event_obj)
assert (config_output == config_expected
), "FAIL: expected configured output to be %s, but found %s" % (
list(config_expected),
list(config_output),
)
def test_ch_encoder():
"""
Tests the encoding of the channel encoder
"""
config = ConfigManager()
config.set("types", "msg_len", "U16")
enc = ChEncoder()
enc_config = ChEncoder(config)
temp = ChTemplate(101, "test_ch", "test_comp", U32Type())
time_obj = TimeType(2, 0, 1533758629, 123456)
ch_obj = ChData(U32Type(42), time_obj, temp)
desc_bin = b"\x00\x00\x00\x01"
id_bin = b"\x00\x00\x00\x65"
time_bin = b"\x00\x02\x00\x5b\x6b\x4c\xa5\x00\x01\xe2\x40"
val_bin = b"\x00\x00\x00\x2a"
long_len_bin = b"\x00\x00\x00\x17"
short_len_bin = b"\x00\x17"
reg_expected = long_len_bin + desc_bin + id_bin + time_bin + val_bin
config_expected = short_len_bin + desc_bin + id_bin + time_bin + val_bin
reg_output = enc.encode_api(ch_obj)
assert (reg_output == reg_expected
), "FAIL: expected regular output to be %s, but found %s" % (
list(reg_expected),
list(reg_output),
)
config_output = enc_config.encode_api(ch_obj)
assert (config_output == config_expected
), "FAIL: expected configured output to be %s, but found %s" % (
list(config_expected),
list(config_output),
)
temp = ChTemplate(102, "test_ch2", "test_comp2", U16Type())
time_obj = TimeType(2, 0, 1533758628, 123457)
ch_obj = ChData(U16Type(40), time_obj, temp)
desc_bin = b"\x00\x00\x00\x01"
id_bin = b"\x00\x00\x00\x66"
time_bin = b"\x00\x02\x00\x5b\x6b\x4c\xa4\x00\x01\xe2\x41"
val_bin = b"\x00\x28"
long_len_bin = b"\x00\x00\x00\x15"
short_len_bin = b"\x00\x15"
reg_expected = long_len_bin + desc_bin + id_bin + time_bin + val_bin
config_expected = short_len_bin + desc_bin + id_bin + time_bin + val_bin
reg_output = enc.encode_api(ch_obj)
assert (reg_output == reg_expected
), "FAIL: expected regular output to be %s, but found %s" % (
list(reg_expected),
list(reg_output),
)
config_output = enc_config.encode_api(ch_obj)
assert (config_output == config_expected
), "FAIL: expected configured output to be %s, but found %s" % (
list(config_expected),
list(config_output),
)
binary_data = (len_bin + desc_bin + id_bin + time_bin + val_bin)
return binary_data
if __name__ == "__main__":
# Unit Tests
config = ConfigManager()
config.set('types', 'msg_len', 'U16')
enc = ChEncoder()
enc_config = ChEncoder("GUI", config)
temp = ChTemplate(101, "test_ch", "test_comp", U32Type())
time_obj = TimeType(2, 0, 1533758629, 123456)
ch_obj = ChData(U32Type(42), time_obj, temp)
desc_bin = "\x00\x00\x00\x01"
id_bin = "\x00\x00\x00\x65"
time_bin = "\x00\x02\x00\x5b\x6b\x4c\xa5\x00\x01\xe2\x40"
val_bin = "\x00\x00\x00\x2a"
long_len_bin = "\x00\x00\x00\x17"
short_len_bin = "\x00\x17"
reg_expected = (long_len_bin + desc_bin + id_bin + time_bin + val_bin)
config_expected = (short_len_bin + desc_bin + id_bin + time_bin + val_bin)
reg_output = enc.encode_api(ch_obj)
def setUp(self):
self.t0 = TimeType(0, 0, 0, 0)
self.t1 = TimeType(0, 0, 1, 0)
self.t15 = TimeType(0, 0, 1, 500000)
def __init__(self):
self.command_count = 0
self.t0 = TimeType()
StandardPipeline.__init__(self)