Bump version

* Fix version

* sf

.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,3 +0,0 @@
-[submodule "BinaryObjectScanner/_EXTERNAL/stormlibsharp"]
-	path = BinaryObjectScanner/_EXTERNAL/stormlibsharp
-	url = https://github.com/robpaveza/stormlibsharp.git

.vscode/launch.json

@@ -5,17 +5,18 @@
    "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
+            "stopAtEntry": false,
+            "justMyCode": false,
         },
         {
             "name": ".NET Core Attach",

.vscode/settings.json

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

BinaryObjectScanner.Test/BinaryObjectScanner.Test.csproj

@@ -0,0 +1,28 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFrameworks>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.4">
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+            <PrivateAssets>all</PrivateAssets>
+        </PackageReference>
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
+        <PackageReference Include="SabreTools.Serialization" Version="2.0.0" />
+        <PackageReference Include="xunit" Version="2.9.3" />
+        <PackageReference Include="xunit.runner.visualstudio" Version="3.1.4">
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+            <PrivateAssets>all</PrivateAssets>
+        </PackageReference>
+    </ItemGroup>
+
+</Project>

BinaryObjectScanner.Test/Data/ProtectionDictionaryTests.cs

@@ -0,0 +1,45 @@
+using System.Collections.Generic;
+using BinaryObjectScanner.Data;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Data
+{
+    public class ProtectionDictionaryTests
+    {
+        #region ProcessProtectionString
+
+        [Fact]
+        public void ProcessProtectionString_Null_Empty()
+        {
+            string? protection = null;
+            List<string> actual = ProtectionDictionary.ProcessProtectionString(protection);
+            Assert.Empty(actual);
+        }
+
+        [Fact]
+        public void ProcessProtectionString_Empty_Empty()
+        {
+            string? protection = string.Empty;
+            List<string> actual = ProtectionDictionary.ProcessProtectionString(protection);
+            Assert.Empty(actual);
+        }
+
+        [Fact]
+        public void ProcessProtectionString_NoIndicator_Single()
+        {
+            string? protection = "item1";
+            List<string> actual = ProtectionDictionary.ProcessProtectionString(protection);
+            Assert.Single(actual);
+        }
+
+        [Fact]
+        public void ProcessProtectionString_Indicator_Multiple()
+        {
+            string? protection = "item1;item2";
+            List<string> actual = ProtectionDictionary.ProcessProtectionString(protection);
+            Assert.Equal(2, actual.Count);
+        }
+
+        #endregion
+    }
+}

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.Equal(6, actual.Length);
+        }
+
+        [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.Equal(7, actual.Length);
+        }
+
+        [Fact]
+        public void PathCheckClasses_Populated()
+        {
+            var actual = StaticChecks.PathCheckClasses;
+            Assert.Equal(68, actual.Length);
+        }
+
+        [Fact]
+        public void PortableExecutableCheckClasses_Populated()
+        {
+            var actual = StaticChecks.PortableExecutableCheckClasses;
+            Assert.Equal(105, actual.Length);
+        }
+    }
+}

BinaryObjectScanner.Test/ExtensionsTests.cs

@@ -0,0 +1,35 @@
+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
+    }
+}

BinaryObjectScanner.Test/FileType/AACSMediaKeyBlockTests.cs

@@ -0,0 +1,34 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class AACSMediaKeyBlockTests
+    {
+        private static readonly SabreTools.Serialization.Wrappers.AACSMediaKeyBlock wrapper
+            = new(new SabreTools.Data.Models.AACS.MediaKeyBlock(), new MemoryStream(new byte[1024]));
+
+        [Fact]
+        public void DetectFile_EmptyString_Null()
+        {
+            string file = string.Empty;
+            var detectable = new AACSMediaKeyBlock(wrapper);
+
+            string? actual = detectable.Detect(file, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void DetectStream_EmptyStream_DefaultValue()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            var detectable = new AACSMediaKeyBlock(wrapper);
+
+            string? actual = detectable.Detect(stream, file, includeDebug: false);
+            Assert.Equal("AACS (Unknown Version)", actual);
+        }
+    }
+}
+

BinaryObjectScanner.Test/FileType/BDPlusSVMTests.cs

@@ -0,0 +1,34 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class BDPlusSVMTests
+    {
+        private static readonly SabreTools.Serialization.Wrappers.BDPlusSVM wrapper
+            = new(new SabreTools.Data.Models.BDPlus.SVM(), new MemoryStream(new byte[1024]));
+
+        [Fact]
+        public void DetectFile_EmptyString_Null()
+        {
+            string file = string.Empty;
+            var detectable = new BDPlusSVM(wrapper);
+
+            string? actual = detectable.Detect(file, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void DetectStream_EmptyStream_DefaultValue()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            var detectable = new BDPlusSVM(wrapper);
+
+            string? actual = detectable.Detect(stream, file, includeDebug: false);
+            Assert.Equal("BD+ 0000-00-00", actual);
+        }
+    }
+}
+

BinaryObjectScanner.Test/FileType/LDSCRYPTTests.cs

@@ -0,0 +1,34 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class LDSCRYPTTests
+    {
+        private static readonly SabreTools.Serialization.Wrappers.LDSCRYPT wrapper
+            = new(new SabreTools.Data.Models.LDSCRYPT.EncryptedFile(), new MemoryStream(new byte[1024]));
+
+        [Fact]
+        public void DetectFile_EmptyString_Null()
+        {
+            string file = string.Empty;
+            var detectable = new LDSCRYPT(wrapper);
+
+            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(wrapper);
+
+            string? actual = detectable.Detect(stream, file, includeDebug: false);
+            Assert.Equal("LDSCRYPT", actual);
+        }
+    }
+}
+

BinaryObjectScanner.Test/FileType/LinearExecutableTests.cs

@@ -0,0 +1,34 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class LinearExecutableTests
+    {
+        private static readonly SabreTools.Serialization.Wrappers.LinearExecutable wrapper
+            = new(new SabreTools.Data.Models.LinearExecutable.Executable(), new MemoryStream(new byte[1024]));
+
+        [Fact]
+        public void DetectFile_EmptyString_Null()
+        {
+            string file = string.Empty;
+            var detectable = new LinearExecutable(wrapper);
+
+            string? actual = detectable.Detect(file, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void DetectStream_EmptyStream_Empty()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            var detectable = new LinearExecutable(wrapper);
+
+            string? actual = detectable.Detect(stream, file, includeDebug: false);
+            Assert.NotNull(actual);
+            Assert.Empty(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/FileType/MSDOSTests.cs

@@ -0,0 +1,34 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class MSDOSTests
+    {
+        private static readonly SabreTools.Serialization.Wrappers.MSDOS wrapper
+            = new(new SabreTools.Data.Models.MSDOS.Executable(), new MemoryStream(new byte[1024]));
+
+        [Fact]
+        public void DetectFile_EmptyString_Null()
+        {
+            string file = string.Empty;
+            var detectable = new MSDOS(wrapper);
+
+            string? actual = detectable.Detect(file, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void DetectStream_EmptyStream_Empty()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            var detectable = new MSDOS(wrapper);
+
+            string? actual = detectable.Detect(stream, file, includeDebug: false);
+            Assert.NotNull(actual);
+            Assert.Empty(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/FileType/NewExecutableTests.cs

@@ -0,0 +1,34 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class NewExecutableTests
+    {
+        private static readonly SabreTools.Serialization.Wrappers.NewExecutable wrapper
+            = new(new SabreTools.Data.Models.NewExecutable.Executable(), new MemoryStream(new byte[1024]));
+
+        [Fact]
+        public void DetectFile_EmptyString_Null()
+        {
+            string file = string.Empty;
+            var detectable = new NewExecutable(wrapper);
+
+            string? actual = detectable.Detect(file, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void DetectStream_EmptyStream_Empty()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            var detectable = new NewExecutable(wrapper);
+
+            string? actual = detectable.Detect(stream, file, includeDebug: false);
+            Assert.NotNull(actual);
+            Assert.Empty(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/FileType/PLJTests.cs

@@ -0,0 +1,34 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class PLJTests
+    {
+        private static readonly SabreTools.Serialization.Wrappers.PlayJAudioFile wrapper
+            = new(new SabreTools.Data.Models.PlayJ.AudioFile(), new MemoryStream(new byte[1024]));
+
+        [Fact]
+        public void DetectFile_EmptyString_Null()
+        {
+            string file = string.Empty;
+            var detectable = new PLJ(wrapper);
+
+            string? actual = detectable.Detect(file, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void DetectStream_EmptyStream_DefaultValue()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            var detectable = new PLJ(wrapper);
+
+            string? actual = detectable.Detect(stream, file, includeDebug: false);
+            Assert.Equal("PlayJ Audio File", actual);
+        }
+    }
+}
+

BinaryObjectScanner.Test/FileType/PortableExecutableTests.cs

@@ -0,0 +1,34 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class PortableExecutableTests
+    {
+        private static readonly SabreTools.Serialization.Wrappers.PortableExecutable wrapper
+            = new(new SabreTools.Data.Models.PortableExecutable.Executable(), new MemoryStream(new byte[1024]));
+
+        [Fact]
+        public void DetectFile_EmptyString_Null()
+        {
+            string file = string.Empty;
+            var detectable = new PortableExecutable(wrapper);
+
+            string? actual = detectable.Detect(file, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void DetectStream_EmptyStream_Empty()
+        {
+            Stream? stream = new MemoryStream();
+            string file = string.Empty;
+            var detectable = new PortableExecutable(wrapper);
+
+            string? actual = detectable.Detect(stream, file, includeDebug: false);
+            Assert.NotNull(actual);
+            Assert.Empty(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/FileType/RealArcadeInstallerTests.cs

@@ -0,0 +1,34 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class RealArcadeInstallerTests
+    {
+        private static readonly SabreTools.Serialization.Wrappers.RealArcadeInstaller wrapper
+            = new(new SabreTools.Data.Models.RealArcade.RgsFile(), new MemoryStream(new byte[1024]));
+
+        [Fact]
+        public void DetectFile_EmptyString_Null()
+        {
+            string file = string.Empty;
+            var detectable = new RealArcadeInstaller(wrapper);
+
+            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(wrapper);
+
+            string? actual = detectable.Detect(stream, file, includeDebug: false);
+            Assert.Equal("RealArcade Installer", actual);
+        }
+    }
+}
+

BinaryObjectScanner.Test/FileType/RealArcadeMezzanineTests.cs

@@ -0,0 +1,34 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class RealArcadeMezzanineTests
+    {
+        private static readonly SabreTools.Serialization.Wrappers.RealArcadeMezzanine wrapper
+            = new(new SabreTools.Data.Models.RealArcade.Mezzanine(), new MemoryStream(new byte[1024]));
+
+        [Fact]
+        public void DetectFile_EmptyString_Null()
+        {
+            string file = string.Empty;
+            var detectable = new RealArcadeMezzanine(wrapper);
+
+            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(wrapper);
+
+            string? actual = detectable.Detect(stream, file, includeDebug: false);
+            Assert.Equal("RealArcade Mezzanine", actual);
+        }
+    }
+}
+

BinaryObjectScanner.Test/FileType/SFFSTests.cs

@@ -0,0 +1,33 @@
+using System.IO;
+using BinaryObjectScanner.FileType;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.FileType
+{
+    public class SFFSTests
+    {
+        private static readonly SabreTools.Serialization.Wrappers.SFFS wrapper
+            = new(new SabreTools.Data.Models.StarForce.FileSystem(), new MemoryStream(new byte[1024]));
+
+        [Fact]
+        public void DetectFile_EmptyString_Null()
+        {
+            string file = string.Empty;
+            var detectable = new SFFS(wrapper);
+
+            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(wrapper);
+
+            string? actual = detectable.Detect(stream, file, includeDebug: false);
+            Assert.Equal("StarForce Filesystem Container", 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/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.Data.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream(new byte[1024]);
+            SabreTools.Serialization.Wrappers.PortableExecutable exe = new(model, source);
+
+            var checker = new RenderWare();
+            string? actual = checker.CheckExecutable(file, exe, includeDebug: false);
+            Assert.Null(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Packer/ASPackTests.cs

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

BinaryObjectScanner.Test/Packer/AdvancedInstallerTests.cs

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

BinaryObjectScanner.Test/Packer/AutoPlayMediaStudioTests.cs

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

BinaryObjectScanner.Test/Packer/CExeTests.cs

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

BinaryObjectScanner.Test/Packer/CrunchTests.cs

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

BinaryObjectScanner.Test/Packer/DotFuscatorTests.cs

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

BinaryObjectScanner.Test/Packer/DotNetReactorTests.cs

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

BinaryObjectScanner.Test/Packer/EXEStealthTests.cs

@@ -0,0 +1,33 @@
+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.Data.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream(new byte[1024]);
+            SabreTools.Serialization.Wrappers.PortableExecutable exe = new(model, source);
+
+            var checker = new EXEStealth();
+            string? actual = checker.CheckExecutable(file, exe, includeDebug: false);
+            Assert.Null(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Packer/EmbeddedFileTests.cs

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

BinaryObjectScanner.Test/Packer/GenteeInstallerTests.cs

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

BinaryObjectScanner.Test/Packer/HyperTechCrackProofTests.cs

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

BinaryObjectScanner.Test/Packer/InnoSetupTests.cs

@@ -0,0 +1,35 @@
+using System.IO;
+using BinaryObjectScanner.Packer;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Packer
+{
+    public class InnoSetupTests
+    {
+        [Fact]
+        public void CheckNewExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Data.Models.NewExecutable.Executable model = new();
+            Stream source = new MemoryStream(new byte[1024]);
+            SabreTools.Serialization.Wrappers.NewExecutable exe = new(model, source);
+
+            var checker = new InnoSetup();
+            string? actual = checker.CheckExecutable(file, exe, includeDebug: false);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Data.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream(new byte[1024]);
+            SabreTools.Serialization.Wrappers.PortableExecutable exe = new(model, source);
+
+            var checker = new InnoSetup();
+            string? actual = checker.CheckExecutable(file, exe, includeDebug: false);
+            Assert.Null(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Packer/InstallAnywhereTests.cs

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

BinaryObjectScanner.Test/Packer/InstallerVISETests.cs

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

BinaryObjectScanner.Test/Packer/IntelInstallationFrameworkTests.cs

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

BinaryObjectScanner.Test/Packer/MicrosoftCABSFXTests.cs

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

BinaryObjectScanner.Test/Packer/NSISTests.cs

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

BinaryObjectScanner.Test/Packer/NeoLiteTests.cs

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

BinaryObjectScanner.Test/Packer/PECompactTests.cs

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

BinaryObjectScanner.Test/Packer/PEtiteTests.cs

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

BinaryObjectScanner.Test/Packer/SetupFactoryTests.cs

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

BinaryObjectScanner.Test/Packer/SevenZipSFXTests.cs

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

BinaryObjectScanner.Test/Packer/ShrinkerTests.cs

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

BinaryObjectScanner.Test/Packer/UPXTests.cs

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

BinaryObjectScanner.Test/Packer/WinRARSFXTests.cs

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

BinaryObjectScanner.Test/Packer/WinZipSFXTests.cs

@@ -0,0 +1,35 @@
+using System.IO;
+using BinaryObjectScanner.Packer;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Packer
+{
+    public class WinZipSFXTests
+    {
+        [Fact]
+        public void CheckNewExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Data.Models.NewExecutable.Executable model = new();
+            Stream source = new MemoryStream(new byte[1024]);
+            SabreTools.Serialization.Wrappers.NewExecutable exe = new(model, source);
+
+            var checker = new WinZipSFX();
+            string? actual = checker.CheckExecutable(file, exe, includeDebug: false);
+            Assert.Null(actual);
+        }
+    
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Data.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream(new byte[1024]);
+            SabreTools.Serialization.Wrappers.PortableExecutable exe = new(model, source);
+
+            var checker = new WinZipSFX();
+            string? actual = checker.CheckExecutable(file, exe, includeDebug: false);
+            Assert.Null(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Packer/WiseInstallerTests.cs

@@ -0,0 +1,35 @@
+using System.IO;
+using BinaryObjectScanner.Packer;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Packer
+{
+    public class WiseInstallerTests
+    {
+        [Fact]
+        public void CheckNewExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Data.Models.NewExecutable.Executable model = new();
+            Stream source = new MemoryStream(new byte[1024]);
+            SabreTools.Serialization.Wrappers.NewExecutable exe = new(model, source);
+
+            var checker = new WiseInstaller();
+            string? actual = checker.CheckExecutable(file, exe, includeDebug: false);
+            Assert.Null(actual);
+        }
+    
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Data.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream(new byte[1024]);
+            SabreTools.Serialization.Wrappers.PortableExecutable exe = new(model, source);
+
+            var checker = new WiseInstaller();
+            string? actual = checker.CheckExecutable(file, exe, includeDebug: false);
+            Assert.Null(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.Data.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream(new byte[1024]);
+            SabreTools.Serialization.Wrappers.PortableExecutable exe = new(model, source);
+
+            var checker = new ActiveMARK();
+            string? actual = checker.CheckExecutable(file, exe, 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.Data.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream(new byte[1024]);
+            SabreTools.Serialization.Wrappers.PortableExecutable exe = new(model, source);
+
+            var checker = new AegiSoft();
+            string? actual = checker.CheckExecutable(file, exe, 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.Data.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream(new byte[1024]);
+            SabreTools.Serialization.Wrappers.PortableExecutable exe = new(model, source);
+
+            var checker = new AlphaROM();
+            string? actual = checker.CheckExecutable(file, exe, includeDebug: false);
+            Assert.Null(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Protection/ArmadilloTests.cs

@@ -0,0 +1,22 @@
+using System.IO;
+using BinaryObjectScanner.Protection;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Protection
+{
+    public class ArmadilloTests
+    {
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Data.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream(new byte[1024]);
+            SabreTools.Serialization.Wrappers.PortableExecutable exe = new(model, source);
+
+            var checker = new Armadillo();
+            string? actual = checker.CheckExecutable(file, exe, includeDebug: false);
+            Assert.Null(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.Data.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream(new byte[1024]);
+            SabreTools.Serialization.Wrappers.PortableExecutable exe = new(model, source);
+
+            var checker = new ByteShield();
+            string? actual = checker.CheckExecutable(file, exe, 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.Data.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream(new byte[1024]);
+            SabreTools.Serialization.Wrappers.PortableExecutable exe = new(model, source);
+
+            var checker = new CDCheck();
+            string? actual = checker.CheckExecutable(file, exe, includeDebug: false);
+            Assert.Null(actual);
+        }
+    }
+}

BinaryObjectScanner.Test/Protection/CDDVDCopsTests.cs

@@ -0,0 +1,57 @@
+using System.Collections.Generic;
+using System.IO;
+using BinaryObjectScanner.Protection;
+using Xunit;
+
+namespace BinaryObjectScanner.Test.Protection
+{
+    public class CDDVDCopsTests
+    {
+        [Fact]
+        public void CheckNewExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Data.Models.NewExecutable.Executable model = new();
+            Stream source = new MemoryStream(new byte[1024]);
+            SabreTools.Serialization.Wrappers.NewExecutable exe = new(model, source);
+
+            var checker = new CDDVDCops();
+            string? actual = checker.CheckExecutable(file, exe, includeDebug: false);
+            Assert.Null(actual);
+        }
+    
+        [Fact]
+        public void CheckPortableExecutableTest()
+        {
+            string file = "filename";
+            SabreTools.Data.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream(new byte[1024]);
+            SabreTools.Serialization.Wrappers.PortableExecutable exe = new(model, source);
+
+            var checker = new CDDVDCops();
+            string? actual = checker.CheckExecutable(file, exe, 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.Data.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream(new byte[1024]);
+            SabreTools.Serialization.Wrappers.PortableExecutable exe = new(model, source);
+
+            var checker = new CDGuard();
+            string? actual = checker.CheckExecutable(file, exe, 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.Data.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream(new byte[1024]);
+            SabreTools.Serialization.Wrappers.PortableExecutable exe = new(model, source);
+
+            var checker = new CDKey();
+            string? actual = checker.CheckExecutable(file, exe, 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.Data.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream(new byte[1024]);
+            SabreTools.Serialization.Wrappers.PortableExecutable exe = new(model, source);
+
+            var checker = new CDLock();
+            string? actual = checker.CheckExecutable(file, exe, 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.Data.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream(new byte[1024]);
+            SabreTools.Serialization.Wrappers.PortableExecutable exe = new(model, source);
+
+            var checker = new CDSHiELDSE();
+            string? actual = checker.CheckExecutable(file, exe, 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.Data.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream(new byte[1024]);
+            SabreTools.Serialization.Wrappers.PortableExecutable exe = new(model, source);
+
+            var checker = new CenegaProtectDVD();
+            string? actual = checker.CheckExecutable(file, exe, 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.Data.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream(new byte[1024]);
+            SabreTools.Serialization.Wrappers.PortableExecutable exe = new(model, source);
+
+            var checker = new Channelware();
+            string? actual = checker.CheckExecutable(file, exe, 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.Data.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream(new byte[1024]);
+            SabreTools.Serialization.Wrappers.PortableExecutable exe = new(model, source);
+
+            var checker = new ChosenBytesCodeLock();
+            string? actual = checker.CheckExecutable(file, exe, 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.Data.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream(new byte[1024]);
+            SabreTools.Serialization.Wrappers.PortableExecutable exe = new(model, source);
+
+            var checker = new CopyKiller();
+            string? actual = checker.CheckExecutable(file, exe, 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.Data.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream(new byte[1024]);
+            SabreTools.Serialization.Wrappers.PortableExecutable exe = new(model, source);
+
+            var checker = new CopyLok();
+            string? actual = checker.CheckExecutable(file, exe, 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.Data.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream(new byte[1024]);
+            SabreTools.Serialization.Wrappers.PortableExecutable exe = new(model, source);
+
+            var checker = new CopyX();
+            string? actual = checker.CheckExecutable(file, exe, 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.Data.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream(new byte[1024]);
+            SabreTools.Serialization.Wrappers.PortableExecutable exe = new(model, source);
+
+            var checker = new CrypKey();
+            string? actual = checker.CheckExecutable(file, exe, 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.Data.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream(new byte[1024]);
+            SabreTools.Serialization.Wrappers.PortableExecutable exe = new(model, source);
+
+            var checker = new Cucko();
+            string? actual = checker.CheckExecutable(file, exe, 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.Data.Models.PortableExecutable.Executable model = new();
+            Stream source = new MemoryStream(new byte[1024]);
+            SabreTools.Serialization.Wrappers.PortableExecutable exe = new(model, source);
+
+            var checker = new Denuvo();
+            string? actual = checker.CheckExecutable(file, exe, 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);
+        }
+    }
+}

BinaryObjectScanner.Test/Protection/DigiGuardTests.cs

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

BinaryObjectScanner.Test/Protection/DinamicMultimediaTests.cs

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

BinaryObjectScanner.Test/Protection/DiscGuardTests.cs

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

BinaryObjectScanner.Test/Protection/EAAntiCheatTests.cs

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

BinaryObjectScanner.Test/Protection/EasyAntiCheatTests.cs

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

BinaryObjectScanner.Test/Protection/ElectronicArtsTests.cs

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

BinaryObjectScanner.Test/Protection/Engine32Tests.cs

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

BinaryObjectScanner.Test/Protection/FreeLockTests.cs

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

BinaryObjectScanner.Test/Protection/GFWLTests.cs

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

BinaryObjectScanner.Test/Protection/GefestTests.cs

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

BinaryObjectScanner.Test/Protection/HexalockAutoLockTests.cs

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

BinaryObjectScanner.Test/Protection/ImpulseReactorTests.cs

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

BinaryObjectScanner.Test/Protection/IndyVCDTests.cs

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

BinaryObjectScanner.Test/Protection/InteniumTests.cs

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

BinaryObjectScanner.Test/Protection/InterLokTests.cs

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

BinaryObjectScanner.Test/Protection/JoWoodTests.cs

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

BinaryObjectScanner.Test/Protection/KalypsoLauncherTests.cs

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

BinaryObjectScanner.Test/Protection/KeyLockTests.cs

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

BinaryObjectScanner.Test/Protection/LabelGateTests.cs

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

BinaryObjectScanner.Test/Protection/LaserLokTests.cs

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

BinaryObjectScanner.Test/Protection/MGIRegistrationTests.cs

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

BinaryObjectScanner.Test/Protection/MacrovisionTests.cs

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

BinaryObjectScanner.Test/Protection/MediaCloQTests.cs

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

BinaryObjectScanner.Test/Protection/MediaMaxTests.cs

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