diff --git a/DotTiled.Tests/TmxSerializer/TestData/Map/empty-map-base64-gzip.tmx b/DotTiled.Tests/TmxSerializer/TestData/Map/empty-map-base64-gzip.tmx new file mode 100644 index 0000000..d3e0f29 --- /dev/null +++ b/DotTiled.Tests/TmxSerializer/TestData/Map/empty-map-base64-gzip.tmx @@ -0,0 +1,8 @@ + + + + + H4sIAAAAAAAACmNgoD0AAMrGiJlkAAAA + + + diff --git a/DotTiled.Tests/TmxSerializer/TestData/Map/empty-map-base64-zlib.tmx b/DotTiled.Tests/TmxSerializer/TestData/Map/empty-map-base64-zlib.tmx new file mode 100644 index 0000000..d35b438 --- /dev/null +++ b/DotTiled.Tests/TmxSerializer/TestData/Map/empty-map-base64-zlib.tmx @@ -0,0 +1,8 @@ + + + + + eJxjYKA9AAAAZAAB + + + diff --git a/DotTiled.Tests/TmxSerializer/TestData/Map/empty-map-base64.tmx b/DotTiled.Tests/TmxSerializer/TestData/Map/empty-map-base64.tmx new file mode 100644 index 0000000..0e98f67 --- /dev/null +++ b/DotTiled.Tests/TmxSerializer/TestData/Map/empty-map-base64.tmx @@ -0,0 +1,8 @@ + + + + + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA== + + + diff --git a/DotTiled.Tests/TmxSerializer/TestData/Map/empty-map.tmx b/DotTiled.Tests/TmxSerializer/TestData/Map/empty-map-csv.tmx similarity index 100% rename from DotTiled.Tests/TmxSerializer/TestData/Map/empty-map.tmx rename to DotTiled.Tests/TmxSerializer/TestData/Map/empty-map-csv.tmx diff --git a/DotTiled.Tests/TmxSerializer/TestData/Map/empty-map-properties.cs b/DotTiled.Tests/TmxSerializer/TestData/Map/empty-map-properties.cs new file mode 100644 index 0000000..c87c183 --- /dev/null +++ b/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 + { + ["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" } + } + }; +} diff --git a/DotTiled.Tests/TmxSerializer/TestData/Map/empty-map-properties.tmx b/DotTiled.Tests/TmxSerializer/TestData/Map/empty-map-properties.tmx new file mode 100644 index 0000000..5a14d94 --- /dev/null +++ b/DotTiled.Tests/TmxSerializer/TestData/Map/empty-map-properties.tmx @@ -0,0 +1,21 @@ + + + + + + + + + + + + + +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 + + + diff --git a/DotTiled.Tests/TmxSerializer/TestData/Map/empty-map.cs b/DotTiled.Tests/TmxSerializer/TestData/Map/empty-map.cs index 077c573..e01516b 100644 --- a/DotTiled.Tests/TmxSerializer/TestData/Map/empty-map.cs +++ b/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, diff --git a/DotTiled.Tests/TmxSerializer/TestData/Map/simple-tileset-embed.cs b/DotTiled.Tests/TmxSerializer/TestData/Map/simple-tileset-embed.cs new file mode 100644 index 0000000..ad27d8e --- /dev/null +++ b/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 + ] + }, + } + ] + }; +} diff --git a/DotTiled.Tests/TmxSerializer/TestData/Map/simple-tileset-embed.tmx b/DotTiled.Tests/TmxSerializer/TestData/Map/simple-tileset-embed.tmx new file mode 100644 index 0000000..3d91b9d --- /dev/null +++ b/DotTiled.Tests/TmxSerializer/TestData/Map/simple-tileset-embed.tmx @@ -0,0 +1,15 @@ + + + + + + + +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 + + + diff --git a/DotTiled.Tests/TmxSerializer/TmxSerializer.DataTests.cs b/DotTiled.Tests/TmxSerializer/TmxSerializer.DataTests.cs new file mode 100644 index 0000000..e08d402 --- /dev/null +++ b/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); + } +} diff --git a/DotTiled.Tests/TmxSerializer/TmxSerializer.ImageTests.cs b/DotTiled.Tests/TmxSerializer/TmxSerializer.ImageTests.cs new file mode 100644 index 0000000..7d00713 --- /dev/null +++ b/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); + } +} diff --git a/DotTiled.Tests/TmxSerializer/TmxSerializer.LayerTests.cs b/DotTiled.Tests/TmxSerializer/TmxSerializer.LayerTests.cs new file mode 100644 index 0000000..5e36b95 --- /dev/null +++ b/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); + } +} diff --git a/DotTiled.Tests/TmxSerializer/TmxSerializer.MapTests.cs b/DotTiled.Tests/TmxSerializer/TmxSerializer.MapTests.cs index e875438..ec3f0e8 100644 --- a/DotTiled.Tests/TmxSerializer/TmxSerializer.MapTests.cs +++ b/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 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); diff --git a/DotTiled.Tests/TmxSerializer/TmxSerializer.ObjectTests.cs b/DotTiled.Tests/TmxSerializer/TmxSerializer.ObjectTests.cs new file mode 100644 index 0000000..c593074 --- /dev/null +++ b/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); + } +} diff --git a/DotTiled.Tests/TmxSerializer/TmxSerializer.PropertiesTests.cs b/DotTiled.Tests/TmxSerializer/TmxSerializer.PropertiesTests.cs new file mode 100644 index 0000000..e22e5b9 --- /dev/null +++ b/DotTiled.Tests/TmxSerializer/TmxSerializer.PropertiesTests.cs @@ -0,0 +1,69 @@ +namespace DotTiled.Tests; + +public partial class TmxSerializerPropertiesTests +{ + public static void AssertProperties(Dictionary? actual, Dictionary? 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); + } +} diff --git a/DotTiled.Tests/TmxSerializer/TmxSerializer.TilesetTests.cs b/DotTiled.Tests/TmxSerializer/TmxSerializer.TilesetTests.cs new file mode 100644 index 0000000..04bb54b --- /dev/null +++ b/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); + } +} diff --git a/DotTiled/Model/Layers/BaseLayer.cs b/DotTiled/Model/Layers/BaseLayer.cs index cf9c383..950a6f1 100644 --- a/DotTiled/Model/Layers/BaseLayer.cs +++ b/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? Properties { get; set; } } diff --git a/DotTiled/Model/Layers/Data.cs b/DotTiled/Model/Layers/Data.cs index 7fcb5d6..0785cec 100644 --- a/DotTiled/Model/Layers/Data.cs +++ b/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; } diff --git a/DotTiled/Model/Layers/TileLayer.cs b/DotTiled/Model/Layers/TileLayer.cs index fc771f4..de4b25d 100644 --- a/DotTiled/Model/Layers/TileLayer.cs +++ b/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; } } diff --git a/DotTiled/Model/Tileset/Tileset.cs b/DotTiled/Model/Tileset/Tileset.cs index a0196e9..ac1da0d 100644 --- a/DotTiled/Model/Tileset/Tileset.cs +++ b/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; }