コード例 #1
0
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
コード例 #2
0
    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)
コード例 #3
0
 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
コード例 #4
0
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)
コード例 #5
0
 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
コード例 #6
0
 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()
コード例 #7
0
ファイル: pkt_decoder.py プロジェクト: ziseputi/fprime
    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)
コード例 #8
0
ファイル: test_pkt_encoder.py プロジェクト: zkneupper/fprime
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),
            )
コード例 #9
0
    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)
コード例 #10
0
    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
コード例 #11
0
 def setUp(self):
     self.t0 = TimeType(0, 0, 0, 0)
     self.t1 = TimeType(0, 0, 1, 0)
     self.t15 = TimeType(0, 0, 1, 500000)
コード例 #12
0
 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
コード例 #13
0
    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)
コード例 #14
0
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),
            )
コード例 #15
0
ファイル: test_ch_encoder.py プロジェクト: zkneupper/fprime
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),
            )
コード例 #16
0
 def get_severity_event(self, severity="DIAGNOSTIC"):
     name = "Severity" + severity
     temp = self.pipeline.dictionaries.event_name[name]
     event = EventData(tuple(), TimeType(), temp)
     return event
コード例 #17
0
        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)
コード例 #18
0
 def __init__(self):
     self.command_count = 0
     self.t0 = TimeType()
     StandardPipeline.__init__(self)