avrotize 2.20.3__tar.gz → 2.20.5__tar.gz

{avrotize-2.20.3 → avrotize-2.20.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: avrotize
-Version: 2.20.3
+Version: 2.20.5
 Summary: Tools to convert from and to Avro Schema from various other schema languages.
 Author-email: Clemens Vasters <clemensv@microsoft.com>
 Requires-Python: >=3.10
@@ -111,6 +111,7 @@ Converting from Avrotize Schema:
 Direct conversions (JSON Structure):
 
 - [`avrotize s2p`](#convert-json-structure-to-protocol-buffers) - Convert JSON Structure to Protocol Buffers (.proto files).
+- [`avrotize oas2s`](#convert-openapi-to-json-structure) - Convert OpenAPI 3.x document to JSON Structure.
 
 Generate code from Avrotize Schema:
 
@@ -1067,6 +1068,29 @@ Conversion notes:
 - The tool generates a complete Maven project with pom.xml including Jackson dependencies.
 - Generated classes include `equals()` and `hashCode()` implementations.
 
+### Convert JSON Structure to JavaScript classes
+
+```bash
+avrotize s2js <path_to_structure_schema_file> [--out <path_to_js_dir>] [--package <package_name>] [--avro-annotation]
+```
+
+Parameters:
+
+- `<path_to_structure_schema_file>`: The path to the JSON Structure schema file to be converted. If omitted, the file is read from stdin.
+- `--out`: The path to the directory to write the JavaScript classes to. Required.
+- `--package`: (optional) The package name for the generated classes.
+- `--avro-annotation`: (optional) Add Avro binary serialization support.
+
+Conversion notes:
+
+- The tool generates JavaScript ES6 classes from JSON Structure schemas with full type support.
+- JSON Structure primitive types are mapped to JavaScript types. Extended types like `date`, `time`, `datetime` are handled as Date objects or strings.
+- Integer types are mapped to JavaScript Number or BigInt depending on size.
+- Choice types are generated as union type classes with factory methods.
+- Tuple types are generated as arrays with fixed length.
+- The tool generates a complete npm package with package.json.
+- Generated classes include serialization/deserialization methods and optional Avro support when enabled.
+
 ### Convert Avrotize Schema to Datapackage schema
 
 ```bash
@@ -1200,6 +1224,47 @@ Conversion notes:
 - Choice types (unions) are converted to Protocol Buffers `oneof` constructs.
 - Abstract types and extensions (`$extends`) are handled by generating appropriate message hierarchies.
 
+### Convert OpenAPI to JSON Structure
+
+```bash
+avrotize oas2s <path_to_openapi_file> --out <path_to_json_structure_file> [--namespace <namespace>] [--preserve-composition] [--detect-discriminators] [--lift-inline-schemas]
+```
+
+Parameters:
+
+- `<path_to_openapi_file>`: The path to the OpenAPI 3.x document (JSON or YAML). If omitted, the file is read from stdin.
+- `--out`: The path to the JSON Structure schema file to write the conversion result to. If omitted, the result is written to stdout.
+- `--namespace`: (optional) Namespace for the JSON Structure schema.
+- `--preserve-composition`: (optional) Preserve composition keywords (allOf, oneOf, anyOf). Default is `true`.
+- `--detect-discriminators`: (optional) Detect OpenAPI discriminator patterns and convert to choice types. Default is `true`.
+- `--lift-inline-schemas`: (optional) Lift inline schemas from paths/operations to named definitions. Default is `false`.
+
+Conversion notes:
+
+- The tool extracts schema definitions from `components.schemas` in the OpenAPI document and converts them to JSON Structure format.
+- OpenAPI-specific keywords are handled as follows:
+  - `nullable`: Converted to type union with `null`
+  - `readOnly`, `writeOnly`, `deprecated`: Mapped to metadata annotations
+  - `discriminator`: Used to create choice types with proper discriminator mapping
+- OpenAPI `$ref` references (e.g., `#/components/schemas/Pet`) are converted to JSON Structure references (`#/definitions/Pet`).
+- All JSON Schema features supported by the JSON Schema converter are preserved, including:
+  - Object structures with properties and required fields
+  - Enumerations
+  - Numeric and string constraints (minimum, maximum, minLength, maxLength, pattern)
+  - Array and set types (with uniqueItems)
+  - Map types (from additionalProperties)
+  - Composition (allOf, oneOf, anyOf)
+
+Example:
+
+```bash
+# Convert an OpenAPI document to JSON Structure
+avrotize oas2s petstore.yaml --out petstore.struct.json
+
+# With namespace and inline schema lifting
+avrotize oas2s api.json --out api.struct.json --namespace com.example.api --lift-inline-schemas
+```
+
 ### Create the Parsing Canonical Form (PCF) of an Avrotize schema
 
 ```bash

{avrotize-2.20.3 → avrotize-2.20.5}/README.md

@@ -63,6 +63,7 @@ Converting from Avrotize Schema:
 Direct conversions (JSON Structure):
 
 - [`avrotize s2p`](#convert-json-structure-to-protocol-buffers) - Convert JSON Structure to Protocol Buffers (.proto files).
+- [`avrotize oas2s`](#convert-openapi-to-json-structure) - Convert OpenAPI 3.x document to JSON Structure.
 
 Generate code from Avrotize Schema:
 
@@ -1019,6 +1020,29 @@ Conversion notes:
 - The tool generates a complete Maven project with pom.xml including Jackson dependencies.
 - Generated classes include `equals()` and `hashCode()` implementations.
 
+### Convert JSON Structure to JavaScript classes
+
+```bash
+avrotize s2js <path_to_structure_schema_file> [--out <path_to_js_dir>] [--package <package_name>] [--avro-annotation]
+```
+
+Parameters:
+
+- `<path_to_structure_schema_file>`: The path to the JSON Structure schema file to be converted. If omitted, the file is read from stdin.
+- `--out`: The path to the directory to write the JavaScript classes to. Required.
+- `--package`: (optional) The package name for the generated classes.
+- `--avro-annotation`: (optional) Add Avro binary serialization support.
+
+Conversion notes:
+
+- The tool generates JavaScript ES6 classes from JSON Structure schemas with full type support.
+- JSON Structure primitive types are mapped to JavaScript types. Extended types like `date`, `time`, `datetime` are handled as Date objects or strings.
+- Integer types are mapped to JavaScript Number or BigInt depending on size.
+- Choice types are generated as union type classes with factory methods.
+- Tuple types are generated as arrays with fixed length.
+- The tool generates a complete npm package with package.json.
+- Generated classes include serialization/deserialization methods and optional Avro support when enabled.
+
 ### Convert Avrotize Schema to Datapackage schema
 
 ```bash
@@ -1152,6 +1176,47 @@ Conversion notes:
 - Choice types (unions) are converted to Protocol Buffers `oneof` constructs.
 - Abstract types and extensions (`$extends`) are handled by generating appropriate message hierarchies.
 
+### Convert OpenAPI to JSON Structure
+
+```bash
+avrotize oas2s <path_to_openapi_file> --out <path_to_json_structure_file> [--namespace <namespace>] [--preserve-composition] [--detect-discriminators] [--lift-inline-schemas]
+```
+
+Parameters:
+
+- `<path_to_openapi_file>`: The path to the OpenAPI 3.x document (JSON or YAML). If omitted, the file is read from stdin.
+- `--out`: The path to the JSON Structure schema file to write the conversion result to. If omitted, the result is written to stdout.
+- `--namespace`: (optional) Namespace for the JSON Structure schema.
+- `--preserve-composition`: (optional) Preserve composition keywords (allOf, oneOf, anyOf). Default is `true`.
+- `--detect-discriminators`: (optional) Detect OpenAPI discriminator patterns and convert to choice types. Default is `true`.
+- `--lift-inline-schemas`: (optional) Lift inline schemas from paths/operations to named definitions. Default is `false`.
+
+Conversion notes:
+
+- The tool extracts schema definitions from `components.schemas` in the OpenAPI document and converts them to JSON Structure format.
+- OpenAPI-specific keywords are handled as follows:
+  - `nullable`: Converted to type union with `null`
+  - `readOnly`, `writeOnly`, `deprecated`: Mapped to metadata annotations
+  - `discriminator`: Used to create choice types with proper discriminator mapping
+- OpenAPI `$ref` references (e.g., `#/components/schemas/Pet`) are converted to JSON Structure references (`#/definitions/Pet`).
+- All JSON Schema features supported by the JSON Schema converter are preserved, including:
+  - Object structures with properties and required fields
+  - Enumerations
+  - Numeric and string constraints (minimum, maximum, minLength, maxLength, pattern)
+  - Array and set types (with uniqueItems)
+  - Map types (from additionalProperties)
+  - Composition (allOf, oneOf, anyOf)
+
+Example:
+
+```bash
+# Convert an OpenAPI document to JSON Structure
+avrotize oas2s petstore.yaml --out petstore.struct.json
+
+# With namespace and inline schema lifting
+avrotize oas2s api.json --out api.struct.json --namespace com.example.api --lift-inline-schemas
+```
+
 ### Create the Parsing Canonical Form (PCF) of an Avrotize schema
 
 ```bash

{avrotize-2.20.3 → avrotize-2.20.5}/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-2.20.3 → avrotize-2.20.5}/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.5'
+__version_tuple__ = version_tuple = (2, 20, 5)
 
-__commit_id__ = commit_id = 'g6ab86e24e'
+__commit_id__ = commit_id = 'g4811363b1'

avrotize-2.20.5/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-2.20.5/avrotize/avrotocsharp/class_test.cs.jinja

@@ -0,0 +1,266 @@
+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+
+{% if namespace %}
+namespace {{ namespace }}
+{
+{% endif %}
+{% set ind=4 if namespace else 0 %}
+{% filter indent(width=ind, first=True) %}
+/// <summary> Test class for {{ class_base_name }} </summary> 
+[TestFixture]
+public class {{ test_class_name }}
+{
+    private {{ class_base_name }} _instance;
+
+    /// <summary> Constructor </summary>
+    public {{ test_class_name }}()
+    {
+        _instance = CreateInstance();
+    }
+
+    /// <summary> Create instance of {{ class_base_name }} </summary>
+    public {{ class_base_name }} CreateInstance()
+    {
+        var instance = new {{ class_base_name }}();
+        {%- for field in fields %}
+        {%- if not field.is_const %}
+        instance.{{ field.field_name }} = {{ field.test_value }};
+        {%- endif %}
+        {%- endfor %}
+        return instance;
+    }
+
+    /// <summary> Testing Equals and GetHashCode - positive case </summary>
+    [Test]
+    public void TestEqualsAndHashCode_PositiveCase()
+    {
+        var instance1 = CreateInstance();
+        var instance2 = CreateInstance();
+        
+        // Test equality
+        Assert.That(instance1.Equals(instance2), Is.True, "Two instances with same values should be equal");
+        Assert.That(instance1 == instance2, Is.False, "Operator == should use reference equality");
+        
+        // Test hash codes
+        Assert.That(instance1.GetHashCode(), Is.EqualTo(instance2.GetHashCode()), 
+            "Equal instances should have equal hash codes");
+    }
+
+    /// <summary> Testing Equals and GetHashCode - negative case </summary>
+    [Test]
+    public void TestEqualsAndHashCode_NegativeCase()
+    {
+        var instance1 = CreateInstance();
+        var instance2 = CreateInstance();
+        
+        {%- set ns = {'found': false, 'is_complex_non_nullable': false} %}
+        {%- for field in fields if not field.is_const %}
+        {%- if not ns.found %}
+        {%- set _ = ns.update({'found': true}) %}
+        // Modify {{ field.field_name }} and verify inequality
+        {%- set base_type = field.field_type.rstrip('?') %}
+        {%- if base_type == "string" %}
+        instance2.{{ field.field_name }} = (instance2.{{ field.field_name }} ?? "test") + "_modified";
+        {%- elif base_type in ["int", "long", "short", "byte", "sbyte", "uint", "ulong", "ushort"] %}
+        instance2.{{ field.field_name }} = ({{ base_type }})({{ "(instance2." + field.field_name + " ?? 0)" if field.field_type.endswith("?") else "instance2." + field.field_name }} + 1);
+        {%- elif base_type in ["float", "double", "decimal"] %}
+        instance2.{{ field.field_name }} = {{ "(instance2." + field.field_name + " ?? 0)" if field.field_type.endswith("?") else "instance2." + field.field_name }} + 1.0{{ "f" if base_type == "float" else "m" if base_type == "decimal" else "" }};
+        {%- elif base_type == "bool" %}
+        instance2.{{ field.field_name }} = !{{ "(instance2." + field.field_name + " ?? false)" if field.field_type.endswith("?") else "instance2." + field.field_name }};
+        {%- elif field.field_type.endswith("?") %}
+        // For nullable complex types (including global:: types), set to null to make it different
+        instance2.{{ field.field_name }} = null;
+        {%- elif base_type.startswith("global::") and field.is_enum %}
+        // For non-nullable enum, cast to int and increment
+        instance2.{{ field.field_name }} = ({{ base_type }})((int)instance2.{{ field.field_name }} + 1);
+        {%- else %}
+        {%- set _ = ns.update({'is_complex_non_nullable': true}) %}
+        {%- endif %}
+        {%- if not ns.is_complex_non_nullable %}
+        Assert.That(instance1.Equals(instance2), Is.False, 
+            "Instances with different {{ field.field_name }} should not be equal");
+        {%- endif %}
+        {%- endif %}
+        {%- endfor %}
+        {%- if ns.is_complex_non_nullable %}
+        // For non-nullable complex types (like unions), verify the positive case works correctly
+        // since we cannot create a meaningfully different value without knowing the type internals
+        Assert.Pass("Skipped negative test for complex non-nullable type - positive case validates Equals implementation");
+        {%- endif %}
+    }
+
+    {%- for field in fields %}
+    /// <summary> Testing property {{ field.field_name }}  </summary>
+    [Test]
+    public void Test{{ field.field_name | replace ('@','') | pascal }}Property()
+    {
+        var testValue = {{ field.test_value }};
+        {%- if not field.is_const %}
+        _instance.{{ field.field_name }} = testValue;
+        {%- endif %}
+        {%- if field.is_primitive %}
+        {%- if field.field_type.startswith("List<") or field.field_type.startswith("Dictionary<") %}
+        Assert.That(_instance.{{ field.field_name }}, Is.EquivalentTo(testValue));
+        {%- else %}
+        Assert.That(_instance.{{ field.field_name }}, Is.EqualTo(testValue));
+        {%- endif %}
+        {%- else %}
+        Assert.That(_instance.{{ field.field_name }}, Is.EqualTo(testValue));
+        {%- endif %}
+    }
+    {%- endfor %}
+    {%- if avro_annotation %}
+    /// <summary> Testing Avro serializer </summary>
+    [Test]
+    public void Test_ToByteArray_FromData_Avro()
+    {
+        var mediaType = "application/vnd.apache.avro+avro";
+        var bytes = _instance.ToByteArray(mediaType);
+        var newInstance = {{ class_base_name }}.FromData(bytes, mediaType);
+        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]
+    public void Test_ToByteArray_FromData_Xml()
+    {
+        var mediaType = "application/xml";
+        var bytes = _instance.ToByteArray(mediaType);
+        var newInstance = {{ class_base_name }}.FromData(bytes, mediaType);
+        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 %}
+}
+{% endif %}