Belle II Software  release-05-01-25
test_hlt.py
1 import os
2 from pathlib import Path
3 from unittest import main
4 import basf2
5 
6 import zmq
7 
8 from zmq_daq.test_support import HLTZMQTestCase
9 
10 
12  """Test case"""
13 
14  event_data = open(basf2.find_file("daq/hbasf2/tests/out.raw"), "br").read()
15 
16  def setUp(self):
17  """Setup port numbers and necessary programs"""
18 
19  self.distributor_input_port = HLTZMQTestCase.get_free_port()
20 
21  self.distributor_output_port = HLTZMQTestCase.get_free_port()
22 
23  self.distributor_monitoring_port = HLTZMQTestCase.get_free_port()
24 
25 
26  self.collector_input_port = HLTZMQTestCase.get_free_port()
27 
28  self.collector_output_port = HLTZMQTestCase.get_free_port()
29 
30  self.collector_monitoring_port = HLTZMQTestCase.get_free_port()
31 
32 
33  self.final_collector_input_port = HLTZMQTestCase.get_free_port()
34 
35  self.final_collector_output_port = HLTZMQTestCase.get_free_port()
36 
37  self.final_collector_monitoring_port = HLTZMQTestCase.get_free_port()
38 
39 
40  self.needed_programs = {
41  "distributor": [
42  "b2hlt_distributor",
43  "--input", f"tcp://localhost:{self.distributor_input_port}",
44  "--output", f"tcp://*:{self.distributor_output_port}",
45  "--monitor", f"tcp://*:{self.distributor_monitoring_port}"
46  ],
47  "collector": [
48  "b2hlt_collector",
49  "--input", f"tcp://*:{self.collector_input_port}",
50  "--output", f"tcp://*:{self.collector_output_port}",
51  "--monitor", f"tcp://*:{self.collector_monitoring_port}"
52  ],
53  "final_collector": [
54  "b2hlt_finalcollector",
55  "--input", f"tcp://*:{self.final_collector_input_port}",
56  "--output", f"tcp://localhost:{self.final_collector_output_port}",
57  "--monitor", f"tcp://*:{self.final_collector_monitoring_port}"
58  ],
59  "worker": [
60  "python3", basf2.find_file("daq/hbasf2/tests/passthrough.no_run_py"),
61  "--input", f"tcp://localhost:{self.distributor_output_port}",
62  "--output", f"tcp://localhost:{self.collector_input_port}"
63  ],
64  "output_worker": [
65  "python3", basf2.find_file("daq/hbasf2/tests/passthrough.no_run_py"),
66  "--prefix", "output_",
67  "--input", f"tcp://localhost:{self.collector_output_port}",
68  "--output", f"tcp://localhost:{self.final_collector_input_port}"
69  ],
70  }
71  super().setUp()
72 
73  def testFullRun(self):
74  """test function"""
75  distributor_monitoring_socket = self.create_socket(self.distributor_monitoring_port)
76  collector_monitoring_socket = self.create_socket(self.collector_monitoring_port)
77  final_collector_monitoring_socket = self.create_socket(self.final_collector_monitoring_port)
78 
79  input_socket = self.create_socket(self.distributor_input_port, socket_type=zmq.STREAM, bind=True)
80  input_identity, _ = self.recv(input_socket)
81 
82  output_socket = self.create_socket(self.final_collector_output_port, socket_type=zmq.STREAM, bind=True)
83  output_identity, _ = self.recv(output_socket)
84 
85  # At the beginning, everything should be at normal state
86  self.assertMonitoring(distributor_monitoring_socket, "input.socket_state", "connected")
87  self.assertMonitoring(distributor_monitoring_socket, "input.socket_connects", 1)
88  self.assertMonitoring(distributor_monitoring_socket, "input.socket_disconnects", 0)
89  self.assertMonitoring(distributor_monitoring_socket, "output.ready_queue_size", 20)
90  self.assertMonitoring(distributor_monitoring_socket, "output.registered_workers", 1)
91 
92  self.assertMonitoring(collector_monitoring_socket, "input.registered_workers", 1)
93  self.assertMonitoring(collector_monitoring_socket, "output.ready_queue_size", 20)
94  self.assertMonitoring(collector_monitoring_socket, "output.registered_workers", 1)
95 
96  self.assertMonitoring(final_collector_monitoring_socket, "input.registered_workers", 1)
97 
98  self.assertHasOutputFile("initialize_called", timeout=1)
99  self.assertHasOutputFile("output_initialize_called", timeout=1)
100 
101  # Now lets try sending some events
102  for _ in range(20):
103  input_socket.send_multipart([input_identity, self.event_data])
104 
105  self.assertMonitoring(distributor_monitoring_socket, "input.socket_state", "connected")
106  self.assertMonitoring(distributor_monitoring_socket, "input.socket_connects", 1)
107  self.assertMonitoring(distributor_monitoring_socket, "input.socket_disconnects", 0)
108  self.assertMonitoring(distributor_monitoring_socket, "output.ready_queue_size", 20)
109  self.assertMonitoring(distributor_monitoring_socket, "output.registered_workers", 1)
110  self.assertMonitoring(distributor_monitoring_socket, "output.sent_events", 20)
111 
112  self.assertMonitoring(collector_monitoring_socket, "input.registered_workers", 1)
113  self.assertMonitoring(collector_monitoring_socket, "input.received_events", 20)
114  self.assertMonitoring(collector_monitoring_socket, "output.ready_queue_size", 20)
115  self.assertMonitoring(collector_monitoring_socket, "output.registered_workers", 1)
116  self.assertMonitoring(collector_monitoring_socket, "output.sent_events", 20)
117 
118  self.assertMonitoring(final_collector_monitoring_socket, "input.registered_workers", 1)
119  self.assertMonitoring(final_collector_monitoring_socket, "input.received_events", 20)
120  self.assertMonitoring(final_collector_monitoring_socket, "output.sent_events", 20)
121 
122  self.assertHasOutputFile("beginrun_called", timeout=1)
123  self.assertHasOutputFile("output_beginrun_called", timeout=1)
124 
125  buffer = b""
126  while output_socket.poll(0):
127  _, msg = self.recv(output_socket)
128  buffer += msg
129  self.assertNothingMore(output_socket)
130 
131  # Data Size != raw data, as data is in different format, size taken from test itself
132  self.assertEqual(len(buffer), 122638 * 20)
133 
134  # Now we stop this run
135  self.send(distributor_monitoring_socket, "l")
136 
137  self.assertMonitoring(distributor_monitoring_socket, "input.socket_state", "connected")
138  self.assertMonitoring(distributor_monitoring_socket, "input.socket_connects", 1)
139  self.assertMonitoring(distributor_monitoring_socket, "input.socket_disconnects", 0)
140  self.assertMonitoring(distributor_monitoring_socket, "output.ready_queue_size", 20)
141  self.assertMonitoring(distributor_monitoring_socket, "output.registered_workers", 1)
142 
143  self.assertMonitoring(collector_monitoring_socket, "input.registered_workers", 1)
144  self.assertMonitoring(collector_monitoring_socket, "input.received_events", 20)
145  self.assertMonitoring(collector_monitoring_socket, "output.ready_queue_size", 20)
146  self.assertMonitoring(collector_monitoring_socket, "output.registered_workers", 1)
147  self.assertMonitoring(collector_monitoring_socket, "input.received_stop_messages", 1)
148  self.assertMonitoring(collector_monitoring_socket, "input.all_stop_messages", 1)
149 
150  self.assertMonitoring(final_collector_monitoring_socket, "input.registered_workers", 1)
151  self.assertMonitoring(final_collector_monitoring_socket, "input.received_events", 20)
152  self.assertMonitoring(final_collector_monitoring_socket, "input.received_stop_messages", 1)
153  self.assertMonitoring(final_collector_monitoring_socket, "input.all_stop_messages", 1)
154 
155  # should go to the workers
156  self.assertHasOutputFile("endrun_called", timeout=1)
157  self.assertHasOutputFile("output_endrun_called", timeout=1)
158 
159  # but not to the output
160  self.assertNothingMore(output_socket)
161 
162  # a second stop message should only reach the first workers up to the collector
163  self.send(distributor_monitoring_socket, "l")
164 
165  self.assertMonitoring(distributor_monitoring_socket, "input.socket_state", "connected")
166  self.assertMonitoring(distributor_monitoring_socket, "input.socket_connects", 1)
167  self.assertMonitoring(distributor_monitoring_socket, "input.socket_disconnects", 0)
168  self.assertMonitoring(distributor_monitoring_socket, "output.ready_queue_size", 20)
169  self.assertMonitoring(distributor_monitoring_socket, "output.registered_workers", 1)
170 
171  self.assertMonitoring(collector_monitoring_socket, "input.registered_workers", 1)
172  self.assertMonitoring(collector_monitoring_socket, "input.received_events", 20)
173  self.assertMonitoring(collector_monitoring_socket, "output.ready_queue_size", 20)
174  self.assertMonitoring(collector_monitoring_socket, "output.registered_workers", 1)
175  self.assertMonitoring(collector_monitoring_socket, "input.received_stop_messages", 1)
176  self.assertMonitoring(collector_monitoring_socket, "input.all_stop_messages", 1)
177 
178  self.assertMonitoring(final_collector_monitoring_socket, "input.registered_workers", 1)
179  self.assertMonitoring(final_collector_monitoring_socket, "input.received_events", 20)
180  self.assertMonitoring(final_collector_monitoring_socket, "input.received_stop_messages", 1)
181  self.assertMonitoring(final_collector_monitoring_socket, "input.all_stop_messages", 1)
182 
183  # should go to the workers (longer timeout as distributor waits a bit)
184  self.assertHasOutputFile("endrun_called", timeout=5)
185  self.assertNotHasOutputFile("output_endrun_called", timeout=1)
186 
187  # Now lets restart the run
188  self.send(distributor_monitoring_socket, "n")
189  self.send(collector_monitoring_socket, "n")
190  self.send(final_collector_monitoring_socket, "n")
191 
192  self.assertMonitoring(distributor_monitoring_socket, "input.socket_state", "connected")
193  self.assertMonitoring(distributor_monitoring_socket, "input.socket_connects", 1)
194  self.assertMonitoring(distributor_monitoring_socket, "input.socket_disconnects", 0)
195  self.assertMonitoring(distributor_monitoring_socket, "output.ready_queue_size", 20)
196  self.assertMonitoring(distributor_monitoring_socket, "output.registered_workers", 1)
197 
198  self.assertMonitoring(collector_monitoring_socket, "input.registered_workers", 1)
199  self.assertMonitoring(collector_monitoring_socket, "input.received_events", 20)
200  self.assertMonitoring(collector_monitoring_socket, "output.ready_queue_size", 20)
201  self.assertMonitoring(collector_monitoring_socket, "output.registered_workers", 1)
202  self.assertMonitoring(collector_monitoring_socket, "input.received_stop_messages", 0)
203  self.assertMonitoring(collector_monitoring_socket, "input.all_stop_messages", 0)
204 
205  self.assertMonitoring(final_collector_monitoring_socket, "input.registered_workers", 1)
206  self.assertMonitoring(final_collector_monitoring_socket, "input.received_events", 20)
207  self.assertMonitoring(final_collector_monitoring_socket, "input.received_stop_messages", 0)
208  self.assertMonitoring(final_collector_monitoring_socket, "input.all_stop_messages", 0)
209 
210  # And send some more events
211  for _ in range(20):
212  input_socket.send_multipart([input_identity, self.event_data])
213 
214  self.assertMonitoring(distributor_monitoring_socket, "input.socket_state", "connected")
215  self.assertMonitoring(distributor_monitoring_socket, "input.socket_connects", 1)
216  self.assertMonitoring(distributor_monitoring_socket, "input.socket_disconnects", 0)
217  self.assertMonitoring(distributor_monitoring_socket, "output.ready_queue_size", 20)
218  self.assertMonitoring(distributor_monitoring_socket, "output.registered_workers", 1)
219  self.assertMonitoring(distributor_monitoring_socket, "output.sent_events", 40)
220 
221  self.assertMonitoring(collector_monitoring_socket, "input.registered_workers", 1)
222  self.assertMonitoring(collector_monitoring_socket, "input.received_events", 40)
223  self.assertMonitoring(collector_monitoring_socket, "output.ready_queue_size", 20)
224  self.assertMonitoring(collector_monitoring_socket, "output.registered_workers", 1)
225  self.assertMonitoring(collector_monitoring_socket, "output.sent_events", 40)
226 
227  self.assertMonitoring(final_collector_monitoring_socket, "input.registered_workers", 1)
228  self.assertMonitoring(final_collector_monitoring_socket, "input.received_events", 40)
229  self.assertMonitoring(final_collector_monitoring_socket, "output.sent_events", 40)
230 
231  self.assertNotHasOutputFile("endrun_called", timeout=1)
232  self.assertNotHasOutputFile("output_endrun_called", timeout=1)
233  self.assertHasOutputFile("beginrun_called", timeout=1)
234  self.assertHasOutputFile("output_beginrun_called", timeout=1)
235 
236  buffer = b""
237  while output_socket.poll(0):
238  _, msg = self.recv(output_socket)
239  buffer += msg
240  self.assertNothingMore(output_socket)
241 
242  # Data Size != raw data, as data is in different format, size taken from test itself
243  self.assertEqual(len(buffer), 122638 * 20)
244 
245  # And finally: terminate everything
246  self.send(distributor_monitoring_socket, "x")
247 
248  self.assertIsDown("collector")
249  self.assertIsDown("final_collector")
250  self.assertIsDown("distributor")
251  self.assertIsDown("worker", timeout=1)
252  self.assertIsDown("output_worker")
253 
254 
256  """Test case"""
257 
258  event_data = open(basf2.find_file("daq/hbasf2/tests/out.raw"), "br").read()
259 
260  def setUp(self):
261  """Setup port numbers and necessary programs"""
262 
263  self.distributor_input_port = HLTZMQTestCase.get_free_port()
264 
265  self.distributor_output_port = HLTZMQTestCase.get_free_port()
266 
267  self.distributor_monitoring_port = HLTZMQTestCase.get_free_port()
268 
269 
270  self.final_collector_input_port = HLTZMQTestCase.get_free_port()
271 
272  self.final_collector_output_port = HLTZMQTestCase.get_free_port()
273 
274  self.final_collector_monitoring_port = HLTZMQTestCase.get_free_port()
275 
276 
278  "distributor": [
279  "b2hlt_distributor",
280  "--input", f"tcp://localhost:{self.distributor_input_port}",
281  "--output", f"tcp://*:{self.distributor_output_port}",
282  "--monitor", f"tcp://*:{self.distributor_monitoring_port}"
283  ],
284  "final_collector": [
285  "b2hlt_finalcollector", "--input", f"tcp://*:{self.final_collector_input_port}",
286  "--output", f"tcp://localhost:{self.final_collector_output_port}",
287  "--monitor", f"tcp://*:{self.final_collector_monitoring_port}"
288  ],
289  "worker": [
290  "python3", basf2.find_file("daq/hbasf2/tests/passthrough.no_run_py"),
291  "--input", f"tcp://localhost:{self.distributor_output_port}",
292  "--output", f"tcp://localhost:{self.final_collector_input_port}"
293  ],
294  "dying_worker": [
295  "python3", basf2.find_file("daq/hbasf2/tests/passthrough.no_run_py"),
296  "--prefix", "dying_", "--exit",
297  "--input", f"tcp://localhost:{self.distributor_output_port}",
298  "--output", f"tcp://localhost:{self.final_collector_input_port}"
299  ],
300  }
301  super().setUp()
302 
303  def testFullRun(self):
304  """test function"""
305  distributor_monitoring_socket = self.create_socket(self.distributor_monitoring_port)
306  final_collector_monitoring_socket = self.create_socket(self.final_collector_monitoring_port)
307 
308  input_socket = self.create_socket(self.distributor_input_port, socket_type=zmq.STREAM, bind=True)
309  input_identity, _ = self.recv(input_socket)
310 
311  output_socket = self.create_socket(self.final_collector_output_port, socket_type=zmq.STREAM, bind=True)
312  output_identity, _ = self.recv(output_socket)
313 
314  # At the beginning, everything should be at normal state
315  self.assertMonitoring(distributor_monitoring_socket, "input.socket_state", "connected")
316  self.assertMonitoring(distributor_monitoring_socket, "input.socket_connects", 1)
317  self.assertMonitoring(distributor_monitoring_socket, "input.socket_disconnects", 0)
318  self.assertMonitoring(distributor_monitoring_socket, "output.ready_queue_size", 40)
319  self.assertMonitoring(distributor_monitoring_socket, "output.registered_workers", 2)
320 
321  self.assertMonitoring(final_collector_monitoring_socket, "input.registered_workers", 2)
322 
323  self.assertHasOutputFile("initialize_called", timeout=1)
324  self.assertHasOutputFile("dying_initialize_called", timeout=1)
325 
326  # Now lets try sending some events
327  for _ in range(100):
328  input_socket.send_multipart([input_identity, self.event_data])
329 
330  self.assertMonitoring(distributor_monitoring_socket, "input.socket_state", "connected")
331  self.assertMonitoring(distributor_monitoring_socket, "input.socket_connects", 1)
332  self.assertMonitoring(distributor_monitoring_socket, "input.socket_disconnects", 0)
333  self.assertMonitoring(distributor_monitoring_socket, "output.ready_queue_size", 40)
334  self.assertMonitoring(distributor_monitoring_socket, "output.registered_workers", 2)
335  self.assertMonitoring(distributor_monitoring_socket, "output.sent_events", 100)
336 
337  self.assertMonitoring(final_collector_monitoring_socket, "input.registered_workers", 2)
338  self.assertMonitoring(final_collector_monitoring_socket, "input.received_events", 100)
339  self.assertMonitoring(final_collector_monitoring_socket, "output.sent_events", 100)
340 
341  self.assertHasOutputFile("beginrun_called", timeout=1)
342  self.assertHasOutputFile("dying_beginrun_called", timeout=1)
343 
344  buffer = b""
345  while output_socket.poll(0):
346  _, msg = self.recv(output_socket)
347  buffer += msg
348  self.assertNothingMore(output_socket)
349 
350  # Data Size != raw data, as data is in different format, size taken from test itself
351  self.assertEqual(len(buffer), 122638 * 100)
352 
353  # Now we kill one of the workers on purpose
354  Path("dying_exit_request").touch()
355 
356  # And send some more events
357  for _ in range(100):
358  input_socket.send_multipart([input_identity, self.event_data])
359 
360  self.assertHasOutputFile("dying_exit_called", timeout=1)
361  self.assertIsDown("dying_worker", timeout=10)
362 
363  buffer = b""
364  while output_socket.poll(0):
365  _, msg = self.recv(output_socket)
366  buffer += msg
367  self.assertNothingMore(output_socket)
368 
369  # We expect to have at least some events (but some will be missing)!
370  # 100 - 20 (queue size of dying worker) - 1 (the event that "caused" the problem) = 79
371  self.assertEqual(len(buffer), 122638 * 79)
372 
373  # The collector should have it removed
374  self.assertMonitoring(final_collector_monitoring_socket, "input.registered_workers", 1)
375 
376  # Also a stop signal should be transported correctly
377  self.send(distributor_monitoring_socket, "l")
378 
379  self.assertMonitoring(distributor_monitoring_socket, "input.socket_state", "connected")
380  self.assertMonitoring(distributor_monitoring_socket, "input.socket_connects", 1)
381  self.assertMonitoring(distributor_monitoring_socket, "input.socket_disconnects", 0)
382  self.assertMonitoring(distributor_monitoring_socket, "output.ready_queue_size", 20)
383  # the distributor does not know about the dying worker, but this is also no problem
384  self.assertMonitoring(distributor_monitoring_socket, "output.registered_workers", 2)
385  self.assertMonitoring(distributor_monitoring_socket, "output.sent_events", 200)
386 
387  self.assertMonitoring(final_collector_monitoring_socket, "input.registered_workers", 1)
388  self.assertMonitoring(final_collector_monitoring_socket, "input.received_events", 179)
389  self.assertMonitoring(final_collector_monitoring_socket, "input.received_stop_messages", 1)
390  self.assertMonitoring(final_collector_monitoring_socket, "input.all_stop_messages", 1)
391 
392  # should go to the workers
393  self.assertHasOutputFile("endrun_called", timeout=1)
394 
395  # Now lets restart the run
396  self.send(distributor_monitoring_socket, "n")
397  self.send(final_collector_monitoring_socket, "n")
398 
399  self.assertMonitoring(distributor_monitoring_socket, "input.socket_state", "connected")
400  self.assertMonitoring(distributor_monitoring_socket, "input.socket_connects", 1)
401  self.assertMonitoring(distributor_monitoring_socket, "input.socket_disconnects", 0)
402  self.assertMonitoring(distributor_monitoring_socket, "output.ready_queue_size", 20)
403  self.assertMonitoring(distributor_monitoring_socket, "output.registered_workers", 2)
404 
405  self.assertMonitoring(final_collector_monitoring_socket, "input.registered_workers", 1)
406  self.assertMonitoring(final_collector_monitoring_socket, "input.received_events", 179)
407  self.assertMonitoring(final_collector_monitoring_socket, "input.received_stop_messages", 0)
408  self.assertMonitoring(final_collector_monitoring_socket, "input.all_stop_messages", 0)
409 
410  for _ in range(100):
411  input_socket.send_multipart([input_identity, self.event_data])
412 
413  self.assertMonitoring(distributor_monitoring_socket, "input.socket_state", "connected")
414  self.assertMonitoring(distributor_monitoring_socket, "input.socket_connects", 1)
415  self.assertMonitoring(distributor_monitoring_socket, "input.socket_disconnects", 0)
416  self.assertMonitoring(distributor_monitoring_socket, "output.ready_queue_size", 20)
417  self.assertMonitoring(distributor_monitoring_socket, "output.registered_workers", 2)
418  self.assertMonitoring(distributor_monitoring_socket, "output.sent_events", 300)
419 
420  self.assertMonitoring(final_collector_monitoring_socket, "input.registered_workers", 1)
421  self.assertMonitoring(final_collector_monitoring_socket, "input.received_events", 279)
422  self.assertMonitoring(final_collector_monitoring_socket, "output.sent_events", 279)
423 
424  self.assertNotHasOutputFile("endrun_called", timeout=1)
425  self.assertHasOutputFile("beginrun_called", timeout=1)
426 
427  buffer = b""
428  while output_socket.poll(0):
429  _, msg = self.recv(output_socket)
430  buffer += msg
431  self.assertNothingMore(output_socket)
432 
433  # Now all events should be transported again
434  self.assertEqual(len(buffer), 122638 * 100)
435 
436  # And finally: terminate everything
437  self.send(distributor_monitoring_socket, "x")
438 
439  self.assertIsDown("final_collector")
440  self.assertIsDown("distributor")
441  self.assertIsDown("worker")
442 
443 
444 if __name__ == '__main__':
445  main()
test_hlt.DyingHLTTestCase.distributor_monitoring_port
distributor_monitoring_port
distributor_monitoring_port
Definition: test_hlt.py:267
zmq_daq.test_support.HLTZMQTestCase.assertNothingMore
def assertNothingMore(self, socket)
Definition: test_support.py:209
test_hlt.DyingHLTTestCase.distributor_output_port
distributor_output_port
distributor_output_port
Definition: test_hlt.py:265
zmq_daq.test_support.HLTZMQTestCase
Definition: test_support.py:17
zmq_daq.test_support.HLTZMQTestCase.needed_programs
needed_programs
The dict name -> cmd args of the programs to start, needs to be set in each test.
Definition: test_support.py:26
zmq_daq.test_support.HLTZMQTestCase.assertIsDown
def assertIsDown(self, name, timeout=5, minimum_delay=0.1)
Definition: test_support.py:81
zmq_daq.test_support.HLTZMQTestCase.recv
def recv(socket)
Definition: test_support.py:147
test_hlt.DyingHLTTestCase.setUp
def setUp(self)
Definition: test_hlt.py:260
zmq_daq.test_support.HLTZMQTestCase.create_socket
def create_socket(port, socket_type=zmq.DEALER, identity="socket", bind=False)
Definition: test_support.py:103
test_hlt.HLTTestCase.final_collector_monitoring_port
final_collector_monitoring_port
final_collector_monitoring_port
Definition: test_hlt.py:37
test_hlt.HLTTestCase.distributor_monitoring_port
distributor_monitoring_port
distributor_monitoring_port
Definition: test_hlt.py:23
zmq_daq.test_support.HLTZMQTestCase.assertNotHasOutputFile
def assertNotHasOutputFile(self, output_file, timeout=0.5)
Definition: test_support.py:233
zmq_daq.test_support.HLTZMQTestCase.assertHasOutputFile
def assertHasOutputFile(self, output_file, unlink=True, timeout=0.5, minimum_delay=0.1)
Definition: test_support.py:215
test_hlt.HLTTestCase.distributor_input_port
distributor_input_port
distributor_input_port
Definition: test_hlt.py:19
test_hlt.HLTTestCase.final_collector_output_port
final_collector_output_port
final_collector_output_port
Definition: test_hlt.py:35
test_hlt.DyingHLTTestCase.distributor_input_port
distributor_input_port
distributor_input_port
Definition: test_hlt.py:263
main
int main(int argc, char **argv)
Run all tests.
Definition: test_main.cc:77
test_hlt.DyingHLTTestCase.event_data
event_data
event_data
Definition: test_hlt.py:258
test_hlt.HLTTestCase.final_collector_input_port
final_collector_input_port
final_collector_input_port
Definition: test_hlt.py:33
test_hlt.DyingHLTTestCase.final_collector_monitoring_port
final_collector_monitoring_port
final_collector_monitoring_port
Definition: test_hlt.py:274
zmq_daq.test_support.HLTZMQTestCase.send
def send(socket, message_type, first_data=b"", second_data=b"", identity="")
Definition: test_support.py:136
test_hlt.DyingHLTTestCase.testFullRun
def testFullRun(self)
Definition: test_hlt.py:303
test_hlt.HLTTestCase.setUp
def setUp(self)
Definition: test_hlt.py:16
test_hlt.DyingHLTTestCase.final_collector_output_port
final_collector_output_port
final_collector_output_port
Definition: test_hlt.py:272
test_hlt.HLTTestCase.event_data
event_data
event_data
Definition: test_hlt.py:14
test_hlt.HLTTestCase.collector_monitoring_port
collector_monitoring_port
collector_monitoring_port
Definition: test_hlt.py:30
zmq_daq.test_support
Definition: test_support.py:1
test_hlt.HLTTestCase.testFullRun
def testFullRun(self)
Definition: test_hlt.py:73
test_hlt.HLTTestCase.distributor_output_port
distributor_output_port
distributor_output_port
Definition: test_hlt.py:21
test_hlt.DyingHLTTestCase.final_collector_input_port
final_collector_input_port
final_collector_input_port
Definition: test_hlt.py:270
test_hlt.HLTTestCase.collector_input_port
collector_input_port
collector_input_port
Definition: test_hlt.py:26
test_hlt.HLTTestCase.collector_output_port
collector_output_port
collector_output_port
Definition: test_hlt.py:28
test_hlt.HLTTestCase
Definition: test_hlt.py:11
zmq_daq.test_support.HLTZMQTestCase.assertMonitoring
def assertMonitoring(self, socket, search_key, search_value, timeout=10)
Definition: test_support.py:157
test_hlt.DyingHLTTestCase
Definition: test_hlt.py:255