From dcbd3ac8418ee69c53ba34d871017243c2d9866b Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 23 Apr 2026 06:12:14 +0000
Subject: [PATCH] test: add comprehensive C# and Python unit tests for the SDK

Agent-Logs-Url: https://github.com/PyMCU/pymcu-sdk/sessions/1eb50c7b-0c67-4b08-83f1-63aac2c394ff

Co-authored-by: begeistert <36460223+begeistert@users.noreply.github.com>
---
 PyMCU.SDK.slnx                                |   3 +
 pyproject.toml                                |   6 +
 .../Analysis/DynamicStackAllocatorTests.cs    | 184 +++++++++
 .../Backend/Analysis/StackAllocatorTests.cs   | 235 +++++++++++
 .../Backend/License/LicenseResultTests.cs     |  64 +++
 .../Backend/License/LicenseValidatorTests.cs  | 169 ++++++++
 .../Serialization/IrSerializerTests.cs        | 364 ++++++++++++++++++
 tests/csharp/IR/DataTypeTests.cs              | 168 ++++++++
 tests/csharp/IR/TackyTests.cs                 | 292 ++++++++++++++
 tests/csharp/PyMCU.Backend.SDK.Tests.csproj   |  29 ++
 tests/python/conftest.py                      |   2 +
 tests/python/test_backend_plugin.py           | 160 ++++++++
 tests/python/test_base_tool.py                | 299 ++++++++++++++
 tests/python/test_toolchain_plugin.py         | 156 ++++++++
 14 files changed, 2131 insertions(+)
 create mode 100644 tests/csharp/Backend/Analysis/DynamicStackAllocatorTests.cs
 create mode 100644 tests/csharp/Backend/Analysis/StackAllocatorTests.cs
 create mode 100644 tests/csharp/Backend/License/LicenseResultTests.cs
 create mode 100644 tests/csharp/Backend/License/LicenseValidatorTests.cs
 create mode 100644 tests/csharp/Backend/Serialization/IrSerializerTests.cs
 create mode 100644 tests/csharp/IR/DataTypeTests.cs
 create mode 100644 tests/csharp/IR/TackyTests.cs
 create mode 100644 tests/csharp/PyMCU.Backend.SDK.Tests.csproj
 create mode 100644 tests/python/conftest.py
 create mode 100644 tests/python/test_backend_plugin.py
 create mode 100644 tests/python/test_base_tool.py
 create mode 100644 tests/python/test_toolchain_plugin.py

diff --git a/PyMCU.SDK.slnx b/PyMCU.SDK.slnx
index 5b84c50..a1b98d9 100644
--- a/PyMCU.SDK.slnx
+++ b/PyMCU.SDK.slnx
@@ -2,4 +2,7 @@
   <Folder Name="/src/">
     <Project Path="src/csharp/PyMCU.Backend.SDK.csproj" />
   </Folder>
+  <Folder Name="/tests/">
+    <Project Path="tests/csharp/PyMCU.Backend.SDK.Tests.csproj" />
+  </Folder>
 </Solution>
diff --git a/pyproject.toml b/pyproject.toml
index 7078455..28f90f0 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -19,3 +19,9 @@ dependencies = [
 [tool.hatch.build.targets.wheel]
 packages = ["src/python/pymcu"]
 
+[tool.pytest.ini_options]
+testpaths = ["tests/python"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+
diff --git a/tests/csharp/Backend/Analysis/DynamicStackAllocatorTests.cs b/tests/csharp/Backend/Analysis/DynamicStackAllocatorTests.cs
new file mode 100644
index 0000000..d6b86d4
--- /dev/null
+++ b/tests/csharp/Backend/Analysis/DynamicStackAllocatorTests.cs
@@ -0,0 +1,184 @@
+// SPDX-License-Identifier: MIT
+// PyMCU Backend SDK — Unit tests for DynamicStackAllocator.
+
+using FluentAssertions;
+using PyMCU.Backend.Analysis;
+using PyMCU.IR;
+using Xunit;
+
+namespace PyMCU.Backend.SDK.Tests.Backend.Analysis;
+
+public class DynamicStackAllocatorTests
+{
+    private static Function MakeFunc(string name, IList<Instruction> body, params string[] parms)
+    {
+        return new Function
+        {
+            Name = name,
+            Params = [.. parms],
+            Body = [.. body]
+        };
+    }
+
+    // ── Word size and reserved-top defaults ───────────────────────────────
+
+    [Fact]
+    public void Allocate_EmptyFunction_TotalSizeIsAlignedReserved()
+    {
+        // No locals, no params: totalSize = reservedTop rounded up to 16.
+        // reservedTop=8 → -currentOffset starts at 8, totalSize=8 → rounds up to 16.
+        var alloc = new DynamicStackAllocator(wordSize: 4, reservedTop: 8);
+        var func = MakeFunc("main", [new Return(new NoneVal())]);
+        var (offsets, total) = alloc.Allocate(func);
+
+        offsets.Should().BeEmpty();
+        total.Should().Be(16); // 8 rounded up to next multiple of 16
+    }
+
+    // ── Single variable allocation ─────────────────────────────────────────
+
+    [Fact]
+    public void Allocate_OneVariable_HasNegativeOffset()
+    {
+        var alloc = new DynamicStackAllocator(wordSize: 4, reservedTop: 8);
+        var func = MakeFunc("main", [
+            new Copy(new Constant(1), new Variable("x")),
+            new Return(new Variable("x"))
+        ]);
+        var (offsets, total) = alloc.Allocate(func);
+
+        offsets.Should().ContainKey("x");
+        offsets["x"].Should().BeNegative(); // frame grows downwards
+        total.Should().BeGreaterThan(0);
+    }
+
+    // ── Parameters come first ─────────────────────────────────────────────
+
+    [Fact]
+    public void Allocate_Params_AllocatedBeforeBodyLocals()
+    {
+        var alloc = new DynamicStackAllocator(wordSize: 4, reservedTop: 8);
+        var func = MakeFunc("add", [
+            new Binary(BinaryOp.Add, new Variable("a"), new Variable("b"), new Variable("result")),
+            new Return(new Variable("result"))
+        ], "a", "b");
+
+        var (offsets, _) = alloc.Allocate(func);
+
+        offsets.Should().ContainKeys("a", "b", "result");
+        // Params a and b are allocated first → more-negative offsets (DynamicStackAllocator
+        // grows downward, so first-allocated = highest address = least-negative offset).
+        // Params come before body locals, so params have a HIGHER (less-negative) offset.
+        offsets["result"].Should().BeLessThan(offsets["a"]);
+        offsets["result"].Should().BeLessThan(offsets["b"]);
+    }
+
+    // ── Alignment: total size is always a multiple of 16 ─────────────────
+
+    [Theory]
+    [InlineData(1)]
+    [InlineData(3)]
+    [InlineData(5)]
+    public void Allocate_TotalSize_IsAlwaysMultipleOf16(int numVars)
+    {
+        var alloc = new DynamicStackAllocator(wordSize: 4, reservedTop: 0);
+        var body = Enumerable.Range(0, numVars)
+            .Select(i => (Instruction)new Copy(new Constant(i), new Variable($"v{i}")))
+            .Append(new Return(new NoneVal()))
+            .ToList();
+
+        var func = MakeFunc("main", body);
+        var (_, total) = alloc.Allocate(func);
+
+        (total % 16).Should().Be(0);
+    }
+
+    // ── Each variable gets a unique offset ────────────────────────────────
+
+    [Fact]
+    public void Allocate_MultipleVars_AllGetDistinctOffsets()
+    {
+        var alloc = new DynamicStackAllocator(wordSize: 4, reservedTop: 0);
+        var func = MakeFunc("main", [
+            new Copy(new Constant(1), new Variable("a")),
+            new Copy(new Constant(2), new Variable("b")),
+            new Copy(new Constant(3), new Variable("c")),
+            new Return(new NoneVal())
+        ]);
+
+        var (offsets, _) = alloc.Allocate(func);
+
+        var vals = new[] { offsets["a"], offsets["b"], offsets["c"] };
+        vals.Should().OnlyHaveUniqueItems();
+    }
+
+    // ── Same variable in multiple instructions — allocated once ───────────
+
+    [Fact]
+    public void Allocate_SameVarReferencedMultipleTimes_AllocatedOnce()
+    {
+        var alloc = new DynamicStackAllocator(wordSize: 4, reservedTop: 0);
+        var func = MakeFunc("main", [
+            new Copy(new Constant(1), new Variable("x")),
+            new Copy(new Variable("x"), new Variable("y")),
+            new Return(new Variable("x"))
+        ]);
+
+        var (offsets, _) = alloc.Allocate(func);
+
+        offsets.Should().ContainKey("x");
+        offsets.Keys.Count(k => k == "x").Should().Be(1); // only one entry for x
+    }
+
+    // ── Temporaries are also allocated ────────────────────────────────────
+
+    [Fact]
+    public void Allocate_Temporaries_AreIncluded()
+    {
+        var alloc = new DynamicStackAllocator(wordSize: 4, reservedTop: 0);
+        var func = MakeFunc("main", [
+            new Binary(BinaryOp.Add, new Variable("a"), new Variable("b"), new Temporary("t1")),
+            new Return(new Temporary("t1"))
+        ]);
+
+        var (offsets, _) = alloc.Allocate(func);
+
+        offsets.Should().ContainKey("t1");
+    }
+
+    // ── Bit instructions ────────────────────────────────────────────────────
+
+    [Fact]
+    public void Allocate_BitInstructions_RegisterVars()
+    {
+        var alloc = new DynamicStackAllocator(wordSize: 4, reservedTop: 0);
+        var func = MakeFunc("main", [
+            new BitSet(new Variable("port"), 3),
+            new BitClear(new Variable("port"), 5),
+            new BitCheck(new Variable("port"), 2, new Temporary("t1")),
+            new BitWrite(new Variable("port"), 4, new Variable("val")),
+            new Return(new NoneVal())
+        ]);
+
+        var (offsets, _) = alloc.Allocate(func);
+
+        offsets.Should().ContainKeys("port", "t1", "val");
+    }
+
+    // ── Custom word size propagates correctly ─────────────────────────────
+
+    [Fact]
+    public void Allocate_CustomWordSize_OffsetsAreSeparatedByWordSize()
+    {
+        var alloc = new DynamicStackAllocator(wordSize: 2, reservedTop: 0);
+        var func = MakeFunc("main", [
+            new Copy(new Constant(1), new Variable("a")),
+            new Copy(new Constant(2), new Variable("b")),
+            new Return(new NoneVal())
+        ]);
+
+        var (offsets, _) = alloc.Allocate(func);
+
+        Math.Abs(offsets["a"] - offsets["b"]).Should().Be(2);
+    }
+}
diff --git a/tests/csharp/Backend/Analysis/StackAllocatorTests.cs b/tests/csharp/Backend/Analysis/StackAllocatorTests.cs
new file mode 100644
index 0000000..1e71782
--- /dev/null
+++ b/tests/csharp/Backend/Analysis/StackAllocatorTests.cs
@@ -0,0 +1,235 @@
+// SPDX-License-Identifier: MIT
+// PyMCU Backend SDK — Unit tests for StackAllocator.
+
+using FluentAssertions;
+using PyMCU.Backend.Analysis;
+using PyMCU.IR;
+using Xunit;
+
+namespace PyMCU.Backend.SDK.Tests.Backend.Analysis;
+
+public class StackAllocatorTests
+{
+    private static ProgramIR MakeProgram(
+        IEnumerable<Variable>? globals = null,
+        IEnumerable<Function>? funcs = null)
+    {
+        var prog = new ProgramIR();
+        if (globals != null) prog.Globals.AddRange(globals);
+        if (funcs != null) prog.Functions.AddRange(funcs);
+        return prog;
+    }
+
+    private static Function MakeFunc(string name, IList<Instruction> body, bool isInterrupt = false, int vector = 0, IList<string>? parms = null)
+    {
+        return new Function
+        {
+            Name = name,
+            Params = parms != null ? [.. parms] : [],
+            Body = [.. body],
+            IsInterrupt = isInterrupt,
+            InterruptVector = vector
+        };
+    }
+
+    // ── Global allocation ──────────────────────────────────────────────────
+
+    [Fact]
+    public void Allocate_NoFunctions_AllocatesGlobals()
+    {
+        var prog = MakeProgram(globals: [
+            new Variable("a", DataType.UINT8),
+            new Variable("b", DataType.UINT16)
+        ]);
+
+        var allocator = new StackAllocator();
+        var (offsets, maxStack) = allocator.Allocate(prog);
+
+        offsets["a"].Should().Be(0);
+        offsets["b"].Should().Be(1);  // UINT8 occupies 1 byte
+        maxStack.Should().Be(3);      // 1 + 2
+    }
+
+    // ── Single function — local variables ─────────────────────────────────
+
+    [Fact]
+    public void Allocate_SingleFunction_AssignsSequentialOffsets()
+    {
+        var prog = MakeProgram(funcs: [MakeFunc("main", [
+            new Copy(new Constant(1), new Variable("x")),
+            new Copy(new Constant(2), new Variable("y")),
+            new Return(new Variable("x"))
+        ])]);
+
+        var allocator = new StackAllocator();
+        var (offsets, maxStack) = allocator.Allocate(prog);
+
+        offsets.Should().ContainKey("x");
+        offsets.Should().ContainKey("y");
+        // x and y are 1-byte locals starting at 0
+        offsets["x"].Should().Be(0);
+        offsets["y"].Should().Be(1);
+        maxStack.Should().BeGreaterThanOrEqualTo(2);
+    }
+
+    // ── Parameter registration ─────────────────────────────────────────────
+
+    [Fact]
+    public void Allocate_FunctionParams_AreRegisteredAsLocals()
+    {
+        // "add" is called from main — params get allocated as part of the call graph.
+        var prog = MakeProgram(funcs: [
+            MakeFunc("main", [
+                new Call("add", [new Constant(1), new Constant(2)], new Variable("out")),
+                new Return(new Variable("out"))
+            ]),
+            MakeFunc("add", [
+                new Binary(BinaryOp.Add, new Variable("a"), new Variable("b"), new Variable("result")),
+                new Return(new Variable("result"))
+            ], parms: ["a", "b"])
+        ]);
+
+        var allocator = new StackAllocator();
+        var (offsets, _) = allocator.Allocate(prog);
+
+        // params a and b should be in the offset table
+        offsets.Should().ContainKey("a");
+        offsets.Should().ContainKey("b");
+    }
+
+    // ── Globals vs locals: globals must not be re-allocated in functions ───
+
+    [Fact]
+    public void Allocate_GlobalNotReallocatedAsLocal()
+    {
+        var prog = MakeProgram(
+            globals: [new Variable("led", DataType.UINT8)],
+            funcs: [MakeFunc("main", [
+                new Copy(new Constant(1), new Variable("led")),   // led is global
+                new Copy(new Constant(0), new Variable("local")),
+                new Return(new NoneVal())
+            ])]);
+
+        var allocator = new StackAllocator();
+        var (offsets, maxStack) = allocator.Allocate(prog);
+
+        // led is global at offset 0
+        offsets["led"].Should().Be(0);
+        // local starts right after the globals (offset 1)
+        offsets["local"].Should().Be(1);
+    }
+
+    // ── Call graph: caller + callee stack frames are sequenced ─────────────
+
+    [Fact]
+    public void Allocate_CallerCallee_SequencesFrames()
+    {
+        var callee = MakeFunc("helper", [
+            new Return(new Variable("ret"))
+        ], parms: ["ret"]);
+
+        var caller = MakeFunc("main", [
+            new Call("helper", [new Constant(1)], new Variable("res")),
+            new Return(new Variable("res"))
+        ]);
+
+        var prog = MakeProgram(funcs: [caller, callee]);
+        var allocator = new StackAllocator();
+        var (offsets, maxStack) = allocator.Allocate(prog);
+
+        // caller's locals come first, then callee's locals start at a higher offset
+        offsets.Should().ContainKey("res");
+        offsets.Should().ContainKey("ret");
+        offsets["ret"].Should().BeGreaterThan(offsets["res"]);
+    }
+
+    // ── Interrupt functions are also allocated ─────────────────────────────
+
+    [Fact]
+    public void Allocate_InterruptFunction_GetsOffsets()
+    {
+        var isr = MakeFunc("isr_tim0", [
+            new Copy(new Constant(0), new Variable("tick")),
+            new Return(new NoneVal())
+        ], isInterrupt: true, vector: 1);
+
+        var main = MakeFunc("main", [new Return(new NoneVal())]);
+
+        var prog = MakeProgram(funcs: [main, isr]);
+        var allocator = new StackAllocator();
+        var (offsets, _) = allocator.Allocate(prog);
+
+        offsets.Should().ContainKey("tick");
+    }
+
+    // ── VariableSizes is populated ────────────────────────────────────────
+
+    [Fact]
+    public void Allocate_VariableSizes_ReflectsDataTypes()
+    {
+        var prog = MakeProgram(funcs: [MakeFunc("main", [
+            new Copy(new Constant(0), new Variable("b8",  DataType.UINT8)),
+            new Copy(new Constant(0), new Variable("b16", DataType.UINT16)),
+            new Copy(new Constant(0), new Variable("b32", DataType.UINT32)),
+            new Return(new NoneVal())
+        ])]);
+
+        var allocator = new StackAllocator();
+        allocator.Allocate(prog);
+
+        allocator.VariableSizes["b8"].Should().Be(1);
+        allocator.VariableSizes["b16"].Should().Be(2);
+        allocator.VariableSizes["b32"].Should().Be(4);
+    }
+
+    // ── BitSet/BitClear/BitCheck/BitWrite variables are captured ──────────
+
+    [Fact]
+    public void Allocate_BitInstructions_RegisterVars()
+    {
+        var prog = MakeProgram(funcs: [MakeFunc("main", [
+            new BitSet(new Variable("port"), 3),
+            new BitClear(new Variable("port"), 5),
+            new BitCheck(new Variable("port"), 2, new Temporary("t1")),
+            new BitWrite(new Variable("port"), 4, new Variable("val")),
+            new Return(new NoneVal())
+        ])]);
+
+        var allocator = new StackAllocator();
+        var (offsets, _) = allocator.Allocate(prog);
+
+        offsets.Should().ContainKey("port");
+        offsets.Should().ContainKey("t1");
+        offsets.Should().ContainKey("val");
+    }
+
+    // ── Array instructions register array name with correct total size ─────
+
+    [Fact]
+    public void Allocate_ArrayLoad_RegistersArrayWithTotalByteSize()
+    {
+        var prog = MakeProgram(funcs: [MakeFunc("main", [
+            new ArrayLoad("buf", new Variable("i"), new Temporary("t1"), DataType.UINT8, 10),
+            new Return(new NoneVal())
+        ])]);
+
+        var allocator = new StackAllocator();
+        allocator.Allocate(prog);
+
+        allocator.VariableSizes["buf"].Should().Be(10); // 10 × UINT8 (1 byte)
+    }
+
+    [Fact]
+    public void Allocate_ArrayStore_RegistersArrayWithTotalByteSize()
+    {
+        var prog = MakeProgram(funcs: [MakeFunc("main", [
+            new ArrayStore("buf", new Variable("i"), new Variable("v"), DataType.UINT16, 4),
+            new Return(new NoneVal())
+        ])]);
+
+        var allocator = new StackAllocator();
+        allocator.Allocate(prog);
+
+        allocator.VariableSizes["buf"].Should().Be(8); // 4 × UINT16 (2 bytes)
+    }
+}
diff --git a/tests/csharp/Backend/License/LicenseResultTests.cs b/tests/csharp/Backend/License/LicenseResultTests.cs
new file mode 100644
index 0000000..a20f26e
--- /dev/null
+++ b/tests/csharp/Backend/License/LicenseResultTests.cs
@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: MIT
+// PyMCU Backend SDK — Unit tests for LicenseResult factory methods.
+
+using FluentAssertions;
+using PyMCU.Backend.License;
+using Xunit;
+
+namespace PyMCU.Backend.SDK.Tests.Backend.License;
+
+public class LicenseResultTests
+{
+    [Fact]
+    public void Free_ReturnsValidStatus_WithFreeMessage()
+    {
+        var result = LicenseResult.Free();
+
+        result.Status.Should().Be(LicenseStatus.Valid);
+        result.Message.Should().Be("free");
+        result.Email.Should().BeNull();
+        result.ExpiryDate.Should().BeNull();
+    }
+
+    [Fact]
+    public void Ok_ReturnsValidStatus_WithEmailAndExpiry()
+    {
+        var expiry = new DateTime(2027, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+        var result = LicenseResult.Ok("dev@example.com", expiry);
+
+        result.Status.Should().Be(LicenseStatus.Valid);
+        result.Email.Should().Be("dev@example.com");
+        result.ExpiryDate.Should().Be(expiry);
+    }
+
+    [Fact]
+    public void NotFound_ReturnsMissingStatus()
+    {
+        var result = LicenseResult.NotFound("avr");
+
+        result.Status.Should().Be(LicenseStatus.Missing);
+        result.Message.Should().Contain("avr");
+        result.Message.Should().Contain("PYMCU_LICENSE_KEY");
+    }
+
+    [Fact]
+    public void Expired_ReturnsExpiredStatus_WithEmailAndDate()
+    {
+        var expiry = new DateTime(2024, 6, 1, 0, 0, 0, DateTimeKind.Utc);
+        var result = LicenseResult.Expired("user@example.com", expiry);
+
+        result.Status.Should().Be(LicenseStatus.Expired);
+        result.Email.Should().Be("user@example.com");
+        result.ExpiryDate.Should().Be(expiry);
+        result.Message.Should().Contain("2024-06-01");
+    }
+
+    [Fact]
+    public void WrongFamily_ReturnsInvalidTargetStatus()
+    {
+        var result = LicenseResult.WrongFamily("pic14");
+
+        result.Status.Should().Be(LicenseStatus.InvalidTarget);
+        result.Message.Should().Contain("pic14");
+    }
+}
diff --git a/tests/csharp/Backend/License/LicenseValidatorTests.cs b/tests/csharp/Backend/License/LicenseValidatorTests.cs
new file mode 100644
index 0000000..0dd759b
--- /dev/null
+++ b/tests/csharp/Backend/License/LicenseValidatorTests.cs
@@ -0,0 +1,169 @@
+// SPDX-License-Identifier: MIT
+// PyMCU Backend SDK — Unit tests for LicenseValidator.
+
+using FluentAssertions;
+using PyMCU.Backend.License;
+using Xunit;
+
+namespace PyMCU.Backend.SDK.Tests.Backend.License;
+
+/// <summary>
+/// Tests for LicenseValidator key resolution and JWT parsing.
+///
+/// Because the SDK ships with the placeholder public key
+/// ("REPLACE_WITH_REAL_RSA2048_PUBLIC_KEY_BASE64_HERE"), signature
+/// verification is intentionally skipped in dev builds.  These tests
+/// therefore exercise key resolution, expiry, family matching, and
+/// structural parsing — not the actual RSA signature.
+/// </summary>
+public class LicenseValidatorResolveKeyTests : IDisposable
+{
+    private readonly string _origEnv;
+    private readonly string _tmpHome;
+
+    public LicenseValidatorResolveKeyTests()
+    {
+        _origEnv = Environment.GetEnvironmentVariable("PYMCU_LICENSE_KEY") ?? "";
+        Environment.SetEnvironmentVariable("PYMCU_LICENSE_KEY", null);
+        _tmpHome = Path.Combine(Path.GetTempPath(), $"pymcu_test_{Guid.NewGuid():N}");
+        Directory.CreateDirectory(_tmpHome);
+    }
+
+    public void Dispose()
+    {
+        Environment.SetEnvironmentVariable("PYMCU_LICENSE_KEY",
+            string.IsNullOrEmpty(_origEnv) ? null : _origEnv);
+        if (Directory.Exists(_tmpHome))
+            Directory.Delete(_tmpHome, recursive: true);
+    }
+
+    [Fact]
+    public void ResolveKey_ExplicitKey_TakesPriority()
+    {
+        Environment.SetEnvironmentVariable("PYMCU_LICENSE_KEY", "env-key");
+        LicenseValidator.ResolveKey("explicit-key").Should().Be("explicit-key");
+    }
+
+    [Fact]
+    public void ResolveKey_EnvVar_ResolvedWhenNoExplicit()
+    {
+        Environment.SetEnvironmentVariable("PYMCU_LICENSE_KEY", "env-key");
+        LicenseValidator.ResolveKey().Should().Be("env-key");
+    }
+
+    [Fact]
+    public void ResolveKey_NoSources_ReturnsNull()
+    {
+        // Ensure env var is cleared and no home file exists for this test
+        Environment.SetEnvironmentVariable("PYMCU_LICENSE_KEY", null);
+        // Note: we can't easily fake the home dir in .NET without reflection,
+        // so we only verify when no env is set and ResolveKey returns null or a
+        // value from the home file (which may legitimately exist in the environment).
+        var result = LicenseValidator.ResolveKey();
+        // Accept null or a non-empty string (in case a real license.key exists on the CI runner)
+        if (result != null) result.Should().NotBeEmpty();
+    }
+
+    [Fact]
+    public void ResolveKey_WhitespaceExplicit_TreatedAsNotSet()
+    {
+        LicenseValidator.ResolveKey("   ").Should().BeNull();
+    }
+}
+
+public class LicenseValidatorValidateTests
+{
+    // ── Pre-built test JWTs (placeholder sig — sig check is skipped in dev mode) ──
+    //
+    // Generated from:
+    //   header = base64url({"alg":"RS256","typ":"JWT"})
+    //   payload = base64url({"sub":"...","iat":...,"exp":...,"backends":[...]})
+    //   jwt = header + "." + payload + ".ZmFrZXNpZ25hdHVyZQ"  (fake sig bytes)
+    //
+    // These JWTs are intentionally unsigned dev tokens used only in tests.
+
+    // Expires 2099 — "avr" backend
+    private const string ValidAvrJwt =
+        "eyJhbGciOiAiUlMyNTYiLCAidHlwIjogIkpXVCJ9" +
+        ".eyJzdWIiOiAidXNlckBleGFtcGxlLmNvbSIsICJpYXQiOiAxNzAwMDAwMDAwLCAiZXhwIjogNDEwMjQ0NDgwMCwgImJhY2tlbmRzIjogWyJhdnIiXX0" +
+        ".ZmFrZXNpZ25hdHVyZQ";
+
+    // Expired in 2001 — "avr" backend
+    private const string ExpiredJwt =
+        "eyJhbGciOiAiUlMyNTYiLCAidHlwIjogIkpXVCJ9" +
+        ".eyJzdWIiOiAidXNlckBleGFtcGxlLmNvbSIsICJpYXQiOiAxNzAwMDAwMDAwLCAiZXhwIjogMTAwMDAwMDAwMCwgImJhY2tlbmRzIjogWyJhdnIiXX0" +
+        ".ZmFrZXNpZ25hdHVyZQ";
+
+    // Expires 2099, "avr" only — queried for "pic14"
+    private const string WrongFamilyJwt =
+        "eyJhbGciOiAiUlMyNTYiLCAidHlwIjogIkpXVCJ9" +
+        ".eyJzdWIiOiAidXNlckBleGFtcGxlLmNvbSIsICJpYXQiOiAxNzAwMDAwMDAwLCAiZXhwIjogNDEwMjQ0NDgwMCwgImJhY2tlbmRzIjogWyJhdnIiXX0" +
+        ".ZmFrZXNpZ25hdHVyZQ";
+
+    // Expires 2099, no "backends" field — covers any family
+    private const string AllFamiliesJwt =
+        "eyJhbGciOiAiUlMyNTYiLCAidHlwIjogIkpXVCJ9" +
+        ".eyJzdWIiOiAidXNlckBleGFtcGxlLmNvbSIsICJpYXQiOiAxNzAwMDAwMDAwLCAiZXhwIjogNDEwMjQ0NDgwMH0" +
+        ".ZmFrZXNpZ25hdHVyZQ";
+
+    [Fact]
+    public void Validate_NoKey_ReturnsMissing()
+    {
+        // Pass an explicit null so it doesn't read from env or file
+        var result = LicenseValidator.Validate("avr", "");
+        result.Status.Should().Be(LicenseStatus.Missing);
+    }
+
+    [Fact]
+    public void Validate_MalformedKey_ReturnsMalformed()
+    {
+        var result = LicenseValidator.Validate("avr", "not.a.jwt.with.too.many.dots.here.x");
+        result.Status.Should().Be(LicenseStatus.Malformed);
+    }
+
+    [Fact]
+    public void Validate_ValidAvrKey_CorrectFamily_ReturnsValid()
+    {
+        var result = LicenseValidator.Validate("avr", ValidAvrJwt);
+        result.Status.Should().Be(LicenseStatus.Valid);
+        result.Email.Should().Be("user@example.com");
+    }
+
+    [Fact]
+    public void Validate_ExpiredKey_ReturnsExpired()
+    {
+        var result = LicenseValidator.Validate("avr", ExpiredJwt);
+        result.Status.Should().Be(LicenseStatus.Expired);
+        result.Email.Should().Be("user@example.com");
+        result.ExpiryDate.Should().BeBefore(DateTime.UtcNow);
+    }
+
+    [Fact]
+    public void Validate_WrongFamily_ReturnsInvalidTarget()
+    {
+        var result = LicenseValidator.Validate("pic14", WrongFamilyJwt);
+        result.Status.Should().Be(LicenseStatus.InvalidTarget);
+    }
+
+    [Fact]
+    public void Validate_AllFamilies_AllowsAnyFamily()
+    {
+        // No "backends" array in payload → all families accepted
+        var result = LicenseValidator.Validate("riscv", AllFamiliesJwt);
+        result.Status.Should().Be(LicenseStatus.Valid);
+    }
+
+    [Fact]
+    public void Free_AlwaysReturnsValid()
+    {
+        LicenseValidator.Free().Status.Should().Be(LicenseStatus.Valid);
+    }
+
+    [Fact]
+    public void Validate_CaseInsensitiveFamily_Match()
+    {
+        // "avr" in JWT, "AVR" queried
+        var result = LicenseValidator.Validate("AVR", ValidAvrJwt);
+        result.Status.Should().Be(LicenseStatus.Valid);
+    }
+}
diff --git a/tests/csharp/Backend/Serialization/IrSerializerTests.cs b/tests/csharp/Backend/Serialization/IrSerializerTests.cs
new file mode 100644
index 0000000..cfa7a39
--- /dev/null
+++ b/tests/csharp/Backend/Serialization/IrSerializerTests.cs
@@ -0,0 +1,364 @@
+// SPDX-License-Identifier: MIT
+// PyMCU Backend SDK — Unit tests for IrSerializer (JSON round-trip).
+
+using FluentAssertions;
+using PyMCU.Backend.Serialization;
+using PyMCU.IR;
+using Xunit;
+
+namespace PyMCU.Backend.SDK.Tests.Backend.Serialization;
+
+public class IrSerializerTests : IDisposable
+{
+    private readonly string _tmpDir = Path.Combine(Path.GetTempPath(), $"irser_{Guid.NewGuid():N}");
+
+    public IrSerializerTests() => Directory.CreateDirectory(_tmpDir);
+
+    public void Dispose()
+    {
+        if (Directory.Exists(_tmpDir))
+            Directory.Delete(_tmpDir, recursive: true);
+    }
+
+    private string TempFile(string name = "test.mir") => Path.Combine(_tmpDir, name);
+
+    private static ProgramIR RoundTrip(ProgramIR prog)
+    {
+        var tmp = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid():N}.mir");
+        try
+        {
+            IrSerializer.Serialize(prog, tmp);
+            return IrSerializer.Deserialize(tmp);
+        }
+        finally
+        {
+            if (File.Exists(tmp)) File.Delete(tmp);
+        }
+    }
+
+    // ── Empty program round-trip ───────────────────────────────────────────
+
+    [Fact]
+    public void Serialize_EmptyProgram_RoundTrips()
+    {
+        var prog = new ProgramIR();
+        var rt = RoundTrip(prog);
+
+        rt.Globals.Should().BeEmpty();
+        rt.Functions.Should().BeEmpty();
+        rt.ExternSymbols.Should().BeEmpty();
+    }
+
+    // ── Globals ────────────────────────────────────────────────────────────
+
+    [Fact]
+    public void Serialize_Globals_RoundTrip()
+    {
+        var prog = new ProgramIR();
+        prog.Globals.Add(new Variable("led", DataType.UINT8));
+        prog.Globals.Add(new Variable("counter", DataType.UINT16));
+
+        var rt = RoundTrip(prog);
+
+        rt.Globals.Should().HaveCount(2);
+        rt.Globals[0].Name.Should().Be("led");
+        rt.Globals[0].Type.Should().Be(DataType.UINT8);
+        rt.Globals[1].Name.Should().Be("counter");
+        rt.Globals[1].Type.Should().Be(DataType.UINT16);
+    }
+
+    // ── ExternSymbols ─────────────────────────────────────────────────────
+
+    [Fact]
+    public void Serialize_ExternSymbols_RoundTrip()
+    {
+        var prog = new ProgramIR();
+        prog.ExternSymbols.AddRange(["uart_write", "delay_ms"]);
+
+        var rt = RoundTrip(prog);
+
+        rt.ExternSymbols.Should().BeEquivalentTo(["uart_write", "delay_ms"]);
+    }
+
+    // ── Function metadata ─────────────────────────────────────────────────
+
+    [Fact]
+    public void Serialize_FunctionMetadata_RoundTrips()
+    {
+        var prog = new ProgramIR();
+        prog.Functions.Add(new Function
+        {
+            Name = "isr_tim0",
+            ReturnType = DataType.VOID,
+            IsInterrupt = true,
+            IsInline = false,
+            InterruptVector = 2,
+            Params = ["arg1"]
+        });
+
+        var rt = RoundTrip(prog);
+        var f = rt.Functions[0];
+
+        f.Name.Should().Be("isr_tim0");
+        f.ReturnType.Should().Be(DataType.VOID);
+        f.IsInterrupt.Should().BeTrue();
+        f.InterruptVector.Should().Be(2);
+        f.Params.Should().ContainSingle("arg1");
+    }
+
+    // ── Instruction type round-trips ───────────────────────────────────────
+
+    [Fact]
+    public void Serialize_ReturnWithConstant_RoundTrips()
+    {
+        var prog = new ProgramIR();
+        prog.Functions.Add(new Function
+        {
+            Name = "main",
+            Body = [new Return(new Constant(42))]
+        });
+
+        var rt = RoundTrip(prog);
+        var ret = rt.Functions[0].Body.OfType<Return>().First();
+
+        ret.Value.Should().BeOfType<Constant>().Which.Value.Should().Be(42);
+    }
+
+    [Fact]
+    public void Serialize_CopyInstruction_RoundTrips()
+    {
+        var prog = new ProgramIR();
+        prog.Functions.Add(new Function
+        {
+            Name = "main",
+            Body = [new Copy(new Constant(1), new Variable("x", DataType.UINT8))]
+        });
+
+        var rt = RoundTrip(prog);
+        var copy = rt.Functions[0].Body.OfType<Copy>().First();
+
+        copy.Src.Should().BeOfType<Constant>().Which.Value.Should().Be(1);
+        copy.Dst.Should().BeOfType<Variable>().Which.Name.Should().Be("x");
+    }
+
+    [Fact]
+    public void Serialize_BinaryInstruction_RoundTrips()
+    {
+        var prog = new ProgramIR();
+        prog.Functions.Add(new Function
+        {
+            Name = "main",
+            Body = [new Binary(BinaryOp.Add, new Variable("a"), new Variable("b"), new Temporary("t1"))]
+        });
+
+        var rt = RoundTrip(prog);
+        var bin = rt.Functions[0].Body.OfType<Binary>().First();
+
+        bin.Op.Should().Be(BinaryOp.Add);
+        bin.Src1.Should().BeOfType<Variable>().Which.Name.Should().Be("a");
+        bin.Src2.Should().BeOfType<Variable>().Which.Name.Should().Be("b");
+        bin.Dst.Should().BeOfType<Temporary>().Which.Name.Should().Be("t1");
+    }
+
+    [Fact]
+    public void Serialize_UnaryInstruction_RoundTrips()
+    {
+        var prog = new ProgramIR();
+        prog.Functions.Add(new Function
+        {
+            Name = "main",
+            Body = [new Unary(UnaryOp.Neg, new Constant(5), new Temporary("t1"))]
+        });
+
+        var rt = RoundTrip(prog);
+        var u = rt.Functions[0].Body.OfType<Unary>().First();
+
+        u.Op.Should().Be(UnaryOp.Neg);
+        u.Src.Should().BeOfType<Constant>().Which.Value.Should().Be(5);
+    }
+
+    [Fact]
+    public void Serialize_BitInstructions_RoundTrip()
+    {
+        var prog = new ProgramIR();
+        prog.Functions.Add(new Function
+        {
+            Name = "main",
+            Body =
+            [
+                new BitSet(new Variable("port"), 3),
+                new BitClear(new Variable("port"), 5),
+                new BitCheck(new Variable("port"), 2, new Temporary("t1")),
+                new BitWrite(new Variable("port"), 4, new Variable("val")),
+                new Return(new NoneVal())
+            ]
+        });
+
+        var rt = RoundTrip(prog);
+        var body = rt.Functions[0].Body;
+
+        body.OfType<BitSet>().First().Bit.Should().Be(3);
+        body.OfType<BitClear>().First().Bit.Should().Be(5);
+        body.OfType<BitCheck>().First().Bit.Should().Be(2);
+        body.OfType<BitWrite>().First().Bit.Should().Be(4);
+    }
+
+    [Fact]
+    public void Serialize_JumpInstructions_RoundTrip()
+    {
+        var prog = new ProgramIR();
+        prog.Functions.Add(new Function
+        {
+            Name = "main",
+            Body =
+            [
+                new JumpIfZero(new Variable("cond"), "end"),
+                new Jump("end"),
+                new Label("end"),
+                new Return(new NoneVal())
+            ]
+        });
+
+        var rt = RoundTrip(prog);
+        var body = rt.Functions[0].Body;
+
+        body.OfType<JumpIfZero>().First().Target.Should().Be("end");
+        body.OfType<Jump>().First().Target.Should().Be("end");
+        body.OfType<Label>().First().Name.Should().Be("end");
+    }
+
+    [Fact]
+    public void Serialize_CallInstruction_RoundTrips()
+    {
+        var prog = new ProgramIR();
+        prog.Functions.Add(new Function
+        {
+            Name = "main",
+            Body = [new Call("helper", [new Variable("a"), new Constant(1)], new Temporary("ret"))]
+        });
+
+        var rt = RoundTrip(prog);
+        var call = rt.Functions[0].Body.OfType<Call>().First();
+
+        call.FunctionName.Should().Be("helper");
+        call.Args.Should().HaveCount(2);
+        call.Dst.Should().BeOfType<Temporary>().Which.Name.Should().Be("ret");
+    }
+
+    [Fact]
+    public void Serialize_ArrayLoadAndStore_RoundTrip()
+    {
+        var prog = new ProgramIR();
+        prog.Functions.Add(new Function
+        {
+            Name = "main",
+            Body =
+            [
+                new ArrayLoad("buf", new Variable("i"), new Temporary("t1"), DataType.UINT8, 8),
+                new ArrayStore("buf", new Variable("j"), new Variable("v"), DataType.UINT8, 8),
+                new Return(new NoneVal())
+            ]
+        });
+
+        var rt = RoundTrip(prog);
+        var body = rt.Functions[0].Body;
+
+        var al = body.OfType<ArrayLoad>().First();
+        al.ArrayName.Should().Be("buf");
+        al.Count.Should().Be(8);
+        al.ElemType.Should().Be(DataType.UINT8);
+
+        var ast = body.OfType<ArrayStore>().First();
+        ast.ArrayName.Should().Be("buf");
+    }
+
+    [Fact]
+    public void Serialize_FlashData_RoundTrips()
+    {
+        var prog = new ProgramIR();
+        prog.Functions.Add(new Function
+        {
+            Name = "main",
+            Body = [new FlashData("lut", [0x00, 0x01, 0xFF]), new Return(new NoneVal())]
+        });
+
+        var rt = RoundTrip(prog);
+        var fd = rt.Functions[0].Body.OfType<FlashData>().First();
+
+        fd.Name.Should().Be("lut");
+        fd.Bytes.Should().BeEquivalentTo([0x00, 0x01, 0xFF]);
+    }
+
+    [Fact]
+    public void Serialize_MemoryAddress_RoundTrips()
+    {
+        var prog = new ProgramIR();
+        prog.Functions.Add(new Function
+        {
+            Name = "main",
+            Body = [new Copy(new MemoryAddress(0x2000, DataType.UINT8), new Variable("x"))]
+        });
+
+        var rt = RoundTrip(prog);
+        var copy = rt.Functions[0].Body.OfType<Copy>().First();
+
+        copy.Src.Should().BeOfType<MemoryAddress>()
+            .Which.Address.Should().Be(0x2000);
+    }
+
+    [Fact]
+    public void Serialize_FloatConstant_RoundTrips()
+    {
+        var prog = new ProgramIR();
+        prog.Functions.Add(new Function
+        {
+            Name = "main",
+            Body = [new Return(new FloatConstant(3.14))]
+        });
+
+        var rt = RoundTrip(prog);
+        var ret = rt.Functions[0].Body.OfType<Return>().First();
+
+        ret.Value.Should().BeOfType<FloatConstant>().Which.Value.Should().BeApproximately(3.14, 1e-9);
+    }
+
+    [Fact]
+    public void Serialize_InlineAsm_WithOperands_RoundTrips()
+    {
+        var prog = new ProgramIR();
+        prog.Functions.Add(new Function
+        {
+            Name = "main",
+            Body = [new InlineAsm("clr %0", [new Variable("x")])]
+        });
+
+        var rt = RoundTrip(prog);
+        var asm = rt.Functions[0].Body.OfType<InlineAsm>().First();
+
+        asm.Code.Should().Be("clr %0");
+        asm.Operands.Should().HaveCount(1);
+    }
+
+    // ── File not found ─────────────────────────────────────────────────────
+
+    [Fact]
+    public void Deserialize_MissingFile_Throws()
+    {
+        var act = () => IrSerializer.Deserialize(Path.Combine(_tmpDir, "nonexistent.mir"));
+        act.Should().Throw<Exception>();
+    }
+
+    // ── Produces a file on disk ────────────────────────────────────────────
+
+    [Fact]
+    public void Serialize_CreatesFile()
+    {
+        var prog = new ProgramIR();
+        var path = TempFile("out.mir");
+
+        IrSerializer.Serialize(prog, path);
+
+        File.Exists(path).Should().BeTrue();
+        new FileInfo(path).Length.Should().BeGreaterThan(0);
+    }
+}
diff --git a/tests/csharp/IR/DataTypeTests.cs b/tests/csharp/IR/DataTypeTests.cs
new file mode 100644
index 0000000..f96aa2d
--- /dev/null
+++ b/tests/csharp/IR/DataTypeTests.cs
@@ -0,0 +1,168 @@
+// SPDX-License-Identifier: MIT
+// PyMCU Backend SDK — Unit tests for DataType and DataTypeExtensions.
+
+using FluentAssertions;
+using PyMCU.IR;
+using Xunit;
+
+namespace PyMCU.Backend.SDK.Tests.IR;
+
+public class DataTypeSizeOfTests
+{
+    [Theory]
+    [InlineData(DataType.UINT8,  1)]
+    [InlineData(DataType.INT8,   1)]
+    [InlineData(DataType.UINT16, 2)]
+    [InlineData(DataType.INT16,  2)]
+    [InlineData(DataType.UINT32, 4)]
+    [InlineData(DataType.INT32,  4)]
+    [InlineData(DataType.FLOAT,  4)]
+    [InlineData(DataType.VOID,   1)] // falls through to default
+    [InlineData(DataType.UNKNOWN,1)] // falls through to default
+    public void SizeOf_ReturnsExpectedBytes(DataType type, int expected)
+    {
+        type.SizeOf().Should().Be(expected);
+    }
+}
+
+public class DataTypeIsSignedTests
+{
+    [Theory]
+    [InlineData(DataType.INT8,   true)]
+    [InlineData(DataType.INT16,  true)]
+    [InlineData(DataType.INT32,  true)]
+    [InlineData(DataType.UINT8,  false)]
+    [InlineData(DataType.UINT16, false)]
+    [InlineData(DataType.UINT32, false)]
+    [InlineData(DataType.FLOAT,  false)]
+    [InlineData(DataType.VOID,   false)]
+    [InlineData(DataType.UNKNOWN,false)]
+    public void IsSigned_ReturnsExpectedResult(DataType type, bool expected)
+    {
+        type.IsSigned().Should().Be(expected);
+    }
+}
+
+public class DataTypeStringToDataTypeTests
+{
+    [Theory]
+    [InlineData("",        DataType.UINT8)]  // empty → UINT8
+    [InlineData("uint8",   DataType.UINT8)]
+    [InlineData("int",     DataType.INT16)]
+    [InlineData("int8",    DataType.INT8)]
+    [InlineData("uint16",  DataType.UINT16)]
+    [InlineData("int16",   DataType.INT16)]
+    [InlineData("uint32",  DataType.UINT32)]
+    [InlineData("int32",   DataType.INT32)]
+    [InlineData("float",   DataType.FLOAT)]
+    [InlineData("const",   DataType.UINT8)]
+    [InlineData("void",    DataType.VOID)]
+    [InlineData("None",    DataType.VOID)]
+    [InlineData("ptr",     DataType.UINT16)]
+    public void StringToDataType_KnownStrings(string input, DataType expected)
+    {
+        DataTypeExtensions.StringToDataType(input).Should().Be(expected);
+    }
+
+    [Theory]
+    [InlineData("const[uint8]",  DataType.UINT8)]
+    [InlineData("const[uint16]", DataType.UINT16)]
+    [InlineData("const[int8]",   DataType.INT8)]
+    [InlineData("const[int32]",  DataType.INT32)]
+    public void StringToDataType_ConstBracket_ExtractsInnerType(string input, DataType expected)
+    {
+        DataTypeExtensions.StringToDataType(input).Should().Be(expected);
+    }
+
+    [Theory]
+    [InlineData("ptr[uint8]",  DataType.UINT8)]
+    [InlineData("ptr[uint16]", DataType.UINT16)]
+    [InlineData("ptr[int32]",  DataType.INT32)]
+    public void StringToDataType_PtrBracket_ExtractsInnerType(string input, DataType expected)
+    {
+        DataTypeExtensions.StringToDataType(input).Should().Be(expected);
+    }
+
+    [Fact]
+    public void StringToDataType_PioRegister_ReturnsUInt16()
+    {
+        DataTypeExtensions.StringToDataType("SomePIORegister").Should().Be(DataType.UINT16);
+    }
+
+    [Fact]
+    public void StringToDataType_Null_ReturnsUInt8()
+    {
+        // null is treated as empty/null by string.IsNullOrEmpty
+        DataTypeExtensions.StringToDataType(null!).Should().Be(DataType.UINT8);
+    }
+
+    [Fact]
+    public void StringToDataType_UnknownString_ReturnsUnknown()
+    {
+        DataTypeExtensions.StringToDataType("bogus_type").Should().Be(DataType.UNKNOWN);
+    }
+}
+
+public class DataTypeGetPromotedTypeTests
+{
+    [Fact]
+    public void GetPromotedType_SameType_ReturnsSame()
+    {
+        DataTypeExtensions.GetPromotedType(DataType.UINT8, DataType.UINT8).Should().Be(DataType.UINT8);
+        DataTypeExtensions.GetPromotedType(DataType.INT16, DataType.INT16).Should().Be(DataType.INT16);
+        DataTypeExtensions.GetPromotedType(DataType.UINT32, DataType.UINT32).Should().Be(DataType.UINT32);
+    }
+
+    [Fact]
+    public void GetPromotedType_LargerType_WinsRegardlessOfSignedness()
+    {
+        // uint16 (2) vs int8 (1) → uint16 wins (larger size)
+        DataTypeExtensions.GetPromotedType(DataType.UINT16, DataType.INT8).Should().Be(DataType.UINT16);
+        DataTypeExtensions.GetPromotedType(DataType.INT8, DataType.UINT16).Should().Be(DataType.UINT16);
+    }
+
+    [Fact]
+    public void GetPromotedType_SameSize_DifferentSignedness_PromotesToNextSigned()
+    {
+        // uint8 (unsigned 1-byte) vs int8 (signed 1-byte) → INT16
+        DataTypeExtensions.GetPromotedType(DataType.UINT8, DataType.INT8).Should().Be(DataType.INT16);
+        DataTypeExtensions.GetPromotedType(DataType.INT8, DataType.UINT8).Should().Be(DataType.INT16);
+    }
+
+    [Fact]
+    public void GetPromotedType_SameSize_SameSignedness_ReturnsFirst()
+    {
+        // Both unsigned 1-byte: same size, same signedness → returns first (a)
+        DataTypeExtensions.GetPromotedType(DataType.UINT8, DataType.UINT8).Should().Be(DataType.UINT8);
+    }
+
+    [Fact]
+    public void GetPromotedType_Uint16_vs_Int16_PromotesToInt32()
+    {
+        // Same size (2 bytes), different signedness → INT32
+        DataTypeExtensions.GetPromotedType(DataType.UINT16, DataType.INT16).Should().Be(DataType.INT32);
+        DataTypeExtensions.GetPromotedType(DataType.INT16, DataType.UINT16).Should().Be(DataType.INT32);
+    }
+
+    [Fact]
+    public void GetPromotedType_Int32_vs_Uint32_PromotesToInt32()
+    {
+        // Same size (4 bytes), different signedness → INT32 (capped at largest signed)
+        DataTypeExtensions.GetPromotedType(DataType.INT32, DataType.UINT32).Should().Be(DataType.INT32);
+    }
+
+    [Fact]
+    public void GetPromotedType_Float_vs_Int32_ReturnsFloat()
+    {
+        // float and int32 both 4 bytes but float is unsigned-classified → INT32 wins via signedness
+        // float.IsSigned() is false, int32.IsSigned() is true, same size → INT32
+        DataTypeExtensions.GetPromotedType(DataType.FLOAT, DataType.INT32).Should().Be(DataType.INT32);
+    }
+
+    [Fact]
+    public void GetPromotedType_Uint32_vs_Int8_ReturnsUInt32()
+    {
+        // uint32 (4) > int8 (1) → UINT32
+        DataTypeExtensions.GetPromotedType(DataType.UINT32, DataType.INT8).Should().Be(DataType.UINT32);
+    }
+}
diff --git a/tests/csharp/IR/TackyTests.cs b/tests/csharp/IR/TackyTests.cs
new file mode 100644
index 0000000..195a204
--- /dev/null
+++ b/tests/csharp/IR/TackyTests.cs
@@ -0,0 +1,292 @@
+// SPDX-License-Identifier: MIT
+// PyMCU Backend SDK — Unit tests for IR value and instruction record types.
+
+using FluentAssertions;
+using PyMCU.IR;
+using Xunit;
+
+namespace PyMCU.Backend.SDK.Tests.IR;
+
+/// <summary>
+/// Tests that Val subtypes and Instruction records have correct structural equality
+/// (record semantics), default values, and can be constructed without error.
+/// </summary>
+public class ValRecordTests
+{
+    [Fact]
+    public void Constant_Equality_ById_Value()
+    {
+        new Constant(42).Should().Be(new Constant(42));
+        new Constant(1).Should().NotBe(new Constant(2));
+    }
+
+    [Fact]
+    public void FloatConstant_Equality()
+    {
+        new FloatConstant(3.14).Should().Be(new FloatConstant(3.14));
+        new FloatConstant(1.0).Should().NotBe(new FloatConstant(2.0));
+    }
+
+    [Fact]
+    public void Variable_DefaultType_IsUInt8()
+    {
+        var v = new Variable("x");
+        v.Type.Should().Be(DataType.UINT8);
+    }
+
+    [Fact]
+    public void Variable_Equality_ConsidersNameAndType()
+    {
+        new Variable("x", DataType.UINT8).Should().Be(new Variable("x", DataType.UINT8));
+        new Variable("x", DataType.UINT8).Should().NotBe(new Variable("x", DataType.UINT16));
+        new Variable("x").Should().NotBe(new Variable("y"));
+    }
+
+    [Fact]
+    public void Temporary_DefaultType_IsUInt8()
+    {
+        var t = new Temporary("t1");
+        t.Type.Should().Be(DataType.UINT8);
+    }
+
+    [Fact]
+    public void MemoryAddress_Equality()
+    {
+        new MemoryAddress(0x20).Should().Be(new MemoryAddress(0x20));
+        new MemoryAddress(0x20, DataType.UINT16).Should().NotBe(new MemoryAddress(0x20, DataType.UINT8));
+    }
+
+    [Fact]
+    public void NoneVal_Equality()
+    {
+        new NoneVal().Should().Be(new NoneVal());
+    }
+
+    [Fact]
+    public void DifferentValTypes_AreNotEqual()
+    {
+        ((Val)new Constant(1)).Should().NotBe(new Variable("x"));
+        ((Val)new NoneVal()).Should().NotBe(new Constant(0));
+    }
+}
+
+public class InstructionRecordTests
+{
+    private static Variable V(string n, DataType t = DataType.UINT8) => new(n, t);
+    private static Temporary T(string n, DataType t = DataType.UINT8) => new(n, t);
+    private static Constant C(int v) => new(v);
+
+    [Fact]
+    public void Return_Equality()
+    {
+        new Return(C(0)).Should().Be(new Return(C(0)));
+        new Return(C(0)).Should().NotBe(new Return(C(1)));
+    }
+
+    [Fact]
+    public void Copy_Equality()
+    {
+        new Copy(C(1), V("x")).Should().Be(new Copy(C(1), V("x")));
+        new Copy(C(1), V("x")).Should().NotBe(new Copy(C(2), V("x")));
+    }
+
+    [Fact]
+    public void Unary_Equality()
+    {
+        new Unary(UnaryOp.Neg, C(5), T("t1"))
+            .Should().Be(new Unary(UnaryOp.Neg, C(5), T("t1")));
+        new Unary(UnaryOp.Neg, C(5), T("t1"))
+            .Should().NotBe(new Unary(UnaryOp.Not, C(5), T("t1")));
+    }
+
+    [Fact]
+    public void Binary_Equality()
+    {
+        new Binary(BinaryOp.Add, V("a"), V("b"), T("t"))
+            .Should().Be(new Binary(BinaryOp.Add, V("a"), V("b"), T("t")));
+        new Binary(BinaryOp.Add, V("a"), V("b"), T("t"))
+            .Should().NotBe(new Binary(BinaryOp.Sub, V("a"), V("b"), T("t")));
+    }
+
+    [Fact]
+    public void Jump_StoresTarget()
+    {
+        var j = new Jump("loop_start");
+        j.Target.Should().Be("loop_start");
+    }
+
+    [Fact]
+    public void JumpIfZero_StoresConditionAndTarget()
+    {
+        var jz = new JumpIfZero(V("flag"), "end");
+        jz.Condition.Should().Be(V("flag"));
+        jz.Target.Should().Be("end");
+    }
+
+    [Fact]
+    public void Label_StoresName()
+    {
+        new Label("loop").Name.Should().Be("loop");
+    }
+
+    [Fact]
+    public void Call_StoresArgsAndDst()
+    {
+        var call = new Call("foo", [V("a"), V("b")], T("ret"));
+        call.FunctionName.Should().Be("foo");
+        call.Args.Should().HaveCount(2);
+        call.Dst.Should().Be(T("ret"));
+    }
+
+    [Fact]
+    public void BitSet_StoresBit()
+    {
+        var bs = new BitSet(V("port"), 3);
+        bs.Bit.Should().Be(3);
+        bs.Target.Should().Be(V("port"));
+    }
+
+    [Fact]
+    public void BitClear_StoresBit()
+    {
+        var bc = new BitClear(V("port"), 5);
+        bc.Bit.Should().Be(5);
+    }
+
+    [Fact]
+    public void BitCheck_StoresSourceBitAndDst()
+    {
+        var bck = new BitCheck(V("port"), 2, T("t1"));
+        bck.Source.Should().Be(V("port"));
+        bck.Bit.Should().Be(2);
+        bck.Dst.Should().Be(T("t1"));
+    }
+
+    [Fact]
+    public void BitWrite_StoresAllFields()
+    {
+        var bw = new BitWrite(V("port"), 4, V("val"));
+        bw.Target.Should().Be(V("port"));
+        bw.Bit.Should().Be(4);
+        bw.Src.Should().Be(V("val"));
+    }
+
+    [Fact]
+    public void AugAssign_StoresOpTargetOperand()
+    {
+        var aug = new AugAssign(BinaryOp.Add, V("x"), C(1));
+        aug.Op.Should().Be(BinaryOp.Add);
+        aug.Target.Should().Be(V("x"));
+        aug.Operand.Should().Be(C(1));
+    }
+
+    [Fact]
+    public void InlineAsm_WithoutOperands_HasNullOperands()
+    {
+        var asm = new InlineAsm("nop");
+        asm.Code.Should().Be("nop");
+        asm.Operands.Should().BeNull();
+    }
+
+    [Fact]
+    public void InlineAsm_WithOperands_StoresList()
+    {
+        var asm = new InlineAsm("mov %0, %1", [V("a"), V("b")]);
+        asm.Operands.Should().HaveCount(2);
+    }
+
+    [Fact]
+    public void DebugLine_StoresAllFields()
+    {
+        var dbg = new DebugLine(42, "x = 1", "main.py");
+        dbg.Line.Should().Be(42);
+        dbg.Text.Should().Be("x = 1");
+        dbg.SourceFile.Should().Be("main.py");
+    }
+
+    [Fact]
+    public void ArrayLoad_StoresAllFields()
+    {
+        var al = new ArrayLoad("arr", V("i"), T("t1"), DataType.UINT8, 16);
+        al.ArrayName.Should().Be("arr");
+        al.ElemType.Should().Be(DataType.UINT8);
+        al.Count.Should().Be(16);
+    }
+
+    [Fact]
+    public void ArrayStore_StoresAllFields()
+    {
+        var ast = new ArrayStore("arr", V("i"), V("val"), DataType.UINT8, 8);
+        ast.ArrayName.Should().Be("arr");
+        ast.ElemType.Should().Be(DataType.UINT8);
+        ast.Count.Should().Be(8);
+    }
+
+    [Fact]
+    public void ArrayLoadFlash_StoresAllFields()
+    {
+        var alf = new ArrayLoadFlash("lut", V("i"), T("t1"));
+        alf.ArrayName.Should().Be("lut");
+    }
+
+    [Fact]
+    public void FlashData_StoresNameAndBytes()
+    {
+        var fd = new FlashData("lut", [0x01, 0x02, 0x03]);
+        fd.Name.Should().Be("lut");
+        fd.Bytes.Should().BeEquivalentTo([1, 2, 3]);
+    }
+
+    [Fact]
+    public void LoadIndirect_StoresSrcPtrAndDst()
+    {
+        var li = new LoadIndirect(V("ptr"), T("t1"));
+        li.SrcPtr.Should().Be(V("ptr"));
+        li.Dst.Should().Be(T("t1"));
+    }
+
+    [Fact]
+    public void StoreIndirect_StoresSrcAndDstPtr()
+    {
+        var si = new StoreIndirect(V("val"), V("ptr"));
+        si.Src.Should().Be(V("val"));
+        si.DstPtr.Should().Be(V("ptr"));
+    }
+}
+
+public class ProgramIRTests
+{
+    [Fact]
+    public void ProgramIR_Default_HasEmptyCollections()
+    {
+        var prog = new ProgramIR();
+        prog.Globals.Should().BeEmpty();
+        prog.Functions.Should().BeEmpty();
+        prog.ExternSymbols.Should().BeEmpty();
+    }
+
+    [Fact]
+    public void Function_Default_HasEmptyCollections()
+    {
+        var func = new Function();
+        func.Name.Should().BeEmpty();
+        func.Params.Should().BeEmpty();
+        func.Body.Should().BeEmpty();
+        func.ReturnType.Should().Be(DataType.VOID);
+        func.IsInline.Should().BeFalse();
+        func.IsInterrupt.Should().BeFalse();
+    }
+
+    [Fact]
+    public void ProgramIR_CanAddGlobalsAndFunctions()
+    {
+        var prog = new ProgramIR();
+        prog.Globals.Add(new Variable("led", DataType.UINT8));
+        prog.Functions.Add(new Function { Name = "main" });
+        prog.ExternSymbols.Add("uart_write");
+
+        prog.Globals.Should().HaveCount(1);
+        prog.Functions.Should().HaveCount(1);
+        prog.ExternSymbols.Should().ContainSingle("uart_write");
+    }
+}
diff --git a/tests/csharp/PyMCU.Backend.SDK.Tests.csproj b/tests/csharp/PyMCU.Backend.SDK.Tests.csproj
new file mode 100644
index 0000000..ebfd45b
--- /dev/null
+++ b/tests/csharp/PyMCU.Backend.SDK.Tests.csproj
@@ -0,0 +1,29 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+    <InvariantGlobalization>true</InvariantGlobalization>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.9.0" />
+    <PackageReference Include="xunit" Version="2.7.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.7">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="coverlet.collector" Version="6.0.2">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="FluentAssertions" Version="6.12.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\csharp\PyMCU.Backend.SDK.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/tests/python/conftest.py b/tests/python/conftest.py
new file mode 100644
index 0000000..dc7b178
--- /dev/null
+++ b/tests/python/conftest.py
@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: MIT
+# PyMCU Backend SDK — shared pytest fixtures for Python unit tests.
diff --git a/tests/python/test_backend_plugin.py b/tests/python/test_backend_plugin.py
new file mode 100644
index 0000000..b4186c6
--- /dev/null
+++ b/tests/python/test_backend_plugin.py
@@ -0,0 +1,160 @@
+# SPDX-License-Identifier: MIT
+# PyMCU Backend SDK — Unit tests for BackendPlugin and resolve_license_key.
+
+import os
+import tempfile
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+from pymcu.backend.sdk.plugin import (
+    BackendPlugin,
+    LicenseStatus,
+    resolve_license_key,
+)
+
+
+# ---------------------------------------------------------------------------
+# resolve_license_key — priority order
+# ---------------------------------------------------------------------------
+
+class TestResolveLicenseKey:
+    def test_explicit_key_wins_over_env_and_file(self, tmp_path):
+        env_key = "env-key-123"
+        with patch.dict(os.environ, {"PYMCU_LICENSE_KEY": env_key}, clear=False):
+            assert resolve_license_key("explicit-key") == "explicit-key"
+
+    def test_env_var_used_when_no_explicit_key(self, tmp_path):
+        with patch.dict(os.environ, {"PYMCU_LICENSE_KEY": "env-key-abc"}, clear=False):
+            assert resolve_license_key() == "env-key-abc"
+
+    def test_env_var_whitespace_stripped(self):
+        with patch.dict(os.environ, {"PYMCU_LICENSE_KEY": "  my-key  "}, clear=False):
+            assert resolve_license_key() == "my-key"
+
+    def test_explicit_key_whitespace_stripped(self):
+        assert resolve_license_key("  trimmed  ") == "trimmed"
+
+    def test_file_used_when_no_explicit_or_env(self, tmp_path):
+        key_file = tmp_path / "license.key"
+        key_file.write_text("file-key-xyz\n")
+        with patch.dict(os.environ, {"PYMCU_LICENSE_KEY": ""}, clear=False):
+            with patch("pathlib.Path.home", return_value=tmp_path):
+                # Create the expected path: ~/.pymcu/license.key
+                pymcu_dir = tmp_path / ".pymcu"
+                pymcu_dir.mkdir(parents=True, exist_ok=True)
+                license_key_path = pymcu_dir / "license.key"
+                license_key_path.write_text("file-key-xyz\n")
+                result = resolve_license_key()
+        # Either from env (empty after strip) or from file
+        # Since env is empty, it should fall through to file
+        # (result depends on whether empty string counts as set in env)
+        # The implementation uses os.environ.get which returns "", truthy only if non-empty
+        assert result == "file-key-xyz"
+
+    def test_returns_none_when_nothing_set(self, tmp_path):
+        with patch.dict(os.environ, {"PYMCU_LICENSE_KEY": ""}, clear=False):
+            with patch("pathlib.Path.home", return_value=tmp_path):
+                # No license.key file exists under tmp_path/.pymcu/
+                result = resolve_license_key()
+        assert result is None
+
+    def test_explicit_none_falls_through_to_env(self):
+        with patch.dict(os.environ, {"PYMCU_LICENSE_KEY": "from-env"}, clear=False):
+            assert resolve_license_key(None) == "from-env"
+
+
+# ---------------------------------------------------------------------------
+# BackendPlugin — abstract base class contract
+# ---------------------------------------------------------------------------
+
+class _FreeBackend(BackendPlugin):
+    """Minimal concrete backend for testing."""
+    family = "test"
+    description = "Test backend"
+    version = "0.0.1"
+    supported_arches = ["atmega", "attiny", "at90"]
+
+    @classmethod
+    def get_backend_binary(cls) -> Path:
+        return Path("/usr/bin/fake-backend")
+
+
+class _PaidBackend(BackendPlugin):
+    """Backend that overrides validate_license to return MISSING."""
+    family = "paid"
+    description = "Paid test backend"
+    version = "1.0.0"
+    supported_arches = ["pic16"]
+
+    @classmethod
+    def get_backend_binary(cls) -> Path:
+        return Path("/usr/bin/paid-backend")
+
+    @classmethod
+    def validate_license(cls, key=None) -> LicenseStatus:
+        return LicenseStatus.MISSING
+
+
+class TestBackendPluginSupports:
+    def test_exact_match(self):
+        assert _FreeBackend.supports("atmega") is True
+
+    def test_prefix_match(self):
+        assert _FreeBackend.supports("atmega328p") is True
+        assert _FreeBackend.supports("attiny85") is True
+        assert _FreeBackend.supports("at90usb") is True
+
+    def test_case_insensitive_match(self):
+        assert _FreeBackend.supports("ATmega328P") is True
+        assert _FreeBackend.supports("ATTINY85") is True
+
+    def test_unsupported_chip_returns_false(self):
+        assert _FreeBackend.supports("pic16f84a") is False
+        assert _FreeBackend.supports("stm32") is False
+        assert _FreeBackend.supports("") is False
+
+    def test_partial_match_does_not_false_positive(self):
+        # "mega" is not a valid prefix — only "atmega" is
+        assert _FreeBackend.supports("mega328") is False
+
+
+class TestBackendPluginValidateLicense:
+    def test_default_returns_valid(self):
+        status = _FreeBackend.validate_license()
+        assert status == LicenseStatus.VALID
+
+    def test_override_can_return_missing(self):
+        status = _PaidBackend.validate_license()
+        assert status == LicenseStatus.MISSING
+
+    def test_default_ignores_key_argument(self):
+        # Default implementation always returns VALID regardless of key
+        assert _FreeBackend.validate_license("any-key") == LicenseStatus.VALID
+        assert _FreeBackend.validate_license(None) == LicenseStatus.VALID
+
+
+class TestBackendPluginGetBackendBinary:
+    def test_returns_path(self):
+        p = _FreeBackend.get_backend_binary()
+        assert isinstance(p, Path)
+
+
+class TestLicenseStatusEnum:
+    def test_all_expected_values_exist(self):
+        assert LicenseStatus.VALID
+        assert LicenseStatus.MISSING
+        assert LicenseStatus.EXPIRED
+        assert LicenseStatus.INVALID_TARGET
+        assert LicenseStatus.MALFORMED
+
+    def test_values_are_distinct(self):
+        values = [
+            LicenseStatus.VALID,
+            LicenseStatus.MISSING,
+            LicenseStatus.EXPIRED,
+            LicenseStatus.INVALID_TARGET,
+            LicenseStatus.MALFORMED,
+        ]
+        assert len(set(values)) == 5
diff --git a/tests/python/test_base_tool.py b/tests/python/test_base_tool.py
new file mode 100644
index 0000000..c9f60b3
--- /dev/null
+++ b/tests/python/test_base_tool.py
@@ -0,0 +1,299 @@
+# SPDX-License-Identifier: MIT
+# PyMCU Backend SDK — Unit tests for CacheableTool (base_tool.py).
+
+import hashlib
+import io
+import os
+import sys
+import tarfile
+import tempfile
+import zipfile
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _make_console() -> MagicMock:
+    """Return a Mock that satisfies the rich.console.Console interface."""
+    return MagicMock()
+
+
+def _make_tool(tmp_path: Path, console=None):
+    """Create a concrete CacheableTool subclass for testing."""
+    from pymcu.toolchain.sdk.base_tool import CacheableTool
+
+    class _DummyTool(CacheableTool):
+        def get_name(self) -> str:
+            return "dummy"
+
+        def is_cached(self) -> bool:
+            return (self._get_tool_dir() / "dummy_binary").exists()
+
+        def install(self) -> Path:
+            binary = self._get_tool_dir() / "dummy_binary"
+            binary.parent.mkdir(parents=True, exist_ok=True)
+            binary.write_text("dummy")
+            return binary
+
+    if console is None:
+        console = _make_console()
+
+    with patch.dict(os.environ, {"PYMCU_TOOLS_DIR": str(tmp_path)}, clear=False):
+        return _DummyTool(console)
+
+
+# ---------------------------------------------------------------------------
+# _default_platform_key
+# ---------------------------------------------------------------------------
+
+class TestDefaultPlatformKey:
+    def test_returns_os_arch_format(self):
+        from pymcu.toolchain.sdk.base_tool import _default_platform_key
+        key = _default_platform_key()
+        assert "-" in key, "Platform key should be '<os>-<arch>'"
+
+    @pytest.mark.parametrize("machine,expected_arch", [
+        ("x86_64", "x86_64"),
+        ("AMD64",  "x86_64"),
+        ("aarch64","arm64"),
+        ("arm64",  "arm64"),
+        ("riscv64","riscv64"),  # unknown → passed through
+    ])
+    def test_architecture_normalisation(self, machine, expected_arch):
+        from pymcu.toolchain.sdk.base_tool import _default_platform_key
+        with patch("platform.machine", return_value=machine):
+            key = _default_platform_key()
+        assert key.endswith(f"-{expected_arch}"), f"Got {key!r}"
+
+    def test_linux_os_normalised_to_linux(self):
+        from pymcu.toolchain.sdk.base_tool import _default_platform_key
+        with patch("sys.platform", "linux"), patch("platform.machine", return_value="x86_64"):
+            key = _default_platform_key()
+        assert key.startswith("linux-")
+
+    def test_darwin_os_kept_as_darwin(self):
+        from pymcu.toolchain.sdk.base_tool import _default_platform_key
+        with patch("sys.platform", "darwin"), patch("platform.machine", return_value="arm64"):
+            key = _default_platform_key()
+        assert key.startswith("darwin-")
+
+
+# ---------------------------------------------------------------------------
+# _is_non_interactive
+# ---------------------------------------------------------------------------
+
+class TestIsNonInteractive:
+    def test_ci_env_var_true_returns_non_interactive(self):
+        from pymcu.toolchain.sdk.base_tool import _is_non_interactive
+        with patch.dict(os.environ, {"CI": "true"}, clear=False):
+            assert _is_non_interactive() is True
+
+    def test_pymcu_no_interactive_env_returns_non_interactive(self):
+        from pymcu.toolchain.sdk.base_tool import _is_non_interactive
+        with patch.dict(os.environ, {"PYMCU_NO_INTERACTIVE": "1", "CI": ""}, clear=False):
+            assert _is_non_interactive() is True
+
+    def test_non_tty_stdin_returns_non_interactive(self):
+        from pymcu.toolchain.sdk.base_tool import _is_non_interactive
+        mock_stdin = MagicMock()
+        mock_stdin.isatty.return_value = False
+        with patch.dict(os.environ, {"CI": "", "PYMCU_NO_INTERACTIVE": ""}, clear=False):
+            with patch("sys.stdin", mock_stdin):
+                assert _is_non_interactive() is True
+
+    def test_tty_stdin_returns_interactive(self):
+        from pymcu.toolchain.sdk.base_tool import _is_non_interactive
+        mock_stdin = MagicMock()
+        mock_stdin.isatty.return_value = True
+        with patch.dict(os.environ, {"CI": "", "PYMCU_NO_INTERACTIVE": ""}, clear=False):
+            with patch("sys.stdin", mock_stdin):
+                assert _is_non_interactive() is False
+
+
+# ---------------------------------------------------------------------------
+# verify_sha256
+# ---------------------------------------------------------------------------
+
+class TestVerifySha256:
+    def test_correct_hash_returns_true(self, tmp_path):
+        tool = _make_tool(tmp_path)
+        content = b"hello pymcu"
+        f = tmp_path / "test.bin"
+        f.write_bytes(content)
+        expected = hashlib.sha256(content).hexdigest()
+        assert tool.verify_sha256(f, expected) is True
+
+    def test_uppercase_hash_also_matches(self, tmp_path):
+        tool = _make_tool(tmp_path)
+        content = b"hello pymcu"
+        f = tmp_path / "test.bin"
+        f.write_bytes(content)
+        expected = hashlib.sha256(content).hexdigest().upper()
+        assert tool.verify_sha256(f, expected) is True
+
+    def test_wrong_hash_returns_false(self, tmp_path):
+        tool = _make_tool(tmp_path)
+        f = tmp_path / "test.bin"
+        f.write_bytes(b"hello")
+        assert tool.verify_sha256(f, "deadbeef" * 8) is False
+
+    def test_missing_file_returns_false(self, tmp_path):
+        tool = _make_tool(tmp_path)
+        assert tool.verify_sha256(tmp_path / "nonexistent.bin", "aabbcc") is False
+
+    def test_empty_file_has_known_sha256(self, tmp_path):
+        tool = _make_tool(tmp_path)
+        f = tmp_path / "empty.bin"
+        f.write_bytes(b"")
+        # SHA-256 of empty string is well-known
+        expected = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+        assert tool.verify_sha256(f, expected) is True
+
+
+# ---------------------------------------------------------------------------
+# _extract_archive — tar.gz, tar.bz2, zip (including zip-slip protection)
+# ---------------------------------------------------------------------------
+
+def _create_tar_gz(archive_path: Path, members: dict[str, bytes]):
+    """Create a tar.gz archive with the given {filename: content} members."""
+    with tarfile.open(archive_path, "w:gz") as tar:
+        for name, data in members.items():
+            info = tarfile.TarInfo(name=name)
+            info.size = len(data)
+            tar.addfile(info, io.BytesIO(data))
+
+
+def _create_tar_bz2(archive_path: Path, members: dict[str, bytes]):
+    with tarfile.open(archive_path, "w:bz2") as tar:
+        for name, data in members.items():
+            info = tarfile.TarInfo(name=name)
+            info.size = len(data)
+            tar.addfile(info, io.BytesIO(data))
+
+
+def _create_zip(archive_path: Path, members: dict[str, bytes]):
+    with zipfile.ZipFile(archive_path, "w") as zf:
+        for name, data in members.items():
+            zf.writestr(name, data)
+
+
+class TestExtractArchiveTarGz:
+    def test_extracts_files(self, tmp_path):
+        tool = _make_tool(tmp_path)
+        archive = tmp_path / "test.tar.gz"
+        dest = tmp_path / "out"
+        dest.mkdir()
+        _create_tar_gz(archive, {"hello.txt": b"world"})
+        tool._extract_archive(archive, dest, "tar.gz")
+        assert (dest / "hello.txt").read_bytes() == b"world"
+
+    def test_zipslip_member_skipped(self, tmp_path):
+        """A path-traversal entry (../../evil.txt) must be skipped, not extracted."""
+        tool = _make_tool(tmp_path)
+        archive = tmp_path / "evil.tar.gz"
+        dest = tmp_path / "out"
+        dest.mkdir()
+        evil_path = "../../evil.txt"
+        _create_tar_gz(archive, {evil_path: b"pwned", "safe.txt": b"ok"})
+        tool._extract_archive(archive, dest, "tar.gz")
+        # safe.txt must be present; evil.txt must NOT escape target dir
+        assert (dest / "safe.txt").read_bytes() == b"ok"
+        escaped = (tmp_path.parent / "evil.txt")
+        assert not escaped.exists()
+
+
+class TestExtractArchiveTarBz2:
+    def test_extracts_files(self, tmp_path):
+        tool = _make_tool(tmp_path)
+        archive = tmp_path / "test.tar.bz2"
+        dest = tmp_path / "out"
+        dest.mkdir()
+        _create_tar_bz2(archive, {"data.bin": b"\x00\x01\x02"})
+        tool._extract_archive(archive, dest, "tar.bz2")
+        assert (dest / "data.bin").read_bytes() == b"\x00\x01\x02"
+
+
+class TestExtractArchiveZip:
+    def test_extracts_files(self, tmp_path):
+        tool = _make_tool(tmp_path)
+        archive = tmp_path / "test.zip"
+        dest = tmp_path / "out"
+        dest.mkdir()
+        _create_zip(archive, {"readme.txt": b"hello"})
+        tool._extract_archive(archive, dest, "zip")
+        assert (dest / "readme.txt").read_bytes() == b"hello"
+
+    def test_zipslip_member_skipped(self, tmp_path):
+        tool = _make_tool(tmp_path)
+        archive = tmp_path / "evil.zip"
+        dest = tmp_path / "out"
+        dest.mkdir()
+        _create_zip(archive, {"../../evil.txt": b"pwned", "safe.txt": b"ok"})
+        tool._extract_archive(archive, dest, "zip")
+        assert (dest / "safe.txt").read_bytes() == b"ok"
+        assert not (tmp_path.parent / "evil.txt").exists()
+
+    def test_unsupported_archive_type_raises(self, tmp_path):
+        tool = _make_tool(tmp_path)
+        with pytest.raises(ValueError, match="Unsupported archive type"):
+            tool._extract_archive(tmp_path / "x.rar", tmp_path, "rar")
+
+
+# ---------------------------------------------------------------------------
+# Base class cache directory logic
+# ---------------------------------------------------------------------------
+
+class TestCacheableToolBaseDir:
+    def test_default_base_dir_uses_home(self, tmp_path):
+        from pymcu.toolchain.sdk.base_tool import CacheableTool, _default_platform_key
+
+        class _DummyTool(CacheableTool):
+            def get_name(self): return "dummy"
+            def is_cached(self): return False
+            def install(self): return Path()
+
+        # Clear PYMCU_TOOLS_DIR so the default path is used
+        with patch.dict(os.environ, {}, clear=False):
+            os.environ.pop("PYMCU_TOOLS_DIR", None)
+            tool = _DummyTool(_make_console())
+        assert str(Path.home()) in str(tool.base_dir)
+        assert _default_platform_key() in str(tool.base_dir)
+
+    def test_env_override_sets_base_dir(self, tmp_path):
+        tool = _make_tool(tmp_path)
+        assert str(tmp_path) in str(tool.base_dir)
+
+    def test_relative_tools_dir_is_resolved_to_absolute(self, tmp_path):
+        from pymcu.toolchain.sdk.base_tool import CacheableTool
+
+        class _DummyTool(CacheableTool):
+            def get_name(self): return "dummy"
+            def is_cached(self): return False
+            def install(self): return Path()
+
+        # Path.resolve() turns a relative path into an absolute one, so the
+        # constructor succeeds and base_dir is always absolute.
+        with patch.dict(os.environ, {"PYMCU_TOOLS_DIR": "relative/path"}, clear=False):
+            tool = _DummyTool(_make_console())
+        assert tool.base_dir.is_absolute()
+
+
+# ---------------------------------------------------------------------------
+# Version file helpers
+# ---------------------------------------------------------------------------
+
+class TestVersionFile:
+    def test_write_and_read_version(self, tmp_path):
+        tool = _make_tool(tmp_path)
+        tool._write_cached_version("1.2.3")
+        assert tool._read_cached_version() == "1.2.3"
+
+    def test_read_missing_version_returns_empty(self, tmp_path):
+        tool = _make_tool(tmp_path)
+        # Don't write anything
+        assert tool._read_cached_version() == ""
diff --git a/tests/python/test_toolchain_plugin.py b/tests/python/test_toolchain_plugin.py
new file mode 100644
index 0000000..c5faa18
--- /dev/null
+++ b/tests/python/test_toolchain_plugin.py
@@ -0,0 +1,156 @@
+# SPDX-License-Identifier: MIT
+# PyMCU Backend SDK — Unit tests for ToolchainPlugin and ExternalToolchain.
+
+from pathlib import Path
+from typing import Optional
+from unittest.mock import MagicMock, patch
+import os
+
+import pytest
+
+from pymcu.toolchain.sdk.plugin import ToolchainPlugin
+from pymcu.toolchain.sdk.toolchain import ExternalToolchain
+from pymcu.toolchain.sdk.base_tool import CacheableTool
+
+
+# ---------------------------------------------------------------------------
+# Concrete stubs for testing
+# ---------------------------------------------------------------------------
+
+def _make_console() -> MagicMock:
+    return MagicMock()
+
+
+class _FakeToolchain(ExternalToolchain):
+    """Minimal concrete ExternalToolchain for testing."""
+
+    def get_name(self) -> str:
+        return "fake-avr-gcc"
+
+    def is_cached(self) -> bool:
+        return False
+
+    def install(self) -> Path:
+        return Path("/fake/avr-gcc")
+
+    @classmethod
+    def supports(cls, chip: str) -> bool:
+        return chip.lower().startswith("atmega") or chip.lower().startswith("attiny")
+
+    def assemble(self, asm_file: Path, output_file: Optional[Path] = None) -> Path:
+        return output_file or asm_file.with_suffix(".hex")
+
+
+class _FakePlugin(ToolchainPlugin):
+    """Concrete ToolchainPlugin that wraps _FakeToolchain."""
+
+    family = "avr"
+    description = "AVR toolchain (fake)"
+    version = "1.0.0"
+    default_chip = "atmega328p"
+
+    @classmethod
+    def supports(cls, chip: str) -> bool:
+        return _FakeToolchain.supports(chip)
+
+    @classmethod
+    def get_toolchain(cls, console, chip: str) -> ExternalToolchain:
+        with patch.dict(os.environ, {"PYMCU_TOOLS_DIR": "/tmp/fake_tools"}, clear=False):
+            return _FakeToolchain(console, chip)
+
+
+# ---------------------------------------------------------------------------
+# ToolchainPlugin.supports
+# ---------------------------------------------------------------------------
+
+class TestToolchainPluginSupports:
+    def test_supported_chip_returns_true(self):
+        assert _FakePlugin.supports("atmega328p") is True
+        assert _FakePlugin.supports("attiny85") is True
+
+    def test_unsupported_chip_returns_false(self):
+        assert _FakePlugin.supports("pic16f84a") is False
+        assert _FakePlugin.supports("stm32f4") is False
+
+
+# ---------------------------------------------------------------------------
+# ToolchainPlugin.get_instance (uses default_chip)
+# ---------------------------------------------------------------------------
+
+class TestToolchainPluginGetInstance:
+    def test_get_instance_returns_external_toolchain(self):
+        console = _make_console()
+        toolchain = _FakePlugin.get_instance(console)
+        assert isinstance(toolchain, ExternalToolchain)
+
+    def test_get_instance_uses_default_chip(self):
+        console = _make_console()
+        toolchain = _FakePlugin.get_instance(console)
+        assert toolchain.chip == _FakePlugin.default_chip
+
+
+# ---------------------------------------------------------------------------
+# ToolchainPlugin.get_ffi_toolchain (default returns None)
+# ---------------------------------------------------------------------------
+
+class TestToolchainPluginFfiDefault:
+    def test_get_ffi_toolchain_returns_none_by_default(self):
+        console = _make_console()
+        result = _FakePlugin.get_ffi_toolchain(console, "atmega328p")
+        assert result is None
+
+
+# ---------------------------------------------------------------------------
+# ExternalToolchain — link() default is None
+# ---------------------------------------------------------------------------
+
+class TestExternalToolchainLinkDefault:
+    def test_link_returns_none_by_default(self, tmp_path):
+        console = _make_console()
+        with patch.dict(os.environ, {"PYMCU_TOOLS_DIR": str(tmp_path)}, clear=False):
+            tc = _FakeToolchain(console, "atmega328p")
+        result = tc.link(Path("/fake/out.hex"), "atmega328p", tmp_path)
+        assert result is None
+
+
+# ---------------------------------------------------------------------------
+# ExternalToolchain — chip attribute is stored
+# ---------------------------------------------------------------------------
+
+class TestExternalToolchainChip:
+    def test_chip_stored_correctly(self, tmp_path):
+        console = _make_console()
+        with patch.dict(os.environ, {"PYMCU_TOOLS_DIR": str(tmp_path)}, clear=False):
+            tc = _FakeToolchain(console, "attiny85")
+        assert tc.chip == "attiny85"
+
+    def test_default_chip_is_empty(self, tmp_path):
+        console = _make_console()
+        with patch.dict(os.environ, {"PYMCU_TOOLS_DIR": str(tmp_path)}, clear=False):
+            tc = _FakeToolchain(console)
+        assert tc.chip == ""
+
+
+# ---------------------------------------------------------------------------
+# ExternalToolchain — assemble() contract
+# ---------------------------------------------------------------------------
+
+class TestExternalToolchainAssemble:
+    def test_assemble_returns_path(self, tmp_path):
+        console = _make_console()
+        asm = tmp_path / "blink.asm"
+        asm.write_text("; nop")
+        with patch.dict(os.environ, {"PYMCU_TOOLS_DIR": str(tmp_path)}, clear=False):
+            tc = _FakeToolchain(console, "atmega328p")
+        result = tc.assemble(asm)
+        assert isinstance(result, Path)
+
+    def test_assemble_with_explicit_output(self, tmp_path):
+        console = _make_console()
+        asm = tmp_path / "blink.asm"
+        out = tmp_path / "blink.hex"
+        asm.write_text("; nop")
+        with patch.dict(os.environ, {"PYMCU_TOOLS_DIR": str(tmp_path)}, clear=False):
+            tc = _FakeToolchain(console, "atmega328p")
+        result = tc.assemble(asm, out)
+        assert result == out