Debug windows-11-arm

Author: Schamper

.github/workflows/dissect-ci.yml

@@ -17,45 +17,78 @@ jobs:
 
   build-native:
     runs-on: ${{ matrix.os }}
+    continue-on-error: true
     strategy:
       matrix:
         os: [ubuntu-latest, ubuntu-24.04-arm, windows-latest, windows-11-arm, macos-13, macos-14]
     steps:
-      - uses: fox-it/dissect-workflow-templates/.github/actions/git-checkout@main
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - run: git lfs install --local
 
-      - if: runner.os == 'Linux' && runner.arch == 'X64'
+      - name: Create LFS file list
+        run: git lfs ls-files --long | cut -d ' ' -f1 | sort > .lfs-assets-id
+
+      - name: Cache LFS
+        uses: actions/cache@v4
+        with:
+          path: .git/lfs
+          key: lfs-${{ hashFiles('.lfs-assets-id') }}-v1
+
+      - name: Pull LFS
+        run: git lfs pull
+
+      - name: Setup QEMU (Linux only)
+        if: runner.os == 'Linux' && runner.arch == 'X64'
         uses: docker/setup-qemu-action@v3
         with:
           platforms: all
 
-      - run: curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain stable
+      - name: Setup Rust
+        if: ${{ matrix.os != 'windows-11-arm' }}
+        run: curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain stable
+
+      - name: Setup Rust (Windows 11 ARM)
+        if: ${{ matrix.os == 'windows-11-arm' }}
+        run: |
+          Invoke-WebRequest -Uri "https://win.rustup.rs/aarch64" -OutFile "$env:TEMP\rustup-init.exe"
+           & "$env:TEMP\rustup-init.exe" -y
+          "$env:USERPROFILE\.cargo\bin" | Out-File -Append -Encoding ascii $env:GITHUB_PATH
+          "CARGO_HOME=$env:USERPROFILE\.cargo" | Out-File -Append -Encoding ascii $env:GITHUB_ENV
+        shell: pwsh
 
-      - uses: actions/setup-python@v5
+      - name: Setup Python
+        uses: actions/setup-python@v5
         with:
-          python-version: "3.12"
+          python-version: "3.13"
 
-      - run: python -m pip install cibuildwheel==2.23.2
+      - name: Install cibuildwheel
+        run: python -m pip install cibuildwheel==2.23.2
 
-      - run: python -m cibuildwheel --output-dir dist
+      - name: Build wheels
+        run: python -m cibuildwheel --output-dir dist
         env:
           CIBW_ARCHS_LINUX: ${{ runner.arch == 'X64' && 'auto ppc64le s390x' || 'auto armv7l' }}
+          CIBW_ARCHS_WINDOWS: ${{ runner.arch == 'X64' && 'AMD64 x86' || 'ARM64' }}
           CIBW_BEFORE_ALL_LINUX: curl -sSf https://sh.rustup.rs | sh -s -- -y
           CIBW_BEFORE_ALL_WINDOWS: ${{ runner.arch == 'X64' && 'rustup target add i686-pc-windows-msvc' || '' }}
           # Manually install setuptools-rust to enable building native wheels
           CIBW_BEFORE_BUILD: >
             python -m pip install -U setuptools>=77.0.0 setuptools_scm[toml]>=6.4.0 setuptools-rust
           CIBW_BUILD_FRONTEND: "build; args: --no-isolation"
-          CIBW_CONFIG_SETTINGS: "--build-option=--py-limited-api=cp39"
+          CIBW_CONFIG_SETTINGS: --build-option=--py-limited-api=cp39
           CIBW_ENABLE: pypy
-          CIBW_ENVIRONMENT_LINUX: 'PATH="$HOME/.cargo/bin:$PATH"'
-          CIBW_ENVIRONMENT_MACOS: 'MACOSX_DEPLOYMENT_TARGET=10.12'
-          CIBW_ENVIRONMENT_WINDOWS: 'PATH="$UserProfile\.cargo\bin;$PATH"'
+          CIBW_ENVIRONMENT_LINUX: PATH="$HOME/.cargo/bin:$PATH"
+          CIBW_ENVIRONMENT_MACOS: MACOSX_DEPLOYMENT_TARGET=10.12
           CIBW_SKIP: '*-musllinux_i686'
           # Run tests
           CIBW_TEST_REQUIRES: tox
           CIBW_TEST_COMMAND: tox -e native -c {package}/tox.ini --installpkg {wheel}
 
-      - run: pip install abi3audit && abi3audit --strict --report dist/*-abi3-*.whl
+      - name: Run abi3audit
+        run: pip install abi3audit && abi3audit --strict --report dist/*-abi3-*.whl
 
       - uses: actions/upload-artifact@v4
         with:

dissect/util/ts.py

@@ -1,10 +1,15 @@
 from __future__ import annotations
 
 import struct
-import sys
 from datetime import datetime, timedelta, timezone, tzinfo
 
-if sys.platform in ("win32", "emscripten"):
+try:
+    datetime.fromtimestamp(-6969696969, tz=timezone.utc)
+
+    def _calculate_timestamp(ts: float) -> datetime:
+        """Calculate timestamps normally."""
+        return datetime.fromtimestamp(ts, tz=timezone.utc)
+except (OSError, OverflowError):
     _EPOCH = datetime(1970, 1, 1, tzinfo=timezone.utc)
 
     def _calculate_timestamp(ts: float) -> datetime:
@@ -16,12 +21,6 @@ def _calculate_timestamp(ts: float) -> datetime:
         """
         return _EPOCH + timedelta(seconds=ts)
 
-else:
-
-    def _calculate_timestamp(ts: float) -> datetime:
-        """Calculate timestamps normally."""
-        return datetime.fromtimestamp(ts, tz=timezone.utc)
-
 
 def now() -> datetime:
     """Return an aware datetime object of the current time in UTC."""

tests/test_ts.py

@@ -1,18 +1,27 @@
-import platform
 from datetime import datetime, timedelta, timezone
 from importlib import reload
 from types import ModuleType
+from typing import NoReturn
 from unittest.mock import patch
 
 import pytest
 
 
-@pytest.fixture(params=["windows", "emscripten", "linux"])
+@pytest.fixture(params=[True, False])
 def imported_ts(request: pytest.FixtureRequest) -> ModuleType:
-    with patch.object(platform, "system", return_value=request.param):
-        from dissect.util import ts
+    from dissect.util import ts
+
+    if request.param:
+
+        class MockDatetime(datetime):
+            @classmethod
+            def fromtimestamp(cls, *args, **kwargs) -> NoReturn:
+                raise OverflowError("Mock overflow error")
 
-        return reload(ts)
+        with patch("datetime.datetime", MockDatetime):
+            return reload(ts)
+
+    return reload(ts)
 
 
 @pytest.fixture
@@ -32,32 +41,32 @@ def test_now(ts: ModuleType) -> None:
     assert ts_now.tzinfo == timezone.utc
 
 
-def test_unix_now(imported_ts: ModuleType) -> None:
-    timestamp = imported_ts.unix_now()
+def test_unix_now(ts: ModuleType) -> None:
+    timestamp = ts.unix_now()
 
     assert isinstance(timestamp, int)
     assert datetime.fromtimestamp(timestamp, tz=timezone.utc).microsecond == 0
 
 
-def test_unix_now_ms(imported_ts: ModuleType) -> None:
-    timestamp = imported_ts.unix_now_ms()
+def test_unix_now_ms(ts: ModuleType) -> None:
+    timestamp = ts.unix_now_ms()
 
     assert isinstance(timestamp, int)
-    assert imported_ts.from_unix_ms(timestamp).microsecond == (timestamp % 1e3) * 1000
+    assert ts.from_unix_ms(timestamp).microsecond == (timestamp % 1e3) * 1000
 
 
-def test_unix_now_us(imported_ts: ModuleType) -> None:
-    timestamp = imported_ts.unix_now_us()
+def test_unix_now_us(ts: ModuleType) -> None:
+    timestamp = ts.unix_now_us()
 
     assert isinstance(timestamp, int)
-    assert imported_ts.from_unix_us(timestamp).microsecond == timestamp % 1e6
+    assert ts.from_unix_us(timestamp).microsecond == timestamp % 1e6
 
 
-def test_unix_now_ns(imported_ts: ModuleType) -> None:
-    timestamp = imported_ts.unix_now_ns()
+def test_unix_now_ns(ts: ModuleType) -> None:
+    timestamp = ts.unix_now_ns()
 
     assert isinstance(timestamp, int)
-    assert imported_ts.from_unix_ns(timestamp).microsecond == int((timestamp // 1000) % 1e6)
+    assert ts.from_unix_ns(timestamp).microsecond == int((timestamp // 1000) % 1e6)
 
 
 def test_to_unix(ts: ModuleType) -> None: