test: convert suite_dfilter to use fixtures
authorPeter Wu <peter@lekensteyn.nl>
Thu, 15 Nov 2018 11:38:12 +0000 (12:38 +0100)
committerPeter Wu <peter@lekensteyn.nl>
Thu, 15 Nov 2018 22:57:40 +0000 (22:57 +0000)
Stop using subprocesstest, drop the (now redundant) DFTestCase base
class and use pytest-style fixtures to inject the dependency on tshark.
This approach makes it easier to switch to pytest in the future.
Most substitutions were automated, so no typos should be present.

Change-Id: I3516029162f87423816937410ff63507ff82e96f
Reviewed-on: https://code.wireshark.org/review/30649
Petri-Dish: Peter Wu <peter@lekensteyn.nl>
Tested-by: Petri Dish Buildbot
Reviewed-by: Peter Wu <peter@lekensteyn.nl>
18 files changed:
test/fixtures_ws.py
test/suite_dfilter/dfiltertest.py
test/suite_dfilter/group_bytes_ether.py
test/suite_dfilter/group_bytes_ipv6.py
test/suite_dfilter/group_bytes_type.py
test/suite_dfilter/group_double.py
test/suite_dfilter/group_integer.py
test/suite_dfilter/group_integer_1byte.py
test/suite_dfilter/group_ipv4.py
test/suite_dfilter/group_membership.py
test/suite_dfilter/group_range_method.py
test/suite_dfilter/group_scanner.py
test/suite_dfilter/group_string_type.py
test/suite_dfilter/group_stringz.py
test/suite_dfilter/group_time_relative.py
test/suite_dfilter/group_time_type.py
test/suite_dfilter/group_tvb.py
test/suite_dfilter/group_uint64.py

index 9917910..18be136 100644 (file)
@@ -150,9 +150,9 @@ def base_env(home_path, request):
     env[home_env] = home_path
 
     # Remove this if test instances no longer inherit from SubprocessTestCase?
-    assert isinstance(request.instance, subprocesstest.SubprocessTestCase)
-    # Inject the test environment as default if it was not overridden.
-    request.instance.injected_test_env = env
+    if isinstance(request.instance, subprocesstest.SubprocessTestCase):
+        # Inject the test environment as default if it was not overridden.
+        request.instance.injected_test_env = env
     return env
 
 
@@ -178,9 +178,9 @@ def test_env(base_env, conf_path, request):
     env['WIRESHARK_QUIT_AFTER_CAPTURE'] = '1'
 
     # Remove this if test instances no longer inherit from SubprocessTestCase?
-    assert isinstance(request.instance, subprocesstest.SubprocessTestCase)
-    # Inject the test environment as default if it was not overridden.
-    request.instance.injected_test_env = env
+    if isinstance(request.instance, subprocesstest.SubprocessTestCase):
+        # Inject the test environment as default if it was not overridden.
+        request.instance.injected_test_env = env
     return env
 
 # XXX capture: capture_interface
index 8ac1786..52fb5f9 100644 (file)
@@ -2,35 +2,46 @@
 #
 # SPDX-License-Identifier: GPL-2.0-or-later
 
-import config
-import os.path
-import subprocesstest
+import subprocess
+import fixtures
 
-class DFTestCase(subprocesstest.SubprocessTestCase):
-    """Base class for all tests in this dfilter-test collection."""
 
-
-    def runDFilter(self, dfilter, expected_return=0):
-        # Create the tshark command
-        return self.assertRun((config.cmd_tshark,
+@fixtures.fixture
+def dfilter_cmd(cmd_tshark, capture_file, request):
+    def wrapped(dfilter):
+        return (
+            cmd_tshark,
             "-n",       # No name resolution
             "-r",       # Next arg is trace file to read
-            os.path.join(config.capture_dir, self.trace_file),
+            capture_file(request.instance.trace_file),
             "-Y",       # packet display filter (used to be -R)
             dfilter
-        ), expected_return=expected_return)
+        )
+    return wrapped
 
 
-    def assertDFilterCount(self, dfilter, expected_count):
+@fixtures.fixture
+def checkDFilterCount(dfilter_cmd, base_env):
+    def checkDFilterCount_real(dfilter, expected_count):
         """Run a display filter and expect a certain number of packets."""
+        output = subprocess.check_output(dfilter_cmd(dfilter),
+                                         universal_newlines=True,
+                                         stderr=subprocess.STDOUT,
+                                         env=base_env)
 
-        dfilter_proc = self.runDFilter(dfilter)
-
-        dfp_count = self.countOutput()
+        dfp_count = output.count("\n")
         msg = "Expected %d, got: %s" % (expected_count, dfp_count)
-        self.assertEqual(dfp_count, expected_count, msg)
-
-    def assertDFilterFail(self, dfilter):
-        """Run a display filter and expect tshark to fail"""
-
-        dfilter_proc = self.runDFilter(dfilter, expected_return=self.exit_error)
+        assert dfp_count == expected_count, msg
+    return checkDFilterCount_real
+
+
+@fixtures.fixture
+def checkDFilterFail(dfilter_cmd, base_env):
+    def checkDFilterFail_real(dfilter):
+        """Run a display filter and expect tshark to fail."""
+        exitcode = subprocess.call(dfilter_cmd(dfilter),
+                                   stdout=subprocess.DEVNULL,
+                                   stderr=subprocess.STDOUT,
+                                   env=base_env)
+        assert exitcode == 2, 'Expected process to fail, got %d' % (exitcode,)
+    return checkDFilterFail_real
index 14fecc5..1d5e14e 100644 (file)
 #
 # SPDX-License-Identifier: GPL-2.0-or-later
 
-from suite_dfilter import dfiltertest
+import unittest
+import fixtures
+from suite_dfilter.dfiltertest import *
 
-class case_bytes_ether(dfiltertest.DFTestCase):
+
+@fixtures.uses_fixtures
+class case_bytes_ether(unittest.TestCase):
     trace_file = "ipx_rip.pcap"
 
     ### Note: Bytes test does not yet test FT_INT64.
 
-    def test_eq_1(self):
+    def test_eq_1(self, checkDFilterCount):
         dfilter = "eth.dst == ff:ff:ff:ff:ff:ff"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_eq_2(self):
+    def test_eq_2(self, checkDFilterCount):
         dfilter = "eth.src == ff:ff:ff:ff:ff:ff"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_ne_1(self):
+    def test_ne_1(self, checkDFilterCount):
         dfilter = "eth.dst != ff:ff:ff:ff:ff:ff"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_ne_2(self):
+    def test_ne_2(self, checkDFilterCount):
         dfilter = "eth.src != ff:ff:ff:ff:ff:ff"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_gt_1(self):
+    def test_gt_1(self, checkDFilterCount):
         dfilter = "eth.src > 00:aa:00:a3:e3:ff"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_gt_2(self):
+    def test_gt_2(self, checkDFilterCount):
         dfilter = "eth.src > 00:aa:00:a3:e3:a4"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_gt_3(self):
+    def test_gt_3(self, checkDFilterCount):
         dfilter = "eth.src > 00:aa:00:a3:e3:00"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_ge_1(self):
+    def test_ge_1(self, checkDFilterCount):
         dfilter = "eth.src >= 00:aa:00:a3:e3:ff"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_ge_2(self):
+    def test_ge_2(self, checkDFilterCount):
         dfilter = "eth.src >= 00:aa:00:a3:e3:a4"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_ge_3(self):
+    def test_ge_3(self, checkDFilterCount):
         dfilter = "eth.src >= 00:aa:00:a3:e3:00"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_lt_1(self):
+    def test_lt_1(self, checkDFilterCount):
         dfilter = "eth.src < 00:aa:00:a3:e3:ff"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_lt_2(self):
+    def test_lt_2(self, checkDFilterCount):
         dfilter = "eth.src < 00:aa:00:a3:e3:a4"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_lt_3(self):
+    def test_lt_3(self, checkDFilterCount):
         dfilter = "eth.src < 00:aa:00:a3:e3:00"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_le_1(self):
+    def test_le_1(self, checkDFilterCount):
         dfilter = "eth.src <= 00:aa:00:a3:e3:ff"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_le_2(self):
+    def test_le_2(self, checkDFilterCount):
         dfilter = "eth.src <= 00:aa:00:a3:e3:a4"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_le_3(self):
+    def test_le_3(self, checkDFilterCount):
         dfilter = "eth.src <= 00:aa:00:a3:e3:00"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_slice_1(self):
+    def test_slice_1(self, checkDFilterCount):
         dfilter = "eth.src[0:3] == 00:aa:00"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_slice_2(self):
+    def test_slice_2(self, checkDFilterCount):
         dfilter = "eth.src[-3:3] == a3:e3:a4"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_slice_3(self):
+    def test_slice_3(self, checkDFilterCount):
         dfilter = "eth.src[1:4] == aa:00:a3:e3"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_slice_4(self):
+    def test_slice_4(self, checkDFilterCount):
         dfilter = "eth.src[0] == 00"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_contains_1(self):
+    def test_contains_1(self, checkDFilterCount):
         dfilter = "ipx.src.node contains a3"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_contains_2(self):
+    def test_contains_2(self, checkDFilterCount):
         dfilter = "ipx.src.node contains a3:e3"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_contains_3(self):
+    def test_contains_3(self, checkDFilterCount):
         dfilter = "ipx.src.node contains 00:aa:00:a3:e3:a4"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_contains_4(self):
+    def test_contains_4(self, checkDFilterCount):
         dfilter = "ipx.src.node contains aa:e3"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
index f2964a0..fd3b007 100644 (file)
 #
 # SPDX-License-Identifier: GPL-2.0-or-later
 
-from suite_dfilter import dfiltertest
+import unittest
+import fixtures
+from suite_dfilter.dfiltertest import *
 
-class case_bytes_ipv6(dfiltertest.DFTestCase):
+
+@fixtures.uses_fixtures
+class case_bytes_ipv6(unittest.TestCase):
     trace_file = "ipv6.pcap"
 
-    def test_eq_1(self):
+    def test_eq_1(self, checkDFilterCount):
         dfilter = "ipv6.dst == ff05::9999"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_eq_2(self):
+    def test_eq_2(self, checkDFilterCount):
         dfilter = "ipv6.dst == ff05::9990"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_ne_1(self):
+    def test_ne_1(self, checkDFilterCount):
         dfilter = "ipv6.dst != ff05::9990"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_ne_2(self):
+    def test_ne_2(self, checkDFilterCount):
         dfilter = "ipv6.dst != ff05::9999"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_gt_1(self):
+    def test_gt_1(self, checkDFilterCount):
         dfilter = "ipv6.dst > ff05::0000"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_gt_2(self):
+    def test_gt_2(self, checkDFilterCount):
         dfilter = "ipv6.dst > ff05::9999"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_ge_1(self):
+    def test_ge_1(self, checkDFilterCount):
         dfilter = "ipv6.dst >= ff05::9999"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_ge_2(self):
+    def test_ge_2(self, checkDFilterCount):
         dfilter = "ipv6.dst >= ff05::a000"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_lt_1(self):
+    def test_lt_1(self, checkDFilterCount):
         dfilter = "ipv6.dst < ff05::a000"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_lt_2(self):
+    def test_lt_2(self, checkDFilterCount):
         dfilter = "ipv6.dst < ff05::9999"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_le_1(self):
+    def test_le_1(self, checkDFilterCount):
         dfilter = "ipv6.dst <= ff05::9999"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_le_2(self):
+    def test_le_2(self, checkDFilterCount):
         dfilter = "ipv6.dst <= ff05::9998"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_cidr_eq_1(self):
+    def test_cidr_eq_1(self, checkDFilterCount):
         dfilter = "ipv6.dst == ff05::9999/128"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_cidr_eq_2(self):
+    def test_cidr_eq_2(self, checkDFilterCount):
         dfilter = "ipv6.dst == ff05::0/64"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_cidr_eq_3(self):
+    def test_cidr_eq_3(self, checkDFilterCount):
         dfilter = "ipv6.dst == ff05::ffff/112"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_cidr_eq_4(self):
+    def test_cidr_eq_4(self, checkDFilterCount):
         dfilter = "ipv6.dst == ff04::0/64"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_cidr_ne_1(self):
+    def test_cidr_ne_1(self, checkDFilterCount):
         dfilter = "ipv6.dst != ff05::9999/128"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_cidr_ne_2(self):
+    def test_cidr_ne_2(self, checkDFilterCount):
         dfilter = "ipv6.dst != ff05::0/64"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_cidr_ne_3(self):
+    def test_cidr_ne_3(self, checkDFilterCount):
         dfilter = "ipv6.dst != ff05::ffff/112"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_cidr_ne_4(self):
+    def test_cidr_ne_4(self, checkDFilterCount):
         dfilter = "ipv6.dst != ff04::00/64"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_slice_1(self):
+    def test_slice_1(self, checkDFilterCount):
         dfilter = "ipv6.dst[14:2] == 99:99"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_slice_2(self):
+    def test_slice_2(self, checkDFilterCount):
         dfilter = "ipv6.dst[14:2] == 00:00"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_slice_3(self):
+    def test_slice_3(self, checkDFilterCount):
         dfilter = "ipv6.dst[15:1] == 99"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_slice_4(self):
+    def test_slice_4(self, checkDFilterCount):
         dfilter = "ipv6.dst[15:1] == 00"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
index 91e4271..62aa942 100644 (file)
@@ -2,15 +2,19 @@
 #
 # SPDX-License-Identifier: GPL-2.0-or-later
 
-from suite_dfilter import dfiltertest
+import unittest
+import fixtures
+from suite_dfilter.dfiltertest import *
 
-class case_bytes_type(dfiltertest.DFTestCase):
+
+@fixtures.uses_fixtures
+class case_bytes_type(unittest.TestCase):
     trace_file = "arp.pcap"
 
-    def test_bytes_1(self):
+    def test_bytes_1(self, checkDFilterCount):
         dfilter = "arp.dst.hw == 00:64"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_ipv6_2(self):
+    def test_ipv6_2(self, checkDFilterCount):
         dfilter = "arp.dst.hw == 00:00"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
index 4275a71..8ceeb0d 100644 (file)
@@ -3,65 +3,67 @@
 # SPDX-License-Identifier: GPL-2.0-or-later
 
 import unittest
+import fixtures
+from suite_dfilter.dfiltertest import *
 
-from suite_dfilter import dfiltertest
 
-class case_double(dfiltertest.DFTestCase):
+@fixtures.uses_fixtures
+class case_double(unittest.TestCase):
 
     trace_file = "icmp.pcapng.gz"
 
-    def test_eq_1(self):
+    def test_eq_1(self, checkDFilterCount):
         dfilter = "icmp.resptime == 492.204"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_eq_2(self):
+    def test_eq_2(self, checkDFilterCount):
         dfilter = "icmp.resptime == 492.205"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_gt_1(self):
+    def test_gt_1(self, checkDFilterCount):
         dfilter = "icmp.resptime > 492"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_gt_2(self):
+    def test_gt_2(self, checkDFilterCount):
         dfilter = "icmp.resptime > 492.203"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_gt_3(self):
+    def test_gt_3(self, checkDFilterCount):
         dfilter = "icmp.resptime > 493"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_ge_1(self):
+    def test_ge_1(self, checkDFilterCount):
         dfilter = "icmp.resptime >= 493"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_ge_2(self):
+    def test_ge_2(self, checkDFilterCount):
         dfilter = "icmp.resptime >= 492"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_ge_3(self):
+    def test_ge_3(self, checkDFilterCount):
         dfilter = "icmp.resptime >= 492.204"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_lt_1(self):
+    def test_lt_1(self, checkDFilterCount):
         dfilter = "icmp.resptime < 493"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_lt_2(self):
+    def test_lt_2(self, checkDFilterCount):
         dfilter = "icmp.resptime < 492"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_lt_3(self):
+    def test_lt_3(self, checkDFilterCount):
         dfilter = "icmp.resptime < 492.204"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_le_1(self):
+    def test_le_1(self, checkDFilterCount):
         dfilter = "icmp.resptime <= 492.204"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_le_2(self):
+    def test_le_2(self, checkDFilterCount):
         dfilter = "icmp.resptime <= 493"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_le_3(self):
+    def test_le_3(self, checkDFilterCount):
         dfilter = "icmp.resptime <= 492"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
index 8d8196d..1a6425e 100644 (file)
 #
 # SPDX-License-Identifier: GPL-2.0-or-later
 
-from suite_dfilter import dfiltertest
+import unittest
+import fixtures
+from suite_dfilter.dfiltertest import *
 
-class case_integer(dfiltertest.DFTestCase):
+
+@fixtures.uses_fixtures
+class case_integer(unittest.TestCase):
     trace_file = "ntp.pcap"
 
-    def test_eq_1(self):
+    def test_eq_1(self, checkDFilterCount):
         dfilter = "ip.version == 4"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_eq_2(self):
+    def test_eq_2(self, checkDFilterCount):
         dfilter = "ip.version == 6"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_eq_3(self):
-       # Invalid filter (only one equals sign)
+    def test_eq_3(self, checkDFilterFail):
+        # Invalid filter (only one equals sign)
         dfilter = "ip.version = 4"
-        self.assertDFilterFail(dfilter)
+        checkDFilterFail(dfilter)
 
-    def test_eq_4(self):
-       # Invalid filter
+    def test_eq_4(self, checkDFilterFail):
+        # Invalid filter
         dfilter = "ip.version == the quick brown fox jumps over the lazy dog"
-        self.assertDFilterFail(dfilter)
+        checkDFilterFail(dfilter)
 
-    def test_eq_5(self):
-       # Invalid filter
+    def test_eq_5(self, checkDFilterFail):
+        # Invalid filter
         dfilter = "ip.version == 4 the quick brown fox jumps over the lazy dog"
-        self.assertDFilterFail(dfilter)
+        checkDFilterFail(dfilter)
 
-    def test_ne_1(self):
+    def test_ne_1(self, checkDFilterCount):
         dfilter = "ip.version != 0"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_ne_2(self):
+    def test_ne_2(self, checkDFilterCount):
         dfilter = "ip.version != 4"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_u_gt_1(self):
+    def test_u_gt_1(self, checkDFilterCount):
         dfilter = "ip.version > 3"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_u_gt_2(self):
+    def test_u_gt_2(self, checkDFilterCount):
         dfilter = "ip.version > 4"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_u_gt_3(self):
+    def test_u_gt_3(self, checkDFilterCount):
         dfilter = "ip.version > 5"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_u_ge_1(self):
+    def test_u_ge_1(self, checkDFilterCount):
         dfilter = "ip.version >= 3"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_u_ge_2(self):
+    def test_u_ge_2(self, checkDFilterCount):
         dfilter = "ip.version >= 4"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_u_ge_3(self):
+    def test_u_ge_3(self, checkDFilterCount):
         dfilter = "ip.version >= 5"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_u_lt_1(self):
+    def test_u_lt_1(self, checkDFilterCount):
         dfilter = "ip.version < 3"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_u_lt_2(self):
+    def test_u_lt_2(self, checkDFilterCount):
         dfilter = "ip.version < 4"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_u_lt_3(self):
+    def test_u_lt_3(self, checkDFilterCount):
         dfilter = "ip.version < 5"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_u_le_1(self):
+    def test_u_le_1(self, checkDFilterCount):
         dfilter = "ip.version <= 3"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_u_le_2(self):
+    def test_u_le_2(self, checkDFilterCount):
         dfilter = "ip.version <= 4"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_u_le_3(self):
+    def test_u_le_3(self, checkDFilterCount):
         dfilter = "ip.version <= 5"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_s_gt_1(self):
+    def test_s_gt_1(self, checkDFilterCount):
         dfilter = "ntp.precision > 244"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_s_gt_2(self):
+    def test_s_gt_2(self, checkDFilterCount):
         dfilter = "ntp.precision > 245"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_s_gt_3(self):
+    def test_s_gt_3(self, checkDFilterCount):
         dfilter = "ntp.precision > 246"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_s_ge_1(self):
+    def test_s_ge_1(self, checkDFilterCount):
         dfilter = "ntp.precision >= 244"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_s_ge_2(self):
+    def test_s_ge_2(self, checkDFilterCount):
         dfilter = "ntp.precision >= 245"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_s_ge_3(self):
+    def test_s_ge_3(self, checkDFilterCount):
         dfilter = "ntp.precision >= 246"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_s_lt_1(self):
+    def test_s_lt_1(self, checkDFilterCount):
         dfilter = "ntp.precision < 244"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_s_lt_2(self):
+    def test_s_lt_2(self, checkDFilterCount):
         dfilter = "ntp.precision < 245"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_s_lt_3(self):
+    def test_s_lt_3(self, checkDFilterCount):
         dfilter = "ntp.precision < 246"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_s_le_1(self):
+    def test_s_le_1(self, checkDFilterCount):
         dfilter = "ntp.precision <= 244"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_s_le_2(self):
+    def test_s_le_2(self, checkDFilterCount):
         dfilter = "ntp.precision <= 245"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_s_le_3(self):
+    def test_s_le_3(self, checkDFilterCount):
         dfilter = "ntp.precision <= 246"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_bool_eq_1(self):
+    def test_bool_eq_1(self, checkDFilterCount):
         dfilter = "ip.flags.df == 0"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_bool_eq_2(self):
+    def test_bool_eq_2(self, checkDFilterCount):
         dfilter = "ip.flags.df == 1"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_bool_ne_1(self):
+    def test_bool_ne_1(self, checkDFilterCount):
         dfilter = "ip.flags.df != 1"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_bool_ne_2(self):
+    def test_bool_ne_2(self, checkDFilterCount):
         dfilter = "ip.flags.df != 0"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
index 0043008..c7d2f54 100644 (file)
@@ -2,17 +2,20 @@
 #
 # SPDX-License-Identifier: GPL-2.0-or-later
 
+import unittest
+import fixtures
+from suite_dfilter.dfiltertest import *
 
-from suite_dfilter import dfiltertest
 
-class case_integer_1_byte(dfiltertest.DFTestCase):
+@fixtures.uses_fixtures
+class case_integer_1_byte(unittest.TestCase):
 
     trace_file = "ipx_rip.pcap"
 
-    def test_ipx_1(self):
+    def test_ipx_1(self, checkDFilterCount):
         dfilter = "ipx.src.net == 0x28"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_ipx_2(self):
+    def test_ipx_2(self, checkDFilterCount):
         dfilter = "ipx.src.net == 0x29"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
index 37f8bf1..cf93de8 100644 (file)
 #
 # SPDX-License-Identifier: GPL-2.0-or-later
 
+import unittest
+import fixtures
+from suite_dfilter.dfiltertest import *
 
-from suite_dfilter import dfiltertest
 
-class case_ipv4(dfiltertest.DFTestCase):
+@fixtures.uses_fixtures
+class case_ipv4(unittest.TestCase):
     trace_file = "nfs.pcap"
 
-    def test_uint64_1(self):
+    def test_uint64_1(self, checkDFilterCount):
         dfilter = "nfs.fattr3.size == 264032"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_eq_1(self):
+    def test_eq_1(self, checkDFilterCount):
         dfilter = "ip.src == 172.25.100.14"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_eq_2(self):
+    def test_eq_2(self, checkDFilterCount):
         dfilter = "ip.src == 255.255.255.255"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_ne_1(self):
+    def test_ne_1(self, checkDFilterCount):
         dfilter = "ip.src != 172.25.100.14"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_ne_2(self):
+    def test_ne_2(self, checkDFilterCount):
         dfilter = "ip.src != 255.255.255.255"
-        self.assertDFilterCount(dfilter, 2)
+        checkDFilterCount(dfilter, 2)
 
-    def test_gt_1(self):
+    def test_gt_1(self, checkDFilterCount):
         dfilter = "ip.dst > 198.95.230.200"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_gt_2(self):
+    def test_gt_2(self, checkDFilterCount):
         dfilter = "ip.dst > 198.95.230.20"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_gt_3(self):
+    def test_gt_3(self, checkDFilterCount):
         dfilter = "ip.dst > 198.95.230.10"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_ge_1(self):
+    def test_ge_1(self, checkDFilterCount):
         dfilter = "ip.dst >= 198.95.230.200"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_ge_2(self):
+    def test_ge_2(self, checkDFilterCount):
         dfilter = "ip.dst >= 198.95.230.20"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_ge_3(self):
+    def test_ge_3(self, checkDFilterCount):
         dfilter = "ip.dst >= 198.95.230.10"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_lt_1(self):
+    def test_lt_1(self, checkDFilterCount):
         dfilter = "ip.src < 172.25.100.140"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_lt_2(self):
+    def test_lt_2(self, checkDFilterCount):
         dfilter = "ip.src < 172.25.100.14"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_lt_3(self):
+    def test_lt_3(self, checkDFilterCount):
         dfilter = "ip.src < 172.25.100.10"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_le_1(self):
+    def test_le_1(self, checkDFilterCount):
         dfilter = "ip.src <= 172.25.100.140"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_le_2(self):
+    def test_le_2(self, checkDFilterCount):
         dfilter = "ip.src <= 172.25.100.14"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_le_3(self):
+    def test_le_3(self, checkDFilterCount):
         dfilter = "ip.src <= 172.25.100.10"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_cidr_eq_1(self):
+    def test_cidr_eq_1(self, checkDFilterCount):
         dfilter = "ip.src == 172.25.100.14/32"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_cidr_eq_2(self):
+    def test_cidr_eq_2(self, checkDFilterCount):
         dfilter = "ip.src == 172.25.100.0/24"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_cidr_eq_3(self):
+    def test_cidr_eq_3(self, checkDFilterCount):
         dfilter = "ip.src == 172.25.0.0/16"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_cidr_eq_4(self):
+    def test_cidr_eq_4(self, checkDFilterCount):
         dfilter = "ip.src == 172.0.0.0/8"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_cidr_ne_1(self):
+    def test_cidr_ne_1(self, checkDFilterCount):
         dfilter = "ip.src != 172.25.100.14/32"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_cidr_ne_2(self):
+    def test_cidr_ne_2(self, checkDFilterCount):
         dfilter = "ip.src != 172.25.100.0/24"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_cidr_ne_3(self):
+    def test_cidr_ne_3(self, checkDFilterCount):
         dfilter = "ip.src != 172.25.0.0/16"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_cidr_ne_4(self):
+    def test_cidr_ne_4(self, checkDFilterCount):
         dfilter = "ip.src != 200.0.0.0/8"
-        self.assertDFilterCount(dfilter, 2)
+        checkDFilterCount(dfilter, 2)
 
-    def test_slice_1(self):
+    def test_slice_1(self, checkDFilterCount):
          dfilter = "ip.src[0:2] == ac:19"
-         self.assertDFilterCount(dfilter, 1)
+         checkDFilterCount(dfilter, 1)
 
-    def test_slice_2(self):
+    def test_slice_2(self, checkDFilterCount):
          dfilter = "ip.src[0:2] == 00:00"
-         self.assertDFilterCount(dfilter, 0)
+         checkDFilterCount(dfilter, 0)
 
-    def test_slice_3(self):
+    def test_slice_3(self, checkDFilterCount):
          dfilter = "ip.src[2:2] == 64:0e"
-         self.assertDFilterCount(dfilter, 1)
+         checkDFilterCount(dfilter, 1)
 
-    def test_slice_4(self):
+    def test_slice_4(self, checkDFilterCount):
          dfilter = "ip.src[2:2] == ff:ff"
-         self.assertDFilterCount(dfilter, 0)
+         checkDFilterCount(dfilter, 0)
 
-    def test_count_1(self):
+    def test_count_1(self, checkDFilterCount):
          dfilter = "count(ip.src) == 1"
-         self.assertDFilterCount(dfilter, 2)
+         checkDFilterCount(dfilter, 2)
 
-    def test_count_2(self):
+    def test_count_2(self, checkDFilterCount):
          dfilter = "count(ip.addr) == 2"
-         self.assertDFilterCount(dfilter, 2)
+         checkDFilterCount(dfilter, 2)
index 1c1201a..1c5b267 100644 (file)
@@ -2,45 +2,49 @@
 #
 # SPDX-License-Identifier: GPL-2.0-or-later
 
-from suite_dfilter import dfiltertest
+import unittest
+import fixtures
+from suite_dfilter.dfiltertest import *
 
-class case_membership(dfiltertest.DFTestCase):
+
+@fixtures.uses_fixtures
+class case_membership(unittest.TestCase):
     trace_file = "http.pcap"
 
-    def test_membership_1_match(self):
+    def test_membership_1_match(self, checkDFilterCount):
         dfilter = 'tcp.port in {80 3267}'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_membership_2_range_match(self):
+    def test_membership_2_range_match(self, checkDFilterCount):
         dfilter = 'tcp.port in {80..81}'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_membership_3_range_no_match(self):
+    def test_membership_3_range_no_match(self, checkDFilterCount):
         dfilter = 'tcp.dstport in {1 .. 79 81 .. 65535}'
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_membership_4_range_no_match_multiple(self):
+    def test_membership_4_range_no_match_multiple(self, checkDFilterCount):
         # Verifies that multiple fields cannot satisfy different conditions.
         dfilter = 'tcp.port in {1 .. 79 81 .. 3266 3268 .. 65535}'
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_membership_5_negative_range_float(self):
+    def test_membership_5_negative_range_float(self, checkDFilterCount):
         dfilter = 'frame.time_delta in {-2.0 .. 0.0}'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_membership_6_both_negative_range_float(self):
+    def test_membership_6_both_negative_range_float(self, checkDFilterCount):
         dfilter = 'frame.time_delta in {-20 .. -.7}'
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_membership_7_string(self):
+    def test_membership_7_string(self, checkDFilterCount):
         dfilter = 'http.request.method in {"GET" "HEAD"}'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_membership_8_ip_range(self):
+    def test_membership_8_ip_range(self, checkDFilterCount):
         dfilter = 'ip.addr in { 10.0.0.5 .. 10.0.0.9 10.0.0.1..10.0.0.1 }'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_membership_9_range_weird_float(self):
+    def test_membership_9_range_weird_float(self, checkDFilterCount):
         # expression should be parsed as "0.1 .. .7"
         dfilter = 'frame.time_delta in {0.1...7}'
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
index 2c56854..4570171 100644 (file)
@@ -2,31 +2,35 @@
 #
 # SPDX-License-Identifier: GPL-2.0-or-later
 
-from suite_dfilter import dfiltertest
+import unittest
+import fixtures
+from suite_dfilter.dfiltertest import *
 
-class case_range(dfiltertest.DFTestCase):
+
+@fixtures.uses_fixtures
+class case_range(unittest.TestCase):
     trace_file = "ipx_rip.pcap"
 
-    def test_slice_1_pos(self):
+    def test_slice_1_pos(self, checkDFilterCount):
         dfilter = "ipx.src.node[1] == aa"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_slice_1_neg(self):
+    def test_slice_1_neg(self, checkDFilterCount):
         dfilter = "ipx.src.node[1] == bb"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_slice_1_hex_pos(self):
+    def test_slice_1_hex_pos(self, checkDFilterCount):
         dfilter = "ipx.src.node[1] == 0xaa"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_slice_1_hex_neg(self):
+    def test_slice_1_hex_neg(self, checkDFilterCount):
         dfilter = "ipx.src.node[1] == 0xbb"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_slice_2_pos(self):
+    def test_slice_2_pos(self, checkDFilterCount):
         dfilter = "ipx.src.node[3:2] == a3:e3"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_slice_2_neg(self):
+    def test_slice_2_neg(self, checkDFilterCount):
         dfilter = "ipx.src.node[3:2] == cc:dd"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
index 7ad1b54..4144a0f 100644 (file)
@@ -2,31 +2,35 @@
 #
 # SPDX-License-Identifier: GPL-2.0-or-later
 
-from suite_dfilter import dfiltertest
+import unittest
+import fixtures
+from suite_dfilter.dfiltertest import *
 
-class case_scanner(dfiltertest.DFTestCase):
+
+@fixtures.uses_fixtures
+class case_scanner(unittest.TestCase):
     trace_file = "http.pcap"
 
-    def test_dquote_1(self):
+    def test_dquote_1(self, checkDFilterCount):
         dfilter = 'http.request.method == "HEAD"'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_dquote_2(self):
+    def test_dquote_2(self, checkDFilterCount):
         dfilter = 'http.request.method == "\\x48EAD"'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_dquote_3(self):
+    def test_dquote_3(self, checkDFilterCount):
         dfilter = 'http.request.method == "\\x58EAD"'
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_dquote_4(self):
+    def test_dquote_4(self, checkDFilterCount):
         dfilter = 'http.request.method == "\\110EAD"'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_dquote_5(self):
+    def test_dquote_5(self, checkDFilterCount):
         dfilter = 'http.request.method == "\\111EAD"'
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_dquote_6(self):
+    def test_dquote_6(self, checkDFilterCount):
         dfilter = 'http.request.method == "\\HEAD"'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
index 166ca75..a1c719e 100644 (file)
 #
 # SPDX-License-Identifier: GPL-2.0-or-later
 
-from suite_dfilter import dfiltertest
+import unittest
+import fixtures
+from suite_dfilter.dfiltertest import *
 
-class case_string(dfiltertest.DFTestCase):
+
+@fixtures.uses_fixtures
+class case_string(unittest.TestCase):
     trace_file = "http.pcap"
 
-    def test_eq_1(self):
+    def test_eq_1(self, checkDFilterCount):
         dfilter = 'http.request.method == "HEAD"'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_eq_2(self):
+    def test_eq_2(self, checkDFilterCount):
         dfilter = 'http.request.method == "POST"'
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_gt_1(self):
+    def test_gt_1(self, checkDFilterCount):
         dfilter = 'http.request.method > "HEAC"'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_gt_2(self):
+    def test_gt_2(self, checkDFilterCount):
         dfilter = 'http.request.method > "HEAD"'
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_gt_3(self):
+    def test_gt_3(self, checkDFilterCount):
         dfilter = 'http.request.method > "HEAE"'
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_ge_1(self):
+    def test_ge_1(self, checkDFilterCount):
         dfilter = 'http.request.method >= "HEAC"'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_ge_2(self):
+    def test_ge_2(self, checkDFilterCount):
         dfilter = 'http.request.method >= "HEAD"'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_ge_3(self):
+    def test_ge_3(self, checkDFilterCount):
         dfilter = 'http.request.method >= "HEAE"'
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_lt_1(self):
+    def test_lt_1(self, checkDFilterCount):
         dfilter = 'http.request.method < "HEAC"'
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_lt_2(self):
+    def test_lt_2(self, checkDFilterCount):
         dfilter = 'http.request.method < "HEAD"'
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_lt_3(self):
+    def test_lt_3(self, checkDFilterCount):
         dfilter = 'http.request.method < "HEAE"'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_le_1(self):
+    def test_le_1(self, checkDFilterCount):
         dfilter = 'http.request.method <= "HEAC"'
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_le_2(self):
+    def test_le_2(self, checkDFilterCount):
         dfilter = 'http.request.method <= "HEAD"'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_le_3(self):
+    def test_le_3(self, checkDFilterCount):
         dfilter = 'http.request.method <= "HEAE"'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_slice_1(self):
+    def test_slice_1(self, checkDFilterCount):
         dfilter = 'http.request.method[0] == "H"'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_slice_2(self):
+    def test_slice_2(self, checkDFilterCount):
         dfilter = 'http.request.method[0] == "P"'
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_slice_3(self):
+    def test_slice_3(self, checkDFilterCount):
         dfilter = 'http.request.method[0:4] == "HEAD"'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_slice_4(self):
+    def test_slice_4(self, checkDFilterCount):
         dfilter = 'http.request.method[0:4] != "HEAD"'
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_slice_5(self):
+    def test_slice_5(self, checkDFilterCount):
         dfilter = 'http.request.method[1:2] == "EA"'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_slice_6(self):
+    def test_slice_6(self, checkDFilterCount):
         dfilter = 'http.request.method[1:2] > "EA"'
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_slice_7(self):
+    def test_slice_7(self, checkDFilterCount):
         dfilter = 'http.request.method[-1] == "D"'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_slice_8(self):
+    def test_slice_8(self, checkDFilterCount):
         dfilter = 'http.request.method[-2] == "D"'
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
     def xxxtest_stringz_1(self):
             return self.DFilterCount(pkt_tftp,
@@ -104,70 +108,70 @@ class case_string(dfiltertest.DFTestCase):
             return self.DFilterCount(pkt_tftp,
                     'tftp.type == "junk"', 0)
 
-    def test_contains_1(self):
+    def test_contains_1(self, checkDFilterCount):
         dfilter = 'http.request.method contains "E"'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_contains_2(self):
+    def test_contains_2(self, checkDFilterCount):
         dfilter = 'http.request.method contains "EA"'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_contains_3(self):
+    def test_contains_3(self, checkDFilterCount):
         dfilter = 'http.request.method contains "HEAD"'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_contains_4(self):
+    def test_contains_4(self, checkDFilterCount):
         dfilter = 'http.request.method contains "POST"'
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_contains_5(self):
+    def test_contains_5(self, checkDFilterCount):
         dfilter = 'http.request.method contains 50:4f:53:54' # "POST"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_contains_6(self):
+    def test_contains_6(self, checkDFilterCount):
         dfilter = 'http.request.method contains 48:45:41:44' # "HEAD"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_contains_fail_0(self):
+    def test_contains_fail_0(self, checkDFilterCount):
         dfilter = 'http.user_agent contains "update"'
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_contains_fail_1(self):
+    def test_contains_fail_1(self, checkDFilterCount):
         dfilter = 'http.user_agent contains "UPDATE"'
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_contains_upper_0(self):
+    def test_contains_upper_0(self, checkDFilterCount):
         dfilter = 'upper(http.user_agent) contains "UPDATE"'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_contains_upper_1(self):
+    def test_contains_upper_1(self, checkDFilterCount):
         dfilter = 'upper(http.user_agent) contains "update"'
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_contains_upper_2(self):
+    def test_contains_upper_2(self, checkDFilterFail):
         dfilter = 'upper(tcp.seq) == 4'
-        self.assertDFilterFail(dfilter)
+        checkDFilterFail(dfilter)
 
-    def test_contains_lower_0(self):
+    def test_contains_lower_0(self, checkDFilterCount):
         dfilter = 'lower(http.user_agent) contains "UPDATE"'
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_contains_lower_1(self):
+    def test_contains_lower_1(self, checkDFilterCount):
         dfilter = 'lower(http.user_agent) contains "update"'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_eq_lower_1(self):
+    def test_eq_lower_1(self, checkDFilterFail):
         dfilter = 'lower(tcp.seq) == 4'
-        self.assertDFilterFail(dfilter)
+        checkDFilterFail(dfilter)
 
-    def test_string_len(self):
+    def test_string_len(self, checkDFilterCount):
         dfilter = 'len(http.request.method) == 4'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_eq_unicode(self):
+    def test_eq_unicode(self, checkDFilterCount):
         dfilter = 'tcp.flags.str == "·······AP···"'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_contains_unicode(self):
+    def test_contains_unicode(self, checkDFilterCount):
         dfilter = 'tcp.flags.str contains "·······AP···"'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
index 594ee21..bfc337d 100644 (file)
@@ -2,20 +2,24 @@
 #
 # SPDX-License-Identifier: GPL-2.0-or-later
 
-from suite_dfilter import dfiltertest
+import unittest
+import fixtures
+from suite_dfilter.dfiltertest import *
 
-class case_stringz(dfiltertest.DFTestCase):
+
+@fixtures.uses_fixtures
+class case_stringz(unittest.TestCase):
     trace_file = "tftp.pcap"
 
-    def test_stringz_1(self):
+    def test_stringz_1(self, checkDFilterCount):
         dfilter = 'tftp.type == octet'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_stringz_2(self):
+    def test_stringz_2(self, checkDFilterCount):
         dfilter = 'tftp.type == "octet"'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_stringz_3(self):
+    def test_stringz_3(self, checkDFilterCount):
         dfilter = 'tftp.type == junk'
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
index 963041c..3cb4f60 100644 (file)
@@ -2,20 +2,24 @@
 #
 # SPDX-License-Identifier: GPL-2.0-or-later
 
-from suite_dfilter import dfiltertest
+import unittest
+import fixtures
+from suite_dfilter.dfiltertest import *
 
-class case_time_relative(dfiltertest.DFTestCase):
+
+@fixtures.uses_fixtures
+class case_time_relative(unittest.TestCase):
     trace_file = "nfs.pcap"
 
-    def test_relative_time_1(self):
+    def test_relative_time_1(self, checkDFilterCount):
         dfilter = "frame.time_delta == 0.7"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_relative_time_2(self):
+    def test_relative_time_2(self, checkDFilterCount):
         dfilter = "frame.time_delta > 0.7"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_relative_time_3(self):
+    def test_relative_time_3(self, checkDFilterCount):
         dfilter = "frame.time_delta < 0.7"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
index 801001d..c1e46ab 100644 (file)
@@ -2,72 +2,76 @@
 #
 # SPDX-License-Identifier: GPL-2.0-or-later
 
-from suite_dfilter import dfiltertest
+import unittest
+import fixtures
+from suite_dfilter.dfiltertest import *
 
-class case_time(dfiltertest.DFTestCase):
+
+@fixtures.uses_fixtures
+class case_time(unittest.TestCase):
     trace_file = "http.pcap"
 
-    def test_eq_1(self):
+    def test_eq_1(self, checkDFilterCount):
         dfilter = 'frame.time == "Dec 31, 2002 13:55:31.3"'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_eq_2(self):
+    def test_eq_2(self, checkDFilterCount):
         dfilter = 'frame.time == "Jan 31, 2002 13:55:31.3"'
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_ne_1(self):
+    def test_ne_1(self, checkDFilterCount):
         dfilter = 'frame.time != "Dec 31, 2002 13:55:31.3"'
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_ne_2(self):
+    def test_ne_2(self, checkDFilterCount):
         dfilter = 'frame.time != "Jan 31, 2002 13:55:31.3"'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_gt_1(self):
+    def test_gt_1(self, checkDFilterCount):
         dfilter = 'frame.time > "Dec 31, 2002 13:54:31.3"'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_gt_2(self):
+    def test_gt_2(self, checkDFilterCount):
         dfilter = 'frame.time > "Dec 31, 2002 13:55:31.3"'
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_gt_3(self):
+    def test_gt_3(self, checkDFilterCount):
         dfilter = 'frame.time > "Dec 31, 2002 13:56:31.3"'
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_ge_1(self):
+    def test_ge_1(self, checkDFilterCount):
         dfilter = 'frame.time >= "Dec 31, 2002 13:54:31.3"'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_ge_2(self):
+    def test_ge_2(self, checkDFilterCount):
         dfilter = 'frame.time >= "Dec 31, 2002 13:55:31.3"'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_ge_3(self):
+    def test_ge_3(self, checkDFilterCount):
         dfilter = 'frame.time >= "Dec 31, 2002 13:56:31.3"'
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_lt_1(self):
+    def test_lt_1(self, checkDFilterCount):
         dfilter = 'frame.time < "Dec 31, 2002 13:54:31.3"'
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_lt_2(self):
+    def test_lt_2(self, checkDFilterCount):
         dfilter = 'frame.time < "Dec 31, 2002 13:55:31.3"'
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_lt_3(self):
+    def test_lt_3(self, checkDFilterCount):
         dfilter = 'frame.time < "Dec 31, 2002 13:56:31.3"'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_le_1(self):
+    def test_le_1(self, checkDFilterCount):
         dfilter = 'frame.time <= "Dec 31, 2002 13:54:31.3"'
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_le_2(self):
+    def test_le_2(self, checkDFilterCount):
         dfilter = 'frame.time <= "Dec 31, 2002 13:55:31.3"'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_le_3(self):
+    def test_le_3(self, checkDFilterCount):
         dfilter = 'frame.time <= "Dec 31, 2002 13:56:31.3"'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
index e257de1..bf47b5f 100644 (file)
@@ -2,59 +2,62 @@
 #
 # SPDX-License-Identifier: GPL-2.0-or-later
 
-from suite_dfilter import dfiltertest
 import unittest
+import fixtures
+from suite_dfilter.dfiltertest import *
 
-class case_tvb(dfiltertest.DFTestCase):
+
+@fixtures.uses_fixtures
+class case_tvb(unittest.TestCase):
     trace_file = "http.pcap"
 
-    def test_eq_1(self):
+    def test_eq_1(self, checkDFilterCount):
         # We expect 0 because even though this byte
         # string matches the 'eth' protocol, protocols cannot
         # work in an '==' comparison yet.
         dfilter = "eth == 00:e0:81:00:b0:28:00:09:6b:88:f6:c9:08:00"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_slice_1(self):
+    def test_slice_1(self, checkDFilterCount):
         dfilter = "ip[0:2] == 45:00"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_slice_2(self):
+    def test_slice_2(self, checkDFilterCount):
         dfilter = "ip[0:2] == 00:00"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_slice_3(self):
+    def test_slice_3(self, checkDFilterCount):
         dfilter = "ip[2:2] == 00:c1"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
     @unittest.skip("This doesn't work yet in Wireshark")
-    def test_slice_4(self):
+    def test_slice_4(self, checkDFilterCount):
         dfilter = "ip[-5] == 0x86"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
     @unittest.skip("This doesn't work yet in Wireshark")
-    def test_slice_5(self):
+    def test_slice_5(self, checkDFilterCount):
         dfilter = "ip[-1] == 0x86"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_contains_1(self):
+    def test_contains_1(self, checkDFilterCount):
         dfilter = "eth contains 6b"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_contains_2(self):
+    def test_contains_2(self, checkDFilterCount):
         dfilter = "eth contains 09:6b:88"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_contains_3(self):
+    def test_contains_3(self, checkDFilterCount):
         dfilter = "eth contains 00:e0:81:00:b0:28:00:09:6b:88:f5:c9:08:00"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_contains_4(self):
+    def test_contains_4(self, checkDFilterCount):
         dfilter = "eth contains ff:ff:ff"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)
 
-    def test_contains_5(self):
+    def test_contains_5(self, checkDFilterCount):
         dfilter = 'http contains "HEAD"'
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
 
index 3194a25..2da7f45 100644 (file)
@@ -2,15 +2,19 @@
 #
 # SPDX-License-Identifier: GPL-2.0-or-later
 
-from suite_dfilter import dfiltertest
+import unittest
+import fixtures
+from suite_dfilter.dfiltertest import *
 
-class case_uint64(dfiltertest.DFTestCase):
+
+@fixtures.uses_fixtures
+class case_uint64(unittest.TestCase):
     trace_file = "nfs.pcap"
 
-    def test_uint64_1(self):
+    def test_uint64_1(self, checkDFilterCount):
         dfilter = "nfs.fattr3.size == 264032"
-        self.assertDFilterCount(dfilter, 1)
+        checkDFilterCount(dfilter, 1)
 
-    def test_uint64_2(self):
+    def test_uint64_2(self, checkDFilterCount):
         dfilter = "nfs.fattr3.size == 264000"
-        self.assertDFilterCount(dfilter, 0)
+        checkDFilterCount(dfilter, 0)