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 test_active_logger_filter(self):
self.set_default_filters()
try:
cmd_events = self.api.get_event_pred(
severity=EventSeverity.COMMAND)
actHI_events = self.api.get_event_pred(
severity=EventSeverity.ACTIVITY_HI)
pred = predicates.greater_than(0)
zero = predicates.equal_to(0)
# Drain time for dispatch events
time.sleep(10)
self.assert_command("cmdDisp.CMD_NO_OP")
self.assert_command("cmdDisp.CMD_NO_OP")
time.sleep(0.5)
self.api.assert_event_count(pred, cmd_events)
self.api.assert_event_count(pred, actHI_events)
self.set_event_filter(self.FilterSeverity.COMMAND, False)
# Drain time for dispatch events
time.sleep(10)
self.api.clear_histories()
self.api.send_command("cmdDisp.CMD_NO_OP")
self.api.send_command("cmdDisp.CMD_NO_OP")
time.sleep(0.5)
self.api.assert_event_count(zero, cmd_events)
self.api.assert_event_count(pred, actHI_events)
finally:
self.set_default_filters()
def test_equal_to(self):
pred = predicates.equal_to(1)
assert pred(1), "one is equal to one"
assert not pred(100), "one hundred is not equal to one"
assert not pred(2), "two is not equal to one"
assert not pred(-1), "negative one is not equal to one"
self.check_str(pred)
def test_find_history_sequence_timeout(self):
sequence = []
for i in range(30, 40, 2):
sequence.append(predicates.equal_to(i))
self.fill_history_async(self.tHistory.data_callback, range(0, 50),
0.01)
results = self.api.find_history_sequence(sequence,
self.tHistory,
timeout=1)
assert results is not None, "The search should have found a sequence"
self.assert_lists_equal(range(30, 40, 2), results)
self.fill_history_async(self.tHistory.data_callback, range(0, 50),
0.01)
results = self.api.find_history_sequence(sequence,
self.tHistory,
start=34,
timeout=1)
assert results is not None, "The search should have found a sequence"
self.assert_lists_equal(range(30, 40, 2), results)
self.tHistory.clear()
self.fill_history_async(self.tHistory.data_callback, range(25, 50),
0.1)
results = self.api.find_history_sequence(sequence,
self.tHistory,
start=90,
timeout=1)
assert len(results) != len(
sequence
), "The search should have returned an incomplete list, but found {}".format(
results)
def test_push_and_retrieve_from_predicate(self):
tList = []
for item in self.get_range(50):
self.cHistory.data_callback(item)
tList.append(item)
for item in self.get_range(50):
self.cHistory.data_callback(item)
tList.append(item)
start = predicates.equal_to(tList[45])
self.assert_lists_equal(tList[45:], self.cHistory.retrieve(start))
def test_satisfies_any(self):
p_list = []
p_list.append(predicates.less_than(8))
p_list.append(predicates.less_than(6))
p_list.append(predicates.equal_to(4))
pred = predicates.satisfies_any(p_list)
assert pred(4), "4 satisfies all predicates in the list"
assert pred(5), "5 satisfies only 2 predicates in the list"
assert pred(7), "7 satisfies only 1 predicate in the list"
assert not pred(9), "9 satisfies only no predicates in the list"
self.check_str(pred)
def test_push_and_retrieve_from_predicate(self):
tList = []
for i in range(50):
self.tHistory.data_callback(i)
tList.append(i)
self.tHistory.data_callback("hello")
tList.append("hello")
for i in range(50):
self.tHistory.data_callback(i)
tList.append(i)
start = predicates.equal_to("hello")
self.assert_lists_equal(tList[50:], self.tHistory.retrieve(start))
def test_find_history_item_timeout(self):
pred = predicates.equal_to(25)
listA = range(0, 50)
self.fill_history_async(self.tHistory.data_callback, listA, 0.01)
result = self.api.find_history_item(pred, self.tHistory, timeout=1)
assert result == 25, "The search should have returned 25, but found {}".format(
result)
pred = predicates.equal_to(49)
result = self.api.find_history_item(pred, self.tHistory, timeout=1)
assert result == 49, "The search should have returned 49, but found {}".format(
result)
self.tHistory.clear()
listA = range(0, 50)
pred = predicates.equal_to(49)
self.fill_history_async(self.tHistory.data_callback, listA, 0.1)
result = self.api.find_history_item(pred, self.tHistory, timeout=1)
assert (
result is None
), "The search should have returned None, but found {}".format(result)
def test_find_history_item(self):
self.fill_history(self.tHistory.data_callback, range(0, 50))
self.fill_history(self.tHistory.data_callback, range(0, 50))
pred = predicates.equal_to(25)
result = self.api.find_history_item(pred, self.tHistory)
assert result == 25, "The search should have returned 25, but found {}".format(
result)
result = self.api.find_history_item(pred, self.tHistory, start=50)
assert result == 25, "The search should have returned 25, but found {}".format(
result)
result = self.api.find_history_item(pred, self.tHistory, start=80)
assert (
result is None
), "The search should have returned None, but found {}".format(result)
def test_is_predicate(self):
class dummyPred:
def __call__(self, item):
pass
def __str__(self):
return "dummyPred"
pred = dummyPred()
assert predicates.is_predicate(
pred), "a class with call and str methods satisfies is_predicate()"
pred = object()
assert not predicates.is_predicate(
pred
), "a class without call and str doesn't satisfy is_predicate()"
pred = predicates.predicate()
assert predicates.is_predicate(
pred), "an instance of predicate satisfies is_predicate()"
pred = predicates.equal_to(1)
assert predicates.is_predicate(
pred
), "an instance of a subclass of predicate satisfies is_predicate()"
def test_find_history_sequence(self):
sequence = []
for i in range(30, 40, 2):
sequence.append(predicates.equal_to(i))
self.fill_history(self.tHistory.data_callback, range(0, 50))
results = self.api.find_history_sequence(sequence, self.tHistory)
assert len(results) == len(
sequence
), "The search should have found {}, but returned {}".format(
range(30, 40, 2), results)
self.assert_lists_equal(range(30, 40, 2), results)
results = self.api.find_history_sequence(sequence,
self.tHistory,
start=34)
assert len(results) != len(
sequence
), "The search should have returned an incomplete list, but found {}".format(
results)
self.fill_history(self.tHistory.data_callback, range(0, 50))
results = self.api.find_history_sequence(sequence,
self.tHistory,
start=34)
assert len(results) == len(
sequence
), "The search should have found {}, but returned {}".format(
range(30, 40, 2), results)
self.assert_lists_equal(range(30, 40, 2), results)
results = self.api.find_history_sequence(sequence,
self.tHistory,
start=90)
assert len(results) != len(
sequence
), "The search should have returned an incomplete list, but found {}".format(
results)
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)
