3 ##############################################################################
4 # Copyright (c) 2015 Ericsson AB and others.
6 # All rights reserved. This program and the accompanying materials
7 # are made available under the terms of the Apache License, Version 2.0
8 # which accompanies this distribution, and is available at
9 # http://www.apache.org/licenses/LICENSE-2.0
10 ##############################################################################
12 # Unittest for yardstick.benchmark.scenarios.networking.pktgen.Pktgen
14 from __future__ import absolute_import
19 from oslo_serialization import jsonutils
21 from yardstick.benchmark.scenarios.networking import pktgen
24 @mock.patch('yardstick.benchmark.scenarios.networking.pktgen.ssh')
25 class PktgenTestCase(unittest.TestCase):
32 'key_filename': 'mykey.key'
37 'key_filename': 'mykey.key',
38 'ipaddr': '172.16.0.138'
42 def test_pktgen_successful_setup(self, mock_ssh):
45 'options': {'packetsize': 60},
47 p = pktgen.Pktgen(args, self.ctx)
50 mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
51 self.assertIsNotNone(p.server)
52 self.assertIsNotNone(p.client)
53 self.assertEqual(p.setup_done, True)
55 def test_pktgen_successful_iptables_setup(self, mock_ssh):
58 'options': {'packetsize': 60, 'number_of_ports': 10},
60 p = pktgen.Pktgen(args, self.ctx)
61 p.server = mock_ssh.SSH.from_node()
62 p.number_of_ports = args['options']['number_of_ports']
64 mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
68 mock_ssh.SSH.from_node().execute.assert_called_with(
70 "sudo iptables -A INPUT -p udp --dport 1000:%s -j DROP"
73 def test_pktgen_unsuccessful_iptables_setup(self, mock_ssh):
76 'options': {'packetsize': 60, 'number_of_ports': 10},
79 p = pktgen.Pktgen(args, self.ctx)
80 p.server = mock_ssh.SSH.from_node()
81 p.number_of_ports = args['options']['number_of_ports']
83 mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
84 self.assertRaises(RuntimeError, p._iptables_setup)
86 def test_pktgen_successful_iptables_get_result(self, mock_ssh):
89 'options': {'packetsize': 60, 'number_of_ports': 10},
92 p = pktgen.Pktgen(args, self.ctx)
93 p.server = mock_ssh.SSH.from_node()
94 p.number_of_ports = args['options']['number_of_ports']
96 mock_ssh.SSH.from_node().execute.return_value = (0, '150000', '')
97 p._iptables_get_result()
99 mock_ssh.SSH.from_node().execute.assert_called_with(
100 "sudo iptables -L INPUT -vnx |"
101 "awk '/dpts:1000:%s/ {{printf \"%%s\", $1}}'"
104 def test_pktgen_unsuccessful_iptables_get_result(self, mock_ssh):
107 'options': {'packetsize': 60, 'number_of_ports': 10},
110 p = pktgen.Pktgen(args, self.ctx)
112 p.server = mock_ssh.SSH.from_node()
113 p.number_of_ports = args['options']['number_of_ports']
115 mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
116 self.assertRaises(RuntimeError, p._iptables_get_result)
118 def test_pktgen_successful_no_sla(self, mock_ssh):
121 'options': {'packetsize': 60, 'number_of_ports': 10},
125 p = pktgen.Pktgen(args, self.ctx)
127 p.server = mock_ssh.SSH.from_node()
128 p.client = mock_ssh.SSH.from_node()
130 mock_iptables_result = mock.Mock()
131 mock_iptables_result.return_value = 149300
132 p._iptables_get_result = mock_iptables_result
134 sample_output = '{"packets_per_second": 9753, "errors": 0, \
135 "packets_sent": 149776, "packetsize": 60, "flows": 110}'
136 mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
139 expected_result = jsonutils.loads(sample_output)
140 expected_result["packets_received"] = 149300
141 expected_result["packetsize"] = 60
142 self.assertEqual(result, expected_result)
144 def test_pktgen_successful_sla(self, mock_ssh):
147 'options': {'packetsize': 60, 'number_of_ports': 10},
148 'sla': {'max_ppm': 10000}
152 p = pktgen.Pktgen(args, self.ctx)
154 p.server = mock_ssh.SSH.from_node()
155 p.client = mock_ssh.SSH.from_node()
157 mock_iptables_result = mock.Mock()
158 mock_iptables_result.return_value = 149300
159 p._iptables_get_result = mock_iptables_result
161 sample_output = '{"packets_per_second": 9753, "errors": 0, \
162 "packets_sent": 149776, "packetsize": 60, "flows": 110}'
163 mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
166 expected_result = jsonutils.loads(sample_output)
167 expected_result["packets_received"] = 149300
168 expected_result["packetsize"] = 60
169 self.assertEqual(result, expected_result)
171 def test_pktgen_unsuccessful_sla(self, mock_ssh):
174 'options': {'packetsize': 60, 'number_of_ports': 10},
175 'sla': {'max_ppm': 1000}
179 p = pktgen.Pktgen(args, self.ctx)
181 p.server = mock_ssh.SSH.from_node()
182 p.client = mock_ssh.SSH.from_node()
184 mock_iptables_result = mock.Mock()
185 mock_iptables_result.return_value = 149300
186 p._iptables_get_result = mock_iptables_result
188 sample_output = '{"packets_per_second": 9753, "errors": 0, \
189 "packets_sent": 149776, "packetsize": 60, "flows": 110}'
190 mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
191 self.assertRaises(AssertionError, p.run, result)
193 def test_pktgen_unsuccessful_script_error(self, mock_ssh):
196 'options': {'packetsize': 60, 'number_of_ports': 10},
197 'sla': {'max_ppm': 1000}
201 p = pktgen.Pktgen(args, self.ctx)
203 p.server = mock_ssh.SSH.from_node()
204 p.client = mock_ssh.SSH.from_node()
206 mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
207 self.assertRaises(RuntimeError, p.run, result)
209 def test_pktgen_get_vnic_driver_name(self, mock_ssh):
211 'options': {'packetsize': 60},
213 p = pktgen.Pktgen(args, self.ctx)
214 p.server = mock_ssh.SSH.from_node()
216 mock_ssh.SSH.from_node().execute.return_value = (0, 'ixgbevf', '')
218 vnic_driver_name = p._get_vnic_driver_name()
219 self.assertEqual(vnic_driver_name, 'ixgbevf')
221 def test_pktgen_unsuccessful_get_vnic_driver_name(self, mock_ssh):
223 'options': {'packetsize': 60},
225 p = pktgen.Pktgen(args, self.ctx)
226 p.server = mock_ssh.SSH.from_node()
228 mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
230 self.assertRaises(RuntimeError, p._get_vnic_driver_name)
232 def test_pktgen_get_sriov_queue_number(self, mock_ssh):
234 'options': {'packetsize': 60},
236 p = pktgen.Pktgen(args, self.ctx)
237 p.server = mock_ssh.SSH.from_node()
239 mock_ssh.SSH.from_node().execute.return_value = (0, '2', '')
241 p.queue_number = p._get_sriov_queue_number()
242 self.assertEqual(p.queue_number, 2)
244 def test_pktgen_unsuccessful_get_sriov_queue_number(self, mock_ssh):
246 'options': {'packetsize': 60},
248 p = pktgen.Pktgen(args, self.ctx)
249 p.server = mock_ssh.SSH.from_node()
251 mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
253 self.assertRaises(RuntimeError, p._get_sriov_queue_number)
255 def test_pktgen_get_available_queue_number(self, mock_ssh):
257 'options': {'packetsize': 60},
259 p = pktgen.Pktgen(args, self.ctx)
260 p.server = mock_ssh.SSH.from_node()
262 mock_ssh.SSH.from_node().execute.return_value = (0, '4', '')
264 p._get_available_queue_number()
266 mock_ssh.SSH.from_node().execute.assert_called_with(
267 "sudo ethtool -l eth0 | grep Combined | head -1 |" \
270 def test_pktgen_unsuccessful_get_available_queue_number(self, mock_ssh):
272 'options': {'packetsize': 60},
274 p = pktgen.Pktgen(args, self.ctx)
275 p.server = mock_ssh.SSH.from_node()
277 mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
279 self.assertRaises(RuntimeError, p._get_available_queue_number)
281 def test_pktgen_get_usable_queue_number(self, mock_ssh):
283 'options': {'packetsize': 60},
285 p = pktgen.Pktgen(args, self.ctx)
286 p.server = mock_ssh.SSH.from_node()
288 mock_ssh.SSH.from_node().execute.return_value = (0, '1', '')
290 p._get_usable_queue_number()
292 mock_ssh.SSH.from_node().execute.assert_called_with(
293 "sudo ethtool -l eth0 | grep Combined | tail -1 |" \
296 def test_pktgen_unsuccessful_get_usable_queue_number(self, mock_ssh):
298 'options': {'packetsize': 60},
300 p = pktgen.Pktgen(args, self.ctx)
301 p.server = mock_ssh.SSH.from_node()
303 mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
305 self.assertRaises(RuntimeError, p._get_usable_queue_number)
307 def test_pktgen_enable_ovs_multiqueue(self, mock_ssh):
309 'options': {'packetsize': 60},
311 p = pktgen.Pktgen(args, self.ctx)
312 p.server = mock_ssh.SSH.from_node()
313 p.client = mock_ssh.SSH.from_node()
315 mock_ssh.SSH.from_node().execute.return_value = (0, '4', '')
317 mock_result1 = mock.Mock()
318 mock_result1.return_value = 1
319 p._get_usable_queue_number = mock_result1
321 mock_result2 = mock.Mock()
322 mock_result2.return_value = 4
323 p._get_available_queue_number = mock_result2
325 p.queue_number = p._enable_ovs_multiqueue()
326 self.assertEqual(p.queue_number, 4)
328 def test_pktgen_enable_ovs_multiqueue_1q(self, mock_ssh):
330 'options': {'packetsize': 60},
332 p = pktgen.Pktgen(args, self.ctx)
333 p.server = mock_ssh.SSH.from_node()
334 p.client = mock_ssh.SSH.from_node()
336 mock_ssh.SSH.from_node().execute.return_value = (0, '1', '')
338 mock_result1 = mock.Mock()
339 mock_result1.return_value = 1
340 p._get_usable_queue_number = mock_result1
342 mock_result2 = mock.Mock()
343 mock_result2.return_value = 1
344 p._get_available_queue_number = mock_result2
346 p.queue_number = p._enable_ovs_multiqueue()
347 self.assertEqual(p.queue_number, 1)
349 def test_pktgen_unsuccessful_enable_ovs_multiqueue(self, mock_ssh):
351 'options': {'packetsize': 60},
353 p = pktgen.Pktgen(args, self.ctx)
354 p.server = mock_ssh.SSH.from_node()
355 p.client = mock_ssh.SSH.from_node()
357 mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
359 mock_result1 = mock.Mock()
360 mock_result1.return_value = 1
361 p._get_usable_queue_number = mock_result1
363 mock_result2 = mock.Mock()
364 mock_result2.return_value = 4
365 p._get_available_queue_number = mock_result2
367 self.assertRaises(RuntimeError, p._enable_ovs_multiqueue)
369 def test_pktgen_setup_irqmapping_ovs(self, mock_ssh):
371 'options': {'packetsize': 60},
373 p = pktgen.Pktgen(args, self.ctx)
374 p.server = mock_ssh.SSH.from_node()
375 p.client = mock_ssh.SSH.from_node()
377 mock_ssh.SSH.from_node().execute.return_value = (0, '10', '')
379 p._setup_irqmapping_ovs(4)
381 mock_ssh.SSH.from_node().execute.assert_called_with(
382 "echo 8 | sudo tee /proc/irq/10/smp_affinity")
384 def test_pktgen_setup_irqmapping_ovs_1q(self, mock_ssh):
386 'options': {'packetsize': 60},
388 p = pktgen.Pktgen(args, self.ctx)
389 p.server = mock_ssh.SSH.from_node()
390 p.client = mock_ssh.SSH.from_node()
392 mock_ssh.SSH.from_node().execute.return_value = (0, '10', '')
394 p._setup_irqmapping_ovs(1)
396 mock_ssh.SSH.from_node().execute.assert_called_with(
397 "echo 1 | sudo tee /proc/irq/10/smp_affinity")
399 def test_pktgen_unsuccessful_setup_irqmapping_ovs(self, mock_ssh):
401 'options': {'packetsize': 60},
403 p = pktgen.Pktgen(args, self.ctx)
404 p.server = mock_ssh.SSH.from_node()
405 p.client = mock_ssh.SSH.from_node()
407 mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
409 self.assertRaises(RuntimeError, p._setup_irqmapping_ovs, 4)
411 def test_pktgen_unsuccessful_setup_irqmapping_ovs_1q(self, mock_ssh):
413 'options': {'packetsize': 60},
415 p = pktgen.Pktgen(args, self.ctx)
416 p.server = mock_ssh.SSH.from_node()
417 p.client = mock_ssh.SSH.from_node()
419 mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
421 self.assertRaises(RuntimeError, p._setup_irqmapping_ovs, 1)
423 def test_pktgen_setup_irqmapping_sriov(self, mock_ssh):
425 'options': {'packetsize': 60},
427 p = pktgen.Pktgen(args, self.ctx)
428 p.server = mock_ssh.SSH.from_node()
429 p.client = mock_ssh.SSH.from_node()
431 mock_ssh.SSH.from_node().execute.return_value = (0, '10', '')
433 p._setup_irqmapping_sriov(2)
435 mock_ssh.SSH.from_node().execute.assert_called_with(
436 "echo 2 | sudo tee /proc/irq/10/smp_affinity")
438 def test_pktgen_setup_irqmapping_sriov_1q(self, mock_ssh):
440 'options': {'packetsize': 60},
442 p = pktgen.Pktgen(args, self.ctx)
443 p.server = mock_ssh.SSH.from_node()
444 p.client = mock_ssh.SSH.from_node()
446 mock_ssh.SSH.from_node().execute.return_value = (0, '10', '')
448 p._setup_irqmapping_sriov(1)
450 mock_ssh.SSH.from_node().execute.assert_called_with(
451 "echo 1 | sudo tee /proc/irq/10/smp_affinity")
453 def test_pktgen_unsuccessful_setup_irqmapping_sriov(self, mock_ssh):
455 'options': {'packetsize': 60},
457 p = pktgen.Pktgen(args, self.ctx)
458 p.server = mock_ssh.SSH.from_node()
459 p.client = mock_ssh.SSH.from_node()
461 mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
463 self.assertRaises(RuntimeError, p._setup_irqmapping_sriov, 2)
465 def test_pktgen_unsuccessful_setup_irqmapping_sriov_1q(self, mock_ssh):
467 'options': {'packetsize': 60},
469 p = pktgen.Pktgen(args, self.ctx)
470 p.server = mock_ssh.SSH.from_node()
471 p.client = mock_ssh.SSH.from_node()
473 mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
475 self.assertRaises(RuntimeError, p._setup_irqmapping_sriov, 1)
477 def test_pktgen_is_irqbalance_disabled(self, mock_ssh):
479 'options': {'packetsize': 60},
481 p = pktgen.Pktgen(args, self.ctx)
482 p.server = mock_ssh.SSH.from_node()
484 mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
486 p._is_irqbalance_disabled()
488 mock_ssh.SSH.from_node().execute.assert_called_with(
489 "grep ENABLED /etc/default/irqbalance")
491 def test_pktgen_unsuccessful_is_irqbalance_disabled(self, mock_ssh):
493 'options': {'packetsize': 60},
495 p = pktgen.Pktgen(args, self.ctx)
496 p.server = mock_ssh.SSH.from_node()
498 mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
500 self.assertRaises(RuntimeError, p._is_irqbalance_disabled)
502 def test_pktgen_disable_irqbalance(self, mock_ssh):
504 'options': {'packetsize': 60},
506 p = pktgen.Pktgen(args, self.ctx)
507 p.server = mock_ssh.SSH.from_node()
508 p.client = mock_ssh.SSH.from_node()
510 mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
512 p._disable_irqbalance()
514 mock_ssh.SSH.from_node().execute.assert_called_with(
515 "sudo service irqbalance disable")
517 def test_pktgen_unsuccessful_disable_irqbalance(self, mock_ssh):
519 'options': {'packetsize': 60},
521 p = pktgen.Pktgen(args, self.ctx)
522 p.server = mock_ssh.SSH.from_node()
523 p.client = mock_ssh.SSH.from_node()
525 mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
527 self.assertRaises(RuntimeError, p._disable_irqbalance)
529 def test_pktgen_multiqueue_setup_ovs(self, mock_ssh):
531 'options': {'packetsize': 60, 'multiqueue': True},
533 p = pktgen.Pktgen(args, self.ctx)
534 p.server = mock_ssh.SSH.from_node()
535 p.client = mock_ssh.SSH.from_node()
537 mock_ssh.SSH.from_node().execute.return_value = (0, '4', '')
539 mock_result1 = mock.Mock()
540 mock_result1.return_value = False
541 p._is_irqbalance_disabled = mock_result1
543 mock_result2 = mock.Mock()
544 mock_result2.return_value = "virtio_net"
545 p._get_vnic_driver_name = mock_result2
547 mock_result3 = mock.Mock()
548 mock_result3.return_value = 1
549 p._get_usable_queue_number = mock_result3
551 mock_result4 = mock.Mock()
552 mock_result4.return_value = 4
553 p._get_available_queue_number = mock_result4
557 self.assertEqual(p.queue_number, 4)
559 def test_pktgen_multiqueue_setup_ovs_1q(self, mock_ssh):
561 'options': {'packetsize': 60, 'multiqueue': True},
563 p = pktgen.Pktgen(args, self.ctx)
564 p.server = mock_ssh.SSH.from_node()
565 p.client = mock_ssh.SSH.from_node()
567 mock_ssh.SSH.from_node().execute.return_value = (0, '1', '')
569 mock_result1 = mock.Mock()
570 mock_result1.return_value = False
571 p._is_irqbalance_disabled = mock_result1
573 mock_result2 = mock.Mock()
574 mock_result2.return_value = "virtio_net"
575 p._get_vnic_driver_name = mock_result2
577 mock_result3 = mock.Mock()
578 mock_result3.return_value = 1
579 p._get_usable_queue_number = mock_result3
581 mock_result4 = mock.Mock()
582 mock_result4.return_value = 1
583 p._get_available_queue_number = mock_result4
587 self.assertEqual(p.queue_number, 1)
589 def test_pktgen_multiqueue_setup_sriov(self, mock_ssh):
591 'options': {'packetsize': 60, 'multiqueue': True},
593 p = pktgen.Pktgen(args, self.ctx)
594 p.server = mock_ssh.SSH.from_node()
595 p.client = mock_ssh.SSH.from_node()
597 mock_ssh.SSH.from_node().execute.return_value = (0, '2', '')
599 mock_result1 = mock.Mock()
600 mock_result1.return_value = False
601 p._is_irqbalance_disabled = mock_result1
603 mock_result2 = mock.Mock()
604 mock_result2.return_value = "ixgbevf"
605 p._get_vnic_driver_name = mock_result2
609 self.assertEqual(p.queue_number, 2)
611 def test_pktgen_multiqueue_setup_sriov_1q(self, mock_ssh):
613 'options': {'packetsize': 60, 'multiqueue': True},
615 p = pktgen.Pktgen(args, self.ctx)
616 p.server = mock_ssh.SSH.from_node()
617 p.client = mock_ssh.SSH.from_node()
619 mock_ssh.SSH.from_node().execute.return_value = (0, '1', '')
621 mock_result1 = mock.Mock()
622 mock_result1.return_value = False
623 p._is_irqbalance_disabled = mock_result1
625 mock_result2 = mock.Mock()
626 mock_result2.return_value = "ixgbevf"
627 p._get_vnic_driver_name = mock_result2
631 self.assertEqual(p.queue_number, 1)
633 def test_pktgen_run_with_setup_done(self, mock_ssh):
635 'options': {'packetsize': 60, 'number_of_ports': 10, 'duration': 20, 'multiqueue': True},
636 'sla': {'max_ppm': 1}
639 p = pktgen.Pktgen(args, self.ctx)
640 p.server = mock_ssh.SSH.from_node()
641 p.client = mock_ssh.SSH.from_node()
644 p.multiqueue_setup_done = True
646 mock_iptables_result = mock.Mock()
647 mock_iptables_result.return_value = 149300
648 p._iptables_get_result = mock_iptables_result
650 sample_output = '{"packets_per_second": 9753, "errors": 0, \
651 "packets_sent": 149300, "flows": 110}'
652 mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
655 expected_result = jsonutils.loads(sample_output)
656 expected_result["packets_received"] = 149300
657 expected_result["packetsize"] = 60
658 self.assertEqual(result, expected_result)
660 def test_pktgen_run_with_ovs_multiqueque(self, mock_ssh):
662 'options': {'packetsize': 60, 'number_of_ports': 10, 'duration': 20, 'multiqueue': True},
663 'sla': {'max_ppm': 1}
667 p = pktgen.Pktgen(args, self.ctx)
669 p.server = mock_ssh.SSH.from_node()
670 p.client = mock_ssh.SSH.from_node()
672 mock_result = mock.Mock()
673 mock_result.return_value = "virtio_net"
674 p._get_vnic_driver_name = mock_result
676 mock_result1 = mock.Mock()
677 mock_result1.return_value = 1
678 p._get_usable_queue_number = mock_result1
680 mock_result2 = mock.Mock()
681 mock_result2.return_value = 4
682 p._get_available_queue_number = mock_result2
684 mock_result3 = mock.Mock()
685 mock_result3.return_value = 4
686 p._enable_ovs_multiqueue = mock_result3
688 mock_result4 = mock.Mock()
689 p._setup_irqmapping_ovs = mock_result4
691 mock_iptables_result = mock.Mock()
692 mock_iptables_result.return_value = 149300
693 p._iptables_get_result = mock_iptables_result
695 sample_output = '{"packets_per_second": 9753, "errors": 0, \
696 "packets_sent": 149300, "flows": 110}'
697 mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
700 expected_result = jsonutils.loads(sample_output)
701 expected_result["packets_received"] = 149300
702 expected_result["packetsize"] = 60
703 self.assertEqual(result, expected_result)
705 def test_pktgen_run_with_sriov_multiqueque(self, mock_ssh):
707 'options': {'packetsize': 60, 'number_of_ports': 10, 'duration': 20, 'multiqueue': True},
708 'sla': {'max_ppm': 1}
712 p = pktgen.Pktgen(args, self.ctx)
714 p.server = mock_ssh.SSH.from_node()
715 p.client = mock_ssh.SSH.from_node()
717 mock_result1 = mock.Mock()
718 mock_result1.return_value = "ixgbevf"
719 p._get_vnic_driver_name = mock_result1
721 mock_result2 = mock.Mock()
722 mock_result2.return_value = 2
723 p._get_sriov_queue_number = mock_result2
725 mock_result3 = mock.Mock()
726 p._setup_irqmapping_sriov = mock_result3
728 mock_iptables_result = mock.Mock()
729 mock_iptables_result.return_value = 149300
730 p._iptables_get_result = mock_iptables_result
732 sample_output = '{"packets_per_second": 9753, "errors": 0, \
733 "packets_sent": 149300, "flows": 110}'
734 mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
737 expected_result = jsonutils.loads(sample_output)
738 expected_result["packets_received"] = 149300
739 expected_result["packetsize"] = 60
740 self.assertEqual(result, expected_result)
745 if __name__ == '__main__':