mirror of
https://github.com/dcronqvist/DotTiled.git
synced 2025-02-05 08:52:50 +02:00
Make assertions tell you where they fail
This commit is contained in:
Daniel Cronqvist
parent
4aebf1d67b
commit
da5bf73ca0
8 changed files with 178 additions and 193 deletions
|
|
@ -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));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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]);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
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]);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
]
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue