pytest

Author: andreax79

coverage.sh

@@ -0,0 +1,2 @@
+[pytest]
+testpaths = tests

pytest.ini

@@ -5,3 +5,4 @@ sphinx
 tox
 black
 twine<3.4
+pytest

requirements-dev.txt

@@ -24,6 +24,7 @@ def readme():
         'Programming Language :: Python :: 3.7',
         'Programming Language :: Python :: 3.8',
         'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',
     ],
     keywords='struct',
     author='Andrea Bonomi',

setup.py

@@ -25,7 +25,6 @@
 #
 # *****************************************************************************
 
-from unittest import TestCase, main
 from cstruct import sizeof, typedef, define, CStruct, NATIVE_ORDER
 
 define("UT_NAMESIZE", 32)
@@ -186,30 +185,32 @@ class Foo10(CStruct):
     """
 
 
-class TestAlignament(TestCase):
-    def test_utmp_sizeof(self):
-        self.assertEqual(sizeof("struct Utmp"), 384)
+def test_utmp_sizeof():
+    assert sizeof("struct Utmp") == 384
 
-    # http://www.catb.org/esr/structure-packing/
 
-    def test_foo1_sizeof(self):
-        self.assertEqual(sizeof("struct Foo1"), 24)
+# http://www.catb.org/esr/structure-packing/
 
-    def test_foo2_sizeof(self):
-        self.assertEqual(sizeof("struct Foo2"), 24)
 
-    def test_foo3_sizeof(self):
-        self.assertEqual(sizeof("struct Foo3"), 16)
+def test_foo1_sizeof():
+    assert sizeof("struct Foo1") == 24
 
-    def test_foo4_sizeof(self):
-        self.assertEqual(sizeof("struct Foo4"), 4)
 
-    def test_foo5_sizeof(self):
-        self.assertEqual(sizeof("struct Foo5"), 24)
+def test_foo2_sizeof():
+    assert sizeof("struct Foo2") == 24
 
-    def test_foo10_sizeof(self):
-        self.assertEqual(sizeof("struct Foo10"), 24)
 
+def test_foo3_sizeof():
+    assert sizeof("struct Foo3") == 16
 
-if __name__ == '__main__':
-    main()
+
+def test_foo4_sizeof():
+    assert sizeof("struct Foo4") == 4
+
+
+def test_foo5_sizeof():
+    assert sizeof("struct Foo5") == 24
+
+
+def test_foo10_sizeof():
+    assert sizeof("struct Foo10") == 24

test.sh

@@ -25,7 +25,6 @@
 #
 # *****************************************************************************
 
-from unittest import TestCase, main
 import cstruct
 from cstruct import sizeof, typedef
 import io
@@ -645,102 +644,106 @@ class PartitionNested(cstruct.CStruct):
     """
 
 
-class TestCStruct(TestCase):
-    def test_len(self):
-        mbr = MBR()
-        self.assertEqual(len(mbr), 512)
-        self.assertEqual(mbr.size, 512)
-
-    def test_sizeof(self):
-        self.assertEqual(sizeof("struct Partition"), sizeof("struct PartitionFlat"))
-        self.assertEqual(sizeof("struct Partition"), sizeof("struct PartitionNested"))
-
-    def test_unpack(self):
-        mbr = MBR()
-        f = io.BytesIO(MBR_DATA)
-        mbr.unpack(f)
-        self.assertEqual(mbr.signature[0], 0x55)
-        self.assertEqual(mbr.signature[1], 0xAA)
-        self.assertEqual(mbr.partitions[0].start.head, 0)
-        self.assertEqual(mbr.partitions[0].end.head, 0xFE)
-        self.assertEqual(mbr.partitions[1].start_sect, 0x2117C7)
-
-    def test_pack(self):
-        mbr = MBR(MBR_DATA)
-        d = mbr.pack()
-        self.assertEqual(MBR_DATA, d)
-        mbr.partitions[3].start.head = 123
-        d1 = mbr.pack()
-        mbr1 = MBR(d1)
-        self.assertEqual(mbr1.partitions[3].start.head, 123)
-
-    def test_init(self):
-        p = Position(head=254, sector=63, cyl=134)
-        mbr = MBR(MBR_DATA)
-        self.assertEqual(mbr.partitions[0].end.head, p.head)
-        self.assertEqual(mbr.partitions[0].end.sector, p.sector)
-        self.assertEqual(mbr.partitions[0].end.cyl, p.cyl)
-
-    def test_none(self):
-        mbr = MBR()
-        self.assertEqual(mbr.partitions[0].end.sector, 0)
-        mbr.unpack(None)
-        self.assertEqual(mbr.partitions[0].end.head, 0)
-
-    def test_clear(self):
-        mbr = MBR()
-        mbr.unpack(MBR_DATA)
-        self.assertEqual(mbr.partitions[0].end.head, 0xFE)
-        mbr.clear()
-        self.assertEqual(mbr.partitions[0].end.head, 0x00)
-
-    def test_inline(self):
-        TestStruct = cstruct.parse(
-            'struct TestStruct { unsigned char head; unsigned char sector; unsigned char cyl; }',
-            __byte_order__=cstruct.LITTLE_ENDIAN,
-        )
-        s = TestStruct(head=254, sector=63, cyl=134)
-        p = Position(head=254, sector=63, cyl=134)
-        self.assertEqual(s.pack(), p.pack())
-
-    def test_dummy(self):
-        dummy = Dummy()
-        dummy.c = b'A'
-        dummy.vc = b'ABCDEFGHIJ'
-        dummy.i = 123456
-        for i in range(0, 10):
-            dummy.vi[i] = i * 10
-        dummy.f = 123.456
-        for i in range(0, 10):
-            dummy.vf[i] = 10.0 / (i + 1)
-        dummy.vl = list(range(0, 10))
-        data = dummy.pack()
-        dummy1 = Dummy(data)
-        for i in range(0, 10):
-            dummy1.vl[i] = dummy.vl[i]
-        self.assertEqual(dummy.pack(), dummy1.pack())
-        dummy2 = Dummy(data)
-        dummy2.vf[2] = 79
-        self.assertNotEqual(dummy.pack(), dummy2.pack())
-        dummy3 = Dummy(data)
-        dummy3.vl = list(range(1, 11))
-        self.assertNotEqual(dummy.pack(), dummy3.pack())
-
-    def test_nested(self):
-        data = os.urandom(sizeof("struct PartitionFlat"))
-        flat = PartitionFlat(data)
-        flat.unpack(data)
-        nested = PartitionNested(data)
-        nested.unpack(data)
-        self.assertEqual(flat.status, nested.status)
-        self.assertEqual(flat.startAddrHead, nested.start.addrHead)
-        self.assertEqual(flat.startAddrCylSec, nested.start.addrCylSec)
-        self.assertEqual(flat.partType, nested.partType)
-        self.assertEqual(flat.endAddrHead, nested.end.addrHead)
-        self.assertEqual(flat.endAddrCylSec, nested.end.addrCylSec)
-        self.assertEqual(flat.startLBA, nested.startLBA)
-        self.assertEqual(flat.endLBA, nested.endLBA)
-
-
-if __name__ == '__main__':
-    main()
+def test_len():
+    mbr = MBR()
+    assert len(mbr) == 512
+    assert mbr.size == 512
+
+
+def test_sizeof():
+    assert sizeof("struct Partition") == sizeof("struct PartitionFlat")
+    assert sizeof("struct Partition") == sizeof("struct PartitionNested")
+
+
+def test_unpack():
+    mbr = MBR()
+    f = io.BytesIO(MBR_DATA)
+    mbr.unpack(f)
+    assert mbr.signature[0] == 0x55
+    assert mbr.signature[1] == 0xAA
+    assert mbr.partitions[0].start.head == 0
+    assert mbr.partitions[0].end.head == 0xFE
+    assert mbr.partitions[1].start_sect == 0x2117C7
+
+
+def test_pack():
+    mbr = MBR(MBR_DATA)
+    d = mbr.pack()
+    assert MBR_DATA == d
+    mbr.partitions[3].start.head = 123
+    d1 = mbr.pack()
+    mbr1 = MBR(d1)
+    assert mbr1.partitions[3].start.head == 123
+
+
+def test_init():
+    p = Position(head=254, sector=63, cyl=134)
+    mbr = MBR(MBR_DATA)
+    assert mbr.partitions[0].end.head == p.head
+    assert mbr.partitions[0].end.sector == p.sector
+    assert mbr.partitions[0].end.cyl == p.cyl
+
+
+def test_none():
+    mbr = MBR()
+    assert mbr.partitions[0].end.sector == 0
+    mbr.unpack(None)
+    assert mbr.partitions[0].end.head == 0
+
+
+def test_clear():
+    mbr = MBR()
+    mbr.unpack(MBR_DATA)
+    assert mbr.partitions[0].end.head == 0xFE
+    mbr.clear()
+    assert mbr.partitions[0].end.head == 0x00
+
+
+def test_inline():
+    StructT1 = cstruct.parse(
+        'struct StructT1 { unsigned char head; unsigned char sector; unsigned char cyl; }',
+        __byte_order__=cstruct.LITTLE_ENDIAN,
+    )
+    s = StructT1(head=254, sector=63, cyl=134)
+    p = Position(head=254, sector=63, cyl=134)
+    assert s.pack() == p.pack()
+
+
+def test_dummy():
+    dummy = Dummy()
+    dummy.c = b'A'
+    dummy.vc = b'ABCDEFGHIJ'
+    dummy.i = 123456
+    for i in range(0, 10):
+        dummy.vi[i] = i * 10
+    dummy.f = 123.456
+    for i in range(0, 10):
+        dummy.vf[i] = 10.0 / (i + 1)
+    dummy.vl = list(range(0, 10))
+    data = dummy.pack()
+    dummy1 = Dummy(data)
+    for i in range(0, 10):
+        dummy1.vl[i] = dummy.vl[i]
+    assert dummy.pack() == dummy1.pack()
+    dummy2 = Dummy(data)
+    dummy2.vf[2] = 79
+    assert dummy.pack() != dummy2.pack()
+    dummy3 = Dummy(data)
+    dummy3.vl = list(range(1, 11))
+    assert dummy.pack() != dummy3.pack()
+
+
+def test_nested():
+    data = os.urandom(sizeof("struct PartitionFlat"))
+    flat = PartitionFlat(data)
+    flat.unpack(data)
+    nested = PartitionNested(data)
+    nested.unpack(data)
+    assert flat.status == nested.status
+    assert flat.startAddrHead == nested.start.addrHead
+    assert flat.startAddrCylSec == nested.start.addrCylSec
+    assert flat.partType == nested.partType
+    assert flat.endAddrHead == nested.end.addrHead
+    assert flat.endAddrCylSec == nested.end.addrCylSec
+    assert flat.startLBA == nested.startLBA
+    assert flat.endLBA == nested.endLBA

tests/test_alignment.py

@@ -25,7 +25,7 @@
 #
 # *****************************************************************************
 
-from unittest import TestCase, main
+import pytest
 import cstruct
 from cstruct import define, undef, sizeof, typedef
 
@@ -41,27 +41,27 @@ class Position(cstruct.CStruct):
     """
 
 
-class TestCaseDefine(TestCase):
-    def test_sizeof(self):
-        self.assertEqual(sizeof('int'), 4)
-        define('INIT_THREAD_SIZE', 2048 * sizeof('long'))
-        self.assertEqual(cstruct.DEFINES['INIT_THREAD_SIZE'], 16384)
-        self.assertEqual(sizeof('struct Position'), 3)
-        self.assertEqual(sizeof('struct Position'), len(Position))
-        self.assertEqual(sizeof(Position), 3)
-        self.assertRaises(KeyError, lambda: sizeof('bla'))
-        self.assertRaises(KeyError, lambda: sizeof('struct Bla'))
+def test_sizeof():
+    assert sizeof('int') == 4
+    define('INIT_THREAD_SIZE', 2048 * sizeof('long'))
+    assert cstruct.DEFINES['INIT_THREAD_SIZE'] == 16384
+    assert sizeof('struct Position') == 3
+    assert sizeof('struct Position') == len(Position)
+    assert sizeof(Position) == 3
+    with pytest.raises(KeyError):
+        sizeof('bla')
+    with pytest.raises(KeyError):
+        sizeof('struct Bla')
 
-    def test_define(self):
-        define('A', 10)
-        self.assertEqual(cstruct.DEFINES['A'], 10)
-        undef('A')
-        self.assertRaises(KeyError, lambda: cstruct.DEFINES['A'])
 
-    def test_typedef(self):
-        typedef('int', 'integer')
-        self.assertEqual(sizeof('integer'), 4)
+def test_define():
+    define('A', 10)
+    assert cstruct.DEFINES['A'] == 10
+    undef('A')
+    with pytest.raises(KeyError):
+        cstruct.DEFINES['A']
 
 
-if __name__ == '__main__':
-    main()
+def test_typedef():
+    typedef('int', 'integer')
+    assert sizeof('integer') == 4