Add tests and some test cases

DotTiled.Tests/TmxSerializer/TestData/Map/empty-map-base64-gzip.tmx

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<map version="1.10" tiledversion="1.11.0" orientation="orthogonal" renderorder="right-down" width="5" height="5" tilewidth="32" tileheight="32" infinite="0" nextlayerid="2" nextobjectid="1">
+ <layer id="1" name="Tile Layer 1" width="5" height="5">
+  <data encoding="base64" compression="gzip">
+   H4sIAAAAAAAACmNgoD0AAMrGiJlkAAAA
+  </data>
+ </layer>
+</map>

DotTiled.Tests/TmxSerializer/TestData/Map/empty-map-base64-zlib.tmx

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<map version="1.10" tiledversion="1.11.0" orientation="orthogonal" renderorder="right-down" width="5" height="5" tilewidth="32" tileheight="32" infinite="0" nextlayerid="2" nextobjectid="1">
+ <layer id="1" name="Tile Layer 1" width="5" height="5">
+  <data encoding="base64" compression="zlib">
+   eJxjYKA9AAAAZAAB
+  </data>
+ </layer>
+</map>

DotTiled.Tests/TmxSerializer/TestData/Map/empty-map-base64.tmx

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<map version="1.10" tiledversion="1.11.0" orientation="orthogonal" renderorder="right-down" width="5" height="5" tilewidth="32" tileheight="32" infinite="0" nextlayerid="2" nextobjectid="1">
+ <layer id="1" name="Tile Layer 1" width="5" height="5">
+  <data encoding="base64">
+   AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==
+  </data>
+ </layer>
+</map>

DotTiled.Tests/TmxSerializer/TestData/Map/empty-map-properties.cs

@@ -0,0 +1,56 @@
+namespace DotTiled.Tests;
+
+public partial class TmxSerializerMapTests
+{
+  private static Map EmptyMapWithProperties() => new Map
+  {
+    Version = "1.10",
+    TiledVersion = "1.11.0",
+    Orientation = MapOrientation.Orthogonal,
+    RenderOrder = RenderOrder.RightDown,
+    Width = 5,
+    Height = 5,
+    TileWidth = 32,
+    TileHeight = 32,
+    Infinite = false,
+    NextLayerID = 2,
+    NextObjectID = 1,
+    Layers = [
+      new TileLayer
+      {
+        ID = 1,
+        Name = "Tile Layer 1",
+        Width = 5,
+        Height = 5,
+        Data = new Data
+        {
+          Encoding = DataEncoding.Csv,
+          GlobalTileIDs = [
+            0,0,0,0,0,
+            0,0,0,0,0,
+            0,0,0,0,0,
+            0,0,0,0,0,
+            0,0,0,0,0
+          ],
+          FlippingFlags = [
+            FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None,
+            FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None,
+            FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None,
+            FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None,
+            FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None
+          ]
+        }
+      }
+    ],
+    Properties = new Dictionary<string, IProperty>
+    {
+      ["MapBool"] = new BoolProperty { Name = "MapBool", Value = true },
+      ["MapColor"] = new ColorProperty { Name = "MapColor", Value = new Color { R = 255, G = 0, B = 0, A = 255 } },
+      ["MapFile"] = new FileProperty { Name = "MapFile", Value = "file.png" },
+      ["MapFloat"] = new FloatProperty { Name = "MapFloat", Value = 5.2f },
+      ["MapInt"] = new IntProperty { Name = "MapInt", Value = 42 },
+      ["MapObject"] = new ObjectProperty { Name = "MapObject", Value = 5 },
+      ["MapString"] = new StringProperty { Name = "MapString", Value = "string in map" }
+    }
+  };
+}

DotTiled.Tests/TmxSerializer/TestData/Map/empty-map-properties.tmx

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<map version="1.10" tiledversion="1.11.0" orientation="orthogonal" renderorder="right-down" width="5" height="5" tilewidth="32" tileheight="32" infinite="0" nextlayerid="2" nextobjectid="1">
+ <properties>
+  <property name="MapBool" type="bool" value="true"/>
+  <property name="MapColor" type="color" value="#ffff0000"/>
+  <property name="MapFile" type="file" value="file.png"/>
+  <property name="MapFloat" type="float" value="5.2"/>
+  <property name="MapInt" type="int" value="42"/>
+  <property name="MapObject" type="object" value="5"/>
+  <property name="MapString" value="string in map"/>
+ </properties>
+ <layer id="1" name="Tile Layer 1" width="5" height="5">
+  <data encoding="csv">
+0,0,0,0,0,
+0,0,0,0,0,
+0,0,0,0,0,
+0,0,0,0,0,
+0,0,0,0,0
+</data>
+ </layer>
+</map>

DotTiled.Tests/TmxSerializer/TestData/Map/empty-map.cs

@@ -2,7 +2,7 @@ namespace DotTiled.Tests;
 
 public partial class TmxSerializerMapTests
 {
-  private readonly static Map EmptyMap = new Map
+  private static Map EmptyMapWithEncodingAndCompression(DataEncoding dataEncoding, DataCompression? compression) => new Map
   {
     Version = "1.10",
     TiledVersion = "1.11.0",
@@ -24,7 +24,8 @@ public partial class TmxSerializerMapTests
         Height = 5,
         Data = new Data
         {
-          Encoding = DataEncoding.Csv,
+          Encoding = dataEncoding,
+          Compression = compression,
           GlobalTileIDs = [
             0,0,0,0,0,
             0,0,0,0,0,

DotTiled.Tests/TmxSerializer/TestData/Map/simple-tileset-embed.cs

@@ -0,0 +1,64 @@
+namespace DotTiled.Tests;
+
+public partial class TmxSerializerMapTests
+{
+  private static Map SimpleMapWithEmbeddedTileset() => new Map
+  {
+    Version = "1.10",
+    TiledVersion = "1.11.0",
+    Orientation = MapOrientation.Orthogonal,
+    RenderOrder = RenderOrder.RightDown,
+    Width = 5,
+    Height = 5,
+    TileWidth = 32,
+    TileHeight = 32,
+    Infinite = false,
+    NextLayerID = 2,
+    NextObjectID = 1,
+    Tilesets = [
+      new Tileset
+      {
+        FirstGID = 1,
+        Name = "Tileset 1",
+        TileWidth = 32,
+        TileHeight = 32,
+        TileCount = 8,
+        Columns = 4,
+        Image = new Image
+        {
+          Source = "tiles.png",
+          Width = 128,
+          Height = 64
+        }
+      }
+    ],
+    Layers = [
+      new TileLayer
+      {
+        ID = 1,
+        Name = "Tile Layer 1",
+        Width = 5,
+        Height = 5,
+        Data = new Data
+        {
+          Encoding = DataEncoding.Csv,
+          Compression = null,
+          GlobalTileIDs = [
+            1,1,1,1,1,
+            1,1,1,1,1,
+            1,1,1,1,1,
+            2,2,2,2,2,
+            2,2,2,2,2
+          ],
+          FlippingFlags = [
+            FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None,
+            FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None,
+            FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None,
+            FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None,
+            FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None
+          ]
+        },
+      }
+    ]
+  };
+}

DotTiled.Tests/TmxSerializer/TestData/Map/simple-tileset-embed.tmx

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<map version="1.10" tiledversion="1.11.0" orientation="orthogonal" renderorder="right-down" width="5" height="5" tilewidth="32" tileheight="32" infinite="0" nextlayerid="2" nextobjectid="1">
+ <tileset firstgid="1" name="Tileset 1" tilewidth="32" tileheight="32" tilecount="8" columns="4">
+  <image source="tiles.png" width="128" height="64"/>
+ </tileset>
+ <layer id="1" name="Tile Layer 1" width="5" height="5">
+  <data encoding="csv">
+1,1,1,1,1,
+1,1,1,1,1,
+1,1,1,1,1,
+2,2,2,2,2,
+2,2,2,2,2
+</data>
+ </layer>
+</map>

DotTiled.Tests/TmxSerializer/TmxSerializer.DataTests.cs

@@ -0,0 +1,43 @@
+namespace DotTiled.Tests;
+
+public partial class TmxSerializerDataTests
+{
+  public static void AssertData(Data? actual, Data? expected)
+  {
+    if (expected is null)
+    {
+      Assert.Null(actual);
+      return;
+    }
+
+    // Attributes
+    Assert.NotNull(actual);
+    Assert.Equal(expected.Encoding, actual.Encoding);
+    Assert.Equal(expected.Compression, actual.Compression);
+
+    // Data
+    Assert.Equal(expected.GlobalTileIDs, actual.GlobalTileIDs);
+    Assert.Equal(expected.FlippingFlags, actual.FlippingFlags);
+
+    if (expected.Chunks is not null)
+    {
+      Assert.NotNull(actual.Chunks);
+      Assert.Equal(expected.Chunks.Length, actual.Chunks.Length);
+      for (var i = 0; i < expected.Chunks.Length; i++)
+        AssertChunk(actual.Chunks[i], expected.Chunks[i]);
+    }
+  }
+
+  private static void AssertChunk(Chunk actual, Chunk expected)
+  {
+    // Attributes
+    Assert.Equal(expected.X, actual.X);
+    Assert.Equal(expected.Y, actual.Y);
+    Assert.Equal(expected.Width, actual.Width);
+    Assert.Equal(expected.Height, actual.Height);
+
+    // Data
+    Assert.Equal(expected.GlobalTileIDs, actual.GlobalTileIDs);
+    Assert.Equal(expected.FlippingFlags, actual.FlippingFlags);
+  }
+}

DotTiled.Tests/TmxSerializer/TmxSerializer.ImageTests.cs

@@ -0,0 +1,21 @@
+namespace DotTiled.Tests;
+
+public partial class TmxSerializerImageTests
+{
+  public static void AssertImage(Image? actual, Image? expected)
+  {
+    if (expected is null)
+    {
+      Assert.Null(actual);
+      return;
+    }
+
+    // Attributes
+    Assert.NotNull(actual);
+    Assert.Equal(expected.Format, actual.Format);
+    Assert.Equal(expected.Source, actual.Source);
+    Assert.Equal(expected.TransparentColor, actual.TransparentColor);
+    Assert.Equal(expected.Width, actual.Width);
+    Assert.Equal(expected.Height, actual.Height);
+  }
+}

DotTiled.Tests/TmxSerializer/TmxSerializer.LayerTests.cs

@@ -0,0 +1,62 @@
+namespace DotTiled.Tests;
+
+public partial class TmxSerializerLayerTests
+{
+  public static void AssertLayer(BaseLayer? actual, BaseLayer? expected)
+  {
+    if (expected is null)
+    {
+      Assert.Null(actual);
+      return;
+    }
+
+    // Attributes
+    Assert.NotNull(actual);
+    Assert.Equal(expected.ID, actual.ID);
+    Assert.Equal(expected.Name, actual.Name);
+    Assert.Equal(expected.Class, actual.Class);
+    Assert.Equal(expected.X, actual.X);
+    Assert.Equal(expected.Y, actual.Y);
+    Assert.Equal(expected.Opacity, actual.Opacity);
+    Assert.Equal(expected.Visible, actual.Visible);
+    Assert.Equal(expected.TintColor, actual.TintColor);
+    Assert.Equal(expected.OffsetX, actual.OffsetX);
+    Assert.Equal(expected.OffsetY, actual.OffsetY);
+    Assert.Equal(expected.ParallaxX, actual.ParallaxX);
+    Assert.Equal(expected.ParallaxY, actual.ParallaxY);
+
+    TmxSerializerPropertiesTests.AssertProperties(actual.Properties, expected.Properties);
+    AssertLayer((dynamic)actual, (dynamic)expected);
+  }
+
+  private static void AssertLayer(TileLayer actual, TileLayer expected)
+  {
+    // Attributes
+    Assert.Equal(expected.Width, actual.Width);
+    Assert.Equal(expected.Height, actual.Height);
+
+    Assert.NotNull(actual.Data);
+    TmxSerializerDataTests.AssertData(actual.Data, expected.Data);
+  }
+
+  private static void AssertLayer(ObjectLayer actual, ObjectLayer expected)
+  {
+    // Attributes
+    Assert.Equal(expected.DrawOrder, actual.DrawOrder);
+
+    Assert.NotNull(actual.Objects);
+    Assert.Equal(expected.Objects.Count, actual.Objects.Count);
+    for (var i = 0; i < expected.Objects.Count; i++)
+      TmxSerializerObjectTests.AssertObject(actual.Objects[i], expected.Objects[i]);
+  }
+
+  private static void AssertLayer(ImageLayer actual, ImageLayer expected)
+  {
+    // Attributes
+    Assert.Equal(expected.RepeatX, actual.RepeatX);
+    Assert.Equal(expected.RepeatY, actual.RepeatY);
+
+    Assert.NotNull(actual.Image);
+    TmxSerializerImageTests.AssertImage(actual.Image, expected.Image);
+  }
+}

DotTiled.Tests/TmxSerializer/TmxSerializer.MapTests.cs

@@ -24,16 +24,33 @@ public partial class TmxSerializerMapTests
     Assert.Equal(expected.NextLayerID, actual.NextLayerID);
     Assert.Equal(expected.NextObjectID, actual.NextObjectID);
     Assert.Equal(expected.Infinite, actual.Infinite);
+
+    TmxSerializerPropertiesTests.AssertProperties(actual.Properties, expected.Properties);
+
+    Assert.NotNull(actual.Tilesets);
+    Assert.Equal(expected.Tilesets.Count, actual.Tilesets.Count);
+    for (var i = 0; i < expected.Tilesets.Count; i++)
+      TmxSerializerTilesetTests.AssertTileset(actual.Tilesets[i], expected.Tilesets[i]);
+
+    Assert.NotNull(actual.Layers);
+    Assert.Equal(expected.Layers.Count, actual.Layers.Count);
+    for (var i = 0; i < expected.Layers.Count; i++)
+      TmxSerializerLayerTests.AssertLayer(actual.Layers[i], expected.Layers[i]);
   }
 
   public static IEnumerable<object[]> DeserializeMap_ValidXmlNoExternalTilesets_ReturnsMapWithoutThrowing_Data =>
     [
-      ["TmxSerializer.TestData.Map.empty-map.tmx", EmptyMap]
+      ["TmxSerializer.TestData.Map.empty-map-csv.tmx", EmptyMapWithEncodingAndCompression(DataEncoding.Csv, null)],
+      ["TmxSerializer.TestData.Map.empty-map-base64.tmx", EmptyMapWithEncodingAndCompression(DataEncoding.Base64, null)],
+      ["TmxSerializer.TestData.Map.empty-map-base64-gzip.tmx", EmptyMapWithEncodingAndCompression(DataEncoding.Base64, DataCompression.GZip)],
+      ["TmxSerializer.TestData.Map.empty-map-base64-zlib.tmx", EmptyMapWithEncodingAndCompression(DataEncoding.Base64, DataCompression.ZLib)],
+      ["TmxSerializer.TestData.Map.simple-tileset-embed.tmx", SimpleMapWithEmbeddedTileset()],
+      ["TmxSerializer.TestData.Map.empty-map-properties.tmx", EmptyMapWithProperties()],
     ];
 
   [Theory]
   [MemberData(nameof(DeserializeMap_ValidXmlNoExternalTilesets_ReturnsMapWithoutThrowing_Data))]
-  public void DeserializeMap_ValidXmlNoExternalTilesets_ReturnsMapWithoutThrowing(string testDataFile, Map expectedMap)
+  public void DeserializeMap_ValidXmlNoExternalTilesets_ReturnsMapThatEqualsExpected(string testDataFile, Map expectedMap)
   {
     // Arrange
     using var reader = TmxSerializerTestData.GetReaderFor(testDataFile);

DotTiled.Tests/TmxSerializer/TmxSerializer.ObjectTests.cs

@@ -0,0 +1,66 @@
+namespace DotTiled.Tests;
+
+public partial class TmxSerializerObjectTests
+{
+  public static void AssertObject(Object actual, Object expected)
+  {
+    // Attributes
+    Assert.Equal(expected.ID, actual.ID);
+    Assert.Equal(expected.Name, actual.Name);
+    Assert.Equal(expected.Type, actual.Type);
+    Assert.Equal(expected.X, actual.X);
+    Assert.Equal(expected.Y, actual.Y);
+    Assert.Equal(expected.Width, actual.Width);
+    Assert.Equal(expected.Height, actual.Height);
+    Assert.Equal(expected.Rotation, actual.Rotation);
+    Assert.Equal(expected.GID, actual.GID);
+    Assert.Equal(expected.Visible, actual.Visible);
+    Assert.Equal(expected.Template, actual.Template);
+
+    TmxSerializerPropertiesTests.AssertProperties(actual.Properties, expected.Properties);
+    AssertObject((dynamic)actual, (dynamic)expected);
+  }
+
+  private static void AssertObject(RectangleObject actual, RectangleObject expected)
+  {
+    Assert.True(true); // A rectangle object is the same as the abstract Object
+  }
+
+  private static void AssertObject(EllipseObject actual, EllipseObject expected)
+  {
+    Assert.True(true); // An ellipse object is the same as the abstract Object
+  }
+
+  private static void AssertObject(PointObject actual, PointObject expected)
+  {
+    Assert.True(true); // A point object is the same as the abstract Object
+  }
+
+  private static void AssertObject(PolygonObject actual, PolygonObject expected)
+  {
+    Assert.Equal(expected.Points, actual.Points);
+  }
+
+  private static void AssertObject(PolylineObject actual, PolylineObject expected)
+  {
+    Assert.Equal(expected.Points, actual.Points);
+  }
+
+  private static void AssertObject(TextObject actual, TextObject expected)
+  {
+    // Attributes
+    Assert.Equal(expected.FontFamily, actual.FontFamily);
+    Assert.Equal(expected.PixelSize, actual.PixelSize);
+    Assert.Equal(expected.Wrap, actual.Wrap);
+    Assert.Equal(expected.Color, actual.Color);
+    Assert.Equal(expected.Bold, actual.Bold);
+    Assert.Equal(expected.Italic, actual.Italic);
+    Assert.Equal(expected.Underline, actual.Underline);
+    Assert.Equal(expected.Strikeout, actual.Strikeout);
+    Assert.Equal(expected.Kerning, actual.Kerning);
+    Assert.Equal(expected.HorizontalAlignment, actual.HorizontalAlignment);
+    Assert.Equal(expected.VerticalAlignment, actual.VerticalAlignment);
+
+    Assert.Equal(expected.Text, actual.Text);
+  }
+}

DotTiled.Tests/TmxSerializer/TmxSerializer.PropertiesTests.cs

@@ -0,0 +1,69 @@
+namespace DotTiled.Tests;
+
+public partial class TmxSerializerPropertiesTests
+{
+  public static void AssertProperties(Dictionary<string, IProperty>? actual, Dictionary<string, IProperty>? expected)
+  {
+    if (expected is null)
+    {
+      Assert.Null(actual);
+      return;
+    }
+
+    Assert.NotNull(actual);
+    Assert.Equal(expected.Count, actual.Count);
+    foreach (var kvp in expected)
+    {
+      Assert.Contains(kvp.Key, actual.Keys);
+      AssertProperty((dynamic)kvp.Value, (dynamic)actual[kvp.Key]);
+    }
+  }
+
+  private static void AssertProperty(IProperty actual, IProperty expected)
+  {
+    Assert.Equal(expected.Type, actual.Type);
+    Assert.Equal(expected.Name, actual.Name);
+    AssertProperties((dynamic)actual, (dynamic)expected);
+  }
+
+  private static void AssertProperty(StringProperty actual, StringProperty expected)
+  {
+    Assert.Equal(expected.Value, actual.Value);
+  }
+
+  private static void AssertProperty(IntProperty actual, IntProperty expected)
+  {
+    Assert.Equal(expected.Value, actual.Value);
+  }
+
+  private static void AssertProperty(FloatProperty actual, FloatProperty expected)
+  {
+    Assert.Equal(expected.Value, actual.Value);
+  }
+
+  private static void AssertProperty(BoolProperty actual, BoolProperty expected)
+  {
+    Assert.Equal(expected.Value, actual.Value);
+  }
+
+  private static void AssertProperty(ColorProperty actual, ColorProperty expected)
+  {
+    Assert.Equal(expected.Value, actual.Value);
+  }
+
+  private static void AssertProperty(FileProperty actual, FileProperty expected)
+  {
+    Assert.Equal(expected.Value, actual.Value);
+  }
+
+  private static void AssertProperty(ObjectProperty actual, ObjectProperty expected)
+  {
+    Assert.Equal(expected.Value, actual.Value);
+  }
+
+  private static void AssertProperty(ClassProperty actual, ClassProperty expected)
+  {
+    Assert.Equal(expected.PropertyType, actual.PropertyType);
+    AssertProperties(actual.Properties, expected.Properties);
+  }
+}

DotTiled.Tests/TmxSerializer/TmxSerializer.TilesetTests.cs

@@ -0,0 +1,160 @@
+namespace DotTiled.Tests;
+
+public partial class TmxSerializerTilesetTests
+{
+  public static void AssertTileset(Tileset actual, Tileset expected)
+  {
+    // Attributes
+    Assert.Equal(expected.Version, actual.Version);
+    Assert.Equal(expected.TiledVersion, actual.TiledVersion);
+    Assert.Equal(expected.FirstGID, actual.FirstGID);
+    Assert.Equal(expected.Source, actual.Source);
+    Assert.Equal(expected.Name, actual.Name);
+    Assert.Equal(expected.Class, actual.Class);
+    Assert.Equal(expected.TileWidth, actual.TileWidth);
+    Assert.Equal(expected.TileHeight, actual.TileHeight);
+    Assert.Equal(expected.Spacing, actual.Spacing);
+    Assert.Equal(expected.Margin, actual.Margin);
+    Assert.Equal(expected.TileCount, actual.TileCount);
+    Assert.Equal(expected.Columns, actual.Columns);
+    Assert.Equal(expected.ObjectAlignment, actual.ObjectAlignment);
+    Assert.Equal(expected.RenderSize, actual.RenderSize);
+    Assert.Equal(expected.FillMode, actual.FillMode);
+
+    // At most one of
+    TmxSerializerImageTests.AssertImage(actual.Image, expected.Image);
+    AssertTileOffset(actual.TileOffset, expected.TileOffset);
+    AssertGrid(actual.Grid, expected.Grid);
+    TmxSerializerPropertiesTests.AssertProperties(actual.Properties, expected.Properties);
+    // TODO: AssertTerrainTypes(actual.TerrainTypes, expected.TerrainTypes);
+    if (expected.Wangsets is not null)
+    {
+      Assert.NotNull(actual.Wangsets);
+      Assert.Equal(expected.Wangsets.Count, actual.Wangsets.Count);
+      for (var i = 0; i < expected.Wangsets.Count; i++)
+        AssertWangset(actual.Wangsets[i], expected.Wangsets[i]);
+    }
+    AssertTransformations(actual.Transformations, expected.Transformations);
+
+    // Any number of
+    Assert.NotNull(actual.Tiles);
+    Assert.Equal(expected.Tiles.Count, actual.Tiles.Count);
+    for (var i = 0; i < expected.Tiles.Count; i++)
+      AssertTile(actual.Tiles[i], expected.Tiles[i]);
+  }
+
+  private static void AssertTileOffset(TileOffset? actual, TileOffset? expected)
+  {
+    if (expected is null)
+    {
+      Assert.Null(actual);
+      return;
+    }
+
+    // Attributes
+    Assert.NotNull(actual);
+    Assert.Equal(expected.X, actual.X);
+    Assert.Equal(expected.Y, actual.Y);
+  }
+
+  private static void AssertGrid(Grid? actual, Grid? expected)
+  {
+    if (expected is null)
+    {
+      Assert.Null(actual);
+      return;
+    }
+
+    // Attributes
+    Assert.NotNull(actual);
+    Assert.Equal(expected.Orientation, actual.Orientation);
+    Assert.Equal(expected.Width, actual.Width);
+    Assert.Equal(expected.Height, actual.Height);
+  }
+
+  private static void AssertWangset(Wangset actual, Wangset expected)
+  {
+    // Attributes
+    Assert.Equal(expected.Name, actual.Name);
+    Assert.Equal(expected.Class, actual.Class);
+    Assert.Equal(expected.Tile, actual.Tile);
+
+    // At most one of
+    TmxSerializerPropertiesTests.AssertProperties(actual.Properties, expected.Properties);
+    if (expected.WangColors is not null)
+    {
+      Assert.NotNull(actual.WangColors);
+      Assert.Equal(expected.WangColors.Count, actual.WangColors.Count);
+      for (var i = 0; i < expected.WangColors.Count; i++)
+        AssertWangColor(actual.WangColors[i], expected.WangColors[i]);
+    }
+    for (var i = 0; i < expected.WangTiles.Count; i++)
+      AssertWangTile(actual.WangTiles[i], expected.WangTiles[i]);
+  }
+
+  private static void AssertWangColor(WangColor actual, WangColor expected)
+  {
+    // Attributes
+    Assert.Equal(expected.Name, actual.Name);
+    Assert.Equal(expected.Class, actual.Class);
+    Assert.Equal(expected.Color, actual.Color);
+    Assert.Equal(expected.Tile, actual.Tile);
+    Assert.Equal(expected.Probability, actual.Probability);
+
+    TmxSerializerPropertiesTests.AssertProperties(actual.Properties, expected.Properties);
+  }
+
+  private static void AssertWangTile(WangTile actual, WangTile expected)
+  {
+    // Attributes
+    Assert.Equal(expected.TileID, actual.TileID);
+    Assert.Equal(expected.WangID, actual.WangID);
+  }
+
+  private static void AssertTransformations(Transformations? actual, Transformations? expected)
+  {
+    if (expected is null)
+    {
+      Assert.Null(actual);
+      return;
+    }
+
+    // Attributes
+    Assert.NotNull(actual);
+    Assert.Equal(expected.HFlip, actual.HFlip);
+    Assert.Equal(expected.VFlip, actual.VFlip);
+    Assert.Equal(expected.Rotate, actual.Rotate);
+    Assert.Equal(expected.PreferUntransformed, actual.PreferUntransformed);
+  }
+
+  private static void AssertTile(Tile actual, Tile expected)
+  {
+    // Attributes
+    Assert.Equal(expected.ID, actual.ID);
+    Assert.Equal(expected.Type, actual.Type);
+    Assert.Equal(expected.Probability, actual.Probability);
+    Assert.Equal(expected.X, actual.X);
+    Assert.Equal(expected.Y, actual.Y);
+    Assert.Equal(expected.Width, actual.Width);
+    Assert.Equal(expected.Height, actual.Height);
+
+    // Elements
+    TmxSerializerPropertiesTests.AssertProperties(actual.Properties, expected.Properties);
+    TmxSerializerImageTests.AssertImage(actual.Image, expected.Image);
+    TmxSerializerLayerTests.AssertLayer(actual.ObjectLayer, expected.ObjectLayer);
+    if (expected.Animation is not null)
+    {
+      Assert.NotNull(actual.Animation);
+      Assert.Equal(expected.Animation.Count, actual.Animation.Count);
+      for (var i = 0; i < expected.Animation.Count; i++)
+        AssertFrame(actual.Animation[i], expected.Animation[i]);
+    }
+  }
+
+  private static void AssertFrame(Frame actual, Frame expected)
+  {
+    // Attributes
+    Assert.Equal(expected.TileID, actual.TileID);
+    Assert.Equal(expected.Duration, actual.Duration);
+  }
+}

DotTiled/Model/Layers/BaseLayer.cs

@@ -18,6 +18,6 @@ public abstract class BaseLayer
   public float ParallaxX { get; set; } = 1.0f;
   public float ParallaxY { get; set; } = 1.0f;
 
-  // Elements
+  // At most one of
   public Dictionary<string, IProperty>? Properties { get; set; }
 }

DotTiled/Model/Layers/Data.cs

@@ -44,7 +44,7 @@ public class Data
   public DataEncoding? Encoding { get; set; }
   public DataCompression? Compression { get; set; }
 
-  // Elements
+  // Data
   public uint[]? GlobalTileIDs { get; set; }
   public FlippingFlags[]? FlippingFlags { get; set; }
   public Chunk[]? Chunks { get; set; }

DotTiled/Model/Layers/TileLayer.cs

@@ -6,6 +6,6 @@ public class TileLayer : BaseLayer
   public required uint Width { get; set; }
   public required uint Height { get; set; }
 
-  // Elements
+  // At most one of
   public Data? Data { get; set; }
 }

DotTiled/Model/Tileset/Tileset.cs

@@ -36,7 +36,7 @@ public class Tileset
   public uint? FirstGID { get; set; }
   public string? Source { get; set; }
   public string? Name { get; set; }
-  public string? Class { get; set; } = "";
+  public string Class { get; set; } = "";
   public uint? TileWidth { get; set; }
   public uint? TileHeight { get; set; }
   public float? Spacing { get; set; }