Bump version

Prone to too many false positives.

.github/workflows/build_and_test.yml

@@ -0,0 +1,40 @@
+name: Build and Test
+
+on:
+  push:
+    branches: [ "master" ]
+
+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: |
+            6.0.x
+            8.0.x
+            9.0.x
+        
+    - name: Run tests
+      run: dotnet test
+      
+    - name: Run publish script
+      run: ./publish-nix.sh -d
+
+    - name: Upload to rolling
+      uses: ncipollo/release-action@v1.14.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/check_pr.yml

@@ -0,0 +1,23 @@
+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: |
+            6.0.x
+            8.0.x
+            9.0.x
+      
+    - name: Build
+      run: dotnet build
+
+    - name: Run tests
+      run: dotnet test

.gitmodules

@@ -1,12 +1,9 @@
-[submodule "BurnOutSharp/External/stormlibsharp"]
-	path = BurnOutSharp/External/stormlibsharp
+[submodule "BinaryObjectScanner/_EXTERNAL/stormlibsharp"]
+	path = BinaryObjectScanner/_EXTERNAL/stormlibsharp
 	url = https://github.com/robpaveza/stormlibsharp.git
-[submodule "HLLibSharp"]
-	path = HLLibSharp
-	url = https://github.com/mnadareski/HLLibSharp
-[submodule "LibMSPackSharp"]
-	path = LibMSPackSharp
-	url = https://github.com/mnadareski/LibMSPackSharp.git
-[submodule "Dtf"]
-	path = Dtf
-	url = https://github.com/wixtoolset/Dtf.git
+[submodule "BinaryObjectScanner/_EXTERNAL/libmspack4n"]
+	path = BinaryObjectScanner/_EXTERNAL/libmspack4n
+	url = https://github.com/activescott/libmspack4n.git
+[submodule "BinaryObjectScanner/_EXTERNAL/LessIO"]
+	path = BinaryObjectScanner/_EXTERNAL/LessIO
+	url = https://github.com/activescott/LessIO.git

.vscode/launch.json

@@ -5,27 +5,27 @@
    "version": "0.2.0",
    "configurations": [
         {
-            "name": ".NET Core Launch (Test)",
+            "name": ".NET Core Launch (ProtectionScan)",
             "type": "coreclr",
             "request": "launch",
             "preLaunchTask": "build",
             // If you have changed target frameworks, make sure to update the program path.
-            "program": "${workspaceFolder}/Test/bin/Debug/net6.0/Test.dll",
+            "program": "${workspaceFolder}/ProtectionScan/bin/Debug/net9.0/ProtectionScan.dll",
             "args": [],
-            "cwd": "${workspaceFolder}/Test",
+            "cwd": "${workspaceFolder}/ProtectionScan",
             // For more information about the 'console' field, see https://aka.ms/VSCode-CS-LaunchJson-Console
             "console": "internalConsole",
             "stopAtEntry": false
         },
         {
-            "name": ".NET Core Launch (ExecutableTest)",
+            "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}/ExecutableTest/bin/Debug/net6.0/ExecutableTest.dll",
+            "program": "${workspaceFolder}/ExtractionTool/bin/Debug/net9.0/ExtractionTool.dll",
             "args": [],
-            "cwd": "${workspaceFolder}/Test",
+            "cwd": "${workspaceFolder}/ExtractionTool",
             // For more information about the 'console' field, see https://aka.ms/VSCode-CS-LaunchJson-Console
             "console": "internalConsole",
             "stopAtEntry": false

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "dotnet.defaultSolution": "BinaryObjectScanner.sln"
+}

.vscode/tasks.json

@@ -7,7 +7,7 @@
             "type": "process",
             "args": [
                 "build",
-                "${workspaceFolder}/BurnOutSharp.sln",
+                "${workspaceFolder}/BinaryObjectScanner.sln",
                 "/property:GenerateFullPaths=true",
                 "/consoleloggerparameters:NoSummary"
             ],
@@ -19,7 +19,7 @@
             "type": "process",
             "args": [
                 "publish",
-                "${workspaceFolder}/BurnOutSharp.sln",
+                "${workspaceFolder}/BinaryObjectScanner.sln",
                 "/property:GenerateFullPaths=true",
                 "/consoleloggerparameters:NoSummary"
             ],
@@ -32,7 +32,7 @@
             "args": [
                 "watch",
                 "run",
-                "${workspaceFolder}/BurnOutSharp.sln",
+                "${workspaceFolder}/BinaryObjectScanner.sln",
                 "/property:GenerateFullPaths=true",
                 "/consoleloggerparameters:NoSummary"
             ],

BinaryObjectScanner.Test/BinaryObjectScanner.Test.csproj

@@ -0,0 +1,28 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFrameworks>net6.0;net8.0;net9.0</TargetFrameworks>
+        <IsPackable>false</IsPackable>
+        <LangVersion>latest</LangVersion>
+        <Nullable>enable</Nullable>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <ProjectReference Include="..\BinaryObjectScanner\BinaryObjectScanner.csproj" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <PackageReference Include="coverlet.collector" Version="6.0.3">
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+            <PrivateAssets>all</PrivateAssets>
+        </PackageReference>
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+        <PackageReference Include="SabreTools.Serialization" Version="1.8.6" />
+        <PackageReference Include="xunit" Version="2.9.2" />
+        <PackageReference Include="xunit.runner.visualstudio" Version="3.0.0">
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+            <PrivateAssets>all</PrivateAssets>
+        </PackageReference>
+    </ItemGroup>
+
+</Project>

BinaryObjectScanner.Test/Data/StaticChecksTests.cs

@@ -0,0 +1,50 @@
+using BinaryObjectScanner.Data;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Data
+{
+    public class StaticChecksTests
+    {
+        [Fact]
+        public void ContentCheckClasses_Populated()
+        {
+            var actual = StaticChecks.ContentCheckClasses;
+            Assert.NotEmpty(actual);
+        }
+
+        [Fact]
+        public void LinearExecutableCheckClasses_Empty()
+        {
+            var actual = StaticChecks.LinearExecutableCheckClasses;
+            Assert.Empty(actual); // No implementations exist yet
+        }
+
+        [Fact]
+        public void MSDOSExecutableCheckClasses_Empty()
+        {
+            var actual = StaticChecks.MSDOSExecutableCheckClasses;
+            Assert.Empty(actual); // No implementations exist yet
+        }
+
+        [Fact]
+        public void NewExecutableCheckClasses_Populated()
+        {
+            var actual = StaticChecks.NewExecutableCheckClasses;
+            Assert.NotEmpty(actual);
+        }
+
+        [Fact]
+        public void PathCheckClasses_Populated()
+        {
+            var actual = StaticChecks.PathCheckClasses;
+            Assert.NotEmpty(actual);
+        }
+
+        [Fact]
+        public void PortableExecutableCheckClasses_Populated()
+        {
+            var actual = StaticChecks.PortableExecutableCheckClasses;
+            Assert.NotEmpty(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/ExtensionsTests.cs

@@ -0,0 +1,332 @@
+using System;
+using System.Collections.Generic;
+using Xunit;
+
+namespace BinaryObjectScanner.Test
+{
+    public class ExtensionsTests
+    {
+        #region FileSize
+
+        [Fact]
+        public void FileSize_Null_Invalid()
+        {
+            string? filename = null;
+            long actual = filename.FileSize();
+            Assert.Equal(-1, actual);
+        }
+
+        [Fact]
+        public void FileSize_Empty_Invalid()
+        {
+            string? filename = string.Empty;
+            long actual = filename.FileSize();
+            Assert.Equal(-1, actual);
+        }
+
+        [Fact]
+        public void FileSize_Invalid_Invalid()
+        {
+            string? filename = "INVALID";
+            long actual = filename.FileSize();
+            Assert.Equal(-1, actual);
+        }
+
+        #endregion
+
+        #region IterateWithAction
+
+        [Fact]
+        public void IterateWithAction_EmptyEnumerable_Success()
+        {
+            List<string> set = new List<string>();
+            Action<string> action = (s) => s.ToLowerInvariant();
+
+            set.IterateWithAction(action);
+            Assert.Empty(set);
+        }
+
+        [Fact]
+        public void IterateWithAction_EmptyAction_Success()
+        {
+            List<string> set = ["a", "b", "c"];
+            Action<string> action = (s) => { };
+
+            set.IterateWithAction(action);
+            Assert.Equal(3, set.Count);
+        }
+
+        [Fact]
+        public void IterateWithAction_Valid_Success()
+        {
+            List<string> set = ["a", "b", "c"];
+            List<string> actual = new List<string>();
+
+            Action<string> action = (s) =>
+            {
+                lock (actual)
+                {
+                    actual.Add(s.ToUpperInvariant());
+                }
+            };
+
+            set.IterateWithAction(action);
+            Assert.Equal(3, set.Count);
+            Assert.Equal(3, actual.Count);
+        }
+
+        #endregion
+
+        #region OptionalContains
+
+        [Fact]
+        public void OptionalContains_NullStringNoComparison_False()
+        {
+            string? str = null;
+            string prefix = "prefix";
+
+            bool actual = str.OptionalContains(prefix);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void OptionalContains_NullStringComparison_False()
+        {
+            string? str = null;
+            string prefix = "prefix";
+
+            bool actual = str.OptionalContains(prefix, StringComparison.OrdinalIgnoreCase);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void OptionalContains_EmptyStringNoComparison_False()
+        {
+            string? str = string.Empty;
+            string prefix = "prefix";
+
+            bool actual = str.OptionalContains(prefix);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void OptionalContains_EmptyStringComparison_False()
+        {
+            string? str = string.Empty;
+            string prefix = "prefix";
+
+            bool actual = str.OptionalContains(prefix, StringComparison.OrdinalIgnoreCase);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void OptionalContains_NoMatchNoComparison_False()
+        {
+            string? str = "postfix";
+            string prefix = "prefix";
+
+            bool actual = str.OptionalContains(prefix);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void OptionalContains_NoMatchComparison_False()
+        {
+            string? str = "postfix";
+            string prefix = "prefix";
+
+            bool actual = str.OptionalContains(prefix, StringComparison.OrdinalIgnoreCase);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void OptionalContains_MatchesNoComparison_True()
+        {
+            string? str = "prefix";
+            string prefix = "prefix";
+
+            bool actual = str.OptionalContains(prefix);
+            Assert.True(actual);
+        }
+
+        [Fact]
+        public void OptionalContains_MatchesComparison_True()
+        {
+            string? str = "prefix";
+            string prefix = "prefix";
+
+            bool actual = str.OptionalContains(prefix, StringComparison.OrdinalIgnoreCase);
+            Assert.True(actual);
+        }
+
+        #endregion
+
+        #region OptionalEquals
+
+        [Fact]
+        public void OptionalEquals_NullStringNoComparison_False()
+        {
+            string? str = null;
+            string prefix = "prefix";
+
+            bool actual = str.OptionalEquals(prefix);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void OptionalEquals_NullStringComparison_False()
+        {
+            string? str = null;
+            string prefix = "prefix";
+
+            bool actual = str.OptionalEquals(prefix, StringComparison.OrdinalIgnoreCase);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void OptionalEquals_EmptyStringNoComparison_False()
+        {
+            string? str = string.Empty;
+            string prefix = "prefix";
+
+            bool actual = str.OptionalEquals(prefix);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void OptionalEquals_EmptyStringComparison_False()
+        {
+            string? str = string.Empty;
+            string prefix = "prefix";
+
+            bool actual = str.OptionalEquals(prefix, StringComparison.OrdinalIgnoreCase);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void OptionalEquals_NoMatchNoComparison_False()
+        {
+            string? str = "postfix";
+            string prefix = "prefix";
+
+            bool actual = str.OptionalEquals(prefix);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void OptionalEquals_NoMatchComparison_False()
+        {
+            string? str = "postfix";
+            string prefix = "prefix";
+
+            bool actual = str.OptionalEquals(prefix, StringComparison.OrdinalIgnoreCase);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void OptionalEquals_MatchesNoComparison_True()
+        {
+            string? str = "prefix";
+            string prefix = "prefix";
+
+            bool actual = str.OptionalEquals(prefix);
+            Assert.True(actual);
+        }
+
+        [Fact]
+        public void OptionalEquals_MatchesComparison_True()
+        {
+            string? str = "prefix";
+            string prefix = "prefix";
+
+            bool actual = str.OptionalEquals(prefix, StringComparison.OrdinalIgnoreCase);
+            Assert.True(actual);
+        }
+
+        #endregion
+
+        #region OptionalStartsWith
+
+        [Fact]
+        public void OptionalStartsWith_NullStringNoComparison_False()
+        {
+            string? str = null;
+            string prefix = "prefix";
+
+            bool actual = str.OptionalStartsWith(prefix);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void OptionalStartsWith_NullStringComparison_False()
+        {
+            string? str = null;
+            string prefix = "prefix";
+
+            bool actual = str.OptionalStartsWith(prefix, StringComparison.OrdinalIgnoreCase);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void OptionalStartsWith_EmptyStringNoComparison_False()
+        {
+            string? str = string.Empty;
+            string prefix = "prefix";
+
+            bool actual = str.OptionalStartsWith(prefix);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void OptionalStartsWith_EmptyStringComparison_False()
+        {
+            string? str = string.Empty;
+            string prefix = "prefix";
+
+            bool actual = str.OptionalStartsWith(prefix, StringComparison.OrdinalIgnoreCase);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void OptionalStartsWith_NoMatchNoComparison_False()
+        {
+            string? str = "postfix";
+            string prefix = "prefix";
+
+            bool actual = str.OptionalStartsWith(prefix);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void OptionalStartsWith_NoMatchComparison_False()
+        {
+            string? str = "postfix";
+            string prefix = "prefix";
+
+            bool actual = str.OptionalStartsWith(prefix, StringComparison.OrdinalIgnoreCase);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void OptionalStartsWith_MatchesNoComparison_True()
+        {
+            string? str = "prefix";
+            string prefix = "prefix";
+
+            bool actual = str.OptionalStartsWith(prefix);
+            Assert.True(actual);
+        }
+
+        [Fact]
+        public void OptionalStartsWith_MatchesComparison_True()
+        {
+            string? str = "prefix";
+            string prefix = "prefix";
+
+            bool actual = str.OptionalStartsWith(prefix, StringComparison.OrdinalIgnoreCase);
+            Assert.True(actual);
+        }
+
+        #endregion
+    }
+}

BinaryObjectScanner.Test/FactoryTests.cs

@@ -0,0 +1,124 @@
+using System;
+using System.Collections.Generic;
+using BinaryObjectScanner.Interfaces;
+using SabreTools.Serialization.Wrappers;
+using Xunit;
+
+namespace BinaryObjectScanner.Test
+{
+    public class FactoryTests
+    {
+        #region CreateDetectable
+
+        private static readonly List<WrapperType> _detectableTypes =
+        [
+            WrapperType.AACSMediaKeyBlock,
+            WrapperType.BDPlusSVM,
+            //WrapperType.CIA,
+            WrapperType.Executable,
+            WrapperType.LDSCRYPT,
+            //WrapperType.N3DS,
+            //WrapperType.Nitro,
+            WrapperType.PlayJAudioFile,
+            WrapperType.RealArcadeInstaller,
+            WrapperType.RealArcadeMezzanine,
+            WrapperType.SFFS,
+            WrapperType.Textfile,
+        ];
+
+        [Theory]
+        [MemberData(nameof(GenerateIDetectableTestData))]
+        public void CreateDetectableTests(WrapperType type, bool expectNull)
+        {
+            IDetectable? actual = Factory.CreateDetectable(type);
+
+            if (expectNull)
+                Assert.Null(actual);
+            else
+                Assert.NotNull(actual);
+        }
+
+        public static List<object?[]> GenerateIDetectableTestData()
+        {
+            var testData = new List<object?[]>() { new object?[] { null, true } };
+            foreach (WrapperType type in Enum.GetValues(typeof(WrapperType)))
+            {
+                if (_detectableTypes.Contains(type))
+                    testData.Add([type, false]);
+                else
+                    testData.Add([type, true]);
+            }
+
+            return testData;
+        }
+
+        #endregion
+
+        #region CreateExtractable
+
+        private static readonly List<WrapperType> _extractableTypes =
+        [
+            WrapperType.BFPK,
+            WrapperType.BSP,
+            WrapperType.BZip2,
+            WrapperType.CFB,
+            //WrapperType.CIA,
+            //WrapperType.Executable,
+            WrapperType.GCF,
+            WrapperType.GZIP,
+            WrapperType.InstallShieldArchiveV3,
+            WrapperType.InstallShieldCAB,
+            WrapperType.LZKWAJ,
+            WrapperType.LZQBasic,
+            WrapperType.LZSZDD,
+            WrapperType.MicrosoftCAB,
+            WrapperType.MoPaQ,
+            //WrapperType.N3DS,
+            //WrapperType.NCF,
+            //WrapperType.Nitro,
+            WrapperType.PAK,
+            WrapperType.PFF,
+            WrapperType.PKZIP,
+            //WrapperType.PlayJAudioFile,
+            //WrapperType.Quantum,
+            WrapperType.RAR,
+            WrapperType.SevenZip,
+            WrapperType.SFFS,
+            WrapperType.SGA,
+            WrapperType.TapeArchive,
+            WrapperType.VBSP,
+            WrapperType.VPK,
+            WrapperType.WAD,
+            WrapperType.XZ,
+            WrapperType.XZP,
+        ];
+
+        [Theory]
+        [MemberData(nameof(GenerateIExtractableTestData))]
+        public void CreateExtractableTests(WrapperType type, bool expectNull)
+        {
+            IExtractable? actual = Factory.CreateExtractable(type);
+
+            if (expectNull)
+                Assert.Null(actual);
+            else
+                Assert.NotNull(actual);
+        }
+
+        public static List<object?[]> GenerateIExtractableTestData()
+        {
+            var testData = new List<object?[]>();
+            foreach (WrapperType type in Enum.GetValues(typeof(WrapperType)))
+            {
+                if (_extractableTypes.Contains(type))
+                    testData.Add([type, false]);
+                else
+                    testData.Add([type, true]);
+            }
+
+            return testData;
+        }
+
+        #endregion
+    }
+}

BinaryObjectScanner.Test/FileType/AACSMediaKeyBlockTests.cs

@@ -0,0 +1,31 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class AACSMediaKeyBlockTests
+    {
+        [Fact]
+        public void DetectFile_EmptyString_Null()
+        {
+            string file = string.Empty;
+            var detectable = new AACSMediaKeyBlock();
+
+            string? actual = detectable.Detect(file, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void DetectStream_EmptyStream_Null()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            var detectable = new AACSMediaKeyBlock();
+
+            string? actual = detectable.Detect(stream, file, includeDebug: false);
+            Assert.Null(actual);
+        }
+    }
+}
+

BinaryObjectScanner.Test/FileType/BDPlusSVMTests.cs

@@ -0,0 +1,31 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class BDPlusSVMTests
+    {
+        [Fact]
+        public void DetectFile_EmptyString_Null()
+        {
+            string file = string.Empty;
+            var detectable = new BDPlusSVM();
+
+            string? actual = detectable.Detect(file, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void DetectStream_EmptyStream_Null()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            var detectable = new BDPlusSVM();
+
+            string? actual = detectable.Detect(stream, file, includeDebug: false);
+            Assert.Null(actual);
+        }
+    }
+}
+

BinaryObjectScanner.Test/FileType/BFPKTests.cs

@@ -0,0 +1,68 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class BFPKTests
+    {
+        [Fact]
+        public void ExtractFile_EmptyString_False()
+        {
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new BFPK();
+
+            bool actual = extractable.Extract(file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Null_False()
+        {
+            Stream? stream = null;
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new BFPK();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Empty_False()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new BFPK();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    
+        [Fact]
+        public void ExtractAll_EmptyModel_False()
+        {
+            var model = new SabreTools.Models.BFPK.Archive();
+            var data = new MemoryStream();
+            var item = new SabreTools.Serialization.Wrappers.BFPK(model, data);
+            string outputDirectory = string.Empty;
+
+            bool actual = BFPK.ExtractAll(item, outputDirectory);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractFile_EmptyModel_False()
+        {
+            var model = new SabreTools.Models.BFPK.Archive();
+            var data = new MemoryStream();
+            var item = new SabreTools.Serialization.Wrappers.BFPK(model, data);
+            string outputDirectory = string.Empty;
+
+            bool actual = BFPK.ExtractFile(item, 0, outputDirectory);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/FileType/BSPTests.cs

@@ -0,0 +1,44 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class BSPTests
+    {
+        [Fact]
+        public void ExtractFile_EmptyString_False()
+        {
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new BSP();
+
+            bool actual = extractable.Extract(file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Null_False()
+        {
+            Stream? stream = null;
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new BSP();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Empty_False()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new BSP();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/FileType/BZip2Tests.cs

@@ -0,0 +1,44 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class BZip2Tests
+    {
+        [Fact]
+        public void ExtractFile_EmptyString_False()
+        {
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new BZip2();
+
+            bool actual = extractable.Extract(file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Null_False()
+        {
+            Stream? stream = null;
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new BZip2();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Empty_False()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new BZip2();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/FileType/CFBTests.cs

@@ -0,0 +1,44 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class CFBTests
+    {
+        [Fact]
+        public void ExtractFile_EmptyString_False()
+        {
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new CFB();
+
+            bool actual = extractable.Extract(file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Null_False()
+        {
+            Stream? stream = null;
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new CFB();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Empty_False()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new CFB();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/FileType/ExecutableTests.cs

@@ -0,0 +1,43 @@
+using System;
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class ExecutableTests
+    {
+        [Fact]
+        public void DetectFile_EmptyString_Null()
+        {
+            string file = string.Empty;
+            var detectable = new Executable();
+
+            string? actual = detectable.Detect(file, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void DetectStream_EmptyStream_Null()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            var detectable = new Executable();
+
+            string? actual = detectable.Detect(stream, file, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void DetectDict_EmptyStream_Empty()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            Func<string, ProtectionDictionary>? getProtections = null;
+            var detectable = new Executable();
+
+            ProtectionDictionary actual = detectable.DetectDict(stream, file, getProtections, includeDebug: false);
+            Assert.Empty(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/FileType/GCFTests.cs

@@ -0,0 +1,44 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class GCFTests
+    {
+        [Fact]
+        public void ExtractFile_EmptyString_False()
+        {
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new GCF();
+
+            bool actual = extractable.Extract(file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Null_False()
+        {
+            Stream? stream = null;
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new GCF();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Empty_False()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new GCF();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/FileType/GZIPTests.cs

@@ -0,0 +1,44 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class GZIPTests
+    {
+        [Fact]
+        public void ExtractFile_EmptyString_False()
+        {
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new GZIP();
+
+            bool actual = extractable.Extract(file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Null_False()
+        {
+            Stream? stream = null;
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new GZIP();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Empty_False()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new GZIP();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/FileType/InstallShieldArchiveV3Tests.cs

@@ -0,0 +1,44 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class InstallShieldArchiveV3Tests
+    {
+        [Fact]
+        public void ExtractFile_EmptyString_False()
+        {
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new InstallShieldArchiveV3();
+
+            bool actual = extractable.Extract(file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Null_False()
+        {
+            Stream? stream = null;
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new InstallShieldArchiveV3();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Empty_False()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new InstallShieldArchiveV3();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/FileType/InstallShieldCABTests.cs

@@ -0,0 +1,44 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class InstallShieldCABTests
+    {
+        [Fact]
+        public void ExtractFile_EmptyString_False()
+        {
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new InstallShieldCAB();
+
+            bool actual = extractable.Extract(file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Null_False()
+        {
+            Stream? stream = null;
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new InstallShieldCAB();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Empty_False()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new InstallShieldCAB();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/FileType/LDSCRYPTTests.cs

@@ -0,0 +1,31 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class LDSCRYPTTests
+    {
+        [Fact]
+        public void DetectFile_EmptyString_Null()
+        {
+            string file = string.Empty;
+            var detectable = new LDSCRYPT();
+
+            string? actual = detectable.Detect(file, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void DetectStream_EmptyStream_Null()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            var detectable = new LDSCRYPT();
+
+            string? actual = detectable.Detect(stream, file, includeDebug: false);
+            Assert.Null(actual);
+        }
+    }
+}
+

BinaryObjectScanner.Test/FileType/LZKWAJTests.cs

@@ -0,0 +1,44 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class LZKWAJTests
+    {
+        [Fact]
+        public void ExtractFile_EmptyString_False()
+        {
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new LZKWAJ();
+
+            bool actual = extractable.Extract(file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Null_False()
+        {
+            Stream? stream = null;
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new LZKWAJ();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Empty_False()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new LZKWAJ();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/FileType/LZQBasicTests.cs

@@ -0,0 +1,44 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class LZQBasicTests
+    {
+        [Fact]
+        public void ExtractFile_EmptyString_False()
+        {
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new LZQBasic();
+
+            bool actual = extractable.Extract(file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Null_False()
+        {
+            Stream? stream = null;
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new LZQBasic();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Empty_False()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new LZQBasic();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/FileType/LZSZDDTests.cs

@@ -0,0 +1,44 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class LZSZDDTests
+    {
+        [Fact]
+        public void ExtractFile_EmptyString_False()
+        {
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new LZSZDD();
+
+            bool actual = extractable.Extract(file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Null_False()
+        {
+            Stream? stream = null;
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new LZSZDD();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Empty_False()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new LZSZDD();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/FileType/MPQTests.cs

@@ -0,0 +1,44 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class MPQTests
+    {
+        [Fact]
+        public void ExtractFile_EmptyString_False()
+        {
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new MPQ();
+
+            bool actual = extractable.Extract(file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Null_False()
+        {
+            Stream? stream = null;
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new MPQ();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Empty_False()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new MPQ();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/FileType/MicrosoftCABTests.cs

@@ -0,0 +1,44 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class MicrosoftCABTests
+    {
+        [Fact]
+        public void ExtractFile_EmptyString_False()
+        {
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new MicrosoftCAB();
+
+            bool actual = extractable.Extract(file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Null_False()
+        {
+            Stream? stream = null;
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new MicrosoftCAB();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Empty_False()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new MicrosoftCAB();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/FileType/PAKTests.cs

@@ -0,0 +1,44 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class PAKTests
+    {
+        [Fact]
+        public void ExtractFile_EmptyString_False()
+        {
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new PAK();
+
+            bool actual = extractable.Extract(file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Null_False()
+        {
+            Stream? stream = null;
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new PAK();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Empty_False()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new PAK();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/FileType/PFFTests.cs

@@ -0,0 +1,44 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class PFFTests
+    {
+        [Fact]
+        public void ExtractFile_EmptyString_False()
+        {
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new PFF();
+
+            bool actual = extractable.Extract(file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Null_False()
+        {
+            Stream? stream = null;
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new PFF();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Empty_False()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new PFF();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/FileType/PKZIPTests.cs

@@ -0,0 +1,79 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class PKZIPTests
+    {
+        [Fact]
+        public void ExtractFile_EmptyString_False()
+        {
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new PKZIP();
+
+            bool actual = extractable.Extract(file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractFile_LookForHeader_EmptyString_False()
+        {
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new PKZIP();
+
+            bool actual = extractable.Extract(file, outDir, lookForHeader: true, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Null_False()
+        {
+            Stream? stream = null;
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new PKZIP();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_LookForHeader_Null_False()
+        {
+            Stream? stream = null;
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new PKZIP();
+
+            bool actual = extractable.Extract(stream, file, outDir, lookForHeader: true, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Empty_False()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new PKZIP();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_LookForHeader_Empty_False()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new PKZIP();
+
+            bool actual = extractable.Extract(stream, file, outDir, lookForHeader: true, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/FileType/PLJTests.cs

@@ -0,0 +1,31 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class PLJTests
+    {
+        [Fact]
+        public void DetectFile_EmptyString_Null()
+        {
+            string file = string.Empty;
+            var detectable = new PLJ();
+
+            string? actual = detectable.Detect(file, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void DetectStream_EmptyStream_Null()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            var detectable = new PLJ();
+
+            string? actual = detectable.Detect(stream, file, includeDebug: false);
+            Assert.Null(actual);
+        }
+    }
+}
+

BinaryObjectScanner.Test/FileType/QuantumTests.cs

@@ -0,0 +1,68 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class QuantumTests
+    {
+        [Fact]
+        public void ExtractFile_EmptyString_False()
+        {
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new Quantum();
+
+            bool actual = extractable.Extract(file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Null_False()
+        {
+            Stream? stream = null;
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new Quantum();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Empty_False()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new Quantum();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractAll_EmptyModel_False()
+        {
+            var model = new SabreTools.Models.Quantum.Archive();
+            var data = new MemoryStream();
+            var item = new SabreTools.Serialization.Wrappers.Quantum(model, data);
+            string outputDirectory = string.Empty;
+
+            bool actual = Quantum.ExtractAll(item, outputDirectory);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractFile_EmptyModel_False()
+        {
+            var model = new SabreTools.Models.Quantum.Archive();
+            var data = new MemoryStream();
+            var item = new SabreTools.Serialization.Wrappers.Quantum(model, data);
+            string outputDirectory = string.Empty;
+
+            bool actual = Quantum.ExtractFile(item, 0, outputDirectory);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/FileType/RARTests.cs

@@ -0,0 +1,79 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class RARTests
+    {
+        [Fact]
+        public void ExtractFile_EmptyString_False()
+        {
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new RAR();
+
+            bool actual = extractable.Extract(file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractFile_LookForHeader_EmptyString_False()
+        {
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new RAR();
+
+            bool actual = extractable.Extract(file, outDir, lookForHeader: true, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Null_False()
+        {
+            Stream? stream = null;
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new RAR();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_LookForHeader_Null_False()
+        {
+            Stream? stream = null;
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new RAR();
+
+            bool actual = extractable.Extract(stream, file, outDir, lookForHeader: true, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Empty_False()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new RAR();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_LookForHeader_Empty_False()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new RAR();
+
+            bool actual = extractable.Extract(stream, file, outDir, lookForHeader: true, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/FileType/RealArcadeInstallerTests.cs

@@ -0,0 +1,31 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class RealArcadeInstallerTests
+    {
+        [Fact]
+        public void DetectFile_EmptyString_Null()
+        {
+            string file = string.Empty;
+            var detectable = new RealArcadeInstaller();
+
+            string? actual = detectable.Detect(file, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void DetectStream_EmptyStream_Null()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            var detectable = new RealArcadeInstaller();
+
+            string? actual = detectable.Detect(stream, file, includeDebug: false);
+            Assert.Null(actual);
+        }
+    }
+}
+

BinaryObjectScanner.Test/FileType/RealArcadeMezzanineTests.cs

@@ -0,0 +1,31 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class RealArcadeMezzanineTests
+    {
+        [Fact]
+        public void DetectFile_EmptyString_Null()
+        {
+            string file = string.Empty;
+            var detectable = new RealArcadeMezzanine();
+
+            string? actual = detectable.Detect(file, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void DetectStream_EmptyStream_Null()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            var detectable = new RealArcadeMezzanine();
+
+            string? actual = detectable.Detect(stream, file, includeDebug: false);
+            Assert.Null(actual);
+        }
+    }
+}
+

BinaryObjectScanner.Test/FileType/SFFSTests.cs

@@ -0,0 +1,65 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class SFFSTests
+    {
+        [Fact]
+        public void DetectFile_EmptyString_Null()
+        {
+            string file = string.Empty;
+            var detectable = new SFFS();
+
+            string? actual = detectable.Detect(file, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void DetectStream_EmptyStream_Null()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            var detectable = new SFFS();
+
+            string? actual = detectable.Detect(stream, file, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void ExtractFile_EmptyString_False()
+        {
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new SFFS();
+
+            bool actual = extractable.Extract(file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Null_False()
+        {
+            Stream? stream = null;
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new SFFS();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Empty_False()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new SFFS();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/FileType/SGATests.cs

@@ -0,0 +1,44 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class SGATests
+    {
+        [Fact]
+        public void ExtractFile_EmptyString_False()
+        {
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new SGA();
+
+            bool actual = extractable.Extract(file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Null_False()
+        {
+            Stream? stream = null;
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new SGA();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Empty_False()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new SGA();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/FileType/SevenZipTests.cs

@@ -0,0 +1,79 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class SevenZipTests
+    {
+        [Fact]
+        public void ExtractFile_EmptyString_False()
+        {
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new SevenZip();
+
+            bool actual = extractable.Extract(file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractFile_LookForHeader_EmptyString_False()
+        {
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new SevenZip();
+
+            bool actual = extractable.Extract(file, outDir, lookForHeader: true, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Null_False()
+        {
+            Stream? stream = null;
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new SevenZip();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_LookForHeader_Null_False()
+        {
+            Stream? stream = null;
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new SevenZip();
+
+            bool actual = extractable.Extract(stream, file, outDir, lookForHeader: true, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Empty_False()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new SevenZip();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_LookForHeader_Empty_False()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new SevenZip();
+
+            bool actual = extractable.Extract(stream, file, outDir, lookForHeader: true, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/FileType/TapeArchiveTests.cs

@@ -0,0 +1,46 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class TapeArchiveTests
+    {
+        [Fact]
+        public void ExtractFile_EmptyString_False()
+        {
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new TapeArchive();
+
+            bool actual = extractable.Extract(file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Null_False()
+        {
+            Stream? stream = null;
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new TapeArchive();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Empty_True()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new TapeArchive();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+
+            // Unexpected result -- Empty file recognized as valid in SharpCompress
+            Assert.True(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/FileType/TextfileTests.cs

@@ -0,0 +1,31 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class TextfileTests
+    {
+        [Fact]
+        public void DetectFile_EmptyString_Null()
+        {
+            string file = string.Empty;
+            var detectable = new Textfile();
+
+            string? actual = detectable.Detect(file, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void DetectStream_EmptyStream_Null()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            var detectable = new Textfile();
+
+            string? actual = detectable.Detect(stream, file, includeDebug: false);
+            Assert.Null(actual);
+        }
+    }
+}
+

BinaryObjectScanner.Test/FileType/VBSPTests.cs

@@ -0,0 +1,44 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class VBSPTests
+    {
+        [Fact]
+        public void ExtractFile_EmptyString_False()
+        {
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new VBSP();
+
+            bool actual = extractable.Extract(file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Null_False()
+        {
+            Stream? stream = null;
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new VBSP();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Empty_False()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new VBSP();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/FileType/VPKTests.cs

@@ -0,0 +1,44 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class VPKTests
+    {
+        [Fact]
+        public void ExtractFile_EmptyString_False()
+        {
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new VPK();
+
+            bool actual = extractable.Extract(file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Null_False()
+        {
+            Stream? stream = null;
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new VPK();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Empty_False()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new VPK();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/FileType/WAD3Tests.cs

@@ -0,0 +1,44 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class WAD3Tests
+    {
+        [Fact]
+        public void ExtractFile_EmptyString_False()
+        {
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new WAD3();
+
+            bool actual = extractable.Extract(file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Null_False()
+        {
+            Stream? stream = null;
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new WAD3();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Empty_False()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new WAD3();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/FileType/XZPTests.cs

@@ -0,0 +1,44 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class XZPTests
+    {
+        [Fact]
+        public void ExtractFile_EmptyString_False()
+        {
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new XZP();
+
+            bool actual = extractable.Extract(file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Null_False()
+        {
+            Stream? stream = null;
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new XZP();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Empty_False()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new XZP();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/FileType/XZTests.cs

@@ -0,0 +1,44 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class XZTests
+    {
+        [Fact]
+        public void ExtractFile_EmptyString_False()
+        {
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new XZ();
+
+            bool actual = extractable.Extract(file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Null_False()
+        {
+            Stream? stream = null;
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new XZ();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractStream_Empty_False()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            string outDir = string.Empty;
+            var extractable = new XZ();
+
+            bool actual = extractable.Extract(stream, file, outDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/GameEngine/RenderWareTests.cs

@@ -0,0 +1,22 @@
+using System.IO;
+using BinaryObjectScanner.GameEngine;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.GameEngine
+{
+    public class RenderWareTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new RenderWare();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Packer/ASPackTests.cs

@@ -0,0 +1,36 @@
+using System.IO;
+using BinaryObjectScanner.Packer;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Packer
+{
+    public class ASPackTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new ASPack();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    
+        [Fact]
+        public void ExtractPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+            string outputDir = string.Empty;
+
+            var checker = new ASPack();
+            bool actual = checker.Extract(file, pex, outputDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Packer/AdvancedInstallerTests.cs

@@ -0,0 +1,36 @@
+using System.IO;
+using BinaryObjectScanner.Packer;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Packer
+{
+    public class AdvancedInstallerTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new AdvancedInstaller();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void ExtractPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+            string outputDir = string.Empty;
+
+            var checker = new AdvancedInstaller();
+            bool actual = checker.Extract(file, pex, outputDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Packer/AutoPlayMediaStudioTests.cs

@@ -0,0 +1,36 @@
+using System.IO;
+using BinaryObjectScanner.Packer;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Packer
+{
+    public class AutoPlayMediaStudioTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new AutoPlayMediaStudio();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    
+        [Fact]
+        public void ExtractPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+            string outputDir = string.Empty;
+
+            var checker = new AutoPlayMediaStudio();
+            bool actual = checker.Extract(file, pex, outputDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Packer/CExeTests.cs

@@ -0,0 +1,36 @@
+using System.IO;
+using BinaryObjectScanner.Packer;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Packer
+{
+    public class CExeTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new CExe();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    
+        [Fact]
+        public void ExtractPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+            string outputDir = string.Empty;
+
+            var checker = new CExe();
+            bool actual = checker.Extract(file, pex, outputDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Packer/DotFuscatorTests.cs

@@ -0,0 +1,36 @@
+using System.IO;
+using BinaryObjectScanner.Packer;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Packer
+{
+    public class DotFuscatorTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new DotFuscator();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    
+        [Fact]
+        public void ExtractPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+            string outputDir = string.Empty;
+
+            var checker = new DotFuscator();
+            bool actual = checker.Extract(file, pex, outputDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Packer/DotNetReactorTests.cs

@@ -0,0 +1,36 @@
+using System.IO;
+using BinaryObjectScanner.Packer;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Packer
+{
+    public class DotNetReactorTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new DotNetReactor();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    
+        [Fact]
+        public void ExtractPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+            string outputDir = string.Empty;
+
+            var checker = new DotNetReactor();
+            bool actual = checker.Extract(file, pex, outputDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Packer/EXEStealthTests.cs

@@ -0,0 +1,47 @@
+using System.IO;
+using BinaryObjectScanner.Packer;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Packer
+{
+    public class EXEStealthTests
+    {
+        [Fact]
+        public void CheckContentsTest()
+        {
+            string file = "filename";
+            byte[] fileContent = [0x01, 0x02, 0x03, 0x04];
+
+            var checker = new EXEStealth();
+            string? actual = checker.CheckContents(file, fileContent, includeDebug: true);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new EXEStealth();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void ExtractPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+            string outputDir = string.Empty;
+
+            var checker = new EXEStealth();
+            bool actual = checker.Extract(file, pex, outputDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Packer/EmbeddedArchiveTests.cs

@@ -0,0 +1,36 @@
+using System.IO;
+using BinaryObjectScanner.Packer;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Packer
+{
+    public class EmbeddedArchiveTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new EmbeddedArchive();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    
+        [Fact]
+        public void ExtractPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+            string outputDir = string.Empty;
+
+            var checker = new EmbeddedArchive();
+            bool actual = checker.Extract(file, pex, outputDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Packer/EmbeddedExecutableTests.cs

@@ -0,0 +1,36 @@
+using System.IO;
+using BinaryObjectScanner.Packer;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Packer
+{
+    public class EmbeddedExecutableTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new EmbeddedExecutable();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    
+        [Fact]
+        public void ExtractPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+            string outputDir = string.Empty;
+
+            var checker = new EmbeddedExecutable();
+            bool actual = checker.Extract(file, pex, outputDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Packer/GenteeInstallerTests.cs

@@ -0,0 +1,36 @@
+using System.IO;
+using BinaryObjectScanner.Packer;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Packer
+{
+    public class GenteeInstallerTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new GenteeInstaller();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    
+        [Fact]
+        public void ExtractPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+            string outputDir = string.Empty;
+
+            var checker = new GenteeInstaller();
+            bool actual = checker.Extract(file, pex, outputDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Packer/HyperTechCrackProofTests.cs

@@ -0,0 +1,36 @@
+using System.IO;
+using BinaryObjectScanner.Packer;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Packer
+{
+    public class HyperTechCrackProofTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new HyperTechCrackProof();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    
+        [Fact]
+        public void ExtractPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+            string outputDir = string.Empty;
+
+            var checker = new HyperTechCrackProof();
+            bool actual = checker.Extract(file, pex, outputDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Packer/InnoSetupTests.cs

@@ -0,0 +1,63 @@
+using System.IO;
+using BinaryObjectScanner.Packer;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Packer
+{
+    public class InnoSetupTests
+    {
+        [Fact]
+        public void CheckNewExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.NewExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.NewExecutable nex = new(model, source);
+
+            var checker = new InnoSetup();
+            string? actual = checker.CheckExecutable(file, nex, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new InnoSetup();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void ExtractNewExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.NewExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.NewExecutable nex = new(model, source);
+            string outputDir = string.Empty;
+
+            var checker = new InnoSetup();
+            bool actual = checker.Extract(file, nex, outputDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+            string outputDir = string.Empty;
+
+            var checker = new InnoSetup();
+            bool actual = checker.Extract(file, pex, outputDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Packer/InstallAnywhereTests.cs

@@ -0,0 +1,36 @@
+using System.IO;
+using BinaryObjectScanner.Packer;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Packer
+{
+    public class InstallAnywhereTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new InstallAnywhere();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    
+        [Fact]
+        public void ExtractPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+            string outputDir = string.Empty;
+
+            var checker = new InstallAnywhere();
+            bool actual = checker.Extract(file, pex, outputDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Packer/InstallerVISETests.cs

@@ -0,0 +1,36 @@
+using System.IO;
+using BinaryObjectScanner.Packer;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Packer
+{
+    public class InstallerVISETests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new InstallerVISE();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    
+        [Fact]
+        public void ExtractPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+            string outputDir = string.Empty;
+
+            var checker = new InstallerVISE();
+            bool actual = checker.Extract(file, pex, outputDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Packer/IntelInstallationFrameworkTests.cs

@@ -0,0 +1,36 @@
+using System.IO;
+using BinaryObjectScanner.Packer;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Packer
+{
+    public class IntelInstallationFrameworkTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new IntelInstallationFramework();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    
+        [Fact]
+        public void ExtractPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+            string outputDir = string.Empty;
+
+            var checker = new IntelInstallationFramework();
+            bool actual = checker.Extract(file, pex, outputDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Packer/MicrosoftCABSFXTests.cs

@@ -0,0 +1,36 @@
+using System.IO;
+using BinaryObjectScanner.Packer;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Packer
+{
+    public class MicrosoftCABSFXTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new MicrosoftCABSFX();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    
+        [Fact]
+        public void ExtractPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+            string outputDir = string.Empty;
+
+            var checker = new MicrosoftCABSFX();
+            bool actual = checker.Extract(file, pex, outputDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Packer/NSISTests.cs

@@ -0,0 +1,36 @@
+using System.IO;
+using BinaryObjectScanner.Packer;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Packer
+{
+    public class NSISTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new NSIS();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    
+        [Fact]
+        public void ExtractPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+            string outputDir = string.Empty;
+
+            var checker = new NSIS();
+            bool actual = checker.Extract(file, pex, outputDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Packer/NeoLiteTests.cs

@@ -0,0 +1,36 @@
+using System.IO;
+using BinaryObjectScanner.Packer;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Packer
+{
+    public class NeoLiteTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new NeoLite();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    
+        [Fact]
+        public void ExtractPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+            string outputDir = string.Empty;
+
+            var checker = new NeoLite();
+            bool actual = checker.Extract(file, pex, outputDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Packer/PECompactTests.cs

@@ -0,0 +1,36 @@
+using System.IO;
+using BinaryObjectScanner.Packer;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Packer
+{
+    public class PECompactTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new PECompact();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    
+        [Fact]
+        public void ExtractPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+            string outputDir = string.Empty;
+
+            var checker = new PECompact();
+            bool actual = checker.Extract(file, pex, outputDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Packer/PEtiteTests.cs

@@ -0,0 +1,36 @@
+using System.IO;
+using BinaryObjectScanner.Packer;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Packer
+{
+    public class PetiteTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new PEtite();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    
+        [Fact]
+        public void ExtractPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+            string outputDir = string.Empty;
+
+            var checker = new PEtite();
+            bool actual = checker.Extract(file, pex, outputDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Packer/SetupFactoryTests.cs

@@ -0,0 +1,36 @@
+using System.IO;
+using BinaryObjectScanner.Packer;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Packer
+{
+    public class SetupFactoryTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new SetupFactory();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void ExtractPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+            string outputDir = string.Empty;
+
+            var checker = new SetupFactory();
+            bool actual = checker.Extract(file, pex, outputDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Packer/SevenZipSFXTests.cs

@@ -0,0 +1,36 @@
+using System.IO;
+using BinaryObjectScanner.Packer;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Packer
+{
+    public class SevenZipSFXTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new SevenZipSFX();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    
+        [Fact]
+        public void ExtractPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+            string outputDir = string.Empty;
+
+            var checker = new SevenZipSFX();
+            bool actual = checker.Extract(file, pex, outputDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Packer/ShrinkerTests.cs

@@ -0,0 +1,36 @@
+using System.IO;
+using BinaryObjectScanner.Packer;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Packer
+{
+    public class ShrinkerTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new Shrinker();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    
+        [Fact]
+        public void ExtractPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+            string outputDir = string.Empty;
+
+            var checker = new Shrinker();
+            bool actual = checker.Extract(file, pex, outputDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Packer/UPXTests.cs

@@ -0,0 +1,36 @@
+using System.IO;
+using BinaryObjectScanner.Packer;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Packer
+{
+    public class UPXTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new UPX();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    
+        [Fact]
+        public void ExtractPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+            string outputDir = string.Empty;
+
+            var checker = new UPX();
+            bool actual = checker.Extract(file, pex, outputDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Packer/WinRARSFXTests.cs

@@ -0,0 +1,36 @@
+using System.IO;
+using BinaryObjectScanner.Packer;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Packer
+{
+    public class WinRARSFXTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new WinRARSFX();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void ExtractPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+            string outputDir = string.Empty;
+
+            var checker = new WinRARSFX();
+            bool actual = checker.Extract(file, pex, outputDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Packer/WinZipSFXTests.cs

@@ -0,0 +1,63 @@
+using System.IO;
+using BinaryObjectScanner.Packer;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Packer
+{
+    public class WinZipSFXTests
+    {
+        [Fact]
+        public void CheckNewExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.NewExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.NewExecutable nex = new(model, source);
+
+            var checker = new WinZipSFX();
+            string? actual = checker.CheckExecutable(file, nex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new WinZipSFX();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    
+        [Fact]
+        public void ExtractNewExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.NewExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.NewExecutable nex = new(model, source);
+            string outputDir = string.Empty;
+
+            var checker = new WinZipSFX();
+            bool actual = checker.Extract(file, nex, outputDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+            string outputDir = string.Empty;
+
+            var checker = new WinZipSFX();
+            bool actual = checker.Extract(file, pex, outputDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Packer/WiseInstallerTests.cs

@@ -0,0 +1,63 @@
+using System.IO;
+using BinaryObjectScanner.Packer;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Packer
+{
+    public class WiseInstallerTests
+    {
+        [Fact]
+        public void CheckNewExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.NewExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.NewExecutable nex = new(model, source);
+
+            var checker = new WiseInstaller();
+            string? actual = checker.CheckExecutable(file, nex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new WiseInstaller();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    
+        [Fact]
+        public void ExtractNewExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.NewExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.NewExecutable nex = new(model, source);
+            string outputDir = string.Empty;
+
+            var checker = new WiseInstaller();
+            bool actual = checker.Extract(file, nex, outputDir, includeDebug: false);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void ExtractPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+            string outputDir = string.Empty;
+
+            var checker = new WiseInstaller();
+            bool actual = checker.Extract(file, pex, outputDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Protection/ActiveMARKTests.cs

@@ -0,0 +1,33 @@
+using System.IO;
+using BinaryObjectScanner.Protection;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Protection
+{
+    public class ActiveMARKTests
+    {
+        [Fact]
+        public void CheckContentsTest()
+        {
+            string file = "filename";
+            byte[] fileContent = [0x01, 0x02, 0x03, 0x04];
+
+            var checker = new ActiveMARK();
+            string? actual = checker.CheckContents(file, fileContent, includeDebug: true);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new ActiveMARK();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Protection/AegiSoftTests.cs

@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+using System.IO;
+using BinaryObjectScanner.Protection;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Protection
+{
+    public class AegiSoftTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new AegiSoft();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void CheckDirectoryPathTest()
+        {
+            string path = "path";
+            List<string> files = [];
+
+            var checker = new AegiSoft();
+            List<string> actual = checker.CheckDirectoryPath(path, files);
+            Assert.Empty(actual);
+        }
+
+        [Fact]
+        public void CheckFilePathTest()
+        {
+            string path = "path";
+
+            var checker = new AegiSoft();
+            string? actual = checker.CheckFilePath(path);
+            Assert.Null(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Protection/AlphaDVDTests.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using BinaryObjectScanner.Protection;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Protection
+{
+    public class AlphaDVDTests
+    {
+        [Fact]
+        public void CheckDirectoryPathTest()
+        {
+            string path = "path";
+            List<string> files = [];
+
+            var checker = new AlphaDVD();
+            List<string> actual = checker.CheckDirectoryPath(path, files);
+            Assert.Empty(actual);
+        }
+
+        [Fact]
+        public void CheckFilePathTest()
+        {
+            string path = "path";
+
+            var checker = new AlphaDVD();
+            string? actual = checker.CheckFilePath(path);
+            Assert.Null(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Protection/AlphaROMTests.cs

@@ -0,0 +1,22 @@
+using System.IO;
+using BinaryObjectScanner.Protection;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Protection
+{
+    public class AlphaROMTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new AlphaROM();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Protection/ArmadilloTests.cs

@@ -0,0 +1,36 @@
+using System.IO;
+using BinaryObjectScanner.Protection;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Protection
+{
+    public class ArmadilloTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new Armadillo();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void ExtractPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+            string outputDir = string.Empty;
+
+            var checker = new Armadillo();
+            bool actual = checker.Extract(file, pex, outputDir, includeDebug: false);
+            Assert.False(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Protection/BitpoolTests.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using BinaryObjectScanner.Protection;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Protection
+{
+    public class BitpoolTests
+    {
+        [Fact]
+        public void CheckDirectoryPathTest()
+        {
+            string path = "path";
+            List<string> files = [];
+
+            var checker = new Bitpool();
+            List<string> actual = checker.CheckDirectoryPath(path, files);
+            Assert.Empty(actual);
+        }
+
+        [Fact]
+        public void CheckFilePathTest()
+        {
+            string path = "path";
+
+            var checker = new Bitpool();
+            string? actual = checker.CheckFilePath(path);
+            Assert.Null(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Protection/ByteShieldTests.cs

@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+using System.IO;
+using BinaryObjectScanner.Protection;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Protection
+{
+    public class ByteShieldTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new ByteShield();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void CheckDirectoryPathTest()
+        {
+            string path = "path";
+            List<string> files = [];
+
+            var checker = new ByteShield();
+            List<string> actual = checker.CheckDirectoryPath(path, files);
+            Assert.Empty(actual);
+        }
+
+        [Fact]
+        public void CheckFilePathTest()
+        {
+            string path = "path";
+
+            var checker = new ByteShield();
+            string? actual = checker.CheckFilePath(path);
+            Assert.Null(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Protection/CDCheckTests.cs

@@ -0,0 +1,22 @@
+using System.IO;
+using BinaryObjectScanner.Protection;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Protection
+{
+    public class CDCheckTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new CDCheck();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Protection/CDDVDCopsTests.cs

@@ -0,0 +1,68 @@
+using System.Collections.Generic;
+using System.IO;
+using BinaryObjectScanner.Protection;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Protection
+{
+    public class CDDVDCopsTests
+    {
+        [Fact]
+        public void CheckContentsTest()
+        {
+            string file = "filename";
+            byte[] fileContent = [0x01, 0x02, 0x03, 0x04];
+
+            var checker = new CDDVDCops();
+            string? actual = checker.CheckContents(file, fileContent, includeDebug: true);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void CheckNewExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.NewExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.NewExecutable nex = new(model, source);
+
+            var checker = new CDDVDCops();
+            string? actual = checker.CheckExecutable(file, nex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new CDDVDCops();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    
+        [Fact]
+        public void CheckDirectoryPathTest()
+        {
+            string path = "path";
+            List<string> files = [];
+
+            var checker = new CDDVDCops();
+            List<string> actual = checker.CheckDirectoryPath(path, files);
+            Assert.Empty(actual);
+        }
+
+        [Fact]
+        public void CheckFilePathTest()
+        {
+            string path = "path";
+
+            var checker = new CDDVDCops();
+            string? actual = checker.CheckFilePath(path);
+            Assert.Null(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Protection/CDGuardTests.cs

@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+using System.IO;
+using BinaryObjectScanner.Protection;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Protection
+{
+    public class CDGuardTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new CDGuard();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void CheckDirectoryPathTest()
+        {
+            string path = "path";
+            List<string> files = [];
+
+            var checker = new CDGuard();
+            List<string> actual = checker.CheckDirectoryPath(path, files);
+            Assert.Empty(actual);
+        }
+
+        [Fact]
+        public void CheckFilePathTest()
+        {
+            string path = "path";
+
+            var checker = new CDGuard();
+            string? actual = checker.CheckFilePath(path);
+            Assert.Null(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Protection/CDKeyTests.cs

@@ -0,0 +1,22 @@
+using System.IO;
+using BinaryObjectScanner.Protection;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Protection
+{
+    public class CDKeyTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new CDKey();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Protection/CDLockTests.cs

@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+using System.IO;
+using BinaryObjectScanner.Protection;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Protection
+{
+    public class CDLockTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new CDLock();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void CheckDirectoryPathTest()
+        {
+            string path = "path";
+            List<string> files = [];
+
+            var checker = new CDLock();
+            List<string> actual = checker.CheckDirectoryPath(path, files);
+            Assert.Empty(actual);
+        }
+
+        [Fact]
+        public void CheckFilePathTest()
+        {
+            string path = "path";
+
+            var checker = new CDLock();
+            string? actual = checker.CheckFilePath(path);
+            Assert.Null(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Protection/CDProtectorTests.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using BinaryObjectScanner.Protection;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Protection
+{
+    public class CDProtectorTests
+    {
+        [Fact]
+        public void CheckDirectoryPathTest()
+        {
+            string path = "path";
+            List<string> files = [];
+
+            var checker = new CDProtector();
+            List<string> actual = checker.CheckDirectoryPath(path, files);
+            Assert.Empty(actual);
+        }
+
+        [Fact]
+        public void CheckFilePathTest()
+        {
+            string path = "path";
+
+            var checker = new CDProtector();
+            string? actual = checker.CheckFilePath(path);
+            Assert.Null(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Protection/CDSHiELDSETests.cs

@@ -0,0 +1,22 @@
+using System.IO;
+using BinaryObjectScanner.Protection;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Protection
+{
+    public class CDSHiELDSETests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new CDSHiELDSE();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Protection/CDXTests.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using BinaryObjectScanner.Protection;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Protection
+{
+    public class CDXTests
+    {
+        [Fact]
+        public void CheckDirectoryPathTest()
+        {
+            string path = "path";
+            List<string> files = [];
+
+            var checker = new CDX();
+            List<string> actual = checker.CheckDirectoryPath(path, files);
+            Assert.Empty(actual);
+        }
+
+        [Fact]
+        public void CheckFilePathTest()
+        {
+            string path = "path";
+
+            var checker = new CDX();
+            string? actual = checker.CheckFilePath(path);
+            Assert.Null(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Protection/CactusDataShieldTests.cs

@@ -0,0 +1,19 @@
+using BinaryObjectScanner.Protection;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Protection
+{
+    public class CactusDataShieldTests
+    {
+        [Fact]
+        public void CheckContentsTest()
+        {
+            string file = "filename";
+            byte[] fileContent = [0x01, 0x02, 0x03, 0x04];
+
+            var checker = new CactusDataShield();
+            string? actual = checker.CheckContents(file, fileContent, includeDebug: true);
+            Assert.Null(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Protection/CenegaProtectDVDTests.cs

@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+using System.IO;
+using BinaryObjectScanner.Protection;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Protection
+{
+    public class CenegaProtectDVDTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new CenegaProtectDVD();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void CheckDirectoryPathTest()
+        {
+            string path = "path";
+            List<string> files = [];
+
+            var checker = new CenegaProtectDVD();
+            List<string> actual = checker.CheckDirectoryPath(path, files);
+            Assert.Empty(actual);
+        }
+
+        [Fact]
+        public void CheckFilePathTest()
+        {
+            string path = "path";
+
+            var checker = new CenegaProtectDVD();
+            string? actual = checker.CheckFilePath(path);
+            Assert.Null(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Protection/ChannelwareTests.cs

@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+using System.IO;
+using BinaryObjectScanner.Protection;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Protection
+{
+    public class ChannelwareTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new Channelware();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void CheckDirectoryPathTest()
+        {
+            string path = "path";
+            List<string> files = [];
+
+            var checker = new Channelware();
+            List<string> actual = checker.CheckDirectoryPath(path, files);
+            Assert.Empty(actual);
+        }
+
+        [Fact]
+        public void CheckFilePathTest()
+        {
+            string path = "path";
+
+            var checker = new Channelware();
+            string? actual = checker.CheckFilePath(path);
+            Assert.Null(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Protection/ChosenBytesCodeLockTests.cs

@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+using System.IO;
+using BinaryObjectScanner.Protection;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Protection
+{
+    public class ChosenBytesCodeLockTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new ChosenBytesCodeLock();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void CheckDirectoryPathTest()
+        {
+            string path = "path";
+            List<string> files = [];
+
+            var checker = new ChosenBytesCodeLock();
+            List<string> actual = checker.CheckDirectoryPath(path, files);
+            Assert.Empty(actual);
+        }
+
+        [Fact]
+        public void CheckFilePathTest()
+        {
+            string path = "path";
+
+            var checker = new ChosenBytesCodeLock();
+            string? actual = checker.CheckFilePath(path);
+            Assert.Null(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Protection/CopyKillerTests.cs

@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+using System.IO;
+using BinaryObjectScanner.Protection;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Protection
+{
+    public class CopyKillerTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new CopyKiller();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void CheckDirectoryPathTest()
+        {
+            string path = "path";
+            List<string> files = [];
+
+            var checker = new CopyKiller();
+            List<string> actual = checker.CheckDirectoryPath(path, files);
+            Assert.Empty(actual);
+        }
+
+        [Fact]
+        public void CheckFilePathTest()
+        {
+            string path = "path";
+
+            var checker = new CopyKiller();
+            string? actual = checker.CheckFilePath(path);
+            Assert.Null(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Protection/CopyLokTests.cs

@@ -0,0 +1,22 @@
+using System.IO;
+using BinaryObjectScanner.Protection;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Protection
+{
+    public class CopyLokTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new CopyLok();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Protection/CopyXTests.cs

@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+using System.IO;
+using BinaryObjectScanner.Protection;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Protection
+{
+    public class CopyXTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new CopyX();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void CheckDirectoryPathTest()
+        {
+            string path = "path";
+            List<string> files = [];
+
+            var checker = new CopyX();
+            List<string> actual = checker.CheckDirectoryPath(path, files);
+            Assert.Empty(actual);
+        }
+
+        [Fact]
+        public void CheckFilePathTest()
+        {
+            string path = "path";
+
+            var checker = new CopyX();
+            string? actual = checker.CheckFilePath(path);
+            Assert.Null(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Protection/CrypKeyTests.cs

@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+using System.IO;
+using BinaryObjectScanner.Protection;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Protection
+{
+    public class CrypKeyTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new CrypKey();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void CheckDirectoryPathTest()
+        {
+            string path = "path";
+            List<string> files = [];
+
+            var checker = new CrypKey();
+            List<string> actual = checker.CheckDirectoryPath(path, files);
+            Assert.Empty(actual);
+        }
+
+        [Fact]
+        public void CheckFilePathTest()
+        {
+            string path = "path";
+
+            var checker = new CrypKey();
+            string? actual = checker.CheckFilePath(path);
+            Assert.Null(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Protection/CuckoTests.cs

@@ -0,0 +1,22 @@
+using System.IO;
+using BinaryObjectScanner.Protection;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Protection
+{
+    public class CuckoTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new Cucko();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Protection/DVDCryptTests.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using BinaryObjectScanner.Protection;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Protection
+{
+    public class DVDCryptTests
+    {
+        [Fact]
+        public void CheckDirectoryPathTest()
+        {
+            string path = "path";
+            List<string> files = [];
+
+            var checker = new DVDCrypt();
+            List<string> actual = checker.CheckDirectoryPath(path, files);
+            Assert.Empty(actual);
+        }
+
+        [Fact]
+        public void CheckFilePathTest()
+        {
+            string path = "path";
+
+            var checker = new DVDCrypt();
+            string? actual = checker.CheckFilePath(path);
+            Assert.Null(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Protection/DVDMoviePROTECTTests.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using BinaryObjectScanner.Protection;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Protection
+{
+    public class DVDMoviePROTECTTests
+    {
+        [Fact]
+        public void CheckDirectoryPathTest()
+        {
+            string path = "path";
+            List<string> files = [];
+
+            var checker = new DVDMoviePROTECT();
+            List<string> actual = checker.CheckDirectoryPath(path, files);
+            Assert.Empty(actual);
+        }
+
+        [Fact]
+        public void CheckFilePathTest()
+        {
+            string path = "path";
+
+            var checker = new DVDMoviePROTECT();
+            string? actual = checker.CheckFilePath(path);
+            Assert.Null(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Protection/DenuvoTests.cs

@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+using System.IO;
+using BinaryObjectScanner.Protection;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Protection
+{
+    public class DenuvoTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream();
+            SabreTools.Serialization.Wrappers.PortableExecutable pex = new(model, source);
+
+            var checker = new Denuvo();
+            string? actual = checker.CheckExecutable(file, pex, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void CheckDirectoryPathTest()
+        {
+            string path = "path";
+            List<string> files = [];
+
+            var checker = new Denuvo();
+            List<string> actual = checker.CheckDirectoryPath(path, files);
+            Assert.Empty(actual);
+        }
+
+        [Fact]
+        public void CheckFilePathTest()
+        {
+            string path = "path";
+
+            var checker = new Denuvo();
+            string? actual = checker.CheckFilePath(path);
+            Assert.Null(actual);
+        }
+    }
+}