Make assertions tell you where they fail

DotTiled.Tests/Assert/AssertData.cs

@@ -12,17 +12,17 @@ public static partial class DotTiledAssert
 
     // Attributes
     Assert.NotNull(actual);
-    Assert.Equal(expected.Encoding, actual.Encoding);
+    AssertEqual(expected.Encoding, actual.Encoding, nameof(Data.Encoding));
-    Assert.Equal(expected.Compression, actual.Compression);
+    AssertEqual(expected.Compression, actual.Compression, nameof(Data.Compression));
 
     // Data
-    Assert.Equal(expected.GlobalTileIDs, actual.GlobalTileIDs);
+    AssertEqual(expected.GlobalTileIDs, actual.GlobalTileIDs, nameof(Data.GlobalTileIDs));
-    Assert.Equal(expected.FlippingFlags, actual.FlippingFlags);
+    AssertEqual(expected.FlippingFlags, actual.FlippingFlags, nameof(Data.FlippingFlags));
 
     if (expected.Chunks is not null)
     {
       Assert.NotNull(actual.Chunks);
-      Assert.Equal(expected.Chunks.Length, actual.Chunks.Length);
+      AssertEqual(expected.Chunks.Length, actual.Chunks.Length, "Chunks.Length");
       for (var i = 0; i < expected.Chunks.Length; i++)
         AssertChunk(expected.Chunks[i], actual.Chunks[i]);
     }
@@ -31,13 +31,13 @@ public static partial class DotTiledAssert
   private static void AssertChunk(Chunk expected, Chunk actual)
   {
     // Attributes
-    Assert.Equal(expected.X, actual.X);
+    AssertEqual(expected.X, actual.X, nameof(Chunk.X));
-    Assert.Equal(expected.Y, actual.Y);
+    AssertEqual(expected.Y, actual.Y, nameof(Chunk.Y));
-    Assert.Equal(expected.Width, actual.Width);
+    AssertEqual(expected.Width, actual.Width, nameof(Chunk.Width));
-    Assert.Equal(expected.Height, actual.Height);
+    AssertEqual(expected.Height, actual.Height, nameof(Chunk.Height));
 
     // Data
-    Assert.Equal(expected.GlobalTileIDs, actual.GlobalTileIDs);
+    AssertEqual(expected.GlobalTileIDs, actual.GlobalTileIDs, nameof(Chunk.GlobalTileIDs));
-    Assert.Equal(expected.FlippingFlags, actual.FlippingFlags);
+    AssertEqual(expected.FlippingFlags, actual.FlippingFlags, nameof(Chunk.FlippingFlags));
   }
 }

DotTiled.Tests/Assert/AssertImage.cs

@@ -12,10 +12,10 @@ public static partial class DotTiledAssert
 
     // Attributes
     Assert.NotNull(actual);
-    Assert.Equal(expected.Format, actual.Format);
+    AssertEqual(expected.Format, actual.Format, nameof(Image.Format));
-    Assert.Equal(expected.Source, actual.Source);
+    AssertEqual(expected.Source, actual.Source, nameof(Image.Source));
-    Assert.Equal(expected.TransparentColor, actual.TransparentColor);
+    AssertEqual(expected.TransparentColor, actual.TransparentColor, nameof(Image.TransparentColor));
-    Assert.Equal(expected.Width, actual.Width);
+    AssertEqual(expected.Width, actual.Width, nameof(Image.Width));
-    Assert.Equal(expected.Height, actual.Height);
+    AssertEqual(expected.Height, actual.Height, nameof(Image.Height));
   }
 }

DotTiled.Tests/Assert/AssertLayer.cs

@@ -12,16 +12,16 @@ public static partial class DotTiledAssert
 
     // Attributes
     Assert.NotNull(actual);
-    Assert.Equal(expected.ID, actual.ID);
+    AssertEqual(expected.ID, actual.ID, nameof(BaseLayer.ID));
-    Assert.Equal(expected.Name, actual.Name);
+    AssertEqual(expected.Name, actual.Name, nameof(BaseLayer.Name));
-    Assert.Equal(expected.Class, actual.Class);
+    AssertEqual(expected.Class, actual.Class, nameof(BaseLayer.Class));
-    Assert.Equal(expected.Opacity, actual.Opacity);
+    AssertEqual(expected.Opacity, actual.Opacity, nameof(BaseLayer.Opacity));
-    Assert.Equal(expected.Visible, actual.Visible);
+    AssertEqual(expected.Visible, actual.Visible, nameof(BaseLayer.Visible));
-    Assert.Equal(expected.TintColor, actual.TintColor);
+    AssertEqual(expected.TintColor, actual.TintColor, nameof(BaseLayer.TintColor));
-    Assert.Equal(expected.OffsetX, actual.OffsetX);
+    AssertEqual(expected.OffsetX, actual.OffsetX, nameof(BaseLayer.OffsetX));
-    Assert.Equal(expected.OffsetY, actual.OffsetY);
+    AssertEqual(expected.OffsetY, actual.OffsetY, nameof(BaseLayer.OffsetY));
-    Assert.Equal(expected.ParallaxX, actual.ParallaxX);
+    AssertEqual(expected.ParallaxX, actual.ParallaxX, nameof(BaseLayer.ParallaxX));
-    Assert.Equal(expected.ParallaxY, actual.ParallaxY);
+    AssertEqual(expected.ParallaxY, actual.ParallaxY, nameof(BaseLayer.ParallaxY));
 
     AssertProperties(expected.Properties, actual.Properties);
     AssertLayer((dynamic)expected, (dynamic)actual);
@@ -30,10 +30,10 @@ public static partial class DotTiledAssert
   private static void AssertLayer(TileLayer expected, TileLayer actual)
   {
     // Attributes
-    Assert.Equal(expected.Width, actual.Width);
+    AssertEqual(expected.Width, actual.Width, nameof(TileLayer.Width));
-    Assert.Equal(expected.Height, actual.Height);
+    AssertEqual(expected.Height, actual.Height, nameof(TileLayer.Height));
-    Assert.Equal(expected.X, actual.X);
+    AssertEqual(expected.X, actual.X, nameof(TileLayer.X));
-    Assert.Equal(expected.Y, actual.Y);
+    AssertEqual(expected.Y, actual.Y, nameof(TileLayer.Y));
 
     Assert.NotNull(actual.Data);
     AssertData(expected.Data, actual.Data);
@@ -42,12 +42,12 @@ public static partial class DotTiledAssert
   private static void AssertLayer(ObjectLayer expected, ObjectLayer actual)
   {
     // Attributes
-    Assert.Equal(expected.DrawOrder, actual.DrawOrder);
+    AssertEqual(expected.DrawOrder, actual.DrawOrder, nameof(ObjectLayer.DrawOrder));
-    Assert.Equal(expected.X, actual.X);
+    AssertEqual(expected.X, actual.X, nameof(ObjectLayer.X));
-    Assert.Equal(expected.Y, actual.Y);
+    AssertEqual(expected.Y, actual.Y, nameof(ObjectLayer.Y));
 
     Assert.NotNull(actual.Objects);
-    Assert.Equal(expected.Objects.Count, actual.Objects.Count);
+    AssertEqual(expected.Objects.Count, actual.Objects.Count, "Objects.Count");
     for (var i = 0; i < expected.Objects.Count; i++)
       AssertObject(expected.Objects[i], actual.Objects[i]);
   }
@@ -55,10 +55,10 @@ public static partial class DotTiledAssert
   private static void AssertLayer(ImageLayer expected, ImageLayer actual)
   {
     // Attributes
-    Assert.Equal(expected.RepeatX, actual.RepeatX);
+    AssertEqual(expected.RepeatX, actual.RepeatX, nameof(ImageLayer.RepeatX));
-    Assert.Equal(expected.RepeatY, actual.RepeatY);
+    AssertEqual(expected.RepeatY, actual.RepeatY, nameof(ImageLayer.RepeatY));
-    Assert.Equal(expected.X, actual.X);
+    AssertEqual(expected.X, actual.X, nameof(ImageLayer.X));
-    Assert.Equal(expected.Y, actual.Y);
+    AssertEqual(expected.Y, actual.Y, nameof(ImageLayer.Y));
 
     Assert.NotNull(actual.Image);
     AssertImage(expected.Image, actual.Image);
@@ -68,7 +68,7 @@ public static partial class DotTiledAssert
   {
     // Attributes
     Assert.NotNull(actual.Layers);
-    Assert.Equal(expected.Layers.Count, actual.Layers.Count);
+    AssertEqual(expected.Layers.Count, actual.Layers.Count, "Layers.Count");
     for (var i = 0; i < expected.Layers.Count; i++)
       AssertLayer(expected.Layers[i], actual.Layers[i]);
   }

DotTiled.Tests/Assert/AssertMap.cs

@@ -2,38 +2,63 @@ namespace DotTiled.Tests;
 
 public static partial class DotTiledAssert
 {
+  private static void AssertEqual<T>(T expected, T actual, string nameof)
+  {
+    if (expected == null)
+    {
+      Assert.Null(actual);
+      return;
+    }
+
+    if (typeof(T).IsArray)
+    {
+      var expectedArray = (Array)(object)expected;
+      var actualArray = (Array)(object)actual!;
+
+      Assert.NotNull(actualArray);
+      AssertEqual(expectedArray.Length, actualArray.Length, $"{nameof}.Length");
+
+      for (var i = 0; i < expectedArray.Length; i++)
+        AssertEqual(expectedArray.GetValue(i), actualArray.GetValue(i), $"{nameof}[{i}]");
+
+      return;
+    }
+
+    Assert.True(expected.Equals(actual), $"Expected {nameof} '{expected}' but got '{actual}'");
+  }
+
   internal static void AssertMap(Map expected, Map actual)
   {
     // Attributes
-    Assert.Equal(expected.Version, actual.Version);
+    AssertEqual(expected.Version, actual.Version, nameof(Map.Version));
-    Assert.Equal(expected.TiledVersion, actual.TiledVersion);
+    AssertEqual(expected.TiledVersion, actual.TiledVersion, nameof(Map.TiledVersion));
-    Assert.Equal(expected.Class, actual.Class);
+    AssertEqual(expected.Class, actual.Class, nameof(Map.Class));
-    Assert.Equal(expected.Orientation, actual.Orientation);
+    AssertEqual(expected.Orientation, actual.Orientation, nameof(Map.Orientation));
-    Assert.Equal(expected.RenderOrder, actual.RenderOrder);
+    AssertEqual(expected.RenderOrder, actual.RenderOrder, nameof(Map.RenderOrder));
-    Assert.Equal(expected.CompressionLevel, actual.CompressionLevel);
+    AssertEqual(expected.CompressionLevel, actual.CompressionLevel, nameof(Map.CompressionLevel));
-    Assert.Equal(expected.Width, actual.Width);
+    AssertEqual(expected.Width, actual.Width, nameof(Map.Width));
-    Assert.Equal(expected.Height, actual.Height);
+    AssertEqual(expected.Height, actual.Height, nameof(Map.Height));
-    Assert.Equal(expected.TileWidth, actual.TileWidth);
+    AssertEqual(expected.TileWidth, actual.TileWidth, nameof(Map.TileWidth));
-    Assert.Equal(expected.TileHeight, actual.TileHeight);
+    AssertEqual(expected.TileHeight, actual.TileHeight, nameof(Map.TileHeight));
-    Assert.Equal(expected.HexSideLength, actual.HexSideLength);
+    AssertEqual(expected.HexSideLength, actual.HexSideLength, nameof(Map.HexSideLength));
-    Assert.Equal(expected.StaggerAxis, actual.StaggerAxis);
+    AssertEqual(expected.StaggerAxis, actual.StaggerAxis, nameof(Map.StaggerAxis));
-    Assert.Equal(expected.StaggerIndex, actual.StaggerIndex);
+    AssertEqual(expected.StaggerIndex, actual.StaggerIndex, nameof(Map.StaggerIndex));
-    Assert.Equal(expected.ParallaxOriginX, actual.ParallaxOriginX);
+    AssertEqual(expected.ParallaxOriginX, actual.ParallaxOriginX, nameof(Map.ParallaxOriginX));
-    Assert.Equal(expected.ParallaxOriginY, actual.ParallaxOriginY);
+    AssertEqual(expected.ParallaxOriginY, actual.ParallaxOriginY, nameof(Map.ParallaxOriginY));
-    Assert.Equal(expected.BackgroundColor, actual.BackgroundColor);
+    AssertEqual(expected.BackgroundColor, actual.BackgroundColor, nameof(Map.BackgroundColor));
-    Assert.Equal(expected.NextLayerID, actual.NextLayerID);
+    AssertEqual(expected.NextLayerID, actual.NextLayerID, nameof(Map.NextLayerID));
-    Assert.Equal(expected.NextObjectID, actual.NextObjectID);
+    AssertEqual(expected.NextObjectID, actual.NextObjectID, nameof(Map.NextObjectID));
-    Assert.Equal(expected.Infinite, actual.Infinite);
+    AssertEqual(expected.Infinite, actual.Infinite, nameof(Map.Infinite));
 
     AssertProperties(actual.Properties, expected.Properties);
 
     Assert.NotNull(actual.Tilesets);
-    Assert.Equal(expected.Tilesets.Count, actual.Tilesets.Count);
+    AssertEqual(expected.Tilesets.Count, actual.Tilesets.Count, "Tilesets.Count");
     for (var i = 0; i < expected.Tilesets.Count; i++)
       AssertTileset(expected.Tilesets[i], actual.Tilesets[i]);
 
     Assert.NotNull(actual.Layers);
-    Assert.Equal(expected.Layers.Count, actual.Layers.Count);
+    AssertEqual(expected.Layers.Count, actual.Layers.Count, "Layers.Count");
     for (var i = 0; i < expected.Layers.Count; i++)
       AssertLayer(expected.Layers[i], actual.Layers[i]);
   }

DotTiled.Tests/Assert/AssertObject.cs

@@ -5,17 +5,17 @@ public static partial class DotTiledAssert
   internal static void AssertObject(Object expected, Object actual)
   {
     // Attributes
-    Assert.Equal(expected.ID, actual.ID);
+    AssertEqual(expected.ID, actual.ID, nameof(Object.ID));
-    Assert.Equal(expected.Name, actual.Name);
+    AssertEqual(expected.Name, actual.Name, nameof(Object.Name));
-    Assert.Equal(expected.Type, actual.Type);
+    AssertEqual(expected.Type, actual.Type, nameof(Object.Type));
-    Assert.Equal(expected.X, actual.X);
+    AssertEqual(expected.X, actual.X, nameof(Object.X));
-    Assert.Equal(expected.Y, actual.Y);
+    AssertEqual(expected.Y, actual.Y, nameof(Object.Y));
-    Assert.Equal(expected.Width, actual.Width);
+    AssertEqual(expected.Width, actual.Width, nameof(Object.Width));
-    Assert.Equal(expected.Height, actual.Height);
+    AssertEqual(expected.Height, actual.Height, nameof(Object.Height));
-    Assert.Equal(expected.Rotation, actual.Rotation);
+    AssertEqual(expected.Rotation, actual.Rotation, nameof(Object.Rotation));
-    Assert.Equal(expected.GID, actual.GID);
+    AssertEqual(expected.GID, actual.GID, nameof(Object.GID));
-    Assert.Equal(expected.Visible, actual.Visible);
+    AssertEqual(expected.Visible, actual.Visible, nameof(Object.Visible));
-    Assert.Equal(expected.Template, actual.Template);
+    AssertEqual(expected.Template, actual.Template, nameof(Object.Template));
 
     AssertProperties(expected.Properties, actual.Properties);
     AssertObject((dynamic)expected, (dynamic)actual);
@@ -38,29 +38,29 @@ public static partial class DotTiledAssert
 
   private static void AssertObject(PolygonObject expected, PolygonObject actual)
   {
-    Assert.Equal(expected.Points, actual.Points);
+    AssertEqual(expected.Points, actual.Points, nameof(PolygonObject.Points));
   }
 
   private static void AssertObject(PolylineObject expected, PolylineObject actual)
   {
-    Assert.Equal(expected.Points, actual.Points);
+    AssertEqual(expected.Points, actual.Points, nameof(PolylineObject.Points));
   }
 
   private static void AssertObject(TextObject expected, TextObject actual)
   {
     // Attributes
-    Assert.Equal(expected.FontFamily, actual.FontFamily);
+    AssertEqual(expected.FontFamily, actual.FontFamily, nameof(TextObject.FontFamily));
-    Assert.Equal(expected.PixelSize, actual.PixelSize);
+    AssertEqual(expected.PixelSize, actual.PixelSize, nameof(TextObject.PixelSize));
-    Assert.Equal(expected.Wrap, actual.Wrap);
+    AssertEqual(expected.Wrap, actual.Wrap, nameof(TextObject.Wrap));
-    Assert.Equal(expected.Color, actual.Color);
+    AssertEqual(expected.Color, actual.Color, nameof(TextObject.Color));
-    Assert.Equal(expected.Bold, actual.Bold);
+    AssertEqual(expected.Bold, actual.Bold, nameof(TextObject.Bold));
-    Assert.Equal(expected.Italic, actual.Italic);
+    AssertEqual(expected.Italic, actual.Italic, nameof(TextObject.Italic));
-    Assert.Equal(expected.Underline, actual.Underline);
+    AssertEqual(expected.Underline, actual.Underline, nameof(TextObject.Underline));
-    Assert.Equal(expected.Strikeout, actual.Strikeout);
+    AssertEqual(expected.Strikeout, actual.Strikeout, nameof(TextObject.Strikeout));
-    Assert.Equal(expected.Kerning, actual.Kerning);
+    AssertEqual(expected.Kerning, actual.Kerning, nameof(TextObject.Kerning));
-    Assert.Equal(expected.HorizontalAlignment, actual.HorizontalAlignment);
+    AssertEqual(expected.HorizontalAlignment, actual.HorizontalAlignment, nameof(TextObject.HorizontalAlignment));
-    Assert.Equal(expected.VerticalAlignment, actual.VerticalAlignment);
+    AssertEqual(expected.VerticalAlignment, actual.VerticalAlignment, nameof(TextObject.VerticalAlignment));
 
-    Assert.Equal(expected.Text, actual.Text);
+    AssertEqual(expected.Text, actual.Text, nameof(TextObject.Text));
   }
 }

DotTiled.Tests/Assert/AssertProperties.cs

@@ -11,7 +11,7 @@ public static partial class DotTiledAssert
     }
 
     Assert.NotNull(actual);
-    Assert.Equal(expected.Count, actual.Count);
+    AssertEqual(expected.Count, actual.Count, "Properties.Count");
     foreach (var kvp in expected)
     {
       Assert.Contains(kvp.Key, actual.Keys);
@@ -21,49 +21,49 @@ public static partial class DotTiledAssert
 
   private static void AssertProperty(IProperty expected, IProperty actual)
   {
-    Assert.Equal(expected.Type, actual.Type);
+    AssertEqual(expected.Type, actual.Type, "Property.Type");
-    Assert.Equal(expected.Name, actual.Name);
+    AssertEqual(expected.Name, actual.Name, "Property.Name");
     AssertProperties((dynamic)actual, (dynamic)expected);
   }
 
   private static void AssertProperty(StringProperty expected, StringProperty actual)
   {
-    Assert.Equal(expected.Value, actual.Value);
+    AssertEqual(expected.Value, actual.Value, "StringProperty.Value");
   }
 
   private static void AssertProperty(IntProperty expected, IntProperty actual)
   {
-    Assert.Equal(expected.Value, actual.Value);
+    AssertEqual(expected.Value, actual.Value, "IntProperty.Value");
   }
 
   private static void AssertProperty(FloatProperty expected, FloatProperty actual)
   {
-    Assert.Equal(expected.Value, actual.Value);
+    AssertEqual(expected.Value, actual.Value, "FloatProperty.Value");
   }
 
   private static void AssertProperty(BoolProperty expected, BoolProperty actual)
   {
-    Assert.Equal(expected.Value, actual.Value);
+    AssertEqual(expected.Value, actual.Value, "BoolProperty.Value");
   }
 
   private static void AssertProperty(ColorProperty expected, ColorProperty actual)
   {
-    Assert.Equal(expected.Value, actual.Value);
+    AssertEqual(expected.Value, actual.Value, "ColorProperty.Value");
   }
 
   private static void AssertProperty(FileProperty expected, FileProperty actual)
   {
-    Assert.Equal(expected.Value, actual.Value);
+    AssertEqual(expected.Value, actual.Value, "FileProperty.Value");
   }
 
   private static void AssertProperty(ObjectProperty expected, ObjectProperty actual)
   {
-    Assert.Equal(expected.Value, actual.Value);
+    AssertEqual(expected.Value, actual.Value, "ObjectProperty.Value");
   }
 
   private static void AssertProperty(ClassProperty expected, ClassProperty actual)
   {
-    Assert.Equal(expected.PropertyType, actual.PropertyType);
+    AssertEqual(expected.PropertyType, actual.PropertyType, "ClassProperty.PropertyType");
     AssertProperties(expected.Properties, actual.Properties);
   }
 }

DotTiled.Tests/Assert/AssertTileset.cs

@@ -5,21 +5,21 @@ public static partial class DotTiledAssert
   internal static void AssertTileset(Tileset expected, Tileset actual)
   {
     // Attributes
-    Assert.Equal(expected.Version, actual.Version);
+    AssertEqual(expected.Version, actual.Version, nameof(Tileset.Version));
-    Assert.Equal(expected.TiledVersion, actual.TiledVersion);
+    AssertEqual(expected.TiledVersion, actual.TiledVersion, nameof(Tileset.TiledVersion));
-    Assert.Equal(expected.FirstGID, actual.FirstGID);
+    AssertEqual(expected.FirstGID, actual.FirstGID, nameof(Tileset.FirstGID));
-    Assert.Equal(expected.Source, actual.Source);
+    AssertEqual(expected.Source, actual.Source, nameof(Tileset.Source));
-    Assert.Equal(expected.Name, actual.Name);
+    AssertEqual(expected.Name, actual.Name, nameof(Tileset.Name));
-    Assert.Equal(expected.Class, actual.Class);
+    AssertEqual(expected.Class, actual.Class, nameof(Tileset.Class));
-    Assert.Equal(expected.TileWidth, actual.TileWidth);
+    AssertEqual(expected.TileWidth, actual.TileWidth, nameof(Tileset.TileWidth));
-    Assert.Equal(expected.TileHeight, actual.TileHeight);
+    AssertEqual(expected.TileHeight, actual.TileHeight, nameof(Tileset.TileHeight));
-    Assert.Equal(expected.Spacing, actual.Spacing);
+    AssertEqual(expected.Spacing, actual.Spacing, nameof(Tileset.Spacing));
-    Assert.Equal(expected.Margin, actual.Margin);
+    AssertEqual(expected.Margin, actual.Margin, nameof(Tileset.Margin));
-    Assert.Equal(expected.TileCount, actual.TileCount);
+    AssertEqual(expected.TileCount, actual.TileCount, nameof(Tileset.TileCount));
-    Assert.Equal(expected.Columns, actual.Columns);
+    AssertEqual(expected.Columns, actual.Columns, nameof(Tileset.Columns));
-    Assert.Equal(expected.ObjectAlignment, actual.ObjectAlignment);
+    AssertEqual(expected.ObjectAlignment, actual.ObjectAlignment, nameof(Tileset.ObjectAlignment));
-    Assert.Equal(expected.RenderSize, actual.RenderSize);
+    AssertEqual(expected.RenderSize, actual.RenderSize, nameof(Tileset.RenderSize));
-    Assert.Equal(expected.FillMode, actual.FillMode);
+    AssertEqual(expected.FillMode, actual.FillMode, nameof(Tileset.FillMode));
 
     // At most one of
     AssertImage(expected.Image, actual.Image);
@@ -30,7 +30,7 @@ public static partial class DotTiledAssert
     if (expected.Wangsets is not null)
     {
       Assert.NotNull(actual.Wangsets);
-      Assert.Equal(expected.Wangsets.Count, actual.Wangsets.Count);
+      AssertEqual(expected.Wangsets.Count, actual.Wangsets.Count, "Wangsets.Count");
       for (var i = 0; i < expected.Wangsets.Count; i++)
         AssertWangset(expected.Wangsets[i], actual.Wangsets[i]);
     }
@@ -38,7 +38,7 @@ public static partial class DotTiledAssert
 
     // Any number of
     Assert.NotNull(actual.Tiles);
-    Assert.Equal(expected.Tiles.Count, actual.Tiles.Count);
+    AssertEqual(expected.Tiles.Count, actual.Tiles.Count, "Tiles.Count");
     for (var i = 0; i < expected.Tiles.Count; i++)
       AssertTile(expected.Tiles[i], actual.Tiles[i]);
   }
@@ -53,8 +53,8 @@ public static partial class DotTiledAssert
 
     // Attributes
     Assert.NotNull(actual);
-    Assert.Equal(expected.X, actual.X);
+    AssertEqual(expected.X, actual.X, nameof(TileOffset.X));
-    Assert.Equal(expected.Y, actual.Y);
+    AssertEqual(expected.Y, actual.Y, nameof(TileOffset.Y));
   }
 
   private static void AssertGrid(Grid? expected, Grid? actual)
@@ -67,24 +67,24 @@ public static partial class DotTiledAssert
 
     // Attributes
     Assert.NotNull(actual);
-    Assert.Equal(expected.Orientation, actual.Orientation);
+    AssertEqual(expected.Orientation, actual.Orientation, nameof(Grid.Orientation));
-    Assert.Equal(expected.Width, actual.Width);
+    AssertEqual(expected.Width, actual.Width, nameof(Grid.Width));
-    Assert.Equal(expected.Height, actual.Height);
+    AssertEqual(expected.Height, actual.Height, nameof(Grid.Height));
   }
 
   private static void AssertWangset(Wangset expected, Wangset actual)
   {
     // Attributes
-    Assert.Equal(expected.Name, actual.Name);
+    AssertEqual(expected.Name, actual.Name, nameof(Wangset.Name));
-    Assert.Equal(expected.Class, actual.Class);
+    AssertEqual(expected.Class, actual.Class, nameof(Wangset.Class));
-    Assert.Equal(expected.Tile, actual.Tile);
+    AssertEqual(expected.Tile, actual.Tile, nameof(Wangset.Tile));
 
     // At most one of
     AssertProperties(expected.Properties, actual.Properties);
     if (expected.WangColors is not null)
     {
       Assert.NotNull(actual.WangColors);
-      Assert.Equal(expected.WangColors.Count, actual.WangColors.Count);
+      AssertEqual(expected.WangColors.Count, actual.WangColors.Count, "WangColors.Count");
       for (var i = 0; i < expected.WangColors.Count; i++)
         AssertWangColor(expected.WangColors[i], actual.WangColors[i]);
     }
@@ -95,11 +95,11 @@ public static partial class DotTiledAssert
   private static void AssertWangColor(WangColor expected, WangColor actual)
   {
     // Attributes
-    Assert.Equal(expected.Name, actual.Name);
+    AssertEqual(expected.Name, actual.Name, nameof(WangColor.Name));
-    Assert.Equal(expected.Class, actual.Class);
+    AssertEqual(expected.Class, actual.Class, nameof(WangColor.Class));
-    Assert.Equal(expected.Color, actual.Color);
+    AssertEqual(expected.Color, actual.Color, nameof(WangColor.Color));
-    Assert.Equal(expected.Tile, actual.Tile);
+    AssertEqual(expected.Tile, actual.Tile, nameof(WangColor.Tile));
-    Assert.Equal(expected.Probability, actual.Probability);
+    AssertEqual(expected.Probability, actual.Probability, nameof(WangColor.Probability));
 
     AssertProperties(expected.Properties, actual.Properties);
   }
@@ -107,8 +107,8 @@ public static partial class DotTiledAssert
   private static void AssertWangTile(WangTile expected, WangTile actual)
   {
     // Attributes
-    Assert.Equal(expected.TileID, actual.TileID);
+    AssertEqual(expected.TileID, actual.TileID, nameof(WangTile.TileID));
-    Assert.Equal(expected.WangID, actual.WangID);
+    AssertEqual(expected.WangID, actual.WangID, nameof(WangTile.WangID));
   }
 
   private static void AssertTransformations(Transformations? expected, Transformations? actual)
@@ -121,22 +121,22 @@ public static partial class DotTiledAssert
 
     // Attributes
     Assert.NotNull(actual);
-    Assert.Equal(expected.HFlip, actual.HFlip);
+    AssertEqual(expected.HFlip, actual.HFlip, nameof(Transformations.HFlip));
-    Assert.Equal(expected.VFlip, actual.VFlip);
+    AssertEqual(expected.VFlip, actual.VFlip, nameof(Transformations.VFlip));
-    Assert.Equal(expected.Rotate, actual.Rotate);
+    AssertEqual(expected.Rotate, actual.Rotate, nameof(Transformations.Rotate));
-    Assert.Equal(expected.PreferUntransformed, actual.PreferUntransformed);
+    AssertEqual(expected.PreferUntransformed, actual.PreferUntransformed, nameof(Transformations.PreferUntransformed));
   }
 
   private static void AssertTile(Tile expected, Tile actual)
   {
     // Attributes
-    Assert.Equal(expected.ID, actual.ID);
+    AssertEqual(expected.ID, actual.ID, nameof(Tile.ID));
-    Assert.Equal(expected.Type, actual.Type);
+    AssertEqual(expected.Type, actual.Type, nameof(Tile.Type));
-    Assert.Equal(expected.Probability, actual.Probability);
+    AssertEqual(expected.Probability, actual.Probability, nameof(Tile.Probability));
-    Assert.Equal(expected.X, actual.X);
+    AssertEqual(expected.X, actual.X, nameof(Tile.X));
-    Assert.Equal(expected.Y, actual.Y);
+    AssertEqual(expected.Y, actual.Y, nameof(Tile.Y));
-    Assert.Equal(expected.Width, actual.Width);
+    AssertEqual(expected.Width, actual.Width, nameof(Tile.Width));
-    Assert.Equal(expected.Height, actual.Height);
+    AssertEqual(expected.Height, actual.Height, nameof(Tile.Height));
 
     // Elements
     AssertProperties(actual.Properties, expected.Properties);
@@ -145,7 +145,7 @@ public static partial class DotTiledAssert
     if (expected.Animation is not null)
     {
       Assert.NotNull(actual.Animation);
-      Assert.Equal(expected.Animation.Count, actual.Animation.Count);
+      AssertEqual(expected.Animation.Count, actual.Animation.Count, "Animation.Count");
       for (var i = 0; i < expected.Animation.Count; i++)
         AssertFrame(expected.Animation[i], actual.Animation[i]);
     }
@@ -154,7 +154,7 @@ public static partial class DotTiledAssert
   private static void AssertFrame(Frame expected, Frame actual)
   {
     // Attributes
-    Assert.Equal(expected.TileID, actual.TileID);
+    AssertEqual(expected.TileID, actual.TileID, nameof(Frame.TileID));
-    Assert.Equal(expected.Duration, actual.Duration);
+    AssertEqual(expected.Duration, actual.Duration, nameof(Frame.Duration));
   }
 }

DotTiled.Tests/Serialization/TestData/Map/default-map/default-map.cs

@@ -36,58 +36,18 @@ public partial class TestData
           Chunks = null,
           Compression = null,
           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,
+            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,
+            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
           ]
         }
       }