Bump version

* debug

* using

* Test fix

* Final fix

.github/workflows/build_and_test.yml

@@ -0,0 +1,48 @@
+name: Build and Test
+
+on:
+    push:
+        branches: ["main"]
+
+jobs:
+    build:
+        runs-on: ubuntu-latest
+
+        steps:
+            - uses: actions/checkout@v5
+              with:
+                  fetch-depth: 0
+
+            - name: Setup .NET
+              uses: actions/setup-dotnet@v5
+              with:
+                  dotnet-version: |
+                      8.0.x
+                      9.0.x
+                      10.0.x
+
+            - name: Run tests
+              run: dotnet test
+
+            - name: Run publish script
+              run: ./publish-nix.sh -d
+
+            - name: Update rolling tag
+              run: |
+                  git config user.name "github-actions[bot]"
+                  git config user.email "github-actions[bot]@users.noreply.github.com"
+                  git tag -f rolling
+                  git push origin :refs/tags/rolling || true
+                  git push origin rolling --force
+
+            - name: Upload to rolling
+              uses: ncipollo/release-action@v1.20.0
+              with:
+                  allowUpdates: True
+                  artifacts: "*.nupkg,*.snupkg,*.zip"
+                  body: "Last built commit: ${{ github.sha }}"
+                  name: "Rolling Release"
+                  prerelease: True
+                  replacesArtifacts: True
+                  tag: "rolling"
+                  updateOnlyUnreleased: True

.github/workflows/build_nupkg.yml

@@ -1,43 +0,0 @@
-name: Nuget Pack
-
-on:
-  push:
-    branches: [ "main" ]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v4
-      with:
-        submodules: recursive
-    
-    - name: Setup .NET
-      uses: actions/setup-dotnet@v4
-      with:
-        dotnet-version: 8.0.x
-        
-    - name: Restore dependencies
-      run: dotnet restore
-      
-    - name: Pack
-      run: dotnet pack
-
-    - name: Upload build
-      uses: actions/upload-artifact@v4
-      with:
-        name: 'Nuget Package'
-        path: 'SabreTools.Serialization/bin/Release/*.nupkg'
-
-    - name: Upload to rolling
-      uses: ncipollo/release-action@v1.14.0
-      with:
-        allowUpdates: True
-        artifacts: 'SabreTools.Serialization/bin/Release/*.nupkg'
-        body: 'Last built commit: ${{ github.sha }}'
-        name: 'Rolling Release'
-        prerelease: True
-        replacesArtifacts: True
-        tag: "rolling"
-        updateOnlyUnreleased: True

.github/workflows/check_pr.yml

@@ -3,15 +3,21 @@ name: Build PR
 on: [pull_request]
 
 jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-    
-    - name: Setup .NET
-      uses: actions/setup-dotnet@v4
-      with:
-        dotnet-version: 8.0.x
-      
-    - name: Build
-      run: dotnet build
+    build:
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v5
+
+            - name: Setup .NET
+              uses: actions/setup-dotnet@v5
+              with:
+                  dotnet-version: |
+                      8.0.x
+                      9.0.x
+                      10.0.x
+
+            - name: Build
+              run: dotnet build
+
+            - name: Run tests
+              run: dotnet test

.gitignore

@@ -1,15 +1,7 @@
-*.swp
-*.*~
-project.lock.json
-.DS_Store
-*.pyc
-nupkg/
-
-# Visual Studio Code
-.vscode
-
-# Rider
-.idea
+## Ignore Visual Studio temporary files, build results, and
+## files generated by popular Visual Studio add-ons.
+##
+## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
 
 # User-specific files
 *.suo
@@ -17,6 +9,9 @@ nupkg/
 *.userosscache
 *.sln.docstates
 
+# User-specific files (MonoDevelop/Xamarin Studio)
+*.userprefs
+
 # Build results
 [Dd]ebug/
 [Dd]ebugPublic/
@@ -24,15 +19,312 @@ nupkg/
 [Rr]eleases/
 x64/
 x86/
-build/
 bld/
 [Bb]in/
 [Oo]bj/
-[Oo]ut/
-msbuild.log
-msbuild.err
-msbuild.wrn
+[Ll]og/
 
-# Visual Studio 2015
+# Visual Studio 2015/2017 cache/options directory
 .vs/
+# Uncomment if you have tasks that create the project's static files in wwwroot
+#wwwroot/
 
+# Visual Studio 2017 auto generated files
+Generated\ Files/
+
+# MSTest test Results
+[Tt]est[Rr]esult*/
+[Bb]uild[Ll]og.*
+
+# NUNIT
+*.VisualState.xml
+TestResult.xml
+
+# Build Results of an ATL Project
+[Dd]ebugPS/
+[Rr]eleasePS/
+dlldata.c
+
+# Benchmark Results
+BenchmarkDotNet.Artifacts/
+
+# .NET Core
+project.lock.json
+project.fragment.lock.json
+artifacts/
+**/Properties/launchSettings.json
+
+# StyleCop
+StyleCopReport.xml
+
+# Files built by Visual Studio
+*_i.c
+*_p.c
+*_i.h
+*.ilk
+*.meta
+*.obj
+*.iobj
+*.pch
+*.pdb
+*.ipdb
+*.pgc
+*.pgd
+*.rsp
+*.sbr
+*.tlb
+*.tli
+*.tlh
+*.tmp
+*.tmp_proj
+*.log
+*.vspscc
+*.vssscc
+.builds
+*.pidb
+*.svclog
+*.scc
+
+# Chutzpah Test files
+_Chutzpah*
+
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opendb
+*.opensdf
+*.sdf
+*.cachefile
+*.VC.db
+*.VC.VC.opendb
+
+# Visual Studio profiler
+*.psess
+*.vsp
+*.vspx
+*.sap
+
+# Visual Studio Trace Files
+*.e2e
+
+# TFS 2012 Local Workspace
+$tf/
+
+# Guidance Automation Toolkit
+*.gpState
+
+# ReSharper is a .NET coding add-in
+_ReSharper*/
+*.[Rr]e[Ss]harper
+*.DotSettings.user
+
+# JustCode is a .NET coding add-in
+.JustCode
+
+# TeamCity is a build add-in
+_TeamCity*
+
+# DotCover is a Code Coverage Tool
+*.dotCover
+
+# AxoCover is a Code Coverage Tool
+.axoCover/*
+!.axoCover/settings.json
+
+# Visual Studio code coverage results
+*.coverage
+*.coveragexml
+
+# NCrunch
+_NCrunch_*
+.*crunch*.local.xml
+nCrunchTemp_*
+
+# MightyMoose
+*.mm.*
+AutoTest.Net/
+
+# Web workbench (sass)
+.sass-cache/
+
+# Installshield output folder
+[Ee]xpress/
+
+# DocProject is a documentation generator add-in
+DocProject/buildhelp/
+DocProject/Help/*.HxT
+DocProject/Help/*.HxC
+DocProject/Help/*.hhc
+DocProject/Help/*.hhk
+DocProject/Help/*.hhp
+DocProject/Help/Html2
+DocProject/Help/html
+
+# Click-Once directory
+publish/
+
+# Publish Web Output
+*.[Pp]ublish.xml
+*.azurePubxml
+# Note: Comment the next line if you want to checkin your web deploy settings,
+# but database connection strings (with potential passwords) will be unencrypted
+*.pubxml
+*.publishproj
+
+# Microsoft Azure Web App publish settings. Comment the next line if you want to
+# checkin your Azure Web App publish settings, but sensitive information contained
+# in these scripts will be unencrypted
+PublishScripts/
+
+# NuGet Packages
+*.nupkg
+# The packages folder can be ignored because of Package Restore
+**/[Pp]ackages/*
+# except build/, which is used as an MSBuild target.
+!**/[Pp]ackages/build/
+# Uncomment if necessary however generally it will be regenerated when needed
+#!**/[Pp]ackages/repositories.config
+# NuGet v3's project.json files produces more ignorable files
+*.nuget.props
+*.nuget.targets
+
+# Microsoft Azure Build Output
+csx/
+*.build.csdef
+
+# Microsoft Azure Emulator
+ecf/
+rcf/
+
+# Windows Store app package directories and files
+AppPackages/
+BundleArtifacts/
+Package.StoreAssociation.xml
+_pkginfo.txt
+*.appx
+
+# Visual Studio cache files
+# files ending in .cache can be ignored
+*.[Cc]ache
+# but keep track of directories ending in .cache
+!*.[Cc]ache/
+
+# Others
+ClientBin/
+~$*
+*~
+*.dbmdl
+*.dbproj.schemaview
+*.jfm
+*.pfx
+*.publishsettings
+orleans.codegen.cs
+
+# Including strong name files can present a security risk 
+# (https://github.com/github/gitignore/pull/2483#issue-259490424)
+#*.snk
+
+# Since there are multiple workflows, uncomment next line to ignore bower_components
+# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
+#bower_components/
+
+# RIA/Silverlight projects
+Generated_Code/
+
+# Backup & report files from converting an old project file
+# to a newer Visual Studio version. Backup files are not needed,
+# because we have git ;-)
+_UpgradeReport_Files/
+Backup*/
+UpgradeLog*.XML
+UpgradeLog*.htm
+ServiceFabricBackup/
+*.rptproj.bak
+
+# SQL Server files
+*.mdf
+*.ldf
+*.ndf
+
+# Business Intelligence projects
+*.rdl.data
+*.bim.layout
+*.bim_*.settings
+*.rptproj.rsuser
+
+# Microsoft Fakes
+FakesAssemblies/
+
+# GhostDoc plugin setting file
+*.GhostDoc.xml
+
+# Node.js Tools for Visual Studio
+.ntvs_analysis.dat
+node_modules/
+
+# Visual Studio 6 build log
+*.plg
+
+# Visual Studio 6 workspace options file
+*.opt
+
+# Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
+*.vbw
+
+# Visual Studio LightSwitch build output
+**/*.HTMLClient/GeneratedArtifacts
+**/*.DesktopClient/GeneratedArtifacts
+**/*.DesktopClient/ModelManifest.xml
+**/*.Server/GeneratedArtifacts
+**/*.Server/ModelManifest.xml
+_Pvt_Extensions
+
+# Paket dependency manager
+.paket/paket.exe
+paket-files/
+
+# FAKE - F# Make
+.fake/
+
+# JetBrains Rider
+.idea/
+*.sln.iml
+
+# CodeRush
+.cr/
+
+# Python Tools for Visual Studio (PTVS)
+__pycache__/
+*.pyc
+
+# Cake - Uncomment if you are using it
+# tools/**
+# !tools/packages.config
+
+# Tabs Studio
+*.tss
+
+# Telerik's JustMock configuration file
+*.jmconfig
+
+# BizTalk build output
+*.btp.cs
+*.btm.cs
+*.odx.cs
+*.xsd.cs
+
+# OpenCover UI analysis results
+OpenCover/
+
+# Azure Stream Analytics local run output 
+ASALocalRun/
+
+# MSBuild Binary and Structured Log
+*.binlog
+
+# NVidia Nsight GPU debugger configuration file
+*.nvuser
+
+# MFractors (Xamarin productivity tool) working folder 
+.mfractor/

.vscode/launch.json

@@ -0,0 +1,42 @@
+{
+    // Use IntelliSense to find out which attributes exist for C# debugging
+    // Use hover for the description of the existing attributes
+    // For further information visit https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger-launchjson.md
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": ".NET Core Launch (ExtractionTool)",
+            "type": "coreclr",
+            "request": "launch",
+            "preLaunchTask": "build",
+            // If you have changed target frameworks, make sure to update the program path.
+            "program": "${workspaceFolder}/ExtractionTool/bin/Debug/net10.0/ExtractionTool.dll",
+            "args": [],
+            "cwd": "${workspaceFolder}",
+            // For more information about the 'console' field, see https://aka.ms/VSCode-CS-LaunchJson-Console
+            "console": "internalConsole",
+            "stopAtEntry": false,
+            "justMyCode": false
+        },
+        {
+            "name": ".NET Core Launch (InfoPrint)",
+            "type": "coreclr",
+            "request": "launch",
+            "preLaunchTask": "build",
+            // If you have changed target frameworks, make sure to update the program path.
+            "program": "${workspaceFolder}/InfoPrint/bin/Debug/net10.0/InfoPrint.dll",
+            "args": [],
+            "cwd": "${workspaceFolder}",
+            // For more information about the 'console' field, see https://aka.ms/VSCode-CS-LaunchJson-Console
+            "console": "internalConsole",
+            "stopAtEntry": false,
+            "justMyCode": false
+        },
+        {
+            "name": ".NET Core Attach",
+            "type": "coreclr",
+            "request": "attach",
+            "processId": "${command:pickProcess}"
+        }
+    ]
+}

.vscode/tasks.json

@@ -0,0 +1,24 @@
+{
+    // See https://go.microsoft.com/fwlink/?LinkId=733558
+    // for the documentation about the tasks.json format
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "build",
+            "command": "dotnet",
+            "type": "shell",
+            "args": [
+                "build",
+                // Ask dotnet build to generate full paths for file names.
+                "/property:GenerateFullPaths=true",
+                // Do not generate summary otherwise it leads to duplicate errors in Problems panel
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "group": "build",
+            "presentation": {
+                "reveal": "silent"
+            },
+            "problemMatcher": "$msCompile"
+        }
+    ]
+}

ExtractionTool/ExtractionTool.csproj

@@ -0,0 +1,56 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFrameworks>net20;net35;net40;net452;net462;net472;net48;netcoreapp3.1;net5.0;net6.0;net7.0;net8.0;net9.0;net10.0</TargetFrameworks>
+        <OutputType>Exe</OutputType>
+        <CheckEolTargetFramework>false</CheckEolTargetFramework>
+        <IncludeNativeLibrariesForSelfExtract>true</IncludeNativeLibrariesForSelfExtract>
+        <IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
+        <LangVersion>latest</LangVersion>
+        <Nullable>enable</Nullable>
+        <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
+        <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+        <Version>2.2.1</Version>
+    </PropertyGroup>
+
+    <!-- Support All Frameworks -->
+    <PropertyGroup Condition="$(TargetFramework.StartsWith(`net2`)) OR $(TargetFramework.StartsWith(`net3`)) OR $(TargetFramework.StartsWith(`net4`))">
+        <RuntimeIdentifiers>win-x86;win-x64</RuntimeIdentifiers>
+    </PropertyGroup>
+    <PropertyGroup Condition="$(TargetFramework.StartsWith(`netcoreapp`)) OR $(TargetFramework.StartsWith(`net5`))">
+        <RuntimeIdentifiers>win-x86;win-x64;win-arm64;linux-x64;linux-arm64;osx-x64</RuntimeIdentifiers>
+    </PropertyGroup>
+    <PropertyGroup Condition="$(TargetFramework.StartsWith(`net6`)) OR $(TargetFramework.StartsWith(`net7`)) OR $(TargetFramework.StartsWith(`net8`)) OR $(TargetFramework.StartsWith(`net9`)) OR $(TargetFramework.StartsWith(`net10`))">
+        <RuntimeIdentifiers>win-x86;win-x64;win-arm64;linux-x64;linux-arm64;osx-x64;osx-arm64</RuntimeIdentifiers>
+    </PropertyGroup>
+    <PropertyGroup Condition="$(RuntimeIdentifier.StartsWith(`osx-arm`))">
+        <TargetFrameworks>net6.0;net7.0;net8.0;net9.0;net10.0</TargetFrameworks>
+    </PropertyGroup>
+
+    <!-- These are needed for dealing with native Windows DLLs -->
+    <ItemGroup Condition="'$(RuntimeIdentifier)'=='win-x86'">
+        <ContentWithTargetPath Include="..\SabreTools.Serialization\runtimes\win-x86\native\StormLib.dll">
+            <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+            <CopyToPublishDirectory>Always</CopyToPublishDirectory>
+            <TargetPath>StormLib.dll</TargetPath>
+        </ContentWithTargetPath>
+    </ItemGroup>
+    <ItemGroup Condition="'$(RuntimeIdentifier)'=='win-x64'">
+        <ContentWithTargetPath Include="..\SabreTools.Serialization\runtimes\win-x64\native\StormLib.dll">
+            <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+            <CopyToPublishDirectory>Always</CopyToPublishDirectory>
+            <TargetPath>StormLib.dll</TargetPath>
+        </ContentWithTargetPath>
+    </ItemGroup>
+
+    <ItemGroup>
+        <ProjectReference Include="..\SabreTools.Serialization\SabreTools.Serialization.csproj" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <PackageReference Include="SabreTools.CommandLine" Version="[1.4.0]" />
+        <PackageReference Include="SabreTools.IO" Version="[1.9.0]" />
+        <PackageReference Include="System.Text.Encoding.CodePages" Version="10.0.0" Condition="!$(TargetFramework.StartsWith(`net2`)) AND !$(TargetFramework.StartsWith(`net3`)) AND !$(TargetFramework.StartsWith(`net40`)) AND !$(TargetFramework.StartsWith(`net452`))" />
+    </ItemGroup>
+
+</Project>

ExtractionTool/Features/MainFeature.cs

@@ -0,0 +1,340 @@
+using System;
+using System.IO;
+using SabreTools.CommandLine;
+using SabreTools.CommandLine.Inputs;
+using SabreTools.IO.Extensions;
+using SabreTools.Serialization;
+using SabreTools.Serialization.Wrappers;
+
+namespace ExtractionTool.Features
+{
+    internal sealed class MainFeature : Feature
+    {
+        #region Feature Definition
+
+        public const string DisplayName = "main";
+
+        /// <remarks>Flags are unused</remarks>
+        private static readonly string[] _flags = [];
+
+        /// <remarks>Description is unused</remarks>
+        private const string _description = "";
+
+        #endregion
+
+        #region Inputs
+
+        private const string _debugName = "debug";
+        internal readonly FlagInput DebugInput = new(_debugName, ["-d", "--debug"], "Enable debug mode");
+
+        private const string _outputPathName = "output-path";
+        internal readonly StringInput OutputPathInput = new(_outputPathName, ["-o", "--outdir"], "Set output path for extraction (required)");
+
+        #endregion
+
+        #region Properties
+
+        /// <summary>
+        /// Enable debug output for relevant operations
+        /// </summary>
+        public bool Debug { get; private set; }
+
+        /// <summary>
+        /// Output path for archive extraction
+        /// </summary>
+        public string OutputPath { get; private set; } = string.Empty;
+
+        #endregion
+
+        public MainFeature()
+            : base(DisplayName, _flags, _description)
+        {
+            RequiresInputs = true;
+
+            Add(DebugInput);
+            Add(OutputPathInput);
+        }
+
+        /// <inheritdoc/>
+        public override bool Execute()
+        {
+            // Get the options from the arguments
+            Debug = GetBoolean(_debugName);
+            OutputPath = GetString(_outputPathName) ?? string.Empty;
+
+            // Validate the output path
+            if (!ValidateExtractionPath())
+                return false;
+
+            // Loop through the input paths
+            for (int i = 0; i < Inputs.Count; i++)
+            {
+                string arg = Inputs[i];
+                ExtractPath(arg);
+            }
+
+            return true;
+        }
+
+        /// <inheritdoc/>
+        public override bool VerifyInputs() => Inputs.Count > 0;
+
+        /// <summary>
+        /// Wrapper to extract data for a single path
+        /// </summary>
+        /// <param name="path">File or directory path</param>
+        private void ExtractPath(string path)
+        {
+            // Normalize by getting the full path
+            path = Path.GetFullPath(path);
+            Console.WriteLine($"Checking possible path: {path}");
+
+            // Check if the file or directory exists
+            if (File.Exists(path))
+            {
+                ExtractFile(path);
+            }
+            else if (Directory.Exists(path))
+            {
+                foreach (string file in path.SafeEnumerateFiles("*", SearchOption.AllDirectories))
+                {
+                    ExtractFile(file);
+                }
+            }
+            else
+            {
+                Console.WriteLine($"{path} does not exist, skipping...");
+            }
+        }
+
+        /// <summary>
+        /// Print information for a single file, if possible
+        /// </summary>
+        /// <param name="path">File path</param>
+        private void ExtractFile(string file)
+        {
+            Console.WriteLine($"Attempting to extract all files from {file}");
+            using Stream stream = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+
+            // Get the extension for certain checks
+            string extension = Path.GetExtension(file).ToLower().TrimStart('.');
+
+            // Get the first 16 bytes for matching
+            byte[] magic = new byte[16];
+            try
+            {
+                int read = stream.Read(magic, 0, 16);
+                stream.SeekIfPossible(0, SeekOrigin.Begin);
+            }
+            catch (Exception ex)
+            {
+                if (Debug) Console.Error.WriteLine(ex);
+                return;
+            }
+
+            // Get the file type
+            WrapperType ft = WrapperFactory.GetFileType(magic, extension);
+            var wrapper = WrapperFactory.CreateWrapper(ft, stream);
+
+            // Create the output directory
+            Directory.CreateDirectory(OutputPath);
+
+            // Print the preamble
+            Console.WriteLine($"Attempting to extract from '{wrapper?.Description() ?? "UNKNOWN"}'");
+            Console.WriteLine();
+
+            switch (wrapper)
+            {
+                // 7-zip
+                case SevenZip sz:
+                    sz.Extract(OutputPath, Debug);
+                    break;
+
+                // BFPK archive
+                case BFPK bfpk:
+                    bfpk.Extract(OutputPath, Debug);
+                    break;
+
+                // BSP
+                case BSP bsp:
+                    bsp.Extract(OutputPath, Debug);
+                    break;
+
+                // bzip2
+                case BZip2 bzip2:
+                    bzip2.Extract(OutputPath, Debug);
+                    break;
+
+                // CD-ROM bin file
+                case CDROM cdrom:
+                    cdrom.Extract(OutputPath, Debug);
+                    break;
+
+                // CFB
+                case CFB cfb:
+                    cfb.Extract(OutputPath, Debug);
+                    break;
+
+                // GCF
+                case GCF gcf:
+                    gcf.Extract(OutputPath, Debug);
+                    break;
+
+                // gzip
+                case GZip gzip:
+                    gzip.Extract(OutputPath, Debug);
+                    break;
+
+                // InstallShield Archive V3 (Z)
+                case InstallShieldArchiveV3 isv3:
+                    isv3.Extract(OutputPath, Debug);
+                    break;
+
+                // IS-CAB archive
+                case InstallShieldCabinet iscab:
+                    iscab.Extract(OutputPath, Debug);
+                    break;
+
+                // ISO 9660 volume
+                case ISO9660 iso9660:
+                    iso9660.Extract(OutputPath, Debug);
+                    break;
+
+                // LZ-compressed file, KWAJ variant
+                case LZKWAJ kwaj:
+                    kwaj.Extract(OutputPath, Debug);
+                    break;
+
+                // LZ-compressed file, QBasic variant
+                case LZQBasic qbasic:
+                    qbasic.Extract(OutputPath, Debug);
+                    break;
+
+                // LZ-compressed file, SZDD variant
+                case LZSZDD szdd:
+                    szdd.Extract(OutputPath, Debug);
+                    break;
+
+                // Microsoft Cabinet archive
+                case MicrosoftCabinet mscab:
+                    mscab.Extract(OutputPath, Debug);
+                    break;
+
+                // MoPaQ (MPQ) archive
+                case MoPaQ mpq:
+                    mpq.Extract(OutputPath, Debug);
+                    break;
+
+                // New Executable
+                case NewExecutable nex:
+                    nex.Extract(OutputPath, Debug);
+                    break;
+
+                // PAK
+                case PAK pak:
+                    pak.Extract(OutputPath, Debug);
+                    break;
+
+                // PFF
+                case PFF pff:
+                    pff.Extract(OutputPath, Debug);
+                    break;
+
+                // PKZIP
+                case PKZIP pkzip:
+                    pkzip.Extract(OutputPath, Debug);
+                    break;
+
+                // Portable Executable
+                case PortableExecutable pex:
+                    pex.Extract(OutputPath, Debug);
+                    break;
+
+                // Quantum
+                case Quantum quantum:
+                    quantum.Extract(OutputPath, Debug);
+                    break;
+
+                // RAR
+                case RAR rar:
+                    rar.Extract(OutputPath, Debug);
+                    break;
+
+                // SGA
+                case SGA sga:
+                    sga.Extract(OutputPath, Debug);
+                    break;
+
+                // Tape Archive
+                case TapeArchive tar:
+                    tar.Extract(OutputPath, Debug);
+                    break;
+
+                // VBSP
+                case VBSP vbsp:
+                    vbsp.Extract(OutputPath, Debug);
+                    break;
+
+                // VPK
+                case VPK vpk:
+                    vpk.Extract(OutputPath, Debug);
+                    break;
+
+                // WAD3
+                case WAD3 wad:
+                    wad.Extract(OutputPath, Debug);
+                    break;
+
+                // xz
+                case XZ xz:
+                    xz.Extract(OutputPath, Debug);
+                    break;
+
+                // XZP
+                case XZP xzp:
+                    xzp.Extract(OutputPath, Debug);
+                    break;
+
+                // ZSTD
+                case ZSTD zstd:
+                    zstd.Extract(OutputPath, Debug);
+                    break;
+
+                // Everything else
+                default:
+                    Console.WriteLine("Not a supported extractable file format, skipping...");
+                    Console.WriteLine();
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Validate the extraction path
+        /// </summary>
+        private bool ValidateExtractionPath()
+        {
+            // Null or empty output path
+            if (string.IsNullOrEmpty(OutputPath))
+            {
+                Console.WriteLine("Output directory required for extraction!");
+                Console.WriteLine();
+                return false;
+            }
+
+            // Malformed output path or invalid location
+            try
+            {
+                OutputPath = Path.GetFullPath(OutputPath);
+                Directory.CreateDirectory(OutputPath);
+            }
+            catch
+            {
+                Console.WriteLine("Output directory could not be created!");
+                Console.WriteLine();
+                return false;
+            }
+
+            return true;
+        }
+    }
+}

ExtractionTool/Program.cs

@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using ExtractionTool.Features;
+using SabreTools.CommandLine;
+using SabreTools.CommandLine.Features;
+
+namespace ExtractionTool
+{
+    public static class Program
+    {
+        public static void Main(string[] args)
+        {
+#if NET462_OR_GREATER || NETCOREAPP
+            // Register the codepages
+            System.Text.Encoding.RegisterProvider(System.Text.CodePagesEncodingProvider.Instance);
+#endif
+
+            // Create the command set
+            var mainFeature = new MainFeature();
+            var commandSet = CreateCommands(mainFeature);
+
+            // If we have no args, show the help and quit
+            if (args == null || args.Length == 0)
+            {
+                commandSet.OutputAllHelp();
+                return;
+            }
+
+            // Cache the first argument and starting index
+            string featureName = args[0];
+
+            // Try processing the standalone arguments
+            var topLevel = commandSet.GetTopLevel(featureName);
+            switch (topLevel)
+            {
+                // Standalone Options
+                case Help help: help.ProcessArgs(args, 0, commandSet); return;
+
+                // Default Behavior
+                default:
+                    if (!mainFeature.ProcessArgs(args, 0))
+                    {
+                        commandSet.OutputAllHelp();
+                        return;
+                    }
+                    else if (!mainFeature.VerifyInputs())
+                    {
+                        Console.Error.WriteLine("At least one input is required");
+                        commandSet.OutputAllHelp();
+                        return;
+                    }
+
+                    mainFeature.Execute();
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Create the command set for the program
+        /// </summary>
+        private static CommandSet CreateCommands(MainFeature mainFeature)
+        {
+            List<string> header = [
+                "Extraction Tool",
+                string.Empty,
+                "ExtractionTool <options> file|directory ...",
+                string.Empty,
+            ];
+
+            var commandSet = new CommandSet(header);
+
+            commandSet.Add(new Help(["-?", "-h", "--help"]));
+            commandSet.Add(mainFeature.DebugInput);
+            commandSet.Add(mainFeature.OutputPathInput);
+
+            return commandSet;
+        }
+    }
+}

InfoPrint/Features/MainFeature.cs

@@ -0,0 +1,278 @@
+using System;
+using System.IO;
+using System.Text;
+using SabreTools.CommandLine;
+using SabreTools.CommandLine.Inputs;
+using SabreTools.Hashing;
+using SabreTools.IO.Extensions;
+using SabreTools.Serialization;
+using SabreTools.Serialization.Wrappers;
+
+namespace InfoPrint.Features
+{
+    internal sealed class MainFeature : Feature
+    {
+        #region Feature Definition
+
+        public const string DisplayName = "main";
+
+        /// <remarks>Flags are unused</remarks>
+        private static readonly string[] _flags = [];
+
+        /// <remarks>Description is unused</remarks>
+        private const string _description = "";
+
+        #endregion
+
+        #region Inputs
+
+        private const string _debugName = "debug";
+        internal readonly FlagInput DebugInput = new(_debugName, ["-d", "--debug"], "Enable debug mode");
+
+        private const string _fileOnlyName = "file-only";
+        internal readonly FlagInput FileOnlyInput = new(_fileOnlyName, ["-f", "--file"], "Print to file only");
+
+        private const string _hashName = "hash";
+        internal readonly FlagInput HashInput = new(_hashName, ["-c", "--hash"], "Output file hashes");
+
+#if NETCOREAPP
+        private const string _jsonName = "json";
+        internal readonly FlagInput JsonInput = new(_jsonName, ["-j", "--json"], "Print info as JSON");
+#endif
+
+        #endregion
+
+        /// <summary>
+        /// Enable debug output for relevant operations
+        /// </summary>
+        public bool Debug { get; private set; }
+
+        /// <summary>
+        /// Output information to file only, skip printing to console
+        /// </summary>
+        public bool FileOnly { get; private set; }
+
+        /// <summary>
+        /// Print external file hashes
+        /// </summary>
+        public bool Hash { get; private set; }
+
+#if NETCOREAPP
+        /// <summary>
+        /// Enable JSON output
+        /// </summary>
+        public bool Json { get; private set; }
+#endif
+
+        public MainFeature()
+            : base(DisplayName, _flags, _description)
+        {
+            RequiresInputs = true;
+
+            Add(DebugInput);
+            Add(HashInput);
+            Add(FileOnlyInput);
+#if NETCOREAPP
+            Add(JsonInput);
+#endif
+        }
+
+        /// <inheritdoc/>
+        public override bool Execute()
+        {
+            // Get the options from the arguments
+            Debug = GetBoolean(_debugName);
+            Hash = GetBoolean(_hashName);
+            FileOnly = GetBoolean(_fileOnlyName);
+#if NETCOREAPP
+            Json = GetBoolean(_jsonName);
+#endif
+
+            // Loop through the input paths
+            for (int i = 0; i < Inputs.Count; i++)
+            {
+                string arg = Inputs[i];
+                PrintPathInfo(arg);
+            }
+
+            return true;
+        }
+
+        /// <inheritdoc/>
+        public override bool VerifyInputs() => Inputs.Count > 0;
+
+        /// <summary>
+        /// Wrapper to print information for a single path
+        /// </summary>
+        /// <param name="path">File or directory path</param>
+        private void PrintPathInfo(string path)
+        {
+            Console.WriteLine($"Checking possible path: {path}");
+
+            // Check if the file or directory exists
+            if (File.Exists(path))
+            {
+                PrintFileInfo(path);
+            }
+            else if (Directory.Exists(path))
+            {
+                foreach (string file in path.SafeEnumerateFiles("*", SearchOption.AllDirectories))
+                {
+                    PrintFileInfo(file);
+                }
+            }
+            else
+            {
+                Console.WriteLine($"{path} does not exist, skipping...");
+            }
+        }
+
+        /// <summary>
+        /// Print information for a single file, if possible
+        /// </summary>
+        /// <param name="file">File path</param>
+        private void PrintFileInfo(string file)
+        {
+            Console.WriteLine($"Attempting to print info for {file}");
+
+            // Get the base info output name
+            string filenameBase = $"info-{DateTime.Now:yyyy-MM-dd_HHmmss.ffff}";
+
+            // If we have the hash flag
+            if (Hash)
+            {
+                var hashBuilder = PrintHashInfo(file);
+                if (hashBuilder != null)
+                {
+                    // Create the output data
+                    string hashData = hashBuilder.ToString();
+
+                    // Write the output data
+                    using var hsw = new StreamWriter(File.OpenWrite($"{filenameBase}.hashes"));
+                    hsw.WriteLine(hashData);
+                    hsw.Flush();
+                }
+            }
+
+            try
+            {
+                using Stream stream = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+
+                // Read the first 8 bytes
+                byte[] magic = stream.PeekBytes(8);
+
+                // Get the file type
+                string extension = Path.GetExtension(file).TrimStart('.');
+                WrapperType ft = WrapperFactory.GetFileType(magic ?? [], extension);
+
+                // Print out the file format
+                Console.WriteLine($"File format found: {ft}");
+
+                // Setup the wrapper to print
+                var wrapper = WrapperFactory.CreateWrapper(ft, stream);
+
+                // If we don't have a wrapper
+                if (wrapper == null)
+                {
+                    Console.WriteLine($"Either {ft} is not supported or something went wrong during parsing!");
+                    Console.WriteLine();
+                    return;
+                }
+
+#if NETCOREAPP
+                // If we have the JSON flag
+                if (Json)
+                {
+                    // Create the output data
+                    string serializedData = wrapper.ExportJSON();
+
+                    // Write the output data
+                    using var jsw = new StreamWriter(File.OpenWrite($"{filenameBase}.json"));
+                    jsw.WriteLine(serializedData);
+                    jsw.Flush();
+                }
+#endif
+
+                // Create the output data
+                var builder = wrapper.ExportStringBuilder();
+                if (builder == null)
+                {
+                    Console.WriteLine("No item information could be generated");
+                    return;
+                }
+
+                // Only print to console if enabled
+                if (!FileOnly)
+                    Console.WriteLine(builder);
+
+                using var sw = new StreamWriter(File.OpenWrite($"{filenameBase}.txt"));
+                sw.WriteLine(file);
+                sw.WriteLine();
+                sw.WriteLine(builder.ToString());
+                sw.Flush();
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine(Debug ? ex : "[Exception opening file, please try again]");
+                Console.WriteLine();
+            }
+        }
+
+        /// <summary>
+        /// Print hash information for a single file, if possible
+        /// </summary>
+        /// <param name="file">File path</param>
+        /// <returns>StringBuilder representing the hash information, if possible</returns>
+        private StringBuilder? PrintHashInfo(string file)
+        {
+            // Ignore missing files
+            if (!File.Exists(file))
+                return null;
+
+            Console.WriteLine($"Attempting to hash {file}, this may take a while...");
+
+            try
+            {
+                // Get all file hashes for flexibility
+                var hashes = HashTool.GetFileHashes(file);
+                if (hashes == null)
+                {
+                    if (Debug) Console.WriteLine($"Hashes for {file} could not be retrieved");
+                    return null;
+                }
+
+                // Output subset of available hashes
+                var builder = new StringBuilder();
+                if (hashes.TryGetValue(HashType.CRC16, out string? crc16) && crc16 != null)
+                    builder.AppendLine($"CRC-16 checksum: {crc16}");
+                if (hashes.TryGetValue(HashType.CRC32, out string? crc32) && crc32 != null)
+                    builder.AppendLine($"CRC-32 checksum: {crc32}");
+                if (hashes.TryGetValue(HashType.MD2, out string? md2) && md2 != null)
+                    builder.AppendLine($"MD2 hash: {md2}");
+                if (hashes.TryGetValue(HashType.MD4, out string? md4) && md4 != null)
+                    builder.AppendLine($"MD4 hash: {md4}");
+                if (hashes.TryGetValue(HashType.MD5, out string? md5) && md5 != null)
+                    builder.AppendLine($"MD5 hash: {md5}");
+                if (hashes.TryGetValue(HashType.RIPEMD128, out string? ripemd128) && ripemd128 != null)
+                    builder.AppendLine($"RIPEMD-128 hash: {ripemd128}");
+                if (hashes.TryGetValue(HashType.RIPEMD160, out string? ripemd160) && ripemd160 != null)
+                    builder.AppendLine($"RIPEMD-160 hash: {ripemd160}");
+                if (hashes.TryGetValue(HashType.SHA1, out string? sha1) && sha1 != null)
+                    builder.AppendLine($"SHA-1 hash: {sha1}");
+                if (hashes.TryGetValue(HashType.SHA256, out string? sha256) && sha256 != null)
+                    builder.AppendLine($"SHA-256 hash: {sha256}");
+                if (hashes.TryGetValue(HashType.SHA384, out string? sha384) && sha384 != null)
+                    builder.AppendLine($"SHA-384 hash: {sha384}");
+                if (hashes.TryGetValue(HashType.SHA512, out string? sha512) && sha512 != null)
+                    builder.AppendLine($"SHA-512 hash: {sha512}");
+
+                return builder;
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine(Debug ? ex : "[Exception opening file, please try again]");
+                return null;
+            }
+        }
+    }
+}

InfoPrint/InfoPrint.csproj

@@ -0,0 +1,40 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFrameworks>net20;net35;net40;net452;net462;net472;net48;netcoreapp3.1;net5.0;net6.0;net7.0;net8.0;net9.0;net10.0</TargetFrameworks>
+        <OutputType>Exe</OutputType>
+        <CheckEolTargetFramework>false</CheckEolTargetFramework>
+        <IncludeNativeLibrariesForSelfExtract>true</IncludeNativeLibrariesForSelfExtract>
+        <IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
+        <LangVersion>latest</LangVersion>
+        <Nullable>enable</Nullable>
+        <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
+        <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+        <Version>2.2.1</Version>
+    </PropertyGroup>
+
+    <!-- Support All Frameworks -->
+    <PropertyGroup Condition="$(TargetFramework.StartsWith(`net2`)) OR $(TargetFramework.StartsWith(`net3`)) OR $(TargetFramework.StartsWith(`net4`))">
+        <RuntimeIdentifiers>win-x86;win-x64</RuntimeIdentifiers>
+    </PropertyGroup>
+    <PropertyGroup Condition="$(TargetFramework.StartsWith(`netcoreapp`)) OR $(TargetFramework.StartsWith(`net5`))">
+        <RuntimeIdentifiers>win-x86;win-x64;win-arm64;linux-x64;linux-arm64;osx-x64</RuntimeIdentifiers>
+    </PropertyGroup>
+    <PropertyGroup Condition="$(TargetFramework.StartsWith(`net6`)) OR $(TargetFramework.StartsWith(`net7`)) OR $(TargetFramework.StartsWith(`net8`)) OR $(TargetFramework.StartsWith(`net9`)) OR $(TargetFramework.StartsWith(`net10`))">
+        <RuntimeIdentifiers>win-x86;win-x64;win-arm64;linux-x64;linux-arm64;osx-x64;osx-arm64</RuntimeIdentifiers>
+    </PropertyGroup>
+    <PropertyGroup Condition="$(RuntimeIdentifier.StartsWith(`osx-arm`))">
+        <TargetFrameworks>net6.0;net7.0;net8.0;net9.0;net10.0</TargetFrameworks>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <ProjectReference Include="..\SabreTools.Serialization\SabreTools.Serialization.csproj" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <PackageReference Include="SabreTools.CommandLine" Version="[1.4.0]" />
+        <PackageReference Include="SabreTools.Hashing" Version="[1.6.0]" />
+        <PackageReference Include="SabreTools.IO" Version="[1.9.0]" />
+    </ItemGroup>
+
+</Project>

InfoPrint/Program.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using InfoPrint.Features;
+using SabreTools.CommandLine;
+using SabreTools.CommandLine.Features;
+
+namespace InfoPrint
+{
+    public static class Program
+    {
+        public static void Main(string[] args)
+        {
+            // Create the command set
+            var mainFeature = new MainFeature();
+            var commandSet = CreateCommands(mainFeature);
+
+            // If we have no args, show the help and quit
+            if (args == null || args.Length == 0)
+            {
+                commandSet.OutputAllHelp();
+                return;
+            }
+
+            // Cache the first argument and starting index
+            string featureName = args[0];
+
+            // Try processing the standalone arguments
+            var topLevel = commandSet.GetTopLevel(featureName);
+            switch (topLevel)
+            {
+                // Standalone Options
+                case Help help: help.ProcessArgs(args, 0, commandSet); return;
+
+                // Default Behavior
+                default:
+                    if (!mainFeature.ProcessArgs(args, 0))
+                    {
+                        commandSet.OutputAllHelp();
+                        return;
+                    }
+                    else if (!mainFeature.VerifyInputs())
+                    {
+                        Console.Error.WriteLine("At least one input is required");
+                        commandSet.OutputAllHelp();
+                        return;
+                    }
+
+                    mainFeature.Execute();
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Create the command set for the program
+        /// </summary>
+        private static CommandSet CreateCommands(MainFeature mainFeature)
+        {
+            List<string> header = [
+                "Information Printing Program",
+                string.Empty,
+                "InfoPrint <options> file|directory ...",
+                string.Empty,
+            ];
+
+            var commandSet = new CommandSet(header);
+
+            commandSet.Add(new Help(["-?", "-h", "--help"]));
+            commandSet.Add(mainFeature.DebugInput);
+            commandSet.Add(mainFeature.HashInput);
+            commandSet.Add(mainFeature.FileOnlyInput);
+#if NETCOREAPP
+            commandSet.Add(mainFeature.JsonInput);
+#endif
+
+            return commandSet;
+        }
+    }
+}

LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2018-2025 Matt Nadareski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.MD

@@ -1,29 +1,121 @@
 # SabreTools.Serialization
 
+[![Build and Test](https://github.com/SabreTools/SabreTools.Serialization/actions/workflows/build_and_test.yml/badge.svg)](https://github.com/SabreTools/SabreTools.Serialization/actions/workflows/build_and_test.yml)
+
 This library comprises of serializers that both read and write from files and streams to the dedicated models as well as convert to and from the common internal models. This library is partially used by the current parsing and writing code but none of the internal model serialization is used.
 
 Find the link to the Nuget package [here](https://www.nuget.org/packages/SabreTools.Serialization).
 
-## `SabreTools.Serialization.Bytes`
+The following non-project libraries (or ports thereof) are used for file handling:
 
-This namespace comprises of deserializers that take byte arrays to convert into models.
+- [GrindCore.SharpCompress](https://github.com/Nanook/GrindCore.SharpCompress) - Common archive format extraction
+- [StormLibSharp](https://github.com/robpaveza/stormlibsharp) - MoPaQ extraction [Unused in non-Windows builds due to Windows-specific libraries]
 
-## `SabreTools.Serialization.CrossModel`
+The following projects have influenced this library:
 
-This namespace comprises of serializers and deserializers that convert models to other common ones. This is mainly used for metadata files converting to and from a common, `Dictionary`-based model.
+- [libmspack](https://github.com/kyz/libmspack) - Documentation around the MS-CAB format and associated compression methods.
+- [Unshield](https://github.com/twogood/unshield/) - InstallShield CAB extraction tool that influenced internal handling
 
-## `SabreTools.Serialization.Files`
+## Releases
 
-This namespace comprises of serializers and deserializers that can convert to and from files on disk. Most of the serializers are symmetric, but this is not guaranteed. Unimplemented methods will throw `NotImplementedException`.
+For the most recent stable build, download the latest release here: [Releases Page](https://github.com/SabreTools/SabreTools.Serialization/releases)
 
-## `SabreTools.Serialization.Streams`
+For the latest WIP build here: [Rolling Release](https://github.com/SabreTools/SabreTools.Serialization/releases/tag/rolling)
 
-This namespace comprises of serializers and deserializers that can convert to and from any type of stream. Most of the serializers are symmetric, but this is not guaranteed. Unimplemented methods will throw `NotImplementedException`.
+## InfoPrint
 
-## `SabreTools.Serialization.Strings`
+**InfoPrint** is a reference implementation for the deserialization and printing features of the library, packaged as a standalone executable for all supported platforms. It will attempt to detect and display information about many supported file types, optionally both hashing the file and outputting the information to a JSON file (.NET Core 3.1 and above only).
 
-This namespace comprises of serializers and deserializers that can convert to and from strings. Most of the serializers are symmetric, but this is not guaranteed. Unimplemented methods will throw `NotImplementedException`.
+```text
+InfoPrint <options> file|directory ...
 
-## `SabreTools.Serialization.Wrappers`
+Options:
+-?, -h, --help           Display this help text
+-d, --debug              Enable debug mode
+-c, --hash               Output file hashes
+-f, --file               Print to file only
+-j, --json               Print info as JSON
+```
 
-This namespace comrpises of wrapping classes that include keeping a reference to the source of each serializable model. Some of the wrappers may also include what are referred to as "extension properties", which are generated properties derived from either parts of the model or the underlying source.
+## ExtractionTool
+
+**ExtractionTool** is a reference implementation for the extraction features of the library, packaged as a standalone executable for all supported platforms. It will attempt to detect and extract many supported file types. See the table below for supported extraction functionality.
+
+```text
+ExtractionTool <options> file|directory ...
+
+Options:
+-?, -h, --help           Display this help text
+-d, --debug              Enable debug mode
+-o, --outdir [PATH]      Set output path for extraction (required)
+```
+
+| Format Name | Notes |
+| --- | --- |
+| 7-zip archive | .NET Framework 4.6.2 and greater |
+| BFPK custom archive format | |
+| bzip2 archive | .NET Framework 4.6.2 and greater |
+| Compound File Binary (CFB) | Only CFB common pieces extractable |
+| gzip archive | |
+| Half-Life Game Cache File (GCF) | |
+| Half-Life Level (BSP) | |
+| Half-Life Package File (PAK) | |
+| Half-Life Texture Package File (WAD3) | |
+| Half-Life 2 Level (VBSP) | |
+| InstallShield Archive V3 (Z) | |
+| InstallShield CAB | |
+| Microsoft cabinet file | Does not support LZX or Quantum compression |
+| Microsoft LZ-compressed files | KWAJ, QBasic, and SZDD variants |
+| MoPaQ game data archive (MPQ) | Windows only |
+| New Exectuable | Embedded archives and executables in the overlay and Wise installer |
+| NovaLogic Game Archive Format (PFF) | |
+| PKZIP and derived files (ZIP, etc.) | .NET Framework 4.6.2 and greater |
+| Portable Executable | Embedded archives and executables in the resources and overlay, CExe-packed data, SFX archives (7-zip, PKZIP, and RAR), and Wise installer |
+| Quantum archive (Q) | Currently not working |
+| RAR archive (RAR) | .NET Framework 4.6.2 and greater |
+| SGA game archive | |
+| Tape archive (TAR) | |
+| Valve Package File (VPK) | |
+| XBox Package File (XZP) | |
+| xz archive (XZ) | .NET Framework 4.6.2 and greater |
+
+## Interfaces
+
+Below is a table representing the various conversion interfaces that are implemented within this library.
+
+| Interface Name | Source Type | Destination Type |
+| --- | --- | --- |
+| `SabreTools.Serialization.Interfaces.IByteReader<TModel>` | `byte[]?` | `TModel` |
+| `SabreTools.Serialization.Interfaces.IByteWriter<TModel>` | `TModel` | `byte[]?` |
+| `SabreTools.Serialization.Interfaces.ICrossModel<TSource, TDest>` | `TSource`/`TDest` | `TDest`/`TSource` |
+| `SabreTools.Serialization.Interfaces.IFileReader<TModel>` | `string?` path | `TModel` |
+| `SabreTools.Serialization.Interfaces.IFileWriter<TModel>` | `TModel` | `string?` path |
+| `SabreTools.Serialization.Interfaces.IStreamReader<TModel>` | `Stream?` | `TModel` |
+| `SabreTools.Serialization.Interfaces.IStreamWriter<TModel>` | `TModel` | `Stream?` |
+| `SabreTools.Serialization.Interfaces.IStringReader<TModel>` | `string?` representation | `TModel` |
+| `SabreTools.Serialization.Interfaces.IStringWriter<TModel>` | `TModel` | `string?` representation |
+
+Below is a table representing the various non-conversion interfaces that are implemented within this library.
+
+| Interface Name | Purpose |
+| --- | --- |
+| `SabreTools.Serialization.Wrappers.IExtractable` | Marks a wrapper as able to be extracted |
+| `SabreTools.Serialization.Wrappers.IPrintable` | Marks a wrapper as able to print model information |
+| `SabreTools.Serialization.Wrappers.IWrapper` | Represents an item with a description and JSON serializable state, allowing for extensions |
+| `SabreTools.Serialization.Wrappers.IWrapper<TModel>` | Wraps a model with source data, allowing for extensions |
+
+## Namespaces
+
+Below is a table of all namespaces within the library and what they represent
+
+| Namespace | Description |
+| --- | --- |
+| `SabreTools.Data.Attributes` | Common attributes for data marking and manipulation |
+| `SabreTools.Data.Extensions` | Extension methods related to models |
+| `SabreTools.Data.Models` | Models representing different file and structure types |
+| `SabreTools.Data.ObjectIdentifier` | Object Identifier (OID) parsing |
+| `SabreTools.Serialization.CrossModel` | Convert between models; mainly used for metadata files converting to and from a common, `Dictionary`-based model |
+| `SabreTools.Serialization.Interfaces` | Interfaces used commonly throughout the library |
+| `SabreTools.Serialization.Readers` | Convert from external sources to models |
+| `SabreTools.Serialization.Wrappers` | Classes that wrap serialization and models to allow for including extension properties |
+| `SabreTools.Serialization.Writers` | Convert from models to external sources |

SabreTools.Serialization.Test/CrossModel/ArchiveDotOrgTests.cs

@@ -0,0 +1,174 @@
+using SabreTools.Serialization.CrossModel;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.CrossModel
+{
+    public class ArchiveDotOrgTests
+    {
+        [Fact]
+        public void RoundTripTest()
+        {
+            // Get the cross-model serializer
+            var serializer = new ArchiveDotOrg();
+
+            // Build the data
+            Data.Models.ArchiveDotOrg.Files files = Build();
+
+            // Serialize to generic model
+            SabreTools.Data.Models.Metadata.MetadataFile? metadata = serializer.Serialize(files);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.ArchiveDotOrg.Files? newFiles = serializer.Deserialize(metadata);
+
+            // Validate the data
+            Assert.NotNull(newFiles);
+            Assert.NotNull(newFiles.File);
+            var newFile = Assert.Single(newFiles.File);
+            Validate(newFile);
+        }
+
+        /// <summary>
+        /// Build model for serialization and deserialization
+        /// </summary>
+        private static Data.Models.ArchiveDotOrg.Files Build()
+        {
+            var file = new Data.Models.ArchiveDotOrg.File
+            {
+                Name = "XXXXXX",
+                Source = "XXXXXX",
+                BitTorrentMagnetHash = "XXXXXX",
+                LastModifiedTime = "XXXXXX",
+                Size = "XXXXXX",
+                MD5 = "XXXXXX",
+                CRC32 = "XXXXXX",
+                SHA1 = "XXXXXX",
+                FileCount = "XXXXXX",
+                Format = "XXXXXX",
+                Original = "XXXXXX",
+                Summation = "XXXXXX",
+                MatrixNumber = "XXXXXX",
+                CollectionCatalogNumber = "XXXXXX",
+                Publisher = "XXXXXX",
+                Comment = "XXXXXX",
+                ASRDetectedLang = "XXXXXX",
+                ASRDetectedLangConf = "XXXXXX",
+                ASRTranscribedLang = "XXXXXX",
+                WhisperASRModuleVersion = "XXXXXX",
+                WhisperModelHash = "XXXXXX",
+                WhisperModelName = "XXXXXX",
+                WhisperVersion = "XXXXXX",
+                ClothCoverDetectionModuleVersion = "XXXXXX",
+                hOCRCharToWordhOCRVersion = "XXXXXX",
+                hOCRCharToWordModuleVersion = "XXXXXX",
+                hOCRFtsTexthOCRVersion = "XXXXXX",
+                hOCRFtsTextModuleVersion = "XXXXXX",
+                hOCRPageIndexhOCRVersion = "XXXXXX",
+                hOCRPageIndexModuleVersion = "XXXXXX",
+                TesseractOCR = "XXXXXX",
+                TesseractOCRConverted = "XXXXXX",
+                TesseractOCRDetectedLang = "XXXXXX",
+                TesseractOCRDetectedLangConf = "XXXXXX",
+                TesseractOCRDetectedScript = "XXXXXX",
+                TesseractOCRDetectedScriptConf = "XXXXXX",
+                TesseractOCRModuleVersion = "XXXXXX",
+                TesseractOCRParameters = "XXXXXX",
+                PDFModuleVersion = "XXXXXX",
+                WordConfidenceInterval0To10 = "XXXXXX",
+                WordConfidenceInterval11To20 = "XXXXXX",
+                WordConfidenceInterval21To30 = "XXXXXX",
+                WordConfidenceInterval31To40 = "XXXXXX",
+                WordConfidenceInterval41To50 = "XXXXXX",
+                WordConfidenceInterval51To60 = "XXXXXX",
+                WordConfidenceInterval61To70 = "XXXXXX",
+                WordConfidenceInterval71To80 = "XXXXXX",
+                WordConfidenceInterval81To90 = "XXXXXX",
+                WordConfidenceInterval91To100 = "XXXXXX",
+                Album = "XXXXXX",
+                Artist = "XXXXXX",
+                Bitrate = "XXXXXX",
+                Creator = "XXXXXX",
+                Height = "XXXXXX",
+                Length = "XXXXXX",
+                PreviewImage = "XXXXXX",
+                Rotation = "XXXXXX",
+                Title = "XXXXXX",
+                Track = "XXXXXX",
+                Width = "XXXXXX",
+            };
+
+            return new Data.Models.ArchiveDotOrg.Files
+            {
+                File = [file]
+            };
+        }
+
+        /// <summary>
+        /// Validate a File
+        /// </summary>
+        private static void Validate(Data.Models.ArchiveDotOrg.File? file)
+        {
+            Assert.NotNull(file);
+            Assert.Equal("XXXXXX", file.Name);
+            Assert.Equal("XXXXXX", file.Source);
+            Assert.Equal("XXXXXX", file.BitTorrentMagnetHash);
+            Assert.Equal("XXXXXX", file.LastModifiedTime);
+            Assert.Equal("XXXXXX", file.Size);
+            Assert.Equal("XXXXXX", file.MD5);
+            Assert.Equal("XXXXXX", file.CRC32);
+            Assert.Equal("XXXXXX", file.SHA1);
+            Assert.Equal("XXXXXX", file.FileCount);
+            Assert.Equal("XXXXXX", file.Format);
+            Assert.Equal("XXXXXX", file.Original);
+            Assert.Equal("XXXXXX", file.Summation);
+            Assert.Equal("XXXXXX", file.MatrixNumber);
+            Assert.Equal("XXXXXX", file.CollectionCatalogNumber);
+            Assert.Equal("XXXXXX", file.Publisher);
+            Assert.Equal("XXXXXX", file.Comment);
+            Assert.Equal("XXXXXX", file.ASRDetectedLang);
+            Assert.Equal("XXXXXX", file.ASRDetectedLangConf);
+            Assert.Equal("XXXXXX", file.ASRTranscribedLang);
+            Assert.Equal("XXXXXX", file.WhisperASRModuleVersion);
+            Assert.Equal("XXXXXX", file.WhisperModelHash);
+            Assert.Equal("XXXXXX", file.WhisperModelName);
+            Assert.Equal("XXXXXX", file.WhisperVersion);
+            Assert.Equal("XXXXXX", file.ClothCoverDetectionModuleVersion);
+            Assert.Equal("XXXXXX", file.hOCRCharToWordhOCRVersion);
+            Assert.Equal("XXXXXX", file.hOCRCharToWordModuleVersion);
+            Assert.Equal("XXXXXX", file.hOCRFtsTexthOCRVersion);
+            Assert.Equal("XXXXXX", file.hOCRFtsTextModuleVersion);
+            Assert.Equal("XXXXXX", file.hOCRPageIndexhOCRVersion);
+            Assert.Equal("XXXXXX", file.hOCRPageIndexModuleVersion);
+            Assert.Equal("XXXXXX", file.TesseractOCR);
+            Assert.Equal("XXXXXX", file.TesseractOCRConverted);
+            Assert.Equal("XXXXXX", file.TesseractOCRDetectedLang);
+            Assert.Equal("XXXXXX", file.TesseractOCRDetectedLangConf);
+            Assert.Equal("XXXXXX", file.TesseractOCRDetectedScript);
+            Assert.Equal("XXXXXX", file.TesseractOCRDetectedScriptConf);
+            Assert.Equal("XXXXXX", file.TesseractOCRModuleVersion);
+            Assert.Equal("XXXXXX", file.TesseractOCRParameters);
+            Assert.Equal("XXXXXX", file.PDFModuleVersion);
+            Assert.Equal("XXXXXX", file.WordConfidenceInterval0To10);
+            Assert.Equal("XXXXXX", file.WordConfidenceInterval11To20);
+            Assert.Equal("XXXXXX", file.WordConfidenceInterval21To30);
+            Assert.Equal("XXXXXX", file.WordConfidenceInterval31To40);
+            Assert.Equal("XXXXXX", file.WordConfidenceInterval41To50);
+            Assert.Equal("XXXXXX", file.WordConfidenceInterval51To60);
+            Assert.Equal("XXXXXX", file.WordConfidenceInterval61To70);
+            Assert.Equal("XXXXXX", file.WordConfidenceInterval71To80);
+            Assert.Equal("XXXXXX", file.WordConfidenceInterval81To90);
+            Assert.Equal("XXXXXX", file.WordConfidenceInterval91To100);
+            Assert.Equal("XXXXXX", file.Album);
+            Assert.Equal("XXXXXX", file.Artist);
+            Assert.Equal("XXXXXX", file.Bitrate);
+            Assert.Equal("XXXXXX", file.Creator);
+            Assert.Equal("XXXXXX", file.Height);
+            Assert.Equal("XXXXXX", file.Length);
+            Assert.Equal("XXXXXX", file.PreviewImage);
+            Assert.Equal("XXXXXX", file.Rotation);
+            Assert.Equal("XXXXXX", file.Title);
+            Assert.Equal("XXXXXX", file.Track);
+            Assert.Equal("XXXXXX", file.Width);
+        }
+    }
+}

SabreTools.Serialization.Test/CrossModel/AttractModeTests.cs

@@ -0,0 +1,112 @@
+using SabreTools.Serialization.CrossModel;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.CrossModel
+{
+    public class AttractModeTests
+    {
+        [Fact]
+        public void RoundTripTest()
+        {
+            // Get the cross-model serializer
+            var serializer = new AttractMode();
+
+            // Build the data
+            Data.Models.AttractMode.MetadataFile mf = Build();
+
+            // Serialize to generic model
+            Data.Models.Metadata.MetadataFile? metadata = serializer.Serialize(mf);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.AttractMode.MetadataFile? newMf = serializer.Deserialize(metadata);
+
+            // Validate the data
+            Assert.NotNull(newMf);
+            Validate(newMf.Header);
+            Assert.NotNull(newMf.Row);
+            var newRow = Assert.Single(newMf.Row);
+            Validate(newRow);
+        }
+
+        /// <summary>
+        /// Build model for serialization and deserialization
+        /// </summary>
+        private static Data.Models.AttractMode.MetadataFile Build()
+        {
+            string[] header = ["header"];
+
+            var row = new Data.Models.AttractMode.Row
+            {
+                Name = "XXXXXX",
+                Title = "XXXXXX",
+                Emulator = "XXXXXX",
+                CloneOf = "XXXXXX",
+                Year = "XXXXXX",
+                Manufacturer = "XXXXXX",
+                Category = "XXXXXX",
+                Players = "XXXXXX",
+                Rotation = "XXXXXX",
+                Control = "XXXXXX",
+                Status = "XXXXXX",
+                DisplayCount = "XXXXXX",
+                DisplayType = "XXXXXX",
+                AltRomname = "XXXXXX",
+                AltTitle = "XXXXXX",
+                Extra = "XXXXXX",
+                Buttons = "XXXXXX",
+                Favorite = "XXXXXX",
+                Tags = "XXXXXX",
+                PlayedCount = "XXXXXX",
+                PlayedTime = "XXXXXX",
+                FileIsAvailable = "XXXXXX",
+            };
+
+            return new Data.Models.AttractMode.MetadataFile
+            {
+                Header = header,
+                Row = [row],
+            };
+        }
+
+        /// <summary>
+        /// Validate a header
+        /// </summary>
+        private static void Validate(string[]? header)
+        {
+            Assert.NotNull(header);
+            string column = Assert.Single(header);
+            Assert.Equal("header", column);
+        }
+
+        /// <summary>
+        /// Validate a Row
+        /// </summary>
+        private static void Validate(Data.Models.AttractMode.Row? row)
+        {
+            Assert.NotNull(row);
+            Assert.Equal("XXXXXX", row.Name);
+            Assert.Equal("XXXXXX", row.Title);
+            Assert.Equal("XXXXXX", row.Emulator);
+            Assert.Equal("XXXXXX", row.CloneOf);
+            Assert.Equal("XXXXXX", row.Year);
+            Assert.Equal("XXXXXX", row.Manufacturer);
+            Assert.Equal("XXXXXX", row.Category);
+            Assert.Equal("XXXXXX", row.Players);
+            Assert.Equal("XXXXXX", row.Rotation);
+            Assert.Equal("XXXXXX", row.Control);
+            Assert.Equal("XXXXXX", row.Status);
+            Assert.Equal("XXXXXX", row.DisplayCount);
+            Assert.Equal("XXXXXX", row.DisplayType);
+            Assert.Equal("XXXXXX", row.AltRomname);
+            Assert.Equal("XXXXXX", row.AltTitle);
+            Assert.Equal("XXXXXX", row.Extra);
+            Assert.Equal("XXXXXX", row.Buttons);
+            Assert.Equal("XXXXXX", row.Favorite);
+            Assert.Equal("XXXXXX", row.Tags);
+            Assert.Equal("XXXXXX", row.PlayedCount);
+            Assert.Equal("XXXXXX", row.PlayedTime);
+            Assert.Equal("XXXXXX", row.FileIsAvailable);
+        }
+    }
+}

SabreTools.Serialization.Test/CrossModel/ClrMameProTests.cs

@@ -0,0 +1,501 @@
+using SabreTools.Serialization.CrossModel;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.CrossModel
+{
+    public class ClrMameProTests
+    {
+        [Fact]
+        public void RoundTripGameTest()
+        {
+            // Get the cross-model serializer
+            var serializer = new ClrMamePro();
+
+            // Build the data
+            Data.Models.ClrMamePro.MetadataFile mf = Build(game: true);
+
+            // Serialize to generic model
+            Data.Models.Metadata.MetadataFile? metadata = serializer.Serialize(mf);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.ClrMamePro.MetadataFile? newMf = serializer.Deserialize(metadata, game: true);
+
+            // Validate the data
+            Assert.NotNull(newMf);
+            Validate(newMf.ClrMamePro);
+            Assert.NotNull(newMf.Game);
+            var newGame = Assert.Single(newMf.Game);
+            Validate(newGame);
+        }
+
+        [Fact]
+        public void RoundTripMachineTest()
+        {
+            // Get the cross-model serializer
+            var serializer = new ClrMamePro();
+
+            // Build the data
+            Data.Models.ClrMamePro.MetadataFile mf = Build(game: false);
+
+            // Serialize to generic model
+            Data.Models.Metadata.MetadataFile? metadata = serializer.Serialize(mf);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.ClrMamePro.MetadataFile? newMf = serializer.Deserialize(metadata, game: false);
+
+            // Validate the data
+            Assert.NotNull(newMf);
+            Validate(newMf.ClrMamePro);
+            Assert.NotNull(newMf.Game);
+            var newGame = Assert.Single(newMf.Game);
+            Validate(newGame);
+        }
+
+        /// <summary>
+        /// Build model for serialization and deserialization
+        /// </summary>
+        private static Data.Models.ClrMamePro.MetadataFile Build(bool game)
+        {
+            var cmp = new Data.Models.ClrMamePro.ClrMamePro
+            {
+                Name = "XXXXXX",
+                Description = "XXXXXX",
+                RootDir = "XXXXXX",
+                Category = "XXXXXX",
+                Version = "XXXXXX",
+                Date = "XXXXXX",
+                Author = "XXXXXX",
+                Homepage = "XXXXXX",
+                Url = "XXXXXX",
+                Comment = "XXXXXX",
+                Header = "XXXXXX",
+                Type = "XXXXXX",
+                ForceMerging = "XXXXXX",
+                ForceZipping = "XXXXXX",
+                ForcePacking = "XXXXXX",
+            };
+
+            var release = new Data.Models.ClrMamePro.Release
+            {
+                Name = "XXXXXX",
+                Region = "XXXXXX",
+                Language = "XXXXXX",
+                Date = "XXXXXX",
+                Default = "XXXXXX",
+            };
+
+            var biosset = new Data.Models.ClrMamePro.BiosSet
+            {
+                Name = "XXXXXX",
+                Description = "XXXXXX",
+                Default = "XXXXXX",
+            };
+
+            var rom = new Data.Models.ClrMamePro.Rom
+            {
+                Name = "XXXXXX",
+                Size = "XXXXXX",
+                CRC = "XXXXXX",
+                MD2 = "XXXXXX",
+                MD4 = "XXXXXX",
+                MD5 = "XXXXXX",
+                RIPEMD128 = "XXXXXX",
+                RIPEMD160 = "XXXXXX",
+                SHA1 = "XXXXXX",
+                Merge = "XXXXXX",
+                Status = "XXXXXX",
+                Flags = "XXXXXX",
+                Date = "XXXXXX",
+                SHA256 = "XXXXXX",
+                SHA384 = "XXXXXX",
+                SHA512 = "XXXXXX",
+                SpamSum = "XXXXXX",
+                xxHash364 = "XXXXXX",
+                xxHash3128 = "XXXXXX",
+                Region = "XXXXXX",
+                Offs = "XXXXXX",
+                Serial = "XXXXXX",
+                Header = "XXXXXX",
+                Inverted = "XXXXXX",
+                MIA = "XXXXXX",
+            };
+
+            var disk = new Data.Models.ClrMamePro.Disk
+            {
+                Name = "XXXXXX",
+                MD5 = "XXXXXX",
+                SHA1 = "XXXXXX",
+                Merge = "XXXXXX",
+                Status = "XXXXXX",
+                Flags = "XXXXXX",
+            };
+
+            var sample = new Data.Models.ClrMamePro.Sample
+            {
+                Name = "XXXXXX",
+            };
+
+            var archive = new Data.Models.ClrMamePro.Archive
+            {
+                Name = "XXXXXX",
+            };
+
+            var media = new Data.Models.ClrMamePro.Media
+            {
+                Name = "XXXXXX",
+                MD5 = "XXXXXX",
+                SHA1 = "XXXXXX",
+                SHA256 = "XXXXXX",
+                SpamSum = "XXXXXX",
+            };
+
+            var chip = new Data.Models.ClrMamePro.Chip
+            {
+                Type = "XXXXXX",
+                Name = "XXXXXX",
+                Flags = "XXXXXX",
+                Clock = "XXXXXX",
+            };
+
+            var video = new Data.Models.ClrMamePro.Video
+            {
+                Screen = "XXXXXX",
+                Orientation = "XXXXXX",
+                X = "XXXXXX",
+                Y = "XXXXXX",
+                AspectX = "XXXXXX",
+                AspectY = "XXXXXX",
+                Freq = "XXXXXX",
+            };
+
+            var sound = new Data.Models.ClrMamePro.Sound
+            {
+                Channels = "XXXXXX",
+            };
+
+            var input = new Data.Models.ClrMamePro.Input
+            {
+                Players = "XXXXXX",
+                Control = "XXXXXX",
+                Buttons = "XXXXXX",
+                Coins = "XXXXXX",
+                Tilt = "XXXXXX",
+                Service = "XXXXXX",
+            };
+
+            var dipswitch = new Data.Models.ClrMamePro.DipSwitch
+            {
+                Name = "XXXXXX",
+                Entry = ["XXXXXX"],
+                Default = "XXXXXX",
+            };
+
+            var driver = new Data.Models.ClrMamePro.Driver
+            {
+                Status = "XXXXXX",
+                Color = "XXXXXX",
+                Sound = "XXXXXX",
+                PaletteSize = "XXXXXX",
+                Blit = "XXXXXX",
+            };
+
+            // TODO: This omits Set, should that have a separate case?
+            Data.Models.ClrMamePro.GameBase gameBase = game
+                ? new Data.Models.ClrMamePro.Game()
+                : new Data.Models.ClrMamePro.Machine();
+            gameBase.Name = "XXXXXX";
+            gameBase.Description = "XXXXXX";
+            gameBase.Year = "XXXXXX";
+            gameBase.Manufacturer = "XXXXXX";
+            gameBase.Category = "XXXXXX";
+            gameBase.CloneOf = "XXXXXX";
+            gameBase.RomOf = "XXXXXX";
+            gameBase.SampleOf = "XXXXXX";
+            gameBase.Release = [release];
+            gameBase.BiosSet = [biosset];
+            gameBase.Rom = [rom];
+            gameBase.Disk = [disk];
+            gameBase.Sample = [sample];
+            gameBase.Archive = [archive];
+            gameBase.Media = [media];
+            gameBase.Chip = [chip];
+            gameBase.Video = [video];
+            gameBase.Sound = sound;
+            gameBase.Input = input;
+            gameBase.DipSwitch = [dipswitch];
+            gameBase.Driver = driver;
+
+            return new Data.Models.ClrMamePro.MetadataFile
+            {
+                ClrMamePro = cmp,
+                Game = [gameBase],
+            };
+        }
+
+        /// <summary>
+        /// Validate a ClrMamePro
+        /// </summary>
+        private static void Validate(Data.Models.ClrMamePro.ClrMamePro? cmp)
+        {
+            Assert.NotNull(cmp);
+            Assert.Equal("XXXXXX", cmp.Name);
+            Assert.Equal("XXXXXX", cmp.Description);
+            Assert.Equal("XXXXXX", cmp.RootDir);
+            Assert.Equal("XXXXXX", cmp.Category);
+            Assert.Equal("XXXXXX", cmp.Version);
+            Assert.Equal("XXXXXX", cmp.Date);
+            Assert.Equal("XXXXXX", cmp.Author);
+            Assert.Equal("XXXXXX", cmp.Homepage);
+            Assert.Equal("XXXXXX", cmp.Url);
+            Assert.Equal("XXXXXX", cmp.Comment);
+            Assert.Equal("XXXXXX", cmp.Header);
+            Assert.Equal("XXXXXX", cmp.Type);
+            Assert.Equal("XXXXXX", cmp.ForceMerging);
+            Assert.Equal("XXXXXX", cmp.ForceZipping);
+            Assert.Equal("XXXXXX", cmp.ForcePacking);
+        }
+
+        /// <summary>
+        /// Validate a GameBase
+        /// </summary>
+        private static void Validate(Data.Models.ClrMamePro.GameBase? gb)
+        {
+            Assert.NotNull(gb);
+            Assert.Equal("XXXXXX", gb.Name);
+            Assert.Equal("XXXXXX", gb.Description);
+            Assert.Equal("XXXXXX", gb.Year);
+            Assert.Equal("XXXXXX", gb.Manufacturer);
+            Assert.Equal("XXXXXX", gb.Category);
+            Assert.Equal("XXXXXX", gb.CloneOf);
+            Assert.Equal("XXXXXX", gb.RomOf);
+            Assert.Equal("XXXXXX", gb.SampleOf);
+
+            Assert.NotNull(gb.Release);
+            var release = Assert.Single(gb.Release);
+            Validate(release);
+
+            Assert.NotNull(gb.BiosSet);
+            var biosset = Assert.Single(gb.BiosSet);
+            Validate(biosset);
+
+            Assert.NotNull(gb.Rom);
+            var rom = Assert.Single(gb.Rom);
+            Validate(rom);
+
+            Assert.NotNull(gb.Disk);
+            var disk = Assert.Single(gb.Disk);
+            Validate(disk);
+
+            Assert.NotNull(gb.Sample);
+            var sample = Assert.Single(gb.Sample);
+            Validate(sample);
+
+            Assert.NotNull(gb.Archive);
+            var archive = Assert.Single(gb.Archive);
+            Validate(archive);
+
+            Assert.NotNull(gb.Media);
+            var media = Assert.Single(gb.Media);
+            Validate(media);
+
+            Assert.NotNull(gb.Chip);
+            var chip = Assert.Single(gb.Chip);
+            Validate(chip);
+
+            Assert.NotNull(gb.Video);
+            var video = Assert.Single(gb.Video);
+            Validate(video);
+
+            Validate(gb.Sound);
+            Validate(gb.Input);
+
+            Assert.NotNull(gb.DipSwitch);
+            var dipswitch = Assert.Single(gb.DipSwitch);
+            Validate(dipswitch);
+
+            Validate(gb.Driver);
+        }
+
+        /// <summary>
+        /// Validate a Release
+        /// </summary>
+        private static void Validate(Data.Models.ClrMamePro.Release? release)
+        {
+            Assert.NotNull(release);
+            Assert.Equal("XXXXXX", release.Name);
+            Assert.Equal("XXXXXX", release.Region);
+            Assert.Equal("XXXXXX", release.Language);
+            Assert.Equal("XXXXXX", release.Date);
+            Assert.Equal("XXXXXX", release.Default);
+        }
+
+        /// <summary>
+        /// Validate a BiosSet
+        /// </summary>
+        private static void Validate(Data.Models.ClrMamePro.BiosSet? biosset)
+        {
+            Assert.NotNull(biosset);
+            Assert.Equal("XXXXXX", biosset.Name);
+            Assert.Equal("XXXXXX", biosset.Description);
+            Assert.Equal("XXXXXX", biosset.Default);
+        }
+
+        /// <summary>
+        /// Validate a Rom
+        /// </summary>
+        private static void Validate(Data.Models.ClrMamePro.Rom? rom)
+        {
+            Assert.NotNull(rom);
+            Assert.Equal("XXXXXX", rom.Name);
+            Assert.Equal("XXXXXX", rom.Size);
+            Assert.Equal("XXXXXX", rom.CRC);
+            Assert.Equal("XXXXXX", rom.MD2);
+            Assert.Equal("XXXXXX", rom.MD4);
+            Assert.Equal("XXXXXX", rom.MD5);
+            Assert.Equal("XXXXXX", rom.RIPEMD128);
+            Assert.Equal("XXXXXX", rom.RIPEMD160);
+            Assert.Equal("XXXXXX", rom.SHA1);
+            Assert.Equal("XXXXXX", rom.Merge);
+            Assert.Equal("XXXXXX", rom.Status);
+            Assert.Equal("XXXXXX", rom.Flags);
+            Assert.Equal("XXXXXX", rom.Date);
+            Assert.Equal("XXXXXX", rom.SHA256);
+            Assert.Equal("XXXXXX", rom.SHA384);
+            Assert.Equal("XXXXXX", rom.SHA512);
+            Assert.Equal("XXXXXX", rom.SpamSum);
+            Assert.Equal("XXXXXX", rom.xxHash364);
+            Assert.Equal("XXXXXX", rom.xxHash3128);
+            Assert.Equal("XXXXXX", rom.Region);
+            Assert.Equal("XXXXXX", rom.Offs);
+            Assert.Equal("XXXXXX", rom.Serial);
+            Assert.Equal("XXXXXX", rom.Header);
+            Assert.Equal("XXXXXX", rom.Inverted);
+            Assert.Equal("XXXXXX", rom.MIA);
+        }
+
+        /// <summary>
+        /// Validate a Disk
+        /// </summary>
+        private static void Validate(Data.Models.ClrMamePro.Disk? disk)
+        {
+            Assert.NotNull(disk);
+            Assert.Equal("XXXXXX", disk.Name);
+            Assert.Equal("XXXXXX", disk.MD5);
+            Assert.Equal("XXXXXX", disk.SHA1);
+            Assert.Equal("XXXXXX", disk.Merge);
+            Assert.Equal("XXXXXX", disk.Status);
+            Assert.Equal("XXXXXX", disk.Flags);
+        }
+
+        /// <summary>
+        /// Validate a Sample
+        /// </summary>
+        private static void Validate(Data.Models.ClrMamePro.Sample? sample)
+        {
+            Assert.NotNull(sample);
+            Assert.Equal("XXXXXX", sample.Name);
+        }
+
+        /// <summary>
+        /// Validate a Archive
+        /// </summary>
+        private static void Validate(Data.Models.ClrMamePro.Archive? archive)
+        {
+            Assert.NotNull(archive);
+            Assert.Equal("XXXXXX", archive.Name);
+        }
+
+        /// <summary>
+        /// Validate a Media
+        /// </summary>
+        private static void Validate(Data.Models.ClrMamePro.Media? media)
+        {
+            Assert.NotNull(media);
+            Assert.Equal("XXXXXX", media.Name);
+            Assert.Equal("XXXXXX", media.MD5);
+            Assert.Equal("XXXXXX", media.SHA1);
+            Assert.Equal("XXXXXX", media.SHA256);
+            Assert.Equal("XXXXXX", media.SpamSum);
+        }
+
+        /// <summary>
+        /// Validate a Chip
+        /// </summary>
+        private static void Validate(Data.Models.ClrMamePro.Chip? chip)
+        {
+            Assert.NotNull(chip);
+            Assert.Equal("XXXXXX", chip.Type);
+            Assert.Equal("XXXXXX", chip.Name);
+            Assert.Equal("XXXXXX", chip.Flags);
+            Assert.Equal("XXXXXX", chip.Clock);
+        }
+
+        /// <summary>
+        /// Validate a Video
+        /// </summary>
+        private static void Validate(Data.Models.ClrMamePro.Video? video)
+        {
+            Assert.NotNull(video);
+            Assert.Equal("XXXXXX", video.Screen);
+            Assert.Equal("XXXXXX", video.Orientation);
+            Assert.Equal("XXXXXX", video.X);
+            Assert.Equal("XXXXXX", video.Y);
+            Assert.Equal("XXXXXX", video.AspectX);
+            Assert.Equal("XXXXXX", video.AspectY);
+            Assert.Equal("XXXXXX", video.Freq);
+        }
+
+        /// <summary>
+        /// Validate a Sound
+        /// </summary>
+        private static void Validate(Data.Models.ClrMamePro.Sound? sound)
+        {
+            Assert.NotNull(sound);
+            Assert.Equal("XXXXXX", sound.Channels);
+        }
+
+        /// <summary>
+        /// Validate a Input
+        /// </summary>
+        private static void Validate(Data.Models.ClrMamePro.Input? input)
+        {
+            Assert.NotNull(input);
+            Assert.Equal("XXXXXX", input.Players);
+            Assert.Equal("XXXXXX", input.Control);
+            Assert.Equal("XXXXXX", input.Buttons);
+            Assert.Equal("XXXXXX", input.Coins);
+            Assert.Equal("XXXXXX", input.Tilt);
+            Assert.Equal("XXXXXX", input.Service);
+        }
+
+        /// <summary>
+        /// Validate a DipSwitch
+        /// </summary>
+        private static void Validate(Data.Models.ClrMamePro.DipSwitch? dipswitch)
+        {
+            Assert.NotNull(dipswitch);
+            Assert.Equal("XXXXXX", dipswitch.Name);
+
+            Assert.NotNull(dipswitch.Entry);
+            string entry = Assert.Single(dipswitch.Entry);
+            Assert.Equal("XXXXXX", entry);
+
+            Assert.Equal("XXXXXX", dipswitch.Default);
+        }
+
+        /// <summary>
+        /// Validate a Driver
+        /// </summary>
+        private static void Validate(Data.Models.ClrMamePro.Driver? driver)
+        {
+            Assert.NotNull(driver);
+            Assert.Equal("XXXXXX", driver.Status);
+            Assert.Equal("XXXXXX", driver.Color);
+            Assert.Equal("XXXXXX", driver.Sound);
+            Assert.Equal("XXXXXX", driver.PaletteSize);
+            Assert.Equal("XXXXXX", driver.Blit);
+        }
+    }
+}

SabreTools.Serialization.Test/CrossModel/DosCenterTests.cs

@@ -0,0 +1,111 @@
+using SabreTools.Serialization.CrossModel;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.CrossModel
+{
+    public class DosCenterTests
+    {
+        [Fact]
+        public void RoundTripTest()
+        {
+            // Get the cross-model serializer
+            var serializer = new DosCenter();
+
+            // Build the data
+            Data.Models.DosCenter.MetadataFile mf = Build();
+
+            // Serialize to generic model
+            Data.Models.Metadata.MetadataFile? metadata = serializer.Serialize(mf);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.DosCenter.MetadataFile? newMf = serializer.Deserialize(metadata);
+
+            // Validate the data
+            Assert.NotNull(newMf);
+            Validate(newMf.DosCenter);
+            Assert.NotNull(newMf.Game);
+            var newGame = Assert.Single(newMf.Game);
+            Validate(newGame);
+        }
+
+        /// <summary>
+        /// Build model for serialization and deserialization
+        /// </summary>
+        private static Data.Models.DosCenter.MetadataFile Build()
+        {
+            var dc = new Data.Models.DosCenter.DosCenter
+            {
+                Name = "XXXXXX",
+                Description = "XXXXXX",
+                Version = "XXXXXX",
+                Date = "XXXXXX",
+                Author = "XXXXXX",
+                Homepage = "XXXXXX",
+                Comment = "XXXXXX",
+            };
+
+            var file = new Data.Models.DosCenter.File
+            {
+                Name = "XXXXXX",
+                Size = "XXXXXX",
+                CRC = "XXXXXX",
+                SHA1 = "XXXXXX",
+                Date = "XXXXXX",
+            };
+
+            var game = new Data.Models.DosCenter.Game
+            {
+                Name = "XXXXXX",
+                File = [file],
+            };
+
+            return new Data.Models.DosCenter.MetadataFile
+            {
+                DosCenter = dc,
+                Game = [game],
+            };
+        }
+
+        /// <summary>
+        /// Validate a DosCenter
+        /// </summary>
+        private static void Validate(Data.Models.DosCenter.DosCenter? cmp)
+        {
+            Assert.NotNull(cmp);
+            Assert.Equal("XXXXXX", cmp.Name);
+            Assert.Equal("XXXXXX", cmp.Description);
+            Assert.Equal("XXXXXX", cmp.Version);
+            Assert.Equal("XXXXXX", cmp.Date);
+            Assert.Equal("XXXXXX", cmp.Author);
+            Assert.Equal("XXXXXX", cmp.Homepage);
+            Assert.Equal("XXXXXX", cmp.Comment);
+        }
+
+        /// <summary>
+        /// Validate a Game
+        /// </summary>
+        private static void Validate(Data.Models.DosCenter.Game? game)
+        {
+            Assert.NotNull(game);
+            Assert.Equal("XXXXXX", game.Name);
+
+            Assert.NotNull(game.File);
+            var file = Assert.Single(game.File);
+            Validate(file);
+        }
+
+        /// <summary>
+        /// Validate a File
+        /// </summary>
+        private static void Validate(Data.Models.DosCenter.File? rom)
+        {
+            Assert.NotNull(rom);
+            Assert.Equal("XXXXXX", rom.Name);
+            Assert.Equal("XXXXXX", rom.Size);
+            Assert.Equal("XXXXXX", rom.CRC);
+            Assert.Equal("XXXXXX", rom.SHA1);
+            Assert.Equal("XXXXXX", rom.Date);
+        }
+    }
+}

SabreTools.Serialization.Test/CrossModel/EverdriveSMDBTests.cs

@@ -0,0 +1,66 @@
+using SabreTools.Serialization.CrossModel;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.CrossModel
+{
+    public class EverdriveSMDBTests
+    {
+        [Fact]
+        public void RoundTripTest()
+        {
+            // Get the cross-model serializer
+            var serializer = new EverdriveSMDB();
+
+            // Build the data
+            Data.Models.EverdriveSMDB.MetadataFile mf = Build();
+
+            // Serialize to generic model
+            Data.Models.Metadata.MetadataFile? metadata = serializer.Serialize(mf);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.EverdriveSMDB.MetadataFile? newMf = serializer.Deserialize(metadata);
+
+            // Validate the data
+            Assert.NotNull(newMf);
+            Assert.NotNull(newMf.Row);
+            var newRow = Assert.Single(newMf.Row);
+            Validate(newRow);
+        }
+
+        /// <summary>
+        /// Build model for serialization and deserialization
+        /// </summary>
+        private static Data.Models.EverdriveSMDB.MetadataFile Build()
+        {
+            var row = new Data.Models.EverdriveSMDB.Row
+            {
+                SHA256 = "XXXXXX",
+                Name = "XXXXXX",
+                SHA1 = "XXXXXX",
+                MD5 = "XXXXXX",
+                CRC32 = "XXXXXX",
+                Size = "XXXXXX",
+            };
+
+            return new Data.Models.EverdriveSMDB.MetadataFile
+            {
+                Row = [row],
+            };
+        }
+
+        /// <summary>
+        /// Validate a Row
+        /// </summary>
+        private static void Validate(Data.Models.EverdriveSMDB.Row? row)
+        {
+            Assert.NotNull(row);
+            Assert.Equal("XXXXXX", row.SHA256);
+            Assert.Equal("XXXXXX", row.Name);
+            Assert.Equal("XXXXXX", row.SHA1);
+            Assert.Equal("XXXXXX", row.MD5);
+            Assert.Equal("XXXXXX", row.CRC32);
+            Assert.Equal("XXXXXX", row.Size);
+        }
+    }
+}

SabreTools.Serialization.Test/CrossModel/HashfileTests.cs

@@ -0,0 +1,327 @@
+using System;
+using SabreTools.Hashing;
+using SabreTools.Serialization.CrossModel;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.CrossModel
+{
+    public class HashfileTests
+    {
+        [Fact]
+        public void RoundTripSFVTest()
+        {
+            // Get the cross-model serializer
+            var serializer = new Hashfile();
+
+            // Build the data
+            Data.Models.Hashfile.Hashfile hf = Build(HashType.CRC32);
+
+            // Serialize to generic model
+            Data.Models.Metadata.MetadataFile? metadata = serializer.Serialize(hf);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.Hashfile.Hashfile? newHf = serializer.Deserialize(metadata, HashType.CRC32);
+
+            // Validate the data
+            Assert.NotNull(newHf);
+            Assert.NotNull(newHf.SFV);
+            var newSfv = Assert.Single(newHf.SFV);
+            Validate(newSfv);
+        }
+
+        [Fact]
+        public void RoundTripMD2Test()
+        {
+            // Get the cross-model serializer
+            var serializer = new Hashfile();
+
+            // Build the data
+            Data.Models.Hashfile.Hashfile hf = Build(HashType.MD2);
+
+            // Serialize to generic model
+            Data.Models.Metadata.MetadataFile? metadata = serializer.Serialize(hf);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.Hashfile.Hashfile? newHf = serializer.Deserialize(metadata, HashType.MD2);
+
+            // Validate the data
+            Assert.NotNull(newHf);
+            Assert.NotNull(newHf.MD2);
+            var newMd2 = Assert.Single(newHf.MD2);
+            Validate(newMd2);
+        }
+
+        [Fact]
+        public void RoundTripMD4Test()
+        {
+            // Get the cross-model serializer
+            var serializer = new Hashfile();
+
+            // Build the data
+            Data.Models.Hashfile.Hashfile hf = Build(HashType.MD4);
+
+            // Serialize to generic model
+            Data.Models.Metadata.MetadataFile? metadata = serializer.Serialize(hf);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.Hashfile.Hashfile? newHf = serializer.Deserialize(metadata, HashType.MD4);
+
+            // Validate the data
+            Assert.NotNull(newHf);
+            Assert.NotNull(newHf.MD4);
+            var newMd4 = Assert.Single(newHf.MD4);
+            Validate(newMd4);
+        }
+
+        [Fact]
+        public void RoundTripMD5Test()
+        {
+            // Get the cross-model serializer
+            var serializer = new Hashfile();
+
+            // Build the data
+            Data.Models.Hashfile.Hashfile hf = Build(HashType.MD5);
+
+            // Serialize to generic model
+            Data.Models.Metadata.MetadataFile? metadata = serializer.Serialize(hf);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.Hashfile.Hashfile? newHf = serializer.Deserialize(metadata, HashType.MD5);
+
+            // Validate the data
+            Assert.NotNull(newHf);
+            Assert.NotNull(newHf.MD5);
+            var newMd5 = Assert.Single(newHf.MD5);
+            Validate(newMd5);
+        }
+
+        [Fact]
+        public void RoundTripSHA1Test()
+        {
+            // Get the cross-model serializer
+            var serializer = new Hashfile();
+
+            // Build the data
+            Data.Models.Hashfile.Hashfile hf = Build(HashType.SHA1);
+
+            // Serialize to generic model
+            Data.Models.Metadata.MetadataFile? metadata = serializer.Serialize(hf);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.Hashfile.Hashfile? newHf = serializer.Deserialize(metadata, HashType.SHA1);
+
+            // Validate the data
+            Assert.NotNull(newHf);
+            Assert.NotNull(newHf.SHA1);
+            var newSha1 = Assert.Single(newHf.SHA1);
+            Validate(newSha1);
+        }
+
+        [Fact]
+        public void RoundTripSHA256Test()
+        {
+            // Get the cross-model serializer
+            var serializer = new Hashfile();
+
+            // Build the data
+            Data.Models.Hashfile.Hashfile hf = Build(HashType.SHA256);
+
+            // Serialize to generic model
+            Data.Models.Metadata.MetadataFile? metadata = serializer.Serialize(hf);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.Hashfile.Hashfile? newHf = serializer.Deserialize(metadata, HashType.SHA256);
+
+            // Validate the data
+            Assert.NotNull(newHf);
+            Assert.NotNull(newHf.SHA256);
+            var newSha256 = Assert.Single(newHf.SHA256);
+            Validate(newSha256);
+        }
+
+        [Fact]
+        public void RoundTripSHA384Test()
+        {
+            // Get the cross-model serializer
+            var serializer = new Hashfile();
+
+            // Build the data
+            Data.Models.Hashfile.Hashfile hf = Build(HashType.SHA384);
+
+            // Serialize to generic model
+            Data.Models.Metadata.MetadataFile? metadata = serializer.Serialize(hf);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.Hashfile.Hashfile? newHf = serializer.Deserialize(metadata, HashType.SHA384);
+
+            // Validate the data
+            Assert.NotNull(newHf);
+            Assert.NotNull(newHf.SHA384);
+            var newSha384 = Assert.Single(newHf.SHA384);
+            Validate(newSha384);
+        }
+
+        [Fact]
+        public void RoundTripSHA512Test()
+        {
+            // Get the cross-model serializer
+            var serializer = new Hashfile();
+
+            // Build the data
+            Data.Models.Hashfile.Hashfile hf = Build(HashType.SHA512);
+
+            // Serialize to generic model
+            Data.Models.Metadata.MetadataFile? metadata = serializer.Serialize(hf);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.Hashfile.Hashfile? newHf = serializer.Deserialize(metadata, HashType.SHA512);
+
+            // Validate the data
+            Assert.NotNull(newHf);
+            Assert.NotNull(newHf.SHA512);
+            var newSha512 = Assert.Single(newHf.SHA512);
+            Validate(newSha512);
+        }
+
+        [Fact]
+        public void RoundTripSpamSumTest()
+        {
+            // Get the cross-model serializer
+            var serializer = new Hashfile();
+
+            // Build the data
+            Data.Models.Hashfile.Hashfile hf = Build(HashType.SpamSum);
+
+            // Serialize to generic model
+            Data.Models.Metadata.MetadataFile? metadata = serializer.Serialize(hf);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.Hashfile.Hashfile? newHf = serializer.Deserialize(metadata, HashType.SpamSum);
+
+            // Validate the data
+            Assert.NotNull(newHf);
+            Assert.NotNull(newHf.SpamSum);
+            var newSpamsum = Assert.Single(newHf.SpamSum);
+            Validate(newSpamsum);
+        }
+
+        /// <summary>
+        /// Build model for serialization and deserialization
+        /// </summary>
+        private static Data.Models.Hashfile.Hashfile Build(HashType hashType)
+        {
+            return hashType switch
+            {
+                HashType.CRC32 => new Data.Models.Hashfile.Hashfile { SFV = [new Data.Models.Hashfile.SFV { File = "XXXXXX", Hash = "XXXXXX" }] },
+                HashType.MD2 => new Data.Models.Hashfile.Hashfile { MD2 = [new Data.Models.Hashfile.MD2 { Hash = "XXXXXX", File = "XXXXXX" }] },
+                HashType.MD4 => new Data.Models.Hashfile.Hashfile { MD4 = [new Data.Models.Hashfile.MD4 { Hash = "XXXXXX", File = "XXXXXX" }] },
+                HashType.MD5 => new Data.Models.Hashfile.Hashfile { MD5 = [new Data.Models.Hashfile.MD5 { Hash = "XXXXXX", File = "XXXXXX" }] },
+                HashType.SHA1 => new Data.Models.Hashfile.Hashfile { SHA1 = [new Data.Models.Hashfile.SHA1 { Hash = "XXXXXX", File = "XXXXXX" }] },
+                HashType.SHA256 => new Data.Models.Hashfile.Hashfile { SHA256 = [new Data.Models.Hashfile.SHA256 { Hash = "XXXXXX", File = "XXXXXX" }] },
+                HashType.SHA384 => new Data.Models.Hashfile.Hashfile { SHA384 = [new Data.Models.Hashfile.SHA384 { Hash = "XXXXXX", File = "XXXXXX" }] },
+                HashType.SHA512 => new Data.Models.Hashfile.Hashfile { SHA512 = [new Data.Models.Hashfile.SHA512 { Hash = "XXXXXX", File = "XXXXXX" }] },
+                HashType.SpamSum => new Data.Models.Hashfile.Hashfile { SpamSum = [new Data.Models.Hashfile.SpamSum { Hash = "XXXXXX", File = "XXXXXX" }] },
+                _ => throw new ArgumentOutOfRangeException(),
+            };
+        }
+
+        /// <summary>
+        /// Validate a SFV
+        /// </summary>
+        private static void Validate(Data.Models.Hashfile.SFV? sfv)
+        {
+            Assert.NotNull(sfv);
+            Assert.Equal("XXXXXX", sfv.File);
+            Assert.Equal("XXXXXX", sfv.Hash);
+        }
+
+        /// <summary>
+        /// Validate a MD2
+        /// </summary>
+        private static void Validate(Data.Models.Hashfile.MD2? md2)
+        {
+            Assert.NotNull(md2);
+            Assert.Equal("XXXXXX", md2.Hash);
+            Assert.Equal("XXXXXX", md2.File);
+        }
+
+        /// <summary>
+        /// Validate a MD4
+        /// </summary>
+        private static void Validate(Data.Models.Hashfile.MD4? md4)
+        {
+            Assert.NotNull(md4);
+            Assert.Equal("XXXXXX", md4.Hash);
+            Assert.Equal("XXXXXX", md4.File);
+        }
+
+        /// <summary>
+        /// Validate a MD5
+        /// </summary>
+        private static void Validate(Data.Models.Hashfile.MD5? md5)
+        {
+            Assert.NotNull(md5);
+            Assert.Equal("XXXXXX", md5.Hash);
+            Assert.Equal("XXXXXX", md5.File);
+        }
+
+        /// <summary>
+        /// Validate a SHA1
+        /// </summary>
+        private static void Validate(Data.Models.Hashfile.SHA1? sha1)
+        {
+            Assert.NotNull(sha1);
+            Assert.Equal("XXXXXX", sha1.Hash);
+            Assert.Equal("XXXXXX", sha1.File);
+        }
+
+        /// <summary>
+        /// Validate a SHA256
+        /// </summary>
+        private static void Validate(Data.Models.Hashfile.SHA256? sha256)
+        {
+            Assert.NotNull(sha256);
+            Assert.Equal("XXXXXX", sha256.Hash);
+            Assert.Equal("XXXXXX", sha256.File);
+        }
+
+        /// <summary>
+        /// Validate a SHA384
+        /// </summary>
+        private static void Validate(Data.Models.Hashfile.SHA384? sha384)
+        {
+            Assert.NotNull(sha384);
+            Assert.Equal("XXXXXX", sha384.Hash);
+            Assert.Equal("XXXXXX", sha384.File);
+        }
+
+        /// <summary>
+        /// Validate a SHA512
+        /// </summary>
+        private static void Validate(Data.Models.Hashfile.SHA512? sha512)
+        {
+            Assert.NotNull(sha512);
+            Assert.Equal("XXXXXX", sha512.Hash);
+            Assert.Equal("XXXXXX", sha512.File);
+        }
+
+        /// <summary>
+        /// Validate a SpamSum
+        /// </summary>
+        private static void Validate(Data.Models.Hashfile.SpamSum? spamsum)
+        {
+            Assert.NotNull(spamsum);
+            Assert.Equal("XXXXXX", spamsum.Hash);
+            Assert.Equal("XXXXXX", spamsum.File);
+        }
+    }
+}

SabreTools.Serialization.Test/CrossModel/ListromTests.cs

@@ -0,0 +1,128 @@
+using SabreTools.Serialization.CrossModel;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.CrossModel
+{
+    public class ListromTests
+    {
+        [Fact]
+        public void RoundTripTest()
+        {
+            // Get the cross-model serializer
+            var serializer = new Listrom();
+
+            // Build the data
+            Data.Models.Listrom.MetadataFile mf = Build();
+
+            // Serialize to generic model
+            Data.Models.Metadata.MetadataFile? metadata = serializer.Serialize(mf);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.Listrom.MetadataFile? newMf = serializer.Deserialize(metadata);
+
+            // Validate the data
+            Assert.NotNull(newMf);
+            Assert.NotNull(newMf.Set);
+            Assert.Equal(2, newMf.Set.Length);
+
+            ValidateDevice(newMf.Set[0]);
+            ValidateDriver(newMf.Set[1]);
+        }
+
+        /// <summary>
+        /// Build model for serialization and deserialization
+        /// </summary>
+        private static Data.Models.Listrom.MetadataFile Build()
+        {
+            var rom = new Data.Models.Listrom.Row
+            {
+                Name = "XXXXXX",
+                Size = "XXXXXX",
+                Bad = true,
+                CRC = "XXXXXX",
+                SHA1 = "XXXXXX",
+                NoGoodDumpKnown = false,
+            };
+
+            var disk = new Data.Models.Listrom.Row
+            {
+                Name = "XXXXXX",
+                Bad = false,
+                MD5 = "XXXXXX",
+                SHA1 = "XXXXXX",
+                NoGoodDumpKnown = true,
+            };
+
+            var device = new Data.Models.Listrom.Set()
+            {
+                Device = "XXXXXX",
+                Row = [rom],
+            };
+
+            var driver = new Data.Models.Listrom.Set()
+            {
+                Driver = "XXXXXX",
+                Row = [disk],
+            };
+
+            return new Data.Models.Listrom.MetadataFile
+            {
+                Set = [device, driver],
+            };
+        }
+
+        /// <summary>
+        /// Validate a Set
+        /// </summary>
+        private static void ValidateDevice(Data.Models.Listrom.Set? set)
+        {
+            Assert.NotNull(set);
+            Assert.Equal("XXXXXX", set.Device);
+
+            Assert.NotNull(set.Row);
+            var row = Assert.Single(set.Row);
+            ValidateRom(row);
+        }
+
+        /// <summary>
+        /// Validate a Set
+        /// </summary>
+        private static void ValidateDriver(Data.Models.Listrom.Set? set)
+        {
+            Assert.NotNull(set);
+            Assert.Equal("XXXXXX", set.Driver);
+
+            Assert.NotNull(set.Row);
+            var row = Assert.Single(set.Row);
+            ValidateDisk(row);
+        }
+
+        /// <summary>
+        /// Validate a Row
+        /// </summary>
+        private static void ValidateRom(Data.Models.Listrom.Row? row)
+        {
+            Assert.NotNull(row);
+            Assert.Equal("XXXXXX", row.Name);
+            Assert.Equal("XXXXXX", row.Size);
+            Assert.True(row.Bad);
+            Assert.Equal("XXXXXX", row.CRC);
+            Assert.Equal("XXXXXX", row.SHA1);
+            Assert.False(row.NoGoodDumpKnown);
+        }
+
+        /// <summary>
+        /// Validate a Row
+        /// </summary>
+        private static void ValidateDisk(Data.Models.Listrom.Row? row)
+        {
+            Assert.NotNull(row);
+            Assert.Equal("XXXXXX", row.Name);
+            Assert.False(row.Bad);
+            Assert.Equal("XXXXXX", row.MD5);
+            Assert.Equal("XXXXXX", row.SHA1);
+            Assert.True(row.NoGoodDumpKnown);
+        }
+    }
+}

SabreTools.Serialization.Test/CrossModel/ListxmlTests.cs

@@ -0,0 +1,879 @@
+using SabreTools.Serialization.CrossModel;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.CrossModel
+{
+    public class ListxmlTests
+    {
+        [Fact]
+        public void RoundTripGameTest()
+        {
+            // Get the cross-model serializer
+            var serializer = new Listxml();
+
+            // Build the data
+            Data.Models.Listxml.Mame mame = Build(game: true);
+
+            // Serialize to generic model
+            Data.Models.Metadata.MetadataFile? metadata = serializer.Serialize(mame);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.Listxml.Mame? newMame = serializer.Deserialize(metadata);
+
+            // Validate the data
+            Assert.NotNull(newMame);
+            Assert.Equal("XXXXXX", newMame.Build);
+            Assert.Equal("XXXXXX", newMame.Debug);
+            Assert.Equal("XXXXXX", newMame.MameConfig);
+
+            Assert.NotNull(newMame.Game);
+            var newGame = Assert.Single(newMame.Game);
+            Validate(newGame);
+        }
+
+        [Fact]
+        public void RoundTripMachineTest()
+        {
+            // Get the cross-model serializer
+            var serializer = new Listxml();
+
+            // Build the data
+            Data.Models.Listxml.Mame mame = Build(game: false);
+
+            // Serialize to generic model
+            Data.Models.Metadata.MetadataFile? metadata = serializer.Serialize(mame);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.Listxml.Mame? newMame = serializer.Deserialize(metadata);
+
+            // Validate the data
+            Assert.NotNull(newMame);
+            Assert.Equal("XXXXXX", newMame.Build);
+            Assert.Equal("XXXXXX", newMame.Debug);
+            Assert.Equal("XXXXXX", newMame.MameConfig);
+
+            Assert.NotNull(newMame.Game);
+            var newGame = Assert.Single(newMame.Game);
+            Validate(newGame);
+        }
+
+        /// <summary>
+        /// Build model for serialization and deserialization
+        /// </summary>
+        private static Data.Models.Listxml.Mame Build(bool game)
+        {
+            var biosset = new Data.Models.Listxml.BiosSet
+            {
+                Name = "XXXXXX",
+                Description = "XXXXXX",
+                Default = "XXXXXX",
+            };
+
+            var rom = new Data.Models.Listxml.Rom
+            {
+                Name = "XXXXXX",
+                Bios = "XXXXXX",
+                Size = "XXXXXX",
+                CRC = "XXXXXX",
+                SHA1 = "XXXXXX",
+                Merge = "XXXXXX",
+                Region = "XXXXXX",
+                Offset = "XXXXXX",
+                Status = "XXXXXX",
+                Optional = "XXXXXX",
+                Dispose = "XXXXXX",
+                SoundOnly = "XXXXXX",
+            };
+
+            var disk = new Data.Models.Listxml.Disk
+            {
+                Name = "XXXXXX",
+                MD5 = "XXXXXX",
+                SHA1 = "XXXXXX",
+                Merge = "XXXXXX",
+                Region = "XXXXXX",
+                Index = "XXXXXX",
+                Writable = "XXXXXX",
+                Status = "XXXXXX",
+                Optional = "XXXXXX",
+            };
+
+            var deviceref = new Data.Models.Listxml.DeviceRef
+            {
+                Name = "XXXXXX",
+            };
+
+            var sample = new Data.Models.Listxml.Sample
+            {
+                Name = "XXXXXX",
+            };
+
+            var chip = new Data.Models.Listxml.Chip
+            {
+                Name = "XXXXXX",
+                Tag = "XXXXXX",
+                Type = "XXXXXX",
+                SoundOnly = "XXXXXX",
+                Clock = "XXXXXX",
+            };
+
+            var display = new Data.Models.Listxml.Display
+            {
+                Tag = "XXXXXX",
+                Type = "XXXXXX",
+                Rotate = "XXXXXX",
+                FlipX = "XXXXXX",
+                Width = "XXXXXX",
+                Height = "XXXXXX",
+                Refresh = "XXXXXX",
+                PixClock = "XXXXXX",
+                HTotal = "XXXXXX",
+                HBEnd = "XXXXXX",
+                HBStart = "XXXXXX",
+                VTotal = "XXXXXX",
+                VBEnd = "XXXXXX",
+                VBStart = "XXXXXX",
+            };
+
+            var video = new Data.Models.Listxml.Video
+            {
+                Screen = "XXXXXX",
+                Orientation = "XXXXXX",
+                Width = "XXXXXX",
+                Height = "XXXXXX",
+                AspectX = "XXXXXX",
+                AspectY = "XXXXXX",
+                Refresh = "XXXXXX",
+            };
+
+            var sound = new Data.Models.Listxml.Sound
+            {
+                Channels = "XXXXXX",
+            };
+
+            var control = new Data.Models.Listxml.Control
+            {
+                Type = "XXXXXX",
+                Player = "XXXXXX",
+                Buttons = "XXXXXX",
+                ReqButtons = "XXXXXX",
+                Minimum = "XXXXXX",
+                Maximum = "XXXXXX",
+                Sensitivity = "XXXXXX",
+                KeyDelta = "XXXXXX",
+                Reverse = "XXXXXX",
+                Ways = "XXXXXX",
+                Ways2 = "XXXXXX",
+                Ways3 = "XXXXXX",
+            };
+
+            var input = new Data.Models.Listxml.Input
+            {
+                Service = "XXXXXX",
+                Tilt = "XXXXXX",
+                Players = "XXXXXX",
+                //ControlAttr = "XXXXXX", // Mututally exclusive with input.Control
+                Buttons = "XXXXXX",
+                Coins = "XXXXXX",
+                Control = [control],
+            };
+
+            var condition = new Data.Models.Listxml.Condition
+            {
+                Tag = "XXXXXX",
+                Mask = "XXXXXX",
+                Relation = "XXXXXX",
+                Value = "XXXXXX",
+            };
+
+            var diplocation = new Data.Models.Listxml.DipLocation
+            {
+                Name = "XXXXXX",
+                Number = "XXXXXX",
+                Inverted = "XXXXXX",
+            };
+
+            var dipvalue = new Data.Models.Listxml.DipValue
+            {
+                Name = "XXXXXX",
+                Value = "XXXXXX",
+                Default = "XXXXXX",
+                Condition = condition,
+            };
+
+            var dipswitch = new Data.Models.Listxml.DipSwitch
+            {
+                Name = "XXXXXX",
+                Tag = "XXXXXX",
+                Mask = "XXXXXX",
+                Condition = condition,
+                DipLocation = [diplocation],
+                DipValue = [dipvalue],
+            };
+
+            var conflocation = new Data.Models.Listxml.ConfLocation
+            {
+                Name = "XXXXXX",
+                Number = "XXXXXX",
+                Inverted = "XXXXXX",
+            };
+
+            var confsetting = new Data.Models.Listxml.ConfSetting
+            {
+                Name = "XXXXXX",
+                Value = "XXXXXX",
+                Default = "XXXXXX",
+                Condition = condition,
+            };
+
+            var configuration = new Data.Models.Listxml.Configuration
+            {
+                Name = "XXXXXX",
+                Tag = "XXXXXX",
+                Mask = "XXXXXX",
+                Condition = condition,
+                ConfLocation = [conflocation],
+                ConfSetting = [confsetting],
+            };
+
+            var analog = new Data.Models.Listxml.Analog
+            {
+                Mask = "XXXXXX",
+            };
+
+            var port = new Data.Models.Listxml.Port
+            {
+                Tag = "XXXXXX",
+                Analog = [analog],
+            };
+
+            var adjuster = new Data.Models.Listxml.Adjuster
+            {
+                Name = "XXXXXX",
+                Default = "XXXXXX",
+                Condition = condition,
+            };
+
+            var driver = new Data.Models.Listxml.Driver
+            {
+                Status = "XXXXXX",
+                Color = "XXXXXX",
+                Sound = "XXXXXX",
+                PaletteSize = "XXXXXX",
+                Emulation = "XXXXXX",
+                Cocktail = "XXXXXX",
+                SaveState = "XXXXXX",
+                RequiresArtwork = "XXXXXX",
+                Unofficial = "XXXXXX",
+                NoSoundHardware = "XXXXXX",
+                Incomplete = "XXXXXX",
+            };
+
+            var feature = new Data.Models.Listxml.Feature
+            {
+                Type = "XXXXXX",
+                Status = "XXXXXX",
+                Overall = "XXXXXX",
+            };
+
+            var instance = new Data.Models.Listxml.Instance
+            {
+                Name = "XXXXXX",
+                BriefName = "XXXXXX",
+            };
+
+            var extension = new Data.Models.Listxml.Extension
+            {
+                Name = "XXXXXX",
+            };
+
+            var device = new Data.Models.Listxml.Device
+            {
+                Type = "XXXXXX",
+                Tag = "XXXXXX",
+                FixedImage = "XXXXXX",
+                Mandatory = "XXXXXX",
+                Interface = "XXXXXX",
+                Instance = instance,
+                Extension = [extension],
+            };
+
+            var slotOption = new Data.Models.Listxml.SlotOption
+            {
+                Name = "XXXXXX",
+                DevName = "XXXXXX",
+                Default = "XXXXXX",
+            };
+
+            var slot = new Data.Models.Listxml.Slot
+            {
+                Name = "XXXXXX",
+                SlotOption = [slotOption],
+            };
+
+            var softwarelist = new Data.Models.Listxml.SoftwareList
+            {
+                Tag = "XXXXXX",
+                Name = "XXXXXX",
+                Status = "XXXXXX",
+                Filter = "XXXXXX",
+            };
+
+            var ramoption = new Data.Models.Listxml.RamOption
+            {
+                Name = "XXXXXX",
+                Default = "XXXXXX",
+                Content = "XXXXXX",
+            };
+
+            Data.Models.Listxml.GameBase gameBase = game
+                ? new Data.Models.Listxml.Game()
+                : new Data.Models.Listxml.Machine();
+            gameBase.Name = "XXXXXX";
+            gameBase.SourceFile = "XXXXXX";
+            gameBase.IsBios = "XXXXXX";
+            gameBase.IsDevice = "XXXXXX";
+            gameBase.IsMechanical = "XXXXXX";
+            gameBase.Runnable = "XXXXXX";
+            gameBase.CloneOf = "XXXXXX";
+            gameBase.RomOf = "XXXXXX";
+            gameBase.SampleOf = "XXXXXX";
+            gameBase.Description = "XXXXXX";
+            gameBase.Year = "XXXXXX";
+            gameBase.Manufacturer = "XXXXXX";
+            gameBase.History = "XXXXXX";
+            gameBase.BiosSet = [biosset];
+            gameBase.Rom = [rom];
+            gameBase.Disk = [disk];
+            gameBase.DeviceRef = [deviceref];
+            gameBase.Sample = [sample];
+            gameBase.Chip = [chip];
+            gameBase.Display = [display];
+            gameBase.Video = [video];
+            gameBase.Sound = sound;
+            gameBase.Input = input;
+            gameBase.DipSwitch = [dipswitch];
+            gameBase.Configuration = [configuration];
+            gameBase.Port = [port];
+            gameBase.Adjuster = [adjuster];
+            gameBase.Driver = driver;
+            gameBase.Feature = [feature];
+            gameBase.Device = [device];
+            gameBase.Slot = [slot];
+            gameBase.SoftwareList = [softwarelist];
+            gameBase.RamOption = [ramoption];
+
+            return new Data.Models.Listxml.Mame
+            {
+                Build = "XXXXXX",
+                Debug = "XXXXXX",
+                MameConfig = "XXXXXX",
+                Game = [gameBase],
+            };
+        }
+
+        /// <summary>
+        /// Validate a GameBase
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.GameBase? gb)
+        {
+            Assert.NotNull(gb);
+            Assert.Equal("XXXXXX", gb.Name);
+            Assert.Equal("XXXXXX", gb.SourceFile);
+            Assert.Equal("XXXXXX", gb.IsBios);
+            Assert.Equal("XXXXXX", gb.IsDevice);
+            Assert.Equal("XXXXXX", gb.IsMechanical);
+            Assert.Equal("XXXXXX", gb.Runnable);
+            Assert.Equal("XXXXXX", gb.CloneOf);
+            Assert.Equal("XXXXXX", gb.RomOf);
+            Assert.Equal("XXXXXX", gb.SampleOf);
+            Assert.Equal("XXXXXX", gb.Description);
+            Assert.Equal("XXXXXX", gb.Year);
+            Assert.Equal("XXXXXX", gb.Manufacturer);
+            Assert.Equal("XXXXXX", gb.History);
+
+            Assert.NotNull(gb.BiosSet);
+            var biosset = Assert.Single(gb.BiosSet);
+            Validate(biosset);
+
+            Assert.NotNull(gb.Rom);
+            var rom = Assert.Single(gb.Rom);
+            Validate(rom);
+
+            Assert.NotNull(gb.Disk);
+            var disk = Assert.Single(gb.Disk);
+            Validate(disk);
+
+            Assert.NotNull(gb.DeviceRef);
+            var deviceref = Assert.Single(gb.DeviceRef);
+            Validate(deviceref);
+
+            Assert.NotNull(gb.Sample);
+            var sample = Assert.Single(gb.Sample);
+            Validate(sample);
+
+            Assert.NotNull(gb.Chip);
+            var chip = Assert.Single(gb.Chip);
+            Validate(chip);
+
+            Assert.NotNull(gb.Display);
+            var display = Assert.Single(gb.Display);
+            Validate(display);
+
+            Assert.NotNull(gb.Video);
+            var video = Assert.Single(gb.Video);
+            Validate(video);
+
+            Validate(gb.Sound);
+            Validate(gb.Input);
+
+            Assert.NotNull(gb.DipSwitch);
+            var dipswitch = Assert.Single(gb.DipSwitch);
+            Validate(dipswitch);
+
+            Assert.NotNull(gb.Configuration);
+            var configuration = Assert.Single(gb.Configuration);
+            Validate(configuration);
+
+            Assert.NotNull(gb.Port);
+            var port = Assert.Single(gb.Port);
+            Validate(port);
+
+            Assert.NotNull(gb.Adjuster);
+            var adjuster = Assert.Single(gb.Adjuster);
+            Validate(adjuster);
+
+            Validate(gb.Driver);
+
+            Assert.NotNull(gb.Feature);
+            var feature = Assert.Single(gb.Feature);
+            Validate(feature);
+
+            Assert.NotNull(gb.Device);
+            var device = Assert.Single(gb.Device);
+            Validate(device);
+
+            Assert.NotNull(gb.Slot);
+            var slot = Assert.Single(gb.Slot);
+            Validate(slot);
+
+            Assert.NotNull(gb.SoftwareList);
+            var softwarelist = Assert.Single(gb.SoftwareList);
+            Validate(softwarelist);
+
+            Assert.NotNull(gb.RamOption);
+            var ramoption = Assert.Single(gb.RamOption);
+            Validate(ramoption);
+        }
+
+        /// <summary>
+        /// Validate a BiosSet
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.BiosSet? biosset)
+        {
+            Assert.NotNull(biosset);
+            Assert.Equal("XXXXXX", biosset.Name);
+            Assert.Equal("XXXXXX", biosset.Description);
+            Assert.Equal("XXXXXX", biosset.Default);
+        }
+
+        /// <summary>
+        /// Validate a Rom
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Rom? rom)
+        {
+            Assert.NotNull(rom);
+            Assert.Equal("XXXXXX", rom.Name);
+            Assert.Equal("XXXXXX", rom.Bios);
+            Assert.Equal("XXXXXX", rom.Size);
+            Assert.Equal("XXXXXX", rom.CRC);
+            Assert.Equal("XXXXXX", rom.SHA1);
+            Assert.Equal("XXXXXX", rom.Merge);
+            Assert.Equal("XXXXXX", rom.Region);
+            Assert.Equal("XXXXXX", rom.Offset);
+            Assert.Equal("XXXXXX", rom.Status);
+            Assert.Equal("XXXXXX", rom.Optional);
+            Assert.Equal("XXXXXX", rom.Dispose);
+            Assert.Equal("XXXXXX", rom.SoundOnly);
+        }
+
+        /// <summary>
+        /// Validate a Disk
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Disk? disk)
+        {
+            Assert.NotNull(disk);
+            Assert.Equal("XXXXXX", disk.Name);
+            Assert.Equal("XXXXXX", disk.MD5);
+            Assert.Equal("XXXXXX", disk.SHA1);
+            Assert.Equal("XXXXXX", disk.Merge);
+            Assert.Equal("XXXXXX", disk.Region);
+            Assert.Equal("XXXXXX", disk.Index);
+            Assert.Equal("XXXXXX", disk.Writable);
+            Assert.Equal("XXXXXX", disk.Status);
+            Assert.Equal("XXXXXX", disk.Optional);
+        }
+
+        /// <summary>
+        /// Validate a DeviceRef
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.DeviceRef? deviceref)
+        {
+            Assert.NotNull(deviceref);
+            Assert.Equal("XXXXXX", deviceref.Name);
+        }
+
+        /// <summary>
+        /// Validate a Sample
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Sample? sample)
+        {
+            Assert.NotNull(sample);
+            Assert.Equal("XXXXXX", sample.Name);
+        }
+
+        /// <summary>
+        /// Validate a Chip
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Chip? chip)
+        {
+            Assert.NotNull(chip);
+            Assert.Equal("XXXXXX", chip.Name);
+            Assert.Equal("XXXXXX", chip.Tag);
+            Assert.Equal("XXXXXX", chip.Type);
+            Assert.Equal("XXXXXX", chip.SoundOnly);
+            Assert.Equal("XXXXXX", chip.Clock);
+        }
+
+        /// <summary>
+        /// Validate a Display
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Display? display)
+        {
+            Assert.NotNull(display);
+            Assert.Equal("XXXXXX", display.Tag);
+            Assert.Equal("XXXXXX", display.Type);
+            Assert.Equal("XXXXXX", display.Rotate);
+            Assert.Equal("XXXXXX", display.FlipX);
+            Assert.Equal("XXXXXX", display.Width);
+            Assert.Equal("XXXXXX", display.Height);
+            Assert.Equal("XXXXXX", display.Refresh);
+            Assert.Equal("XXXXXX", display.PixClock);
+            Assert.Equal("XXXXXX", display.HTotal);
+            Assert.Equal("XXXXXX", display.HBEnd);
+            Assert.Equal("XXXXXX", display.HBStart);
+            Assert.Equal("XXXXXX", display.VTotal);
+            Assert.Equal("XXXXXX", display.VBEnd);
+            Assert.Equal("XXXXXX", display.VBStart);
+        }
+
+        /// <summary>
+        /// Validate a Video
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Video? video)
+        {
+            Assert.NotNull(video);
+            Assert.Equal("XXXXXX", video.Screen);
+            Assert.Equal("XXXXXX", video.Orientation);
+            Assert.Equal("XXXXXX", video.Width);
+            Assert.Equal("XXXXXX", video.Height);
+            Assert.Equal("XXXXXX", video.AspectX);
+            Assert.Equal("XXXXXX", video.AspectY);
+            Assert.Equal("XXXXXX", video.Refresh);
+        }
+
+        /// <summary>
+        /// Validate a Sound
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Sound? sound)
+        {
+            Assert.NotNull(sound);
+            Assert.Equal("XXXXXX", sound.Channels);
+        }
+
+        /// <summary>
+        /// Validate a Input
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Input? input)
+        {
+            Assert.NotNull(input);
+            Assert.Equal("XXXXXX", input.Service);
+            Assert.Equal("XXXXXX", input.Tilt);
+            Assert.Equal("XXXXXX", input.Players);
+            //Assert.Equal("XXXXXX", input.ControlAttr); // Mututally exclusive with input.Control
+            Assert.Equal("XXXXXX", input.Buttons);
+            Assert.Equal("XXXXXX", input.Coins);
+
+            Assert.NotNull(input.Control);
+            var control = Assert.Single(input.Control);
+            Validate(control);
+        }
+
+        /// <summary>
+        /// Validate a Control
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Control? control)
+        {
+            Assert.NotNull(control);
+            Assert.Equal("XXXXXX", control.Type);
+            Assert.Equal("XXXXXX", control.Player);
+            Assert.Equal("XXXXXX", control.Buttons);
+            Assert.Equal("XXXXXX", control.ReqButtons);
+            Assert.Equal("XXXXXX", control.Minimum);
+            Assert.Equal("XXXXXX", control.Maximum);
+            Assert.Equal("XXXXXX", control.Sensitivity);
+            Assert.Equal("XXXXXX", control.KeyDelta);
+            Assert.Equal("XXXXXX", control.Reverse);
+            Assert.Equal("XXXXXX", control.Ways);
+            Assert.Equal("XXXXXX", control.Ways2);
+            Assert.Equal("XXXXXX", control.Ways3);
+        }
+
+        /// <summary>
+        /// Validate a DipSwitch
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.DipSwitch? dipswitch)
+        {
+            Assert.NotNull(dipswitch);
+            Assert.Equal("XXXXXX", dipswitch.Name);
+            Assert.Equal("XXXXXX", dipswitch.Tag);
+            Assert.Equal("XXXXXX", dipswitch.Mask);
+            Validate(dipswitch.Condition);
+
+            Assert.NotNull(dipswitch.DipLocation);
+            var diplocation = Assert.Single(dipswitch.DipLocation);
+            Validate(diplocation);
+
+            Assert.NotNull(dipswitch.DipValue);
+            var dipvalue = Assert.Single(dipswitch.DipValue);
+            Validate(dipvalue);
+        }
+
+        /// <summary>
+        /// Validate a Condition
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Condition? condition)
+        {
+            Assert.NotNull(condition);
+            Assert.Equal("XXXXXX", condition.Tag);
+            Assert.Equal("XXXXXX", condition.Mask);
+            Assert.Equal("XXXXXX", condition.Relation);
+            Assert.Equal("XXXXXX", condition.Value);
+        }
+
+        /// <summary>
+        /// Validate a DipLocation
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.DipLocation? diplocation)
+        {
+            Assert.NotNull(diplocation);
+            Assert.Equal("XXXXXX", diplocation.Name);
+            Assert.Equal("XXXXXX", diplocation.Number);
+            Assert.Equal("XXXXXX", diplocation.Inverted);
+        }
+
+        /// <summary>
+        /// Validate a DipValue
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.DipValue? dipvalue)
+        {
+            Assert.NotNull(dipvalue);
+            Assert.Equal("XXXXXX", dipvalue.Name);
+            Assert.Equal("XXXXXX", dipvalue.Value);
+            Assert.Equal("XXXXXX", dipvalue.Default);
+            Validate(dipvalue.Condition);
+        }
+
+        /// <summary>
+        /// Validate a Configuration
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Configuration? configuration)
+        {
+            Assert.NotNull(configuration);
+            Assert.Equal("XXXXXX", configuration.Name);
+            Assert.Equal("XXXXXX", configuration.Tag);
+            Assert.Equal("XXXXXX", configuration.Mask);
+            Validate(configuration.Condition);
+
+            Assert.NotNull(configuration.ConfLocation);
+            var conflocation = Assert.Single(configuration.ConfLocation);
+            Validate(conflocation);
+
+            Assert.NotNull(configuration.ConfSetting);
+            var confsetting = Assert.Single(configuration.ConfSetting);
+            Validate(confsetting);
+        }
+
+        /// <summary>
+        /// Validate a ConfLocation
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.ConfLocation? conflocation)
+        {
+            Assert.NotNull(conflocation);
+            Assert.Equal("XXXXXX", conflocation.Name);
+            Assert.Equal("XXXXXX", conflocation.Number);
+            Assert.Equal("XXXXXX", conflocation.Inverted);
+        }
+
+        /// <summary>
+        /// Validate a ConfSetting
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.ConfSetting? confsetting)
+        {
+            Assert.NotNull(confsetting);
+            Assert.Equal("XXXXXX", confsetting.Name);
+            Assert.Equal("XXXXXX", confsetting.Value);
+            Assert.Equal("XXXXXX", confsetting.Default);
+            Validate(confsetting.Condition);
+        }
+
+        /// <summary>
+        /// Validate a Port
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Port? port)
+        {
+            Assert.NotNull(port);
+            Assert.Equal("XXXXXX", port.Tag);
+
+            Assert.NotNull(port.Analog);
+            var analog = Assert.Single(port.Analog);
+            Validate(analog);
+        }
+
+        /// <summary>
+        /// Validate a Analog
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Analog? analog)
+        {
+            Assert.NotNull(analog);
+            Assert.Equal("XXXXXX", analog.Mask);
+        }
+
+        /// <summary>
+        /// Validate a Adjuster
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Adjuster? adjuster)
+        {
+            Assert.NotNull(adjuster);
+            Assert.Equal("XXXXXX", adjuster.Name);
+            Assert.Equal("XXXXXX", adjuster.Default);
+            Validate(adjuster.Condition);
+        }
+
+        /// <summary>
+        /// Validate a Driver
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Driver? driver)
+        {
+            Assert.NotNull(driver);
+            Assert.Equal("XXXXXX", driver.Status);
+            Assert.Equal("XXXXXX", driver.Color);
+            Assert.Equal("XXXXXX", driver.Sound);
+            Assert.Equal("XXXXXX", driver.PaletteSize);
+            Assert.Equal("XXXXXX", driver.Emulation);
+            Assert.Equal("XXXXXX", driver.Cocktail);
+            Assert.Equal("XXXXXX", driver.SaveState);
+            Assert.Equal("XXXXXX", driver.RequiresArtwork);
+            Assert.Equal("XXXXXX", driver.Unofficial);
+            Assert.Equal("XXXXXX", driver.NoSoundHardware);
+            Assert.Equal("XXXXXX", driver.Incomplete);
+        }
+
+        /// <summary>
+        /// Validate a Feature
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Feature? feature)
+        {
+            Assert.NotNull(feature);
+            Assert.Equal("XXXXXX", feature.Type);
+            Assert.Equal("XXXXXX", feature.Status);
+            Assert.Equal("XXXXXX", feature.Overall);
+        }
+
+        /// <summary>
+        /// Validate a Device
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Device? device)
+        {
+            Assert.NotNull(device);
+            Assert.Equal("XXXXXX", device.Type);
+            Assert.Equal("XXXXXX", device.Tag);
+            Assert.Equal("XXXXXX", device.FixedImage);
+            Assert.Equal("XXXXXX", device.Mandatory);
+            Assert.Equal("XXXXXX", device.Interface);
+            Validate(device.Instance);
+
+            Assert.NotNull(device.Extension);
+            var extension = Assert.Single(device.Extension);
+            Validate(extension);
+        }
+
+        /// <summary>
+        /// Validate a Instance
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Instance? instance)
+        {
+            Assert.NotNull(instance);
+            Assert.Equal("XXXXXX", instance.Name);
+            Assert.Equal("XXXXXX", instance.BriefName);
+        }
+
+        /// <summary>
+        /// Validate a Extension
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Extension? extension)
+        {
+            Assert.NotNull(extension);
+            Assert.Equal("XXXXXX", extension.Name);
+        }
+
+        /// <summary>
+        /// Validate a Slot
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Slot? slot)
+        {
+            Assert.NotNull(slot);
+            Assert.Equal("XXXXXX", slot.Name);
+
+            Assert.NotNull(slot.SlotOption);
+            var slotoption = Assert.Single(slot.SlotOption);
+            Validate(slotoption);
+        }
+
+        /// <summary>
+        /// Validate a SlotOption
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.SlotOption? slotoption)
+        {
+            Assert.NotNull(slotoption);
+            Assert.Equal("XXXXXX", slotoption.Name);
+            Assert.Equal("XXXXXX", slotoption.DevName);
+            Assert.Equal("XXXXXX", slotoption.Default);
+        }
+
+        /// <summary>
+        /// Validate a SoftwareList
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.SoftwareList? softwarelist)
+        {
+            Assert.NotNull(softwarelist);
+            Assert.Equal("XXXXXX", softwarelist.Tag);
+            Assert.Equal("XXXXXX", softwarelist.Name);
+            Assert.Equal("XXXXXX", softwarelist.Status);
+            Assert.Equal("XXXXXX", softwarelist.Filter);
+        }
+
+        /// <summary>
+        /// Validate a RamOption
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.RamOption? ramoption)
+        {
+            Assert.NotNull(ramoption);
+            Assert.Equal("XXXXXX", ramoption.Name);
+            Assert.Equal("XXXXXX", ramoption.Default);
+            Assert.Equal("XXXXXX", ramoption.Content);
+        }
+    }
+}

SabreTools.Serialization.Test/CrossModel/LogiqxTests.cs

@@ -0,0 +1,571 @@
+using SabreTools.Serialization.CrossModel;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.CrossModel
+{
+    public class LogiqxTests
+    {
+        [Fact]
+        public void RoundTripGameTest()
+        {
+            // Get the cross-model serializer
+            var serializer = new Logiqx();
+
+            // Build the data
+            Data.Models.Logiqx.Datafile df = Build(game: true);
+
+            // Serialize to generic model
+            Data.Models.Metadata.MetadataFile? metadata = serializer.Serialize(df);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.Logiqx.Datafile? newDf = serializer.Deserialize(metadata, game: true);
+
+            // Validate the data
+            Assert.NotNull(newDf);
+            Assert.Equal("XXXXXX", newDf.Build);
+            Assert.Equal("XXXXXX", newDf.Debug);
+            Assert.Equal("XXXXXX", newDf.SchemaLocation);
+            Validate(newDf.Header);
+
+            Assert.NotNull(newDf.Game);
+            Assert.Equal(2, newDf.Game.Length);
+            Validate(newDf.Game[0], nested: false);
+            Validate(newDf.Game[1], nested: true);
+
+            // TODO: Unsupported for round-trip
+            Assert.Null(newDf.Dir);
+        }
+
+        [Fact]
+        public void RoundTripMachineTest()
+        {
+            // Get the cross-model serializer
+            var serializer = new Logiqx();
+
+            // Build the data
+            Data.Models.Logiqx.Datafile df = Build(game: false);
+
+            // Serialize to generic model
+            Data.Models.Metadata.MetadataFile? metadata = serializer.Serialize(df);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.Logiqx.Datafile? newDf = serializer.Deserialize(metadata, game: false);
+
+            // Validate the data
+            Assert.NotNull(newDf);
+            Assert.Equal("XXXXXX", newDf.Build);
+            Assert.Equal("XXXXXX", newDf.Debug);
+            Assert.Equal("XXXXXX", newDf.SchemaLocation);
+            Validate(newDf.Header);
+
+            Assert.NotNull(newDf.Game);
+            Assert.Equal(2, newDf.Game.Length);
+            Validate(newDf.Game[0], nested: false);
+            Validate(newDf.Game[1], nested: true);
+
+            // TODO: Unsupported for round-trip
+            Assert.Null(newDf.Dir);
+        }
+
+        /// <summary>
+        /// Build model for serialization and deserialization
+        /// </summary>
+        private static Data.Models.Logiqx.Datafile Build(bool game)
+        {
+            var clrmamepro = new Data.Models.Logiqx.ClrMamePro
+            {
+                Header = "XXXXXX",
+                ForceMerging = "XXXXXX",
+                ForceNodump = "XXXXXX",
+                ForcePacking = "XXXXXX",
+            };
+
+            var romcenter = new Data.Models.Logiqx.RomCenter
+            {
+                Plugin = "XXXXXX",
+                RomMode = "XXXXXX",
+                BiosMode = "XXXXXX",
+                SampleMode = "XXXXXX",
+                LockRomMode = "XXXXXX",
+                LockBiosMode = "XXXXXX",
+                LockSampleMode = "XXXXXX",
+            };
+
+            var header = new Data.Models.Logiqx.Header
+            {
+                Id = "XXXXXX",
+                Name = "XXXXXX",
+                Description = "XXXXXX",
+                RootDir = "XXXXXX",
+                Category = "XXXXXX",
+                Version = "XXXXXX",
+                Date = "XXXXXX",
+                Author = "XXXXXX",
+                Email = "XXXXXX",
+                Homepage = "XXXXXX",
+                Url = "XXXXXX",
+                Comment = "XXXXXX",
+                Type = "XXXXXX",
+                ClrMamePro = clrmamepro,
+                RomCenter = romcenter,
+            };
+
+            var trurip = new Data.Models.Logiqx.Trurip
+            {
+                TitleID = "XXXXXX",
+                Publisher = "XXXXXX",
+                Developer = "XXXXXX",
+                Year = "XXXXXX",
+                Genre = "XXXXXX",
+                Subgenre = "XXXXXX",
+                Ratings = "XXXXXX",
+                Score = "XXXXXX",
+                Players = "XXXXXX",
+                Enabled = "XXXXXX",
+                CRC = "XXXXXX",
+                Source = "XXXXXX",
+                CloneOf = "XXXXXX",
+                RelatedTo = "XXXXXX",
+            };
+
+            var release = new Data.Models.Logiqx.Release
+            {
+                Name = "XXXXXX",
+                Region = "XXXXXX",
+                Language = "XXXXXX",
+                Date = "XXXXXX",
+                Default = "XXXXXX",
+            };
+
+            var biosset = new Data.Models.Logiqx.BiosSet
+            {
+                Name = "XXXXXX",
+                Description = "XXXXXX",
+                Default = "XXXXXX",
+            };
+
+            var rom = new Data.Models.Logiqx.Rom
+            {
+                Name = "XXXXXX",
+                Size = "XXXXXX",
+                CRC = "XXXXXX",
+                MD2 = "XXXXXX",
+                MD4 = "XXXXXX",
+                MD5 = "XXXXXX",
+                RIPEMD128 = "XXXXXX",
+                RIPEMD160 = "XXXXXX",
+                SHA1 = "XXXXXX",
+                SHA256 = "XXXXXX",
+                SHA384 = "XXXXXX",
+                SHA512 = "XXXXXX",
+                SpamSum = "XXXXXX",
+                xxHash364 = "XXXXXX",
+                xxHash3128 = "XXXXXX",
+                Merge = "XXXXXX",
+                Status = "XXXXXX",
+                Serial = "XXXXXX",
+                Header = "XXXXXX",
+                Date = "XXXXXX",
+                Inverted = "XXXXXX",
+                MIA = "XXXXXX",
+            };
+
+            var disk = new Data.Models.Logiqx.Disk
+            {
+                Name = "XXXXXX",
+                MD5 = "XXXXXX",
+                SHA1 = "XXXXXX",
+                Merge = "XXXXXX",
+                Status = "XXXXXX",
+                Region = "XXXXXX",
+            };
+
+            var media = new Data.Models.Logiqx.Media
+            {
+                Name = "XXXXXX",
+                MD5 = "XXXXXX",
+                SHA1 = "XXXXXX",
+                SHA256 = "XXXXXX",
+                SpamSum = "XXXXXX",
+            };
+
+            var deviceRef = new Data.Models.Logiqx.DeviceRef
+            {
+                Name = "XXXXXX",
+            };
+
+            var sample = new Data.Models.Logiqx.Sample
+            {
+                Name = "XXXXXX",
+            };
+
+            var archive = new Data.Models.Logiqx.Archive
+            {
+                Name = "XXXXXX",
+            };
+
+            var driver = new Data.Models.Logiqx.Driver
+            {
+                Status = "XXXXXX",
+                Emulation = "XXXXXX",
+                Cocktail = "XXXXXX",
+                SaveState = "XXXXXX",
+                RequiresArtwork = "XXXXXX",
+                Unofficial = "XXXXXX",
+                NoSoundHardware = "XXXXXX",
+                Incomplete = "XXXXXX",
+            };
+
+            var softwarelist = new Data.Models.Logiqx.SoftwareList
+            {
+                Tag = "XXXXXX",
+                Name = "XXXXXX",
+                Status = "XXXXXX",
+                Filter = "XXXXXX",
+            };
+
+            Data.Models.Logiqx.GameBase gameBase = game
+                ? new Data.Models.Logiqx.Game()
+                : new Data.Models.Logiqx.Machine();
+            gameBase.Name = "XXXXXX";
+            gameBase.SourceFile = "XXXXXX";
+            gameBase.IsBios = "XXXXXX";
+            gameBase.IsDevice = "XXXXXX";
+            gameBase.IsMechanical = "XXXXXX";
+            gameBase.CloneOf = "XXXXXX";
+            gameBase.RomOf = "XXXXXX";
+            gameBase.SampleOf = "XXXXXX";
+            gameBase.Board = "XXXXXX";
+            gameBase.RebuildTo = "XXXXXX";
+            gameBase.Id = "XXXXXX";
+            gameBase.CloneOfId = "XXXXXX";
+            gameBase.Runnable = "XXXXXX";
+            gameBase.Comment = ["XXXXXX"];
+            gameBase.Description = "XXXXXX";
+            gameBase.Year = "XXXXXX";
+            gameBase.Manufacturer = "XXXXXX";
+            gameBase.Publisher = "XXXXXX";
+            gameBase.Category = ["XXXXXX"];
+            gameBase.Trurip = trurip;
+            gameBase.Release = [release];
+            gameBase.BiosSet = [biosset];
+            gameBase.Rom = [rom];
+            gameBase.Disk = [disk];
+            gameBase.Media = [media];
+            gameBase.DeviceRef = [deviceRef];
+            gameBase.Sample = [sample];
+            gameBase.Archive = [archive];
+            gameBase.Driver = driver;
+            gameBase.SoftwareList = [softwarelist];
+
+            var subdir = new Data.Models.Logiqx.Dir
+            {
+                Name = "XXXXXX",
+                Game = [gameBase],
+            };
+
+            var dir = new Data.Models.Logiqx.Dir
+            {
+                Name = "XXXXXX",
+                Subdir = [subdir],
+            };
+
+            return new Data.Models.Logiqx.Datafile
+            {
+                Build = "XXXXXX",
+                Debug = "XXXXXX",
+                SchemaLocation = "XXXXXX",
+                Header = header,
+                Game = [gameBase],
+                Dir = [dir],
+            };
+        }
+
+        /// <summary>
+        /// Validate a Header
+        /// </summary>
+        private static void Validate(Data.Models.Logiqx.Header? header)
+        {
+            Assert.NotNull(header);
+            Assert.Equal("XXXXXX", header.Id);
+            Assert.Equal("XXXXXX", header.Name);
+            Assert.Equal("XXXXXX", header.Description);
+            Assert.Equal("XXXXXX", header.RootDir);
+            Assert.Equal("XXXXXX", header.Category);
+            Assert.Equal("XXXXXX", header.Version);
+            Assert.Equal("XXXXXX", header.Date);
+            Assert.Equal("XXXXXX", header.Author);
+            Assert.Equal("XXXXXX", header.Email);
+            Assert.Equal("XXXXXX", header.Homepage);
+            Assert.Equal("XXXXXX", header.Url);
+            Assert.Equal("XXXXXX", header.Comment);
+            Assert.Equal("XXXXXX", header.Type);
+            Validate(header.ClrMamePro);
+            Validate(header.RomCenter);
+        }
+
+        /// <summary>
+        /// Validate a ClrMamePro
+        /// </summary>
+        private static void Validate(Data.Models.Logiqx.ClrMamePro? cmp)
+        {
+            Assert.NotNull(cmp);
+            Assert.Equal("XXXXXX", cmp.Header);
+            Assert.Equal("XXXXXX", cmp.ForceMerging);
+            Assert.Equal("XXXXXX", cmp.ForceNodump);
+            Assert.Equal("XXXXXX", cmp.ForcePacking);
+        }
+
+        /// <summary>
+        /// Validate a RomCenter
+        /// </summary>
+        private static void Validate(Data.Models.Logiqx.RomCenter? rc)
+        {
+            Assert.NotNull(rc);
+            Assert.Equal("XXXXXX", rc.Plugin);
+            Assert.Equal("XXXXXX", rc.RomMode);
+            Assert.Equal("XXXXXX", rc.BiosMode);
+            Assert.Equal("XXXXXX", rc.SampleMode);
+            Assert.Equal("XXXXXX", rc.LockRomMode);
+            Assert.Equal("XXXXXX", rc.LockBiosMode);
+            Assert.Equal("XXXXXX", rc.LockSampleMode);
+        }
+
+        /// <summary>
+        /// Validate a GameBase
+        /// </summary>
+        private static void Validate(Data.Models.Logiqx.GameBase? gb, bool nested)
+        {
+            Assert.NotNull(gb);
+            if (nested)
+                Assert.Equal("XXXXXX\\XXXXXX\\XXXXXX", gb.Name);
+            else
+                Assert.Equal("XXXXXX", gb.Name);
+            Assert.Equal("XXXXXX", gb.SourceFile);
+            Assert.Equal("XXXXXX", gb.IsBios);
+            Assert.Equal("XXXXXX", gb.IsDevice);
+            Assert.Equal("XXXXXX", gb.IsMechanical);
+            Assert.Equal("XXXXXX", gb.CloneOf);
+            Assert.Equal("XXXXXX", gb.RomOf);
+            Assert.Equal("XXXXXX", gb.SampleOf);
+            Assert.Equal("XXXXXX", gb.Board);
+            Assert.Equal("XXXXXX", gb.RebuildTo);
+            Assert.Equal("XXXXXX", gb.Id);
+            Assert.Equal("XXXXXX", gb.CloneOfId);
+            Assert.Equal("XXXXXX", gb.Runnable);
+
+            Assert.NotNull(gb.Comment);
+            string comment = Assert.Single(gb.Comment);
+            Assert.Equal("XXXXXX", comment);
+
+            Assert.Equal("XXXXXX", gb.Description);
+            Assert.Equal("XXXXXX", gb.Year);
+            Assert.Equal("XXXXXX", gb.Manufacturer);
+            Assert.Equal("XXXXXX", gb.Publisher);
+
+            Assert.NotNull(gb.Category);
+            string category = Assert.Single(gb.Category);
+            Assert.Equal("XXXXXX", category);
+
+            Validate(gb.Trurip);
+
+            Assert.NotNull(gb.Release);
+            var release = Assert.Single(gb.Release);
+            Validate(release);
+
+            Assert.NotNull(gb.BiosSet);
+            var biosset = Assert.Single(gb.BiosSet);
+            Validate(biosset);
+
+            Assert.NotNull(gb.Rom);
+            var rom = Assert.Single(gb.Rom);
+            Validate(rom);
+
+            Assert.NotNull(gb.Disk);
+            var disk = Assert.Single(gb.Disk);
+            Validate(disk);
+
+            Assert.NotNull(gb.Media);
+            var media = Assert.Single(gb.Media);
+            Validate(media);
+
+            Assert.NotNull(gb.DeviceRef);
+            var deviceref = Assert.Single(gb.DeviceRef);
+            Validate(deviceref);
+
+            Assert.NotNull(gb.Sample);
+            var sample = Assert.Single(gb.Sample);
+            Validate(sample);
+
+            Assert.NotNull(gb.Archive);
+            var archive = Assert.Single(gb.Archive);
+            Validate(archive);
+
+            Validate(gb.Driver);
+
+            Assert.NotNull(gb.SoftwareList);
+            var softwarelist = Assert.Single(gb.SoftwareList);
+            Validate(softwarelist);
+        }
+
+        /// <summary>
+        /// Validate a Trurip
+        /// </summary>
+        private static void Validate(Data.Models.Logiqx.Trurip? trurip)
+        {
+            Assert.NotNull(trurip);
+            Assert.Equal("XXXXXX", trurip.TitleID);
+            Assert.Equal("XXXXXX", trurip.Publisher);
+            Assert.Equal("XXXXXX", trurip.Developer);
+            Assert.Equal("XXXXXX", trurip.Year);
+            Assert.Equal("XXXXXX", trurip.Genre);
+            Assert.Equal("XXXXXX", trurip.Subgenre);
+            Assert.Equal("XXXXXX", trurip.Ratings);
+            Assert.Equal("XXXXXX", trurip.Score);
+            Assert.Equal("XXXXXX", trurip.Players);
+            Assert.Equal("XXXXXX", trurip.Enabled);
+            Assert.Equal("XXXXXX", trurip.CRC);
+            Assert.Equal("XXXXXX", trurip.Source);
+            Assert.Equal("XXXXXX", trurip.CloneOf);
+            Assert.Equal("XXXXXX", trurip.RelatedTo);
+        }
+
+        /// <summary>
+        /// Validate a Release
+        /// </summary>
+        private static void Validate(Data.Models.Logiqx.Release? release)
+        {
+            Assert.NotNull(release);
+            Assert.Equal("XXXXXX", release.Name);
+            Assert.Equal("XXXXXX", release.Region);
+            Assert.Equal("XXXXXX", release.Language);
+            Assert.Equal("XXXXXX", release.Date);
+            Assert.Equal("XXXXXX", release.Default);
+        }
+
+        /// <summary>
+        /// Validate a BiosSet
+        /// </summary>
+        private static void Validate(Data.Models.Logiqx.BiosSet? biosset)
+        {
+            Assert.NotNull(biosset);
+            Assert.Equal("XXXXXX", biosset.Name);
+            Assert.Equal("XXXXXX", biosset.Description);
+            Assert.Equal("XXXXXX", biosset.Default);
+        }
+
+        /// <summary>
+        /// Validate a Rom
+        /// </summary>
+        private static void Validate(Data.Models.Logiqx.Rom? rom)
+        {
+            Assert.NotNull(rom);
+            Assert.Equal("XXXXXX", rom.Name);
+            Assert.Equal("XXXXXX", rom.Size);
+            Assert.Equal("XXXXXX", rom.CRC);
+            Assert.Equal("XXXXXX", rom.MD2);
+            Assert.Equal("XXXXXX", rom.MD4);
+            Assert.Equal("XXXXXX", rom.MD5);
+            Assert.Equal("XXXXXX", rom.RIPEMD128);
+            Assert.Equal("XXXXXX", rom.RIPEMD160);
+            Assert.Equal("XXXXXX", rom.SHA1);
+            Assert.Equal("XXXXXX", rom.SHA256);
+            Assert.Equal("XXXXXX", rom.SHA384);
+            Assert.Equal("XXXXXX", rom.SHA512);
+            Assert.Equal("XXXXXX", rom.SpamSum);
+            Assert.Equal("XXXXXX", rom.xxHash364);
+            Assert.Equal("XXXXXX", rom.xxHash3128);
+            Assert.Equal("XXXXXX", rom.Merge);
+            Assert.Equal("XXXXXX", rom.Status);
+            Assert.Equal("XXXXXX", rom.Serial);
+            Assert.Equal("XXXXXX", rom.Header);
+            Assert.Equal("XXXXXX", rom.Date);
+            Assert.Equal("XXXXXX", rom.Inverted);
+            Assert.Equal("XXXXXX", rom.MIA);
+        }
+
+        /// <summary>
+        /// Validate a Disk
+        /// </summary>
+        private static void Validate(Data.Models.Logiqx.Disk? disk)
+        {
+            Assert.NotNull(disk);
+            Assert.Equal("XXXXXX", disk.Name);
+            Assert.Equal("XXXXXX", disk.MD5);
+            Assert.Equal("XXXXXX", disk.SHA1);
+            Assert.Equal("XXXXXX", disk.Merge);
+            Assert.Equal("XXXXXX", disk.Status);
+            Assert.Equal("XXXXXX", disk.Region);
+        }
+
+        /// <summary>
+        /// Validate a Media
+        /// </summary>
+        private static void Validate(Data.Models.Logiqx.Media? media)
+        {
+            Assert.NotNull(media);
+            Assert.Equal("XXXXXX", media.Name);
+            Assert.Equal("XXXXXX", media.MD5);
+            Assert.Equal("XXXXXX", media.SHA1);
+            Assert.Equal("XXXXXX", media.SHA256);
+            Assert.Equal("XXXXXX", media.SpamSum);
+        }
+
+        /// <summary>
+        /// Validate a DeviceRef
+        /// </summary>
+        private static void Validate(Data.Models.Logiqx.DeviceRef? deviceref)
+        {
+            Assert.NotNull(deviceref);
+            Assert.Equal("XXXXXX", deviceref.Name);
+        }
+
+        /// <summary>
+        /// Validate a Sample
+        /// </summary>
+        private static void Validate(Data.Models.Logiqx.Sample? sample)
+        {
+            Assert.NotNull(sample);
+            Assert.Equal("XXXXXX", sample.Name);
+        }
+
+        /// <summary>
+        /// Validate a Archive
+        /// </summary>
+        private static void Validate(Data.Models.Logiqx.Archive? archive)
+        {
+            Assert.NotNull(archive);
+            Assert.Equal("XXXXXX", archive.Name);
+        }
+
+        /// <summary>
+        /// Validate a Driver
+        /// </summary>
+        private static void Validate(Data.Models.Logiqx.Driver? driver)
+        {
+            Assert.NotNull(driver);
+            Assert.Equal("XXXXXX", driver.Status);
+            Assert.Equal("XXXXXX", driver.Emulation);
+            Assert.Equal("XXXXXX", driver.Cocktail);
+            Assert.Equal("XXXXXX", driver.SaveState);
+            Assert.Equal("XXXXXX", driver.RequiresArtwork);
+            Assert.Equal("XXXXXX", driver.Unofficial);
+            Assert.Equal("XXXXXX", driver.NoSoundHardware);
+            Assert.Equal("XXXXXX", driver.Incomplete);
+        }
+
+        /// <summary>
+        /// Validate a SoftwareList
+        /// </summary>
+        private static void Validate(Data.Models.Logiqx.SoftwareList? softwarelist)
+        {
+            Assert.NotNull(softwarelist);
+            Assert.Equal("XXXXXX", softwarelist.Tag);
+            Assert.Equal("XXXXXX", softwarelist.Name);
+            Assert.Equal("XXXXXX", softwarelist.Status);
+            Assert.Equal("XXXXXX", softwarelist.Filter);
+        }
+    }
+}

SabreTools.Serialization.Test/CrossModel/M1Tests.cs

@@ -0,0 +1,873 @@
+using SabreTools.Serialization.CrossModel;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.CrossModel
+{
+    public class M1Tests
+    {
+        [Fact]
+        public void RoundTripGameTest()
+        {
+            // Get the cross-model serializer
+            var serializer = new M1();
+
+            // Build the data
+            Data.Models.Listxml.M1 m1 = Build(game: true);
+
+            // Serialize to generic model
+            Data.Models.Metadata.MetadataFile? metadata = serializer.Serialize(m1);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.Listxml.M1? newM1 = serializer.Deserialize(metadata);
+
+            // Validate the data
+            Assert.NotNull(newM1);
+            Assert.Equal("XXXXXX", newM1.Version);
+
+            Assert.NotNull(newM1.Game);
+            var newGame = Assert.Single(newM1.Game);
+            Validate(newGame);
+        }
+
+        [Fact]
+        public void RoundTripMachineTest()
+        {
+            // Get the cross-model serializer
+            var serializer = new M1();
+
+            // Build the data
+            Data.Models.Listxml.M1 m1 = Build(game: false);
+
+            // Serialize to generic model
+            Data.Models.Metadata.MetadataFile? metadata = serializer.Serialize(m1);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.Listxml.M1? newM1 = serializer.Deserialize(metadata);
+
+            // Validate the data
+            Assert.NotNull(newM1);
+            Assert.Equal("XXXXXX", newM1.Version);
+
+            Assert.NotNull(newM1.Game);
+            var newGame = Assert.Single(newM1.Game);
+            Validate(newGame);
+        }
+
+        /// <summary>
+        /// Build model for serialization and deserialization
+        /// </summary>
+        private static Data.Models.Listxml.M1 Build(bool game)
+        {
+            var biosset = new Data.Models.Listxml.BiosSet
+            {
+                Name = "XXXXXX",
+                Description = "XXXXXX",
+                Default = "XXXXXX",
+            };
+
+            var rom = new Data.Models.Listxml.Rom
+            {
+                Name = "XXXXXX",
+                Bios = "XXXXXX",
+                Size = "XXXXXX",
+                CRC = "XXXXXX",
+                SHA1 = "XXXXXX",
+                Merge = "XXXXXX",
+                Region = "XXXXXX",
+                Offset = "XXXXXX",
+                Status = "XXXXXX",
+                Optional = "XXXXXX",
+                Dispose = "XXXXXX",
+                SoundOnly = "XXXXXX",
+            };
+
+            var disk = new Data.Models.Listxml.Disk
+            {
+                Name = "XXXXXX",
+                MD5 = "XXXXXX",
+                SHA1 = "XXXXXX",
+                Merge = "XXXXXX",
+                Region = "XXXXXX",
+                Index = "XXXXXX",
+                Writable = "XXXXXX",
+                Status = "XXXXXX",
+                Optional = "XXXXXX",
+            };
+
+            var deviceref = new Data.Models.Listxml.DeviceRef
+            {
+                Name = "XXXXXX",
+            };
+
+            var sample = new Data.Models.Listxml.Sample
+            {
+                Name = "XXXXXX",
+            };
+
+            var chip = new Data.Models.Listxml.Chip
+            {
+                Name = "XXXXXX",
+                Tag = "XXXXXX",
+                Type = "XXXXXX",
+                SoundOnly = "XXXXXX",
+                Clock = "XXXXXX",
+            };
+
+            var display = new Data.Models.Listxml.Display
+            {
+                Tag = "XXXXXX",
+                Type = "XXXXXX",
+                Rotate = "XXXXXX",
+                FlipX = "XXXXXX",
+                Width = "XXXXXX",
+                Height = "XXXXXX",
+                Refresh = "XXXXXX",
+                PixClock = "XXXXXX",
+                HTotal = "XXXXXX",
+                HBEnd = "XXXXXX",
+                HBStart = "XXXXXX",
+                VTotal = "XXXXXX",
+                VBEnd = "XXXXXX",
+                VBStart = "XXXXXX",
+            };
+
+            var video = new Data.Models.Listxml.Video
+            {
+                Screen = "XXXXXX",
+                Orientation = "XXXXXX",
+                Width = "XXXXXX",
+                Height = "XXXXXX",
+                AspectX = "XXXXXX",
+                AspectY = "XXXXXX",
+                Refresh = "XXXXXX",
+            };
+
+            var sound = new Data.Models.Listxml.Sound
+            {
+                Channels = "XXXXXX",
+            };
+
+            var control = new Data.Models.Listxml.Control
+            {
+                Type = "XXXXXX",
+                Player = "XXXXXX",
+                Buttons = "XXXXXX",
+                ReqButtons = "XXXXXX",
+                Minimum = "XXXXXX",
+                Maximum = "XXXXXX",
+                Sensitivity = "XXXXXX",
+                KeyDelta = "XXXXXX",
+                Reverse = "XXXXXX",
+                Ways = "XXXXXX",
+                Ways2 = "XXXXXX",
+                Ways3 = "XXXXXX",
+            };
+
+            var input = new Data.Models.Listxml.Input
+            {
+                Service = "XXXXXX",
+                Tilt = "XXXXXX",
+                Players = "XXXXXX",
+                //ControlAttr = "XXXXXX", // Mututally exclusive with input.Control
+                Buttons = "XXXXXX",
+                Coins = "XXXXXX",
+                Control = [control],
+            };
+
+            var condition = new Data.Models.Listxml.Condition
+            {
+                Tag = "XXXXXX",
+                Mask = "XXXXXX",
+                Relation = "XXXXXX",
+                Value = "XXXXXX",
+            };
+
+            var diplocation = new Data.Models.Listxml.DipLocation
+            {
+                Name = "XXXXXX",
+                Number = "XXXXXX",
+                Inverted = "XXXXXX",
+            };
+
+            var dipvalue = new Data.Models.Listxml.DipValue
+            {
+                Name = "XXXXXX",
+                Value = "XXXXXX",
+                Default = "XXXXXX",
+                Condition = condition,
+            };
+
+            var dipswitch = new Data.Models.Listxml.DipSwitch
+            {
+                Name = "XXXXXX",
+                Tag = "XXXXXX",
+                Mask = "XXXXXX",
+                Condition = condition,
+                DipLocation = [diplocation],
+                DipValue = [dipvalue],
+            };
+
+            var conflocation = new Data.Models.Listxml.ConfLocation
+            {
+                Name = "XXXXXX",
+                Number = "XXXXXX",
+                Inverted = "XXXXXX",
+            };
+
+            var confsetting = new Data.Models.Listxml.ConfSetting
+            {
+                Name = "XXXXXX",
+                Value = "XXXXXX",
+                Default = "XXXXXX",
+                Condition = condition,
+            };
+
+            var configuration = new Data.Models.Listxml.Configuration
+            {
+                Name = "XXXXXX",
+                Tag = "XXXXXX",
+                Mask = "XXXXXX",
+                Condition = condition,
+                ConfLocation = [conflocation],
+                ConfSetting = [confsetting],
+            };
+
+            var analog = new Data.Models.Listxml.Analog
+            {
+                Mask = "XXXXXX",
+            };
+
+            var port = new Data.Models.Listxml.Port
+            {
+                Tag = "XXXXXX",
+                Analog = [analog],
+            };
+
+            var adjuster = new Data.Models.Listxml.Adjuster
+            {
+                Name = "XXXXXX",
+                Default = "XXXXXX",
+                Condition = condition,
+            };
+
+            var driver = new Data.Models.Listxml.Driver
+            {
+                Status = "XXXXXX",
+                Color = "XXXXXX",
+                Sound = "XXXXXX",
+                PaletteSize = "XXXXXX",
+                Emulation = "XXXXXX",
+                Cocktail = "XXXXXX",
+                SaveState = "XXXXXX",
+                RequiresArtwork = "XXXXXX",
+                Unofficial = "XXXXXX",
+                NoSoundHardware = "XXXXXX",
+                Incomplete = "XXXXXX",
+            };
+
+            var feature = new Data.Models.Listxml.Feature
+            {
+                Type = "XXXXXX",
+                Status = "XXXXXX",
+                Overall = "XXXXXX",
+            };
+
+            var instance = new Data.Models.Listxml.Instance
+            {
+                Name = "XXXXXX",
+                BriefName = "XXXXXX",
+            };
+
+            var extension = new Data.Models.Listxml.Extension
+            {
+                Name = "XXXXXX",
+            };
+
+            var device = new Data.Models.Listxml.Device
+            {
+                Type = "XXXXXX",
+                Tag = "XXXXXX",
+                FixedImage = "XXXXXX",
+                Mandatory = "XXXXXX",
+                Interface = "XXXXXX",
+                Instance = instance,
+                Extension = [extension],
+            };
+
+            var slotOption = new Data.Models.Listxml.SlotOption
+            {
+                Name = "XXXXXX",
+                DevName = "XXXXXX",
+                Default = "XXXXXX",
+            };
+
+            var slot = new Data.Models.Listxml.Slot
+            {
+                Name = "XXXXXX",
+                SlotOption = [slotOption],
+            };
+
+            var softwarelist = new Data.Models.Listxml.SoftwareList
+            {
+                Tag = "XXXXXX",
+                Name = "XXXXXX",
+                Status = "XXXXXX",
+                Filter = "XXXXXX",
+            };
+
+            var ramoption = new Data.Models.Listxml.RamOption
+            {
+                Name = "XXXXXX",
+                Default = "XXXXXX",
+                Content = "XXXXXX",
+            };
+
+            Data.Models.Listxml.GameBase gameBase = game
+                ? new Data.Models.Listxml.Game()
+                : new Data.Models.Listxml.Machine();
+            gameBase.Name = "XXXXXX";
+            gameBase.SourceFile = "XXXXXX";
+            gameBase.IsBios = "XXXXXX";
+            gameBase.IsDevice = "XXXXXX";
+            gameBase.IsMechanical = "XXXXXX";
+            gameBase.Runnable = "XXXXXX";
+            gameBase.CloneOf = "XXXXXX";
+            gameBase.RomOf = "XXXXXX";
+            gameBase.SampleOf = "XXXXXX";
+            gameBase.Description = "XXXXXX";
+            gameBase.Year = "XXXXXX";
+            gameBase.Manufacturer = "XXXXXX";
+            gameBase.History = "XXXXXX";
+            gameBase.BiosSet = [biosset];
+            gameBase.Rom = [rom];
+            gameBase.Disk = [disk];
+            gameBase.DeviceRef = [deviceref];
+            gameBase.Sample = [sample];
+            gameBase.Chip = [chip];
+            gameBase.Display = [display];
+            gameBase.Video = [video];
+            gameBase.Sound = sound;
+            gameBase.Input = input;
+            gameBase.DipSwitch = [dipswitch];
+            gameBase.Configuration = [configuration];
+            gameBase.Port = [port];
+            gameBase.Adjuster = [adjuster];
+            gameBase.Driver = driver;
+            gameBase.Feature = [feature];
+            gameBase.Device = [device];
+            gameBase.Slot = [slot];
+            gameBase.SoftwareList = [softwarelist];
+            gameBase.RamOption = [ramoption];
+
+            return new Data.Models.Listxml.M1
+            {
+                Version = "XXXXXX",
+                Game = [gameBase],
+            };
+        }
+
+        /// <summary>
+        /// Validate a GameBase
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.GameBase? gb)
+        {
+            Assert.NotNull(gb);
+            Assert.Equal("XXXXXX", gb.Name);
+            Assert.Equal("XXXXXX", gb.SourceFile);
+            Assert.Equal("XXXXXX", gb.IsBios);
+            Assert.Equal("XXXXXX", gb.IsDevice);
+            Assert.Equal("XXXXXX", gb.IsMechanical);
+            Assert.Equal("XXXXXX", gb.Runnable);
+            Assert.Equal("XXXXXX", gb.CloneOf);
+            Assert.Equal("XXXXXX", gb.RomOf);
+            Assert.Equal("XXXXXX", gb.SampleOf);
+            Assert.Equal("XXXXXX", gb.Description);
+            Assert.Equal("XXXXXX", gb.Year);
+            Assert.Equal("XXXXXX", gb.Manufacturer);
+            Assert.Equal("XXXXXX", gb.History);
+
+            Assert.NotNull(gb.BiosSet);
+            var biosset = Assert.Single(gb.BiosSet);
+            Validate(biosset);
+
+            Assert.NotNull(gb.Rom);
+            var rom = Assert.Single(gb.Rom);
+            Validate(rom);
+
+            Assert.NotNull(gb.Disk);
+            var disk = Assert.Single(gb.Disk);
+            Validate(disk);
+
+            Assert.NotNull(gb.DeviceRef);
+            var deviceref = Assert.Single(gb.DeviceRef);
+            Validate(deviceref);
+
+            Assert.NotNull(gb.Sample);
+            var sample = Assert.Single(gb.Sample);
+            Validate(sample);
+
+            Assert.NotNull(gb.Chip);
+            var chip = Assert.Single(gb.Chip);
+            Validate(chip);
+
+            Assert.NotNull(gb.Display);
+            var display = Assert.Single(gb.Display);
+            Validate(display);
+
+            Assert.NotNull(gb.Video);
+            var video = Assert.Single(gb.Video);
+            Validate(video);
+
+            Validate(gb.Sound);
+            Validate(gb.Input);
+
+            Assert.NotNull(gb.DipSwitch);
+            var dipswitch = Assert.Single(gb.DipSwitch);
+            Validate(dipswitch);
+
+            Assert.NotNull(gb.Configuration);
+            var configuration = Assert.Single(gb.Configuration);
+            Validate(configuration);
+
+            Assert.NotNull(gb.Port);
+            var port = Assert.Single(gb.Port);
+            Validate(port);
+
+            Assert.NotNull(gb.Adjuster);
+            var adjuster = Assert.Single(gb.Adjuster);
+            Validate(adjuster);
+
+            Validate(gb.Driver);
+
+            Assert.NotNull(gb.Feature);
+            var feature = Assert.Single(gb.Feature);
+            Validate(feature);
+
+            Assert.NotNull(gb.Device);
+            var device = Assert.Single(gb.Device);
+            Validate(device);
+
+            Assert.NotNull(gb.Slot);
+            var slot = Assert.Single(gb.Slot);
+            Validate(slot);
+
+            Assert.NotNull(gb.SoftwareList);
+            var softwarelist = Assert.Single(gb.SoftwareList);
+            Validate(softwarelist);
+
+            Assert.NotNull(gb.RamOption);
+            var ramoption = Assert.Single(gb.RamOption);
+            Validate(ramoption);
+        }
+
+        /// <summary>
+        /// Validate a BiosSet
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.BiosSet? biosset)
+        {
+            Assert.NotNull(biosset);
+            Assert.Equal("XXXXXX", biosset.Name);
+            Assert.Equal("XXXXXX", biosset.Description);
+            Assert.Equal("XXXXXX", biosset.Default);
+        }
+
+        /// <summary>
+        /// Validate a Rom
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Rom? rom)
+        {
+            Assert.NotNull(rom);
+            Assert.Equal("XXXXXX", rom.Name);
+            Assert.Equal("XXXXXX", rom.Bios);
+            Assert.Equal("XXXXXX", rom.Size);
+            Assert.Equal("XXXXXX", rom.CRC);
+            Assert.Equal("XXXXXX", rom.SHA1);
+            Assert.Equal("XXXXXX", rom.Merge);
+            Assert.Equal("XXXXXX", rom.Region);
+            Assert.Equal("XXXXXX", rom.Offset);
+            Assert.Equal("XXXXXX", rom.Status);
+            Assert.Equal("XXXXXX", rom.Optional);
+            Assert.Equal("XXXXXX", rom.Dispose);
+            Assert.Equal("XXXXXX", rom.SoundOnly);
+        }
+
+        /// <summary>
+        /// Validate a Disk
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Disk? disk)
+        {
+            Assert.NotNull(disk);
+            Assert.Equal("XXXXXX", disk.Name);
+            Assert.Equal("XXXXXX", disk.MD5);
+            Assert.Equal("XXXXXX", disk.SHA1);
+            Assert.Equal("XXXXXX", disk.Merge);
+            Assert.Equal("XXXXXX", disk.Region);
+            Assert.Equal("XXXXXX", disk.Index);
+            Assert.Equal("XXXXXX", disk.Writable);
+            Assert.Equal("XXXXXX", disk.Status);
+            Assert.Equal("XXXXXX", disk.Optional);
+        }
+
+        /// <summary>
+        /// Validate a DeviceRef
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.DeviceRef? deviceref)
+        {
+            Assert.NotNull(deviceref);
+            Assert.Equal("XXXXXX", deviceref.Name);
+        }
+
+        /// <summary>
+        /// Validate a Sample
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Sample? sample)
+        {
+            Assert.NotNull(sample);
+            Assert.Equal("XXXXXX", sample.Name);
+        }
+
+        /// <summary>
+        /// Validate a Chip
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Chip? chip)
+        {
+            Assert.NotNull(chip);
+            Assert.Equal("XXXXXX", chip.Name);
+            Assert.Equal("XXXXXX", chip.Tag);
+            Assert.Equal("XXXXXX", chip.Type);
+            Assert.Equal("XXXXXX", chip.SoundOnly);
+            Assert.Equal("XXXXXX", chip.Clock);
+        }
+
+        /// <summary>
+        /// Validate a Display
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Display? display)
+        {
+            Assert.NotNull(display);
+            Assert.Equal("XXXXXX", display.Tag);
+            Assert.Equal("XXXXXX", display.Type);
+            Assert.Equal("XXXXXX", display.Rotate);
+            Assert.Equal("XXXXXX", display.FlipX);
+            Assert.Equal("XXXXXX", display.Width);
+            Assert.Equal("XXXXXX", display.Height);
+            Assert.Equal("XXXXXX", display.Refresh);
+            Assert.Equal("XXXXXX", display.PixClock);
+            Assert.Equal("XXXXXX", display.HTotal);
+            Assert.Equal("XXXXXX", display.HBEnd);
+            Assert.Equal("XXXXXX", display.HBStart);
+            Assert.Equal("XXXXXX", display.VTotal);
+            Assert.Equal("XXXXXX", display.VBEnd);
+            Assert.Equal("XXXXXX", display.VBStart);
+        }
+
+        /// <summary>
+        /// Validate a Video
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Video? video)
+        {
+            Assert.NotNull(video);
+            Assert.Equal("XXXXXX", video.Screen);
+            Assert.Equal("XXXXXX", video.Orientation);
+            Assert.Equal("XXXXXX", video.Width);
+            Assert.Equal("XXXXXX", video.Height);
+            Assert.Equal("XXXXXX", video.AspectX);
+            Assert.Equal("XXXXXX", video.AspectY);
+            Assert.Equal("XXXXXX", video.Refresh);
+        }
+
+        /// <summary>
+        /// Validate a Sound
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Sound? sound)
+        {
+            Assert.NotNull(sound);
+            Assert.Equal("XXXXXX", sound.Channels);
+        }
+
+        /// <summary>
+        /// Validate a Input
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Input? input)
+        {
+            Assert.NotNull(input);
+            Assert.Equal("XXXXXX", input.Service);
+            Assert.Equal("XXXXXX", input.Tilt);
+            Assert.Equal("XXXXXX", input.Players);
+            //Assert.Equal("XXXXXX", input.ControlAttr); // Mututally exclusive with input.Control
+            Assert.Equal("XXXXXX", input.Buttons);
+            Assert.Equal("XXXXXX", input.Coins);
+
+            Assert.NotNull(input.Control);
+            var control = Assert.Single(input.Control);
+            Validate(control);
+        }
+
+        /// <summary>
+        /// Validate a Control
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Control? control)
+        {
+            Assert.NotNull(control);
+            Assert.Equal("XXXXXX", control.Type);
+            Assert.Equal("XXXXXX", control.Player);
+            Assert.Equal("XXXXXX", control.Buttons);
+            Assert.Equal("XXXXXX", control.ReqButtons);
+            Assert.Equal("XXXXXX", control.Minimum);
+            Assert.Equal("XXXXXX", control.Maximum);
+            Assert.Equal("XXXXXX", control.Sensitivity);
+            Assert.Equal("XXXXXX", control.KeyDelta);
+            Assert.Equal("XXXXXX", control.Reverse);
+            Assert.Equal("XXXXXX", control.Ways);
+            Assert.Equal("XXXXXX", control.Ways2);
+            Assert.Equal("XXXXXX", control.Ways3);
+        }
+
+        /// <summary>
+        /// Validate a DipSwitch
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.DipSwitch? dipswitch)
+        {
+            Assert.NotNull(dipswitch);
+            Assert.Equal("XXXXXX", dipswitch.Name);
+            Assert.Equal("XXXXXX", dipswitch.Tag);
+            Assert.Equal("XXXXXX", dipswitch.Mask);
+            Validate(dipswitch.Condition);
+
+            Assert.NotNull(dipswitch.DipLocation);
+            var diplocation = Assert.Single(dipswitch.DipLocation);
+            Validate(diplocation);
+
+            Assert.NotNull(dipswitch.DipValue);
+            var dipvalue = Assert.Single(dipswitch.DipValue);
+            Validate(dipvalue);
+        }
+
+        /// <summary>
+        /// Validate a Condition
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Condition? condition)
+        {
+            Assert.NotNull(condition);
+            Assert.Equal("XXXXXX", condition.Tag);
+            Assert.Equal("XXXXXX", condition.Mask);
+            Assert.Equal("XXXXXX", condition.Relation);
+            Assert.Equal("XXXXXX", condition.Value);
+        }
+
+        /// <summary>
+        /// Validate a DipLocation
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.DipLocation? diplocation)
+        {
+            Assert.NotNull(diplocation);
+            Assert.Equal("XXXXXX", diplocation.Name);
+            Assert.Equal("XXXXXX", diplocation.Number);
+            Assert.Equal("XXXXXX", diplocation.Inverted);
+        }
+
+        /// <summary>
+        /// Validate a DipValue
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.DipValue? dipvalue)
+        {
+            Assert.NotNull(dipvalue);
+            Assert.Equal("XXXXXX", dipvalue.Name);
+            Assert.Equal("XXXXXX", dipvalue.Value);
+            Assert.Equal("XXXXXX", dipvalue.Default);
+            Validate(dipvalue.Condition);
+        }
+
+        /// <summary>
+        /// Validate a Configuration
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Configuration? configuration)
+        {
+            Assert.NotNull(configuration);
+            Assert.Equal("XXXXXX", configuration.Name);
+            Assert.Equal("XXXXXX", configuration.Tag);
+            Assert.Equal("XXXXXX", configuration.Mask);
+            Validate(configuration.Condition);
+
+            Assert.NotNull(configuration.ConfLocation);
+            var conflocation = Assert.Single(configuration.ConfLocation);
+            Validate(conflocation);
+
+            Assert.NotNull(configuration.ConfSetting);
+            var confsetting = Assert.Single(configuration.ConfSetting);
+            Validate(confsetting);
+        }
+
+        /// <summary>
+        /// Validate a ConfLocation
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.ConfLocation? conflocation)
+        {
+            Assert.NotNull(conflocation);
+            Assert.Equal("XXXXXX", conflocation.Name);
+            Assert.Equal("XXXXXX", conflocation.Number);
+            Assert.Equal("XXXXXX", conflocation.Inverted);
+        }
+
+        /// <summary>
+        /// Validate a ConfSetting
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.ConfSetting? confsetting)
+        {
+            Assert.NotNull(confsetting);
+            Assert.Equal("XXXXXX", confsetting.Name);
+            Assert.Equal("XXXXXX", confsetting.Value);
+            Assert.Equal("XXXXXX", confsetting.Default);
+            Validate(confsetting.Condition);
+        }
+
+        /// <summary>
+        /// Validate a Port
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Port? port)
+        {
+            Assert.NotNull(port);
+            Assert.Equal("XXXXXX", port.Tag);
+
+            Assert.NotNull(port.Analog);
+            var analog = Assert.Single(port.Analog);
+            Validate(analog);
+        }
+
+        /// <summary>
+        /// Validate a Analog
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Analog? analog)
+        {
+            Assert.NotNull(analog);
+            Assert.Equal("XXXXXX", analog.Mask);
+        }
+
+        /// <summary>
+        /// Validate a Adjuster
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Adjuster? adjuster)
+        {
+            Assert.NotNull(adjuster);
+            Assert.Equal("XXXXXX", adjuster.Name);
+            Assert.Equal("XXXXXX", adjuster.Default);
+            Validate(adjuster.Condition);
+        }
+
+        /// <summary>
+        /// Validate a Driver
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Driver? driver)
+        {
+            Assert.NotNull(driver);
+            Assert.Equal("XXXXXX", driver.Status);
+            Assert.Equal("XXXXXX", driver.Color);
+            Assert.Equal("XXXXXX", driver.Sound);
+            Assert.Equal("XXXXXX", driver.PaletteSize);
+            Assert.Equal("XXXXXX", driver.Emulation);
+            Assert.Equal("XXXXXX", driver.Cocktail);
+            Assert.Equal("XXXXXX", driver.SaveState);
+            Assert.Equal("XXXXXX", driver.RequiresArtwork);
+            Assert.Equal("XXXXXX", driver.Unofficial);
+            Assert.Equal("XXXXXX", driver.NoSoundHardware);
+            Assert.Equal("XXXXXX", driver.Incomplete);
+        }
+
+        /// <summary>
+        /// Validate a Feature
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Feature? feature)
+        {
+            Assert.NotNull(feature);
+            Assert.Equal("XXXXXX", feature.Type);
+            Assert.Equal("XXXXXX", feature.Status);
+            Assert.Equal("XXXXXX", feature.Overall);
+        }
+
+        /// <summary>
+        /// Validate a Device
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Device? device)
+        {
+            Assert.NotNull(device);
+            Assert.Equal("XXXXXX", device.Type);
+            Assert.Equal("XXXXXX", device.Tag);
+            Assert.Equal("XXXXXX", device.FixedImage);
+            Assert.Equal("XXXXXX", device.Mandatory);
+            Assert.Equal("XXXXXX", device.Interface);
+            Validate(device.Instance);
+
+            Assert.NotNull(device.Extension);
+            var extension = Assert.Single(device.Extension);
+            Validate(extension);
+        }
+
+        /// <summary>
+        /// Validate a Instance
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Instance? instance)
+        {
+            Assert.NotNull(instance);
+            Assert.Equal("XXXXXX", instance.Name);
+            Assert.Equal("XXXXXX", instance.BriefName);
+        }
+
+        /// <summary>
+        /// Validate a Extension
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Extension? extension)
+        {
+            Assert.NotNull(extension);
+            Assert.Equal("XXXXXX", extension.Name);
+        }
+
+        /// <summary>
+        /// Validate a Slot
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Slot? slot)
+        {
+            Assert.NotNull(slot);
+            Assert.Equal("XXXXXX", slot.Name);
+
+            Assert.NotNull(slot.SlotOption);
+            var slotoption = Assert.Single(slot.SlotOption);
+            Validate(slotoption);
+        }
+
+        /// <summary>
+        /// Validate a SlotOption
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.SlotOption? slotoption)
+        {
+            Assert.NotNull(slotoption);
+            Assert.Equal("XXXXXX", slotoption.Name);
+            Assert.Equal("XXXXXX", slotoption.DevName);
+            Assert.Equal("XXXXXX", slotoption.Default);
+        }
+
+        /// <summary>
+        /// Validate a SoftwareList
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.SoftwareList? softwarelist)
+        {
+            Assert.NotNull(softwarelist);
+            Assert.Equal("XXXXXX", softwarelist.Tag);
+            Assert.Equal("XXXXXX", softwarelist.Name);
+            Assert.Equal("XXXXXX", softwarelist.Status);
+            Assert.Equal("XXXXXX", softwarelist.Filter);
+        }
+
+        /// <summary>
+        /// Validate a RamOption
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.RamOption? ramoption)
+        {
+            Assert.NotNull(ramoption);
+            Assert.Equal("XXXXXX", ramoption.Name);
+            Assert.Equal("XXXXXX", ramoption.Default);
+            Assert.Equal("XXXXXX", ramoption.Content);
+        }
+    }
+}

SabreTools.Serialization.Test/CrossModel/MessTests.cs

@@ -0,0 +1,873 @@
+using SabreTools.Serialization.CrossModel;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.CrossModel
+{
+    public class MessTests
+    {
+        [Fact]
+        public void RoundTripGameTest()
+        {
+            // Get the cross-model serializer
+            var serializer = new Mess();
+
+            // Build the data
+            Data.Models.Listxml.Mess m1 = Build(game: true);
+
+            // Serialize to generic model
+            Data.Models.Metadata.MetadataFile? metadata = serializer.Serialize(m1);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.Listxml.Mess? newMess = serializer.Deserialize(metadata);
+
+            // Validate the data
+            Assert.NotNull(newMess);
+            Assert.Equal("XXXXXX", newMess.Version);
+
+            Assert.NotNull(newMess.Game);
+            var newGame = Assert.Single(newMess.Game);
+            Validate(newGame);
+        }
+
+        [Fact]
+        public void RoundTripMachineTest()
+        {
+            // Get the cross-model serializer
+            var serializer = new Mess();
+
+            // Build the data
+            Data.Models.Listxml.Mess m1 = Build(game: false);
+
+            // Serialize to generic model
+            Data.Models.Metadata.MetadataFile? metadata = serializer.Serialize(m1);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.Listxml.Mess? newMess = serializer.Deserialize(metadata);
+
+            // Validate the data
+            Assert.NotNull(newMess);
+            Assert.Equal("XXXXXX", newMess.Version);
+
+            Assert.NotNull(newMess.Game);
+            var newGame = Assert.Single(newMess.Game);
+            Validate(newGame);
+        }
+
+        /// <summary>
+        /// Build model for serialization and deserialization
+        /// </summary>
+        private static Data.Models.Listxml.Mess Build(bool game)
+        {
+            var biosset = new Data.Models.Listxml.BiosSet
+            {
+                Name = "XXXXXX",
+                Description = "XXXXXX",
+                Default = "XXXXXX",
+            };
+
+            var rom = new Data.Models.Listxml.Rom
+            {
+                Name = "XXXXXX",
+                Bios = "XXXXXX",
+                Size = "XXXXXX",
+                CRC = "XXXXXX",
+                SHA1 = "XXXXXX",
+                Merge = "XXXXXX",
+                Region = "XXXXXX",
+                Offset = "XXXXXX",
+                Status = "XXXXXX",
+                Optional = "XXXXXX",
+                Dispose = "XXXXXX",
+                SoundOnly = "XXXXXX",
+            };
+
+            var disk = new Data.Models.Listxml.Disk
+            {
+                Name = "XXXXXX",
+                MD5 = "XXXXXX",
+                SHA1 = "XXXXXX",
+                Merge = "XXXXXX",
+                Region = "XXXXXX",
+                Index = "XXXXXX",
+                Writable = "XXXXXX",
+                Status = "XXXXXX",
+                Optional = "XXXXXX",
+            };
+
+            var deviceref = new Data.Models.Listxml.DeviceRef
+            {
+                Name = "XXXXXX",
+            };
+
+            var sample = new Data.Models.Listxml.Sample
+            {
+                Name = "XXXXXX",
+            };
+
+            var chip = new Data.Models.Listxml.Chip
+            {
+                Name = "XXXXXX",
+                Tag = "XXXXXX",
+                Type = "XXXXXX",
+                SoundOnly = "XXXXXX",
+                Clock = "XXXXXX",
+            };
+
+            var display = new Data.Models.Listxml.Display
+            {
+                Tag = "XXXXXX",
+                Type = "XXXXXX",
+                Rotate = "XXXXXX",
+                FlipX = "XXXXXX",
+                Width = "XXXXXX",
+                Height = "XXXXXX",
+                Refresh = "XXXXXX",
+                PixClock = "XXXXXX",
+                HTotal = "XXXXXX",
+                HBEnd = "XXXXXX",
+                HBStart = "XXXXXX",
+                VTotal = "XXXXXX",
+                VBEnd = "XXXXXX",
+                VBStart = "XXXXXX",
+            };
+
+            var video = new Data.Models.Listxml.Video
+            {
+                Screen = "XXXXXX",
+                Orientation = "XXXXXX",
+                Width = "XXXXXX",
+                Height = "XXXXXX",
+                AspectX = "XXXXXX",
+                AspectY = "XXXXXX",
+                Refresh = "XXXXXX",
+            };
+
+            var sound = new Data.Models.Listxml.Sound
+            {
+                Channels = "XXXXXX",
+            };
+
+            var control = new Data.Models.Listxml.Control
+            {
+                Type = "XXXXXX",
+                Player = "XXXXXX",
+                Buttons = "XXXXXX",
+                ReqButtons = "XXXXXX",
+                Minimum = "XXXXXX",
+                Maximum = "XXXXXX",
+                Sensitivity = "XXXXXX",
+                KeyDelta = "XXXXXX",
+                Reverse = "XXXXXX",
+                Ways = "XXXXXX",
+                Ways2 = "XXXXXX",
+                Ways3 = "XXXXXX",
+            };
+
+            var input = new Data.Models.Listxml.Input
+            {
+                Service = "XXXXXX",
+                Tilt = "XXXXXX",
+                Players = "XXXXXX",
+                //ControlAttr = "XXXXXX", // Mututally exclusive with input.Control
+                Buttons = "XXXXXX",
+                Coins = "XXXXXX",
+                Control = [control],
+            };
+
+            var condition = new Data.Models.Listxml.Condition
+            {
+                Tag = "XXXXXX",
+                Mask = "XXXXXX",
+                Relation = "XXXXXX",
+                Value = "XXXXXX",
+            };
+
+            var diplocation = new Data.Models.Listxml.DipLocation
+            {
+                Name = "XXXXXX",
+                Number = "XXXXXX",
+                Inverted = "XXXXXX",
+            };
+
+            var dipvalue = new Data.Models.Listxml.DipValue
+            {
+                Name = "XXXXXX",
+                Value = "XXXXXX",
+                Default = "XXXXXX",
+                Condition = condition,
+            };
+
+            var dipswitch = new Data.Models.Listxml.DipSwitch
+            {
+                Name = "XXXXXX",
+                Tag = "XXXXXX",
+                Mask = "XXXXXX",
+                Condition = condition,
+                DipLocation = [diplocation],
+                DipValue = [dipvalue],
+            };
+
+            var conflocation = new Data.Models.Listxml.ConfLocation
+            {
+                Name = "XXXXXX",
+                Number = "XXXXXX",
+                Inverted = "XXXXXX",
+            };
+
+            var confsetting = new Data.Models.Listxml.ConfSetting
+            {
+                Name = "XXXXXX",
+                Value = "XXXXXX",
+                Default = "XXXXXX",
+                Condition = condition,
+            };
+
+            var configuration = new Data.Models.Listxml.Configuration
+            {
+                Name = "XXXXXX",
+                Tag = "XXXXXX",
+                Mask = "XXXXXX",
+                Condition = condition,
+                ConfLocation = [conflocation],
+                ConfSetting = [confsetting],
+            };
+
+            var analog = new Data.Models.Listxml.Analog
+            {
+                Mask = "XXXXXX",
+            };
+
+            var port = new Data.Models.Listxml.Port
+            {
+                Tag = "XXXXXX",
+                Analog = [analog],
+            };
+
+            var adjuster = new Data.Models.Listxml.Adjuster
+            {
+                Name = "XXXXXX",
+                Default = "XXXXXX",
+                Condition = condition,
+            };
+
+            var driver = new Data.Models.Listxml.Driver
+            {
+                Status = "XXXXXX",
+                Color = "XXXXXX",
+                Sound = "XXXXXX",
+                PaletteSize = "XXXXXX",
+                Emulation = "XXXXXX",
+                Cocktail = "XXXXXX",
+                SaveState = "XXXXXX",
+                RequiresArtwork = "XXXXXX",
+                Unofficial = "XXXXXX",
+                NoSoundHardware = "XXXXXX",
+                Incomplete = "XXXXXX",
+            };
+
+            var feature = new Data.Models.Listxml.Feature
+            {
+                Type = "XXXXXX",
+                Status = "XXXXXX",
+                Overall = "XXXXXX",
+            };
+
+            var instance = new Data.Models.Listxml.Instance
+            {
+                Name = "XXXXXX",
+                BriefName = "XXXXXX",
+            };
+
+            var extension = new Data.Models.Listxml.Extension
+            {
+                Name = "XXXXXX",
+            };
+
+            var device = new Data.Models.Listxml.Device
+            {
+                Type = "XXXXXX",
+                Tag = "XXXXXX",
+                FixedImage = "XXXXXX",
+                Mandatory = "XXXXXX",
+                Interface = "XXXXXX",
+                Instance = instance,
+                Extension = [extension],
+            };
+
+            var slotOption = new Data.Models.Listxml.SlotOption
+            {
+                Name = "XXXXXX",
+                DevName = "XXXXXX",
+                Default = "XXXXXX",
+            };
+
+            var slot = new Data.Models.Listxml.Slot
+            {
+                Name = "XXXXXX",
+                SlotOption = [slotOption],
+            };
+
+            var softwarelist = new Data.Models.Listxml.SoftwareList
+            {
+                Tag = "XXXXXX",
+                Name = "XXXXXX",
+                Status = "XXXXXX",
+                Filter = "XXXXXX",
+            };
+
+            var ramoption = new Data.Models.Listxml.RamOption
+            {
+                Name = "XXXXXX",
+                Default = "XXXXXX",
+                Content = "XXXXXX",
+            };
+
+            Data.Models.Listxml.GameBase gameBase = game
+                ? new Data.Models.Listxml.Game()
+                : new Data.Models.Listxml.Machine();
+            gameBase.Name = "XXXXXX";
+            gameBase.SourceFile = "XXXXXX";
+            gameBase.IsBios = "XXXXXX";
+            gameBase.IsDevice = "XXXXXX";
+            gameBase.IsMechanical = "XXXXXX";
+            gameBase.Runnable = "XXXXXX";
+            gameBase.CloneOf = "XXXXXX";
+            gameBase.RomOf = "XXXXXX";
+            gameBase.SampleOf = "XXXXXX";
+            gameBase.Description = "XXXXXX";
+            gameBase.Year = "XXXXXX";
+            gameBase.Manufacturer = "XXXXXX";
+            gameBase.History = "XXXXXX";
+            gameBase.BiosSet = [biosset];
+            gameBase.Rom = [rom];
+            gameBase.Disk = [disk];
+            gameBase.DeviceRef = [deviceref];
+            gameBase.Sample = [sample];
+            gameBase.Chip = [chip];
+            gameBase.Display = [display];
+            gameBase.Video = [video];
+            gameBase.Sound = sound;
+            gameBase.Input = input;
+            gameBase.DipSwitch = [dipswitch];
+            gameBase.Configuration = [configuration];
+            gameBase.Port = [port];
+            gameBase.Adjuster = [adjuster];
+            gameBase.Driver = driver;
+            gameBase.Feature = [feature];
+            gameBase.Device = [device];
+            gameBase.Slot = [slot];
+            gameBase.SoftwareList = [softwarelist];
+            gameBase.RamOption = [ramoption];
+
+            return new Data.Models.Listxml.Mess
+            {
+                Version = "XXXXXX",
+                Game = [gameBase],
+            };
+        }
+
+        /// <summary>
+        /// Validate a GameBase
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.GameBase? gb)
+        {
+            Assert.NotNull(gb);
+            Assert.Equal("XXXXXX", gb.Name);
+            Assert.Equal("XXXXXX", gb.SourceFile);
+            Assert.Equal("XXXXXX", gb.IsBios);
+            Assert.Equal("XXXXXX", gb.IsDevice);
+            Assert.Equal("XXXXXX", gb.IsMechanical);
+            Assert.Equal("XXXXXX", gb.Runnable);
+            Assert.Equal("XXXXXX", gb.CloneOf);
+            Assert.Equal("XXXXXX", gb.RomOf);
+            Assert.Equal("XXXXXX", gb.SampleOf);
+            Assert.Equal("XXXXXX", gb.Description);
+            Assert.Equal("XXXXXX", gb.Year);
+            Assert.Equal("XXXXXX", gb.Manufacturer);
+            Assert.Equal("XXXXXX", gb.History);
+
+            Assert.NotNull(gb.BiosSet);
+            var biosset = Assert.Single(gb.BiosSet);
+            Validate(biosset);
+
+            Assert.NotNull(gb.Rom);
+            var rom = Assert.Single(gb.Rom);
+            Validate(rom);
+
+            Assert.NotNull(gb.Disk);
+            var disk = Assert.Single(gb.Disk);
+            Validate(disk);
+
+            Assert.NotNull(gb.DeviceRef);
+            var deviceref = Assert.Single(gb.DeviceRef);
+            Validate(deviceref);
+
+            Assert.NotNull(gb.Sample);
+            var sample = Assert.Single(gb.Sample);
+            Validate(sample);
+
+            Assert.NotNull(gb.Chip);
+            var chip = Assert.Single(gb.Chip);
+            Validate(chip);
+
+            Assert.NotNull(gb.Display);
+            var display = Assert.Single(gb.Display);
+            Validate(display);
+
+            Assert.NotNull(gb.Video);
+            var video = Assert.Single(gb.Video);
+            Validate(video);
+
+            Validate(gb.Sound);
+            Validate(gb.Input);
+
+            Assert.NotNull(gb.DipSwitch);
+            var dipswitch = Assert.Single(gb.DipSwitch);
+            Validate(dipswitch);
+
+            Assert.NotNull(gb.Configuration);
+            var configuration = Assert.Single(gb.Configuration);
+            Validate(configuration);
+
+            Assert.NotNull(gb.Port);
+            var port = Assert.Single(gb.Port);
+            Validate(port);
+
+            Assert.NotNull(gb.Adjuster);
+            var adjuster = Assert.Single(gb.Adjuster);
+            Validate(adjuster);
+
+            Validate(gb.Driver);
+
+            Assert.NotNull(gb.Feature);
+            var feature = Assert.Single(gb.Feature);
+            Validate(feature);
+
+            Assert.NotNull(gb.Device);
+            var device = Assert.Single(gb.Device);
+            Validate(device);
+
+            Assert.NotNull(gb.Slot);
+            var slot = Assert.Single(gb.Slot);
+            Validate(slot);
+
+            Assert.NotNull(gb.SoftwareList);
+            var softwarelist = Assert.Single(gb.SoftwareList);
+            Validate(softwarelist);
+
+            Assert.NotNull(gb.RamOption);
+            var ramoption = Assert.Single(gb.RamOption);
+            Validate(ramoption);
+        }
+
+        /// <summary>
+        /// Validate a BiosSet
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.BiosSet? biosset)
+        {
+            Assert.NotNull(biosset);
+            Assert.Equal("XXXXXX", biosset.Name);
+            Assert.Equal("XXXXXX", biosset.Description);
+            Assert.Equal("XXXXXX", biosset.Default);
+        }
+
+        /// <summary>
+        /// Validate a Rom
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Rom? rom)
+        {
+            Assert.NotNull(rom);
+            Assert.Equal("XXXXXX", rom.Name);
+            Assert.Equal("XXXXXX", rom.Bios);
+            Assert.Equal("XXXXXX", rom.Size);
+            Assert.Equal("XXXXXX", rom.CRC);
+            Assert.Equal("XXXXXX", rom.SHA1);
+            Assert.Equal("XXXXXX", rom.Merge);
+            Assert.Equal("XXXXXX", rom.Region);
+            Assert.Equal("XXXXXX", rom.Offset);
+            Assert.Equal("XXXXXX", rom.Status);
+            Assert.Equal("XXXXXX", rom.Optional);
+            Assert.Equal("XXXXXX", rom.Dispose);
+            Assert.Equal("XXXXXX", rom.SoundOnly);
+        }
+
+        /// <summary>
+        /// Validate a Disk
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Disk? disk)
+        {
+            Assert.NotNull(disk);
+            Assert.Equal("XXXXXX", disk.Name);
+            Assert.Equal("XXXXXX", disk.MD5);
+            Assert.Equal("XXXXXX", disk.SHA1);
+            Assert.Equal("XXXXXX", disk.Merge);
+            Assert.Equal("XXXXXX", disk.Region);
+            Assert.Equal("XXXXXX", disk.Index);
+            Assert.Equal("XXXXXX", disk.Writable);
+            Assert.Equal("XXXXXX", disk.Status);
+            Assert.Equal("XXXXXX", disk.Optional);
+        }
+
+        /// <summary>
+        /// Validate a DeviceRef
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.DeviceRef? deviceref)
+        {
+            Assert.NotNull(deviceref);
+            Assert.Equal("XXXXXX", deviceref.Name);
+        }
+
+        /// <summary>
+        /// Validate a Sample
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Sample? sample)
+        {
+            Assert.NotNull(sample);
+            Assert.Equal("XXXXXX", sample.Name);
+        }
+
+        /// <summary>
+        /// Validate a Chip
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Chip? chip)
+        {
+            Assert.NotNull(chip);
+            Assert.Equal("XXXXXX", chip.Name);
+            Assert.Equal("XXXXXX", chip.Tag);
+            Assert.Equal("XXXXXX", chip.Type);
+            Assert.Equal("XXXXXX", chip.SoundOnly);
+            Assert.Equal("XXXXXX", chip.Clock);
+        }
+
+        /// <summary>
+        /// Validate a Display
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Display? display)
+        {
+            Assert.NotNull(display);
+            Assert.Equal("XXXXXX", display.Tag);
+            Assert.Equal("XXXXXX", display.Type);
+            Assert.Equal("XXXXXX", display.Rotate);
+            Assert.Equal("XXXXXX", display.FlipX);
+            Assert.Equal("XXXXXX", display.Width);
+            Assert.Equal("XXXXXX", display.Height);
+            Assert.Equal("XXXXXX", display.Refresh);
+            Assert.Equal("XXXXXX", display.PixClock);
+            Assert.Equal("XXXXXX", display.HTotal);
+            Assert.Equal("XXXXXX", display.HBEnd);
+            Assert.Equal("XXXXXX", display.HBStart);
+            Assert.Equal("XXXXXX", display.VTotal);
+            Assert.Equal("XXXXXX", display.VBEnd);
+            Assert.Equal("XXXXXX", display.VBStart);
+        }
+
+        /// <summary>
+        /// Validate a Video
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Video? video)
+        {
+            Assert.NotNull(video);
+            Assert.Equal("XXXXXX", video.Screen);
+            Assert.Equal("XXXXXX", video.Orientation);
+            Assert.Equal("XXXXXX", video.Width);
+            Assert.Equal("XXXXXX", video.Height);
+            Assert.Equal("XXXXXX", video.AspectX);
+            Assert.Equal("XXXXXX", video.AspectY);
+            Assert.Equal("XXXXXX", video.Refresh);
+        }
+
+        /// <summary>
+        /// Validate a Sound
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Sound? sound)
+        {
+            Assert.NotNull(sound);
+            Assert.Equal("XXXXXX", sound.Channels);
+        }
+
+        /// <summary>
+        /// Validate a Input
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Input? input)
+        {
+            Assert.NotNull(input);
+            Assert.Equal("XXXXXX", input.Service);
+            Assert.Equal("XXXXXX", input.Tilt);
+            Assert.Equal("XXXXXX", input.Players);
+            //Assert.Equal("XXXXXX", input.ControlAttr); // Mututally exclusive with input.Control
+            Assert.Equal("XXXXXX", input.Buttons);
+            Assert.Equal("XXXXXX", input.Coins);
+
+            Assert.NotNull(input.Control);
+            var control = Assert.Single(input.Control);
+            Validate(control);
+        }
+
+        /// <summary>
+        /// Validate a Control
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Control? control)
+        {
+            Assert.NotNull(control);
+            Assert.Equal("XXXXXX", control.Type);
+            Assert.Equal("XXXXXX", control.Player);
+            Assert.Equal("XXXXXX", control.Buttons);
+            Assert.Equal("XXXXXX", control.ReqButtons);
+            Assert.Equal("XXXXXX", control.Minimum);
+            Assert.Equal("XXXXXX", control.Maximum);
+            Assert.Equal("XXXXXX", control.Sensitivity);
+            Assert.Equal("XXXXXX", control.KeyDelta);
+            Assert.Equal("XXXXXX", control.Reverse);
+            Assert.Equal("XXXXXX", control.Ways);
+            Assert.Equal("XXXXXX", control.Ways2);
+            Assert.Equal("XXXXXX", control.Ways3);
+        }
+
+        /// <summary>
+        /// Validate a DipSwitch
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.DipSwitch? dipswitch)
+        {
+            Assert.NotNull(dipswitch);
+            Assert.Equal("XXXXXX", dipswitch.Name);
+            Assert.Equal("XXXXXX", dipswitch.Tag);
+            Assert.Equal("XXXXXX", dipswitch.Mask);
+            Validate(dipswitch.Condition);
+
+            Assert.NotNull(dipswitch.DipLocation);
+            var diplocation = Assert.Single(dipswitch.DipLocation);
+            Validate(diplocation);
+
+            Assert.NotNull(dipswitch.DipValue);
+            var dipvalue = Assert.Single(dipswitch.DipValue);
+            Validate(dipvalue);
+        }
+
+        /// <summary>
+        /// Validate a Condition
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Condition? condition)
+        {
+            Assert.NotNull(condition);
+            Assert.Equal("XXXXXX", condition.Tag);
+            Assert.Equal("XXXXXX", condition.Mask);
+            Assert.Equal("XXXXXX", condition.Relation);
+            Assert.Equal("XXXXXX", condition.Value);
+        }
+
+        /// <summary>
+        /// Validate a DipLocation
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.DipLocation? diplocation)
+        {
+            Assert.NotNull(diplocation);
+            Assert.Equal("XXXXXX", diplocation.Name);
+            Assert.Equal("XXXXXX", diplocation.Number);
+            Assert.Equal("XXXXXX", diplocation.Inverted);
+        }
+
+        /// <summary>
+        /// Validate a DipValue
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.DipValue? dipvalue)
+        {
+            Assert.NotNull(dipvalue);
+            Assert.Equal("XXXXXX", dipvalue.Name);
+            Assert.Equal("XXXXXX", dipvalue.Value);
+            Assert.Equal("XXXXXX", dipvalue.Default);
+            Validate(dipvalue.Condition);
+        }
+
+        /// <summary>
+        /// Validate a Configuration
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Configuration? configuration)
+        {
+            Assert.NotNull(configuration);
+            Assert.Equal("XXXXXX", configuration.Name);
+            Assert.Equal("XXXXXX", configuration.Tag);
+            Assert.Equal("XXXXXX", configuration.Mask);
+            Validate(configuration.Condition);
+
+            Assert.NotNull(configuration.ConfLocation);
+            var conflocation = Assert.Single(configuration.ConfLocation);
+            Validate(conflocation);
+
+            Assert.NotNull(configuration.ConfSetting);
+            var confsetting = Assert.Single(configuration.ConfSetting);
+            Validate(confsetting);
+        }
+
+        /// <summary>
+        /// Validate a ConfLocation
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.ConfLocation? conflocation)
+        {
+            Assert.NotNull(conflocation);
+            Assert.Equal("XXXXXX", conflocation.Name);
+            Assert.Equal("XXXXXX", conflocation.Number);
+            Assert.Equal("XXXXXX", conflocation.Inverted);
+        }
+
+        /// <summary>
+        /// Validate a ConfSetting
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.ConfSetting? confsetting)
+        {
+            Assert.NotNull(confsetting);
+            Assert.Equal("XXXXXX", confsetting.Name);
+            Assert.Equal("XXXXXX", confsetting.Value);
+            Assert.Equal("XXXXXX", confsetting.Default);
+            Validate(confsetting.Condition);
+        }
+
+        /// <summary>
+        /// Validate a Port
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Port? port)
+        {
+            Assert.NotNull(port);
+            Assert.Equal("XXXXXX", port.Tag);
+
+            Assert.NotNull(port.Analog);
+            var analog = Assert.Single(port.Analog);
+            Validate(analog);
+        }
+
+        /// <summary>
+        /// Validate a Analog
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Analog? analog)
+        {
+            Assert.NotNull(analog);
+            Assert.Equal("XXXXXX", analog.Mask);
+        }
+
+        /// <summary>
+        /// Validate a Adjuster
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Adjuster? adjuster)
+        {
+            Assert.NotNull(adjuster);
+            Assert.Equal("XXXXXX", adjuster.Name);
+            Assert.Equal("XXXXXX", adjuster.Default);
+            Validate(adjuster.Condition);
+        }
+
+        /// <summary>
+        /// Validate a Driver
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Driver? driver)
+        {
+            Assert.NotNull(driver);
+            Assert.Equal("XXXXXX", driver.Status);
+            Assert.Equal("XXXXXX", driver.Color);
+            Assert.Equal("XXXXXX", driver.Sound);
+            Assert.Equal("XXXXXX", driver.PaletteSize);
+            Assert.Equal("XXXXXX", driver.Emulation);
+            Assert.Equal("XXXXXX", driver.Cocktail);
+            Assert.Equal("XXXXXX", driver.SaveState);
+            Assert.Equal("XXXXXX", driver.RequiresArtwork);
+            Assert.Equal("XXXXXX", driver.Unofficial);
+            Assert.Equal("XXXXXX", driver.NoSoundHardware);
+            Assert.Equal("XXXXXX", driver.Incomplete);
+        }
+
+        /// <summary>
+        /// Validate a Feature
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Feature? feature)
+        {
+            Assert.NotNull(feature);
+            Assert.Equal("XXXXXX", feature.Type);
+            Assert.Equal("XXXXXX", feature.Status);
+            Assert.Equal("XXXXXX", feature.Overall);
+        }
+
+        /// <summary>
+        /// Validate a Device
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Device? device)
+        {
+            Assert.NotNull(device);
+            Assert.Equal("XXXXXX", device.Type);
+            Assert.Equal("XXXXXX", device.Tag);
+            Assert.Equal("XXXXXX", device.FixedImage);
+            Assert.Equal("XXXXXX", device.Mandatory);
+            Assert.Equal("XXXXXX", device.Interface);
+            Validate(device.Instance);
+
+            Assert.NotNull(device.Extension);
+            var extension = Assert.Single(device.Extension);
+            Validate(extension);
+        }
+
+        /// <summary>
+        /// Validate a Instance
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Instance? instance)
+        {
+            Assert.NotNull(instance);
+            Assert.Equal("XXXXXX", instance.Name);
+            Assert.Equal("XXXXXX", instance.BriefName);
+        }
+
+        /// <summary>
+        /// Validate a Extension
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Extension? extension)
+        {
+            Assert.NotNull(extension);
+            Assert.Equal("XXXXXX", extension.Name);
+        }
+
+        /// <summary>
+        /// Validate a Slot
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Slot? slot)
+        {
+            Assert.NotNull(slot);
+            Assert.Equal("XXXXXX", slot.Name);
+
+            Assert.NotNull(slot.SlotOption);
+            var slotoption = Assert.Single(slot.SlotOption);
+            Validate(slotoption);
+        }
+
+        /// <summary>
+        /// Validate a SlotOption
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.SlotOption? slotoption)
+        {
+            Assert.NotNull(slotoption);
+            Assert.Equal("XXXXXX", slotoption.Name);
+            Assert.Equal("XXXXXX", slotoption.DevName);
+            Assert.Equal("XXXXXX", slotoption.Default);
+        }
+
+        /// <summary>
+        /// Validate a SoftwareList
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.SoftwareList? softwarelist)
+        {
+            Assert.NotNull(softwarelist);
+            Assert.Equal("XXXXXX", softwarelist.Tag);
+            Assert.Equal("XXXXXX", softwarelist.Name);
+            Assert.Equal("XXXXXX", softwarelist.Status);
+            Assert.Equal("XXXXXX", softwarelist.Filter);
+        }
+
+        /// <summary>
+        /// Validate a RamOption
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.RamOption? ramoption)
+        {
+            Assert.NotNull(ramoption);
+            Assert.Equal("XXXXXX", ramoption.Name);
+            Assert.Equal("XXXXXX", ramoption.Default);
+            Assert.Equal("XXXXXX", ramoption.Content);
+        }
+    }
+}

SabreTools.Serialization.Test/CrossModel/OfflineListTests.cs

@@ -0,0 +1,451 @@
+using SabreTools.Serialization.CrossModel;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.CrossModel
+{
+    public class OfflineListTests
+    {
+        [Fact]
+        public void RoundTripTest()
+        {
+            // Get the cross-model serializer
+            var serializer = new OfflineList();
+
+            // Build the data
+            Data.Models.OfflineList.Dat dat = Build();
+
+            // Serialize to generic model
+            Data.Models.Metadata.MetadataFile? metadata = serializer.Serialize(dat);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.OfflineList.Dat? newDat = serializer.Deserialize(metadata);
+
+            // Validate the data
+            Assert.NotNull(newDat);
+            Assert.Equal("XXXXXX", newDat.NoNamespaceSchemaLocation);
+            Validate(newDat.Configuration);
+            Validate(newDat.Games);
+            Validate(newDat.GUI);
+        }
+
+        /// <summary>
+        /// Build model for serialization and deserialization
+        /// </summary>
+        private static Data.Models.OfflineList.Dat Build()
+        {
+            var infos = new Data.Models.OfflineList.Infos
+            {
+                Title = new Data.Models.OfflineList.Title
+                {
+                    Visible = "XXXXXX",
+                    InNamingOption = "XXXXXX",
+                    Default = "XXXXXX",
+                },
+                Location = new Data.Models.OfflineList.Location
+                {
+                    Visible = "XXXXXX",
+                    InNamingOption = "XXXXXX",
+                    Default = "XXXXXX",
+                },
+                Publisher = new Data.Models.OfflineList.Publisher
+                {
+                    Visible = "XXXXXX",
+                    InNamingOption = "XXXXXX",
+                    Default = "XXXXXX",
+                },
+                SourceRom = new Data.Models.OfflineList.SourceRom
+                {
+                    Visible = "XXXXXX",
+                    InNamingOption = "XXXXXX",
+                    Default = "XXXXXX",
+                },
+                SaveType = new Data.Models.OfflineList.SaveType
+                {
+                    Visible = "XXXXXX",
+                    InNamingOption = "XXXXXX",
+                    Default = "XXXXXX",
+                },
+                RomSize = new Data.Models.OfflineList.RomSize
+                {
+                    Visible = "XXXXXX",
+                    InNamingOption = "XXXXXX",
+                    Default = "XXXXXX",
+                },
+                ReleaseNumber = new Data.Models.OfflineList.ReleaseNumber
+                {
+                    Visible = "XXXXXX",
+                    InNamingOption = "XXXXXX",
+                    Default = "XXXXXX",
+                },
+                ImageNumber = new Data.Models.OfflineList.ImageNumber
+                {
+                    Visible = "XXXXXX",
+                    InNamingOption = "XXXXXX",
+                    Default = "XXXXXX",
+                },
+                LanguageNumber = new Data.Models.OfflineList.LanguageNumber
+                {
+                    Visible = "XXXXXX",
+                    InNamingOption = "XXXXXX",
+                    Default = "XXXXXX",
+                },
+                Comment = new Data.Models.OfflineList.Comment
+                {
+                    Visible = "XXXXXX",
+                    InNamingOption = "XXXXXX",
+                    Default = "XXXXXX",
+                },
+                RomCRC = new Data.Models.OfflineList.RomCRC
+                {
+                    Visible = "XXXXXX",
+                    InNamingOption = "XXXXXX",
+                    Default = "XXXXXX",
+                },
+                Im1CRC = new Data.Models.OfflineList.Im1CRC
+                {
+                    Visible = "XXXXXX",
+                    InNamingOption = "XXXXXX",
+                    Default = "XXXXXX",
+                },
+                Im2CRC = new Data.Models.OfflineList.Im2CRC
+                {
+                    Visible = "XXXXXX",
+                    InNamingOption = "XXXXXX",
+                    Default = "XXXXXX",
+                },
+                Languages = new Data.Models.OfflineList.Languages
+                {
+                    Visible = "XXXXXX",
+                    InNamingOption = "XXXXXX",
+                    Default = "XXXXXX",
+                },
+            };
+
+            var canopen = new Data.Models.OfflineList.CanOpen
+            {
+                Extension = ["XXXXXX"],
+            };
+
+            var daturl = new Data.Models.OfflineList.DatUrl
+            {
+                FileName = "XXXXXX",
+                Content = "XXXXXX",
+            };
+
+            var newdat = new Data.Models.OfflineList.NewDat
+            {
+                DatVersionUrl = "XXXXXX",
+                DatUrl = daturl,
+                ImUrl = "XXXXXX",
+            };
+
+            var find = new Data.Models.OfflineList.Find
+            {
+                Operation = "XXXXXX",
+                Value = "XXXXXX",
+                Content = "XXXXXX",
+            };
+
+            var to = new Data.Models.OfflineList.To
+            {
+                Value = "XXXXXX",
+                Default = "XXXXXX",
+                Auto = "XXXXXX",
+                Find = [find],
+            };
+
+            var search = new Data.Models.OfflineList.Search
+            {
+                To = [to],
+            };
+
+            var configuration = new Data.Models.OfflineList.Configuration
+            {
+                DatName = "XXXXXX",
+                ImFolder = "XXXXXX",
+                DatVersion = "XXXXXX",
+                System = "XXXXXX",
+                ScreenshotsWidth = "XXXXXX",
+                ScreenshotsHeight = "XXXXXX",
+                Infos = infos,
+                CanOpen = canopen,
+                NewDat = newdat,
+                Search = search,
+                RomTitle = "XXXXXX",
+            };
+
+            var fileromcrc = new Data.Models.OfflineList.FileRomCRC
+            {
+                Extension = "XXXXXX",
+                Content = "XXXXXX",
+            };
+
+            var files = new Data.Models.OfflineList.Files
+            {
+                RomCRC = [fileromcrc],
+            };
+
+            var game = new Data.Models.OfflineList.Game
+            {
+                ImageNumber = "XXXXXX",
+                ReleaseNumber = "XXXXXX",
+                Title = "XXXXXX",
+                SaveType = "XXXXXX",
+                RomSize = "XXXXXX",
+                Publisher = "XXXXXX",
+                Location = "XXXXXX",
+                SourceRom = "XXXXXX",
+                Language = "XXXXXX",
+                Files = files,
+                Im1CRC = "XXXXXX",
+                Im2CRC = "XXXXXX",
+                Comment = "XXXXXX",
+                DuplicateID = "XXXXXX",
+            };
+
+            var games = new Data.Models.OfflineList.Games
+            {
+                Game = [game],
+            };
+
+            var image = new Data.Models.OfflineList.Image
+            {
+                X = "XXXXXX",
+                Y = "XXXXXX",
+                Width = "XXXXXX",
+                Height = "XXXXXX",
+            };
+
+            var images = new Data.Models.OfflineList.Images
+            {
+                Width = "XXXXXX",
+                Height = "XXXXXX",
+                Image = [image],
+            };
+
+            var gui = new Data.Models.OfflineList.GUI
+            {
+                Images = images,
+            };
+
+            return new Data.Models.OfflineList.Dat
+            {
+                NoNamespaceSchemaLocation = "XXXXXX",
+                Configuration = configuration,
+                Games = games,
+                GUI = gui,
+            };
+        }
+
+        /// <summary>
+        /// Validate a Configuration
+        /// </summary>
+        private static void Validate(Data.Models.OfflineList.Configuration? configuration)
+        {
+            Assert.NotNull(configuration);
+            Assert.Equal("XXXXXX", configuration.DatName);
+            Assert.Equal("XXXXXX", configuration.ImFolder);
+            Assert.Equal("XXXXXX", configuration.DatVersion);
+            Assert.Equal("XXXXXX", configuration.System);
+            Assert.Equal("XXXXXX", configuration.ScreenshotsWidth);
+            Assert.Equal("XXXXXX", configuration.ScreenshotsHeight);
+            Validate(configuration.Infos);
+            Validate(configuration.CanOpen);
+            Validate(configuration.NewDat);
+            Validate(configuration.Search);
+            Assert.Equal("XXXXXX", configuration.RomTitle);
+        }
+
+        /// <summary>
+        /// Validate a Infos
+        /// </summary>
+        private static void Validate(Data.Models.OfflineList.Infos? infos)
+        {
+            Assert.NotNull(infos);
+            Validate(infos.Title);
+            Validate(infos.Location);
+            Validate(infos.Publisher);
+            Validate(infos.SourceRom);
+            Validate(infos.SaveType);
+            Validate(infos.RomSize);
+            Validate(infos.ReleaseNumber);
+            Validate(infos.ImageNumber);
+            Validate(infos.LanguageNumber);
+            Validate(infos.Comment);
+            Validate(infos.RomCRC);
+            Validate(infos.Im1CRC);
+            Validate(infos.Im2CRC);
+            Validate(infos.Languages);
+        }
+
+        /// <summary>
+        /// Validate a InfoBase
+        /// </summary>
+        private static void Validate(Data.Models.OfflineList.InfoBase? info)
+        {
+            Assert.NotNull(info);
+            Assert.Equal("XXXXXX", info.Visible);
+            Assert.Equal("XXXXXX", info.InNamingOption);
+            Assert.Equal("XXXXXX", info.Default);
+        }
+
+        /// <summary>
+        /// Validate a CanOpen
+        /// </summary>
+        private static void Validate(Data.Models.OfflineList.CanOpen? canopen)
+        {
+            Assert.NotNull(canopen);
+            Assert.NotNull(canopen.Extension);
+            string extension = Assert.Single(canopen.Extension);
+            Assert.Equal("XXXXXX", extension);
+        }
+
+        /// <summary>
+        /// Validate a NewDat
+        /// </summary>
+        private static void Validate(Data.Models.OfflineList.NewDat? newdat)
+        {
+            Assert.NotNull(newdat);
+            Assert.Equal("XXXXXX", newdat.DatVersionUrl);
+            Validate(newdat.DatUrl);
+            Assert.Equal("XXXXXX", newdat.ImUrl);
+        }
+
+        /// <summary>
+        /// Validate a DatUrl
+        /// </summary>
+        private static void Validate(Data.Models.OfflineList.DatUrl? daturl)
+        {
+            Assert.NotNull(daturl);
+            Assert.Equal("XXXXXX", daturl.FileName);
+            Assert.Equal("XXXXXX", daturl.Content);
+        }
+
+        /// <summary>
+        /// Validate a Search
+        /// </summary>
+        private static void Validate(Data.Models.OfflineList.Search? search)
+        {
+            Assert.NotNull(search);
+            Assert.NotNull(search.To);
+            var to = Assert.Single(search.To);
+            Validate(to);
+        }
+
+        /// <summary>
+        /// Validate a To
+        /// </summary>
+        private static void Validate(Data.Models.OfflineList.To? to)
+        {
+            Assert.NotNull(to);
+            Assert.Equal("XXXXXX", to.Value);
+            Assert.Equal("XXXXXX", to.Default);
+            Assert.Equal("XXXXXX", to.Auto);
+
+            Assert.NotNull(to.Find);
+            var find = Assert.Single(to.Find);
+            Validate(find);
+        }
+
+        /// <summary>
+        /// Validate a Find
+        /// </summary>
+        private static void Validate(Data.Models.OfflineList.Find? find)
+        {
+            Assert.NotNull(find);
+            Assert.Equal("XXXXXX", find.Operation);
+            Assert.Equal("XXXXXX", find.Value);
+            Assert.Equal("XXXXXX", find.Content);
+        }
+
+        /// <summary>
+        /// Validate a Games
+        /// </summary>
+        private static void Validate(Data.Models.OfflineList.Games? games)
+        {
+            Assert.NotNull(games);
+            Assert.NotNull(games.Game);
+            var game = Assert.Single(games.Game);
+            Validate(game);
+        }
+
+        /// <summary>
+        /// Validate a Game
+        /// </summary>
+        private static void Validate(Data.Models.OfflineList.Game? game)
+        {
+            Assert.NotNull(game);
+            Assert.Equal("XXXXXX", game.ImageNumber);
+            Assert.Equal("XXXXXX", game.ReleaseNumber);
+            Assert.Equal("XXXXXX", game.Title);
+            Assert.Equal("XXXXXX", game.SaveType);
+            Assert.Equal("0", game.RomSize); // Converted due to filtering
+            Assert.Equal("XXXXXX", game.Publisher);
+            Assert.Equal("XXXXXX", game.Location);
+            Assert.Equal("XXXXXX", game.SourceRom);
+            Assert.Equal("XXXXXX", game.Language);
+            Validate(game.Files);
+            Assert.Equal("XXXXXX", game.Im1CRC);
+            Assert.Equal("XXXXXX", game.Im2CRC);
+            Assert.Equal("XXXXXX", game.Comment);
+            Assert.Equal("XXXXXX", game.DuplicateID);
+        }
+
+        /// <summary>
+        /// Validate a Files
+        /// </summary>
+        private static void Validate(Data.Models.OfflineList.Files? files)
+        {
+            Assert.NotNull(files);
+            Assert.NotNull(files.RomCRC);
+            var fileromcrc = Assert.Single(files.RomCRC);
+            Validate(fileromcrc);
+        }
+
+        /// <summary>
+        /// Validate a FileRomCRC
+        /// </summary>
+        private static void Validate(Data.Models.OfflineList.FileRomCRC? fileromcrc)
+        {
+            Assert.NotNull(fileromcrc);
+            Assert.Equal("XXXXXX", fileromcrc.Extension);
+            Assert.Equal("XXXXXX", fileromcrc.Content);
+        }
+
+        /// <summary>
+        /// Validate a GUI
+        /// </summary>
+        private static void Validate(Data.Models.OfflineList.GUI? gui)
+        {
+            Assert.NotNull(gui);
+            Validate(gui.Images);
+        }
+
+        /// <summary>
+        /// Validate a Images
+        /// </summary>
+        private static void Validate(Data.Models.OfflineList.Images? images)
+        {
+            Assert.NotNull(images);
+            Assert.Equal("XXXXXX", images.Width);
+            Assert.Equal("XXXXXX", images.Height);
+
+            Assert.NotNull(images.Image);
+            var image = Assert.Single(images.Image);
+            Validate(image);
+        }
+
+        /// <summary>
+        /// Validate a Image
+        /// </summary>
+        private static void Validate(Data.Models.OfflineList.Image? image)
+        {
+            Assert.NotNull(image);
+            Assert.Equal("XXXXXX", image.X);
+            Assert.Equal("XXXXXX", image.Y);
+            Assert.Equal("XXXXXX", image.Width);
+            Assert.Equal("XXXXXX", image.Height);
+        }
+    }
+}

SabreTools.Serialization.Test/CrossModel/OpenMSXTests.cs

@@ -0,0 +1,157 @@
+using SabreTools.Serialization.CrossModel;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.CrossModel
+{
+    public class OpenMSXTests
+    {
+        [Fact]
+        public void RoundTripTest()
+        {
+            // Get the cross-model serializer
+            var serializer = new OpenMSX();
+
+            // Build the data
+            Data.Models.OpenMSX.SoftwareDb sdb = Build();
+
+            // Serialize to generic model
+            Data.Models.Metadata.MetadataFile? metadata = serializer.Serialize(sdb);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.OpenMSX.SoftwareDb? newSdb = serializer.Deserialize(metadata);
+
+            // Validate the data
+            Assert.NotNull(newSdb);
+            Assert.Equal("XXXXXX", newSdb.Timestamp);
+
+            Assert.NotNull(newSdb.Software);
+            var software = Assert.Single(newSdb.Software);
+            Validate(software);
+        }
+
+        /// <summary>
+        /// Build model for serialization and deserialization
+        /// </summary>
+        private static Data.Models.OpenMSX.SoftwareDb Build()
+        {
+            var original = new Data.Models.OpenMSX.Original
+            {
+                Value = "XXXXXX",
+                Content = "XXXXXX",
+            };
+
+            var rom = new Data.Models.OpenMSX.Rom
+            {
+                Start = "XXXXXX",
+                Type = "XXXXXX",
+                Hash = "XXXXXX",
+                Remark = "XXXXXX",
+            };
+
+            var dump_rom = new Data.Models.OpenMSX.Dump
+            {
+                Original = original,
+                Rom = rom,
+            };
+
+            var megarom = new Data.Models.OpenMSX.MegaRom
+            {
+                Start = "XXXXXX",
+                Type = "XXXXXX",
+                Hash = "XXXXXX",
+                Remark = "XXXXXX",
+            };
+
+            var dump_megarom = new Data.Models.OpenMSX.Dump
+            {
+                Original = original,
+                Rom = megarom,
+            };
+
+            var sccpluscart = new Data.Models.OpenMSX.SCCPlusCart
+            {
+                Start = "XXXXXX",
+                Type = "XXXXXX",
+                Hash = "XXXXXX",
+                Remark = "XXXXXX",
+            };
+
+            var dump_sccpluscart = new Data.Models.OpenMSX.Dump
+            {
+                Original = original,
+                Rom = sccpluscart,
+            };
+
+            var software = new Data.Models.OpenMSX.Software
+            {
+                Title = "XXXXXX",
+                GenMSXID = "XXXXXX",
+                System = "XXXXXX",
+                Company = "XXXXXX",
+                Year = "XXXXXX",
+                Country = "XXXXXX",
+                Dump = [dump_rom, dump_megarom, dump_sccpluscart],
+            };
+
+            return new Data.Models.OpenMSX.SoftwareDb
+            {
+                Timestamp = "XXXXXX",
+                Software = [software],
+            };
+        }
+
+        /// <summary>
+        /// Validate a Software
+        /// </summary>
+        private static void Validate(Data.Models.OpenMSX.Software? software)
+        {
+            Assert.NotNull(software);
+            Assert.Equal("XXXXXX", software.Title);
+            Assert.Equal("XXXXXX", software.GenMSXID);
+            Assert.Equal("XXXXXX", software.System);
+            Assert.Equal("XXXXXX", software.Company);
+            Assert.Equal("XXXXXX", software.Year);
+            Assert.Equal("XXXXXX", software.Country);
+
+            Assert.NotNull(software.Dump);
+            Assert.Equal(3, software.Dump.Length);
+            foreach (var dump in software.Dump)
+            {
+                Validate(dump);
+            }
+        }
+
+        /// <summary>
+        /// Validate a Dump
+        /// </summary>
+        private static void Validate(Data.Models.OpenMSX.Dump? dump)
+        {
+            Assert.NotNull(dump);
+            Validate(dump.Original);
+            Validate(dump.Rom);
+        }
+
+        /// <summary>
+        /// Validate a Original
+        /// </summary>
+        private static void Validate(Data.Models.OpenMSX.Original? original)
+        {
+            Assert.NotNull(original);
+            Assert.Equal("XXXXXX", original.Value);
+            Assert.Equal("XXXXXX", original.Content);
+        }
+
+        /// <summary>
+        /// Validate a RomBase
+        /// </summary>
+        private static void Validate(Data.Models.OpenMSX.RomBase? rombase)
+        {
+            Assert.NotNull(rombase);
+            Assert.Equal("XXXXXX", rombase.Start);
+            Assert.Equal("XXXXXX", rombase.Type);
+            Assert.Equal("XXXXXX", rombase.Hash);
+            Assert.Equal("XXXXXX", rombase.Remark);
+        }
+    }
+}

SabreTools.Serialization.Test/CrossModel/RomCenterTests.cs

@@ -0,0 +1,154 @@
+using SabreTools.Serialization.CrossModel;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.CrossModel
+{
+    public class RomCenterTests
+    {
+        [Fact]
+        public void RoundTripTest()
+        {
+            // Get the cross-model serializer
+            var serializer = new RomCenter();
+
+            // Build the data
+            Data.Models.RomCenter.MetadataFile mf = Build();
+
+            // Serialize to generic model
+            Data.Models.Metadata.MetadataFile? metadata = serializer.Serialize(mf);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.RomCenter.MetadataFile? newMf = serializer.Deserialize(metadata);
+
+            // Validate the data
+            Assert.NotNull(newMf);
+            Validate(newMf.Credits);
+            Validate(newMf.Dat);
+            Validate(newMf.Emulator);
+            Validate(newMf.Games);
+        }
+
+        /// <summary>
+        /// Build model for serialization and deserialization
+        /// </summary>
+        private static Data.Models.RomCenter.MetadataFile Build()
+        {
+            var credits = new Data.Models.RomCenter.Credits
+            {
+                Author = "XXXXXX",
+                Version = "XXXXXX",
+                Email = "XXXXXX",
+                Homepage = "XXXXXX",
+                Url = "XXXXXX",
+                Date = "XXXXXX",
+                Comment = "XXXXXX",
+            };
+
+            var dat = new Data.Models.RomCenter.Dat
+            {
+                Version = "XXXXXX",
+                Plugin = "XXXXXX",
+                Split = "XXXXXX",
+                Merge = "XXXXXX",
+            };
+
+            var emulator = new Data.Models.RomCenter.Emulator
+            {
+                RefName = "XXXXXX",
+                Version = "XXXXXX",
+            };
+
+            var rom = new Data.Models.RomCenter.Rom
+            {
+                ParentName = "XXXXXX",
+                ParentDescription = "XXXXXX",
+                GameName = "XXXXXX",
+                GameDescription = "XXXXXX",
+                RomName = "XXXXXX",
+                RomCRC = "XXXXXX",
+                RomSize = "XXXXXX",
+                RomOf = "XXXXXX",
+                MergeName = "XXXXXX",
+            };
+
+            var games = new Data.Models.RomCenter.Games
+            {
+                Rom = [rom],
+            };
+
+            return new Data.Models.RomCenter.MetadataFile
+            {
+                Credits = credits,
+                Dat = dat,
+                Emulator = emulator,
+                Games = games,
+            };
+        }
+
+        /// <summary>
+        /// Validate a Credits
+        /// </summary>
+        private static void Validate(Data.Models.RomCenter.Credits? credits)
+        {
+            Assert.NotNull(credits);
+            Assert.Equal("XXXXXX", credits.Author);
+            Assert.Equal("XXXXXX", credits.Version);
+            Assert.Equal("XXXXXX", credits.Email);
+            Assert.Equal("XXXXXX", credits.Homepage);
+            Assert.Equal("XXXXXX", credits.Url);
+            Assert.Equal("XXXXXX", credits.Date);
+            Assert.Equal("XXXXXX", credits.Comment);
+        }
+
+        /// <summary>
+        /// Validate a Dat
+        /// </summary>
+        private static void Validate(Data.Models.RomCenter.Dat? dat)
+        {
+            Assert.NotNull(dat);
+            Assert.Equal("XXXXXX", dat.Version);
+            Assert.Equal("XXXXXX", dat.Plugin);
+            Assert.Equal("no", dat.Split); // Converted due to filtering
+            Assert.Equal("no", dat.Merge); // Converted due to filtering
+        }
+
+        /// <summary>
+        /// Validate a Emulator
+        /// </summary>
+        private static void Validate(Data.Models.RomCenter.Emulator? emulator)
+        {
+            Assert.NotNull(emulator);
+            Assert.Equal("XXXXXX", emulator.RefName);
+            Assert.Equal("XXXXXX", emulator.Version);
+        }
+
+        /// <summary>
+        /// Validate a Games
+        /// </summary>
+        private static void Validate(Data.Models.RomCenter.Games? games)
+        {
+            Assert.NotNull(games);
+            Assert.NotNull(games.Rom);
+            var rom = Assert.Single(games.Rom);
+            Validate(rom);
+        }
+
+        /// <summary>
+        /// Validate a Rom
+        /// </summary>
+        private static void Validate(Data.Models.RomCenter.Rom? rom)
+        {
+            Assert.NotNull(rom);
+            Assert.Equal("XXXXXX", rom.ParentName);
+            Assert.Null(rom.ParentDescription); // This is unmappable
+            Assert.Equal("XXXXXX", rom.GameName);
+            Assert.Equal("XXXXXX", rom.GameDescription);
+            Assert.Equal("XXXXXX", rom.RomName);
+            Assert.Equal("XXXXXX", rom.RomCRC);
+            Assert.Equal("XXXXXX", rom.RomSize);
+            Assert.Equal("XXXXXX", rom.RomOf);
+            Assert.Equal("XXXXXX", rom.MergeName);
+        }
+    }
+}

SabreTools.Serialization.Test/CrossModel/SeparatedValueTests.cs

@@ -0,0 +1,183 @@
+using SabreTools.Serialization.CrossModel;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.CrossModel
+{
+    public class SeparatedValueTests
+    {
+        [Fact]
+        public void RoundTripTest()
+        {
+            // Get the cross-model serializer
+            var serializer = new SeparatedValue();
+
+            // Build the data
+            Data.Models.SeparatedValue.MetadataFile mf = Build();
+
+            // Serialize to generic model
+            Data.Models.Metadata.MetadataFile? metadata = serializer.Serialize(mf);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.SeparatedValue.MetadataFile? newMf = serializer.Deserialize(metadata);
+
+            // Validate the data
+            Assert.NotNull(newMf);
+            Validate(newMf.Header);
+            Assert.NotNull(newMf.Row);
+            Assert.Equal(3, newMf.Row.Length);
+
+            ValidateDisk(newMf.Row[0]);
+            ValidateMedia(newMf.Row[1]);
+            ValidateRom(newMf.Row[2]);
+        }
+
+        /// <summary>
+        /// Build model for serialization and deserialization
+        /// </summary>
+        private static Data.Models.SeparatedValue.MetadataFile Build()
+        {
+            string[] header = ["header"];
+
+            var disk = new Data.Models.SeparatedValue.Row
+            {
+                FileName = "XXXXXX",
+                InternalName = "XXXXXX",
+                Description = "XXXXXX",
+                GameName = "XXXXXX",
+                GameDescription = "XXXXXX",
+                Type = "disk",
+                DiskName = "XXXXXX",
+                MD5 = "XXXXXX",
+                SHA1 = "XXXXXX",
+                Status = "XXXXXX",
+            };
+
+            var media = new Data.Models.SeparatedValue.Row
+            {
+                FileName = "XXXXXX",
+                InternalName = "XXXXXX",
+                Description = "XXXXXX",
+                GameName = "XXXXXX",
+                GameDescription = "XXXXXX",
+                Type = "media",
+                DiskName = "XXXXXX",
+                MD5 = "XXXXXX",
+                SHA1 = "XXXXXX",
+                SHA256 = "XXXXXX",
+                SpamSum = "XXXXXX",
+            };
+
+            var rom = new Data.Models.SeparatedValue.Row
+            {
+                FileName = "XXXXXX",
+                InternalName = "XXXXXX",
+                Description = "XXXXXX",
+                GameName = "XXXXXX",
+                GameDescription = "XXXXXX",
+                Type = "rom",
+                RomName = "XXXXXX",
+                Size = "XXXXXX",
+                CRC = "XXXXXX",
+                MD5 = "XXXXXX",
+                SHA1 = "XXXXXX",
+                SHA256 = "XXXXXX",
+                SHA384 = "XXXXXX",
+                SHA512 = "XXXXXX",
+                SpamSum = "XXXXXX",
+                Status = "XXXXXX",
+            };
+
+            return new Data.Models.SeparatedValue.MetadataFile
+            {
+                Header = header,
+                Row = [disk, media, rom],
+            };
+        }
+
+        /// <summary>
+        /// Validate a header
+        /// </summary>
+        private static void Validate(string[]? header)
+        {
+            Assert.NotNull(header);
+            string column = Assert.Single(header);
+            Assert.Equal("header", column);
+        }
+
+        /// <summary>
+        /// Validate a Row
+        /// </summary>
+        private static void ValidateDisk(Data.Models.SeparatedValue.Row? row)
+        {
+            Assert.NotNull(row);
+            Assert.Equal("XXXXXX", row.FileName);
+            Assert.Equal("XXXXXX", row.InternalName);
+            Assert.Equal("XXXXXX", row.Description);
+            Assert.Equal("XXXXXX", row.GameName);
+            Assert.Equal("XXXXXX", row.GameDescription);
+            Assert.Equal("disk", row.Type);
+            Assert.Null(row.RomName);
+            Assert.Equal("XXXXXX", row.DiskName);
+            Assert.Null(row.Size);
+            Assert.Null(row.CRC);
+            Assert.Equal("XXXXXX", row.MD5);
+            Assert.Equal("XXXXXX", row.SHA1);
+            Assert.Null(row.SHA256);
+            Assert.Null(row.SHA384);
+            Assert.Null(row.SHA512);
+            Assert.Null(row.SpamSum);
+            Assert.Equal("XXXXXX", row.Status);
+        }
+
+        /// <summary>
+        /// Validate a Row
+        /// </summary>
+        private static void ValidateMedia(Data.Models.SeparatedValue.Row? row)
+        {
+            Assert.NotNull(row);
+            Assert.Equal("XXXXXX", row.FileName);
+            Assert.Equal("XXXXXX", row.InternalName);
+            Assert.Equal("XXXXXX", row.Description);
+            Assert.Equal("XXXXXX", row.GameName);
+            Assert.Equal("XXXXXX", row.GameDescription);
+            Assert.Equal("media", row.Type);
+            Assert.Null(row.RomName);
+            Assert.Equal("XXXXXX", row.DiskName);
+            Assert.Null(row.Size);
+            Assert.Null(row.CRC);
+            Assert.Equal("XXXXXX", row.MD5);
+            Assert.Equal("XXXXXX", row.SHA1);
+            Assert.Equal("XXXXXX", row.SHA256);
+            Assert.Null(row.SHA384);
+            Assert.Null(row.SHA512);
+            Assert.Equal("XXXXXX", row.SpamSum);
+            Assert.Null(row.Status);
+        }
+
+        /// <summary>
+        /// Validate a Row
+        /// </summary>
+        private static void ValidateRom(Data.Models.SeparatedValue.Row? row)
+        {
+            Assert.NotNull(row);
+            Assert.Equal("XXXXXX", row.FileName);
+            Assert.Equal("XXXXXX", row.InternalName);
+            Assert.Equal("XXXXXX", row.Description);
+            Assert.Equal("XXXXXX", row.GameName);
+            Assert.Equal("XXXXXX", row.GameDescription);
+            Assert.Equal("rom", row.Type);
+            Assert.Equal("XXXXXX", row.RomName);
+            Assert.Null(row.DiskName);
+            Assert.Equal("XXXXXX", row.Size);
+            Assert.Equal("XXXXXX", row.CRC);
+            Assert.Equal("XXXXXX", row.MD5);
+            Assert.Equal("XXXXXX", row.SHA1);
+            Assert.Equal("XXXXXX", row.SHA256);
+            Assert.Equal("XXXXXX", row.SHA384);
+            Assert.Equal("XXXXXX", row.SHA512);
+            Assert.Equal("XXXXXX", row.SpamSum);
+            Assert.Equal("XXXXXX", row.Status);
+        }
+    }
+}

SabreTools.Serialization.Test/CrossModel/SoftwareListTests.cs

@@ -0,0 +1,311 @@
+using SabreTools.Serialization.CrossModel;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.CrossModel
+{
+    public class SoftwareListTests
+    {
+        [Fact]
+        public void RoundTripTest()
+        {
+            // Get the cross-model serializer
+            var serializer = new SoftwareList();
+
+            // Build the data
+            Data.Models.SoftwareList.SoftwareList sl = Build();
+
+            // Serialize to generic model
+            Data.Models.Metadata.MetadataFile? metadata = serializer.Serialize(sl);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.SoftwareList.SoftwareList? newSl = serializer.Deserialize(metadata);
+
+            // Validate the data
+            Assert.NotNull(newSl);
+            Assert.Equal("XXXXXX", newSl.Name);
+            Assert.Equal("XXXXXX", newSl.Description);
+            Assert.Equal("XXXXXX", newSl.Notes);
+
+            Assert.NotNull(newSl.Software);
+            var newSoftware = Assert.Single(newSl.Software);
+            Validate(newSoftware);
+        }
+
+        /// <summary>
+        /// Build model for serialization and deserialization
+        /// </summary>
+        private static Data.Models.SoftwareList.SoftwareList Build()
+        {
+            var info = new Data.Models.SoftwareList.Info
+            {
+                Name = "XXXXXX",
+                Value = "XXXXXX",
+            };
+
+            var sharedfeat = new Data.Models.SoftwareList.SharedFeat
+            {
+                Name = "XXXXXX",
+                Value = "XXXXXX",
+            };
+
+            var feature = new Data.Models.SoftwareList.Feature
+            {
+                Name = "XXXXXX",
+                Value = "XXXXXX",
+            };
+
+            var rom = new Data.Models.SoftwareList.Rom
+            {
+                Name = "XXXXXX",
+                Size = "XXXXXX",
+                Length = "XXXXXX",
+                CRC = "XXXXXX",
+                SHA1 = "XXXXXX",
+                Offset = "XXXXXX",
+                Value = "XXXXXX",
+                Status = "XXXXXX",
+                LoadFlag = "XXXXXX",
+            };
+
+            var dataarea = new Data.Models.SoftwareList.DataArea
+            {
+                Name = "XXXXXX",
+                Size = "XXXXXX",
+                Width = "XXXXXX",
+                Endianness = "XXXXXX",
+                Rom = [rom],
+            };
+
+            var disk = new Data.Models.SoftwareList.Disk
+            {
+                Name = "XXXXXX",
+                MD5 = "XXXXXX",
+                SHA1 = "XXXXXX",
+                Status = "XXXXXX",
+                Writeable = "XXXXXX",
+            };
+
+            var diskarea = new Data.Models.SoftwareList.DiskArea
+            {
+                Name = "XXXXXX",
+                Disk = [disk],
+            };
+
+            var dipvalue = new Data.Models.SoftwareList.DipValue
+            {
+                Name = "XXXXXX",
+                Value = "XXXXXX",
+                Default = "XXXXXX",
+            };
+
+            var dipswitch = new Data.Models.SoftwareList.DipSwitch
+            {
+                Name = "XXXXXX",
+                Tag = "XXXXXX",
+                Mask = "XXXXXX",
+                DipValue = [dipvalue],
+            };
+
+            var part = new Data.Models.SoftwareList.Part
+            {
+                Name = "XXXXXX",
+                Interface = "XXXXXX",
+                Feature = [feature],
+                DataArea = [dataarea],
+                DiskArea = [diskarea],
+                DipSwitch = [dipswitch],
+            };
+
+            var software = new Data.Models.SoftwareList.Software
+            {
+                Name = "XXXXXX",
+                CloneOf = "XXXXXX",
+                Supported = "XXXXXX",
+                Description = "XXXXXX",
+                Year = "XXXXXX",
+                Publisher = "XXXXXX",
+                Notes = "XXXXXX",
+                Info = [info],
+                SharedFeat = [sharedfeat],
+                Part = [part],
+            };
+
+            return new Data.Models.SoftwareList.SoftwareList
+            {
+                Name = "XXXXXX",
+                Description = "XXXXXX",
+                Notes = "XXXXXX",
+                Software = [software],
+            };
+        }
+
+        /// <summary>
+        /// Validate a Software
+        /// </summary>
+        private static void Validate(Data.Models.SoftwareList.Software? software)
+        {
+            Assert.NotNull(software);
+            Assert.Equal("XXXXXX", software.Name);
+            Assert.Equal("XXXXXX", software.CloneOf);
+            Assert.Equal("XXXXXX", software.Supported);
+            Assert.Equal("XXXXXX", software.Description);
+            Assert.Equal("XXXXXX", software.Year);
+            Assert.Equal("XXXXXX", software.Publisher);
+            Assert.Equal("XXXXXX", software.Notes);
+
+            Assert.NotNull(software.Info);
+            var info = Assert.Single(software.Info);
+            Validate(info);
+
+            Assert.NotNull(software.SharedFeat);
+            var sharedfeat = Assert.Single(software.SharedFeat);
+            Validate(sharedfeat);
+
+            Assert.NotNull(software.Part);
+            var part = Assert.Single(software.Part);
+            Validate(part);
+        }
+
+        /// <summary>
+        /// Validate a Info
+        /// </summary>
+        private static void Validate(Data.Models.SoftwareList.Info? info)
+        {
+            Assert.NotNull(info);
+            Assert.Equal("XXXXXX", info.Name);
+            Assert.Equal("XXXXXX", info.Value);
+        }
+
+        /// <summary>
+        /// Validate a SharedFeat
+        /// </summary>
+        private static void Validate(Data.Models.SoftwareList.SharedFeat? sharedfeat)
+        {
+            Assert.NotNull(sharedfeat);
+            Assert.Equal("XXXXXX", sharedfeat.Name);
+            Assert.Equal("XXXXXX", sharedfeat.Value);
+        }
+
+        /// <summary>
+        /// Validate a Part
+        /// </summary>
+        private static void Validate(Data.Models.SoftwareList.Part? part)
+        {
+            Assert.NotNull(part);
+            Assert.Equal("XXXXXX", part.Name);
+            Assert.Equal("XXXXXX", part.Interface);
+
+            Assert.NotNull(part.Feature);
+            var feature = Assert.Single(part.Feature);
+            Validate(feature);
+
+            Assert.NotNull(part.DataArea);
+            var dataarea = Assert.Single(part.DataArea);
+            Validate(dataarea);
+
+            Assert.NotNull(part.DiskArea);
+            var diskarea = Assert.Single(part.DiskArea);
+            Validate(diskarea);
+
+            Assert.NotNull(part.DipSwitch);
+            var dipswitch = Assert.Single(part.DipSwitch);
+            Validate(dipswitch);
+        }
+
+        /// <summary>
+        /// Validate a Feature
+        /// </summary>
+        private static void Validate(Data.Models.SoftwareList.Feature? feature)
+        {
+            Assert.NotNull(feature);
+            Assert.Equal("XXXXXX", feature.Name);
+            Assert.Equal("XXXXXX", feature.Value);
+        }
+
+        /// <summary>
+        /// Validate a DataArea
+        /// </summary>
+        private static void Validate(Data.Models.SoftwareList.DataArea? dataarea)
+        {
+            Assert.NotNull(dataarea);
+            Assert.Equal("XXXXXX", dataarea.Name);
+            Assert.Equal("XXXXXX", dataarea.Size);
+            Assert.Equal("XXXXXX", dataarea.Width);
+            Assert.Equal("XXXXXX", dataarea.Endianness);
+
+            Assert.NotNull(dataarea.Rom);
+            var rom = Assert.Single(dataarea.Rom);
+            Validate(rom);
+        }
+
+        /// <summary>
+        /// Validate a Rom
+        /// </summary>
+        private static void Validate(Data.Models.SoftwareList.Rom? rom)
+        {
+            Assert.NotNull(rom);
+            Assert.Equal("XXXXXX", rom.Name);
+            Assert.Equal("XXXXXX", rom.Size);
+            Assert.Equal("XXXXXX", rom.Length);
+            Assert.Equal("XXXXXX", rom.CRC);
+            Assert.Equal("XXXXXX", rom.SHA1);
+            Assert.Equal("XXXXXX", rom.Offset);
+            Assert.Equal("XXXXXX", rom.Value);
+            Assert.Equal("XXXXXX", rom.Status);
+            Assert.Equal("XXXXXX", rom.LoadFlag);
+        }
+
+        /// <summary>
+        /// Validate a DiskArea
+        /// </summary>
+        private static void Validate(Data.Models.SoftwareList.DiskArea? diskarea)
+        {
+            Assert.NotNull(diskarea);
+            Assert.Equal("XXXXXX", diskarea.Name);
+
+            Assert.NotNull(diskarea.Disk);
+            var disk = Assert.Single(diskarea.Disk);
+            Validate(disk);
+        }
+
+        /// <summary>
+        /// Validate a Disk
+        /// </summary>
+        private static void Validate(Data.Models.SoftwareList.Disk? disk)
+        {
+            Assert.NotNull(disk);
+            Assert.Equal("XXXXXX", disk.Name);
+            Assert.Equal("XXXXXX", disk.MD5);
+            Assert.Equal("XXXXXX", disk.SHA1);
+            Assert.Equal("XXXXXX", disk.Status);
+            Assert.Equal("XXXXXX", disk.Writeable);
+        }
+
+        /// <summary>
+        /// Validate a DipSwitch
+        /// </summary>
+        private static void Validate(Data.Models.SoftwareList.DipSwitch? dipswitch)
+        {
+            Assert.NotNull(dipswitch);
+            Assert.Equal("XXXXXX", dipswitch.Name);
+            Assert.Equal("XXXXXX", dipswitch.Tag);
+            Assert.Equal("XXXXXX", dipswitch.Mask);
+
+            Assert.NotNull(dipswitch.DipValue);
+            var dipvalue = Assert.Single(dipswitch.DipValue);
+            Validate(dipvalue);
+        }
+
+        /// <summary>
+        /// Validate a DipValue
+        /// </summary>
+        private static void Validate(Data.Models.SoftwareList.DipValue? dipvalue)
+        {
+            Assert.NotNull(dipvalue);
+            Assert.Equal("XXXXXX", dipvalue.Name);
+            Assert.Equal("XXXXXX", dipvalue.Value);
+            Assert.Equal("XXXXXX", dipvalue.Default);
+        }
+    }
+}

SabreTools.Serialization.Test/Extensions/TypeLengthValueTests.cs

@@ -0,0 +1,213 @@
+using System;
+using SabreTools.Data.Extensions;
+using SabreTools.Data.Models.ASN1;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Extensions
+{
+    public class TypeLengthValueTests
+    {
+        #region Formatting
+
+        [Fact]
+        public void Format_EOC()
+        {
+            string expected = "Type: V_ASN1_EOC";
+            var tlv = new Data.Models.ASN1.TypeLengthValue { Type = ASN1Type.V_ASN1_EOC, Length = 0, Value = null };
+            string actual = tlv.Format();
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void Format_ZeroLength()
+        {
+            string expected = "Type: V_ASN1_NULL, Length: 0";
+            var tlv = new Data.Models.ASN1.TypeLengthValue { Type = ASN1Type.V_ASN1_NULL, Length = 0, Value = null };
+            string actual = tlv.Format();
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void Format_InvalidConstructed()
+        {
+            string expected = "Type: V_ASN1_OBJECT, V_ASN1_CONSTRUCTED, Length: 1, Value: [INVALID DATA TYPE]";
+            var tlv = new Data.Models.ASN1.TypeLengthValue { Type = ASN1Type.V_ASN1_OBJECT | ASN1Type.V_ASN1_CONSTRUCTED, Length = 1, Value = (object?)false };
+            string actual = tlv.Format();
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void Format_ValidConstructed()
+        {
+            string expected = "Type: V_ASN1_OBJECT, V_ASN1_CONSTRUCTED, Length: 3, Value:\n Type: V_ASN1_BOOLEAN, Length: 1, Value: True";
+            var boolTlv = new Data.Models.ASN1.TypeLengthValue { Type = ASN1Type.V_ASN1_BOOLEAN, Length = 1, Value = new byte[] { 0x01 } };
+            var tlv = new Data.Models.ASN1.TypeLengthValue { Type = ASN1Type.V_ASN1_OBJECT | ASN1Type.V_ASN1_CONSTRUCTED, Length = 3, Value = new Data.Models.ASN1.TypeLengthValue[] { boolTlv } };
+            string actual = tlv.Format();
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void Format_InvalidDataType()
+        {
+            string expected = "Type: V_ASN1_OBJECT, Length: 1, Value: [INVALID DATA TYPE]";
+            var tlv = new Data.Models.ASN1.TypeLengthValue { Type = ASN1Type.V_ASN1_OBJECT, Length = 1, Value = (object?)false };
+            string actual = tlv.Format();
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void Format_InvalidLength()
+        {
+            string expected = "Type: V_ASN1_NULL, Length: 1, Value: [NO DATA]";
+            var tlv = new Data.Models.ASN1.TypeLengthValue { Type = ASN1Type.V_ASN1_NULL, Length = 1, Value = Array.Empty<byte>() };
+            string actual = tlv.Format();
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void Format_InvalidBooleanLength()
+        {
+            string expected = "Type: V_ASN1_BOOLEAN, Length: 2 [Expected length of 1], Value: True";
+            var tlv = new Data.Models.ASN1.TypeLengthValue { Type = ASN1Type.V_ASN1_BOOLEAN, Length = 2, Value = new byte[] { 0x01 } };
+            string actual = tlv.Format();
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void Format_InvalidBooleanArrayLength()
+        {
+            string expected = "Type: V_ASN1_BOOLEAN, Length: 1 [Expected value length of 1], Value: True";
+            var tlv = new Data.Models.ASN1.TypeLengthValue { Type = ASN1Type.V_ASN1_BOOLEAN, Length = 1, Value = new byte[] { 0x01, 0x00 } };
+            string actual = tlv.Format();
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void Format_ValidBoolean()
+        {
+            string expected = "Type: V_ASN1_BOOLEAN, Length: 1, Value: True";
+            var tlv = new Data.Models.ASN1.TypeLengthValue { Type = ASN1Type.V_ASN1_BOOLEAN, Length = 1, Value = new byte[] { 0x01 } };
+            string actual = tlv.Format();
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void Format_ValidInteger()
+        {
+            string expected = "Type: V_ASN1_INTEGER, Length: 1, Value: 1";
+            var tlv = new Data.Models.ASN1.TypeLengthValue { Type = ASN1Type.V_ASN1_INTEGER, Length = 1, Value = new byte[] { 0x01 } };
+            string actual = tlv.Format();
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void Format_ValidBitString_NoBits()
+        {
+            string expected = "Type: V_ASN1_BIT_STRING, Length: 1, Value with 0 unused bits";
+            var tlv = new Data.Models.ASN1.TypeLengthValue { Type = ASN1Type.V_ASN1_BIT_STRING, Length = 1, Value = new byte[] { 0x00 } };
+            string actual = tlv.Format();
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void Format_ValidBitString_Bits()
+        {
+            string expected = "Type: V_ASN1_BIT_STRING, Length: 1, Value with 1 unused bits: 01";
+            var tlv = new Data.Models.ASN1.TypeLengthValue { Type = ASN1Type.V_ASN1_BIT_STRING, Length = 1, Value = new byte[] { 0x01, 0x01 } };
+            string actual = tlv.Format();
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void Format_ValidOctetString()
+        {
+            string expected = "Type: V_ASN1_OCTET_STRING, Length: 1, Value: 01";
+            var tlv = new Data.Models.ASN1.TypeLengthValue { Type = ASN1Type.V_ASN1_OCTET_STRING, Length = 1, Value = new byte[] { 0x01 } };
+            string actual = tlv.Format();
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void Format_ValidObject()
+        {
+            string expected = "Type: V_ASN1_OBJECT, Length: 3, Value: 0.1.2.3 (/ITU-T/1/2/3)";
+            var tlv = new Data.Models.ASN1.TypeLengthValue { Type = ASN1Type.V_ASN1_OBJECT, Length = 3, Value = new byte[] { 0x01, 0x02, 0x03 } };
+            string actual = tlv.Format();
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void Format_ValidUTF8String()
+        {
+            string expected = "Type: V_ASN1_UTF8STRING, Length: 3, Value: ABC";
+            var tlv = new Data.Models.ASN1.TypeLengthValue { Type = ASN1Type.V_ASN1_UTF8STRING, Length = 3, Value = new byte[] { 0x41, 0x42, 0x43 } };
+            string actual = tlv.Format();
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void Format_ValidPrintableString()
+        {
+            string expected = "Type: V_ASN1_PRINTABLESTRING, Length: 3, Value: ABC";
+            var tlv = new Data.Models.ASN1.TypeLengthValue { Type = ASN1Type.V_ASN1_PRINTABLESTRING, Length = 3, Value = new byte[] { 0x41, 0x42, 0x43 } };
+            string actual = tlv.Format();
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void Format_ValidTeletexString()
+        {
+            string expected = "Type: V_ASN1_TELETEXSTRING, Length: 3, Value: ABC";
+            var tlv = new Data.Models.ASN1.TypeLengthValue { Type = ASN1Type.V_ASN1_TELETEXSTRING, Length = 3, Value = new byte[] { 0x41, 0x42, 0x43 } };
+            string actual = tlv.Format();
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void Format_ValidIA5String()
+        {
+            string expected = "Type: V_ASN1_IA5STRING, Length: 3, Value: ABC";
+            var tlv = new Data.Models.ASN1.TypeLengthValue { Type = ASN1Type.V_ASN1_IA5STRING, Length = 3, Value = new byte[] { 0x41, 0x42, 0x43 } };
+            string actual = tlv.Format();
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void Format_InvalidUTCTime()
+        {
+            string expected = "Type: V_ASN1_UTCTIME, Length: 3, Value: ABC";
+            var tlv = new Data.Models.ASN1.TypeLengthValue { Type = ASN1Type.V_ASN1_UTCTIME, Length = 3, Value = new byte[] { 0x41, 0x42, 0x43 } };
+            string actual = tlv.Format();
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void Format_ValidUTCTime()
+        {
+            string expected = "Type: V_ASN1_UTCTIME, Length: 3, Value: 1980-01-01 00:00:00";
+            var tlv = new Data.Models.ASN1.TypeLengthValue { Type = ASN1Type.V_ASN1_UTCTIME, Length = 3, Value = new byte[] { 0x31, 0x39, 0x38, 0x30, 0x2D, 0x30, 0x31, 0x2D, 0x30, 0x31, 0x20, 0x30, 0x30, 0x3A, 0x30, 0x30, 0x3A, 0x30, 0x30 } };
+            string actual = tlv.Format();
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void Format_ValidBmpString()
+        {
+            string expected = "Type: V_ASN1_BMPSTRING, Length: 6, Value: ABC";
+            var tlv = new Data.Models.ASN1.TypeLengthValue { Type = ASN1Type.V_ASN1_BMPSTRING, Length = 6, Value = new byte[] { 0x41, 0x00, 0x42, 0x00, 0x43, 0x00 } };
+            string actual = tlv.Format();
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void Format_ValidUnformatted()
+        {
+            string expected = "Type: V_ASN1_OBJECT_DESCRIPTOR, Length: 1, Value: 01";
+            var tlv = new Data.Models.ASN1.TypeLengthValue { Type = ASN1Type.V_ASN1_OBJECT_DESCRIPTOR, Length = 1, Value = new byte[] { 0x01 } };
+            string actual = tlv.Format();
+            Assert.Equal(expected, actual);
+        }
+
+        #endregion
+    }
+}

SabreTools.Serialization.Test/ObjectIdentifier/ParserTests.cs

@@ -0,0 +1,111 @@
+using SabreTools.Data.ObjectIdentifier;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.ObjectIdentifier
+{
+    // These tests are known to be incomplete due to the sheer number
+    // of possible OIDs that exist. The tests below are a minimal
+    // representation of functionality to guarantee proper behavior
+    // not necessarily absolute outputs
+    public class ParserTests
+    {
+        #region ASN.1
+
+        [Fact]
+        public void ASN1Notation_AlwaysNull()
+        {
+            ulong[]? values = null;
+            string? actual = Parser.ParseOIDToASN1Notation(values);
+            Assert.Null(actual);
+        }
+
+        #endregion
+
+        #region Dot Notation
+
+        [Fact]
+        public void DotNotation_NullValues_Null()
+        {
+            ulong[]? values = null;
+            string? actual = Parser.ParseOIDToDotNotation(values);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void DotNotation_EmptyValues_Null()
+        {
+            ulong[]? values = [];
+            string? actual = Parser.ParseOIDToDotNotation(values);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void DotNotation_Values_Formatted()
+        {
+            string expected = "0.1.2.3";
+            ulong[]? values = [0, 1, 2, 3];
+            string? actual = Parser.ParseOIDToDotNotation(values);
+            Assert.Equal(expected, actual);
+        }
+
+        #endregion
+
+        #region Modified OID-IRI
+
+        [Fact]
+        public void ModifiedOIDIRI_NullValues_Null()
+        {
+            ulong[]? values = null;
+            string? actual = Parser.ParseOIDToModifiedOIDIRI(values);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void ModifiedOIDIRI_EmptyValues_Null()
+        {
+            ulong[]? values = [];
+            string? actual = Parser.ParseOIDToModifiedOIDIRI(values);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void ModifiedOIDIRI_Values_Formatted()
+        {
+            string expected = "/ITU-T/[question]/2/3";
+            ulong[]? values = [0, 1, 2, 3];
+            string? actual = Parser.ParseOIDToModifiedOIDIRI(values);
+            Assert.Equal(expected, actual);
+        }
+
+        #endregion
+
+        #region OID-IRI
+
+        [Fact]
+        public void OIDIRI_NullValues_Null()
+        {
+            ulong[]? values = null;
+            string? actual = Parser.ParseOIDToOIDIRINotation(values);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void OIDIRI_EmptyValues_Null()
+        {
+            ulong[]? values = [];
+            string? actual = Parser.ParseOIDToOIDIRINotation(values);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void OIDIRI_Values_Formatted()
+        {
+            string expected = "/ITU-T/1/2/3";
+            ulong[]? values = [0, 1, 2, 3];
+            string? actual = Parser.ParseOIDToOIDIRINotation(values);
+            Assert.Equal(expected, actual);
+        }
+
+        #endregion
+    }
+}

SabreTools.Serialization.Test/Readers/AACSTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class AACSTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new AACS();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new AACS();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new AACS();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new AACS();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new AACS();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new AACS();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/AbstractSyntaxNotationOneTests.cs

@@ -0,0 +1,152 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Data.Models.ASN1;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class AbstractSyntaxNotationOneTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new AbstractSyntaxNotationOne();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new AbstractSyntaxNotationOne();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new AbstractSyntaxNotationOne();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new AbstractSyntaxNotationOne();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new AbstractSyntaxNotationOne();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new AbstractSyntaxNotationOne();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void ValidMinimalStream_NotNull()
+        {
+            Stream data = new MemoryStream([0x00]);
+            var deserializer = new AbstractSyntaxNotationOne();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.NotNull(actual);
+
+            var actualSingle = Assert.Single(actual);
+            Assert.Equal(ASN1Type.V_ASN1_EOC, actualSingle.Type);
+            Assert.Equal(default, actualSingle.Length);
+            Assert.Null(actualSingle.Value);
+        }
+
+        [Fact]
+        public void ValidBoolean_NotNull()
+        {
+            Stream data = new MemoryStream([0x01, 0x01, 0x01]);
+            var deserializer = new AbstractSyntaxNotationOne();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.NotNull(actual);
+
+            var actualSingle = Assert.Single(actual);
+            Assert.Equal(ASN1Type.V_ASN1_BOOLEAN, actualSingle.Type);
+            Assert.Equal(1UL, actualSingle.Length);
+            Assert.NotNull(actualSingle.Value);
+
+            byte[]? valueAsArray = actualSingle.Value as byte[];
+            Assert.NotNull(valueAsArray);
+            byte actualValue = Assert.Single(valueAsArray);
+            Assert.Equal(0x01, actualValue);
+        }
+
+        [Theory]
+        [InlineData(new byte[] { 0x26, 0x81, 0x03, 0x01, 0x01, 0x01 })]
+        [InlineData(new byte[] { 0x26, 0x82, 0x00, 0x03, 0x01, 0x01, 0x01 })]
+        [InlineData(new byte[] { 0x26, 0x83, 0x00, 0x00, 0x03, 0x01, 0x01, 0x01 })]
+        [InlineData(new byte[] { 0x26, 0x84, 0x00, 0x00, 0x00, 0x03, 0x01, 0x01, 0x01 })]
+        [InlineData(new byte[] { 0x26, 0x85, 0x00, 0x00, 0x00, 0x00, 0x03, 0x01, 0x01, 0x01 })]
+        [InlineData(new byte[] { 0x26, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x01, 0x01, 0x01 })]
+        [InlineData(new byte[] { 0x26, 0x87, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x01, 0x01, 0x01 })]
+        [InlineData(new byte[] { 0x26, 0x88, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x01, 0x01, 0x01 })]
+        public void ComplexValue_NotNull(byte[] arr)
+        {
+            Stream data = new MemoryStream(arr);
+            var deserializer = new AbstractSyntaxNotationOne();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.NotNull(actual);
+
+            var actualSingle = Assert.Single(actual);
+            Assert.Equal(ASN1Type.V_ASN1_CONSTRUCTED | ASN1Type.V_ASN1_OBJECT, actualSingle.Type);
+            Assert.Equal(3UL, actualSingle.Length);
+            Assert.NotNull(actualSingle.Value);
+
+            TypeLengthValue[]? valueAsArray = actualSingle.Value as TypeLengthValue[];
+            Assert.NotNull(valueAsArray);
+            TypeLengthValue actualSub = Assert.Single(valueAsArray);
+
+            Assert.Equal(ASN1Type.V_ASN1_BOOLEAN, actualSub.Type);
+            Assert.Equal(1UL, actualSub.Length);
+            Assert.NotNull(actualSub.Value);
+        }
+
+        [Theory]
+        [InlineData(new byte[] { 0x26, 0x80 })]
+        [InlineData(new byte[] { 0x26, 0x89 })]
+        public void ComplexValueInvalidLength_Null(byte[] arr)
+        {
+            Stream data = new MemoryStream(arr);
+            var deserializer = new AbstractSyntaxNotationOne();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/AdvancedInstallerTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class AdvancedInstallerTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new AdvancedInstaller();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new AdvancedInstaller();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new AdvancedInstaller();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new AdvancedInstaller();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new AdvancedInstaller();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new AdvancedInstaller();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/AppPkgHeaderTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class AppPkgHeaderTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new AppPkgHeader();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new AppPkgHeader();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new AppPkgHeader();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new AppPkgHeader();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new AppPkgHeader();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new AppPkgHeader();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/ArchiveDotOrgTests.cs

@@ -0,0 +1,240 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class ArchiveDotOrgTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new ArchiveDotOrg();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new ArchiveDotOrg();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new ArchiveDotOrg();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new ArchiveDotOrg();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new ArchiveDotOrg();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new ArchiveDotOrg();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void RoundTripTest()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new ArchiveDotOrg();
+            var serializer = new SabreTools.Serialization.Writers.ArchiveDotOrg();
+
+            // Build the data
+            Data.Models.ArchiveDotOrg.Files files = Build();
+
+            // Serialize to stream
+            Stream? actual = serializer.Serialize(files);
+            Assert.NotNull(actual);
+
+            // Serialize back to original model
+            Data.Models.ArchiveDotOrg.Files? newFiles = deserializer.Deserialize(actual);
+
+            // Validate the data
+            Assert.NotNull(newFiles);
+            Assert.NotNull(newFiles.File);
+            var newFile = Assert.Single(newFiles.File);
+            Validate(newFile);
+        }
+
+        /// <summary>
+        /// Build model for serialization and deserialization
+        /// </summary>
+        private static Data.Models.ArchiveDotOrg.Files Build()
+        {
+            var file = new Data.Models.ArchiveDotOrg.File
+            {
+                Name = "XXXXXX",
+                Source = "XXXXXX",
+                BitTorrentMagnetHash = "XXXXXX",
+                LastModifiedTime = "XXXXXX",
+                Size = "XXXXXX",
+                MD5 = "XXXXXX",
+                CRC32 = "XXXXXX",
+                SHA1 = "XXXXXX",
+                FileCount = "XXXXXX",
+                Format = "XXXXXX",
+                Original = "XXXXXX",
+                Summation = "XXXXXX",
+                MatrixNumber = "XXXXXX",
+                CollectionCatalogNumber = "XXXXXX",
+                Publisher = "XXXXXX",
+                Comment = "XXXXXX",
+                ASRDetectedLang = "XXXXXX",
+                ASRDetectedLangConf = "XXXXXX",
+                ASRTranscribedLang = "XXXXXX",
+                WhisperASRModuleVersion = "XXXXXX",
+                WhisperModelHash = "XXXXXX",
+                WhisperModelName = "XXXXXX",
+                WhisperVersion = "XXXXXX",
+                ClothCoverDetectionModuleVersion = "XXXXXX",
+                hOCRCharToWordhOCRVersion = "XXXXXX",
+                hOCRCharToWordModuleVersion = "XXXXXX",
+                hOCRFtsTexthOCRVersion = "XXXXXX",
+                hOCRFtsTextModuleVersion = "XXXXXX",
+                hOCRPageIndexhOCRVersion = "XXXXXX",
+                hOCRPageIndexModuleVersion = "XXXXXX",
+                TesseractOCR = "XXXXXX",
+                TesseractOCRConverted = "XXXXXX",
+                TesseractOCRDetectedLang = "XXXXXX",
+                TesseractOCRDetectedLangConf = "XXXXXX",
+                TesseractOCRDetectedScript = "XXXXXX",
+                TesseractOCRDetectedScriptConf = "XXXXXX",
+                TesseractOCRModuleVersion = "XXXXXX",
+                TesseractOCRParameters = "XXXXXX",
+                PDFModuleVersion = "XXXXXX",
+                WordConfidenceInterval0To10 = "XXXXXX",
+                WordConfidenceInterval11To20 = "XXXXXX",
+                WordConfidenceInterval21To30 = "XXXXXX",
+                WordConfidenceInterval31To40 = "XXXXXX",
+                WordConfidenceInterval41To50 = "XXXXXX",
+                WordConfidenceInterval51To60 = "XXXXXX",
+                WordConfidenceInterval61To70 = "XXXXXX",
+                WordConfidenceInterval71To80 = "XXXXXX",
+                WordConfidenceInterval81To90 = "XXXXXX",
+                WordConfidenceInterval91To100 = "XXXXXX",
+                Album = "XXXXXX",
+                Artist = "XXXXXX",
+                Bitrate = "XXXXXX",
+                Creator = "XXXXXX",
+                Height = "XXXXXX",
+                Length = "XXXXXX",
+                PreviewImage = "XXXXXX",
+                Rotation = "XXXXXX",
+                Title = "XXXXXX",
+                Track = "XXXXXX",
+                Width = "XXXXXX",
+            };
+
+            return new Data.Models.ArchiveDotOrg.Files
+            {
+                File = [file]
+            };
+        }
+
+        /// <summary>
+        /// Validate a File
+        /// </summary>
+        private static void Validate(Data.Models.ArchiveDotOrg.File? file)
+        {
+            Assert.NotNull(file);
+            Assert.Equal("XXXXXX", file.Name);
+            Assert.Equal("XXXXXX", file.Source);
+            Assert.Equal("XXXXXX", file.BitTorrentMagnetHash);
+            Assert.Equal("XXXXXX", file.LastModifiedTime);
+            Assert.Equal("XXXXXX", file.Size);
+            Assert.Equal("XXXXXX", file.MD5);
+            Assert.Equal("XXXXXX", file.CRC32);
+            Assert.Equal("XXXXXX", file.SHA1);
+            Assert.Equal("XXXXXX", file.FileCount);
+            Assert.Equal("XXXXXX", file.Format);
+            Assert.Equal("XXXXXX", file.Original);
+            Assert.Equal("XXXXXX", file.Summation);
+            Assert.Equal("XXXXXX", file.MatrixNumber);
+            Assert.Equal("XXXXXX", file.CollectionCatalogNumber);
+            Assert.Equal("XXXXXX", file.Publisher);
+            Assert.Equal("XXXXXX", file.Comment);
+            Assert.Equal("XXXXXX", file.ASRDetectedLang);
+            Assert.Equal("XXXXXX", file.ASRDetectedLangConf);
+            Assert.Equal("XXXXXX", file.ASRTranscribedLang);
+            Assert.Equal("XXXXXX", file.WhisperASRModuleVersion);
+            Assert.Equal("XXXXXX", file.WhisperModelHash);
+            Assert.Equal("XXXXXX", file.WhisperModelName);
+            Assert.Equal("XXXXXX", file.WhisperVersion);
+            Assert.Equal("XXXXXX", file.ClothCoverDetectionModuleVersion);
+            Assert.Equal("XXXXXX", file.hOCRCharToWordhOCRVersion);
+            Assert.Equal("XXXXXX", file.hOCRCharToWordModuleVersion);
+            Assert.Equal("XXXXXX", file.hOCRFtsTexthOCRVersion);
+            Assert.Equal("XXXXXX", file.hOCRFtsTextModuleVersion);
+            Assert.Equal("XXXXXX", file.hOCRPageIndexhOCRVersion);
+            Assert.Equal("XXXXXX", file.hOCRPageIndexModuleVersion);
+            Assert.Equal("XXXXXX", file.TesseractOCR);
+            Assert.Equal("XXXXXX", file.TesseractOCRConverted);
+            Assert.Equal("XXXXXX", file.TesseractOCRDetectedLang);
+            Assert.Equal("XXXXXX", file.TesseractOCRDetectedLangConf);
+            Assert.Equal("XXXXXX", file.TesseractOCRDetectedScript);
+            Assert.Equal("XXXXXX", file.TesseractOCRDetectedScriptConf);
+            Assert.Equal("XXXXXX", file.TesseractOCRModuleVersion);
+            Assert.Equal("XXXXXX", file.TesseractOCRParameters);
+            Assert.Equal("XXXXXX", file.PDFModuleVersion);
+            Assert.Equal("XXXXXX", file.WordConfidenceInterval0To10);
+            Assert.Equal("XXXXXX", file.WordConfidenceInterval11To20);
+            Assert.Equal("XXXXXX", file.WordConfidenceInterval21To30);
+            Assert.Equal("XXXXXX", file.WordConfidenceInterval31To40);
+            Assert.Equal("XXXXXX", file.WordConfidenceInterval41To50);
+            Assert.Equal("XXXXXX", file.WordConfidenceInterval51To60);
+            Assert.Equal("XXXXXX", file.WordConfidenceInterval61To70);
+            Assert.Equal("XXXXXX", file.WordConfidenceInterval71To80);
+            Assert.Equal("XXXXXX", file.WordConfidenceInterval81To90);
+            Assert.Equal("XXXXXX", file.WordConfidenceInterval91To100);
+            Assert.Equal("XXXXXX", file.Album);
+            Assert.Equal("XXXXXX", file.Artist);
+            Assert.Equal("XXXXXX", file.Bitrate);
+            Assert.Equal("XXXXXX", file.Creator);
+            Assert.Equal("XXXXXX", file.Height);
+            Assert.Equal("XXXXXX", file.Length);
+            Assert.Equal("XXXXXX", file.PreviewImage);
+            Assert.Equal("XXXXXX", file.Rotation);
+            Assert.Equal("XXXXXX", file.Title);
+            Assert.Equal("XXXXXX", file.Track);
+            Assert.Equal("XXXXXX", file.Width);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/AttractModeTests.cs

@@ -0,0 +1,217 @@
+using System;
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class AttractModeTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new AttractMode();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new AttractMode();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new AttractMode();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new AttractMode();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new AttractMode();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            var data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new AttractMode();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void RoundTripShortTest()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new AttractMode();
+            var serializer = new SabreTools.Serialization.Writers.AttractMode();
+
+            // Build the data
+            Data.Models.AttractMode.MetadataFile mf = Build();
+
+            // Serialize to stream
+            Stream? actual = serializer.SerializeStream(mf, longHeader: false);
+            Assert.NotNull(actual);
+
+            // Serialize back to original model
+            Data.Models.AttractMode.MetadataFile? newMf = deserializer.Deserialize(actual);
+
+            // Validate the data
+            Assert.NotNull(newMf);
+            Validate(newMf.Header, longHeader: false);
+            Assert.NotNull(newMf.Row);
+            var newRow = Assert.Single(newMf.Row);
+            Validate(newRow, longHeader: false);
+        }
+
+        [Fact]
+        public void RoundTripLongTest()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new AttractMode();
+            var serializer = new SabreTools.Serialization.Writers.AttractMode();
+
+            // Build the data
+            Data.Models.AttractMode.MetadataFile mf = Build();
+
+            // Serialize to stream
+            Stream? actual = serializer.SerializeStream(mf, longHeader: true);
+            Assert.NotNull(actual);
+
+            // Serialize back to original model
+            Data.Models.AttractMode.MetadataFile? newMf = deserializer.Deserialize(actual);
+
+            // Validate the data
+            Assert.NotNull(newMf);
+            Validate(newMf.Header, longHeader: true);
+            Assert.NotNull(newMf.Row);
+            var newRow = Assert.Single(newMf.Row);
+            Validate(newRow, longHeader: true);
+        }
+
+        /// <summary>
+        /// Build model for serialization and deserialization
+        /// </summary>
+        private static Data.Models.AttractMode.MetadataFile Build()
+        {
+            string[] header = ["header"];
+
+            var row = new Data.Models.AttractMode.Row
+            {
+                Name = "XXXXXX",
+                Title = "XXXXXX",
+                Emulator = "XXXXXX",
+                CloneOf = "XXXXXX",
+                Year = "XXXXXX",
+                Manufacturer = "XXXXXX",
+                Category = "XXXXXX",
+                Players = "XXXXXX",
+                Rotation = "XXXXXX",
+                Control = "XXXXXX",
+                Status = "XXXXXX",
+                DisplayCount = "XXXXXX",
+                DisplayType = "XXXXXX",
+                AltRomname = "XXXXXX",
+                AltTitle = "XXXXXX",
+                Extra = "XXXXXX",
+                Buttons = "XXXXXX",
+                Favorite = "XXXXXX",
+                Tags = "XXXXXX",
+                PlayedCount = "XXXXXX",
+                PlayedTime = "XXXXXX",
+                FileIsAvailable = "XXXXXX",
+            };
+
+            return new Data.Models.AttractMode.MetadataFile
+            {
+                Header = header,
+                Row = [row],
+            };
+        }
+
+        /// <summary>
+        /// Validate a header
+        /// </summary>
+        private static void Validate(string[]? header, bool longHeader)
+        {
+            Assert.NotNull(header);
+            if (longHeader)
+                Assert.True(SabreTools.Serialization.Writers.AttractMode.HeaderArrayWithRomname.SequenceEqual(header));
+            else
+                Assert.True(SabreTools.Serialization.Writers.AttractMode.HeaderArrayWithoutRomname.SequenceEqual(header));
+        }
+
+        /// <summary>
+        /// Validate a Row
+        /// </summary>
+        private static void Validate(Data.Models.AttractMode.Row? row, bool longHeader)
+        {
+            Assert.NotNull(row);
+            Assert.Equal("XXXXXX", row.Name);
+            Assert.Equal("XXXXXX", row.Title);
+            Assert.Equal("XXXXXX", row.Emulator);
+            Assert.Equal("XXXXXX", row.CloneOf);
+            Assert.Equal("XXXXXX", row.Year);
+            Assert.Equal("XXXXXX", row.Manufacturer);
+            Assert.Equal("XXXXXX", row.Category);
+            Assert.Equal("XXXXXX", row.Players);
+            Assert.Equal("XXXXXX", row.Rotation);
+            Assert.Equal("XXXXXX", row.Control);
+            Assert.Equal("XXXXXX", row.Status);
+            Assert.Equal("XXXXXX", row.DisplayCount);
+            Assert.Equal("XXXXXX", row.DisplayType);
+            Assert.Equal("XXXXXX", row.AltRomname);
+            Assert.Equal("XXXXXX", row.AltTitle);
+            Assert.Equal("XXXXXX", row.Extra);
+            Assert.Equal("XXXXXX", row.Buttons);
+            if (longHeader)
+            {
+                Assert.Equal("XXXXXX", row.Favorite);
+                Assert.Equal("XXXXXX", row.Tags);
+                Assert.Equal("XXXXXX", row.PlayedCount);
+                Assert.Equal("XXXXXX", row.PlayedTime);
+                Assert.Equal("XXXXXX", row.FileIsAvailable);
+            }
+            else
+            {
+                Assert.Null(row.Favorite);
+                Assert.Null(row.Tags);
+                Assert.Null(row.PlayedCount);
+                Assert.Null(row.PlayedTime);
+                Assert.Null(row.FileIsAvailable);
+            }
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/BDPlusTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class BDPlusTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new BDPlus();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new BDPlus();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new BDPlus();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new BDPlus();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new BDPlus();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new BDPlus();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/BFPKTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class BFPKTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new BFPK();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new BFPK();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new BFPK();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new BFPK();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new BFPK();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new BFPK();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/BSPTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class BSPTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new BSP();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new BSP();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new BSP();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new BSP();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new BSP();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new BSP();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/CFBTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class CFBTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new CFB();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new CFB();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new CFB();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new CFB();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new CFB();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new CFB();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/CHDTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class CHDTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new CHD();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new CHD();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new CHD();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new CHD();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new CHD();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new CHD();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/CIATests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class CIATests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new CIA();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new CIA();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new CIA();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new CIA();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new CIA();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new CIA();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/CatalogTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class CatalogTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new Catalog();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new Catalog();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new Catalog();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new Catalog();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new Catalog();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new Catalog();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/ClrMameProTests.cs

@@ -0,0 +1,618 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class ClrMameProTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new ClrMamePro();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new ClrMamePro();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new ClrMamePro();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new ClrMamePro();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new ClrMamePro();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new ClrMamePro();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void RoundTripGameTest()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new ClrMamePro();
+            var serializer = new SabreTools.Serialization.Writers.ClrMamePro();
+
+            // Build the data
+            Data.Models.ClrMamePro.MetadataFile mf = Build(game: true);
+
+            // Serialize to stream
+            Stream? actual = serializer.SerializeStream(mf);
+            Assert.NotNull(actual);
+
+            // Serialize back to original model
+            Data.Models.ClrMamePro.MetadataFile? newMf = deserializer.Deserialize(actual);
+
+            // Validate the data
+            Assert.NotNull(newMf);
+            Validate(newMf.ClrMamePro);
+            Assert.NotNull(newMf.Game);
+            var newGame = Assert.Single(newMf.Game);
+            Validate(newGame);
+        }
+
+        [Fact]
+        public void RoundTripGameWithoutQuotesTest()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new ClrMamePro();
+            var serializer = new SabreTools.Serialization.Writers.ClrMamePro();
+
+            // Build the data
+            Data.Models.ClrMamePro.MetadataFile mf = Build(game: true);
+
+            // Serialize to stream
+            Stream? actual = serializer.SerializeStream(mf, quotes: false);
+            Assert.NotNull(actual);
+
+            // Serialize back to original model
+            Data.Models.ClrMamePro.MetadataFile? newMf = deserializer.Deserialize(actual);
+
+            // Validate the data
+            Assert.NotNull(newMf);
+            Validate(newMf.ClrMamePro);
+            Assert.NotNull(newMf.Game);
+            var newGame = Assert.Single(newMf.Game);
+            Validate(newGame);
+        }
+
+        [Fact]
+        public void RoundTripMachineTest()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new ClrMamePro();
+            var serializer = new SabreTools.Serialization.Writers.ClrMamePro();
+
+            // Build the data
+            Data.Models.ClrMamePro.MetadataFile mf = Build(game: false);
+
+            // Serialize to stream
+            Stream? actual = serializer.SerializeStream(mf);
+            Assert.NotNull(actual);
+
+            // Serialize back to original model
+            Data.Models.ClrMamePro.MetadataFile? newMf = deserializer.Deserialize(actual);
+
+            // Validate the data
+            Assert.NotNull(newMf);
+            Validate(newMf.ClrMamePro);
+            Assert.NotNull(newMf.Game);
+            var newGame = Assert.Single(newMf.Game);
+            Validate(newGame);
+        }
+
+        [Fact]
+        public void RoundTripMachineWithoutQuotesTest()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new ClrMamePro();
+            var serializer = new SabreTools.Serialization.Writers.ClrMamePro();
+
+            // Build the data
+            Data.Models.ClrMamePro.MetadataFile mf = Build(game: false);
+
+            // Serialize to stream
+            Stream? actual = serializer.SerializeStream(mf, quotes: false);
+            Assert.NotNull(actual);
+
+            // Serialize back to original model
+            Data.Models.ClrMamePro.MetadataFile? newMf = deserializer.Deserialize(actual);
+
+            // Validate the data
+            Assert.NotNull(newMf);
+            Validate(newMf.ClrMamePro);
+            Assert.NotNull(newMf.Game);
+            var newGame = Assert.Single(newMf.Game);
+            Validate(newGame);
+        }
+
+        /// <summary>
+        /// Build model for serialization and deserialization
+        /// </summary>
+        private static Data.Models.ClrMamePro.MetadataFile Build(bool game)
+        {
+            var cmp = new Data.Models.ClrMamePro.ClrMamePro
+            {
+                Name = "XXXXXX",
+                Description = "XXXXXX",
+                RootDir = "XXXXXX",
+                Category = "XXXXXX",
+                Version = "XXXXXX",
+                Date = "XXXXXX",
+                Author = "XXXXXX",
+                Homepage = "XXXXXX",
+                Url = "XXXXXX",
+                Comment = "XXXXXX",
+                Header = "XXXXXX",
+                Type = "XXXXXX",
+                ForceMerging = "XXXXXX",
+                ForceZipping = "XXXXXX",
+                ForcePacking = "XXXXXX",
+            };
+
+            var release = new Data.Models.ClrMamePro.Release
+            {
+                Name = "XXXXXX",
+                Region = "XXXXXX",
+                Language = "XXXXXX",
+                Date = "XXXXXX",
+                Default = "XXXXXX",
+            };
+
+            var biosset = new Data.Models.ClrMamePro.BiosSet
+            {
+                Name = "XXXXXX",
+                Description = "XXXXXX",
+                Default = "XXXXXX",
+            };
+
+            var rom = new Data.Models.ClrMamePro.Rom
+            {
+                Name = "XXXXXX",
+                Size = "XXXXXX",
+                CRC = "XXXXXX",
+                MD2 = "XXXXXX",
+                MD4 = "XXXXXX",
+                MD5 = "XXXXXX",
+                RIPEMD128 = "XXXXXX",
+                RIPEMD160 = "XXXXXX",
+                SHA1 = "XXXXXX",
+                Merge = "XXXXXX",
+                Status = "XXXXXX",
+                Flags = "XXXXXX",
+                Date = "XXXXXX",
+                SHA256 = "XXXXXX",
+                SHA384 = "XXXXXX",
+                SHA512 = "XXXXXX",
+                SpamSum = "XXXXXX",
+                xxHash364 = "XXXXXX",
+                xxHash3128 = "XXXXXX",
+                Region = "XXXXXX",
+                Offs = "XXXXXX",
+                Serial = "XXXXXX",
+                Header = "XXXXXX",
+                Inverted = "XXXXXX",
+                MIA = "XXXXXX",
+            };
+
+            var disk = new Data.Models.ClrMamePro.Disk
+            {
+                Name = "XXXXXX",
+                MD5 = "XXXXXX",
+                SHA1 = "XXXXXX",
+                Merge = "XXXXXX",
+                Status = "XXXXXX",
+                Flags = "XXXXXX",
+            };
+
+            var sample = new Data.Models.ClrMamePro.Sample
+            {
+                Name = "XXXXXX",
+            };
+
+            var archive = new Data.Models.ClrMamePro.Archive
+            {
+                Name = "XXXXXX",
+            };
+
+            var media = new Data.Models.ClrMamePro.Media
+            {
+                Name = "XXXXXX",
+                MD5 = "XXXXXX",
+                SHA1 = "XXXXXX",
+                SHA256 = "XXXXXX",
+                SpamSum = "XXXXXX",
+            };
+
+            var chip = new Data.Models.ClrMamePro.Chip
+            {
+                Type = "XXXXXX",
+                Name = "XXXXXX",
+                Flags = "XXXXXX",
+                Clock = "XXXXXX",
+            };
+
+            var video = new Data.Models.ClrMamePro.Video
+            {
+                Screen = "XXXXXX",
+                Orientation = "XXXXXX",
+                X = "XXXXXX",
+                Y = "XXXXXX",
+                AspectX = "XXXXXX",
+                AspectY = "XXXXXX",
+                Freq = "XXXXXX",
+            };
+
+            var sound = new Data.Models.ClrMamePro.Sound
+            {
+                Channels = "XXXXXX",
+            };
+
+            var input = new Data.Models.ClrMamePro.Input
+            {
+                Players = "XXXXXX",
+                Control = "XXXXXX",
+                Buttons = "XXXXXX",
+                Coins = "XXXXXX",
+                Tilt = "XXXXXX",
+                Service = "XXXXXX",
+            };
+
+            var dipswitch = new Data.Models.ClrMamePro.DipSwitch
+            {
+                Name = "XXXXXX",
+                Entry = ["XXXXXX"],
+                Default = "XXXXXX",
+            };
+
+            var driver = new Data.Models.ClrMamePro.Driver
+            {
+                Status = "XXXXXX",
+                Color = "XXXXXX",
+                Sound = "XXXXXX",
+                PaletteSize = "XXXXXX",
+                Blit = "XXXXXX",
+            };
+
+            // TODO: This omits Set, should that have a separate case?
+            Data.Models.ClrMamePro.GameBase gameBase = game
+                ? new Data.Models.ClrMamePro.Game()
+                : new Data.Models.ClrMamePro.Machine();
+            gameBase.Name = "XXXXXX";
+            gameBase.Description = "XXXXXX";
+            gameBase.Year = "XXXXXX";
+            gameBase.Manufacturer = "XXXXXX";
+            gameBase.Category = "XXXXXX";
+            gameBase.CloneOf = "XXXXXX";
+            gameBase.RomOf = "XXXXXX";
+            gameBase.SampleOf = "XXXXXX";
+            gameBase.Release = [release];
+            gameBase.BiosSet = [biosset];
+            gameBase.Rom = [rom];
+            gameBase.Disk = [disk];
+            gameBase.Sample = [sample];
+            gameBase.Archive = [archive];
+            gameBase.Media = [media];
+            gameBase.Chip = [chip];
+            gameBase.Video = [video];
+            gameBase.Sound = sound;
+            gameBase.Input = input;
+            gameBase.DipSwitch = [dipswitch];
+            gameBase.Driver = driver;
+
+            return new Data.Models.ClrMamePro.MetadataFile
+            {
+                ClrMamePro = cmp,
+                Game = [gameBase],
+            };
+        }
+
+        /// <summary>
+        /// Validate a ClrMamePro
+        /// </summary>
+        private static void Validate(Data.Models.ClrMamePro.ClrMamePro? cmp)
+        {
+            Assert.NotNull(cmp);
+            Assert.Equal("XXXXXX", cmp.Name);
+            Assert.Equal("XXXXXX", cmp.Description);
+            Assert.Equal("XXXXXX", cmp.RootDir);
+            Assert.Equal("XXXXXX", cmp.Category);
+            Assert.Equal("XXXXXX", cmp.Version);
+            Assert.Equal("XXXXXX", cmp.Date);
+            Assert.Equal("XXXXXX", cmp.Author);
+            Assert.Equal("XXXXXX", cmp.Homepage);
+            Assert.Equal("XXXXXX", cmp.Url);
+            Assert.Equal("XXXXXX", cmp.Comment);
+            Assert.Equal("XXXXXX", cmp.Header);
+            Assert.Equal("XXXXXX", cmp.Type);
+            Assert.Equal("XXXXXX", cmp.ForceMerging);
+            Assert.Equal("XXXXXX", cmp.ForceZipping);
+            Assert.Equal("XXXXXX", cmp.ForcePacking);
+        }
+
+        /// <summary>
+        /// Validate a GameBase
+        /// </summary>
+        private static void Validate(Data.Models.ClrMamePro.GameBase? gb)
+        {
+            Assert.NotNull(gb);
+            Assert.Equal("XXXXXX", gb.Name);
+            Assert.Equal("XXXXXX", gb.Description);
+            Assert.Equal("XXXXXX", gb.Year);
+            Assert.Equal("XXXXXX", gb.Manufacturer);
+            Assert.Equal("XXXXXX", gb.Category);
+            Assert.Equal("XXXXXX", gb.CloneOf);
+            Assert.Equal("XXXXXX", gb.RomOf);
+            Assert.Equal("XXXXXX", gb.SampleOf);
+
+            Assert.NotNull(gb.Release);
+            var release = Assert.Single(gb.Release);
+            Validate(release);
+
+            Assert.NotNull(gb.BiosSet);
+            var biosset = Assert.Single(gb.BiosSet);
+            Validate(biosset);
+
+            Assert.NotNull(gb.Rom);
+            var rom = Assert.Single(gb.Rom);
+            Validate(rom);
+
+            Assert.NotNull(gb.Disk);
+            var disk = Assert.Single(gb.Disk);
+            Validate(disk);
+
+            Assert.NotNull(gb.Sample);
+            var sample = Assert.Single(gb.Sample);
+            Validate(sample);
+
+            Assert.NotNull(gb.Archive);
+            var archive = Assert.Single(gb.Archive);
+            Validate(archive);
+
+            Assert.NotNull(gb.Media);
+            var media = Assert.Single(gb.Media);
+            Validate(media);
+
+            Assert.NotNull(gb.Chip);
+            var chip = Assert.Single(gb.Chip);
+            Validate(chip);
+
+            Assert.NotNull(gb.Video);
+            var video = Assert.Single(gb.Video);
+            Validate(video);
+
+            Validate(gb.Sound);
+            Validate(gb.Input);
+
+            Assert.NotNull(gb.DipSwitch);
+            var dipswitch = Assert.Single(gb.DipSwitch);
+            Validate(dipswitch);
+
+            Validate(gb.Driver);
+        }
+
+        /// <summary>
+        /// Validate a Release
+        /// </summary>
+        private static void Validate(Data.Models.ClrMamePro.Release? release)
+        {
+            Assert.NotNull(release);
+            Assert.Equal("XXXXXX", release.Name);
+            Assert.Equal("XXXXXX", release.Region);
+            Assert.Equal("XXXXXX", release.Language);
+            Assert.Equal("XXXXXX", release.Date);
+            Assert.Equal("XXXXXX", release.Default);
+        }
+
+        /// <summary>
+        /// Validate a BiosSet
+        /// </summary>
+        private static void Validate(Data.Models.ClrMamePro.BiosSet? biosset)
+        {
+            Assert.NotNull(biosset);
+            Assert.Equal("XXXXXX", biosset.Name);
+            Assert.Equal("XXXXXX", biosset.Description);
+            Assert.Equal("XXXXXX", biosset.Default);
+        }
+
+        /// <summary>
+        /// Validate a Rom
+        /// </summary>
+        private static void Validate(Data.Models.ClrMamePro.Rom? rom)
+        {
+            Assert.NotNull(rom);
+            Assert.Equal("XXXXXX", rom.Name);
+            Assert.Equal("XXXXXX", rom.Size);
+            Assert.Equal("XXXXXX", rom.CRC);
+            Assert.Equal("XXXXXX", rom.MD2);
+            Assert.Equal("XXXXXX", rom.MD4);
+            Assert.Equal("XXXXXX", rom.MD5);
+            Assert.Equal("XXXXXX", rom.RIPEMD128);
+            Assert.Equal("XXXXXX", rom.RIPEMD160);
+            Assert.Equal("XXXXXX", rom.SHA1);
+            Assert.Equal("XXXXXX", rom.Merge);
+            Assert.Equal("XXXXXX", rom.Status);
+            Assert.Equal("XXXXXX", rom.Flags);
+            Assert.Equal("XXXXXX", rom.Date);
+            Assert.Equal("XXXXXX", rom.SHA256);
+            Assert.Equal("XXXXXX", rom.SHA384);
+            Assert.Equal("XXXXXX", rom.SHA512);
+            Assert.Equal("XXXXXX", rom.SpamSum);
+            Assert.Equal("XXXXXX", rom.xxHash364);
+            Assert.Equal("XXXXXX", rom.xxHash3128);
+            Assert.Equal("XXXXXX", rom.Region);
+            Assert.Equal("XXXXXX", rom.Offs);
+            Assert.Equal("XXXXXX", rom.Serial);
+            Assert.Equal("XXXXXX", rom.Header);
+            Assert.Equal("XXXXXX", rom.Inverted);
+            Assert.Equal("XXXXXX", rom.MIA);
+        }
+
+        /// <summary>
+        /// Validate a Disk
+        /// </summary>
+        private static void Validate(Data.Models.ClrMamePro.Disk? disk)
+        {
+            Assert.NotNull(disk);
+            Assert.Equal("XXXXXX", disk.Name);
+            Assert.Equal("XXXXXX", disk.MD5);
+            Assert.Equal("XXXXXX", disk.SHA1);
+            Assert.Equal("XXXXXX", disk.Merge);
+            Assert.Equal("XXXXXX", disk.Status);
+            Assert.Equal("XXXXXX", disk.Flags);
+        }
+
+        /// <summary>
+        /// Validate a Sample
+        /// </summary>
+        private static void Validate(Data.Models.ClrMamePro.Sample? sample)
+        {
+            Assert.NotNull(sample);
+            Assert.Equal("XXXXXX", sample.Name);
+        }
+
+        /// <summary>
+        /// Validate a Archive
+        /// </summary>
+        private static void Validate(Data.Models.ClrMamePro.Archive? archive)
+        {
+            Assert.NotNull(archive);
+            Assert.Equal("XXXXXX", archive.Name);
+        }
+
+        /// <summary>
+        /// Validate a Media
+        /// </summary>
+        private static void Validate(Data.Models.ClrMamePro.Media? media)
+        {
+            Assert.NotNull(media);
+            Assert.Equal("XXXXXX", media.Name);
+            Assert.Equal("XXXXXX", media.MD5);
+            Assert.Equal("XXXXXX", media.SHA1);
+            Assert.Equal("XXXXXX", media.SHA256);
+            Assert.Equal("XXXXXX", media.SpamSum);
+        }
+
+        /// <summary>
+        /// Validate a Chip
+        /// </summary>
+        private static void Validate(Data.Models.ClrMamePro.Chip? chip)
+        {
+            Assert.NotNull(chip);
+            Assert.Equal("XXXXXX", chip.Type);
+            Assert.Equal("XXXXXX", chip.Name);
+            Assert.Equal("XXXXXX", chip.Flags);
+            Assert.Equal("XXXXXX", chip.Clock);
+        }
+
+        /// <summary>
+        /// Validate a Video
+        /// </summary>
+        private static void Validate(Data.Models.ClrMamePro.Video? video)
+        {
+            Assert.NotNull(video);
+            Assert.Equal("XXXXXX", video.Screen);
+            Assert.Equal("XXXXXX", video.Orientation);
+            Assert.Equal("XXXXXX", video.X);
+            Assert.Equal("XXXXXX", video.Y);
+            Assert.Equal("XXXXXX", video.AspectX);
+            Assert.Equal("XXXXXX", video.AspectY);
+            Assert.Equal("XXXXXX", video.Freq);
+        }
+
+        /// <summary>
+        /// Validate a Sound
+        /// </summary>
+        private static void Validate(Data.Models.ClrMamePro.Sound? sound)
+        {
+            Assert.NotNull(sound);
+            Assert.Equal("XXXXXX", sound.Channels);
+        }
+
+        /// <summary>
+        /// Validate a Input
+        /// </summary>
+        private static void Validate(Data.Models.ClrMamePro.Input? input)
+        {
+            Assert.NotNull(input);
+            Assert.Equal("XXXXXX", input.Players);
+            Assert.Equal("XXXXXX", input.Control);
+            Assert.Equal("XXXXXX", input.Buttons);
+            Assert.Equal("XXXXXX", input.Coins);
+            Assert.Equal("XXXXXX", input.Tilt);
+            Assert.Equal("XXXXXX", input.Service);
+        }
+
+        /// <summary>
+        /// Validate a DipSwitch
+        /// </summary>
+        private static void Validate(Data.Models.ClrMamePro.DipSwitch? dipswitch)
+        {
+            Assert.NotNull(dipswitch);
+            Assert.Equal("XXXXXX", dipswitch.Name);
+
+            Assert.NotNull(dipswitch.Entry);
+            string entry = Assert.Single(dipswitch.Entry);
+            Assert.Equal("XXXXXX", entry);
+
+            Assert.Equal("XXXXXX", dipswitch.Default);
+        }
+
+        /// <summary>
+        /// Validate a Driver
+        /// </summary>
+        private static void Validate(Data.Models.ClrMamePro.Driver? driver)
+        {
+            Assert.NotNull(driver);
+            Assert.Equal("XXXXXX", driver.Status);
+            Assert.Equal("XXXXXX", driver.Color);
+            Assert.Equal("XXXXXX", driver.Sound);
+            Assert.Equal("XXXXXX", driver.PaletteSize);
+            Assert.Equal("XXXXXX", driver.Blit);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/CueSheetTests.cs

@@ -0,0 +1,118 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class CueSheetTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new CueSheet();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new CueSheet();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new CueSheet();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new CueSheet();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new CueSheet();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new CueSheet();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        #region ReadQuotedString
+
+        [Fact]
+        public void ReadQuotedString_EmptyReader_Throws()
+        {
+            byte[] data = Encoding.UTF8.GetBytes(string.Empty);
+            var stream = new MemoryStream(data);
+            var reader = new StreamReader(stream, Encoding.UTF8);
+            Assert.Throws<ArgumentNullException>(() => CueSheet.ReadQuotedString(reader));
+        }
+
+        [Fact]
+        public void ReadQuotedString_NoQuotes_Correct()
+        {
+            byte[] data = Encoding.UTF8.GetBytes("Test1 Test2");
+            var stream = new MemoryStream(data);
+            var reader = new StreamReader(stream, Encoding.UTF8);
+            string? actual = CueSheet.ReadQuotedString(reader);
+            Assert.Equal("Test1 Test2", actual);
+        }
+
+        [Fact]
+        public void ReadQuotedString_SingleLineQuotes_Correct()
+        {
+            byte[] data = Encoding.UTF8.GetBytes("\"Test1 Test2\"");
+            var stream = new MemoryStream(data);
+            var reader = new StreamReader(stream, Encoding.UTF8);
+            string? actual = CueSheet.ReadQuotedString(reader);
+            Assert.Equal("\"Test1 Test2\"", actual);
+        }
+
+        [Fact]
+        public void ReadQuotedString_MultiLineQuotes_Correct()
+        {
+            byte[] data = Encoding.UTF8.GetBytes("\"Test1\nTest2\"");
+            var stream = new MemoryStream(data);
+            var reader = new StreamReader(stream, Encoding.UTF8);
+            string? actual = CueSheet.ReadQuotedString(reader);
+            Assert.Equal("\"Test1\nTest2\"", actual);
+        }
+
+        #endregion
+    }
+}

SabreTools.Serialization.Test/Readers/DosCenterTests.cs

@@ -0,0 +1,177 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class DosCenterTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new DosCenter();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new DosCenter();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new DosCenter();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new DosCenter();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new DosCenter();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new DosCenter();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void RoundTripTest()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new DosCenter();
+            var serializer = new SabreTools.Serialization.Writers.DosCenter();
+
+            // Build the data
+            Data.Models.DosCenter.MetadataFile mf = Build();
+
+            // Serialize to stream
+            Stream? actual = serializer.SerializeStream(mf);
+            Assert.NotNull(actual);
+
+            // Serialize back to original model
+            Data.Models.DosCenter.MetadataFile? newMf = deserializer.Deserialize(actual);
+
+            // Validate the data
+            Assert.NotNull(newMf);
+            Validate(newMf.DosCenter);
+            Assert.NotNull(newMf.Game);
+            var newGame = Assert.Single(newMf.Game);
+            Validate(newGame);
+        }
+
+        /// <summary>
+        /// Build model for serialization and deserialization
+        /// </summary>
+        private static Data.Models.DosCenter.MetadataFile Build()
+        {
+            var dc = new Data.Models.DosCenter.DosCenter
+            {
+                Name = "XXXXXX",
+                Description = "XXXXXX",
+                Version = "XXXXXX",
+                Date = "XXXXXX",
+                Author = "XXXXXX",
+                Homepage = "XXXXXX",
+                Comment = "XXXXXX",
+            };
+
+            var file = new Data.Models.DosCenter.File
+            {
+                Name = "XXXXXX",
+                Size = "XXXXXX",
+                CRC = "XXXXXX",
+                SHA1 = "XXXXXX",
+                Date = "XXXXXX XXXXXX",
+            };
+
+            var game = new Data.Models.DosCenter.Game
+            {
+                Name = "XXXXXX",
+                File = [file],
+            };
+
+            return new Data.Models.DosCenter.MetadataFile
+            {
+                DosCenter = dc,
+                Game = [game],
+            };
+        }
+
+        /// <summary>
+        /// Validate a DosCenter
+        /// </summary>
+        private static void Validate(Data.Models.DosCenter.DosCenter? cmp)
+        {
+            Assert.NotNull(cmp);
+            Assert.Equal("XXXXXX", cmp.Name);
+            Assert.Equal("XXXXXX", cmp.Description);
+            Assert.Equal("XXXXXX", cmp.Version);
+            Assert.Equal("XXXXXX", cmp.Date);
+            Assert.Equal("XXXXXX", cmp.Author);
+            Assert.Equal("XXXXXX", cmp.Homepage);
+            Assert.Equal("XXXXXX", cmp.Comment);
+        }
+
+        /// <summary>
+        /// Validate a Game
+        /// </summary>
+        private static void Validate(Data.Models.DosCenter.Game? game)
+        {
+            Assert.NotNull(game);
+            Assert.Equal("XXXXXX", game.Name);
+
+            Assert.NotNull(game.File);
+            var file = Assert.Single(game.File);
+            Validate(file);
+        }
+
+        /// <summary>
+        /// Validate a File
+        /// </summary>
+        private static void Validate(Data.Models.DosCenter.File? rom)
+        {
+            Assert.NotNull(rom);
+            Assert.Equal("XXXXXX", rom.Name);
+            Assert.Equal("XXXXXX", rom.Size);
+            Assert.Equal("XXXXXX", rom.CRC);
+            Assert.Equal("XXXXXX", rom.SHA1);
+            Assert.Equal("XXXXXX XXXXXX", rom.Date);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/EverdriveSMDBTests.cs

@@ -0,0 +1,132 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class EverdriveSMDBTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new EverdriveSMDB();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new EverdriveSMDB();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new EverdriveSMDB();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new EverdriveSMDB();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new EverdriveSMDB();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new EverdriveSMDB();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void RoundTripTest()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new EverdriveSMDB();
+            var serializer = new SabreTools.Serialization.Writers.EverdriveSMDB();
+
+            // Build the data
+            Data.Models.EverdriveSMDB.MetadataFile mf = Build();
+
+            // Serialize to stream
+            Stream? actual = serializer.SerializeStream(mf);
+            Assert.NotNull(actual);
+
+            // Serialize back to original model
+            Data.Models.EverdriveSMDB.MetadataFile? newMf = deserializer.Deserialize(actual);
+
+            // Validate the data
+            Assert.NotNull(newMf);
+            Assert.NotNull(newMf.Row);
+            var newRow = Assert.Single(newMf.Row);
+            Validate(newRow);
+        }
+
+        /// <summary>
+        /// Build model for serialization and deserialization
+        /// </summary>
+        private static Data.Models.EverdriveSMDB.MetadataFile Build()
+        {
+            var row = new Data.Models.EverdriveSMDB.Row
+            {
+                SHA256 = "XXXXXX",
+                Name = "XXXXXX",
+                SHA1 = "XXXXXX",
+                MD5 = "XXXXXX",
+                CRC32 = "XXXXXX",
+                Size = "XXXXXX",
+            };
+
+            return new Data.Models.EverdriveSMDB.MetadataFile
+            {
+                Row = [row],
+            };
+        }
+
+        /// <summary>
+        /// Validate a Row
+        /// </summary>
+        private static void Validate(Data.Models.EverdriveSMDB.Row? row)
+        {
+            Assert.NotNull(row);
+            Assert.Equal("XXXXXX", row.SHA256);
+            Assert.Equal("XXXXXX", row.Name);
+            Assert.Equal("XXXXXX", row.SHA1);
+            Assert.Equal("XXXXXX", row.MD5);
+            Assert.Equal("XXXXXX", row.CRC32);
+            Assert.Equal("XXXXXX", row.Size);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/GCFTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class GCFTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new GCF();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new GCF();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new GCF();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new GCF();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new GCF();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new GCF();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/GZipTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class GZipTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new GZip();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new GZip();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new GZip();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new GZip();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new GZip();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new GZip();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/HashfileTests.cs

@@ -0,0 +1,401 @@
+using System;
+using System.IO;
+using System.Linq;
+using SabreTools.Hashing;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class HashfileTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new Hashfile();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new Hashfile();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new Hashfile();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new Hashfile();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new Hashfile();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new Hashfile();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void RoundTripSFVTest()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new Hashfile();
+            var serializer = new SabreTools.Serialization.Writers.Hashfile();
+
+            // Build the data
+            Data.Models.Hashfile.Hashfile hf = Build(HashType.CRC32);
+
+            // Serialize to stream
+            Stream? actual = serializer.SerializeStream(hf, HashType.CRC32);
+            Assert.NotNull(actual);
+
+            // Serialize back to original model
+            Data.Models.Hashfile.Hashfile? newHf = deserializer.Deserialize(actual, HashType.CRC32);
+
+            // Validate the data
+            Assert.NotNull(newHf);
+            Assert.NotNull(newHf.SFV);
+            var newSfv = Assert.Single(newHf.SFV);
+            Validate(newSfv);
+        }
+
+        [Fact]
+        public void RoundTripMD2Test()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new Hashfile();
+            var serializer = new SabreTools.Serialization.Writers.Hashfile();
+
+            // Build the data
+            Data.Models.Hashfile.Hashfile hf = Build(HashType.MD2);
+
+            // Serialize to stream
+            Stream? actual = serializer.SerializeStream(hf, HashType.MD2);
+            Assert.NotNull(actual);
+
+            // Serialize back to original model
+            Data.Models.Hashfile.Hashfile? newHf = deserializer.Deserialize(actual, HashType.MD2);
+
+            // Validate the data
+            Assert.NotNull(newHf);
+            Assert.NotNull(newHf.MD2);
+            var newMd2 = Assert.Single(newHf.MD2);
+            Validate(newMd2);
+        }
+
+        [Fact]
+        public void RoundTripMD4Test()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new Hashfile();
+            var serializer = new SabreTools.Serialization.Writers.Hashfile();
+
+            // Build the data
+            Data.Models.Hashfile.Hashfile hf = Build(HashType.MD4);
+
+            // Serialize to stream
+            Stream? actual = serializer.SerializeStream(hf, HashType.MD4);
+            Assert.NotNull(actual);
+
+            // Serialize back to original model
+            Data.Models.Hashfile.Hashfile? newHf = deserializer.Deserialize(actual, HashType.MD4);
+
+            // Validate the data
+            Assert.NotNull(newHf);
+            Assert.NotNull(newHf.MD4);
+            var newMd4 = Assert.Single(newHf.MD4);
+            Validate(newMd4);
+        }
+
+        [Fact]
+        public void RoundTripMD5Test()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new Hashfile();
+            var serializer = new SabreTools.Serialization.Writers.Hashfile();
+
+            // Build the data
+            Data.Models.Hashfile.Hashfile hf = Build(HashType.MD5);
+
+            // Serialize to stream
+            Stream? actual = serializer.SerializeStream(hf, HashType.MD5);
+            Assert.NotNull(actual);
+
+            // Serialize back to original model
+            Data.Models.Hashfile.Hashfile? newHf = deserializer.Deserialize(actual, HashType.MD5);
+
+            // Validate the data
+            Assert.NotNull(newHf);
+            Assert.NotNull(newHf.MD5);
+            var newMd5 = Assert.Single(newHf.MD5);
+            Validate(newMd5);
+        }
+
+        [Fact]
+        public void RoundTripSHA1Test()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new Hashfile();
+            var serializer = new SabreTools.Serialization.Writers.Hashfile();
+
+            // Build the data
+            Data.Models.Hashfile.Hashfile hf = Build(HashType.SHA1);
+
+            // Serialize to stream
+            Stream? actual = serializer.SerializeStream(hf, HashType.SHA1);
+            Assert.NotNull(actual);
+
+            // Serialize back to original model
+            Data.Models.Hashfile.Hashfile? newHf = deserializer.Deserialize(actual, HashType.SHA1);
+
+            // Validate the data
+            Assert.NotNull(newHf);
+            Assert.NotNull(newHf.SHA1);
+            var newSha1 = Assert.Single(newHf.SHA1);
+            Validate(newSha1);
+        }
+
+        [Fact]
+        public void RoundTripSHA256Test()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new Hashfile();
+            var serializer = new SabreTools.Serialization.Writers.Hashfile();
+
+            // Build the data
+            Data.Models.Hashfile.Hashfile hf = Build(HashType.SHA256);
+
+            // Serialize to stream
+            Stream? actual = serializer.SerializeStream(hf, HashType.SHA256);
+            Assert.NotNull(actual);
+
+            // Serialize back to original model
+            Data.Models.Hashfile.Hashfile? newHf = deserializer.Deserialize(actual, HashType.SHA256);
+
+            // Validate the data
+            Assert.NotNull(newHf);
+            Assert.NotNull(newHf.SHA256);
+            var newSha256 = Assert.Single(newHf.SHA256);
+            Validate(newSha256);
+        }
+
+        [Fact]
+        public void RoundTripSHA384Test()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new Hashfile();
+            var serializer = new SabreTools.Serialization.Writers.Hashfile();
+
+            // Build the data
+            Data.Models.Hashfile.Hashfile hf = Build(HashType.SHA384);
+
+            // Serialize to stream
+            Stream? actual = serializer.SerializeStream(hf, HashType.SHA384);
+            Assert.NotNull(actual);
+
+            // Serialize back to original model
+            Data.Models.Hashfile.Hashfile? newHf = deserializer.Deserialize(actual, HashType.SHA384);
+
+            // Validate the data
+            Assert.NotNull(newHf);
+            Assert.NotNull(newHf.SHA384);
+            var newSha384 = Assert.Single(newHf.SHA384);
+            Validate(newSha384);
+        }
+
+        [Fact]
+        public void RoundTripSHA512Test()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new Hashfile();
+            var serializer = new SabreTools.Serialization.Writers.Hashfile();
+
+            // Build the data
+            Data.Models.Hashfile.Hashfile hf = Build(HashType.SHA512);
+
+            // Serialize to stream
+            Stream? actual = serializer.SerializeStream(hf, HashType.SHA512);
+            Assert.NotNull(actual);
+
+            // Serialize back to original model
+            Data.Models.Hashfile.Hashfile? newHf = deserializer.Deserialize(actual, HashType.SHA512);
+
+            // Validate the data
+            Assert.NotNull(newHf);
+            Assert.NotNull(newHf.SHA512);
+            var newSha512 = Assert.Single(newHf.SHA512);
+            Validate(newSha512);
+        }
+
+        [Fact]
+        public void RoundTripSpamSumTest()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new Hashfile();
+            var serializer = new SabreTools.Serialization.Writers.Hashfile();
+
+            // Build the data
+            Data.Models.Hashfile.Hashfile hf = Build(HashType.SpamSum);
+
+            // Serialize to stream
+            Stream? actual = serializer.SerializeStream(hf, HashType.SpamSum);
+            Assert.NotNull(actual);
+
+            // Serialize back to original model
+            Data.Models.Hashfile.Hashfile? newHf = deserializer.Deserialize(actual, HashType.SpamSum);
+
+            // Validate the data
+            Assert.NotNull(newHf);
+            Assert.NotNull(newHf.SpamSum);
+            var newSpamsum = Assert.Single(newHf.SpamSum);
+            Validate(newSpamsum);
+        }
+
+        /// <summary>
+        /// Build model for serialization and deserialization
+        /// </summary>
+        private static Data.Models.Hashfile.Hashfile Build(HashType hashType)
+        {
+            return hashType switch
+            {
+                HashType.CRC32 => new Data.Models.Hashfile.Hashfile { SFV = [new Data.Models.Hashfile.SFV { File = "XXXXXX", Hash = "XXXXXX" }] },
+                HashType.MD2 => new Data.Models.Hashfile.Hashfile { MD2 = [new Data.Models.Hashfile.MD2 { Hash = "XXXXXX", File = "XXXXXX" }] },
+                HashType.MD4 => new Data.Models.Hashfile.Hashfile { MD4 = [new Data.Models.Hashfile.MD4 { Hash = "XXXXXX", File = "XXXXXX" }] },
+                HashType.MD5 => new Data.Models.Hashfile.Hashfile { MD5 = [new Data.Models.Hashfile.MD5 { Hash = "XXXXXX", File = "XXXXXX" }] },
+                HashType.SHA1 => new Data.Models.Hashfile.Hashfile { SHA1 = [new Data.Models.Hashfile.SHA1 { Hash = "XXXXXX", File = "XXXXXX" }] },
+                HashType.SHA256 => new Data.Models.Hashfile.Hashfile { SHA256 = [new Data.Models.Hashfile.SHA256 { Hash = "XXXXXX", File = "XXXXXX" }] },
+                HashType.SHA384 => new Data.Models.Hashfile.Hashfile { SHA384 = [new Data.Models.Hashfile.SHA384 { Hash = "XXXXXX", File = "XXXXXX" }] },
+                HashType.SHA512 => new Data.Models.Hashfile.Hashfile { SHA512 = [new Data.Models.Hashfile.SHA512 { Hash = "XXXXXX", File = "XXXXXX" }] },
+                HashType.SpamSum => new Data.Models.Hashfile.Hashfile { SpamSum = [new Data.Models.Hashfile.SpamSum { Hash = "XXXXXX", File = "XXXXXX" }] },
+                _ => throw new ArgumentOutOfRangeException(),
+            };
+        }
+
+        /// <summary>
+        /// Validate a SFV
+        /// </summary>
+        private static void Validate(Data.Models.Hashfile.SFV? sfv)
+        {
+            Assert.NotNull(sfv);
+            Assert.Equal("XXXXXX", sfv.File);
+            Assert.Equal("XXXXXX", sfv.Hash);
+        }
+
+        /// <summary>
+        /// Validate a MD2
+        /// </summary>
+        private static void Validate(Data.Models.Hashfile.MD2? md2)
+        {
+            Assert.NotNull(md2);
+            Assert.Equal("XXXXXX", md2.Hash);
+            Assert.Equal("XXXXXX", md2.File);
+        }
+
+        /// <summary>
+        /// Validate a MD4
+        /// </summary>
+        private static void Validate(Data.Models.Hashfile.MD4? md4)
+        {
+            Assert.NotNull(md4);
+            Assert.Equal("XXXXXX", md4.Hash);
+            Assert.Equal("XXXXXX", md4.File);
+        }
+
+        /// <summary>
+        /// Validate a MD5
+        /// </summary>
+        private static void Validate(Data.Models.Hashfile.MD5? md5)
+        {
+            Assert.NotNull(md5);
+            Assert.Equal("XXXXXX", md5.Hash);
+            Assert.Equal("XXXXXX", md5.File);
+        }
+
+        /// <summary>
+        /// Validate a SHA1
+        /// </summary>
+        private static void Validate(Data.Models.Hashfile.SHA1? sha1)
+        {
+            Assert.NotNull(sha1);
+            Assert.Equal("XXXXXX", sha1.Hash);
+            Assert.Equal("XXXXXX", sha1.File);
+        }
+
+        /// <summary>
+        /// Validate a SHA256
+        /// </summary>
+        private static void Validate(Data.Models.Hashfile.SHA256? sha256)
+        {
+            Assert.NotNull(sha256);
+            Assert.Equal("XXXXXX", sha256.Hash);
+            Assert.Equal("XXXXXX", sha256.File);
+        }
+
+        /// <summary>
+        /// Validate a SHA384
+        /// </summary>
+        private static void Validate(Data.Models.Hashfile.SHA384? sha384)
+        {
+            Assert.NotNull(sha384);
+            Assert.Equal("XXXXXX", sha384.Hash);
+            Assert.Equal("XXXXXX", sha384.File);
+        }
+
+        /// <summary>
+        /// Validate a SHA512
+        /// </summary>
+        private static void Validate(Data.Models.Hashfile.SHA512? sha512)
+        {
+            Assert.NotNull(sha512);
+            Assert.Equal("XXXXXX", sha512.Hash);
+            Assert.Equal("XXXXXX", sha512.File);
+        }
+
+        /// <summary>
+        /// Validate a SpamSum
+        /// </summary>
+        private static void Validate(Data.Models.Hashfile.SpamSum? spamsum)
+        {
+            Assert.NotNull(spamsum);
+            Assert.Equal("XXXXXX", spamsum.Hash);
+            Assert.Equal("XXXXXX", spamsum.File);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/IRDTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class IRDTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new IRD();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new IRD();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new IRD();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new IRD();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new IRD();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new IRD();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/ISO9660Tests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class ISO9660Tests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new ISO9660();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new ISO9660();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new ISO9660();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new ISO9660();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new ISO9660();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new ISO9660();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/InstallShieldArchiveV3Tests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class InstallShieldArchiveV3Tests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new InstallShieldArchiveV3();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new InstallShieldArchiveV3();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new InstallShieldArchiveV3();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new InstallShieldArchiveV3();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new InstallShieldArchiveV3();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new InstallShieldArchiveV3();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/InstallShieldCabinetTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class InstallShieldCabinetTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new InstallShieldCabinet();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new InstallShieldCabinet();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new InstallShieldCabinet();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new InstallShieldCabinet();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new InstallShieldCabinet();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new InstallShieldCabinet();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/InstallShieldExecutableFileTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class InstallShieldExecutableFileTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new InstallShieldExecutableFile();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new InstallShieldExecutableFile();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new InstallShieldExecutableFile();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new InstallShieldExecutableFile();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new InstallShieldExecutableFile();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new InstallShieldExecutableFile();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/LZKWAJTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class LZKWAJTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new LZKWAJ();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new LZKWAJ();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new LZKWAJ();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new LZKWAJ();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new LZKWAJ();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new LZKWAJ();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/LZQBasicTests.cs

@@ -0,0 +1,74 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class LZQBasicTests
+
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new LZQBasic();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new LZQBasic();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new LZQBasic();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new LZQBasic();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new LZQBasic();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new LZQBasic();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/LZSZDDTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class LZSZDDTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new LZSZDD();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new LZSZDD();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new LZSZDD();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new LZSZDD();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new LZSZDD();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new LZSZDD();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/LinearExecutableTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class LinearExecutableTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new LinearExecutable();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new LinearExecutable();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new LinearExecutable();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new LinearExecutable();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new LinearExecutable();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new LinearExecutable();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/ListromTests.cs

@@ -0,0 +1,267 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class ListromTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new Listrom();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new Listrom();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new Listrom();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new Listrom();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new Listrom();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new Listrom();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void RoundTripTest()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new Listrom();
+            var serializer = new SabreTools.Serialization.Writers.Listrom();
+
+            // Build the data
+            Data.Models.Listrom.MetadataFile mf = Build();
+
+            // Serialize to stream
+            Stream? actual = serializer.SerializeStream(mf);
+            Assert.NotNull(actual);
+
+            // Serialize back to original model
+            Data.Models.Listrom.MetadataFile? newMf = deserializer.Deserialize(actual);
+
+            // Validate the data
+            Assert.NotNull(newMf);
+            Assert.NotNull(newMf.Set);
+            Assert.Equal(2, newMf.Set.Length);
+
+            ValidateDevice(newMf.Set[0]);
+            ValidateDriver(newMf.Set[1]);
+        }
+
+        /// <summary>
+        /// Build model for serialization and deserialization
+        /// </summary>
+        private static Data.Models.Listrom.MetadataFile Build()
+        {
+            var romGood = new Data.Models.Listrom.Row
+            {
+                Name = "XXXXXX",
+                Size = "12345",
+                Bad = false,
+                CRC = Hashing.ZeroHash.CRC32Str,
+                SHA1 = Hashing.ZeroHash.SHA1Str,
+                NoGoodDumpKnown = false,
+            };
+
+            var romBad = new Data.Models.Listrom.Row
+            {
+                Name = "XXXXXX",
+                Size = "12345",
+                Bad = true,
+                CRC = Hashing.ZeroHash.CRC32Str,
+                SHA1 = Hashing.ZeroHash.SHA1Str,
+                NoGoodDumpKnown = false,
+            };
+
+            var diskGoodMd5 = new Data.Models.Listrom.Row
+            {
+                Name = "XXXXXX",
+                Bad = false,
+                MD5 = Hashing.ZeroHash.MD5Str,
+                SHA1 = null,
+                NoGoodDumpKnown = false,
+            };
+
+            var diskGoodSha1 = new Data.Models.Listrom.Row
+            {
+                Name = "XXXXXX",
+                Bad = false,
+                MD5 = null,
+                SHA1 = Hashing.ZeroHash.SHA1Str,
+                NoGoodDumpKnown = false,
+            };
+
+            var diskBad = new Data.Models.Listrom.Row
+            {
+                Name = "XXXXXX",
+                Bad = false,
+                MD5 = Hashing.ZeroHash.MD5Str,
+                SHA1 = Hashing.ZeroHash.SHA1Str,
+                NoGoodDumpKnown = true,
+            };
+
+            var device = new Data.Models.Listrom.Set()
+            {
+                Device = "XXXXXX",
+                Row = [romGood, romBad],
+            };
+
+            var driver = new Data.Models.Listrom.Set()
+            {
+                Driver = "XXXXXX",
+                Row = [diskGoodMd5, diskGoodSha1, diskBad],
+            };
+
+            return new Data.Models.Listrom.MetadataFile
+            {
+                Set = [device, driver],
+            };
+        }
+
+        /// <summary>
+        /// Validate a Set
+        /// </summary>
+        private static void ValidateDevice(Data.Models.Listrom.Set? set)
+        {
+            Assert.NotNull(set);
+            Assert.Equal("XXXXXX", set.Device);
+
+            Assert.NotNull(set.Row);
+            Assert.Equal(2, set.Row.Length);
+
+            ValidateGoodRom(set.Row[0]);
+            ValidateBadRom(set.Row[1]);
+        }
+
+        /// <summary>
+        /// Validate a Set
+        /// </summary>
+        private static void ValidateDriver(Data.Models.Listrom.Set? set)
+        {
+            Assert.NotNull(set);
+            Assert.Equal("XXXXXX", set.Driver);
+
+            Assert.NotNull(set.Row);
+            Assert.Equal(3, set.Row.Length);
+
+            ValidateGoodMd5Disk(set.Row[0]);
+            ValidateGoodSha1Disk(set.Row[1]);
+            ValidateBadDisk(set.Row[2]);
+        }
+
+        /// <summary>
+        /// Validate a Row
+        /// </summary>
+        private static void ValidateGoodRom(Data.Models.Listrom.Row? row)
+        {
+            Assert.NotNull(row);
+            Assert.Equal("XXXXXX", row.Name);
+            Assert.Equal("12345", row.Size);
+            Assert.False(row.Bad);
+            Assert.Equal(Hashing.ZeroHash.CRC32Str, row.CRC);
+            Assert.Equal(Hashing.ZeroHash.SHA1Str, row.SHA1);
+            Assert.False(row.NoGoodDumpKnown);
+        }
+
+        /// <summary>
+        /// Validate a Row
+        /// </summary>
+        private static void ValidateBadRom(Data.Models.Listrom.Row? row)
+        {
+            Assert.NotNull(row);
+            Assert.Equal("XXXXXX", row.Name);
+            Assert.Equal("12345", row.Size);
+            Assert.True(row.Bad);
+            Assert.Equal(Hashing.ZeroHash.CRC32Str, row.CRC);
+            Assert.Equal(Hashing.ZeroHash.SHA1Str, row.SHA1);
+            Assert.False(row.NoGoodDumpKnown);
+        }
+
+        /// <summary>
+        /// Validate a Row
+        /// </summary>
+        private static void ValidateGoodMd5Disk(Data.Models.Listrom.Row? row)
+        {
+            Assert.NotNull(row);
+            Assert.Equal("XXXXXX", row.Name);
+            Assert.False(row.Bad);
+            Assert.Equal(Hashing.ZeroHash.MD5Str, row.MD5);
+            Assert.Null(row.SHA1);
+            Assert.False(row.NoGoodDumpKnown);
+        }
+
+        /// <summary>
+        /// Validate a Row
+        /// </summary>
+        private static void ValidateGoodSha1Disk(Data.Models.Listrom.Row? row)
+        {
+            Assert.NotNull(row);
+            Assert.Equal("XXXXXX", row.Name);
+            Assert.False(row.Bad);
+            Assert.Null(row.MD5);
+            Assert.Equal(Hashing.ZeroHash.SHA1Str, row.SHA1);
+            Assert.False(row.NoGoodDumpKnown);
+        }
+
+        /// <summary>
+        /// Validate a Row
+        /// </summary>
+        private static void ValidateBadDisk(Data.Models.Listrom.Row? row)
+        {
+            Assert.NotNull(row);
+            Assert.Equal("XXXXXX", row.Name);
+            Assert.False(row.Bad);
+            Assert.Null(row.MD5);
+            Assert.Null(row.SHA1);
+            Assert.True(row.NoGoodDumpKnown);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/ListxmlTests.cs

@@ -0,0 +1,946 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class ListxmlTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new Listxml();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new Listxml();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new Listxml();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new Listxml();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new Listxml();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new Listxml();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void RoundTripGameTest()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new Listxml();
+            var serializer = new SabreTools.Serialization.Writers.Listxml();
+
+            // Build the data
+            Data.Models.Listxml.Mame mame = Build(game: true);
+
+            // Serialize to stream
+            Stream? actual = serializer.Serialize(mame);
+            Assert.NotNull(actual);
+
+            // Serialize back to original model
+            Data.Models.Listxml.Mame? newMame = deserializer.Deserialize(actual);
+
+            // Validate the data
+            Assert.NotNull(newMame);
+            Assert.Equal("XXXXXX", newMame.Build);
+            Assert.Equal("XXXXXX", newMame.Debug);
+            Assert.Equal("XXXXXX", newMame.MameConfig);
+
+            Assert.NotNull(newMame.Game);
+            var newGame = Assert.Single(newMame.Game);
+            Validate(newGame);
+        }
+
+        [Fact]
+        public void RoundTripMachineTest()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new Listxml();
+            var serializer = new SabreTools.Serialization.Writers.Listxml();
+
+            // Build the data
+            Data.Models.Listxml.Mame mame = Build(game: false);
+
+            // Serialize to stream
+            Stream? actual = serializer.Serialize(mame);
+            Assert.NotNull(actual);
+
+            // Serialize back to original model
+            Data.Models.Listxml.Mame? newMame = deserializer.Deserialize(actual);
+
+            // Validate the data
+            Assert.NotNull(newMame);
+            Assert.Equal("XXXXXX", newMame.Build);
+            Assert.Equal("XXXXXX", newMame.Debug);
+            Assert.Equal("XXXXXX", newMame.MameConfig);
+
+            Assert.NotNull(newMame.Game);
+            var newGame = Assert.Single(newMame.Game);
+            Validate(newGame);
+        }
+
+        /// <summary>
+        /// Build model for serialization and deserialization
+        /// </summary>
+        private static Data.Models.Listxml.Mame Build(bool game)
+        {
+            var biosset = new Data.Models.Listxml.BiosSet
+            {
+                Name = "XXXXXX",
+                Description = "XXXXXX",
+                Default = "XXXXXX",
+            };
+
+            var rom = new Data.Models.Listxml.Rom
+            {
+                Name = "XXXXXX",
+                Bios = "XXXXXX",
+                Size = "XXXXXX",
+                CRC = "XXXXXX",
+                SHA1 = "XXXXXX",
+                Merge = "XXXXXX",
+                Region = "XXXXXX",
+                Offset = "XXXXXX",
+                Status = "XXXXXX",
+                Optional = "XXXXXX",
+                Dispose = "XXXXXX",
+                SoundOnly = "XXXXXX",
+            };
+
+            var disk = new Data.Models.Listxml.Disk
+            {
+                Name = "XXXXXX",
+                MD5 = "XXXXXX",
+                SHA1 = "XXXXXX",
+                Merge = "XXXXXX",
+                Region = "XXXXXX",
+                Index = "XXXXXX",
+                Writable = "XXXXXX",
+                Status = "XXXXXX",
+                Optional = "XXXXXX",
+            };
+
+            var deviceref = new Data.Models.Listxml.DeviceRef
+            {
+                Name = "XXXXXX",
+            };
+
+            var sample = new Data.Models.Listxml.Sample
+            {
+                Name = "XXXXXX",
+            };
+
+            var chip = new Data.Models.Listxml.Chip
+            {
+                Name = "XXXXXX",
+                Tag = "XXXXXX",
+                Type = "XXXXXX",
+                SoundOnly = "XXXXXX",
+                Clock = "XXXXXX",
+            };
+
+            var display = new Data.Models.Listxml.Display
+            {
+                Tag = "XXXXXX",
+                Type = "XXXXXX",
+                Rotate = "XXXXXX",
+                FlipX = "XXXXXX",
+                Width = "XXXXXX",
+                Height = "XXXXXX",
+                Refresh = "XXXXXX",
+                PixClock = "XXXXXX",
+                HTotal = "XXXXXX",
+                HBEnd = "XXXXXX",
+                HBStart = "XXXXXX",
+                VTotal = "XXXXXX",
+                VBEnd = "XXXXXX",
+                VBStart = "XXXXXX",
+            };
+
+            var video = new Data.Models.Listxml.Video
+            {
+                Screen = "XXXXXX",
+                Orientation = "XXXXXX",
+                Width = "XXXXXX",
+                Height = "XXXXXX",
+                AspectX = "XXXXXX",
+                AspectY = "XXXXXX",
+                Refresh = "XXXXXX",
+            };
+
+            var sound = new Data.Models.Listxml.Sound
+            {
+                Channels = "XXXXXX",
+            };
+
+            var control = new Data.Models.Listxml.Control
+            {
+                Type = "XXXXXX",
+                Player = "XXXXXX",
+                Buttons = "XXXXXX",
+                ReqButtons = "XXXXXX",
+                Minimum = "XXXXXX",
+                Maximum = "XXXXXX",
+                Sensitivity = "XXXXXX",
+                KeyDelta = "XXXXXX",
+                Reverse = "XXXXXX",
+                Ways = "XXXXXX",
+                Ways2 = "XXXXXX",
+                Ways3 = "XXXXXX",
+            };
+
+            var input = new Data.Models.Listxml.Input
+            {
+                Service = "XXXXXX",
+                Tilt = "XXXXXX",
+                Players = "XXXXXX",
+                //ControlAttr = "XXXXXX", // Mututally exclusive with input.Control
+                Buttons = "XXXXXX",
+                Coins = "XXXXXX",
+                Control = [control],
+            };
+
+            var condition = new Data.Models.Listxml.Condition
+            {
+                Tag = "XXXXXX",
+                Mask = "XXXXXX",
+                Relation = "XXXXXX",
+                Value = "XXXXXX",
+            };
+
+            var diplocation = new Data.Models.Listxml.DipLocation
+            {
+                Name = "XXXXXX",
+                Number = "XXXXXX",
+                Inverted = "XXXXXX",
+            };
+
+            var dipvalue = new Data.Models.Listxml.DipValue
+            {
+                Name = "XXXXXX",
+                Value = "XXXXXX",
+                Default = "XXXXXX",
+                Condition = condition,
+            };
+
+            var dipswitch = new Data.Models.Listxml.DipSwitch
+            {
+                Name = "XXXXXX",
+                Tag = "XXXXXX",
+                Mask = "XXXXXX",
+                Condition = condition,
+                DipLocation = [diplocation],
+                DipValue = [dipvalue],
+            };
+
+            var conflocation = new Data.Models.Listxml.ConfLocation
+            {
+                Name = "XXXXXX",
+                Number = "XXXXXX",
+                Inverted = "XXXXXX",
+            };
+
+            var confsetting = new Data.Models.Listxml.ConfSetting
+            {
+                Name = "XXXXXX",
+                Value = "XXXXXX",
+                Default = "XXXXXX",
+                Condition = condition,
+            };
+
+            var configuration = new Data.Models.Listxml.Configuration
+            {
+                Name = "XXXXXX",
+                Tag = "XXXXXX",
+                Mask = "XXXXXX",
+                Condition = condition,
+                ConfLocation = [conflocation],
+                ConfSetting = [confsetting],
+            };
+
+            var analog = new Data.Models.Listxml.Analog
+            {
+                Mask = "XXXXXX",
+            };
+
+            var port = new Data.Models.Listxml.Port
+            {
+                Tag = "XXXXXX",
+                Analog = [analog],
+            };
+
+            var adjuster = new Data.Models.Listxml.Adjuster
+            {
+                Name = "XXXXXX",
+                Default = "XXXXXX",
+                Condition = condition,
+            };
+
+            var driver = new Data.Models.Listxml.Driver
+            {
+                Status = "XXXXXX",
+                Color = "XXXXXX",
+                Sound = "XXXXXX",
+                PaletteSize = "XXXXXX",
+                Emulation = "XXXXXX",
+                Cocktail = "XXXXXX",
+                SaveState = "XXXXXX",
+                RequiresArtwork = "XXXXXX",
+                Unofficial = "XXXXXX",
+                NoSoundHardware = "XXXXXX",
+                Incomplete = "XXXXXX",
+            };
+
+            var feature = new Data.Models.Listxml.Feature
+            {
+                Type = "XXXXXX",
+                Status = "XXXXXX",
+                Overall = "XXXXXX",
+            };
+
+            var instance = new Data.Models.Listxml.Instance
+            {
+                Name = "XXXXXX",
+                BriefName = "XXXXXX",
+            };
+
+            var extension = new Data.Models.Listxml.Extension
+            {
+                Name = "XXXXXX",
+            };
+
+            var device = new Data.Models.Listxml.Device
+            {
+                Type = "XXXXXX",
+                Tag = "XXXXXX",
+                FixedImage = "XXXXXX",
+                Mandatory = "XXXXXX",
+                Interface = "XXXXXX",
+                Instance = instance,
+                Extension = [extension],
+            };
+
+            var slotOption = new Data.Models.Listxml.SlotOption
+            {
+                Name = "XXXXXX",
+                DevName = "XXXXXX",
+                Default = "XXXXXX",
+            };
+
+            var slot = new Data.Models.Listxml.Slot
+            {
+                Name = "XXXXXX",
+                SlotOption = [slotOption],
+            };
+
+            var softwarelist = new Data.Models.Listxml.SoftwareList
+            {
+                Tag = "XXXXXX",
+                Name = "XXXXXX",
+                Status = "XXXXXX",
+                Filter = "XXXXXX",
+            };
+
+            var ramoption = new Data.Models.Listxml.RamOption
+            {
+                Name = "XXXXXX",
+                Default = "XXXXXX",
+                Content = "XXXXXX",
+            };
+
+            Data.Models.Listxml.GameBase gameBase = game
+                ? new Data.Models.Listxml.Game()
+                : new Data.Models.Listxml.Machine();
+            gameBase.Name = "XXXXXX";
+            gameBase.SourceFile = "XXXXXX";
+            gameBase.IsBios = "XXXXXX";
+            gameBase.IsDevice = "XXXXXX";
+            gameBase.IsMechanical = "XXXXXX";
+            gameBase.Runnable = "XXXXXX";
+            gameBase.CloneOf = "XXXXXX";
+            gameBase.RomOf = "XXXXXX";
+            gameBase.SampleOf = "XXXXXX";
+            gameBase.Description = "XXXXXX";
+            gameBase.Year = "XXXXXX";
+            gameBase.Manufacturer = "XXXXXX";
+            gameBase.History = "XXXXXX";
+            gameBase.BiosSet = [biosset];
+            gameBase.Rom = [rom];
+            gameBase.Disk = [disk];
+            gameBase.DeviceRef = [deviceref];
+            gameBase.Sample = [sample];
+            gameBase.Chip = [chip];
+            gameBase.Display = [display];
+            gameBase.Video = [video];
+            gameBase.Sound = sound;
+            gameBase.Input = input;
+            gameBase.DipSwitch = [dipswitch];
+            gameBase.Configuration = [configuration];
+            gameBase.Port = [port];
+            gameBase.Adjuster = [adjuster];
+            gameBase.Driver = driver;
+            gameBase.Feature = [feature];
+            gameBase.Device = [device];
+            gameBase.Slot = [slot];
+            gameBase.SoftwareList = [softwarelist];
+            gameBase.RamOption = [ramoption];
+
+            return new Data.Models.Listxml.Mame
+            {
+                Build = "XXXXXX",
+                Debug = "XXXXXX",
+                MameConfig = "XXXXXX",
+                Game = [gameBase],
+            };
+        }
+
+        /// <summary>
+        /// Validate a GameBase
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.GameBase? gb)
+        {
+            Assert.NotNull(gb);
+            Assert.Equal("XXXXXX", gb.Name);
+            Assert.Equal("XXXXXX", gb.SourceFile);
+            Assert.Equal("XXXXXX", gb.IsBios);
+            Assert.Equal("XXXXXX", gb.IsDevice);
+            Assert.Equal("XXXXXX", gb.IsMechanical);
+            Assert.Equal("XXXXXX", gb.Runnable);
+            Assert.Equal("XXXXXX", gb.CloneOf);
+            Assert.Equal("XXXXXX", gb.RomOf);
+            Assert.Equal("XXXXXX", gb.SampleOf);
+            Assert.Equal("XXXXXX", gb.Description);
+            Assert.Equal("XXXXXX", gb.Year);
+            Assert.Equal("XXXXXX", gb.Manufacturer);
+            Assert.Equal("XXXXXX", gb.History);
+
+            Assert.NotNull(gb.BiosSet);
+            var biosset = Assert.Single(gb.BiosSet);
+            Validate(biosset);
+
+            Assert.NotNull(gb.Rom);
+            var rom = Assert.Single(gb.Rom);
+            Validate(rom);
+
+            Assert.NotNull(gb.Disk);
+            var disk = Assert.Single(gb.Disk);
+            Validate(disk);
+
+            Assert.NotNull(gb.DeviceRef);
+            var deviceref = Assert.Single(gb.DeviceRef);
+            Validate(deviceref);
+
+            Assert.NotNull(gb.Sample);
+            var sample = Assert.Single(gb.Sample);
+            Validate(sample);
+
+            Assert.NotNull(gb.Chip);
+            var chip = Assert.Single(gb.Chip);
+            Validate(chip);
+
+            Assert.NotNull(gb.Display);
+            var display = Assert.Single(gb.Display);
+            Validate(display);
+
+            Assert.NotNull(gb.Video);
+            var video = Assert.Single(gb.Video);
+            Validate(video);
+
+            Validate(gb.Sound);
+            Validate(gb.Input);
+
+            Assert.NotNull(gb.DipSwitch);
+            var dipswitch = Assert.Single(gb.DipSwitch);
+            Validate(dipswitch);
+
+            Assert.NotNull(gb.Configuration);
+            var configuration = Assert.Single(gb.Configuration);
+            Validate(configuration);
+
+            Assert.NotNull(gb.Port);
+            var port = Assert.Single(gb.Port);
+            Validate(port);
+
+            Assert.NotNull(gb.Adjuster);
+            var adjuster = Assert.Single(gb.Adjuster);
+            Validate(adjuster);
+
+            Validate(gb.Driver);
+
+            Assert.NotNull(gb.Feature);
+            var feature = Assert.Single(gb.Feature);
+            Validate(feature);
+
+            Assert.NotNull(gb.Device);
+            var device = Assert.Single(gb.Device);
+            Validate(device);
+
+            Assert.NotNull(gb.Slot);
+            var slot = Assert.Single(gb.Slot);
+            Validate(slot);
+
+            Assert.NotNull(gb.SoftwareList);
+            var softwarelist = Assert.Single(gb.SoftwareList);
+            Validate(softwarelist);
+
+            Assert.NotNull(gb.RamOption);
+            var ramoption = Assert.Single(gb.RamOption);
+            Validate(ramoption);
+        }
+
+        /// <summary>
+        /// Validate a BiosSet
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.BiosSet? biosset)
+        {
+            Assert.NotNull(biosset);
+            Assert.Equal("XXXXXX", biosset.Name);
+            Assert.Equal("XXXXXX", biosset.Description);
+            Assert.Equal("XXXXXX", biosset.Default);
+        }
+
+        /// <summary>
+        /// Validate a Rom
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Rom? rom)
+        {
+            Assert.NotNull(rom);
+            Assert.Equal("XXXXXX", rom.Name);
+            Assert.Equal("XXXXXX", rom.Bios);
+            Assert.Equal("XXXXXX", rom.Size);
+            Assert.Equal("XXXXXX", rom.CRC);
+            Assert.Equal("XXXXXX", rom.SHA1);
+            Assert.Equal("XXXXXX", rom.Merge);
+            Assert.Equal("XXXXXX", rom.Region);
+            Assert.Equal("XXXXXX", rom.Offset);
+            Assert.Equal("XXXXXX", rom.Status);
+            Assert.Equal("XXXXXX", rom.Optional);
+            Assert.Equal("XXXXXX", rom.Dispose);
+            Assert.Equal("XXXXXX", rom.SoundOnly);
+        }
+
+        /// <summary>
+        /// Validate a Disk
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Disk? disk)
+        {
+            Assert.NotNull(disk);
+            Assert.Equal("XXXXXX", disk.Name);
+            Assert.Equal("XXXXXX", disk.MD5);
+            Assert.Equal("XXXXXX", disk.SHA1);
+            Assert.Equal("XXXXXX", disk.Merge);
+            Assert.Equal("XXXXXX", disk.Region);
+            Assert.Equal("XXXXXX", disk.Index);
+            Assert.Equal("XXXXXX", disk.Writable);
+            Assert.Equal("XXXXXX", disk.Status);
+            Assert.Equal("XXXXXX", disk.Optional);
+        }
+
+        /// <summary>
+        /// Validate a DeviceRef
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.DeviceRef? deviceref)
+        {
+            Assert.NotNull(deviceref);
+            Assert.Equal("XXXXXX", deviceref.Name);
+        }
+
+        /// <summary>
+        /// Validate a Sample
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Sample? sample)
+        {
+            Assert.NotNull(sample);
+            Assert.Equal("XXXXXX", sample.Name);
+        }
+
+        /// <summary>
+        /// Validate a Chip
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Chip? chip)
+        {
+            Assert.NotNull(chip);
+            Assert.Equal("XXXXXX", chip.Name);
+            Assert.Equal("XXXXXX", chip.Tag);
+            Assert.Equal("XXXXXX", chip.Type);
+            Assert.Equal("XXXXXX", chip.SoundOnly);
+            Assert.Equal("XXXXXX", chip.Clock);
+        }
+
+        /// <summary>
+        /// Validate a Display
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Display? display)
+        {
+            Assert.NotNull(display);
+            Assert.Equal("XXXXXX", display.Tag);
+            Assert.Equal("XXXXXX", display.Type);
+            Assert.Equal("XXXXXX", display.Rotate);
+            Assert.Equal("XXXXXX", display.FlipX);
+            Assert.Equal("XXXXXX", display.Width);
+            Assert.Equal("XXXXXX", display.Height);
+            Assert.Equal("XXXXXX", display.Refresh);
+            Assert.Equal("XXXXXX", display.PixClock);
+            Assert.Equal("XXXXXX", display.HTotal);
+            Assert.Equal("XXXXXX", display.HBEnd);
+            Assert.Equal("XXXXXX", display.HBStart);
+            Assert.Equal("XXXXXX", display.VTotal);
+            Assert.Equal("XXXXXX", display.VBEnd);
+            Assert.Equal("XXXXXX", display.VBStart);
+        }
+
+        /// <summary>
+        /// Validate a Video
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Video? video)
+        {
+            Assert.NotNull(video);
+            Assert.Equal("XXXXXX", video.Screen);
+            Assert.Equal("XXXXXX", video.Orientation);
+            Assert.Equal("XXXXXX", video.Width);
+            Assert.Equal("XXXXXX", video.Height);
+            Assert.Equal("XXXXXX", video.AspectX);
+            Assert.Equal("XXXXXX", video.AspectY);
+            Assert.Equal("XXXXXX", video.Refresh);
+        }
+
+        /// <summary>
+        /// Validate a Sound
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Sound? sound)
+        {
+            Assert.NotNull(sound);
+            Assert.Equal("XXXXXX", sound.Channels);
+        }
+
+        /// <summary>
+        /// Validate a Input
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Input? input)
+        {
+            Assert.NotNull(input);
+            Assert.Equal("XXXXXX", input.Service);
+            Assert.Equal("XXXXXX", input.Tilt);
+            Assert.Equal("XXXXXX", input.Players);
+            //Assert.Equal("XXXXXX", input.ControlAttr); // Mututally exclusive with input.Control
+            Assert.Equal("XXXXXX", input.Buttons);
+            Assert.Equal("XXXXXX", input.Coins);
+
+            Assert.NotNull(input.Control);
+            var control = Assert.Single(input.Control);
+            Validate(control);
+        }
+
+        /// <summary>
+        /// Validate a Control
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Control? control)
+        {
+            Assert.NotNull(control);
+            Assert.Equal("XXXXXX", control.Type);
+            Assert.Equal("XXXXXX", control.Player);
+            Assert.Equal("XXXXXX", control.Buttons);
+            Assert.Equal("XXXXXX", control.ReqButtons);
+            Assert.Equal("XXXXXX", control.Minimum);
+            Assert.Equal("XXXXXX", control.Maximum);
+            Assert.Equal("XXXXXX", control.Sensitivity);
+            Assert.Equal("XXXXXX", control.KeyDelta);
+            Assert.Equal("XXXXXX", control.Reverse);
+            Assert.Equal("XXXXXX", control.Ways);
+            Assert.Equal("XXXXXX", control.Ways2);
+            Assert.Equal("XXXXXX", control.Ways3);
+        }
+
+        /// <summary>
+        /// Validate a DipSwitch
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.DipSwitch? dipswitch)
+        {
+            Assert.NotNull(dipswitch);
+            Assert.Equal("XXXXXX", dipswitch.Name);
+            Assert.Equal("XXXXXX", dipswitch.Tag);
+            Assert.Equal("XXXXXX", dipswitch.Mask);
+            Validate(dipswitch.Condition);
+
+            Assert.NotNull(dipswitch.DipLocation);
+            var diplocation = Assert.Single(dipswitch.DipLocation);
+            Validate(diplocation);
+
+            Assert.NotNull(dipswitch.DipValue);
+            var dipvalue = Assert.Single(dipswitch.DipValue);
+            Validate(dipvalue);
+        }
+
+        /// <summary>
+        /// Validate a Condition
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Condition? condition)
+        {
+            Assert.NotNull(condition);
+            Assert.Equal("XXXXXX", condition.Tag);
+            Assert.Equal("XXXXXX", condition.Mask);
+            Assert.Equal("XXXXXX", condition.Relation);
+            Assert.Equal("XXXXXX", condition.Value);
+        }
+
+        /// <summary>
+        /// Validate a DipLocation
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.DipLocation? diplocation)
+        {
+            Assert.NotNull(diplocation);
+            Assert.Equal("XXXXXX", diplocation.Name);
+            Assert.Equal("XXXXXX", diplocation.Number);
+            Assert.Equal("XXXXXX", diplocation.Inverted);
+        }
+
+        /// <summary>
+        /// Validate a DipValue
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.DipValue? dipvalue)
+        {
+            Assert.NotNull(dipvalue);
+            Assert.Equal("XXXXXX", dipvalue.Name);
+            Assert.Equal("XXXXXX", dipvalue.Value);
+            Assert.Equal("XXXXXX", dipvalue.Default);
+            Validate(dipvalue.Condition);
+        }
+
+        /// <summary>
+        /// Validate a Configuration
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Configuration? configuration)
+        {
+            Assert.NotNull(configuration);
+            Assert.Equal("XXXXXX", configuration.Name);
+            Assert.Equal("XXXXXX", configuration.Tag);
+            Assert.Equal("XXXXXX", configuration.Mask);
+            Validate(configuration.Condition);
+
+            Assert.NotNull(configuration.ConfLocation);
+            var conflocation = Assert.Single(configuration.ConfLocation);
+            Validate(conflocation);
+
+            Assert.NotNull(configuration.ConfSetting);
+            var confsetting = Assert.Single(configuration.ConfSetting);
+            Validate(confsetting);
+        }
+
+        /// <summary>
+        /// Validate a ConfLocation
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.ConfLocation? conflocation)
+        {
+            Assert.NotNull(conflocation);
+            Assert.Equal("XXXXXX", conflocation.Name);
+            Assert.Equal("XXXXXX", conflocation.Number);
+            Assert.Equal("XXXXXX", conflocation.Inverted);
+        }
+
+        /// <summary>
+        /// Validate a ConfSetting
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.ConfSetting? confsetting)
+        {
+            Assert.NotNull(confsetting);
+            Assert.Equal("XXXXXX", confsetting.Name);
+            Assert.Equal("XXXXXX", confsetting.Value);
+            Assert.Equal("XXXXXX", confsetting.Default);
+            Validate(confsetting.Condition);
+        }
+
+        /// <summary>
+        /// Validate a Port
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Port? port)
+        {
+            Assert.NotNull(port);
+            Assert.Equal("XXXXXX", port.Tag);
+
+            Assert.NotNull(port.Analog);
+            var analog = Assert.Single(port.Analog);
+            Validate(analog);
+        }
+
+        /// <summary>
+        /// Validate a Analog
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Analog? analog)
+        {
+            Assert.NotNull(analog);
+            Assert.Equal("XXXXXX", analog.Mask);
+        }
+
+        /// <summary>
+        /// Validate a Adjuster
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Adjuster? adjuster)
+        {
+            Assert.NotNull(adjuster);
+            Assert.Equal("XXXXXX", adjuster.Name);
+            Assert.Equal("XXXXXX", adjuster.Default);
+            Validate(adjuster.Condition);
+        }
+
+        /// <summary>
+        /// Validate a Driver
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Driver? driver)
+        {
+            Assert.NotNull(driver);
+            Assert.Equal("XXXXXX", driver.Status);
+            Assert.Equal("XXXXXX", driver.Color);
+            Assert.Equal("XXXXXX", driver.Sound);
+            Assert.Equal("XXXXXX", driver.PaletteSize);
+            Assert.Equal("XXXXXX", driver.Emulation);
+            Assert.Equal("XXXXXX", driver.Cocktail);
+            Assert.Equal("XXXXXX", driver.SaveState);
+            Assert.Equal("XXXXXX", driver.RequiresArtwork);
+            Assert.Equal("XXXXXX", driver.Unofficial);
+            Assert.Equal("XXXXXX", driver.NoSoundHardware);
+            Assert.Equal("XXXXXX", driver.Incomplete);
+        }
+
+        /// <summary>
+        /// Validate a Feature
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Feature? feature)
+        {
+            Assert.NotNull(feature);
+            Assert.Equal("XXXXXX", feature.Type);
+            Assert.Equal("XXXXXX", feature.Status);
+            Assert.Equal("XXXXXX", feature.Overall);
+        }
+
+        /// <summary>
+        /// Validate a Device
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Device? device)
+        {
+            Assert.NotNull(device);
+            Assert.Equal("XXXXXX", device.Type);
+            Assert.Equal("XXXXXX", device.Tag);
+            Assert.Equal("XXXXXX", device.FixedImage);
+            Assert.Equal("XXXXXX", device.Mandatory);
+            Assert.Equal("XXXXXX", device.Interface);
+            Validate(device.Instance);
+
+            Assert.NotNull(device.Extension);
+            var extension = Assert.Single(device.Extension);
+            Validate(extension);
+        }
+
+        /// <summary>
+        /// Validate a Instance
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Instance? instance)
+        {
+            Assert.NotNull(instance);
+            Assert.Equal("XXXXXX", instance.Name);
+            Assert.Equal("XXXXXX", instance.BriefName);
+        }
+
+        /// <summary>
+        /// Validate a Extension
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Extension? extension)
+        {
+            Assert.NotNull(extension);
+            Assert.Equal("XXXXXX", extension.Name);
+        }
+
+        /// <summary>
+        /// Validate a Slot
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Slot? slot)
+        {
+            Assert.NotNull(slot);
+            Assert.Equal("XXXXXX", slot.Name);
+
+            Assert.NotNull(slot.SlotOption);
+            var slotoption = Assert.Single(slot.SlotOption);
+            Validate(slotoption);
+        }
+
+        /// <summary>
+        /// Validate a SlotOption
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.SlotOption? slotoption)
+        {
+            Assert.NotNull(slotoption);
+            Assert.Equal("XXXXXX", slotoption.Name);
+            Assert.Equal("XXXXXX", slotoption.DevName);
+            Assert.Equal("XXXXXX", slotoption.Default);
+        }
+
+        /// <summary>
+        /// Validate a SoftwareList
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.SoftwareList? softwarelist)
+        {
+            Assert.NotNull(softwarelist);
+            Assert.Equal("XXXXXX", softwarelist.Tag);
+            Assert.Equal("XXXXXX", softwarelist.Name);
+            Assert.Equal("XXXXXX", softwarelist.Status);
+            Assert.Equal("XXXXXX", softwarelist.Filter);
+        }
+
+        /// <summary>
+        /// Validate a RamOption
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.RamOption? ramoption)
+        {
+            Assert.NotNull(ramoption);
+            Assert.Equal("XXXXXX", ramoption.Name);
+            Assert.Equal("XXXXXX", ramoption.Default);
+            Assert.Equal("XXXXXX", ramoption.Content);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/LogiqxTests.cs

@@ -0,0 +1,621 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class LogiqxTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new Logiqx();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new Logiqx();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new Logiqx();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new Logiqx();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new Logiqx();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new Logiqx();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void RoundTripGameTest()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new Logiqx();
+            var serializer = new SabreTools.Serialization.Writers.Logiqx();
+
+            // Build the data
+            Data.Models.Logiqx.Datafile df = Build(game: true);
+
+            // Serialize to stream
+            Stream? metadata = serializer.Serialize(df);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.Logiqx.Datafile? newDf = deserializer.Deserialize(metadata);
+
+            // Validate the data
+            Assert.NotNull(newDf);
+            Assert.Equal("XXXXXX", newDf.Build);
+            Assert.Equal("XXXXXX", newDf.Debug);
+            Assert.Equal("XXXXXX", newDf.SchemaLocation);
+            Validate(newDf.Header);
+
+            Assert.NotNull(newDf.Game);
+            var newGame = Assert.Single(newDf.Game);
+            Validate(newGame);
+
+            // TODO: Unsupported
+            Assert.Null(newDf.Dir);
+        }
+
+        [Fact]
+        public void RoundTripMachineTest()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new Logiqx();
+            var serializer = new SabreTools.Serialization.Writers.Logiqx();
+
+            // Build the data
+            Data.Models.Logiqx.Datafile df = Build(game: false);
+
+            // Serialize to stream
+            Stream? metadata = serializer.Serialize(df);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.Logiqx.Datafile? newDf = deserializer.Deserialize(metadata);
+
+            // Validate the data
+            Assert.NotNull(newDf);
+            Assert.Equal("XXXXXX", newDf.Build);
+            Assert.Equal("XXXXXX", newDf.Debug);
+            Assert.Equal("XXXXXX", newDf.SchemaLocation);
+            Validate(newDf.Header);
+
+            Assert.NotNull(newDf.Game);
+            var newGame = Assert.Single(newDf.Game);
+            Validate(newGame);
+
+            // TODO: Unsupported
+            Assert.Null(newDf.Dir);
+        }
+
+        /// <summary>
+        /// Build model for serialization and deserialization
+        /// </summary>
+        private static Data.Models.Logiqx.Datafile Build(bool game)
+        {
+            var clrmamepro = new Data.Models.Logiqx.ClrMamePro
+            {
+                Header = "XXXXXX",
+                ForceMerging = "XXXXXX",
+                ForceNodump = "XXXXXX",
+                ForcePacking = "XXXXXX",
+            };
+
+            var romcenter = new Data.Models.Logiqx.RomCenter
+            {
+                Plugin = "XXXXXX",
+                RomMode = "XXXXXX",
+                BiosMode = "XXXXXX",
+                SampleMode = "XXXXXX",
+                LockRomMode = "XXXXXX",
+                LockBiosMode = "XXXXXX",
+                LockSampleMode = "XXXXXX",
+            };
+
+            var header = new Data.Models.Logiqx.Header
+            {
+                Id = "XXXXXX",
+                Name = "XXXXXX",
+                Description = "XXXXXX",
+                RootDir = "XXXXXX",
+                Category = "XXXXXX",
+                Version = "XXXXXX",
+                Date = "XXXXXX",
+                Author = "XXXXXX",
+                Email = "XXXXXX",
+                Homepage = "XXXXXX",
+                Url = "XXXXXX",
+                Comment = "XXXXXX",
+                Type = "XXXXXX",
+                ClrMamePro = clrmamepro,
+                RomCenter = romcenter,
+            };
+
+            var trurip = new Data.Models.Logiqx.Trurip
+            {
+                TitleID = "XXXXXX",
+                Publisher = "XXXXXX",
+                Developer = "XXXXXX",
+                Year = "XXXXXX",
+                Genre = "XXXXXX",
+                Subgenre = "XXXXXX",
+                Ratings = "XXXXXX",
+                Score = "XXXXXX",
+                Players = "XXXXXX",
+                Enabled = "XXXXXX",
+                CRC = "XXXXXX",
+                Source = "XXXXXX",
+                CloneOf = "XXXXXX",
+                RelatedTo = "XXXXXX",
+            };
+
+            var release = new Data.Models.Logiqx.Release
+            {
+                Name = "XXXXXX",
+                Region = "XXXXXX",
+                Language = "XXXXXX",
+                Date = "XXXXXX",
+                Default = "XXXXXX",
+            };
+
+            var biosset = new Data.Models.Logiqx.BiosSet
+            {
+                Name = "XXXXXX",
+                Description = "XXXXXX",
+                Default = "XXXXXX",
+            };
+
+            var rom = new Data.Models.Logiqx.Rom
+            {
+                Name = "XXXXXX",
+                Size = "XXXXXX",
+                CRC = "XXXXXX",
+                MD2 = "XXXXXX",
+                MD4 = "XXXXXX",
+                MD5 = "XXXXXX",
+                RIPEMD128 = "XXXXXX",
+                RIPEMD160 = "XXXXXX",
+                SHA1 = "XXXXXX",
+                SHA256 = "XXXXXX",
+                SHA384 = "XXXXXX",
+                SHA512 = "XXXXXX",
+                SpamSum = "XXXXXX",
+                xxHash364 = "XXXXXX",
+                xxHash3128 = "XXXXXX",
+                Merge = "XXXXXX",
+                Status = "XXXXXX",
+                Serial = "XXXXXX",
+                Header = "XXXXXX",
+                Date = "XXXXXX",
+                Inverted = "XXXXXX",
+                MIA = "XXXXXX",
+            };
+
+            var disk = new Data.Models.Logiqx.Disk
+            {
+                Name = "XXXXXX",
+                MD5 = "XXXXXX",
+                SHA1 = "XXXXXX",
+                Merge = "XXXXXX",
+                Status = "XXXXXX",
+                Region = "XXXXXX",
+            };
+
+            var media = new Data.Models.Logiqx.Media
+            {
+                Name = "XXXXXX",
+                MD5 = "XXXXXX",
+                SHA1 = "XXXXXX",
+                SHA256 = "XXXXXX",
+                SpamSum = "XXXXXX",
+            };
+
+            var deviceRef = new Data.Models.Logiqx.DeviceRef
+            {
+                Name = "XXXXXX",
+            };
+
+            var sample = new Data.Models.Logiqx.Sample
+            {
+                Name = "XXXXXX",
+            };
+
+            var archive = new Data.Models.Logiqx.Archive
+            {
+                Name = "XXXXXX",
+            };
+
+            var driver = new Data.Models.Logiqx.Driver
+            {
+                Status = "XXXXXX",
+                Emulation = "XXXXXX",
+                Cocktail = "XXXXXX",
+                SaveState = "XXXXXX",
+                RequiresArtwork = "XXXXXX",
+                Unofficial = "XXXXXX",
+                NoSoundHardware = "XXXXXX",
+                Incomplete = "XXXXXX",
+            };
+
+            var softwarelist = new Data.Models.Logiqx.SoftwareList
+            {
+                Tag = "XXXXXX",
+                Name = "XXXXXX",
+                Status = "XXXXXX",
+                Filter = "XXXXXX",
+            };
+
+            Data.Models.Logiqx.GameBase gameBase = game
+                ? new Data.Models.Logiqx.Game()
+                : new Data.Models.Logiqx.Machine();
+            gameBase.Name = "XXXXXX";
+            gameBase.SourceFile = "XXXXXX";
+            gameBase.IsBios = "XXXXXX";
+            gameBase.IsDevice = "XXXXXX";
+            gameBase.IsMechanical = "XXXXXX";
+            gameBase.CloneOf = "XXXXXX";
+            gameBase.RomOf = "XXXXXX";
+            gameBase.SampleOf = "XXXXXX";
+            gameBase.Board = "XXXXXX";
+            gameBase.RebuildTo = "XXXXXX";
+            gameBase.Id = "XXXXXX";
+            gameBase.CloneOfId = "XXXXXX";
+            gameBase.Runnable = "XXXXXX";
+            gameBase.Comment = ["XXXXXX"];
+            gameBase.Description = "XXXXXX";
+            gameBase.Year = "XXXXXX";
+            gameBase.Manufacturer = "XXXXXX";
+            gameBase.Publisher = "XXXXXX";
+            gameBase.Category = ["XXXXXX"];
+            gameBase.Trurip = trurip;
+            gameBase.Release = [release];
+            gameBase.BiosSet = [biosset];
+            gameBase.Rom = [rom];
+            gameBase.Disk = [disk];
+            gameBase.Media = [media];
+            gameBase.DeviceRef = [deviceRef];
+            gameBase.Sample = [sample];
+            gameBase.Archive = [archive];
+            gameBase.Driver = driver;
+            gameBase.SoftwareList = [softwarelist];
+
+            return new Data.Models.Logiqx.Datafile
+            {
+                Build = "XXXXXX",
+                Debug = "XXXXXX",
+                SchemaLocation = "XXXXXX",
+                Header = header,
+                Game = [gameBase],
+                // Dir = [dir], // TODO: Unsupported
+            };
+        }
+
+        /// <summary>
+        /// Validate a Header
+        /// </summary>
+        private static void Validate(Data.Models.Logiqx.Header? header)
+        {
+            Assert.NotNull(header);
+            Assert.Equal("XXXXXX", header.Id);
+            Assert.Equal("XXXXXX", header.Name);
+            Assert.Equal("XXXXXX", header.Description);
+            Assert.Equal("XXXXXX", header.RootDir);
+            Assert.Equal("XXXXXX", header.Category);
+            Assert.Equal("XXXXXX", header.Version);
+            Assert.Equal("XXXXXX", header.Date);
+            Assert.Equal("XXXXXX", header.Author);
+            Assert.Equal("XXXXXX", header.Email);
+            Assert.Equal("XXXXXX", header.Homepage);
+            Assert.Equal("XXXXXX", header.Url);
+            Assert.Equal("XXXXXX", header.Comment);
+            Assert.Equal("XXXXXX", header.Type);
+            Validate(header.ClrMamePro);
+            Validate(header.RomCenter);
+        }
+
+        /// <summary>
+        /// Validate a ClrMamePro
+        /// </summary>
+        private static void Validate(Data.Models.Logiqx.ClrMamePro? cmp)
+        {
+            Assert.NotNull(cmp);
+            Assert.Equal("XXXXXX", cmp.Header);
+            Assert.Equal("XXXXXX", cmp.ForceMerging);
+            Assert.Equal("XXXXXX", cmp.ForceNodump);
+            Assert.Equal("XXXXXX", cmp.ForcePacking);
+        }
+
+        /// <summary>
+        /// Validate a RomCenter
+        /// </summary>
+        private static void Validate(Data.Models.Logiqx.RomCenter? rc)
+        {
+            Assert.NotNull(rc);
+            Assert.Equal("XXXXXX", rc.Plugin);
+            Assert.Equal("XXXXXX", rc.RomMode);
+            Assert.Equal("XXXXXX", rc.BiosMode);
+            Assert.Equal("XXXXXX", rc.SampleMode);
+            Assert.Equal("XXXXXX", rc.LockRomMode);
+            Assert.Equal("XXXXXX", rc.LockBiosMode);
+            Assert.Equal("XXXXXX", rc.LockSampleMode);
+        }
+
+        /// <summary>
+        /// Validate a GameBase
+        /// </summary>
+        private static void Validate(Data.Models.Logiqx.GameBase? gb)
+        {
+            Assert.NotNull(gb);
+            Assert.Equal("XXXXXX", gb.Name);
+            Assert.Equal("XXXXXX", gb.SourceFile);
+            Assert.Equal("XXXXXX", gb.IsBios);
+            Assert.Equal("XXXXXX", gb.IsDevice);
+            Assert.Equal("XXXXXX", gb.IsMechanical);
+            Assert.Equal("XXXXXX", gb.CloneOf);
+            Assert.Equal("XXXXXX", gb.RomOf);
+            Assert.Equal("XXXXXX", gb.SampleOf);
+            Assert.Equal("XXXXXX", gb.Board);
+            Assert.Equal("XXXXXX", gb.RebuildTo);
+            Assert.Equal("XXXXXX", gb.Id);
+            Assert.Equal("XXXXXX", gb.CloneOfId);
+            Assert.Equal("XXXXXX", gb.Runnable);
+
+            Assert.NotNull(gb.Comment);
+            string comment = Assert.Single(gb.Comment);
+            Assert.Equal("XXXXXX", comment);
+
+            Assert.Equal("XXXXXX", gb.Description);
+            Assert.Equal("XXXXXX", gb.Year);
+            Assert.Equal("XXXXXX", gb.Manufacturer);
+            Assert.Equal("XXXXXX", gb.Publisher);
+
+            Assert.NotNull(gb.Category);
+            string category = Assert.Single(gb.Category);
+            Assert.Equal("XXXXXX", category);
+
+            Validate(gb.Trurip);
+
+            Assert.NotNull(gb.Release);
+            var release = Assert.Single(gb.Release);
+            Validate(release);
+
+            Assert.NotNull(gb.BiosSet);
+            var biosset = Assert.Single(gb.BiosSet);
+            Validate(biosset);
+
+            Assert.NotNull(gb.Rom);
+            var rom = Assert.Single(gb.Rom);
+            Validate(rom);
+
+            Assert.NotNull(gb.Disk);
+            var disk = Assert.Single(gb.Disk);
+            Validate(disk);
+
+            Assert.NotNull(gb.Media);
+            var media = Assert.Single(gb.Media);
+            Validate(media);
+
+            Assert.NotNull(gb.DeviceRef);
+            var deviceref = Assert.Single(gb.DeviceRef);
+            Validate(deviceref);
+
+            Assert.NotNull(gb.Sample);
+            var sample = Assert.Single(gb.Sample);
+            Validate(sample);
+
+            Assert.NotNull(gb.Archive);
+            var archive = Assert.Single(gb.Archive);
+            Validate(archive);
+
+            Validate(gb.Driver);
+
+            Assert.NotNull(gb.SoftwareList);
+            var softwarelist = Assert.Single(gb.SoftwareList);
+            Validate(softwarelist);
+        }
+
+        /// <summary>
+        /// Validate a Trurip
+        /// </summary>
+        private static void Validate(Data.Models.Logiqx.Trurip? trurip)
+        {
+            Assert.NotNull(trurip);
+            Assert.Equal("XXXXXX", trurip.TitleID);
+            Assert.Equal("XXXXXX", trurip.Publisher);
+            Assert.Equal("XXXXXX", trurip.Developer);
+            Assert.Equal("XXXXXX", trurip.Year);
+            Assert.Equal("XXXXXX", trurip.Genre);
+            Assert.Equal("XXXXXX", trurip.Subgenre);
+            Assert.Equal("XXXXXX", trurip.Ratings);
+            Assert.Equal("XXXXXX", trurip.Score);
+            Assert.Equal("XXXXXX", trurip.Players);
+            Assert.Equal("XXXXXX", trurip.Enabled);
+            Assert.Equal("XXXXXX", trurip.CRC);
+            Assert.Equal("XXXXXX", trurip.Source);
+            Assert.Equal("XXXXXX", trurip.CloneOf);
+            Assert.Equal("XXXXXX", trurip.RelatedTo);
+        }
+
+        /// <summary>
+        /// Validate a Release
+        /// </summary>
+        private static void Validate(Data.Models.Logiqx.Release? release)
+        {
+            Assert.NotNull(release);
+            Assert.Equal("XXXXXX", release.Name);
+            Assert.Equal("XXXXXX", release.Region);
+            Assert.Equal("XXXXXX", release.Language);
+            Assert.Equal("XXXXXX", release.Date);
+            Assert.Equal("XXXXXX", release.Default);
+        }
+
+        /// <summary>
+        /// Validate a BiosSet
+        /// </summary>
+        private static void Validate(Data.Models.Logiqx.BiosSet? biosset)
+        {
+            Assert.NotNull(biosset);
+            Assert.Equal("XXXXXX", biosset.Name);
+            Assert.Equal("XXXXXX", biosset.Description);
+            Assert.Equal("XXXXXX", biosset.Default);
+        }
+
+        /// <summary>
+        /// Validate a Rom
+        /// </summary>
+        private static void Validate(Data.Models.Logiqx.Rom? rom)
+        {
+            Assert.NotNull(rom);
+            Assert.Equal("XXXXXX", rom.Name);
+            Assert.Equal("XXXXXX", rom.Size);
+            Assert.Equal("XXXXXX", rom.CRC);
+            Assert.Equal("XXXXXX", rom.MD2);
+            Assert.Equal("XXXXXX", rom.MD4);
+            Assert.Equal("XXXXXX", rom.MD5);
+            Assert.Equal("XXXXXX", rom.RIPEMD128);
+            Assert.Equal("XXXXXX", rom.RIPEMD160);
+            Assert.Equal("XXXXXX", rom.SHA1);
+            Assert.Equal("XXXXXX", rom.SHA256);
+            Assert.Equal("XXXXXX", rom.SHA384);
+            Assert.Equal("XXXXXX", rom.SHA512);
+            Assert.Equal("XXXXXX", rom.SpamSum);
+            Assert.Equal("XXXXXX", rom.xxHash364);
+            Assert.Equal("XXXXXX", rom.xxHash3128);
+            Assert.Equal("XXXXXX", rom.Merge);
+            Assert.Equal("XXXXXX", rom.Status);
+            Assert.Equal("XXXXXX", rom.Serial);
+            Assert.Equal("XXXXXX", rom.Header);
+            Assert.Equal("XXXXXX", rom.Date);
+            Assert.Equal("XXXXXX", rom.Inverted);
+            Assert.Equal("XXXXXX", rom.MIA);
+        }
+
+        /// <summary>
+        /// Validate a Disk
+        /// </summary>
+        private static void Validate(Data.Models.Logiqx.Disk? disk)
+        {
+            Assert.NotNull(disk);
+            Assert.Equal("XXXXXX", disk.Name);
+            Assert.Equal("XXXXXX", disk.MD5);
+            Assert.Equal("XXXXXX", disk.SHA1);
+            Assert.Equal("XXXXXX", disk.Merge);
+            Assert.Equal("XXXXXX", disk.Status);
+            Assert.Equal("XXXXXX", disk.Region);
+        }
+
+        /// <summary>
+        /// Validate a Media
+        /// </summary>
+        private static void Validate(Data.Models.Logiqx.Media? media)
+        {
+            Assert.NotNull(media);
+            Assert.Equal("XXXXXX", media.Name);
+            Assert.Equal("XXXXXX", media.MD5);
+            Assert.Equal("XXXXXX", media.SHA1);
+            Assert.Equal("XXXXXX", media.SHA256);
+            Assert.Equal("XXXXXX", media.SpamSum);
+        }
+
+        /// <summary>
+        /// Validate a DeviceRef
+        /// </summary>
+        private static void Validate(Data.Models.Logiqx.DeviceRef? deviceref)
+        {
+            Assert.NotNull(deviceref);
+            Assert.Equal("XXXXXX", deviceref.Name);
+        }
+
+        /// <summary>
+        /// Validate a Sample
+        /// </summary>
+        private static void Validate(Data.Models.Logiqx.Sample? sample)
+        {
+            Assert.NotNull(sample);
+            Assert.Equal("XXXXXX", sample.Name);
+        }
+
+        /// <summary>
+        /// Validate a Archive
+        /// </summary>
+        private static void Validate(Data.Models.Logiqx.Archive? archive)
+        {
+            Assert.NotNull(archive);
+            Assert.Equal("XXXXXX", archive.Name);
+        }
+
+        /// <summary>
+        /// Validate a Driver
+        /// </summary>
+        private static void Validate(Data.Models.Logiqx.Driver? driver)
+        {
+            Assert.NotNull(driver);
+            Assert.Equal("XXXXXX", driver.Status);
+            Assert.Equal("XXXXXX", driver.Emulation);
+            Assert.Equal("XXXXXX", driver.Cocktail);
+            Assert.Equal("XXXXXX", driver.SaveState);
+            Assert.Equal("XXXXXX", driver.RequiresArtwork);
+            Assert.Equal("XXXXXX", driver.Unofficial);
+            Assert.Equal("XXXXXX", driver.NoSoundHardware);
+            Assert.Equal("XXXXXX", driver.Incomplete);
+        }
+
+        /// <summary>
+        /// Validate a SoftwareList
+        /// </summary>
+        private static void Validate(Data.Models.Logiqx.SoftwareList? softwarelist)
+        {
+            Assert.NotNull(softwarelist);
+            Assert.Equal("XXXXXX", softwarelist.Tag);
+            Assert.Equal("XXXXXX", softwarelist.Name);
+            Assert.Equal("XXXXXX", softwarelist.Status);
+            Assert.Equal("XXXXXX", softwarelist.Filter);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/M1Tests.cs

@@ -0,0 +1,940 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class M1Tests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new M1();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new M1();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new M1();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new M1();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new M1();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new M1();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void RoundTripGameTest()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new M1();
+            var serializer = new SabreTools.Serialization.Writers.M1();
+
+            // Build the data
+            Data.Models.Listxml.M1 m1 = Build(game: true);
+
+            // Serialize to generic model
+            Stream? metadata = serializer.Serialize(m1);
+            Assert.NotNull(metadata);
+
+            // Serialize to stream
+            Data.Models.Listxml.M1? newM1 = deserializer.Deserialize(metadata);
+
+            // Validate the data
+            Assert.NotNull(newM1);
+            Assert.Equal("XXXXXX", newM1.Version);
+
+            Assert.NotNull(newM1.Game);
+            var newGame = Assert.Single(newM1.Game);
+            Validate(newGame);
+        }
+
+        [Fact]
+        public void RoundTripMachineTest()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new M1();
+            var serializer = new SabreTools.Serialization.Writers.M1();
+
+            // Build the data
+            Data.Models.Listxml.M1 m1 = Build(game: false);
+
+            // Serialize to generic model
+            Stream? metadata = serializer.Serialize(m1);
+            Assert.NotNull(metadata);
+
+            // Serialize to stream
+            Data.Models.Listxml.M1? newM1 = deserializer.Deserialize(metadata);
+
+            // Validate the data
+            Assert.NotNull(newM1);
+            Assert.Equal("XXXXXX", newM1.Version);
+
+            Assert.NotNull(newM1.Game);
+            var newGame = Assert.Single(newM1.Game);
+            Validate(newGame);
+        }
+
+        /// <summary>
+        /// Build model for serialization and deserialization
+        /// </summary>
+        private static Data.Models.Listxml.M1 Build(bool game)
+        {
+            var biosset = new Data.Models.Listxml.BiosSet
+            {
+                Name = "XXXXXX",
+                Description = "XXXXXX",
+                Default = "XXXXXX",
+            };
+
+            var rom = new Data.Models.Listxml.Rom
+            {
+                Name = "XXXXXX",
+                Bios = "XXXXXX",
+                Size = "XXXXXX",
+                CRC = "XXXXXX",
+                SHA1 = "XXXXXX",
+                Merge = "XXXXXX",
+                Region = "XXXXXX",
+                Offset = "XXXXXX",
+                Status = "XXXXXX",
+                Optional = "XXXXXX",
+                Dispose = "XXXXXX",
+                SoundOnly = "XXXXXX",
+            };
+
+            var disk = new Data.Models.Listxml.Disk
+            {
+                Name = "XXXXXX",
+                MD5 = "XXXXXX",
+                SHA1 = "XXXXXX",
+                Merge = "XXXXXX",
+                Region = "XXXXXX",
+                Index = "XXXXXX",
+                Writable = "XXXXXX",
+                Status = "XXXXXX",
+                Optional = "XXXXXX",
+            };
+
+            var deviceref = new Data.Models.Listxml.DeviceRef
+            {
+                Name = "XXXXXX",
+            };
+
+            var sample = new Data.Models.Listxml.Sample
+            {
+                Name = "XXXXXX",
+            };
+
+            var chip = new Data.Models.Listxml.Chip
+            {
+                Name = "XXXXXX",
+                Tag = "XXXXXX",
+                Type = "XXXXXX",
+                SoundOnly = "XXXXXX",
+                Clock = "XXXXXX",
+            };
+
+            var display = new Data.Models.Listxml.Display
+            {
+                Tag = "XXXXXX",
+                Type = "XXXXXX",
+                Rotate = "XXXXXX",
+                FlipX = "XXXXXX",
+                Width = "XXXXXX",
+                Height = "XXXXXX",
+                Refresh = "XXXXXX",
+                PixClock = "XXXXXX",
+                HTotal = "XXXXXX",
+                HBEnd = "XXXXXX",
+                HBStart = "XXXXXX",
+                VTotal = "XXXXXX",
+                VBEnd = "XXXXXX",
+                VBStart = "XXXXXX",
+            };
+
+            var video = new Data.Models.Listxml.Video
+            {
+                Screen = "XXXXXX",
+                Orientation = "XXXXXX",
+                Width = "XXXXXX",
+                Height = "XXXXXX",
+                AspectX = "XXXXXX",
+                AspectY = "XXXXXX",
+                Refresh = "XXXXXX",
+            };
+
+            var sound = new Data.Models.Listxml.Sound
+            {
+                Channels = "XXXXXX",
+            };
+
+            var control = new Data.Models.Listxml.Control
+            {
+                Type = "XXXXXX",
+                Player = "XXXXXX",
+                Buttons = "XXXXXX",
+                ReqButtons = "XXXXXX",
+                Minimum = "XXXXXX",
+                Maximum = "XXXXXX",
+                Sensitivity = "XXXXXX",
+                KeyDelta = "XXXXXX",
+                Reverse = "XXXXXX",
+                Ways = "XXXXXX",
+                Ways2 = "XXXXXX",
+                Ways3 = "XXXXXX",
+            };
+
+            var input = new Data.Models.Listxml.Input
+            {
+                Service = "XXXXXX",
+                Tilt = "XXXXXX",
+                Players = "XXXXXX",
+                //ControlAttr = "XXXXXX", // Mututally exclusive with input.Control
+                Buttons = "XXXXXX",
+                Coins = "XXXXXX",
+                Control = [control],
+            };
+
+            var condition = new Data.Models.Listxml.Condition
+            {
+                Tag = "XXXXXX",
+                Mask = "XXXXXX",
+                Relation = "XXXXXX",
+                Value = "XXXXXX",
+            };
+
+            var diplocation = new Data.Models.Listxml.DipLocation
+            {
+                Name = "XXXXXX",
+                Number = "XXXXXX",
+                Inverted = "XXXXXX",
+            };
+
+            var dipvalue = new Data.Models.Listxml.DipValue
+            {
+                Name = "XXXXXX",
+                Value = "XXXXXX",
+                Default = "XXXXXX",
+                Condition = condition,
+            };
+
+            var dipswitch = new Data.Models.Listxml.DipSwitch
+            {
+                Name = "XXXXXX",
+                Tag = "XXXXXX",
+                Mask = "XXXXXX",
+                Condition = condition,
+                DipLocation = [diplocation],
+                DipValue = [dipvalue],
+            };
+
+            var conflocation = new Data.Models.Listxml.ConfLocation
+            {
+                Name = "XXXXXX",
+                Number = "XXXXXX",
+                Inverted = "XXXXXX",
+            };
+
+            var confsetting = new Data.Models.Listxml.ConfSetting
+            {
+                Name = "XXXXXX",
+                Value = "XXXXXX",
+                Default = "XXXXXX",
+                Condition = condition,
+            };
+
+            var configuration = new Data.Models.Listxml.Configuration
+            {
+                Name = "XXXXXX",
+                Tag = "XXXXXX",
+                Mask = "XXXXXX",
+                Condition = condition,
+                ConfLocation = [conflocation],
+                ConfSetting = [confsetting],
+            };
+
+            var analog = new Data.Models.Listxml.Analog
+            {
+                Mask = "XXXXXX",
+            };
+
+            var port = new Data.Models.Listxml.Port
+            {
+                Tag = "XXXXXX",
+                Analog = [analog],
+            };
+
+            var adjuster = new Data.Models.Listxml.Adjuster
+            {
+                Name = "XXXXXX",
+                Default = "XXXXXX",
+                Condition = condition,
+            };
+
+            var driver = new Data.Models.Listxml.Driver
+            {
+                Status = "XXXXXX",
+                Color = "XXXXXX",
+                Sound = "XXXXXX",
+                PaletteSize = "XXXXXX",
+                Emulation = "XXXXXX",
+                Cocktail = "XXXXXX",
+                SaveState = "XXXXXX",
+                RequiresArtwork = "XXXXXX",
+                Unofficial = "XXXXXX",
+                NoSoundHardware = "XXXXXX",
+                Incomplete = "XXXXXX",
+            };
+
+            var feature = new Data.Models.Listxml.Feature
+            {
+                Type = "XXXXXX",
+                Status = "XXXXXX",
+                Overall = "XXXXXX",
+            };
+
+            var instance = new Data.Models.Listxml.Instance
+            {
+                Name = "XXXXXX",
+                BriefName = "XXXXXX",
+            };
+
+            var extension = new Data.Models.Listxml.Extension
+            {
+                Name = "XXXXXX",
+            };
+
+            var device = new Data.Models.Listxml.Device
+            {
+                Type = "XXXXXX",
+                Tag = "XXXXXX",
+                FixedImage = "XXXXXX",
+                Mandatory = "XXXXXX",
+                Interface = "XXXXXX",
+                Instance = instance,
+                Extension = [extension],
+            };
+
+            var slotOption = new Data.Models.Listxml.SlotOption
+            {
+                Name = "XXXXXX",
+                DevName = "XXXXXX",
+                Default = "XXXXXX",
+            };
+
+            var slot = new Data.Models.Listxml.Slot
+            {
+                Name = "XXXXXX",
+                SlotOption = [slotOption],
+            };
+
+            var softwarelist = new Data.Models.Listxml.SoftwareList
+            {
+                Tag = "XXXXXX",
+                Name = "XXXXXX",
+                Status = "XXXXXX",
+                Filter = "XXXXXX",
+            };
+
+            var ramoption = new Data.Models.Listxml.RamOption
+            {
+                Name = "XXXXXX",
+                Default = "XXXXXX",
+                Content = "XXXXXX",
+            };
+
+            Data.Models.Listxml.GameBase gameBase = game
+                ? new Data.Models.Listxml.Game()
+                : new Data.Models.Listxml.Machine();
+            gameBase.Name = "XXXXXX";
+            gameBase.SourceFile = "XXXXXX";
+            gameBase.IsBios = "XXXXXX";
+            gameBase.IsDevice = "XXXXXX";
+            gameBase.IsMechanical = "XXXXXX";
+            gameBase.Runnable = "XXXXXX";
+            gameBase.CloneOf = "XXXXXX";
+            gameBase.RomOf = "XXXXXX";
+            gameBase.SampleOf = "XXXXXX";
+            gameBase.Description = "XXXXXX";
+            gameBase.Year = "XXXXXX";
+            gameBase.Manufacturer = "XXXXXX";
+            gameBase.History = "XXXXXX";
+            gameBase.BiosSet = [biosset];
+            gameBase.Rom = [rom];
+            gameBase.Disk = [disk];
+            gameBase.DeviceRef = [deviceref];
+            gameBase.Sample = [sample];
+            gameBase.Chip = [chip];
+            gameBase.Display = [display];
+            gameBase.Video = [video];
+            gameBase.Sound = sound;
+            gameBase.Input = input;
+            gameBase.DipSwitch = [dipswitch];
+            gameBase.Configuration = [configuration];
+            gameBase.Port = [port];
+            gameBase.Adjuster = [adjuster];
+            gameBase.Driver = driver;
+            gameBase.Feature = [feature];
+            gameBase.Device = [device];
+            gameBase.Slot = [slot];
+            gameBase.SoftwareList = [softwarelist];
+            gameBase.RamOption = [ramoption];
+
+            return new Data.Models.Listxml.M1
+            {
+                Version = "XXXXXX",
+                Game = [gameBase],
+            };
+        }
+
+        /// <summary>
+        /// Validate a GameBase
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.GameBase? gb)
+        {
+            Assert.NotNull(gb);
+            Assert.Equal("XXXXXX", gb.Name);
+            Assert.Equal("XXXXXX", gb.SourceFile);
+            Assert.Equal("XXXXXX", gb.IsBios);
+            Assert.Equal("XXXXXX", gb.IsDevice);
+            Assert.Equal("XXXXXX", gb.IsMechanical);
+            Assert.Equal("XXXXXX", gb.Runnable);
+            Assert.Equal("XXXXXX", gb.CloneOf);
+            Assert.Equal("XXXXXX", gb.RomOf);
+            Assert.Equal("XXXXXX", gb.SampleOf);
+            Assert.Equal("XXXXXX", gb.Description);
+            Assert.Equal("XXXXXX", gb.Year);
+            Assert.Equal("XXXXXX", gb.Manufacturer);
+            Assert.Equal("XXXXXX", gb.History);
+
+            Assert.NotNull(gb.BiosSet);
+            var biosset = Assert.Single(gb.BiosSet);
+            Validate(biosset);
+
+            Assert.NotNull(gb.Rom);
+            var rom = Assert.Single(gb.Rom);
+            Validate(rom);
+
+            Assert.NotNull(gb.Disk);
+            var disk = Assert.Single(gb.Disk);
+            Validate(disk);
+
+            Assert.NotNull(gb.DeviceRef);
+            var deviceref = Assert.Single(gb.DeviceRef);
+            Validate(deviceref);
+
+            Assert.NotNull(gb.Sample);
+            var sample = Assert.Single(gb.Sample);
+            Validate(sample);
+
+            Assert.NotNull(gb.Chip);
+            var chip = Assert.Single(gb.Chip);
+            Validate(chip);
+
+            Assert.NotNull(gb.Display);
+            var display = Assert.Single(gb.Display);
+            Validate(display);
+
+            Assert.NotNull(gb.Video);
+            var video = Assert.Single(gb.Video);
+            Validate(video);
+
+            Validate(gb.Sound);
+            Validate(gb.Input);
+
+            Assert.NotNull(gb.DipSwitch);
+            var dipswitch = Assert.Single(gb.DipSwitch);
+            Validate(dipswitch);
+
+            Assert.NotNull(gb.Configuration);
+            var configuration = Assert.Single(gb.Configuration);
+            Validate(configuration);
+
+            Assert.NotNull(gb.Port);
+            var port = Assert.Single(gb.Port);
+            Validate(port);
+
+            Assert.NotNull(gb.Adjuster);
+            var adjuster = Assert.Single(gb.Adjuster);
+            Validate(adjuster);
+
+            Validate(gb.Driver);
+
+            Assert.NotNull(gb.Feature);
+            var feature = Assert.Single(gb.Feature);
+            Validate(feature);
+
+            Assert.NotNull(gb.Device);
+            var device = Assert.Single(gb.Device);
+            Validate(device);
+
+            Assert.NotNull(gb.Slot);
+            var slot = Assert.Single(gb.Slot);
+            Validate(slot);
+
+            Assert.NotNull(gb.SoftwareList);
+            var softwarelist = Assert.Single(gb.SoftwareList);
+            Validate(softwarelist);
+
+            Assert.NotNull(gb.RamOption);
+            var ramoption = Assert.Single(gb.RamOption);
+            Validate(ramoption);
+        }
+
+        /// <summary>
+        /// Validate a BiosSet
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.BiosSet? biosset)
+        {
+            Assert.NotNull(biosset);
+            Assert.Equal("XXXXXX", biosset.Name);
+            Assert.Equal("XXXXXX", biosset.Description);
+            Assert.Equal("XXXXXX", biosset.Default);
+        }
+
+        /// <summary>
+        /// Validate a Rom
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Rom? rom)
+        {
+            Assert.NotNull(rom);
+            Assert.Equal("XXXXXX", rom.Name);
+            Assert.Equal("XXXXXX", rom.Bios);
+            Assert.Equal("XXXXXX", rom.Size);
+            Assert.Equal("XXXXXX", rom.CRC);
+            Assert.Equal("XXXXXX", rom.SHA1);
+            Assert.Equal("XXXXXX", rom.Merge);
+            Assert.Equal("XXXXXX", rom.Region);
+            Assert.Equal("XXXXXX", rom.Offset);
+            Assert.Equal("XXXXXX", rom.Status);
+            Assert.Equal("XXXXXX", rom.Optional);
+            Assert.Equal("XXXXXX", rom.Dispose);
+            Assert.Equal("XXXXXX", rom.SoundOnly);
+        }
+
+        /// <summary>
+        /// Validate a Disk
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Disk? disk)
+        {
+            Assert.NotNull(disk);
+            Assert.Equal("XXXXXX", disk.Name);
+            Assert.Equal("XXXXXX", disk.MD5);
+            Assert.Equal("XXXXXX", disk.SHA1);
+            Assert.Equal("XXXXXX", disk.Merge);
+            Assert.Equal("XXXXXX", disk.Region);
+            Assert.Equal("XXXXXX", disk.Index);
+            Assert.Equal("XXXXXX", disk.Writable);
+            Assert.Equal("XXXXXX", disk.Status);
+            Assert.Equal("XXXXXX", disk.Optional);
+        }
+
+        /// <summary>
+        /// Validate a DeviceRef
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.DeviceRef? deviceref)
+        {
+            Assert.NotNull(deviceref);
+            Assert.Equal("XXXXXX", deviceref.Name);
+        }
+
+        /// <summary>
+        /// Validate a Sample
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Sample? sample)
+        {
+            Assert.NotNull(sample);
+            Assert.Equal("XXXXXX", sample.Name);
+        }
+
+        /// <summary>
+        /// Validate a Chip
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Chip? chip)
+        {
+            Assert.NotNull(chip);
+            Assert.Equal("XXXXXX", chip.Name);
+            Assert.Equal("XXXXXX", chip.Tag);
+            Assert.Equal("XXXXXX", chip.Type);
+            Assert.Equal("XXXXXX", chip.SoundOnly);
+            Assert.Equal("XXXXXX", chip.Clock);
+        }
+
+        /// <summary>
+        /// Validate a Display
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Display? display)
+        {
+            Assert.NotNull(display);
+            Assert.Equal("XXXXXX", display.Tag);
+            Assert.Equal("XXXXXX", display.Type);
+            Assert.Equal("XXXXXX", display.Rotate);
+            Assert.Equal("XXXXXX", display.FlipX);
+            Assert.Equal("XXXXXX", display.Width);
+            Assert.Equal("XXXXXX", display.Height);
+            Assert.Equal("XXXXXX", display.Refresh);
+            Assert.Equal("XXXXXX", display.PixClock);
+            Assert.Equal("XXXXXX", display.HTotal);
+            Assert.Equal("XXXXXX", display.HBEnd);
+            Assert.Equal("XXXXXX", display.HBStart);
+            Assert.Equal("XXXXXX", display.VTotal);
+            Assert.Equal("XXXXXX", display.VBEnd);
+            Assert.Equal("XXXXXX", display.VBStart);
+        }
+
+        /// <summary>
+        /// Validate a Video
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Video? video)
+        {
+            Assert.NotNull(video);
+            Assert.Equal("XXXXXX", video.Screen);
+            Assert.Equal("XXXXXX", video.Orientation);
+            Assert.Equal("XXXXXX", video.Width);
+            Assert.Equal("XXXXXX", video.Height);
+            Assert.Equal("XXXXXX", video.AspectX);
+            Assert.Equal("XXXXXX", video.AspectY);
+            Assert.Equal("XXXXXX", video.Refresh);
+        }
+
+        /// <summary>
+        /// Validate a Sound
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Sound? sound)
+        {
+            Assert.NotNull(sound);
+            Assert.Equal("XXXXXX", sound.Channels);
+        }
+
+        /// <summary>
+        /// Validate a Input
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Input? input)
+        {
+            Assert.NotNull(input);
+            Assert.Equal("XXXXXX", input.Service);
+            Assert.Equal("XXXXXX", input.Tilt);
+            Assert.Equal("XXXXXX", input.Players);
+            //Assert.Equal("XXXXXX", input.ControlAttr); // Mututally exclusive with input.Control
+            Assert.Equal("XXXXXX", input.Buttons);
+            Assert.Equal("XXXXXX", input.Coins);
+
+            Assert.NotNull(input.Control);
+            var control = Assert.Single(input.Control);
+            Validate(control);
+        }
+
+        /// <summary>
+        /// Validate a Control
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Control? control)
+        {
+            Assert.NotNull(control);
+            Assert.Equal("XXXXXX", control.Type);
+            Assert.Equal("XXXXXX", control.Player);
+            Assert.Equal("XXXXXX", control.Buttons);
+            Assert.Equal("XXXXXX", control.ReqButtons);
+            Assert.Equal("XXXXXX", control.Minimum);
+            Assert.Equal("XXXXXX", control.Maximum);
+            Assert.Equal("XXXXXX", control.Sensitivity);
+            Assert.Equal("XXXXXX", control.KeyDelta);
+            Assert.Equal("XXXXXX", control.Reverse);
+            Assert.Equal("XXXXXX", control.Ways);
+            Assert.Equal("XXXXXX", control.Ways2);
+            Assert.Equal("XXXXXX", control.Ways3);
+        }
+
+        /// <summary>
+        /// Validate a DipSwitch
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.DipSwitch? dipswitch)
+        {
+            Assert.NotNull(dipswitch);
+            Assert.Equal("XXXXXX", dipswitch.Name);
+            Assert.Equal("XXXXXX", dipswitch.Tag);
+            Assert.Equal("XXXXXX", dipswitch.Mask);
+            Validate(dipswitch.Condition);
+
+            Assert.NotNull(dipswitch.DipLocation);
+            var diplocation = Assert.Single(dipswitch.DipLocation);
+            Validate(diplocation);
+
+            Assert.NotNull(dipswitch.DipValue);
+            var dipvalue = Assert.Single(dipswitch.DipValue);
+            Validate(dipvalue);
+        }
+
+        /// <summary>
+        /// Validate a Condition
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Condition? condition)
+        {
+            Assert.NotNull(condition);
+            Assert.Equal("XXXXXX", condition.Tag);
+            Assert.Equal("XXXXXX", condition.Mask);
+            Assert.Equal("XXXXXX", condition.Relation);
+            Assert.Equal("XXXXXX", condition.Value);
+        }
+
+        /// <summary>
+        /// Validate a DipLocation
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.DipLocation? diplocation)
+        {
+            Assert.NotNull(diplocation);
+            Assert.Equal("XXXXXX", diplocation.Name);
+            Assert.Equal("XXXXXX", diplocation.Number);
+            Assert.Equal("XXXXXX", diplocation.Inverted);
+        }
+
+        /// <summary>
+        /// Validate a DipValue
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.DipValue? dipvalue)
+        {
+            Assert.NotNull(dipvalue);
+            Assert.Equal("XXXXXX", dipvalue.Name);
+            Assert.Equal("XXXXXX", dipvalue.Value);
+            Assert.Equal("XXXXXX", dipvalue.Default);
+            Validate(dipvalue.Condition);
+        }
+
+        /// <summary>
+        /// Validate a Configuration
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Configuration? configuration)
+        {
+            Assert.NotNull(configuration);
+            Assert.Equal("XXXXXX", configuration.Name);
+            Assert.Equal("XXXXXX", configuration.Tag);
+            Assert.Equal("XXXXXX", configuration.Mask);
+            Validate(configuration.Condition);
+
+            Assert.NotNull(configuration.ConfLocation);
+            var conflocation = Assert.Single(configuration.ConfLocation);
+            Validate(conflocation);
+
+            Assert.NotNull(configuration.ConfSetting);
+            var confsetting = Assert.Single(configuration.ConfSetting);
+            Validate(confsetting);
+        }
+
+        /// <summary>
+        /// Validate a ConfLocation
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.ConfLocation? conflocation)
+        {
+            Assert.NotNull(conflocation);
+            Assert.Equal("XXXXXX", conflocation.Name);
+            Assert.Equal("XXXXXX", conflocation.Number);
+            Assert.Equal("XXXXXX", conflocation.Inverted);
+        }
+
+        /// <summary>
+        /// Validate a ConfSetting
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.ConfSetting? confsetting)
+        {
+            Assert.NotNull(confsetting);
+            Assert.Equal("XXXXXX", confsetting.Name);
+            Assert.Equal("XXXXXX", confsetting.Value);
+            Assert.Equal("XXXXXX", confsetting.Default);
+            Validate(confsetting.Condition);
+        }
+
+        /// <summary>
+        /// Validate a Port
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Port? port)
+        {
+            Assert.NotNull(port);
+            Assert.Equal("XXXXXX", port.Tag);
+
+            Assert.NotNull(port.Analog);
+            var analog = Assert.Single(port.Analog);
+            Validate(analog);
+        }
+
+        /// <summary>
+        /// Validate a Analog
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Analog? analog)
+        {
+            Assert.NotNull(analog);
+            Assert.Equal("XXXXXX", analog.Mask);
+        }
+
+        /// <summary>
+        /// Validate a Adjuster
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Adjuster? adjuster)
+        {
+            Assert.NotNull(adjuster);
+            Assert.Equal("XXXXXX", adjuster.Name);
+            Assert.Equal("XXXXXX", adjuster.Default);
+            Validate(adjuster.Condition);
+        }
+
+        /// <summary>
+        /// Validate a Driver
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Driver? driver)
+        {
+            Assert.NotNull(driver);
+            Assert.Equal("XXXXXX", driver.Status);
+            Assert.Equal("XXXXXX", driver.Color);
+            Assert.Equal("XXXXXX", driver.Sound);
+            Assert.Equal("XXXXXX", driver.PaletteSize);
+            Assert.Equal("XXXXXX", driver.Emulation);
+            Assert.Equal("XXXXXX", driver.Cocktail);
+            Assert.Equal("XXXXXX", driver.SaveState);
+            Assert.Equal("XXXXXX", driver.RequiresArtwork);
+            Assert.Equal("XXXXXX", driver.Unofficial);
+            Assert.Equal("XXXXXX", driver.NoSoundHardware);
+            Assert.Equal("XXXXXX", driver.Incomplete);
+        }
+
+        /// <summary>
+        /// Validate a Feature
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Feature? feature)
+        {
+            Assert.NotNull(feature);
+            Assert.Equal("XXXXXX", feature.Type);
+            Assert.Equal("XXXXXX", feature.Status);
+            Assert.Equal("XXXXXX", feature.Overall);
+        }
+
+        /// <summary>
+        /// Validate a Device
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Device? device)
+        {
+            Assert.NotNull(device);
+            Assert.Equal("XXXXXX", device.Type);
+            Assert.Equal("XXXXXX", device.Tag);
+            Assert.Equal("XXXXXX", device.FixedImage);
+            Assert.Equal("XXXXXX", device.Mandatory);
+            Assert.Equal("XXXXXX", device.Interface);
+            Validate(device.Instance);
+
+            Assert.NotNull(device.Extension);
+            var extension = Assert.Single(device.Extension);
+            Validate(extension);
+        }
+
+        /// <summary>
+        /// Validate a Instance
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Instance? instance)
+        {
+            Assert.NotNull(instance);
+            Assert.Equal("XXXXXX", instance.Name);
+            Assert.Equal("XXXXXX", instance.BriefName);
+        }
+
+        /// <summary>
+        /// Validate a Extension
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Extension? extension)
+        {
+            Assert.NotNull(extension);
+            Assert.Equal("XXXXXX", extension.Name);
+        }
+
+        /// <summary>
+        /// Validate a Slot
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Slot? slot)
+        {
+            Assert.NotNull(slot);
+            Assert.Equal("XXXXXX", slot.Name);
+
+            Assert.NotNull(slot.SlotOption);
+            var slotoption = Assert.Single(slot.SlotOption);
+            Validate(slotoption);
+        }
+
+        /// <summary>
+        /// Validate a SlotOption
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.SlotOption? slotoption)
+        {
+            Assert.NotNull(slotoption);
+            Assert.Equal("XXXXXX", slotoption.Name);
+            Assert.Equal("XXXXXX", slotoption.DevName);
+            Assert.Equal("XXXXXX", slotoption.Default);
+        }
+
+        /// <summary>
+        /// Validate a SoftwareList
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.SoftwareList? softwarelist)
+        {
+            Assert.NotNull(softwarelist);
+            Assert.Equal("XXXXXX", softwarelist.Tag);
+            Assert.Equal("XXXXXX", softwarelist.Name);
+            Assert.Equal("XXXXXX", softwarelist.Status);
+            Assert.Equal("XXXXXX", softwarelist.Filter);
+        }
+
+        /// <summary>
+        /// Validate a RamOption
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.RamOption? ramoption)
+        {
+            Assert.NotNull(ramoption);
+            Assert.Equal("XXXXXX", ramoption.Name);
+            Assert.Equal("XXXXXX", ramoption.Default);
+            Assert.Equal("XXXXXX", ramoption.Content);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/MSDOSTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class MSDOSTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new MSDOS();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new MSDOS();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new MSDOS();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new MSDOS();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new MSDOS();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new MSDOS();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/MessTests.cs

@@ -0,0 +1,940 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class MessTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new Mess();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new Mess();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new Mess();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new Mess();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new Mess();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new Mess();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void RoundTripGameTest()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new Mess();
+            var serializer = new SabreTools.Serialization.Writers.Mess();
+
+            // Build the data
+            Data.Models.Listxml.Mess m1 = Build(game: true);
+
+            // Serialize to generic model
+            Stream? metadata = serializer.Serialize(m1);
+            Assert.NotNull(metadata);
+
+            // Serialize to stream
+            Data.Models.Listxml.Mess? newMess = deserializer.Deserialize(metadata);
+
+            // Validate the data
+            Assert.NotNull(newMess);
+            Assert.Equal("XXXXXX", newMess.Version);
+
+            Assert.NotNull(newMess.Game);
+            var newGame = Assert.Single(newMess.Game);
+            Validate(newGame);
+        }
+
+        [Fact]
+        public void RoundTripMachineTest()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new Mess();
+            var serializer = new SabreTools.Serialization.Writers.Mess();
+
+            // Build the data
+            Data.Models.Listxml.Mess m1 = Build(game: false);
+
+            // Serialize to generic model
+            Stream? metadata = serializer.Serialize(m1);
+            Assert.NotNull(metadata);
+
+            // Serialize to stream
+            Data.Models.Listxml.Mess? newMess = deserializer.Deserialize(metadata);
+
+            // Validate the data
+            Assert.NotNull(newMess);
+            Assert.Equal("XXXXXX", newMess.Version);
+
+            Assert.NotNull(newMess.Game);
+            var newGame = Assert.Single(newMess.Game);
+            Validate(newGame);
+        }
+
+        /// <summary>
+        /// Build model for serialization and deserialization
+        /// </summary>
+        private static Data.Models.Listxml.Mess Build(bool game)
+        {
+            var biosset = new Data.Models.Listxml.BiosSet
+            {
+                Name = "XXXXXX",
+                Description = "XXXXXX",
+                Default = "XXXXXX",
+            };
+
+            var rom = new Data.Models.Listxml.Rom
+            {
+                Name = "XXXXXX",
+                Bios = "XXXXXX",
+                Size = "XXXXXX",
+                CRC = "XXXXXX",
+                SHA1 = "XXXXXX",
+                Merge = "XXXXXX",
+                Region = "XXXXXX",
+                Offset = "XXXXXX",
+                Status = "XXXXXX",
+                Optional = "XXXXXX",
+                Dispose = "XXXXXX",
+                SoundOnly = "XXXXXX",
+            };
+
+            var disk = new Data.Models.Listxml.Disk
+            {
+                Name = "XXXXXX",
+                MD5 = "XXXXXX",
+                SHA1 = "XXXXXX",
+                Merge = "XXXXXX",
+                Region = "XXXXXX",
+                Index = "XXXXXX",
+                Writable = "XXXXXX",
+                Status = "XXXXXX",
+                Optional = "XXXXXX",
+            };
+
+            var deviceref = new Data.Models.Listxml.DeviceRef
+            {
+                Name = "XXXXXX",
+            };
+
+            var sample = new Data.Models.Listxml.Sample
+            {
+                Name = "XXXXXX",
+            };
+
+            var chip = new Data.Models.Listxml.Chip
+            {
+                Name = "XXXXXX",
+                Tag = "XXXXXX",
+                Type = "XXXXXX",
+                SoundOnly = "XXXXXX",
+                Clock = "XXXXXX",
+            };
+
+            var display = new Data.Models.Listxml.Display
+            {
+                Tag = "XXXXXX",
+                Type = "XXXXXX",
+                Rotate = "XXXXXX",
+                FlipX = "XXXXXX",
+                Width = "XXXXXX",
+                Height = "XXXXXX",
+                Refresh = "XXXXXX",
+                PixClock = "XXXXXX",
+                HTotal = "XXXXXX",
+                HBEnd = "XXXXXX",
+                HBStart = "XXXXXX",
+                VTotal = "XXXXXX",
+                VBEnd = "XXXXXX",
+                VBStart = "XXXXXX",
+            };
+
+            var video = new Data.Models.Listxml.Video
+            {
+                Screen = "XXXXXX",
+                Orientation = "XXXXXX",
+                Width = "XXXXXX",
+                Height = "XXXXXX",
+                AspectX = "XXXXXX",
+                AspectY = "XXXXXX",
+                Refresh = "XXXXXX",
+            };
+
+            var sound = new Data.Models.Listxml.Sound
+            {
+                Channels = "XXXXXX",
+            };
+
+            var control = new Data.Models.Listxml.Control
+            {
+                Type = "XXXXXX",
+                Player = "XXXXXX",
+                Buttons = "XXXXXX",
+                ReqButtons = "XXXXXX",
+                Minimum = "XXXXXX",
+                Maximum = "XXXXXX",
+                Sensitivity = "XXXXXX",
+                KeyDelta = "XXXXXX",
+                Reverse = "XXXXXX",
+                Ways = "XXXXXX",
+                Ways2 = "XXXXXX",
+                Ways3 = "XXXXXX",
+            };
+
+            var input = new Data.Models.Listxml.Input
+            {
+                Service = "XXXXXX",
+                Tilt = "XXXXXX",
+                Players = "XXXXXX",
+                //ControlAttr = "XXXXXX", // Mututally exclusive with input.Control
+                Buttons = "XXXXXX",
+                Coins = "XXXXXX",
+                Control = [control],
+            };
+
+            var condition = new Data.Models.Listxml.Condition
+            {
+                Tag = "XXXXXX",
+                Mask = "XXXXXX",
+                Relation = "XXXXXX",
+                Value = "XXXXXX",
+            };
+
+            var diplocation = new Data.Models.Listxml.DipLocation
+            {
+                Name = "XXXXXX",
+                Number = "XXXXXX",
+                Inverted = "XXXXXX",
+            };
+
+            var dipvalue = new Data.Models.Listxml.DipValue
+            {
+                Name = "XXXXXX",
+                Value = "XXXXXX",
+                Default = "XXXXXX",
+                Condition = condition,
+            };
+
+            var dipswitch = new Data.Models.Listxml.DipSwitch
+            {
+                Name = "XXXXXX",
+                Tag = "XXXXXX",
+                Mask = "XXXXXX",
+                Condition = condition,
+                DipLocation = [diplocation],
+                DipValue = [dipvalue],
+            };
+
+            var conflocation = new Data.Models.Listxml.ConfLocation
+            {
+                Name = "XXXXXX",
+                Number = "XXXXXX",
+                Inverted = "XXXXXX",
+            };
+
+            var confsetting = new Data.Models.Listxml.ConfSetting
+            {
+                Name = "XXXXXX",
+                Value = "XXXXXX",
+                Default = "XXXXXX",
+                Condition = condition,
+            };
+
+            var configuration = new Data.Models.Listxml.Configuration
+            {
+                Name = "XXXXXX",
+                Tag = "XXXXXX",
+                Mask = "XXXXXX",
+                Condition = condition,
+                ConfLocation = [conflocation],
+                ConfSetting = [confsetting],
+            };
+
+            var analog = new Data.Models.Listxml.Analog
+            {
+                Mask = "XXXXXX",
+            };
+
+            var port = new Data.Models.Listxml.Port
+            {
+                Tag = "XXXXXX",
+                Analog = [analog],
+            };
+
+            var adjuster = new Data.Models.Listxml.Adjuster
+            {
+                Name = "XXXXXX",
+                Default = "XXXXXX",
+                Condition = condition,
+            };
+
+            var driver = new Data.Models.Listxml.Driver
+            {
+                Status = "XXXXXX",
+                Color = "XXXXXX",
+                Sound = "XXXXXX",
+                PaletteSize = "XXXXXX",
+                Emulation = "XXXXXX",
+                Cocktail = "XXXXXX",
+                SaveState = "XXXXXX",
+                RequiresArtwork = "XXXXXX",
+                Unofficial = "XXXXXX",
+                NoSoundHardware = "XXXXXX",
+                Incomplete = "XXXXXX",
+            };
+
+            var feature = new Data.Models.Listxml.Feature
+            {
+                Type = "XXXXXX",
+                Status = "XXXXXX",
+                Overall = "XXXXXX",
+            };
+
+            var instance = new Data.Models.Listxml.Instance
+            {
+                Name = "XXXXXX",
+                BriefName = "XXXXXX",
+            };
+
+            var extension = new Data.Models.Listxml.Extension
+            {
+                Name = "XXXXXX",
+            };
+
+            var device = new Data.Models.Listxml.Device
+            {
+                Type = "XXXXXX",
+                Tag = "XXXXXX",
+                FixedImage = "XXXXXX",
+                Mandatory = "XXXXXX",
+                Interface = "XXXXXX",
+                Instance = instance,
+                Extension = [extension],
+            };
+
+            var slotOption = new Data.Models.Listxml.SlotOption
+            {
+                Name = "XXXXXX",
+                DevName = "XXXXXX",
+                Default = "XXXXXX",
+            };
+
+            var slot = new Data.Models.Listxml.Slot
+            {
+                Name = "XXXXXX",
+                SlotOption = [slotOption],
+            };
+
+            var softwarelist = new Data.Models.Listxml.SoftwareList
+            {
+                Tag = "XXXXXX",
+                Name = "XXXXXX",
+                Status = "XXXXXX",
+                Filter = "XXXXXX",
+            };
+
+            var ramoption = new Data.Models.Listxml.RamOption
+            {
+                Name = "XXXXXX",
+                Default = "XXXXXX",
+                Content = "XXXXXX",
+            };
+
+            Data.Models.Listxml.GameBase gameBase = game
+                ? new Data.Models.Listxml.Game()
+                : new Data.Models.Listxml.Machine();
+            gameBase.Name = "XXXXXX";
+            gameBase.SourceFile = "XXXXXX";
+            gameBase.IsBios = "XXXXXX";
+            gameBase.IsDevice = "XXXXXX";
+            gameBase.IsMechanical = "XXXXXX";
+            gameBase.Runnable = "XXXXXX";
+            gameBase.CloneOf = "XXXXXX";
+            gameBase.RomOf = "XXXXXX";
+            gameBase.SampleOf = "XXXXXX";
+            gameBase.Description = "XXXXXX";
+            gameBase.Year = "XXXXXX";
+            gameBase.Manufacturer = "XXXXXX";
+            gameBase.History = "XXXXXX";
+            gameBase.BiosSet = [biosset];
+            gameBase.Rom = [rom];
+            gameBase.Disk = [disk];
+            gameBase.DeviceRef = [deviceref];
+            gameBase.Sample = [sample];
+            gameBase.Chip = [chip];
+            gameBase.Display = [display];
+            gameBase.Video = [video];
+            gameBase.Sound = sound;
+            gameBase.Input = input;
+            gameBase.DipSwitch = [dipswitch];
+            gameBase.Configuration = [configuration];
+            gameBase.Port = [port];
+            gameBase.Adjuster = [adjuster];
+            gameBase.Driver = driver;
+            gameBase.Feature = [feature];
+            gameBase.Device = [device];
+            gameBase.Slot = [slot];
+            gameBase.SoftwareList = [softwarelist];
+            gameBase.RamOption = [ramoption];
+
+            return new Data.Models.Listxml.Mess
+            {
+                Version = "XXXXXX",
+                Game = [gameBase],
+            };
+        }
+
+        /// <summary>
+        /// Validate a GameBase
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.GameBase? gb)
+        {
+            Assert.NotNull(gb);
+            Assert.Equal("XXXXXX", gb.Name);
+            Assert.Equal("XXXXXX", gb.SourceFile);
+            Assert.Equal("XXXXXX", gb.IsBios);
+            Assert.Equal("XXXXXX", gb.IsDevice);
+            Assert.Equal("XXXXXX", gb.IsMechanical);
+            Assert.Equal("XXXXXX", gb.Runnable);
+            Assert.Equal("XXXXXX", gb.CloneOf);
+            Assert.Equal("XXXXXX", gb.RomOf);
+            Assert.Equal("XXXXXX", gb.SampleOf);
+            Assert.Equal("XXXXXX", gb.Description);
+            Assert.Equal("XXXXXX", gb.Year);
+            Assert.Equal("XXXXXX", gb.Manufacturer);
+            Assert.Equal("XXXXXX", gb.History);
+
+            Assert.NotNull(gb.BiosSet);
+            var biosset = Assert.Single(gb.BiosSet);
+            Validate(biosset);
+
+            Assert.NotNull(gb.Rom);
+            var rom = Assert.Single(gb.Rom);
+            Validate(rom);
+
+            Assert.NotNull(gb.Disk);
+            var disk = Assert.Single(gb.Disk);
+            Validate(disk);
+
+            Assert.NotNull(gb.DeviceRef);
+            var deviceref = Assert.Single(gb.DeviceRef);
+            Validate(deviceref);
+
+            Assert.NotNull(gb.Sample);
+            var sample = Assert.Single(gb.Sample);
+            Validate(sample);
+
+            Assert.NotNull(gb.Chip);
+            var chip = Assert.Single(gb.Chip);
+            Validate(chip);
+
+            Assert.NotNull(gb.Display);
+            var display = Assert.Single(gb.Display);
+            Validate(display);
+
+            Assert.NotNull(gb.Video);
+            var video = Assert.Single(gb.Video);
+            Validate(video);
+
+            Validate(gb.Sound);
+            Validate(gb.Input);
+
+            Assert.NotNull(gb.DipSwitch);
+            var dipswitch = Assert.Single(gb.DipSwitch);
+            Validate(dipswitch);
+
+            Assert.NotNull(gb.Configuration);
+            var configuration = Assert.Single(gb.Configuration);
+            Validate(configuration);
+
+            Assert.NotNull(gb.Port);
+            var port = Assert.Single(gb.Port);
+            Validate(port);
+
+            Assert.NotNull(gb.Adjuster);
+            var adjuster = Assert.Single(gb.Adjuster);
+            Validate(adjuster);
+
+            Validate(gb.Driver);
+
+            Assert.NotNull(gb.Feature);
+            var feature = Assert.Single(gb.Feature);
+            Validate(feature);
+
+            Assert.NotNull(gb.Device);
+            var device = Assert.Single(gb.Device);
+            Validate(device);
+
+            Assert.NotNull(gb.Slot);
+            var slot = Assert.Single(gb.Slot);
+            Validate(slot);
+
+            Assert.NotNull(gb.SoftwareList);
+            var softwarelist = Assert.Single(gb.SoftwareList);
+            Validate(softwarelist);
+
+            Assert.NotNull(gb.RamOption);
+            var ramoption = Assert.Single(gb.RamOption);
+            Validate(ramoption);
+        }
+
+        /// <summary>
+        /// Validate a BiosSet
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.BiosSet? biosset)
+        {
+            Assert.NotNull(biosset);
+            Assert.Equal("XXXXXX", biosset.Name);
+            Assert.Equal("XXXXXX", biosset.Description);
+            Assert.Equal("XXXXXX", biosset.Default);
+        }
+
+        /// <summary>
+        /// Validate a Rom
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Rom? rom)
+        {
+            Assert.NotNull(rom);
+            Assert.Equal("XXXXXX", rom.Name);
+            Assert.Equal("XXXXXX", rom.Bios);
+            Assert.Equal("XXXXXX", rom.Size);
+            Assert.Equal("XXXXXX", rom.CRC);
+            Assert.Equal("XXXXXX", rom.SHA1);
+            Assert.Equal("XXXXXX", rom.Merge);
+            Assert.Equal("XXXXXX", rom.Region);
+            Assert.Equal("XXXXXX", rom.Offset);
+            Assert.Equal("XXXXXX", rom.Status);
+            Assert.Equal("XXXXXX", rom.Optional);
+            Assert.Equal("XXXXXX", rom.Dispose);
+            Assert.Equal("XXXXXX", rom.SoundOnly);
+        }
+
+        /// <summary>
+        /// Validate a Disk
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Disk? disk)
+        {
+            Assert.NotNull(disk);
+            Assert.Equal("XXXXXX", disk.Name);
+            Assert.Equal("XXXXXX", disk.MD5);
+            Assert.Equal("XXXXXX", disk.SHA1);
+            Assert.Equal("XXXXXX", disk.Merge);
+            Assert.Equal("XXXXXX", disk.Region);
+            Assert.Equal("XXXXXX", disk.Index);
+            Assert.Equal("XXXXXX", disk.Writable);
+            Assert.Equal("XXXXXX", disk.Status);
+            Assert.Equal("XXXXXX", disk.Optional);
+        }
+
+        /// <summary>
+        /// Validate a DeviceRef
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.DeviceRef? deviceref)
+        {
+            Assert.NotNull(deviceref);
+            Assert.Equal("XXXXXX", deviceref.Name);
+        }
+
+        /// <summary>
+        /// Validate a Sample
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Sample? sample)
+        {
+            Assert.NotNull(sample);
+            Assert.Equal("XXXXXX", sample.Name);
+        }
+
+        /// <summary>
+        /// Validate a Chip
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Chip? chip)
+        {
+            Assert.NotNull(chip);
+            Assert.Equal("XXXXXX", chip.Name);
+            Assert.Equal("XXXXXX", chip.Tag);
+            Assert.Equal("XXXXXX", chip.Type);
+            Assert.Equal("XXXXXX", chip.SoundOnly);
+            Assert.Equal("XXXXXX", chip.Clock);
+        }
+
+        /// <summary>
+        /// Validate a Display
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Display? display)
+        {
+            Assert.NotNull(display);
+            Assert.Equal("XXXXXX", display.Tag);
+            Assert.Equal("XXXXXX", display.Type);
+            Assert.Equal("XXXXXX", display.Rotate);
+            Assert.Equal("XXXXXX", display.FlipX);
+            Assert.Equal("XXXXXX", display.Width);
+            Assert.Equal("XXXXXX", display.Height);
+            Assert.Equal("XXXXXX", display.Refresh);
+            Assert.Equal("XXXXXX", display.PixClock);
+            Assert.Equal("XXXXXX", display.HTotal);
+            Assert.Equal("XXXXXX", display.HBEnd);
+            Assert.Equal("XXXXXX", display.HBStart);
+            Assert.Equal("XXXXXX", display.VTotal);
+            Assert.Equal("XXXXXX", display.VBEnd);
+            Assert.Equal("XXXXXX", display.VBStart);
+        }
+
+        /// <summary>
+        /// Validate a Video
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Video? video)
+        {
+            Assert.NotNull(video);
+            Assert.Equal("XXXXXX", video.Screen);
+            Assert.Equal("XXXXXX", video.Orientation);
+            Assert.Equal("XXXXXX", video.Width);
+            Assert.Equal("XXXXXX", video.Height);
+            Assert.Equal("XXXXXX", video.AspectX);
+            Assert.Equal("XXXXXX", video.AspectY);
+            Assert.Equal("XXXXXX", video.Refresh);
+        }
+
+        /// <summary>
+        /// Validate a Sound
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Sound? sound)
+        {
+            Assert.NotNull(sound);
+            Assert.Equal("XXXXXX", sound.Channels);
+        }
+
+        /// <summary>
+        /// Validate a Input
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Input? input)
+        {
+            Assert.NotNull(input);
+            Assert.Equal("XXXXXX", input.Service);
+            Assert.Equal("XXXXXX", input.Tilt);
+            Assert.Equal("XXXXXX", input.Players);
+            //Assert.Equal("XXXXXX", input.ControlAttr); // Mututally exclusive with input.Control
+            Assert.Equal("XXXXXX", input.Buttons);
+            Assert.Equal("XXXXXX", input.Coins);
+
+            Assert.NotNull(input.Control);
+            var control = Assert.Single(input.Control);
+            Validate(control);
+        }
+
+        /// <summary>
+        /// Validate a Control
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Control? control)
+        {
+            Assert.NotNull(control);
+            Assert.Equal("XXXXXX", control.Type);
+            Assert.Equal("XXXXXX", control.Player);
+            Assert.Equal("XXXXXX", control.Buttons);
+            Assert.Equal("XXXXXX", control.ReqButtons);
+            Assert.Equal("XXXXXX", control.Minimum);
+            Assert.Equal("XXXXXX", control.Maximum);
+            Assert.Equal("XXXXXX", control.Sensitivity);
+            Assert.Equal("XXXXXX", control.KeyDelta);
+            Assert.Equal("XXXXXX", control.Reverse);
+            Assert.Equal("XXXXXX", control.Ways);
+            Assert.Equal("XXXXXX", control.Ways2);
+            Assert.Equal("XXXXXX", control.Ways3);
+        }
+
+        /// <summary>
+        /// Validate a DipSwitch
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.DipSwitch? dipswitch)
+        {
+            Assert.NotNull(dipswitch);
+            Assert.Equal("XXXXXX", dipswitch.Name);
+            Assert.Equal("XXXXXX", dipswitch.Tag);
+            Assert.Equal("XXXXXX", dipswitch.Mask);
+            Validate(dipswitch.Condition);
+
+            Assert.NotNull(dipswitch.DipLocation);
+            var diplocation = Assert.Single(dipswitch.DipLocation);
+            Validate(diplocation);
+
+            Assert.NotNull(dipswitch.DipValue);
+            var dipvalue = Assert.Single(dipswitch.DipValue);
+            Validate(dipvalue);
+        }
+
+        /// <summary>
+        /// Validate a Condition
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Condition? condition)
+        {
+            Assert.NotNull(condition);
+            Assert.Equal("XXXXXX", condition.Tag);
+            Assert.Equal("XXXXXX", condition.Mask);
+            Assert.Equal("XXXXXX", condition.Relation);
+            Assert.Equal("XXXXXX", condition.Value);
+        }
+
+        /// <summary>
+        /// Validate a DipLocation
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.DipLocation? diplocation)
+        {
+            Assert.NotNull(diplocation);
+            Assert.Equal("XXXXXX", diplocation.Name);
+            Assert.Equal("XXXXXX", diplocation.Number);
+            Assert.Equal("XXXXXX", diplocation.Inverted);
+        }
+
+        /// <summary>
+        /// Validate a DipValue
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.DipValue? dipvalue)
+        {
+            Assert.NotNull(dipvalue);
+            Assert.Equal("XXXXXX", dipvalue.Name);
+            Assert.Equal("XXXXXX", dipvalue.Value);
+            Assert.Equal("XXXXXX", dipvalue.Default);
+            Validate(dipvalue.Condition);
+        }
+
+        /// <summary>
+        /// Validate a Configuration
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Configuration? configuration)
+        {
+            Assert.NotNull(configuration);
+            Assert.Equal("XXXXXX", configuration.Name);
+            Assert.Equal("XXXXXX", configuration.Tag);
+            Assert.Equal("XXXXXX", configuration.Mask);
+            Validate(configuration.Condition);
+
+            Assert.NotNull(configuration.ConfLocation);
+            var conflocation = Assert.Single(configuration.ConfLocation);
+            Validate(conflocation);
+
+            Assert.NotNull(configuration.ConfSetting);
+            var confsetting = Assert.Single(configuration.ConfSetting);
+            Validate(confsetting);
+        }
+
+        /// <summary>
+        /// Validate a ConfLocation
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.ConfLocation? conflocation)
+        {
+            Assert.NotNull(conflocation);
+            Assert.Equal("XXXXXX", conflocation.Name);
+            Assert.Equal("XXXXXX", conflocation.Number);
+            Assert.Equal("XXXXXX", conflocation.Inverted);
+        }
+
+        /// <summary>
+        /// Validate a ConfSetting
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.ConfSetting? confsetting)
+        {
+            Assert.NotNull(confsetting);
+            Assert.Equal("XXXXXX", confsetting.Name);
+            Assert.Equal("XXXXXX", confsetting.Value);
+            Assert.Equal("XXXXXX", confsetting.Default);
+            Validate(confsetting.Condition);
+        }
+
+        /// <summary>
+        /// Validate a Port
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Port? port)
+        {
+            Assert.NotNull(port);
+            Assert.Equal("XXXXXX", port.Tag);
+
+            Assert.NotNull(port.Analog);
+            var analog = Assert.Single(port.Analog);
+            Validate(analog);
+        }
+
+        /// <summary>
+        /// Validate a Analog
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Analog? analog)
+        {
+            Assert.NotNull(analog);
+            Assert.Equal("XXXXXX", analog.Mask);
+        }
+
+        /// <summary>
+        /// Validate a Adjuster
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Adjuster? adjuster)
+        {
+            Assert.NotNull(adjuster);
+            Assert.Equal("XXXXXX", adjuster.Name);
+            Assert.Equal("XXXXXX", adjuster.Default);
+            Validate(adjuster.Condition);
+        }
+
+        /// <summary>
+        /// Validate a Driver
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Driver? driver)
+        {
+            Assert.NotNull(driver);
+            Assert.Equal("XXXXXX", driver.Status);
+            Assert.Equal("XXXXXX", driver.Color);
+            Assert.Equal("XXXXXX", driver.Sound);
+            Assert.Equal("XXXXXX", driver.PaletteSize);
+            Assert.Equal("XXXXXX", driver.Emulation);
+            Assert.Equal("XXXXXX", driver.Cocktail);
+            Assert.Equal("XXXXXX", driver.SaveState);
+            Assert.Equal("XXXXXX", driver.RequiresArtwork);
+            Assert.Equal("XXXXXX", driver.Unofficial);
+            Assert.Equal("XXXXXX", driver.NoSoundHardware);
+            Assert.Equal("XXXXXX", driver.Incomplete);
+        }
+
+        /// <summary>
+        /// Validate a Feature
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Feature? feature)
+        {
+            Assert.NotNull(feature);
+            Assert.Equal("XXXXXX", feature.Type);
+            Assert.Equal("XXXXXX", feature.Status);
+            Assert.Equal("XXXXXX", feature.Overall);
+        }
+
+        /// <summary>
+        /// Validate a Device
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Device? device)
+        {
+            Assert.NotNull(device);
+            Assert.Equal("XXXXXX", device.Type);
+            Assert.Equal("XXXXXX", device.Tag);
+            Assert.Equal("XXXXXX", device.FixedImage);
+            Assert.Equal("XXXXXX", device.Mandatory);
+            Assert.Equal("XXXXXX", device.Interface);
+            Validate(device.Instance);
+
+            Assert.NotNull(device.Extension);
+            var extension = Assert.Single(device.Extension);
+            Validate(extension);
+        }
+
+        /// <summary>
+        /// Validate a Instance
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Instance? instance)
+        {
+            Assert.NotNull(instance);
+            Assert.Equal("XXXXXX", instance.Name);
+            Assert.Equal("XXXXXX", instance.BriefName);
+        }
+
+        /// <summary>
+        /// Validate a Extension
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Extension? extension)
+        {
+            Assert.NotNull(extension);
+            Assert.Equal("XXXXXX", extension.Name);
+        }
+
+        /// <summary>
+        /// Validate a Slot
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.Slot? slot)
+        {
+            Assert.NotNull(slot);
+            Assert.Equal("XXXXXX", slot.Name);
+
+            Assert.NotNull(slot.SlotOption);
+            var slotoption = Assert.Single(slot.SlotOption);
+            Validate(slotoption);
+        }
+
+        /// <summary>
+        /// Validate a SlotOption
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.SlotOption? slotoption)
+        {
+            Assert.NotNull(slotoption);
+            Assert.Equal("XXXXXX", slotoption.Name);
+            Assert.Equal("XXXXXX", slotoption.DevName);
+            Assert.Equal("XXXXXX", slotoption.Default);
+        }
+
+        /// <summary>
+        /// Validate a SoftwareList
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.SoftwareList? softwarelist)
+        {
+            Assert.NotNull(softwarelist);
+            Assert.Equal("XXXXXX", softwarelist.Tag);
+            Assert.Equal("XXXXXX", softwarelist.Name);
+            Assert.Equal("XXXXXX", softwarelist.Status);
+            Assert.Equal("XXXXXX", softwarelist.Filter);
+        }
+
+        /// <summary>
+        /// Validate a RamOption
+        /// </summary>
+        private static void Validate(Data.Models.Listxml.RamOption? ramoption)
+        {
+            Assert.NotNull(ramoption);
+            Assert.Equal("XXXXXX", ramoption.Name);
+            Assert.Equal("XXXXXX", ramoption.Default);
+            Assert.Equal("XXXXXX", ramoption.Content);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/MicrosoftCabinetTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class MicrosoftCabinetTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new MicrosoftCabinet();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new MicrosoftCabinet();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new MicrosoftCabinet();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new MicrosoftCabinet();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new MicrosoftCabinet();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new MicrosoftCabinet();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/MoPaQTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class MoPaQTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new MoPaQ();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new MoPaQ();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new MoPaQ();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new MoPaQ();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new MoPaQ();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new MoPaQ();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/N3DSTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class N3DSTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new N3DS();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new N3DS();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new N3DS();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new N3DS();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new N3DS();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new N3DS();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/NCFTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class NCFTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new NCF();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new NCF();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new NCF();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new NCF();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new NCF();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new NCF();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/NewExecutableTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class NewExecutableTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new NewExecutable();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new NewExecutable();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new NewExecutable();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new NewExecutable();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new NewExecutable();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new NewExecutable();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/NitroTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class NitroTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new Nitro();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new Nitro();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new Nitro();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new Nitro();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new Nitro();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new Nitro();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/OfflineListTests.cs

@@ -0,0 +1,517 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class OfflineListTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new OfflineList();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new OfflineList();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new OfflineList();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new OfflineList();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new OfflineList();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new OfflineList();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void RoundTripTest()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new OfflineList();
+            var serializer = new SabreTools.Serialization.Writers.OfflineList();
+
+            // Build the data
+            Data.Models.OfflineList.Dat dat = Build();
+
+            // Serialize to stream
+            Stream? metadata = serializer.Serialize(dat);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.OfflineList.Dat? newDat = deserializer.Deserialize(metadata);
+
+            // Validate the data
+            Assert.NotNull(newDat);
+            Assert.Equal("XXXXXX", newDat.NoNamespaceSchemaLocation);
+            Validate(newDat.Configuration);
+            Validate(newDat.Games);
+            Validate(newDat.GUI);
+        }
+
+        /// <summary>
+        /// Build model for serialization and deserialization
+        /// </summary>
+        private static Data.Models.OfflineList.Dat Build()
+        {
+            var infos = new Data.Models.OfflineList.Infos
+            {
+                Title = new Data.Models.OfflineList.Title
+                {
+                    Visible = "XXXXXX",
+                    InNamingOption = "XXXXXX",
+                    Default = "XXXXXX",
+                },
+                Location = new Data.Models.OfflineList.Location
+                {
+                    Visible = "XXXXXX",
+                    InNamingOption = "XXXXXX",
+                    Default = "XXXXXX",
+                },
+                Publisher = new Data.Models.OfflineList.Publisher
+                {
+                    Visible = "XXXXXX",
+                    InNamingOption = "XXXXXX",
+                    Default = "XXXXXX",
+                },
+                SourceRom = new Data.Models.OfflineList.SourceRom
+                {
+                    Visible = "XXXXXX",
+                    InNamingOption = "XXXXXX",
+                    Default = "XXXXXX",
+                },
+                SaveType = new Data.Models.OfflineList.SaveType
+                {
+                    Visible = "XXXXXX",
+                    InNamingOption = "XXXXXX",
+                    Default = "XXXXXX",
+                },
+                RomSize = new Data.Models.OfflineList.RomSize
+                {
+                    Visible = "XXXXXX",
+                    InNamingOption = "XXXXXX",
+                    Default = "XXXXXX",
+                },
+                ReleaseNumber = new Data.Models.OfflineList.ReleaseNumber
+                {
+                    Visible = "XXXXXX",
+                    InNamingOption = "XXXXXX",
+                    Default = "XXXXXX",
+                },
+                ImageNumber = new Data.Models.OfflineList.ImageNumber
+                {
+                    Visible = "XXXXXX",
+                    InNamingOption = "XXXXXX",
+                    Default = "XXXXXX",
+                },
+                LanguageNumber = new Data.Models.OfflineList.LanguageNumber
+                {
+                    Visible = "XXXXXX",
+                    InNamingOption = "XXXXXX",
+                    Default = "XXXXXX",
+                },
+                Comment = new Data.Models.OfflineList.Comment
+                {
+                    Visible = "XXXXXX",
+                    InNamingOption = "XXXXXX",
+                    Default = "XXXXXX",
+                },
+                RomCRC = new Data.Models.OfflineList.RomCRC
+                {
+                    Visible = "XXXXXX",
+                    InNamingOption = "XXXXXX",
+                    Default = "XXXXXX",
+                },
+                Im1CRC = new Data.Models.OfflineList.Im1CRC
+                {
+                    Visible = "XXXXXX",
+                    InNamingOption = "XXXXXX",
+                    Default = "XXXXXX",
+                },
+                Im2CRC = new Data.Models.OfflineList.Im2CRC
+                {
+                    Visible = "XXXXXX",
+                    InNamingOption = "XXXXXX",
+                    Default = "XXXXXX",
+                },
+                Languages = new Data.Models.OfflineList.Languages
+                {
+                    Visible = "XXXXXX",
+                    InNamingOption = "XXXXXX",
+                    Default = "XXXXXX",
+                },
+            };
+
+            var canopen = new Data.Models.OfflineList.CanOpen
+            {
+                Extension = ["XXXXXX"],
+            };
+
+            var daturl = new Data.Models.OfflineList.DatUrl
+            {
+                FileName = "XXXXXX",
+                Content = "XXXXXX",
+            };
+
+            var newdat = new Data.Models.OfflineList.NewDat
+            {
+                DatVersionUrl = "XXXXXX",
+                DatUrl = daturl,
+                ImUrl = "XXXXXX",
+            };
+
+            var find = new Data.Models.OfflineList.Find
+            {
+                Operation = "XXXXXX",
+                Value = "XXXXXX",
+                Content = "XXXXXX",
+            };
+
+            var to = new Data.Models.OfflineList.To
+            {
+                Value = "XXXXXX",
+                Default = "XXXXXX",
+                Auto = "XXXXXX",
+                Find = [find],
+            };
+
+            var search = new Data.Models.OfflineList.Search
+            {
+                To = [to],
+            };
+
+            var configuration = new Data.Models.OfflineList.Configuration
+            {
+                DatName = "XXXXXX",
+                ImFolder = "XXXXXX",
+                DatVersion = "XXXXXX",
+                System = "XXXXXX",
+                ScreenshotsWidth = "XXXXXX",
+                ScreenshotsHeight = "XXXXXX",
+                Infos = infos,
+                CanOpen = canopen,
+                NewDat = newdat,
+                Search = search,
+                RomTitle = "XXXXXX",
+            };
+
+            var fileromcrc = new Data.Models.OfflineList.FileRomCRC
+            {
+                Extension = "XXXXXX",
+                Content = "XXXXXX",
+            };
+
+            var files = new Data.Models.OfflineList.Files
+            {
+                RomCRC = [fileromcrc],
+            };
+
+            var game = new Data.Models.OfflineList.Game
+            {
+                ImageNumber = "XXXXXX",
+                ReleaseNumber = "XXXXXX",
+                Title = "XXXXXX",
+                SaveType = "XXXXXX",
+                RomSize = "XXXXXX",
+                Publisher = "XXXXXX",
+                Location = "XXXXXX",
+                SourceRom = "XXXXXX",
+                Language = "XXXXXX",
+                Files = files,
+                Im1CRC = "XXXXXX",
+                Im2CRC = "XXXXXX",
+                Comment = "XXXXXX",
+                DuplicateID = "XXXXXX",
+            };
+
+            var games = new Data.Models.OfflineList.Games
+            {
+                Game = [game],
+            };
+
+            var image = new Data.Models.OfflineList.Image
+            {
+                X = "XXXXXX",
+                Y = "XXXXXX",
+                Width = "XXXXXX",
+                Height = "XXXXXX",
+            };
+
+            var images = new Data.Models.OfflineList.Images
+            {
+                Width = "XXXXXX",
+                Height = "XXXXXX",
+                Image = [image],
+            };
+
+            var gui = new Data.Models.OfflineList.GUI
+            {
+                Images = images,
+            };
+
+            return new Data.Models.OfflineList.Dat
+            {
+                NoNamespaceSchemaLocation = "XXXXXX",
+                Configuration = configuration,
+                Games = games,
+                GUI = gui,
+            };
+        }
+
+        /// <summary>
+        /// Validate a Configuration
+        /// </summary>
+        private static void Validate(Data.Models.OfflineList.Configuration? configuration)
+        {
+            Assert.NotNull(configuration);
+            Assert.Equal("XXXXXX", configuration.DatName);
+            Assert.Equal("XXXXXX", configuration.ImFolder);
+            Assert.Equal("XXXXXX", configuration.DatVersion);
+            Assert.Equal("XXXXXX", configuration.System);
+            Assert.Equal("XXXXXX", configuration.ScreenshotsWidth);
+            Assert.Equal("XXXXXX", configuration.ScreenshotsHeight);
+            Validate(configuration.Infos);
+            Validate(configuration.CanOpen);
+            Validate(configuration.NewDat);
+            Validate(configuration.Search);
+            Assert.Equal("XXXXXX", configuration.RomTitle);
+        }
+
+        /// <summary>
+        /// Validate a Infos
+        /// </summary>
+        private static void Validate(Data.Models.OfflineList.Infos? infos)
+        {
+            Assert.NotNull(infos);
+            Validate(infos.Title);
+            Validate(infos.Location);
+            Validate(infos.Publisher);
+            Validate(infos.SourceRom);
+            Validate(infos.SaveType);
+            Validate(infos.RomSize);
+            Validate(infos.ReleaseNumber);
+            Validate(infos.ImageNumber);
+            Validate(infos.LanguageNumber);
+            Validate(infos.Comment);
+            Validate(infos.RomCRC);
+            Validate(infos.Im1CRC);
+            Validate(infos.Im2CRC);
+            Validate(infos.Languages);
+        }
+
+        /// <summary>
+        /// Validate a InfoBase
+        /// </summary>
+        private static void Validate(Data.Models.OfflineList.InfoBase? info)
+        {
+            Assert.NotNull(info);
+            Assert.Equal("XXXXXX", info.Visible);
+            Assert.Equal("XXXXXX", info.InNamingOption);
+            Assert.Equal("XXXXXX", info.Default);
+        }
+
+        /// <summary>
+        /// Validate a CanOpen
+        /// </summary>
+        private static void Validate(Data.Models.OfflineList.CanOpen? canopen)
+        {
+            Assert.NotNull(canopen);
+            Assert.NotNull(canopen.Extension);
+            string extension = Assert.Single(canopen.Extension);
+            Assert.Equal("XXXXXX", extension);
+        }
+
+        /// <summary>
+        /// Validate a NewDat
+        /// </summary>
+        private static void Validate(Data.Models.OfflineList.NewDat? newdat)
+        {
+            Assert.NotNull(newdat);
+            Assert.Equal("XXXXXX", newdat.DatVersionUrl);
+            Validate(newdat.DatUrl);
+            Assert.Equal("XXXXXX", newdat.ImUrl);
+        }
+
+        /// <summary>
+        /// Validate a DatUrl
+        /// </summary>
+        private static void Validate(Data.Models.OfflineList.DatUrl? daturl)
+        {
+            Assert.NotNull(daturl);
+            Assert.Equal("XXXXXX", daturl.FileName);
+            Assert.Equal("XXXXXX", daturl.Content);
+        }
+
+        /// <summary>
+        /// Validate a Search
+        /// </summary>
+        private static void Validate(Data.Models.OfflineList.Search? search)
+        {
+            Assert.NotNull(search);
+            Assert.NotNull(search.To);
+            var to = Assert.Single(search.To);
+            Validate(to);
+        }
+
+        /// <summary>
+        /// Validate a To
+        /// </summary>
+        private static void Validate(Data.Models.OfflineList.To? to)
+        {
+            Assert.NotNull(to);
+            Assert.Equal("XXXXXX", to.Value);
+            Assert.Equal("XXXXXX", to.Default);
+            Assert.Equal("XXXXXX", to.Auto);
+
+            Assert.NotNull(to.Find);
+            var find = Assert.Single(to.Find);
+            Validate(find);
+        }
+
+        /// <summary>
+        /// Validate a Find
+        /// </summary>
+        private static void Validate(Data.Models.OfflineList.Find? find)
+        {
+            Assert.NotNull(find);
+            Assert.Equal("XXXXXX", find.Operation);
+            Assert.Equal("XXXXXX", find.Value);
+            Assert.Equal("XXXXXX", find.Content);
+        }
+
+        /// <summary>
+        /// Validate a Games
+        /// </summary>
+        private static void Validate(Data.Models.OfflineList.Games? games)
+        {
+            Assert.NotNull(games);
+            Assert.NotNull(games.Game);
+            var game = Assert.Single(games.Game);
+            Validate(game);
+        }
+
+        /// <summary>
+        /// Validate a Game
+        /// </summary>
+        private static void Validate(Data.Models.OfflineList.Game? game)
+        {
+            Assert.NotNull(game);
+            Assert.Equal("XXXXXX", game.ImageNumber);
+            Assert.Equal("XXXXXX", game.ReleaseNumber);
+            Assert.Equal("XXXXXX", game.Title);
+            Assert.Equal("XXXXXX", game.SaveType);
+            Assert.Equal("XXXXXX", game.RomSize);
+            Assert.Equal("XXXXXX", game.Publisher);
+            Assert.Equal("XXXXXX", game.Location);
+            Assert.Equal("XXXXXX", game.SourceRom);
+            Assert.Equal("XXXXXX", game.Language);
+            Validate(game.Files);
+            Assert.Equal("XXXXXX", game.Im1CRC);
+            Assert.Equal("XXXXXX", game.Im2CRC);
+            Assert.Equal("XXXXXX", game.Comment);
+            Assert.Equal("XXXXXX", game.DuplicateID);
+        }
+
+        /// <summary>
+        /// Validate a Files
+        /// </summary>
+        private static void Validate(Data.Models.OfflineList.Files? files)
+        {
+            Assert.NotNull(files);
+            Assert.NotNull(files.RomCRC);
+            var fileromcrc = Assert.Single(files.RomCRC);
+            Validate(fileromcrc);
+        }
+
+        /// <summary>
+        /// Validate a FileRomCRC
+        /// </summary>
+        private static void Validate(Data.Models.OfflineList.FileRomCRC? fileromcrc)
+        {
+            Assert.NotNull(fileromcrc);
+            Assert.Equal("XXXXXX", fileromcrc.Extension);
+            Assert.Equal("XXXXXX", fileromcrc.Content);
+        }
+
+        /// <summary>
+        /// Validate a GUI
+        /// </summary>
+        private static void Validate(Data.Models.OfflineList.GUI? gui)
+        {
+            Assert.NotNull(gui);
+            Validate(gui.Images);
+        }
+
+        /// <summary>
+        /// Validate a Images
+        /// </summary>
+        private static void Validate(Data.Models.OfflineList.Images? images)
+        {
+            Assert.NotNull(images);
+            Assert.Equal("XXXXXX", images.Width);
+            Assert.Equal("XXXXXX", images.Height);
+
+            Assert.NotNull(images.Image);
+            var image = Assert.Single(images.Image);
+            Validate(image);
+        }
+
+        /// <summary>
+        /// Validate a Image
+        /// </summary>
+        private static void Validate(Data.Models.OfflineList.Image? image)
+        {
+            Assert.NotNull(image);
+            Assert.Equal("XXXXXX", image.X);
+            Assert.Equal("XXXXXX", image.Y);
+            Assert.Equal("XXXXXX", image.Width);
+            Assert.Equal("XXXXXX", image.Height);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/OpenMSXTests.cs

@@ -0,0 +1,223 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class OpenMSXTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new OpenMSX();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new OpenMSX();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new OpenMSX();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new OpenMSX();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new OpenMSX();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new OpenMSX();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void RoundTripTest()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new OpenMSX();
+            var serializer = new SabreTools.Serialization.Writers.OpenMSX();
+
+            // Build the data
+            Data.Models.OpenMSX.SoftwareDb sdb = Build();
+
+            // Serialize to stream
+            Stream? metadata = serializer.Serialize(sdb);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.OpenMSX.SoftwareDb? newSdb = deserializer.Deserialize(metadata);
+
+            // Validate the data
+            Assert.NotNull(newSdb);
+            Assert.Equal("XXXXXX", newSdb.Timestamp);
+
+            Assert.NotNull(newSdb.Software);
+            var software = Assert.Single(newSdb.Software);
+            Validate(software);
+        }
+
+        /// <summary>
+        /// Build model for serialization and deserialization
+        /// </summary>
+        private static Data.Models.OpenMSX.SoftwareDb Build()
+        {
+            var original = new Data.Models.OpenMSX.Original
+            {
+                Value = "XXXXXX",
+                Content = "XXXXXX",
+            };
+
+            var rom = new Data.Models.OpenMSX.Rom
+            {
+                Start = "XXXXXX",
+                Type = "XXXXXX",
+                Hash = "XXXXXX",
+                Remark = "XXXXXX",
+            };
+
+            var dump_rom = new Data.Models.OpenMSX.Dump
+            {
+                Original = original,
+                Rom = rom,
+            };
+
+            var megarom = new Data.Models.OpenMSX.MegaRom
+            {
+                Start = "XXXXXX",
+                Type = "XXXXXX",
+                Hash = "XXXXXX",
+                Remark = "XXXXXX",
+            };
+
+            var dump_megarom = new Data.Models.OpenMSX.Dump
+            {
+                Original = original,
+                Rom = megarom,
+            };
+
+            var sccpluscart = new Data.Models.OpenMSX.SCCPlusCart
+            {
+                Start = "XXXXXX",
+                Type = "XXXXXX",
+                Hash = "XXXXXX",
+                Remark = "XXXXXX",
+            };
+
+            var dump_sccpluscart = new Data.Models.OpenMSX.Dump
+            {
+                Original = original,
+                Rom = sccpluscart,
+            };
+
+            var software = new Data.Models.OpenMSX.Software
+            {
+                Title = "XXXXXX",
+                GenMSXID = "XXXXXX",
+                System = "XXXXXX",
+                Company = "XXXXXX",
+                Year = "XXXXXX",
+                Country = "XXXXXX",
+                Dump = [dump_rom, dump_megarom, dump_sccpluscart],
+            };
+
+            return new Data.Models.OpenMSX.SoftwareDb
+            {
+                Timestamp = "XXXXXX",
+                Software = [software],
+            };
+        }
+
+        /// <summary>
+        /// Validate a Software
+        /// </summary>
+        private static void Validate(Data.Models.OpenMSX.Software? software)
+        {
+            Assert.NotNull(software);
+            Assert.Equal("XXXXXX", software.Title);
+            Assert.Equal("XXXXXX", software.GenMSXID);
+            Assert.Equal("XXXXXX", software.System);
+            Assert.Equal("XXXXXX", software.Company);
+            Assert.Equal("XXXXXX", software.Year);
+            Assert.Equal("XXXXXX", software.Country);
+
+            Assert.NotNull(software.Dump);
+            Assert.Equal(3, software.Dump.Length);
+            foreach (var dump in software.Dump)
+            {
+                Validate(dump);
+            }
+        }
+
+        /// <summary>
+        /// Validate a Dump
+        /// </summary>
+        private static void Validate(Data.Models.OpenMSX.Dump? dump)
+        {
+            Assert.NotNull(dump);
+            Validate(dump.Original);
+            Validate(dump.Rom);
+        }
+
+        /// <summary>
+        /// Validate a Original
+        /// </summary>
+        private static void Validate(Data.Models.OpenMSX.Original? original)
+        {
+            Assert.NotNull(original);
+            Assert.Equal("XXXXXX", original.Value);
+            Assert.Equal("XXXXXX", original.Content);
+        }
+
+        /// <summary>
+        /// Validate a RomBase
+        /// </summary>
+        private static void Validate(Data.Models.OpenMSX.RomBase? rombase)
+        {
+            Assert.NotNull(rombase);
+            Assert.Equal("XXXXXX", rombase.Start);
+            Assert.Equal("XXXXXX", rombase.Type);
+            Assert.Equal("XXXXXX", rombase.Hash);
+            Assert.Equal("XXXXXX", rombase.Remark);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/PAKTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class PAKTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new PAK();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new PAK();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new PAK();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new PAK();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new PAK();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new PAK();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/PFFTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class PFFTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new PFF();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new PFF();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new PFF();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new PFF();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new PFF();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new PFF();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/PICTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class PICTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new PIC();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new PIC();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new PIC();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new PIC();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new PIC();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new PIC();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/PKZIPTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class PKZIPTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new PKZIP();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new PKZIP();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new PKZIP();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new PKZIP();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new PKZIP();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new PKZIP();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/PlayJAudioTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class PlayJAudioTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new PlayJAudio();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new PlayJAudio();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new PlayJAudio();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new PlayJAudio();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new PlayJAudio();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new PlayJAudio();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/PlayJPlaylistTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class PlayJPlaylistTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new PlayJPlaylist();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new PlayJPlaylist();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new PlayJPlaylist();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new PlayJPlaylist();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new PlayJPlaylist();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new PlayJPlaylist();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/PortableExecutableTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class PortableExecutableTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new PortableExecutable();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new PortableExecutable();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new PortableExecutable();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new PortableExecutable();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new PortableExecutable();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new PortableExecutable();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/QuantumTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class QuantumTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new Quantum();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new Quantum();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new Quantum();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new Quantum();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new Quantum();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new Quantum();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/RomCenterTests.cs

@@ -0,0 +1,220 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class RomCenterTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new RomCenter();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new RomCenter();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new RomCenter();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new RomCenter();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new RomCenter();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new RomCenter();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void RoundTripTest()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new RomCenter();
+            var serializer = new SabreTools.Serialization.Writers.RomCenter();
+
+            // Build the data
+            Data.Models.RomCenter.MetadataFile mf = Build();
+
+            // Serialize to stream
+            Stream? metadata = serializer.SerializeStream(mf);
+            Assert.NotNull(metadata);
+
+            // Serialize back to original model
+            Data.Models.RomCenter.MetadataFile? newMf = deserializer.Deserialize(metadata);
+
+            // Validate the data
+            Assert.NotNull(newMf);
+            Validate(newMf.Credits);
+            Validate(newMf.Dat);
+            Validate(newMf.Emulator);
+            Validate(newMf.Games);
+        }
+
+        /// <summary>
+        /// Build model for serialization and deserialization
+        /// </summary>
+        private static Data.Models.RomCenter.MetadataFile Build()
+        {
+            var credits = new Data.Models.RomCenter.Credits
+            {
+                Author = "XXXXXX",
+                Version = "XXXXXX",
+                Email = "XXXXXX",
+                Homepage = "XXXXXX",
+                Url = "XXXXXX",
+                Date = "XXXXXX",
+                Comment = "XXXXXX",
+            };
+
+            var dat = new Data.Models.RomCenter.Dat
+            {
+                Version = "XXXXXX",
+                Plugin = "XXXXXX",
+                Split = "XXXXXX",
+                Merge = "XXXXXX",
+            };
+
+            var emulator = new Data.Models.RomCenter.Emulator
+            {
+                RefName = "XXXXXX",
+                Version = "XXXXXX",
+            };
+
+            var rom = new Data.Models.RomCenter.Rom
+            {
+                ParentName = "XXXXXX",
+                ParentDescription = "XXXXXX",
+                GameName = "XXXXXX",
+                GameDescription = "XXXXXX",
+                RomName = "XXXXXX",
+                RomCRC = "XXXXXX",
+                RomSize = "XXXXXX",
+                RomOf = "XXXXXX",
+                MergeName = "XXXXXX",
+            };
+
+            var games = new Data.Models.RomCenter.Games
+            {
+                Rom = [rom],
+            };
+
+            return new Data.Models.RomCenter.MetadataFile
+            {
+                Credits = credits,
+                Dat = dat,
+                Emulator = emulator,
+                Games = games,
+            };
+        }
+
+        /// <summary>
+        /// Validate a Credits
+        /// </summary>
+        private static void Validate(Data.Models.RomCenter.Credits? credits)
+        {
+            Assert.NotNull(credits);
+            Assert.Equal("XXXXXX", credits.Author);
+            Assert.Equal("XXXXXX", credits.Version);
+            Assert.Equal("XXXXXX", credits.Email);
+            Assert.Equal("XXXXXX", credits.Homepage);
+            Assert.Equal("XXXXXX", credits.Url);
+            Assert.Equal("XXXXXX", credits.Date);
+            Assert.Equal("XXXXXX", credits.Comment);
+        }
+
+        /// <summary>
+        /// Validate a Dat
+        /// </summary>
+        private static void Validate(Data.Models.RomCenter.Dat? dat)
+        {
+            Assert.NotNull(dat);
+            Assert.Equal("XXXXXX", dat.Version);
+            Assert.Equal("XXXXXX", dat.Plugin);
+            Assert.Equal("XXXXXX", dat.Split);
+            Assert.Equal("XXXXXX", dat.Merge);
+        }
+
+        /// <summary>
+        /// Validate a Emulator
+        /// </summary>
+        private static void Validate(Data.Models.RomCenter.Emulator? emulator)
+        {
+            Assert.NotNull(emulator);
+            Assert.Equal("XXXXXX", emulator.RefName);
+            Assert.Equal("XXXXXX", emulator.Version);
+        }
+
+        /// <summary>
+        /// Validate a Games
+        /// </summary>
+        private static void Validate(Data.Models.RomCenter.Games? games)
+        {
+            Assert.NotNull(games);
+            Assert.NotNull(games.Rom);
+            var rom = Assert.Single(games.Rom);
+            Validate(rom);
+        }
+
+        /// <summary>
+        /// Validate a Rom
+        /// </summary>
+        private static void Validate(Data.Models.RomCenter.Rom? rom)
+        {
+            Assert.NotNull(rom);
+            Assert.Equal("XXXXXX", rom.ParentName);
+            Assert.Equal("XXXXXX", rom.ParentDescription);
+            Assert.Equal("XXXXXX", rom.GameName);
+            Assert.Equal("XXXXXX", rom.GameDescription);
+            Assert.Equal("XXXXXX", rom.RomName);
+            Assert.Equal("XXXXXX", rom.RomCRC);
+            Assert.Equal("XXXXXX", rom.RomSize);
+            Assert.Equal("XXXXXX", rom.RomOf);
+            Assert.Equal("XXXXXX", rom.MergeName);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/SFBTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class SFBTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new SFB();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new SFB();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new SFB();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new SFB();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new SFB();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new SFB();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/SFOTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class SFOTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new SFO();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new SFO();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new SFO();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new SFO();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new SFO();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new SFO();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/SGATests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class SGATests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new SGA();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new SGA();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new SGA();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new SGA();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new SGA();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new SGA();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/SeparatedValueTests.cs

@@ -0,0 +1,308 @@
+using System;
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class SeparatedValueTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new SeparatedValue();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new SeparatedValue();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new SeparatedValue();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new SeparatedValue();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new SeparatedValue();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new SeparatedValue();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void RoundTripShortTest()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new SeparatedValue();
+            var serializer = new SabreTools.Serialization.Writers.SeparatedValue();
+
+            // Build the data
+            Data.Models.SeparatedValue.MetadataFile mf = Build();
+
+            // Serialize to stream
+            Stream? actual = serializer.SerializeStream(mf, ',', longHeader: false);
+            Assert.NotNull(actual);
+
+            // Serialize back to original model
+            Data.Models.SeparatedValue.MetadataFile? newMf = deserializer.Deserialize(actual);
+
+            // Validate the data
+            Assert.NotNull(newMf);
+            Validate(newMf.Header, longHeader: false);
+            Assert.NotNull(newMf.Row);
+            Assert.Equal(3, newMf.Row.Length);
+
+            ValidateDisk(newMf.Row[0], longHeader: false);
+            ValidateMedia(newMf.Row[1], longHeader: false);
+            ValidateRom(newMf.Row[2], longHeader: false);
+        }
+
+        [Fact]
+        public void RoundTripLongTest()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new SeparatedValue();
+            var serializer = new SabreTools.Serialization.Writers.SeparatedValue();
+
+            // Build the data
+            Data.Models.SeparatedValue.MetadataFile mf = Build();
+
+            // Serialize to stream
+            Stream? actual = serializer.SerializeStream(mf, ',', longHeader: true);
+            Assert.NotNull(actual);
+
+            // Serialize back to original model
+            Data.Models.SeparatedValue.MetadataFile? newMf = deserializer.Deserialize(actual);
+
+            // Validate the data
+            Assert.NotNull(newMf);
+            Validate(newMf.Header, longHeader: true);
+            Assert.NotNull(newMf.Row);
+            Assert.Equal(3, newMf.Row.Length);
+
+            ValidateDisk(newMf.Row[0], longHeader: true);
+            ValidateMedia(newMf.Row[1], longHeader: true);
+            ValidateRom(newMf.Row[2], longHeader: true);
+        }
+
+        /// <summary>
+        /// Build model for serialization and deserialization
+        /// </summary>
+        private static Data.Models.SeparatedValue.MetadataFile Build()
+        {
+            string[] header = ["header"];
+
+            var disk = new Data.Models.SeparatedValue.Row
+            {
+                FileName = "XXXXXX",
+                InternalName = "XXXXXX",
+                Description = "XXXXXX",
+                GameName = "XXXXXX",
+                GameDescription = "XXXXXX",
+                Type = "disk",
+                DiskName = "XXXXXX",
+                MD5 = "XXXXXX",
+                SHA1 = "XXXXXX",
+                Status = "XXXXXX",
+            };
+
+            var media = new Data.Models.SeparatedValue.Row
+            {
+                FileName = "XXXXXX",
+                InternalName = "XXXXXX",
+                Description = "XXXXXX",
+                GameName = "XXXXXX",
+                GameDescription = "XXXXXX",
+                Type = "media",
+                DiskName = "XXXXXX",
+                MD5 = "XXXXXX",
+                SHA1 = "XXXXXX",
+                SHA256 = "XXXXXX",
+                SpamSum = "XXXXXX",
+            };
+
+            var rom = new Data.Models.SeparatedValue.Row
+            {
+                FileName = "XXXXXX",
+                InternalName = "XXXXXX",
+                Description = "XXXXXX",
+                GameName = "XXXXXX",
+                GameDescription = "XXXXXX",
+                Type = "rom",
+                RomName = "XXXXXX",
+                Size = "XXXXXX",
+                CRC = "XXXXXX",
+                MD5 = "XXXXXX",
+                SHA1 = "XXXXXX",
+                SHA256 = "XXXXXX",
+                SHA384 = "XXXXXX",
+                SHA512 = "XXXXXX",
+                SpamSum = "XXXXXX",
+                Status = "XXXXXX",
+            };
+
+            return new Data.Models.SeparatedValue.MetadataFile
+            {
+                Header = header,
+                Row = [disk, media, rom],
+            };
+        }
+
+        /// <summary>
+        /// Validate a header
+        /// </summary>
+        private static void Validate(string[]? header, bool longHeader)
+        {
+            Assert.NotNull(header);
+            if (longHeader)
+                Assert.True(SabreTools.Serialization.Writers.SeparatedValue.HeaderArrayExtended.SequenceEqual(header));
+            else
+                Assert.True(SabreTools.Serialization.Writers.SeparatedValue.HeaderArrayStandard.SequenceEqual(header));
+        }
+
+        /// <summary>
+        /// Validate a Row
+        /// </summary>
+        private static void ValidateDisk(Data.Models.SeparatedValue.Row? row, bool longHeader)
+        {
+            Assert.NotNull(row);
+            Assert.Equal("XXXXXX", row.FileName);
+            Assert.Equal("XXXXXX", row.InternalName);
+            Assert.Equal("XXXXXX", row.Description);
+            Assert.Equal("XXXXXX", row.GameName);
+            Assert.Equal("XXXXXX", row.GameDescription);
+            Assert.Equal("disk", row.Type);
+            Assert.NotNull(row.RomName); Assert.Empty(row.RomName);
+            Assert.Equal("XXXXXX", row.DiskName);
+            Assert.NotNull(row.Size); Assert.Empty(row.Size);
+            Assert.NotNull(row.CRC); Assert.Empty(row.CRC);
+            Assert.Equal("XXXXXX", row.MD5);
+            Assert.Equal("XXXXXX", row.SHA1);
+            Assert.NotNull(row.CRC); Assert.Empty(row.CRC);
+            if (longHeader)
+            {
+                Assert.NotNull(row.SHA384); Assert.Empty(row.SHA384);
+                Assert.NotNull(row.SHA512); Assert.Empty(row.SHA512);
+                Assert.NotNull(row.SpamSum); Assert.Empty(row.SpamSum);
+            }
+            else
+            {
+                Assert.Null(row.SHA384);
+                Assert.Null(row.SHA512);
+                Assert.Null(row.SpamSum);
+            }
+            Assert.Equal("XXXXXX", row.Status);
+        }
+
+        /// <summary>
+        /// Validate a Row
+        /// </summary>
+        private static void ValidateMedia(Data.Models.SeparatedValue.Row? row, bool longHeader)
+        {
+            Assert.NotNull(row);
+            Assert.Equal("XXXXXX", row.FileName);
+            Assert.Equal("XXXXXX", row.InternalName);
+            Assert.Equal("XXXXXX", row.Description);
+            Assert.Equal("XXXXXX", row.GameName);
+            Assert.Equal("XXXXXX", row.GameDescription);
+            Assert.Equal("media", row.Type);
+            Assert.NotNull(row.RomName); Assert.Empty(row.RomName);
+            Assert.Equal("XXXXXX", row.DiskName);
+            Assert.NotNull(row.Size); Assert.Empty(row.Size);
+            Assert.NotNull(row.CRC); Assert.Empty(row.CRC);
+            Assert.Equal("XXXXXX", row.MD5);
+            Assert.Equal("XXXXXX", row.SHA1);
+            Assert.Equal("XXXXXX", row.SHA256);
+            if (longHeader)
+            {
+                Assert.NotNull(row.SHA384); Assert.Empty(row.SHA384);
+                Assert.NotNull(row.SHA512); Assert.Empty(row.SHA512);
+                Assert.Equal("XXXXXX", row.SpamSum);
+            }
+            else
+            {
+                Assert.Null(row.SHA384);
+                Assert.Null(row.SHA512);
+                Assert.Null(row.SpamSum);
+            }
+            Assert.NotNull(row.Status); Assert.Empty(row.Status);
+        }
+
+        /// <summary>
+        /// Validate a Row
+        /// </summary>
+        private static void ValidateRom(Data.Models.SeparatedValue.Row? row, bool longHeader)
+        {
+            Assert.NotNull(row);
+            Assert.Equal("XXXXXX", row.FileName);
+            Assert.Equal("XXXXXX", row.InternalName);
+            Assert.Equal("XXXXXX", row.Description);
+            Assert.Equal("XXXXXX", row.GameName);
+            Assert.Equal("XXXXXX", row.GameDescription);
+            Assert.Equal("rom", row.Type);
+            Assert.Equal("XXXXXX", row.RomName);
+            Assert.NotNull(row.DiskName);
+            Assert.Empty(row.DiskName);
+            Assert.Equal("XXXXXX", row.Size);
+            Assert.Equal("XXXXXX", row.CRC);
+            Assert.Equal("XXXXXX", row.MD5);
+            Assert.Equal("XXXXXX", row.SHA1);
+            Assert.Equal("XXXXXX", row.SHA256);
+            if (longHeader)
+            {
+                Assert.Equal("XXXXXX", row.SHA384);
+                Assert.Equal("XXXXXX", row.SHA512);
+                Assert.Equal("XXXXXX", row.SpamSum);
+            }
+            else
+            {
+                Assert.Null(row.SHA384);
+                Assert.Null(row.SHA512);
+                Assert.Null(row.SpamSum);
+            }
+            Assert.Equal("XXXXXX", row.Status);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/SoftwareListTests.cs

@@ -0,0 +1,377 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class SoftwareListTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new SoftwareList();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new SoftwareList();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new SoftwareList();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new SoftwareList();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new SoftwareList();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new SoftwareList();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void RoundTripTest()
+        {
+            // Get the serializer and deserializer
+            var deserializer = new SoftwareList();
+            var serializer = new SabreTools.Serialization.Writers.SoftwareList();
+
+            // Build the data
+            Data.Models.SoftwareList.SoftwareList sl = Build();
+
+            // Serialize to stream
+            Stream? actual = serializer.Serialize(sl);
+            Assert.NotNull(actual);
+
+            // Serialize back to original model
+            Data.Models.SoftwareList.SoftwareList? newSl = deserializer.Deserialize(actual);
+
+            // Validate the data
+            Assert.NotNull(newSl);
+            Assert.Equal("XXXXXX", newSl.Name);
+            Assert.Equal("XXXXXX", newSl.Description);
+            Assert.Equal("XXXXXX", newSl.Notes);
+
+            Assert.NotNull(newSl.Software);
+            var newSoftware = Assert.Single(newSl.Software);
+            Validate(newSoftware);
+        }
+
+        /// <summary>
+        /// Build model for serialization and deserialization
+        /// </summary>
+        private static Data.Models.SoftwareList.SoftwareList Build()
+        {
+            var info = new Data.Models.SoftwareList.Info
+            {
+                Name = "XXXXXX",
+                Value = "XXXXXX",
+            };
+
+            var sharedfeat = new Data.Models.SoftwareList.SharedFeat
+            {
+                Name = "XXXXXX",
+                Value = "XXXXXX",
+            };
+
+            var feature = new Data.Models.SoftwareList.Feature
+            {
+                Name = "XXXXXX",
+                Value = "XXXXXX",
+            };
+
+            var rom = new Data.Models.SoftwareList.Rom
+            {
+                Name = "XXXXXX",
+                Size = "XXXXXX",
+                Length = "XXXXXX",
+                CRC = "XXXXXX",
+                SHA1 = "XXXXXX",
+                Offset = "XXXXXX",
+                Value = "XXXXXX",
+                Status = "XXXXXX",
+                LoadFlag = "XXXXXX",
+            };
+
+            var dataarea = new Data.Models.SoftwareList.DataArea
+            {
+                Name = "XXXXXX",
+                Size = "XXXXXX",
+                Width = "XXXXXX",
+                Endianness = "XXXXXX",
+                Rom = [rom],
+            };
+
+            var disk = new Data.Models.SoftwareList.Disk
+            {
+                Name = "XXXXXX",
+                MD5 = "XXXXXX",
+                SHA1 = "XXXXXX",
+                Status = "XXXXXX",
+                Writeable = "XXXXXX",
+            };
+
+            var diskarea = new Data.Models.SoftwareList.DiskArea
+            {
+                Name = "XXXXXX",
+                Disk = [disk],
+            };
+
+            var dipvalue = new Data.Models.SoftwareList.DipValue
+            {
+                Name = "XXXXXX",
+                Value = "XXXXXX",
+                Default = "XXXXXX",
+            };
+
+            var dipswitch = new Data.Models.SoftwareList.DipSwitch
+            {
+                Name = "XXXXXX",
+                Tag = "XXXXXX",
+                Mask = "XXXXXX",
+                DipValue = [dipvalue],
+            };
+
+            var part = new Data.Models.SoftwareList.Part
+            {
+                Name = "XXXXXX",
+                Interface = "XXXXXX",
+                Feature = [feature],
+                DataArea = [dataarea],
+                DiskArea = [diskarea],
+                DipSwitch = [dipswitch],
+            };
+
+            var software = new Data.Models.SoftwareList.Software
+            {
+                Name = "XXXXXX",
+                CloneOf = "XXXXXX",
+                Supported = "XXXXXX",
+                Description = "XXXXXX",
+                Year = "XXXXXX",
+                Publisher = "XXXXXX",
+                Notes = "XXXXXX",
+                Info = [info],
+                SharedFeat = [sharedfeat],
+                Part = [part],
+            };
+
+            return new Data.Models.SoftwareList.SoftwareList
+            {
+                Name = "XXXXXX",
+                Description = "XXXXXX",
+                Notes = "XXXXXX",
+                Software = [software],
+            };
+        }
+
+        /// <summary>
+        /// Validate a Software
+        /// </summary>
+        private static void Validate(Data.Models.SoftwareList.Software? software)
+        {
+            Assert.NotNull(software);
+            Assert.Equal("XXXXXX", software.Name);
+            Assert.Equal("XXXXXX", software.CloneOf);
+            Assert.Equal("XXXXXX", software.Supported);
+            Assert.Equal("XXXXXX", software.Description);
+            Assert.Equal("XXXXXX", software.Year);
+            Assert.Equal("XXXXXX", software.Publisher);
+            Assert.Equal("XXXXXX", software.Notes);
+
+            Assert.NotNull(software.Info);
+            var info = Assert.Single(software.Info);
+            Validate(info);
+
+            Assert.NotNull(software.SharedFeat);
+            var sharedfeat = Assert.Single(software.SharedFeat);
+            Validate(sharedfeat);
+
+            Assert.NotNull(software.Part);
+            var part = Assert.Single(software.Part);
+            Validate(part);
+        }
+
+        /// <summary>
+        /// Validate a Info
+        /// </summary>
+        private static void Validate(Data.Models.SoftwareList.Info? info)
+        {
+            Assert.NotNull(info);
+            Assert.Equal("XXXXXX", info.Name);
+            Assert.Equal("XXXXXX", info.Value);
+        }
+
+        /// <summary>
+        /// Validate a SharedFeat
+        /// </summary>
+        private static void Validate(Data.Models.SoftwareList.SharedFeat? sharedfeat)
+        {
+            Assert.NotNull(sharedfeat);
+            Assert.Equal("XXXXXX", sharedfeat.Name);
+            Assert.Equal("XXXXXX", sharedfeat.Value);
+        }
+
+        /// <summary>
+        /// Validate a Part
+        /// </summary>
+        private static void Validate(Data.Models.SoftwareList.Part? part)
+        {
+            Assert.NotNull(part);
+            Assert.Equal("XXXXXX", part.Name);
+            Assert.Equal("XXXXXX", part.Interface);
+
+            Assert.NotNull(part.Feature);
+            var feature = Assert.Single(part.Feature);
+            Validate(feature);
+
+            Assert.NotNull(part.DataArea);
+            var dataarea = Assert.Single(part.DataArea);
+            Validate(dataarea);
+
+            Assert.NotNull(part.DiskArea);
+            var diskarea = Assert.Single(part.DiskArea);
+            Validate(diskarea);
+
+            Assert.NotNull(part.DipSwitch);
+            var dipswitch = Assert.Single(part.DipSwitch);
+            Validate(dipswitch);
+        }
+
+        /// <summary>
+        /// Validate a Feature
+        /// </summary>
+        private static void Validate(Data.Models.SoftwareList.Feature? feature)
+        {
+            Assert.NotNull(feature);
+            Assert.Equal("XXXXXX", feature.Name);
+            Assert.Equal("XXXXXX", feature.Value);
+        }
+
+        /// <summary>
+        /// Validate a DataArea
+        /// </summary>
+        private static void Validate(Data.Models.SoftwareList.DataArea? dataarea)
+        {
+            Assert.NotNull(dataarea);
+            Assert.Equal("XXXXXX", dataarea.Name);
+            Assert.Equal("XXXXXX", dataarea.Size);
+            Assert.Equal("XXXXXX", dataarea.Width);
+            Assert.Equal("XXXXXX", dataarea.Endianness);
+
+            Assert.NotNull(dataarea.Rom);
+            var rom = Assert.Single(dataarea.Rom);
+            Validate(rom);
+        }
+
+        /// <summary>
+        /// Validate a Rom
+        /// </summary>
+        private static void Validate(Data.Models.SoftwareList.Rom? rom)
+        {
+            Assert.NotNull(rom);
+            Assert.Equal("XXXXXX", rom.Name);
+            Assert.Equal("XXXXXX", rom.Size);
+            Assert.Equal("XXXXXX", rom.Length);
+            Assert.Equal("XXXXXX", rom.CRC);
+            Assert.Equal("XXXXXX", rom.SHA1);
+            Assert.Equal("XXXXXX", rom.Offset);
+            Assert.Equal("XXXXXX", rom.Value);
+            Assert.Equal("XXXXXX", rom.Status);
+            Assert.Equal("XXXXXX", rom.LoadFlag);
+        }
+
+        /// <summary>
+        /// Validate a DiskArea
+        /// </summary>
+        private static void Validate(Data.Models.SoftwareList.DiskArea? diskarea)
+        {
+            Assert.NotNull(diskarea);
+            Assert.Equal("XXXXXX", diskarea.Name);
+
+            Assert.NotNull(diskarea.Disk);
+            var disk = Assert.Single(diskarea.Disk);
+            Validate(disk);
+        }
+
+        /// <summary>
+        /// Validate a Disk
+        /// </summary>
+        private static void Validate(Data.Models.SoftwareList.Disk? disk)
+        {
+            Assert.NotNull(disk);
+            Assert.Equal("XXXXXX", disk.Name);
+            Assert.Equal("XXXXXX", disk.MD5);
+            Assert.Equal("XXXXXX", disk.SHA1);
+            Assert.Equal("XXXXXX", disk.Status);
+            Assert.Equal("XXXXXX", disk.Writeable);
+        }
+
+        /// <summary>
+        /// Validate a DipSwitch
+        /// </summary>
+        private static void Validate(Data.Models.SoftwareList.DipSwitch? dipswitch)
+        {
+            Assert.NotNull(dipswitch);
+            Assert.Equal("XXXXXX", dipswitch.Name);
+            Assert.Equal("XXXXXX", dipswitch.Tag);
+            Assert.Equal("XXXXXX", dipswitch.Mask);
+
+            Assert.NotNull(dipswitch.DipValue);
+            var dipvalue = Assert.Single(dipswitch.DipValue);
+            Validate(dipvalue);
+        }
+
+        /// <summary>
+        /// Validate a DipValue
+        /// </summary>
+        private static void Validate(Data.Models.SoftwareList.DipValue? dipvalue)
+        {
+            Assert.NotNull(dipvalue);
+            Assert.Equal("XXXXXX", dipvalue.Name);
+            Assert.Equal("XXXXXX", dipvalue.Value);
+            Assert.Equal("XXXXXX", dipvalue.Default);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/TapeArchiveTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class TapeArchiveTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new TapeArchive();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new TapeArchive();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new TapeArchive();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new TapeArchive();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new TapeArchive();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new TapeArchive();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/VBSPTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class VBSPTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new VBSP();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new VBSP();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new VBSP();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new VBSP();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new VBSP();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new VBSP();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/VPKTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class VPKTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new VPK();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new VPK();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new VPK();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new VPK();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new VPK();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new VPK();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/WAD3Tests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class WAD3Tests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new WAD3();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new WAD3();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new WAD3();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new WAD3();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new WAD3();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new WAD3();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/WiseOverlayHeaderTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class WiseOverlayHeaderTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new WiseOverlayHeader();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new WiseOverlayHeader();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new WiseOverlayHeader();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new WiseOverlayHeader();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new WiseOverlayHeader();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new WiseOverlayHeader();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/WiseScriptTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class WiseScriptTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new WiseScript();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new WiseScript();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new WiseScript();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new WiseScript();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new WiseScript();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new WiseScript();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/WiseSectionHeaderTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class WiseSectionHeaderTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new WiseSectionHeader();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new WiseSectionHeader();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new WiseSectionHeader();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new WiseSectionHeader();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new WiseSectionHeader();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new WiseSectionHeader();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/XMIDTests.cs

@@ -0,0 +1,39 @@
+
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class XMIDTests
+    {
+        [Fact]
+        public void NullString_Null()
+        {
+            string? data = null;
+            var deserializer = new XMID();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyString_Null()
+        {
+            string? data = string.Empty;
+            var deserializer = new XMID();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidString_Null()
+        {
+            string? data = "INVALID";
+            var deserializer = new XMID();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/XZPTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class XZPTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new XZP();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new XZP();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new XZP();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new XZP();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new XZP();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new XZP();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/XZTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class XZTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var deserializer = new XZ();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var deserializer = new XZ();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var deserializer = new XZ();
+
+            var actual = deserializer.Deserialize(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var deserializer = new XZ();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var deserializer = new XZ();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var deserializer = new XZ();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Readers/XeMIDTests.cs

@@ -0,0 +1,38 @@
+using SabreTools.Serialization.Readers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Readers
+{
+    public class XeMIDTests
+    {
+        [Fact]
+        public void NullString_Null()
+        {
+            string? data = null;
+            var deserializer = new XeMID();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyString_Null()
+        {
+            string? data = string.Empty;
+            var deserializer = new XeMID();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void InvalidString_Null()
+        {
+            string? data = "INVALID";
+            var deserializer = new XeMID();
+
+            var actual = deserializer.Deserialize(data);
+            Assert.Null(actual);
+        }
+    }
+}