No more TmxSerializer, now different readers for each file format

DotTiled.Tests/Assert/AssertData.cs

@@ -1,8 +1,8 @@
 namespace DotTiled.Tests;
 
-public partial class TmxSerializerDataTests
+public static partial class DotTiledAssert
 {
-  public static void AssertData(Data? actual, Data? expected)
+  internal static void AssertData(Data? expected, Data? actual)
   {
     if (expected is null)
     {
@@ -24,11 +24,11 @@ public partial class TmxSerializerDataTests
       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]);
+        AssertChunk(expected.Chunks[i], actual.Chunks[i]);
     }
   }
 
-  private static void AssertChunk(Chunk actual, Chunk expected)
+  private static void AssertChunk(Chunk expected, Chunk actual)
   {
     // Attributes
     Assert.Equal(expected.X, actual.X);

DotTiled.Tests/Assert/AssertImage.cs

@@ -1,8 +1,8 @@
 namespace DotTiled.Tests;
 
-public partial class TmxSerializerImageTests
+public static partial class DotTiledAssert
 {
-  public static void AssertImage(Image? actual, Image? expected)
+  internal static void AssertImage(Image? expected, Image? actual)
   {
     if (expected is null)
     {

DotTiled.Tests/Assert/AssertLayer.cs

@@ -1,8 +1,8 @@
 namespace DotTiled.Tests;
 
-public partial class TmxSerializerLayerTests
+public static partial class DotTiledAssert
 {
-  public static void AssertLayer(BaseLayer? actual, BaseLayer? expected)
+  internal static void AssertLayer(BaseLayer? expected, BaseLayer? actual)
   {
     if (expected is null)
     {
@@ -23,11 +23,11 @@ public partial class TmxSerializerLayerTests
     Assert.Equal(expected.ParallaxX, actual.ParallaxX);
     Assert.Equal(expected.ParallaxY, actual.ParallaxY);
 
-    TmxSerializerPropertiesTests.AssertProperties(actual.Properties, expected.Properties);
-    AssertLayer((dynamic)actual, (dynamic)expected);
+    AssertProperties(expected.Properties, actual.Properties);
+    AssertLayer((dynamic)expected, (dynamic)actual);
   }
 
-  private static void AssertLayer(TileLayer actual, TileLayer expected)
+  private static void AssertLayer(TileLayer expected, TileLayer actual)
   {
     // Attributes
     Assert.Equal(expected.Width, actual.Width);
@@ -36,10 +36,10 @@ public partial class TmxSerializerLayerTests
     Assert.Equal(expected.Y, actual.Y);
 
     Assert.NotNull(actual.Data);
-    TmxSerializerDataTests.AssertData(actual.Data, expected.Data);
+    AssertData(expected.Data, actual.Data);
   }
 
-  private static void AssertLayer(ObjectLayer actual, ObjectLayer expected)
+  private static void AssertLayer(ObjectLayer expected, ObjectLayer actual)
   {
     // Attributes
     Assert.Equal(expected.DrawOrder, actual.DrawOrder);
@@ -49,10 +49,10 @@ public partial class TmxSerializerLayerTests
     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]);
+      AssertObject(expected.Objects[i], actual.Objects[i]);
   }
 
-  private static void AssertLayer(ImageLayer actual, ImageLayer expected)
+  private static void AssertLayer(ImageLayer expected, ImageLayer actual)
   {
     // Attributes
     Assert.Equal(expected.RepeatX, actual.RepeatX);
@@ -61,15 +61,15 @@ public partial class TmxSerializerLayerTests
     Assert.Equal(expected.Y, actual.Y);
 
     Assert.NotNull(actual.Image);
-    TmxSerializerImageTests.AssertImage(actual.Image, expected.Image);
+    AssertImage(expected.Image, actual.Image);
   }
 
-  private static void AssertLayer(Group actual, Group expected)
+  private static void AssertLayer(Group expected, Group actual)
   {
     // Attributes
     Assert.NotNull(actual.Layers);
     Assert.Equal(expected.Layers.Count, actual.Layers.Count);
     for (var i = 0; i < expected.Layers.Count; i++)
-      AssertLayer(actual.Layers[i], expected.Layers[i]);
+      AssertLayer(expected.Layers[i], actual.Layers[i]);
   }
 }

DotTiled.Tests/Assert/AssertMap.cs

@@ -0,0 +1,40 @@
+namespace DotTiled.Tests;
+
+public static partial class DotTiledAssert
+{
+  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);
+
+    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++)
+      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++)
+      AssertLayer(actual.Layers[i], expected.Layers[i]);
+  }
+}

DotTiled.Tests/Assert/AssertObject.cs

@@ -1,8 +1,8 @@
 namespace DotTiled.Tests;
 
-public partial class TmxSerializerObjectTests
+public static partial class DotTiledAssert
 {
-  public static void AssertObject(Object actual, Object expected)
+  internal static void AssertObject(Object expected, Object actual)
   {
     // Attributes
     Assert.Equal(expected.ID, actual.ID);
@@ -17,36 +17,36 @@ public partial class TmxSerializerObjectTests
     Assert.Equal(expected.Visible, actual.Visible);
     Assert.Equal(expected.Template, actual.Template);
 
-    TmxSerializerPropertiesTests.AssertProperties(actual.Properties, expected.Properties);
-    AssertObject((dynamic)actual, (dynamic)expected);
+    AssertProperties(actual.Properties, expected.Properties);
+    AssertObject((dynamic)expected, (dynamic)actual);
   }
 
-  private static void AssertObject(RectangleObject actual, RectangleObject expected)
+  private static void AssertObject(RectangleObject expected, RectangleObject actual)
   {
     Assert.True(true); // A rectangle object is the same as the abstract Object
   }
 
-  private static void AssertObject(EllipseObject actual, EllipseObject expected)
+  private static void AssertObject(EllipseObject expected, EllipseObject actual)
   {
     Assert.True(true); // An ellipse object is the same as the abstract Object
   }
 
-  private static void AssertObject(PointObject actual, PointObject expected)
+  private static void AssertObject(PointObject expected, PointObject actual)
   {
     Assert.True(true); // A point object is the same as the abstract Object
   }
 
-  private static void AssertObject(PolygonObject actual, PolygonObject expected)
+  private static void AssertObject(PolygonObject expected, PolygonObject actual)
   {
     Assert.Equal(expected.Points, actual.Points);
   }
 
-  private static void AssertObject(PolylineObject actual, PolylineObject expected)
+  private static void AssertObject(PolylineObject expected, PolylineObject actual)
   {
     Assert.Equal(expected.Points, actual.Points);
   }
 
-  private static void AssertObject(TextObject actual, TextObject expected)
+  private static void AssertObject(TextObject expected, TextObject actual)
   {
     // Attributes
     Assert.Equal(expected.FontFamily, actual.FontFamily);

DotTiled.Tests/Assert/AssertProperties.cs

@@ -1,8 +1,8 @@
 namespace DotTiled.Tests;
 
-public partial class TmxSerializerPropertiesTests
+public static partial class DotTiledAssert
 {
-  public static void AssertProperties(Dictionary<string, IProperty>? actual, Dictionary<string, IProperty>? expected)
+  internal static void AssertProperties(Dictionary<string, IProperty>? expected, Dictionary<string, IProperty>? actual)
   {
     if (expected is null)
     {

DotTiled.Tests/Assert/AssertTileset.cs

@@ -1,8 +1,8 @@
 namespace DotTiled.Tests;
 
-public partial class TmxSerializerTilesetTests
+public static partial class DotTiledAssert
 {
-  public static void AssertTileset(Tileset actual, Tileset expected)
+  internal static void AssertTileset(Tileset expected, Tileset actual)
   {
     // Attributes
     Assert.Equal(expected.Version, actual.Version);
@@ -22,28 +22,28 @@ public partial class TmxSerializerTilesetTests
     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);
+    AssertImage(expected.Image, actual.Image);
+    AssertTileOffset(expected.TileOffset, actual.TileOffset);
+    AssertGrid(expected.Grid, actual.Grid);
+    AssertProperties(expected.Properties, actual.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]);
+        AssertWangset(expected.Wangsets[i], actual.Wangsets[i]);
     }
-    AssertTransformations(actual.Transformations, expected.Transformations);
+    AssertTransformations(expected.Transformations, actual.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]);
+      AssertTile(expected.Tiles[i], actual.Tiles[i]);
   }
 
-  private static void AssertTileOffset(TileOffset? actual, TileOffset? expected)
+  private static void AssertTileOffset(TileOffset? expected, TileOffset? actual)
   {
     if (expected is null)
     {
@@ -57,7 +57,7 @@ public partial class TmxSerializerTilesetTests
     Assert.Equal(expected.Y, actual.Y);
   }
 
-  private static void AssertGrid(Grid? actual, Grid? expected)
+  private static void AssertGrid(Grid? expected, Grid? actual)
   {
     if (expected is null)
     {
@@ -72,7 +72,7 @@ public partial class TmxSerializerTilesetTests
     Assert.Equal(expected.Height, actual.Height);
   }
 
-  private static void AssertWangset(Wangset actual, Wangset expected)
+  private static void AssertWangset(Wangset expected, Wangset actual)
   {
     // Attributes
     Assert.Equal(expected.Name, actual.Name);
@@ -80,19 +80,19 @@ public partial class TmxSerializerTilesetTests
     Assert.Equal(expected.Tile, actual.Tile);
 
     // At most one of
-    TmxSerializerPropertiesTests.AssertProperties(actual.Properties, expected.Properties);
+    AssertProperties(expected.Properties, actual.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]);
+        AssertWangColor(expected.WangColors[i], actual.WangColors[i]);
     }
     for (var i = 0; i < expected.WangTiles.Count; i++)
-      AssertWangTile(actual.WangTiles[i], expected.WangTiles[i]);
+      AssertWangTile(expected.WangTiles[i], actual.WangTiles[i]);
   }
 
-  private static void AssertWangColor(WangColor actual, WangColor expected)
+  private static void AssertWangColor(WangColor expected, WangColor actual)
   {
     // Attributes
     Assert.Equal(expected.Name, actual.Name);
@@ -101,17 +101,17 @@ public partial class TmxSerializerTilesetTests
     Assert.Equal(expected.Tile, actual.Tile);
     Assert.Equal(expected.Probability, actual.Probability);
 
-    TmxSerializerPropertiesTests.AssertProperties(actual.Properties, expected.Properties);
+    AssertProperties(expected.Properties, actual.Properties);
   }
 
-  private static void AssertWangTile(WangTile actual, WangTile expected)
+  private static void AssertWangTile(WangTile expected, WangTile actual)
   {
     // Attributes
     Assert.Equal(expected.TileID, actual.TileID);
     Assert.Equal(expected.WangID, actual.WangID);
   }
 
-  private static void AssertTransformations(Transformations? actual, Transformations? expected)
+  private static void AssertTransformations(Transformations? expected, Transformations? actual)
   {
     if (expected is null)
     {
@@ -127,7 +127,7 @@ public partial class TmxSerializerTilesetTests
     Assert.Equal(expected.PreferUntransformed, actual.PreferUntransformed);
   }
 
-  private static void AssertTile(Tile actual, Tile expected)
+  private static void AssertTile(Tile expected, Tile actual)
   {
     // Attributes
     Assert.Equal(expected.ID, actual.ID);
@@ -139,19 +139,19 @@ public partial class TmxSerializerTilesetTests
     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);
+    AssertProperties(actual.Properties, expected.Properties);
+    AssertImage(actual.Image, expected.Image);
+    AssertLayer((BaseLayer?)actual.ObjectLayer, (BaseLayer?)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]);
+        AssertFrame(expected.Animation[i], actual.Animation[i]);
     }
   }
 
-  private static void AssertFrame(Frame actual, Frame expected)
+  private static void AssertFrame(Frame expected, Frame actual)
   {
     // Attributes
     Assert.Equal(expected.TileID, actual.TileID);

DotTiled.Tests/DotTiled.Tests.csproj

@@ -26,7 +26,7 @@
 
   <ItemGroup>
     <!-- TmxSerializer test data -->
-    <EmbeddedResource Include="TmxSerializer/TestData/**/*" />
+    <EmbeddedResource Include="Serialization/Tmx/TestData/**/*" />
   </ItemGroup>
 
 </Project>

DotTiled.Tests/Serialization/Tmx/TestData/Map/empty-map-properties.cs

@@ -1,6 +1,6 @@
 namespace DotTiled.Tests;
 
-public partial class TmxSerializerMapTests
+public partial class TmxMapReaderTests
 {
   private static Map EmptyMapWithProperties() => new Map
   {

DotTiled.Tests/Serialization/Tmx/TestData/Map/empty-map.cs

@@ -1,6 +1,6 @@
 namespace DotTiled.Tests;
 
-public partial class TmxSerializerMapTests
+public partial class TmxMapReaderTests
 {
   private static Map EmptyMapWithEncodingAndCompression(DataEncoding dataEncoding, DataCompression? compression) => new Map
   {

DotTiled.Tests/Serialization/Tmx/TestData/Map/map-with-group.cs

@@ -1,6 +1,6 @@
 namespace DotTiled.Tests;
 
-public partial class TmxSerializerMapTests
+public partial class TmxMapReaderTests
 {
   private static Map MapWithGroup() => new Map
   {

DotTiled.Tests/Serialization/Tmx/TestData/Map/map-with-object-template.cs

@@ -1,6 +1,6 @@
 namespace DotTiled.Tests;
 
-public partial class TmxSerializerMapTests
+public partial class TmxMapReaderTests
 {
   private static Map MapWithObjectTemplate() => new Map
   {

DotTiled.Tests/Serialization/Tmx/TestData/Map/simple-tileset-embed.cs

@@ -1,6 +1,6 @@
 namespace DotTiled.Tests;
 
-public partial class TmxSerializerMapTests
+public partial class TmxMapReaderTests
 {
   private static Map SimpleMapWithEmbeddedTileset() => new Map
   {

DotTiled.Tests/Serialization/Tmx/TestData/TestData.cs

@@ -2,12 +2,12 @@ using System.Xml;
 
 namespace DotTiled.Tests;
 
-public static class TmxSerializerTestData
+public static class TmxMapReaderTestData
 {
-  public static XmlReader GetReaderFor(string testDataFile)
+  public static XmlReader GetXmlReaderFor(string testDataFile)
   {
     var fullyQualifiedTestDataFile = $"DotTiled.Tests.{testDataFile}";
-    using var stream = typeof(TmxSerializerTestData).Assembly.GetManifestResourceStream(fullyQualifiedTestDataFile)
+    using var stream = typeof(TmxMapReaderTestData).Assembly.GetManifestResourceStream(fullyQualifiedTestDataFile)
                        ?? throw new ArgumentException($"Test data file '{fullyQualifiedTestDataFile}' not found");
 
     using var stringReader = new StreamReader(stream);
@@ -19,7 +19,7 @@ public static class TmxSerializerTestData
   public static string GetRawStringFor(string testDataFile)
   {
     var fullyQualifiedTestDataFile = $"DotTiled.Tests.{testDataFile}";
-    using var stream = typeof(TmxSerializerTestData).Assembly.GetManifestResourceStream(fullyQualifiedTestDataFile)
+    using var stream = typeof(TmxMapReaderTestData).Assembly.GetManifestResourceStream(fullyQualifiedTestDataFile)
                        ?? throw new ArgumentException($"Test data file '{fullyQualifiedTestDataFile}' not found");
 
     using var stringReader = new StreamReader(stream);

DotTiled.Tests/Serialization/Tmx/TmxMapReaderTests.cs

@@ -0,0 +1,150 @@
+using System.Xml;
+
+namespace DotTiled.Tests;
+
+public partial class TmxMapReaderTests
+{
+  [Fact]
+  public void TmxMapReaderConstructor_XmlReaderIsNull_ThrowsArgumentNullException()
+  {
+    // Arrange
+    XmlReader xmlReader = null!;
+    Func<string, Tileset> externalTilesetResolver = (_) => new Tileset();
+    Func<string, Template> externalTemplateResolver = (_) => new Template { Object = new RectangleObject { } };
+
+    // Act
+    Action act = () =>
+    {
+      using var _ = new TmxMapReader(xmlReader, externalTilesetResolver, externalTemplateResolver);
+    };
+
+    // Assert
+    Assert.Throws<ArgumentNullException>(act);
+  }
+
+  [Fact]
+  public void TmxMapReaderConstructor_ExternalTilesetResolverIsNull_ThrowsArgumentNullException()
+  {
+    // Arrange
+    using var stringReader = new StringReader("<map></map>");
+    using var xmlReader = XmlReader.Create(stringReader);
+    Func<string, Tileset> externalTilesetResolver = null!;
+    Func<string, Template> externalTemplateResolver = (_) => new Template { Object = new RectangleObject { } };
+
+    // Act
+    Action act = () =>
+    {
+      using var _ = new TmxMapReader(xmlReader, externalTilesetResolver, externalTemplateResolver);
+    };
+
+    // Assert
+    Assert.Throws<ArgumentNullException>(act);
+  }
+
+  [Fact]
+  public void TmxMapReaderConstructor_ExternalTemplateResolverIsNull_ThrowsArgumentNullException()
+  {
+    // Arrange
+    using var stringReader = new StringReader("<map></map>");
+    using var xmlReader = XmlReader.Create(stringReader);
+    Func<string, Tileset> externalTilesetResolver = (_) => new Tileset();
+    Func<string, Template> externalTemplateResolver = null!;
+
+    // Act
+    Action act = () =>
+    {
+      using var _ = new TmxMapReader(xmlReader, externalTilesetResolver, externalTemplateResolver);
+    };
+
+    // Assert
+    Assert.Throws<ArgumentNullException>(act);
+  }
+
+  [Fact]
+  public void TmxMapReaderConstructor_NoneNull_DoesNotThrow()
+  {
+    // Arrange
+    using var stringReader = new StringReader("<map></map>");
+    using var xmlReader = XmlReader.Create(stringReader);
+    Func<string, Tileset> externalTilesetResolver = (_) => new Tileset();
+    Func<string, Template> externalTemplateResolver = (_) => new Template { Object = new RectangleObject { } };
+
+    // Act
+    using var tmxMapReader = new TmxMapReader(xmlReader, externalTilesetResolver, externalTemplateResolver);
+
+    // Assert
+    Assert.NotNull(tmxMapReader);
+  }
+
+  public static IEnumerable<object[]> DeserializeMap_ValidXmlNoExternalTilesets_ReturnsMapWithoutThrowing_Data =>
+  [
+    ["Serialization.Tmx.TestData.Map.empty-map-csv.tmx", EmptyMapWithEncodingAndCompression(DataEncoding.Csv, null)],
+    ["Serialization.Tmx.TestData.Map.empty-map-base64.tmx", EmptyMapWithEncodingAndCompression(DataEncoding.Base64, null)],
+    ["Serialization.Tmx.TestData.Map.empty-map-base64-gzip.tmx", EmptyMapWithEncodingAndCompression(DataEncoding.Base64, DataCompression.GZip)],
+    ["Serialization.Tmx.TestData.Map.empty-map-base64-zlib.tmx", EmptyMapWithEncodingAndCompression(DataEncoding.Base64, DataCompression.ZLib)],
+    ["Serialization.Tmx.TestData.Map.simple-tileset-embed.tmx", SimpleMapWithEmbeddedTileset()],
+    ["Serialization.Tmx.TestData.Map.empty-map-properties.tmx", EmptyMapWithProperties()],
+  ];
+
+  [Theory]
+  [MemberData(nameof(DeserializeMap_ValidXmlNoExternalTilesets_ReturnsMapWithoutThrowing_Data))]
+  public void TmxMapReaderReadMap_ValidXmlNoExternalTilesets_ReturnsMapThatEqualsExpected(string testDataFile, Map expectedMap)
+  {
+    // Arrange
+    using var reader = TmxMapReaderTestData.GetXmlReaderFor(testDataFile);
+    static Template ResolveTemplate(string source)
+    {
+      using var xmlTemplateReader = TmxMapReaderTestData.GetXmlReaderFor($"Serialization.Tmx.TestData.Template.{source}");
+      using var templateReader = new TxTemplateReader(xmlTemplateReader, ResolveTileset, ResolveTemplate);
+      return templateReader.ReadTemplate();
+    }
+    static Tileset ResolveTileset(string source)
+    {
+      using var xmlTilesetReader = TmxMapReaderTestData.GetXmlReaderFor($"Serialization.Tmx.TestData.Tileset.{source}");
+      using var tilesetReader = new TsxTilesetReader(xmlTilesetReader, ResolveTemplate);
+      return tilesetReader.ReadTileset();
+    }
+    using var mapReader = new TmxMapReader(reader, ResolveTileset, ResolveTemplate);
+
+    // Act
+    var map = mapReader.ReadMap();
+
+    // Assert
+    Assert.NotNull(map);
+    DotTiledAssert.AssertMap(expectedMap, map);
+  }
+
+  public static IEnumerable<object[]> DeserializeMap_ValidXmlExternalTilesetsAndTemplates_ReturnsMapThatEqualsExpected_Data =>
+  [
+    ["Serialization.Tmx.TestData.Map.map-with-object-template.tmx", MapWithObjectTemplate()],
+    ["Serialization.Tmx.TestData.Map.map-with-group.tmx", MapWithGroup()],
+  ];
+
+  [Theory]
+  [MemberData(nameof(DeserializeMap_ValidXmlExternalTilesetsAndTemplates_ReturnsMapThatEqualsExpected_Data))]
+  public void TmxMapReaderReadMap_ValidXmlExternalTilesetsAndTemplates_ReturnsMapThatEqualsExpected(string testDataFile, Map expectedMap)
+  {
+    // Arrange
+    using var reader = TmxMapReaderTestData.GetXmlReaderFor(testDataFile);
+    static Template ResolveTemplate(string source)
+    {
+      using var xmlTemplateReader = TmxMapReaderTestData.GetXmlReaderFor($"Serialization.Tmx.TestData.Template.{source}");
+      using var templateReader = new TxTemplateReader(xmlTemplateReader, ResolveTileset, ResolveTemplate);
+      return templateReader.ReadTemplate();
+    }
+    static Tileset ResolveTileset(string source)
+    {
+      using var xmlTilesetReader = TmxMapReaderTestData.GetXmlReaderFor($"Serialization.Tmx.TestData.Tileset.{source}");
+      using var tilesetReader = new TsxTilesetReader(xmlTilesetReader, ResolveTemplate);
+      return tilesetReader.ReadTileset();
+    }
+    using var mapReader = new TmxMapReader(reader, ResolveTileset, ResolveTemplate);
+
+    // Act
+    var map = mapReader.ReadMap();
+
+    // Assert
+    Assert.NotNull(map);
+    DotTiledAssert.AssertMap(expectedMap, map);
+  }
+}

DotTiled.Tests/TmxSerializer/TmxSerializer.MapTests.cs

@@ -1,242 +0,0 @@
-namespace DotTiled.Tests;
-
-public partial class TmxSerializerMapTests
-{
-  private static void AssertMap(Map actual, Map expected)
-  {
-    // 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);
-
-    TmxSerializerPropertiesTests.AssertProperties(actual.Properties, expected.Properties);
-
-    Assert.NotNull(actual.Tilesets);
-    Assert.Equal(expected.Tilesets.Count, actual.Tilesets.Count);
-    for (var i = 0; i < expected.Tilesets.Count; i++)
-      TmxSerializerTilesetTests.AssertTileset(actual.Tilesets[i], expected.Tilesets[i]);
-
-    Assert.NotNull(actual.Layers);
-    Assert.Equal(expected.Layers.Count, actual.Layers.Count);
-    for (var i = 0; i < expected.Layers.Count; i++)
-      TmxSerializerLayerTests.AssertLayer(actual.Layers[i], expected.Layers[i]);
-  }
-
-  public static IEnumerable<object[]> DeserializeMap_ValidXmlNoExternalTilesets_ReturnsMapWithoutThrowing_Data =>
-    [
-      ["TmxSerializer.TestData.Map.empty-map-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 DeserializeMapFromXmlReader_ValidXmlNoExternalTilesets_ReturnsMapThatEqualsExpected(string testDataFile, Map expectedMap)
-  {
-    // Arrange
-    using var reader = TmxSerializerTestData.GetReaderFor(testDataFile);
-    var testDataFileText = TmxSerializerTestData.GetRawStringFor(testDataFile);
-    Func<TmxSerializer, string, Tileset> externalTilesetResolver = (TmxSerializer serializer, string s) =>
-      throw new NotSupportedException("External tilesets are not supported in this test");
-    Func<TmxSerializer, string, Template> externalTemplateResolver = (TmxSerializer serializer, string s) =>
-      throw new NotSupportedException("External templates are not supported in this test");
-    var tmxSerializer = new TmxSerializer(
-      externalTilesetResolver,
-      externalTemplateResolver);
-
-    // Act
-
-    static Template ResolveTemplate(string source)
-    {
-      using var xmlTemplateReader = TmxSerializerTestData.GetReaderFor($"TmxSerializer.TestData.Template.{source}");
-      using var templateReader = new TxTemplateReader(xmlTemplateReader, ResolveTileset, ResolveTemplate);
-      return templateReader.ReadTemplate();
-    }
-
-    static Tileset ResolveTileset(string source)
-    {
-      using var xmlTilesetReader = TmxSerializerTestData.GetReaderFor($"TmxSerializer.TestData.Tileset.{source}");
-      using var tilesetReader = new TsxTilesetReader(xmlTilesetReader, ResolveTemplate);
-      return tilesetReader.ReadTileset();
-    }
-
-    var mapReader = new TmxMapReader(reader, ResolveTileset, ResolveTemplate);
-
-    var map = mapReader.ReadMap();
-    var raw = tmxSerializer.DeserializeMap(testDataFileText);
-
-    // Assert
-    Assert.NotNull(map);
-    AssertMap(map, expectedMap);
-
-    Assert.NotNull(raw);
-    AssertMap(raw, expectedMap);
-
-    AssertMap(map, raw);
-  }
-
-  [Theory]
-  [MemberData(nameof(DeserializeMap_ValidXmlNoExternalTilesets_ReturnsMapWithoutThrowing_Data))]
-  public void DeserializeMapFromString_ValidXmlNoExternalTilesets_ReturnsMapThatEqualsExpected(string testDataFile, Map expectedMap)
-  {
-    // Arrange
-    var testDataFileText = TmxSerializerTestData.GetRawStringFor(testDataFile);
-    Func<TmxSerializer, string, Tileset> externalTilesetResolver = (TmxSerializer serializer, string s) =>
-      throw new NotSupportedException("External tilesets are not supported in this test");
-    Func<TmxSerializer, string, Template> externalTemplateResolver = (TmxSerializer serializer, string s) =>
-      throw new NotSupportedException("External templates are not supported in this test");
-    var tmxSerializer = new TmxSerializer(
-      externalTilesetResolver,
-      externalTemplateResolver);
-
-    // Act
-    var raw = tmxSerializer.DeserializeMap(testDataFileText);
-
-    // Assert
-    Assert.NotNull(raw);
-    AssertMap(raw, expectedMap);
-  }
-
-  [Theory]
-  [MemberData(nameof(DeserializeMap_ValidXmlNoExternalTilesets_ReturnsMapWithoutThrowing_Data))]
-  public void DeserializeMapFromStringFromXmlReader_ValidXmlNoExternalTilesets_Equal(string testDataFile, Map expectedMap)
-  {
-    // Arrange
-    using var reader = TmxSerializerTestData.GetReaderFor(testDataFile);
-    var testDataFileText = TmxSerializerTestData.GetRawStringFor(testDataFile);
-    Func<TmxSerializer, string, Tileset> externalTilesetResolver = (TmxSerializer serializer, string s) =>
-      throw new NotSupportedException("External tilesets are not supported in this test");
-    Func<TmxSerializer, string, Template> externalTemplateResolver = (TmxSerializer serializer, string s) =>
-      throw new NotSupportedException("External templates are not supported in this test");
-    var tmxSerializer = new TmxSerializer(
-      externalTilesetResolver,
-      externalTemplateResolver);
-
-    // Act
-    var map = tmxSerializer.DeserializeMap(reader);
-    var raw = tmxSerializer.DeserializeMap(testDataFileText);
-
-    // Assert
-    Assert.NotNull(map);
-    Assert.NotNull(raw);
-
-    AssertMap(map, raw);
-    AssertMap(map, expectedMap);
-    AssertMap(raw, expectedMap);
-  }
-
-  public static IEnumerable<object[]> DeserializeMap_ValidXmlExternalTilesetsAndTemplates_ReturnsMapThatEqualsExpected_Data =>
-    [
-      ["TmxSerializer.TestData.Map.map-with-object-template.tmx", MapWithObjectTemplate()],
-      ["TmxSerializer.TestData.Map.map-with-group.tmx", MapWithGroup()],
-    ];
-
-  [Theory]
-  [MemberData(nameof(DeserializeMap_ValidXmlExternalTilesetsAndTemplates_ReturnsMapThatEqualsExpected_Data))]
-  public void DeserializeMapFromXmlReader_ValidXmlExternalTilesetsAndTemplates_ReturnsMapThatEqualsExpected(string testDataFile, Map expectedMap)
-  {
-    // Arrange
-    using var reader = TmxSerializerTestData.GetReaderFor(testDataFile);
-    Func<TmxSerializer, string, Tileset> externalTilesetResolver = (TmxSerializer serializer, string s) =>
-    {
-      using var tilesetReader = TmxSerializerTestData.GetReaderFor($"TmxSerializer.TestData.Tileset.{s}");
-      return serializer.DeserializeTileset(tilesetReader);
-    };
-    Func<TmxSerializer, string, Template> externalTemplateResolver = (TmxSerializer serializer, string s) =>
-    {
-      using var templateReader = TmxSerializerTestData.GetReaderFor($"TmxSerializer.TestData.Template.{s}");
-      return serializer.DeserializeTemplate(templateReader);
-    };
-    var tmxSerializer = new TmxSerializer(
-      externalTilesetResolver,
-      externalTemplateResolver);
-
-    // Act
-    var map = tmxSerializer.DeserializeMap(reader);
-
-    // Assert
-    Assert.NotNull(map);
-    AssertMap(map, expectedMap);
-  }
-
-  [Theory]
-  [MemberData(nameof(DeserializeMap_ValidXmlExternalTilesetsAndTemplates_ReturnsMapThatEqualsExpected_Data))]
-  public void DeserializeMapFromString_ValidXmlExternalTilesetsAndTemplates_ReturnsMapThatEqualsExpected(string testDataFile, Map expectedMap)
-  {
-    // Arrange
-    var testDataFileText = TmxSerializerTestData.GetRawStringFor(testDataFile);
-    Func<TmxSerializer, string, Tileset> externalTilesetResolver = (TmxSerializer serializer, string s) =>
-    {
-      using var tilesetReader = TmxSerializerTestData.GetReaderFor($"TmxSerializer.TestData.Tileset.{s}");
-      return serializer.DeserializeTileset(tilesetReader);
-    };
-    Func<TmxSerializer, string, Template> externalTemplateResolver = (TmxSerializer serializer, string s) =>
-    {
-      using var templateReader = TmxSerializerTestData.GetReaderFor($"TmxSerializer.TestData.Template.{s}");
-      return serializer.DeserializeTemplate(templateReader);
-    };
-    var tmxSerializer = new TmxSerializer(
-      externalTilesetResolver,
-      externalTemplateResolver);
-
-    // Act
-    var map = tmxSerializer.DeserializeMap(testDataFileText);
-
-    // Assert
-    Assert.NotNull(map);
-    AssertMap(map, expectedMap);
-  }
-
-  [Theory]
-  [MemberData(nameof(DeserializeMap_ValidXmlExternalTilesetsAndTemplates_ReturnsMapThatEqualsExpected_Data))]
-  public void DeserializeMapFromStringFromXmlReader_ValidXmlExternalTilesetsAndTemplates_Equal(string testDataFile, Map expectedMap)
-  {
-    // Arrange
-    using var reader = TmxSerializerTestData.GetReaderFor(testDataFile);
-    var testDataFileText = TmxSerializerTestData.GetRawStringFor(testDataFile);
-    Func<TmxSerializer, string, Tileset> externalTilesetResolver = (TmxSerializer serializer, string s) =>
-    {
-      using var tilesetReader = TmxSerializerTestData.GetReaderFor($"TmxSerializer.TestData.Tileset.{s}");
-      return serializer.DeserializeTileset(tilesetReader);
-    };
-    Func<TmxSerializer, string, Template> externalTemplateResolver = (TmxSerializer serializer, string s) =>
-    {
-      using var templateReader = TmxSerializerTestData.GetReaderFor($"TmxSerializer.TestData.Template.{s}");
-      return serializer.DeserializeTemplate(templateReader);
-    };
-    var tmxSerializer = new TmxSerializer(
-      externalTilesetResolver,
-      externalTemplateResolver);
-
-    // Act
-    var map = tmxSerializer.DeserializeMap(reader);
-    var raw = tmxSerializer.DeserializeMap(testDataFileText);
-
-    // Assert
-    Assert.NotNull(map);
-    Assert.NotNull(raw);
-
-    AssertMap(map, raw);
-    AssertMap(map, expectedMap);
-    AssertMap(raw, expectedMap);
-  }
-}

DotTiled.Tests/TmxSerializer/TmxSerializerTests.cs

@@ -1,32 +0,0 @@
-namespace DotTiled.Tests;
-
-public class TmxSerializerTests
-{
-  [Fact]
-  public void TmxSerializerConstructor_ExternalTilesetResolverIsNull_ThrowsArgumentNullException()
-  {
-    // Arrange
-    Func<TmxSerializer, string, Tileset> externalTilesetResolver = null!;
-    Func<TmxSerializer, string, Template> externalTemplateResolver = null!;
-
-    // Act
-    Action act = () => _ = new TmxSerializer(externalTilesetResolver, externalTemplateResolver);
-
-    // Assert
-    Assert.Throws<ArgumentNullException>(act);
-  }
-
-  [Fact]
-  public void TmxSerializerConstructor_ExternalTilesetResolverIsNotNull_DoesNotThrow()
-  {
-    // Arrange
-    Func<TmxSerializer, string, Tileset> externalTilesetResolver = (_, _) => new Tileset();
-    Func<TmxSerializer, string, Template> externalTemplateResolver = (_, _) => new Template { Object = new RectangleObject { } };
-
-    // Act
-    var tmxSerializer = new TmxSerializer(externalTilesetResolver, externalTemplateResolver);
-
-    // Assert
-    Assert.NotNull(tmxSerializer);
-  }
-}