dissect.cstruct 4.7.dev1__tar.gz → 4.8.dev2__tar.gz

{dissect_cstruct-4.7.dev1 → dissect_cstruct-4.8.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dissect.cstruct
-Version: 4.7.dev1
+Version: 4.8.dev2
 Summary: A Dissect module implementing a parser for C-like structures: structure parsing in Python made easy
 Author-email: Dissect Team <dissect@fox-it.com>
 License-Expression: Apache-2.0

{dissect_cstruct-4.7.dev1 → dissect_cstruct-4.8.dev2}/dissect.cstruct.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dissect.cstruct
-Version: 4.7.dev1
+Version: 4.8.dev2
 Summary: A Dissect module implementing a parser for C-like structures: structure parsing in Python made easy
 Author-email: Dissect Team <dissect@fox-it.com>
 License-Expression: Apache-2.0

{dissect_cstruct-4.7.dev1 → dissect_cstruct-4.8.dev2}/dissect.cstruct.egg-info/SOURCES.txt

@@ -45,6 +45,7 @@ tests/conftest.py
 tests/test_align.py
 tests/test_annotations.py
 tests/test_basic.py
+tests/test_benchmark.py
 tests/test_bitbuffer.py
 tests/test_bitfield.py
 tests/test_compiler.py

dissect_cstruct-4.8.dev2/tests/conftest.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import importlib.util
+
+import pytest
+
+from dissect.cstruct.cstruct import cstruct
+
+HAS_BENCHMARK = importlib.util.find_spec("pytest_benchmark") is not None
+
+
+def pytest_configure(config: pytest.Config) -> None:
+    if not HAS_BENCHMARK:
+        # If we don't have pytest-benchmark (or pytest-codspeed) installed, register the benchmark marker ourselves
+        # to avoid pytest warnings
+        config.addinivalue_line("markers", "benchmark: mark test for benchmarking (requires pytest-benchmark)")
+
+
+def pytest_runtest_setup(item: pytest.Item) -> None:
+    if not HAS_BENCHMARK and item.get_closest_marker("benchmark") is not None:
+        pytest.skip("pytest-benchmark is not installed")
+
+
+@pytest.fixture
+def cs() -> cstruct:
+    return cstruct()
+
+
+@pytest.fixture(params=[True, False], ids=["compiled", "interpreted"])
+def compiled(request: pytest.FixtureRequest) -> bool:
+    return request.param

dissect_cstruct-4.8.dev2/tests/test_benchmark.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+from functools import partial
+from typing import TYPE_CHECKING
+
+import pytest
+
+from dissect.cstruct.expression import Expression
+
+if TYPE_CHECKING:
+    from pytest_benchmark.fixture import BenchmarkFixture
+
+    from dissect.cstruct.cstruct import cstruct
+
+
+@pytest.mark.benchmark
+def test_benchmark_basic(cs: cstruct, compiled: bool, benchmark: BenchmarkFixture) -> None:
+    """Benchmark the parsing of a simple struct with both the compiled and interpreted backends."""
+    cdef = """
+    struct test {
+        uint32  a;
+        uint64  b;
+        uint16  c;
+        uint8   d;
+    };
+    """
+    cs.load(cdef, compiled=compiled)
+
+    benchmark(lambda: cs.test(b"\x01\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x03\x00\x04"))
+
+
+@pytest.mark.benchmark
+def test_benchmark_union(cs: cstruct, compiled: bool, benchmark: BenchmarkFixture) -> None:
+    """Benchmark the parsing of a simple union with both the compiled and interpreted backends."""
+    cdef = """
+    union test {
+        uint32  a;
+        uint64  b;
+        uint16  c;
+        uint8   d;
+    };
+    """
+    cs.load(cdef, compiled=compiled)
+
+    benchmark(lambda: cs.test(b"\x01\x02\x03\x04\x05\x06\x07\x08"))
+
+
+@pytest.mark.benchmark
+def test_benchmark_attribute_access(cs: cstruct, benchmark: BenchmarkFixture) -> None:
+    """Benchmark the attribute access of a parsed struct."""
+    cdef = """
+    struct test {
+        uint32  a;
+        uint64  b;
+        uint16  c;
+        uint8   d;
+    };
+    """
+    cs.load(cdef)
+    obj = cs.test(b"\x01\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x03\x00\x04")
+
+    benchmark(lambda: (obj.a, obj.b, obj.c, obj.d))
+
+
+@pytest.mark.benchmark
+def test_benchmark_getattr_constants(cs: cstruct, benchmark: BenchmarkFixture) -> None:
+    """Benchmark the resolving of constants on the cstruct instance."""
+    cdef = """
+    #define CONST1 1
+    """
+    cs.load(cdef)
+
+    benchmark(lambda: cs.CONST1)
+
+
+@pytest.mark.benchmark
+def test_benchmark_getattr_types(cs: cstruct, benchmark: BenchmarkFixture) -> None:
+    """Benchmark the resolving of types on the cstruct instance."""
+    benchmark(lambda: cs.uint8)
+
+
+@pytest.mark.benchmark
+def test_benchmark_getattr_typedefs(cs: cstruct, benchmark: BenchmarkFixture) -> None:
+    """Benchmark the resolving of typedefs on the cstruct instance."""
+    cdef = """
+    typedef uint8 my_uint8;
+    """
+    cs.load(cdef)
+
+    benchmark(lambda: cs.my_uint8)
+
+
+@pytest.mark.benchmark
+def test_benchmark_expression_parse(cs: cstruct, benchmark: BenchmarkFixture) -> None:
+    """Benchmark the parsing of expressions."""
+    cs.load("#define a 5\n#define b 10")
+
+    benchmark(lambda: Expression("a * 2 + b * (3 + 4) >> 1"))
+
+
+@pytest.mark.benchmark
+def test_benchmark_expression_evaluate(cs: cstruct, benchmark: BenchmarkFixture) -> None:
+    """Benchmark the evaluation of expressions."""
+    cs.load("#define a 5\n#define b 10")
+
+    expression = Expression("a * 2 + b * (3 + 4) >> 1")
+    benchmark(lambda: expression.evaluate(cs))
+
+
+@pytest.mark.benchmark
+def test_benchmark_expression_parse_and_evaluate(cs: cstruct, benchmark: BenchmarkFixture) -> None:
+    """Benchmark the parsing and evaluation of expressions."""
+    cs.load("#define a 5\n#define b 10")
+
+    benchmark(lambda: Expression("a * 2 + b * (3 + 4) >> 1").evaluate(cs))
+
+
+_BENCHMARK_CDEF = """
+struct SECURITY_DESCRIPTOR {
+    uint8   Revision;
+    uint8   Sbz1;
+    uint16  Control;
+    uint32  OffsetOwner;
+    uint32  OffsetGroup;
+    uint32  OffsetSacl;
+    uint32  OffsetDacl;
+};
+
+struct LDAP_SID_IDENTIFIER_AUTHORITY {
+    char    Value[6];
+};
+
+struct LDAP_SID {
+    uint8   Revision;
+    uint8   SubAuthorityCount;
+    LDAP_SID_IDENTIFIER_AUTHORITY   IdentifierAuthority;
+    uint32  SubAuthority[SubAuthorityCount];
+};
+
+struct ACL {
+    uint8   AclRevision;
+    uint8   Sbz1;
+    uint16  AclSize;
+    uint16  AceCount;
+    uint16  Sbz2;
+    char    Data[AclSize - 8];
+};
+
+struct ACE {
+    uint8   AceType;
+    uint8   AceFlags;
+    uint16  AceSize;
+    char    Data[AceSize - 4];
+};
+
+struct ACCESS_ALLOWED_ACE {
+    uint16  Mask;
+    LDAP_SID Sid;
+};
+
+struct ACCESS_ALLOWED_OBJECT_ACE {
+    uint32  Mask;
+    uint32  Flags;
+    char    ObjectType[(Flags & 1) * 16];
+    char    InheritedObjectType[(Flags & 2) * 8];
+    LDAP_SID Sid;
+};
+"""
+
+
+@pytest.mark.benchmark
+def test_benchmark_lexer_and_parser(cs: cstruct, benchmark: BenchmarkFixture) -> None:
+    """Benchmark tokenizing and parsing a realistic set of struct definitions."""
+    cs.add_type = partial(cs.add_type, replace=True)
+
+    benchmark(lambda: cs.load(_BENCHMARK_CDEF))

{dissect_cstruct-4.7.dev1 → dissect_cstruct-4.8.dev2}/tox.ini

@@ -18,10 +18,20 @@ deps =
     coverage
 dependency_groups = test
 commands =
-    pytest --basetemp="{envtmpdir}" {posargs:--color=yes --cov=dissect --cov-report=term-missing -v tests}
+    pytest --basetemp="{envtmpdir}" --import-mode="append" {posargs:--color=yes --cov=dissect --cov-report=term-missing -v tests}
     coverage report
     coverage xml
 
+[testenv:benchmark]
+deps =
+    pytest-benchmark
+    pytest-codspeed
+dependency_groups = test
+passenv =
+    CODSPEED_ENV
+commands =
+    pytest --basetemp="{envtmpdir}" --import-mode="append" -m benchmark {posargs:--color=yes -v tests}
+
 [testenv:build]
 package = skip
 dependency_groups = build

dissect_cstruct-4.7.dev1/tests/conftest.py

@@ -1,13 +0,0 @@
-import pytest
-
-from dissect.cstruct.cstruct import cstruct
-
-
-@pytest.fixture
-def cs() -> cstruct:
-    return cstruct()
-
-
-@pytest.fixture(params=[True, False])
-def compiled(request: pytest.FixtureRequest) -> bool:
-    return request.param