Refactor serialization and deserialization test suite

The serialization and deserialization test suite has been updated for clarity and performance. The process is now consolidated into a single method called `RoundTripTest()`. Additionally, equality implementations for `AstMessage` and `Junk` classes have been added, allowing for more reliable object comparison in tests. Implementations for processing `Junk` and `AstMessage` have been tweaked for correctness and better error reporting.

Linguini.Serialization.Test/SerializeAndDeserializeTest.cs

@@ -16,18 +16,28 @@ public class SerializeAndDeserializeTest
     [Test]
     [TestCaseSource(nameof(AstExamples))]
     [Parallelizable]
-    public void SerializeDeserializeTest(object x)
+    public void RoundTripTest(object x)
     {
-        SerializeAndDeserializeTest.SerializeDeserializeTest(x);
+        // Serialize the object to JSON string.
+        var jsonString = JsonSerializer.Serialize(x, Options);
+
+        // Deserialize the JSON string back into an object.
+        Debug.Assert(x != null, nameof(x) + " != null");
+        var deserializedObject = JsonSerializer.Deserialize(jsonString, x.GetType(), Options);
+
+        // Now you have a 'deserializedObject' which should be equivalent to the original 'expected' object.
+        Assert.That(deserializedObject, Is.Not.Null);
+        Assert.That(deserializedObject, Is.EqualTo(x));
     }
 
     public static IEnumerable<object> AstExamples()
     {
+        yield return new Attribute("desc", new PatternBuilder("description"));
         yield return new CallArgumentsBuilder()
             .AddPositionalArg(InlineExpressionBuilder.CreateMessageReference("x"))
             .AddNamedArg("y", 3)
             .Build();
-        yield return new Attribute("desc", new PatternBuilder("description"));
+        yield return new AstComment(CommentLevel.Comment, new() { "test".AsMemory() });
         yield return new DynamicReference("dyn", "attr", new CallArgumentsBuilder()
             .AddPositionalArg(InlineExpressionBuilder.CreateMessageReference("x"))
             .AddNamedArg("y", 3));
@@ -37,7 +47,20 @@ public static IEnumerable<object> AstExamples()
             .Build()
         );
         yield return new Identifier("test");
+        yield return new Junk("Test".AsMemory());
         yield return new MessageReference("message", "attribute");
+        yield return new AstMessage(
+            new Identifier("x"), 
+            new PatternBuilder(3).Build(), 
+            new List<Attribute>()
+            {
+                new("attr1", new PatternBuilder("value1")),
+                new("attr2", new PatternBuilder("value2"))
+            }, 
+            new(CommentLevel.ResourceComment, new()
+            {
+                "test".AsMemory()
+            }));
         yield return new PatternBuilder("text ").AddMessage("x").AddText(" more text").Build();
         yield return new SelectExpressionBuilder(new VariableReference("x"))
             .AddVariant("one", new PatternBuilder("select 1"))
@@ -47,22 +70,6 @@ public static IEnumerable<object> AstExamples()
         yield return new TermReference("x", "y");
         yield return new VariableReference("x");
         yield return new Variant(2.0f, new PatternBuilder(3));
-        yield return new AstComment(CommentLevel.Comment, new() { "test".AsMemory() });
-        yield return new Junk("Test".AsMemory());
-    }
-
-    private static void SerializeDeserializeTest<T>(T expected)
-    {
-        // Serialize the object to JSON string.
-        var jsonString = JsonSerializer.Serialize(expected, Options);
-
-        // Deserialize the JSON string back into an object.
-        Debug.Assert(expected != null, nameof(expected) + " != null");
-        var deserializedObject = JsonSerializer.Deserialize(jsonString, expected.GetType(), Options);
-
-        // Now you have a 'deserializedObject' which should be equivalent to the original 'expected' object.
-        Assert.That(deserializedObject, Is.Not.Null);
-        Assert.That(deserializedObject, Is.EqualTo(expected));
     }
 
     private static readonly JsonSerializerOptions Options = new()

Linguini.Serialization/Converters/JunkSerializer.cs

@@ -10,7 +10,18 @@ public class JunkSerializer : JsonConverter<Junk>
     {
         public override Junk Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
-            throw new NotImplementedException();
+            return ProcessJunk(JsonSerializer.Deserialize<JsonElement>(ref reader, options), options);
+        }
+
+        private Junk ProcessJunk(JsonElement el, JsonSerializerOptions options)
+        {
+            if (el.TryGetProperty("content", out var content))
+            {
+                var str = content.GetString() ?? "";
+                return new Junk(str);
+            }
+
+            throw new JsonException("Junk must have content");
         }
 
         public override void Write(Utf8JsonWriter writer, Junk value, JsonSerializerOptions options)

Linguini.Serialization/Converters/MessageReferenceSerializer.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 using Linguini.Syntax.Ast;

Linguini.Serialization/Converters/MessageSerializer.cs

@@ -1,15 +1,46 @@
 using System;
+using System.Collections.Generic;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 using Linguini.Syntax.Ast;
+using Attribute = Linguini.Syntax.Ast.Attribute;
 
 namespace Linguini.Serialization.Converters
 {
     public class MessageSerializer : JsonConverter<AstMessage>
     {
         public override AstMessage Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
-            throw new NotImplementedException();
+            var el = JsonSerializer.Deserialize<JsonElement>(ref reader, options);
+            if (!el.TryGetProperty("id", out var jsonId) ||
+                !IdentifierSerializer.TryGetIdentifier(jsonId, options, out var identifier))
+            {
+                throw new JsonException("AstMessage must have at least `id` element");
+            }
+
+            Pattern? value = null;
+            AstComment? comment = null;
+            var attrs = new List<Attribute>();
+            if (el.TryGetProperty("value", out var patternJson) && patternJson.ValueKind == JsonValueKind.Object)
+            {
+                PatternSerializer.TryReadPattern(patternJson, options, out value);
+            }
+
+            if (el.TryGetProperty("comment", out var commentJson) && patternJson.ValueKind == JsonValueKind.Object)
+            {
+                comment = JsonSerializer.Deserialize<AstComment>(commentJson.GetRawText(), options);
+            }
+
+            if (el.TryGetProperty("attributes", out var attrsJson) && attrsJson.ValueKind == JsonValueKind.Array)
+            {
+                foreach (var attributeJson in attrsJson.EnumerateArray())
+                {
+                    var attr = JsonSerializer.Deserialize<Attribute>(attributeJson.GetRawText(), options);
+                    if (attr != null) attrs.Add(attr);
+                }
+            }
+
+            return new AstMessage(identifier, value, attrs, comment);
         }
 
         public override void Write(Utf8JsonWriter writer, AstMessage msg, JsonSerializerOptions options)
@@ -48,4 +79,4 @@ public override void Write(Utf8JsonWriter writer, AstMessage msg, JsonSerializer
             writer.WriteEndObject();
         }
     }
-}
+}

Linguini.Syntax/Ast/Base.cs

@@ -13,6 +13,26 @@ public class Attribute : IEquatable<Attribute>
         public readonly Identifier Id;
         public readonly Pattern Value;
 
+        public static AttributeComparer Comparer = new();
+
+        public class AttributeComparer : IEqualityComparer<Attribute>
+        {
+            public bool Equals(Attribute? x, Attribute? y)
+            {
+                if (ReferenceEquals(x, y)) return true;
+                if (ReferenceEquals(x, null)) return false;
+                if (ReferenceEquals(y, null)) return false;
+                if (x.GetType() != y.GetType()) return false;
+                return Identifier.Comparator.Equals(x.Id, y.Id) &&
+                       x.Value.Equals(y.Value);
+            }
+
+            public int GetHashCode(Attribute obj)
+            {
+                return HashCode.Combine(obj.Id, obj.Value);
+            }
+        }
+
         public Attribute(Identifier id, Pattern value)
         {
             Id = id;

Linguini.Syntax/Ast/Entry.cs

@@ -18,7 +18,7 @@ public Resource(List<IEntry> body, List<ParseError> errors)
         }
     }
 
-    public class AstMessage : IEntry
+    public class AstMessage : IEntry, IEquatable<AstMessage>
     {
         public readonly Identifier Id;
         public readonly Pattern? Value;
@@ -39,6 +39,28 @@ public string GetId()
         {
             return Id.ToString();
         }
+
+        public bool Equals(AstMessage? other)
+        {
+            if (ReferenceEquals(null, other)) return false;
+            if (ReferenceEquals(this, other)) return true;
+            return Identifier.Comparator.Equals(Id, other.Id) && Equals(Value, other.Value) &&
+                   Attributes.SequenceEqual(other.Attributes, Attribute.Comparer) &&
+                   Equals(InternalComment, other.InternalComment);
+        }
+
+        public override bool Equals(object? obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((AstMessage)obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(Id, Value, Attributes, InternalComment);
+        }
     }
 
     public class AstTerm : IEntry
@@ -129,20 +151,25 @@ public override int GetHashCode()
         }
     }
 
-    public class Junk : IEntry
+    public class Junk : IEntry, IEquatable<Junk>
     {
         public readonly ReadOnlyMemory<char> Content;
 
         public Junk()
         {
             Content = ReadOnlyMemory<char>.Empty;
         }
-        
+
         public Junk(ReadOnlyMemory<char> content)
         {
             Content = content;
         }
 
+        public Junk(string content)
+        {
+            Content = content.AsMemory();
+        }
+
         public string AsStr()
         {
             return Content.Span.ToString();
@@ -152,5 +179,25 @@ public string GetId()
         {
             return Content.Span.ToString();
         }
+
+        public bool Equals(Junk? other)
+        {
+            if (ReferenceEquals(null, other)) return false;
+            if (ReferenceEquals(this, other)) return true;
+            return Content.Span.SequenceEqual(other.Content.Span);
+        }
+
+        public override bool Equals(object? obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((Junk)obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return Content.GetHashCode();
+        }
     }
 }