From da5bf73ca02e402418ab5ff9631f6ec13fc1f04b Mon Sep 17 00:00:00 2001 From: Daniel Cronqvist Date: Mon, 12 Aug 2024 22:00:59 +0200 Subject: [PATCH] Make assertions tell you where they fail --- DotTiled.Tests/Assert/AssertData.cs | 22 ++--- DotTiled.Tests/Assert/AssertImage.cs | 10 +- DotTiled.Tests/Assert/AssertLayer.cs | 46 ++++----- DotTiled.Tests/Assert/AssertMap.cs | 67 ++++++++----- DotTiled.Tests/Assert/AssertObject.cs | 50 +++++----- DotTiled.Tests/Assert/AssertProperties.cs | 22 ++--- DotTiled.Tests/Assert/AssertTileset.cs | 94 +++++++++---------- .../TestData/Map/default-map/default-map.cs | 60 ++---------- 8 files changed, 178 insertions(+), 193 deletions(-) diff --git a/DotTiled.Tests/Assert/AssertData.cs b/DotTiled.Tests/Assert/AssertData.cs index d4b54f0..31ffff2 100644 --- a/DotTiled.Tests/Assert/AssertData.cs +++ b/DotTiled.Tests/Assert/AssertData.cs @@ -12,17 +12,17 @@ public static partial class DotTiledAssert // Attributes Assert.NotNull(actual); - Assert.Equal(expected.Encoding, actual.Encoding); - Assert.Equal(expected.Compression, actual.Compression); + AssertEqual(expected.Encoding, actual.Encoding, nameof(Data.Encoding)); + AssertEqual(expected.Compression, actual.Compression, nameof(Data.Compression)); // Data - Assert.Equal(expected.GlobalTileIDs, actual.GlobalTileIDs); - Assert.Equal(expected.FlippingFlags, actual.FlippingFlags); + AssertEqual(expected.GlobalTileIDs, actual.GlobalTileIDs, nameof(Data.GlobalTileIDs)); + 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); - Assert.Equal(expected.Y, actual.Y); - Assert.Equal(expected.Width, actual.Width); - Assert.Equal(expected.Height, actual.Height); + AssertEqual(expected.X, actual.X, nameof(Chunk.X)); + AssertEqual(expected.Y, actual.Y, nameof(Chunk.Y)); + AssertEqual(expected.Width, actual.Width, nameof(Chunk.Width)); + AssertEqual(expected.Height, actual.Height, nameof(Chunk.Height)); // Data - Assert.Equal(expected.GlobalTileIDs, actual.GlobalTileIDs); - Assert.Equal(expected.FlippingFlags, actual.FlippingFlags); + AssertEqual(expected.GlobalTileIDs, actual.GlobalTileIDs, nameof(Chunk.GlobalTileIDs)); + AssertEqual(expected.FlippingFlags, actual.FlippingFlags, nameof(Chunk.FlippingFlags)); } } diff --git a/DotTiled.Tests/Assert/AssertImage.cs b/DotTiled.Tests/Assert/AssertImage.cs index 9943c46..a674faa 100644 --- a/DotTiled.Tests/Assert/AssertImage.cs +++ b/DotTiled.Tests/Assert/AssertImage.cs @@ -12,10 +12,10 @@ public static partial class DotTiledAssert // 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); + AssertEqual(expected.Format, actual.Format, nameof(Image.Format)); + AssertEqual(expected.Source, actual.Source, nameof(Image.Source)); + AssertEqual(expected.TransparentColor, actual.TransparentColor, nameof(Image.TransparentColor)); + AssertEqual(expected.Width, actual.Width, nameof(Image.Width)); + AssertEqual(expected.Height, actual.Height, nameof(Image.Height)); } } diff --git a/DotTiled.Tests/Assert/AssertLayer.cs b/DotTiled.Tests/Assert/AssertLayer.cs index 57df04d..5432d62 100644 --- a/DotTiled.Tests/Assert/AssertLayer.cs +++ b/DotTiled.Tests/Assert/AssertLayer.cs @@ -12,16 +12,16 @@ public static partial class DotTiledAssert // 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.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); + AssertEqual(expected.ID, actual.ID, nameof(BaseLayer.ID)); + AssertEqual(expected.Name, actual.Name, nameof(BaseLayer.Name)); + AssertEqual(expected.Class, actual.Class, nameof(BaseLayer.Class)); + AssertEqual(expected.Opacity, actual.Opacity, nameof(BaseLayer.Opacity)); + AssertEqual(expected.Visible, actual.Visible, nameof(BaseLayer.Visible)); + AssertEqual(expected.TintColor, actual.TintColor, nameof(BaseLayer.TintColor)); + AssertEqual(expected.OffsetX, actual.OffsetX, nameof(BaseLayer.OffsetX)); + AssertEqual(expected.OffsetY, actual.OffsetY, nameof(BaseLayer.OffsetY)); + AssertEqual(expected.ParallaxX, actual.ParallaxX, nameof(BaseLayer.ParallaxX)); + 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); - Assert.Equal(expected.Height, actual.Height); - Assert.Equal(expected.X, actual.X); - Assert.Equal(expected.Y, actual.Y); + AssertEqual(expected.Width, actual.Width, nameof(TileLayer.Width)); + AssertEqual(expected.Height, actual.Height, nameof(TileLayer.Height)); + AssertEqual(expected.X, actual.X, nameof(TileLayer.X)); + 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); - Assert.Equal(expected.X, actual.X); - Assert.Equal(expected.Y, actual.Y); + AssertEqual(expected.DrawOrder, actual.DrawOrder, nameof(ObjectLayer.DrawOrder)); + AssertEqual(expected.X, actual.X, nameof(ObjectLayer.X)); + 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); - Assert.Equal(expected.RepeatY, actual.RepeatY); - Assert.Equal(expected.X, actual.X); - Assert.Equal(expected.Y, actual.Y); + AssertEqual(expected.RepeatX, actual.RepeatX, nameof(ImageLayer.RepeatX)); + AssertEqual(expected.RepeatY, actual.RepeatY, nameof(ImageLayer.RepeatY)); + AssertEqual(expected.X, actual.X, nameof(ImageLayer.X)); + 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]); } diff --git a/DotTiled.Tests/Assert/AssertMap.cs b/DotTiled.Tests/Assert/AssertMap.cs index e831063..6596ee8 100644 --- a/DotTiled.Tests/Assert/AssertMap.cs +++ b/DotTiled.Tests/Assert/AssertMap.cs @@ -2,38 +2,63 @@ namespace DotTiled.Tests; public static partial class DotTiledAssert { + private static void AssertEqual(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); - Assert.Equal(expected.TiledVersion, actual.TiledVersion); - Assert.Equal(expected.Class, actual.Class); - Assert.Equal(expected.Orientation, actual.Orientation); - Assert.Equal(expected.RenderOrder, actual.RenderOrder); - Assert.Equal(expected.CompressionLevel, actual.CompressionLevel); - Assert.Equal(expected.Width, actual.Width); - Assert.Equal(expected.Height, actual.Height); - Assert.Equal(expected.TileWidth, actual.TileWidth); - Assert.Equal(expected.TileHeight, actual.TileHeight); - Assert.Equal(expected.HexSideLength, actual.HexSideLength); - Assert.Equal(expected.StaggerAxis, actual.StaggerAxis); - Assert.Equal(expected.StaggerIndex, actual.StaggerIndex); - Assert.Equal(expected.ParallaxOriginX, actual.ParallaxOriginX); - Assert.Equal(expected.ParallaxOriginY, actual.ParallaxOriginY); - Assert.Equal(expected.BackgroundColor, actual.BackgroundColor); - Assert.Equal(expected.NextLayerID, actual.NextLayerID); - Assert.Equal(expected.NextObjectID, actual.NextObjectID); - Assert.Equal(expected.Infinite, actual.Infinite); + AssertEqual(expected.Version, actual.Version, nameof(Map.Version)); + AssertEqual(expected.TiledVersion, actual.TiledVersion, nameof(Map.TiledVersion)); + AssertEqual(expected.Class, actual.Class, nameof(Map.Class)); + AssertEqual(expected.Orientation, actual.Orientation, nameof(Map.Orientation)); + AssertEqual(expected.RenderOrder, actual.RenderOrder, nameof(Map.RenderOrder)); + AssertEqual(expected.CompressionLevel, actual.CompressionLevel, nameof(Map.CompressionLevel)); + AssertEqual(expected.Width, actual.Width, nameof(Map.Width)); + AssertEqual(expected.Height, actual.Height, nameof(Map.Height)); + AssertEqual(expected.TileWidth, actual.TileWidth, nameof(Map.TileWidth)); + AssertEqual(expected.TileHeight, actual.TileHeight, nameof(Map.TileHeight)); + AssertEqual(expected.HexSideLength, actual.HexSideLength, nameof(Map.HexSideLength)); + AssertEqual(expected.StaggerAxis, actual.StaggerAxis, nameof(Map.StaggerAxis)); + AssertEqual(expected.StaggerIndex, actual.StaggerIndex, nameof(Map.StaggerIndex)); + AssertEqual(expected.ParallaxOriginX, actual.ParallaxOriginX, nameof(Map.ParallaxOriginX)); + AssertEqual(expected.ParallaxOriginY, actual.ParallaxOriginY, nameof(Map.ParallaxOriginY)); + AssertEqual(expected.BackgroundColor, actual.BackgroundColor, nameof(Map.BackgroundColor)); + AssertEqual(expected.NextLayerID, actual.NextLayerID, nameof(Map.NextLayerID)); + AssertEqual(expected.NextObjectID, actual.NextObjectID, nameof(Map.NextObjectID)); + 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]); } diff --git a/DotTiled.Tests/Assert/AssertObject.cs b/DotTiled.Tests/Assert/AssertObject.cs index 3b08744..c49b6e7 100644 --- a/DotTiled.Tests/Assert/AssertObject.cs +++ b/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); - 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); + AssertEqual(expected.ID, actual.ID, nameof(Object.ID)); + AssertEqual(expected.Name, actual.Name, nameof(Object.Name)); + AssertEqual(expected.Type, actual.Type, nameof(Object.Type)); + AssertEqual(expected.X, actual.X, nameof(Object.X)); + AssertEqual(expected.Y, actual.Y, nameof(Object.Y)); + AssertEqual(expected.Width, actual.Width, nameof(Object.Width)); + AssertEqual(expected.Height, actual.Height, nameof(Object.Height)); + AssertEqual(expected.Rotation, actual.Rotation, nameof(Object.Rotation)); + AssertEqual(expected.GID, actual.GID, nameof(Object.GID)); + AssertEqual(expected.Visible, actual.Visible, nameof(Object.Visible)); + 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); - 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); + AssertEqual(expected.FontFamily, actual.FontFamily, nameof(TextObject.FontFamily)); + AssertEqual(expected.PixelSize, actual.PixelSize, nameof(TextObject.PixelSize)); + AssertEqual(expected.Wrap, actual.Wrap, nameof(TextObject.Wrap)); + AssertEqual(expected.Color, actual.Color, nameof(TextObject.Color)); + AssertEqual(expected.Bold, actual.Bold, nameof(TextObject.Bold)); + AssertEqual(expected.Italic, actual.Italic, nameof(TextObject.Italic)); + AssertEqual(expected.Underline, actual.Underline, nameof(TextObject.Underline)); + AssertEqual(expected.Strikeout, actual.Strikeout, nameof(TextObject.Strikeout)); + AssertEqual(expected.Kerning, actual.Kerning, nameof(TextObject.Kerning)); + AssertEqual(expected.HorizontalAlignment, actual.HorizontalAlignment, nameof(TextObject.HorizontalAlignment)); + AssertEqual(expected.VerticalAlignment, actual.VerticalAlignment, nameof(TextObject.VerticalAlignment)); - Assert.Equal(expected.Text, actual.Text); + AssertEqual(expected.Text, actual.Text, nameof(TextObject.Text)); } } diff --git a/DotTiled.Tests/Assert/AssertProperties.cs b/DotTiled.Tests/Assert/AssertProperties.cs index afd28c2..740ba2b 100644 --- a/DotTiled.Tests/Assert/AssertProperties.cs +++ b/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); - Assert.Equal(expected.Name, actual.Name); + AssertEqual(expected.Type, actual.Type, "Property.Type"); + 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); } } diff --git a/DotTiled.Tests/Assert/AssertTileset.cs b/DotTiled.Tests/Assert/AssertTileset.cs index 8421bd0..e6b39bb 100644 --- a/DotTiled.Tests/Assert/AssertTileset.cs +++ b/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); - 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); + AssertEqual(expected.Version, actual.Version, nameof(Tileset.Version)); + AssertEqual(expected.TiledVersion, actual.TiledVersion, nameof(Tileset.TiledVersion)); + AssertEqual(expected.FirstGID, actual.FirstGID, nameof(Tileset.FirstGID)); + AssertEqual(expected.Source, actual.Source, nameof(Tileset.Source)); + AssertEqual(expected.Name, actual.Name, nameof(Tileset.Name)); + AssertEqual(expected.Class, actual.Class, nameof(Tileset.Class)); + AssertEqual(expected.TileWidth, actual.TileWidth, nameof(Tileset.TileWidth)); + AssertEqual(expected.TileHeight, actual.TileHeight, nameof(Tileset.TileHeight)); + AssertEqual(expected.Spacing, actual.Spacing, nameof(Tileset.Spacing)); + AssertEqual(expected.Margin, actual.Margin, nameof(Tileset.Margin)); + AssertEqual(expected.TileCount, actual.TileCount, nameof(Tileset.TileCount)); + AssertEqual(expected.Columns, actual.Columns, nameof(Tileset.Columns)); + AssertEqual(expected.ObjectAlignment, actual.ObjectAlignment, nameof(Tileset.ObjectAlignment)); + AssertEqual(expected.RenderSize, actual.RenderSize, nameof(Tileset.RenderSize)); + 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); - Assert.Equal(expected.Y, actual.Y); + AssertEqual(expected.X, actual.X, nameof(TileOffset.X)); + 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); - Assert.Equal(expected.Width, actual.Width); - Assert.Equal(expected.Height, actual.Height); + AssertEqual(expected.Orientation, actual.Orientation, nameof(Grid.Orientation)); + AssertEqual(expected.Width, actual.Width, nameof(Grid.Width)); + AssertEqual(expected.Height, actual.Height, nameof(Grid.Height)); } private static void AssertWangset(Wangset expected, Wangset actual) { // Attributes - Assert.Equal(expected.Name, actual.Name); - Assert.Equal(expected.Class, actual.Class); - Assert.Equal(expected.Tile, actual.Tile); + AssertEqual(expected.Name, actual.Name, nameof(Wangset.Name)); + AssertEqual(expected.Class, actual.Class, nameof(Wangset.Class)); + 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); - Assert.Equal(expected.Class, actual.Class); - Assert.Equal(expected.Color, actual.Color); - Assert.Equal(expected.Tile, actual.Tile); - Assert.Equal(expected.Probability, actual.Probability); + AssertEqual(expected.Name, actual.Name, nameof(WangColor.Name)); + AssertEqual(expected.Class, actual.Class, nameof(WangColor.Class)); + AssertEqual(expected.Color, actual.Color, nameof(WangColor.Color)); + AssertEqual(expected.Tile, actual.Tile, nameof(WangColor.Tile)); + 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); - Assert.Equal(expected.WangID, actual.WangID); + AssertEqual(expected.TileID, actual.TileID, nameof(WangTile.TileID)); + 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); - Assert.Equal(expected.VFlip, actual.VFlip); - Assert.Equal(expected.Rotate, actual.Rotate); - Assert.Equal(expected.PreferUntransformed, actual.PreferUntransformed); + AssertEqual(expected.HFlip, actual.HFlip, nameof(Transformations.HFlip)); + AssertEqual(expected.VFlip, actual.VFlip, nameof(Transformations.VFlip)); + AssertEqual(expected.Rotate, actual.Rotate, nameof(Transformations.Rotate)); + AssertEqual(expected.PreferUntransformed, actual.PreferUntransformed, nameof(Transformations.PreferUntransformed)); } private static void AssertTile(Tile expected, Tile actual) { // 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); + AssertEqual(expected.ID, actual.ID, nameof(Tile.ID)); + AssertEqual(expected.Type, actual.Type, nameof(Tile.Type)); + AssertEqual(expected.Probability, actual.Probability, nameof(Tile.Probability)); + AssertEqual(expected.X, actual.X, nameof(Tile.X)); + AssertEqual(expected.Y, actual.Y, nameof(Tile.Y)); + AssertEqual(expected.Width, actual.Width, nameof(Tile.Width)); + 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); - Assert.Equal(expected.Duration, actual.Duration); + AssertEqual(expected.TileID, actual.TileID, nameof(Frame.TileID)); + AssertEqual(expected.Duration, actual.Duration, nameof(Frame.Duration)); } } diff --git a/DotTiled.Tests/Serialization/TestData/Map/default-map/default-map.cs b/DotTiled.Tests/Serialization/TestData/Map/default-map/default-map.cs index 44c909e..eff73d9 100644 --- a/DotTiled.Tests/Serialization/TestData/Map/default-map/default-map.cs +++ b/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 ] } }