v2.0.0 Release

.github/workflows/dotnet-package.yml

@@ -13,11 +13,11 @@ jobs:
       contents: read
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
       - name: Setup .NET
-        uses: actions/setup-dotnet@v1
+        uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: '6.0.x' # SDK Version to use.
+          dotnet-version: '9.0.x' # SDK Version to use.
       - name: Build
         working-directory: ./src
         run: dotnet build --configuration Release .

.github/workflows/dotnet.yml

@@ -13,23 +13,15 @@ jobs:
     steps:
     - name: Clean
       run: rm -rf *.*
-    - uses: actions/checkout@v2
-    - name: Setup .NET 6
-      uses: actions/setup-dotnet@v1
+    - uses: actions/checkout@v4
+    - name: Setup .NET 9
+      uses: actions/setup-dotnet@v4
       with:
-        dotnet-version: '6.0.x'
-    - name: Setup .NET 5
-      uses: actions/setup-dotnet@v1
+        dotnet-version: '9.0.x'
+    - name: Setup .NET 8
+      uses: actions/setup-dotnet@v4
       with:
-        dotnet-version: '5.0.x'
-    - name: Setup .NET Core 3.1
-      uses: actions/setup-dotnet@v1
-      with:
-        dotnet-version: '3.1.x'
-    - name: Setup .NET Core 2.1
-      uses: actions/setup-dotnet@v1
-      with:
-        dotnet-version: '2.1.x'
+        dotnet-version: '8.0.x'
     - name: Restore dependencies
       working-directory: ./src
       run: dotnet restore
@@ -38,4 +30,4 @@ jobs:
       run: dotnet build --no-restore --configuration Release
     - name: Test
       working-directory: ./src
-      run: dotnet test --no-build --verbosity normal --configuration Release
+      run: dotnet test --no-build --verbosity normal --configuration Release

src/FileTypeInterrogator.Tests/FileTypeInterrogator.Tests.csproj

@@ -1,18 +1,21 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>netcoreapp2.1;netcoreapp3.1;net5.0;net6.0</TargetFrameworks>
+    <TargetFrameworks>net8.0;net9.0</TargetFrameworks>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="coverlet.collector" Version="1.2.0">
+    <PackageReference Include="coverlet.collector" Version="6.0.4">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />    
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.0.2">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
-    <PackageReference Include="MSTest.TestAdapter" Version="2.2.8" />
-    <PackageReference Include="MSTest.TestFramework" Version="2.2.8" />
   </ItemGroup>
 
   <ItemGroup>

src/FileTypeInterrogator.Tests/FileTypeInterrogatorTests.cs

@@ -1,137 +1,136 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using Xunit;
 
 namespace FileTypeInterrogator.Tests
 {
     public partial class FileTypeInterrogatorTests
     {
-        [TestMethod]
+        [Fact]
         public void CanDetectAscii()
         {
             const string extension = "ascii";
             DetectType(extension, result =>
             {
-                Assert.IsNotNull(result);
-                Assert.IsTrue(result.Name.StartsWith(extension, StringComparison.OrdinalIgnoreCase));
+                Assert.NotNull(result);
+                Assert.StartsWith(extension, result.Name, StringComparison.OrdinalIgnoreCase);
             });
         }
 
-        [TestMethod]
+        [Fact]
         public void CanDetectUTF8()
         {
             const string extension = "utf8";
             DetectType(extension, result =>
             {
-                Assert.IsNotNull(result);
-                Assert.IsTrue(result.Name.StartsWith("UTF-8", StringComparison.OrdinalIgnoreCase));
-                Assert.IsTrue(result.Name.IndexOf("BOM", StringComparison.OrdinalIgnoreCase) == -1);
+                Assert.NotNull(result);
+                Assert.StartsWith("UTF-8", result.Name, StringComparison.OrdinalIgnoreCase);
+                Assert.True(result.Name.IndexOf("BOM", StringComparison.OrdinalIgnoreCase) == -1);
             });
         }
 
-        [TestMethod]
+        [Fact]
         public void CanDetectUTF8BOM()
         {
             const string extension = "utf8bom";
             DetectType(extension, result =>
             {
-                Assert.IsNotNull(result);
-                Assert.IsTrue(result.Name.StartsWith("UTF-8", StringComparison.OrdinalIgnoreCase));
-                Assert.IsTrue(result.Name.IndexOf("BOM", StringComparison.OrdinalIgnoreCase) > -1);
+                Assert.NotNull(result);
+                Assert.StartsWith("UTF-8", result.Name, StringComparison.OrdinalIgnoreCase);
+                Assert.True(result.Name.IndexOf("BOM", StringComparison.OrdinalIgnoreCase) > -1);
             });
         }
 
-        [DataTestMethod]
-        [DataRow("pdf", DisplayName = "PDF Test")]
-        [DataRow("fdf", DisplayName = "FDF Test")]
+        [Theory]
+        [InlineData("pdf")]
+        [InlineData("fdf")]
         public void CanDetectAdobe(string extension)
         {
             DetectType(extension);
         }
 
-        [DataTestMethod]
-        [DataRow("ai", DisplayName = "AI Test")]
-        [DataRow("bmp", DisplayName = "BMP Test")]
-        [DataRow("gif", DisplayName = "GIF Test")]
-        [DataRow("ico", DisplayName = "ICO Test")]
-        [DataRow("jp2", DisplayName = "JP2 Test")]
-        [DataRow("jpg", DisplayName = "JPG Test")]
-        [DataRow("pcx", DisplayName = "PCX Test")]
-        [DataRow("png", DisplayName = "PNG Test")]
-        [DataRow("psd", DisplayName = "PSD Test")]
-        [DataRow("tif", DisplayName = "TIF Test")]
-        [DataRow("webp", DisplayName = "WEBP Test")]
+        [Theory]
+        [InlineData("bmp")]
+        [InlineData("gif")]
+        [InlineData("ico")]
+        [InlineData("jp2")]
+        [InlineData("jpg")]
+        [InlineData("pcx")]
+        [InlineData("png")]
+        [InlineData("psd")]
+        [InlineData("tif")]
+        [InlineData("webp")]
         public void CanDetectImages(string extension)
         {
             DetectType(extension);
         }
 
-        [DataTestMethod]
-        [DataRow("3gp", DisplayName = "3GP Test")]
-        [DataRow("avi", DisplayName = "AVI Test")]
-        [DataRow("flv", DisplayName = "FLV Test")]
-        [DataRow("mid", DisplayName = "MID Test")]
-        [DataRow("mkv", DisplayName = "MKV Test")]
-        [DataRow("mp4", DisplayName = "MP4 Test")]
-        [DataRow("webm", DisplayName = "WEBM Test")]
-        [DataRow("wmv", DisplayName = "WMV Test")]
+        [Theory]
+        [InlineData("3gp")]
+        [InlineData("avi")]
+        [InlineData("flv")]
+        [InlineData("mid")]
+        [InlineData("mkv")]
+        [InlineData("mp4")]
+        [InlineData("webm")]
+        [InlineData("wmv")]
         public void CanDetectVideo(string extension)
         {
             DetectType(extension);
         }
 
-        [DataTestMethod]
-        [DataRow("ac3", DisplayName = "AC3 Test")]
-        [DataRow("aiff", DisplayName = "AIFF Test")]
-        [DataRow("flac", DisplayName = "FLAC Test")]
-        [DataRow("mp3", DisplayName = "MP3 Test")]
-        [DataRow("ogg", DisplayName = "OGG Test")]
-        [DataRow("ra", DisplayName = "RA Test")]
-        [DataRow("wav", DisplayName = "WAV Test")]
+        [Theory]
+        [InlineData("ac3")]
+        [InlineData("aiff")]
+        [InlineData("flac")]
+        [InlineData("mp3")]
+        [InlineData("ogg")]
+        [InlineData("ra")]
+        [InlineData("wav")]
         public void CanDetectAudio(string extension)
         {
             DetectType(extension);
         }
 
-        [DataTestMethod]
-        [DataRow("doc", DisplayName = "DOC Test")]
-        [DataRow("docx", DisplayName = "DOC Test")]
-        [DataRow("odp", DisplayName = "ODP Test")]
-        [DataRow("odt", DisplayName = "ODT Test")]
-        [DataRow("ppt", DisplayName = "PPT Test")]
-        [DataRow("pptx", DisplayName = "PPTX Test")]
-        [DataRow("rtf", DisplayName = "RTF Test")]
-        [DataRow("xls", DisplayName = "XLS Test")]
-        [DataRow("xlsx", DisplayName = "XLSX Test")]
+        [Theory]
+        [InlineData("doc")]
+        [InlineData("docx")]
+        [InlineData("odp")]
+        [InlineData("odt")]
+        [InlineData("ppt")]
+        [InlineData("pptx")]
+        [InlineData("rtf")]
+        [InlineData("xls")]
+        [InlineData("xlsx")]
         public void CanDetectOffice(string extension)
         {
             DetectType(extension);
         }
 
-        [DataTestMethod]
-        [DataRow("otf", DisplayName = "OTF Test")]
-        [DataRow("ttf", DisplayName = "TTF Test")]
-        [DataRow("woff", DisplayName = "WOFF Test")]
+        [Theory]
+        [InlineData("otf")]
+        [InlineData("ttf")]
+        [InlineData("woff")]
         public void CanDetectFont(string extension)
         {
             DetectType(extension);
         }
 
-        [DataTestMethod]
-        [DataRow("7z", DisplayName = "7Z Test")]
-        [DataRow("gz", DisplayName = "GZ Test")]
-        [DataRow("rar", DisplayName = "RAR Test")]
-        [DataRow("zip", DisplayName = "ZIP Test")]
+        [Theory]
+        [InlineData("7z")]
+        [InlineData("gz")]
+        [InlineData("rar")]
+        [InlineData("zip")]
         public void CanDetectCompressed(string extension)
         {
             DetectType(extension);
         }
 
-        [DataTestMethod]
-        [DataRow("eml", DisplayName = "EML Test")]
-        [DataRow("vcf", DisplayName = "VCF Test")]
+        [Theory]
+        [InlineData("eml")]
+        [InlineData("vcf")]
         public void CanDetectOther(string extension)
         {
             DetectType(extension);
@@ -141,12 +140,12 @@ private void DetectType(string extension)
         {
             DetectType(extension, result =>
             {
-                Assert.IsNotNull(result);
-                Assert.IsTrue(
+                Assert.NotNull(result);
+                Assert.True(
                     result.FileType.Equals(extension, StringComparison.OrdinalIgnoreCase) ||
                     result.Alias?.Any(a => a.Equals(extension, StringComparison.OrdinalIgnoreCase)) == true,
-                    "{0} and/or {1} do not equal {2}",
-                    result.FileType, result.Alias?.FirstOrDefault(), extension);
+                    string.Format("{0} and/or {1} do not equal {2}",
+                    result.FileType, result.Alias?.FirstOrDefault(), extension));
             });
         }
 

src/FileTypeInterrogator.Tests/FileTypeInterrogatorTests_Alias.cs

@@ -1,50 +1,48 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System.IO;
+using System.IO;
+using Xunit;
 
 namespace FileTypeInterrogator.Tests
 {
-    [TestClass]
     public partial class FileTypeInterrogatorTests
     {
         private IFileTypeInterrogator fileTypeInterrogator;
 
-        [TestInitialize]
-        public void Init()
+        public FileTypeInterrogatorTests()
         {
             fileTypeInterrogator = new FileTypeInterrogator();
         }
 
-        [TestMethod]
+        [Fact]
         public void CanDetectAlias_Jpg()
         {
             var filePath = GetFileByType("jpg");
             var fileContents = File.ReadAllBytes(filePath);
 
             var result = fileTypeInterrogator.IsType(fileContents, "jpg");
 
-            Assert.IsTrue(result);
+            Assert.True(result);
         }
 
-        [TestMethod]
+        [Fact]
         public void CanDetectAlias_Jpeg()
         {
             var filePath = GetFileByType("jpg");
             var fileContents = File.ReadAllBytes(filePath);
 
             var result = fileTypeInterrogator.IsType(fileContents, "jpeg");
 
-            Assert.IsTrue(result);
+            Assert.True(result);
         }
 
-        [TestMethod]
+        [Fact]
         public void CanDetectJpg_By_MimeType()
         {
             var filePath = GetFileByType("jpg");
             var fileContents = File.ReadAllBytes(filePath);
 
             var result = fileTypeInterrogator.IsType(fileContents, "image/jpeg");
 
-            Assert.IsTrue(result);
+            Assert.True(result);
         }
     }
 }

src/FileTypeInterrogator.sln

@@ -1,11 +1,20 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 15
-VisualStudioVersion = 15.0.28307.421
+# Visual Studio Version 17
+VisualStudioVersion = 17.1.32210.238
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "FileTypeInterrogator", "FileTypeInterrogator\FileTypeInterrogator.csproj", "{E5333901-A30A-45D0-B787-BC2F58208F9F}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FileTypeInterrogator.Tests", "FileTypeInterrogator.Tests\FileTypeInterrogator.Tests.csproj", "{8181D724-8886-4541-8819-9FF208A28074}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "FileTypeInterrogator.Tests", "FileTypeInterrogator.Tests\FileTypeInterrogator.Tests.csproj", "{8181D724-8886-4541-8819-9FF208A28074}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{42DC82B3-A307-4945-AC5C-D0A6D527F942}"
+	ProjectSection(SolutionItems) = preProject
+		..\.editorconfig = ..\.editorconfig
+		..\.gitattributes = ..\.gitattributes
+		..\.gitignore = ..\.gitignore
+		..\LICENSE.md = ..\LICENSE.md
+		..\README.md = ..\README.md
+	EndProjectSection
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution