avrotize 2.21.1__py3-none-any.whl

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 %}

avrotize/avrotocsharp/dataclass_core.jinja

@@ -0,0 +1,293 @@
+    {%- 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>
+    /// <param name="data">The input data to convert</param>
+    /// <param name="contentTypeString">The content type string of the desired encoding</param>
+    /// <returns>The converted object</returns>
+    public static {{ class_name }}? FromData(object? data, string? contentTypeString )
+    {
+        if ( data == null ) return null;
+        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 or protobuf_net_annotation or msgpack_annotation %}
+        if ( contentType.MediaType.EndsWith("+gzip"))
+        {
+            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 gzip decompression")
+            };
+            using (var gzip = new System.IO.Compression.GZipStream(stream, System.IO.Compression.CompressionMode.Decompress))
+            {
+                System.IO.MemoryStream memoryStream = new System.IO.MemoryStream();
+                gzip.CopyTo(memoryStream);
+                memoryStream.Position = 0;
+                data = memoryStream.ToArray();
+            }
+        }
+    {%- endif %}
+    {%- if avro_annotation %}
+        if ( contentType.MediaType.StartsWith("avro/") || contentType.MediaType.StartsWith("application/vnd.apache.avro") )
+        {
+            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")
+            };
+            #pragma warning disable CS8625 // Cannot convert null literal to non-nullable reference type.
+            if (contentType.MediaType.StartsWith("avro/binary") || contentType.MediaType.StartsWith("application/vnd.apache.avro+avro"))
+            {
+                var reader = new global::Avro.Generic.GenericDatumReader<global::Avro.Generic.GenericRecord>({{ class_name }}.AvroSchema, {{ class_name }}.AvroSchema);
+                return new {{ class_name }}(reader.Read(null, new global::Avro.IO.BinaryDecoder(stream)));
+            }
+            if ( contentType.MediaType.StartsWith("avro/json") || contentType.MediaType.StartsWith("application/vnd.apache.avro+json"))
+            {
+                var reader = new global::Avro.Generic.GenericDatumReader<global::Avro.Generic.GenericRecord>({{ class_name }}.AvroSchema, {{ class_name }}.AvroSchema);
+                return new {{ class_name }}(reader.Read(null, new global::Avro.IO.JsonDecoder({{ class_name }}.AvroSchema, stream)));
+            }
+            #pragma warning restore CS8625
+        }
+    {%- endif %}
+    {%- if system_text_json_annotation %}
+        if ( contentType.MediaType.StartsWith(System.Net.Mime.MediaTypeNames.Application.Json))
+        {
+            if (data is System.Text.Json.JsonElement)
+            {
+                return System.Text.Json.JsonSerializer.Deserialize<{{ class_name }}>((System.Text.Json.JsonElement)data);
+            }
+            else if ( data is string)
+            {
+                return System.Text.Json.JsonSerializer.Deserialize<{{ class_name }}>((string)data);
+            }
+            else if (data is System.BinaryData)
+            {
+                return ((System.BinaryData)data).ToObjectFromJson<{{ class_name }}>();
+            }
+            else if (data is byte[])
+            {
+                return System.Text.Json.JsonSerializer.Deserialize<{{ class_name }}>(new ReadOnlySpan<byte>((byte[])data));
+            }
+            else if (data is System.IO.Stream)
+            {
+                return System.Text.Json.JsonSerializer.DeserializeAsync<{{ class_name }}>((System.IO.Stream)data).Result;
+            }
+        }
+    {%- endif %}
+    {%- if newtonsoft_json_annotation %}
+        if ( contentType.MediaType.StartsWith(System.Net.Mime.MediaTypeNames.Application.Json))
+        {
+            if (data is string)
+            {
+                return Newtonsoft.Json.JsonConvert.DeserializeObject<{{ class_name }}>((string)data);
+            }
+            else if (data is System.BinaryData)
+            {
+                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"))
+        {
+            var serializer = new System.Xml.Serialization.XmlSerializer(typeof({{ class_name }}));
+            if (data is string)
+            {
+                using (var reader = new System.IO.StringReader((string)data))
+                {
+                    return ({{ class_name }}?)serializer.Deserialize(reader);
+                }
+            }
+            else if (data is System.IO.Stream)
+            {
+                return ({{ class_name }}?)serializer.Deserialize((System.IO.Stream)data);
+            }
+            else if (data is System.BinaryData)
+            {
+                var memoryStream = new System.IO.MemoryStream(((System.BinaryData)data).ToArray());
+                return ({{ class_name }}?)serializer.Deserialize(memoryStream);
+            }
+            else if (data is byte[])
+            {
+                var memoryStream = new System.IO.MemoryStream((byte[])data);
+                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 }}>
+    {
+        public SpecificDatumWriter() : base({{ class_name }}.AvroSchema)
+        {
+        }
+
+         protected override WriteItem ResolveEnum(global::Avro.EnumSchema es)
+         {
+            var enumType = GetType().Assembly.GetType(GetType().Assembly.GetName().Name+"."+es.Namespace + "." + es.Name, false, true);
+            if (enumType != null)
+            {
+                return base.ResolveEnum(global::Avro.EnumSchema.Create(enumType.Name, es.Symbols, enumType.Namespace, null, null, es.Documentation, es.Default));
+            }
+            else
+            {
+                return base.ResolveEnum(es);
+            }
+         }
+    }
+    {%- endif %}
+
+    {%- if avro_annotation %}
+    {%- endif%}
+
+    {%- 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>
+    /// <param name="contentTypeString">The content type string of the desired encoding</param>
+    /// <returns>The encoded data</returns>
+    public byte[] ToByteArray(string contentTypeString)
+    {
+        var contentType = new System.Net.Mime.ContentType(contentTypeString);
+        byte[]? result = null;
+    {%- if avro_annotation %}
+        if (contentType.MediaType.StartsWith("avro/binary") || contentType.MediaType.StartsWith("application/vnd.apache.avro+avro"))
+        {
+            var stream = new System.IO.MemoryStream();
+            var writer = new SpecificDatumWriter();
+            var encoder = new global::Avro.IO.BinaryEncoder(stream);
+            writer.Write(this, encoder);
+            encoder.Flush();
+            result = stream.ToArray();
+        }
+        else if (contentType.MediaType.StartsWith("avro/json") || contentType.MediaType.StartsWith("application/vnd.apache.avro+json"))
+        {
+            var stream = new System.IO.MemoryStream();
+            var writer = new global::Avro.Specific.SpecificDatumWriter<{{ class_name }}>({{ class_name }}.AvroSchema);
+            var encoder = new global::Avro.IO.JsonEncoder({{ class_name }}.AvroSchema, stream);
+            writer.Write(this, encoder);
+            encoder.Flush();
+            result = stream.ToArray();
+        }
+    {%- endif %}
+    {%- if system_text_json_annotation %}
+    if (contentType.MediaType.StartsWith(System.Net.Mime.MediaTypeNames.Application.Json))
+        {
+            result = System.Text.Json.JsonSerializer.SerializeToUtf8Bytes(this);
+        }
+    {%- endif %}
+    {%- if newtonsoft_json_annotation %}
+        if (contentType.MediaType.StartsWith(System.Net.Mime.MediaTypeNames.Application.Json))
+        {
+            result = System.Text.Encoding.GetEncoding(contentType.CharSet??"utf-8").GetBytes(Newtonsoft.Json.JsonConvert.SerializeObject(this));
+        }
+    {%- 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"))
+        {
+            var serializer = new System.Xml.Serialization.XmlSerializer(typeof({{ class_name }}));
+            using (var stream = new System.IO.MemoryStream())
+            {
+                using (var writer = new System.IO.StreamWriter(stream))
+                {
+                    serializer.Serialize(writer, this);
+                    writer.Flush();
+                    result = stream.ToArray();
+                }
+            }
+        }
+    {%- endif %}
+    {%- 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();
+            using (var gzip = new System.IO.Compression.GZipStream(stream, System.IO.Compression.CompressionMode.Compress))
+            {
+                gzip.Write(result, 0, result.Length);
+            }
+            result = stream.ToArray();
+        }
+    {%- endif %}
+        return ( result != null ) ? result : throw new System.NotSupportedException($"Unsupported media type {contentType.MediaType}");
+    }
+    {%- endif %}
+
+    {%- if system_text_json_annotation or newtonsoft_json_annotation %}
+    /// <summary>
+    /// Checks if the JSON element matches the schema
+    /// </summary>
+    /// <param name="element">The JSON element to check</param>
+    public static bool IsJsonMatch(System.Text.Json.JsonElement element)
+    {
+        return 
+    {%- for clause in json_match_clauses %}
+        {{ clause }}{{ ' &&' if not loop.last }}
+    {%- endfor %};
+    }
+    {%- endif %}

avrotize/avrotocsharp/enum_test.cs.jinja

@@ -0,0 +1,20 @@
+using System;
+using NUnit.Framework;
+
+namespace {{ namespace }}
+{
+    /// <summary> Test class for {{ enum_base_name }} </summary>
+    [TestFixture]
+    public class {{ test_class_name }}
+    {
+        /// <summary> Test {{ enum_base_name }} Enum </summary>
+        [Test]
+        public void Test_{{ enum_base_name }}_Enum()
+        {
+            var values = Enum.GetValues(typeof({{ enum_base_name }}));
+            {%- for symbol in symbols %}
+            Assert.That(Enum.IsDefined(typeof({{ enum_base_name }}), "{{ symbol }}"));
+            {%- endfor %}
+        }
+    }
+}

avrotize/avrotocsharp/project.csproj.jinja

@@ -0,0 +1,30 @@
+<Project Sdk="Microsoft.NET.Sdk">
+    <PropertyGroup>
+        <TargetFramework>net9.0</TargetFramework>
+        <Nullable>enable</Nullable>
+        <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    </PropertyGroup>
+    <ItemGroup>
+        {%- 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>
+        <PackageReference Include="NUnit" Version="{{ NUNIT_VERSION }}" />
+        <PackageReference Include="NUnit3TestAdapter" Version="{{ NUNIT_ADAPTER_VERSION }}" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="{{ MSTEST_SDK_VERSION }}" />
+    </ItemGroup>
+</Project>  

avrotize/avrotocsharp/project.sln.jinja

@@ -0,0 +1,34 @@
+{%- set slnguid = uuid() -%}
+{%- set prjguid = uuid() -%}
+{%- set testguid = uuid() -%}
+{%- set slnguid2 = uuid() -%}
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.5.002.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{ {{-slnguid-}} }") = "{{project_name|pascal}}", "src\{{project_name|pascal}}.csproj", "{ {{-prjguid-}} }"
+EndProject
+Project("{ {{-slnguid-}} }") = "{{project_name|pascal}}_test", "test\{{project_name|pascal}}.Test.csproj", "{ {{-testguid-}} }"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{ {{-prjguid-}} }.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{ {{-prjguid-}} }.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{ {{-prjguid-}} }.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{ {{-prjguid-}} }.Release|Any CPU.Build.0 = Release|Any CPU
+		{ {{-testguid-}} }.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{ {{-testguid-}} }.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{ {{-testguid-}} }.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{ {{-testguid-}} }.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = { {{-slnguid2-}} }
+	EndGlobalSection
+EndGlobal