avrotize 2.20.3__py3-none-any.whl → 2.20.4__py3-none-any.whl

avrotize/__init__.py

@@ -56,6 +56,8 @@ _mappings = {
     "convert_avro_to_rust": (f"{mod}.avrotorust", "convert_avro_to_rust"),
     "convert_avro_schema_to_rust": (f"{mod}.avrotorust", "convert_avro_schema_to_rust"),
     "convert_avro_to_datapackage": (f"{mod}.avrotodatapackage", "convert_avro_to_datapackage"),
+    "convert_structure_to_javascript": (f"{mod}.structuretojs", "convert_structure_to_javascript"),
+    "convert_structure_schema_to_javascript": (f"{mod}.structuretojs", "convert_structure_schema_to_javascript"),
 }
 
 _lazy_loader = LazyLoader(_mappings)

avrotize/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '2.20.3'
-__version_tuple__ = version_tuple = (2, 20, 3)
+__version__ = version = '2.20.4'
+__version_tuple__ = version_tuple = (2, 20, 4)
 
 __commit_id__ = commit_id = None

avrotize/avrotocsharp/README.md.jinja

@@ -0,0 +1,166 @@
+# {{ project_name }}
+
+This is a generated C# project from an Avro schema using [avrotize](https://github.com/clemensv/avrotize).
+
+## Project Structure
+
+```
+{{ project_name }}/
+├── src/                    # Generated C# classes from Avro schema
+│   └── {{ project_name | pascal }}.csproj
+├── test/                   # Generated unit tests
+│   └── {{ project_name | pascal }}.Test.csproj
+├── run_coverage.ps1        # PowerShell coverage script
+├── run_coverage.sh         # Bash coverage script (Linux/macOS)
+└── {{ project_name }}.sln  # Visual Studio solution file
+```
+
+## Building and Running
+
+### Quick Start
+```bash
+# Build the project
+dotnet build
+
+# Run tests
+dotnet test
+
+# Run tests with coverage
+dotnet test --collect:"XPlat Code Coverage"
+```
+
+### Code Coverage
+
+This project includes automated code coverage collection and reporting.
+
+#### Using the Coverage Scripts
+
+**PowerShell (Windows):**
+```powershell
+# Run tests with default 85% coverage threshold
+.\run_coverage.ps1
+
+# Set custom coverage threshold
+.\run_coverage.ps1 -Threshold 90
+
+# Generate HTML coverage report
+.\run_coverage.ps1 -HtmlReport
+
+# Generate and open HTML report in browser
+.\run_coverage.ps1 -HtmlReport -OpenReport
+
+# Run without failing on low coverage
+.\run_coverage.ps1 -FailOnLowCoverage:$false
+```
+
+**Bash (Linux/macOS):**
+```bash
+# Run tests with default 85% coverage threshold
+./run_coverage.sh
+
+# Set custom coverage threshold
+./run_coverage.sh --threshold 90
+
+# Generate HTML coverage report
+./run_coverage.sh --html-report
+
+# Generate and open HTML report in browser
+./run_coverage.sh --open-report
+
+# Run without failing on low coverage
+./run_coverage.sh --no-fail
+```
+
+#### Coverage Configuration
+
+The test project is configured with the following coverage settings in `test/{{ project_name | pascal }}.Test.csproj`:
+
+- **Default Threshold**: 85% line coverage
+- **Output Format**: Cobertura XML
+- **Coverage Output**: `./coverage/` directory
+- **Includes**: All `{{ project_name | pascal }}` namespace code
+- **Excludes**: Test projects
+
+#### Coverage Reports
+
+Coverage reports are generated in the following formats:
+
+1. **Cobertura XML**: `./coverage/[guid]/coverage.cobertura.xml`
+2. **HTML Report** (when requested): `./coverage/html/index.html`
+
+#### Continuous Integration
+
+For CI/CD pipelines, use:
+
+```yaml
+# Example GitHub Actions step
+- name: Run tests with coverage
+  run: |
+    dotnet test --collect:"XPlat Code Coverage" --results-directory:"./coverage"
+    
+# Or use the coverage script for threshold enforcement
+- name: Run tests with coverage threshold
+  run: ./run_coverage.sh --threshold 85
+```
+
+## Generated Code Features
+
+This project includes generated C# classes with the following features:
+
+- **Value Equality**: Generated `Equals()` and `GetHashCode()` methods
+- **Comprehensive Unit Tests**: Property tests, equality tests, and serialization tests
+- **Multiple Serialization Support**: JSON, XML, and Avro serialization (if enabled)
+- **Nullable Reference Types**: Full C# nullable reference type support
+
+## Test Coverage Goals
+
+The generated tests aim to provide comprehensive coverage of:
+
+- ✅ **Property Access**: All public properties
+- ✅ **Equality Methods**: `Equals()` and `GetHashCode()` 
+- ✅ **Constructors**: Default and parameterized constructors
+- ✅ **Serialization**: JSON/XML/Avro serialization (when enabled)
+- ✅ **Edge Cases**: Null handling and type conversion
+
+### Typical Coverage Results
+
+The generated tests typically achieve:
+- **Line Coverage**: 95%+
+- **Branch Coverage**: 90%+
+
+## Customizing Coverage
+
+To modify coverage settings, edit the `test/{{ project_name | pascal }}.Test.csproj` file:
+
+```xml
+<PropertyGroup>
+  <!-- Modify these values -->
+  <Threshold>85</Threshold>                    <!-- Minimum coverage % -->
+  <ThresholdType>line</ThresholdType>          <!-- line, branch, or method -->
+  <ThresholdStat>minimum</ThresholdStat>       <!-- minimum, average, or total -->
+</PropertyGroup>
+```
+
+## Dependencies
+
+### Runtime
+- .NET 9.0
+- Newtonsoft.Json (if JSON serialization enabled)
+- Apache.Avro (if Avro serialization enabled)
+
+### Testing
+- NUnit 4.3.2
+- NUnit3TestAdapter 5.0.0
+- Microsoft.NET.Test.Sdk 17.13.0
+- coverlet.collector 6.0.4
+- coverlet.msbuild 6.0.4
+
+## Additional Tools
+
+For enhanced coverage reporting, install ReportGenerator globally:
+
+```bash
+dotnet tool install -g dotnet-reportgenerator-globaltool
+```
+
+This enables HTML report generation with the `-HtmlReport` option.

avrotize/avrotocsharp/class_test.cs.jinja

@@ -122,6 +122,17 @@ public class {{ test_class_name }}
         Assert.That(newInstance, Is.EqualTo(_instance));
     }
     {%- endif %}
+    {%- if protobuf_net_annotation %}
+    /// <summary> Testing Protobuf serializer </summary>
+    [Test]
+    public void Test_ToByteArray_FromData_Protobuf()
+    {
+        var mediaType = "application/x-protobuf";
+        var bytes = _instance.ToByteArray(mediaType);
+        var newInstance = {{ class_base_name }}.FromData(bytes, mediaType);
+        Assert.That(newInstance, Is.EqualTo(_instance));
+    }
+    {%- endif %}
     {%- if system_xml_annotation %}
     /// <summary> Testing XML serializer </summary>
     [Test]
@@ -133,6 +144,121 @@ public class {{ test_class_name }}
         Assert.That(newInstance, Is.EqualTo(_instance));
     }
     {%- endif %}
+    {%- if system_text_json_annotation %}
+    /// <summary> Testing JSON serializer </summary>
+    [Test]
+    public void Test_ToByteArray_FromData_Json()
+    {
+        var mediaType = "application/json";
+        var bytes = _instance.ToByteArray(mediaType);
+        var newInstance = {{ class_base_name }}.FromData(bytes, mediaType);
+        Assert.That(newInstance, Is.EqualTo(_instance));
+    }
+    {%- endif %}
+    {%- if msgpack_annotation %}
+    /// <summary> Testing MsgPack serializer </summary>
+    [Test]
+    public void Test_ToByteArray_FromData_MsgPack()
+    {
+        var mediaType = "application/msgpack";
+        var bytes = _instance.ToByteArray(mediaType);
+        var newInstance = {{ class_base_name }}.FromData(bytes, mediaType);
+        Assert.That(newInstance, Is.EqualTo(_instance));
+    }
+    {%- endif %}
+    {%- if avro_annotation or system_text_json_annotation or newtonsoft_json_annotation or system_xml_annotation or msgpack_annotation or protobuf_net_annotation %}
+
+    /// <summary> Testing FromData with edge cases </summary>
+    [Test]
+    public void Test_FromData_EdgeCases()
+    {
+        {%- if system_text_json_annotation %}
+        // Test null data - FromData returns null for null input
+        Assert.That({{ class_base_name }}.FromData((byte[])null!, "application/json"), Is.Null);
+        // Test empty data - should throw JsonException for invalid JSON
+        Assert.Throws<System.Text.Json.JsonException>(() => {{ class_base_name }}.FromData(Array.Empty<byte>(), "application/json"));
+        {%- elif newtonsoft_json_annotation %}
+        // Test null data - FromData returns null for null input
+        Assert.That({{ class_base_name }}.FromData((byte[])null!, "application/json"), Is.Null);
+        // Test empty data - Newtonsoft.Json returns null for empty string
+        Assert.That({{ class_base_name }}.FromData(Array.Empty<byte>(), "application/json"), Is.Null);
+        {%- elif avro_annotation %}
+        // Test null data - FromData returns null for null input
+        Assert.That({{ class_base_name }}.FromData((byte[])null!, "avro/binary"), Is.Null);
+        {%- elif msgpack_annotation %}
+        // Test null data - FromData returns null for null input
+        Assert.That({{ class_base_name }}.FromData((byte[])null!, "application/msgpack"), Is.Null);
+        {%- elif protobuf_net_annotation %}
+        // Test null data - FromData returns null for null input
+        Assert.That({{ class_base_name }}.FromData((byte[])null!, "application/x-protobuf"), Is.Null);
+        {%- elif system_xml_annotation %}
+        // Test null data - FromData returns null for null input
+        Assert.That({{ class_base_name }}.FromData((byte[])null!, "application/xml"), Is.Null);
+        {%- endif %}
+    }
+    {%- endif %}
+    {%- if system_text_json_annotation %}
+
+    /// <summary> Testing IsJsonMatch </summary>
+    [Test]
+    public void Test_IsJsonMatch()
+    {
+        var json = System.Text.Json.JsonSerializer.Serialize(_instance);
+        using var doc = System.Text.Json.JsonDocument.Parse(json);
+        Assert.That({{ class_base_name }}.IsJsonMatch(doc.RootElement), Is.True);
+    }
+    {%- endif %}
+    {%- if system_text_json_annotation or newtonsoft_json_annotation %}
+
+    /// <summary> Testing Gzip compression </summary>
+    [Test]
+    public void Test_ToByteArray_Gzip()
+    {
+        var mediaType = "application/json";
+        var gzipMediaType = "application/json+gzip";
+        var plainBytes = _instance.ToByteArray(mediaType);
+        var gzipBytes = _instance.ToByteArray(gzipMediaType);
+        // Gzip compressed data should start with magic bytes 0x1f 0x8b
+        Assert.That(gzipBytes.Length >= 2 && gzipBytes[0] == 0x1f && gzipBytes[1] == 0x8b, Is.True,
+            "Gzip compressed data should have correct magic bytes");
+        var newInstance = {{ class_base_name }}.FromData(gzipBytes, gzipMediaType);
+        Assert.That(newInstance, Is.EqualTo(_instance));
+    }
+    {%- endif %}
+    {%- if msgpack_annotation and not (system_text_json_annotation or newtonsoft_json_annotation) %}
+
+    /// <summary> Testing Gzip compression with MessagePack </summary>
+    [Test]
+    public void Test_ToByteArray_Gzip_MsgPack()
+    {
+        var mediaType = "application/msgpack";
+        var gzipMediaType = "application/msgpack+gzip";
+        var plainBytes = _instance.ToByteArray(mediaType);
+        var gzipBytes = _instance.ToByteArray(gzipMediaType);
+        // Gzip compressed data should start with magic bytes 0x1f 0x8b
+        Assert.That(gzipBytes.Length >= 2 && gzipBytes[0] == 0x1f && gzipBytes[1] == 0x8b, Is.True,
+            "Gzip compressed data should have correct magic bytes");
+        var newInstance = {{ class_base_name }}.FromData(gzipBytes, gzipMediaType);
+        Assert.That(newInstance, Is.EqualTo(_instance));
+    }
+    {%- endif %}
+    {%- if protobuf_net_annotation and not (system_text_json_annotation or newtonsoft_json_annotation or msgpack_annotation) %}
+
+    /// <summary> Testing Gzip compression with Protobuf </summary>
+    [Test]
+    public void Test_ToByteArray_Gzip_Protobuf()
+    {
+        var mediaType = "application/x-protobuf";
+        var gzipMediaType = "application/x-protobuf+gzip";
+        var plainBytes = _instance.ToByteArray(mediaType);
+        var gzipBytes = _instance.ToByteArray(gzipMediaType);
+        // Gzip compressed data should start with magic bytes 0x1f 0x8b
+        Assert.That(gzipBytes.Length >= 2 && gzipBytes[0] == 0x1f && gzipBytes[1] == 0x8b, Is.True,
+            "Gzip compressed data should have correct magic bytes");
+        var newInstance = {{ class_base_name }}.FromData(gzipBytes, gzipMediaType);
+        Assert.That(newInstance, Is.EqualTo(_instance));
+    }
+    {%- endif %}
 }
 {% endfilter %}
 {% if namespace %}

avrotize/avrotocsharp/dataclass_core.jinja

@@ -1,4 +1,4 @@
-    {%- if avro_annotation or system_text_json_annotation or newtonsoft_json_annotation or system_xml_annotation %}
+    {%- if avro_annotation or system_text_json_annotation or newtonsoft_json_annotation or system_xml_annotation or protobuf_net_annotation or msgpack_annotation %}
     /// <summary>
     /// Creates an object from the data
     /// </summary>
@@ -11,7 +11,7 @@
         if ( data is {{ class_name }}) return ({{ class_name }})data;
         if ( contentTypeString == null ) contentTypeString = System.Net.Mime.MediaTypeNames.Application.Octet;
         var contentType = new System.Net.Mime.ContentType(contentTypeString);
-    {%- if avro_annotation or system_text_json_annotation or newtonsoft_json_annotation or system_xml_annotation %}
+    {%- if avro_annotation or system_text_json_annotation or newtonsoft_json_annotation or system_xml_annotation or protobuf_net_annotation or msgpack_annotation %}
         if ( contentType.MediaType.EndsWith("+gzip"))
         {
             var stream = data switch
@@ -84,10 +84,32 @@
             }
             else if (data is System.BinaryData)
             {
-                return ((System.BinaryData)data).ToObjectFromJson<{{ class_name }}>();
+                return Newtonsoft.Json.JsonConvert.DeserializeObject<{{ class_name }}>(((System.BinaryData)data).ToString());
+            }
+            else if (data is byte[])
+            {
+                return Newtonsoft.Json.JsonConvert.DeserializeObject<{{ class_name }}>(System.Text.Encoding.UTF8.GetString((byte[])data));
+            }
+            else if (data is System.IO.Stream)
+            {
+                using (var reader = new System.IO.StreamReader((System.IO.Stream)data))
+                {
+                    return Newtonsoft.Json.JsonConvert.DeserializeObject<{{ class_name }}>(reader.ReadToEnd());
+                }
             }
         }
     {%- endif %}
+    {%- if protobuf_net_annotation %}
+        if ( contentType.MediaType.StartsWith("application/x-protobuf") || contentType.MediaType.StartsWith("application/protobuf") || contentType.MediaType.StartsWith("application/vnd.google.protobuf"))
+        {
+            var stream = data switch
+            {
+                System.IO.Stream s => s, System.BinaryData bd => bd.ToStream(), byte[] bytes => new System.IO.MemoryStream(bytes),
+                _ => throw new NotSupportedException("Data is not of a supported type for conversion to Stream")
+            };
+            return global::ProtoBuf.Serializer.Deserialize<{{ class_name }}>(stream);
+        }
+    {%- endif %}
     {%- if system_xml_annotation %}
         if ( contentType.MediaType.StartsWith(System.Net.Mime.MediaTypeNames.Text.Xml) || contentType.MediaType.StartsWith(System.Net.Mime.MediaTypeNames.Application.Xml) || contentType.MediaType.EndsWith("+xml"))
         {
@@ -114,11 +136,35 @@
                 return ({{ class_name }}?)serializer.Deserialize(memoryStream);
             }
         }
+    {%- endif %}
+    {%- if msgpack_annotation %}
+        if (contentType.MediaType.StartsWith("application/msgpack") || contentType.MediaType.StartsWith("application/x-msgpack"))
+        {
+            var bytes = data switch
+            {
+                byte[] b => b,
+                System.IO.Stream s => ReadStreamToBytes(s),
+                System.BinaryData bd => bd.ToArray(),
+                _ => throw new NotSupportedException("Data type not supported for MsgPack")
+            };
+            return MessagePack.MessagePackSerializer.Deserialize<{{ class_name }}>(bytes);
+        }
     {%- endif %}
         throw new System.NotSupportedException($"Unsupported media type {contentType.MediaType}");
     }
     {%- endif %}
 
+    {%- if msgpack_annotation %}
+    private static byte[] ReadStreamToBytes(System.IO.Stream stream)
+    {
+        using (var memoryStream = new System.IO.MemoryStream())
+        {
+            stream.CopyTo(memoryStream);
+            return memoryStream.ToArray();
+        }
+    }
+    {%- endif %}
+
     {%- if avro_annotation %}
     private class SpecificDatumWriter : global::Avro.Specific.SpecificDatumWriter<{{ class_name }}>
     {
@@ -144,7 +190,7 @@
     {%- if avro_annotation %}
     {%- endif%}
 
-    {%- if avro_annotation or system_text_json_annotation or newtonsoft_json_annotation or system_xml_annotation %}
+    {%- if avro_annotation or system_text_json_annotation or newtonsoft_json_annotation or system_xml_annotation or protobuf_net_annotation or msgpack_annotation %}
     /// <summary>
     /// Converts the object to a byte array
     /// </summary>
@@ -201,7 +247,23 @@
             }
         }
     {%- endif %}
-    {%- if avro_annotation or system_text_json_annotation or newtonsoft_json_annotation or system_xml_annotation %}
+    {%- if protobuf_net_annotation %}
+        if (contentType.MediaType.StartsWith("application/x-protobuf") || contentType.MediaType.StartsWith("application/protobuf") || contentType.MediaType.StartsWith("application/vnd.google.protobuf"))
+        {
+            using (var stream = new System.IO.MemoryStream())
+            {
+                global::ProtoBuf.Serializer.Serialize(stream, this);
+                result = stream.ToArray();
+            }
+        }
+    {%- endif %}
+    {%- if msgpack_annotation %}
+        if (contentType.MediaType.StartsWith("application/msgpack") || contentType.MediaType.StartsWith("application/x-msgpack"))
+        {
+            result = MessagePack.MessagePackSerializer.Serialize(this);
+        }
+    {%- endif %}
+    {%- if avro_annotation or system_text_json_annotation or newtonsoft_json_annotation or system_xml_annotation or protobuf_net_annotation or msgpack_annotation %}
     if (result != null && contentType.MediaType.EndsWith("+gzip"))
         {
             var stream = new System.IO.MemoryStream();

avrotize/avrotocsharp/project.csproj.jinja

@@ -8,12 +8,18 @@
         {%- if avro_annotation %}
         <PackageReference Include="Apache.Avro" Version="{{ CSHARP_AVRO_VERSION }}" />
         {%- endif %}
+        {%- if protobuf_net_annotation %}
+        <PackageReference Include="protobuf-net" Version="{{ PROTOBUF_NET_VERSION }}" />
+        {%- endif %}
         {%- if newtonsoft_json_annotation %}
         <PackageReference Include="Newtonsoft.Json" Version="{{ NEWTONSOFT_JSON_VERSION }}" />
         {%- endif %}
         {%- if system_text_json_annotation %}
         <PackageReference Include="System.Text.Json" Version="{{ SYSTEM_TEXT_JSON_VERSION }}" />
         {%- endif %}
+        {%- if msgpack_annotation %}
+        <PackageReference Include="MessagePack" Version="{{ MSGPACK_VERSION }}" />
+        {%- endif %}
         <PackageReference Include="System.Memory.Data" Version="{{ SYSTEM_MEMORY_DATA_VERSION }}" />
     </ItemGroup>
     <ItemGroup>

avrotize/avrotocsharp/run_coverage.ps1.jinja

@@ -0,0 +1,98 @@
+#!/usr/bin/env pwsh
+# PowerShell script to run tests with code coverage and generate reports
+# Generated for project: {{ project_name }}
+
+param(
+    [Parameter(HelpMessage="Minimum coverage threshold (default: 85)")]
+    [int]$Threshold = 85,
+    
+    [Parameter(HelpMessage="Generate HTML report")]
+    [switch]$HtmlReport = $false,
+    
+    [Parameter(HelpMessage="Open HTML report in browser")]
+    [switch]$OpenReport = $false,
+    
+    [Parameter(HelpMessage="Fail build if coverage below threshold")]
+    [switch]$FailOnLowCoverage = $true
+)
+
+Write-Host "🧪 Running tests with code coverage for {{ project_name }}..." -ForegroundColor Green
+
+# Clean previous coverage results
+$coverageDir = "./coverage"
+if (Test-Path $coverageDir) {
+    Remove-Item $coverageDir -Recurse -Force
+    Write-Host "🧹 Cleaned previous coverage results" -ForegroundColor Yellow
+}
+
+# Run tests with coverage collection
+Write-Host "📊 Collecting code coverage..." -ForegroundColor Blue
+$testResult = dotnet test --collect:"XPlat Code Coverage" --results-directory:"$coverageDir" --logger:"console;verbosity=detailed"
+$testExitCode = $LASTEXITCODE
+
+if ($testExitCode -ne 0) {
+    Write-Host "❌ Tests failed!" -ForegroundColor Red
+    exit $testExitCode
+}
+
+# Find coverage file
+$coverageFile = Get-ChildItem -Recurse -Path $coverageDir -Name "*.cobertura.xml" | Select-Object -First 1
+if (-not $coverageFile) {
+    Write-Host "❌ No coverage file found!" -ForegroundColor Red
+    exit 1
+}
+
+$coverageFilePath = Join-Path $coverageDir $coverageFile
+Write-Host "📄 Coverage file: $coverageFilePath" -ForegroundColor Green
+
+# Parse coverage percentage
+$coverage = Select-Xml -Path $coverageFilePath -XPath "/coverage/@line-rate"
+$coveragePercent = [math]::Round([double]$coverage.Node.Value * 100, 2)
+
+Write-Host "📈 Line Coverage: $coveragePercent%" -ForegroundColor $(if ($coveragePercent -ge $Threshold) { "Green" } else { "Red" })
+
+# Parse branch coverage
+$branchCoverage = Select-Xml -Path $coverageFilePath -XPath "/coverage/@branch-rate"
+$branchPercent = [math]::Round([double]$branchCoverage.Node.Value * 100, 2)
+Write-Host "🌿 Branch Coverage: $branchPercent%" -ForegroundColor $(if ($branchPercent -ge $Threshold) { "Green" } else { "Red" })
+
+# Generate HTML report if requested
+if ($HtmlReport) {
+    Write-Host "📊 Generating HTML coverage report..." -ForegroundColor Blue
+    
+    # Check if reportgenerator is installed
+    $reportGenExists = Get-Command reportgenerator -ErrorAction SilentlyContinue
+    if (-not $reportGenExists) {
+        Write-Host "⬇️ Installing ReportGenerator..." -ForegroundColor Yellow
+        dotnet tool install -g dotnet-reportgenerator-globaltool
+    }
+    
+    $htmlReportPath = Join-Path $coverageDir "html"
+    reportgenerator "-reports:$coverageFilePath" "-targetdir:$htmlReportPath" "-reporttypes:Html"
+    
+    Write-Host "📊 HTML report generated: $htmlReportPath/index.html" -ForegroundColor Green
+    
+    if ($OpenReport) {
+        $indexPath = Join-Path $htmlReportPath "index.html"
+        Start-Process $indexPath
+        Write-Host "🌐 Opened coverage report in browser" -ForegroundColor Green
+    }
+}
+
+# Coverage summary
+Write-Host ""
+Write-Host "📊 Coverage Summary:" -ForegroundColor Cyan
+Write-Host "  Line Coverage: $coveragePercent% (Threshold: $Threshold%)" -ForegroundColor White
+Write-Host "  Branch Coverage: $branchPercent%" -ForegroundColor White
+Write-Host "  Status: $(if ($coveragePercent -ge $Threshold) { "✅ PASSED" } else { "❌ FAILED" })" -ForegroundColor $(if ($coveragePercent -ge $Threshold) { "Green" } else { "Red" })
+
+# Fail if coverage is below threshold and FailOnLowCoverage is set
+if ($FailOnLowCoverage -and $coveragePercent -lt $Threshold) {
+    Write-Host ""
+    Write-Host "❌ Coverage $coveragePercent% is below the required threshold of $Threshold%" -ForegroundColor Red
+    exit 1
+}
+
+Write-Host ""
+Write-Host "✅ Coverage analysis completed successfully!" -ForegroundColor Green
+exit 0